X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_I%2FSMESH_Gen_i.cxx;h=773deda151a0587e060f5c06171999ce66ebe6b2;hp=b6cc5826573ccf86949bd3ef5fbed5fc63e0fb5c;hb=7b70ad87bf8f5c46b2751f94cd196932b9ae7122;hpb=4791f5b30ea7a9c1247aa551750dc71cb83b99aa diff --git a/src/SMESH_I/SMESH_Gen_i.cxx b/src/SMESH_I/SMESH_Gen_i.cxx index b6cc58265..773deda15 100644 --- a/src/SMESH_I/SMESH_Gen_i.cxx +++ b/src/SMESH_I/SMESH_Gen_i.cxx @@ -26,7 +26,6 @@ // Module : SMESH // $Header$ -using namespace std; using namespace std; #include #include @@ -54,15 +53,9 @@ using namespace std; #include "SMESH_LocalLength_i.hxx" #include "SMESH_NumberOfSegments_i.hxx" #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 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; isetId; + + 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::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,1092 +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(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 hdf_group, hdf_subgroup; - map 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; - 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); - } - } - } - 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(); - Handle(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(); + + int nb_submeshes = hdf_subgroupmyLevel1Tag->nInternalObjects(); + char name_meshgroup[30]; + //SCRUTE(nb_submeshes); - // Convert temporary files to stream - aStreamFile = SALOMEDS_Tool::PutFilesToStream(tmpDir.ToCString(), aFileSeq.in(), isMultiFile); + for (int j = 0; j < nb_submeshes; j++) + { + //cmpt_sm++; + //myTag = 10 + cmpt_sm; + hdf_subgroupmyLevel1Tag->InternalObjectIndentify(j, name_meshgroup); - // Remove temporary files and directory - if (isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(tmpDir.ToCString(), aFileSeq.in(), true); + 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("<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); - - // Set names of temporary files - TCollection_AsciiString filename = tmpDir + aFileSeq[0];//"SMESH.hdf"; - TCollection_AsciiString hypofile = tmpDir + aFileSeq[1];//"SMESH_Hypo.txt"; - TCollection_AsciiString algofile = tmpDir + aFileSeq[2];//"SMESH_Algo.txt"; - TCollection_AsciiString meshfile = tmpDir + aFileSeq[3];//"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_::Instance() ; - ASSERT(SINGLETON_::IsAlreadyExisting()) ; - _NS->init_orb( _orb ) ; - SALOME_LifeCycleCORBA* myEnginesLifeCycle = new SALOME_LifeCycleCORBA(_NS); - Engines::Component_var geomEngine = - myEnginesLifeCycle->FindOrLoad_Component("FactoryServer","Geometry"); - 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 hdf_group, hdf_subgroup; - map 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;iInternalObjectIndentify(i,name); - //SCRUTE(name); - -//*************** -// Loading of the Hypothesis Branch -//*************** - if (strcmp(name,"Hypothesis")==0) { - - double length,maxElementsArea; - 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; - } - - - } - 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="<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(); - Handle(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;iiInternalObjectIndentify(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;jOpenOnDisk(); - 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;jOpenOnDisk(); - 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;jInternalObjectIndentify(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;kInternalObjectIndentify(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;lOpenOnDisk(); - 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;lOpenOnDisk(); - 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); } //============================================================================= @@ -1445,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 "<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 "<string_to_object(anIOR->Value())); - if (!mySubMesh->_is_nil()) { - char objectId[10]; - sprintf(objectId,"%d",mySubMesh->GetId()); -// cout<<"********** delete SubMesh "<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 "< + 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 "< + string_to_object(anIOR->Value())); + if (!mySubMesh->_is_nil()) + { + char objectId[10]; + sprintf(objectId, "%ld", mySubMesh->GetId()); +// cout<<"********** delete SubMesh "<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")); - } - } - } } //============================================================================= @@ -1580,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()); } //============================================================================= @@ -1598,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; + 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_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 @@ -1725,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(); + } }