Salome HOME
Merge br_enable_import_mesh. Enable import mesh and save/load SMESH study.
authorjrt <jrt>
Mon, 15 Mar 2004 18:42:16 +0000 (18:42 +0000)
committerjrt <jrt>
Mon, 15 Mar 2004 18:42:16 +0000 (18:42 +0000)
44 files changed:
idl/SMESH_Gen.idl
idl/SMESH_Mesh.idl
src/Driver/Document_Reader.cxx
src/Driver/Document_Reader.h
src/Driver/Document_Writer.cxx
src/Driver/Document_Writer.h
src/Driver/Makefile.in
src/Driver/SMESHDriver.cxx
src/Driver/SMESHDriver.h
src/DriverDAT/DriverDAT_R_SMDS_Mesh.cxx
src/DriverDAT/DriverDAT_W_SMDS_Mesh.cxx
src/DriverDAT/Makefile.in
src/DriverMED/DriverMED_R_SMESHDS_Document.cxx
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
src/DriverMED/Makefile.in
src/DriverUNV/DriverUNV_R_SMDS_Mesh.cxx
src/DriverUNV/DriverUNV_W_SMDS_Mesh.cxx
src/DriverUNV/Makefile.in
src/SMDS/SMDS_Mesh.cxx
src/SMDS/SMDS_Mesh.hxx
src/SMESH/Makefile.in
src/SMESH/SMESH_Gen.cxx
src/SMESH/SMESH_Gen.hxx
src/SMESH/SMESH_Mesh.cxx
src/SMESH/SMESH_Mesh.hxx
src/SMESHDS/SMESHDS_Command.hxx
src/SMESHDS/SMESHDS_CommandType.hxx
src/SMESHDS/SMESHDS_Hypothesis.cxx
src/SMESHDS/SMESHDS_Hypothesis.hxx
src/SMESHDS/SMESHDS_Mesh.cxx
src/SMESHDS/SMESHDS_Mesh.hxx
src/SMESHDS/SMESHDS_Script.cxx
src/SMESHDS/SMESHDS_Script.hxx
src/SMESHGUI/Makefile.in
src/SMESHGUI/SMESHGUI.cxx
src/SMESHGUI/SMESHGUI.h
src/SMESHGUI/SMESHGUI_StudyAPI.cxx
src/SMESH_I/SMESH_Gen_i.cxx
src/SMESH_I/SMESH_Gen_i.hxx
src/SMESH_I/SMESH_Hypothesis_i.cxx
src/SMESH_I/SMESH_Hypothesis_i.hxx
src/SMESH_I/SMESH_Mesh_i.cxx
src/SMESH_I/SMESH_Mesh_i.hxx

index c30750b..82136fe 100644 (file)
@@ -104,7 +104,13 @@ module SMESH
     //                          in shape_array listOfSubShape)
     //  raises (SALOME::SALOME_Exception);
     
-
+       /**
+        * Import a mesh from a file.
+        * @param fileName file name to be imported.
+        * @param fileType Currently it could be either "DAT", "UNV" or "MED".
+        * @param studyId The id of the current study.
+        */
+       SMESH_Mesh Import(in long studyId, in string fileName, in string fileType);
   };
 
 };
index a051ada..b2c5813 100644 (file)
@@ -49,7 +49,8 @@ module SMESH
       ADD_PRISM,
       ADD_HEXAHEDRON,
       REMOVE_NODE,
-      REMOVE_ELEMENT
+      REMOVE_ELEMENT,
+         REMOVE_ALL
     };
 
   struct log_block
@@ -161,13 +162,11 @@ module SMESH
        raises (SALOME::SALOME_Exception);
 
     /*!
-     * Export Mesh with DAT and MED Formats
+     * Export mesh to a file
+        * @param fileName file name where to export the file
+        * @param fileType Currently it could be either "DAT", "UNV" or "MED".
      */
-    void ExportDAT( in string file )
-      raises (SALOME::SALOME_Exception);
-    void ExportMED( in string file )
-      raises (SALOME::SALOME_Exception);
-    void ExportUNV( in string file )
+    void Export( in string fileName, in string fileType )
       raises (SALOME::SALOME_Exception);
 
     /*!
index 26dcf14..edb1c77 100644 (file)
@@ -38,3 +38,16 @@ void Document_Reader::SetDocument(SMESHDS_Document * aDoc)
 {
        myDocument = aDoc;
 }
+
+void Document_Reader::Read()
+{
+       int myMeshId = myDocument->NewMesh();
+       SMDS_Mesh * myMesh = myDocument->GetMesh(myMeshId);
+       myReader->SetMesh(myMesh);
+       myReader->SetFile(myFile);
+       myReader->Read();
+}
+
+Document_Reader::Document_Reader(Mesh_Reader* reader): myReader(reader)
+{
+}
index 2766466..7196658 100644 (file)
 #define _INCLUDE_DOCUMENT_READER
 
 #include "SMESHDS_Document.hxx"
+#include "Mesh_Reader.h"
 #include <string>
 
 class Document_Reader
 {
   public:
-       virtual void Read() = 0;
+       virtual void Read();
        void SetFile(string);
        void SetDocument(SMESHDS_Document *);
+       Document_Reader(Mesh_Reader*);
 
   protected:
-         SMESHDS_Document * myDocument;
+       SMESHDS_Document * myDocument;
        string myFile;
+
+  private:
+       Mesh_Reader* myReader;
 };
 #endif
index 8704c12..95f195d 100644 (file)
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
 // 
 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
-//
-//
-//
-//  File   : Document_Writer.cxx
-//  Module : SMESH
 
-using namespace std;
 #include "Document_Writer.h"
+#include "utilities.h"
 
 void Document_Writer::SetFile(string aFile)
 {
@@ -36,3 +31,28 @@ void Document_Writer::SetDocument(SMESHDS_Document * aDoc)
 {
        myDocument = aDoc;
 }
+
+void Document_Writer::Write()
+{
+       SCRUTE(myFile);
+       SMESHDS_Mesh * myMesh;
+       int nb_of_meshes = myDocument->NbMeshes();      //voir avec Yves
+       SCRUTE(nb_of_meshes);
+
+       int numero = 0;
+
+       myDocument->InitMeshesIterator();
+       while(myDocument->MoreMesh())
+       {
+               numero++;
+               myMesh = myDocument->NextMesh();
+               myWriter->SetMesh(myMesh);
+               myWriter->SetFile(myFile);
+               myWriter->SetMeshId(numero);
+               myWriter->Add();
+       }
+}
+
+Document_Writer::Document_Writer(Mesh_Writer* writer): myWriter(writer)
+{
+}
index 4aea960..f50b594 100644 (file)
 #define _INCLUDE_DOCUMENT_WRITER
 
 #include "SMESHDS_Document.hxx"
+#include "Mesh_Writer.h"
 #include <string>
 
 class Document_Writer
 {
 
-  public:virtual void Write() = 0;
+  public:virtual void Write();
        void SetFile(string);
        void SetDocument(SMESHDS_Document *);
+       Document_Writer(Mesh_Writer* );
 
-  protected:  SMESHDS_Document * myDocument;
+  protected:
+       SMESHDS_Document * myDocument;
        string myFile;
+       Mesh_Writer * myWriter;
 
 };
 #endif
index 6016ac8..cad4d3b 100644 (file)
@@ -35,11 +35,21 @@ VPATH=.:@srcdir@
 @COMMENCE@
 
 # header files 
-EXPORT_HEADERS= Document_Reader.h Document_Writer.h Mesh_Reader.h Mesh_Writer.h
+EXPORT_HEADERS = \
+       SMESHDriver.h \
+       Document_Reader.h \
+       Document_Writer.h \
+       Mesh_Reader.h \
+       Mesh_Writer.h
 
 # Libraries targets
 LIB = libMeshDriver.la
-LIB_SRC = Document_Reader.cxx Document_Writer.cxx Mesh_Reader.cxx Mesh_Writer.cxx
+LIB_SRC = \
+       SMESHDriver.cxx \
+       Document_Reader.cxx \
+       Document_Writer.cxx 
+#      Mesh_Reader.cxx \
+#      Mesh_Writer.cxx \
 
 LIB_CLIENT_IDL =
 
index 83e9037..696c00d 100644 (file)
@@ -1,4 +1,4 @@
-//  SMESH Driver : implementaion of driver for reading and writing     
+//  SMESH Driver : implementation of driver for reading and writing    
 //
 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
 // 
 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
-//
-//
-//
-//  File   : SMESHDriver.cxx
-//  Module : SMESH
 
-using namespace std;
 #include "SMESHDriver.h"
 
 #include <dlfcn.h>
 #include <utilities.h>
 
-//A enlever
-#include "DriverMED_R_SMESHDS_Document.h"
-#include "DriverMED_R_SMESHDS_Mesh.h"
-#include "DriverMED_R_SMDS_Mesh.h"
-#include "DriverMED_W_SMESHDS_Document.h"
-#include "DriverMED_W_SMESHDS_Mesh.h"
-#include "DriverMED_W_SMDS_Mesh.h"
-
-#include "DriverDAT_R_SMESHDS_Document.h"
-#include "DriverDAT_R_SMESHDS_Mesh.h"
-#include "DriverDAT_R_SMDS_Mesh.h"
-#include "DriverDAT_W_SMESHDS_Document.h"
-#include "DriverDAT_W_SMESHDS_Mesh.h"
-#include "DriverDAT_W_SMDS_Mesh.h"
-//
-
-Document_Reader* SMESHDriver::GetDocumentReader(string Extension, string Class) {
-  if (Extension==string("MED")) {
-    DriverMED_R_SMESHDS_Document* myDriver = new DriverMED_R_SMESHDS_Document();
-    return (myDriver);
-  }
-  else if (Extension==string("DAT")) {
-    DriverDAT_R_SMESHDS_Document* myDriver = new DriverDAT_R_SMESHDS_Document();
-    return (myDriver);
-  }
-  else {
-    MESSAGE("No driver known for this extension");
-    return (Document_Reader*)NULL;
-  }
-
-
+Document_Reader* SMESHDriver::GetDocumentReader(string Extension)
+{
+       // if there is not document reader in the driver create a default
+       // one with the mesh reader.
+       Document_Reader * docReader=
+               (Document_Reader*)getMeshDocumentDriver(Extension);
+
+       if(docReader==NULL)
+       {
+               Mesh_Reader * reader=GetMeshReader(Extension);
+               if(reader==NULL)
+               {
+               MESSAGE("No driver known for this extension");
+                       return NULL;
+               }
+               return new Document_Reader(reader);
+       }
+       else return docReader;
 }
 
-Document_Writer* SMESHDriver::GetDocumentWriter(string Extension, string Class) {
-  if (Extension==string("MED")) {
-    DriverMED_W_SMESHDS_Document* myDriver = new DriverMED_W_SMESHDS_Document();
-    return (myDriver);
-  }    
-  else if (Extension==string("DAT")) {
-    DriverDAT_W_SMESHDS_Document* myDriver = new DriverDAT_W_SMESHDS_Document();
-    return (myDriver);
-  }    
-  else {
-    MESSAGE("No driver known for this extension");
-    return (Document_Writer*)NULL;
-  }
-
-
+Document_Writer* SMESHDriver::GetDocumentWriter(string Extension)
+{
+       Mesh_Writer * writer=GetMeshWriter(Extension);
+       if(writer==NULL)
+       {
+       MESSAGE("No driver known for this extension");
+               return NULL;
+       }
+       return new Document_Writer(writer);
 }
 
-Mesh_Reader* SMESHDriver::GetMeshReader(string Extension, string Class) {
-  if (Extension==string("MED")) {
-
-  if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
-    DriverMED_R_SMESHDS_Mesh* myDriver = new DriverMED_R_SMESHDS_Mesh();
-    return (myDriver);
-  }
-  else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
-    DriverMED_R_SMDS_Mesh* myDriver = new DriverMED_R_SMDS_Mesh();
-    return (myDriver);
-  }
-
-  }
-  else if (Extension==string("DAT")) {
-
-  if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
-    DriverDAT_R_SMESHDS_Mesh* myDriver = new DriverDAT_R_SMESHDS_Mesh();
-    return (myDriver);
-  }
-  else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
-    DriverDAT_R_SMDS_Mesh* myDriver = new DriverDAT_R_SMDS_Mesh();
-    return (myDriver);
-  }
-
-  }
-
-
+Mesh_Reader* SMESHDriver::GetMeshReader(string extension)
+{
+       void * driver = getMeshDriver(extension, string("Reader"));
+       return (Mesh_Reader*)driver;
 }
 
-Mesh_Writer* SMESHDriver::GetMeshWriter(string Extension, string Class) {
-  if (Extension==string("MED")) {
-
-  if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
-    DriverMED_W_SMESHDS_Mesh* myDriver = new DriverMED_W_SMESHDS_Mesh();
-    return (myDriver);
-  }
-  else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
-    DriverMED_W_SMDS_Mesh* myDriver = new DriverMED_W_SMDS_Mesh();
-    return (myDriver);
-  }
-
-  }
-  else if (Extension==string("DAT")) {
-
-  if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
-    DriverDAT_W_SMESHDS_Mesh* myDriver = new DriverDAT_W_SMESHDS_Mesh();
-    return (myDriver);
-  }
-  else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
-    DriverDAT_W_SMDS_Mesh* myDriver = new DriverDAT_W_SMDS_Mesh();
-    return (myDriver);
-  }
-
-  }
+Mesh_Writer* SMESHDriver::GetMeshWriter(string extension)
+{
+       void * driver = getMeshDriver(extension, string("Writer"));
+       return (Mesh_Writer*)driver;
+}
 
+void * SMESHDriver::getMeshDriver(string extension, string type)
+{
+       string libName = string("libMeshDriver")+extension+string(".so");
+       void * handle = dlopen(libName.c_str(), RTLD_LAZY);
+       if(!handle)
+       {
+               fputs (dlerror(), stderr);
+               return NULL;
+       }
+       else
+       {
+               void * (*factory)();
+               string symbol = string("SMESH_create")+extension+string("Mesh")+type;
+               factory = (void * (*)()) dlsym(handle, symbol.c_str());
+               if(factory==NULL)
+               {
+                       fputs (dlerror(), stderr);
+                       return NULL;
+               }
+               else return factory();
+       }
 }
 
+void * SMESHDriver::getMeshDocumentDriver(string extension)
+{
+       string libName = string("libMeshDriver")+extension+string(".so");
+       void * handle = dlopen(libName.c_str(), RTLD_LAZY);
+       if(!handle)
+       {
+               fputs (dlerror(), stderr);
+               return NULL;
+       }
+       else
+       {
+               void * (*factory)();
+               string symbol = string("SMESH_create")+extension+string("DocumentReader");
+               factory = (void * (*)()) dlsym(handle, symbol.c_str());
+               if(factory==NULL)
+               {
+                       fputs (dlerror(), stderr);
+                       return NULL;
+               }
+               else return factory();
+       }
+}
index 78731c3..119208c 100644 (file)
 #include "Mesh_Reader.h"
 #include "Mesh_Writer.h"
 
-class SMESHDriver {
-
+class SMESHDriver
+{
   public :
-    static Document_Reader* GetDocumentReader(string Extension, string Class);
-    static Document_Writer* GetDocumentWriter(string Extension, string Class);
+    static Document_Reader* GetDocumentReader(string Extension);
+    static Document_Writer* GetDocumentWriter(string Extension);
 
-    static Mesh_Reader* GetMeshReader(string Extension, string Class);
-    static Mesh_Writer* GetMeshWriter(string Extension, string Class);
+    static Mesh_Reader* GetMeshReader(string Extension);
+    static Mesh_Writer* GetMeshWriter(string Extension);
 
+  private:
+       static void * getMeshDriver(string Extension, string type);
+       static void * getMeshDocumentDriver(string Extension);
 };
 #endif
index bd95f49..0990acc 100644 (file)
 //  File   : DriverDAT_R_SMDS_Mesh.cxx
 //  Module : SMESH
 
-using namespace std;
 #include "DriverDAT_R_SMDS_Mesh.h"
-
 #include "utilities.h"
 
+extern "C"
+{
+
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createDATMeshReader()
+{
+       return new DriverDAT_R_SMDS_Mesh();
+}
+}
+
 DriverDAT_R_SMDS_Mesh::DriverDAT_R_SMDS_Mesh()
 {
        ;
index 9ebe754..d99a124 100644 (file)
 //  File   : DriverDAT_W_SMDS_Mesh.cxx
 //  Module : SMESH
 
-using namespace std;
 #include "DriverDAT_W_SMDS_Mesh.h"
-
 #include "SMDS_MeshElement.hxx"
 #include "SMDS_MeshNode.hxx"
-
 #include "utilities.h"
 
+extern "C"
+{
+
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createDATMeshWriter()
+{
+       return new DriverDAT_W_SMDS_Mesh();
+}
+}
+
 DriverDAT_W_SMDS_Mesh::DriverDAT_W_SMDS_Mesh()
 {
-       ;
 }
 
 DriverDAT_W_SMDS_Mesh::~DriverDAT_W_SMDS_Mesh()
@@ -64,12 +72,12 @@ void DriverDAT_W_SMDS_Mesh::SetMeshId(int aMeshId)
 
 void DriverDAT_W_SMDS_Mesh::Add()
 {
-       ;
+       MESSAGE("Adding a mesh to a DAT document. As DAT do not support more than one mesh in a file, the previous mesh is deleted");
+       Write();
 }
 
 void DriverDAT_W_SMDS_Mesh::Write()
 {
-
        int nbNodes, nbCells;
        int i;
 
@@ -80,7 +88,7 @@ void DriverDAT_W_SMDS_Mesh::Write()
                fprintf(stderr, ">> ERREUR : ouverture du fichier %s \n", file2Read);
                exit(EXIT_FAILURE);
        }
-       SCRUTE(myMesh);
+
   /****************************************************************************
   *                       NOMBRES D'OBJETS                                    *
   ****************************************************************************/
@@ -97,9 +105,6 @@ void DriverDAT_W_SMDS_Mesh::Write()
        nb_of_faces = myMesh->NbFaces();
        nb_of_volumes = myMesh->NbVolumes();
        nbCells = nb_of_edges + nb_of_faces + nb_of_volumes;
-       SCRUTE(nb_of_edges);
-       SCRUTE(nb_of_faces);
-       SCRUTE(nb_of_volumes);
 
        fprintf(stdout, "%d %d\n", nbNodes, nbCells);
        fprintf(myFileId, "%d %d\n", nbNodes, nbCells);
@@ -118,7 +123,8 @@ void DriverDAT_W_SMDS_Mesh::Write()
                fprintf(myFileId, "%d %e %e %e\n", node->GetID(), node->X(),
                        node->Y(), node->Z());
        }
-       
+       delete itNodes;
+
   /****************************************************************************
   *                       ECRITURE DES ELEMENTS                                *
   ****************************************************************************/
@@ -127,10 +133,10 @@ void DriverDAT_W_SMDS_Mesh::Write()
        fprintf(stdout, "(**************************)");
        /* Ecriture des connectivites, noms, numeros des mailles */
 
-       SMDS_Iterator<const SMDS_MeshEdge *> * itEdges=myMesh->edgesIterator();
+       SMDS_Iterator<const SMDS_MeshEdge*> * itEdges=myMesh->edgesIterator();
        while(itEdges->more())
        {
-               const SMDS_MeshElement * elem = itEdges->next();
+               const SMDS_MeshEdge * elem = itEdges->next();
 
                switch (elem->NbNodes())
                {
@@ -146,11 +152,13 @@ void DriverDAT_W_SMDS_Mesh::Write()
                }
                }
 
-               SMDS_Iterator<const SMDS_MeshElement *> * it=elem->nodesIterator();
-               while(it->more()) fprintf(myFileId, "%d ", it->next()->GetID());
-
+               SMDS_Iterator<const SMDS_MeshElement *> * itNodes=elem->nodesIterator();
+               while(itNodes->more())
+                       fprintf(myFileId, "%d ", itNodes->next()->GetID());
+               
                fprintf(myFileId, "\n");
        }
+       delete itEdges;
 
        SMDS_Iterator<const SMDS_MeshFace *> * itFaces=myMesh->facesIterator();
        while(itFaces->more())
@@ -176,13 +184,16 @@ void DriverDAT_W_SMDS_Mesh::Write()
                }
                }
 
-               SMDS_Iterator<const SMDS_MeshElement *> * it=elem->nodesIterator();
-               while(it->more()) fprintf(myFileId, "%d ", it->next()->GetID());
-
+               SMDS_Iterator<const SMDS_MeshElement *> * itNodes=elem->nodesIterator();
+               while(itNodes->more())
+                       fprintf(myFileId, "%d ", itNodes->next()->GetID());
+               delete itNodes;
+       
                fprintf(myFileId, "\n");
        }
+       delete itFaces;
 
-       SMDS_Iterator<const SMDS_MeshVolume *> * itVolumes=myMesh->volumesIterator();
+       SMDS_Iterator<const SMDS_MeshVolume*> * itVolumes=myMesh->volumesIterator();
        while(itVolumes->more())
        {
                const SMDS_MeshElement * elem = itVolumes->next();
@@ -196,11 +207,14 @@ void DriverDAT_W_SMDS_Mesh::Write()
                }
                }
 
-               SMDS_Iterator<const SMDS_MeshElement *> * it=elem->nodesIterator();
-               while(it->more()) fprintf(myFileId, "%d ", it->next()->GetID());
+               SMDS_Iterator<const SMDS_MeshElement *> * itNodes=elem->nodesIterator();
+               while(itNodes->more())
+                       fprintf(myFileId, "%d ", itNodes->next()->GetID());
+               delete itNodes; 
 
                fprintf(myFileId, "\n");
        }
+       delete itVolumes;
 
        fclose(myFileId);
 }
index cf3dba9..8043bf7 100644 (file)
@@ -35,11 +35,23 @@ VPATH=.:@srcdir@
 @COMMENCE@
 
 # header files 
-EXPORT_HEADERS= DriverDAT_R_SMDS_Mesh.h DriverDAT_R_SMESHDS_Mesh.h DriverDAT_R_SMESHDS_Document.h DriverDAT_W_SMDS_Mesh.h DriverDAT_W_SMESHDS_Mesh.h DriverDAT_W_SMESHDS_Document.h 
+EXPORT_HEADERS = \
+       DriverDAT_R_SMDS_Mesh.h \
+       DriverDAT_R_SMESHDS_Mesh.h \
+       DriverDAT_W_SMDS_Mesh.h \
+       DriverDAT_W_SMESHDS_Mesh.h 
+#      DriverDAT_W_SMESHDS_Document.h \
+#      DriverDAT_R_SMESHDS_Document.h \
 
 # Libraries targets
 LIB = libMeshDriverDAT.la
-LIB_SRC = DriverDAT_R_SMDS_Mesh.cxx DriverDAT_R_SMESHDS_Mesh.cxx DriverDAT_R_SMESHDS_Document.cxx DriverDAT_W_SMDS_Mesh.cxx DriverDAT_W_SMESHDS_Mesh.cxx DriverDAT_W_SMESHDS_Document.cxx 
+LIB_SRC = \
+       DriverDAT_R_SMDS_Mesh.cxx \
+       DriverDAT_R_SMESHDS_Mesh.cxx \
+       DriverDAT_W_SMDS_Mesh.cxx \
+       DriverDAT_W_SMESHDS_Mesh.cxx 
+       #DriverDAT_W_SMESHDS_Document.cxx \
+       #DriverDAT_R_SMESHDS_Document.cxx \
 
 LIB_CLIENT_IDL =
 
index ca50c55..4949199 100644 (file)
@@ -31,13 +31,14 @@ using namespace std;
 
 extern "C"
 {
-       Document_Reader *maker()
+       void * SMESH_createMEDDocumentReader()
        {
                return new DriverMED_R_SMESHDS_Document;
        }
 }
 
 DriverMED_R_SMESHDS_Document::DriverMED_R_SMESHDS_Document()
+       :Document_Reader(new DriverMED_R_SMESHDS_Mesh())
 {
        ;
 }
@@ -60,8 +61,6 @@ void DriverMED_R_SMESHDS_Document::Read()
 
        int myMeshId;
 
-       //string myFile = string("/home/home_users/cai/projects/salome_prev04/SALOME_ROOT/data/fra1.med");
-
 /****************************************************************************
   *                      OUVERTURE DU FICHIER EN LECTURE                      *
   ****************************************************************************/
index 1652a55..3c14759 100644 (file)
@@ -31,6 +31,18 @@ using namespace std;
 
 #include <stdlib.h>
 
+extern "C"
+{
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createMEDMeshReader()
+{
+       return new DriverMED_R_SMESHDS_Mesh();
+}
+
+}
+
 DriverMED_R_SMESHDS_Mesh::DriverMED_R_SMESHDS_Mesh()
 {
        myFileId = -1;
index 8459854..8b1567f 100644 (file)
@@ -33,6 +33,18 @@ using namespace std;
 #include <vector>
 #include "utilities.h"
 
+extern "C"
+{
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createMEDMeshWriter()
+{
+       return new DriverMED_W_SMESHDS_Mesh();
+}
+
+}
+
 DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh()
 {
        ;
@@ -65,19 +77,7 @@ void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId)
 
 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();
-
+       Add();
 }
 
 void DriverMED_W_SMESHDS_Mesh::Add()
