X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FDriverMED%2FDriverMED_W_SMESHDS_Mesh.cxx;h=f6cf1ff7833658b27de42a44e5dcd41944493bdd;hp=6bdfc09becde59b240b3e24ad81bbd11d9c74e5e;hb=104ff7b2818ce4d0f8a38d840abd3e5c70190668;hpb=ed456586bfb1411c5bff73b221658766689a6253

diff --git a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
index 6bdfc09be..f6cf1ff78 100644
--- a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
+++ b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
@@ -17,7 +17,7 @@
 //  License along with this library; if not, write to the Free Software 
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
 // 
-//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
 //
 //
@@ -33,15 +33,18 @@
 #include "SMESHDS_Mesh.hxx"
 #include "SMDS_MeshElement.hxx"
 #include "SMDS_MeshNode.hxx"
+#include "SMDS_PolyhedralVolumeOfNodes.hxx"
+
 #include "utilities.h"
 
-#include "MEDA_Wrapper.hxx"
 #include "MED_Utilities.hxx"
 
 #define _EDF_NODE_IDS_
 //#define _ELEMENTS_BY_DIM_
 
 using namespace std;
+using namespace MED;
+
 
 DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
   myAllSubMeshes (false),
@@ -51,6 +54,18 @@ DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
   myDoGroupOfVolumes (false)
 {}
 
+void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName, 
+				       MED::EVersion theId)
+{
+  myMed = CrWrapper(theFileName,theId);
+  Driver_SMESHDS_Mesh::SetFile(theFileName);
+}
+
+void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName)
+{
+  return SetFile(theFileName,MED::eV2_2);
+}
+
 void DriverMED_W_SMESHDS_Mesh::SetMeshName(const std::string& theMeshName)
 {
   myMeshName = theMeshName;
@@ -91,95 +106,106 @@ void DriverMED_W_SMESHDS_Mesh::AddGroupOfVolumes()
   myDoGroupOfVolumes = true;
 }
 
-typedef double (SMDS_MeshNode::* TGetCoord)() const;
-typedef const char* TName;
-typedef const char* TUnit;
-
-static TUnit aUnit[3] = {"m","m","m"};
-
-static TGetCoord aXYZGetCoord[3] = {
-  &SMDS_MeshNode::X, 
-  &SMDS_MeshNode::Y, 
-  &SMDS_MeshNode::Z
-};
-static TName aXYZName[3] = {"x","y","z"};
-
-
-static TGetCoord aXYGetCoord[2] = {
-  &SMDS_MeshNode::X, 
-  &SMDS_MeshNode::Y
-};
-static TName aXYName[2] = {"x","y"};
-
-static TGetCoord aYZGetCoord[2] = {
-  &SMDS_MeshNode::Y, 
-  &SMDS_MeshNode::Z
-};
-static TName aYZName[2] = {"y","z"};
-
-static TGetCoord aXZGetCoord[2] = {
-  &SMDS_MeshNode::X, 
-  &SMDS_MeshNode::Z
-};
-static TName aXZName[2] = {"x","z"};
-
-
-static TGetCoord aXGetCoord[1] = {
-  &SMDS_MeshNode::X
-};
-static TName aXName[1] = {"x"};
-
-static TGetCoord aYGetCoord[1] = {
-  &SMDS_MeshNode::Y
-};
-static TName aYName[1] = {"y"};
-
-static TGetCoord aZGetCoord[1] = {
-  &SMDS_MeshNode::Z
-};
-static TName aZName[1] = {"z"};
-
-
-class TCoordHelper{
-  SMDS_NodeIteratorPtr myNodeIter;
-  const SMDS_MeshNode* myCurrentNode;
-  TGetCoord* myGetCoord;
-  TName* myName;
-  TUnit* myUnit;
-public:
-  TCoordHelper(const SMDS_NodeIteratorPtr& theNodeIter,
-	       TGetCoord* theGetCoord,
-	       TName* theName,
-	       TUnit* theUnit = aUnit):
-    myNodeIter(theNodeIter),
-    myGetCoord(theGetCoord),
-    myName(theName),
-    myUnit(theUnit)
-  {}
-  virtual ~TCoordHelper(){}
-  bool Next(){ 
-    return myNodeIter->more() && 
-      (myCurrentNode = myNodeIter->next());
-  }
-  const SMDS_MeshNode* GetNode(){
-    return myCurrentNode;
-  }
-  MED::TIntVector::value_type GetID(){
-    return myCurrentNode->GetID();
-  }
-  MED::TFloatVector::value_type GetCoord(med_int theCoodId){
-    return (myCurrentNode->*myGetCoord[theCoodId])();
-  }
-  MED::TStringVector::value_type GetName(med_int theDimId){
-    return myName[theDimId];
-  }
-  MED::TStringVector::value_type GetUnit(med_int theDimId){
-    return myUnit[theDimId];
-  }
-};
-typedef boost::shared_ptr<TCoordHelper> TCoordHelperPtr;
-
+namespace{
+  typedef double (SMDS_MeshNode::* TGetCoord)() const;
+  typedef const char* TName;
+  typedef const char* TUnit;
+
+  // name length in a mesh must be equal to 16 :
+  //         1234567890123456
+  TName M = "m               ";
+  TName X = "x               ";
+  TName Y = "y               ";
+  TName Z = "z               ";
+
+  TUnit aUnit[3] = {M,M,M};
+
+  // 3 dim
+  TGetCoord aXYZGetCoord[3] = {
+    &SMDS_MeshNode::X, 
+    &SMDS_MeshNode::Y, 
+    &SMDS_MeshNode::Z
+  };
+  TName aXYZName[3] = {X,Y,Z};
+  
+  // 2 dim
+  TGetCoord aXYGetCoord[2] = {
+    &SMDS_MeshNode::X, 
+    &SMDS_MeshNode::Y
+  };
+  TName aXYName[2] = {X,Y};
+
+  TGetCoord aYZGetCoord[2] = {
+    &SMDS_MeshNode::Y, 
+    &SMDS_MeshNode::Z
+  };
+  TName aYZName[2] = {Y,Z};
+
+  TGetCoord aXZGetCoord[2] = {
+    &SMDS_MeshNode::X, 
+    &SMDS_MeshNode::Z
+  };
+  TName aXZName[2] = {X,Z};
+
+  // 1 dim
+  TGetCoord aXGetCoord[1] = {
+    &SMDS_MeshNode::X
+  };
+  TName aXName[1] = {X};
+
+  TGetCoord aYGetCoord[1] = {
+    &SMDS_MeshNode::Y
+  };
+  TName aYName[1] = {Y};
+
+  TGetCoord aZGetCoord[1] = {
+    &SMDS_MeshNode::Z
+  };
+  TName aZName[1] = {Z};
+
+
+  class TCoordHelper{
+    SMDS_NodeIteratorPtr myNodeIter;
+    const SMDS_MeshNode* myCurrentNode;
+    TGetCoord* myGetCoord;
+    TName* myName;
+    TUnit* myUnit;
+  public:
+    TCoordHelper(const SMDS_NodeIteratorPtr& theNodeIter,
+		 TGetCoord* theGetCoord,
+		 TName* theName,
+		 TUnit* theUnit = aUnit):
+      myNodeIter(theNodeIter),
+      myGetCoord(theGetCoord),
+      myName(theName),
+      myUnit(theUnit)
+    {}
+    virtual ~TCoordHelper(){}
+    bool Next(){ 
+      return myNodeIter->more() && 
+	(myCurrentNode = myNodeIter->next());
+    }
+    const SMDS_MeshNode* GetNode(){
+      return myCurrentNode;
+    }
+    MED::TIntVector::value_type GetID(){
+      return myCurrentNode->GetID();
+    }
+    MED::TFloatVector::value_type GetCoord(TInt theCoodId){
+      return (myCurrentNode->*myGetCoord[theCoodId])();
+    }
+    MED::TStringVector::value_type GetName(TInt theDimId){
+      return myName[theDimId];
+    }
+    MED::TStringVector::value_type GetUnit(TInt theDimId){
+      return myUnit[theDimId];
+    }
+  };
+  typedef boost::shared_ptr<TCoordHelper> TCoordHelperPtr;
+  
+}
 
