src/MEDCoupling/MEDCouplingUMeshDesc.cxx

   1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony Geay (CEA/DEN)
  20
  21 #include "MEDCouplingUMeshDesc.hxx"
  22 #include "CellModel.hxx"
  23 #include "MEDCouplingMemArray.hxx"
  24 #include "MEDCouplingAutoRefCountObjectPtr.hxx"
  25
  26 #include <limits>
  27 #include <sstream>
  28
  29 using namespace ParaMEDMEM;
  30
  31 MEDCouplingUMeshDesc::MEDCouplingUMeshDesc():_mesh_dim(-2),_desc_connec(0),_desc_connec_index(0),
  32                                              _nodal_connec_face(0),_nodal_connec_face_index(0)
  33 {
  34 }
  35
  36 MEDCouplingUMeshDesc::~MEDCouplingUMeshDesc()
  37 {
  38   if(_desc_connec)
  39     _desc_connec->decrRef();
  40   if(_desc_connec_index)
  41     _desc_connec_index->decrRef();
  42   if(_nodal_connec_face)
  43     _nodal_connec_face->decrRef();
  44   if(_nodal_connec_face_index)
  45     _nodal_connec_face_index->decrRef();
  46 }
  47
  48 MEDCouplingUMeshDesc *MEDCouplingUMeshDesc::New()
  49 {
  50   return new MEDCouplingUMeshDesc;
  51 }
  52
  53 MEDCouplingUMeshDesc *MEDCouplingUMeshDesc::New(const char *meshName, int meshDim)
  54 {
  55   MEDCouplingUMeshDesc *ret=new MEDCouplingUMeshDesc;
  56   ret->setName(meshName);
  57   ret->setMeshDimension(meshDim);
  58   return ret;
  59 }
  60
  61 std::size_t MEDCouplingUMeshDesc::getHeapMemorySize() const
  62 {
  63   std::size_t ret=0;
  64   if(_desc_connec)
  65     ret+=_desc_connec->getHeapMemorySize();
  66   if(_desc_connec_index)
  67     ret+=_desc_connec_index->getHeapMemorySize();
  68   if(_nodal_connec_face)
  69     ret+=_nodal_connec_face->getHeapMemorySize();
  70   if(_nodal_connec_face_index)
  71     ret+=_nodal_connec_face_index->getHeapMemorySize();
  72   return MEDCouplingPointSet::getHeapMemorySize()+ret;
  73 }
  74
  75
  76 MEDCouplingMesh *MEDCouplingUMeshDesc::deepCpy() const
  77 {
  78   throw INTERP_KERNEL::Exception("Not implemented yet !");
  79   return 0;
  80 }
  81
  82 void MEDCouplingUMeshDesc::checkCoherency() const throw(INTERP_KERNEL::Exception)
  83 {
  84   for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=_types.begin();iter!=_types.end();iter++)
  85     {
  86       if((int)INTERP_KERNEL::CellModel::GetCellModel(*iter).getDimension()!=_mesh_dim)
  87         {
  88           std::ostringstream message;
  89           message << "MeshDesc invalid because dimension is " << _mesh_dim << " and there is presence of cell(s) with type " << (*iter);
  90           throw INTERP_KERNEL::Exception(message.str().c_str());
  91         }
  92     }
  93 }
  94
  95 void MEDCouplingUMeshDesc::checkCoherency1(double eps) const throw(INTERP_KERNEL::Exception)
  96 {
  97   checkCoherency();
  98 }
  99
 100 void MEDCouplingUMeshDesc::checkCoherency2(double eps) const throw(INTERP_KERNEL::Exception)
 101 {
 102   checkCoherency1(eps);
 103 }
 104
 105 void MEDCouplingUMeshDesc::checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
 106                                                 DataArrayInt *&cellCor, DataArrayInt *&nodeCor) const throw(INTERP_KERNEL::Exception)
 107 {
 108   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::checkDeepEquivalWith : not implemented yet !");
 109 }
 110
 111 void MEDCouplingUMeshDesc::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
 112                                                            DataArrayInt *&cellCor) const throw(INTERP_KERNEL::Exception)
 113 {
 114   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::checkDeepEquivalOnSameNodesWith : not implemented yet !");
 115 }
 116
 117 void MEDCouplingUMeshDesc::setMeshDimension(unsigned meshDim)
 118 {
 119   _mesh_dim=meshDim;
 120   declareAsNew();
 121 }
 122
 123 int MEDCouplingUMeshDesc::getNumberOfCells() const
 124 {
 125   if(_desc_connec_index)
 126     return _desc_connec_index->getNumberOfTuples()-1;
 127   else
 128     throw INTERP_KERNEL::Exception("Unable to get number of cells because no connectivity specified !");
 129 }
 130
 131 int MEDCouplingUMeshDesc::getNumberOfFaces() const
 132 {
 133   if(_nodal_connec_face_index)
 134     return _nodal_connec_face_index->getNumberOfTuples()-1;
 135   else
 136     throw INTERP_KERNEL::Exception("Unable to get number of faces because no connectivity specified !");
 137 }
 138
 139 int MEDCouplingUMeshDesc::getCellMeshLength() const
 140 {
 141   return _desc_connec->getNbOfElems();
 142 }
 143
 144 int MEDCouplingUMeshDesc::getFaceMeshLength() const
 145 {
 146   return _nodal_connec_face->getNbOfElems();
 147 }
 148
 149 INTERP_KERNEL::NormalizedCellType MEDCouplingUMeshDesc::getTypeOfCell(int cellId) const
 150 {
 151   const int *desc_connec=_desc_connec->getConstPointer();
 152   const int *desc_connec_index=_desc_connec_index->getConstPointer();
 153   return (INTERP_KERNEL::NormalizedCellType)desc_connec[desc_connec_index[cellId]+1];
 154 }
 155
 156 std::set<INTERP_KERNEL::NormalizedCellType> MEDCouplingUMeshDesc::getAllGeoTypes() const
 157 {
 158   return _types;
 159 }
 160
 161 DataArrayInt *MEDCouplingUMeshDesc::giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const throw(INTERP_KERNEL::Exception)
 162 {
 163   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::giveCellsWithType : not implemented yet !");
 164 }
 165
 166 DataArrayInt *MEDCouplingUMeshDesc::computeNbOfNodesPerCell() const throw(INTERP_KERNEL::Exception)
 167 {
 168   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::computeNbOfNodesPerCell : not implemented yet !");
 169 }
 170
 171 DataArrayInt *MEDCouplingUMeshDesc::computeNbOfFacesPerCell() const throw(INTERP_KERNEL::Exception)
 172 {
 173   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::computeNbOfFacesPerCell : not implemented yet !");
 174 }
 175
 176 int MEDCouplingUMeshDesc::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
 177 {
 178   const int *desc_connec=_desc_connec->getConstPointer();
 179   const int *desc_connec_index=_desc_connec_index->getConstPointer();
 180   int nbOfCells=getNumberOfCells();
 181   int ret=0;
 182   for(int i=0;i<nbOfCells;i++)
 183     if((INTERP_KERNEL::NormalizedCellType) desc_connec[desc_connec_index[i]]==type)
 184       ret++;
 185   return ret;
 186 }
 187
 188 void MEDCouplingUMeshDesc::getNodeIdsOfCell(int cellId, std::vector<int>& conn) const
 189 {
 190   throw INTERP_KERNEL::Exception("Not implemented yet !");
 191 }
 192
 193 std::string MEDCouplingUMeshDesc::simpleRepr() const
 194 {
 195   std::string ret("Unstructured mesh with descending connectivity : ");
 196   ret+=getName();
 197   ret+="\n";
 198   return ret;
 199 }
 200
 201 std::string MEDCouplingUMeshDesc::advancedRepr() const
 202 {
 203   std::string ret("Unstructured mesh with descending connectivity : ");
 204   ret+=getName();
 205   ret+="\n";
 206   return ret;
 207 }
 208
 209 void MEDCouplingUMeshDesc::setConnectivity(DataArrayInt *descConn, DataArrayInt *descConnIndex, DataArrayInt *nodalFaceConn, DataArrayInt *nodalFaceConnIndx)
 210 {
 211   DataArrayInt::SetArrayIn(descConn,_desc_connec);
 212   DataArrayInt::SetArrayIn(descConnIndex,_desc_connec_index);
 213   DataArrayInt::SetArrayIn(nodalFaceConn,_nodal_connec_face);
 214   DataArrayInt::SetArrayIn(nodalFaceConnIndx,_nodal_connec_face_index);
 215   computeTypes();
 216 }
 217
 218 std::vector<int> MEDCouplingUMeshDesc::getDistributionOfTypes() const throw(INTERP_KERNEL::Exception)
 219 {
 220   throw INTERP_KERNEL::Exception("Not implemented yet !");
 221 }
 222
 223 DataArrayInt *MEDCouplingUMeshDesc::checkTypeConsistencyAndContig(const std::vector<int>& code, const std::vector<const DataArrayInt *>& idsPerType) const throw(INTERP_KERNEL::Exception)
 224 {
 225   throw INTERP_KERNEL::Exception("Not implemented yet !");
 226 }
 227
 228 void MEDCouplingUMeshDesc::splitProfilePerType(const DataArrayInt *profile, std::vector<int>& code, std::vector<DataArrayInt *>& idsInPflPerType, std::vector<DataArrayInt *>& idsPerType) const throw(INTERP_KERNEL::Exception)
 229 {
 230   throw INTERP_KERNEL::Exception("Not implemented yet !");
 231 }
 232
 233 void MEDCouplingUMeshDesc::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<int>& tinyInfo, std::vector<std::string>& littleStrings) const
 234 {
 235   MEDCouplingPointSet::getTinySerializationInformation(tinyInfoD,tinyInfo,littleStrings);
 236   tinyInfo.push_back(getMeshDimension());
 237   tinyInfo.push_back(getNumberOfNodes());
 238   tinyInfo.push_back(getNumberOfCells());
 239   tinyInfo.push_back(getCellMeshLength());
 240   tinyInfo.push_back(getNumberOfFaces());
 241   tinyInfo.push_back(getFaceMeshLength());
 242 }
 243
 244 bool MEDCouplingUMeshDesc::isEmptyMesh(const std::vector<int>& tinyInfo) const
 245 {
 246   return tinyInfo[5]<=0;
 247 }
 248
 249 void MEDCouplingUMeshDesc::resizeForUnserialization(const std::vector<int>& tinyInfo, DataArrayInt *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
 250 {
 251   std::vector<int> tinyInfoTmp(tinyInfo.begin()+1,tinyInfo.end());
 252   MEDCouplingPointSet::resizeForUnserialization(tinyInfoTmp,a1,a2,littleStrings);
 253   a1->alloc(tinyInfo[5]+tinyInfo[4]+1+tinyInfo[7]+tinyInfo[6]+1,1);
 254 }
 255
 256 void MEDCouplingUMeshDesc::serialize(DataArrayInt *&a1, DataArrayDouble *&a2) const
 257 {
 258   MEDCouplingPointSet::serialize(a1,a2);
 259   //
 260   a1=DataArrayInt::New();
 261   a1->alloc(getCellMeshLength()+getNumberOfCells()+1+getFaceMeshLength()+getNumberOfFaces()+1,1);
 262   int *ptA1=a1->getPointer();
 263   const int *descConn=_desc_connec->getConstPointer();
 264   const int *descConnIndex=_desc_connec_index->getConstPointer();
 265   const int *faceConn=_nodal_connec_face->getConstPointer();
 266   const int *faceConnIndex=_nodal_connec_face_index->getConstPointer();
 267   ptA1=std::copy(descConn,descConn+getCellMeshLength(),ptA1);
 268   ptA1=std::copy(descConnIndex,descConnIndex+getNumberOfCells()+1,ptA1);
 269   ptA1=std::copy(faceConn,faceConn+getFaceMeshLength(),ptA1);
 270   std::copy(faceConnIndex,faceConnIndex+getNumberOfFaces()+1,ptA1);
 271 }
 272
 273 void MEDCouplingUMeshDesc::unserialization(const std::vector<double>& tinyInfoD, const std::vector<int>& tinyInfo, const DataArrayInt *a1, DataArrayDouble *a2, const std::vector<std::string>& littleStrings)
 274 {
 275   std::vector<int> tinyInfoTmp(tinyInfo.begin()+1,tinyInfo.end());
 276   MEDCouplingPointSet::unserialization(tinyInfoD,tinyInfoTmp,a1,a2,littleStrings);
 277   //
 278   const int *recvBuffer=a1->getConstPointer();
 279   DataArrayInt *descConn=DataArrayInt::New();
 280   descConn->alloc(tinyInfo[5],1);
 281   std::copy(recvBuffer,recvBuffer+tinyInfo[5],descConn->getPointer());
 282   DataArrayInt *descConnIndex=DataArrayInt::New();
 283   descConnIndex->alloc(tinyInfo[4]+1,1);
 284   std::copy(recvBuffer+tinyInfo[5],recvBuffer+tinyInfo[5]+tinyInfo[4]+1,descConnIndex->getPointer());
 285   DataArrayInt *faceConn=DataArrayInt::New();
 286   faceConn->alloc(tinyInfo[7],1);
 287   std::copy(recvBuffer+tinyInfo[5]+tinyInfo[4]+1,recvBuffer+tinyInfo[5]+tinyInfo[4]+1+tinyInfo[7],faceConn->getPointer());
 288   DataArrayInt *faceConnIndex=DataArrayInt::New();
 289   faceConnIndex->alloc(tinyInfo[6]+1,1);
 290   std::copy(recvBuffer+tinyInfo[5]+tinyInfo[4]+1+tinyInfo[7],
 291             recvBuffer+tinyInfo[5]+tinyInfo[5]+1+tinyInfo[7]+tinyInfo[6]+1,faceConnIndex->getPointer());
 292   setConnectivity(descConn,descConnIndex,faceConn,faceConnIndex);
 293   descConn->decrRef();
 294   descConnIndex->decrRef();
 295   faceConn->decrRef();
 296   faceConnIndex->decrRef();
 297   setMeshDimension(tinyInfo[2]);
 298 }
 299
 300 DataArrayInt *MEDCouplingUMeshDesc::getCellsInBoundingBox(const double *bbox, double eps) const
 301 {
 302   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> elems=DataArrayInt::New(); elems->alloc(0,1);
 303   int dim=getSpaceDimension();
 304   double* elem_bb=new double[2*dim];
 305   const int* conn      = _desc_connec->getConstPointer();
 306   const int* conn_index= _desc_connec_index->getConstPointer();
 307   const int* face      = _nodal_connec_face->getConstPointer();
 308   const int* face_index= _nodal_connec_face_index->getConstPointer();
 309   const double* coords = getCoords()->getConstPointer();
 310   int nbOfCells=getNumberOfCells();
 311   for ( int ielem=0; ielem<nbOfCells;ielem++ )
 312     {
 313       for (int i=0; i<dim; i++)
 314         {
 315           elem_bb[i*2]=std::numeric_limits<double>::max();
 316           elem_bb[i*2+1]=-std::numeric_limits<double>::max();
 317         }
 318
 319       for (int jface=conn_index[ielem]+1; jface<conn_index[ielem+1]; jface++)//+1 due to offset of cell type.
 320         {
 321           int iface=conn[jface];
 322           for(int inode=face_index[iface]+1;inode<face_index[iface+1];inode++)
 323             {
 324               int node=face[inode];
 325               for (int idim=0; idim<dim; idim++)
 326                 {
 327                   if ( coords[node*dim+idim] < elem_bb[idim*2] )
 328                     {
 329                       elem_bb[idim*2] = coords[node*dim+idim] ;
 330                     }
 331                   if ( coords[node*dim+idim] > elem_bb[idim*2+1] )
 332                     {
 333                       elem_bb[idim*2+1] = coords[node*dim+idim] ;
 334                     }
 335                 }
 336             }
 337         }
 338       if(intersectsBoundingBox(elem_bb, bbox, dim, eps))
 339         elems->pushBackSilent(ielem);
 340     }
 341   delete [] elem_bb;
 342   return elems.retn();
 343 }
 344
 345 DataArrayInt *MEDCouplingUMeshDesc::getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox &bbox, double eps)
 346 {
 347   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> elems=DataArrayInt::New(); elems->alloc(0,1);
 348   int dim=getSpaceDimension();
 349   double* elem_bb=new double[2*dim];
 350   const int* conn      = _desc_connec->getConstPointer();
 351   const int* conn_index= _desc_connec_index->getConstPointer();
 352   const int* face      = _nodal_connec_face->getConstPointer();
 353   const int* face_index= _nodal_connec_face_index->getConstPointer();
 354   const double* coords = getCoords()->getConstPointer();
 355   int nbOfCells=getNumberOfCells();
 356   for ( int ielem=0; ielem<nbOfCells;ielem++ )
 357     {
 358       for (int i=0; i<dim; i++)
 359         {
 360           elem_bb[i*2]=std::numeric_limits<double>::max();
 361           elem_bb[i*2+1]=-std::numeric_limits<double>::max();
 362         }
 363
 364       for (int jface=conn_index[ielem]+1; jface<conn_index[ielem+1]; jface++)//+1 due to offset of cell type.
 365         {
 366           int iface=conn[jface];
 367           for(int inode=face_index[iface]+1;inode<face_index[iface+1];inode++)
 368             {
 369               int node=face[inode];
 370               for (int idim=0; idim<dim; idim++)
 371                 {
 372                   if ( coords[node*dim+idim] < elem_bb[idim*2] )
 373                     {
 374                       elem_bb[idim*2] = coords[node*dim+idim] ;
 375                     }
 376                   if ( coords[node*dim+idim] > elem_bb[idim*2+1] )
 377                     {
 378                       elem_bb[idim*2+1] = coords[node*dim+idim] ;
 379                     }
 380                 }
 381             }
 382         }
 383       if (intersectsBoundingBox(bbox, elem_bb, dim, eps))
 384         elems->pushBackSilent(ielem);
 385     }
 386   delete [] elem_bb;
 387   return elems.retn();
 388 }
 389
 390 DataArrayInt *MEDCouplingUMeshDesc::mergeNodes(double precision, bool& areNodesMerged, int& newNbOfNodes)
 391 {
 392   throw INTERP_KERNEL::Exception("Not implemented yet !");
 393   areNodesMerged=false;
 394   return 0;
 395 }
 396
 397 DataArrayInt *MEDCouplingUMeshDesc::mergeNodes2(double precision, bool& areNodesMerged, int& newNbOfNodes)
 398 {
 399   throw INTERP_KERNEL::Exception("Not implemented yet !");
 400   areNodesMerged=false;
 401   return 0;
 402 }
 403
 404 void MEDCouplingUMeshDesc::tryToShareSameCoordsPermute(const MEDCouplingPointSet& other, double epsilon) throw(INTERP_KERNEL::Exception)
 405 {
 406   throw INTERP_KERNEL::Exception("Not implemented yet !");
 407 }
 408
 409 MEDCouplingPointSet *MEDCouplingUMeshDesc::buildPartOfMySelf2(int start, int end, int step, bool keepCoords) const throw(INTERP_KERNEL::Exception)
 410 {
 411   throw INTERP_KERNEL::Exception("Not implemented yet !");
 412   return 0;
 413 }
 414
 415 MEDCouplingPointSet *MEDCouplingUMeshDesc::buildPartOfMySelf(const int *start, const int *end, bool keepCoords) const
 416 {
 417   throw INTERP_KERNEL::Exception("Not implemented yet !");
 418   return 0;
 419 }
 420
 421 MEDCouplingPointSet *MEDCouplingUMeshDesc::buildPartOfMySelfNode(const int *start, const int *end, bool fullyIn) const
 422 {
 423   throw INTERP_KERNEL::Exception("Not implemented yet !");
 424   return 0;
 425 }
 426
 427 MEDCouplingPointSet *MEDCouplingUMeshDesc::buildFacePartOfMySelfNode(const int *start, const int *end, bool fullyIn) const
 428 {
 429   throw INTERP_KERNEL::Exception("Not implemented yet !");
 430   return 0;
 431 }
 432
 433 DataArrayInt *MEDCouplingUMeshDesc::simplexize(int policy) throw(INTERP_KERNEL::Exception)
 434 {
 435   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::simplexize : Not implemented yet !");
 436 }
 437
 438 DataArrayInt *MEDCouplingUMeshDesc::findBoundaryNodes() const
 439 {
 440   throw INTERP_KERNEL::Exception("Not implemented yet !");
 441 }
 442
 443 MEDCouplingPointSet *MEDCouplingUMeshDesc::buildBoundaryMesh(bool keepCoords) const
 444 {
 445   throw INTERP_KERNEL::Exception("Not implemented yet !");
 446   return 0;
 447 }
 448
 449 MEDCouplingUMesh *MEDCouplingUMeshDesc::buildUnstructured() const throw(INTERP_KERNEL::Exception)
 450 {
 451   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::buildUnstructured : not implemented yet !");
 452 }
 453
 454 void MEDCouplingUMeshDesc::renumberCells(const int *old2NewBg, bool check) throw(INTERP_KERNEL::Exception)
 455 {
 456   throw INTERP_KERNEL::Exception("Available for UMesh desc but not implemented yet !");
 457 }
 458
 459 void MEDCouplingUMeshDesc::renumberNodes(const int *newNodeNumbers, int newNbOfNodes)
 460 {
 461   MEDCouplingPointSet::renumberNodes(newNodeNumbers,newNbOfNodes);
 462   throw INTERP_KERNEL::Exception("Not implemented yet !");
 463 }
 464
 465 MEDCouplingFieldDouble *MEDCouplingUMeshDesc::getMeasureField(bool isAbs) const
 466 {
 467   throw INTERP_KERNEL::Exception("Not implemented yet !");
 468   return 0;
 469 }
 470
 471 MEDCouplingFieldDouble *MEDCouplingUMeshDesc::getMeasureFieldOnNode(bool isAbs) const
 472 {
 473   throw INTERP_KERNEL::Exception("Not implemented yet !");
 474   return 0;
 475 }
 476
 477 MEDCouplingFieldDouble *MEDCouplingUMeshDesc::buildOrthogonalField() const
 478 {
 479   if(getMeshDimension()!=2)
 480     throw INTERP_KERNEL::Exception("Expected a cmesh with meshDim == 2 !");
 481   throw INTERP_KERNEL::Exception("Not implemented yet !");
 482   return 0;
 483 }
 484
 485 DataArrayInt *MEDCouplingUMeshDesc::zipCoordsTraducer()
 486 {
 487   throw INTERP_KERNEL::Exception("Not implemented yet !");
 488   return 0;
 489 }
 490
 491 void MEDCouplingUMeshDesc::computeTypes()
 492 {
 493   if(_desc_connec && _desc_connec_index)
 494     {
 495       _types.clear();
 496       const int *conn=_desc_connec->getConstPointer();
 497       const int *connIndex=_desc_connec_index->getConstPointer();
 498       int nbOfElem=_desc_connec_index->getNbOfElems()-1;
 499       for(const int *pt=connIndex;pt!=connIndex+nbOfElem;pt++)
 500         _types.insert((INTERP_KERNEL::NormalizedCellType)conn[*pt]);
 501     }
 502 }
 503
 504 void MEDCouplingUMeshDesc::checkFullyDefined() const throw(INTERP_KERNEL::Exception)
 505 {
 506   if(!_desc_connec || !_desc_connec_index || !_nodal_connec_face || !_nodal_connec_face_index || !_coords)
 507     throw INTERP_KERNEL::Exception("full connectivity and coordinates not set in unstructured mesh.");
 508 }
 509
 510 MEDCouplingMesh *MEDCouplingUMeshDesc::mergeMyselfWith(const MEDCouplingMesh *other) const
 511 {
 512   throw INTERP_KERNEL::Exception("Not implemented yet !");
 513   return 0;
 514 }
 515
 516 DataArrayDouble *MEDCouplingUMeshDesc::getBarycenterAndOwner() const
 517 {
 518   throw INTERP_KERNEL::Exception("Not implemented yet !");
 519   return 0;
 520 }
 521
 522 int MEDCouplingUMeshDesc::getCellContainingPoint(const double *pos, double eps) const
 523 {
 524   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::getCellContainingPoint : not implemented yet !");
 525 }
 526
 527 void MEDCouplingUMeshDesc::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData) const throw(INTERP_KERNEL::Exception)
 528 {
 529   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::writeVTKLL : not implemented yet !");
 530 }
 531
 532 std::string MEDCouplingUMeshDesc::getVTKDataSetType() const throw(INTERP_KERNEL::Exception)
 533 {
 534   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::getVTKDataSetType : not implemented yet !");
 535 }
 536
 537 DataArrayDouble *MEDCouplingUMeshDesc::computeIsoBarycenterOfNodesPerCell() const throw(INTERP_KERNEL::Exception)
 538 {
 539   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::computeIsoBarycenterOfNodesPerCell : not implemented yet !");
 540 }
 541
 542 void MEDCouplingUMeshDesc::reprQuickOverview(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
 543 {
 544   stream << "MEDCouplingUMeshDesc C++ instance at " << this << ". Name : \"" << getName() << "\".";
 545 }