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     med_int aNbElems = myMesh->NbNodes();
 212     MED::TIntVector anElemNums(aNbElems);
 213     MED::TIntVector aFamilyNums(aNbElems);
 214     MED::TFloatVector aCoordinates(aNbElems*SMDS_MESH_DIM);
 215     SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
 216     for(med_int iNode = 0, iCoord = 0; aNodesIter->more(); iNode++, iCoord+=SMDS_MESH_DIM){
 217       const SMDS_MeshNode* aNode = aNodesIter->next();
 218       aCoordinates[iCoord] = aNode->X();
 219       aCoordinates[iCoord+1] = aNode->Y();
 220       aCoordinates[iCoord+2] = aNode->Z();
 221       anElemNums[iNode] = aNode->GetID();
 222       //cout<<aNode->GetID()<<": "<<aNode->X()<<", "<<aNode->Y()<<", "<<aNode->Z()<<endl;
 223
 224       if (anElemFamMap.find(aNode) != anElemFamMap.end())
 225         aFamilyNums[iNode] = anElemFamMap[aNode];
 226       else
 227         aFamilyNums[iNode] = myNodesDefaultFamilyId;
 228     }
 229
 230     MED::TStringVector aCoordNames(3);
 231     aCoordNames[0] = "x";  aCoordNames[1] = "y";  aCoordNames[2] = "z";
 232
 233     MED::TStringVector aCoordUnits(3);
 234     aCoordUnits[0] = "m";  aCoordUnits[1] = "m";  aCoordUnits[2] = "m";
 235
 236     const med_repere SMDS_COORDINATE_SYSTEM = MED_CART;
 237
 238     PNodeInfo aNodeInfo = TWrapper::CrNodeInfo(aMeshInfo,
 239                                                SMDS_COORDINATE_SYSTEM,
 240                                                aCoordinates,
 241                                                aCoordNames,
 242                                                aCoordUnits,
 243                                                aFamilyNums,
 244                                                anElemNums);
 245     MESSAGE("Add - aNodeInfo->GetNbElem() = "<<aNbElems);
 246     aMed.SetNodeInfo(aNodeInfo);
 247
 248
 249     // Storing others SMDS elements to the MED file for the MED mesh
 250     //--------------------------------------------------------------
 251     const med_entite_maillage SMDS_MED_ENTITY = MED_MAILLE;
 252     const med_connectivite SMDS_MED_CONNECTIVITY = MED_NOD;
 253
 254     // Storing SMDS Edges
 255     if(med_int aNbElems = myMesh->NbEdges()){
 256       SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator();
 257       med_int aNbConnectivity = MED::GetNbConn(SMDS_MED_ENTITY,MED_SEG2,SMDS_MESH_DIM);
 258       MED::TIntVector anElemNums(aNbElems);
 259       MED::TIntVector aFamilyNums(aNbElems);
 260       MED::TIntVector aConnectivity(aNbElems*aNbConnectivity);
 261
 262       for(med_int iElem = 0, iConn = 0; anIter->more(); iElem++, iConn+=aNbConnectivity){
 263         const SMDS_MeshEdge* anElem = anIter->next();
 264         SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
 265         for(med_int iNode = 0; iNode < aNbConnectivity && aNodesIter->more(); iNode++){
 266           const SMDS_MeshElement* aNode = aNodesIter->next();
 267           aConnectivity[iConn+iNode] = aNode->GetID();
 268         }
 269         anElemNums[iElem] = anElem->GetID();
 270         //cout<<anElem->GetID()<<": ";
 271         //for(med_int iNode = 0; iNode < aNbNodes; iNode++)
 272         //  cout<<(*aConnectivity)[iConn+iNode]<<", ";
 273         //cout<<endl;
 274
 275         if (anElemFamMap.find(anElem) != anElemFamMap.end())
 276           aFamilyNums[iElem] = anElemFamMap[anElem];
 277         else
 278           aFamilyNums[iElem] = myEdgesDefaultFamilyId;
 279       }
 280
 281       PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 282                                                  SMDS_MED_ENTITY,
 283                                                  MED_SEG2,
 284                                                  SMDS_MED_CONNECTIVITY,
 285                                                  aConnectivity,
 286                                                  aFamilyNums,
 287                                                  anElemNums);
 288       aMed.SetCellInfo(aCellInfo);
 289     }
 290
 291     // Storing SMDS Faces
 292     if(med_int aNbElems = myMesh->NbFaces()){
 293       SMDS_FaceIteratorPtr anIter = myMesh->facesIterator();
 294
 295       med_int aNbTriaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TRIA3,SMDS_MESH_DIM);
 296       MED::TIntVector anTriaElemNums;
 297       anTriaElemNums.reserve(aNbElems);
 298       MED::TIntVector aTriaFamilyNums;
 299       aTriaFamilyNums.reserve(aNbElems);
 300       MED::TIntVector aTriaConn;
 301       aTriaConn.reserve(aNbElems*aNbTriaConn);
 302
 303       med_int aNbQuadConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_QUAD4,SMDS_MESH_DIM);
 304       MED::TIntVector aQuadElemNums;
 305       aQuadElemNums.reserve(aNbElems);
 306       MED::TIntVector aQuadFamilyNums;
 307       aQuadFamilyNums.reserve(aNbElems);
 308       MED::TIntVector aQuadConn;
 309       aQuadConn.reserve(aNbElems*aNbQuadConn);
 310
 311       for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
 312         const SMDS_MeshFace* anElem = anIter->next();
 313         med_int aNbNodes = anElem->NbNodes();
 314         SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
 315         med_int aNbConnectivity;
 316         MED::TIntVector* anElemNums;
 317         MED::TIntVector* aFamilyNums;
 318         MED::TIntVector* aConnectivity;
 319         switch(aNbNodes){
 320         case 3:
 321           aNbConnectivity = aNbTriaConn;
 322           anElemNums = &anTriaElemNums;
 323           aFamilyNums = &aTriaFamilyNums;
 324           aConnectivity = &aTriaConn;
 325           break;
 326         case 4:
 327           aNbConnectivity = aNbQuadConn;
 328           anElemNums = &aQuadElemNums;
 329           aFamilyNums = &aQuadFamilyNums;
 330           aConnectivity = &aQuadConn;
 331           break;
 332         }
 333         MED::TIntVector aVector(aNbNodes);
 334         for(med_int iNode = 0; aNodesIter->more(); iNode++){
 335           const SMDS_MeshElement* aNode = aNodesIter->next();
 336           aVector[iNode] = aNode->GetID();
 337         }
 338
 339         med_int aSize = aConnectivity->size();
 340         aConnectivity->resize(aSize+aNbConnectivity);
 341         // There is some differnce between SMDS and MED in cells mapping
 342         switch(aNbNodes){
 343         case 4:
 344           (*aConnectivity)[aSize+0] = aVector[0];
 345           (*aConnectivity)[aSize+1] = aVector[1];
 346           (*aConnectivity)[aSize+2] = aVector[3];
 347           (*aConnectivity)[aSize+3] = aVector[2];
 348         default:
 349           for(med_int iNode = 0; iNode < aNbNodes; iNode++)
 350             (*aConnectivity)[aSize+iNode] = aVector[iNode];
 351         }
 352         anElemNums->push_back(anElem->GetID());
 353         //cout<<anElem->GetID()<<": ";
 354         //for(med_int iNode = 0; iNode < aNbNodes; iNode++)
 355         //  cout<<(*aConnectivity)[aSize+iNode]<<", ";
 356         //cout<<endl;
 357
 358         if (anElemFamMap.find(anElem) != anElemFamMap.end())
 359           aFamilyNums->push_back(anElemFamMap[anElem]);
 360         else
 361           aFamilyNums->push_back(myFacesDefaultFamilyId);
 362       }
 363       if(med_int aNbElems = anTriaElemNums.size()){
 364         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 365                                                    SMDS_MED_ENTITY,
 366                                                    MED_TRIA3,
 367                                                    SMDS_MED_CONNECTIVITY,
 368                                                    aTriaConn,
 369                                                    aTriaFamilyNums,
 370                                                    anTriaElemNums);
 371         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TRIA3<<"; aNbElems = "<<aNbElems);
 372         aMed.SetCellInfo(aCellInfo);
 373       }
 374       if(med_int aNbElems = aQuadElemNums.size()){
 375         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 376                                                    SMDS_MED_ENTITY,
 377                                                    MED_QUAD4,
 378                                                    SMDS_MED_CONNECTIVITY,
 379                                                    aQuadConn,
 380                                                    aQuadFamilyNums,
 381                                                    aQuadElemNums);
 382         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_QUAD4<<"; aNbElems = "<<aNbElems);
 383         aMed.SetCellInfo(aCellInfo);
 384       }
 385     }
 386
 387     // Storing SMDS Volumes
 388     if(med_int aNbElems = myMesh->NbVolumes()){
 389       SMDS_VolumeIteratorPtr anIter = myMesh->volumesIterator();
 390
 391       med_int aNbTetraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TETRA4,SMDS_MESH_DIM);
 392       MED::TIntVector anTetraElemNums;
 393       anTetraElemNums.reserve(aNbElems);
 394       MED::TIntVector aTetraFamilyNums;
 395       aTetraFamilyNums.reserve(aNbElems);
 396       MED::TIntVector aTetraConn;
 397       aTetraConn.reserve(aNbElems*aNbTetraConn);
 398
 399       med_int aNbPyraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PYRA5,SMDS_MESH_DIM);
 400       MED::TIntVector anPyraElemNums;
 401       anPyraElemNums.reserve(aNbElems);
 402       MED::TIntVector aPyraFamilyNums;
 403       aPyraFamilyNums.reserve(aNbElems);
 404       MED::TIntVector aPyraConn;
 405       aPyraConn.reserve(aNbElems*aNbPyraConn);
 406
 407       med_int aNbPentaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PENTA6,SMDS_MESH_DIM);
 408       MED::TIntVector anPentaElemNums;
 409       anPentaElemNums.reserve(aNbElems);
 410       MED::TIntVector aPentaFamilyNums;
 411       aPentaFamilyNums.reserve(aNbElems);
 412       MED::TIntVector aPentaConn;
 413       aPentaConn.reserve(aNbElems*aNbPentaConn);
 414
 415       med_int aNbHexaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_HEXA8,SMDS_MESH_DIM);
 416       MED::TIntVector aHexaElemNums;
 417       aHexaElemNums.reserve(aNbElems);
 418       MED::TIntVector aHexaFamilyNums;
 419       aHexaFamilyNums.reserve(aNbElems);
 420       MED::TIntVector aHexaConn;
 421       aHexaConn.reserve(aNbElems*aNbHexaConn);
 422
 423       for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
 424         const SMDS_MeshVolume* anElem = anIter->next();
 425         med_int aNbNodes = anElem->NbNodes();
 426         SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
 427         med_int aNbConnectivity;
 428         MED::TIntVector* anElemNums;
 429         MED::TIntVector* aFamilyNums;
 430         MED::TIntVector* aConnectivity;
 431         switch(aNbNodes){
 432         case 4:
 433           aNbConnectivity = aNbTetraConn;
 434           anElemNums = &anTetraElemNums;
 435           aFamilyNums = &aTetraFamilyNums;
 436           aConnectivity = &aTetraConn;
 437           break;
 438         case 5:
 439           aNbConnectivity = aNbPyraConn;
 440           anElemNums = &anPyraElemNums;
 441           aFamilyNums = &aPyraFamilyNums;
 442           aConnectivity = &aPyraConn;
 443           break;
 444         case 6:
 445           aNbConnectivity = aNbPentaConn;
 446           anElemNums = &anPentaElemNums;
 447           aFamilyNums = &aPentaFamilyNums;
 448           aConnectivity = &aPentaConn;
 449           break;
 450         case 8:
 451           aNbConnectivity = aNbHexaConn;
 452           anElemNums = &aHexaElemNums;
 453           aFamilyNums = &aHexaFamilyNums;
 454           aConnectivity = &aHexaConn;
 455         }
 456
 457         MED::TIntVector aVector(aNbNodes);
 458         for(med_int iNode = 0; aNodesIter->more(); iNode++){
 459           const SMDS_MeshElement* aNode = aNodesIter->next();
 460           aVector[iNode] = aNode->GetID();
 461         }
 462         med_int aSize = aConnectivity->size();
 463         aConnectivity->resize(aSize+aNbConnectivity);
 464         // There is some difference between SMDS and MED in cells mapping
 465         switch(aNbNodes){
 466         case 5:
 467           (*aConnectivity)[aSize+0] = aVector[0];
 468           (*aConnectivity)[aSize+1] = aVector[3];
 469           (*aConnectivity)[aSize+2] = aVector[2];
 470           (*aConnectivity)[aSize+3] = aVector[1];
 471           (*aConnectivity)[aSize+4] = aVector[4];
 472         default:
 473           for(med_int iNode = 0; iNode < aNbNodes; iNode++)
 474             (*aConnectivity)[aSize+iNode] = aVector[iNode];
 475         }
 476         anElemNums->push_back(anElem->GetID());
 477
 478         if (anElemFamMap.find(anElem) != anElemFamMap.end())
 479           aFamilyNums->push_back(anElemFamMap[anElem]);
 480         else
 481           aFamilyNums->push_back(myVolumesDefaultFamilyId);
 482       }
 483
 484       if(med_int aNbElems = anTetraElemNums.size()){
 485         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 486                                                    SMDS_MED_ENTITY,
 487                                                    MED_TETRA4,
 488                                                    SMDS_MED_CONNECTIVITY,
 489                                                    aTetraConn,
 490                                                    aTetraFamilyNums,
 491                                                    anTetraElemNums);
 492         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TETRA4<<"; aNbElems = "<<aNbElems);
 493         aMed.SetCellInfo(aCellInfo);
 494       }
 495       if(med_int aNbElems = anPyraElemNums.size()){
 496         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 497                                                    SMDS_MED_ENTITY,
 498                                                    MED_PYRA5,
 499                                                    SMDS_MED_CONNECTIVITY,
 500                                                    aPyraConn,
 501                                                    aPyraFamilyNums,
 502                                                    anPyraElemNums);
 503         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PYRA5<<"; aNbElems = "<<aNbElems);
 504         aMed.SetCellInfo(aCellInfo);
 505       }
 506       if(med_int aNbElems = anPentaElemNums.size()){
 507         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 508                                                    SMDS_MED_ENTITY,
 509                                                    MED_PENTA6,
 510                                                    SMDS_MED_CONNECTIVITY,
 511                                                    aPentaConn,
 512                                                    aPentaFamilyNums,
 513                                                    anPentaElemNums);
 514         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PENTA6<<"; aNbElems = "<<aNbElems);
 515         aMed.SetCellInfo(aCellInfo);
 516       }
 517       if(med_int aNbElems = aHexaElemNums.size()){
 518         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 519                                                    SMDS_MED_ENTITY,
 520                                                    MED_HEXA8,
 521                                                    SMDS_MED_CONNECTIVITY,
 522                                                    aHexaConn,
 523                                                    aHexaFamilyNums,
 524                                                    aHexaElemNums);
 525         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_HEXA8<<"; aNbElems = "<<aNbElems);
 526         aMed.SetCellInfo(aCellInfo);
 527       }
 528     }
 529   }catch(const std::exception& exc){
 530     INFOS("Follow exception was cought:\n\t"<<exc.what());
 531   }catch(...){
 532     INFOS("Unknown exception was cought !!!");
 533   }
 534
 535   myMeshId = -1;
 536   myGroups.clear();
 537   mySubMeshes.clear();
 538 }