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=5b77395aa7603aa328f51419e0ba24ac0a7ddc9d;hp=e17c1d84de34eac15bb18b20afb9c3af10fd7a29;hb=c3bf92bd87b770fd81631a3853f7f5bb1ac6a4e8;hpb=2a01836df7e8236c96093b7e2f85b567966078dc

diff --git a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
index e17c1d84d..5b77395aa 100644
--- a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
+++ b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
@@ -24,73 +24,103 @@
 //  File   : DriverMED_W_SMESHDS_Mesh.cxx
 //  Module : SMESH
 
-using namespace std;
 #include "DriverMED_W_SMESHDS_Mesh.h"
 #include "DriverMED_W_SMDS_Mesh.h"
+#include "DriverMED_Family.h"
 
 #include "SMDS_MeshElement.hxx"
 #include "SMDS_MeshNode.hxx"
-#include "SMDS_MeshFacesIterator.hxx"
-#include "SMDS_MeshEdgesIterator.hxx"
-#include "SMDS_MeshNodesIterator.hxx"
-#include "SMDS_MeshVolumesIterator.hxx"
-#include "SMESHDS_SubMesh.hxx"
-#include "SMDS_MapIteratorOfExtendedMap.hxx"
-#include "SMDS_MapOfMeshElement.hxx"
-#include "SMDS_Position.hxx"
-
-#include <TopExp.hxx>
-#include <TopExp_Explorer.hxx>
-#include <TopoDS.hxx>
-#include <TopoDS_Iterator.hxx>
-#include <TopoDS_Compound.hxx>
-#include <TopoDS_CompSolid.hxx>
-#include <TopoDS_Solid.hxx>
-#include <TopoDS_Shell.hxx>
-#include <TopoDS_Face.hxx>
-#include <TopoDS_Wire.hxx>
-#include <TopoDS_Edge.hxx>
-#include <TopoDS_Vertex.hxx>
-#include <TopoDS_Shape.hxx>
-#include <TopTools_MapOfShape.hxx>
-#include <TColStd_ListIteratorOfListOfInteger.hxx>
-
-
-#include <map>
-#include <set>
-#include <vector>
 #include "utilities.h"
 
-DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh() {
-  ;
+#include "MEDA_Wrapper.hxx"
+#include <sstream>	
+
+#include "MED_Utilities.hxx"
+
+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)
+{
 }
 
