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::shallowCopyConnectivityFrom(const MEDCouplingPointSet *other) throw(INTERP_KERNEL::Exception)
  83 {
  84   throw INTERP_KERNEL::Exception("Not implemented yet !");
  85 }
  86
  87 void MEDCouplingUMeshDesc::checkCoherency() const throw(INTERP_KERNEL::Exception)
  88 {
  89   for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=_types.begin();iter!=_types.end();iter++)
  90     {
  91       if((int)INTERP_KERNEL::CellModel::GetCellModel(*iter).getDimension()!=_mesh_dim)
  92         {
  93           std::ostringstream message;
  94           message << "MeshDesc invalid because dimension is " << _mesh_dim << " and there is presence of cell(s) with type " << (*iter);
  95           throw INTERP_KERNEL::Exception(message.str().c_str());
  96         }
  97     }
  98 }
  99
 100 void MEDCouplingUMeshDesc::checkCoherency1(double eps) const throw(INTERP_KERNEL::Exception)
 101 {
 102   checkCoherency();
 103 }
 104
 105 void MEDCouplingUMeshDesc::checkCoherency2(double eps) const throw(INTERP_KERNEL::Exception)
 106 {
 107   checkCoherency1(eps);
 108 }
 109
 110 void MEDCouplingUMeshDesc::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
 111                                                            DataArrayInt *&cellCor) const throw(INTERP_KERNEL::Exception)
 112 {
 113   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::checkDeepEquivalOnSameNodesWith : not implemented yet !");
 114 }
 115
 116 void MEDCouplingUMeshDesc::setMeshDimension(unsigned meshDim)
 117 {
 118   _mesh_dim=meshDim;
 119   declareAsNew();
 120 }
 121
 122 int MEDCouplingUMeshDesc::getNumberOfCells() const
 123 {
 124   if(_desc_connec_index)
 125     return _desc_connec_index->getNumberOfTuples()-1;
 126   else
 127     throw INTERP_KERNEL::Exception("Unable to get number of cells because no connectivity specified !");
 128 }
 129
 130 int MEDCouplingUMeshDesc::getNumberOfFaces() const
 131 {
 132   if(_nodal_connec_face_index)
 133     return _nodal_connec_face_index->getNumberOfTuples()-1;
 134   else
 135     throw INTERP_KERNEL::Exception("Unable to get number of faces because no connectivity specified !");
 136 }
 137
 138 int MEDCouplingUMeshDesc::getCellMeshLength() const
 139 {
 140   return _desc_connec->getNbOfElems();
 141 }
 142
 143 int MEDCouplingUMeshDesc::getFaceMeshLength() const
 144 {
 145   return _nodal_connec_face->getNbOfElems();
 146 }
 147
 148 INTERP_KERNEL::NormalizedCellType MEDCouplingUMeshDesc::getTypeOfCell(int cellId) const
 149 {
 150   const int *desc_connec=_desc_connec->getConstPointer();
 151   const int *desc_connec_index=_desc_connec_index->getConstPointer();
 152   return (INTERP_KERNEL::NormalizedCellType)desc_connec[desc_connec_index[cellId]+1];
 153 }
 154
 155 std::set<INTERP_KERNEL::NormalizedCellType> MEDCouplingUMeshDesc::getAllGeoTypes() const
 156 {
 157   return _types;
 158 }
 159
 160 DataArrayInt *MEDCouplingUMeshDesc::giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const throw(INTERP_KERNEL::Exception)
 161 {
 162   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::giveCellsWithType : not implemented yet !");
 163 }
 164
 165 DataArrayInt *MEDCouplingUMeshDesc::computeNbOfNodesPerCell() const throw(INTERP_KERNEL::Exception)
 166 {
 167   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::computeNbOfNodesPerCell : not implemented yet !");
 168 }
 169
 170 DataArrayInt *MEDCouplingUMeshDesc::computeNbOfFacesPerCell() const throw(INTERP_KERNEL::Exception)
 171 {
 172   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::computeNbOfFacesPerCell : not implemented yet !");
 173 }
 174
 175 int MEDCouplingUMeshDesc::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
 176 {
 177   const int *desc_connec=_desc_connec->getConstPointer();
 178   const int *desc_connec_index=_desc_connec_index->getConstPointer();
 179   int nbOfCells=getNumberOfCells();
 180   int ret=0;
 181   for(int i=0;i<nbOfCells;i++)
 182     if((INTERP_KERNEL::NormalizedCellType) desc_connec[desc_connec_index[i]]==type)
 183       ret++;
 184   return ret;
 185 }
 186
 187 void MEDCouplingUMeshDesc::getNodeIdsOfCell(int cellId, std::vector<int>& conn) const
 188 {
 189   throw INTERP_KERNEL::Exception("Not implemented yet !");
 190 }
 191
 192 std::string MEDCouplingUMeshDesc::simpleRepr() const
 193 {
 194   std::string ret("Unstructured mesh with descending connectivity : ");
 195   ret+=getName();
 196   ret+="\n";
 197   return ret;
 198 }
 199
 200 std::string MEDCouplingUMeshDesc::advancedRepr() const
 201 {
 202   std::string ret("Unstructured mesh with descending connectivity : ");
 203   ret+=getName();
 204   ret+="\n";
 205   return ret;
 206 }
 207
 208 void MEDCouplingUMeshDesc::setConnectivity(DataArrayInt *descConn, DataArrayInt *descConnIndex, DataArrayInt *nodalFaceConn, DataArrayInt *nodalFaceConnIndx)
 209 {
 210   DataArrayInt::SetArrayIn(descConn,_desc_connec);
 211   DataArrayInt::SetArrayIn(descConnIndex,_desc_connec_index);
 212   DataArrayInt::SetArrayIn(nodalFaceConn,_nodal_connec_face);
 213   DataArrayInt::SetArrayIn(nodalFaceConnIndx,_nodal_connec_face_index);
 214   computeTypes();
 215 }
 216
 217 std::vector<int> MEDCouplingUMeshDesc::getDistributionOfTypes() const throw(INTERP_KERNEL::Exception)
 218 {
 219   throw INTERP_KERNEL::Exception("Not implemented yet !");
 220 }
 221
 222 DataArrayInt *MEDCouplingUMeshDesc::checkTypeConsistencyAndContig(const std::vector<int>& code, const std::vector<const DataArrayInt *>& idsPerType) const throw(INTERP_KERNEL::Exception)
 223 {
 224   throw INTERP_KERNEL::Exception("Not implemented yet !");
 225 }
 226
 227 void MEDCouplingUMeshDesc::splitProfilePerType(const DataArrayInt *profile, std::vector<int>& code, std::vector<DataArrayInt *>& idsInPflPerType, std::vector<DataArrayInt *>& idsPerType) const throw(INTERP_KERNEL::Exception)
 228 {
 229   throw INTERP_KERNEL::Exception("Not implemented yet !");
 230 }
 231
 232 void MEDCouplingUMeshDesc::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<int>& tinyInfo, std::vector<std::string>& littleStrings) const
 233 {
 234   MEDCouplingPointSet::getTinySerializationInformation(tinyInfoD,tinyInfo,littleStrings);
 235   tinyInfo.push_back(getMeshDimension());
 236   tinyInfo.push_back(getNumberOfNodes());
 237   tinyInfo.push_back(getNumberOfCells());
 238   tinyInfo.push_back(getCellMeshLength());
 239   tinyInfo.push_back(getNumberOfFaces());
 240   tinyInfo.push_back(getFaceMeshLength());
 241 }
 242
 243 bool MEDCouplingUMeshDesc::isEmptyMesh(const std::vector<int>& tinyInfo) const
 244 {
 245   return tinyInfo[5]<=0;
 246 }
 247
 248 void MEDCouplingUMeshDesc::resizeForUnserialization(const std::vector<int>& tinyInfo, DataArrayInt *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
 249 {
 250   std::vector<int> tinyInfoTmp(tinyInfo.begin()+1,tinyInfo.end());
 251   MEDCouplingPointSet::resizeForUnserialization(tinyInfoTmp,a1,a2,littleStrings);
 252   a1->alloc(tinyInfo[5]+tinyInfo[4]+1+tinyInfo[7]+tinyInfo[6]+1,1);
 253 }
 254
 255 void MEDCouplingUMeshDesc::serialize(DataArrayInt *&a1, DataArrayDouble *&a2) const
 256 {
 257   MEDCouplingPointSet::serialize(a1,a2);
 258   //
 259   a1=DataArrayInt::New();
 260   a1->alloc(getCellMeshLength()+getNumberOfCells()+1+getFaceMeshLength()+getNumberOfFaces()+1,1);
 261   int *ptA1=a1->getPointer();
 262   const int *descConn=_desc_connec->getConstPointer();
 263   const int *descConnIndex=_desc_connec_index->getConstPointer();
 264   const int *faceConn=_nodal_connec_face->getConstPointer();
 265   const int *faceConnIndex=_nodal_connec_face_index->getConstPointer();
 266   ptA1=std::copy(descConn,descConn+getCellMeshLength(),ptA1);
 267   ptA1=std::copy(descConnIndex,descConnIndex+getNumberOfCells()+1,ptA1);
 268   ptA1=std::copy(faceConn,faceConn+getFaceMeshLength(),ptA1);
 269   std::copy(faceConnIndex,faceConnIndex+getNumberOfFaces()+1,ptA1);
 270 }
 271
 272 void MEDCouplingUMeshDesc::unserialization(const std::vector<double>& tinyInfoD, const std::vector<int>& tinyInfo, const DataArrayInt *a1, DataArrayDouble *a2, const std::vector<std::string>& littleStrings)
 273 {
 274   std::vector<int> tinyInfoTmp(tinyInfo.begin()+1,tinyInfo.end());
 275   MEDCouplingPointSet::unserialization(tinyInfoD,tinyInfoTmp,a1,a2,littleStrings);
 276   //
 277   const int *recvBuffer=a1->getConstPointer();
 278   DataArrayInt *descConn=DataArrayInt::New();
 279   descConn->alloc(tinyInfo[5],1);
 280   std::copy(recvBuffer,recvBuffer+tinyInfo[5],descConn->getPointer());
 281   DataArrayInt *descConnIndex=DataArrayInt::New();
 282   descConnIndex->alloc(tinyInfo[4]+1,1);
 283   std::copy(recvBuffer+tinyInfo[5],recvBuffer+tinyInfo[5]+tinyInfo[4]+1,descConnIndex->getPointer());
 284   DataArrayInt *faceConn=DataArrayInt::New();
 285   faceConn->alloc(tinyInfo[7],1);
 286   std::copy(recvBuffer+tinyInfo[5]+tinyInfo[4]+1,recvBuffer+tinyInfo[5]+tinyInfo[4]+1+tinyInfo[7],faceConn->getPointer());
 287   DataArrayInt *faceConnIndex=DataArrayInt::New();
 288   faceConnIndex->alloc(tinyInfo[6]+1,1);
 289   std::copy(recvBuffer+tinyInfo[5]+tinyInfo[4]+1+tinyInfo[7],
 290             recvBuffer+tinyInfo[5]+tinyInfo[5]+1+tinyInfo[7]+tinyInfo[6]+1,faceConnIndex->getPointer());
 291   setConnectivity(descConn,descConnIndex,faceConn,faceConnIndex);
 292   descConn->decrRef();
 293   descConnIndex->decrRef();
 294   faceConn->decrRef();
 295   faceConnIndex->decrRef();
 296   setMeshDimension(tinyInfo[2]);
 297 }
 298
 299 DataArrayInt *MEDCouplingUMeshDesc::getCellsInBoundingBox(const double *bbox, double eps) const
 300 {
 301   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> elems=DataArrayInt::New(); elems->alloc(0,1);
 302   int dim=getSpaceDimension();
 303   double* elem_bb=new double[2*dim];
 304   const int* conn      = _desc_connec->getConstPointer();
 305   const int* conn_index= _desc_connec_index->getConstPointer();
 306   const int* face      = _nodal_connec_face->getConstPointer();
 307   const int* face_index= _nodal_connec_face_index->getConstPointer();
 308   const double* coords = getCoords()->getConstPointer();
 309   int nbOfCells=getNumberOfCells();
 310   for ( int ielem=0; ielem<nbOfCells;ielem++ )
 311     {
 312       for (int i=0; i<dim; i++)
 313         {
 314           elem_bb[i*2]=std::numeric_limits<double>::max();
 315           elem_bb[i*2+1]=-std::numeric_limits<double>::max();
 316         }
 317
 318       for (int jface=conn_index[ielem]+1; jface<conn_index[ielem+1]; jface++)//+1 due to offset of cell type.
 319         {
 320           int iface=conn[jface];
 321           for(int inode=face_index[iface]+1;inode<face_index[iface+1];inode++)
 322             {
 323               int node=face[inode];
 324               for (int idim=0; idim<dim; idim++)
 325                 {
 326                   if ( coords[node*dim+idim] < elem_bb[idim*2] )
 327                     {
 328                       elem_bb[idim*2] = coords[node*dim+idim] ;
 329                     }
 330                   if ( coords[node*dim+idim] > elem_bb[idim*2+1] )
 331                     {
 332                       elem_bb[idim*2+1] = coords[node*dim+idim] ;
 333                     }
 334                 }
 335             }
 336         }
 337       if(intersectsBoundingBox(elem_bb, bbox, dim, eps))
 338         elems->pushBackSilent(ielem);
 339     }
 340   delete [] elem_bb;
 341   return elems.retn();
 342 }
 343
 344 DataArrayInt *MEDCouplingUMeshDesc::getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox &bbox, double eps)
 345 {
 346   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> elems=DataArrayInt::New(); elems->alloc(0,1);
 347   int dim=getSpaceDimension();
 348   double* elem_bb=new double[2*dim];
 349   const int* conn      = _desc_connec->getConstPointer();
 350   const int* conn_index= _desc_connec_index->getConstPointer();
 351   const int* face      = _nodal_connec_face->getConstPointer();
 352   const int* face_index= _nodal_connec_face_index->getConstPointer();
 353   const double* coords = getCoords()->getConstPointer();
 354   int nbOfCells=getNumberOfCells();
 355   for ( int ielem=0; ielem<nbOfCells;ielem++ )
 356     {
 357       for (int i=0; i<dim; i++)
 358         {
 359           elem_bb[i*2]=std::numeric_limits<double>::max();
 360           elem_bb[i*2+1]=-std::numeric_limits<double>::max();
 361         }
 362
 363       for (int jface=conn_index[ielem]+1; jface<conn_index[ielem+1]; jface++)//+1 due to offset of cell type.
 364         {
 365           int iface=conn[jface];
 366           for(int inode=face_index[iface]+1;inode<face_index[iface+1];inode++)
 367             {
 368               int node=face[inode];
 369               for (int idim=0; idim<dim; idim++)
 370                 {
 371                   if ( coords[node*dim+idim] < elem_bb[idim*2] )
 372                     {
 373                       elem_bb[idim*2] = coords[node*dim+idim] ;
 374                     }
 375                   if ( coords[node*dim+idim] > elem_bb[idim*2+1] )
 376                     {
 377                       elem_bb[idim*2+1] = coords[node*dim+idim] ;
 378                     }
 379                 }
 380             }
 381         }
 382       if (intersectsBoundingBox(bbox, elem_bb, dim, eps))
 383         elems->pushBackSilent(ielem);
 384     }
 385   delete [] elem_bb;
 386   return elems.retn();
 387 }
 388
 389 DataArrayInt *MEDCouplingUMeshDesc::mergeNodes(double precision, bool& areNodesMerged, int& newNbOfNodes)
 390 {
 391   throw INTERP_KERNEL::Exception("Not implemented yet !");
 392   areNodesMerged=false;
 393   return 0;
 394 }
 395
 396 DataArrayInt *MEDCouplingUMeshDesc::mergeNodes2(double precision, bool& areNodesMerged, int& newNbOfNodes)
 397 {
 398   throw INTERP_KERNEL::Exception("Not implemented yet !");
 399   areNodesMerged=false;
 400   return 0;
 401 }
 402
 403 MEDCouplingPointSet *MEDCouplingUMeshDesc::mergeMyselfWithOnSameCoords(const MEDCouplingPointSet *other) const
 404 {
 405   throw INTERP_KERNEL::Exception("Not implemented yet !");
 406 }
 407
 408 MEDCouplingPointSet *MEDCouplingUMeshDesc::buildPartOfMySelfNode(const int *start, const int *end, bool fullyIn) const
 409 {
 410   throw INTERP_KERNEL::Exception("Not implemented yet !");
 411   return 0;
 412 }
 413
 414 MEDCouplingPointSet *MEDCouplingUMeshDesc::buildFacePartOfMySelfNode(const int *start, const int *end, bool fullyIn) const
 415 {
 416   throw INTERP_KERNEL::Exception("Not implemented yet !");
 417   return 0;
 418 }
 419
 420 MEDCouplingPointSet *MEDCouplingUMeshDesc::buildPartOfMySelfKeepCoords(const int *begin, const int *end) const
 421 {
 422   throw INTERP_KERNEL::Exception("Not implemented yet !");
 423 }
 424
 425 MEDCouplingPointSet *MEDCouplingUMeshDesc::buildPartOfMySelfKeepCoords2(int start, int end, int step) const
 426 {
 427   throw INTERP_KERNEL::Exception("Not implemented yet !");
 428 }
 429
 430 DataArrayInt *MEDCouplingUMeshDesc::simplexize(int policy) throw(INTERP_KERNEL::Exception)
 431 {
 432   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::simplexize : Not implemented yet !");
 433 }
 434
 435 DataArrayInt *MEDCouplingUMeshDesc::findBoundaryNodes() const
 436 {
 437   throw INTERP_KERNEL::Exception("Not implemented yet !");
 438 }
 439
 440 MEDCouplingPointSet *MEDCouplingUMeshDesc::buildBoundaryMesh(bool keepCoords) const
 441 {
 442   throw INTERP_KERNEL::Exception("Not implemented yet !");
 443   return 0;
 444 }
 445
 446 MEDCouplingUMesh *MEDCouplingUMeshDesc::buildUnstructured() const throw(INTERP_KERNEL::Exception)
 447 {
 448   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::buildUnstructured : not implemented yet !");
 449 }
 450
 451 void MEDCouplingUMeshDesc::renumberCells(const int *old2NewBg, bool check) throw(INTERP_KERNEL::Exception)
 452 {
 453   throw INTERP_KERNEL::Exception("Available for UMesh desc but not implemented yet !");
 454 }
 455
 456 void MEDCouplingUMeshDesc::renumberNodesInConn(const int *newNodeNumbersO2N)
 457 {
 458   throw INTERP_KERNEL::Exception("Not implemented yet !");
 459 }
 460
 461 MEDCouplingFieldDouble *MEDCouplingUMeshDesc::getMeasureField(bool isAbs) const
 462 {
 463   throw INTERP_KERNEL::Exception("Not implemented yet !");
 464   return 0;
 465 }
 466
 467 MEDCouplingFieldDouble *MEDCouplingUMeshDesc::getMeasureFieldOnNode(bool isAbs) const
 468 {
 469   throw INTERP_KERNEL::Exception("Not implemented yet !");
 470   return 0;
 471 }
 472
 473 MEDCouplingFieldDouble *MEDCouplingUMeshDesc::buildOrthogonalField() const
 474 {
 475   if(getMeshDimension()!=2)
 476     throw INTERP_KERNEL::Exception("Expected a cmesh with meshDim == 2 !");
 477   throw INTERP_KERNEL::Exception("Not implemented yet !");
 478   return 0;
 479 }
 480
 481 DataArrayInt *MEDCouplingUMeshDesc::zipCoordsTraducer() throw(INTERP_KERNEL::Exception)
 482 {
 483   throw INTERP_KERNEL::Exception("Not implemented yet !");
 484   return 0;
 485 }
 486
 487 void MEDCouplingUMeshDesc::findCommonCells(int compType, int startCellId, DataArrayInt *& commonCellsArr, DataArrayInt *& commonCellsIArr) const throw(INTERP_KERNEL::Exception)
 488 {
 489   throw INTERP_KERNEL::Exception("Not implemented yet !");
 490 }
 491
 492 void MEDCouplingUMeshDesc::getReverseNodalConnectivity(DataArrayInt *revNodal, DataArrayInt *revNodalIndx) const throw(INTERP_KERNEL::Exception)
 493 {
 494   throw INTERP_KERNEL::Exception("Not implemented yet !");
 495 }
 496
 497 void MEDCouplingUMeshDesc::computeTypes()
 498 {
 499   if(_desc_connec && _desc_connec_index)
 500     {
 501       _types.clear();
 502       const int *conn=_desc_connec->getConstPointer();
 503       const int *connIndex=_desc_connec_index->getConstPointer();
 504       int nbOfElem=_desc_connec_index->getNbOfElems()-1;
 505       for(const int *pt=connIndex;pt!=connIndex+nbOfElem;pt++)
 506         _types.insert((INTERP_KERNEL::NormalizedCellType)conn[*pt]);
 507     }
 508 }
 509
 510 void MEDCouplingUMeshDesc::checkFullyDefined() const throw(INTERP_KERNEL::Exception)
 511 {
 512   if(!_desc_connec || !_desc_connec_index || !_nodal_connec_face || !_nodal_connec_face_index || !_coords)
 513     throw INTERP_KERNEL::Exception("full connectivity and coordinates not set in unstructured mesh.");
 514 }
 515
 516 MEDCouplingMesh *MEDCouplingUMeshDesc::mergeMyselfWith(const MEDCouplingMesh *other) const
 517 {
 518   throw INTERP_KERNEL::Exception("Not implemented yet !");
 519   return 0;
 520 }
 521
 522 DataArrayInt *MEDCouplingUMeshDesc::getNodeIdsInUse(int& nbrOfNodesInUse) const throw(INTERP_KERNEL::Exception)
 523 {
 524   throw INTERP_KERNEL::Exception("Not implemented yet !");
 525 }
 526
 527 void MEDCouplingUMeshDesc::fillCellIdsToKeepFromNodeIds(const int *begin, const int *end, bool fullyIn, DataArrayInt *&cellIdsKeptArr) const
 528 {
 529   throw INTERP_KERNEL::Exception("Not implemented yet !");
 530 }
 531
 532 DataArrayDouble *MEDCouplingUMeshDesc::getBarycenterAndOwner() const
 533 {
 534   throw INTERP_KERNEL::Exception("Not implemented yet !");
 535   return 0;
 536 }
 537
 538 int MEDCouplingUMeshDesc::getCellContainingPoint(const double *pos, double eps) const
 539 {
 540   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::getCellContainingPoint : not implemented yet !");
 541 }
 542
 543 void MEDCouplingUMeshDesc::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData) const throw(INTERP_KERNEL::Exception)
 544 {
 545   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::writeVTKLL : not implemented yet !");
 546 }
 547
 548 std::string MEDCouplingUMeshDesc::getVTKDataSetType() const throw(INTERP_KERNEL::Exception)
 549 {
 550   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::getVTKDataSetType : not implemented yet !");
 551 }
 552
 553 DataArrayDouble *MEDCouplingUMeshDesc::computeIsoBarycenterOfNodesPerCell() const throw(INTERP_KERNEL::Exception)
 554 {
 555   throw INTERP_KERNEL::Exception("MEDCouplingUMeshDesc::computeIsoBarycenterOfNodesPerCell : not implemented yet !");
 556 }
 557
 558 void MEDCouplingUMeshDesc::reprQuickOverview(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
 559 {
 560   stream << "MEDCouplingUMeshDesc C++ instance at " << this << ". Name : \"" << getName() << "\".";
 561 }