+  
 Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
 {
   Status aResult = DRS_OK;
@@ -188,11 +214,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
     return DRS_FAIL;
   }
   try{
-    using namespace MEDA;
-    using namespace boost;
-
     MESSAGE("Perform - myFile : "<<myFile);
-    TWrapper aMed(myFile);
 
     // Creating the MED mesh for corresponding SMDS structure
     //-------------------------------------------------------
@@ -206,7 +228,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
     }
 
     // Mesh dimension definition
-    med_int aMeshDimension;
+    TInt aMeshDimension;
     TCoordHelperPtr aCoordHelperPtr;
     {  
       bool anIsXDimension = false;
@@ -237,7 +259,6 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
 	anIsXDimension = (aBounds[1] - aBounds[0]) + abs(aBounds[1]) + abs(aBounds[0]) > EPS;
 	anIsYDimension = (aBounds[3] - aBounds[2]) + abs(aBounds[3]) + abs(aBounds[2]) > EPS;
 	anIsZDimension = (aBounds[5] - aBounds[4]) + abs(aBounds[5]) + abs(aBounds[4]) > EPS;
-
 	aMeshDimension = anIsXDimension + anIsYDimension + anIsZDimension;
 	if(!aMeshDimension)
 	  aMeshDimension = 3;
@@ -268,9 +289,9 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
     }
 
     
-    PMeshInfo aMeshInfo = TWrapper::CrMeshInfo(aMeshDimension,aMeshName);
+    PMeshInfo aMeshInfo = myMed->CrMeshInfo(aMeshDimension,aMeshName);
     MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
-    aMed.SetMeshInfo(aMeshInfo);
+    myMed->SetMeshInfo(aMeshInfo);
 
     // Storing SMDS groups and sub-meshes
     //-----------------------------------
@@ -303,31 +324,30 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
 
     for (; aFamsIter != aFamilies.end(); aFamsIter++)
     {
-      PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(aMeshInfo);
-      aMed.SetFamilyInfo(aFamilyInfo);
+      PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(myMed,aMeshInfo);
+      myMed->SetFamilyInfo(aFamilyInfo);
       int aFamId = (*aFamsIter)->GetId();
 
       const set<const SMDS_MeshElement *>& anElems = (*aFamsIter)->GetElements();
-      set<const SMDS_MeshElement *>::iterator anElemsIter = anElems.begin();
+      set<const SMDS_MeshElement *>::const_iterator anElemsIter = anElems.begin();
       for (; anElemsIter != anElems.end(); anElemsIter++)
       {
         anElemFamMap[*anElemsIter] = aFamId;
       }
-//      delete (*aFamsIter);
     }
 
     // Storing SMDS nodes to the MED file for the MED mesh
     //----------------------------------------------------
 #ifdef _EDF_NODE_IDS_
-    typedef map<med_int,med_int> TNodeIdMap;
+    typedef map<TInt,TInt> TNodeIdMap;
     TNodeIdMap aNodeIdMap;
 #endif
-    med_int aNbElems = myMesh->NbNodes();
+    TInt aNbElems = myMesh->NbNodes();
     MED::TIntVector anElemNums(aNbElems);
     MED::TIntVector aFamilyNums(aNbElems);
     MED::TFloatVector aCoordinates(aNbElems*aMeshDimension);