@@ -520,40 +520,45 @@ void DriverMED_W_SMESHDS_Mesh::Add()
        {
                int nbFamillesElts = 0;
                SMESHDS_Mesh * mySMESHDSMesh = dynamic_cast<SMESHDS_Mesh *>(myMesh);
-               TopTools_IndexedMapOfShape myIndexToShape;
-               TopExp::MapShapes(mySMESHDSMesh->ShapeToMesh(), myIndexToShape);
-
                map<int,int> mapFamille;
 
-               if (besoinfamilledemaille == 1)
+               if(!mySMESHDSMesh->ShapeToMesh().IsNull())
                {
-                       int t;
-                       for (t = 1; t <= myIndexToShape.Extent(); t++)
+                       TopTools_IndexedMapOfShape myIndexToShape;
+                       TopExp::MapShapes(mySMESHDSMesh->ShapeToMesh(), myIndexToShape);
+
+
+                       if (besoinfamilledemaille == 1)
                        {
-                               const TopoDS_Shape S = myIndexToShape(t);
-                               if (mySMESHDSMesh->HasMeshElements(S))
+                               int t;
+                               for (t = 1; t <= myIndexToShape.Extent(); t++)
                                {
-                                       //MESSAGE ("********* Traitement de la Famille "<<-t);
-
-                                       SMESHDS_SubMesh * SM = mySMESHDSMesh->MeshElements(S);
-                                       SMDS_Iterator<const SMDS_MeshElement*> * ite=SM->GetElements();
-                                       bool plein = false;
-                                       while(ite->more())
-                                       {
-                                               mapFamille[ite->next()->GetID()] = -t;
-                                               plein = true;
-                                       }
-                                       if (plein)
+                                       const TopoDS_Shape S = myIndexToShape(t);
+                                       if (mySMESHDSMesh->HasMeshElements(S))
                                        {
-                                               nbFamillesElts++;
-                                               char famille[MED_TAILLE_NOM + 1];
-                                               sprintf(famille, "E%d", t);
-                                               CreateFamily(strdup(nommaa), strdup(famille), -t,
-                                                       attvalabs++);
+                                               //MESSAGE ("********* Traitement de la Famille "<<-t);
+       
+                                               SMESHDS_SubMesh * SM = mySMESHDSMesh->MeshElements(S);
+                                               SMDS_Iterator<const SMDS_MeshElement*> * ite=SM->GetElements();
+                                               bool plein = false;
+                                               while(ite->more())
+                                               {
+                                                       mapFamille[ite->next()->GetID()] = -t;
+                                                       plein = true;
+                                               }
+                                               if (plein)
+                                               {
+                                                       nbFamillesElts++;
+                                                       char famille[MED_TAILLE_NOM + 1];
+                                                       sprintf(famille, "E%d", t);
+                                                       CreateFamily(strdup(nommaa), strdup(famille), -t,
+                                                               attvalabs++);
+                                               }
                                        }
                                }
                        }
                }
+               else besoinfamilledemaille = 0;
 
                int indice = 1;
                for (i = 0; i < MED_NBR_GEOMETRIE_MAILLE; i++)
index 4217426..1a5396a 100644 (file)
 # 
 #  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
 #
-#
-#
 #  File   : Makefile.in
 #  Author : Marc Tajchman (CEA)
 #  Module : SMESH
-#  $Header$
 
 top_srcdir=@top_srcdir@
 top_builddir=../..
@@ -35,18 +32,23 @@ VPATH=.:@srcdir@
 @COMMENCE@
 
 # header files 
-EXPORT_HEADERS= DriverMED_R_SMDS_Mesh.h DriverMED_R_SMESHDS_Mesh.h DriverMED_R_SMESHDS_Document.h DriverMED_W_SMDS_Mesh.h DriverMED_W_SMESHDS_Mesh.h DriverMED_W_SMESHDS_Document.h 
+EXPORT_HEADERS = \
+       DriverMED_R_SMESHDS_Mesh.h \
+       DriverMED_R_SMESHDS_Document.h \
+       DriverMED_R_SMDS_Mesh.h \
+       DriverMED_W_SMESHDS_Mesh.h 
+       #DriverMED_W_SMDS_Mesh.h \
+       #DriverMED_W_SMESHDS_Document.h 
 
 # Libraries targets
 LIB = libMeshDriverMED.la
 LIB_SRC = \
-       DriverMED_R_SMDS_Mesh.cxx \
        DriverMED_R_SMESHDS_Mesh.cxx \
        DriverMED_R_SMESHDS_Document.cxx \
-       DriverMED_W_SMDS_Mesh.cxx \
-       DriverMED_W_SMESHDS_Document.cxx \
-       DriverMED_W_SMESHDS_Mesh.cxx
-
+       DriverMED_R_SMDS_Mesh.cxx \
+       DriverMED_W_SMESHDS_Mesh.cxx 
+       #DriverMED_W_SMDS_Mesh.cxx \
+       #DriverMED_W_SMESHDS_Document.cxx 
 LIB_CLIENT_IDL =
 LIB_SERVER_IDL =
 
index c6286a7..36bba74 100644 (file)
@@ -3,6 +3,20 @@ using namespace std;
 
 #include "utilities.h"
 
+
+extern "C"
+{
+
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createUNVMeshReader()
+{
+       return new DriverUNV_R_SMDS_Mesh();
+}
+
+}
+
 DriverUNV_R_SMDS_Mesh::DriverUNV_R_SMDS_Mesh()
 {
        ;
index 01b112b..a841488 100644 (file)
@@ -1,13 +1,7 @@
-using namespace std;
 #include "DriverUNV_W_SMDS_Mesh.h"
-
 #include "SMDS_MeshElement.hxx"
 #include "SMDS_MeshNode.hxx"
 
-
-
-
-
 #include <utilities.h>
 
 #define sNODE_UNV_ID "  2411"
@@ -19,6 +13,19 @@ using namespace std;
 #define sELT_BEAM_DESC1 "%10d        %2d         1         1         7         %1d\n"
 #define sELT_BEAM_DESC2 "         0         1         1\n"
 
+extern "C"
+{
+
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createUNVMeshWriter()
+{
+       return new DriverUNV_W_SMDS_Mesh();
+}
+
+}
+
 DriverUNV_W_SMDS_Mesh::DriverUNV_W_SMDS_Mesh()
 {
        ;
@@ -89,7 +96,6 @@ void DriverUNV_W_SMDS_Mesh::Write()
        SCRUTE(nb_of_volumes);
 
        fprintf(stdout, "%d %d\n", nbNodes, nbCells);
-       fprintf(myFileId, "%d %d\n", nbNodes, nbCells);
 
   /****************************************************************************
   *                       ECRITURE DES NOEUDS                                 *
index cfb0487..f052db3 100644 (file)
@@ -35,18 +35,23 @@ VPATH=.:@srcdir@
 @COMMENCE@
 
 # header files 
-EXPORT_HEADERS= DriverUNV_R_SMDS_Mesh.h DriverUNV_R_SMESHDS_Mesh.h DriverUNV_R_SMESHDS_Document.h \
-                DriverUNV_W_SMDS_Mesh.h DriverUNV_W_SMESHDS_Mesh.h DriverUNV_W_SMESHDS_Document.h 
+EXPORT_HEADERS = \
+       DriverUNV_R_SMDS_Mesh.h \
+       DriverUNV_W_SMDS_Mesh.h 
+       #DriverUNV_W_SMESHDS_Mesh.h \
+       #DriverUNV_W_SMESHDS_Document.h \
+       #DriverUNV_R_SMESHDS_Mesh.h \
+       #DriverUNV_R_SMESHDS_Document.h \
 
 # Libraries targets
 LIB = libMeshDriverUNV.la
 LIB_SRC = \
        DriverUNV_R_SMDS_Mesh.cxx \
-       DriverUNV_R_SMESHDS_Mesh.cxx \
-       DriverUNV_R_SMESHDS_Document.cxx \
-       DriverUNV_W_SMESHDS_Document.cxx \
-       DriverUNV_W_SMDS_Mesh.cxx \
-       DriverUNV_W_SMESHDS_Mesh.cxx 
+       DriverUNV_W_SMDS_Mesh.cxx 
+       #DriverUNV_W_SMESHDS_Mesh.cxx \
+       #DriverUNV_R_SMESHDS_Mesh.cxx \
+       #DriverUNV_R_SMESHDS_Document.cxx \
+       #DriverUNV_W_SMESHDS_Document.cxx \
 
 LIB_CLIENT_IDL =
 
index a67db9d..eda54c9 100644 (file)
@@ -1271,7 +1271,7 @@ SMDS_Iterator<const SMDS_MeshNode *> * SMDS_Mesh::nodesIterator() const
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-///Return an iterator on volumes of the current mesh. Once used this iterator
+///Return an iterator on egdes of the current mesh. Once used this iterator
 ///must be free by the caller
 ///////////////////////////////////////////////////////////////////////////////
 SMDS_Iterator<const SMDS_MeshEdge *> * SMDS_Mesh::edgesIterator() const
@@ -1574,3 +1574,126 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
        delete s2;
        delete s1;
 }
+
+/**
+ * Concat the coordinates of all nodes in an array.
+ * Its used to display the mesh.
+ * @return A array of size 3*NbNodes() containing the coordinates of nodes.
+ */
+double * SMDS_Mesh::getNodesCoordinates()
+{
+       double * toReturn=new double[3*NbNodes()];
+       SMDS_Iterator<const SMDS_MeshNode*> * it=nodesIterator();
+       int i=0;
+       while(it->more())
+       {
+               const SMDS_MeshNode * n=it->next();
+               toReturn[i]=n->X();
+               i++;
+               toReturn[i]=n->Y();
+               i++;
+               toReturn[i]=n->Z();
+               i++;
+       }
+       delete it;
+       return toReturn;
+}
+
+/**
+ * Concat the id of all nodes in an array.
+ * Its used to display the mesh.
+ * @return A array of size NbNodes() containing the ids of nodes.
+ */
+long * SMDS_Mesh::getNodesID()
+{
+       long * toReturn=new long[NbNodes()];
+       SMDS_Iterator<const SMDS_MeshNode*> * it=nodesIterator();
+       int i=0;
+       while(it->more())
+       {
+               const SMDS_MeshNode * n=it->next();             
+               toReturn[i]=n->GetID();
+               i++;
+       }
+       delete it;
+       return toReturn;
+}
+
+/**
+ * Concat the id of nodes of edges in an array.
+ * Array format is {edge_id, node1_id, node2_id}
+ * Its used to display the mesh.
+ * @return A array of size 3*NbEdges() containing the edges.
+ */
+long * SMDS_Mesh::getEdgesIndices()
+{
+       long * toReturn=new long[NbEdges()*3];
+       SMDS_Iterator<const SMDS_MeshEdge*> * it=edgesIterator();
+       int i=0;
+       
+       while(it->more())
+       {
+               const SMDS_MeshEdge * e=it->next();
+               toReturn[i]=e->GetID();
+               i++;
+               SMDS_Iterator<const SMDS_MeshElement*> * itn=e->nodesIterator();
+               while(itn->more())
+               {
+                       const SMDS_MeshElement * n=itn->next();
+                       toReturn[i]=n->GetID();
+                       i++;
+               }
+               delete itn;
+       }
+       delete it;
+       return toReturn;
+}
+
+/**
+ * Concat the id of nodes of triangles in an array.
+ * Array format is {tria_id, node1_id, node2_id, node3_id}
+ * Its used to display the mesh.
+ * @return A array of size 4*NbTriangles() containing the edges.
+ */
+long * SMDS_Mesh::getTrianglesIndices()
+{
+       long * toReturn=new long[NbTriangles()*4];
+       SMDS_Iterator<const SMDS_MeshFace*> * it=facesIterator();
+       int i=0;
+       while(it->more())
+       {
+               const SMDS_MeshFace * f=it->next();
+               if(f->NbNodes()==3)
+               {
+                       toReturn[i]=f->GetID();
+                       i++;            
+                       SMDS_Iterator<const SMDS_MeshElement*> * itn=f->nodesIterator();
+                       while(itn->more())
+                       {
+                               const SMDS_MeshElement * n=itn->next();
+                               toReturn[i]=n->GetID();
+                               i++;
+                       }
+                       delete itn;
+               }
+       }
+       delete it;
+       return toReturn;
+}
+
+/**
+ * Return the number of 3 nodes faces in the mesh.
+ * This method run in O(n).
+ * @return The number of face whose number of nodes is 3
+ */
+int SMDS_Mesh::NbTriangles() const
+{
+       SMDS_Iterator<const SMDS_MeshFace*> * it=facesIterator();
+       int toReturn=0;
+       while(it->more())
+       {
+               const SMDS_MeshFace * f=it->next();
+               if(f->NbNodes()==3) toReturn++;
+       }
+       return toReturn;
+}
index f869cd7..47c22b0 100644 (file)
@@ -167,6 +167,7 @@ class SMDS_Mesh:public SMDS_MeshObject
        int NbNodes() const;
        int NbEdges() const;
        int NbFaces() const;
+       int NbTriangles() const;
        int NbVolumes() const;
        int NbSubMesh() const;
        void DumpNodes() const;
@@ -184,6 +185,11 @@ class SMDS_Mesh:public SMDS_MeshObject
     void setConstructionFaces(bool);
        void setInverseElements(bool);
 
+       double * getNodesCoordinates();
+       long * getNodesID();
+       long * getEdgesIndices();
+       long * getTrianglesIndices();
+
   private:
     SMDS_Mesh(SMDS_Mesh * parent);
     SMDS_MeshFace * createTriangle(SMDS_MeshNode * node1,
index ef442ef..e5badac 100644 (file)
@@ -94,7 +94,7 @@ CXXFLAGS+= $(OCC_CXXFLAGS) $(MED2_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR
 
 #IDLCXXFLAGS+= -Wbtp
 
-LDFLAGS+= $(HDF5_LIBS) $(MED2_LIBS) -lOpUtil -lSMESHDS -lSMDS -lMEFISTO2D -lMeshDriverDAT -lMeshDriverMED -lMeshDriverUNV -L${KERNEL_ROOT_DIR}/lib/salome
+LDFLAGS+= $(HDF5_LIBS) $(MED2_LIBS) -lOpUtil -lSMESHDS -lSMDS -lMEFISTO2D -lMeshDriver -L${KERNEL_ROOT_DIR}/lib/salome
 
 ifeq (@WITHNETGEN@,yes)
   LIB_SRC+= SMESH_NETGEN_3D.cxx
index ec40c71..5be63b4 100644 (file)
@@ -30,6 +30,7 @@
 #include "SMESH_subMesh.hxx"
 #include "SMDS_MeshElement.hxx"
 #include "SMDS_MeshNode.hxx"
+#include "SMESHDriver.h"
 
 #include <gp_Pnt.hxx>
 #include <BRep_Tool.hxx>
@@ -126,7 +127,8 @@ throw(SALOME_Exception)
 
 //=============================================================================
 /*!
- * 
+ * @TODO Doing a full update after computation is not optimal when doing a local
+ * remeshing.
  */
 //=============================================================================
 
@@ -138,7 +140,7 @@ throw(SALOME_Exception)
 /* 
 Algo : s'appuie ou non sur une geometrie
 Si geometrie:
-Vertex : rien à faire (range le point)
+Vertex : rien faire (range le point)
 Edge, Wire, collection d'edge et wire : 1D
 Face, Shell, collection de Face et Shells : 2D
 Solid, Collection de Solid : 3D
@@ -183,6 +185,8 @@ Solid, Collection de Solid : 3D
                smToCompute = sm->GetFirstToCompute();
        }
 
+       aMesh.GetMeshDS()->logFullUpdate();
+
        return ret;
 }
 
@@ -404,3 +408,40 @@ int SMESH_Gen::GetShapeDim(const TopoDS_Shape & aShape)
 //   SCRUTE(shapeDim);
        return shapeDim;
 }
+
+/**
+ * Import a mesh from a file
+ * @param fileName file name to be imported
+ * @param fileType Currently it could be either "DAT", "UNV" or "MED".
+ * @todo
+ */
+SMESH_Mesh * SMESH_Gen::Import(int studyId, const char * fileName,
+       const char * fileType)
+{
+       MESSAGE("SMESH_Gen::Import("<<studyId<<","<<fileName<<","<<fileType<<")");
+
+       // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
+       StudyContextStruct *myStudyContext = GetStudyContext(studyId);
+
+       // will be used with document
+       /*Document_Reader * reader = SMESHDriver::GetDocumentReader(string(fileType));
+       reader->SetDocument(myStudyContext->myDocument);
+       reader->SetFile(string(fileName));
+       reader->Read();*/
+       // currently we only read one mesh from a file (limitation on MED files).
+
+       // create a new SMESH_mesh object 
+       SMESH_Mesh *mesh = new SMESH_Mesh(_localId++, studyId, this,
+               myStudyContext->myDocument);
+       myStudyContext->mapMesh[_localId] = mesh;
+       
+       Mesh_Reader * reader = SMESHDriver::GetMeshReader(string(fileType));
+       reader->SetMesh(mesh->GetMeshDS());
+       reader->SetFile(string(fileName));
+       reader->Read();
+       
+       mesh->GetMeshDS()->logFullUpdate();
+       
+       return mesh;
+}
+
index 5443c0e..70f17f5 100644 (file)
@@ -69,7 +69,8 @@ class SMESH_Gen
 
        static int GetShapeDim(const TopoDS_Shape & aShape);
        SMESH_Algo *GetAlgo(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape);
-
+       SMESH_Mesh *Import(int studyId, const char * fileName, const char * fileType);
        // inherited methods from SALOMEDS::Driver
 
        void Save(int studyId, const char *aUrlOfFile);
index 82f24dd..a259117 100644 (file)
 #include "SMESH_Hypothesis.hxx"
 #include "SMESHDS_Script.hxx"
 #include "SMDS_MeshVolume.hxx"
-
 #include "utilities.h"
-
-#include "Mesh_Writer.h"
-#include "DriverMED_W_SMESHDS_Mesh.h"
-#include "DriverDAT_W_SMESHDS_Mesh.h"
-#include "DriverUNV_W_SMESHDS_Mesh.h"
+#include "SMESHDriver.h"
 
 #include <TCollection_AsciiString.hxx>
 
@@ -415,37 +410,22 @@ throw(SALOME_Exception)
        return _subMeshesUsingHypothesisList;
 }
 
-//=============================================================================
 /*!
- *
+ * Export mesh to a file
+ * @param fileName file name where to export the file
+ * @param fileType Currently it could be either "DAT", "UNV" or "MED".
  */
-//=============================================================================
-
-void SMESH_Mesh::ExportMED(const char *file) throw(SALOME_Exception)
-{
-       Mesh_Writer *myWriter = new DriverMED_W_SMESHDS_Mesh;
-       myWriter->SetFile(string(file));
-       myWriter->SetMesh(_myMeshDS);
-       MESSAGE(" _idDoc " << _idDoc) myWriter->SetMeshId(_idDoc);
-       myWriter->Add();
-}
-
-void SMESH_Mesh::ExportDAT(const char *file) throw(SALOME_Exception)
-{
-       Mesh_Writer *myWriter = new DriverDAT_W_SMESHDS_Mesh;
-       myWriter->SetFile(string(file));
-       myWriter->SetMesh(_myMeshDS);
-       myWriter->SetMeshId(_idDoc);
-       myWriter->Add();
-}
-
-void SMESH_Mesh::ExportUNV(const char *file) throw(SALOME_Exception)
+void SMESH_Mesh::Export(const char *fileName, const char *fileType)
+       throw(SALOME_Exception)
 {
-       Mesh_Writer *myWriter = new DriverUNV_W_SMESHDS_Mesh;
-       myWriter->SetFile(string(file));
-       myWriter->SetMesh(_myMeshDS);
-       myWriter->SetMeshId(_idDoc);
-       myWriter->Add();
+       MESSAGE("SMESH_Mesh::Export("<<fileName<<","<<fileType<<")");
+       Mesh_Writer * writer = SMESHDriver::GetMeshWriter(string(fileType));
+       if(writer!=NULL)
+       {
+               writer->SetMesh(GetMeshDS());
+               writer->SetFile(string(fileName));
+               writer->Write();
+       }
 }
 
 //=============================================================================
index f179f68..fbda43b 100644 (file)
@@ -101,9 +101,8 @@ class SMESH_Mesh
                GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp)
                throw(SALOME_Exception);
 
-       void ExportDAT(const char *file) throw(SALOME_Exception);
-       void ExportMED(const char *file) throw(SALOME_Exception);
-       void ExportUNV(const char *file) throw(SALOME_Exception);
+       void Export(const char *fileName, const char *fileType)
+               throw(SALOME_Exception);
 
        int NbNodes() throw(SALOME_Exception);
 
index 7c3014e..5de4a71 100644 (file)
@@ -29,6 +29,7 @@
 
 #include "SMESHDS_CommandType.hxx"
 #include <list>
+using namespace std;
 
 class SMESHDS_Command
 {
index fd64ba0..404642e 100644 (file)
@@ -38,7 +38,8 @@ SMESHDS_AddPrism,
 SMESHDS_AddHexahedron,
 SMESHDS_RemoveNode,
 SMESHDS_RemoveElement,
-SMESHDS_MoveNode
+SMESHDS_MoveNode,
+SMESHDS_UpdateAll
 };
 
 
index b1cf717..bb50474 100644 (file)
@@ -97,3 +97,7 @@ int SMESHDS_Hypothesis::GetType() const
   return _type;
 }
 
+void SMESHDS_Hypothesis::SetID(int id)
+{
+       _hypId=id;
+}
\ No newline at end of file
index 3a79039..b5c414a 100644 (file)
@@ -48,6 +48,7 @@ public:
 
   const char* GetName() const;
   int GetID() const;
+  void SetID(int id);
   int GetType() const;
 
   virtual ostream & SaveTo(ostream & save)=0;
index 0396c6b..4aafa43 100644 (file)
@@ -577,3 +577,12 @@ void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement* anElement,
 SMESHDS_Mesh::~SMESHDS_Mesh()
 {
 }
+
+/**
+ * Add FULL_UPDATE command to the log of this mesh. Once interpreted by the
+ * graphical client it will (re)draw the full mesh.
+ */
+void SMESHDS_Mesh::logFullUpdate()
+{
+       myScript->UpdateAll();
+}
index 6159a4f..2f37661 100644 (file)
@@ -133,7 +133,8 @@ class SMESHDS_Mesh:public SMDS_Mesh
        void SetNodeOnVertex(SMDS_MeshNode * aNode, int Index);
        void SetMeshElementOnShape(const SMDS_MeshElement * anElt, int Index);
         ~SMESHDS_Mesh();
-
+       void logFullUpdate();
+       
   private:
        struct HashTopoDS_Shape
     {
index 57baf30..cc969b7 100644 (file)
@@ -26,7 +26,6 @@
 //  Module : SMESH
 //  $Header: 
 
-using namespace std;
 #include "SMESHDS_Script.hxx"
 
 //=======================================================================
@@ -321,3 +320,12 @@ const list<SMESHDS_Command*>& SMESHDS_Script::GetCommands()
 {
        return myCommands;
 }
+
+/**
+ * Add UpdateAll command to the log of this mesh. Once interpreted by the
+ * graphical client it will (re)draw the full mesh.
+ */
+void SMESHDS_Script::UpdateAll()
+{
+       myCommands.insert(myCommands.end(), new SMESHDS_Command(SMESHDS_UpdateAll));
+}
index 8a67c98..70d4d5b 100644 (file)
@@ -52,6 +52,7 @@ class SMESHDS_Script
        void RemoveElement(int ElementID);
        void Clear();
        const list<SMESHDS_Command*> & GetCommands();
+       void UpdateAll();
        ~SMESHDS_Script();
   
   private:
index 660789e..6f6c98f 100644 (file)
@@ -126,6 +126,6 @@ CPPFLAGS += $(QT_INCLUDES) $(VTK_INCLUDES) $(OGL_INCLUDES) $(OCC_INCLUDES) $(PYT
 CXXFLAGS += -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome
 #$(OCC_CXXFLAGS)
 
-LDFLAGS += -lOCCViewer -lVTKViewer -lSalomeObject -lSalomeGUI -lSMESHObject -lSMDS -lSMESHDS -lSMESHFiltersSelection -lGEOMClient -lMeshDriverDAT -lMeshDriverMED -lMeshDriverUNV $(OCC_KERNEL_LIBS) -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome
+LDFLAGS += -lOCCViewer -lVTKViewer -lSalomeObject -lSalomeGUI -lSMESHObject -lSMDS -lSMESHDS -lSMESHFiltersSelection -lGEOMClient $(OCC_KERNEL_LIBS) -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome
 
 @CONCLUDE@
index 5f56add..1c05405 100644 (file)
@@ -87,26 +87,6 @@ using namespace std;
 #include "SALOMEGUI_QtCatchCorbaException.hxx"
 #include "utilities.h"
 
-#include "SMDS_Mesh.hxx"
-#include "SMESHDS_Document.hxx"
-#include "Document_Reader.h"
-#include "Document_Writer.h"
-#include "Mesh_Reader.h"
-#include "Mesh_Writer.h"
-
-#include "DriverDAT_R_SMESHDS_Document.h"
-#include "DriverMED_R_SMESHDS_Document.h"
-#include "DriverUNV_R_SMESHDS_Document.h"
-#include "DriverDAT_W_SMESHDS_Document.h"
-#include "DriverMED_W_SMESHDS_Document.h"
-#include "DriverUNV_W_SMESHDS_Document.h"
-#include "DriverDAT_R_SMESHDS_Mesh.h"
-#include "DriverMED_R_SMESHDS_Mesh.h"
-#include "DriverUNV_R_SMESHDS_Mesh.h"
-#include "DriverDAT_W_SMESHDS_Mesh.h"
-#include "DriverMED_W_SMESHDS_Mesh.h"
-#include "DriverUNV_W_SMESHDS_Mesh.h"
-
 // QT Includes
 #define         INCLUDE_MENUITEM_DEF
 #include <qapplication.h>
@@ -237,8 +217,6 @@ SMESHGUI *SMESHGUI::GetOrCreateSMESHGUI(QAD_Desktop * desktop)
                smeshGUI->myStudyAPI =
                        SMESHGUI_StudyAPI(smeshGUI->myStudy, smeshGUI->myComponentMesh);
 
-               smeshGUI->myDocument = new SMESHDS_Document(1); //NBU
-
                smeshGUI->mySimulationActors = vtkActorCollection::New();
                smeshGUI->mySimulationActors2D = vtkActor2DCollection::New();
        }
@@ -2104,8 +2082,7 @@ bool SMESHGUI::OnGUIEvent(int theCommandID, QAD_Desktop * parent)
        case 112:
        case 111:
        {
-               Import_Document(parent, theCommandID);  //NBU
-               //Import_Mesh(parent,theCommandID);
+               smeshGUI->Import_Document(parent, theCommandID);
                break;
        }
 
@@ -3503,58 +3480,6 @@ SALOMEDS::Study::ListOfSObject *
  *
  */
 //=============================================================================
-void SMESHGUI::Import_Mesh(QAD_Desktop * parent, int theCommandID)
-{
-       QString filter;
-       string myExtension;
-       Mesh_Reader *myReader;
-
-       if (theCommandID == 113)
-       {
-               filter = tr("MED files (*.med)");
-               myExtension = string("MED");
-               myReader = new DriverMED_R_SMESHDS_Mesh;
-       }
-       else if (theCommandID == 112)
-       {
-               filter = tr("IDEAS files (*.unv)");
-               myExtension = string("UNV");
-       }
-       else if (theCommandID == 111)
-       {
-               filter = tr("DAT files (*.dat)");
-               myExtension = string("MED");
-               myReader = new DriverDAT_R_SMESHDS_Mesh;
-       }
-
-       QString filename = QAD_FileDlg::getFileName(parent,
-               "",
-               filter,
-               tr("Import mesh"),
-               true);
-       if (!filename.isEmpty())
-       {
-               QApplication::setOverrideCursor(Qt::waitCursor);
-               string myClass = string("SMESHDS_Mesh");
-//    Mesh_Reader* myReader = SMESHDriver::GetMeshReader(myExtension, myClass);
-
-               int myMeshId = (smeshGUI->myDocument)->NewMesh();
-               SMDS_Mesh *myMesh = (smeshGUI->myDocument)->GetMesh(myMeshId);
-
-               myReader->SetFile(string(filename.latin1()));
-               myReader->SetMesh(myMesh);
-               myReader->SetMeshId(myMeshId);
-               myReader->Read();
-
-               QApplication::restoreOverrideCursor();
-       }
-}
-
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
 void SMESHGUI::Export_Mesh(QAD_Desktop * parent, int theCommandID)
 {
        SALOME_Selection *Sel =
@@ -3577,7 +3502,7 @@ void SMESHGUI::Export_Mesh(QAD_Desktop * parent, int theCommandID)
                                if (!filename.isEmpty())
                                {
                                        QApplication::setOverrideCursor(Qt::waitCursor);
-                                       aMesh->ExportMED(filename.latin1());
+                                       aMesh->Export(filename.latin1(), "MED");
                                        QApplication::restoreOverrideCursor();
                                }
                        }
@@ -3591,7 +3516,7 @@ void SMESHGUI::Export_Mesh(QAD_Desktop * parent, int theCommandID)
                                if (!filename.isEmpty())
                                {
                                        QApplication::setOverrideCursor(Qt::waitCursor);
-                                       aMesh->ExportDAT(filename.latin1());
+                                       aMesh->Export(filename.latin1(), "DAT");
                                        QApplication::restoreOverrideCursor();
                                }
                        }
@@ -3605,11 +3530,11 @@ void SMESHGUI::Export_Mesh(QAD_Desktop * parent, int theCommandID)
                                if (!filename.isEmpty())
                                {
                                        QApplication::setOverrideCursor(Qt::waitCursor);
-                                       aMesh->ExportUNV(filename.latin1());
+                                       aMesh->Export(filename.latin1(), "UNV");
                                        QApplication::restoreOverrideCursor();
                                }
                                else
-                                       aMesh->ExportDAT(filename.latin1());
+                                       aMesh->Export(filename.latin1(), "DAT");
 
                                QApplication::restoreOverrideCursor();
 
@@ -3642,90 +3567,49 @@ void SMESHGUI::Import_Document(QAD_Desktop * parent, int theCommandID)
 {
        QString filter;
        string myExtension;
-       Document_Reader *myReader;
 
        if (theCommandID == 113)
        {
                filter = tr("MED files (*.med)");
                myExtension = string("MED");
-               myReader = new DriverMED_R_SMESHDS_Document;
        }
        else if (theCommandID == 112)
        {
                filter = tr("IDEAS files (*.unv)");
                myExtension = string("UNV");
-               myReader = new DriverUNV_R_SMESHDS_Document;
        }
        else if (theCommandID == 111)
        {
                filter = tr("DAT files (*.dat)");
                myExtension = string("DAT");
-               myReader = new DriverDAT_R_SMESHDS_Document;
-       }
-
-       QString filename = QAD_FileDlg::getFileName(parent,
-               "",
-               filter,
-               tr("Import document"),
-               true);
-       if (!filename.isEmpty())
-       {
-               QApplication::setOverrideCursor(Qt::waitCursor);
-               string myClass = string("SMESHDS_Document");
-//    Document_Reader* myReader = SMESHDriver::GetDocumentReader(myExtension, myClass);
-               SMESHDS_Document *newDocument = new SMESHDS_Document(1);
-
-               myReader->SetFile(string(filename.latin1()));
-               myReader->SetDocument(smeshGUI->myDocument);
-               myReader->Read();
-               QApplication::restoreOverrideCursor();
        }
-}
 
-void SMESHGUI::Export_Document(QAD_Desktop * parent, int theCommandID)
-{
-       QString filter;
-       Document_Writer *myWriter;
-       string myExtension;
+       QString filename = QAD_FileDlg::getFileName(parent, "", filter,
+               tr("Import document"), true);
 
-       if (theCommandID == 122)
-       {
-               filter = tr("MED files (*.med)");
-               myExtension = string("MED");
-               myWriter = new DriverMED_W_SMESHDS_Document;
-       }
-       else if (theCommandID == 121)
-       {
-               filter = tr("DAT files (*.dat)");
-               myExtension = string("DAT");
-               myWriter = new DriverDAT_W_SMESHDS_Document;
-       }
-       else if (theCommandID == 123)
-       {
-               filter = tr("IDEAS files (*.unv)");
-               myExtension = string("UNV");
-               myWriter = new DriverUNV_W_SMESHDS_Document;
-       }
-
-       QString filename = QAD_FileDlg::getFileName(parent,
-               "",
-               filter,
-               tr("Export document"),
-               false);
        if (!filename.isEmpty())
        {
                QApplication::setOverrideCursor(Qt::waitCursor);
-               string myClass = string("SMESHDS_Document");
-               //Document_Writer* myWriter = SMESHDriver::GetDocumentWriter(myExtension, myClass);
-
-               myWriter->SetFile(string(filename.latin1()));
-               myWriter->SetDocument(smeshGUI->myDocument);
-
-               //StudyContextStruct* myStudyContext = _impl.GetStudyContext(myStudyId);
-               //Handle(SMESHDS_Document) myDocument = myStudyContext->myDocument;
-               //myWriter->SetDocument(myDocument);
-
-               myWriter->Write();
+               try
+               {
+                       if (!myComponentMesh->_is_nil())
+                       {
+                               SMESH::SMESH_Mesh_var aMesh =
+                                       myComponentMesh->Import(myStudyId, filename.latin1(),
+                                       myExtension.c_str());
+       
+                               if (!aMesh->_is_nil())
+                               {
+                                       SALOMEDS::SObject_var SM = myStudyAPI.AddNewMesh(aMesh);
+                                       myStudyAPI.SetName(SM, filename);
+                               }
+                       }
+               }
+               catch(const SALOME::SALOME_Exception & S_ex)
+               {
+                       QtCatchCorbaException(S_ex);
+               }
+               myActiveStudy->updateObjBrowser(true);
                QApplication::restoreOverrideCursor();
        }
 }
@@ -3817,9 +3701,6 @@ bool SMESHGUI::SetSettings(QAD_Desktop * parent)
                smeshGUI->myAutomaticUpdate = false;
        }
 
-       /* menus disable */
-       parent->menuBar()->setItemEnabled(11, false);   // IMPORT
-
        return true;
 }
 