-DriverMED_W_SMESHDS_Mesh::~DriverMED_W_SMESHDS_Mesh() {
-  ;
+DriverMED_W_SMESHDS_Mesh::~DriverMED_W_SMESHDS_Mesh()
+{
 }
 
-void DriverMED_W_SMESHDS_Mesh::SetMesh(Handle(SMDS_Mesh)& aMesh) {
+void DriverMED_W_SMESHDS_Mesh::SetMesh(SMDS_Mesh * aMesh)
+{
   myMesh = aMesh;
 }
 
-void DriverMED_W_SMESHDS_Mesh::SetFile(string aFile) {
+void DriverMED_W_SMESHDS_Mesh::SetFile(string aFile)
+{
   myFile = aFile;
 }
 
-void DriverMED_W_SMESHDS_Mesh::SetFileId(med_idt aFileId) {
+void DriverMED_W_SMESHDS_Mesh::SetFileId(med_idt aFileId)
+{
   myFileId = aFileId;
 }
 
-void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId) {
+void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId)
+{
   myMeshId = aMeshId;
 }
 
-void DriverMED_W_SMESHDS_Mesh::Write() {
+void DriverMED_W_SMESHDS_Mesh::SetMeshName(string theMeshName)
+{
+  myMeshName = theMeshName;
+}
+
+void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_Group* theGroup)
+{
+  myGroups.push_back(theGroup);
+}
+
+void DriverMED_W_SMESHDS_Mesh::AddAllSubMeshes()
+{
+  myAllSubMeshes = true;
+}
+
+void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int theID)
+{
+  mySubMeshes[theID] = theSubMesh;
+}
+
+void DriverMED_W_SMESHDS_Mesh::AddGroupOfNodes()
+{
+  myDoGroupOfNodes = true;
+}
+
+void DriverMED_W_SMESHDS_Mesh::AddGroupOfEdges()
+{
+  myDoGroupOfEdges = true;
+}
 
+void DriverMED_W_SMESHDS_Mesh::AddGroupOfFaces()
+{
+  myDoGroupOfFaces = true;
+}
+
+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;
+  DriverMED_W_SMDS_Mesh *myWriter = new DriverMED_W_SMDS_Mesh;
 
   myWriter->SetMesh(myMesh);
   //  myWriter->SetFile(myFile);
@@ -98,565 +128,408 @@ void DriverMED_W_SMESHDS_Mesh::Write() {
   myWriter->SetFileId(myFileId);
 
   myWriter->Write();
-
-
 }
 
-void DriverMED_W_SMESHDS_Mesh::Add() {
-
-  med_err ret = 0;
-  int i,j,k,l;
-  int numero;
-  char message[200];
-  Standard_Boolean ok;
-  /* nombre d'objets MED */
-  char nom_universel[MED_TAILLE_LNOM+1];
-  med_int long_fichier_en_tete;
-  char *fichier_en_tete;
-  char version_hdf[10];
-  char version_med[10];
-  med_int nmaa,mdim,nnoe;
-  med_int nmai[MED_NBR_GEOMETRIE_MAILLE],nfac[MED_NBR_GEOMETRIE_FACE];
-  med_int nare[MED_NBR_GEOMETRIE_ARETE];
-  /* nom du maillage */
-  char nommaa[MED_TAILLE_NOM+1];
-  /* noeuds */
-  med_float *coo;
-  // PN : Initilialisation de nomcoo et unicoo pour lisibilite du maillage
-  char nomcoo[3*MED_TAILLE_PNOM+1]="x       y        z      ";
-  char unicoo[3*MED_TAILLE_PNOM+1]="m       m        m     ";
-  char *nomnoe;
-  med_int *numnoe;
-  med_int *nufano;
-  med_repere rep;
-  med_booleen inonoe,inunoe;
-  med_mode_switch mode_coo;
-  char str[MED_TAILLE_PNOM+1];
-  med_int nbNodes;
-  /* elements */
-  med_int nsup;
-  med_int edim;
-  med_int taille;
-  med_int elem_id,myId;
-  med_int *connectivite;
-  char *nomele;
-  med_int *numele;
-  med_int *nufael;
-  med_booleen inoele, inuele;
-  med_connectivite typ_con;
-  med_geometrie_element typgeo;
-  med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2,
-							    MED_SEG3,MED_TRIA3,
-							    MED_TRIA6,MED_QUAD4,
-							    MED_QUAD8,MED_TETRA4,
-							    MED_TETRA10,MED_HEXA8,
-							    MED_HEXA20,MED_PENTA6,
-							    MED_PENTA15,MED_PYRA5,
-							    MED_PYRA13};
-  med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5};
-  med_int nmailles[MED_NBR_GEOMETRIE_MAILLE];
-  char nommai[MED_NBR_GEOMETRIE_MAILLE] [MED_TAILLE_NOM+1] = {"MED_POINT1",
-							      "MED_SEG2",
-							      "MED_SEG3",
-							      "MED_TRIA3",
-							      "MED_TRIA6",
-							      "MED_QUAD4",
-							      "MED_QUAD8",
-							      "MED_TETRA4",
-							      "MED_TETRA10",
-							      "MED_HEXA8",
-							      "MED_HEXA20",
-							      "MED_PENTA6",
-							      "MED_PENTA15",
-							      "MED_PYRA5",
-							      "MED_PYRA13"};
-  med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6,
-							  MED_QUAD4,MED_QUAD8};
-  med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4};
-  med_int nfaces[MED_NBR_GEOMETRIE_FACE];
-  char nomfac[MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] = {"MED_TRIA3","MED_TRIA6",
-							   "MED_QUAD4","MED_QUAD8"};
-  med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3};
-  med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3};
-  med_int naretes[MED_NBR_GEOMETRIE_ARETE];
-  char nomare[MED_NBR_GEOMETRIE_ARETE] [MED_TAILLE_NOM+1] = {"MED_SEG2","MED_SEG3"};
-
-  typ_con = MED_NOD;
-  mode_coo = MED_FULL_INTERLACE;
-  numero = myMeshId;
-
-  //---- provisoire : switch pour ecrire les familles de mailles
-  int besoinfamilledemaille=1;
-  //---- provisoire : switch pour ecrire les familles de mailles
-
-  /****************************************************************************
-   *                      OUVERTURE DU FICHIER EN ECRITURE                    *
-   ****************************************************************************/
-  char* file2Read = (char*)myFile.c_str();
-
-  MESSAGE ( " file2Read " << file2Read )
-
-    myFileId = MEDouvrir(file2Read,MED_REMP);
-  if (myFileId < 0)
-    {
-      fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",file2Read);
-      exit(EXIT_FAILURE);
-    }
-
-  /****************************************************************************
-   *                       NOMBRES D'OBJETS MED                               *
-   ****************************************************************************/
-  MESSAGE("(****************************)");
-  MESSAGE("(* INFORMATIONS GENERALES : *)");
-  MESSAGE("(****************************)");
-
-  /* calcul de la dimension */
-  mdim=2;
-  double epsilon=0.00001;
-  double nodeRefX;
-  double nodeRefY;
-  double nodeRefZ;
-
-  bool dimX = true;
-  bool dimY = true;
-  bool dimZ = true;
-
-  SMDS_MeshNodesIterator myItNodes(myMesh);
-  int inode = 0;
-  for (;myItNodes.More();myItNodes.Next()) {
-    const Handle(SMDS_MeshElement)& elem = myItNodes.Value();
-    const Handle(SMDS_MeshNode)& node = myMesh->GetNode(1,elem);
-    if ( inode == 0 ) {
-      nodeRefX = fabs(node->X());
-      nodeRefY = fabs(node->Y());
-      nodeRefZ = fabs(node->Z());
-    }
-    SCRUTE( inode );
-    SCRUTE( nodeRefX );
-    SCRUTE( nodeRefY );
-    SCRUTE( nodeRefZ );
-
-    if ( inode !=0 ) {
-      if ( (fabs(fabs(node->X()) - nodeRefX) > epsilon ) && dimX )
-	dimX = false;
-      if ( (fabs(fabs(node->Y()) - nodeRefY) > epsilon ) && dimY )
-	dimY = false;
-      if ( (fabs(fabs(node->Z()) - nodeRefZ) > epsilon ) && dimZ )
-	dimZ = false;
+void DriverMED_W_SMESHDS_Mesh::Add()
+{
+  if (myMesh->hasConstructionEdges() || myMesh->hasConstructionFaces()) {
+    INFOS("SMDS_MESH with hasConstructionEdges() or hasConstructionFaces() do not supports!!!");
+    return;
+  }
+  try{
+    using namespace MEDA;
+    using namespace boost;
+
+    MESSAGE("Add - myFile : "<<myFile);
+    TWrapper aMed(myFile);
+
+    // Creating the MED mesh for corresponding SMDS structure
+    //-------------------------------------------------------
+    string aMeshName;
+    if (myMeshId != -1) {
+      ostringstream aMeshNameStr;
+      aMeshNameStr<<myMeshId;
+      aMeshName = aMeshNameStr.str();
+    } else {
+      aMeshName = myMeshName;
     }
-    if ( !dimX && !dimY && !dimZ ) {
-      mdim = 3;
-      break;
+    const int SMDS_MESH_DIM = 3;
+    PMeshInfo aMeshInfo = TWrapper::CrMeshInfo(SMDS_MESH_DIM,aMeshName);
+    MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
+    aMed.SetMeshInfo(aMeshInfo);
+
+    // Storing SMDS groups and sub-meshes
+    //-----------------------------------
+    int myNodesDefaultFamilyId = 0;
+    int myEdgesDefaultFamilyId = 0;
+    int myFacesDefaultFamilyId = 0;
+    int myVolumesDefaultFamilyId = 0;
+    if (myDoGroupOfNodes)
+      myNodesDefaultFamilyId = REST_NODES_FAMILY;
+    if (myDoGroupOfEdges)
+      myEdgesDefaultFamilyId = REST_EDGES_FAMILY;
+    if (myDoGroupOfFaces)
+      myFacesDefaultFamilyId = REST_FACES_FAMILY;
+    if (myDoGroupOfVolumes)
+      myVolumesDefaultFamilyId = REST_VOLUMES_FAMILY;
+
+    MESSAGE("Add - 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,
+         myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
+    } else {
+      aFamilies = DriverMED_Family::MakeFamilies
+        (mySubMeshes, myGroups,
+         myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
     }
-    inode++;
-  }
+    list<DriverMED_FamilyPtr>::iterator aFamsIter = aFamilies.begin();
 
-  if ( mdim != 3 ) {
-    if ( dimX && dimY && dimZ )
-      mdim = 0;
-    else if ( !dimX ) {
-      if ( dimY && dimZ )
-	mdim = 1;
-      else if (( dimY && !dimZ ) || ( !dimY && dimZ ) )
-	mdim = 2;
-    } else if ( !dimY ) {
-      if ( dimX && dimZ )
-	mdim = 1;
-      else if (( dimX && !dimZ ) || ( !dimX && dimZ ) )
-	mdim = 2;
-    } else if ( !dimZ ) {
-      if ( dimY && dimX )
-	mdim = 1;
-      else if (( dimY && !dimX ) || ( !dimY && dimX ) )
-	mdim = 2;
+    for (; aFamsIter != aFamilies.end(); aFamsIter++)
+    {
+      PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(aMeshInfo);
+      aMed.SetFamilyInfo(aFamilyInfo);
+      int aFamId = (*aFamsIter)->GetId();
+
+      const set<const SMDS_MeshElement *>& anElems = (*aFamsIter)->GetElements();
+      set<const SMDS_MeshElement *>::iterator anElemsIter = anElems.begin();
+      for (; anElemsIter != anElems.end(); anElemsIter++)
+      {
+        anElemFamMap[*anElemsIter] = aFamId;
+      }
+//      delete (*aFamsIter);
     }
-  }
-
-  MESSAGE ( " mdim " << mdim );
-
-  /* creation du maillage */
-  //mdim=3;
-  sprintf(nommaa,"Mesh %d",numero);
-  SCRUTE(nommaa);
-  ret = MEDmaaCr(myFileId,nommaa,mdim);
-
-  ASSERT(ret == 0);
-  SCRUTE( ret );
-
-  /* Combien de noeuds ? */
-  nnoe = myMesh->NbNodes();
-  //SCRUTE(nnoe);
-  /* Combien de mailles, faces ou aretes ? */
-  for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
-    nmailles[i]=0;
 
-  Standard_Integer nb_of_nodes, nb_of_faces, nb_of_edges;
-  vector<int> elem_Id[MED_NBR_GEOMETRIE_MAILLE];
-
-  SMDS_MeshEdgesIterator itEdges(myMesh);
-  nb_of_edges = myMesh->NbEdges();
-  for (;itEdges.More();itEdges.Next()) {
-    const Handle(SMDS_MeshElement)& elem = itEdges.Value();
-
-    nb_of_nodes = elem->NbNodes();
-
-    switch (nb_of_nodes) {
-    case 2 : {
-      elem_Id[1].push_back(elem->GetID());
-      nmailles[1]++;
-      break;
-    }
-    case 3 : {
-      elem_Id[2].push_back(elem->GetID());
-      nmailles[2]++;
-      break;
-    }
+    // Storing SMDS nodes to the MED file for the MED mesh
+    //----------------------------------------------------
+    typedef map<med_int,med_int> TNodeIdMap;
+    TNodeIdMap aNodeIdMap;
+
+    med_int aNbElems = myMesh->NbNodes();
+    MED::TIntVector anElemNums(aNbElems);
+    MED::TIntVector aFamilyNums(aNbElems);
+    MED::TFloatVector aCoordinates(aNbElems*SMDS_MESH_DIM);
+    SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
+    for(med_int iNode = 0, iCoord = 0; aNodesIter->more(); iNode++, iCoord+=SMDS_MESH_DIM){
+      const SMDS_MeshNode* aNode = aNodesIter->next();
+      aCoordinates[iCoord] = aNode->X();
+      aCoordinates[iCoord+1] = aNode->Y();
+      aCoordinates[iCoord+2] = aNode->Z();
+      TNodeIdMap::key_type aNodeId = aNode->GetID();
+      anElemNums[iNode] = aNodeId;
+      aNodeIdMap[aNodeId] = iNode+1;
+      //cout<<aNode->GetID()<<": "<<aNode->X()<<", "<<aNode->Y()<<", "<<aNode->Z()<<endl;
+
+      if (anElemFamMap.find(aNode) != anElemFamMap.end())
+        aFamilyNums[iNode] = anElemFamMap[aNode];
+      else
+        aFamilyNums[iNode] = myNodesDefaultFamilyId;
     }
-  }
-
-
-  SMDS_MeshFacesIterator itFaces(myMesh);
-  nb_of_faces = myMesh->NbFaces();
-  for (;itFaces.More();itFaces.Next()) {
-    const Handle(SMDS_MeshElement)& elem = itFaces.Value();
 
-    nb_of_nodes = elem->NbNodes();
+    MED::TStringVector aCoordNames(3);
+    aCoordNames[0] = "x";  aCoordNames[1] = "y";  aCoordNames[2] = "z";
+
+    MED::TStringVector aCoordUnits(3);
+    aCoordUnits[0] = "m";  aCoordUnits[1] = "m";  aCoordUnits[2] = "m";
+
+    const med_repere SMDS_COORDINATE_SYSTEM = MED_CART;
+
+    PNodeInfo aNodeInfo = TWrapper::CrNodeInfo(aMeshInfo,
+					       SMDS_COORDINATE_SYSTEM,
+					       aCoordinates,
+					       aCoordNames,
+					       aCoordUnits,
+					       aFamilyNums,
+					       anElemNums);
+    MESSAGE("Add - aNodeInfo->GetNbElem() = "<<aNbElems);
+    aMed.SetNodeInfo(aNodeInfo);
+
+
+    // Storing others SMDS elements to the MED file for the MED mesh
+    //--------------------------------------------------------------
+    const med_entite_maillage SMDS_MED_ENTITY = MED_MAILLE;
+    const med_connectivite SMDS_MED_CONNECTIVITY = MED_NOD;
+
+    // Storing SMDS Edges
+    if(med_int aNbElems = myMesh->NbEdges()){
+      SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator();
+      med_int aNbConnectivity = MED::GetNbConn(SMDS_MED_ENTITY,MED_SEG2,SMDS_MESH_DIM);
+      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){
+	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();
+	  aConnectivity[iConn+iNode] = aNodeIdMap[aNode->GetID()];
+	}
+	anElemNums[iElem] = anElem->GetID();
 
-    switch (nb_of_nodes) {
-    case 3 : {
-      elem_Id[3].push_back(elem->GetID());
-      nmailles[3]++;
-      break;
-    }
-    case 4 : {
-      elem_Id[5].push_back(elem->GetID());
-      nmailles[5]++;
-      break;
-    }
-    case 6 : {
-      elem_Id[4].push_back(elem->GetID());
-      nmailles[4]++;
-      break;
-    }
+        if (anElemFamMap.find(anElem) != anElemFamMap.end())
+          aFamilyNums[iElem] = anElemFamMap[anElem];
+        else
+          aFamilyNums[iElem] = myEdgesDefaultFamilyId;
+      }
+      
+      PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
+						 SMDS_MED_ENTITY,
+						 MED_SEG2,
+						 SMDS_MED_CONNECTIVITY,
+						 aConnectivity,
+						 aFamilyNums,
+						 anElemNums);
+      aMed.SetCellInfo(aCellInfo);
     }
 
-  }
+    // Storing SMDS Faces
+    if(med_int aNbElems = myMesh->NbFaces()){
+      SMDS_FaceIteratorPtr anIter = myMesh->facesIterator();
+
+      med_int aNbTriaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TRIA3,SMDS_MESH_DIM);
+      MED::TIntVector anTriaElemNums; 
+      anTriaElemNums.reserve(aNbElems);
+      MED::TIntVector aTriaFamilyNums;
+      aTriaFamilyNums.reserve(aNbElems);
+      MED::TIntVector aTriaConn;
+      aTriaConn.reserve(aNbElems*aNbTriaConn);
+
+      med_int aNbQuadConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_QUAD4,SMDS_MESH_DIM);
+      MED::TIntVector aQuadElemNums;
+      aQuadElemNums.reserve(aNbElems);
+      MED::TIntVector aQuadFamilyNums;
+      aQuadFamilyNums.reserve(aNbElems);
+      MED::TIntVector aQuadConn;
+      aQuadConn.reserve(aNbElems*aNbQuadConn);
+
+      for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
+	const SMDS_MeshFace* 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 3:
+	  aNbConnectivity = aNbTriaConn;
+	  anElemNums = &anTriaElemNums;
+	  aFamilyNums = &aTriaFamilyNums;
+	  aConnectivity = &aTriaConn;
+	  break;
+	case 4:
+	  aNbConnectivity = aNbQuadConn;
+	  anElemNums = &aQuadElemNums;
+	  aFamilyNums = &aQuadFamilyNums;
+	  aConnectivity = &aQuadConn;
+	  break;
+	}
+	MED::TIntVector aVector(aNbNodes);
+	for(med_int iNode = 0; aNodesIter->more(); iNode++){
+	  const SMDS_MeshElement* aNode = aNodesIter->next();
+	  aVector[iNode] = aNode->GetID();
+	}
 
-  SMDS_MeshVolumesIterator itVolumes(myMesh);
-  for (;itVolumes.More();itVolumes.Next()) {
-    const Handle(SMDS_MeshElement)& elem = itVolumes.Value();
+	med_int aSize = aConnectivity->size();
+	aConnectivity->resize(aSize+aNbConnectivity);
+	// There is some differnce between SMDS and MED in cells mapping
+	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]];
+	}
+	anElemNums->push_back(anElem->GetID());
 
-    nb_of_nodes = elem->NbNodes();
-    switch (nb_of_nodes) {
-    case 8 : {
-      elem_Id[9].push_back(elem->GetID());
-      nmailles[9]++;
-      break;
-    }
+        if (anElemFamMap.find(anElem) != anElemFamMap.end())
+          aFamilyNums->push_back(anElemFamMap[anElem]);
+        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(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);
+      }
     }
