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 #define _EDF_NODE_IDS_
  41 #define _ELEMENTS_BY_DIM_
  42
  43 DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh()
  44      :
  45        myMesh (NULL),
  46        myFile (""),
  47        myFileId (-1),
  48        myMeshId (-1),
  49        myAllSubMeshes (false),
  50        myDoGroupOfNodes (false),
  51        myDoGroupOfEdges (false),
  52        myDoGroupOfFaces (false),
  53        myDoGroupOfVolumes (false)
  54 {
  55 }
  56
  57 DriverMED_W_SMESHDS_Mesh::~DriverMED_W_SMESHDS_Mesh()
  58 {
  59 }
  60
  61 void DriverMED_W_SMESHDS_Mesh::SetMesh(SMDS_Mesh * aMesh)
  62 {
  63   myMesh = aMesh;
  64 }
  65
  66 void DriverMED_W_SMESHDS_Mesh::SetFile(string aFile)
  67 {
  68   myFile = aFile;
  69 }
  70
  71 void DriverMED_W_SMESHDS_Mesh::SetFileId(med_idt aFileId)
  72 {
  73   myFileId = aFileId;
  74 }
  75
  76 void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId)
  77 {
  78   myMeshId = aMeshId;
  79 }
  80
  81 void DriverMED_W_SMESHDS_Mesh::SetMeshName(string theMeshName)
  82 {
  83   myMeshName = theMeshName;
  84 }
  85
  86 void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_Group* theGroup)
  87 {
  88   myGroups.push_back(theGroup);
  89 }
  90
  91 void DriverMED_W_SMESHDS_Mesh::AddAllSubMeshes()
  92 {
  93   myAllSubMeshes = true;
  94 }
  95
  96 void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int theID)
  97 {
  98   mySubMeshes[theID] = theSubMesh;
  99 }
 100
 101 void DriverMED_W_SMESHDS_Mesh::AddGroupOfNodes()
 102 {
 103   myDoGroupOfNodes = true;
 104 }
 105
 106 void DriverMED_W_SMESHDS_Mesh::AddGroupOfEdges()
 107 {
 108   myDoGroupOfEdges = true;
 109 }
 110
 111 void DriverMED_W_SMESHDS_Mesh::AddGroupOfFaces()
 112 {
 113   myDoGroupOfFaces = true;
 114 }
 115
 116 void DriverMED_W_SMESHDS_Mesh::AddGroupOfVolumes()
 117 {
 118   myDoGroupOfVolumes = true;
 119 }
 120
 121 void DriverMED_W_SMESHDS_Mesh::Write()
 122 {
 123   string myClass = string("SMDS_Mesh");
 124   string myExtension = string("MED");
 125
 126   DriverMED_W_SMDS_Mesh *myWriter = new DriverMED_W_SMDS_Mesh;
 127
 128   myWriter->SetMesh(myMesh);
 129   //  myWriter->SetFile(myFile);
 130   myWriter->SetMeshId(myMeshId);
 131   myWriter->SetFileId(myFileId);
 132
 133   myWriter->Write();
 134 }
 135
 136
 137 typedef double (SMDS_MeshNode::* TGetCoord)() const;
 138 typedef const char* TName;
 139 typedef const char* TUnit;
 140
 141 static TUnit aUnit[3] = {"m","m","m"};
 142
 143 static TGetCoord aXYZGetCoord[3] = {
 144   &SMDS_MeshNode::X,
 145   &SMDS_MeshNode::Y,
 146   &SMDS_MeshNode::Z
 147 };
 148 static TName aXYZName[3] = {"x","y","z"};
 149
 150
 151 static TGetCoord aXYGetCoord[2] = {
 152   &SMDS_MeshNode::X,
 153   &SMDS_MeshNode::Y
 154 };
 155 static TName aXYName[2] = {"x","y"};
 156
 157 static TGetCoord aYZGetCoord[2] = {
 158   &SMDS_MeshNode::Y,
 159   &SMDS_MeshNode::Z
 160 };
 161 static TName aYZName[2] = {"y","z"};
 162
 163 static TGetCoord aXZGetCoord[2] = {
 164   &SMDS_MeshNode::X,
 165   &SMDS_MeshNode::Z
 166 };
 167 static TName aXZName[2] = {"x","z"};
 168
 169
 170 static TGetCoord aXGetCoord[1] = {
 171   &SMDS_MeshNode::X
 172 };
 173 static TName aXName[1] = {"x"};
 174
 175 static TGetCoord aYGetCoord[1] = {
 176   &SMDS_MeshNode::Y
 177 };
 178 static TName aYName[1] = {"y"};
 179
 180 static TGetCoord aZGetCoord[1] = {
 181   &SMDS_MeshNode::Z
 182 };
 183 static TName aZName[1] = {"z"};
 184
 185
 186 class TCoordHelper{
 187   SMDS_NodeIteratorPtr myNodeIter;
 188   const SMDS_MeshNode* myCurrentNode;
 189   TGetCoord* myGetCoord;
 190   TName* myName;
 191   TUnit* myUnit;
 192 public:
 193   TCoordHelper(const SMDS_NodeIteratorPtr& theNodeIter,
 194                TGetCoord* theGetCoord,
 195                TName* theName,
 196                TUnit* theUnit = aUnit):
 197     myNodeIter(theNodeIter),
 198     myGetCoord(theGetCoord),
 199     myName(theName),
 200     myUnit(theUnit)
 201   {}
 202   virtual ~TCoordHelper(){}
 203   bool Next(){
 204     return myNodeIter->more() &&
 205       (myCurrentNode = myNodeIter->next());
 206   }
 207   const SMDS_MeshNode* GetNode(){
 208     return myCurrentNode;
 209   }
 210   MED::TIntVector::value_type GetID(){
 211     myCurrentNode->GetID();
 212   }
 213   MED::TFloatVector::value_type GetCoord(med_int theCoodId){
 214     return (myCurrentNode->*myGetCoord[theCoodId])();
 215   }
 216   MED::TStringVector::value_type GetName(med_int theDimId){
 217     return myName[theDimId];
 218   }
 219   MED::TStringVector::value_type GetUnit(med_int theDimId){
 220     return myUnit[theDimId];
 221   }
 222 };
 223 typedef boost::shared_ptr<TCoordHelper> TCoordHelperPtr;
 224
 225
 226 void DriverMED_W_SMESHDS_Mesh::Add()
 227 {
 228   if (myMesh->hasConstructionEdges() || myMesh->hasConstructionFaces()) {
 229     INFOS("SMDS_MESH with hasConstructionEdges() or hasConstructionFaces() do not supports!!!");
 230     return;
 231   }
 232   try{
 233     using namespace MEDA;
 234     using namespace boost;
 235
 236     MESSAGE("Add - myFile : "<<myFile);
 237     TWrapper aMed(myFile);
 238
 239     // Creating the MED mesh for corresponding SMDS structure
 240     //-------------------------------------------------------
 241     string aMeshName;
 242     if (myMeshId != -1) {
 243       ostringstream aMeshNameStr;
 244       aMeshNameStr<<myMeshId;
 245       aMeshName = aMeshNameStr.str();
 246     } else {
 247       aMeshName = myMeshName;
 248     }
 249
 250     // Mesh dimension definition
 251     med_int aMeshDimension;
 252     TCoordHelperPtr aCoordHelperPtr;
 253     {
 254       bool anIsXDimension = false;
 255       bool anIsYDimension = false;
 256       bool anIsZDimension = false;
 257       {
 258         SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
 259         double aBounds[6];
 260         if(aNodesIter->more()){
 261           const SMDS_MeshNode* aNode = aNodesIter->next();
 262           aBounds[0] = aBounds[1] = aNode->X();
 263           aBounds[2] = aBounds[3] = aNode->Y();
 264           aBounds[4] = aBounds[5] = aNode->Z();
 265         }
 266         while(aNodesIter->more()){
 267           const SMDS_MeshNode* aNode = aNodesIter->next();
 268           aBounds[0] = min(aBounds[0],aNode->X());
 269           aBounds[1] = max(aBounds[1],aNode->X());
 270
 271           aBounds[2] = min(aBounds[2],aNode->Y());
 272           aBounds[3] = max(aBounds[3],aNode->Y());
 273
 274           aBounds[4] = min(aBounds[4],aNode->Z());
 275           aBounds[5] = max(aBounds[5],aNode->Z());
 276         }
 277
 278         double EPS = 1.0E-7;
 279         anIsXDimension = (aBounds[1] - aBounds[0]) > EPS;
 280         anIsYDimension = (aBounds[3] - aBounds[2]) > EPS;
 281         anIsZDimension = (aBounds[5] - aBounds[4]) > EPS;
 282
 283         aMeshDimension = anIsXDimension + anIsYDimension + anIsZDimension;
 284         if(!aMeshDimension)
 285           aMeshDimension = 3;
 286       }
 287
 288       SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
 289       switch(aMeshDimension){
 290       case 3:
 291         aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYZGetCoord,aXYZName));
 292         break;
 293       case 2:
 294         if(anIsXDimension && anIsYDimension)
 295           aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYGetCoord,aXYName));
 296         if(anIsYDimension && anIsZDimension)
 297           aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYZGetCoord,aYZName));
 298         if(anIsXDimension && anIsZDimension)
 299           aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXZGetCoord,aXZName));
 300         break;
 301       case 1:
 302         if(anIsXDimension)
 303           aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXGetCoord,aXName));
 304         if(anIsYDimension)
 305           aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYGetCoord,aYName));
 306         if(anIsZDimension)
 307           aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aZGetCoord,aZName));
 308         break;
 309       }
 310     }
 311
 312
 313     PMeshInfo aMeshInfo = TWrapper::CrMeshInfo(aMeshDimension,aMeshName);
 314     MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
 315     aMed.SetMeshInfo(aMeshInfo);
 316
 317     // Storing SMDS groups and sub-meshes
 318     //-----------------------------------
 319     int myNodesDefaultFamilyId = 0;
 320     int myEdgesDefaultFamilyId = 0;
 321     int myFacesDefaultFamilyId = 0;
 322     int myVolumesDefaultFamilyId = 0;
 323     if (myDoGroupOfNodes)
 324       myNodesDefaultFamilyId = REST_NODES_FAMILY;
 325     if (myDoGroupOfEdges)
 326       myEdgesDefaultFamilyId = REST_EDGES_FAMILY;
 327     if (myDoGroupOfFaces)
 328       myFacesDefaultFamilyId = REST_FACES_FAMILY;
 329     if (myDoGroupOfVolumes)
 330       myVolumesDefaultFamilyId = REST_VOLUMES_FAMILY;
 331
 332     MESSAGE("Add - aFamilyInfo");
 333     map<const SMDS_MeshElement *, int> anElemFamMap;
 334     list<DriverMED_FamilyPtr> aFamilies;
 335     if (myAllSubMeshes) {
 336       SMESHDS_Mesh* aSMESHDSMesh = dynamic_cast<SMESHDS_Mesh*>(myMesh);
 337       if (!aSMESHDSMesh) {
 338         EXCEPTION(runtime_error,"Can not cast SMDS_Mesh to SMESHDS_Mesh");
 339       }
 340       aFamilies = DriverMED_Family::MakeFamilies
 341         (aSMESHDSMesh->SubMeshes(), myGroups,
 342          myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
 343     } else {
 344       aFamilies = DriverMED_Family::MakeFamilies
 345         (mySubMeshes, myGroups,
 346          myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
 347     }
 348     list<DriverMED_FamilyPtr>::iterator aFamsIter = aFamilies.begin();
 349
 350     for (; aFamsIter != aFamilies.end(); aFamsIter++)
 351     {
 352       PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(aMeshInfo);
 353       aMed.SetFamilyInfo(aFamilyInfo);
 354       int aFamId = (*aFamsIter)->GetId();
 355
 356       const set<const SMDS_MeshElement *>& anElems = (*aFamsIter)->GetElements();
 357       set<const SMDS_MeshElement *>::iterator anElemsIter = anElems.begin();
 358       for (; anElemsIter != anElems.end(); anElemsIter++)
 359       {
 360         anElemFamMap[*anElemsIter] = aFamId;
 361       }
 362 //      delete (*aFamsIter);
 363     }
 364
 365     // Storing SMDS nodes to the MED file for the MED mesh
 366     //----------------------------------------------------
 367 #ifdef _EDF_NODE_IDS_
 368     typedef map<med_int,med_int> TNodeIdMap;
 369     TNodeIdMap aNodeIdMap;
 370 #endif
 371     med_int aNbElems = myMesh->NbNodes();
 372     MED::TIntVector anElemNums(aNbElems);
 373     MED::TIntVector aFamilyNums(aNbElems);
 374     MED::TFloatVector aCoordinates(aNbElems*aMeshDimension);
 375     for(med_int iNode = 0, aStartId = 0; aCoordHelperPtr->Next(); iNode++, aStartId += aMeshDimension){
 376       for(med_int iCoord = 0; iCoord < aMeshDimension; iCoord++){
 377         aCoordinates[aStartId+iCoord] = aCoordHelperPtr->GetCoord(iCoord);
 378       }
 379       int aNodeID = aCoordHelperPtr->GetID();
 380       anElemNums[iNode] = aNodeID;
 381 #ifdef _EDF_NODE_IDS_
 382       aNodeIdMap[aNodeID] = iNode+1;
 383 #endif
 384       const SMDS_MeshNode* aNode = aCoordHelperPtr->GetNode();
 385       if (anElemFamMap.find(aNode) != anElemFamMap.end())
 386         aFamilyNums[iNode] = anElemFamMap[aNode];
 387       else
 388         aFamilyNums[iNode] = myNodesDefaultFamilyId;
 389     }
 390
 391     MED::TStringVector aCoordNames(aMeshDimension);
 392     MED::TStringVector aCoordUnits(aMeshDimension);
 393     for(med_int iCoord = 0; iCoord < aMeshDimension; iCoord++){
 394       aCoordNames[iCoord] = aCoordHelperPtr->GetName(iCoord);
 395       aCoordUnits[iCoord] = aCoordHelperPtr->GetUnit(iCoord);
 396     }
 397
 398     const med_repere SMDS_COORDINATE_SYSTEM = MED_CART;
 399
 400     PNodeInfo aNodeInfo = TWrapper::CrNodeInfo(aMeshInfo,
 401                                                SMDS_COORDINATE_SYSTEM,
 402                                                aCoordinates,
 403                                                aCoordNames,
 404                                                aCoordUnits,
 405                                                aFamilyNums,
 406                                                anElemNums);
 407     MESSAGE("Add - aNodeInfo->GetNbElem() = "<<aNbElems);
 408     aMed.SetNodeInfo(aNodeInfo);
 409
 410
 411     // Storing others SMDS elements to the MED file for the MED mesh
 412     //--------------------------------------------------------------
 413     med_entite_maillage SMDS_MED_ENTITY = MED_MAILLE;
 414     const med_connectivite SMDS_MED_CONNECTIVITY = MED_NOD;
 415
 416     // Storing SMDS Edges
 417     if(med_int aNbElems = myMesh->NbEdges()){
 418 #ifdef _ELEMENTS_BY_DIM_
 419       SMDS_MED_ENTITY = MED_ARETE;
 420 #endif
 421       SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator();
 422       med_int aNbConnectivity = MED::GetNbConn(SMDS_MED_ENTITY,MED_SEG2,aMeshDimension);
 423       MED::TIntVector anElemNums(aNbElems);
 424       MED::TIntVector aFamilyNums(aNbElems);
 425       MED::TIntVector aConnectivity(aNbElems*aNbConnectivity);
 426
 427       for(med_int iElem = 0, iConn = 0; anIter->more(); iElem++, iConn+=aNbConnectivity){
 428         const SMDS_MeshEdge* anElem = anIter->next();
 429         SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
 430         for(med_int iNode = 0; iNode < aNbConnectivity && aNodesIter->more(); iNode++){
 431           const SMDS_MeshElement* aNode = aNodesIter->next();
 432 #ifdef _EDF_NODE_IDS_
 433           aConnectivity[iConn+iNode] = aNodeIdMap[aNode->GetID()];
 434 #else
 435           aConnectivity[iConn+iNode] = aNode->GetID();
 436 #endif
 437         }
 438         anElemNums[iElem] = anElem->GetID();
 439
 440         if (anElemFamMap.find(anElem) != anElemFamMap.end())
 441           aFamilyNums[iElem] = anElemFamMap[anElem];
 442         else
 443           aFamilyNums[iElem] = myEdgesDefaultFamilyId;
 444       }
 445
 446       PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 447                                                  SMDS_MED_ENTITY,
 448                                                  MED_SEG2,
 449                                                  SMDS_MED_CONNECTIVITY,
 450                                                  aConnectivity,
 451                                                  aFamilyNums,
 452                                                  anElemNums);
 453       aMed.SetCellInfo(aCellInfo);
 454     }
 455
 456     // Storing SMDS Faces
 457     if(med_int aNbElems = myMesh->NbFaces()){
 458       SMDS_FaceIteratorPtr anIter = myMesh->facesIterator();
 459 #ifdef _ELEMENTS_BY_DIM_
 460       SMDS_MED_ENTITY = MED_FACE;
 461 #endif
 462       med_int aNbTriaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TRIA3,aMeshDimension);
 463       MED::TIntVector anTriaElemNums;
 464       anTriaElemNums.reserve(aNbElems);
 465       MED::TIntVector aTriaFamilyNums;
 466       aTriaFamilyNums.reserve(aNbElems);
 467       MED::TIntVector aTriaConn;
 468       aTriaConn.reserve(aNbElems*aNbTriaConn);
 469
 470       med_int aNbQuadConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_QUAD4,aMeshDimension);
 471       MED::TIntVector aQuadElemNums;
 472       aQuadElemNums.reserve(aNbElems);
 473       MED::TIntVector aQuadFamilyNums;
 474       aQuadFamilyNums.reserve(aNbElems);
 475       MED::TIntVector aQuadConn;
 476       aQuadConn.reserve(aNbElems*aNbQuadConn);
 477
 478       for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
 479         const SMDS_MeshFace* anElem = anIter->next();
 480         med_int aNbNodes = anElem->NbNodes();
 481         SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
 482         med_int aNbConnectivity;
 483         MED::TIntVector* anElemNums;
 484         MED::TIntVector* aFamilyNums;
 485         MED::TIntVector* aConnectivity;
 486         switch(aNbNodes){
 487         case 3:
 488           aNbConnectivity = aNbTriaConn;
 489           anElemNums = &anTriaElemNums;
 490           aFamilyNums = &aTriaFamilyNums;
 491           aConnectivity = &aTriaConn;
 492           break;
 493         case 4:
 494           aNbConnectivity = aNbQuadConn;
 495           anElemNums = &aQuadElemNums;
 496           aFamilyNums = &aQuadFamilyNums;
 497           aConnectivity = &aQuadConn;
 498           break;
 499         }
 500         MED::TIntVector aVector(aNbNodes);
 501         for(med_int iNode = 0; aNodesIter->more(); iNode++){
 502           const SMDS_MeshElement* aNode = aNodesIter->next();
 503           aVector[iNode] = aNode->GetID();
 504         }
 505
 506         med_int aSize = aConnectivity->size();
 507         aConnectivity->resize(aSize+aNbConnectivity);
 508         // There is some differnce between SMDS and MED in cells mapping
 509 #ifdef _EDF_NODE_IDS_
 510         switch(aNbNodes){
 511         case 4:
 512           (*aConnectivity)[aSize+0] = aNodeIdMap[aVector[0]];
 513           (*aConnectivity)[aSize+1] = aNodeIdMap[aVector[1]];
 514           (*aConnectivity)[aSize+2] = aNodeIdMap[aVector[3]];
 515           (*aConnectivity)[aSize+3] = aNodeIdMap[aVector[2]];
 516         default:
 517           for(med_int iNode = 0; iNode < aNbNodes; iNode++)
 518             (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]];
 519         }
 520 #else
 521         switch(aNbNodes){
 522         case 4:
 523           (*aConnectivity)[aSize+0] = aVector[0];
 524           (*aConnectivity)[aSize+1] = aVector[1];
 525           (*aConnectivity)[aSize+2] = aVector[3];
 526           (*aConnectivity)[aSize+3] = aVector[2];
 527         default:
 528           for(med_int iNode = 0; iNode < aNbNodes; iNode++)
 529             (*aConnectivity)[aSize+iNode] = aVector[iNode];
 530         }
 531 #endif
 532         anElemNums->push_back(anElem->GetID());
 533
 534         if (anElemFamMap.find(anElem) != anElemFamMap.end())
 535           aFamilyNums->push_back(anElemFamMap[anElem]);
 536         else
 537           aFamilyNums->push_back(myFacesDefaultFamilyId);
 538       }
 539       if(med_int aNbElems = anTriaElemNums.size()){
 540         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 541                                                    SMDS_MED_ENTITY,
 542                                                    MED_TRIA3,
 543                                                    SMDS_MED_CONNECTIVITY,
 544                                                    aTriaConn,
 545                                                    aTriaFamilyNums,
 546                                                    anTriaElemNums);
 547         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TRIA3<<"; aNbElems = "<<aNbElems);
 548         aMed.SetCellInfo(aCellInfo);
 549       }
 550       if(med_int aNbElems = aQuadElemNums.size()){
 551         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 552                                                    SMDS_MED_ENTITY,
 553                                                    MED_QUAD4,
 554                                                    SMDS_MED_CONNECTIVITY,
 555                                                    aQuadConn,
 556                                                    aQuadFamilyNums,
 557                                                    aQuadElemNums);
 558         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_QUAD4<<"; aNbElems = "<<aNbElems);
 559         aMed.SetCellInfo(aCellInfo);
 560       }
 561     }
 562
 563     // Storing SMDS Volumes
 564     if(med_int aNbElems = myMesh->NbVolumes()){
 565       SMDS_VolumeIteratorPtr anIter = myMesh->volumesIterator();
 566 #ifdef _ELEMENTS_BY_DIM_
 567       SMDS_MED_ENTITY = MED_MAILLE;
 568 #endif
 569       med_int aNbTetraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TETRA4,aMeshDimension);
 570       MED::TIntVector anTetraElemNums;
 571       anTetraElemNums.reserve(aNbElems);
 572       MED::TIntVector aTetraFamilyNums;
 573       aTetraFamilyNums.reserve(aNbElems);
 574       MED::TIntVector aTetraConn;
 575       aTetraConn.reserve(aNbElems*aNbTetraConn);
 576
 577       med_int aNbPyraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PYRA5,aMeshDimension);
 578       MED::TIntVector anPyraElemNums;
 579       anPyraElemNums.reserve(aNbElems);
 580       MED::TIntVector aPyraFamilyNums;
 581       aPyraFamilyNums.reserve(aNbElems);
 582       MED::TIntVector aPyraConn;
 583       aPyraConn.reserve(aNbElems*aNbPyraConn);
 584
 585       med_int aNbPentaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PENTA6,aMeshDimension);
 586       MED::TIntVector anPentaElemNums;
 587       anPentaElemNums.reserve(aNbElems);
 588       MED::TIntVector aPentaFamilyNums;
 589       aPentaFamilyNums.reserve(aNbElems);
 590       MED::TIntVector aPentaConn;
 591       aPentaConn.reserve(aNbElems*aNbPentaConn);
 592
 593       med_int aNbHexaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_HEXA8,aMeshDimension);
 594       MED::TIntVector aHexaElemNums;
 595       aHexaElemNums.reserve(aNbElems);
 596       MED::TIntVector aHexaFamilyNums;
 597       aHexaFamilyNums.reserve(aNbElems);
 598       MED::TIntVector aHexaConn;
 599       aHexaConn.reserve(aNbElems*aNbHexaConn);
 600
 601       for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
 602         const SMDS_MeshVolume* anElem = anIter->next();
 603         med_int aNbNodes = anElem->NbNodes();
 604         SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
 605         med_int aNbConnectivity;
 606         MED::TIntVector* anElemNums;
 607         MED::TIntVector* aFamilyNums;
 608         MED::TIntVector* aConnectivity;
 609         switch(aNbNodes){
 610         case 4:
 611           aNbConnectivity = aNbTetraConn;
 612           anElemNums = &anTetraElemNums;
 613           aFamilyNums = &aTetraFamilyNums;
 614           aConnectivity = &aTetraConn;
 615           break;
 616         case 5:
 617           aNbConnectivity = aNbPyraConn;
 618           anElemNums = &anPyraElemNums;
 619           aFamilyNums = &aPyraFamilyNums;
 620           aConnectivity = &aPyraConn;
 621           break;
 622         case 6:
 623           aNbConnectivity = aNbPentaConn;
 624           anElemNums = &anPentaElemNums;
 625           aFamilyNums = &aPentaFamilyNums;
 626           aConnectivity = &aPentaConn;
 627           break;
 628         case 8:
 629           aNbConnectivity = aNbHexaConn;
 630           anElemNums = &aHexaElemNums;
 631           aFamilyNums = &aHexaFamilyNums;
 632           aConnectivity = &aHexaConn;
 633         }
 634
 635         MED::TIntVector aVector(aNbNodes);
 636         for(med_int iNode = 0; aNodesIter->more(); iNode++){
 637           const SMDS_MeshElement* aNode = aNodesIter->next();
 638           aVector[iNode] = aNode->GetID();
 639         }
 640         med_int aSize = aConnectivity->size();
 641         aConnectivity->resize(aSize+aNbConnectivity);
 642         // There is some difference between SMDS and MED in cells mapping
 643 #ifdef _EDF_NODE_IDS_
 644         switch(aNbNodes){
 645         case 5:
 646           (*aConnectivity)[aSize+0] = aNodeIdMap[aVector[0]];
 647           (*aConnectivity)[aSize+1] = aNodeIdMap[aVector[3]];
 648           (*aConnectivity)[aSize+2] = aNodeIdMap[aVector[2]];
 649           (*aConnectivity)[aSize+3] = aNodeIdMap[aVector[1]];
 650           (*aConnectivity)[aSize+4] = aNodeIdMap[aVector[4]];
 651         default:
 652           for(med_int iNode = 0; iNode < aNbNodes; iNode++)
 653             (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]];
 654         }
 655 #else
 656         switch(aNbNodes){
 657         case 5:
 658           (*aConnectivity)[aSize+0] = aVector[0];
 659           (*aConnectivity)[aSize+1] = aVector[3];
 660           (*aConnectivity)[aSize+2] = aVector[2];
 661           (*aConnectivity)[aSize+3] = aVector[1];
 662           (*aConnectivity)[aSize+4] = aVector[4];
 663         default:
 664           for(med_int iNode = 0; iNode < aNbNodes; iNode++)
 665             (*aConnectivity)[aSize+iNode] = aVector[iNode];
 666         }
 667 #endif
 668         anElemNums->push_back(anElem->GetID());
 669
 670         if (anElemFamMap.find(anElem) != anElemFamMap.end())
 671           aFamilyNums->push_back(anElemFamMap[anElem]);
 672         else
 673           aFamilyNums->push_back(myVolumesDefaultFamilyId);
 674       }
 675
 676       if(med_int aNbElems = anTetraElemNums.size()){
 677         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 678                                                    SMDS_MED_ENTITY,
 679                                                    MED_TETRA4,
 680                                                    SMDS_MED_CONNECTIVITY,
 681                                                    aTetraConn,
 682                                                    aTetraFamilyNums,
 683                                                    anTetraElemNums);
 684         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TETRA4<<"; aNbElems = "<<aNbElems);
 685         aMed.SetCellInfo(aCellInfo);
 686       }
 687       if(med_int aNbElems = anPyraElemNums.size()){
 688         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 689                                                    SMDS_MED_ENTITY,
 690                                                    MED_PYRA5,
 691                                                    SMDS_MED_CONNECTIVITY,
 692                                                    aPyraConn,
 693                                                    aPyraFamilyNums,
 694                                                    anPyraElemNums);
 695         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PYRA5<<"; aNbElems = "<<aNbElems);
 696         aMed.SetCellInfo(aCellInfo);
 697       }
 698       if(med_int aNbElems = anPentaElemNums.size()){
 699         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 700                                                    SMDS_MED_ENTITY,
 701                                                    MED_PENTA6,
 702                                                    SMDS_MED_CONNECTIVITY,
 703                                                    aPentaConn,
 704                                                    aPentaFamilyNums,
 705                                                    anPentaElemNums);
 706         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PENTA6<<"; aNbElems = "<<aNbElems);
 707         aMed.SetCellInfo(aCellInfo);
 708       }
 709       if(med_int aNbElems = aHexaElemNums.size()){
 710         PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
 711                                                    SMDS_MED_ENTITY,
 712                                                    MED_HEXA8,
 713                                                    SMDS_MED_CONNECTIVITY,
 714                                                    aHexaConn,
 715                                                    aHexaFamilyNums,
 716                                                    aHexaElemNums);
 717         MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_HEXA8<<"; aNbElems = "<<aNbElems);
 718         aMed.SetCellInfo(aCellInfo);
 719       }
 720     }
 721   }catch(const std::exception& exc){
 722     INFOS("Follow exception was cought:\n\t"<<exc.what());
 723   }catch(...){
 724     INFOS("Unknown exception was cought !!!");
 725   }
 726
 727   myMeshId = -1;
 728   myGroups.clear();
 729   mySubMeshes.clear();
 730 }