@@ -4098,13 +3979,13 @@ bool SMESHGUI::CustomPopup(QAD_Desktop * parent,
        return false;
 }
 
-//=============================================================================
-/*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
- *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
+/**
+ * Ensures that the actor for the given <theIO> exists in the active VTK view
+ * @TODO Handle multiple selection.
  */
-//=============================================================================
 void SMESHGUI::BuildPresentation(const Handle(SALOME_InteractiveObject) & theIO)
 {
+       MESSAGE("SMESHGUI::BuildPresentation("<<theIO->getEntry()<<")");
        /* Create or retrieve an object SMESHGUI */
        SMESHGUI::GetOrCreateSMESHGUI(QAD_Application::getDesktop());
 
@@ -4113,7 +3994,8 @@ void SMESHGUI::BuildPresentation(const Handle(SALOME_InteractiveObject) & theIO)
        if (activeFrame->getTypeView() == VIEW_VTK)
        {
                // VTK
-               SALOMEDS::SObject_var fatherSF =
+               // Some ideas to handle multiple selection...
+               /*SALOMEDS::SObject_var fatherSF =
                        smeshGUI->myStudy->FindObjectID(activeFrame->entry());
 
                SALOME_Selection *Sel =
@@ -4121,8 +4003,8 @@ void SMESHGUI::BuildPresentation(const Handle(SALOME_InteractiveObject) & theIO)
                        getSelection());
                SALOME_ListIteratorOfListIO It(Sel->StoredIObjects());
 
-//    for(;It.More();It.Next()) {
-//      Handle(SALOME_InteractiveObject) IObject = It.Value();
+           for(;It.More();It.Next()) {
+      Handle(SALOME_InteractiveObject) IObject = It.Value();*/
                Handle(SALOME_InteractiveObject) IObject = theIO;
                if (IObject->hasEntry())
                {
@@ -4130,42 +4012,39 @@ void SMESHGUI::BuildPresentation(const Handle(SALOME_InteractiveObject) & theIO)
                        Standard_Boolean res;
                        SMESH_Actor *ac =
                                smeshGUI->FindActorByEntry(IObject->getEntry(), res, false);
-
-                       // Actor not found at all -> mesh is not computed -> do nothing!!!
+                       
                        if (!res)
                        {
-                               /*SMESH::SMESH_Mesh_var aM;
-                                * SALOMEDS::SObject_var aMorSM = smeshGUI->myStudy->FindObjectID( IObject->getEntry() );
-                                * SALOMEDS::SObject_var father = aMorSM->GetFather();
-                                * SALOMEDS::SObject_var fatherComp = aMorSM->GetFatherComponent();
-                                * 
-                                * // Non-displayable objects (Hypo, Algo) have tags < 3 or have a father different from component
-                                * if (aMorSM->Tag() < 3 || strcmp(father->GetID(), fatherComp->GetID()) != 0)
-                                * continue;
-                                * 
-                                * SALOMEDS::GenericAttribute_var anAttr;
-                                * SALOMEDS::AttributeIOR_var     anIOR;
-                                * if ( !aMorSM->_is_nil() ) {
-                                * if (aMorSM->FindAttribute(anAttr, "AttributeIOR") ) {
-                                * anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
-                                * aM = SMESH::SMESH_Mesh::_narrow( _orb->string_to_object(anIOR->Value()) );
-                                * }
-                                * }
-                                * 
-                                * if (!aM->_is_nil()) {
-                                * smeshGUI->InitActor(aM);
-                                * ac = smeshGUI->ReadScript(aM);
-                                * }
-                                * 
-                                * if (ac) {
-                                * smeshGUI->DisplayActor( ac, true );
-                                * smeshGUI->DisplayEdges( ac ); 
-                                * smeshGUI->ChangeRepresentation( ac, ac->getDisplayMode() );
-                                * } */
-//    continue;
+                               SALOMEDS::SObject_var aMorSM=smeshGUI->myStudy->FindObjectID( IObject->getEntry());
+                               SALOMEDS::GenericAttribute_var anAttr;
+                               SALOMEDS::AttributeIOR_var     anIOR;
+                               if(aMorSM->FindAttribute(anAttr, "AttributeIOR"))
+                               {
+                                       anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
+                                       SMESH::SMESH_Mesh_var aM =
+                                               SMESH::SMESH_Mesh::_narrow( _orb->string_to_object(anIOR->Value()));
+                                       if(!aM->_is_nil())
+                                       {
+                                               smeshGUI->InitActor(aM);
+                                               ac = smeshGUI->ReadScript(aM);
+                                               smeshGUI->DisplayActor( ac, true );
+                                               smeshGUI->DisplayEdges( ac );
+                                               smeshGUI->ChangeRepresentation( ac, ac->getDisplayMode() );
+                                       }
+                                       else
+                                       {
+                                               MESSAGE("Do not know how to display something which is not a SMESH_Mesh");
+                                       }
+                               }
+                               else
+                               {
+                                       MESSAGE("The object "<<theIO->getEntry()<<
+                                               " do not have \"AttributeIOR\" attribute");
+                               }
                        }
                        else
-                       {                                       // The actor exists in some view
+                       {
+                               // The actor exists in some view
                                // Check whether the actor belongs to the active view
                                VTKViewer_RenderWindowInteractor *rwInter =
                                        ((VTKViewer_ViewFrame *) activeFrame->getRightFrame()->
@@ -4188,12 +4067,11 @@ void SMESHGUI::BuildPresentation(const Handle(SALOME_InteractiveObject) & theIO)
                                smeshGUI->ChangeRepresentation(ac, ac->getDisplayMode());
                        }
                }
-//    }
        }
        else
        {
-       MESSAGE
-                       ("BuildPresentation() must not be called while non-VTK view is active")}
+               MESSAGE("BuildPresentation() must not be called while non-VTK view is active");
+       }
 }
 
 //=============================================================================
@@ -4216,13 +4094,14 @@ void SMESHGUI::setOrb()
        ASSERT(!CORBA::is_nil(_orb));
 }
 
-//=============================================================================
-/*!
- *
+/**
+ * Get the history of all commands made in the SMESH server. This list of command
+ * is used to display the mesh in the VTK view
+ * @TODO Handle the REMOVE_ALL command.
  */
-//=============================================================================
 SMESH_Actor *SMESHGUI::ReadScript(SMESH::SMESH_Mesh_ptr aMesh)
 {
+       MESSAGE("SMESHGUI::ReadScript");
        SMESH_Actor *MeshActor;
        if (!aMesh->_is_nil())
        {
@@ -4231,11 +4110,8 @@ SMESH_Actor *SMESHGUI::ReadScript(SMESH::SMESH_Mesh_ptr aMesh)
                if (result)
                {
                        SMESH::log_array_var aSeq = aMesh->GetLog(true);
-
-                       if (aSeq->length() == 0)
-                       {
-                               MESSAGE("ReadScript(): log is empty") return MeshActor;
-                       }
+                       MESSAGE("SMESHGUI::ReadScript: The log contains "<<aSeq->length()
+                               <<" commands.");
 
                        for (unsigned int ind = 0; ind < aSeq->length(); ind++)
                        {
@@ -4296,6 +4172,10 @@ SMESH_Actor *SMESHGUI::ReadScript(SMESH::SMESH_Mesh_ptr aMesh)
                                                aSeq[ind].coords, aSeq[ind].indexes);
                                        break;
                                }
+                               case SMESH::REMOVE_ALL:
+                                       MESSAGE("REMOVE_ALL command not yet implemented");
+                                       break;
+                               default: MESSAGE("Warning: Unknown script command.");
                                }
                        }
                        return MeshActor;