-    for(med_int iNode = 0, aStartId = 0; aCoordHelperPtr->Next(); iNode++, aStartId += aMeshDimension){
-      for(med_int iCoord = 0; iCoord < aMeshDimension; iCoord++){
+    for(TInt iNode = 0, aStartId = 0; aCoordHelperPtr->Next(); iNode++, aStartId += aMeshDimension){
+      for(TInt iCoord = 0; iCoord < aMeshDimension; iCoord++){
 	aCoordinates[aStartId+iCoord] = aCoordHelperPtr->GetCoord(iCoord);
       }
       int aNodeID = aCoordHelperPtr->GetID();
@@ -344,76 +364,128 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
 
     MED::TStringVector aCoordNames(aMeshDimension);
     MED::TStringVector aCoordUnits(aMeshDimension);
-    for(med_int iCoord = 0; iCoord < aMeshDimension; iCoord++){
+    for(TInt iCoord = 0; iCoord < aMeshDimension; iCoord++){
       aCoordNames[iCoord] = aCoordHelperPtr->GetName(iCoord);
       aCoordUnits[iCoord] = aCoordHelperPtr->GetUnit(iCoord);
     }
 
-    const med_repere SMDS_COORDINATE_SYSTEM = MED_CART;
+    const ERepere SMDS_COORDINATE_SYSTEM = eCART;
 
-    PNodeInfo aNodeInfo = TWrapper::CrNodeInfo(aMeshInfo,
-					       SMDS_COORDINATE_SYSTEM,
-					       aCoordinates,
-					       aCoordNames,
-					       aCoordUnits,
-					       aFamilyNums,
-					       anElemNums);
+    PNodeInfo aNodeInfo = myMed->CrNodeInfo(aMeshInfo,
+					    aCoordinates,
+					    eFULL_INTERLACE,
+					    SMDS_COORDINATE_SYSTEM,
+					    aCoordNames,
+					    aCoordUnits,
+					    aFamilyNums,
+					    anElemNums);
     MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems);
-    aMed.SetNodeInfo(aNodeInfo);
+    myMed->SetNodeInfo(aNodeInfo);
 
 
     // Storing others SMDS elements to the MED file for the MED mesh
     //--------------------------------------------------------------
-    med_entite_maillage SMDS_MED_ENTITY = MED_MAILLE;
-    const med_connectivite SMDS_MED_CONNECTIVITY = MED_NOD;
+    EEntiteMaillage SMDS_MED_ENTITY = eMAILLE;
+    const EConnectivite SMDS_MED_CONNECTIVITY = eNOD;
 
     // Storing SMDS Edges
-    if(med_int aNbElems = myMesh->NbEdges()){
+    if(TInt aNbElems = myMesh->NbEdges()){
 #ifdef _ELEMENTS_BY_DIM_
-      SMDS_MED_ENTITY = MED_ARETE;
+      SMDS_MED_ENTITY = eARETE;
 #endif
+      // count edges of diff types
+      int aNbSeg3 = 0, aNbSeg2 = 0;
       SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator();
-      med_int aNbConnectivity = MED::GetNbConn(SMDS_MED_ENTITY,MED_SEG2,aMeshDimension);
-      MED::TIntVector anElemNums(aNbElems);
-      MED::TIntVector aFamilyNums(aNbElems);
-      MED::TIntVector aConnectivity(aNbElems*aNbConnectivity);
-
-      for(med_int iElem = 0, iConn = 0; anIter->more(); iElem++, iConn+=aNbConnectivity){
+      while ( anIter->more() )
+        if ( anIter->next()->NbNodes() == 3 )
+          ++aNbSeg3;
+      aNbSeg2 = aNbElems - aNbSeg3;
+
+      TInt aNbSeg2Conn = MED::GetNbNodes(eSEG2);
+      MED::TIntVector aSeg2ElemNums, aSeg2FamilyNums, aSeg2Conn;
+      aSeg2ElemNums  .reserve( aNbSeg2 );
+      aSeg2FamilyNums.reserve( aNbSeg2 );
+      aSeg2Conn      .reserve( aNbSeg2*aNbSeg2Conn );
+
+      TInt aNbSeg3Conn = MED::GetNbNodes(eSEG3);
+      MED::TIntVector aSeg3ElemNums, aSeg3FamilyNums, aSeg3Conn;
+      aSeg3ElemNums  .reserve( aNbSeg3 );
+      aSeg3FamilyNums.reserve( aNbSeg3 );
+      aSeg3Conn      .reserve( aNbSeg3*aNbSeg3Conn );
+
+      anIter = myMesh->edgesIterator();
+      while ( anIter->more() ) {
 	const SMDS_MeshEdge* anElem = anIter->next();
-	SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
-	for(med_int iNode = 0; iNode < aNbConnectivity && aNodesIter->more(); iNode++){
-	  const SMDS_MeshElement* aNode = aNodesIter->next();
+	TInt aNbNodes = anElem->NbNodes();
+
+	TInt aNbConnectivity;
+	MED::TIntVector* anElemNums;
+        MED::TIntVector* aFamilyNums;
+	MED::TIntVector* aConnectivity;
+        switch(aNbNodes){
+        case 2:
+          aNbConnectivity = aNbSeg2Conn;
+          anElemNums      = &aSeg2ElemNums;
+          aFamilyNums     = &aSeg2FamilyNums;
+          aConnectivity   = &aSeg2Conn;
+          break;
+        case 3:
+          aNbConnectivity = aNbSeg3Conn;
+          anElemNums      = &aSeg3ElemNums;
+          aFamilyNums     = &aSeg3FamilyNums;
+          aConnectivity   = &aSeg3Conn;
+          break;
+        default:
+          break;
+        }
+
+        for(TInt iNode = 0; iNode < aNbNodes; iNode++) {
+	  const SMDS_MeshElement* aNode = anElem->GetNode( iNode );
 #ifdef _EDF_NODE_IDS_
-	  aConnectivity[iConn+iNode] = aNodeIdMap[aNode->GetID()];
+	  aConnectivity->push_back( aNodeIdMap[aNode->GetID()] );
 #else
-	  aConnectivity[iConn+iNode] = aNode->GetID();
+	  aConnectivity->push_back( aNode->GetID() );
 #endif
-	}
-	anElemNums[iElem] = anElem->GetID();
+        }
 
-        if (anElemFamMap.find(anElem) != anElemFamMap.end())
-          aFamilyNums[iElem] = anElemFamMap[anElem];
+	anElemNums->push_back(anElem->GetID());
+
+        map<const SMDS_MeshElement*,int>::iterator edge_fam = anElemFamMap.find( anElem );
+        if ( edge_fam != anElemFamMap.end() )
+          aFamilyNums->push_back( edge_fam->second );
         else
-          aFamilyNums[iElem] = myEdgesDefaultFamilyId;
+          aFamilyNums->push_back( myEdgesDefaultFamilyId );
       }
       
-      PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
-						 SMDS_MED_ENTITY,
-						 MED_SEG2,
-						 SMDS_MED_CONNECTIVITY,
-						 aConnectivity,
-						 aFamilyNums,
-						 anElemNums);
-      aMed.SetCellInfo(aCellInfo);
+      if ( aNbSeg2 ) {
+        PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+                                                SMDS_MED_ENTITY,
+                                                eSEG2,
+                                                aSeg2Conn,
+                                                SMDS_MED_CONNECTIVITY,
+                                                aSeg2FamilyNums,
+                                                aSeg2ElemNums);
+        myMed->SetCellInfo(aCellInfo);
+      }
+      if ( aNbSeg3 ) {
+        PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+                                                SMDS_MED_ENTITY,
+                                                eSEG3,
+                                                aSeg3Conn,
+                                                SMDS_MED_CONNECTIVITY,
+                                                aSeg3FamilyNums,
+                                                aSeg3ElemNums);
+        myMed->SetCellInfo(aCellInfo);
+      }
     }
 
     // Storing SMDS Faces
-    if(med_int aNbElems = myMesh->NbFaces()){
+    if(TInt aNbElems = myMesh->NbFaces()){
       SMDS_FaceIteratorPtr anIter = myMesh->facesIterator();
 #ifdef _ELEMENTS_BY_DIM_
-      SMDS_MED_ENTITY = MED_FACE;
+      SMDS_MED_ENTITY = eFACE;
 #endif
-      med_int aNbTriaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TRIA3,aMeshDimension);
+      TInt aNbTriaConn = MED::GetNbNodes(eTRIA3);
       MED::TIntVector anTriaElemNums; 
       anTriaElemNums.reserve(aNbElems);
       MED::TIntVector aTriaFamilyNums;
@@ -421,7 +493,15 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
       MED::TIntVector aTriaConn;
       aTriaConn.reserve(aNbElems*aNbTriaConn);
 
-      med_int aNbQuadConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_QUAD4,aMeshDimension);
+      TInt aNbTria6Conn = MED::GetNbNodes(eTRIA6);
+      MED::TIntVector anTria6ElemNums; 
+      anTria6ElemNums.reserve(aNbElems);
+      MED::TIntVector aTria6FamilyNums;
+      aTria6FamilyNums.reserve(aNbElems);
+      MED::TIntVector aTria6Conn;
+      aTria6Conn.reserve(aNbElems*aNbTria6Conn);
+
+      TInt aNbQuadConn = MED::GetNbNodes(eQUAD4);
       MED::TIntVector aQuadElemNums;
       aQuadElemNums.reserve(aNbElems);
       MED::TIntVector aQuadFamilyNums;
@@ -429,49 +509,81 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
       MED::TIntVector aQuadConn;
       aQuadConn.reserve(aNbElems*aNbQuadConn);
 
-      for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
+      TInt aNbQuad8Conn = MED::GetNbNodes(eQUAD8);
+      MED::TIntVector aQuad8ElemNums;
+      aQuad8ElemNums.reserve(aNbElems);
+      MED::TIntVector aQuad8FamilyNums;
+      aQuad8FamilyNums.reserve(aNbElems);
+      MED::TIntVector aQuad8Conn;
+      aQuad8Conn.reserve(aNbElems*aNbQuad8Conn);
+
+      MED::TIntVector aPolygoneElemNums;
+      aPolygoneElemNums.reserve(aNbElems);
+      MED::TIntVector aPolygoneInds;
+      aPolygoneInds.reserve(aNbElems + 1);
+      aPolygoneInds.push_back(1); // reference on the first element in the connectivities
+      MED::TIntVector aPolygoneFamilyNums;
+      aPolygoneFamilyNums.reserve(aNbElems);
+      MED::TIntVector aPolygoneConn;
+      aPolygoneConn.reserve(aNbElems*aNbQuadConn);
+
+      for(TInt iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
 	const SMDS_MeshFace* anElem = anIter->next();
-	med_int aNbNodes = anElem->NbNodes();
+	TInt aNbNodes = anElem->NbNodes();
 	SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
-	med_int aNbConnectivity;
+	TInt aNbConnectivity;
 	MED::TIntVector* anElemNums;
         MED::TIntVector* aFamilyNums;
 	MED::TIntVector* aConnectivity;
-	switch(aNbNodes){
-	case 3:
-	  aNbConnectivity = aNbTriaConn;
-	  anElemNums = &anTriaElemNums;
-	  aFamilyNums = &aTriaFamilyNums;
-	  aConnectivity = &aTriaConn;
-	  break;
-	case 4:
-	  aNbConnectivity = aNbQuadConn;
-	  anElemNums = &aQuadElemNums;
-	  aFamilyNums = &aQuadFamilyNums;
-	  aConnectivity = &aQuadConn;
-	  break;
-	}
+        if (anElem->IsPoly()) {
+	  aNbConnectivity = aNbNodes;
+          anElemNums = &aPolygoneElemNums;
+          aFamilyNums = &aPolygoneFamilyNums;
+          aConnectivity = &aPolygoneConn;
+        }
+        else {
+          switch(aNbNodes){
+          case 3:
+            aNbConnectivity = aNbTriaConn;
+            anElemNums = &anTriaElemNums;
+            aFamilyNums = &aTriaFamilyNums;
+            aConnectivity = &aTriaConn;
+            break;
+          case 4:
+            aNbConnectivity = aNbQuadConn;
+            anElemNums = &aQuadElemNums;
+            aFamilyNums = &aQuadFamilyNums;
+            aConnectivity = &aQuadConn;
+            break;
+          case 6:
+            aNbConnectivity = aNbTria6Conn;
+            anElemNums = &anTria6ElemNums;
+            aFamilyNums = &aTria6FamilyNums;
+            aConnectivity = &aTria6Conn;
+            break;
+          case 8:
+            aNbConnectivity = aNbQuad8Conn;
+            anElemNums = &aQuad8ElemNums;
+            aFamilyNums = &aQuad8FamilyNums;
+            aConnectivity = &aQuad8Conn;
+            break;
+          default:
+            break;
+          }
+        }
 	MED::TIntVector aVector(aNbNodes);
-	for(med_int iNode = 0; aNodesIter->more(); iNode++){
+	for(TInt iNode = 0; aNodesIter->more(); iNode++){
 	  const SMDS_MeshElement* aNode = aNodesIter->next();
+#ifdef _EDF_NODE_IDS_
+	  aVector[iNode] = aNodeIdMap[aNode->GetID()];
+#else
 	  aVector[iNode] = aNode->GetID();
+#endif
 	}
 
-	med_int aSize = aConnectivity->size();
+	TInt aSize = aConnectivity->size();
 	aConnectivity->resize(aSize+aNbConnectivity);
-	// There is some differnce between SMDS and MED in cells mapping
-#ifdef _EDF_NODE_IDS_
-	switch(aNbNodes){
-	case 4:
-	  (*aConnectivity)[aSize+0] = aNodeIdMap[aVector[0]];
-	  (*aConnectivity)[aSize+1] = aNodeIdMap[aVector[1]];
-	  (*aConnectivity)[aSize+2] = aNodeIdMap[aVector[3]];  
-	  (*aConnectivity)[aSize+3] = aNodeIdMap[aVector[2]];  
-	default:
-	  for(med_int iNode = 0; iNode < aNbNodes; iNode++) 
-	    (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]];
-	}
-#else
+	// There is some differences between SMDS and MED in cells mapping
 	switch(aNbNodes){
 	case 4:
 	  (*aConnectivity)[aSize+0] = aVector[0];
@@ -479,10 +591,16 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
 	  (*aConnectivity)[aSize+2] = aVector[3];  
 	  (*aConnectivity)[aSize+3] = aVector[2];  
 	default:
-	  for(med_int iNode = 0; iNode < aNbNodes; iNode++) 
+	  for(TInt iNode = 0; iNode < aNbNodes; iNode++) 
 	    (*aConnectivity)[aSize+iNode] = aVector[iNode];
 	}
-#endif
+
+        if (anElem->IsPoly()) {
+          // fill indices for polygonal element
+          TInt aPrevPos = aPolygoneInds.back();
+          aPolygoneInds.push_back(aPrevPos + aNbNodes);
+        }
+
 	anElemNums->push_back(anElem->GetID());
 
         if (anElemFamMap.find(anElem) != anElemFamMap.end())
@@ -490,37 +608,75 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
         else
           aFamilyNums->push_back(myFacesDefaultFamilyId);
       }
-      if(med_int aNbElems = anTriaElemNums.size()){
-	PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
-						   SMDS_MED_ENTITY,
-						   MED_TRIA3,
-						   SMDS_MED_CONNECTIVITY,
-						   aTriaConn,
-						   aTriaFamilyNums,
-						   anTriaElemNums);
-	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TRIA3<<"; aNbElems = "<<aNbElems);
-	aMed.SetCellInfo(aCellInfo);
+      if(TInt aNbElems = anTriaElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						eTRIA3,
+						aTriaConn,
+						SMDS_MED_CONNECTIVITY,
+						aTriaFamilyNums,
+						anTriaElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTRIA3<<"; aNbElems = "<<aNbElems);
+	myMed->SetCellInfo(aCellInfo);
+      }
+      if(TInt aNbElems = aQuadElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						eQUAD4,
+						aQuadConn,
+						SMDS_MED_CONNECTIVITY,
+						aQuadFamilyNums,
+						aQuadElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eQUAD4<<"; aNbElems = "<<aNbElems);
+	myMed->SetCellInfo(aCellInfo);
+      }
+      if(TInt aNbElems = anTria6ElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						eTRIA6,
+						aTria6Conn,
+						SMDS_MED_CONNECTIVITY,
+						aTria6FamilyNums,
+						anTria6ElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTRIA6<<"; aNbElems = "<<aNbElems);
+	myMed->SetCellInfo(aCellInfo);
+      }
+      if(TInt aNbElems = aQuad8ElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						eQUAD8,
+						aQuad8Conn,
+						SMDS_MED_CONNECTIVITY,
+						aQuad8FamilyNums,
+						aQuad8ElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eQUAD8<<"; aNbElems = "<<aNbElems);
+	myMed->SetCellInfo(aCellInfo);
       }
