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.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //
  23 //
  24 //  File   : DriverMED_W_SMESHDS_Mesh.cxx
  25 //  Module : SMESH
  26
  27 #include <sstream>
  28
  29 #include "DriverMED_W_SMESHDS_Mesh.h"
  30 #include "DriverMED_W_SMDS_Mesh.h"
  31 #include "DriverMED_Family.h"
  32
  33 #include "SMESHDS_Mesh.hxx"
  34 #include "SMDS_MeshElement.hxx"
  35 #include "SMDS_MeshNode.hxx"
  36 #include "SMDS_PolyhedralVolumeOfNodes.hxx"
  37
  38 #include "utilities.h"
  39
  40 #include "MED_Utilities.hxx"
  41
  42 #define _EDF_NODE_IDS_
  43 //#define _ELEMENTS_BY_DIM_
  44
  45 using namespace std;
  46 using namespace MED;
  47
  48
  49 DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
  50   myAllSubMeshes (false),
  51   myDoGroupOfNodes (false),
  52   myDoGroupOfEdges (false),
  53   myDoGroupOfFaces (false),
  54   myDoGroupOfVolumes (false)
  55 {}
  56
  57 void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName,
  58                                        MED::EVersion theId)
  59 {
  60   myMed = CrWrapper(theFileName,theId);
  61   Driver_SMESHDS_Mesh::SetFile(theFileName);
  62 }
  63
  64 void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName)
  65 {
  66   return SetFile(theFileName,MED::eV2_2);
  67 }
  68
  69 void DriverMED_W_SMESHDS_Mesh::SetMeshName(const std::string& theMeshName)
  70 {
  71   myMeshName = theMeshName;
  72 }
  73
  74 void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_GroupBase* theGroup)
  75 {
  76   myGroups.push_back(theGroup);
  77 }
  78
  79 void DriverMED_W_SMESHDS_Mesh::AddAllSubMeshes()
  80 {
  81   myAllSubMeshes = true;
  82 }
  83
  84 void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int theID)
  85 {
  86   mySubMeshes[theID] = theSubMesh;
  87 }
  88
  89 void DriverMED_W_SMESHDS_Mesh::AddGroupOfNodes()
  90 {
  91   myDoGroupOfNodes = true;
  92 }
  93
  94 void DriverMED_W_SMESHDS_Mesh::AddGroupOfEdges()
  95 {
  96   myDoGroupOfEdges = true;
  97 }
  98
  99 void DriverMED_W_SMESHDS_Mesh::AddGroupOfFaces()
 100 {
 101   myDoGroupOfFaces = true;
 102 }
 103
 104 void DriverMED_W_SMESHDS_Mesh::AddGroupOfVolumes()
 105 {
 106   myDoGroupOfVolumes = true;
 107 }
 108
 109 namespace{
 110   typedef double (SMDS_MeshNode::* TGetCoord)() const;
 111   typedef const char* TName;
 112   typedef const char* TUnit;
 113
 114   // name length in a mesh must be equal to 16 :
 115   //         1234567890123456
 116   TName M = "m               ";
 117   TName X = "x               ";
 118   TName Y = "y               ";
 119   TName Z = "z               ";
 120
 121   TUnit aUnit[3] = {M,M,M};
 122
 123   // 3 dim
 124   TGetCoord aXYZGetCoord[3] = {
 125     &SMDS_MeshNode::X,
 126     &SMDS_MeshNode::Y,
 127     &SMDS_MeshNode::Z
 128   };
 129   TName aXYZName[3] = {X,Y,Z};
 130
 131   // 2 dim
 132   TGetCoord aXYGetCoord[2] = {
 133     &SMDS_MeshNode::X,
 134     &SMDS_MeshNode::Y
 135   };
 136   TName aXYName[2] = {X,Y};
 137
 138   TGetCoord aYZGetCoord[2] = {
 139     &SMDS_MeshNode::Y,
 140     &SMDS_MeshNode::Z
 141   };
 142   TName aYZName[2] = {Y,Z};
 143
 144   TGetCoord aXZGetCoord[2] = {
 145     &SMDS_MeshNode::X,
 146     &SMDS_MeshNode::Z
 147   };
 148   TName aXZName[2] = {X,Z};
 149
 150   // 1 dim
 151   TGetCoord aXGetCoord[1] = {
 152     &SMDS_MeshNode::X
 153   };
 154   TName aXName[1] = {X};
 155
 156   TGetCoord aYGetCoord[1] = {
 157     &SMDS_MeshNode::Y
 158   };
 159   TName aYName[1] = {Y};
 160
 161   TGetCoord aZGetCoord[1] = {
 162     &SMDS_MeshNode::Z
 163   };
 164   TName aZName[1] = {Z};
 165
 166
 167   class TCoordHelper{
 168     SMDS_NodeIteratorPtr myNodeIter;
 169     const SMDS_MeshNode* myCurrentNode;
 170     TGetCoord* myGetCoord;
 171     TName* myName;
 172     TUnit* myUnit;
 173   public:
 174     TCoordHelper(const SMDS_NodeIteratorPtr& theNodeIter,
 175                  TGetCoord* theGetCoord,
 176                  TName* theName,
 177                  TUnit* theUnit = aUnit):
 178       myNodeIter(theNodeIter),
 179       myGetCoord(theGetCoord),
 180       myName(theName),
 181       myUnit(theUnit)
 182     {}
 183     virtual ~TCoordHelper(){}
 184     bool Next(){
 185       return myNodeIter->more() &&
 186         (myCurrentNode = myNodeIter->next());
 187     }
 188     const SMDS_MeshNode* GetNode(){
 189       return myCurrentNode;
 190     }
 191     MED::TIntVector::value_type GetID(){
 192       return myCurrentNode->GetID();
 193     }
 194     MED::TFloatVector::value_type GetCoord(TInt theCoodId){
 195       return (myCurrentNode->*myGetCoord[theCoodId])();
 196     }
 197     MED::TStringVector::value_type GetName(TInt theDimId){
 198       return myName[theDimId];
 199     }
 200     MED::TStringVector::value_type GetUnit(TInt theDimId){
 201       return myUnit[theDimId];
 202     }
 203   };
 204   typedef boost::shared_ptr<TCoordHelper> TCoordHelperPtr;
 205
 206 }
 207
 208
 209 Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
 210 {
 211   Status aResult = DRS_OK;
 212   if (myMesh->hasConstructionEdges() || myMesh->hasConstructionFaces()) {
 213     INFOS("SMDS_MESH with hasConstructionEdges() or hasConstructionFaces() do not supports!!!");
 214     return DRS_FAIL;
 215   }
 216   try{
 217     MESSAGE("Perform - myFile : "<<myFile);
 218
 219     // Creating the MED mesh for corresponding SMDS structure
 220     //-------------------------------------------------------
 221     string aMeshName;
 222     if (myMeshId != -1) {
 223       ostringstream aMeshNameStr;
 224       aMeshNameStr<<myMeshId;
 225       aMeshName = aMeshNameStr.str();
 226     } else {
 227       aMeshName = myMeshName;
 228     }
 229
 230     // Mesh dimension definition
 231     TInt aMeshDimension;
 232     TCoordHelperPtr aCoordHelperPtr;
 233     {
 234       bool anIsXDimension = false;
 235       bool anIsYDimension = false;
 236       bool anIsZDimension = false;
 237       {
 238         SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
 239         double aBounds[6];
 240         if(aNodesIter->more()){
 241           const SMDS_MeshNode* aNode = aNodesIter->next();
 242           aBounds[0] = aBounds[1] = aNode->X();
 243           aBounds[2] = aBounds[3] = aNode->Y();
 244           aBounds[4] = aBounds[5] = aNode->Z();
 245         }
 246         while(aNodesIter->more()){
 247           const SMDS_MeshNode* aNode = aNodesIter->next();
 248           aBounds[0] = min(aBounds[0],aNode->X());
 249           aBounds[1] = max(aBounds[1],aNode->X());
 250
 251           aBounds[2] = min(aBounds[2],aNode->Y());
 252           aBounds[3] = max(aBounds[3],aNode->Y());
 253
 254           aBounds[4] = min(aBounds[4],aNode->Z());
 255           aBounds[5] = max(aBounds[5],aNode->Z());
 256         }
 257
 258         double EPS = 1.0E-7;
 259         anIsXDimension = (aBounds[1] - aBounds[0]) + abs(aBounds[1]) + abs(aBounds[0]) > EPS;
 260         anIsYDimension = (aBounds[3] - aBounds[2]) + abs(aBounds[3]) + abs(aBounds[2]) > EPS;
 261         anIsZDimension = (aBounds[5] - aBounds[4]) + abs(aBounds[5]) + abs(aBounds[4]) > EPS;
 262         aMeshDimension = anIsXDimension + anIsYDimension + anIsZDimension;
 263         if(!aMeshDimension)
 264           aMeshDimension = 3;
 265       }
 266
 267       SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
 268       switch(aMeshDimension){
 269       case 3:
 270         aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYZGetCoord,aXYZName));
 271         break;
 272       case 2:
 273         if(anIsXDimension && anIsYDimension)
 274           aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYGetCoord,aXYName));
 275         if(anIsYDimension && anIsZDimension)
 276           aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYZGetCoord,aYZName));
 277         if(anIsXDimension && anIsZDimension)
 278           aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXZGetCoord,aXZName));
 279         break;
 280       case 1:
 281         if(anIsXDimension)
 282           aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXGetCoord,aXName));
 283         if(anIsYDimension)
 284           aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYGetCoord,aYName));
 285         if(anIsZDimension)
 286           aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aZGetCoord,aZName));
 287         break;
 288       }
 289     }
 290
 291
 292     PMeshInfo aMeshInfo = myMed->CrMeshInfo(aMeshDimension,aMeshName);
 293     MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
 294     myMed->SetMeshInfo(aMeshInfo);
 295
 296     // Storing SMDS groups and sub-meshes
 297     //-----------------------------------
 298     int myNodesDefaultFamilyId = 0;
 299     int myEdgesDefaultFamilyId = 0;
 300     int myFacesDefaultFamilyId = 0;
 301     int myVolumesDefaultFamilyId = 0;
 302     if (myDoGroupOfNodes)
 303       myNodesDefaultFamilyId = REST_NODES_FAMILY;
 304     if (myDoGroupOfEdges)
 305       myEdgesDefaultFamilyId = REST_EDGES_FAMILY;
 306     if (myDoGroupOfFaces)
 307       myFacesDefaultFamilyId = REST_FACES_FAMILY;
 308     if (myDoGroupOfVolumes)
 309       myVolumesDefaultFamilyId = REST_VOLUMES_FAMILY;
 310
 311     MESSAGE("Perform - aFamilyInfo");
 312     map<const SMDS_MeshElement *, int> anElemFamMap;
 313     list<DriverMED_FamilyPtr> aFamilies;
 314     if (myAllSubMeshes) {
 315       aFamilies = DriverMED_Family::MakeFamilies
 316         (myMesh->SubMeshes(), myGroups,
 317          myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
 318     } else {
 319       aFamilies = DriverMED_Family::MakeFamilies
 320         (mySubMeshes, myGroups,
 321          myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
 322     }
 323     list<DriverMED_FamilyPtr>::iterator aFamsIter = aFamilies.begin();
 324
 325     for (; aFamsIter != aFamilies.end(); aFamsIter++)
 326     {
 327       PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(myMed,aMeshInfo);
 328       myMed->SetFamilyInfo(aFamilyInfo);
 329       int aFamId = (*aFamsIter)->GetId();
 330
 331       const set<const SMDS_MeshElement *>& anElems = (*aFamsIter)->GetElements();
 332       set<const SMDS_MeshElement *>::const_iterator anElemsIter = anElems.begin();
 333       for (; anElemsIter != anElems.end(); anElemsIter++)
 334       {
 335         anElemFamMap[*anElemsIter] = aFamId;
 336       }
 337     }
 338
 339     // Storing SMDS nodes to the MED file for the MED mesh
 340     //----------------------------------------------------
 341 #ifdef _EDF_NODE_IDS_
 342     typedef map<TInt,TInt> TNodeIdMap;
 343     TNodeIdMap aNodeIdMap;
 344 #endif
 345     TInt aNbElems = myMesh->NbNodes();
 346     MED::TIntVector anElemNums(aNbElems);
 347     MED::TIntVector aFamilyNums(aNbElems);
 348     MED::TFloatVector aCoordinates(aNbElems*aMeshDimension);
 349     for(TInt iNode = 0, aStartId = 0; aCoordHelperPtr->Next(); iNode++, aStartId += aMeshDimension){
 350       for(TInt iCoord = 0; iCoord < aMeshDimension; iCoord++){
 351         aCoordinates[aStartId+iCoord] = aCoordHelperPtr->GetCoord(iCoord);
 352       }
 353       int aNodeID = aCoordHelperPtr->GetID();
 354       anElemNums[iNode] = aNodeID;
 355 #ifdef _EDF_NODE_IDS_
 356       aNodeIdMap[aNodeID] = iNode+1;
 357 #endif
 358       const SMDS_MeshNode* aNode = aCoordHelperPtr->GetNode();
 359       if (anElemFamMap.find(aNode) != anElemFamMap.end())
 360         aFamilyNums[iNode] = anElemFamMap[aNode];
 361       else
 362         aFamilyNums[iNode] = myNodesDefaultFamilyId;
 363     }
 364
 365     MED::TStringVector aCoordNames(aMeshDimension);
 366     MED::TStringVector aCoordUnits(aMeshDimension);
 367     for(TInt iCoord = 0; iCoord < aMeshDimension; iCoord++){
 368       aCoordNames[iCoord] = aCoordHelperPtr->GetName(iCoord);
 369       aCoordUnits[iCoord] = aCoordHelperPtr->GetUnit(iCoord);
 370     }
 371
 372     const ERepere SMDS_COORDINATE_SYSTEM = eCART;
 373
 374     PNodeInfo aNodeInfo = myMed->CrNodeInfo(aMeshInfo,
 375                                             aCoordinates,
 376                                             eFULL_INTERLACE,
 377                                             SMDS_COORDINATE_SYSTEM,
 378                                             aCoordNames,
 379                                             aCoordUnits,
 380                                             aFamilyNums,
 381                                             anElemNums);
 382     MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems);
 383     myMed->SetNodeInfo(aNodeInfo);
 384
 385
 386     // Storing others SMDS elements to the MED file for the MED mesh
 387     //--------------------------------------------------------------
 388     EEntiteMaillage SMDS_MED_ENTITY = eMAILLE;
 389     const EConnectivite SMDS_MED_CONNECTIVITY = eNOD;
 390
 391     // Storing SMDS Edges
 392     if(TInt aNbElems = myMesh->NbEdges()){
 393 #ifdef _ELEMENTS_BY_DIM_
 394       SMDS_MED_ENTITY = eARETE;
 395 #endif
 396       // count edges of diff types
 397       int aNbSeg3 = 0, aNbSeg2 = 0;
 398       SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator();
 399       while ( anIter->more() )
 400         if ( anIter->next()->NbNodes() == 3 )
 401           ++aNbSeg3;
 402       aNbSeg2 = aNbElems - aNbSeg3;
 403
 404       TInt aNbSeg2Conn = MED::GetNbNodes(eSEG2);
 405       MED::TIntVector aSeg2ElemNums, aSeg2FamilyNums, aSeg2Conn;
 406       aSeg2ElemNums  .reserve( aNbSeg2 );
 407       aSeg2FamilyNums.reserve( aNbSeg2 );
 408       aSeg2Conn      .reserve( aNbSeg2*aNbSeg2Conn );
 409
 410       TInt aNbSeg3Conn = MED::GetNbNodes(eSEG3);
 411       MED::TIntVector aSeg3ElemNums, aSeg3FamilyNums, aSeg3Conn;
 412       aSeg3ElemNums  .reserve( aNbSeg3 );
 413       aSeg3FamilyNums.reserve( aNbSeg3 );
 414       aSeg3Conn      .reserve( aNbSeg3*aNbSeg3Conn );
 415
 416       anIter = myMesh->edgesIterator();
 417       while ( anIter->more() ) {
 418         const SMDS_MeshEdge* anElem = anIter->next();
 419         TInt aNbNodes = anElem->NbNodes();
 420
 421         TInt aNbConnectivity;
 422         MED::TIntVector* anElemNums;
 423         MED::TIntVector* aFamilyNums;
 424         MED::TIntVector* aConnectivity;
 425         switch(aNbNodes){
 426         case 2:
 427           aNbConnectivity = aNbSeg2Conn;
 428           anElemNums      = &aSeg2ElemNums;
 429           aFamilyNums     = &aSeg2FamilyNums;
 430           aConnectivity   = &aSeg2Conn;
 431           break;
 432         case 3:
 433           aNbConnectivity = aNbSeg3Conn;
 434           anElemNums      = &aSeg3ElemNums;
 435           aFamilyNums     = &aSeg3FamilyNums;
 436           aConnectivity   = &aSeg3Conn;
 437           break;
 438         default:
 439           break;
 440         }
 441
 442         for(TInt iNode = 0; iNode < aNbNodes; iNode++) {
 443           const SMDS_MeshElement* aNode = anElem->GetNode( iNode );
 444 #ifdef _EDF_NODE_IDS_
 445           aConnectivity->push_back( aNodeIdMap[aNode->GetID()] );
 446 #else
 447           aConnectivity->push_back( aNode->GetID() );
 448 #endif
 449         }
 450
 451         anElemNums->push_back(anElem->GetID());
 452
 453         map<const SMDS_MeshElement*,int>::iterator edge_fam = anElemFamMap.find( anElem );
 454         if ( edge_fam != anElemFamMap.end() )
 455           aFamilyNums->push_back( edge_fam->second );
 456         else
 457           aFamilyNums->push_back( myFacesDefaultFamilyId );
 458       }
 459
 460       if ( aNbSeg2 ) {
 461         PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
 462                                                 SMDS_MED_ENTITY,
 463                                                 eSEG2,
 464                                                 aSeg2Conn,
 465                                                 SMDS_MED_CONNECTIVITY,
 466                                                 aSeg2FamilyNums,
 467                                                 aSeg2ElemNums);
 468         myMed->SetCellInfo(aCellInfo);
 469       }
 470       if ( aNbSeg3 ) {
 471         PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
 472                                                 SMDS_MED_ENTITY,
 473                                                 eSEG3,
 474                                                 aSeg3Conn,
 475                                                 SMDS_MED_CONNECTIVITY,
 476                                                 aSeg3FamilyNums,
 477                                                 aSeg3ElemNums);
 478         myMed->SetCellInfo(aCellInfo);
 479       }
 480     }
 481
 482     // Storing SMDS Faces
 483     if(TInt aNbElems = myMesh->NbFaces()){
 484       SMDS_FaceIteratorPtr anIter = myMesh->facesIterator();
 485 #ifdef _ELEMENTS_BY_DIM_
 486       SMDS_MED_ENTITY = eFACE;
 487 #endif
 488       TInt aNbTriaConn = MED::GetNbNodes(eTRIA3);
 489       MED::TIntVector anTriaElemNums;
 490       anTriaElemNums.reserve(aNbElems);
 491       MED::TIntVector aTriaFamilyNums;
 492       aTriaFamilyNums.reserve(aNbElems);
 493       MED::TIntVector aTriaConn;
 494       aTriaConn.reserve(aNbElems*aNbTriaConn);
 495
 496       TInt aNbTria6Conn = MED::GetNbNodes(eTRIA6);
 497       MED::TIntVector anTria6ElemNums;
 498       anTria6ElemNums.reserve(aNbElems);
 499       MED::TIntVector aTria6FamilyNums;
 500       aTria6FamilyNums.reserve(aNbElems);
 501       MED::TIntVector aTria6Conn;
 502       aTria6Conn.reserve(aNbElems*aNbTria6Conn);
 503
 504       TInt aNbQuadConn = MED::GetNbNodes(eQUAD4);
 505       MED::TIntVector aQuadElemNums;
 506       aQuadElemNums.reserve(aNbElems);
 507       MED::TIntVector aQuadFamilyNums;
 508       aQuadFamilyNums.reserve(aNbElems);
 509       MED::TIntVector aQuadConn;
 510       aQuadConn.reserve(aNbElems*aNbQuadConn);
 511
 512       TInt aNbQuad8Conn = MED::GetNbNodes(eQUAD8);
 513       MED::TIntVector aQuad8ElemNums;
 514       aQuad8ElemNums.reserve(aNbElems);
 515       MED::TIntVector aQuad8FamilyNums;
 516       aQuad8FamilyNums.reserve(aNbElems);
 517       MED::TIntVector aQuad8Conn;
 518       aQuad8Conn.reserve(aNbElems*aNbQuad8Conn);
 519
 520       MED::TIntVector aPolygoneElemNums;
 521       aPolygoneElemNums.reserve(aNbElems);
 522       MED::TIntVector aPolygoneInds;
 523       aPolygoneInds.reserve(aNbElems + 1);
 524       aPolygoneInds.push_back(1); // reference on the first element in the connectivities
 525       MED::TIntVector aPolygoneFamilyNums;
 526       aPolygoneFamilyNums.reserve(aNbElems);
 527       MED::TIntVector aPolygoneConn;
 528       aPolygoneConn.reserve(aNbElems*aNbQuadConn);
 529
 530       for(TInt iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
 531         const SMDS_MeshFace* anElem = anIter->next();
 532         TInt aNbNodes = anElem->NbNodes();
 533         SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
 534         TInt aNbConnectivity;
 535         MED::TIntVector* anElemNums;
 536         MED::TIntVector* aFamilyNums;
 537         MED::TIntVector* aConnectivity;
 538         if (anElem->IsPoly()) {
 539           aNbConnectivity = aNbNodes;
 540           anElemNums = &aPolygoneElemNums;
 541           aFamilyNums = &aPolygoneFamilyNums;
 542           aConnectivity = &aPolygoneConn;
 543         }
 544         else {
 545           switch(aNbNodes){
 546           case 3:
 547             aNbConnectivity = aNbTriaConn;
 548             anElemNums = &anTriaElemNums;
 549             aFamilyNums = &aTriaFamilyNums;
 550             aConnectivity = &aTriaConn;
 551             break;
 552           case 4:
 553             aNbConnectivity = aNbQuadConn;
 554             anElemNums = &aQuadElemNums;
 555             aFamilyNums = &aQuadFamilyNums;
 556             aConnectivity = &aQuadConn;
 557             break;
 558           case 6:
 559             aNbConnectivity = aNbTria6Conn;
 560             anElemNums = &anTria6ElemNums;
 561             aFamilyNums = &aTria6FamilyNums;
 562             aConnectivity = &aTria6Conn;
 563             break;
 564           case 8:
 565             aNbConnectivity = aNbQuad8Conn;
 566             anElemNums = &aQuad8ElemNums;
 567             aFamilyNums = &aQuad8FamilyNums;
 568             aConnectivity = &aQuad8Conn;
 569             break;
 570           default:
 571             break;
 572           }
 573         }
 574         MED::TIntVector aVector(aNbNodes);
 575         for(TInt iNode = 0; aNodesIter->more(); iNode++){
 576           const SMDS_MeshElement* aNode = aNodesIter->next();
 577 #ifdef _EDF_NODE_IDS_
 578           aVector[iNode] = aNodeIdMap[aNode->GetID()];
 579 #else
 580           aVector[iNode] = aNode->GetID();
 581 #endif
 582         }
 583
 584         TInt aSize = aConnectivity->size();
 585         aConnectivity->resize(aSize+aNbConnectivity);
 586         // There is some differences between SMDS and MED in cells mapping
 587         switch(aNbNodes){
 588         case 4:
 589           (*aConnectivity)[aSize+0] = aVector[0];
 590           (*aConnectivity)[aSize+1] = aVector[1];
 591           (*aConnectivity)[aSize+2] = aVector[3];
 592           (*aConnectivity)[aSize+3] = aVector[2];
 593         default:
 594           for(TInt iNode = 0; iNode < aNbNodes; iNode++)
 595             (*aConnectivity)[aSize+iNode] = aVector[iNode];
 596         }
 597
 598         if (anElem->IsPoly()) {
 599           // fill indices for polygonal element
 600           TInt aPrevPos = aPolygoneInds.back();
 601           aPolygoneInds.push_back(aPrevPos + aNbNodes);
 602         }
 603
 604         anElemNums->push_back(anElem->GetID());
 605
 606         if (anElemFamMap.find(anElem) != anElemFamMap.end())
 607           aFamilyNums->push_back(anElemFamMap[anElem]);
 608         else
 609           aFamilyNums->push_back(myFacesDefaultFamilyId);
 610       }
 611       if(TInt aNbElems = anTriaElemNums.size()){
 612         PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
 613                                                 SMDS_MED_ENTITY,
 614                                                 eTRIA3,
 615                                                 aTriaConn,
 616                                                 SMDS_MED_CONNECTIVITY,
 617                                                 aTriaFamilyNums,
 618                                                 anTriaElemNums);
 619         MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTRIA3<<"; aNbElems = "<<aNbElems);
 620         myMed->SetCellInfo(aCellInfo);
 621       }
 622       if(TInt aNbElems = aQuadElemNums.size()){
 623         PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
 624                                                 SMDS_MED_ENTITY,
 625                                                 eQUAD4,
 626                                                 aQuadConn,
 627                                                 SMDS_MED_CONNECTIVITY,
 628                                                 aQuadFamilyNums,
 629                                                 aQuadElemNums);
 630         MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eQUAD4<<"; aNbElems = "<<aNbElems);
 631         myMed->SetCellInfo(aCellInfo);
 632       }
 633       if(TInt aNbElems = anTria6ElemNums.size()){
 634         PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
 635                                                 SMDS_MED_ENTITY,
 636                                                 eTRIA6,
 637                                                 aTria6Conn,
 638                                                 SMDS_MED_CONNECTIVITY,
 639                                                 aTria6FamilyNums,
 640                                                 anTria6ElemNums);
 641         MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTRIA6<<"; aNbElems = "<<aNbElems);
 642         myMed->SetCellInfo(aCellInfo);
 643       }
 644       if(TInt aNbElems = aQuad8ElemNums.size()){
 645         PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
 646                                                 SMDS_MED_ENTITY,
 647                                                 eQUAD8,
 648                                                 aQuad8Conn,
 649                                                 SMDS_MED_CONNECTIVITY,
 650                                                 aQuad8FamilyNums,
 651                                                 aQuad8ElemNums);
 652         MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eQUAD8<<"; aNbElems = "<<aNbElems);
 653         myMed->SetCellInfo(aCellInfo);
 654       }
 655       if(TInt aNbElems = aPolygoneElemNums.size()){
 656         // add one element in connectivities,
 657         // referenced by the last element in indices
 658         aPolygoneConn.push_back(0);
 659
 660         PPolygoneInfo aCellInfo = myMed->CrPolygoneInfo(aMeshInfo,
 661                                                         SMDS_MED_ENTITY,
 662                                                         ePOLYGONE,
 663                                                         aPolygoneInds,
 664                                                         aPolygoneConn,
 665                                                         SMDS_MED_CONNECTIVITY,
 666                                                         aPolygoneFamilyNums,
 667                                                         aPolygoneElemNums);
 668         MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePOLYGONE<<"; aNbElems = "<<aNbElems);
 669         myMed->SetPolygoneInfo(aCellInfo);
 670       }
 671     }
 672
 673     // Storing SMDS Volumes
 674     if(TInt aNbElems = myMesh->NbVolumes()){
 675       SMDS_VolumeIteratorPtr anIter = myMesh->volumesIterator();
 676 #ifdef _ELEMENTS_BY_DIM_
 677       SMDS_MED_ENTITY = eMAILLE;
 678 #endif
 679       TInt aNbTetraConn = MED::GetNbNodes(eTETRA4);
 680       MED::TIntVector anTetraElemNums;
 681       anTetraElemNums.reserve(aNbElems);
 682       MED::TIntVector aTetraFamilyNums;
 683       aTetraFamilyNums.reserve(aNbElems);
 684       MED::TIntVector aTetraConn;
 685       aTetraConn.reserve(aNbElems*aNbTetraConn);
 686
 687       TInt aNbPyraConn = MED::GetNbNodes(ePYRA5);
 688       MED::TIntVector anPyraElemNums;
 689       anPyraElemNums.reserve(aNbElems);
 690       MED::TIntVector aPyraFamilyNums;
 691       aPyraFamilyNums.reserve(aNbElems);
 692       MED::TIntVector aPyraConn;
 693       aPyraConn.reserve(aNbElems*aNbPyraConn);
 694
 695       TInt aNbPentaConn = MED::GetNbNodes(ePENTA6);
 696       MED::TIntVector anPentaElemNums;
 697       anPentaElemNums.reserve(aNbElems);
 698       MED::TIntVector aPentaFamilyNums;
 699       aPentaFamilyNums.reserve(aNbElems);
 700       MED::TIntVector aPentaConn;
 701       aPentaConn.reserve(aNbElems*aNbPentaConn);
 702
 703       TInt aNbHexaConn = MED::GetNbNodes(eHEXA8);
 704       MED::TIntVector aHexaElemNums;
 705       aHexaElemNums.reserve(aNbElems);
 706       MED::TIntVector aHexaFamilyNums;
 707       aHexaFamilyNums.reserve(aNbElems);
 708       MED::TIntVector aHexaConn;
 709       aHexaConn.reserve(aNbElems*aNbHexaConn);
 710
 711       TInt aNbTetra10Conn = MED::GetNbNodes(eTETRA10);
 712       MED::TIntVector anTetra10ElemNums;
 713       anTetra10ElemNums.reserve(aNbElems);
 714       MED::TIntVector aTetra10FamilyNums;
 715       aTetra10FamilyNums.reserve(aNbElems);
 716       MED::TIntVector aTetra10Conn;
 717       aTetra10Conn.reserve(aNbElems*aNbTetra10Conn);
 718
 719       TInt aNbPyra13Conn = MED::GetNbNodes(ePYRA13);
 720       MED::TIntVector anPyra13ElemNums;
 721       anPyra13ElemNums.reserve(aNbElems);
 722       MED::TIntVector aPyra13FamilyNums;
 723       aPyra13FamilyNums.reserve(aNbElems);
 724       MED::TIntVector aPyra13Conn;
 725       aPyra13Conn.reserve(aNbElems*aNbPyra13Conn);
 726
 727       TInt aNbPenta15Conn = MED::GetNbNodes(ePENTA15);
 728       MED::TIntVector anPenta15ElemNums;
 729       anPenta15ElemNums.reserve(aNbElems);
 730       MED::TIntVector aPenta15FamilyNums;
 731       aPenta15FamilyNums.reserve(aNbElems);
 732       MED::TIntVector aPenta15Conn;
 733       aPenta15Conn.reserve(aNbElems*aNbPenta15Conn);
 734
 735       TInt aNbHexa20Conn = MED::GetNbNodes(eHEXA20);
 736       MED::TIntVector aHexa20ElemNums;
 737       aHexa20ElemNums.reserve(aNbElems);
 738       MED::TIntVector aHexa20FamilyNums;
 739       aHexa20FamilyNums.reserve(aNbElems);
 740       MED::TIntVector aHexa20Conn;
 741       aHexa20Conn.reserve(aNbElems*aNbHexa20Conn);
 742
 743       MED::TIntVector aPolyedreElemNums;
 744       aPolyedreElemNums.reserve(aNbElems);
 745       MED::TIntVector aPolyedreInds;
 746       aPolyedreInds.reserve(aNbElems + 1);
 747       aPolyedreInds.push_back(1); // reference on the first element in the faces
 748       MED::TIntVector aPolyedreFaces;
 749       aPolyedreFaces.reserve(aNbElems + 1);
 750       aPolyedreFaces.push_back(1); // reference on the first element in the connectivities
 751       MED::TIntVector aPolyedreFamilyNums;
 752       aPolyedreFamilyNums.reserve(aNbElems);
 753       MED::TIntVector aPolyedreConn;
 754       aPolyedreConn.reserve(aNbElems*aNbHexaConn);
 755
 756       for(TInt iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
 757         const SMDS_MeshVolume* anElem = anIter->next();
 758
 759         MED::TIntVector* anElemNums;
 760         MED::TIntVector* aFamilyNums;
 761
 762         if (anElem->IsPoly()) {
 763           const SMDS_PolyhedralVolumeOfNodes* aPolyedre =
 764             (const SMDS_PolyhedralVolumeOfNodes*) anElem;
 765           if (!aPolyedre) {
 766             MESSAGE("Warning: bad volumic element");
 767             continue;
 768           }
 769
 770           anElemNums = &aPolyedreElemNums;
 771           aFamilyNums = &aPolyedreFamilyNums;
 772
 773           TInt aNodeId, aNbFaces = aPolyedre->NbFaces();
 774           for (int iface = 1; iface <= aNbFaces; iface++) {
 775             int aNbFaceNodes = aPolyedre->NbFaceNodes(iface);
 776             for (int inode = 1; inode <= aNbFaceNodes; inode++) {
 777               aNodeId = aPolyedre->GetFaceNode(iface, inode)->GetID();
 778 #ifdef _EDF_NODE_IDS_
 779               aPolyedreConn.push_back(aNodeIdMap[aNodeId]);
 780 #else
 781               aPolyedreConn.push_back(aNodeId);
 782 #endif
 783             }
 784             TInt aPrevPos = aPolyedreFaces.back();
 785             aPolyedreFaces.push_back(aPrevPos + aNbFaceNodes);
 786           }
 787           TInt aPrevPos = aPolyedreInds.back();
 788           aPolyedreInds.push_back(aPrevPos + aNbFaces);
 789
 790         }
 791         else {
 792           TInt aNbNodes = anElem->NbNodes();
 793           SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
 794           TInt aNbConnectivity;
 795           MED::TIntVector* aConnectivity;
 796           switch(aNbNodes){
 797           case 4:
 798             aNbConnectivity = aNbTetraConn;
 799             anElemNums = &anTetraElemNums;
 800             aFamilyNums = &aTetraFamilyNums;
 801             aConnectivity = &aTetraConn;
 802             break;
 803           case 5:
 804             aNbConnectivity = aNbPyraConn;
 805             anElemNums = &anPyraElemNums;
 806             aFamilyNums = &aPyraFamilyNums;
 807             aConnectivity = &aPyraConn;
 808             break;
 809           case 6:
 810             aNbConnectivity = aNbPentaConn;
 811             anElemNums = &anPentaElemNums;
 812             aFamilyNums = &aPentaFamilyNums;
 813             aConnectivity = &aPentaConn;
 814             break;
 815           case 8:
 816             aNbConnectivity = aNbHexaConn;
 817             anElemNums = &aHexaElemNums;
 818             aFamilyNums = &aHexaFamilyNums;
 819             aConnectivity = &aHexaConn;
 820             break;
 821           case 10:
 822             aNbConnectivity = aNbTetra10Conn;
 823             anElemNums = &anTetra10ElemNums;
 824             aFamilyNums = &aTetra10FamilyNums;
 825             aConnectivity = &aTetra10Conn;
 826             break;
 827           case 13:
 828             aNbConnectivity = aNbPyra13Conn;
 829             anElemNums = &anPyra13ElemNums;
 830             aFamilyNums = &aPyra13FamilyNums;
 831             aConnectivity = &aPyra13Conn;
 832             break;
 833           case 15:
 834             aNbConnectivity = aNbPenta15Conn;
 835             anElemNums = &anPenta15ElemNums;
 836             aFamilyNums = &aPenta15FamilyNums;
 837             aConnectivity = &aPenta15Conn;
 838             break;
 839           case 20:
 840             aNbConnectivity = aNbHexa20Conn;
 841             anElemNums = &aHexa20ElemNums;
 842             aFamilyNums = &aHexa20FamilyNums;
 843             aConnectivity = &aHexa20Conn;
 844           }
 845
 846           TInt aSize = aConnectivity->size();
 847           aConnectivity->resize(aSize + aNbConnectivity);
 848
 849           MED::TIntVector aVector(aNbNodes);
 850           for(TInt iNode = 0; aNodesIter->more(); iNode++){
 851             const SMDS_MeshElement* aNode = aNodesIter->next();
 852 #ifdef _EDF_NODE_IDS_
 853             aVector[iNode] = aNodeIdMap[aNode->GetID()];
 854 #else
 855             aVector[iNode] = aNode->GetID();
 856 #endif
 857           }
 858           // There is some difference between SMDS and MED in cells mapping
 859           switch(aNbNodes){
 860           case 5:
 861             (*aConnectivity)[aSize+0] = aVector[0];
 862             (*aConnectivity)[aSize+1] = aVector[3];
 863             (*aConnectivity)[aSize+2] = aVector[2];
 864             (*aConnectivity)[aSize+3] = aVector[1];
 865             (*aConnectivity)[aSize+4] = aVector[4];
 866           default:
 867             for(TInt iNode = 0; iNode < aNbNodes; iNode++)
 868               (*aConnectivity)[aSize+iNode] = aVector[iNode];
 869           }
 870         }
 871
 872         anElemNums->push_back(anElem->GetID());
 873
 874         if (anElemFamMap.find(anElem) != anElemFamMap.end())
 875           aFamilyNums->push_back(anElemFamMap[anElem]);
 876         else
 877           aFamilyNums->push_back(myVolumesDefaultFamilyId);
 878       }
 879
 880       if(TInt aNbElems = anTetraElemNums.size()){
 881         PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
 882                                                 SMDS_MED_ENTITY,
 883                                                 eTETRA4,
 884                                                 aTetraConn,
 885                                                 SMDS_MED_CONNECTIVITY,
 886                                                 aTetraFamilyNums,
 887                                                 anTetraElemNums);
 888         MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTETRA4<<"; aNbElems = "<<aNbElems);
 889         myMed->SetCellInfo(aCellInfo);
 890       }
 891       if(TInt aNbElems = anPyraElemNums.size()){
 892         PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
 893                                                 SMDS_MED_ENTITY,
 894                                                 ePYRA5,
 895                                                 aPyraConn,
 896                                                 SMDS_MED_CONNECTIVITY,
 897                                                 aPyraFamilyNums,
 898                                                 anPyraElemNums);
 899         MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePYRA5<<"; aNbElems = "<<aNbElems);
 900         myMed->SetCellInfo(aCellInfo);
 901       }
 902       if(TInt aNbElems = anPentaElemNums.size()){
 903         PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
 904                                                 SMDS_MED_ENTITY,
 905                                                 ePENTA6,
 906                                                 aPentaConn,
 907                                                 SMDS_MED_CONNECTIVITY,
 908                                                 aPentaFamilyNums,
 909                                                 anPentaElemNums);
 910         MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePENTA6<<"; aNbElems = "<<aNbElems);
 911         myMed->SetCellInfo(aCellInfo);
 912       }
 913       if(TInt aNbElems = aHexaElemNums.size()){
 914         PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
 915                                                 SMDS_MED_ENTITY,
 916                                                 eHEXA8,
 917                                                 aHexaConn,
 918                                                 SMDS_MED_CONNECTIVITY,
 919                                                 aHexaFamilyNums,
 920                                                 aHexaElemNums);
 921         MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eHEXA8<<"; aNbElems = "<<aNbElems);
 922         myMed->SetCellInfo(aCellInfo);
 923       }
 924       if(TInt aNbElems = anTetra10ElemNums.size()){
 925         PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
 926                                                 SMDS_MED_ENTITY,
 927                                                 eTETRA10,
 928                                                 aTetra10Conn,
 929                                                 SMDS_MED_CONNECTIVITY,
 930                                                 aTetra10FamilyNums,
 931                                                 anTetra10ElemNums);
 932         MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTETRA10<<"; aNbElems = "<<aNbElems);
 933         myMed->SetCellInfo(aCellInfo);
 934       }
 935       if(TInt aNbElems = anPyra13ElemNums.size()){
 936         PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
 937                                                 SMDS_MED_ENTITY,
 938                                                 ePYRA13,
 939                                                 aPyra13Conn,
 940                                                 SMDS_MED_CONNECTIVITY,
 941                                                 aPyra13FamilyNums,
 942                                                 anPyra13ElemNums);
 943         MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePYRA13<<"; aNbElems = "<<aNbElems);
 944         myMed->SetCellInfo(aCellInfo);
 945       }
 946       if(TInt aNbElems = anPenta15ElemNums.size()){
 947         PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
 948                                                 SMDS_MED_ENTITY,
 949                                                 ePENTA15,
 950                                                 aPenta15Conn,
 951                                                 SMDS_MED_CONNECTIVITY,
 952                                                 aPenta15FamilyNums,
 953                                                 anPenta15ElemNums);
 954         MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePENTA15<<"; aNbElems = "<<aNbElems);
 955         myMed->SetCellInfo(aCellInfo);
 956       }
 957       if(TInt aNbElems = aHexa20ElemNums.size()){
 958         PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
 959                                                 SMDS_MED_ENTITY,
 960                                                 eHEXA20,
 961                                                 aHexa20Conn,
 962                                                 SMDS_MED_CONNECTIVITY,
 963                                                 aHexa20FamilyNums,
 964                                                 aHexa20ElemNums);
 965         MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eHEXA20<<"; aNbElems = "<<aNbElems);
 966         myMed->SetCellInfo(aCellInfo);
 967       }
 968
 969       if(TInt aNbElems = aPolyedreElemNums.size()){
 970         // add one element in connectivities,
 971         // referenced by the last element in faces
 972         aPolyedreConn.push_back(0);
 973
 974         PPolyedreInfo aCellInfo = myMed->CrPolyedreInfo(aMeshInfo,
 975                                                         SMDS_MED_ENTITY,
 976                                                         ePOLYEDRE,
 977                                                         aPolyedreInds,
 978                                                         aPolyedreFaces,
 979                                                         aPolyedreConn,
 980                                                         SMDS_MED_CONNECTIVITY,
 981                                                         aPolyedreFamilyNums,
 982                                                         aPolyedreElemNums);
 983         MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePOLYEDRE<<"; aNbElems = "<<aNbElems);
 984         myMed->SetPolyedreInfo(aCellInfo);
 985       }
 986     }
 987   }
 988   catch(const std::exception& exc) {
 989     INFOS("Follow exception was cought:\n\t"<<exc.what());
 990   }
 991   catch(...) {
 992     INFOS("Unknown exception was cought !!!");
 993   }
 994
 995   myMeshId = -1;
 996   myGroups.clear();
 997   mySubMeshes.clear();
 998   return aResult;
 999 }