@@ -4348,6 +4228,7 @@ void SMESHGUI::Dump(SMESH_Actor * Mactor)
 void SMESHGUI::AddNodes(SMESH_Actor * Mactor, int number,
        const SMESH::double_array & coords, const SMESH::long_array & indexes)
 {
+       MESSAGE("SMESHGUI::AddNodes(number="<<number<<", indexes.length()="<<indexes.length()<<")");
        QApplication::setOverrideCursor(Qt::waitCursor);
        if (Mactor->GetMapper() == NULL)
        {
@@ -4405,8 +4286,9 @@ void SMESHGUI::AddNode(SMESH_Actor * Mactor, int idnode, float x, float y,
        float z)
 {
        QApplication::setOverrideCursor(Qt::waitCursor);
-       MESSAGE("SMESHGUI::AddNode " << idnode << " : " << x << ";" << y << ";" <<
-               z) if (Mactor->GetMapper() == NULL)
+       MESSAGE("SMESHGUI::AddNode " << idnode << " : " << x << ";" << y << ";" << z);
+       
+       if (Mactor->GetMapper() == NULL)
        {
                vtkPoints *Pts = vtkPoints::New();
                int idVTK = Pts->InsertNextPoint(x, y, z);
@@ -5067,6 +4949,9 @@ void SMESHGUI::AddEdge(SMESH_Actor * Mactor, int idedge, int idnode1,
 void SMESHGUI::AddTriangles(SMESH_Actor * Mactor, int number,
        const SMESH::double_array & coords, const SMESH::long_array & indexes)
 {
+       MESSAGE("SMESHGUI::AddTriangles(number="<<number<<", indexes.length="
+               <<indexes.length()<<")");
+
        QApplication::setOverrideCursor(Qt::waitCursor);
        //vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
        SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
@@ -6011,6 +5896,7 @@ void SMESHGUI::InitActor(SMESH::SMESH_Mesh_ptr aMesh)
 //=============================================================================
 void SMESHGUI::Update()
 {
+       MESSAGE("SMESHGUI::Update");
        if (myActiveStudy->getActiveStudyFrame()->getTypeView() == VIEW_VTK)
        {                                                       //VTK
                vtkRenderer *theRenderer =
index ee29287..fdcbe7c 100644 (file)
@@ -88,8 +88,6 @@ private :
 
   //  vtkScalarBarActor*    myScalarBar;
 
-  SMESHDS_Document *        myDocument;//NBU
-
   bool                      myAutomaticUpdate;
 
 public :
@@ -303,9 +301,7 @@ public :
   static void setOrb();
 
   /* Import/Export */ //NBU
-  static void Import_Document(QAD_Desktop* parent, int theCommandID);
-  static void Export_Document(QAD_Desktop* parent, int theCommandID);
-  static void Import_Mesh(QAD_Desktop* parent, int theCommandID);
+  void Import_Document(QAD_Desktop* parent, int theCommandID);
   static void Export_Mesh(QAD_Desktop* parent, int theCommandID);
 
 signals:
index 42e2724..a205272 100644 (file)
@@ -99,7 +99,7 @@ SMESHGUI_StudyAPI::SMESHGUI_StudyAPI ( SALOMEDS::Study_ptr aStudy,
   // NRI
 
   SALOMEDS::SComponent_var father = aStudy->FindComponent("MESH");
-  SALOMEDS::GenericAttribute_var anAttr;
+  /*SALOMEDS::GenericAttribute_var anAttr;
   SALOMEDS::AttributeName_var    aName;
   SALOMEDS::AttributePixMap_var  aPixmap;
   
@@ -115,7 +115,7 @@ SMESHGUI_StudyAPI::SMESHGUI_StudyAPI ( SALOMEDS::Study_ptr aStudy,
   aPixmap->SetPixMap( "ICON_OBJBROWSER_SMESH" );
   
   myStudyBuilder->DefineComponentInstance(father, CompMesh );
-  mySComponentMesh = SALOMEDS::SComponent::_narrow( father );
+  mySComponentMesh = SALOMEDS::SComponent::_narrow( father );*/
 }
 
 //=======================================================================
index b55ed35..773deda 100644 (file)
@@ -55,14 +55,7 @@ using namespace std;
 #include "SMESH_MaxElementArea_i.hxx"
 #include "SMESH_MaxElementVolume_i.hxx"
 
-#include "SMESHDS_Document.hxx"
-
-#include "Document_Reader.h"
-#include "DriverMED_W_SMESHDS_Mesh.h"
-#include "DriverMED_R_SMESHDS_Mesh.h"
-#include "DriverMED_R_SMESHDS_Document.h"
-#include "DriverUNV_R_SMESHDS_Document.h"
-#include "DriverDAT_R_SMESHDS_Document.h"
+#include "SMESHDriver.h"
 
 #include "Utils_CorbaException.hxx"
 #include "utilities.h"
@@ -82,10 +75,10 @@ using namespace std;
 #define NUM_TMP_FILES 4
 
 // Tags definition 
-long Tag_HypothesisRoot  = 1;
-long Tag_AlgorithmsRoot  = 2;
+long Tag_HypothesisRoot = 1;
+long Tag_AlgorithmsRoot = 2;
 
-long Tag_RefOnShape      = 1;
+long Tag_RefOnShape = 1;
 long Tag_RefOnAppliedHypothesis = 2;
 long Tag_RefOnAppliedAlgorithms = 3;
 
@@ -95,7 +88,6 @@ long Tag_SubMeshOnFace = 6;
 long Tag_SubMeshOnSolid = 7;
 long Tag_SubMeshOnCompound = 8;
 
-
 //=============================================================================
 /*!
  *  default constructor: not for use
@@ -104,8 +96,8 @@ long Tag_SubMeshOnCompound = 8;
 
 SMESH_Gen_i::SMESH_Gen_i()
 {
-  MESSAGE("SMESH_Gen_i default constructor");
-  // ****
+       MESSAGE("SMESH_Gen_i default constructor");
+       // ****
 }
 
 //=============================================================================
@@ -115,18 +107,18 @@ SMESH_Gen_i::SMESH_Gen_i()
 //=============================================================================
 
 SMESH_Gen_i::SMESH_Gen_i(CORBA::ORB_ptr orb,
-              PortableServer::POA_ptr poa,
-              PortableServer::ObjectId * contId, 
-              const char *instanceName, 
-                         const char *interfaceName) :
-  Engines_Component_i(orb, poa, contId, instanceName, interfaceName)
+       PortableServer::POA_ptr poa,
+       PortableServer::ObjectId * contId,
+       const char *instanceName,
+       const char *interfaceName):Engines_Component_i(orb, poa, contId,
+       instanceName, interfaceName)
 {
-  MESSAGE("activate object");
-  _thisObj = this ;
-  _id = _poa->activate_object(_thisObj);
+       MESSAGE("activate object");
+       _thisObj = this;
+       _id = _poa->activate_object(_thisObj);
 
-  _ShapeReader = NULL;
-  _localId = 0;  // number of created objects & local id 
+       _ShapeReader = NULL;
+       _localId = 0;                           // number of created objects & local id 
 
 }
 
@@ -138,43 +130,40 @@ SMESH_Gen_i::SMESH_Gen_i(CORBA::ORB_ptr orb,
 
 SMESH_Gen_i::~SMESH_Gen_i()
 {
-  MESSAGE("~SMESH_Gen_i");
-  // ****
+       MESSAGE("~SMESH_Gen_i");
+       // ****
 }
-  
+
 //=============================================================================
 /*!
  *  
  */
 //=============================================================================
 
-SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis(const char* anHyp,
-                                                          CORBA::Long studyId)
-  throw (SALOME::SALOME_Exception)
+SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis(const char *anHyp,
+       CORBA::Long studyId) throw(SALOME::SALOME_Exception)
 {
-  MESSAGE("CreateHypothesis");
-
-  // create a new hypothesis object servant
-
-  SMESH_Hypothesis_i* myHypothesis_i = 0;
-  try
-    {
-      myHypothesis_i = _hypothesisFactory_i.Create(anHyp,
-                                                   studyId,
-                                                   &_impl);
-    }
-  catch (SALOME_Exception& S_ex)
-    {
-      THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
-    }
-
-  // activate the CORBA servant of hypothesis
-
-  SMESH::SMESH_Hypothesis_var hypothesis_i
-    = SMESH::SMESH_Hypothesis::_narrow(myHypothesis_i->_this());
-  return SMESH::SMESH_Hypothesis::_duplicate(hypothesis_i);
+       MESSAGE("CreateHypothesis");
+
+       // create a new hypothesis object servant
+
+       SMESH_Hypothesis_i *myHypothesis_i = 0;
+       try
+       {
+               myHypothesis_i = _hypothesisFactory_i.Create(anHyp, studyId, &_impl);
+       }
+       catch(SALOME_Exception & S_ex)
+       {
+               THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
+       }
+
+       // activate the CORBA servant of hypothesis
+
+       SMESH::SMESH_Hypothesis_var hypothesis_i
+               = SMESH::SMESH_Hypothesis::_narrow(myHypothesis_i->_this());
+       return SMESH::SMESH_Hypothesis::_duplicate(hypothesis_i);
 }
-  
+
 //=============================================================================
 /*!
  *  
@@ -182,70 +171,64 @@ SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis(const char* anHyp,
 //=============================================================================
 
 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::Init(GEOM::GEOM_Gen_ptr geomEngine,
-                                        CORBA::Long studyId,
-                                        GEOM::GEOM_Shape_ptr aShape)
-  throw (SALOME::SALOME_Exception)
+       CORBA::Long studyId,
+       GEOM::GEOM_Shape_ptr aShape) throw(SALOME::SALOME_Exception)
 {
-  MESSAGE("Init");
-  // _narrow() duplicates the reference and checks the type
-  GEOM::GEOM_Gen_var geom = GEOM::GEOM_Gen::_narrow(geomEngine);
-  GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(aShape);
-
-  if (CORBA::is_nil(geom))
-    THROW_SALOME_CORBA_EXCEPTION("bad geom reference", \
-                                 SALOME::BAD_PARAM);
-  if (CORBA::is_nil(myShape))
-    THROW_SALOME_CORBA_EXCEPTION("bad shape reference", \
-                                 SALOME::BAD_PARAM);
-
-  // Get or create the GEOM_Client instance
-
-  SMESH_Mesh_i* meshServant = 0;
-  try
-    {
-      if (! _ShapeReader) _ShapeReader = new GEOM_Client();
-      ASSERT(_ShapeReader);
-      
-      // explore main Shape, get local TopoDS_Shapes of all subShapes
-      //  SMESH_topo* myTopo = ExploreMainShape(geom, studyId, myShape);
-      
-      // Get studyContext_i, create it if it does'nt exist
-      
-      if (_mapStudyContext_i.find(studyId) == _mapStudyContext_i.end())
-        {
-          _mapStudyContext_i[studyId] = new StudyContext_iStruct;      
-        }
-      StudyContext_iStruct* myStudyContext = _mapStudyContext_i[studyId];
-      
-      // create a new mesh object servant, store it in a map in study context
-      
-      meshServant = new SMESH_Mesh_i(this,
-                                     geom,
-                                     studyId,
-                                     _localId);
-      myStudyContext->mapMesh_i[_localId] = meshServant;
-      _localId++;
-
-      // create a new mesh object
-      
-      TopoDS_Shape myLocShape  = _ShapeReader->GetShape(geom,myShape);
-      meshServant->SetImpl(_impl.Init(studyId, myLocShape));
-    }
-  catch (SALOME_Exception& S_ex)
-    {
-      THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
-    }
-
-  // activate the CORBA servant of Mesh
-  
-  SMESH::SMESH_Mesh_var mesh
-    = SMESH::SMESH_Mesh::_narrow(meshServant->_this());
-  
-  meshServant->SetIor(mesh);
-
-  return SMESH::SMESH_Mesh::_duplicate(mesh);
+       MESSAGE("Init");
+       // _narrow() duplicates the reference and checks the type
+       GEOM::GEOM_Gen_var geom = GEOM::GEOM_Gen::_narrow(geomEngine);
+       GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(aShape);
+
+       if (CORBA::is_nil(geom))
+               THROW_SALOME_CORBA_EXCEPTION("bad geom reference", SALOME::BAD_PARAM);
+       if (CORBA::is_nil(myShape))
+               THROW_SALOME_CORBA_EXCEPTION("bad shape reference", SALOME::BAD_PARAM);
+
+       // Get or create the GEOM_Client instance
+
+       SMESH_Mesh_i *meshServant = 0;
+       try
+       {
+               if (!_ShapeReader)
+                       _ShapeReader = new GEOM_Client();
+               ASSERT(_ShapeReader);
+
+               // explore main Shape, get local TopoDS_Shapes of all subShapes
+               //  SMESH_topo* myTopo = ExploreMainShape(geom, studyId, myShape);
+
+               // Get studyContext_i, create it if it does'nt exist
+
+               if (_mapStudyContext_i.find(studyId) == _mapStudyContext_i.end())
+               {
+                       _mapStudyContext_i[studyId] = new StudyContext_iStruct;
+               }
+               StudyContext_iStruct *myStudyContext = _mapStudyContext_i[studyId];
+
+               // create a new mesh object servant, store it in a map in study context
+
+               meshServant = new SMESH_Mesh_i(this, geom, studyId, _localId);
+               myStudyContext->mapMesh_i[_localId] = meshServant;
+               _localId++;
+
+               // create a new mesh object
+
+               TopoDS_Shape myLocShape = _ShapeReader->GetShape(geom, myShape);
+               meshServant->SetImpl(_impl.Init(studyId, myLocShape));
+       }
+       catch(SALOME_Exception & S_ex)
+       {
+               THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
+       }
+
+       // activate the CORBA servant of Mesh
+
+       SMESH::SMESH_Mesh_var mesh
+               = SMESH::SMESH_Mesh::_narrow(meshServant->_this());
+
+       meshServant->SetIor(mesh);
+
+       return SMESH::SMESH_Mesh::_duplicate(mesh);
 }
-  
 
 //=============================================================================
 /*!
@@ -254,11 +237,10 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::Init(GEOM::GEOM_Gen_ptr geomEngine,
 //=============================================================================
 
 CORBA::Boolean SMESH_Gen_i::IsReadyToCompute(SMESH::SMESH_Mesh_ptr aMesh,
-                                             GEOM::GEOM_Shape_ptr aShape)
-  throw (SALOME::SALOME_Exception)
+       GEOM::GEOM_Shape_ptr aShape) throw(SALOME::SALOME_Exception)
 {
-  MESSAGE("SMESH_Gen_i::IsReadyToCompute");
-  return true;
+       MESSAGE("SMESH_Gen_i::IsReadyToCompute");
+       return true;
 }
 
 //=============================================================================
@@ -267,79 +249,80 @@ CORBA::Boolean SMESH_Gen_i::IsReadyToCompute(SMESH::SMESH_Mesh_ptr aMesh,
  */
 //=============================================================================
 
-  SMESH::long_array* 
-  SMESH_Gen_i::GetSubShapesId(GEOM::GEOM_Gen_ptr geomEngine,
-                              CORBA::Long studyId,
-                              GEOM::GEOM_Shape_ptr mainShape,
-                              const SMESH::shape_array& listOfSubShape)
-    throw (SALOME::SALOME_Exception)
+SMESH::long_array *
+       SMESH_Gen_i::GetSubShapesId(GEOM::GEOM_Gen_ptr geomEngine,
+       CORBA::Long studyId,
+       GEOM::GEOM_Shape_ptr mainShape,
+       const SMESH::shape_array & listOfSubShape)throw(SALOME::SALOME_Exception)
 {
-  MESSAGE("SMESH_Gen_i::GetSubShapesId");
-  SMESH::long_array_var shapesId = new SMESH::long_array;
-  set<int> setId;
-
-  GEOM::GEOM_Gen_var geom = GEOM::GEOM_Gen::_narrow(geomEngine);
-  GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(mainShape);
-
-  if (CORBA::is_nil(geom))
-    THROW_SALOME_CORBA_EXCEPTION("bad geom reference", \
-                                 SALOME::BAD_PARAM);
-  if (CORBA::is_nil(myShape))
-    THROW_SALOME_CORBA_EXCEPTION("bad shape reference", \
-                                 SALOME::BAD_PARAM);
-
-  try
-    {
-      if (! _ShapeReader) _ShapeReader = new GEOM_Client();
-      ASSERT(_ShapeReader);
-      TopoDS_Shape myMainShape  = _ShapeReader->GetShape(geom,myShape);
-      TopTools_IndexedMapOfShape myIndexToShape;      
-      TopExp::MapShapes(myMainShape,myIndexToShape);
-
-      for (int i=0; i<listOfSubShape.length(); i++)
+       MESSAGE("SMESH_Gen_i::GetSubShapesId");
+       SMESH::long_array_var shapesId = new SMESH::long_array;
+       set < int >setId;
+
+       GEOM::GEOM_Gen_var geom = GEOM::GEOM_Gen::_narrow(geomEngine);
+       GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(mainShape);
+
+       if (CORBA::is_nil(geom))
+               THROW_SALOME_CORBA_EXCEPTION("bad geom reference", SALOME::BAD_PARAM);
+       if (CORBA::is_nil(myShape))
+               THROW_SALOME_CORBA_EXCEPTION("bad shape reference", SALOME::BAD_PARAM);
+
+       try
        {
-         GEOM::GEOM_Shape_var aShape
-           = GEOM::GEOM_Shape::_narrow(listOfSubShape[i]);
-         if (CORBA::is_nil(aShape))
-           THROW_SALOME_CORBA_EXCEPTION("bad shape reference", \
-                                        SALOME::BAD_PARAM);
-         TopoDS_Shape locShape  = _ShapeReader->GetShape(geom,aShape);
-         for (TopExp_Explorer exp(locShape,TopAbs_FACE); exp.More(); exp.Next())
-           {
-             const TopoDS_Face& F = TopoDS::Face(exp.Current());
-             setId.insert(myIndexToShape.FindIndex(F));
-             SCRUTE(myIndexToShape.FindIndex(F));
-           }
-         for (TopExp_Explorer exp(locShape,TopAbs_EDGE); exp.More(); exp.Next())
-           {
-             const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
-             setId.insert(myIndexToShape.FindIndex(E));
-             SCRUTE(myIndexToShape.FindIndex(E));
-           }
-         for (TopExp_Explorer exp(locShape,TopAbs_VERTEX); exp.More(); exp.Next())
-           {
-             const TopoDS_Vertex& V = TopoDS::Vertex(exp.Current());
-             setId.insert(myIndexToShape.FindIndex(V));
-             SCRUTE(myIndexToShape.FindIndex(V));
-           }
+               if (!_ShapeReader)
+                       _ShapeReader = new GEOM_Client();
+               ASSERT(_ShapeReader);
+               TopoDS_Shape myMainShape = _ShapeReader->GetShape(geom, myShape);
+               TopTools_IndexedMapOfShape myIndexToShape;
+               TopExp::MapShapes(myMainShape, myIndexToShape);
+
+               for (unsigned int i = 0; i < listOfSubShape.length(); i++)
+               {
+                       GEOM::GEOM_Shape_var aShape
+                               = GEOM::GEOM_Shape::_narrow(listOfSubShape[i]);
+                       if (CORBA::is_nil(aShape))
+                               THROW_SALOME_CORBA_EXCEPTION("bad shape reference",
+                                       SALOME::BAD_PARAM);
+                       TopoDS_Shape locShape = _ShapeReader->GetShape(geom, aShape);
+                       for (TopExp_Explorer exp(locShape, TopAbs_FACE); exp.More();
+                               exp.Next())
+                       {
+                               const TopoDS_Face & F = TopoDS::Face(exp.Current());
+                               setId.insert(myIndexToShape.FindIndex(F));
+                               SCRUTE(myIndexToShape.FindIndex(F));
+                       }
+                       for (TopExp_Explorer exp(locShape, TopAbs_EDGE); exp.More();
+                               exp.Next())
+                       {
+                               const TopoDS_Edge & E = TopoDS::Edge(exp.Current());
+                               setId.insert(myIndexToShape.FindIndex(E));
+                               SCRUTE(myIndexToShape.FindIndex(E));
+                       }
+                       for (TopExp_Explorer exp(locShape, TopAbs_VERTEX); exp.More();
+                               exp.Next())
+                       {
+                               const TopoDS_Vertex & V = TopoDS::Vertex(exp.Current());
+                               setId.insert(myIndexToShape.FindIndex(V));
+                               SCRUTE(myIndexToShape.FindIndex(V));
+                       }
+               }
+               shapesId->length(setId.size());
+               set < int >::iterator iind;
+               int i = 0;
+               for (iind = setId.begin(); iind != setId.end(); iind++)
+               {
+                       SCRUTE((*iind));
+                       shapesId[i] = (*iind);
+                       SCRUTE(shapesId[i]);
+                       i++;
+               }
        }
-      shapesId->length(setId.size());
-      set<int>::iterator iind;
-      int i=0;
-      for (iind = setId.begin(); iind != setId.end(); iind++)
+       catch(SALOME_Exception & S_ex)
        {
-         SCRUTE((*iind));
-         shapesId[i] = (*iind);
-         SCRUTE(shapesId[i]);
-         i++;
+               THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
        }
-    }
-  catch (SALOME_Exception& S_ex)
-    {
-      THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
-    }
 
-  return shapesId._retn();
+       return shapesId._retn();
 }
 
 //=============================================================================
@@ -349,1110 +332,1297 @@ CORBA::Boolean SMESH_Gen_i::IsReadyToCompute(SMESH::SMESH_Mesh_ptr aMesh,
 //=============================================================================
 
 CORBA::Boolean SMESH_Gen_i::Compute(SMESH::SMESH_Mesh_ptr aMesh,
-                                    GEOM::GEOM_Shape_ptr aShape)
-  throw (SALOME::SALOME_Exception)
+       GEOM::GEOM_Shape_ptr aShape) throw(SALOME::SALOME_Exception)
 {
-  MESSAGE("SMESH_Gen_i::Compute");
-  GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(aShape);
-  if (CORBA::is_nil(myShape))
-    THROW_SALOME_CORBA_EXCEPTION("bad shape reference", \
-                                 SALOME::BAD_PARAM);
-
-  SMESH::SMESH_Mesh_var myMesh = SMESH::SMESH_Mesh::_narrow(aMesh);
-  if (CORBA::is_nil(myMesh))
-    THROW_SALOME_CORBA_EXCEPTION("bad Mesh reference", \
-                                 SALOME::BAD_PARAM);
-
-  bool ret = false;
-  try
-    {
-      
-      // get study context from studyId given by CORBA mesh object
-      
-      int studyId = myMesh->GetStudyId();
-      ASSERT(_mapStudyContext_i.find(studyId) != _mapStudyContext_i.end());
-      StudyContext_iStruct* myStudyContext = _mapStudyContext_i[studyId];
-      
-      // get local Mesh_i object with Id and study context 
-      
-      int meshId = myMesh->GetId();
-      ASSERT(myStudyContext->mapMesh_i.find(meshId) != myStudyContext->mapMesh_i.end());
-      SMESH_Mesh_i* meshServant = myStudyContext->mapMesh_i[meshId];
-      ASSERT(meshServant);
-      
-      // get local TopoDS_Shape
-      
-      GEOM::GEOM_Gen_var geom = meshServant->GetGeomEngine();
-      TopoDS_Shape myLocShape  = _ShapeReader->GetShape(geom,myShape);
-
-      // implementation compute
-      
-      ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
-      ret = _impl.Compute(myLocMesh, myLocShape);
-    }
-  catch (SALOME_Exception& S_ex)
-    {
-      MESSAGE("catch exception "<< S_ex.what());
-      return false;
+       MESSAGE("SMESH_Gen_i::Compute");
+       GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(aShape);
+       if (CORBA::is_nil(myShape))
+               THROW_SALOME_CORBA_EXCEPTION("bad shape reference", SALOME::BAD_PARAM);
+
+       SMESH::SMESH_Mesh_var myMesh = SMESH::SMESH_Mesh::_narrow(aMesh);
+       if (CORBA::is_nil(myMesh))
+               THROW_SALOME_CORBA_EXCEPTION("bad Mesh reference", SALOME::BAD_PARAM);
+
+       bool ret = false;
+       try
+       {
+
+               // get study context from studyId given by CORBA mesh object
+
+               int studyId = myMesh->GetStudyId();
+               ASSERT(_mapStudyContext_i.find(studyId) != _mapStudyContext_i.end());
+               StudyContext_iStruct *myStudyContext = _mapStudyContext_i[studyId];
+
+               // get local Mesh_i object with Id and study context 
+
+               int meshId = myMesh->GetId();
+               ASSERT(myStudyContext->mapMesh_i.find(meshId) !=
+                       myStudyContext->mapMesh_i.end());
+               SMESH_Mesh_i *meshServant = myStudyContext->mapMesh_i[meshId];
+               ASSERT(meshServant);
+
+               // get local TopoDS_Shape
+
+               GEOM::GEOM_Gen_var geom = meshServant->GetGeomEngine();
+               TopoDS_Shape myLocShape = _ShapeReader->GetShape(geom, myShape);
+
+               // implementation compute
+
+               ::SMESH_Mesh & myLocMesh = meshServant->GetImpl();
+               ret = _impl.Compute(myLocMesh, myLocShape);
+       }
+       catch(SALOME_Exception & S_ex)
+       {
+               MESSAGE("catch exception " << S_ex.what());
+               return false;
 //       THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
-    }
+       }
 
-  return ret;
+       return ret;
 }
 
-
 //=============================================================================
 /*!
  *  
  */
 //=============================================================================
 
-SALOMEDS::TMPFile* SMESH_Gen_i::Save(SALOMEDS::SComponent_ptr theComponent,
-                                    const char* theURL,
-                                    bool isMultiFile)
+SALOMEDS::TMPFile * SMESH_Gen_i::Save(SALOMEDS::SComponent_ptr theComponent,
+       const char *theURL, bool isMultiFile)
 {
-  MESSAGE("SMESH_Gen_i::SAVE");
-  SALOMEDS::Study_var Study = theComponent->GetStudy(); 
-  int studyId;
-  
-  // Declare a byte stream
-  SALOMEDS::TMPFile_var aStreamFile;
-  
-  // Obtain a temporary dir
-  TCollection_AsciiString tmpDir = (isMultiFile)?TCollection_AsciiString((char*)theURL):SALOMEDS_Tool::GetTmpDir();
-
-  // Create a sequence of files processed
-  SALOMEDS::ListOfFileNames_var aFileSeq = new SALOMEDS::ListOfFileNames;
-  aFileSeq->length(NUM_TMP_FILES);
-
-  TCollection_AsciiString aStudyName("");
-
-  // Set names of temporary files
-  TCollection_AsciiString filename = aStudyName + TCollection_AsciiString("_SMESH.hdf");
-  TCollection_AsciiString hypofile = aStudyName + TCollection_AsciiString("_SMESH_Hypo.txt");
-  TCollection_AsciiString algofile = aStudyName + TCollection_AsciiString("_SMESH_Algo.txt");
-  TCollection_AsciiString meshfile = aStudyName + TCollection_AsciiString("_SMESH_Mesh.med");
-  aFileSeq[0] = CORBA::string_dup(filename.ToCString());
-  aFileSeq[1] = CORBA::string_dup(hypofile.ToCString());
-  aFileSeq[2] = CORBA::string_dup(algofile.ToCString());
-  aFileSeq[3] = CORBA::string_dup(meshfile.ToCString());
-  filename = tmpDir + filename;
-  hypofile = tmpDir + hypofile;
-  algofile = tmpDir + algofile;
-  meshfile = tmpDir + meshfile;
-
-  HDFfile * hdf_file;
-  map <int,HDFgroup*> hdf_group, hdf_subgroup;
-  map <int,HDFdataset*> hdf_dataset;
-  FILE* destFile;
-
-  SALOMEDS::ChildIterator_var itBig,it,itSM;
-  SALOMEDS::SObject_var mySObject,myBranch,mySObjectChild;
-  hdf_size size[1];
-  int longueur,cmpt_ds = 0,cmpt_it;
-  char *name_group,name_dataset[30],name_meshgroup[30];
-  bool ok,_found;
-  int cmpt_sm = 0, myTag;
+       MESSAGE("SMESH_Gen_i::SAVE");
+       SALOMEDS::Study_var Study = theComponent->GetStudy();
+       int studyId;
+
+       // Declare a byte stream
+       SALOMEDS::TMPFile_var aStreamFile;
+
+       // Obtain a temporary dir
+       TCollection_AsciiString tmpDir =
+               (isMultiFile) ? TCollection_AsciiString((char *)theURL) :
+               SALOMEDS_Tool::GetTmpDir();
+
+       // Create a sequence of files processed
+       SALOMEDS::ListOfFileNames_var aFileSeq = new SALOMEDS::ListOfFileNames;
+       aFileSeq->length(NUM_TMP_FILES);
+
+       TCollection_AsciiString aStudyName("");
+
+       if (isMultiFile)
+               aStudyName =
+                       (SALOMEDS_Tool::GetNameFromPath(theComponent->GetStudy()->URL()));
+
+       // Set names of temporary files
+       TCollection_AsciiString filename =
+               aStudyName + TCollection_AsciiString("_SMESH.hdf");
+       TCollection_AsciiString hypofile =
+               aStudyName + TCollection_AsciiString("_SMESH_Hypo.txt");
+       TCollection_AsciiString algofile =
+               aStudyName + TCollection_AsciiString("_SMESH_Algo.txt");
+       TCollection_AsciiString meshfile =
+               aStudyName + TCollection_AsciiString("_SMESH_Mesh.med");
+       aFileSeq[0] = CORBA::string_dup(filename.ToCString());
+       aFileSeq[1] = CORBA::string_dup(hypofile.ToCString());
+       aFileSeq[2] = CORBA::string_dup(algofile.ToCString());
+       aFileSeq[3] = CORBA::string_dup(meshfile.ToCString());
+       filename = tmpDir + filename;
+       hypofile = tmpDir + hypofile;
+       algofile = tmpDir + algofile;
+       meshfile = tmpDir + meshfile;
+
+       HDFfile *hdf_file;
+       map < int, HDFgroup * >hdf_group, hdf_subgroup;
+       map < int, HDFdataset * >hdf_dataset;
+       FILE *destFile;
+
+       SALOMEDS::ChildIterator_var itBig, it, itSM;
+       SALOMEDS::SObject_var mySObject, myBranch, mySObjectChild;
+       hdf_size size[1];
+       int longueur, cmpt_ds = 0, cmpt_it;
+       char *name_group, name_dataset[30], name_meshgroup[30];
+       bool ok, _found;
+       int cmpt_sm = 0, myTag;
 
 //************* HDF file creation
-  hdf_file = new HDFfile(filename.ToCString());
-  hdf_file->CreateOnDisk();
+       hdf_file = new HDFfile(filename.ToCString());
+       hdf_file->CreateOnDisk();
 //****************************
 
-  itBig = Study->NewChildIterator(theComponent);
-  for (; itBig->More();itBig->Next()) {
-    SALOMEDS::SObject_var gotBranch = itBig->Value();
+       itBig = Study->NewChildIterator(theComponent);
+       SCRUTE(Tag_HypothesisRoot);
+       SCRUTE(Tag_AlgorithmsRoot);
+       for (; itBig->More(); itBig->Next())
+       {
+               SALOMEDS::SObject_var gotBranch = itBig->Value();
+               SCRUTE(gotBranch->Name());
+               SCRUTE(gotBranch->Tag());
+               SCRUTE(gotBranch->GetID());
 
 //************branch 1 : hypothesis
-    if (gotBranch->Tag()==Tag_HypothesisRoot) { //hypothesis = tag 1
-
-      double length,maxElementsArea,maxElementsVolume;
-      int numberOfSegments;
-
-      destFile = fopen( hypofile.ToCString() ,"w");
-      it = Study->NewChildIterator(gotBranch);
-      for (; it->More();it->Next()) {
-        mySObject = it->Value();
-        SALOMEDS::GenericAttribute_var anAttr;
-        SALOMEDS::AttributeIOR_var anIOR;
-        if ( mySObject->FindAttribute(anAttr, "AttributeIOR")) {
-          anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
-
-          SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(anIOR->Value()));
-          fprintf(destFile,"%s\n",myHyp->GetName());
-          
-          if (strcmp(myHyp->GetName(),"LocalLength")==0) {
-            SMESH::SMESH_LocalLength_var LL = SMESH::SMESH_LocalLength::_narrow( myHyp );
-            length = LL->GetLength();
-            fprintf(destFile,"%f\n",length);
-          }
-          else if (strcmp(myHyp->GetName(),"NumberOfSegments")==0) {
-            SMESH::SMESH_NumberOfSegments_var NOS = SMESH::SMESH_NumberOfSegments::_narrow( myHyp );
-            numberOfSegments = NOS->GetNumberOfSegments();
-            fprintf(destFile,"%d\n",numberOfSegments);
-          }
-          else if (strcmp(myHyp->GetName(),"MaxElementArea")==0) {
-            SMESH::SMESH_MaxElementArea_var MEA = SMESH::SMESH_MaxElementArea::_narrow( myHyp );
-            maxElementsArea = MEA->GetMaxElementArea();
-            fprintf(destFile,"%f\n",maxElementsArea);
-          }
-          else if (strcmp(myHyp->GetName(),"MaxElementVolume")==0) {
-            SMESH::SMESH_MaxElementVolume_var MEV = SMESH::SMESH_MaxElementVolume::_narrow( myHyp );
-            maxElementsVolume = MEV->GetMaxElementVolume();
-            fprintf(destFile,"%f\n",maxElementsVolume);
-          }
-        }
-      }
-      fclose(destFile);
+               if (gotBranch->Tag() == Tag_HypothesisRoot)
+               {                                               //hypothesis = tag 1
+                       double length, maxElementsArea, maxElementsVolume;
+                       int numberOfSegments;
+
+                       destFile = fopen(hypofile.ToCString(), "w");
+                       it = Study->NewChildIterator(gotBranch);
+                       for (; it->More(); it->Next())
+                       {
+                               mySObject = it->Value();
+                               SALOMEDS::GenericAttribute_var anAttr;
+                               SALOMEDS::AttributeIOR_var anIOR;
+                               if (mySObject->FindAttribute(anAttr, "AttributeIOR"))
+                               {
+                                       anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
+
+                                       SMESH::SMESH_Hypothesis_var myHyp =
+                                               SMESH::SMESH_Hypothesis::_narrow(_orb->
+                                               string_to_object(anIOR->Value()));
+                                       SCRUTE(myHyp->GetName());
+                                       fprintf(destFile, "%li\n", myHyp->GetId());
+                                       fprintf(destFile, "%s\n", myHyp->GetName());
+                                       if (strcmp(myHyp->GetName(), "LocalLength") == 0)
+                                       {
+                                               SMESH::SMESH_LocalLength_var LL =
+                                                       SMESH::SMESH_LocalLength::_narrow(myHyp);
+                                               length = LL->GetLength();
+                                               fprintf(destFile, "%f\n", length);
+                                       }
+                                       else if (strcmp(myHyp->GetName(), "NumberOfSegments") == 0)
+                                       {
+                                               SMESH::SMESH_NumberOfSegments_var NOS =
+                                                       SMESH::SMESH_NumberOfSegments::_narrow(myHyp);
+                                               numberOfSegments = NOS->GetNumberOfSegments();
+                                               fprintf(destFile, "%d\n", numberOfSegments);
+                                       }
+                                       else if (strcmp(myHyp->GetName(), "MaxElementArea") == 0)
+                                       {
+                                               SMESH::SMESH_MaxElementArea_var MEA =
+                                                       SMESH::SMESH_MaxElementArea::_narrow(myHyp);
+                                               maxElementsArea = MEA->GetMaxElementArea();
+                                               fprintf(destFile, "%f\n", maxElementsArea);
+                                       }
+                                       else if (strcmp(myHyp->GetName(), "MaxElementVolume") == 0)
+                                       {
+                                               SMESH::SMESH_MaxElementVolume_var MEV =
+                                                       SMESH::SMESH_MaxElementVolume::_narrow(myHyp);
+                                               maxElementsVolume = MEV->GetMaxElementVolume();
+                                               fprintf(destFile, "%f\n", maxElementsVolume);
+                                       }
+                               }
+                       }
+                       fclose(destFile);
 
 //writes the file name in the hdf file
-      longueur = hypofile.Length() +1;
-      name_group="Hypothesis";
-      //SCRUTE(name_group);
-      
-      size[0]=longueur;
-      hdf_group[1] = new HDFgroup(name_group,hdf_file);
-      hdf_group[1]->CreateOnDisk();
-      
-      hdf_dataset[cmpt_ds]=new HDFdataset(name_group,hdf_group[1],HDF_STRING,size,1);
-      hdf_dataset[cmpt_ds]->CreateOnDisk();
-      hdf_dataset[cmpt_ds]->WriteOnDisk(hypofile.ToCString());
-      hdf_dataset[cmpt_ds]->CloseOnDisk();
-      cmpt_ds++;
-      
-      hdf_group[1]->CloseOnDisk();
-      MESSAGE("End of Hypothesis Save");
-
-    }
+                       longueur = hypofile.Length() + 1;
+                       name_group = "Hypothesis";
+                       //SCRUTE(name_group);
+
+                       size[0] = longueur;
+                       hdf_group[1] = new HDFgroup(name_group, hdf_file);
+                       hdf_group[1]->CreateOnDisk();
+
+                       hdf_dataset[cmpt_ds] =
+                               new HDFdataset(name_group, hdf_group[1], HDF_STRING, size, 1);
+                       hdf_dataset[cmpt_ds]->CreateOnDisk();
+                       hdf_dataset[cmpt_ds]->WriteOnDisk(hypofile.ToCString());
+                       hdf_dataset[cmpt_ds]->CloseOnDisk();
+                       cmpt_ds++;
+
+                       hdf_group[1]->CloseOnDisk();
+                       MESSAGE("End of Hypothesis Save");
+
+               }
 //************branch 2 : algorithms
-    else if (gotBranch->Tag()==Tag_AlgorithmsRoot) {//algos = tag 2
-      
-      destFile = fopen( algofile.ToCString() ,"w");
-      it = Study->NewChildIterator(gotBranch);
-      for (; it->More();it->Next()) {
-        mySObject = it->Value();
-        SALOMEDS::GenericAttribute_var anAttr;
-        SALOMEDS::AttributeIOR_var anIOR;
-        if (mySObject->FindAttribute(anAttr, "AttributeIOR")) {
-          anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
-          SMESH::SMESH_Algo_var myAlgo = SMESH::SMESH_Algo::_narrow(_orb->string_to_object(anIOR->Value()));
-          fprintf(destFile,"%s\n",myAlgo->GetName());
-        }
-      }
-    
-      fclose(destFile);
-  
+               else if (gotBranch->Tag() == Tag_AlgorithmsRoot)
+               {                                               //algos = tag 2
+                       destFile = fopen(algofile.ToCString(), "w");
+                       it = Study->NewChildIterator(gotBranch);
+                       for (; it->More(); it->Next())
+                       {
+                               mySObject = it->Value();
+                               SALOMEDS::GenericAttribute_var anAttr;
+                               SALOMEDS::AttributeIOR_var anIOR;
+                               if (mySObject->FindAttribute(anAttr, "AttributeIOR"))
+                               {
+                                       anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
+                                       SMESH::SMESH_Algo_var myAlgo =
+                                               SMESH::SMESH_Algo::_narrow(_orb->
+                                               string_to_object(anIOR->Value()));
+                                       SCRUTE(anIOR->Value());
+                                       SCRUTE(myAlgo->_is_nil());
+                                       fprintf(destFile, "%i\n", myAlgo->GetId());
+                                       fprintf(destFile, "%s\n", myAlgo->GetName());
+                               }
+                       }
+
+                       fclose(destFile);
+
 //writes the file name in the hdf file
-      longueur = algofile.Length() +1;
-      name_group="Algorithms";
-      //SCRUTE(name_group);
-      
-      size[0]=longueur;
-      hdf_group[2] = new HDFgroup(name_group,hdf_file);
-      hdf_group[2]->CreateOnDisk();
-      
-      hdf_dataset[cmpt_ds]=new HDFdataset(name_group,hdf_group[2],HDF_STRING,size,1);
-      hdf_dataset[cmpt_ds]->CreateOnDisk();
-      hdf_dataset[cmpt_ds]->WriteOnDisk(algofile.ToCString());
-      hdf_dataset[cmpt_ds]->CloseOnDisk();
-      cmpt_ds++;
-      
-      hdf_group[2]->CloseOnDisk();
-      MESSAGE("End of Algos Save");
-
-    }
-//************branch 3 : meshes
-    else if (gotBranch->Tag()>=3) {//meshes = tag > 3
+                       longueur = algofile.Length() + 1;
+                       name_group = "Algorithms";
+                       //SCRUTE(name_group);
+
+                       size[0] = longueur;
+                       hdf_group[2] = new HDFgroup(name_group, hdf_file);
+                       hdf_group[2]->CreateOnDisk();
+
+                       hdf_dataset[cmpt_ds] =
+                               new HDFdataset(name_group, hdf_group[2], HDF_STRING, size, 1);
+                       hdf_dataset[cmpt_ds]->CreateOnDisk();
+                       hdf_dataset[cmpt_ds]->WriteOnDisk(algofile.ToCString());
+                       hdf_dataset[cmpt_ds]->CloseOnDisk();
+                       cmpt_ds++;
 
-      SALOMEDS::GenericAttribute_var anAttr;
-      SALOMEDS::AttributeIOR_var anIOR;
-      if (gotBranch->FindAttribute(anAttr, "AttributeIOR")) {
-        anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
-       
-       SMESH::SMESH_Mesh_var myMesh =  SMESH::SMESH_Mesh::_narrow(_orb->string_to_object(anIOR->Value())) ;
-       studyId = myMesh->GetStudyId();
-       SCRUTE(studyId);
-       
-       StudyContext_iStruct* myStudyContext = _mapStudyContext_i[studyId];
-       int meshId = myMesh->GetId();
-       SMESH_Mesh_i* meshServant = myStudyContext->mapMesh_i[meshId];
-       ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
-       SMESHDS_Mesh* mySMESHDSMesh = myLocMesh.GetMeshDS();
-       
-       SCRUTE(mySMESHDSMesh->NbNodes());
-       if (mySMESHDSMesh->NbNodes()>0) {//checks if the mesh is not empty
-         
-         DriverMED_W_SMESHDS_Mesh* myWriter = new DriverMED_W_SMESHDS_Mesh;
-         myWriter->SetFile(meshfile.ToCString());
-         
-         myWriter->SetMesh(mySMESHDSMesh);
-         myWriter->SetMeshId(gotBranch->Tag());
-         myWriter->Add();
+                       hdf_group[2]->CloseOnDisk();
+                       MESSAGE("End of Algos Save");
+
+               }
+//************branch 3 : meshes
+               else if (gotBranch->Tag() >= 3)
+               {                                               //meshes = tag > 3
+
+                       SALOMEDS::GenericAttribute_var anAttr;
+                       SALOMEDS::AttributeIOR_var anIOR;
+                       if (gotBranch->FindAttribute(anAttr, "AttributeIOR"))
+                       {
+                               anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
+
+                               SMESH::SMESH_Mesh_var myMesh =
+                                       SMESH::SMESH_Mesh::_narrow(_orb->string_to_object(anIOR->
+                                               Value()));
+                               studyId = myMesh->GetStudyId();
+                               SCRUTE(studyId);
+
+                               StudyContext_iStruct *myStudyContext =
+                                       _mapStudyContext_i[studyId];
+                               int meshId = myMesh->GetId();
+                               SMESH_Mesh_i *meshServant = myStudyContext->mapMesh_i[meshId];
+                               ::SMESH_Mesh & myLocMesh = meshServant->GetImpl();
+                               SMESHDS_Mesh *mySMESHDSMesh = myLocMesh.GetMeshDS();
+
+                               SCRUTE(mySMESHDSMesh->NbNodes());
+                               if (mySMESHDSMesh->NbNodes() > 0)
+                               {
+                                       //checks if the mesh is not empty   
+                                       Mesh_Writer *myWriter = SMESHDriver::GetMeshWriter("MED");
+                                       myWriter->SetFile(meshfile.ToCString());
+                                       myWriter->SetMesh(mySMESHDSMesh);
+                                       myWriter->SetMeshId(gotBranch->Tag());
+                                       myWriter->Add();
+                               }
+                               else
+                                       meshfile = "No data";
+
+                               //********** opening of the HDF group
+                               sprintf(name_meshgroup, "Mesh %d", gotBranch->Tag());
+                               SCRUTE(name_meshgroup);
+                               hdf_group[gotBranch->Tag()] =
+                                       new HDFgroup(name_meshgroup, hdf_file);
+                               hdf_group[gotBranch->Tag()]->CreateOnDisk();
+                               //********** 
+
+                               //********** file where the data are stored
+                               longueur = strlen(meshfile.ToCString()) + 1;
+                               size[0] = longueur;
+                               strcpy(name_dataset, "Mesh data");
+                               hdf_dataset[cmpt_ds] =
+                                       new HDFdataset(name_dataset, hdf_group[gotBranch->Tag()],
+                                       HDF_STRING, size, 1);
+                               hdf_dataset[cmpt_ds]->CreateOnDisk();
+                               hdf_dataset[cmpt_ds]->WriteOnDisk(meshfile.ToCString());
+                               hdf_dataset[cmpt_ds]->CloseOnDisk();
+                               cmpt_ds++;
+                               //********** 
+
+                               //********** ref on shape
+                               Standard_CString myRefOnObject = "";
+                               SALOMEDS::SObject_var myRef, myShape;
+                               _found = gotBranch->FindSubObject(Tag_RefOnShape, myRef);
+                               if (_found)
+                               {
+                                       ok = myRef->ReferencedObject(myShape);
+                                       myRefOnObject = myShape->GetID();
+                                       SCRUTE(myRefOnObject);
+
+                                       longueur = strlen(myRefOnObject) + 1;
+                                       if (longueur > 1)
+                                       {
+                                               size[0] = longueur;
+                                               strcpy(name_dataset, "Ref on shape");
+                                               hdf_dataset[cmpt_ds] =
+                                                       new HDFdataset(name_dataset,
+                                                       hdf_group[gotBranch->Tag()], HDF_STRING, size, 1);
+                                               hdf_dataset[cmpt_ds]->CreateOnDisk();
+                                               hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject);
+                                               hdf_dataset[cmpt_ds]->CloseOnDisk();
+                                               cmpt_ds++;
+
+                                       }
+                               }
+                               //********** 
+
+                               //********** ref on applied hypothesis
+                               _found =
+                                       gotBranch->FindSubObject(Tag_RefOnAppliedHypothesis,
+                                       myBranch);
+                               if (_found)
+                               {
+
+                                       strcpy(name_meshgroup, "Applied Hypothesis");
+                                       hdf_subgroup[Tag_RefOnAppliedHypothesis] =
+                                               new HDFgroup(name_meshgroup,
+                                               hdf_group[gotBranch->Tag()]);
+                                       hdf_subgroup[Tag_RefOnAppliedHypothesis]->CreateOnDisk();
+
+                                       it = Study->NewChildIterator(myBranch);
+                                       cmpt_it = 0;
+                                       for (; it->More(); it->Next())
+                                       {
+                                               mySObject = it->Value();
+                                               ok = mySObject->ReferencedObject(myRef);
+                                               myRefOnObject = myRef->GetID();
+
+                                               longueur = strlen(myRefOnObject) + 1;
+                                               if (longueur > 1)
+                                               {
+                                                       size[0] = longueur;
+                                                       sprintf(name_dataset, "Hyp %d", cmpt_it);
+                                                       hdf_dataset[cmpt_ds] =
+                                                               new HDFdataset(name_dataset,
+                                                               hdf_subgroup[Tag_RefOnAppliedHypothesis],
+                                                               HDF_STRING, size, 1);
+                                                       hdf_dataset[cmpt_ds]->CreateOnDisk();
+                                                       hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject);
+                                                       hdf_dataset[cmpt_ds]->CloseOnDisk();
+                                               }
+                                               cmpt_ds++;
+                                               cmpt_it++;
+                                       }
+                                       hdf_subgroup[Tag_RefOnAppliedHypothesis]->CloseOnDisk();
+                               }
+                               //********** 
+
+                               //********** ref on applied algorithms
+                               _found =
+                                       gotBranch->FindSubObject(Tag_RefOnAppliedAlgorithms,
+                                       myBranch);
+                               if (_found)
+                               {
+
+                                       strcpy(name_meshgroup, "Applied Algorithms");
+                                       hdf_subgroup[Tag_RefOnAppliedAlgorithms] =
+                                               new HDFgroup(name_meshgroup,
+                                               hdf_group[gotBranch->Tag()]);
+                                       hdf_subgroup[Tag_RefOnAppliedAlgorithms]->CreateOnDisk();
+
+                                       it = Study->NewChildIterator(myBranch);
+                                       cmpt_it = 0;
+                                       for (; it->More(); it->Next())
+                                       {
+                                               mySObject = it->Value();
+                                               ok = mySObject->ReferencedObject(myRef);
+                                               myRefOnObject = myRef->GetID();
+
+                                               longueur = strlen(myRefOnObject) + 1;
+                                               if (longueur > 1)
+                                               {
+                                                       size[0] = longueur;
+                                                       sprintf(name_dataset, "Algo %d", cmpt_it);
+                                                       hdf_dataset[cmpt_ds] =
+                                                               new HDFdataset(name_dataset,
+                                                               hdf_subgroup[Tag_RefOnAppliedAlgorithms],
+                                                               HDF_STRING, size, 1);
+                                                       hdf_dataset[cmpt_ds]->CreateOnDisk();
+                                                       hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject);
+                                                       hdf_dataset[cmpt_ds]->CloseOnDisk();
+                                               }
+                                               cmpt_ds++;
+                                               cmpt_it++;
+                                       }
+                                       hdf_subgroup[Tag_RefOnAppliedAlgorithms]->CloseOnDisk();
+                               }
+                               MESSAGE("end of algo applied");
+                               //********** 
+
+                               //********** submeshes on subshapes
+                               int myLevel1Tag;
+                               for (int i = Tag_SubMeshOnVertex; i <= Tag_SubMeshOnCompound;
+                                       i++)
+                               {
+                                       _found = gotBranch->FindSubObject(i, myBranch);
+                                       if (_found)
+                                       {
+                                               if (i == Tag_SubMeshOnVertex)
+                                                       strcpy(name_meshgroup, "SubMeshes On Vertex");
+                                               else if (i == Tag_SubMeshOnEdge)
+                                                       strcpy(name_meshgroup, "SubMeshes On Edge");
+                                               else if (i == Tag_SubMeshOnFace)
+                                                       strcpy(name_meshgroup, "SubMeshes On Face");
+                                               else if (i == Tag_SubMeshOnSolid)
+                                                       strcpy(name_meshgroup, "SubMeshes On Solid");
+                                               else if (i == Tag_SubMeshOnCompound)
+                                                       strcpy(name_meshgroup, "SubMeshes On Compound");
+
+                                               cmpt_sm++;
+                                               myLevel1Tag = 10 + cmpt_sm;
+                                               hdf_subgroup[myLevel1Tag] =
+                                                       new HDFgroup(name_meshgroup,
+                                                       hdf_group[gotBranch->Tag()]);
+                                               hdf_subgroup[myLevel1Tag]->CreateOnDisk();
+
+                                               itSM = Study->NewChildIterator(myBranch);
+                                               for (; itSM->More(); itSM->Next())
+                                               {               //Loop on all submeshes
+                                                       mySObject = itSM->Value();
+                                                       cmpt_sm++;
+                                                       myTag = 10 + cmpt_sm;
+                                                       mySObject->FindAttribute(anAttr, "AttributeIOR");
+                                                       anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
+                                                       SMESH::SMESH_subMesh_var mySubMesh =
+                                                               SMESH::SMESH_subMesh::_narrow(_orb->
+                                                               string_to_object(anIOR->Value()));
+
+                                                       //sprintf(name_meshgroup,"SubMesh %d",myTag);
+                                                       sprintf(name_meshgroup, "SubMesh %ld",
+                                                               mySubMesh->GetId());
+                                                       SCRUTE(name_meshgroup);
+
+                                                       hdf_subgroup[myTag] =
+                                                               new HDFgroup(name_meshgroup,
+                                                               hdf_subgroup[myLevel1Tag]);
+                                                       hdf_subgroup[myTag]->CreateOnDisk();
+
+                                                       //********** ref on shape
+                                                       Standard_CString myRefOnObject = "";
+                                                       SALOMEDS::SObject_var myRef, myShape;
+                                                       bool _found2;
+                                                       _found2 =
+                                                               mySObject->FindSubObject(Tag_RefOnShape, myRef);
+                                                       if (_found2)
+                                                       {
+                                                               ok = myRef->ReferencedObject(myShape);
+                                                               myRefOnObject = myShape->GetID();
+                                                               SCRUTE(myRefOnObject);
+
+                                                               longueur = strlen(myRefOnObject) + 1;
+                                                               if (longueur > 1)
+                                                               {
+                                                                       size[0] = longueur;
+                                                                       strcpy(name_dataset, "Ref on shape");
+                                                                       hdf_dataset[cmpt_ds] =
+                                                                               new HDFdataset(name_dataset,
+                                                                               hdf_subgroup[myTag], HDF_STRING, size,
+                                                                               1);
+                                                                       hdf_dataset[cmpt_ds]->CreateOnDisk();
+                                                                       hdf_dataset[cmpt_ds]->
+                                                                               WriteOnDisk(myRefOnObject);
+                                                                       hdf_dataset[cmpt_ds]->CloseOnDisk();
+                                                                       cmpt_ds++;
+                                                               }
+                                                       }
+                                                       //********** 
+
+                                                       //********** ref on applied hypothesis
+                                                       _found2 =
+                                                               mySObject->
+                                                               FindSubObject(Tag_RefOnAppliedHypothesis,
+                                                               myBranch);
+                                                       if (_found2)
+                                                       {
+
+                                                               strcpy(name_meshgroup, "Applied Hypothesis");
+                                                               cmpt_sm++;
+                                                               hdf_subgroup[10 + cmpt_sm] =
+                                                                       new HDFgroup(name_meshgroup,
+                                                                       hdf_subgroup[myTag]);
+                                                               hdf_subgroup[10 + cmpt_sm]->CreateOnDisk();
+
+                                                               it = Study->NewChildIterator(myBranch);
+                                                               cmpt_it = 0;
+                                                               for (; it->More(); it->Next())
+                                                               {
+                                                                       mySObjectChild = it->Value();
+                                                                       ok = mySObjectChild->
+                                                                               ReferencedObject(myRef);
+                                                                       myRefOnObject = myRef->GetID();
+
+                                                                       longueur = strlen(myRefOnObject) + 1;
+                                                                       if (longueur > 1)
+                                                                       {
+                                                                               size[0] = longueur;
+                                                                               sprintf(name_dataset, "Hyp %d",
+                                                                                       cmpt_it);
+                                                                               SCRUTE(cmpt_it);
+                                                                               hdf_dataset[cmpt_ds] =
+                                                                                       new HDFdataset(name_dataset,
+                                                                                       hdf_subgroup[10 + cmpt_sm],
+                                                                                       HDF_STRING, size, 1);
+                                                                               hdf_dataset[cmpt_ds]->CreateOnDisk();
+                                                                               hdf_dataset[cmpt_ds]->
+                                                                                       WriteOnDisk(myRefOnObject);
+                                                                               hdf_dataset[cmpt_ds]->CloseOnDisk();
+                                                                       }
+                                                                       cmpt_ds++;
+                                                                       cmpt_it++;
+                                                               }
+                                                               hdf_subgroup[10 + cmpt_sm]->CloseOnDisk();
+                                                       }
+                                                       //********** 
+
+                                                       //********** ref on applied algorithms
+                                                       _found2 =
+                                                               mySObject->
+                                                               FindSubObject(Tag_RefOnAppliedAlgorithms,
+                                                               myBranch);
+                                                       SCRUTE(_found2);
+                                                       if (_found2)
+                                                       {
+
+                                                               strcpy(name_meshgroup, "Applied Algorithms");
+                                                               cmpt_sm++;
+                                                               hdf_subgroup[10 + cmpt_sm] =
+                                                                       new HDFgroup(name_meshgroup,
+                                                                       hdf_subgroup[myTag]);
+                                                               hdf_subgroup[10 + cmpt_sm]->CreateOnDisk();
+
+                                                               it = Study->NewChildIterator(myBranch);
+                                                               cmpt_it = 0;
+                                                               for (; it->More(); it->Next())
+                                                               {
+                                                                       mySObjectChild = it->Value();
+                                                                       ok = mySObjectChild->
+                                                                               ReferencedObject(myRef);
+                                                                       myRefOnObject = myRef->GetID();
+
+                                                                       longueur = strlen(myRefOnObject) + 1;
+                                                                       if (longueur > 1)
+                                                                       {
+                                                                               size[0] = longueur;
+                                                                               sprintf(name_dataset, "Algo %d",
+                                                                                       cmpt_it);
+                                                                               hdf_dataset[cmpt_ds] =
+                                                                                       new HDFdataset(name_dataset,
+                                                                                       hdf_subgroup[10 + cmpt_sm],
+                                                                                       HDF_STRING, size, 1);
+                                                                               hdf_dataset[cmpt_ds]->CreateOnDisk();
+                                                                               hdf_dataset[cmpt_ds]->
+                                                                                       WriteOnDisk(myRefOnObject);
+                                                                               hdf_dataset[cmpt_ds]->CloseOnDisk();
+                                                                       }
+                                                                       cmpt_ds++;
+                                                                       cmpt_it++;
+                                                               }
+                                                               hdf_subgroup[10 + cmpt_sm]->CloseOnDisk();
+                                                       }
+                                                       //MESSAGE("end of algo applied");
+                                                       //********** 
+
+                                                       hdf_subgroup[myTag]->CloseOnDisk();
+                                               }
+
+                                               hdf_subgroup[myLevel1Tag]->CloseOnDisk();
+                                       }
+
+                               }
+                               //********** 
+
+                               //********** closing of the HDF group
+                               hdf_group[gotBranch->Tag()]->CloseOnDisk();
+                               MESSAGE("End of Mesh Save");
+                               //********** 
+                       }
+               }
+               MESSAGE("End of Meshes Save");
        }
-       else meshfile = "No data";
-       
-       //********** opening of the HDF group
-       sprintf(name_meshgroup,"Mesh %d",gotBranch->Tag());
-       SCRUTE(name_meshgroup);
-       hdf_group[gotBranch->Tag()] = new HDFgroup(name_meshgroup,hdf_file);
-       hdf_group[gotBranch->Tag()]->CreateOnDisk();
-       //********** 
-       
-       //********** file where the data are stored
-       longueur = strlen(meshfile.ToCString()) +1;
-       size[0]=longueur;
-       strcpy(name_dataset,"Mesh data");
-       hdf_dataset[cmpt_ds]=new HDFdataset(name_dataset,hdf_group[gotBranch->Tag()],HDF_STRING,size,1);
-       hdf_dataset[cmpt_ds]->CreateOnDisk();
-       hdf_dataset[cmpt_ds]->WriteOnDisk(meshfile.ToCString());
-       hdf_dataset[cmpt_ds]->CloseOnDisk();
-       cmpt_ds++;
-       //********** 
+
+       MESSAGE("hdf_file->CloseOnDisk()");
+       hdf_file->CloseOnDisk();
+
+       MESSAGE("delete hdf_file");
+       delete hdf_file;
+       hdf_file = 0;
+
+       // Convert temporary files to stream
+       MESSAGE("Convert temporary files to stream");
+       aStreamFile =
+               SALOMEDS_Tool::PutFilesToStream(tmpDir.ToCString(), aFileSeq.in(),
+               isMultiFile);
+
+       // Remove temporary files and directory
+       MESSAGE("Remove temporary files and directory");
+       if (!isMultiFile)
+               SALOMEDS_Tool::RemoveTemporaryFiles(tmpDir.ToCString(), aFileSeq.in(),
+                       true);
+
+       MESSAGE("End SMESH_Gen_i::Save");
+
+       return aStreamFile._retn();
+}
+
+SALOMEDS::TMPFile *
+       SMESH_Gen_i::SaveASCII(SALOMEDS::SComponent_ptr theComponent,
+       const char *theURL, bool isMultiFile)
+{
+       SALOMEDS::TMPFile_var aStreamFile = Save(theComponent, theURL, isMultiFile);
+       return aStreamFile._retn();
+}
+
+void SMESH_Gen_i::loadHypothesis(char * name, HDFfile * hdf_file,
+       char * hypofile, int studyId)
+{
+       char name_of_group[HDF_NAME_MAX_LEN + 1];
+       char objectId[10];
+       double length, maxElementsArea, maxElementsVolume;
+       int numberOfSegments;
+
+       HDFgroup * hdfGroup = new HDFgroup(name, hdf_file);
+       hdfGroup->OpenOnDisk();
+
+       hdfGroup->InternalObjectIndentify(0, name_of_group);
+       HDFdataset * dataset = new HDFdataset(name_of_group, hdfGroup);
+       dataset->OpenOnDisk();
+       char *name_of_file = new char[dataset->GetSize()];
+       dataset->ReadFromDisk(name_of_file);
+       SCRUTE(name_of_file);
+       dataset->CloseOnDisk();
+       hdfGroup->CloseOnDisk();
+       delete[]name_of_file;
        
-       //********** ref on shape
-       Standard_CString  myRefOnObject="" ;
-       SALOMEDS::SObject_var myRef,myShape;
-       _found = gotBranch->FindSubObject(Tag_RefOnShape,myRef);
-       if (_found) {
-         ok = myRef->ReferencedObject(myShape);
-         myRefOnObject = myShape->GetID();
-         SCRUTE(myRefOnObject);
-         
-         longueur = strlen(myRefOnObject) +1;
-         if (longueur>1) {
-           size[0]=longueur;
-           strcpy(name_dataset,"Ref on shape");
-           hdf_dataset[cmpt_ds]=new HDFdataset(name_dataset,hdf_group[gotBranch->Tag()],HDF_STRING,size,1);
-           hdf_dataset[cmpt_ds]->CreateOnDisk();
-           hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject);
-           hdf_dataset[cmpt_ds]->CloseOnDisk();
-           cmpt_ds++;
-           
-         }
+       ifstream loadedFile(hypofile);
+       while (!loadedFile.eof())
+       {
+               int hypothesisID;
+               string hypothesisName;
+               loadedFile >> hypothesisID;
+               loadedFile >> hypothesisName;
+               if(hypothesisName.length()==0) break;
+               SMESH_Hypothesis_i * corbaHyp =
+                       _hypothesisFactory_i.Create(hypothesisName.c_str(), studyId, &_impl);
+               SMESH_Hypothesis * localHyp = corbaHyp->getImpl();
+               localHyp->SetID(hypothesisID);
+               localHyp->LoadFrom(loadedFile);
+               
+               SMESH::SMESH_Hypothesis_var varHyp = corbaHyp->_this();
+               string iorString = _orb->object_to_string(varHyp);
+               sprintf(objectId, "%ld", varHyp->GetId());
+               _SMESHCorbaObj[string("Hypo_") + string(objectId)] =
+                       iorString;
        }
-       //********** 
-       
-       //********** ref on applied hypothesis
-       _found = gotBranch->FindSubObject(Tag_RefOnAppliedHypothesis,myBranch);
-       if (_found) {
-         
-         strcpy(name_meshgroup,"Applied Hypothesis");
-         hdf_subgroup[Tag_RefOnAppliedHypothesis] = new HDFgroup(name_meshgroup,hdf_group[gotBranch->Tag()]);
-         hdf_subgroup[Tag_RefOnAppliedHypothesis]->CreateOnDisk();
-         
-         it = Study->NewChildIterator(myBranch);
-         cmpt_it = 0;
-         for (; it->More();it->Next()) {
-           mySObject = it->Value();
-           ok = mySObject->ReferencedObject(myRef);
-           myRefOnObject = myRef->GetID();
-           
-           longueur = strlen(myRefOnObject) +1;
-           if (longueur>1) {
-             size[0]=longueur;
-             sprintf(name_dataset,"Hyp %d",cmpt_it);
-             hdf_dataset[cmpt_ds]=new HDFdataset(name_dataset,hdf_subgroup[Tag_RefOnAppliedHypothesis],HDF_STRING,size,1);
-             hdf_dataset[cmpt_ds]->CreateOnDisk();
-             hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject);
-             hdf_dataset[cmpt_ds]->CloseOnDisk();
-           }
-           cmpt_ds++;
-           cmpt_it++;
-         }
-         hdf_subgroup[Tag_RefOnAppliedHypothesis]->CloseOnDisk();
+       MESSAGE("End of Hypos Load");
+}
+
+void SMESH_Gen_i::loadAlgorithms(char * name, HDFfile * hdf_file,
+       char* algofile, int studyId)
+{
+       char name_of_group[HDF_NAME_MAX_LEN + 1];
+       char objectId[10];
+       HDFgroup * hdfGroup = new HDFgroup(name, hdf_file);
+       hdfGroup->OpenOnDisk();
+
+       hdfGroup->InternalObjectIndentify(0, name_of_group);
+       HDFdataset * dataset =
+               new HDFdataset(name_of_group, hdfGroup);
+       dataset->OpenOnDisk();
+
+       char *name_of_file = new char[dataset->GetSize()];
+       dataset->ReadFromDisk(name_of_file);
+       dataset->CloseOnDisk();
+       hdfGroup->CloseOnDisk();        
+       delete[]name_of_file;
+
+       char * aLine = new char[100];
+       FILE * loadedFile = fopen(algofile, "r");
+       while (!feof(loadedFile))
+       {
+               int hypothesisID;
+               fscanf(loadedFile, "%i", &hypothesisID);
+               fscanf(loadedFile, "%s\n", aLine);
+               //SCRUTE(aLine);
+               if (strcmp(aLine, "") != 0)
+               {
+                       SMESH_Hypothesis_i * corbaHyp =
+                               _hypothesisFactory_i.Create(aLine, studyId, &_impl);
+                       SMESH_Hypothesis * localHyp = corbaHyp->getImpl();
+                       localHyp->SetID(hypothesisID);
+                       
+                       SMESH::SMESH_Hypothesis_var myHyp = corbaHyp->_this();
+                       
+                       SMESH::SMESH_Algo_var myAlgo =
+                               SMESH::SMESH_Algo::_narrow(myHyp);
+                       string iorString = _orb->object_to_string(myAlgo);
+                       sprintf(objectId, "%ld", myAlgo->GetId());
+                       _SMESHCorbaObj[string("Hypo_") + string(objectId)] =
+                               iorString;
+               }
        }
-       //********** 
+       fclose(loadedFile);
+       delete[]aLine;
+       aLine = 0;
+       MESSAGE("End of Algos Load");
+}
+
+/**
+ * @param hdfGroupMeshId The group where to read the hypothesis
+ * @param _found ???
+ * @param Study The study where to create the hypothesis
+ * @param myNewMesh The mesh on which the hypothesis is applied
+ * @param aShape The shape with which this mesh is linked
+ */
+void SMESH_Gen_i::loadAppliedHypothesis(HDFgroup * hdfGroupMeshId, 
+       bool _found, SALOMEDS::Study_var Study, SMESH::SMESH_Mesh_var myNewMesh, 
+       GEOM::GEOM_Shape_var aShape)
+{
+       HDFgroup * hdf_subgroup = new HDFgroup("Applied Hypothesis", hdfGroupMeshId);
+       hdf_subgroup->OpenOnDisk();
+       int nb_datasets = hdf_subgroup->nInternalObjects();
+       char name_dataset[10];
        
-       //********** ref on applied algorithms
-       _found = gotBranch->FindSubObject(Tag_RefOnAppliedAlgorithms,myBranch);
-       if (_found) {
-         
-         strcpy(name_meshgroup,"Applied Algorithms");
-         hdf_subgroup[Tag_RefOnAppliedAlgorithms] = new HDFgroup(name_meshgroup,hdf_group[gotBranch->Tag()]);
-         hdf_subgroup[Tag_RefOnAppliedAlgorithms]->CreateOnDisk();
-         
-         it = Study->NewChildIterator(myBranch);
-         cmpt_it = 0;
-         for (; it->More();it->Next()) {
-           mySObject = it->Value();
-           ok = mySObject->ReferencedObject(myRef);
-           myRefOnObject = myRef->GetID();
-           
-           longueur = strlen(myRefOnObject) +1;
-           if (longueur>1) {
-             size[0]=longueur;
-             sprintf(name_dataset,"Algo %d",cmpt_it);
-             hdf_dataset[cmpt_ds]=new HDFdataset(name_dataset,hdf_subgroup[Tag_RefOnAppliedAlgorithms],HDF_STRING,size,1);
-             hdf_dataset[cmpt_ds]->CreateOnDisk();
-             hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject);
-             hdf_dataset[cmpt_ds]->CloseOnDisk();
-           }
-           cmpt_ds++;
-           cmpt_it++;
-         }
-         hdf_subgroup[Tag_RefOnAppliedAlgorithms]->CloseOnDisk();
+       for (int j = 0; j < nb_datasets; j++)
+       {
+               sprintf(name_dataset, "Hyp %d", j);
+               HDFdataset * hdf_dataset = new HDFdataset(name_dataset, hdf_subgroup);
+               hdf_dataset->OpenOnDisk();
+
+               char *refFromFile = new char[hdf_dataset->GetSize()];
+               hdf_dataset->ReadFromDisk(refFromFile);
+               hdf_dataset->CloseOnDisk();
+               delete hdf_dataset;
+
+               if (_found)
+               {
+                       SALOMEDS::SObject_var HypSO =
+                               Study->FindObjectID(refFromFile);
+                       if (!CORBA::is_nil(HypSO))
+                       {
+                               SALOMEDS::GenericAttribute_var anAttr;
+                               HypSO->FindAttribute(anAttr, "AttributeIOR");
+                               SALOMEDS::AttributeIOR_var anIOR =
+                                       SALOMEDS::AttributeIOR::_narrow(anAttr);
+                               if (!CORBA::is_nil(anIOR))
+                               {
+                                       char *HypIOR = anIOR->Value();
+                                       SMESH::SMESH_Hypothesis_var anHyp =
+                                               SMESH::SMESH_Hypothesis::_narrow(_orb->
+                                               string_to_object(HypIOR));
+                                       if (!CORBA::is_nil(anHyp))
+                                       {
+                                               myNewMesh->AddHypothesis(aShape, anHyp);
+                                               MESSAGE("Hypothesis added ...");
+                                       }
+                               }
+                       }
+               }
        }
-       MESSAGE("end of algo applied");
-       //********** 
+       hdf_subgroup->CloseOnDisk();
+}
+
+/**
+ * @param hdfGroupMeshId The group where to read the hypothesis
+ * @param _found ???
+ * @param Study The study where to create the hypothesis
+ * @param myNewMesh The mesh on which the hypothesis is applied
+ * @param aShape The shape with which this mesh is linked
+ */
+void SMESH_Gen_i::loadAppliedAlgorithms(HDFgroup * hdfGroupMeshId, 
+       bool _found, SALOMEDS::Study_var Study, SMESH::SMESH_Mesh_var myNewMesh, 
+       GEOM::GEOM_Shape_var aShape)
+{
+       HDFgroup * hdf_subgroup = new HDFgroup("Applied Algorithms", hdfGroupMeshId);
+       hdf_subgroup->OpenOnDisk();
+
+       int nb_datasets = hdf_subgroup->nInternalObjects();
+       SCRUTE(nb_datasets);
+       char name_dataset[10];
        
-       //********** submeshes on subshapes
-       int myLevel1Tag;
-       for (int i=Tag_SubMeshOnVertex;i<=Tag_SubMeshOnCompound;i++) {
-         _found = gotBranch->FindSubObject(i,myBranch);
-         if (_found) {
-           if (i==Tag_SubMeshOnVertex)
-             strcpy(name_meshgroup,"SubMeshes On Vertex");
-           else if (i==Tag_SubMeshOnEdge)
-             strcpy(name_meshgroup,"SubMeshes On Edge");
-           else if (i==Tag_SubMeshOnFace)
-             strcpy(name_meshgroup,"SubMeshes On Face");
-           else if (i==Tag_SubMeshOnSolid)
-             strcpy(name_meshgroup,"SubMeshes On Solid");
-           else if (i==Tag_SubMeshOnCompound)
-             strcpy(name_meshgroup,"SubMeshes On Compound");
-
-           cmpt_sm++;
-           myLevel1Tag = 10+cmpt_sm;
-           hdf_subgroup[myLevel1Tag] = new HDFgroup(name_meshgroup,hdf_group[gotBranch->Tag()]);
-           hdf_subgroup[myLevel1Tag]->CreateOnDisk();
-           
-           itSM = Study->NewChildIterator(myBranch);
-           for (; itSM->More();itSM->Next()) {//Loop on all submeshes
-             mySObject = itSM->Value();
-             cmpt_sm++;
-             myTag = 10+cmpt_sm;
-             mySObject->FindAttribute(anAttr, "AttributeIOR");
-             anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
-             SMESH::SMESH_subMesh_var mySubMesh =  SMESH::SMESH_subMesh::_narrow(_orb->string_to_object(anIOR->Value())) ;
-
-             //sprintf(name_meshgroup,"SubMesh %d",myTag);
-             sprintf(name_meshgroup,"SubMesh %d",mySubMesh->GetId());
-             SCRUTE(name_meshgroup);
-             
-             hdf_subgroup[myTag] = new HDFgroup(name_meshgroup,hdf_subgroup[myLevel1Tag]);
-             hdf_subgroup[myTag]->CreateOnDisk();
-             
-             //********** ref on shape
-             Standard_CString  myRefOnObject="" ;
-             SALOMEDS::SObject_var myRef,myShape;
-             bool _found2;
-             _found2 = mySObject->FindSubObject(Tag_RefOnShape,myRef);
-             if (_found2) {
-               ok = myRef->ReferencedObject(myShape);
-               myRefOnObject = myShape->GetID();
-               SCRUTE(myRefOnObject);
-               
-               longueur = strlen(myRefOnObject) +1;
-               if (longueur>1) {
-                 size[0]=longueur;
-                 strcpy(name_dataset,"Ref on shape");
-                 hdf_dataset[cmpt_ds]=new HDFdataset(name_dataset,hdf_subgroup[myTag],HDF_STRING,size,1);
-                 hdf_dataset[cmpt_ds]->CreateOnDisk();
-                 hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject);
-                 hdf_dataset[cmpt_ds]->CloseOnDisk();
-                 cmpt_ds++;
-               }
-             }
-             //********** 
-             
-             //********** ref on applied hypothesis
-             _found2 = mySObject->FindSubObject(Tag_RefOnAppliedHypothesis,myBranch);
-             if (_found2) {
-               
-               strcpy(name_meshgroup,"Applied Hypothesis");
-               cmpt_sm++;
-               hdf_subgroup[10+cmpt_sm] = new HDFgroup(name_meshgroup,hdf_subgroup[myTag]);
-               hdf_subgroup[10+cmpt_sm]->CreateOnDisk();
-               
-               it = Study->NewChildIterator(myBranch);
-               cmpt_it = 0;
-               for (; it->More();it->Next()) {
-                 mySObjectChild = it->Value();
-                 ok = mySObjectChild->ReferencedObject(myRef);
-                 myRefOnObject = myRef->GetID();
-                 
-                 longueur = strlen(myRefOnObject) +1;
-                 if (longueur>1) {
-                   size[0]=longueur;
-                   sprintf(name_dataset,"Hyp %d",cmpt_it);
-                   SCRUTE(cmpt_it);
-                   hdf_dataset[cmpt_ds]=new HDFdataset(name_dataset,hdf_subgroup[10+cmpt_sm],HDF_STRING,size,1);
-                   hdf_dataset[cmpt_ds]->CreateOnDisk();
-                   hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject);
-                   hdf_dataset[cmpt_ds]->CloseOnDisk();
-                 }
-                 cmpt_ds++;
-                 cmpt_it++;
-               }
-               hdf_subgroup[10+cmpt_sm]->CloseOnDisk();
-             }
-             //********** 
-             
-             //********** ref on applied algorithms
-             _found2 = mySObject->FindSubObject(Tag_RefOnAppliedAlgorithms,myBranch);
-             SCRUTE(_found2);
-             if (_found2) {
-               
-               strcpy(name_meshgroup,"Applied Algorithms");
-               cmpt_sm++;
-               hdf_subgroup[10+cmpt_sm] = new HDFgroup(name_meshgroup,hdf_subgroup[myTag]);
-               hdf_subgroup[10+cmpt_sm]->CreateOnDisk();
-               
-               it = Study->NewChildIterator(myBranch);
-               cmpt_it = 0;
-               for (; it->More();it->Next()) {
-                 mySObjectChild = it->Value();
-                 ok = mySObjectChild->ReferencedObject(myRef);
-                 myRefOnObject = myRef->GetID();
-                 
-                 longueur = strlen(myRefOnObject) +1;
-                 if (longueur>1) {
-                   size[0]=longueur;
-                   sprintf(name_dataset,"Algo %d",cmpt_it);
-                   hdf_dataset[cmpt_ds]=new HDFdataset(name_dataset,hdf_subgroup[10+cmpt_sm],HDF_STRING,size,1);
-                   hdf_dataset[cmpt_ds]->CreateOnDisk();
-                   hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject);
-                   hdf_dataset[cmpt_ds]->CloseOnDisk();
-                 }
-                 cmpt_ds++;
-                 cmpt_it++;
+       for (int j = 0; j < nb_datasets; j++)
+       {
+               sprintf(name_dataset, "Algo %d", j);
+               HDFdataset * dataset =
+                       new HDFdataset(name_dataset, hdf_subgroup);
+               dataset->OpenOnDisk();
+
+               char *refFromFile = new char[dataset->GetSize()];
+               dataset->ReadFromDisk(refFromFile);
+               dataset->CloseOnDisk();
+               delete dataset;
+
+               if (_found)
+               {
+                       SALOMEDS::SObject_var AlgoSO =
+                               Study->FindObjectID(refFromFile);
+                       if (!CORBA::is_nil(AlgoSO))
+                       {
+                               SALOMEDS::GenericAttribute_var anAttr;
+                               AlgoSO->FindAttribute(anAttr, "AttributeIOR");
+                               SALOMEDS::AttributeIOR_var anIOR =
+                                       SALOMEDS::AttributeIOR::_narrow(anAttr);
+                               if (!CORBA::is_nil(anIOR))
+                               {
+                                       char *AlgoIOR = anIOR->Value();
+                                       //SCRUTE(AlgoIOR);
+                                       SMESH::SMESH_Hypothesis_var myHyp =
+                                               SMESH::SMESH_Hypothesis::_narrow(_orb->
+                                               string_to_object(AlgoIOR));
+                                       SMESH::SMESH_Algo_var anAlgo =
+                                               SMESH::SMESH_Algo::_narrow(myHyp);
+                                                                                       
+                                       if (!CORBA::is_nil(anAlgo))
+                                       {
+                                               myNewMesh->AddHypothesis(aShape, anAlgo);       //essayer avec _SMESHCorbaObj
+                                               MESSAGE("Algorithms added ...");
+                                       }
+                               }
+                       }
                }
-               hdf_subgroup[10+cmpt_sm]->CloseOnDisk();
-             }
-             //MESSAGE("end of algo applied");
-             //********** 
-             
-             hdf_subgroup[myTag]->CloseOnDisk();
-           }
-           
-           hdf_subgroup[myLevel1Tag]->CloseOnDisk();
-         }
-         
        }
-       //********** 
-       
-       //********** closing of the HDF group
-       hdf_group[gotBranch->Tag()]->CloseOnDisk();
-       MESSAGE("End of Mesh Save");
-       //********** 
-      }                  
-    }
-    MESSAGE("End of Meshes Save");
-  }
+       hdf_subgroup->CloseOnDisk();
+}
 
-  hdf_file->CloseOnDisk();
-  delete hdf_file;
-  hdf_file = 0;
+/**
+ * @param hdfGroupMeshId The group where to read the hypothesis
+ * @param msgname ???
+ * @param Study The study where to create the hypothesis
+ * @param myNewMesh The mesh on which the hypothesis is applied
+ */
+void SMESH_Gen_i::loadSubMeshes(HDFgroup * hdfGroupMeshId, char * msgname,
+       SALOMEDS::Study_var Study, SMESH::SMESH_Mesh_var myNewMesh)
+{
+       MESSAGE("SMESH_Gen_i::loadSubMeshes");
+       HDFgroup * hdf_subgroupmyLevel1Tag = new HDFgroup(msgname, hdfGroupMeshId);
+       hdf_subgroupmyLevel1Tag->OpenOnDisk();
 
-  // Convert temporary files to stream
-  aStreamFile = SALOMEDS_Tool::PutFilesToStream(tmpDir.ToCString(), aFileSeq.in(), isMultiFile);
+       int nb_submeshes = hdf_subgroupmyLevel1Tag->nInternalObjects();
+       char name_meshgroup[30];
+       //SCRUTE(nb_submeshes);
 
-  // Remove temporary files and directory
-  if (!isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(tmpDir.ToCString(), aFileSeq.in(), true);
+       for (int j = 0; j < nb_submeshes; j++)
+       {
+               //cmpt_sm++;
+               //myTag = 10 + cmpt_sm;
+               hdf_subgroupmyLevel1Tag->InternalObjectIndentify(j, name_meshgroup);                            
+
+               HDFgroup * hdf_subgroupmyTag = new HDFgroup(name_meshgroup, 
+                       hdf_subgroupmyLevel1Tag);
+               hdf_subgroupmyTag->OpenOnDisk();
+               int subMeshId = atoi((string(name_meshgroup).substr(8, 18)).c_str());
+
+               MESSAGE("Ref on shape");
+               //********** ref on shape               
+               HDFdataset * hdf_dataset =
+                       new HDFdataset("Ref on shape", hdf_subgroupmyTag);
+               hdf_dataset->OpenOnDisk();
+
+               char *refFromFile = new char[hdf_dataset->GetSize()];
+               hdf_dataset->ReadFromDisk(refFromFile);
+               hdf_dataset->CloseOnDisk();
+               delete hdf_dataset;
+
+               bool _found3 = false;
+               SALOMEDS::SObject_var GSO = Study->FindObjectID(refFromFile);
+               SMESH::SMESH_subMesh_var aSubMesh;
+               GEOM::GEOM_Shape_var aSubShape;
 
-  MESSAGE("End SMESH_Gen_i::Save");
+               if (!CORBA::is_nil(GSO))
+               {
+                       SALOMEDS::GenericAttribute_var anAttr;
+                       GSO->FindAttribute(anAttr, "AttributeIOR");
+                       SALOMEDS::AttributeIOR_var anIOR = 
+                               SALOMEDS::AttributeIOR::_narrow(anAttr);
+                               
+                       char *SubShapeIOR = anIOR->Value();
+                       aSubShape =
+                               GEOM::GEOM_Shape::_narrow(_orb-> string_to_object(SubShapeIOR));
+
+                       if (!CORBA::is_nil(aSubShape))
+                       {
+                               aSubMesh = myNewMesh->GetElementsOnShape(aSubShape);
+                               string iorString = _orb->object_to_string(aSubMesh);
+                               char objectId[10];
+                               sprintf(objectId, "%d", subMeshId);
+                               _SMESHCorbaObj[string("SubMesh_") + string(objectId)] =
+                                        iorString;
+                               _found3 = true;
+                       }
+               }
 
-  return aStreamFile._retn();
+               int nb_subgroup = hdf_subgroupmyTag->nInternalObjects();
+               SCRUTE(nb_subgroup);
+               char sgname[HDF_NAME_MAX_LEN + 1];
+               for (int k = 0; k < nb_subgroup; k++)
+               {
+                       hdf_subgroupmyTag->InternalObjectIndentify(k, sgname);
+                       if (strcmp(sgname, "Ref on shape") == 0)
+                       {
+                               //nothing
+                       }
+                       else if (strcmp(sgname, "Applied Hypothesis") == 0)
+                       {
+                               //********** ref on applied hypothesis
+                               MESSAGE("Applied Hypothesis");
+                               strcpy(name_meshgroup, "Applied Hypothesis");
+                               //cmpt_sm++;
+                               HDFgroup * hdf_subgroup10cmpt_sm = new HDFgroup(name_meshgroup,
+                                       hdf_subgroupmyTag);
+                                       
+                               hdf_subgroup10cmpt_sm->OpenOnDisk();
+                               int nb_datasets = hdf_subgroup10cmpt_sm->nInternalObjects();
+                               // SCRUTE(nb_datasets);
+
+                               char name_dataset[30];
+                               for (int l = 0; l < nb_datasets; l++)
+                               {
+                                       sprintf(name_dataset, "Hyp %d", l);
+                                       HDFdataset * hdf_datasetcmpt_ds =
+                                               new HDFdataset(name_dataset, hdf_subgroup10cmpt_sm);
+                                       hdf_datasetcmpt_ds->OpenOnDisk();
+                                       int size = hdf_datasetcmpt_ds->GetSize();
+
+                                       char *refFromFile = new char[size];
+                                       hdf_datasetcmpt_ds->ReadFromDisk(refFromFile);
+                                       hdf_datasetcmpt_ds->CloseOnDisk();
+                                       //cmpt_ds++;
+
+                                       if (_found3)
+                                       {
+                                               SALOMEDS::SObject_var HypSO =
+                                                       Study->FindObjectID(refFromFile);
+                                               if (!CORBA::is_nil(HypSO))
+                                               {
+                                                       SALOMEDS::GenericAttribute_var anAttr;
+                                                       SALOMEDS::AttributeIOR_var anIOR;
+                                                       HypSO->FindAttribute(anAttr, "AttributeIOR");
+                                                       anIOR = SALOMEDS::AttributeIOR:: _narrow(anAttr);
+                                                       if (!CORBA::is_nil(anIOR))
+                                                       {
+                                                               char *HypIOR = anIOR->Value();
+                                                               SMESH::SMESH_Hypothesis_var anHyp =
+                                                                       SMESH::SMESH_Hypothesis::_narrow(_orb->
+                                                                       string_to_object(HypIOR));
+                                                               if (!CORBA::is_nil(anHyp))
+                                                               {
+                                                                       SMESH::SMESH_Mesh_var aMesh = 
+                                                                               aSubMesh->GetFather();
+                                                                       aMesh->AddHypothesis(aSubShape, anHyp); //essayer avec _SMESHCorbaObj
+                                                                       MESSAGE("Hypothesis added ...");
+                                                               }
+                                                       }
+                                               }
+                                       }
+                               }
+                       }
+                       else if (strcmp(sgname, "Applied Algorithms") == 0)
+                       {
+                               //********** ref on applied algorithms
+                               MESSAGE("Applied Algorithms");
+                               strcpy(name_meshgroup, "Applied Algorithms");
+                               //cmpt_sm++;
+                               HDFgroup * hdf_subgroup10cmpt_sm = new HDFgroup(name_meshgroup,
+                                       hdf_subgroupmyTag);
+                               hdf_subgroup10cmpt_sm->OpenOnDisk();
+                               int nb_datasets = hdf_subgroup10cmpt_sm->nInternalObjects();
+                               SCRUTE(nb_datasets);
+
+                               char name_dataset[30];
+                               for (int l = 0; l < nb_datasets; l++)
+                               {
+                                       sprintf(name_dataset, "Algo %d", l);
+                                       HDFdataset * hdf_datasetcmpt_ds = new HDFdataset(
+                                               name_dataset, hdf_subgroup10cmpt_sm);
+                                       hdf_datasetcmpt_ds->OpenOnDisk();
+                                       int size = hdf_datasetcmpt_ds->GetSize();
+
+                                       char *refFromFile = new char[size];
+                                       hdf_datasetcmpt_ds->ReadFromDisk(refFromFile);
+                                       hdf_datasetcmpt_ds->CloseOnDisk();
+                                       delete hdf_datasetcmpt_ds;
+                                       //cmpt_ds++;
+
+                                       if (_found3)
+                                       {
+                                               SALOMEDS::SObject_var AlgoSO =
+                                                       Study->FindObjectID(refFromFile);
+                                               if (!CORBA::is_nil(AlgoSO))
+                                               {
+                                                       SALOMEDS::GenericAttribute_var anAttr;
+                                                       SALOMEDS::AttributeIOR_var anIOR;
+                                                       AlgoSO->FindAttribute(anAttr, "AttributeIOR");
+                                                       anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
+                                                       if (!CORBA::is_nil(anIOR))
+                                                       {
+                                                               char *AlgoIOR = anIOR->Value();
+                                                               //SCRUTE(AlgoIOR);
+                                                               SMESH::SMESH_Hypothesis_var myHyp =
+                                                                       SMESH::SMESH_Hypothesis::_narrow(_orb->
+                                                                       string_to_object(AlgoIOR));
+                                                               SMESH::SMESH_Algo_var anAlgo =
+                                                                       SMESH::SMESH_Algo::_narrow(myHyp);
+                                                               //SMESH::SMESH_Algo_var anAlgo = SMESH::SMESH_Algo::_narrow(_orb->string_to_object(AlgoIOR));
+                                                               if (!CORBA::is_nil(anAlgo))
+                                                               {
+                                                                       SMESH::SMESH_Mesh_var aMesh =
+                                                                               aSubMesh->GetFather();
+                                                                       aMesh->AddHypothesis(aSubShape, anAlgo);        //essayer avec _SMESHCorbaObj
+                                                                       MESSAGE("Algorithms added ...");
+                                                               }
+                                                       }
+                                               }
+                                       }
+                               }
+                       }
+               }
+               hdf_subgroupmyTag->CloseOnDisk();
+               delete hdf_subgroupmyTag;
+       }
+       hdf_subgroupmyLevel1Tag->CloseOnDisk();
+       delete hdf_subgroupmyLevel1Tag;
 }
 
-SALOMEDS::TMPFile* SMESH_Gen_i::SaveASCII(SALOMEDS::SComponent_ptr theComponent,
-                                         const char* theURL,
-                                         bool isMultiFile) {
-  SALOMEDS::TMPFile_var aStreamFile = Save(theComponent, theURL, isMultiFile);
-  return aStreamFile._retn();
+GEOM::GEOM_Gen_var SMESH_Gen_i::getGeomEngine()
+{
+       MESSAGE("SMESH_Gen_i::getGeomEngine");
+       SALOME_NamingService *_NS = SINGLETON_ < SALOME_NamingService >::Instance();
+       ASSERT(SINGLETON_ < SALOME_NamingService >::IsAlreadyExisting());
+       _NS->init_orb(_orb);
+       SALOME_LifeCycleCORBA *myEnginesLifeCycle = new SALOME_LifeCycleCORBA(_NS);
+       Engines::Component_var geomEngine =
+       myEnginesLifeCycle->FindOrLoad_Component("FactoryServer", "GEOM");
+       GEOM::GEOM_Gen_var myGeomEngine = GEOM::GEOM_Gen::_narrow(geomEngine);
+       return myGeomEngine;    
 }
 
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
+GEOM::GEOM_Shape_var SMESH_Gen_i::getShape(SALOMEDS::Study_var Study, char * refFromFile)
+{
+       MESSAGE("SMESH_Gen_i::getShape("<<Study<<","<<refFromFile<<")");
+       SCRUTE(CORBA::is_nil(Study));
+       SALOMEDS::SObject_var CSO = Study->FindObjectID(refFromFile);
+       GEOM::GEOM_Shape_var aShape;
 
-bool SMESH_Gen_i::Load(SALOMEDS::SComponent_ptr theComponent,
-                      const SALOMEDS::TMPFile& theStream,
-                      const char* theURL,
-                      bool isMultiFile)
+       if (!CORBA::is_nil(CSO))
+       {
+               SALOMEDS::GenericAttribute_var anAttr;
+               CSO->FindAttribute(anAttr, "AttributeIOR");
+               if (!CORBA::is_nil(CSO))
+               {
+                       MESSAGE("The shape was not loaded. Try to load it.");
+                       SALOMEDS::Driver_var driver = SALOMEDS::Driver::_narrow(getGeomEngine());
+                       SALOMEDS::SComponent_var SCO = SALOMEDS::SComponent::_narrow(Study->FindObject("Geometry"));
+                       SALOMEDS::StudyBuilder_var B = Study->NewBuilder();     
+                       B->LoadWith(SCO,driver);
+                       CSO->FindAttribute(anAttr, "AttributeIOR");
+               }
+
+               SALOMEDS::AttributeIOR_var anIOR =
+                       SALOMEDS::AttributeIOR::_narrow(anAttr);
+               
+               char *ShapeIOR = anIOR->Value();
+               aShape =
+                       GEOM::GEOM_Shape::_narrow(_orb->string_to_object(ShapeIOR));
+       }
+       return aShape;
+}
+
+void SMESH_Gen_i::loadMesh(char * name, HDFfile * hdf_file,
+       char* meshfile, SALOMEDS::Study_var Study)
 {
-  MESSAGE("SMESH_Gen_i::Load\n");
-
-  // Get temporary files location
-  TCollection_AsciiString tmpDir = isMultiFile?TCollection_AsciiString((char*)theURL):SALOMEDS_Tool::GetTmpDir();
-
-  // Convert the stream into sequence of files to process
-  SALOMEDS::ListOfFileNames_var aFileSeq = SALOMEDS_Tool::PutStreamToFiles(theStream,
-                                                                           tmpDir.ToCString(),
-                                                                          isMultiFile);
-
-  TCollection_AsciiString aStudyName("");
-  if (isMultiFile) aStudyName = (SALOMEDS_Tool::GetNameFromPath(theComponent->GetStudy()->URL()));
-
-  // Set names of temporary files
-  TCollection_AsciiString filename = tmpDir + aStudyName + TCollection_AsciiString("_SMESH.hdf");
-  TCollection_AsciiString hypofile = tmpDir + aStudyName + TCollection_AsciiString("_SMESH_Hypo.txt");
-  TCollection_AsciiString algofile = tmpDir + aStudyName + TCollection_AsciiString("_SMESH_Algo.txt");
-  TCollection_AsciiString meshfile = tmpDir + aStudyName + TCollection_AsciiString("_SMESH_Mesh.med");
-
-  SALOMEDS::Study_var Study = theComponent->GetStudy(); 
-  int studyId = Study->StudyId();
-  SCRUTE(studyId);
-
-  SALOMEDS::GenericAttribute_var anAttr;
-  SALOMEDS::AttributeName_var    aName;
-  SALOMEDS::AttributeIOR_var    anIOR;
-
-  SALOMEDS::SComponent_var fathergeom = Study->FindComponent("GEOM");
-  SALOMEDS::SComponent_var myGeomSComp = SALOMEDS::SComponent::_narrow( fathergeom );
-  SCRUTE(fathergeom);
-
-  //to get the geom engine !!!
-  //useful to define our new mesh
-  SALOME_NamingService* _NS = SINGLETON_<SALOME_NamingService>::Instance() ;
-  ASSERT(SINGLETON_<SALOME_NamingService>::IsAlreadyExisting()) ;
-  _NS->init_orb( _orb ) ;
-  SALOME_LifeCycleCORBA* myEnginesLifeCycle = new SALOME_LifeCycleCORBA(_NS);
-  Engines::Component_var geomEngine =
-    myEnginesLifeCycle->FindOrLoad_Component("FactoryServer","GEOM");
-  GEOM::GEOM_Gen_var myGeomEngine = GEOM::GEOM_Gen::_narrow(geomEngine);
-
-
-  char* aLine;
-  bool ok;
-  char objectId[10],name_dataset[10];
-  int nb_datasets,size,cmpt_ds=0;
-  int cmpt_sm = 0;
-
-  char name[HDF_NAME_MAX_LEN+1];
-  char sgname[HDF_NAME_MAX_LEN+1];
-  char msgname[HDF_NAME_MAX_LEN+1];
-  char name_of_group[HDF_NAME_MAX_LEN+1];
-  char *name_meshgroup;
-  map <int,HDFgroup*> hdf_group, hdf_subgroup;
-  map <int,HDFdataset*> hdf_dataset;
-  FILE *loadedFile;
-
-  //************* HDF file opening
-  HDFfile * hdf_file = new HDFfile(filename.ToCString());
-  try {
-    hdf_file->OpenOnDisk(HDF_RDONLY);
-  }
-  catch (HDFexception) {
-    MESSAGE("Load(): " << filename << " not found!");
-    return false;
-  }
-
-  //****************************
-
-  int nb_group = hdf_file->nInternalObjects(); 
-  SCRUTE(nb_group);
-  for (int i=0;i<nb_group;i++) 
-    {
-      hdf_file->InternalObjectIndentify(i,name);
-      //SCRUTE(name);
-      
-//***************
-// Loading of the Hypothesis Branch
-//***************
-      if (strcmp(name,"Hypothesis")==0) {
-        
-        double length,maxElementsArea,maxElementsVolume;
-        int numberOfSegments;
-
-        hdf_group[Tag_HypothesisRoot] = new HDFgroup(name,hdf_file); 
-        hdf_group[Tag_HypothesisRoot]->OpenOnDisk();
-        
-        hdf_group[Tag_HypothesisRoot]->InternalObjectIndentify(0,name_of_group);
-        hdf_dataset[cmpt_ds]=new HDFdataset(name_of_group,hdf_group[Tag_HypothesisRoot]);
-        hdf_dataset[cmpt_ds]->OpenOnDisk();
-        size=hdf_dataset[cmpt_ds]->GetSize();
-
-        char * name_of_file =new char[size];
-        hdf_dataset[cmpt_ds]->ReadFromDisk(name_of_file);
-        SCRUTE(name_of_file);
-        hdf_dataset[cmpt_ds]->CloseOnDisk();
-        hdf_group[Tag_HypothesisRoot]->CloseOnDisk();
-        cmpt_ds++;
-        delete[] name_of_file;
-        name_of_file = 0;
-
-        aLine = new char[100];
-        loadedFile = fopen( hypofile.ToCString() ,"r");
-        while (!feof(loadedFile)) {
-          fscanf(loadedFile,"%s",aLine);
-          //SCRUTE(aLine);
-          if (strcmp(aLine,"LocalLength")==0) {
-            SMESH::SMESH_Hypothesis_var myHyp  = this->CreateHypothesis(aLine,studyId);
-            SMESH::SMESH_LocalLength_var LL = SMESH::SMESH_LocalLength::_narrow( myHyp );
-            fscanf(loadedFile,"%s",aLine);
-            length = atof(aLine);
-            LL->SetLength(length);
-            string iorString = _orb->object_to_string(LL);
-            sprintf(objectId,"%d",LL->GetId());
-            _SMESHCorbaObj[string("Hypo_")+string(objectId)] = iorString;
-          }
-          else if (strcmp(aLine,"NumberOfSegments")==0) {
-            SMESH::SMESH_Hypothesis_var myHyp  = this->CreateHypothesis(aLine,studyId);
-            SMESH::SMESH_NumberOfSegments_var NOS = SMESH::SMESH_NumberOfSegments::_narrow( myHyp );
-            fscanf(loadedFile,"%s",aLine);
-            numberOfSegments = atoi(aLine);
-            NOS->SetNumberOfSegments(numberOfSegments);
-            string iorString = _orb->object_to_string(NOS);
-            sprintf(objectId,"%d",NOS->GetId());
-            _SMESHCorbaObj[string("Hypo_")+string(objectId)] = iorString;
-          }
-          else if (strcmp(aLine,"MaxElementArea")==0) {
-            SMESH::SMESH_Hypothesis_var myHyp  = this->CreateHypothesis(aLine,studyId);
-            SMESH::SMESH_MaxElementArea_var MEA = SMESH::SMESH_MaxElementArea::_narrow( myHyp );
-            fscanf(loadedFile,"%s",aLine);
-            maxElementsArea = atof(aLine);
-            MEA->SetMaxElementArea(maxElementsArea);
-            string iorString = _orb->object_to_string(MEA);
-            sprintf(objectId,"%d",MEA->GetId());
-            _SMESHCorbaObj[string("Hypo_")+string(objectId)] = iorString;
-          }
-          else if (strcmp(aLine,"MaxElementVolume")==0) {
-            SMESH::SMESH_Hypothesis_var myHyp  = this->CreateHypothesis(aLine,studyId);
-            SMESH::SMESH_MaxElementVolume_var MEV = SMESH::SMESH_MaxElementVolume::_narrow( myHyp );
-            fscanf(loadedFile,"%s",aLine);
-            maxElementsVolume = atof(aLine);
-            MEV->SetMaxElementVolume(maxElementsVolume);
-            string iorString = _orb->object_to_string(MEV);
-            sprintf(objectId,"%d",MEV->GetId());
-            _SMESHCorbaObj[string("Hypo_")+string(objectId)] = iorString;
-          }
-          
-
-        }
-        fclose(loadedFile);
-        delete[] aLine;
-        aLine = 0;
-        MESSAGE("End of Hypos Load");
-
-      }
-//***************
-// Loading of the Algorithms Branch
-//***************
-      else if (strcmp(name,"Algorithms")==0) {
-
-        hdf_group[Tag_AlgorithmsRoot] = new HDFgroup(name,hdf_file); 
-        hdf_group[Tag_AlgorithmsRoot]->OpenOnDisk();
-        
-        hdf_group[Tag_AlgorithmsRoot]->InternalObjectIndentify(0,name_of_group);
-        hdf_dataset[cmpt_ds] = new HDFdataset(name_of_group,hdf_group[Tag_AlgorithmsRoot]);
-        hdf_dataset[cmpt_ds]->OpenOnDisk();
-        size=hdf_dataset[cmpt_ds]->GetSize();
-
-        char * name_of_file =new char[size];
-        hdf_dataset[cmpt_ds]->ReadFromDisk(name_of_file);
-        hdf_dataset[cmpt_ds]->CloseOnDisk();
-        hdf_group[Tag_AlgorithmsRoot]->CloseOnDisk();
-        cmpt_ds++;
-        delete[] name_of_file;
-        name_of_file = 0;
-        
-        aLine = new char[100];
-        loadedFile = fopen( algofile.ToCString(),"r");
-        while (!feof(loadedFile)) {
-          fscanf(loadedFile,"%s\n",aLine);
-          //SCRUTE(aLine);
-          if (strcmp(aLine,"")!=0) {
-            SMESH::SMESH_Hypothesis_var myHyp = this->CreateHypothesis(aLine,studyId);
-            SMESH::SMESH_Algo_var myAlgo = SMESH::SMESH_Algo::_narrow(myHyp);
-            string iorString = _orb->object_to_string(myAlgo);
-            sprintf(objectId,"%d",myAlgo->GetId());
-            _SMESHCorbaObj[string("Hypo_")+string(objectId)] = iorString;
-          }
-        }
-        fclose(loadedFile);
-        delete[] aLine;
-        aLine = 0;
-        MESSAGE("End of Algos Load");
-
-      }
-
-//***************
-// Loading of the Mesh Branch
-//***************
-      else if (string(name).substr(0,4)==string("Mesh")) {
-        MESSAGE("in mesh load");
-
-        Standard_Integer myMeshId = atoi((string(name).substr(5,5)).c_str());
-        SCRUTE(myMeshId);
-
-       hdf_group[myMeshId] = new HDFgroup(name,hdf_file); 
-       hdf_group[myMeshId]->OpenOnDisk();
-
-       int nb_meshsubgroup = hdf_group[myMeshId]->nInternalObjects(); 
+       MESSAGE("in mesh load");
+       char msgname[HDF_NAME_MAX_LEN + 1];     
+       char objectId[10];
+       char name_of_group[HDF_NAME_MAX_LEN + 1];
+       
+       int myMeshId =
+               atoi((string(name).substr(5, 5)).c_str());
+       SCRUTE(myMeshId);
+
+       HDFgroup * hdfGroupMeshId = new HDFgroup(name, hdf_file);
+       hdfGroupMeshId->OpenOnDisk();
+
+       int nb_meshsubgroup = hdfGroupMeshId->nInternalObjects();
        SCRUTE(nb_meshsubgroup);
-             
+
        //********** Loading of the file name where the data are stored
        MESSAGE("Mesh data file");
-       strcpy(name_of_group,"Mesh data");
-       hdf_dataset[cmpt_ds]=new HDFdataset(name_of_group,hdf_group[myMeshId]);
-       hdf_dataset[cmpt_ds]->OpenOnDisk();
-       size=hdf_dataset[cmpt_ds]->GetSize();
-       
-       char * datafilename =new char[size];
-       hdf_dataset[cmpt_ds]->ReadFromDisk(datafilename);
-       hdf_dataset[cmpt_ds]->CloseOnDisk();
-       cmpt_ds++;
-             
-       //********** 
-       //}
-       //else if (strcmp(msgname,"Ref on shape")==0) {
+       strcpy(name_of_group, "Mesh data");
+       HDFdataset * dataset =
+               new HDFdataset(name_of_group, hdfGroupMeshId);
+       dataset->OpenOnDisk();
+
+       char *datafilename = new char[dataset->GetSize()];
+       dataset->ReadFromDisk(datafilename);
+       dataset->CloseOnDisk(); 
+       MESSAGE("datafilename="<<datafilename<<" but this is ignored. We will read from "<<meshfile);
+       datafilename=meshfile;
+
        //********** Loading of the reference on the shape
        //********** and mesh initialization
        MESSAGE("Ref on shape");
-       strcpy(name_of_group,"Ref on shape");
-       hdf_dataset[cmpt_ds] = new HDFdataset(name_of_group,hdf_group[myMeshId]);
-       hdf_dataset[cmpt_ds]->OpenOnDisk();
-       size=hdf_dataset[cmpt_ds]->GetSize();
-             
-       char * refFromFile =new char[size];
-       hdf_dataset[cmpt_ds]->ReadFromDisk(refFromFile);
-       hdf_dataset[cmpt_ds]->CloseOnDisk();
-       cmpt_ds++;
-             
-       Standard_CString  myRefOnShape="";   //look for ref on shape
-             
+       strcpy(name_of_group, "Ref on shape");
+       dataset =
+               new HDFdataset(name_of_group, hdfGroupMeshId);
+       dataset->OpenOnDisk();
+       
+       char *refFromFile = new char[dataset->GetSize()];
+       dataset->ReadFromDisk(refFromFile);
+       dataset->CloseOnDisk(); 
+
        bool _found = false;
-       SALOMEDS::SObject_var CSO = Study->FindObjectID(refFromFile);
+       SCRUTE(refFromFile);
        SMESH::SMESH_Mesh_var myNewMesh;
-       GEOM::GEOM_Shape_var aShape;
-             
-       if (!CORBA::is_nil(CSO)) {
-         _found = true;
-         CSO->FindAttribute(anAttr, "AttributeIOR");
-         anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
-         char* ShapeIOR = anIOR->Value();
-         aShape = GEOM::GEOM_Shape::_narrow(_orb->string_to_object(ShapeIOR));
+       GEOM::GEOM_Shape_var aShape=getShape(Study, refFromFile);
+
+       if (!CORBA::is_nil(aShape))
+       {
+               _found = true;
+               myNewMesh = this->Init(getGeomEngine(), Study->StudyId(), aShape);
+               string iorString = _orb->object_to_string(myNewMesh);
+               sprintf(objectId, "%ld", myNewMesh->GetId());
+               _SMESHCorbaObj[string("Mesh_") + string(objectId)] = iorString;
+
                
-         myNewMesh = this->Init(myGeomEngine,studyId,aShape);
-         string iorString = _orb->object_to_string(myNewMesh);
-         sprintf(objectId,"%d",myNewMesh->GetId());
-         _SMESHCorbaObj[string("Mesh_")+string(objectId)] = iorString;
-                               
-         //********** 
-         //********** Loading of mesh data
-         if (strcmp(datafilename,"No data")!=0) {
-                 
-           med_idt fid;
-           int ret;
-           
-           //****************************************************************************
-           //*                      OUVERTURE DU FICHIER EN LECTURE                      *
-           //****************************************************************************
-                 
-           fid = MEDouvrir(datafilename,MED_LECT);
-           if (fid < 0)
-             {
-               printf(">> ERREUR : ouverture du fichier %s \n",datafilename);
-               exit(EXIT_FAILURE);
-             }
-           else {
-                   
-             StudyContext_iStruct* myStudyContext = _mapStudyContext_i[studyId];
-             int meshId = myNewMesh->GetId();
-             SMESH_Mesh_i* meshServant = myStudyContext->mapMesh_i[meshId];
-             ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
-             SMESHDS_Mesh* mySMESHDSMesh = myLocMesh.GetMeshDS();
-                   
-             DriverMED_R_SMESHDS_Mesh* myReader = new DriverMED_R_SMESHDS_Mesh;
-                   
-             myReader->SetMesh(mySMESHDSMesh);
-             myReader->SetMeshId(myMeshId);
-             myReader->SetFileId(fid);
-             myReader->ReadMySelf();
-             //SCRUTE(mySMESHDSMesh->NbNodes());
-             //myNewMesh->ExportUNV("/tmp/test.unv");//only to check out
-                   
-             //****************************************************************************
-             //*                      FERMETURE DU FICHIER                                 *
-             //****************************************************************************
-             ret = MEDfermer(fid);
-                   
-             if (ret != 0)
-               printf(">> ERREUR : erreur a la fermeture du fichier %s\n",datafilename);
-                   
-           }
-         }
+               //********** 
+               //********** Loading of mesh data
+               if (strcmp(datafilename, "No data") != 0)
+               {                       
+                       StudyContext_iStruct *myStudyContext =
+                               _mapStudyContext_i[Study->StudyId()];
+                       int meshId = myNewMesh->GetId();
+                       SMESH_Mesh_i *meshServant =
+                               myStudyContext->mapMesh_i[meshId];
+                       ::SMESH_Mesh & myLocMesh = meshServant->GetImpl();
+                       SMESHDS_Mesh *mySMESHDSMesh = myLocMesh.GetMeshDS();
+
+                       Mesh_Reader *myReader = SMESHDriver::GetMeshReader("MED");
+                       myReader->SetMesh(mySMESHDSMesh);
+                       myReader->SetMeshId(myMeshId);
+                       myReader->SetFile(datafilename);
+                       myReader->Read();
+                       mySMESHDSMesh->logFullUpdate();
+                       MESSAGE("Loaded a mesh with " << mySMESHDSMesh->NbNodes() <<" nodes");
+               }
        }
        //********** 
        //}
        //else if (strcmp(msgname,"Applied Hypothesis")==0) {
-       for (int ii=0;ii<nb_meshsubgroup;ii++) 
-         {
-           hdf_group[myMeshId]->InternalObjectIndentify(ii,msgname);
-           if (strcmp(msgname,"Mesh data")==0) {
-             //nothing
-           }
-           else if (strcmp(msgname,"Ref on shape")==0) {
-             //nothing
-           }
-           else if (strcmp(msgname,"Applied Hypothesis")==0) {
-             //********** Loading of the applied hypothesis
-             strcpy(name_of_group,"Applied Hypothesis");
-             hdf_subgroup[Tag_RefOnAppliedHypothesis] = new HDFgroup(name_of_group,hdf_group[myMeshId]);
-             hdf_subgroup[Tag_RefOnAppliedHypothesis]->OpenOnDisk();
-             
-             nb_datasets = hdf_subgroup[Tag_RefOnAppliedHypothesis]->nInternalObjects();  
-             SCRUTE(nb_datasets);
-             
-             for (int j=0;j<nb_datasets;j++) {
-               sprintf(name_dataset,"Hyp %d",j);
-               hdf_dataset[cmpt_ds] = new HDFdataset(name_dataset,hdf_subgroup[Tag_RefOnAppliedHypothesis]);
-               hdf_dataset[cmpt_ds]->OpenOnDisk();
-               size=hdf_dataset[cmpt_ds]->GetSize();
-               
-               char * refFromFile =new char[size];
-               hdf_dataset[cmpt_ds]->ReadFromDisk(refFromFile);
-               //SCRUTE(refFromFile);
-               hdf_dataset[cmpt_ds]->CloseOnDisk();
-               cmpt_ds++;
-               if (_found) {
-                 SALOMEDS::SObject_var HypSO = Study->FindObjectID(refFromFile);
-                 if (!CORBA::is_nil(HypSO)) {
-                   HypSO->FindAttribute(anAttr, "AttributeIOR");
-                   anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
-                   if (!CORBA::is_nil(anIOR)) {
-                     char* HypIOR = anIOR->Value();
-                     SMESH::SMESH_Hypothesis_var anHyp = SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(HypIOR));
-                     if (!CORBA::is_nil(anHyp)) {
-                       myNewMesh->AddHypothesis(aShape,anHyp);
-                       MESSAGE("Hypothesis added ...");
-                     }
-                   }
-                 }
+       for (int ii = 0; ii < nb_meshsubgroup; ii++)
+       {
+               hdfGroupMeshId->InternalObjectIndentify(ii, msgname);
+               if (strcmp(msgname, "Mesh data") == 0)
+               {
+                       //nothing
                }
-             } 
-             
-             hdf_subgroup[Tag_RefOnAppliedHypothesis]->CloseOnDisk();
-             //********** 
-           }
-           else if (strcmp(msgname,"Applied Algorithms")==0) {
-
-             //********** Loading of the applied algorithms 
-             strcpy(name_of_group,"Applied Algorithms");
-             hdf_subgroup[Tag_RefOnAppliedAlgorithms] = new HDFgroup(name_of_group,hdf_group[myMeshId]);
-             hdf_subgroup[Tag_RefOnAppliedAlgorithms]->OpenOnDisk();
-             
-             nb_datasets = hdf_subgroup[Tag_RefOnAppliedAlgorithms]->nInternalObjects();  
-             SCRUTE(nb_datasets);
-             
-             for (int j=0;j<nb_datasets;j++) {
-               sprintf(name_dataset,"Algo %d",j);
-               hdf_dataset[cmpt_ds] = new HDFdataset(name_dataset,hdf_subgroup[Tag_RefOnAppliedAlgorithms]);
-               hdf_dataset[cmpt_ds]->OpenOnDisk();
-               size=hdf_dataset[cmpt_ds]->GetSize();
-               
-               char * refFromFile =new char[size];
-               hdf_dataset[cmpt_ds]->ReadFromDisk(refFromFile);
-               hdf_dataset[cmpt_ds]->CloseOnDisk();
-               cmpt_ds++;
-               
-               if (_found) {
-                 SALOMEDS::SObject_var AlgoSO = Study->FindObjectID(refFromFile);
-                 if (!CORBA::is_nil(AlgoSO)) {
-                   AlgoSO->FindAttribute(anAttr, "AttributeIOR");
-                   anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
-                   if (!CORBA::is_nil(anIOR)) {
-                     char* AlgoIOR = anIOR->Value();
-                     //SCRUTE(AlgoIOR);
-                     SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(AlgoIOR));
-                     SMESH::SMESH_Algo_var anAlgo = SMESH::SMESH_Algo::_narrow(myHyp);
-                     //SMESH::SMESH_Algo_var anAlgo = SMESH::SMESH_Algo::_narrow(_orb->string_to_object(AlgoIOR));
-                     if (!CORBA::is_nil(anAlgo)) {
-                       myNewMesh->AddHypothesis(aShape,anAlgo);//essayer avec _SMESHCorbaObj
-                       MESSAGE("Algorithms added ...");
-                     }
-                   }
-                 }
+               else if (strcmp(msgname, "Ref on shape") == 0)
+               {
+                       //nothing
                }
-             } 
-             
-             hdf_subgroup[Tag_RefOnAppliedAlgorithms]->CloseOnDisk();
-             //********** 
-           }
-           else if (string(msgname).substr(0,9)==string("SubMeshes")) {
-             
-             
-             //********** Loading of the submeshes on subshapes
-             int myLevel1Tag, myTag;
-             SCRUTE(msgname);
-             cmpt_sm++;
-             myLevel1Tag = 10+cmpt_sm;
-             hdf_subgroup[myLevel1Tag] = new HDFgroup(name_of_group,hdf_group[myMeshId]);
-             hdf_subgroup[myLevel1Tag] = new HDFgroup(msgname,hdf_group[myMeshId]);
-             hdf_subgroup[myLevel1Tag]->OpenOnDisk();
-       
-             int nb_submeshes = hdf_subgroup[myLevel1Tag]->nInternalObjects();  
-             SCRUTE(nb_submeshes);
-
-             for (int j=0;j<nb_submeshes;j++) {
-               cmpt_sm++;
-               myTag = 10+cmpt_sm;
-               hdf_subgroup[myLevel1Tag]->InternalObjectIndentify(j,name_meshgroup);
-               SCRUTE(name_meshgroup);
-
-               hdf_subgroup[myTag] = new HDFgroup(name_meshgroup,hdf_subgroup[myLevel1Tag]);
-               hdf_subgroup[myTag]->OpenOnDisk();
-               int subMeshId = atoi((string(name_meshgroup).substr(8,18)).c_str());
-               
-               MESSAGE("Ref on shape");
-               //********** ref on shape
-               sprintf(name_dataset,"Ref on shape");
-               hdf_dataset[cmpt_ds] = new HDFdataset(name_dataset,hdf_subgroup[myTag]);
-               hdf_dataset[cmpt_ds]->OpenOnDisk();
-               size=hdf_dataset[cmpt_ds]->GetSize();
-               
-               char * refFromFile =new char[size];
-               hdf_dataset[cmpt_ds]->ReadFromDisk(refFromFile);
-               hdf_dataset[cmpt_ds]->CloseOnDisk();
-               cmpt_ds++;
-               
-               bool _found3 = false;
-               SALOMEDS::SObject_var GSO = Study->FindObjectID(refFromFile);
-               SMESH::SMESH_subMesh_var aSubMesh;
-               GEOM::GEOM_Shape_var aSubShape;
-               
-               if (!CORBA::is_nil(GSO)) {
-                 GSO->FindAttribute(anAttr, "AttributeIOR");
-                 anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
-                 char* SubShapeIOR = anIOR->Value();
-                 aSubShape = GEOM::GEOM_Shape::_narrow(_orb->string_to_object(SubShapeIOR));
-                 
-                 if (!CORBA::is_nil(aSubShape)) {
-                   aSubMesh = myNewMesh->GetElementsOnShape(aSubShape);
-                   string iorString = _orb->object_to_string(aSubMesh);
-                   sprintf(objectId,"%d",subMeshId);
-                   _SMESHCorbaObj[string("SubMesh_")+string(objectId)] = iorString;
-                   _found3 = true;
-                   //SCRUTE(aSubMesh->GetNumberOfNodes());
-                   //MESSAGE("yes");
-                   //SCRUTE(aSubMesh->GetNumberOfElements());
-                 }
+               else if (strcmp(msgname, "Applied Hypothesis") == 0)
+               {
+                       loadAppliedHypothesis(hdfGroupMeshId, _found, Study, myNewMesh,
+                               aShape);
                }
-                   
-               int nb_subgroup = hdf_subgroup[myTag]->nInternalObjects(); 
-               SCRUTE(nb_subgroup);
-               for (int k=0;k<nb_subgroup;k++) 
-                 {
-                   hdf_subgroup[myTag]->InternalObjectIndentify(k,sgname);
-                   if (strcmp(sgname,"Ref on shape")==0) {
-                     //nothing
-                   }
-                   else if (strcmp(sgname,"Applied Hypothesis")==0) {
-                     //********** ref on applied hypothesis
-                     MESSAGE("Applied Hypothesis");
-                     strcpy(name_meshgroup,"Applied Hypothesis");
-                     cmpt_sm++;
-                     hdf_subgroup[10+cmpt_sm] = new HDFgroup(name_meshgroup,hdf_subgroup[myTag]);
-                     hdf_subgroup[10+cmpt_sm]->OpenOnDisk();
-                     nb_datasets = hdf_subgroup[10+cmpt_sm]->nInternalObjects();  
-                     SCRUTE(nb_datasets);
-                     
-                     for (int l=0;l<nb_datasets;l++) {
-                       sprintf(name_dataset,"Hyp %d",l);
-                       hdf_dataset[cmpt_ds] = new HDFdataset(name_dataset,hdf_subgroup[10+cmpt_sm]);
-                       hdf_dataset[cmpt_ds]->OpenOnDisk();
-                       size=hdf_dataset[cmpt_ds]->GetSize();
-                       
-                       char * refFromFile =new char[size];
-                       hdf_dataset[cmpt_ds]->ReadFromDisk(refFromFile);
-                       hdf_dataset[cmpt_ds]->CloseOnDisk();
-                       cmpt_ds++;
-                       
-                       if (_found3) {
-                         SALOMEDS::SObject_var HypSO = Study->FindObjectID(refFromFile);
-                         if (!CORBA::is_nil(HypSO)) {
-                           HypSO->FindAttribute(anAttr, "AttributeIOR");
-                           anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
-                           if (!CORBA::is_nil(anIOR)) {
-                             char* HypIOR = anIOR->Value();
-                             SMESH::SMESH_Hypothesis_var anHyp = SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(HypIOR));
-                             if (!CORBA::is_nil(anHyp)) {
-                               SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
-                               aMesh->AddHypothesis(aSubShape,anHyp);//essayer avec _SMESHCorbaObj
-                               MESSAGE("Hypothesis added ...");
-                             }
-                           }
-                         }
-                       }
-                     } 
-                   }
-                   else if (strcmp(sgname,"Applied Algorithms")==0) {
-                     //********** ref on applied algorithms
-                     MESSAGE("Applied Algorithms");
-                     strcpy(name_meshgroup,"Applied Algorithms");
-                     cmpt_sm++;
-                     hdf_subgroup[10+cmpt_sm] = new HDFgroup(name_meshgroup,hdf_subgroup[myTag]);
-                     hdf_subgroup[10+cmpt_sm]->OpenOnDisk();
-                     nb_datasets = hdf_subgroup[10+cmpt_sm]->nInternalObjects();  
-                     SCRUTE(nb_datasets);
-                     
-                     for (int l=0;l<nb_datasets;l++) {
-                       sprintf(name_dataset,"Algo %d",l);
-                       hdf_dataset[cmpt_ds] = new HDFdataset(name_dataset,hdf_subgroup[10+cmpt_sm]);
-                       hdf_dataset[cmpt_ds]->OpenOnDisk();
-                       size=hdf_dataset[cmpt_ds]->GetSize();
-                       
-                       char * refFromFile =new char[size];
-                       hdf_dataset[cmpt_ds]->ReadFromDisk(refFromFile);
-                       hdf_dataset[cmpt_ds]->CloseOnDisk();
-                       cmpt_ds++;
-                       
-                       if (_found3) {
-                         SALOMEDS::SObject_var AlgoSO = Study->FindObjectID(refFromFile);
-                         if (!CORBA::is_nil(AlgoSO)) {
-                           AlgoSO->FindAttribute(anAttr, "AttributeIOR");
-                           anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
-                           if (!CORBA::is_nil(anIOR)) {
-                             char* AlgoIOR = anIOR->Value();
-                             //SCRUTE(AlgoIOR);
-                             SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(AlgoIOR));
-                             SMESH::SMESH_Algo_var anAlgo = SMESH::SMESH_Algo::_narrow(myHyp);
-                             //SMESH::SMESH_Algo_var anAlgo = SMESH::SMESH_Algo::_narrow(_orb->string_to_object(AlgoIOR));
-                             if (!CORBA::is_nil(anAlgo)) {
-                               SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
-                               aMesh->AddHypothesis(aSubShape,anAlgo);//essayer avec _SMESHCorbaObj
-                               MESSAGE("Algorithms added ...");
-                             }
-                           }
-                         }
-                       }
-                       
-                     } 
-                   }
-                 }
-               hdf_subgroup[myTag]->CloseOnDisk();
-             }
-             hdf_subgroup[myLevel1Tag]->CloseOnDisk();
-           }
-         }
-       hdf_group[myMeshId]->CloseOnDisk();     
-       
+               else if (strcmp(msgname, "Applied Algorithms") == 0)
+               {
+                       loadAppliedAlgorithms(hdfGroupMeshId, _found, Study, myNewMesh,
+                               aShape);
+               }
+               else if (string(msgname).substr(0, 9) == string("SubMeshes"))
+               {
+                       loadSubMeshes(hdfGroupMeshId, msgname, Study, myNewMesh);
+               }
+       }
+       hdfGroupMeshId->CloseOnDisk();
        MESSAGE("End of Meshes Load");
-      }
-    }
-  
-  MESSAGE("End of SMESH_Gen::Load");
-  
-  hdf_file->CloseOnDisk();
-  delete  hdf_file;
-  hdf_file=0;
-
-  // Remove temporary files created from the stream
-  if (isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(tmpDir.ToCString(), aFileSeq.in(), true);
-
-  return true;
+}
+
+/**
+ * Load the part of the study related to SMESH.
+ */
+bool SMESH_Gen_i::Load(SALOMEDS::SComponent_ptr theComponent,
+       const SALOMEDS::TMPFile & theStream, const char *theURL, bool isMultiFile)
+{
+       MESSAGE("SMESH_Gen_i::Load");   
+       // Get temporary files location
+       TCollection_AsciiString tmpDir =
+               isMultiFile ? TCollection_AsciiString((char *)theURL) : SALOMEDS_Tool::
+               GetTmpDir();
+
+       // Convert the stream into sequence of files to process
+       SALOMEDS::ListOfFileNames_var aFileSeq =
+               SALOMEDS_Tool::PutStreamToFiles(theStream, tmpDir.ToCString(),
+               isMultiFile);
+
+       TCollection_AsciiString aStudyName("");
+       if (isMultiFile)
+               aStudyName =
+                       (SALOMEDS_Tool::GetNameFromPath(theComponent->GetStudy()->URL()));
+
+       // Set names of temporary files
+       TCollection_AsciiString filename =
+               tmpDir + aStudyName + TCollection_AsciiString("_SMESH.hdf");
+       TCollection_AsciiString hypofile =
+               tmpDir + aStudyName + TCollection_AsciiString("_SMESH_Hypo.txt");
+       TCollection_AsciiString algofile =
+               tmpDir + aStudyName + TCollection_AsciiString("_SMESH_Algo.txt");
+       TCollection_AsciiString meshfile =
+               tmpDir + aStudyName + TCollection_AsciiString("_SMESH_Mesh.med");
+
+       SALOMEDS::Study_var Study = theComponent->GetStudy();
+       int studyId = Study->StudyId();
+       SCRUTE(studyId);
+
+       SALOMEDS::AttributeName_var aName;
+       
+       SALOMEDS::SComponent_var fathergeom = Study->FindComponent("GEOM");
+       SALOMEDS::SComponent_var myGeomSComp =
+               SALOMEDS::SComponent::_narrow(fathergeom);
+       SCRUTE(fathergeom);
+
+       char name[HDF_NAME_MAX_LEN + 1];
+       map < int, HDFgroup * > hdf_subgroup;   
+
+
+       //************* HDF file opening
+       HDFfile *hdf_file = new HDFfile(filename.ToCString());
+       try
+       {
+               hdf_file->OpenOnDisk(HDF_RDONLY);
+       }
+       catch(HDFexception)
+       {
+               MESSAGE("Load(): " << filename << " not found!");
+               return false;
+       }
+
+       //****************************
+
+       int nb_group = hdf_file->nInternalObjects();
+       SCRUTE(nb_group);
+       for (int i = 0; i < nb_group; i++)
+       {
+               hdf_file->InternalObjectIndentify(i, name);
+               if (strcmp(name, "Hypothesis") == 0)
+                       loadHypothesis(name, hdf_file, hypofile.ToCString(), studyId);
+               else if (strcmp(name, "Algorithms") == 0)
+                       loadAlgorithms(name, hdf_file, algofile.ToCString(), studyId);
+               else if (string(name).substr(0, 4) == string("Mesh"))
+                       loadMesh(name, hdf_file, meshfile.ToCString(), Study);
+       }
+
+       MESSAGE("End of SMESH_Gen::Load");
+
+       hdf_file->CloseOnDisk();
+
+       // Remove temporary files created from the stream
+       if (isMultiFile)
+               SALOMEDS_Tool::RemoveTemporaryFiles(tmpDir.ToCString(), aFileSeq.in(),
+                       true);
+
+       return true;
 }
 
 bool SMESH_Gen_i::LoadASCII(SALOMEDS::SComponent_ptr theComponent,
-                           const SALOMEDS::TMPFile& theStream,
-                           const char* theURL,
-                           bool isMultiFile) {
-  return Load(theComponent, theStream, theURL, isMultiFile);
+       const SALOMEDS::TMPFile & theStream, const char *theURL, bool isMultiFile)
+{
+       return Load(theComponent, theStream, theURL, isMultiFile);
 }
 
 //=============================================================================
@@ -1463,64 +1633,84 @@ bool SMESH_Gen_i::LoadASCII(SALOMEDS::SComponent_ptr theComponent,
 
 void SMESH_Gen_i::Close(SALOMEDS::SComponent_ptr theComponent)
 {
-  MESSAGE("Close");
-  SALOMEDS::Study_var aStudy = theComponent->GetStudy();
-  SALOMEDS::ChildIterator_var itBig = aStudy->NewChildIterator(theComponent);
-  for (; itBig->More();itBig->Next()) {
-    SALOMEDS::SObject_var gotBranch = itBig->Value();
-    
-    // branch 1 : hypothesis
-    if (gotBranch->Tag()==Tag_HypothesisRoot || gotBranch->Tag()==Tag_AlgorithmsRoot) {
-      SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(gotBranch);
-      for (; it->More();it->Next()) {
-       SALOMEDS::SObject_var mySObject = it->Value();
-       SALOMEDS::GenericAttribute_var anAttr;
-       SALOMEDS::AttributeIOR_var anIOR;
-       if ( mySObject->FindAttribute(anAttr, "AttributeIOR")) {
-         anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
-         SMESH::SMESH_Hypothesis_var myHyp =
-           SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(anIOR->Value()));
-         char objectId[10];
-         sprintf(objectId,"%d",myHyp->GetId());
-//       cout<<"********** delete Hyp "<<objectId<<endl;
-         _SMESHCorbaObj.erase(string("Hypo_")+string(objectId));
-         myHyp = SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(anIOR->Value()));
-       }
-      }
-    }
-    // branch 2 : algorithms
-    else if (gotBranch->Tag()>=3) {
-      SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(gotBranch);
-      for (; it->More();it->Next()) {
-       SALOMEDS::SObject_var mySObject = it->Value();
-       SALOMEDS::GenericAttribute_var anAttr;
-       SALOMEDS::AttributeIOR_var anIOR;
-       if ( mySObject->FindAttribute(anAttr, "AttributeIOR")) {
-         anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
-         SMESH::SMESH_Mesh_var myMesh =
-           SMESH::SMESH_Mesh::_narrow(_orb->string_to_object(anIOR->Value()));
-         if (!myMesh->_is_nil()) {
-           char objectId[10];
-           sprintf(objectId,"%d",myMesh->GetId());
-//         cout<<"********** delete Mesh "<<objectId<<endl;
-           _SMESHCorbaObj.erase(string("Mesh_")+string(objectId));
-           CORBA::release(myMesh);
-         }
-         else {
-           SMESH::SMESH_subMesh_var mySubMesh =
-             SMESH::SMESH_subMesh::_narrow(_orb->string_to_object(anIOR->Value()));
-           if (!mySubMesh->_is_nil()) {
-             char objectId[10];
-             sprintf(objectId,"%d",mySubMesh->GetId());
-//           cout<<"********** delete SubMesh "<<objectId<<endl;
-             _SMESHCorbaObj.erase(string("SubMesh_")+string(objectId));
-             CORBA::release(mySubMesh);
-           }
-         }
+       MESSAGE("Close");
+       SALOMEDS::Study_var aStudy = theComponent->GetStudy();
+       SALOMEDS::ChildIterator_var itBig = aStudy->NewChildIterator(theComponent);
+       for (; itBig->More(); itBig->Next())
+       {
+               SALOMEDS::SObject_var gotBranch = itBig->Value();
+
+               // branch 1 : hypothesis
+               if (gotBranch->Tag() == Tag_HypothesisRoot ||
+                       gotBranch->Tag() == Tag_AlgorithmsRoot)
+               {
+                       SALOMEDS::ChildIterator_var it =
+                               aStudy->NewChildIterator(gotBranch);
+                       for (; it->More(); it->Next())
+                       {
+                               SALOMEDS::SObject_var mySObject = it->Value();
+                               SALOMEDS::GenericAttribute_var anAttr;
+                               SALOMEDS::AttributeIOR_var anIOR;
+                               if (mySObject->FindAttribute(anAttr, "AttributeIOR"))
+                               {
+                                       anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
+                                       SMESH::SMESH_Hypothesis_var myHyp =
+                                               SMESH::SMESH_Hypothesis::_narrow(_orb->
+                                               string_to_object(anIOR->Value()));
+                                       char objectId[10];
+                                       sprintf(objectId, "%ld", myHyp->GetId());
+//        cout<<"********** delete Hyp "<<objectId<<endl;
+                                       _SMESHCorbaObj.erase(string("Hypo_") + string(objectId));
+                                       myHyp =
+                                               SMESH::SMESH_Hypothesis::_narrow(_orb->
+                                               string_to_object(anIOR->Value()));
+                               }
+                       }
+               }
+               // branch 2 : algorithms
+               else if (gotBranch->Tag() >= 3)
+               {
+                       SALOMEDS::ChildIterator_var it =
+                               aStudy->NewChildIterator(gotBranch);
+                       for (; it->More(); it->Next())
+                       {
+                               SALOMEDS::SObject_var mySObject = it->Value();
+                               SALOMEDS::GenericAttribute_var anAttr;
+                               SALOMEDS::AttributeIOR_var anIOR;
+                               if (mySObject->FindAttribute(anAttr, "AttributeIOR"))
+                               {
+                                       anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
+                                       SMESH::SMESH_Mesh_var myMesh =
+                                               SMESH::SMESH_Mesh::_narrow(_orb->
+                                               string_to_object(anIOR->Value()));
+                                       if (!myMesh->_is_nil())
+                                       {
+                                               char objectId[10];
+                                               sprintf(objectId, "%ld", myMesh->GetId());
+//          cout<<"********** delete Mesh "<<objectId<<endl;
+                                               _SMESHCorbaObj.erase(string("Mesh_") +
+                                                       string(objectId));
+                                               CORBA::release(myMesh);
+                                       }
+                                       else
+                                       {
+                                               SMESH::SMESH_subMesh_var mySubMesh =
+                                                       SMESH::SMESH_subMesh::_narrow(_orb->
+                                                       string_to_object(anIOR->Value()));
+                                               if (!mySubMesh->_is_nil())
+                                               {
+                                                       char objectId[10];
+                                                       sprintf(objectId, "%ld", mySubMesh->GetId());
+//            cout<<"********** delete SubMesh "<<objectId<<endl;
+                                                       _SMESHCorbaObj.erase(string("SubMesh_") +
+                                                               string(objectId));
+                                                       CORBA::release(mySubMesh);
+                                               }
+                                       }
+                               }
+                       }
+               }
        }
-      }
-    }
-  }
 }
 
 //=============================================================================
@@ -1529,67 +1719,73 @@ void SMESH_Gen_i::Close(SALOMEDS::SComponent_ptr theComponent)
  */
 //=============================================================================
 
-charSMESH_Gen_i::ComponentDataType()
+char *SMESH_Gen_i::ComponentDataType()
 {
-  MESSAGE("SMESH_Gen_i::ComponentDataType");
-  return strdup("SMESH");
+       MESSAGE("SMESH_Gen_i::ComponentDataType");
+       return strdup("SMESH");
 }
 
-    
 //=============================================================================
 /*!
  *  
  */
 //=============================================================================
 
-char* SMESH_Gen_i::IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject,
-                                         const char* IORString,
-                                         CORBA::Boolean isMultiFile,
-                                         CORBA::Boolean isASCII)
+char *SMESH_Gen_i::IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject,
+       const char *IORString, CORBA::Boolean isMultiFile, CORBA::Boolean isASCII)
 {
-  MESSAGE("SMESH_Gen_i::IORToLocalPersistentID");
-
-  char objectId[10];
-
-  SMESH::SMESH_Algo_var myAlgo = SMESH::SMESH_Algo::_narrow(_orb->string_to_object(IORString));
-  if (! CORBA::is_nil(myAlgo))
-    {
-      string prefix = "Hypo_";
-      sprintf(objectId,"%d",myAlgo->GetId());
-      string lpID = prefix + string(objectId);
-      return CORBA::string_dup(lpID.c_str());
-    }
-  else {
-    SMESH::SMESH_Hypothesis_var myHypo = SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(IORString));
-    if (! CORBA::is_nil(myHypo))
-      {
-        string prefix = "Hypo_";
-        sprintf(objectId,"%d",myHypo->GetId());
-        string lpID = prefix + string(objectId);
-        return CORBA::string_dup(lpID.c_str());
-      }
-    else {
-      SMESH::SMESH_Mesh_var myMesh = SMESH::SMESH_Mesh::_narrow(_orb->string_to_object(IORString));
-      if (! CORBA::is_nil(myMesh))
+       MESSAGE("SMESH_Gen_i::IORToLocalPersistentID");
+
+       char objectId[10];
+
+       SMESH::SMESH_Algo_var myAlgo =
+               SMESH::SMESH_Algo::_narrow(_orb->string_to_object(IORString));
+       if (!CORBA::is_nil(myAlgo))
        {
-         string prefix = "Mesh_";
-         sprintf(objectId,"%d",myMesh->GetId());
-         string lpID = prefix + string(objectId);
-         return CORBA::string_dup(lpID.c_str());
+               string prefix = "Hypo_";
+               sprintf(objectId, "%ld", myAlgo->GetId());
+               string lpID = prefix + string(objectId);
+               return CORBA::string_dup(lpID.c_str());
+       }
+       else
+       {
+               SMESH::SMESH_Hypothesis_var myHypo =
+                       SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(IORString));
+               if (!CORBA::is_nil(myHypo))
+               {
+                       string prefix = "Hypo_";
+                       sprintf(objectId, "%ld", myHypo->GetId());
+                       string lpID = prefix + string(objectId);
+                       return CORBA::string_dup(lpID.c_str());
+               }
+               else
+               {
+                       SMESH::SMESH_Mesh_var myMesh =
+                               SMESH::SMESH_Mesh::_narrow(_orb->string_to_object(IORString));
+                       if (!CORBA::is_nil(myMesh))
+                       {
+                               string prefix = "Mesh_";
+                               sprintf(objectId, "%ld", myMesh->GetId());
+                               string lpID = prefix + string(objectId);
+                               return CORBA::string_dup(lpID.c_str());
+                       }
+                       else
+                       {
+                               SMESH::SMESH_subMesh_var mySubMesh =
+                                       SMESH::SMESH_subMesh::_narrow(_orb->
+                                       string_to_object(IORString));
+                               if (!CORBA::is_nil(mySubMesh))
+                               {
+                                       string prefix = "SubMesh_";
+                                       sprintf(objectId, "%ld", mySubMesh->GetId());
+                                       string lpID = prefix + string(objectId);
+                                       return CORBA::string_dup(lpID.c_str());
+                               }
+                               else
+                                       return (strdup("no object"));
+                       }
+               }
        }
-      else {
-       SMESH::SMESH_subMesh_var mySubMesh = SMESH::SMESH_subMesh::_narrow(_orb->string_to_object(IORString));
-       if (! CORBA::is_nil(mySubMesh))
-         {
-           string prefix = "SubMesh_";
-           sprintf(objectId,"%d",mySubMesh->GetId());
-           string lpID = prefix + string(objectId);
-           return CORBA::string_dup(lpID.c_str());
-         }
-       else return (strdup("no object"));
-      }
-    }
-  }
 }
 
 //=============================================================================
@@ -1598,16 +1794,15 @@ char* SMESH_Gen_i::IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject,
  */
 //=============================================================================
 
-char* SMESH_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject,
-                                         const char* aLocalPersistentID,
-                                         CORBA::Boolean isMultiFile,
-                                         CORBA::Boolean isASCII)
+char *SMESH_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject,
+       const char *aLocalPersistentID,
+       CORBA::Boolean isMultiFile, CORBA::Boolean isASCII)
 {
-  MESSAGE("SMESH_Gen_i::LocalPersistentIDToIOR");
-  SCRUTE(aLocalPersistentID);
-  string clef = string(aLocalPersistentID);
-  SCRUTE(_SMESHCorbaObj[clef].c_str());
-  return CORBA::string_dup(_SMESHCorbaObj[clef].c_str());
+       MESSAGE("SMESH_Gen_i::LocalPersistentIDToIOR");
+       SCRUTE(aLocalPersistentID);
+       string clef = string(aLocalPersistentID);
+       SCRUTE(_SMESHCorbaObj[clef].c_str());
+       return CORBA::string_dup(_SMESHCorbaObj[clef].c_str());
 }
 
 //=============================================================================
@@ -1616,125 +1811,164 @@ char* SMESH_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject,
  */
 //=============================================================================
 
-SMESH_topo* SMESH_Gen_i::ExploreMainShape(GEOM::GEOM_Gen_ptr geomEngine,
-                                          CORBA::Long studyId,
-                                          GEOM::GEOM_Shape_ptr aShape)
+SMESH_topo *SMESH_Gen_i::ExploreMainShape(GEOM::GEOM_Gen_ptr geomEngine,
+       CORBA::Long studyId, GEOM::GEOM_Shape_ptr aShape)
+{
+       MESSAGE("SMESH_Mesh_i::ExploreMainShape");
+       // _narrow() duplicates the reference and check the type
+       GEOM::GEOM_Gen_var geom = GEOM::GEOM_Gen::_narrow(geomEngine);
+       GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(aShape);
+
+       if (CORBA::is_nil(geom))
+               THROW_SALOME_CORBA_EXCEPTION("bad geom reference", SALOME::BAD_PARAM);
+       if (CORBA::is_nil(myShape))
+               THROW_SALOME_CORBA_EXCEPTION("bad shape reference", SALOME::BAD_PARAM);
+       MESSAGE("---");
+       SCRUTE(myShape->Name());
+       geom->GetCurrentStudy(studyId);
+       SCRUTE(studyId);
+       TopoDS_Shape mainShape = _ShapeReader->GetShape(geom, myShape);
+       MESSAGE("---");
+
+       // create an SMESH_topo object for the mainShape
+
+       SMESH_topo *myTopo = new SMESH_topo();
+       MESSAGE("---");
+
+       // explore local TopoDS_Shape, store reference of local TopoDS subShapes
+
+       for (TopExp_Explorer exp(mainShape, TopAbs_COMPOUND); exp.More();
+               exp.Next())
+       {
+               const TopoDS_Compound & E = TopoDS::Compound(exp.Current());
+               int i = myTopo->_myShapes[TopAbs_COMPOUND].Add(E);
+               SCRUTE(i);
+       }
+       for (TopExp_Explorer exp(mainShape, TopAbs_COMPSOLID); exp.More();
+               exp.Next())
+       {
+               const TopoDS_CompSolid & E = TopoDS::CompSolid(exp.Current());
+               int i = myTopo->_myShapes[TopAbs_COMPSOLID].Add(E);
+               SCRUTE(i);
+       }
+       for (TopExp_Explorer exp(mainShape, TopAbs_SOLID); exp.More(); exp.Next())
+       {
+               const TopoDS_Solid & E = TopoDS::Solid(exp.Current());
+               int i = myTopo->_myShapes[TopAbs_SOLID].Add(E);
+               SCRUTE(i);
+       }
+       for (TopExp_Explorer exp(mainShape, TopAbs_SHELL); exp.More(); exp.Next())
+       {
+               const TopoDS_Shell & E = TopoDS::Shell(exp.Current());
+               int i = myTopo->_myShapes[TopAbs_SHELL].Add(E);
+               SCRUTE(i);
+       }
+       for (TopExp_Explorer exp(mainShape, TopAbs_FACE); exp.More(); exp.Next())
+       {
+               const TopoDS_Face & E = TopoDS::Face(exp.Current());
+               int i = myTopo->_myShapes[TopAbs_FACE].Add(E);
+               SCRUTE(i);
+       }
+       for (TopExp_Explorer exp(mainShape, TopAbs_WIRE); exp.More(); exp.Next())
+       {
+               const TopoDS_Wire & E = TopoDS::Wire(exp.Current());
+               int i = myTopo->_myShapes[TopAbs_WIRE].Add(E);
+               SCRUTE(i);
+       }
+       for (TopExp_Explorer exp(mainShape, TopAbs_EDGE); exp.More(); exp.Next())
+       {
+               const TopoDS_Edge & E = TopoDS::Edge(exp.Current());
+               int i = myTopo->_myShapes[TopAbs_EDGE].Add(E);
+               SCRUTE(i);
+       }
+       for (TopExp_Explorer exp(mainShape, TopAbs_VERTEX); exp.More(); exp.Next())
+       {
+               const TopoDS_Vertex & E = TopoDS::Vertex(exp.Current());
+               int i = myTopo->_myShapes[TopAbs_VERTEX].Add(E);
+               SCRUTE(i);
+       }
+
+       // explore subShapes of distant CORBA object,
+       // associate distant CORBA subShape references
+       // with local reference to local TopoDS subShape
+
+       string filenode = "toposhape.txt";
+       ofstream fic(filenode.c_str());
+
+       for (int shapeType = TopAbs_COMPOUND; shapeType < TopAbs_SHAPE; shapeType++)
+       {
+               fic << "shape type : " << SMESH_shapeTypeNames[shapeType];
+
+               GEOM::GEOM_Gen::ListOfGeomShapes_var subShapes
+                       = geom->SubShapeAll(myShape, shapeType);
+               int nbSubShapes = subShapes->length();
+               int nbLocal = myTopo->_myShapes[shapeType].Extent();
+               fic << " - number of elements: " << nbSubShapes << endl;
+               ASSERT(nbSubShapes == nbLocal);
+
+               for (int i = 0; i < nbSubShapes; i++)
+               {
+                       GEOM::GEOM_Shape_var aSubShape = subShapes[i];
+                       string idShape = SMESH_topo::GetShapeLocalId(aSubShape);
+                       fic << "  " << idShape;
+                       SCRUTE(idShape);
+                       TopoDS_Shape aLocShape = _ShapeReader->GetShape(geom, aSubShape);
+                       for (int j = 1; j <= nbLocal; j++)
+                               if (aLocShape.IsSame(myTopo->_myShapes[shapeType].FindKey(j)))
+                               {
+                                       MESSAGE("  --- trouve = " << j);
+                                       myTopo->_mapIndShapes[shapeType][idShape] = j;
+                                       fic << "  --- trouve = " << j;
+                                       break;
+                               }
+                       fic << endl;
+               }
+       }
+       fic.close();
+
+       return myTopo;
+}
+
+/**
+ * Import a mesh from a file
+ * @param fileName file name to be imported
+ * @param fileType Currently it could be either "DAT", "UNV" or "MED".
+ */
+SMESH::SMESH_Mesh_ptr SMESH_Gen_i::Import(CORBA::Long studyId,
+       const char *fileName, const char *fileType)
 {
-  MESSAGE("SMESH_Mesh_i::ExploreMainShape");
-  // _narrow() duplicates the reference and check the type
-  GEOM::GEOM_Gen_var geom = GEOM::GEOM_Gen::_narrow(geomEngine);
-  GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(aShape);
-
-  if (CORBA::is_nil(geom))
-    THROW_SALOME_CORBA_EXCEPTION("bad geom reference", \
-                                 SALOME::BAD_PARAM);
-  if (CORBA::is_nil(myShape))
-    THROW_SALOME_CORBA_EXCEPTION("bad shape reference", \
-                                 SALOME::BAD_PARAM);
-  MESSAGE("---");
-  SCRUTE(myShape->Name());
-  geom->GetCurrentStudy(studyId);
-  SCRUTE(studyId);
-  TopoDS_Shape mainShape  = _ShapeReader->GetShape(geom,myShape);
-  MESSAGE("---");
-
-  // create an SMESH_topo object for the mainShape
-
-  SMESH_topo* myTopo = new SMESH_topo();
-  MESSAGE("---");
-
-  // explore local TopoDS_Shape, store reference of local TopoDS subShapes
-
-  for (TopExp_Explorer exp(mainShape,TopAbs_COMPOUND); exp.More(); exp.Next())
-    {
-      const TopoDS_Compound& E = TopoDS::Compound(exp.Current());
-      int i = myTopo->_myShapes[TopAbs_COMPOUND].Add(E);
-      SCRUTE(i);
-    }
-  for (TopExp_Explorer exp(mainShape,TopAbs_COMPSOLID); exp.More(); exp.Next())
-    {
-      const TopoDS_CompSolid& E = TopoDS::CompSolid(exp.Current());
-      int i = myTopo->_myShapes[TopAbs_COMPSOLID].Add(E);
-      SCRUTE(i);
-    }
-  for (TopExp_Explorer exp(mainShape,TopAbs_SOLID); exp.More(); exp.Next())
-    {
-      const TopoDS_Solid& E = TopoDS::Solid(exp.Current());
-      int i = myTopo->_myShapes[TopAbs_SOLID].Add(E);
-      SCRUTE(i);
-    }
-  for (TopExp_Explorer exp(mainShape,TopAbs_SHELL); exp.More(); exp.Next())
-    {
-      const TopoDS_Shell& E = TopoDS::Shell(exp.Current());
-      int i = myTopo->_myShapes[TopAbs_SHELL].Add(E);
-      SCRUTE(i);
-    }
-  for (TopExp_Explorer exp(mainShape,TopAbs_FACE); exp.More(); exp.Next())
-    {
-      const TopoDS_Face& E = TopoDS::Face(exp.Current());
-      int i = myTopo->_myShapes[TopAbs_FACE].Add(E);
-      SCRUTE(i);
-    }
-  for (TopExp_Explorer exp(mainShape,TopAbs_WIRE); exp.More(); exp.Next())
-    {
-      const TopoDS_Wire& E = TopoDS::Wire(exp.Current());
-      int i = myTopo->_myShapes[TopAbs_WIRE].Add(E);
-      SCRUTE(i);
-    }
-  for (TopExp_Explorer exp(mainShape,TopAbs_EDGE); exp.More(); exp.Next())
-    {
-      const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
-      int i = myTopo->_myShapes[TopAbs_EDGE].Add(E);
-      SCRUTE(i);
-    }
-  for (TopExp_Explorer exp(mainShape,TopAbs_VERTEX); exp.More(); exp.Next())
-    {
-      const TopoDS_Vertex& E = TopoDS::Vertex(exp.Current());
-      int i = myTopo->_myShapes[TopAbs_VERTEX].Add(E);
-      SCRUTE(i);
-    }
-  
-  // explore subShapes of distant CORBA object,
-  // associate distant CORBA subShape references
-  // with local reference to local TopoDS subShape
-
-  string filenode = "toposhape.txt";
-  ofstream fic(filenode.c_str());
-
-  for (int shapeType = TopAbs_COMPOUND; shapeType < TopAbs_SHAPE; shapeType++)
-    {
-      fic << "shape type : " << SMESH_shapeTypeNames[shapeType];
-
-      GEOM::GEOM_Gen::ListOfGeomShapes_var subShapes
-        = geom->SubShapeAll(myShape,shapeType); 
-      int nbSubShapes = subShapes->length();
-      int nbLocal = myTopo->_myShapes[shapeType].Extent();
-      fic << " - number of elements: " << nbSubShapes << endl;
-      ASSERT(nbSubShapes == nbLocal);
-
-      for (int i=0; i< nbSubShapes; i++)
-        {
-          GEOM::GEOM_Shape_var aSubShape = subShapes[i];
-          string idShape = SMESH_topo::GetShapeLocalId(aSubShape);
-          fic << "  " <<  idShape;
-          SCRUTE(idShape);
-          TopoDS_Shape aLocShape  = _ShapeReader->GetShape(geom,aSubShape);
-          for (int j=1; j <= nbLocal; j++)
-            if (aLocShape.IsSame(myTopo->_myShapes[shapeType].FindKey(j)))
-              {
-                MESSAGE("  --- trouve = " << j);
-                myTopo->_mapIndShapes[shapeType][idShape] = j;
-                fic << "  --- trouve = " << j;
-                break;
-              }
-          fic << endl;
-        }
-    }
-  fic.close();
-
-  return myTopo;
+       MESSAGE("SMESH_Gen_I::Import");
+       SMESH_Mesh_i *meshServant;
+       try
+       {
+               if (_mapStudyContext_i.find(studyId) == _mapStudyContext_i.end())
+               {
+                       _mapStudyContext_i[studyId] = new StudyContext_iStruct;
+               }
+               StudyContext_iStruct *myStudyContext = _mapStudyContext_i[studyId];
+
+               // create a new mesh object servant, store it in a map in study context
+               meshServant = new SMESH_Mesh_i(this, NULL, studyId, _localId);
+               myStudyContext->mapMesh_i[_localId] = meshServant;
+               _localId++;
+
+               // create a new mesh object
+               meshServant->SetImpl(_impl.Import(studyId, fileName, fileType));
+       }
+       catch(SALOME_Exception & S_ex)
+       {
+               THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
+       }
+
+       // activate the CORBA servant of Mesh
+
+       SMESH::SMESH_Mesh_var mesh
+               = SMESH::SMESH_Mesh::_narrow(meshServant->_this());
+
+       meshServant->SetIor(mesh);
+       return SMESH::SMESH_Mesh::_duplicate(mesh);
 }
-      
+
 //=============================================================================
 /*! 
  * C factory, accessible with dlsym, after dlopen  
@@ -1743,17 +1977,15 @@ SMESH_topo* SMESH_Gen_i::ExploreMainShape(GEOM::GEOM_Gen_ptr geomEngine,
 
 extern "C"
 {
-  PortableServer::ObjectId * SMESHEngine_factory(
-                               CORBA::ORB_ptr orb,
-                               PortableServer::POA_ptr poa, 
-                               PortableServer::ObjectId * contId,
-                               const char *instanceName, 
-                               const char *interfaceName)
-  {
-    MESSAGE("PortableServer::ObjectId * SMESHEngine_factory()");
-    SCRUTE(interfaceName);
-    SMESH_Gen_i * mySMESH_Gen 
-      = new SMESH_Gen_i(orb, poa, contId, instanceName, interfaceName);
-    return mySMESH_Gen->getId() ;
-  }
+       PortableServer::ObjectId * SMESHEngine_factory(CORBA::ORB_ptr orb,
+               PortableServer::POA_ptr poa,
+               PortableServer::ObjectId * contId,
+               const char *instanceName, const char *interfaceName)
+       {
+               MESSAGE("PortableServer::ObjectId * SMESHEngine_factory()");
+               SCRUTE(interfaceName);
+               SMESH_Gen_i *mySMESH_Gen
+                       = new SMESH_Gen_i(orb, poa, contId, instanceName, interfaceName);
+               return mySMESH_Gen->getId();
+       }
 }
index 1a04532..15cf0b9 100644 (file)
@@ -96,6 +96,8 @@ public:
                                    const SMESH::shape_array& listOfSubShape)
     throw (SALOME::SALOME_Exception);
 
+       SMESH::SMESH_Mesh_ptr Import(CORBA::Long studyId, const char* fileName,
+               const char* fileType);
 
   // inherited methods from SALOMEDS::Driver
 
@@ -153,6 +155,24 @@ protected:
                                GEOM::GEOM_Shape_ptr aShape);
   
 private:
+       void loadMesh(char * name, HDFfile * hdf_file, char * meshFile,
+               SALOMEDS::Study_var study);
+       void loadHypothesis(char * name, HDFfile * hdf_file, char * hypothesisFile,
+               int studyId);
+       void loadAlgorithms(char * name, HDFfile * hdf_file, char * algorithmsFile,
+               int studyId);
+       void loadAppliedHypothesis(HDFgroup * hdfGroupMeshId, bool _found,
+               SALOMEDS::Study_var Study, SMESH::SMESH_Mesh_var myNewMesh,
+               GEOM::GEOM_Shape_var aShape);
+       GEOM::GEOM_Gen_var getGeomEngine();
+       GEOM::GEOM_Shape_var getShape(SALOMEDS::Study_var Study, char * refFromFile);
+
+void loadAppliedAlgorithms(HDFgroup * hdfGroupMeshId, 
+       bool _found, SALOMEDS::Study_var Study, SMESH::SMESH_Mesh_var myNewMesh, 
+       GEOM::GEOM_Shape_var aShape);
+void loadSubMeshes(HDFgroup * hdfGroupMeshId, char * msgname,
+       SALOMEDS::Study_var Study, SMESH::SMESH_Mesh_var myNewMesh);
+                       
   SMESH_HypothesisFactory_i _hypothesisFactory_i;
   ::SMESH_Gen _impl;  // no namespace here
   int _localId; // unique Id of created objects, within SMESH_Gen_i entity
index 2c86f6a..96ddd7e 100644 (file)
@@ -81,3 +81,8 @@ CORBA::Long SMESH_Hypothesis_i::GetId()
   MESSAGE("GetId");
   return _baseImpl->GetID();
 }
+
+::SMESH_Hypothesis* SMESH_Hypothesis_i::getImpl()
+{
+       return _baseImpl;
+}
\ No newline at end of file
index 9277426..686e687 100644 (file)
@@ -44,7 +44,8 @@ public:
 
   char* GetName();
   CORBA::Long GetId();
-
+  ::SMESH_Hypothesis* getImpl();
+  
 protected:
   ::SMESH_Hypothesis* _baseImpl;
   ::SMESH_Gen* _genImpl;
index 9dee0f5..9f1f900 100644 (file)
@@ -162,18 +162,15 @@ CORBA::Boolean
        return ret;
 };
 
-//=============================================================================
-/*!
- *  
+/**
+ *@TODO Not implemented
  */
-//=============================================================================
-
 SMESH::ListOfHypothesis *
        SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Shape_ptr aSubShape)
 throw(SALOME::SALOME_Exception)
 {
-       MESSAGE("GetHypothesisList");
-       // ****
+       MESSAGE("GetHypothesisList: Not implemented");
+       return NULL;
 };
 
 //=============================================================================