-      if(med_int aNbElems = aQuadElemNums.size()){
-	PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
-						   SMDS_MED_ENTITY,
-						   MED_QUAD4,
-						   SMDS_MED_CONNECTIVITY,
-						   aQuadConn,
-						   aQuadFamilyNums,
-						   aQuadElemNums);
-	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_QUAD4<<"; aNbElems = "<<aNbElems);
-	aMed.SetCellInfo(aCellInfo);
+      if(TInt aNbElems = aPolygoneElemNums.size()){
+        // add one element in connectivities,
+        // referenced by the last element in indices
+        aPolygoneConn.push_back(0);
+
+	PPolygoneInfo aCellInfo = myMed->CrPolygoneInfo(aMeshInfo,
+                                                        SMDS_MED_ENTITY,
+                                                        ePOLYGONE,
+                                                        aPolygoneInds,
+                                                        aPolygoneConn,
+                                                        SMDS_MED_CONNECTIVITY,
+                                                        aPolygoneFamilyNums,
+                                                        aPolygoneElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePOLYGONE<<"; aNbElems = "<<aNbElems);
+	myMed->SetPolygoneInfo(aCellInfo);
       }
     }
 
     // Storing SMDS Volumes
-    if(med_int aNbElems = myMesh->NbVolumes()){
+    if(TInt aNbElems = myMesh->NbVolumes()){
       SMDS_VolumeIteratorPtr anIter = myMesh->volumesIterator();
 #ifdef _ELEMENTS_BY_DIM_
-      SMDS_MED_ENTITY = MED_MAILLE;
+      SMDS_MED_ENTITY = eMAILLE;
 #endif
-      med_int aNbTetraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TETRA4,aMeshDimension);
+      TInt aNbTetraConn = MED::GetNbNodes(eTETRA4);
       MED::TIntVector anTetraElemNums; 
       anTetraElemNums.reserve(aNbElems);
       MED::TIntVector aTetraFamilyNums;
@@ -528,7 +684,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
       MED::TIntVector aTetraConn;
       aTetraConn.reserve(aNbElems*aNbTetraConn);
 
-      med_int aNbPyraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PYRA5,aMeshDimension);
+      TInt aNbPyraConn = MED::GetNbNodes(ePYRA5);
       MED::TIntVector anPyraElemNums; 
       anPyraElemNums.reserve(aNbElems);
       MED::TIntVector aPyraFamilyNums;