-  }
-
-
 
-  /****************************************************************************
-   *                       ECRITURE DES NOEUDS                                *
-   ****************************************************************************/
-  MESSAGE("(************************)");
-  MESSAGE("(* NOEUDS DU MAILLAGE : *)");
-  MESSAGE("(************************)");
-
-  /* Allocations memoires */
-  /* table des coordonnees
-     profil : (dimension * nombre de noeuds ) */
-  coo = (med_float*) malloc(sizeof(med_float)*nnoe*mdim);
-  /* table  des numeros, des numeros de familles des noeuds
-     profil : (nombre de noeuds) */
-  numnoe = (med_int*) malloc(sizeof(med_int)*nnoe);
-  nufano = (med_int*) malloc(sizeof(med_int)*nnoe);
-  /* table des noms des noeuds
-     profil : (nnoe*MED_TAILLE_PNOM+1) */
-  nomnoe ="";
-
-  /* PN  pour aster, il faut une famille 0 pour les noeuds et une autre pour les elements*/
-  /* PN : Creation de la famille 0 */
-  char * nomfam="FAMILLE_0";
-  char *attdes="";
-  char *gro=0;
-  med_int ngro=0;
-  med_int natt=1;
-  med_int attide = 0;
-  med_int attval=0;
-  med_int numfam = 0;
-  med_int attvalabs=1;
-  ret = MEDfamCr(myFileId,nommaa,nomfam,numfam, &attide,&attval,attdes,natt,gro,ngro);
-  ASSERT(ret == 0);
-
-
-  /* PN : FIN Creation de la famille 0 */
-
-  map < int, int > mapNoeud;
-  typedef pair<set<int>::iterator, bool> IsFamily;
-  int nbFamillesNoeud;
-
-
-  i = 0;
-  set<int> FamilySet;
-  nbFamillesNoeud = 0;
-  int verifienbnoeuds = 0;
-  med_int* rien=0;
-
-  SMDS_MeshNodesIterator itNodes(myMesh);
-  for (;itNodes.More();itNodes.Next())
-    {
-      const Handle(SMDS_MeshElement)& elem = itNodes.Value();
-      const Handle(SMDS_MeshNode)& node = myMesh->GetNode(1,elem);
-
-      if(mdim==3){
-	coo[i*3]=node->X();
-	coo[i*3+1]=node->Y();
-	coo[i*3+2]=node->Z();
-      } else if(mdim==2) {
-	if ( dimX ) {
-	  coo[i*2]=node->Y();
-	  coo[i*2+1]=node->Z();
-	} 
-	if ( dimY ) {
-	  coo[i*2]=node->X();
-	  coo[i*2+1]=node->Z();
-	} 
-	if ( dimZ ) {
-	  coo[i*2]=node->X();
-	  coo[i*2+1]=node->Y();
-	} 
-      } else {
-	if ( dimX ) {
-	  coo[i*2]=node->Y();
-	  coo[i*2+1]=node->Z();
-	} 
-	if ( dimY ) {
-	  coo[i*2]=node->X();
-	  coo[i*2+1]=node->Z();
-	} 
-	if ( dimZ ) {
-	  coo[i*2]=node->X();
-	  coo[i*2+1]=node->Y();
-	} 
-      }
-      mapNoeud[node->GetID()] = i+1;
-
-      // renvoie 0 pour les noeuds internes du volume
-      int numfamille=node->GetPosition()->GetShapeId();
-      nufano[i]=numfamille;
-
-      //SCRUTE(i);
-      //SCRUTE(nufano[i]);
-      //SCRUTE(coo[i*3]);
-      //SCRUTE(coo[i*3+1]);
-      //SCRUTE(coo[i*3+2]);
-      if ( nufano[i] != 0 )
-	{
-	  IsFamily deja = FamilySet.insert(nufano[i]); // insert if new, or gives existant
-	  if (deja.second)                       	      // actually inserted
-	    {
-	      char famille[MED_TAILLE_NOM+1];
-	      sprintf(famille,"F%d",nufano[i]);
-	      //	      CreateFamily(strdup(nommaa),strdup(famille),nufano[i],attvalabs++);
-	      attvalabs++;
-	      CreateFamily(strdup(nommaa),strdup(famille),nufano[i],numfamille);
-	      //MESSAGE("---famille-noeud--- "<<nbFamillesNoeud<<" "<<nufano[i]);
-	      nbFamillesNoeud++;
-	    }
+    // Storing SMDS Volumes
+    if(med_int aNbElems = myMesh->NbVolumes()){
+      SMDS_VolumeIteratorPtr anIter = myMesh->volumesIterator();
+
+      med_int aNbTetraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TETRA4,SMDS_MESH_DIM);
+      MED::TIntVector anTetraElemNums; 
+      anTetraElemNums.reserve(aNbElems);
+      MED::TIntVector aTetraFamilyNums;
+      aTetraFamilyNums.reserve(aNbElems);
+      MED::TIntVector aTetraConn;
+      aTetraConn.reserve(aNbElems*aNbTetraConn);
+
+      med_int aNbPyraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PYRA5,SMDS_MESH_DIM);
+      MED::TIntVector anPyraElemNums; 
+      anPyraElemNums.reserve(aNbElems);
+      MED::TIntVector aPyraFamilyNums;
+      aPyraFamilyNums.reserve(aNbElems);
+      MED::TIntVector aPyraConn;
+      aPyraConn.reserve(aNbElems*aNbPyraConn);
+
+      med_int aNbPentaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PENTA6,SMDS_MESH_DIM);
+      MED::TIntVector anPentaElemNums; 
+      anPentaElemNums.reserve(aNbElems);
+      MED::TIntVector aPentaFamilyNums;
+      aPentaFamilyNums.reserve(aNbElems);
+      MED::TIntVector aPentaConn;
+      aPentaConn.reserve(aNbElems*aNbPentaConn);
+
+      med_int aNbHexaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_HEXA8,SMDS_MESH_DIM);
+      MED::TIntVector aHexaElemNums;
+      aHexaElemNums.reserve(aNbElems);
+      MED::TIntVector aHexaFamilyNums;
+      aHexaFamilyNums.reserve(aNbElems);
+      MED::TIntVector aHexaConn;
+      aHexaConn.reserve(aNbElems*aNbHexaConn);
+
+      for(med_int 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;
 	}
 