@@ -230,25 +227,101 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetElementsOnShape(GEOM::
        return SMESH::SMESH_subMesh::_duplicate(_mapSubMeshIor[subMeshId]);
 }
 
-//=============================================================================
-/*!
- *  
+/**
+ * Translate the UpdateAll SMESHDS_Command to a set of SMESH::log_command.
+ * As the input log need to be resized, it is realocated.
+ * @param logBlock The log where to insert created commands
+ * @param index The place where to insert created commands in log. It is updated
+ * with the place to put new elements.
+ * @return The realocated and resized log.
+ * @TODO Add support for other type of elements
  */
-//=============================================================================
+SMESH::log_array_var SMESH_Mesh_i::
+       createUpdateAllCommand(SMESH::log_array_var log, int * index)
+{
+       MESSAGE("SMESH_Mesh_i::createUpdateAllCommand");
+       SMESH::log_array_var aLog=new SMESH::log_array(log->length()+3);
+       aLog->length(log->length()+3);
+       
+       for(int i=0;i<*index;i++)
+       {               
+               aLog[i]=log[i];
+       }
+       
+       log->length(0);
+       int id=*index;
+               
+       //Remove all elements
+       aLog[id].commandType=SMESH::REMOVE_ALL;
+       id++;
+       
+       //Export nodes
+       aLog[id].commandType=SMESH::ADD_NODE;
+       aLog[id].number=_impl->GetMeshDS()->NbNodes();
+
+       double * nodesCoordinates=_impl->GetMeshDS()->getNodesCoordinates();
+       aLog[id].coords=SMESH::double_array(
+               aLog[id].number*3,
+               aLog[id].number*3,
+               nodesCoordinates);
+
+       long * nodesID=_impl->GetMeshDS()->getNodesID();
+       aLog[id].indexes=SMESH::long_array(
+               aLog[id].number,
+               aLog[id].number,
+               nodesID);
+
+       id++;
+       
+       MESSAGE("Export edges");
+       //Export edges
+       aLog[id].commandType=SMESH::ADD_EDGE;
+       aLog[id].number=_impl->GetMeshDS()->NbEdges();  
+       aLog[id].coords.length(0);
+
+       long * edgesIndices=_impl->GetMeshDS()->getEdgesIndices();
+       aLog[id].indexes=SMESH::long_array(
+               aLog[id].number*3,
+               aLog[id].number*3,
+               edgesIndices);
+
+       id++;
+       
+       MESSAGE("Export triangles");
+       //Export triangles
+       aLog[id].commandType=SMESH::ADD_TRIANGLE;
+       aLog[id].number=_impl->GetMeshDS()->NbTriangles();      
+       aLog[id].coords.length(0);
+
+       long * triasIndices=_impl->GetMeshDS()->getTrianglesIndices();
+       aLog[id].indexes=SMESH::long_array(
+               aLog[id].number*4,
+               aLog[id].number*4,
+               triasIndices);
+
+       (*index)=id;
+       return aLog;
+}
 