@@ -536,7 +692,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
       MED::TIntVector aPyraConn;
       aPyraConn.reserve(aNbElems*aNbPyraConn);
 
-      med_int aNbPentaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PENTA6,aMeshDimension);
+      TInt aNbPentaConn = MED::GetNbNodes(ePENTA6);
       MED::TIntVector anPentaElemNums; 
       anPentaElemNums.reserve(aNbElems);
       MED::TIntVector aPentaFamilyNums;
@@ -544,7 +700,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
       MED::TIntVector aPentaConn;
       aPentaConn.reserve(aNbElems*aNbPentaConn);
 
-      med_int aNbHexaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_HEXA8,aMeshDimension);
+      TInt aNbHexaConn = MED::GetNbNodes(eHEXA8);
       MED::TIntVector aHexaElemNums;
       aHexaElemNums.reserve(aNbElems);
       MED::TIntVector aHexaFamilyNums;
@@ -552,74 +708,168 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
       MED::TIntVector aHexaConn;
       aHexaConn.reserve(aNbElems*aNbHexaConn);
 
-      for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
+      TInt aNbTetra10Conn = MED::GetNbNodes(eTETRA10);
+      MED::TIntVector anTetra10ElemNums; 
+      anTetra10ElemNums.reserve(aNbElems);
+      MED::TIntVector aTetra10FamilyNums;
+      aTetra10FamilyNums.reserve(aNbElems);
+      MED::TIntVector aTetra10Conn;
+      aTetra10Conn.reserve(aNbElems*aNbTetra10Conn);
+
+      TInt aNbPyra13Conn = MED::GetNbNodes(ePYRA13);
+      MED::TIntVector anPyra13ElemNums; 
+      anPyra13ElemNums.reserve(aNbElems);
+      MED::TIntVector aPyra13FamilyNums;
+      aPyra13FamilyNums.reserve(aNbElems);
+      MED::TIntVector aPyra13Conn;
+      aPyra13Conn.reserve(aNbElems*aNbPyra13Conn);
+
+      TInt aNbPenta15Conn = MED::GetNbNodes(ePENTA15);
+      MED::TIntVector anPenta15ElemNums; 
+      anPenta15ElemNums.reserve(aNbElems);
+      MED::TIntVector aPenta15FamilyNums;
+      aPenta15FamilyNums.reserve(aNbElems);
+      MED::TIntVector aPenta15Conn;
+      aPenta15Conn.reserve(aNbElems*aNbPenta15Conn);
+
+      TInt aNbHexa20Conn = MED::GetNbNodes(eHEXA20);
+      MED::TIntVector aHexa20ElemNums;
+      aHexa20ElemNums.reserve(aNbElems);
+      MED::TIntVector aHexa20FamilyNums;
+      aHexa20FamilyNums.reserve(aNbElems);
+      MED::TIntVector aHexa20Conn;
+      aHexa20Conn.reserve(aNbElems*aNbHexa20Conn);
+
+      MED::TIntVector aPolyedreElemNums;
+      aPolyedreElemNums.reserve(aNbElems);
+      MED::TIntVector aPolyedreInds;
+      aPolyedreInds.reserve(aNbElems + 1);
+      aPolyedreInds.push_back(1); // reference on the first element in the faces
+      MED::TIntVector aPolyedreFaces;
+      aPolyedreFaces.reserve(aNbElems + 1);
+      aPolyedreFaces.push_back(1); // reference on the first element in the connectivities
+      MED::TIntVector aPolyedreFamilyNums;
+      aPolyedreFamilyNums.reserve(aNbElems);
+      MED::TIntVector aPolyedreConn;
+      aPolyedreConn.reserve(aNbElems*aNbHexaConn);
+
+      for(TInt iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
 	const SMDS_MeshVolume* anElem = anIter->next();
-	med_int aNbNodes = anElem->NbNodes();
-	SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
-	med_int aNbConnectivity;
-	MED::TIntVector* anElemNums;
-	MED::TIntVector* aFamilyNums;
-	MED::TIntVector* aConnectivity;
-	switch(aNbNodes){
-	case 4:
-	  aNbConnectivity = aNbTetraConn;
-	  anElemNums = &anTetraElemNums;
-	  aFamilyNums = &aTetraFamilyNums;
-	  aConnectivity = &aTetraConn;
-	  break;
-	case 5:
-	  aNbConnectivity = aNbPyraConn;
-	  anElemNums = &anPyraElemNums;
-	  aFamilyNums = &aPyraFamilyNums;
-	  aConnectivity = &aPyraConn;
-	  break;
-	case 6:
-	  aNbConnectivity = aNbPentaConn;
-	  anElemNums = &anPentaElemNums;
-	  aFamilyNums = &aPentaFamilyNums;
-	  aConnectivity = &aPentaConn;
-	  break;
-	case 8:
-	  aNbConnectivity = aNbHexaConn;
-	  anElemNums = &aHexaElemNums;
-	  aFamilyNums = &aHexaFamilyNums;
-	  aConnectivity = &aHexaConn;
-	}
 
-	MED::TIntVector aVector(aNbNodes);
-	for(med_int iNode = 0; aNodesIter->more(); iNode++){
-	  const SMDS_MeshElement* aNode = aNodesIter->next();
-	  aVector[iNode] = aNode->GetID();
-	}
-	med_int aSize = aConnectivity->size();
-	aConnectivity->resize(aSize+aNbConnectivity);
-	// There is some difference between SMDS and MED in cells mapping
+        MED::TIntVector* anElemNums;
+        MED::TIntVector* aFamilyNums;
+
+        if (anElem->IsPoly()) {
+          const SMDS_PolyhedralVolumeOfNodes* aPolyedre =
+            (const SMDS_PolyhedralVolumeOfNodes*) anElem;
+          if (!aPolyedre) {
+            MESSAGE("Warning: bad volumic element");
+            continue;
+          }
+
+          anElemNums = &aPolyedreElemNums;
+          aFamilyNums = &aPolyedreFamilyNums;
+
+          TInt aNodeId, aNbFaces = aPolyedre->NbFaces();
+          for (int iface = 1; iface <= aNbFaces; iface++) {
+            int aNbFaceNodes = aPolyedre->NbFaceNodes(iface);
+            for (int inode = 1; inode <= aNbFaceNodes; inode++) {
+              aNodeId = aPolyedre->GetFaceNode(iface, inode)->GetID();
 #ifdef _EDF_NODE_IDS_
-	switch(aNbNodes){
-	case 5:
-	  (*aConnectivity)[aSize+0] = aNodeIdMap[aVector[0]];
-	  (*aConnectivity)[aSize+1] = aNodeIdMap[aVector[3]];
-	  (*aConnectivity)[aSize+2] = aNodeIdMap[aVector[2]];  
-	  (*aConnectivity)[aSize+3] = aNodeIdMap[aVector[1]];  
-	  (*aConnectivity)[aSize+4] = aNodeIdMap[aVector[4]];  
-	default:
-	  for(med_int iNode = 0; iNode < aNbNodes; iNode++) 
-	    (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]];
-	}
+              aPolyedreConn.push_back(aNodeIdMap[aNodeId]);
 #else
-	switch(aNbNodes){
-	case 5:
-	  (*aConnectivity)[aSize+0] = aVector[0];
-	  (*aConnectivity)[aSize+1] = aVector[3];
-	  (*aConnectivity)[aSize+2] = aVector[2];  
-	  (*aConnectivity)[aSize+3] = aVector[1];  
-	  (*aConnectivity)[aSize+4] = aVector[4];  
-	default:
-	  for(med_int iNode = 0; iNode < aNbNodes; iNode++) 
-	    (*aConnectivity)[aSize+iNode] = aVector[iNode];
-	}
+              aPolyedreConn.push_back(aNodeId);
 #endif
-	anElemNums->push_back(anElem->GetID());
+            }
+            TInt aPrevPos = aPolyedreFaces.back();
+            aPolyedreFaces.push_back(aPrevPos + aNbFaceNodes);
+          }
+          TInt aPrevPos = aPolyedreInds.back();
+          aPolyedreInds.push_back(aPrevPos + aNbFaces);
+
+        }
+        else {
+          TInt aNbNodes = anElem->NbNodes();
+          SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
+          TInt aNbConnectivity;
+          MED::TIntVector* aConnectivity;
+          switch(aNbNodes){
+          case 4:
+            aNbConnectivity = aNbTetraConn;
+            anElemNums = &anTetraElemNums;
+            aFamilyNums = &aTetraFamilyNums;
+            aConnectivity = &aTetraConn;
+            break;
+          case 5:
+            aNbConnectivity = aNbPyraConn;
+            anElemNums = &anPyraElemNums;
+            aFamilyNums = &aPyraFamilyNums;
+            aConnectivity = &aPyraConn;
+            break;
+          case 6:
+            aNbConnectivity = aNbPentaConn;
+            anElemNums = &anPentaElemNums;
+            aFamilyNums = &aPentaFamilyNums;
+            aConnectivity = &aPentaConn;
+            break;
+          case 8:
+            aNbConnectivity = aNbHexaConn;
+            anElemNums = &aHexaElemNums;
+            aFamilyNums = &aHexaFamilyNums;
+            aConnectivity = &aHexaConn;
+	    break;
+          case 10:
+            aNbConnectivity = aNbTetra10Conn;
+            anElemNums = &anTetra10ElemNums;
+            aFamilyNums = &aTetra10FamilyNums;
+            aConnectivity = &aTetra10Conn;
+            break;
+          case 13:
+            aNbConnectivity = aNbPyra13Conn;
+            anElemNums = &anPyra13ElemNums;
+            aFamilyNums = &aPyra13FamilyNums;
+            aConnectivity = &aPyra13Conn;
+            break;
+          case 15:
+            aNbConnectivity = aNbPenta15Conn;
+            anElemNums = &anPenta15ElemNums;
+            aFamilyNums = &aPenta15FamilyNums;
+            aConnectivity = &aPenta15Conn;
+            break;
+          case 20:
+            aNbConnectivity = aNbHexa20Conn;
+            anElemNums = &aHexa20ElemNums;
+            aFamilyNums = &aHexa20FamilyNums;
+            aConnectivity = &aHexa20Conn;
+          }
+
+          TInt aSize = aConnectivity->size();
+          aConnectivity->resize(aSize + aNbConnectivity);
+
+          MED::TIntVector aVector(aNbNodes);
+          for(TInt iNode = 0; aNodesIter->more(); iNode++){
+            const SMDS_MeshElement* aNode = aNodesIter->next();
+#ifdef _EDF_NODE_IDS_
+            aVector[iNode] = aNodeIdMap[aNode->GetID()];
+#else
+            aVector[iNode] = aNode->GetID();
+#endif
+          }
+          // There is some difference between SMDS and MED in cells mapping
+          switch(aNbNodes){
+          case 5:
+            (*aConnectivity)[aSize+0] = aVector[0];
+            (*aConnectivity)[aSize+1] = aVector[3];
+            (*aConnectivity)[aSize+2] = aVector[2];  
+            (*aConnectivity)[aSize+3] = aVector[1];  
+            (*aConnectivity)[aSize+4] = aVector[4];  
+          default:
+            for(TInt iNode = 0; iNode < aNbNodes; iNode++) 
+              (*aConnectivity)[aSize+iNode] = aVector[iNode];
+          }
+        }
+
+        anElemNums->push_back(anElem->GetID());
 
         if (anElemFamMap.find(anElem) != anElemFamMap.end())
           aFamilyNums->push_back(anElemFamMap[anElem]);