-      i++;
-      verifienbnoeuds ++;
-    }
-  ret = MEDnoeudsEcr(myFileId,nommaa,mdim,coo,mode_coo,MED_CART,
-		     nomcoo,unicoo,nomnoe,MED_FAUX,rien,MED_FAUX,
-		     nufano,nnoe,MED_REMP);
-  ASSERT(ret == 0);
-  MESSAGE("--- Creation de " << verifienbnoeuds << " noeuds");
-  ASSERT(verifienbnoeuds == nnoe);
-  MESSAGE("--- Creation de " << nbFamillesNoeud << " familles de noeuds");
-
-  /* liberation memoire */
-  free(coo);
-  free(numnoe);
-  free(nufano);
-
-  /****************************************************************************
-   *                       ECRITURE DES ELEMENTS                              *
-   ****************************************************************************/
-  MESSAGE("(**************************)");
-  MESSAGE("(* ELEMENTS DU MAILLAGE : *)");
-  MESSAGE("(**************************)");
-  
-  /* Ecriture des connectivites, noms, numeros des mailles */
-
-  if (ret == 0)
-    {
-      int nbFamillesElts =0;
-      Handle(SMESHDS_Mesh) mySMESHDSMesh = Handle(SMESHDS_Mesh)::DownCast(myMesh);
-      TopTools_IndexedMapOfShape myIndexToShape;
-      TopExp::MapShapes(mySMESHDSMesh->ShapeToMesh(),myIndexToShape);
-
-      map < int, int > mapFamille;
-
-      if (besoinfamilledemaille == 1)
-	{
-	  int t;
-	  for (t =1; t <= myIndexToShape.Extent(); t++)
-	    {
-	      const TopoDS_Shape S = myIndexToShape(t);
-	      if (mySMESHDSMesh->HasMeshElements(S))
-		{
-		  //MESSAGE ("********* Traitement de la Famille "<<-t);
-		
-		  Handle(SMESHDS_SubMesh) SM = mySMESHDSMesh->MeshElements(S);
-		  const TColStd_ListOfInteger& indElt = SM->GetIDElements();
-		  TColStd_ListIteratorOfListOfInteger ite(indElt);
-		
-		  bool plein=false;
-		  for (; ite.More(); ite.Next())
-		    {
-		      int eltId = ite.Value();
-		      mapFamille [eltId] = - t;
-		      plein=true;
-		    }
-		  if (plein)
-		    {
-		      nbFamillesElts++;
-		      char famille[MED_TAILLE_NOM+1];
-		      sprintf(famille,"E%d",t);
-		      CreateFamily(strdup(nommaa),strdup(famille),-t,attvalabs++);
-		    }
-		}
-	    }
+	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
+	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]];
 	}