+/**
+ * Return the log of the current mesh. CORBA wrap of the SMESH::GetLog method
+ * with a special treatment for SMESHDS_UpdateAll commands
+ * @param clearAfterGet Tell if the log must be cleared after being returned
+ * @return the log
+ */
 SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
-throw(SALOME::SALOME_Exception)
+       throw(SALOME::SALOME_Exception)
 {
        MESSAGE("SMESH_Mesh_i::GetLog");
 
        SMESH::log_array_var aLog;
-       try
-       {
+       /*try
+       {*/
                list < SMESHDS_Command * >logDS = _impl->GetLog();
                aLog = new SMESH::log_array;
                int indexLog = 0;
                int lg = logDS.size();
-               SCRUTE(lg);
+               MESSAGE("Number of command in the log: "<<lg);
                aLog->length(lg);
                list < SMESHDS_Command * >::iterator its = logDS.begin();
                while (its != logDS.end())
@@ -267,32 +340,38 @@ throw(SALOME::SALOME_Exception)
                        //SCRUTE(rnum);
                        list < double >::const_iterator ir = coordList.begin();
                        aLog[indexLog].commandType = comType;
-                       aLog[indexLog].number = lgcom;
-                       aLog[indexLog].coords.length(rnum);
-                       aLog[indexLog].indexes.length(inum);
-                       for (int i = 0; i < rnum; i++)
+                       if(comType==SMESHDS_UpdateAll)
                        {
-                               aLog[indexLog].coords[i] = *ir;
-                               //MESSAGE(" "<<i<<" "<<ir.Value());
-                               ir++;
+                               aLog=createUpdateAllCommand(aLog, &indexLog);
                        }
-                       for (int i = 0; i < inum; i++)
+                       else
                        {
-                               aLog[indexLog].indexes[i] = *ii;
-                               //MESSAGE(" "<<i<<" "<<ii.Value());
-                               ii++;
+                               aLog[indexLog].number = lgcom;
+                               aLog[indexLog].coords.length(rnum);
+                               aLog[indexLog].indexes.length(inum);
+                               for (int i = 0; i < rnum; i++)
+                               {
+                                       aLog[indexLog].coords[i] = *ir;
+                                       //MESSAGE(" "<<i<<" "<<ir.Value());
+                                       ir++;
+                               }
+                               for (int i = 0; i < inum; i++)
+                               {
+                                       aLog[indexLog].indexes[i] = *ii;
+                                       //MESSAGE(" "<<i<<" "<<ii.Value());
+                                       ii++;
+                               }
+                               indexLog++;
                        }
-                       indexLog++;
                        its++;
                }
-               if (clearAfterGet)
-                       _impl->ClearLog();
-       }
+               if (clearAfterGet) _impl->ClearLog();
+               return aLog._retn();
+       /*}
        catch(SALOME_Exception & S_ex)
        {
                THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
-       }
-       return aLog._retn();
+       }*/
 }
 
 //  SMESH::string_array* SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