@@ -627,54 +877,118 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
           aFamilyNums->push_back(myVolumesDefaultFamilyId);
       }
 
-      if(med_int aNbElems = anTetraElemNums.size()){
-	PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
-						   SMDS_MED_ENTITY,
-						   MED_TETRA4,
-						   SMDS_MED_CONNECTIVITY,
-						   aTetraConn,
-						   aTetraFamilyNums,
-						   anTetraElemNums);
-	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TETRA4<<"; aNbElems = "<<aNbElems);
-	aMed.SetCellInfo(aCellInfo);
+      if(TInt aNbElems = anTetraElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						eTETRA4,
+						aTetraConn,
+						SMDS_MED_CONNECTIVITY,
+						aTetraFamilyNums,
+						anTetraElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTETRA4<<"; aNbElems = "<<aNbElems);
+	myMed->SetCellInfo(aCellInfo);
+      }
+      if(TInt aNbElems = anPyraElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						ePYRA5,
+						aPyraConn,
+						SMDS_MED_CONNECTIVITY,
+						aPyraFamilyNums,
+						anPyraElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePYRA5<<"; aNbElems = "<<aNbElems);
+	myMed->SetCellInfo(aCellInfo);
+      }
+      if(TInt aNbElems = anPentaElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						ePENTA6,
+						aPentaConn,
+						SMDS_MED_CONNECTIVITY,
+						aPentaFamilyNums,
+						anPentaElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePENTA6<<"; aNbElems = "<<aNbElems);
+	myMed->SetCellInfo(aCellInfo);
+      }
+      if(TInt aNbElems = aHexaElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						eHEXA8,
+						aHexaConn,
+						SMDS_MED_CONNECTIVITY,
+						aHexaFamilyNums,
+						aHexaElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eHEXA8<<"; aNbElems = "<<aNbElems);
+	myMed->SetCellInfo(aCellInfo);
       }
