X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FDriverMED%2FDriverMED_W_SMESHDS_Mesh.cxx;h=82e134adfd93c63021cf5d63645bd886b2e0bff6;hb=d9cc1f52dd4ec81095a093109ee321a29aa90374;hp=e918f84281aa8e4064fcae295da1404ce32b25d4;hpb=51569f091c2d18be76ea9bd3e68ca0247cc731c3;p=modules%2Fsmesh.git

diff --git a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
index e918f8428..82e134adf 100644
--- a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
+++ b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
@@ -24,66 +24,54 @@
 //  File   : DriverMED_W_SMESHDS_Mesh.cxx
 //  Module : SMESH
 
+#include <sstream>
+
 #include "DriverMED_W_SMESHDS_Mesh.h"
 #include "DriverMED_W_SMDS_Mesh.h"
 #include "DriverMED_Family.h"
 
+#include "SMESHDS_Mesh.hxx"
 #include "SMDS_MeshElement.hxx"
 #include "SMDS_MeshNode.hxx"
-#include "utilities.h"
+#include "SMDS_PolyhedralVolumeOfNodes.hxx"
 
-#include "MEDA_Wrapper.hxx"
-#include <sstream>	
+#include "utilities.h"
 
 #include "MED_Utilities.hxx"
 
 #define _EDF_NODE_IDS_
-#define _ELEMENTS_BY_DIM_
-
-DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh()
-     :
-       myMesh (NULL),
-       myFile (""),
-       myFileId (-1),
-       myMeshId (-1),
-       myAllSubMeshes (false),
-       myDoGroupOfNodes (false),
-       myDoGroupOfEdges (false),
-       myDoGroupOfFaces (false),
-       myDoGroupOfVolumes (false)
-{
-}
+//#define _ELEMENTS_BY_DIM_
 
-DriverMED_W_SMESHDS_Mesh::~DriverMED_W_SMESHDS_Mesh()
-{
-}
+using namespace std;
+using namespace MED;
 
-void DriverMED_W_SMESHDS_Mesh::SetMesh(SMDS_Mesh * aMesh)
-{
-  myMesh = aMesh;
-}
 
-void DriverMED_W_SMESHDS_Mesh::SetFile(string aFile)
-{
-  myFile = aFile;
-}
+DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
+  myAllSubMeshes (false),
+  myDoGroupOfNodes (false),
+  myDoGroupOfEdges (false),
+  myDoGroupOfFaces (false),
+  myDoGroupOfVolumes (false)
+{}
 
-void DriverMED_W_SMESHDS_Mesh::SetFileId(med_idt aFileId)
+void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName, 
+				       MED::EVersion theId)
 {
-  myFileId = aFileId;
+  myMed = CrWrapper(theFileName,theId);
+  Driver_SMESHDS_Mesh::SetFile(theFileName);
 }
 
-void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId)
+void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName)
 {
-  myMeshId = aMeshId;
+  return SetFile(theFileName,MED::eV2_2);
 }
 
-void DriverMED_W_SMESHDS_Mesh::SetMeshName(string theMeshName)
+void DriverMED_W_SMESHDS_Mesh::SetMeshName(const std::string& theMeshName)
 {
   myMeshName = theMeshName;
 }
 
-void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_Group* theGroup)
+void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_GroupBase* theGroup)
 {
   myGroups.push_back(theGroup);
 }
@@ -118,123 +106,107 @@ void DriverMED_W_SMESHDS_Mesh::AddGroupOfVolumes()
   myDoGroupOfVolumes = true;
 }
 
