Back to index

salome-med  6.5.0
MEDCouplingUMeshDesc.cxx
Go to the documentation of this file.
00001 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D
00002 //
00003 // This library is free software; you can redistribute it and/or
00004 // modify it under the terms of the GNU Lesser General Public
00005 // License as published by the Free Software Foundation; either
00006 // version 2.1 of the License.
00007 //
00008 // This library is distributed in the hope that it will be useful,
00009 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00010 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00011 // Lesser General Public License for more details.
00012 //
00013 // You should have received a copy of the GNU Lesser General Public
00014 // License along with this library; if not, write to the Free Software
00015 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00016 //
00017 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00018 //
00019 
00020 #include "MEDCouplingUMeshDesc.hxx"
00021 #include "CellModel.hxx"
00022 #include "MEDCouplingMemArray.hxx"
00023 
00024 #include <limits>
00025 #include <sstream>
00026 
00027 using namespace ParaMEDMEM;
00028 
00029 MEDCouplingUMeshDesc::MEDCouplingUMeshDesc():_mesh_dim(-2),_desc_connec(0),_desc_connec_index(0),
00030                                              _nodal_connec_face(0),_nodal_connec_face_index(0)
00031 {
00032 }
00033 
00034 MEDCouplingUMeshDesc::~MEDCouplingUMeshDesc()
00035 {
00036   if(_desc_connec)
00037     _desc_connec->decrRef();
00038   if(_desc_connec_index)
00039     _desc_connec_index->decrRef();
00040   if(_nodal_connec_face)
00041     _nodal_connec_face->decrRef();
00042   if(_nodal_connec_face_index)
00043     _nodal_connec_face_index->decrRef();
00044 }
00045 
00046 MEDCouplingUMeshDesc *MEDCouplingUMeshDesc::New()
00047 {
00048   return new MEDCouplingUMeshDesc;
00049 }
00050 
00051 MEDCouplingUMeshDesc *MEDCouplingUMeshDesc::New(const char *meshName, int meshDim)
00052 {
00053   MEDCouplingUMeshDesc *ret=new MEDCouplingUMeshDesc;
00054   ret->setName(meshName);
00055   ret->setMeshDimension(meshDim);
00056   return ret;
00057 }
00058 
00059 MEDCouplingMesh *MEDCouplingUMeshDesc::deepCpy() const
00060 {
00061   throw INTERP_KERNEL::Exception("Not implemented yet !");
00062   return 0;
00063 }
00064 
00065 void MEDCouplingUMeshDesc::checkCoherency() const throw(INTERP_KERNEL::Exception)
00066 {
00067   for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=_types.begin();iter!=_types.end();iter++)
00068     {
00069       if((int)INTERP_KERNEL::CellModel::GetCellModel(*iter).getDimension()!=_mesh_dim)
00070         {
00071           std::ostringstream message;
00072           message << "MeshDesc invalid because dimension is " << _mesh_dim << " and there is presence of cell(s) with type " << (*iter);
00073           throw INTERP_KERNEL::Exception(message.str().c_str());
00074         }
00075     }
00076 }
00077 
00078 void MEDCouplingUMeshDesc::checkCoherency1(double eps) const throw(INTERP_KERNEL::Exception)
00079 {
00080   checkCoherency();
00081 }
00082 
00083 void MEDCouplingUMeshDesc::checkCoherency2(double eps) const throw(INTERP_KERNEL::Exception)
00084 {
00085   checkCoherency1(eps);
00086 }
00087 
00088 void MEDCouplingUMeshDesc::checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
00089                                                 DataArrayInt *&cellCor, DataArrayInt *&nodeCor) const throw(INTERP_KERNEL::Exception)
00090 {
00091   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::checkDeepEquivalWith : not implemented yet !");
00092 }
00093 
00094 void MEDCouplingUMeshDesc::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
00095                                                            DataArrayInt *&cellCor) const throw(INTERP_KERNEL::Exception)
00096 {
00097   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::checkDeepEquivalOnSameNodesWith : not implemented yet !");
00098 }
00099 
00100 void MEDCouplingUMeshDesc::setMeshDimension(unsigned meshDim)
00101 {
00102   _mesh_dim=meshDim;
00103   declareAsNew();
00104 }
00105 
00106 int MEDCouplingUMeshDesc::getNumberOfCells() const
00107 {
00108   if(_desc_connec_index)
00109     return _desc_connec_index->getNumberOfTuples()-1;
00110   else
00111     throw INTERP_KERNEL::Exception("Unable to get number of cells because no connectivity specified !");
00112 }
00113 
00114 int MEDCouplingUMeshDesc::getNumberOfFaces() const
00115 {
00116   if(_nodal_connec_face_index)
00117     return _nodal_connec_face_index->getNumberOfTuples()-1;
00118   else
00119     throw INTERP_KERNEL::Exception("Unable to get number of faces because no connectivity specified !");
00120 }
00121 
00122 int MEDCouplingUMeshDesc::getCellMeshLength() const
00123 {
00124   return _desc_connec->getNbOfElems();
00125 }
00126 
00127 int MEDCouplingUMeshDesc::getFaceMeshLength() const
00128 {
00129   return _nodal_connec_face->getNbOfElems();
00130 }
00131 
00132 INTERP_KERNEL::NormalizedCellType MEDCouplingUMeshDesc::getTypeOfCell(int cellId) const
00133 {
00134   const int *desc_connec=_desc_connec->getConstPointer();
00135   const int *desc_connec_index=_desc_connec_index->getConstPointer();
00136   return (INTERP_KERNEL::NormalizedCellType)desc_connec[desc_connec_index[cellId]+1];
00137 }
00138 
00139 std::set<INTERP_KERNEL::NormalizedCellType> MEDCouplingUMeshDesc::getAllGeoTypes() const
00140 {
00141   return _types;
00142 }
00143 
00144 int MEDCouplingUMeshDesc::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
00145 {
00146   const int *desc_connec=_desc_connec->getConstPointer();
00147   const int *desc_connec_index=_desc_connec_index->getConstPointer();
00148   int nbOfCells=getNumberOfCells();
00149   int ret=0;
00150   for(int i=0;i<nbOfCells;i++)
00151     if((INTERP_KERNEL::NormalizedCellType) desc_connec[desc_connec_index[i]]==type)
00152       ret++;
00153   return ret;
00154 }
00155 
00156 void MEDCouplingUMeshDesc::getNodeIdsOfCell(int cellId, std::vector<int>& conn) const
00157 {
00158   throw INTERP_KERNEL::Exception("Not implemented yet !");
00159 }
00160 
00161 std::string MEDCouplingUMeshDesc::simpleRepr() const
00162 {
00163   std::string ret("Unstructured mesh with descending connectivity : ");
00164   ret+=getName();
00165   ret+="\n";
00166   return ret;
00167 }
00168 
00169 std::string MEDCouplingUMeshDesc::advancedRepr() const
00170 {
00171   std::string ret("Unstructured mesh with descending connectivity : ");
00172   ret+=getName();
00173   ret+="\n";
00174   return ret;
00175 }
00176 
00177 void MEDCouplingUMeshDesc::setConnectivity(DataArrayInt *descConn, DataArrayInt *descConnIndex, DataArrayInt *nodalFaceConn, DataArrayInt *nodalFaceConnIndx)
00178 {
00179   DataArrayInt::SetArrayIn(descConn,_desc_connec);
00180   DataArrayInt::SetArrayIn(descConnIndex,_desc_connec_index);
00181   DataArrayInt::SetArrayIn(nodalFaceConn,_nodal_connec_face);
00182   DataArrayInt::SetArrayIn(nodalFaceConnIndx,_nodal_connec_face_index);
00183   computeTypes();
00184 }
00185 
00186 std::vector<int> MEDCouplingUMeshDesc::getDistributionOfTypes() const throw(INTERP_KERNEL::Exception)
00187 {
00188   throw INTERP_KERNEL::Exception("Not implemented yet !");
00189 }
00190 
00191 DataArrayInt *MEDCouplingUMeshDesc::checkTypeConsistencyAndContig(const std::vector<int>& code, const std::vector<const DataArrayInt *>& idsPerType) const throw(INTERP_KERNEL::Exception)
00192 {
00193   throw INTERP_KERNEL::Exception("Not implemented yet !");
00194 }
00195 
00196 void MEDCouplingUMeshDesc::splitProfilePerType(const DataArrayInt *profile, std::vector<int>& code, std::vector<DataArrayInt *>& idsInPflPerType, std::vector<DataArrayInt *>& idsPerType) const throw(INTERP_KERNEL::Exception)
00197 {
00198   throw INTERP_KERNEL::Exception("Not implemented yet !");
00199 }
00200 
00201 void MEDCouplingUMeshDesc::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<int>& tinyInfo, std::vector<std::string>& littleStrings) const
00202 {
00203   MEDCouplingPointSet::getTinySerializationInformation(tinyInfoD,tinyInfo,littleStrings);
00204   tinyInfo.push_back(getMeshDimension());
00205   tinyInfo.push_back(getNumberOfNodes());
00206   tinyInfo.push_back(getNumberOfCells());
00207   tinyInfo.push_back(getCellMeshLength());
00208   tinyInfo.push_back(getNumberOfFaces());
00209   tinyInfo.push_back(getFaceMeshLength());
00210 }
00211 
00212 bool MEDCouplingUMeshDesc::isEmptyMesh(const std::vector<int>& tinyInfo) const
00213 {
00214   return tinyInfo[5]<=0;
00215 }
00216 
00217 void MEDCouplingUMeshDesc::resizeForUnserialization(const std::vector<int>& tinyInfo, DataArrayInt *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
00218 {
00219   std::vector<int> tinyInfoTmp(tinyInfo.begin()+1,tinyInfo.end());
00220   MEDCouplingPointSet::resizeForUnserialization(tinyInfoTmp,a1,a2,littleStrings);
00221   a1->alloc(tinyInfo[5]+tinyInfo[4]+1+tinyInfo[7]+tinyInfo[6]+1,1);
00222 }
00223 
00224 void MEDCouplingUMeshDesc::serialize(DataArrayInt *&a1, DataArrayDouble *&a2) const
00225 {
00226   MEDCouplingPointSet::serialize(a1,a2);
00227   //
00228   a1=DataArrayInt::New();
00229   a1->alloc(getCellMeshLength()+getNumberOfCells()+1+getFaceMeshLength()+getNumberOfFaces()+1,1);
00230   int *ptA1=a1->getPointer();
00231   const int *descConn=_desc_connec->getConstPointer();
00232   const int *descConnIndex=_desc_connec_index->getConstPointer();
00233   const int *faceConn=_nodal_connec_face->getConstPointer();
00234   const int *faceConnIndex=_nodal_connec_face_index->getConstPointer();
00235   ptA1=std::copy(descConn,descConn+getCellMeshLength(),ptA1);
00236   ptA1=std::copy(descConnIndex,descConnIndex+getNumberOfCells()+1,ptA1);
00237   ptA1=std::copy(faceConn,faceConn+getFaceMeshLength(),ptA1);
00238   std::copy(faceConnIndex,faceConnIndex+getNumberOfFaces()+1,ptA1);
00239 }
00240 
00241 void MEDCouplingUMeshDesc::unserialization(const std::vector<double>& tinyInfoD, const std::vector<int>& tinyInfo, const DataArrayInt *a1, DataArrayDouble *a2, const std::vector<std::string>& littleStrings)
00242 {
00243   std::vector<int> tinyInfoTmp(tinyInfo.begin()+1,tinyInfo.end());
00244   MEDCouplingPointSet::unserialization(tinyInfoD,tinyInfoTmp,a1,a2,littleStrings);
00245   //
00246   const int *recvBuffer=a1->getConstPointer();
00247   DataArrayInt *descConn=DataArrayInt::New();
00248   descConn->alloc(tinyInfo[5],1);
00249   std::copy(recvBuffer,recvBuffer+tinyInfo[5],descConn->getPointer());
00250   DataArrayInt *descConnIndex=DataArrayInt::New();
00251   descConnIndex->alloc(tinyInfo[4]+1,1);
00252   std::copy(recvBuffer+tinyInfo[5],recvBuffer+tinyInfo[5]+tinyInfo[4]+1,descConnIndex->getPointer());
00253   DataArrayInt *faceConn=DataArrayInt::New();
00254   faceConn->alloc(tinyInfo[7],1);
00255   std::copy(recvBuffer+tinyInfo[5]+tinyInfo[4]+1,recvBuffer+tinyInfo[5]+tinyInfo[4]+1+tinyInfo[7],faceConn->getPointer());
00256   DataArrayInt *faceConnIndex=DataArrayInt::New();
00257   faceConnIndex->alloc(tinyInfo[6]+1,1);
00258   std::copy(recvBuffer+tinyInfo[5]+tinyInfo[4]+1+tinyInfo[7],
00259             recvBuffer+tinyInfo[5]+tinyInfo[5]+1+tinyInfo[7]+tinyInfo[6]+1,faceConnIndex->getPointer());
00260   setConnectivity(descConn,descConnIndex,faceConn,faceConnIndex);
00261   descConn->decrRef();
00262   descConnIndex->decrRef();
00263   faceConn->decrRef();
00264   faceConnIndex->decrRef();
00265   setMeshDimension(tinyInfo[2]);
00266 }
00267 
00268 void MEDCouplingUMeshDesc::getCellsInBoundingBox(const double *bbox, double eps, std::vector<int>& elems) const
00269 {
00270   int dim=getSpaceDimension();
00271   double* elem_bb=new double[2*dim];
00272   const int* conn      = _desc_connec->getConstPointer();
00273   const int* conn_index= _desc_connec_index->getConstPointer();
00274   const int* face      = _nodal_connec_face->getConstPointer();
00275   const int* face_index= _nodal_connec_face_index->getConstPointer();
00276   const double* coords = getCoords()->getConstPointer();
00277   int nbOfCells=getNumberOfCells();
00278   for ( int ielem=0; ielem<nbOfCells;ielem++ )
00279     {
00280       for (int i=0; i<dim; i++)
00281         {
00282           elem_bb[i*2]=std::numeric_limits<double>::max();
00283           elem_bb[i*2+1]=-std::numeric_limits<double>::max();
00284         }
00285 
00286       for (int jface=conn_index[ielem]+1; jface<conn_index[ielem+1]; jface++)//+1 due to offset of cell type.
00287         {
00288           int iface=conn[jface];
00289           for(int inode=face_index[iface]+1;inode<face_index[iface+1];inode++)
00290             {
00291               int node=face[inode];
00292               for (int idim=0; idim<dim; idim++)
00293                 {
00294                   if ( coords[node*dim+idim] < elem_bb[idim*2] )
00295                     {
00296                       elem_bb[idim*2] = coords[node*dim+idim] ;
00297                     }
00298                   if ( coords[node*dim+idim] > elem_bb[idim*2+1] )
00299                     {
00300                       elem_bb[idim*2+1] = coords[node*dim+idim] ;
00301                     }
00302                 }
00303             }
00304         }
00305       if (intersectsBoundingBox(elem_bb, bbox, dim, eps))
00306         {
00307           elems.push_back(ielem);
00308         }
00309     }
00310   delete [] elem_bb;
00311 }
00312 
00313 void MEDCouplingUMeshDesc::getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox &bbox, double eps, std::vector<int>& elems)
00314 {
00315   int dim=getSpaceDimension();
00316   double* elem_bb=new double[2*dim];
00317   const int* conn      = _desc_connec->getConstPointer();
00318   const int* conn_index= _desc_connec_index->getConstPointer();
00319   const int* face      = _nodal_connec_face->getConstPointer();
00320   const int* face_index= _nodal_connec_face_index->getConstPointer();
00321   const double* coords = getCoords()->getConstPointer();
00322   int nbOfCells=getNumberOfCells();
00323   for ( int ielem=0; ielem<nbOfCells;ielem++ )
00324     {
00325       for (int i=0; i<dim; i++)
00326         {
00327           elem_bb[i*2]=std::numeric_limits<double>::max();
00328           elem_bb[i*2+1]=-std::numeric_limits<double>::max();
00329         }
00330 
00331       for (int jface=conn_index[ielem]+1; jface<conn_index[ielem+1]; jface++)//+1 due to offset of cell type.
00332         {
00333           int iface=conn[jface];
00334           for(int inode=face_index[iface]+1;inode<face_index[iface+1];inode++)
00335             {
00336               int node=face[inode];
00337               for (int idim=0; idim<dim; idim++)
00338                 {
00339                   if ( coords[node*dim+idim] < elem_bb[idim*2] )
00340                     {
00341                       elem_bb[idim*2] = coords[node*dim+idim] ;
00342                     }
00343                   if ( coords[node*dim+idim] > elem_bb[idim*2+1] )
00344                     {
00345                       elem_bb[idim*2+1] = coords[node*dim+idim] ;
00346                     }
00347                 }
00348             }
00349         }
00350       if (intersectsBoundingBox(bbox, elem_bb, dim, eps))
00351         {
00352           elems.push_back(ielem);
00353         }
00354     }
00355   delete [] elem_bb;
00356 }
00357 
00358 DataArrayInt *MEDCouplingUMeshDesc::mergeNodes(double precision, bool& areNodesMerged, int& newNbOfNodes)
00359 {
00360   throw INTERP_KERNEL::Exception("Not implemented yet !");
00361   areNodesMerged=false;
00362   return 0;
00363 }
00364 
00365 DataArrayInt *MEDCouplingUMeshDesc::mergeNodes2(double precision, bool& areNodesMerged, int& newNbOfNodes)
00366 {
00367   throw INTERP_KERNEL::Exception("Not implemented yet !");
00368   areNodesMerged=false;
00369   return 0;
00370 }
00371 
00372 void MEDCouplingUMeshDesc::tryToShareSameCoordsPermute(const MEDCouplingPointSet& other, double epsilon) throw(INTERP_KERNEL::Exception)
00373 {
00374   throw INTERP_KERNEL::Exception("Not implemented yet !");
00375 }
00376 
00377 MEDCouplingPointSet *MEDCouplingUMeshDesc::buildPartOfMySelf(const int *start, const int *end, bool keepCoords) const
00378 {
00379   throw INTERP_KERNEL::Exception("Not implemented yet !");
00380   return 0;
00381 }
00382 
00383 MEDCouplingPointSet *MEDCouplingUMeshDesc::buildPartOfMySelfNode(const int *start, const int *end, bool fullyIn) const
00384 {
00385   throw INTERP_KERNEL::Exception("Not implemented yet !");
00386   return 0;
00387 }
00388 
00389 MEDCouplingPointSet *MEDCouplingUMeshDesc::buildFacePartOfMySelfNode(const int *start, const int *end, bool fullyIn) const
00390 {
00391   throw INTERP_KERNEL::Exception("Not implemented yet !");
00392   return 0;
00393 }
00394 
00395 DataArrayInt *MEDCouplingUMeshDesc::simplexize(int policy) throw(INTERP_KERNEL::Exception)
00396 {
00397   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::simplexize : Not implemented yet !");
00398 }
00399 
00400 void MEDCouplingUMeshDesc::findBoundaryNodes(std::vector<int>& nodes) const
00401 {
00402   throw INTERP_KERNEL::Exception("Not implemented yet !");
00403 }
00404 
00405 MEDCouplingPointSet *MEDCouplingUMeshDesc::buildBoundaryMesh(bool keepCoords) const
00406 {
00407   throw INTERP_KERNEL::Exception("Not implemented yet !");
00408   return 0;
00409 }
00410 
00411 MEDCouplingUMesh *MEDCouplingUMeshDesc::buildUnstructured() const throw(INTERP_KERNEL::Exception)
00412 {
00413   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::buildUnstructured : not implemented yet !");
00414 }
00415 
00416 void MEDCouplingUMeshDesc::renumberCells(const int *old2NewBg, bool check) throw(INTERP_KERNEL::Exception)
00417 {
00418   throw INTERP_KERNEL::Exception("Available for UMesh desc but not implemented yet !");
00419 }
00420 
00421 void MEDCouplingUMeshDesc::renumberNodes(const int *newNodeNumbers, int newNbOfNodes)
00422 {
00423   MEDCouplingPointSet::renumberNodes(newNodeNumbers,newNbOfNodes);
00424   throw INTERP_KERNEL::Exception("Not implemented yet !");
00425 }
00426 
00427 MEDCouplingFieldDouble *MEDCouplingUMeshDesc::getMeasureField(bool isAbs) const
00428 {
00429   throw INTERP_KERNEL::Exception("Not implemented yet !");
00430   return 0;
00431 }
00432 
00433 MEDCouplingFieldDouble *MEDCouplingUMeshDesc::getMeasureFieldOnNode(bool isAbs) const
00434 {
00435   throw INTERP_KERNEL::Exception("Not implemented yet !");
00436   return 0;
00437 }
00438 
00439 MEDCouplingFieldDouble *MEDCouplingUMeshDesc::buildOrthogonalField() const
00440 {
00441   if(getMeshDimension()!=2)
00442     throw INTERP_KERNEL::Exception("Expected a cmesh with meshDim == 2 !");
00443   throw INTERP_KERNEL::Exception("Not implemented yet !");
00444   return 0;
00445 }
00446 
00447 DataArrayInt *MEDCouplingUMeshDesc::zipCoordsTraducer()
00448 {
00449   throw INTERP_KERNEL::Exception("Not implemented yet !");
00450   return 0;
00451 }
00452 
00453 void MEDCouplingUMeshDesc::computeTypes()
00454 {
00455   if(_desc_connec && _desc_connec_index)
00456     {
00457       _types.clear();
00458       const int *conn=_desc_connec->getConstPointer();
00459       const int *connIndex=_desc_connec_index->getConstPointer();
00460       int nbOfElem=_desc_connec_index->getNbOfElems()-1;
00461       for(const int *pt=connIndex;pt!=connIndex+nbOfElem;pt++)
00462         _types.insert((INTERP_KERNEL::NormalizedCellType)conn[*pt]);
00463     }
00464 }
00465 
00466 void MEDCouplingUMeshDesc::checkFullyDefined() const throw(INTERP_KERNEL::Exception)
00467 {
00468   if(!_desc_connec || !_desc_connec_index || !_nodal_connec_face || !_nodal_connec_face_index || !_coords)
00469     throw INTERP_KERNEL::Exception("full connectivity and coordinates not set in unstructured mesh.");
00470 }
00471 
00472 MEDCouplingMesh *MEDCouplingUMeshDesc::mergeMyselfWith(const MEDCouplingMesh *other) const
00473 {  
00474   throw INTERP_KERNEL::Exception("Not implemented yet !");
00475   return 0;
00476 }
00477 
00478 DataArrayDouble *MEDCouplingUMeshDesc::getBarycenterAndOwner() const
00479 {
00480   throw INTERP_KERNEL::Exception("Not implemented yet !");
00481   return 0;
00482 }
00483 
00484 int MEDCouplingUMeshDesc::getCellContainingPoint(const double *pos, double eps) const
00485 {
00486   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::getCellContainingPoint : not implemented yet !");
00487 }
00488 
00489 void MEDCouplingUMeshDesc::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData) const throw(INTERP_KERNEL::Exception)
00490 {
00491   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::writeVTKLL : not implemented yet !");
00492 }
00493 
00494 std::string MEDCouplingUMeshDesc::getVTKDataSetType() const throw(INTERP_KERNEL::Exception)
00495 {
00496   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::getVTKDataSetType : not implemented yet !");
00497 }
00498