-      if(med_int aNbElems = anPyraElemNums.size()){
-	PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
-						   SMDS_MED_ENTITY,
-						   MED_PYRA5,
-						   SMDS_MED_CONNECTIVITY,
-						   aPyraConn,
-						   aPyraFamilyNums,
-						   anPyraElemNums);
-	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PYRA5<<"; aNbElems = "<<aNbElems);
-	aMed.SetCellInfo(aCellInfo);
+      if(TInt aNbElems = anTetra10ElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						eTETRA10,
+						aTetra10Conn,
+						SMDS_MED_CONNECTIVITY,
+						aTetra10FamilyNums,
+						anTetra10ElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTETRA10<<"; aNbElems = "<<aNbElems);
+	myMed->SetCellInfo(aCellInfo);
       }
-      if(med_int aNbElems = anPentaElemNums.size()){
-	PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
-						   SMDS_MED_ENTITY,
-						   MED_PENTA6,
-						   SMDS_MED_CONNECTIVITY,
-						   aPentaConn,
-						   aPentaFamilyNums,
-						   anPentaElemNums);
-	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PENTA6<<"; aNbElems = "<<aNbElems);
-	aMed.SetCellInfo(aCellInfo);
+      if(TInt aNbElems = anPyra13ElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						ePYRA13,
+						aPyra13Conn,
+						SMDS_MED_CONNECTIVITY,
+						aPyra13FamilyNums,
+						anPyra13ElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePYRA13<<"; aNbElems = "<<aNbElems);
+	myMed->SetCellInfo(aCellInfo);
       }