@@ -530,25 +609,6 @@ SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
  */
 //=============================================================================
 
-void SMESH_Mesh_i::ExportMED(const char *file) throw(SALOME::SALOME_Exception)
-{
-       _impl->ExportMED(file);
-}
-void SMESH_Mesh_i::ExportDAT(const char *file) throw(SALOME::SALOME_Exception)
-{
-       _impl->ExportDAT(file);
-}
-void SMESH_Mesh_i::ExportUNV(const char *file) throw(SALOME::SALOME_Exception)
-{
-       _impl->ExportUNV(file);
-}
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
 SALOME_MED::MESH_ptr SMESH_Mesh_i::GetMEDMesh()throw(SALOME::SALOME_Exception)
 {
        SMESH_MEDMesh_i *aMedMesh = new SMESH_MEDMesh_i(this);
@@ -625,3 +685,14 @@ CORBA::Long SMESH_Mesh_i::NbSubMesh()throw(SALOME::SALOME_Exception)
 {
        return _impl->NbSubMesh();
 }
+
+/*!
+ * Export mesh to a file
+ * @param fileName file name where to export the file
+ * @param fileType Currently it could be either "DAT", "UNV" or "MED".
+ */
+void SMESH_Mesh_i::Export(const char* fileName, const char* fileType)
+       throw (SALOME::SALOME_Exception)
+{
+       _impl->Export(fileName, fileType);
+}
index ca63143..7964214 100644 (file)
@@ -91,6 +91,9 @@ public:
   CORBA::Long GetStudyId()
     throw (SALOME::SALOME_Exception);
 
+  void Export(const char* fileName, const char* fileType)
+       throw (SALOME::SALOME_Exception);
+
   // --- C++ interface
 
   void SetImpl(::SMESH_Mesh* impl);
@@ -100,13 +103,6 @@ public:
   void SetIor(SMESH::SMESH_Mesh_ptr myIor);
   SMESH::SMESH_Mesh_ptr GetIor();
 
-  void ExportMED( const char* file )
-    throw (SALOME::SALOME_Exception);
-  void ExportDAT( const char* file )
-    throw (SALOME::SALOME_Exception);
-  void ExportUNV( const char* file )
-    throw (SALOME::SALOME_Exception);
-
   SALOME_MED::MESH_ptr GetMEDMesh()
     throw (SALOME::SALOME_Exception);
   
@@ -142,7 +138,7 @@ public:
   map<int, ::SMESH_subMesh*> _mapSubMesh;   //NRI
 
 private:
-
+  SMESH::log_array_var createUpdateAllCommand(SMESH::log_array_var log, int * index);
   ::SMESH_Mesh* _impl;  // :: force no namespace here
   SMESH_Gen_i* _gen_i;
   //   CORBA::ORB_ptr _orb;