-void DriverMED_W_SMESHDS_Mesh::Write()
-{
-  string myClass = string("SMDS_Mesh");
-  string myExtension = string("MED");
-
-  DriverMED_W_SMDS_Mesh *myWriter = new DriverMED_W_SMDS_Mesh;
-
-  myWriter->SetMesh(myMesh);
-  //  myWriter->SetFile(myFile);
-  myWriter->SetMeshId(myMeshId);
-  myWriter->SetFileId(myFileId);
-
-  myWriter->Write();
+namespace{
+  typedef double (SMDS_MeshNode::* TGetCoord)() const;
+  typedef const char* TName;
+  typedef const char* TUnit;
+  
+  TUnit aUnit[3] = {"m","m","m"};
+
+  TGetCoord aXYZGetCoord[3] = {
+    &SMDS_MeshNode::X, 
+    &SMDS_MeshNode::Y, 
+    &SMDS_MeshNode::Z
+  };
+  TName aXYZName[3] = {"x","y","z"};
+  
+  
+  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"};
+
+
+  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;
+  
 }
 
-
-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(){
-    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;
-
-
-void DriverMED_W_SMESHDS_Mesh::Add()
+  
+Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
 {
+  Status aResult = DRS_OK;
   if (myMesh->hasConstructionEdges() || myMesh->hasConstructionFaces()) {
     INFOS("SMDS_MESH with hasConstructionEdges() or hasConstructionFaces() do not supports!!!");
-    return;
+    return DRS_FAIL;
   }
   try{
-    using namespace MEDA;
-    using namespace boost;
-
-    MESSAGE("Add - myFile : "<<myFile);
-    TWrapper aMed(myFile);
+    MESSAGE("Perform - myFile : "<<myFile);
 
     // Creating the MED mesh for corresponding SMDS structure
     //-------------------------------------------------------
@@ -248,7 +220,7 @@ void DriverMED_W_SMESHDS_Mesh::Add()
     }
 
     // Mesh dimension definition
-    med_int aMeshDimension;
+    TInt aMeshDimension;
     TCoordHelperPtr aCoordHelperPtr;
     {  
       bool anIsXDimension = false;
@@ -276,10 +248,9 @@ void DriverMED_W_SMESHDS_Mesh::Add()
 	}
 
 	double EPS = 1.0E-7;
-	anIsXDimension = (aBounds[1] - aBounds[0]) > EPS;
-	anIsYDimension = (aBounds[3] - aBounds[2]) > EPS;
-	anIsZDimension = (aBounds[5] - aBounds[4]) > EPS;
-
+	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;
@@ -310,9 +281,9 @@ void DriverMED_W_SMESHDS_Mesh::Add()
     }
 
     
-    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
     //-----------------------------------
@@ -329,16 +300,12 @@ void DriverMED_W_SMESHDS_Mesh::Add()
     if (myDoGroupOfVolumes)
       myVolumesDefaultFamilyId = REST_VOLUMES_FAMILY;
 
-    MESSAGE("Add - aFamilyInfo");
+    MESSAGE("Perform - aFamilyInfo");
     map<const SMDS_MeshElement *, int> anElemFamMap;
     list<DriverMED_FamilyPtr> aFamilies;
     if (myAllSubMeshes) {
-      SMESHDS_Mesh* aSMESHDSMesh = dynamic_cast<SMESHDS_Mesh*>(myMesh);
-      if (!aSMESHDSMesh) {
-        EXCEPTION(runtime_error,"Can not cast SMDS_Mesh to SMESHDS_Mesh");
-      }
       aFamilies = DriverMED_Family::MakeFamilies
-        (aSMESHDSMesh->SubMeshes(), myGroups,
+        (myMesh->SubMeshes(), myGroups,
          myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
     } else {
       aFamilies = DriverMED_Family::MakeFamilies
@@ -349,8 +316,8 @@ void DriverMED_W_SMESHDS_Mesh::Add()
 
     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();
@@ -365,15 +332,15 @@ void DriverMED_W_SMESHDS_Mesh::Add()
     // 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();
@@ -390,44 +357,44 @@ void DriverMED_W_SMESHDS_Mesh::Add()
 
     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);
-    MESSAGE("Add - aNodeInfo->GetNbElem() = "<<aNbElems);
-    aMed.SetNodeInfo(aNodeInfo);
+    PNodeInfo aNodeInfo = myMed->CrNodeInfo(aMeshInfo,
+					    SMDS_COORDINATE_SYSTEM,
+					    aCoordinates,
+					    aCoordNames,
+					    aCoordUnits,
+					    aFamilyNums,
+					    anElemNums);
+    MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems);
+    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
       SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator();
-      med_int aNbConnectivity = MED::GetNbConn(SMDS_MED_ENTITY,MED_SEG2,aMeshDimension);
+      TInt aNbConnectivity = MED::GetNbNodes(eSEG2);
       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){
+      for(TInt iElem = 0, iConn = 0; anIter->more(); iElem++, iConn+=aNbConnectivity){
 	const SMDS_MeshEdge* anElem = anIter->next();
 	SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
-	for(med_int iNode = 0; iNode < aNbConnectivity && aNodesIter->more(); iNode++){
+	for(TInt iNode = 0; iNode < aNbConnectivity && aNodesIter->more(); iNode++){
 	  const SMDS_MeshElement* aNode = aNodesIter->next();
 #ifdef _EDF_NODE_IDS_
 	  aConnectivity[iConn+iNode] = aNodeIdMap[aNode->GetID()];
@@ -443,23 +410,23 @@ void DriverMED_W_SMESHDS_Mesh::Add()
           aFamilyNums[iElem] = myEdgesDefaultFamilyId;
       }
       
-      PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
-						 SMDS_MED_ENTITY,
-						 MED_SEG2,
-						 SMDS_MED_CONNECTIVITY,
-						 aConnectivity,
-						 aFamilyNums,
-						 anElemNums);
-      aMed.SetCellInfo(aCellInfo);
+      PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+					      SMDS_MED_ENTITY,
+					      eSEG2,
+					      SMDS_MED_CONNECTIVITY,
+					      aConnectivity,
+					      aFamilyNums,
+					      anElemNums);
+      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;
@@ -467,7 +434,7 @@ void DriverMED_W_SMESHDS_Mesh::Add()
       MED::TIntVector aTriaConn;
       aTriaConn.reserve(aNbElems*aNbTriaConn);
 
-      med_int aNbQuadConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_QUAD4,aMeshDimension);
+      TInt aNbQuadConn = MED::GetNbNodes(eQUAD4);
       MED::TIntVector aQuadElemNums;
       aQuadElemNums.reserve(aNbElems);
       MED::TIntVector aQuadFamilyNums;
@@ -475,49 +442,60 @@ void DriverMED_W_SMESHDS_Mesh::Add()
       MED::TIntVector aQuadConn;
       aQuadConn.reserve(aNbElems*aNbQuadConn);
 
-      for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
+      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;
+          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];
@@ -525,10 +503,16 @@ void DriverMED_W_SMESHDS_Mesh::Add()
 	  (*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())
@@ -536,37 +520,53 @@ void DriverMED_W_SMESHDS_Mesh::Add()
         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("Add - 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,
+						SMDS_MED_CONNECTIVITY,
+						aTriaConn,
+						aTriaFamilyNums,
+						anTriaElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTRIA3<<"; 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("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_QUAD4<<"; aNbElems = "<<aNbElems);
-	aMed.SetCellInfo(aCellInfo);
+      if(TInt aNbElems = aQuadElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						eQUAD4,
+						SMDS_MED_CONNECTIVITY,
+						aQuadConn,
+						aQuadFamilyNums,
+						aQuadElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eQUAD4<<"; aNbElems = "<<aNbElems);
+	myMed->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,
+                                                        SMDS_MED_CONNECTIVITY,
+                                                        aPolygoneConn,
+                                                        aPolygoneInds,
+                                                        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;
@@ -574,7 +574,7 @@ void DriverMED_W_SMESHDS_Mesh::Add()
       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;
@@ -582,7 +582,7 @@ void DriverMED_W_SMESHDS_Mesh::Add()
       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;
@@ -590,7 +590,7 @@ void DriverMED_W_SMESHDS_Mesh::Add()
       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;
@@ -598,74 +598,111 @@ void DriverMED_W_SMESHDS_Mesh::Add()
       MED::TIntVector aHexaConn;
       aHexaConn.reserve(aNbElems*aNbHexaConn);
 
-      for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
+      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;
+          }
+
+          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]);
@@ -673,49 +710,66 @@ void DriverMED_W_SMESHDS_Mesh::Add()
           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("Add - 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,
+						SMDS_MED_CONNECTIVITY,
+						aTetraConn,
+						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,
+						SMDS_MED_CONNECTIVITY,
+						aPyraConn,
+						aPyraFamilyNums,
+						anPyraElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePYRA5<<"; 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("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PYRA5<<"; aNbElems = "<<aNbElems);
-	aMed.SetCellInfo(aCellInfo);
+      if(TInt aNbElems = anPentaElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						ePENTA6,
+						SMDS_MED_CONNECTIVITY,
+						aPentaConn,
+						aPentaFamilyNums,
+						anPentaElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePENTA6<<"; 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("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PENTA6<<"; aNbElems = "<<aNbElems);
-	aMed.SetCellInfo(aCellInfo);
+      if(TInt aNbElems = aHexaElemNums.size()){
+	PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+						SMDS_MED_ENTITY,
+						eHEXA8,
+						SMDS_MED_CONNECTIVITY,
+						aHexaConn,
+						aHexaFamilyNums,
+						aHexaElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eHEXA8<<"; 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("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_HEXA8<<"; aNbElems = "<<aNbElems);
-	aMed.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,
+                                                        SMDS_MED_CONNECTIVITY,
+                                                        aPolyedreConn,
+                                                        aPolyedreFaces,
+                                                        aPolyedreInds,
+                                                        aPolyedreFamilyNums,
+                                                        aPolyedreElemNums);
+	MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePOLYEDRE<<"; aNbElems = "<<aNbElems);
+	myMed->SetPolyedreInfo(aCellInfo);
       }
     }
   }catch(const std::exception& exc){
@@ -727,4 +781,5 @@ void DriverMED_W_SMESHDS_Mesh::Add()
   myMeshId = -1;
   myGroups.clear();
   mySubMeshes.clear();
+  return aResult;
 }