+	anElemNums->push_back(anElem->GetID());
 
-      int indice=1;
-      for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
-	{
-	  if (nmailles[i] > 0 && ret == 0)
-	    {
-	      MESSAGE ( " Start "<<typmai[i]);
-	
-	      /* dimension de la maille */
-	      edim = typmai[i] / 100;
-	      nsup = 0;
-	      if (mdim  == 2 || mdim == 3)
-		if (edim == 1) nsup = 1;
-	      if (mdim == 3)
-		if (edim == 2) nsup = 1;
-	      //SCRUTE(nsup);
-	
-	      taille = nsup+typmai[i]%100;
-	      //SCRUTE(taille);
-	
-	      /* allocation memoire */
-	      connectivite = (med_int*)malloc(sizeof(med_int)* taille*nmailles[i]);
-	      nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM* nmailles[i]+1);
-	      numele = (med_int*)malloc(sizeof(med_int)* nmailles[i]);
-	      nufael = (med_int*)malloc(sizeof(med_int)* nmailles[i]);
-	      nomele="";
-	      nbNodes=typmai[i]%100;
-	
-	      for (j=0;j<nmailles[i];j++)
-		{
-		  myId = elem_Id[i][j];
-		  const Handle(SMDS_MeshElement)& elem = myMesh->FindElement(myId);
-		  //*(numele+j) = myId;
-		  *(numele+j) = indice ++;
-		
-		  for (k=0; k<nbNodes; k++)
-		    {
-		      *(connectivite+j*taille+k) = mapNoeud[elem->GetConnection(k+1)];
-		      //SCRUTE(*(connectivite+j*taille+k));
-		    }
-		  if (nsup) *(connectivite+j*taille + nbNodes) = 0;
-		
-		  if (besoinfamilledemaille == 1)
-		    {
-		      if (mapFamille.find(myId)!=mapFamille.end())
-			{
-			  nufael[j]=mapFamille[myId];
-			}
-		      else
-			{
-			  nufael[j]=0;
-			}
-		    }
-		  else
-		    {
-		      nufael[j]=0;
-		    }
-		
-		  //SCRUTE(myId);
-		  //SCRUTE(j);
-		  //SCRUTE(nufael[j]);
-		}
-	
-	      /* ecriture des données */
-		
-		    med_int* rien=0;
-		    ret=MEDelementsEcr( myFileId,nommaa,mdim,connectivite,mode_coo,nomele,MED_FAUX,numele,
-					MED_VRAI,nufael,nmailles[i],MED_MAILLE,typmai[i],typ_con,MED_REMP);
-		    ASSERT(ret == 0);
-		    //SCRUTE(ret);
-		
-		    if (ret < 0) MESSAGE(">> ERREUR : ecriture des mailles \n");
-		
-		    /* liberation memoire */
-		    free(connectivite);
-		    free(numele);
-		    free(nufael);
-		    MESSAGE ( " End "<<typmai[i]);
-	    }
-      };
-	  MESSAGE("--- Creation de " << nbFamillesElts << " familles d elements");
+        if (anElemFamMap.find(anElem) != anElemFamMap.end())
+          aFamilyNums->push_back(anElemFamMap[anElem]);
+        else
+          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(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(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(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);
+      }
     }
