src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx

   1 //  SMESH DriverMED : driver to read and write 'med' files
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //
  24 //  File   : DriverMED_W_SMESHDS_Mesh.cxx
  25 //  Module : SMESH
  26
  27 #include "DriverMED_W_SMESHDS_Mesh.h"
  28 #include "DriverMED_W_SMDS_Mesh.h"
  29 #include "DriverMED_Family.h"
  30
  31 #include "SMDS_MeshElement.hxx"
  32 #include "SMDS_MeshNode.hxx"
  33 #include "utilities.h"
  34
  35 #include "MEDA_Wrapper.hxx"
  36 #include <sstream>
  37
  38 #include "MED_Utilities.hxx"
  39
  40 DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh()
  41      :
  42        myMesh (NULL),
  43        myFile (""),
  44        myFileId (-1),
  45        myMeshId (-1),
  46        myAllSubMeshes (false),
  47        myDoGroupOfNodes (false),
  48        myDoGroupOfEdges (false),
  49        myDoGroupOfFaces (false),
  50        myDoGroupOfVolumes (false)
  51 {
  52 }
  53
  54 DriverMED_W_SMESHDS_Mesh::~DriverMED_W_SMESHDS_Mesh()
  55 {
  56 }
  57
  58 void DriverMED_W_SMESHDS_Mesh::SetMesh(SMDS_Mesh * aMesh)
  59 {
  60   myMesh = aMesh;
  61 }
  62
  63 void DriverMED_W_SMESHDS_Mesh::SetFile(string aFile)
  64 {
  65   myFile = aFile;
  66 }
  67
  68 void DriverMED_W_SMESHDS_Mesh::SetFileId(med_idt aFileId)
  69 {
  70   myFileId = aFileId;
  71 }
  72
  73 void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId)
  74 {
  75   myMeshId = aMeshId;
  76 }
  77
  78 void DriverMED_W_SMESHDS_Mesh::SetMeshName(string theMeshName)
  79 {
  80   myMeshName = theMeshName;
  81 }
  82
  83 void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_Group* theGroup)
  84 {
  85   myGroups.push_back(theGroup);
  86 }
  87
  88 void DriverMED_W_SMESHDS_Mesh::AddAllSubMeshes()
  89 {
  90   myAllSubMeshes = true;
  91 }
  92
  93 void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int theID)
  94 {
  95   mySubMeshes[theID] = theSubMesh;
  96 }
  97
  98 void DriverMED_W_SMESHDS_Mesh::AddGroupOfNodes()
  99 {
 100   myDoGroupOfNodes = true;
 101 }
 102
 103 void DriverMED_W_SMESHDS_Mesh::AddGroupOfEdges()
 104 {
 105   myDoGroupOfEdges = true;
 106 }
 107
 108 void DriverMED_W_SMESHDS_Mesh::AddGroupOfFaces()
 109 {
 110   myDoGroupOfFaces = true;
 111 }
 112
 113 void DriverMED_W_SMESHDS_Mesh::AddGroupOfVolumes()
 114 {
 115   myDoGroupOfVolumes = true;
 116 }
 117
 118 void DriverMED_W_SMESHDS_Mesh::Write()
 119 {
 120   string myClass = string("SMDS_Mesh");
 121   string myExtension = string("MED");
 122
 123   DriverMED_W_SMDS_Mesh *myWriter = new DriverMED_W_SMDS_Mesh;
 124
 125   myWriter->SetMesh(myMesh);
 126   //  myWriter->SetFile(myFile);
 127   myWriter->SetMeshId(myMeshId);
 128   myWriter->SetFileId(myFileId);
 129
 130   myWriter->Write();
 131 }
 132
 133 void DriverMED_W_SMESHDS_Mesh::Add()
 134 {
 135   if (myMesh->hasConstructionEdges() || myMesh->hasConstructionFaces()) {
 136     INFOS("SMDS_MESH with hasConstructionEdges() or hasConstructionFaces() do not supports!!!");
 137     return;
 138   }
 139   try{
 140     using namespace MEDA;
 141     using namespace boost;
 142
 143     MESSAGE("Add - myFile : "<<myFile);
 144     TWrapper aMed(myFile);
 145
 146     // Creating the MED mesh for corresponding SMDS structure
 147     //-------------------------------------------------------
 148     string aMeshName;
 149     if (myMeshId != -1) {
 150       ostringstream aMeshNameStr;
 151       aMeshNameStr<<myMeshId;
 152       aMeshName = aMeshNameStr.str();
 153     } else {
 154       aMeshName = myMeshName;
 155     }
 156     const int SMDS_MESH_DIM = 3;
 157     PMeshInfo aMeshInfo = TWrapper::CrMeshInfo(SMDS_MESH_DIM,aMeshName);
 158     MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
 159     aMed.SetMeshInfo(aMeshInfo);
 160
 161     // Storing SMDS groups and sub-meshes
 162     //-----------------------------------
 163     int myNodesDefaultFamilyId = 0;
 164     int myEdgesDefaultFamilyId = 0;
 165     int myFacesDefaultFamilyId = 0;
 166     int myVolumesDefaultFamilyId = 0;
 167     if (myDoGroupOfNodes)
 168       myNodesDefaultFamilyId = REST_NODES_FAMILY;
 169     if (myDoGroupOfEdges)
 170       myEdgesDefaultFamilyId = REST_EDGES_FAMILY;
 171     if (myDoGroupOfFaces)
 172       myFacesDefaultFamilyId = REST_FACES_FAMILY;
 173     if (myDoGroupOfVolumes)
 174       myVolumesDefaultFamilyId = REST_VOLUMES_FAMILY;
 175
 176     MESSAGE("Add - aFamilyInfo");
 177     map<const SMDS_MeshElement *, int> anElemFamMap;
 178     list<DriverMED_FamilyPtr> aFamilies;
 179     if (myAllSubMeshes) {
 180       SMESHDS_Mesh* aSMESHDSMesh = dynamic_cast<SMESHDS_Mesh*>(myMesh);
 181       if (!aSMESHDSMesh) {
 182         EXCEPTION(runtime_error,"Can not cast SMDS_Mesh to SMESHDS_Mesh");
 183       }
 184       aFamilies = DriverMED_Family::MakeFamilies
 185         (aSMESHDSMesh->SubMeshes(), myGroups,
 186          myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
 187     } else {
 188       aFamilies = DriverMED_Family::MakeFamilies
 189         (mySubMeshes, myGroups,
 190          myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
 191     }
 192     list<DriverMED_FamilyPtr>::iterator aFamsIter = aFamilies.begin();
 193
 194     for (; aFamsIter != aFamilies.end(); aFamsIter++)
 195     {
 196       PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(aMeshInfo);
 197       aMed.SetFamilyInfo(aFamilyInfo);
 198       int aFamId = (*aFamsIter)->GetId();
 199
 200       const set<const SMDS_MeshElement *>& anElems = (*aFamsIter)->GetElements();
 201       set<const SMDS_MeshElement *>::iterator anElemsIter = anElems.begin();
 202       for (; anElemsIter != anElems.end(); anElemsIter++)
 203       {
 204         anElemFamMap[*anElemsIter] = aFamId;
 205       }
 206 //      delete (*aFamsIter);
 207     }
 208
 209     // Storing SMDS nodes to the MED file for the MED mesh
 210     //----------------------------------------------------
 211     typedef map<med_int,med_int> TNodeIdMap;
 212     TNodeIdMap aNodeIdMap;
 213
 214     med_int aNbElems = myMesh->NbNodes();
 215     MED::TIntVector anElemNums(aNbElems);
 216     MED::TIntVector aFamilyNums(aNbElems);
 217     MED::TFloatVector aCoordinates(aNbElems*SMDS_MESH_DIM);
 218     SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
 219     for(med_int iNode = 0, iCoord = 0; aNodesIter->more(); iNode++, iCoord+=SMDS_MESH_DIM){
 220       const SMDS_MeshNode* aNode = aNodesIter->next();
 221       aCoordinates[iCoord] = aNode->X();
 222       aCoordinates[iCoord+1] = aNode->Y();
 223       aCoordinates[iCoord+2] = aNode->Z();
 224       TNodeIdMap::key_type aNodeId = aNode->GetID();
 225       anElemNums[iNode] = aNodeId;
 226       aNodeIdMap[aNodeId] = iNode+1;
 227       //cout<<aNode->GetID()<<": "<<aNode->X()<<", "<<aNode->Y()<<", "<<aNode->Z()<<endl;
 228
 229       if (anElemFamMap.find(aNode) != anElemFamMap.end())
 230         aFamilyNums[iNode] = anElemFamMap[aNode];
 231       else
 232         aFamilyNums[iNode] = myNodesDefaultFamilyId;
 233     }
 234
 235     MED::TStringVector aCoordNames(3);
 236     aCoordNames[0] = "x";  aCoordNames[1] = "y";  aCoordNames[2] = "z";
 237
 238     MED::TStringVector aCoordUnits(3);
 239     aCoordUnits[0] = "m";  aCoordUnits[1] = "m";  aCoordUnits[2] = "m";
 240
 241     const med_repere SMDS_COORDINATE_SYSTEM = MED_CART;
 242
 243     PNodeInfo aNodeInfo = TWrapper::CrNodeInfo(aMeshInfo,
 244                                                SMDS_COORDINATE_SYSTEM,
 245                                                aCoordinates,
 246                                                aCoordNames,
 247                                                aCoordUnits,
 248                                                aFamilyNums,
 249                                                anElemNums);
 250     MESSAGE("Add - aNodeInfo->GetNbElem() = "<<aNbElems);
 251     aMed.SetNodeInfo(aNodeInfo);
 252
 253
 254     // Storing others SMDS elements to the MED file for the MED mesh
 255     //--------------------------------------------------------------
 256     const med_entite_maillage SMDS_MED_ENTITY = MED_MAILLE;
 257     const med_connectivite SMDS_MED_CONNECTIVITY = MED_NOD;
 258
 259     // Storing SMDS Edges
 260     if(med_int aNbElems = myMesh->NbEdges()){
 261       SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator();
 262       med_int aNbConnectivity = MED::GetNbConn(SMDS_MED_ENTITY,MED_SEG2,SMDS_MESH_DIM);
 263       MED::TIntVector anElemNums(aNbElems);
 264       MED::TIntVector aFamilyNums(aNbElems);
 265       MED::TIntVector aConnectivity(aNbElems*aNbConnectivity);
 266
 267       for(med_int iElem = 0, iConn = 0; anIter->more(); iElem++, iConn+=aNbConnectivity){
 268         const SMDS_MeshEdge* anElem = anIter->next();
 269         SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
 270         for(med_int iNode = 0; iNode < aNbConnectivity && aNodesIter->more(); iNode++){
 271           const SMDS_MeshElement* aNode = aNodesIter->next();
 272           aConnectivity[iConn+iNode] = aNodeIdMap[aNode->GetID()];
 273         }
 274         anElemNums[iElem] = anElem->GetID();
 275
 276         if (anElemFamMap.find(anElem) != anElemFamMap.end())
 277           aFamilyNums[iElem] = anElemFamMap[anElem];
 278         else
 279           aFamilyNums[iElem] = myEdgesDefaultFamilyId;
 280       }
 281
 282       PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 283                                                  SMDS_MED_ENTITY,
 284                                                  MED_SEG2,
 285                                                  SMDS_MED_CONNECTIVITY,
 286                                                  aConnectivity,
 287                                                  aFamilyNums,
 288                                                  anElemNums);
 289       aMed.SetCellInfo(aCellInfo);
 290     }
 291
 292     // Storing SMDS Faces
 293     if(med_int aNbElems = myMesh->NbFaces()){
 294       SMDS_FaceIteratorPtr anIter = myMesh->facesIterator();
 295
 296       med_int aNbTriaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TRIA3,SMDS_MESH_DIM);
 297       MED::TIntVector anTriaElemNums;
 298       anTriaElemNums.reserve(aNbElems);
 299       MED::TIntVector aTriaFamilyNums;
 300       aTriaFamilyNums.reserve(aNbElems);
 301       MED::TIntVector aTriaConn;
 302       aTriaConn.reserve(aNbElems*aNbTriaConn);
 303
 304       med_int aNbQuadConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_QUAD4,SMDS_MESH_DIM);
 305       MED::TIntVector aQuadElemNums;
 306       aQuadElemNums.reserve(aNbElems);
 307       MED::TIntVector aQuadFamilyNums;
 308       aQuadFamilyNums.reserve(aNbElems);
 309       MED::TIntVector aQuadConn;
 310       aQuadConn.reserve(aNbElems*aNbQuadConn);
 311
 312       for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
 313         const SMDS_MeshFace* anElem = anIter->next();
 314         med_int aNbNodes = anElem->NbNodes();
 315         SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
 316         med_int aNbConnectivity;
 317         MED::TIntVector* anElemNums;
 318         MED::TIntVector* aFamilyNums;
 319         MED::TIntVector* aConnectivity;
 320         switch(aNbNodes){
 321         case 3:
 322           aNbConnectivity = aNbTriaConn;
 323           anElemNums = &anTriaElemNums;
 324           aFamilyNums = &aTriaFamilyNums;
 325           aConnectivity = &aTriaConn;
 326           break;
 327         case 4:
 328           aNbConnectivity = aNbQuadConn;
 329           anElemNums = &aQuadElemNums;
 330           aFamilyNums = &aQuadFamilyNums;
 331           aConnectivity = &aQuadConn;
 332           break;
 333         }
 334         MED::TIntVector aVector(aNbNodes);
 335         for(med_int iNode = 0; aNodesIter->more(); iNode++){
 336           const SMDS_MeshElement* aNode = aNodesIter->next();
 337           aVector[iNode] = aNode->GetID();
 338         }
 339
 340         med_int aSize = aConnectivity->size();
 341         aConnectivity->resize(aSize+aNbConnectivity);
 342         // There is some differnce between SMDS and MED in cells mapping
 343         switch(aNbNodes){
 344         case 4:
 345           (*aConnectivity)[aSize+0] = aNodeIdMap[aVector[0]];
 346           (*aConnectivity)[aSize+1] = aNodeIdMap[aVector[1]];
 347           (*aConnectivity)[aSize+2] = aNodeIdMap[aVector[3]];
 348           (*aConnectivity)[aSize+3] = aNodeIdMap[aVector[2]];
 349         default:
 350           for(med_int iNode = 0; iNode < aNbNodes; iNode++)
 351             (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]];
 352         }
 353         anElemNums->push_back(anElem->GetID());
 354
 355         if (anElemFamMap.find(anElem) != anElemFamMap.end())
 356           aFamilyNums->push_back(anElemFamMap[anElem]);
 357         else
 358           aFamilyNums->push_back(myFacesDefaultFamilyId);
 359       }
 360       if(med_int aNbElems = anTriaElemNums.size()){
 361         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 362                                                    SMDS_MED_ENTITY,
 363                                                    MED_TRIA3,
 364                                                    SMDS_MED_CONNECTIVITY,
 365                                                    aTriaConn,
 366                                                    aTriaFamilyNums,
 367                                                    anTriaElemNums);
 368         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TRIA3<<"; aNbElems = "<<aNbElems);
 369         aMed.SetCellInfo(aCellInfo);
 370       }
 371       if(med_int aNbElems = aQuadElemNums.size()){
 372         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 373                                                    SMDS_MED_ENTITY,
 374                                                    MED_QUAD4,
 375                                                    SMDS_MED_CONNECTIVITY,
 376                                                    aQuadConn,
 377                                                    aQuadFamilyNums,
 378                                                    aQuadElemNums);
 379         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_QUAD4<<"; aNbElems = "<<aNbElems);
 380         aMed.SetCellInfo(aCellInfo);
 381       }
 382     }
 383
 384     // Storing SMDS Volumes
 385     if(med_int aNbElems = myMesh->NbVolumes()){
 386       SMDS_VolumeIteratorPtr anIter = myMesh->volumesIterator();
 387
 388       med_int aNbTetraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TETRA4,SMDS_MESH_DIM);
 389       MED::TIntVector anTetraElemNums;
 390       anTetraElemNums.reserve(aNbElems);
 391       MED::TIntVector aTetraFamilyNums;
 392       aTetraFamilyNums.reserve(aNbElems);
 393       MED::TIntVector aTetraConn;
 394       aTetraConn.reserve(aNbElems*aNbTetraConn);
 395
 396       med_int aNbPyraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PYRA5,SMDS_MESH_DIM);
 397       MED::TIntVector anPyraElemNums;
 398       anPyraElemNums.reserve(aNbElems);
 399       MED::TIntVector aPyraFamilyNums;
 400       aPyraFamilyNums.reserve(aNbElems);
 401       MED::TIntVector aPyraConn;
 402       aPyraConn.reserve(aNbElems*aNbPyraConn);
 403
 404       med_int aNbPentaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PENTA6,SMDS_MESH_DIM);
 405       MED::TIntVector anPentaElemNums;
 406       anPentaElemNums.reserve(aNbElems);
 407       MED::TIntVector aPentaFamilyNums;
 408       aPentaFamilyNums.reserve(aNbElems);
 409       MED::TIntVector aPentaConn;
 410       aPentaConn.reserve(aNbElems*aNbPentaConn);
 411
 412       med_int aNbHexaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_HEXA8,SMDS_MESH_DIM);
 413       MED::TIntVector aHexaElemNums;
 414       aHexaElemNums.reserve(aNbElems);
 415       MED::TIntVector aHexaFamilyNums;
 416       aHexaFamilyNums.reserve(aNbElems);
 417       MED::TIntVector aHexaConn;
 418       aHexaConn.reserve(aNbElems*aNbHexaConn);
 419
 420       for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
 421         const SMDS_MeshVolume* anElem = anIter->next();
 422         med_int aNbNodes = anElem->NbNodes();
 423         SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
 424         med_int aNbConnectivity;
 425         MED::TIntVector* anElemNums;
 426         MED::TIntVector* aFamilyNums;
 427         MED::TIntVector* aConnectivity;
 428         switch(aNbNodes){
 429         case 4:
 430           aNbConnectivity = aNbTetraConn;
 431           anElemNums = &anTetraElemNums;
 432           aFamilyNums = &aTetraFamilyNums;
 433           aConnectivity = &aTetraConn;
 434           break;
 435         case 5:
 436           aNbConnectivity = aNbPyraConn;
 437           anElemNums = &anPyraElemNums;
 438           aFamilyNums = &aPyraFamilyNums;
 439           aConnectivity = &aPyraConn;
 440           break;
 441         case 6:
 442           aNbConnectivity = aNbPentaConn;
 443           anElemNums = &anPentaElemNums;
 444           aFamilyNums = &aPentaFamilyNums;
 445           aConnectivity = &aPentaConn;
 446           break;
 447         case 8:
 448           aNbConnectivity = aNbHexaConn;
 449           anElemNums = &aHexaElemNums;
 450           aFamilyNums = &aHexaFamilyNums;
 451           aConnectivity = &aHexaConn;
 452         }
 453
 454         MED::TIntVector aVector(aNbNodes);
 455         for(med_int iNode = 0; aNodesIter->more(); iNode++){
 456           const SMDS_MeshElement* aNode = aNodesIter->next();
 457           aVector[iNode] = aNode->GetID();
 458         }
 459         med_int aSize = aConnectivity->size();
 460         aConnectivity->resize(aSize+aNbConnectivity);
 461         // There is some difference between SMDS and MED in cells mapping
 462         switch(aNbNodes){
 463         case 5:
 464           (*aConnectivity)[aSize+0] = aNodeIdMap[aVector[0]];
 465           (*aConnectivity)[aSize+1] = aNodeIdMap[aVector[3]];
 466           (*aConnectivity)[aSize+2] = aNodeIdMap[aVector[2]];
 467           (*aConnectivity)[aSize+3] = aNodeIdMap[aVector[1]];
 468           (*aConnectivity)[aSize+4] = aNodeIdMap[aVector[4]];
 469         default:
 470           for(med_int iNode = 0; iNode < aNbNodes; iNode++)
 471             (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]];
 472         }
 473         anElemNums->push_back(anElem->GetID());
 474
 475         if (anElemFamMap.find(anElem) != anElemFamMap.end())
 476           aFamilyNums->push_back(anElemFamMap[anElem]);
 477         else
 478           aFamilyNums->push_back(myVolumesDefaultFamilyId);
 479       }
 480
 481       if(med_int aNbElems = anTetraElemNums.size()){
 482         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 483                                                    SMDS_MED_ENTITY,
 484                                                    MED_TETRA4,
 485                                                    SMDS_MED_CONNECTIVITY,
 486                                                    aTetraConn,
 487                                                    aTetraFamilyNums,
 488                                                    anTetraElemNums);
 489         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TETRA4<<"; aNbElems = "<<aNbElems);
 490         aMed.SetCellInfo(aCellInfo);
 491       }
 492       if(med_int aNbElems = anPyraElemNums.size()){
 493         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 494                                                    SMDS_MED_ENTITY,
 495                                                    MED_PYRA5,
 496                                                    SMDS_MED_CONNECTIVITY,
 497                                                    aPyraConn,
 498                                                    aPyraFamilyNums,
 499                                                    anPyraElemNums);
 500         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PYRA5<<"; aNbElems = "<<aNbElems);
 501         aMed.SetCellInfo(aCellInfo);
 502       }
 503       if(med_int aNbElems = anPentaElemNums.size()){
 504         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 505                                                    SMDS_MED_ENTITY,
 506                                                    MED_PENTA6,
 507                                                    SMDS_MED_CONNECTIVITY,
 508                                                    aPentaConn,
 509                                                    aPentaFamilyNums,
 510                                                    anPentaElemNums);
 511         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PENTA6<<"; aNbElems = "<<aNbElems);
 512         aMed.SetCellInfo(aCellInfo);
 513       }
 514       if(med_int aNbElems = aHexaElemNums.size()){
 515         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 516                                                    SMDS_MED_ENTITY,
 517                                                    MED_HEXA8,
 518                                                    SMDS_MED_CONNECTIVITY,
 519                                                    aHexaConn,
 520                                                    aHexaFamilyNums,
 521                                                    aHexaElemNums);
 522         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_HEXA8<<"; aNbElems = "<<aNbElems);
 523         aMed.SetCellInfo(aCellInfo);
 524       }
 525     }
 526   }catch(const std::exception& exc){
 527     INFOS("Follow exception was cought:\n\t"<<exc.what());
 528   }catch(...){
 529     INFOS("Unknown exception was cought !!!");
 530   }
 531
 532   myMeshId = -1;
 533   myGroups.clear();
 534   mySubMeshes.clear();
 535 }