-      if(med_int aNbElems = aHexaElemNums.size()){
-	PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
-						   SMDS_MED_ENTITY,
-						   MED_HEXA8,
-						   SMDS_MED_CONNECTIVITY,
-						   aHexaConn,
-						   aHexaFamilyNums,
-						   aHexaElemNums);
-	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_HEXA8<<"; aNbElems = "<<aNbElems);
-	aMed.SetCellInfo(aCellInfo);
+      if(TInt aNbElems = anPenta15ElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						ePENTA15,
+						aPenta15Conn,
+						SMDS_MED_CONNECTIVITY,
+						aPenta15FamilyNums,
+						anPenta15ElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePENTA15<<"; aNbElems = "<<aNbElems);
+	myMed->SetCellInfo(aCellInfo);
+      }
+      if(TInt aNbElems = aHexa20ElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						eHEXA20,
+						aHexa20Conn,
+						SMDS_MED_CONNECTIVITY,
+						aHexa20FamilyNums,
+						aHexa20ElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eHEXA20<<"; aNbElems = "<<aNbElems);
+	myMed->SetCellInfo(aCellInfo);
+      }
+
+      if(TInt aNbElems = aPolyedreElemNums.size()){
+        // add one element in connectivities,
+        // referenced by the last element in faces
+        aPolyedreConn.push_back(0);
+
+	PPolyedreInfo aCellInfo = myMed->CrPolyedreInfo(aMeshInfo,
+                                                        SMDS_MED_ENTITY,
+                                                        ePOLYEDRE,
+                                                        aPolyedreInds,
+                                                        aPolyedreFaces,
+                                                        aPolyedreConn,
+                                                        SMDS_MED_CONNECTIVITY,
+                                                        aPolyedreFamilyNums,
+                                                        aPolyedreElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePOLYEDRE<<"; aNbElems = "<<aNbElems);
+	myMed->SetPolyedreInfo(aCellInfo);
       }
     }
-  }catch(const std::exception& exc){
+  }
+  catch(const std::exception& exc) {
     INFOS("Follow exception was cought:\n\t"<<exc.what());
-  }catch(...){
+  }
+  catch(...) {
     INFOS("Unknown exception was cought !!!");
   }