+  }catch(const std::exception& exc){
+    INFOS("Follow exception was cought:\n\t"<<exc.what());
+  }catch(...){
+    INFOS("Unknown exception was cought !!!");
+  }
 
-      /****************************************************************************
-      *                      FERMETURE DU FICHIER                                *
-      ****************************************************************************/
-
-      ret = MEDfermer(myFileId);
-
-      if (ret != 0)
-	fprintf(stderr,">> ERREUR : erreur a la fermeture du fichier %s\n",file2Read);
-      MESSAGE ("fichier ferme");
-
-
-}
-
-void DriverMED_W_SMESHDS_Mesh::CreateFamily(char* nommaa, char* famille, int i,med_int k) {
-
-  med_int ngro=0;
-  med_int natt;
-
-  natt=1;
-  char attdes[MED_TAILLE_DESC+1];
-  char gro[MED_TAILLE_LNOM+1];
-  char fam2[MED_TAILLE_LNOM+1];
-
-  strcpy(attdes,"");
-  strcpy(gro,"");
-  strcpy(fam2,famille);
-
-  med_int * attide=new med_int[1];
-  med_int * attval=new med_int[1];
-  attide[0] = k;
-  attval[0] = k;
-
-
-  //MESSAGE("-------- Creation de la Famille : "<< famille << "numero " << i << " --------------");
-  med_int ret = MEDfamCr(myFileId, nommaa, fam2, i, attide, attval, attdes, natt, gro, ngro);
-  ASSERT(ret==0);
-  delete [] attide;
-  delete [] attval;
-
+  myMeshId = -1;
+  myGroups.clear();
+  mySubMeshes.clear();
 }
-
-
-