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=bf046ac9b97119c6bc9939d871f6c530960bfb4a;hp=0d77f87268b5910ba3dd1770557ce1005aa0427d;hb=542321374cd456002427be9d180929752703c161;hpb=61c36a7e0c3f43b3aedd77ef20793ff15620defe diff --git a/src/SMESH_I/SMESH_Gen_i.cxx b/src/SMESH_I/SMESH_Gen_i.cxx index 0d77f8726..bf046ac9b 100644 --- a/src/SMESH_I/SMESH_Gen_i.cxx +++ b/src/SMESH_I/SMESH_Gen_i.cxx @@ -40,21 +40,39 @@ #include #include #include +#include #include #include #include +#include "Utils_CorbaException.hxx" + +#include "utilities.h" +#include +#include +#include + +#include + #include "SMESH_Gen_i.hxx" #include "SMESH_Mesh_i.hxx" -#include "SMESH_LocalLength_i.hxx" -#include "SMESH_NumberOfSegments_i.hxx" -#include "SMESH_MaxElementArea_i.hxx" -#include "SMESH_MaxElementVolume_i.hxx" +#include "SMESH_Hypothesis_i.hxx" +#include "SMESH_Algo_i.hxx" +#include "SMESH_Group_i.hxx" -#include "SMESHDriver.h" +#include "SMESHDS_Document.hxx" +#include "SMESHDS_Group.hxx" +#include "SMESHDS_GroupOnGeom.hxx" +#include "SMESH_Group.hxx" -#include "Utils_CorbaException.hxx" -#include "utilities.h" +#include "SMDS_EdgePosition.hxx" +#include "SMDS_FacePosition.hxx" + +#include CORBA_SERVER_HEADER(SMESH_Group) +#include CORBA_SERVER_HEADER(SMESH_Filter) + +#include "DriverMED_W_SMESHDS_Mesh.h" +#include "DriverMED_R_SMESHDS_Mesh.h" #include "SALOMEDS_Tool.hxx" #include "SALOME_NamingService.hxx" @@ -62,1926 +80,2412 @@ #include "Utils_SINGLETON.hxx" #include "OpUtil.hxx" -//#include +#include CORBA_CLIENT_HEADER(SALOME_ModuleCatalog) #include "GEOM_Client.hxx" +#include "Utils_ExceptHandlers.hxx" #include -#include -#include +#include + using namespace std; -#define NUM_TMP_FILES 4 +#define NUM_TMP_FILES 2 -// Tags definition -long Tag_HypothesisRoot = 1; -long Tag_AlgorithmsRoot = 2; +#ifdef _DEBUG_ +static int MYDEBUG = 0; +#else +static int MYDEBUG = 0; +#endif -long Tag_RefOnShape = 1; -long Tag_RefOnAppliedHypothesis = 2; -long Tag_RefOnAppliedAlgorithms = 3; +// Static variables definition +CORBA::ORB_var SMESH_Gen_i::myOrb; +PortableServer::POA_var SMESH_Gen_i::myPoa; +SALOME_NamingService* SMESH_Gen_i::myNS = NULL; +SALOME_LifeCycleCORBA* SMESH_Gen_i::myLCC = NULL; +SMESH_Gen_i* SMESH_Gen_i::mySMESHGen = NULL; -long Tag_SubMeshOnVertex = 4; -long Tag_SubMeshOnEdge = 5; -long Tag_SubMeshOnFace = 6; -long Tag_SubMeshOnSolid = 7; -long Tag_SubMeshOnCompound = 8; +//============================================================================= +/*! + * GetServant [ static ] + * + * Get servant of the CORBA object + */ +//============================================================================= + +PortableServer::ServantBase_var SMESH_Gen_i::GetServant( CORBA::Object_ptr theObject ) +{ + if( CORBA::is_nil( theObject ) || CORBA::is_nil( GetPOA() ) ) + return NULL; + try { + PortableServer::Servant aServant = GetPOA()->reference_to_servant( theObject ); + return aServant; + } + catch (...) { + INFOS( "GetServant - Unknown exception was caught!!!" ); + return NULL; + } +} //============================================================================= /*! - * default constructor: not for use + * SObjectToObject [ static ] + * + * Get CORBA object corresponding to the SALOMEDS::SObject */ //============================================================================= -SMESH_Gen_i::SMESH_Gen_i() +CORBA::Object_var SMESH_Gen_i::SObjectToObject( SALOMEDS::SObject_ptr theSObject ) { - MESSAGE("SMESH_Gen_i default constructor"); - // **** + SALOMEDS::GenericAttribute_var anAttr; + CORBA::Object_var anObj; + if ( !theSObject->_is_nil() ) { + try { + if( theSObject->FindAttribute( anAttr, "AttributeIOR" ) ) { + SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow( anAttr ); + CORBA::String_var aValue = anIOR->Value(); + if( strcmp( aValue, "" ) != 0 ) + anObj = GetORB()->string_to_object( aValue ); + } + } + catch( ... ) { + INFOS( "SObjectToObject - Unknown exception was caught!!!" ); + } + } + return anObj; } //============================================================================= /*! - * Standard constructor, used with Container. + * GetNS [ static ] + * + * Get SALOME_NamingService object */ //============================================================================= -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) +SALOME_NamingService* SMESH_Gen_i::GetNS() { - MESSAGE("activate object"); - _thisObj = this; - _id = _poa->activate_object(_thisObj); + if ( myNS == NULL ) { + myNS = SINGLETON_::Instance(); + ASSERT(SINGLETON_::IsAlreadyExisting()); + myNS->init_orb( GetORB() ); + } + return myNS; +} + +//============================================================================= +/*! + * GetLCC [ static ] + * + * Get SALOME_LifeCycleCORBA object + */ +//============================================================================= +SALOME_LifeCycleCORBA* SMESH_Gen_i::GetLCC() { + if ( myLCC == NULL ) { + myLCC = new SALOME_LifeCycleCORBA( GetNS() ); + } + return myLCC; +} - _ShapeReader = NULL; +//============================================================================= +/*! + * GetGeomEngine [ static ] + * + * Get GEOM::GEOM_Gen reference + */ +//============================================================================= +GEOM::GEOM_Gen_ptr SMESH_Gen_i::GetGeomEngine() { + GEOM::GEOM_Gen_var aGeomEngine = + GEOM::GEOM_Gen::_narrow( GetLCC()->FindOrLoad_Component("FactoryServer","GEOM") ); + return aGeomEngine._retn(); } //============================================================================= /*! - * Standard destructor + * SMESH_Gen_i::SMESH_Gen_i + * + * Default constructor: not for use */ //============================================================================= -SMESH_Gen_i::~SMESH_Gen_i() +SMESH_Gen_i::SMESH_Gen_i() { - MESSAGE("~SMESH_Gen_i"); - // **** + INFOS( "SMESH_Gen_i::SMESH_Gen_i : default constructor" ); } //============================================================================= /*! - * + * SMESH_Gen_i::SMESH_Gen_i + * + * Standard constructor, used with Container */ //============================================================================= -SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis(const char *anHyp, - CORBA::Long studyId) throw(SALOME::SALOME_Exception) +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 ) { - 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); - } + INFOS( "SMESH_Gen_i::SMESH_Gen_i : standard constructor" ); + + myOrb = CORBA::ORB::_duplicate(orb); + myPoa = PortableServer::POA::_duplicate(poa); + + _thisObj = this ; + _id = myPoa->activate_object( _thisObj ); + + myShapeReader = NULL; // shape reader + mySMESHGen = this; +} - // activate the CORBA servant of hypothesis +//============================================================================= +/*! + * SMESH_Gen_i::~SMESH_Gen_i + * + * Destructor + */ +//============================================================================= - SMESH::SMESH_Hypothesis_var hypothesis_i - = SMESH::SMESH_Hypothesis::_narrow(myHypothesis_i->_this()); - return SMESH::SMESH_Hypothesis::_duplicate(hypothesis_i); +SMESH_Gen_i::~SMESH_Gen_i() +{ + INFOS( "SMESH_Gen_i::~SMESH_Gen_i" ); + + // delete hypothesis creators + map::iterator itHyp; + for (itHyp = myHypCreatorMap.begin(); itHyp != myHypCreatorMap.end(); itHyp++) + { + delete (*itHyp).second; + } + myHypCreatorMap.clear(); + + // Clear study contexts data + map::iterator it; + for ( it = myStudyContextMap.begin(); it != myStudyContextMap.end(); ++it ) { + delete it->second; + } + myStudyContextMap.clear(); + // delete shape reader + if ( !myShapeReader ) + delete myShapeReader; } - -/** - * CORBA implementation of SMESH_Gen::Init. See SMESH_Gen.idl. + +//============================================================================= +/*! + * SMESH_Gen_i::createHypothesis + * + * Create hypothesis of given type */ -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) +//============================================================================= +SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName, + const char* theLibName) + throw (SALOME::SALOME_Exception) { - return Init(geomEngine, studyId, aShape, -1); + Unexpect aCatch(SALOME_SalomeException); + if(MYDEBUG) MESSAGE( "Create Hypothesis <" << theHypName << "> from " << theLibName); + + // create a new hypothesis object servant + SMESH_Hypothesis_i* myHypothesis_i = 0; + SMESH::SMESH_Hypothesis_var hypothesis_i; + + try + { + // check, if creator for this hypothesis type already exists + if (myHypCreatorMap.find(string(theHypName)) == myHypCreatorMap.end()) + { + // load plugin library + if(MYDEBUG) MESSAGE("Loading server meshers plugin library ..."); + void* libHandle = dlopen (theLibName, RTLD_LAZY); + if (!libHandle) + { + // report any error, if occured + const char* anError = dlerror(); + throw(SALOME_Exception(anError)); + } + + // get method, returning hypothesis creator + if(MYDEBUG) MESSAGE("Find GetHypothesisCreator() method ..."); + typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char* theHypName); + GetHypothesisCreator procHandle = + (GetHypothesisCreator)dlsym( libHandle, "GetHypothesisCreator" ); + if (!procHandle) + { + throw(SALOME_Exception(LOCALIZED("bad hypothesis plugin library"))); + dlclose(libHandle); + } + + // get hypothesis creator + if(MYDEBUG) MESSAGE("Get Hypothesis Creator for " << theHypName); + GenericHypothesisCreator_i* aCreator = procHandle(theHypName); + if (!aCreator) + { + throw(SALOME_Exception(LOCALIZED("no such a hypothesis in this plugin"))); + } + + // map hypothesis creator to a hypothesis name + myHypCreatorMap[string(theHypName)] = aCreator; + } + + // create a new hypothesis object, store its ref. in studyContext + if(MYDEBUG) MESSAGE("Create Hypothesis " << theHypName); + myHypothesis_i = + myHypCreatorMap[string(theHypName)]->Create (myPoa, GetCurrentStudyID(), &myGen); + // _CS_gbo Explicit activation (no longer made in the constructor). + myHypothesis_i->Activate(); + myHypothesis_i->SetLibName(theLibName); // for persistency assurance + } + catch (SALOME_Exception& S_ex) + { + THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); + } + + if (!myHypothesis_i) + return hypothesis_i._retn(); + + // activate the CORBA servant of hypothesis + hypothesis_i = SMESH::SMESH_Hypothesis::_narrow( myHypothesis_i->_this() ); + int nextId = RegisterObject( hypothesis_i ); + if(MYDEBUG) MESSAGE( "Add hypo to map with id = "<< nextId ); + + return hypothesis_i._retn(); } - -/** - * This is NOT a CORBA implementation. Differ from the Init CORBA method - * by allowing to specify the ID of the created mesh. + +//============================================================================= +/*! + * SMESH_Gen_i::createMesh + * + * Create empty mesh on shape */ -SMESH::SMESH_Mesh_ptr SMESH_Gen_i::Init(GEOM::GEOM_Gen_ptr geomEngine, - CORBA::Long studyId, GEOM::GEOM_Shape_ptr aShape, int meshID) - throw(SALOME::SALOME_Exception) +//============================================================================= +SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh() + 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 - TopoDS_Shape myLocShape = _ShapeReader->GetShape(geom, myShape); - SMESH_Mesh * meshImpl=_impl.Init(studyId, myLocShape, meshID); - - // create a new mesh object servant, store it in a map in study context - meshServant = new SMESH_Mesh_i(this, geom, studyId, meshImpl); - myStudyContext->mapMesh_i[meshServant->GetId()] = meshServant; - } - 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); + Unexpect aCatch(SALOME_SalomeException); + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::createMesh" ); + + // Get or create the GEOM_Client instance + try { + // create a new mesh object servant, store it in a map in study context + SMESH_Mesh_i* meshServant = new SMESH_Mesh_i( GetPOA(), this, GetCurrentStudyID() ); + // create a new mesh object + meshServant->SetImpl( myGen.CreateMesh( GetCurrentStudyID() )); + + // activate the CORBA servant of Mesh + SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( meshServant->_this() ); + int nextId = RegisterObject( mesh ); + if(MYDEBUG) MESSAGE( "Add mesh to map with id = "<< nextId); + return mesh._retn(); + } + catch (SALOME_Exception& S_ex) { + THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM ); + } + return SMESH::SMESH_Mesh::_nil(); } //============================================================================= /*! - * + * SMESH_Gen_i::GetShapeReader + * + * Get shape reader */ //============================================================================= - -CORBA::Boolean SMESH_Gen_i::IsReadyToCompute(SMESH::SMESH_Mesh_ptr aMesh, - GEOM::GEOM_Shape_ptr aShape) throw(SALOME::SALOME_Exception) +GEOM_Client* SMESH_Gen_i::GetShapeReader() { - MESSAGE("SMESH_Gen_i::IsReadyToCompute"); - return true; + // create shape reader if necessary + if ( !myShapeReader ) + myShapeReader = new GEOM_Client(GetContainerRef()); + ASSERT( myShapeReader ); + return myShapeReader; } //============================================================================= /*! - * + * SMESH_Gen_i::SetCurrentStudy + * + * Set current study */ //============================================================================= -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) +void SMESH_Gen_i::SetCurrentStudy( SALOMEDS::Study_ptr theStudy ) { - MESSAGE("SMESH_Gen_i::GetSubShapesId"); - SMESH::long_array_var shapesId = new SMESH::long_array; - set < int >setId; - - GEOM::GEOM_Gen_var geom = GEOM::GEOM_Gen::_narrow(geomEngine); - GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(mainShape); - - if (CORBA::is_nil(geom)) - THROW_SALOME_CORBA_EXCEPTION("bad geom reference", SALOME::BAD_PARAM); - if (CORBA::is_nil(myShape)) - THROW_SALOME_CORBA_EXCEPTION("bad shape reference", SALOME::BAD_PARAM); - - try - { - if (!_ShapeReader) - _ShapeReader = new GEOM_Client(); - ASSERT(_ShapeReader); - TopoDS_Shape myMainShape = _ShapeReader->GetShape(geom, myShape); - TopTools_IndexedMapOfShape myIndexToShape; - TopExp::MapShapes(myMainShape, myIndexToShape); - - for (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++; - } - } - catch(SALOME_Exception & S_ex) - { - THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); - } - - return shapesId._retn(); + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::SetCurrentStudy" ); + myCurrentStudy = SALOMEDS::Study::_duplicate( theStudy ); + // create study context, if it doesn't exist and set current study + int studyId = GetCurrentStudyID(); + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::SetCurrentStudy: study Id = " << studyId ); + if ( myStudyContextMap.find( studyId ) == myStudyContextMap.end() ) { + myStudyContextMap[ studyId ] = new StudyContext; + } + // set current study for geom engine + /* + if ( !CORBA::is_nil( GetGeomEngine() ) ) + GetGeomEngine()->GetCurrentStudy( myCurrentStudy->StudyId() ); + */ } //============================================================================= /*! - * + * SMESH_Gen_i::GetCurrentStudy + * + * Get current study */ //============================================================================= -CORBA::Boolean SMESH_Gen_i::Compute(SMESH::SMESH_Mesh_ptr aMesh, - GEOM::GEOM_Shape_ptr aShape) throw(SALOME::SALOME_Exception) +SALOMEDS::Study_ptr SMESH_Gen_i::GetCurrentStudy() { - 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; + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetCurrentStudy: study Id = " << GetCurrentStudyID() ); + return SALOMEDS::Study::_duplicate( myCurrentStudy ); } //============================================================================= /*! - * + * SMESH_Gen_i::GetCurrentStudyContext + * + * Get current study context */ //============================================================================= - -SALOMEDS::TMPFile * SMESH_Gen_i::Save(SALOMEDS::SComponent_ptr theComponent, - const char *theURL, bool isMultiFile) +StudyContext* SMESH_Gen_i::GetCurrentStudyContext() { - 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(); -//**************************** - - itBig = Study->NewChildIterator(theComponent); - SCRUTE(Tag_HypothesisRoot); - SCRUTE(Tag_AlgorithmsRoot); - for (; itBig->More(); itBig->Next()) - { - SALOMEDS::SObject_var gotBranch = itBig->Value(); - SCRUTE(gotBranch->Name()); - SCRUTE(gotBranch->Tag()); - SCRUTE(gotBranch->GetID()); - -//************branch 1 : hypothesis - if (gotBranch->Tag() == Tag_HypothesisRoot) - { //hypothesis = tag 1 - double length, maxElementsArea, maxElementsVolume; - int numberOfSegments; - - destFile = fopen(hypofile.ToCString(), "w"); - it = Study->NewChildIterator(gotBranch); - for (; it->More(); it->Next()) - { - mySObject = it->Value(); - SALOMEDS::GenericAttribute_var anAttr; - SALOMEDS::AttributeIOR_var anIOR; - if (mySObject->FindAttribute(anAttr, "AttributeIOR")) - { - anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); - - SMESH::SMESH_Hypothesis_var myHyp = - SMESH::SMESH_Hypothesis::_narrow(_orb-> - string_to_object(anIOR->Value())); - 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"); - - } -//************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())); - SCRUTE(anIOR->Value()); - SCRUTE(myAlgo->_is_nil()); - fprintf(destFile, "%li\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 - - 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", meshId); - 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"); - } - - MESSAGE("hdf_file->CloseOnDisk()"); - hdf_file->CloseOnDisk(); - - MESSAGE("delete hdf_file"); - delete hdf_file; - hdf_file = 0; + if ( !CORBA::is_nil( myCurrentStudy ) && + myStudyContextMap.find( GetCurrentStudyID() ) != myStudyContextMap.end() ) + return myStudyContextMap[ myCurrentStudy->StudyId() ]; + else + return 0; +} - // Convert temporary files to stream - MESSAGE("Convert temporary files to stream"); - aStreamFile = - SALOMEDS_Tool::PutFilesToStream(tmpDir.ToCString(), aFileSeq.in(), - isMultiFile); +//============================================================================= +/*! + * SMESH_Gen_i::CreateHypothesis + * + * Create hypothesis/algorothm of given type and publish it in the study + */ +//============================================================================= - // Remove temporary files and directory - MESSAGE("Remove temporary files and directory"); - if (!isMultiFile) - SALOMEDS_Tool::RemoveTemporaryFiles(tmpDir.ToCString(), aFileSeq.in(), - true); +SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis( const char* theHypName, + const char* theLibName ) + throw ( SALOME::SALOME_Exception ) +{ + Unexpect aCatch(SALOME_SalomeException); + // Create hypothesis/algorithm + SMESH::SMESH_Hypothesis_var hyp = this->createHypothesis( theHypName, theLibName ); - MESSAGE("End SMESH_Gen_i::Save"); + // Publish hypothesis/algorithm in the study + if ( CanPublishInStudy( hyp ) ) + PublishHypothesis( myCurrentStudy, hyp ); - return aStreamFile._retn(); + return hyp._retn(); } + +//============================================================================= +/*! + * SMESH_Gen_i::CreateMesh + * + * Create empty mesh on a shape and publish it in the study + */ +//============================================================================= -SALOMEDS::TMPFile * - SMESH_Gen_i::SaveASCII(SALOMEDS::SComponent_ptr theComponent, - const char *theURL, bool isMultiFile) +SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObject ) + throw ( SALOME::SALOME_Exception ) { - SALOMEDS::TMPFile_var aStreamFile = Save(theComponent, theURL, isMultiFile); - return aStreamFile._retn(); + Unexpect aCatch(SALOME_SalomeException); + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" ); + // create mesh + SMESH::SMESH_Mesh_var mesh = this->createMesh(); + // set shape + SMESH_Mesh_i* meshServant = dynamic_cast( GetServant( mesh ).in() ); + ASSERT( meshServant ); + meshServant->SetShape( theShapeObject ); + // publish mesh in the study + if ( CanPublishInStudy( mesh ) ) + PublishMesh( myCurrentStudy, mesh.in() ); + return mesh._retn(); } -void SMESH_Gen_i::loadHypothesis(char * name, HDFfile * hdf_file, - char * hypofile, int studyId) +//============================================================================= +/*! + * SMESH_Gen_i::CreateMeshFromUNV + * + * Create mesh and import data from UNV file + */ +//============================================================================= + +SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromUNV( const char* theFileName ) + throw ( SALOME::SALOME_Exception ) { - 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); - SCRUTE(name_of_file); - dataset->CloseOnDisk(); - hdfGroup->CloseOnDisk(); - delete[]name_of_file; - - 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; - } - MESSAGE("End of Hypos Load"); + Unexpect aCatch(SALOME_SalomeException); + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshesFromUNV" ); + + SMESH::SMESH_Mesh_var aMesh = createMesh(); + string aFileName; // = boost::filesystem::path(theFileName).leaf(); + // publish mesh in the study + if ( CanPublishInStudy( aMesh ) ) + PublishMesh( myCurrentStudy, aMesh.in(), aFileName.c_str() ); + + SMESH_Mesh_i* aServant = dynamic_cast( GetServant( aMesh ).in() ); + ASSERT( aServant ); + aServant->ImportUNVFile( theFileName ); + return aMesh._retn(); } -void SMESH_Gen_i::loadAlgorithms(char * name, HDFfile * hdf_file, - char* algofile, int studyId) +//============================================================================= +/*! + * SMESH_Gen_i::CreateMeshFromMED + * + * Create mesh and import data from MED file + */ +//============================================================================= + +SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName, + SMESH::DriverMED_ReadStatus& theStatus) + throw ( SALOME::SALOME_Exception ) { - 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"); + Unexpect aCatch(SALOME_SalomeException); + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshFromMED" ); + + // Retrieve mesh names from the file + DriverMED_R_SMESHDS_Mesh myReader; + myReader.SetFile( theFileName ); + myReader.SetMeshId( -1 ); + Driver_Mesh::Status aStatus; + list aNames = myReader.GetMeshNames(aStatus); + SMESH::mesh_array_var aResult = new SMESH::mesh_array(); + theStatus = (SMESH::DriverMED_ReadStatus)aStatus; + if(theStatus == SMESH::DRS_OK){ + aResult->length( aNames.size() ); + int i = 0; + + // Iterate through all meshes and create mesh objects + for ( list::iterator it = aNames.begin(); it != aNames.end(); it++ ) { + // create mesh + SMESH::SMESH_Mesh_var mesh = createMesh(); + + // publish mesh in the study + if ( CanPublishInStudy( mesh ) ) + PublishMesh( myCurrentStudy, mesh.in(), (*it).c_str() ); + + // Read mesh data (groups are published automatically by ImportMEDFile()) + SMESH_Mesh_i* meshServant = dynamic_cast( GetServant( mesh ).in() ); + ASSERT( meshServant ); + SMESH::DriverMED_ReadStatus status1 = + meshServant->ImportMEDFile( theFileName, (*it).c_str() ); + if (status1 > theStatus) + theStatus = status1; + + aResult[i++] = SMESH::SMESH_Mesh::_duplicate( mesh ); + } + } + return aResult._retn(); } -/** - * @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 +//============================================================================= +/*! + * SMESH_Gen_i::CreateMeshFromSTL + * + * Create mesh and import data from STL file */ -void SMESH_Gen_i::loadAppliedHypothesis(HDFgroup * hdfGroupMeshId, - bool _found, SALOMEDS::Study_var Study, SMESH::SMESH_Mesh_var myNewMesh, - GEOM::GEOM_Shape_var aShape) +//============================================================================= + +SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName ) + throw ( SALOME::SALOME_Exception ) { - HDFgroup * hdf_subgroup = new HDFgroup("Applied Hypothesis", hdfGroupMeshId); - hdf_subgroup->OpenOnDisk(); - int nb_datasets = hdf_subgroup->nInternalObjects(); - char name_dataset[10]; - - 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 ..."); - } - } - } - } - } - hdf_subgroup->CloseOnDisk(); + Unexpect aCatch(SALOME_SalomeException); + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshesFromSTL" ); + + SMESH::SMESH_Mesh_var aMesh = createMesh(); + string aFileName; // = boost::filesystem::path(theFileName).leaf(); + // publish mesh in the study + if ( CanPublishInStudy( aMesh ) ) + PublishInStudy( myCurrentStudy, SALOMEDS::SObject::_nil(), aMesh.in(), aFileName.c_str() ); + + SMESH_Mesh_i* aServant = dynamic_cast( GetServant( aMesh ).in() ); + ASSERT( aServant ); + aServant->ImportSTLFile( theFileName ); + return aMesh._retn(); } -/** - * @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 +//============================================================================= +/*! + * SMESH_Gen_i::IsReadyToCompute + * + * Returns true if mesh contains enough data to be computed */ -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]; - - 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(); - - 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->CloseOnDisk(); +CORBA::Boolean SMESH_Gen_i::IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh, + GEOM::GEOM_Object_ptr theShapeObject ) + throw ( SALOME::SALOME_Exception ) +{ + Unexpect aCatch(SALOME_SalomeException); + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IsReadyToCompute" ); + + if ( CORBA::is_nil( theShapeObject ) ) + THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", + SALOME::BAD_PARAM ); + + if ( CORBA::is_nil( theMesh ) ) + THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference", + SALOME::BAD_PARAM ); + + try { + // get mesh servant + SMESH_Mesh_i* meshServant = dynamic_cast( GetServant( theMesh ).in() ); + ASSERT( meshServant ); + if ( meshServant ) { + // get local TopoDS_Shape + TopoDS_Shape myLocShape = GeomObjectToShape( theShapeObject ); + // call implementation + ::SMESH_Mesh& myLocMesh = meshServant->GetImpl(); + return myGen.CheckAlgoState( myLocMesh, myLocShape ); + } + } + catch ( SALOME_Exception& S_ex ) { + INFOS( "catch exception "<< S_ex.what() ); + } + return false; } -/** - * @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 +//============================================================================= +/*! + * SMESH_Gen_i::GetSubShapesId + * + * Get sub-shapes unique ID's list */ -void SMESH_Gen_i::loadSubMeshes(HDFgroup * hdfGroupMeshId, char * msgname, - SALOMEDS::Study_var Study, SMESH::SMESH_Mesh_var myNewMesh) +//============================================================================= + +SMESH::long_array* SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject, + const SMESH::object_array& theListOfSubShapeObject ) + throw ( SALOME::SALOME_Exception ) { - MESSAGE("SMESH_Gen_i::loadSubMeshes"); - HDFgroup * hdf_subgroupmyLevel1Tag = new HDFgroup(msgname, hdfGroupMeshId); - hdf_subgroupmyLevel1Tag->OpenOnDisk(); + Unexpect aCatch(SALOME_SalomeException); + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetSubShapesId" ); - int nb_submeshes = hdf_subgroupmyLevel1Tag->nInternalObjects(); - char name_meshgroup[30]; - //SCRUTE(nb_submeshes); + SMESH::long_array_var shapesId = new SMESH::long_array; + set setId; - for (int j = 0; j < nb_submeshes; j++) - { - //cmpt_sm++; - //myTag = 10 + cmpt_sm; - hdf_subgroupmyLevel1Tag->InternalObjectIndentify(j, name_meshgroup); - - HDFgroup * hdf_subgroupmyTag = new HDFgroup(name_meshgroup, - hdf_subgroupmyLevel1Tag); - hdf_subgroupmyTag->OpenOnDisk(); - int subMeshId = atoi((string(name_meshgroup).substr(8, 18)).c_str()); - - MESSAGE("Ref on shape"); - //********** ref on shape - HDFdataset * hdf_dataset = - new HDFdataset("Ref on shape", hdf_subgroupmyTag); - hdf_dataset->OpenOnDisk(); - - char *refFromFile = new char[hdf_dataset->GetSize()]; - hdf_dataset->ReadFromDisk(refFromFile); - hdf_dataset->CloseOnDisk(); - - 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)) - { - 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; - } - } + if ( CORBA::is_nil( theMainShapeObject ) ) + THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", + SALOME::BAD_PARAM ); - 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(); + try + { + TopoDS_Shape myMainShape = GeomObjectToShape(theMainShapeObject); + TopTools_IndexedMapOfShape myIndexToShape; + TopExp::MapShapes(myMainShape,myIndexToShape); + + for ( int i = 0; i < theListOfSubShapeObject.length(); i++ ) + { + GEOM::GEOM_Object_var aShapeObject + = GEOM::GEOM_Object::_narrow(theListOfSubShapeObject[i]); + if ( CORBA::is_nil( aShapeObject ) ) + THROW_SALOME_CORBA_EXCEPTION ("bad shape object reference", \ + SALOME::BAD_PARAM ); + + TopoDS_Shape locShape = GeomObjectToShape(aShapeObject); + for (TopExp_Explorer exp(locShape,TopAbs_FACE); exp.More(); exp.Next()) + { + const TopoDS_Face& F = TopoDS::Face(exp.Current()); + setId.insert(myIndexToShape.FindIndex(F)); + if(MYDEBUG) 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)); + if(MYDEBUG) 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)); + if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(V)); + } } - hdf_subgroupmyLevel1Tag->CloseOnDisk(); -} + shapesId->length(setId.size()); + set::iterator iind; + int i=0; + for (iind = setId.begin(); iind != setId.end(); iind++) + { + if(MYDEBUG) SCRUTE((*iind)); + shapesId[i] = (*iind); + if(MYDEBUG) SCRUTE(shapesId[i]); + i++; + } + } + catch (SALOME_Exception& S_ex) + { + THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); + } -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; + return shapesId._retn(); } -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; - - 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"); - } +//============================================================================= +/*! + * SMESH_Gen_i::Compute + * + * Compute mesh on a shape + */ +//============================================================================= - SALOMEDS::AttributeIOR_var anIOR = - SALOMEDS::AttributeIOR::_narrow(anAttr); - - char *ShapeIOR = anIOR->Value(); - aShape = - GEOM::GEOM_Shape::_narrow(_orb->string_to_object(ShapeIOR)); - } - return aShape; +CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh, + GEOM::GEOM_Object_ptr theShapeObject ) + throw ( SALOME::SALOME_Exception ) +{ + Unexpect aCatch(SALOME_SalomeException); + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Compute" ); + + if ( CORBA::is_nil( theShapeObject ) ) + THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", + SALOME::BAD_PARAM ); + + if ( CORBA::is_nil( theMesh ) ) + THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference", + SALOME::BAD_PARAM ); + + try { + // get mesh servant + SMESH_Mesh_i* meshServant = dynamic_cast( GetServant( theMesh ).in() ); + ASSERT( meshServant ); + if ( meshServant ) { + // get local TopoDS_Shape + TopoDS_Shape myLocShape = GeomObjectToShape( theShapeObject ); + // call implementation compute + ::SMESH_Mesh& myLocMesh = meshServant->GetImpl(); + return myGen.Compute( myLocMesh, myLocShape); + } + } + catch ( SALOME_Exception& S_ex ) { + INFOS( "Compute(): catch exception "<< S_ex.what() ); + } + catch ( ... ) { + INFOS( "Compute(): unknown exception " ); + } + return false; } -void SMESH_Gen_i::loadMesh(char * name, HDFfile * hdf_file, - char* meshfile, SALOMEDS::Study_var Study) +//============================================================================= +/*! + * SMESH_Gen_i::Save + * + * Save SMESH module's data + */ +//============================================================================= +SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent, + const char* theURL, + bool isMultiFile ) { - MESSAGE("SMESH_Gen_i::loadMesh("<OpenOnDisk(); - - int nb_meshsubgroup = hdfGroupMeshId->nInternalObjects(); - SCRUTE(nb_meshsubgroup); - - //********** Loading of the file name where the data are stored - 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(); - - char *refFromFile = new char[dataset->GetSize()]; - dataset->ReadFromDisk(refFromFile); - dataset->CloseOnDisk(); - - bool _found = false; - SCRUTE(refFromFile); - SMESH::SMESH_Mesh_var myNewMesh; - GEOM::GEOM_Shape_var aShape=getShape(Study, refFromFile); - - if (!CORBA::is_nil(aShape)) - { - _found = true; - myNewMesh = Init(getGeomEngine(), Study->StudyId(), aShape, myMeshId); - string iorString = _orb->object_to_string(myNewMesh); - sprintf(objectId, "%ld", myNewMesh->GetId()); - string key=string("Mesh_")+string(objectId); - MESSAGE("IOR of "<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"); - } + INFOS( "SMESH_Gen_i::Save" ); + +// ASSERT( theComponent->GetStudy()->StudyId() == myCurrentStudy->StudyId() ) + // san -- in case differs from theComponent's study, + // use that of the component + if ( myCurrentStudy->_is_nil() || + theComponent->GetStudy()->StudyId() != myCurrentStudy->StudyId() ) + SetCurrentStudy( theComponent->GetStudy() ); + + StudyContext* myStudyContext = GetCurrentStudyContext(); + + // Declare a byte stream + SALOMEDS::TMPFile_var aStreamFile; + + // Obtain a temporary dir + TCollection_AsciiString tmpDir = + ( isMultiFile ) ? TCollection_AsciiString( ( char* )theURL ) : ( char* )SALOMEDS_Tool::GetTmpDir().c_str(); + + // Create a sequence of files processed + SALOMEDS::ListOfFileNames_var aFileSeq = new SALOMEDS::ListOfFileNames; + aFileSeq->length( NUM_TMP_FILES ); + + TCollection_AsciiString aStudyName( "" ); + if ( isMultiFile ) + aStudyName = ( (char*)SALOMEDS_Tool::GetNameFromPath( myCurrentStudy->URL() ).c_str() ); + + // Set names of temporary files + TCollection_AsciiString filename = + aStudyName + TCollection_AsciiString( "_SMESH.hdf" ); // for SMESH data itself + TCollection_AsciiString meshfile = + aStudyName + TCollection_AsciiString( "_SMESH_Mesh.med" ); // for mesh data to be stored in MED file + aFileSeq[ 0 ] = CORBA::string_dup( filename.ToCString() ); + aFileSeq[ 1 ] = CORBA::string_dup( meshfile.ToCString() ); + filename = tmpDir + filename; + meshfile = tmpDir + meshfile; + + HDFfile* aFile; + HDFdataset* aDataset; + HDFgroup* aTopGroup; + HDFgroup* aGroup; + HDFgroup* aSubGroup; + HDFgroup* aSubSubGroup; + hdf_size aSize[ 1 ]; + + // MED writer to be used by storage process + DriverMED_W_SMESHDS_Mesh myWriter; + myWriter.SetFile( meshfile.ToCString() ); + + // Write data + // ---> create HDF file + aFile = new HDFfile( filename.ToCString() ); + aFile->CreateOnDisk(); + + // --> iterator for top-level objects + SALOMEDS::ChildIterator_var itBig = myCurrentStudy->NewChildIterator( theComponent ); + for ( ; itBig->More(); itBig->Next() ) { + SALOMEDS::SObject_var gotBranch = itBig->Value(); + + // --> hypotheses root branch (only one for the study) + if ( gotBranch->Tag() == GetHypothesisRootTag() ) { + // create hypotheses root HDF group + aTopGroup = new HDFgroup( "Hypotheses", aFile ); + aTopGroup->CreateOnDisk(); + + // iterator for all hypotheses + SALOMEDS::ChildIterator_var it = myCurrentStudy->NewChildIterator( gotBranch ); + for ( ; it->More(); it->Next() ) { + SALOMEDS::SObject_var mySObject = it->Value(); + CORBA::Object_var anObject = SObjectToObject( mySObject ); + if ( !CORBA::is_nil( anObject ) ) { + SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow( anObject ); + if ( !myHyp->_is_nil() ) { + SMESH_Hypothesis_i* myImpl = dynamic_cast( GetServant( myHyp ).in() ); + if ( myImpl ) { + string hypname = string( myHyp->GetName() ); + string libname = string( myHyp->GetLibName() ); + int id = myStudyContext->findId( string( GetORB()->object_to_string( anObject ) ) ); + string hypdata = string( myImpl->SaveTo() ); + + // for each hypothesis create HDF group basing on its id + char hypGrpName[30]; + sprintf( hypGrpName, "Hypothesis %d", id ); + aGroup = new HDFgroup( hypGrpName, aTopGroup ); + aGroup->CreateOnDisk(); + // --> type name of hypothesis + aSize[ 0 ] = hypname.length() + 1; + aDataset = new HDFdataset( "Name", aGroup, HDF_STRING, aSize, 1 ); + aDataset->CreateOnDisk(); + aDataset->WriteOnDisk( ( char* )( hypname.c_str() ) ); + aDataset->CloseOnDisk(); + // --> server plugin library name of hypothesis + aSize[ 0 ] = libname.length() + 1; + aDataset = new HDFdataset( "LibName", aGroup, HDF_STRING, aSize, 1 ); + aDataset->CreateOnDisk(); + aDataset->WriteOnDisk( ( char* )( libname.c_str() ) ); + aDataset->CloseOnDisk(); + // --> persistent data of hypothesis + aSize[ 0 ] = hypdata.length() + 1; + aDataset = new HDFdataset( "Data", aGroup, HDF_STRING, aSize, 1 ); + aDataset->CreateOnDisk(); + aDataset->WriteOnDisk( ( char* )( hypdata.c_str() ) ); + aDataset->CloseOnDisk(); + // close hypothesis HDF group + aGroup->CloseOnDisk(); + } + } } - //********** - //} - //else if (strcmp(msgname,"Applied Hypothesis")==0) { - for (int ii = 0; ii < nb_meshsubgroup; ii++) - { - hdfGroupMeshId->InternalObjectIndentify(ii, msgname); - if (strcmp(msgname, "Mesh data") == 0) - { - //nothing + } + // close hypotheses root HDF group + aTopGroup->CloseOnDisk(); + } + // --> algorithms root branch (only one for the study) + else if ( gotBranch->Tag() == GetAlgorithmsRootTag() ) { + // create algorithms root HDF group + aTopGroup = new HDFgroup( "Algorithms", aFile ); + aTopGroup->CreateOnDisk(); + + // iterator for all algorithms + SALOMEDS::ChildIterator_var it = myCurrentStudy->NewChildIterator( gotBranch ); + for ( ; it->More(); it->Next() ) { + SALOMEDS::SObject_var mySObject = it->Value(); + CORBA::Object_var anObject = SObjectToObject( mySObject ); + if ( !CORBA::is_nil( anObject ) ) { + SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow( anObject ); + if ( !myHyp->_is_nil() ) { + SMESH_Hypothesis_i* myImpl = dynamic_cast( GetServant( myHyp ).in() ); + if ( myImpl ) { + string hypname = string( myHyp->GetName() ); + string libname = string( myHyp->GetLibName() ); + int id = myStudyContext->findId( string( GetORB()->object_to_string( anObject ) ) ); + string hypdata = string( myImpl->SaveTo() ); + + // for each algorithm create HDF group basing on its id + char hypGrpName[30]; + sprintf( hypGrpName, "Algorithm %d", id ); + aGroup = new HDFgroup( hypGrpName, aTopGroup ); + aGroup->CreateOnDisk(); + // --> type name of algorithm + aSize[0] = hypname.length() + 1; + aDataset = new HDFdataset( "Name", aGroup, HDF_STRING, aSize, 1 ); + aDataset->CreateOnDisk(); + aDataset->WriteOnDisk( ( char* )( hypname.c_str() ) ); + aDataset->CloseOnDisk(); + // --> server plugin library name of hypothesis + aSize[0] = libname.length() + 1; + aDataset = new HDFdataset( "LibName", aGroup, HDF_STRING, aSize, 1 ); + aDataset->CreateOnDisk(); + aDataset->WriteOnDisk( ( char* )( libname.c_str() ) ); + aDataset->CloseOnDisk(); + // --> persistent data of algorithm + aSize[0] = hypdata.length() + 1; + aDataset = new HDFdataset( "Data", aGroup, HDF_STRING, aSize, 1 ); + aDataset->CreateOnDisk(); + aDataset->WriteOnDisk( ( char* )( hypdata.c_str() ) ); + aDataset->CloseOnDisk(); + // close algorithm HDF group + aGroup->CloseOnDisk(); + } + } + } + } + // close algorithms root HDF group + aTopGroup->CloseOnDisk(); + } + // --> mesh objects roots branches + else if ( gotBranch->Tag() > GetAlgorithmsRootTag() ) { + CORBA::Object_var anObject = SObjectToObject( gotBranch ); + if ( !CORBA::is_nil( anObject ) ) { + SMESH::SMESH_Mesh_var myMesh = SMESH::SMESH_Mesh::_narrow( anObject ) ; + if ( !myMesh->_is_nil() ) { + SMESH_Mesh_i* myImpl = dynamic_cast( GetServant( myMesh ).in() ); + if ( myImpl ) { + int id = myStudyContext->findId( string( GetORB()->object_to_string( anObject ) ) ); + ::SMESH_Mesh& myLocMesh = myImpl->GetImpl(); + SMESHDS_Mesh* mySMESHDSMesh = myLocMesh.GetMeshDS(); + + // for each mesh open the HDF group basing on its id + char meshGrpName[ 30 ]; + sprintf( meshGrpName, "Mesh %d", id ); + aTopGroup = new HDFgroup( meshGrpName, aFile ); + aTopGroup->CreateOnDisk(); + + // --> put dataset to hdf file which is a flag that mesh has data + string strHasData = "0"; + // check if the mesh is not empty + if ( mySMESHDSMesh->NbNodes() > 0 ) { + // write mesh data to med file + myWriter.SetMesh( mySMESHDSMesh ); + myWriter.SetMeshId( id ); + strHasData = "1"; + } + aSize[ 0 ] = strHasData.length() + 1; + aDataset = new HDFdataset( "Has data", aTopGroup, HDF_STRING, aSize, 1 ); + aDataset->CreateOnDisk(); + aDataset->WriteOnDisk( ( char* )( strHasData.c_str() ) ); + aDataset->CloseOnDisk(); + + // write reference on a shape if exists + SALOMEDS::SObject_var myRef; + bool shapeRefFound = false; + bool found = gotBranch->FindSubObject( GetRefOnShapeTag(), myRef ); + if ( found ) { + SALOMEDS::SObject_var myShape; + bool ok = myRef->ReferencedObject( myShape ); + if ( ok ) { + shapeRefFound = (! CORBA::is_nil( myShape->GetObject() )); + string myRefOnObject = myShape->GetID(); + if ( shapeRefFound && myRefOnObject.length() > 0 ) { + aSize[ 0 ] = myRefOnObject.length() + 1; + aDataset = new HDFdataset( "Ref on shape", aTopGroup, HDF_STRING, aSize, 1 ); + aDataset->CreateOnDisk(); + aDataset->WriteOnDisk( ( char* )( myRefOnObject.c_str() ) ); + aDataset->CloseOnDisk(); } - else if (strcmp(msgname, "Ref on shape") == 0) - { - //nothing + } + } + // maybe a shape was deleted in the study + if ( !shapeRefFound && !mySMESHDSMesh->ShapeToMesh().IsNull() ) { + TopoDS_Shape nullShape; + myLocMesh.ShapeToMesh( nullShape ); // remove shape referring data + } + + // write applied hypotheses if exist + SALOMEDS::SObject_var myHypBranch; + found = gotBranch->FindSubObject( GetRefOnAppliedHypothesisTag(), myHypBranch ); + if ( found && !shapeRefFound ) { // remove applied hyps + myCurrentStudy->NewBuilder()->RemoveObjectWithChildren( myHypBranch ); + } + if ( found && shapeRefFound ) { + aGroup = new HDFgroup( "Applied Hypotheses", aTopGroup ); + aGroup->CreateOnDisk(); + + SALOMEDS::ChildIterator_var it = myCurrentStudy->NewChildIterator( myHypBranch ); + int hypNb = 0; + for ( ; it->More(); it->Next() ) { + SALOMEDS::SObject_var mySObject = it->Value(); + SALOMEDS::SObject_var myRefOnHyp; + bool ok = mySObject->ReferencedObject( myRefOnHyp ); + if ( ok ) { + // san - it is impossible to recover applied hypotheses + // using their entries within Load() method, + // for there are no AttributeIORs in the study when Load() is working. + // Hence, it is better to store persistent IDs of hypotheses as references to them + + //string myRefOnObject = myRefOnHyp->GetID(); + CORBA::Object_var anObject = SObjectToObject( myRefOnHyp ); + int id = myStudyContext->findId( string( GetORB()->object_to_string( anObject ) ) ); + //if ( myRefOnObject.length() > 0 ) { + //aSize[ 0 ] = myRefOnObject.length() + 1; + char hypName[ 30 ], hypId[ 30 ]; + sprintf( hypName, "Hyp %d", ++hypNb ); + sprintf( hypId, "%d", id ); + aSize[ 0 ] = strlen( hypId ) + 1; + aDataset = new HDFdataset( hypName, aGroup, HDF_STRING, aSize, 1 ); + aDataset->CreateOnDisk(); + //aDataset->WriteOnDisk( ( char* )( myRefOnObject.c_str() ) ); + aDataset->WriteOnDisk( hypId ); + aDataset->CloseOnDisk(); + //} } - else if (strcmp(msgname, "Applied Hypothesis") == 0) - { - loadAppliedHypothesis(hdfGroupMeshId, _found, Study, myNewMesh, - aShape); + } + aGroup->CloseOnDisk(); + } + + // write applied algorithms if exist + SALOMEDS::SObject_var myAlgoBranch; + found = gotBranch->FindSubObject( GetRefOnAppliedAlgorithmsTag(), myAlgoBranch ); + if ( found && !shapeRefFound ) { // remove applied hyps + myCurrentStudy->NewBuilder()->RemoveObjectWithChildren( myAlgoBranch ); + } + if ( found && shapeRefFound ) { + aGroup = new HDFgroup( "Applied Algorithms", aTopGroup ); + aGroup->CreateOnDisk(); + + SALOMEDS::ChildIterator_var it = myCurrentStudy->NewChildIterator( myAlgoBranch ); + int algoNb = 0; + for ( ; it->More(); it->Next() ) { + SALOMEDS::SObject_var mySObject = it->Value(); + SALOMEDS::SObject_var myRefOnAlgo; + bool ok = mySObject->ReferencedObject( myRefOnAlgo ); + if ( ok ) { + // san - it is impossible to recover applied algorithms + // using their entries within Load() method, + // for there are no AttributeIORs in the study when Load() is working. + // Hence, it is better to store persistent IDs of algorithms as references to them + + //string myRefOnObject = myRefOnAlgo->GetID(); + CORBA::Object_var anObject = SObjectToObject( myRefOnAlgo ); + int id = myStudyContext->findId( string( GetORB()->object_to_string( anObject ) ) ); + //if ( myRefOnObject.length() > 0 ) { + //aSize[ 0 ] = myRefOnObject.length() + 1; + char algoName[ 30 ], algoId[ 30 ]; + sprintf( algoName, "Algo %d", ++algoNb ); + sprintf( algoId, "%d", id ); + aSize[ 0 ] = strlen( algoId ) + 1; + aDataset = new HDFdataset( algoName, aGroup, HDF_STRING, aSize, 1 ); + aDataset->CreateOnDisk(); + //aDataset->WriteOnDisk( ( char* )( myRefOnObject.c_str() ) ); + aDataset->WriteOnDisk( algoId ); + aDataset->CloseOnDisk(); + //} } - else if (strcmp(msgname, "Applied Algorithms") == 0) - { - loadAppliedAlgorithms(hdfGroupMeshId, _found, Study, myNewMesh, - aShape); + } + aGroup->CloseOnDisk(); + } + + // --> submesh objects sub-branches + + for ( int i = GetSubMeshOnVertexTag(); i <= GetSubMeshOnCompoundTag(); i++ ) { + SALOMEDS::SObject_var mySubmeshBranch; + found = gotBranch->FindSubObject( i, mySubmeshBranch ); + + if ( found ) // check if there is shape reference in submeshes + { + bool hasShapeRef = false; + SALOMEDS::ChildIterator_var itSM = + myCurrentStudy->NewChildIterator( mySubmeshBranch ); + for ( ; itSM->More(); itSM->Next() ) { + SALOMEDS::SObject_var mySubRef, myShape, mySObject = itSM->Value(); + if ( mySObject->FindSubObject( GetRefOnShapeTag(), mySubRef )) + mySubRef->ReferencedObject( myShape ); + if ( !CORBA::is_nil( myShape ) && !CORBA::is_nil( myShape->GetObject() )) + hasShapeRef = true; + else + { // remove one submesh + if ( shapeRefFound ) + { // unassign hypothesis + SMESH::SMESH_subMesh_var mySubMesh = + SMESH::SMESH_subMesh::_narrow( SObjectToObject( mySObject )); + if ( !mySubMesh->_is_nil() ) { + int shapeID = mySubMesh->GetId(); + TopoDS_Shape S = mySMESHDSMesh->IndexToShape( shapeID ); + const list& hypList = + mySMESHDSMesh->GetHypothesis( S ); + list::const_iterator hyp = hypList.begin(); + while ( hyp != hypList.end() ) { + int hypID = (*hyp++)->GetID(); // goto next here because + myLocMesh.RemoveHypothesis( S, hypID ); // hypList changes here + } + } + } + myCurrentStudy->NewBuilder()->RemoveObjectWithChildren( mySObject ); + } + } // loop on submeshes of a type + if ( !shapeRefFound || !hasShapeRef ) { // remove the whole submeshes branch + myCurrentStudy->NewBuilder()->RemoveObjectWithChildren( mySubmeshBranch ); + found = false; + } + } // end check if there is shape reference in submeshes + if ( found ) { + char name_meshgroup[ 30 ]; + if ( i == GetSubMeshOnVertexTag() ) + strcpy( name_meshgroup, "SubMeshes On Vertex" ); + else if ( i == GetSubMeshOnEdgeTag() ) + strcpy( name_meshgroup, "SubMeshes On Edge" ); + else if ( i == GetSubMeshOnWireTag() ) + strcpy( name_meshgroup, "SubMeshes On Wire" ); + else if ( i == GetSubMeshOnFaceTag() ) + strcpy( name_meshgroup, "SubMeshes On Face" ); + else if ( i == GetSubMeshOnShellTag() ) + strcpy( name_meshgroup, "SubMeshes On Shell" ); + else if ( i == GetSubMeshOnSolidTag() ) + strcpy( name_meshgroup, "SubMeshes On Solid" ); + else if ( i == GetSubMeshOnCompoundTag() ) + strcpy( name_meshgroup, "SubMeshes On Compound" ); + + // for each type of submeshes create container HDF group + aGroup = new HDFgroup( name_meshgroup, aTopGroup ); + aGroup->CreateOnDisk(); + + // iterator for all submeshes of given type + SALOMEDS::ChildIterator_var itSM = myCurrentStudy->NewChildIterator( mySubmeshBranch ); + for ( ; itSM->More(); itSM->Next() ) { + SALOMEDS::SObject_var mySObject = itSM->Value(); + CORBA::Object_var anSubObject = SObjectToObject( mySObject ); + if ( !CORBA::is_nil( anSubObject )) + { + SMESH::SMESH_subMesh_var mySubMesh = SMESH::SMESH_subMesh::_narrow( anSubObject ) ; + int subid = myStudyContext->findId( string( GetORB()->object_to_string( anSubObject ) ) ); + + // for each mesh open the HDF group basing on its id + char submeshGrpName[ 30 ]; + sprintf( submeshGrpName, "SubMesh %d", subid ); + aSubGroup = new HDFgroup( submeshGrpName, aGroup ); + aSubGroup->CreateOnDisk(); + + // write reference on a shape, already checked if it exists + SALOMEDS::SObject_var mySubRef, myShape; + if ( mySObject->FindSubObject( GetRefOnShapeTag(), mySubRef )) + mySubRef->ReferencedObject( myShape ); + string myRefOnObject = myShape->GetID(); + if ( myRefOnObject.length() > 0 ) { + aSize[ 0 ] = myRefOnObject.length() + 1; + aDataset = new HDFdataset( "Ref on shape", aSubGroup, HDF_STRING, aSize, 1 ); + aDataset->CreateOnDisk(); + aDataset->WriteOnDisk( ( char* )( myRefOnObject.c_str() ) ); + aDataset->CloseOnDisk(); + } + + // write applied hypotheses if exist + SALOMEDS::SObject_var mySubHypBranch; + found = mySObject->FindSubObject( GetRefOnAppliedHypothesisTag(), mySubHypBranch ); + if ( found ) { + aSubSubGroup = new HDFgroup( "Applied Hypotheses", aSubGroup ); + aSubSubGroup->CreateOnDisk(); + + SALOMEDS::ChildIterator_var it = myCurrentStudy->NewChildIterator( mySubHypBranch ); + int hypNb = 0; + for ( ; it->More(); it->Next() ) { + SALOMEDS::SObject_var mySubSObject = it->Value(); + SALOMEDS::SObject_var myRefOnHyp; + bool ok = mySubSObject->ReferencedObject( myRefOnHyp ); + if ( ok ) { + //string myRefOnObject = myRefOnHyp->GetID(); + CORBA::Object_var anObject = SObjectToObject( myRefOnHyp ); + int id = myStudyContext->findId( string( GetORB()->object_to_string( anObject ) ) ); + //if ( myRefOnObject.length() > 0 ) { + //aSize[ 0 ] = myRefOnObject.length() + 1; + char hypName[ 30 ], hypId[ 30 ]; + sprintf( hypName, "Hyp %d", ++hypNb ); + sprintf( hypId, "%d", id ); + aSize[ 0 ] = strlen( hypId ) + 1; + aDataset = new HDFdataset( hypName, aSubSubGroup, HDF_STRING, aSize, 1 ); + aDataset->CreateOnDisk(); + //aDataset->WriteOnDisk( ( char* )( myRefOnObject.c_str() ) ); + aDataset->WriteOnDisk( hypId ); + aDataset->CloseOnDisk(); + //} + } + } + aSubSubGroup->CloseOnDisk(); + } + + // write applied algorithms if exist + SALOMEDS::SObject_var mySubAlgoBranch; + found = mySObject->FindSubObject( GetRefOnAppliedAlgorithmsTag(), mySubAlgoBranch ); + if ( found ) { + aSubSubGroup = new HDFgroup( "Applied Algorithms", aSubGroup ); + aSubSubGroup->CreateOnDisk(); + + SALOMEDS::ChildIterator_var it = myCurrentStudy->NewChildIterator( mySubAlgoBranch ); + int algoNb = 0; + for ( ; it->More(); it->Next() ) { + SALOMEDS::SObject_var mySubSObject = it->Value(); + SALOMEDS::SObject_var myRefOnAlgo; + bool ok = mySubSObject->ReferencedObject( myRefOnAlgo ); + if ( ok ) { + //string myRefOnObject = myRefOnAlgo->GetID(); + CORBA::Object_var anObject = SObjectToObject( myRefOnAlgo ); + int id = myStudyContext->findId( string( GetORB()->object_to_string( anObject ) ) ); + //if ( myRefOnObject.length() > 0 ) { + //aSize[ 0 ] = myRefOnObject.length() + 1; + char algoName[ 30 ], algoId[ 30 ]; + sprintf( algoName, "Algo %d", ++algoNb ); + sprintf( algoId, "%d", id ); + aSize[ 0 ] = strlen( algoId ) + 1; + aDataset = new HDFdataset( algoName, aSubSubGroup, HDF_STRING, aSize, 1 ); + aDataset->CreateOnDisk(); + //aDataset->WriteOnDisk( ( char* )( myRefOnObject.c_str() ) ); + aDataset->WriteOnDisk( algoId ); + aDataset->CloseOnDisk(); + //} + } + } + aSubSubGroup->CloseOnDisk(); + } + // close submesh HDF group + aSubGroup->CloseOnDisk(); + } } - else if (string(msgname).substr(0, 9) == string("SubMeshes")) - { - loadSubMeshes(hdfGroupMeshId, msgname, Study, myNewMesh); + // close container of submeshes by type HDF group + aGroup->CloseOnDisk(); + } + } + // All sub-meshes will be stored in MED file + myWriter.AddAllSubMeshes(); + + // groups root sub-branch + SALOMEDS::SObject_var myGroupsBranch; + for ( int i = GetNodeGroupsTag(); i <= GetVolumeGroupsTag(); i++ ) { + found = gotBranch->FindSubObject( i, myGroupsBranch ); + if ( found ) { + char name_group[ 30 ]; + if ( i == GetNodeGroupsTag() ) + strcpy( name_group, "Groups of Nodes" ); + else if ( i == GetEdgeGroupsTag() ) + strcpy( name_group, "Groups of Edges" ); + else if ( i == GetFaceGroupsTag() ) + strcpy( name_group, "Groups of Faces" ); + else if ( i == GetVolumeGroupsTag() ) + strcpy( name_group, "Groups of Volumes" ); + + aGroup = new HDFgroup( name_group, aTopGroup ); + aGroup->CreateOnDisk(); + + SALOMEDS::ChildIterator_var it = myCurrentStudy->NewChildIterator( myGroupsBranch ); + for ( ; it->More(); it->Next() ) { + SALOMEDS::SObject_var mySObject = it->Value(); + CORBA::Object_var aSubObject = SObjectToObject( mySObject ); + if ( !CORBA::is_nil( aSubObject ) ) { + SMESH_GroupBase_i* myGroupImpl = + dynamic_cast( GetServant( aSubObject ).in() ); + if ( !myGroupImpl ) + continue; + + int anId = myStudyContext->findId( string( GetORB()->object_to_string( aSubObject ) ) ); + + // For each group, create a dataset named "Group " + // and store the group's user name into it + char grpName[ 30 ]; + sprintf( grpName, "Group %d", anId ); + char* aUserName = myGroupImpl->GetName(); + aSize[ 0 ] = strlen( aUserName ) + 1; + + aDataset = new HDFdataset( grpName, aGroup, HDF_STRING, aSize, 1 ); + aDataset->CreateOnDisk(); + aDataset->WriteOnDisk( aUserName ); + aDataset->CloseOnDisk(); + + // Store the group contents into MED file + if ( myLocMesh.GetGroup( myGroupImpl->GetLocalID() ) ) { + + if(MYDEBUG) MESSAGE( "VSR - SMESH_Gen_i::Save(): saving group with StoreName = " + << grpName << " to MED file" ); + SMESHDS_GroupBase* aGrpBaseDS = + myLocMesh.GetGroup( myGroupImpl->GetLocalID() )->GetGroupDS(); + aGrpBaseDS->SetStoreName( grpName ); + + // Pass SMESHDS_Group to MED writer + SMESHDS_Group* aGrpDS = dynamic_cast( aGrpBaseDS ); + if ( aGrpDS ) + myWriter.AddGroup( aGrpDS ); + + // write reference on a shape if exists + SMESHDS_GroupOnGeom* aGeomGrp = + dynamic_cast( aGrpBaseDS ); + if ( aGeomGrp ) { + SALOMEDS::SObject_var mySubRef, myShape; + if (mySObject->FindSubObject( GetRefOnShapeTag(), mySubRef ) && + mySubRef->ReferencedObject( myShape ) && + !CORBA::is_nil( myShape->GetObject() )) + { + string myRefOnObject = myShape->GetID(); + if ( myRefOnObject.length() > 0 ) { + char aRefName[ 30 ]; + sprintf( aRefName, "Ref on shape %d", anId); + aSize[ 0 ] = myRefOnObject.length() + 1; + aDataset = new HDFdataset(aRefName, aGroup, HDF_STRING, aSize, 1); + aDataset->CreateOnDisk(); + aDataset->WriteOnDisk( ( char* )( myRefOnObject.c_str() ) ); + aDataset->CloseOnDisk(); + } + } + else // shape ref is invalid: + { + // save a group on geometry as ordinary group + myWriter.AddGroup( aGeomGrp ); + } + } + } + } } + aGroup->CloseOnDisk(); + } + } // loop on groups + + if ( strcmp( strHasData.c_str(), "1" ) == 0 ) + { + // Flush current mesh information into MED file + myWriter.Perform(); + + + // Store node positions on sub-shapes (SMDS_Position): + + if ( !mySMESHDSMesh->SubMeshes().empty() ) + { + aGroup = new HDFgroup( "Node Positions", aTopGroup ); + aGroup->CreateOnDisk(); + + // in aGroup, create 5 datasets to contain: + // "Nodes on Edges" - ID of node on edge + // "Edge positions" - U parameter on node on edge + // "Nodes on Faces" - ID of node on face + // "Face U positions" - U parameter of node on face + // "Face V positions" - V parameter of node on face + + // Find out nb of nodes on edges and faces + // Collect corresponing sub-meshes + int nbEdgeNodes = 0, nbFaceNodes = 0; + list aEdgeSM, aFaceSM; + // loop on SMESHDS_SubMesh'es + const map& aSubMeshes = mySMESHDSMesh->SubMeshes(); + map::const_iterator itSubM ( aSubMeshes.begin() ); + for ( ; itSubM != aSubMeshes.end() ; itSubM++ ) + { + SMESHDS_SubMesh* aSubMesh = (*itSubM).second; + if ( aSubMesh->IsComplexSubmesh() ) + continue; // submesh containing other submeshs + int nbNodes = aSubMesh->NbNodes(); + if ( nbNodes == 0 ) continue; + + int aShapeID = (*itSubM).first; + int aShapeType = mySMESHDSMesh->IndexToShape( aShapeID ).ShapeType(); + // write only SMDS_FacePosition and SMDS_EdgePosition + switch ( aShapeType ) { + case TopAbs_FACE: + nbFaceNodes += nbNodes; + aFaceSM.push_back( aSubMesh ); + break; + case TopAbs_EDGE: + nbEdgeNodes += nbNodes; + aEdgeSM.push_back( aSubMesh ); + break; + default: + continue; + } + } + // Treat positions on edges or faces + for ( int onFace = 0; onFace < 2; onFace++ ) + { + // Create arrays to store in datasets + int iNode = 0, nbNodes = ( onFace ? nbFaceNodes : nbEdgeNodes ); + if (!nbNodes) continue; + int* aNodeIDs = new int [ nbNodes ]; + double* aUPos = new double [ nbNodes ]; + double* aVPos = ( onFace ? new double[ nbNodes ] : 0 ); + + // Fill arrays + // loop on sub-meshes + list * pListSM = ( onFace ? &aFaceSM : &aEdgeSM ); + list::iterator itSM = pListSM->begin(); + for ( ; itSM != pListSM->end(); itSM++ ) + { + SMESHDS_SubMesh* aSubMesh = (*itSM); + if ( aSubMesh->IsComplexSubmesh() ) + continue; // submesh containing other submeshs + + SMDS_NodeIteratorPtr itNode = aSubMesh->GetNodes(); + // loop on nodes in aSubMesh + while ( itNode->more() ) + { + //node ID + const SMDS_MeshNode* node = itNode->next(); + aNodeIDs [ iNode ] = node->GetID(); + + // Position + const SMDS_PositionPtr pos = node->GetPosition(); + if ( onFace ) { // on FACE + const SMDS_FacePosition* fPos = + dynamic_cast( pos.get() ); + if ( fPos ) { + aUPos[ iNode ] = fPos->GetUParameter(); + aVPos[ iNode ] = fPos->GetVParameter(); + iNode++; + } + else + nbNodes--; + } + else { // on EDGE + const SMDS_EdgePosition* ePos = + dynamic_cast( pos.get() ); + if ( ePos ) { + aUPos[ iNode ] = ePos->GetUParameter(); + iNode++; + } + else + nbNodes--; + } + } // loop on nodes in aSubMesh + } // loop on sub-meshes + + // Write datasets + if ( nbNodes ) + { + aSize[ 0 ] = nbNodes; + // IDS + string aDSName( onFace ? "Nodes on Faces" : "Nodes on Edges"); + aDataset = new HDFdataset( (char*)aDSName.c_str(), aGroup, HDF_INT32, aSize, 1 ); + aDataset->CreateOnDisk(); + aDataset->WriteOnDisk( aNodeIDs ); + aDataset->CloseOnDisk(); + + // U Positions + aDSName = ( onFace ? "Face U positions" : "Edge positions"); + aDataset = new HDFdataset( (char*)aDSName.c_str(), aGroup, HDF_FLOAT64, aSize, 1); + aDataset->CreateOnDisk(); + aDataset->WriteOnDisk( aUPos ); + aDataset->CloseOnDisk(); + // V Positions + if ( onFace ) { + aDataset = new HDFdataset( "Face V positions", aGroup, HDF_FLOAT64, aSize, 1); + aDataset->CreateOnDisk(); + aDataset->WriteOnDisk( aVPos ); + aDataset->CloseOnDisk(); + } + } + delete [] aNodeIDs; + delete [] aUPos; + if ( aVPos ) delete [] aVPos; + + } // treat positions on edges or faces + + // close "Node Positions" group + aGroup->CloseOnDisk(); + + } // if ( there are submeshes in SMESHDS_Mesh ) + } // if ( hasData ) + + // close mesh HDF group + aTopGroup->CloseOnDisk(); + } } - hdfGroupMeshId->CloseOnDisk(); -} + } + } + } -/** - * 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); + // close HDF file + aFile->CloseOnDisk(); + delete aFile; - char name[HDF_NAME_MAX_LEN + 1]; - map < int, HDFgroup * > hdf_subgroup; + // Convert temporary files to stream + aStreamFile = SALOMEDS_Tool::PutFilesToStream( tmpDir.ToCString(), aFileSeq.in(), isMultiFile ); + // Remove temporary files and directory + if ( !isMultiFile ) + SALOMEDS_Tool::RemoveTemporaryFiles( tmpDir.ToCString(), aFileSeq.in(), true ); - //************* 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; - } - - //**************************** + INFOS( "SMESH_Gen_i::Save() completed" ); + return aStreamFile._retn(); +} - 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); - } +//============================================================================= +/*! + * SMESH_Gen_i::SaveASCII + * + * Save SMESH module's data in ASCII format (not implemented yet) + */ +//============================================================================= - MESSAGE("End of SMESH_Gen::Load"); +SALOMEDS::TMPFile* SMESH_Gen_i::SaveASCII( SALOMEDS::SComponent_ptr theComponent, + const char* theURL, + bool isMultiFile ) { + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::SaveASCII" ); + SALOMEDS::TMPFile_var aStreamFile = Save( theComponent, theURL, isMultiFile ); + return aStreamFile._retn(); +} - hdf_file->CloseOnDisk(); +//============================================================================= +/*! + * SMESH_Gen_i::loadGeomData + * + * Load GEOM module data + */ +//============================================================================= - // Remove temporary files created from the stream - if (isMultiFile) - SALOMEDS_Tool::RemoveTemporaryFiles(tmpDir.ToCString(), aFileSeq.in(), - true); +void SMESH_Gen_i::loadGeomData( SALOMEDS::SComponent_ptr theCompRoot ) +{ + if ( theCompRoot->_is_nil() ) + return; - return true; -} + SALOMEDS::Study_var aStudy = SALOMEDS::Study::_narrow( theCompRoot->GetStudy() ); + if ( aStudy->_is_nil() ) + return; -bool SMESH_Gen_i::LoadASCII(SALOMEDS::SComponent_ptr theComponent, - const SALOMEDS::TMPFile & theStream, const char *theURL, bool isMultiFile) -{ - return Load(theComponent, theStream, theURL, isMultiFile); + SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder(); + aStudyBuilder->LoadWith( theCompRoot, GetGeomEngine() ); } //============================================================================= /*! - * + * SMESH_Gen_i::Load + * + * Load SMESH module's data */ //============================================================================= -void SMESH_Gen_i::Close(SALOMEDS::SComponent_ptr theComponent) +bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent, + const SALOMEDS::TMPFile& theStream, + const char* theURL, + bool isMultiFile ) { - MESSAGE("Close"); - SALOMEDS::Study_var aStudy = theComponent->GetStudy(); - SALOMEDS::ChildIterator_var itBig = aStudy->NewChildIterator(theComponent); - for (; itBig->More(); itBig->Next()) - { - SALOMEDS::SObject_var gotBranch = itBig->Value(); - - // branch 1 : hypothesis - if (gotBranch->Tag() == Tag_HypothesisRoot || - gotBranch->Tag() == Tag_AlgorithmsRoot) - { - SALOMEDS::ChildIterator_var it = - aStudy->NewChildIterator(gotBranch); - for (; it->More(); it->Next()) - { - SALOMEDS::SObject_var mySObject = it->Value(); - SALOMEDS::GenericAttribute_var anAttr; - SALOMEDS::AttributeIOR_var anIOR; - if (mySObject->FindAttribute(anAttr, "AttributeIOR")) - { - anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); - SMESH::SMESH_Hypothesis_var myHyp = - SMESH::SMESH_Hypothesis::_narrow(_orb-> - string_to_object(anIOR->Value())); - char objectId[10]; - sprintf(objectId, "%ld", myHyp->GetId()); -// cout<<"********** delete Hyp "< - string_to_object(anIOR->Value())); - } - } + INFOS( "SMESH_Gen_i::Load" ); + + if ( myCurrentStudy->_is_nil() || + theComponent->GetStudy()->StudyId() != myCurrentStudy->StudyId() ) + SetCurrentStudy( theComponent->GetStudy() ); + + StudyContext* myStudyContext = GetCurrentStudyContext(); + + // Get temporary files location + TCollection_AsciiString tmpDir = + isMultiFile ? TCollection_AsciiString( ( char* )theURL ) : ( char* )SALOMEDS_Tool::GetTmpDir().c_str(); + + // 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 = ( (char*)SALOMEDS_Tool::GetNameFromPath( myCurrentStudy->URL() ).c_str() ); + + // Set names of temporary files + TCollection_AsciiString filename = tmpDir + aStudyName + TCollection_AsciiString( "_SMESH.hdf" ); + TCollection_AsciiString meshfile = tmpDir + aStudyName + TCollection_AsciiString( "_SMESH_Mesh.med" ); + + int size; + HDFfile* aFile; + HDFdataset* aDataset; + HDFgroup* aTopGroup; + HDFgroup* aGroup; + HDFgroup* aSubGroup; + HDFgroup* aSubSubGroup; + + // Read data + // ---> open HDF file + aFile = new HDFfile( filename.ToCString() ); + try { + aFile->OpenOnDisk( HDF_RDONLY ); + } + catch ( HDFexception ) { + INFOS( "Load(): " << filename << " not found!" ); + return false; + } + + DriverMED_R_SMESHDS_Mesh myReader; + myReader.SetFile( meshfile.ToCString() ); + + // get total number of top-level groups + int aNbGroups = aFile->nInternalObjects(); + if ( aNbGroups > 0 ) { + // --> in first turn we should read&create hypotheses + if ( aFile->ExistInternalObject( "Hypotheses" ) ) { + // open hypotheses root HDF group + aTopGroup = new HDFgroup( "Hypotheses", aFile ); + aTopGroup->OpenOnDisk(); + + // get number of hypotheses + int aNbObjects = aTopGroup->nInternalObjects(); + for ( int j = 0; j < aNbObjects; j++ ) { + // try to identify hypothesis + char hypGrpName[ HDF_NAME_MAX_LEN+1 ]; + aTopGroup->InternalObjectIndentify( j, hypGrpName ); + + if ( string( hypGrpName ).substr( 0, 10 ) == string( "Hypothesis" ) ) { + // open hypothesis group + aGroup = new HDFgroup( hypGrpName, aTopGroup ); + aGroup->OpenOnDisk(); + + // --> get hypothesis id + int id = atoi( string( hypGrpName ).substr( 10 ).c_str() ); + string hypname; + string libname; + string hypdata; + + // get number of datasets + int aNbSubObjects = aGroup->nInternalObjects(); + for ( int k = 0; k < aNbSubObjects; k++ ) { + // identify dataset + char name_of_subgroup[ HDF_NAME_MAX_LEN+1 ]; + aGroup->InternalObjectIndentify( k, name_of_subgroup ); + // --> get hypothesis name + if ( strcmp( name_of_subgroup, "Name" ) == 0 ) { + aDataset = new HDFdataset( name_of_subgroup, aGroup ); + aDataset->OpenOnDisk(); + size = aDataset->GetSize(); + char* hypname_str = new char[ size ]; + aDataset->ReadFromDisk( hypname_str ); + hypname = string( hypname_str ); + delete hypname_str; + aDataset->CloseOnDisk(); + } + // --> get hypothesis plugin library name + if ( strcmp( name_of_subgroup, "LibName" ) == 0 ) { + aDataset = new HDFdataset( name_of_subgroup, aGroup ); + aDataset->OpenOnDisk(); + size = aDataset->GetSize(); + char* libname_str = new char[ size ]; + aDataset->ReadFromDisk( libname_str ); + if(MYDEBUG) SCRUTE( libname_str ); + libname = string( libname_str ); + delete libname_str; + aDataset->CloseOnDisk(); + } + // --> get hypothesis data + if ( strcmp( name_of_subgroup, "Data" ) == 0 ) { + aDataset = new HDFdataset( name_of_subgroup, aGroup ); + aDataset->OpenOnDisk(); + size = aDataset->GetSize(); + char* hypdata_str = new char[ size ]; + aDataset->ReadFromDisk( hypdata_str ); + hypdata = string( hypdata_str ); + delete hypdata_str; + aDataset->CloseOnDisk(); + } + } + // close hypothesis HDF group + aGroup->CloseOnDisk(); + + // --> restore hypothesis from data + if ( id > 0 && !hypname.empty()/* && !hypdata.empty()*/ ) { // VSR : persistent data can be empty + if(MYDEBUG) MESSAGE("VSR - load hypothesis : id = " << id << + ", name = " << hypname.c_str() << ", persistent string = " << hypdata.c_str()); + SMESH::SMESH_Hypothesis_var myHyp; + + try { // protect persistence mechanism against exceptions + myHyp = this->createHypothesis( hypname.c_str(), libname.c_str() ); + } + catch (...) { + INFOS( "Exception during hypothesis creation" ); + } + + SMESH_Hypothesis_i* myImpl = dynamic_cast( GetServant( myHyp ).in() ); + if ( myImpl ) { + myImpl->LoadFrom( hypdata.c_str() ); + string iorString = GetORB()->object_to_string( myHyp ); + int newId = myStudyContext->findId( iorString ); + myStudyContext->mapOldToNew( id, newId ); + } + else + if(MYDEBUG) MESSAGE( "VSR - SMESH_Gen::Load - can't get servant" ); + } + } + } + // close hypotheses root HDF group + aTopGroup->CloseOnDisk(); + } + + // --> then we should read&create algorithms + if ( aFile->ExistInternalObject( "Algorithms" ) ) { + // open algorithms root HDF group + aTopGroup = new HDFgroup( "Algorithms", aFile ); + aTopGroup->OpenOnDisk(); + + // get number of algorithms + int aNbObjects = aTopGroup->nInternalObjects(); + for ( int j = 0; j < aNbObjects; j++ ) { + // try to identify algorithm + char hypGrpName[ HDF_NAME_MAX_LEN+1 ]; + aTopGroup->InternalObjectIndentify( j, hypGrpName ); + + if ( string( hypGrpName ).substr( 0, 9 ) == string( "Algorithm" ) ) { + // open algorithm group + aGroup = new HDFgroup( hypGrpName, aTopGroup ); + aGroup->OpenOnDisk(); + + // --> get algorithm id + int id = atoi( string( hypGrpName ).substr( 9 ).c_str() ); + string hypname; + string libname; + string hypdata; + + // get number of datasets + int aNbSubObjects = aGroup->nInternalObjects(); + for ( int k = 0; k < aNbSubObjects; k++ ) { + // identify dataset + char name_of_subgroup[ HDF_NAME_MAX_LEN+1 ]; + aGroup->InternalObjectIndentify( k, name_of_subgroup ); + // --> get algorithm name + if ( strcmp( name_of_subgroup, "Name" ) == 0 ) { + aDataset = new HDFdataset( name_of_subgroup, aGroup ); + aDataset->OpenOnDisk(); + size = aDataset->GetSize(); + char* hypname_str = new char[ size ]; + aDataset->ReadFromDisk( hypname_str ); + hypname = string( hypname_str ); + delete hypname_str; + aDataset->CloseOnDisk(); + } + // --> get algorithm plugin library name + if ( strcmp( name_of_subgroup, "LibName" ) == 0 ) { + aDataset = new HDFdataset( name_of_subgroup, aGroup ); + aDataset->OpenOnDisk(); + size = aDataset->GetSize(); + char* libname_str = new char[ size ]; + aDataset->ReadFromDisk( libname_str ); + if(MYDEBUG) SCRUTE( libname_str ); + libname = string( libname_str ); + delete libname_str; + aDataset->CloseOnDisk(); + } + // --> get algorithm data + if ( strcmp( name_of_subgroup, "Data" ) == 0 ) { + aDataset = new HDFdataset( name_of_subgroup, aGroup ); + aDataset->OpenOnDisk(); + size = aDataset->GetSize(); + char* hypdata_str = new char[ size ]; + aDataset->ReadFromDisk( hypdata_str ); + if(MYDEBUG) SCRUTE( hypdata_str ); + hypdata = string( hypdata_str ); + delete hypdata_str; + aDataset->CloseOnDisk(); + } + } + // close algorithm HDF group + aGroup->CloseOnDisk(); + + // --> restore algorithm from data + if ( id > 0 && !hypname.empty()/* && !hypdata.empty()*/ ) { // VSR : persistent data can be empty + if(MYDEBUG) MESSAGE("VSR - load algo : id = " << id << + ", name = " << hypname.c_str() << ", persistent string = " << hypdata.c_str()); + SMESH::SMESH_Hypothesis_var myHyp; + + try { // protect persistence mechanism against exceptions + myHyp = this->createHypothesis( hypname.c_str(), libname.c_str() ); + } + catch (...) { + INFOS( "Exception during hypothesis creation" ); + } + + SMESH_Hypothesis_i* myImpl = dynamic_cast( GetServant( myHyp ).in() ); + if ( myImpl ) { + myImpl->LoadFrom( hypdata.c_str() ); + string iorString = GetORB()->object_to_string( myHyp ); + int newId = myStudyContext->findId( iorString ); + myStudyContext->mapOldToNew( id, newId ); + } + else + if(MYDEBUG) MESSAGE( "VSR - SMESH_Gen::Load - can't get servant" ); + } + } + } + // close algorithms root HDF group + aTopGroup->CloseOnDisk(); + } + + // --> the rest groups should be meshes + for ( int i = 0; i < aNbGroups; i++ ) { + // identify next group + char meshName[ HDF_NAME_MAX_LEN+1 ]; + aFile->InternalObjectIndentify( i, meshName ); + + if ( string( meshName ).substr( 0, 4 ) == string( "Mesh" ) ) { + // --> get mesh id + int id = atoi( string( meshName ).substr( 4 ).c_str() ); + if ( id <= 0 ) + continue; + + bool hasData = false; + + // open mesh HDF group + aTopGroup = new HDFgroup( meshName, aFile ); + aTopGroup->OpenOnDisk(); + + // get number of child HDF objects + int aNbObjects = aTopGroup->nInternalObjects(); + if ( aNbObjects > 0 ) { + // create mesh + if(MYDEBUG) MESSAGE( "VSR - load mesh : id = " << id ); + SMESH::SMESH_Mesh_var myNewMesh = this->createMesh(); + SMESH_Mesh_i* myNewMeshImpl = dynamic_cast( GetServant( myNewMesh ).in() ); + if ( !myNewMeshImpl ) + continue; + string iorString = GetORB()->object_to_string( myNewMesh ); + int newId = myStudyContext->findId( iorString ); + myStudyContext->mapOldToNew( id, newId ); + + ::SMESH_Mesh& myLocMesh = myNewMeshImpl->GetImpl(); + SMESHDS_Mesh* mySMESHDSMesh = myLocMesh.GetMeshDS(); + + // try to find mesh data dataset + if ( aTopGroup->ExistInternalObject( "Has data" ) ) { + // load mesh "has data" flag + aDataset = new HDFdataset( "Has data", aTopGroup ); + aDataset->OpenOnDisk(); + size = aDataset->GetSize(); + char* strHasData = new char[ size ]; + aDataset->ReadFromDisk( strHasData ); + aDataset->CloseOnDisk(); + if ( strcmp( strHasData, "1") == 0 ) { + // read mesh data from MED file + myReader.SetMesh( mySMESHDSMesh ); + myReader.SetMeshId( id ); + myReader.Perform(); + hasData = true; + } + } + + // try to read and set reference to shape + GEOM::GEOM_Object_var aShapeObject; + if ( aTopGroup->ExistInternalObject( "Ref on shape" ) ) { + // load mesh "Ref on shape" - it's an entry to SObject + aDataset = new HDFdataset( "Ref on shape", aTopGroup ); + aDataset->OpenOnDisk(); + size = aDataset->GetSize(); + char* refFromFile = new char[ size ]; + aDataset->ReadFromDisk( refFromFile ); + aDataset->CloseOnDisk(); + if ( strlen( refFromFile ) > 0 ) { + SALOMEDS::SObject_var shapeSO = myCurrentStudy->FindObjectID( refFromFile ); + + // Make sure GEOM data are loaded first + loadGeomData( shapeSO->GetFatherComponent() ); + + CORBA::Object_var shapeObject = SObjectToObject( shapeSO ); + if ( !CORBA::is_nil( shapeObject ) ) { + aShapeObject = GEOM::GEOM_Object::_narrow( shapeObject ); + if ( !aShapeObject->_is_nil() ) + myNewMeshImpl->SetShape( aShapeObject ); + } + } + } + + // try to get applied hypotheses + if ( aTopGroup->ExistInternalObject( "Applied Hypotheses" ) ) { + aGroup = new HDFgroup( "Applied Hypotheses", aTopGroup ); + aGroup->OpenOnDisk(); + // get number of applied hypotheses + int aNbSubObjects = aGroup->nInternalObjects(); + for ( int j = 0; j < aNbSubObjects; j++ ) { + char name_dataset[ HDF_NAME_MAX_LEN+1 ]; + aGroup->InternalObjectIndentify( j, name_dataset ); + // check if it is a hypothesis + if ( string( name_dataset ).substr( 0, 3 ) == string( "Hyp" ) ) { + aDataset = new HDFdataset( name_dataset, aGroup ); + aDataset->OpenOnDisk(); + size = aDataset->GetSize(); + char* refFromFile = new char[ size ]; + aDataset->ReadFromDisk( refFromFile ); + aDataset->CloseOnDisk(); + + // san - it is impossible to recover applied hypotheses using their entries within Load() method + + //SALOMEDS::SObject_var hypSO = myCurrentStudy->FindObjectID( refFromFile ); + //CORBA::Object_var hypObject = SObjectToObject( hypSO ); + int id = atoi( refFromFile ); + string anIOR = myStudyContext->getIORbyOldId( id ); + if ( !anIOR.empty() ) { + CORBA::Object_var hypObject = GetORB()->string_to_object( anIOR.c_str() ); + if ( !CORBA::is_nil( hypObject ) ) { + SMESH::SMESH_Hypothesis_var anHyp = SMESH::SMESH_Hypothesis::_narrow( hypObject ); + if ( !anHyp->_is_nil() && !aShapeObject->_is_nil() ) + myNewMeshImpl->addHypothesis( aShapeObject, anHyp ); + } } - // 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 "<CloseOnDisk(); + } + + // try to get applied algorithms + if ( aTopGroup->ExistInternalObject( "Applied Algorithms" ) ) { + aGroup = new HDFgroup( "Applied Algorithms", aTopGroup ); + aGroup->OpenOnDisk(); + // get number of applied algorithms + int aNbSubObjects = aGroup->nInternalObjects(); + if(MYDEBUG) MESSAGE( "VSR - number of applied algos " << aNbSubObjects ); + for ( int j = 0; j < aNbSubObjects; j++ ) { + char name_dataset[ HDF_NAME_MAX_LEN+1 ]; + aGroup->InternalObjectIndentify( j, name_dataset ); + // check if it is an algorithm + if ( string( name_dataset ).substr( 0, 4 ) == string( "Algo" ) ) { + aDataset = new HDFdataset( name_dataset, aGroup ); + aDataset->OpenOnDisk(); + size = aDataset->GetSize(); + char* refFromFile = new char[ size ]; + aDataset->ReadFromDisk( refFromFile ); + aDataset->CloseOnDisk(); + + // san - it is impossible to recover applied algorithms using their entries within Load() method + + //SALOMEDS::SObject_var hypSO = myCurrentStudy->FindObjectID( refFromFile ); + //CORBA::Object_var hypObject = SObjectToObject( hypSO ); + int id = atoi( refFromFile ); + string anIOR = myStudyContext->getIORbyOldId( id ); + if ( !anIOR.empty() ) { + CORBA::Object_var hypObject = GetORB()->string_to_object( anIOR.c_str() ); + if ( !CORBA::is_nil( hypObject ) ) { + SMESH::SMESH_Hypothesis_var anHyp = SMESH::SMESH_Hypothesis::_narrow( hypObject ); + if ( !anHyp->_is_nil() && !aShapeObject->_is_nil() ) + myNewMeshImpl->addHypothesis( aShapeObject, anHyp ); + } + } + } + } + aGroup->CloseOnDisk(); + } + + // --> try to find submeshes containers for each type of submesh + for ( int j = GetSubMeshOnVertexTag(); j <= GetSubMeshOnCompoundTag(); j++ ) { + char name_meshgroup[ 30 ]; + if ( j == GetSubMeshOnVertexTag() ) + strcpy( name_meshgroup, "SubMeshes On Vertex" ); + else if ( j == GetSubMeshOnEdgeTag() ) + strcpy( name_meshgroup, "SubMeshes On Edge" ); + else if ( j == GetSubMeshOnWireTag() ) + strcpy( name_meshgroup, "SubMeshes On Wire" ); + else if ( j == GetSubMeshOnFaceTag() ) + strcpy( name_meshgroup, "SubMeshes On Face" ); + else if ( j == GetSubMeshOnShellTag() ) + strcpy( name_meshgroup, "SubMeshes On Shell" ); + else if ( j == GetSubMeshOnSolidTag() ) + strcpy( name_meshgroup, "SubMeshes On Solid" ); + else if ( j == GetSubMeshOnCompoundTag() ) + strcpy( name_meshgroup, "SubMeshes On Compound" ); + + // try to get submeshes container HDF group + if ( aTopGroup->ExistInternalObject( name_meshgroup ) ) { + // open submeshes containers HDF group + aGroup = new HDFgroup( name_meshgroup, aTopGroup ); + aGroup->OpenOnDisk(); + + // get number of submeshes + int aNbSubMeshes = aGroup->nInternalObjects(); + for ( int k = 0; k < aNbSubMeshes; k++ ) { + // identify submesh + char name_submeshgroup[ HDF_NAME_MAX_LEN+1 ]; + aGroup->InternalObjectIndentify( k, name_submeshgroup ); + if ( string( name_submeshgroup ).substr( 0, 7 ) == string( "SubMesh" ) ) { + // --> get submesh id + int subid = atoi( string( name_submeshgroup ).substr( 7 ).c_str() ); + if ( subid <= 0 ) + continue; + // open submesh HDF group + aSubGroup = new HDFgroup( name_submeshgroup, aGroup ); + aSubGroup->OpenOnDisk(); + + // try to read and set reference to subshape + GEOM::GEOM_Object_var aSubShapeObject; + SMESH::SMESH_subMesh_var aSubMesh; + + if ( aSubGroup->ExistInternalObject( "Ref on shape" ) ) { + // load submesh "Ref on shape" - it's an entry to SObject + aDataset = new HDFdataset( "Ref on shape", aSubGroup ); + aDataset->OpenOnDisk(); + size = aDataset->GetSize(); + char* refFromFile = new char[ size ]; + aDataset->ReadFromDisk( refFromFile ); + aDataset->CloseOnDisk(); + if ( strlen( refFromFile ) > 0 ) { + SALOMEDS::SObject_var subShapeSO = myCurrentStudy->FindObjectID( refFromFile ); + CORBA::Object_var subShapeObject = SObjectToObject( subShapeSO ); + if ( !CORBA::is_nil( subShapeObject ) ) { + aSubShapeObject = GEOM::GEOM_Object::_narrow( subShapeObject ); + if ( !aSubShapeObject->_is_nil() ) + aSubMesh = SMESH::SMESH_subMesh::_duplicate + ( myNewMeshImpl->createSubMesh( aSubShapeObject ) ); + if ( aSubMesh->_is_nil() ) + continue; + string iorSubString = GetORB()->object_to_string( aSubMesh ); + int newSubId = myStudyContext->findId( iorSubString ); + myStudyContext->mapOldToNew( subid, newSubId ); + } + } + } + + if ( aSubMesh->_is_nil() ) + continue; + + // VSR: Get submesh data from MED convertor +// int anInternalSubmeshId = aSubMesh->GetId(); // this is not a persistent ID, it's an internal one computed from sub-shape +// if (myNewMeshImpl->_mapSubMesh.find(anInternalSubmeshId) != myNewMeshImpl->_mapSubMesh.end()) { +// if(MYDEBUG) MESSAGE("VSR - SMESH_Gen_i::Load(): loading from MED file submesh with ID = " << +// subid << " for subshape # " << anInternalSubmeshId); +// SMESHDS_SubMesh* aSubMeshDS = +// myNewMeshImpl->_mapSubMesh[anInternalSubmeshId]->CreateSubMeshDS(); +// if ( !aSubMeshDS ) { +// if(MYDEBUG) MESSAGE("VSR - SMESH_Gen_i::Load(): FAILED to create a submesh for subshape # " << +// anInternalSubmeshId << " in current mesh!"); +// } +// else +// myReader.GetSubMesh( aSubMeshDS, subid ); +// } + + // try to get applied hypotheses + if ( aSubGroup->ExistInternalObject( "Applied Hypotheses" ) ) { + // open "applied hypotheses" HDF group + aSubSubGroup = new HDFgroup( "Applied Hypotheses", aSubGroup ); + aSubSubGroup->OpenOnDisk(); + // get number of applied hypotheses + int aNbSubObjects = aSubSubGroup->nInternalObjects(); + for ( int l = 0; l < aNbSubObjects; l++ ) { + char name_dataset[ HDF_NAME_MAX_LEN+1 ]; + aSubSubGroup->InternalObjectIndentify( l, name_dataset ); + // check if it is a hypothesis + if ( string( name_dataset ).substr( 0, 3 ) == string( "Hyp" ) ) { + aDataset = new HDFdataset( name_dataset, aSubSubGroup ); + aDataset->OpenOnDisk(); + size = aDataset->GetSize(); + char* refFromFile = new char[ size ]; + aDataset->ReadFromDisk( refFromFile ); + aDataset->CloseOnDisk(); + + //SALOMEDS::SObject_var hypSO = myCurrentStudy->FindObjectID( refFromFile ); + //CORBA::Object_var hypObject = SObjectToObject( hypSO ); + int id = atoi( refFromFile ); + string anIOR = myStudyContext->getIORbyOldId( id ); + if ( !anIOR.empty() ) { + CORBA::Object_var hypObject = GetORB()->string_to_object( anIOR.c_str() ); + if ( !CORBA::is_nil( hypObject ) ) { + SMESH::SMESH_Hypothesis_var anHyp = SMESH::SMESH_Hypothesis::_narrow( hypObject ); + if ( !anHyp->_is_nil() && !aShapeObject->_is_nil() ) + myNewMeshImpl->addHypothesis( aSubShapeObject, anHyp ); + } } + } + } + // close "applied hypotheses" HDF group + aSubSubGroup->CloseOnDisk(); + } + + // try to get applied algorithms + if ( aSubGroup->ExistInternalObject( "Applied Algorithms" ) ) { + // open "applied algorithms" HDF group + aSubSubGroup = new HDFgroup( "Applied Algorithms", aSubGroup ); + aSubSubGroup->OpenOnDisk(); + // get number of applied algorithms + int aNbSubObjects = aSubSubGroup->nInternalObjects(); + for ( int l = 0; l < aNbSubObjects; l++ ) { + char name_dataset[ HDF_NAME_MAX_LEN+1 ]; + aSubSubGroup->InternalObjectIndentify( l, name_dataset ); + // check if it is an algorithm + if ( string( name_dataset ).substr( 0, 4 ) == string( "Algo" ) ) { + aDataset = new HDFdataset( name_dataset, aSubSubGroup ); + aDataset->OpenOnDisk(); + size = aDataset->GetSize(); + char* refFromFile = new char[ size ]; + aDataset->ReadFromDisk( refFromFile ); + aDataset->CloseOnDisk(); + + //SALOMEDS::SObject_var hypSO = myCurrentStudy->FindObjectID( refFromFile ); + //CORBA::Object_var hypObject = SObjectToObject( hypSO ); + int id = atoi( refFromFile ); + string anIOR = myStudyContext->getIORbyOldId( id ); + if ( !anIOR.empty() ) { + CORBA::Object_var hypObject = GetORB()->string_to_object( anIOR.c_str() ); + if ( !CORBA::is_nil( hypObject ) ) { + SMESH::SMESH_Hypothesis_var anHyp = SMESH::SMESH_Hypothesis::_narrow( hypObject ); + if ( !anHyp->_is_nil() && !aShapeObject->_is_nil() ) + myNewMeshImpl->addHypothesis( aSubShapeObject, anHyp ); + } + } + } + } + // close "applied algorithms" HDF group + aSubSubGroup->CloseOnDisk(); + } + + // close submesh HDF group + aSubGroup->CloseOnDisk(); + } + } + // close submeshes containers HDF group + aGroup->CloseOnDisk(); + } + } + + if(hasData) { + // Read sub-meshes from MED + if(MYDEBUG) MESSAGE("JFA - Create all sub-meshes"); + myReader.CreateAllSubMeshes(); + + + // Read node positions on sub-shapes (SMDS_Position) + + if ( aTopGroup->ExistInternalObject( "Node Positions" )) + { + // There are 5 datasets to read: + // "Nodes on Edges" - ID of node on edge + // "Edge positions" - U parameter on node on edge + // "Nodes on Faces" - ID of node on face + // "Face U positions" - U parameter of node on face + // "Face V positions" - V parameter of node on face + char* aEid_DSName = "Nodes on Edges"; + char* aEu_DSName = "Edge positions"; + char* aFu_DSName = "Face U positions"; + //char* aFid_DSName = "Nodes on Faces"; + //char* aFv_DSName = "Face V positions"; + + // data to retrieve + int nbEids = 0, nbFids = 0; + int *aEids = 0, *aFids = 0; + double *aEpos = 0, *aFupos = 0, *aFvpos = 0; + + // open a group + aGroup = new HDFgroup( "Node Positions", aTopGroup ); + aGroup->OpenOnDisk(); + + // loop on 5 data sets + int aNbObjects = aGroup->nInternalObjects(); + for ( int i = 0; i < aNbObjects; i++ ) + { + // identify dataset + char aDSName[ HDF_NAME_MAX_LEN+1 ]; + aGroup->InternalObjectIndentify( i, aDSName ); + // read data + aDataset = new HDFdataset( aDSName, aGroup ); + aDataset->OpenOnDisk(); + if ( aDataset->GetType() == HDF_FLOAT64 ) // Positions + { + double* pos = new double [ aDataset->GetSize() ]; + aDataset->ReadFromDisk( pos ); + // which one? + if ( strncmp( aDSName, aEu_DSName, strlen( aEu_DSName )) == 0 ) + aEpos = pos; + else if ( strncmp( aDSName, aFu_DSName, strlen( aFu_DSName )) == 0 ) + aFupos = pos; + else + aFvpos = pos; + } + else // NODE IDS + { + int* ids = new int [ aDataset->GetSize() ]; + aDataset->ReadFromDisk( ids ); + // on face or nodes? + if ( strncmp( aDSName, aEid_DSName, strlen( aEid_DSName )) == 0 ) { + aEids = ids; + nbEids = aDataset->GetSize(); + } + else { + aFids = ids; + nbFids = aDataset->GetSize(); + } + } + } // loop on 5 datasets + + // Set node positions on edges or faces + for ( int onFace = 0; onFace < 2; onFace++ ) + { + int nbNodes = ( onFace ? nbFids : nbEids ); + if ( nbNodes == 0 ) continue; + int* aNodeIDs = ( onFace ? aFids : aEids ); + double* aUPos = ( onFace ? aFupos : aEpos ); + double* aVPos = ( onFace ? aFvpos : 0 ); + // loop on node IDs + for ( int iNode = 0; iNode < nbNodes; iNode++ ) + { + const SMDS_MeshNode* node = mySMESHDSMesh->FindNode( aNodeIDs[ iNode ]); + ASSERT( node ); + SMDS_PositionPtr aPos = node->GetPosition(); + ASSERT( aPos ) + if ( onFace ) { + ASSERT( aPos->GetTypeOfPosition() == SMDS_TOP_FACE ); + SMDS_FacePosition* fPos = const_cast + ( static_cast( aPos.get() )); + fPos->SetUParameter( aUPos[ iNode ]); + fPos->SetVParameter( aVPos[ iNode ]); + } + else { + ASSERT( aPos->GetTypeOfPosition() == SMDS_TOP_EDGE ); + SMDS_EdgePosition* fPos = const_cast + ( static_cast( aPos.get() )); + fPos->SetUParameter( aUPos[ iNode ]); + } + } + } + if ( aEids ) delete [] aEids; + if ( aFids ) delete [] aFids; + if ( aEpos ) delete [] aEpos; + if ( aFupos ) delete [] aFupos; + if ( aFvpos ) delete [] aFvpos; + + aGroup->CloseOnDisk(); + + } // if ( aTopGroup->ExistInternalObject( "Node Positions" ) ) + } // if ( hasData ) + + // Recompute State (as computed sub-meshes are restored from MED) + if ( !aShapeObject->_is_nil() ) { + MESSAGE("JFA - Compute State Engine ..."); + TopoDS_Shape myLocShape = GeomObjectToShape( aShapeObject ); + myNewMeshImpl->GetImpl().GetSubMesh(myLocShape)->ComputeStateEngine + (SMESH_subMesh::SUBMESH_RESTORED); + MESSAGE("JFA - Compute State Engine finished"); + } + + // try to get groups + for ( int ii = GetNodeGroupsTag(); ii <= GetVolumeGroupsTag(); ii++ ) { + char name_group[ 30 ]; + if ( ii == GetNodeGroupsTag() ) + strcpy( name_group, "Groups of Nodes" ); + else if ( ii == GetEdgeGroupsTag() ) + strcpy( name_group, "Groups of Edges" ); + else if ( ii == GetFaceGroupsTag() ) + strcpy( name_group, "Groups of Faces" ); + else if ( ii == GetVolumeGroupsTag() ) + strcpy( name_group, "Groups of Volumes" ); + + if ( aTopGroup->ExistInternalObject( name_group ) ) { + aGroup = new HDFgroup( name_group, aTopGroup ); + aGroup->OpenOnDisk(); + // get number of groups + int aNbSubObjects = aGroup->nInternalObjects(); + for ( int j = 0; j < aNbSubObjects; j++ ) { + char name_dataset[ HDF_NAME_MAX_LEN+1 ]; + aGroup->InternalObjectIndentify( j, name_dataset ); + // check if it is an group + if ( string( name_dataset ).substr( 0, 5 ) == string( "Group" ) ) { + // --> get group id + int subid = atoi( string( name_dataset ).substr( 5 ).c_str() ); + if ( subid <= 0 ) + continue; + aDataset = new HDFdataset( name_dataset, aGroup ); + aDataset->OpenOnDisk(); + + // Retrieve actual group name + size = aDataset->GetSize(); + char* nameFromFile = new char[ size ]; + aDataset->ReadFromDisk( nameFromFile ); + aDataset->CloseOnDisk(); + + // Try to find a shape reference + TopoDS_Shape aShape; + char aRefName[ 30 ]; + sprintf( aRefName, "Ref on shape %d", subid); + if ( aGroup->ExistInternalObject( aRefName ) ) { + // load mesh "Ref on shape" - it's an entry to SObject + aDataset = new HDFdataset( aRefName, aGroup ); + aDataset->OpenOnDisk(); + size = aDataset->GetSize(); + char* refFromFile = new char[ size ]; + aDataset->ReadFromDisk( refFromFile ); + aDataset->CloseOnDisk(); + if ( strlen( refFromFile ) > 0 ) { + SALOMEDS::SObject_var shapeSO = myCurrentStudy->FindObjectID( refFromFile ); + CORBA::Object_var shapeObject = SObjectToObject( shapeSO ); + if ( !CORBA::is_nil( shapeObject ) ) { + aShapeObject = GEOM::GEOM_Object::_narrow( shapeObject ); + if ( !aShapeObject->_is_nil() ) + aShape = GeomObjectToShape( aShapeObject ); + } + } + } + // Create group servant + SMESH::ElementType type = (SMESH::ElementType)(ii - GetNodeGroupsTag() + 1); + SMESH::SMESH_GroupBase_var aNewGroup = SMESH::SMESH_GroupBase::_duplicate + ( myNewMeshImpl->createGroup( type, nameFromFile, aShape ) ); + // Obtain a SMESHDS_Group object + if ( aNewGroup->_is_nil() ) + continue; + + string iorSubString = GetORB()->object_to_string( aNewGroup ); + int newSubId = myStudyContext->findId( iorSubString ); + myStudyContext->mapOldToNew( subid, newSubId ); + + SMESH_GroupBase_i* aGroupImpl = + dynamic_cast( GetServant( aNewGroup ).in() ); + if ( !aGroupImpl ) + continue; + + SMESH_Group* aLocalGroup = myLocMesh.GetGroup( aGroupImpl->GetLocalID() ); + if ( !aLocalGroup ) + continue; + + SMESHDS_GroupBase* aGroupBaseDS = aLocalGroup->GetGroupDS(); + aGroupBaseDS->SetStoreName( name_dataset ); + + // Fill group with contents from MED file + SMESHDS_Group* aGrp = dynamic_cast( aGroupBaseDS ); + if ( aGrp ) + myReader.GetGroup( aGrp ); } + } + aGroup->CloseOnDisk(); + } + } } + // close mesh group + aTopGroup->CloseOnDisk(); + } + } + } + // close HDF file + aFile->CloseOnDisk(); + delete aFile; + + // Remove temporary files created from the stream + if ( !isMultiFile ) + SALOMEDS_Tool::RemoveTemporaryFiles( tmpDir.ToCString(), aFileSeq.in(), true ); + + INFOS( "SMESH_Gen_i::Load completed" ); + return true; } //============================================================================= /*! - * + * SMESH_Gen_i::LoadASCII + * + * Load SMESH module's data in ASCII format (not implemented yet) */ //============================================================================= -char *SMESH_Gen_i::ComponentDataType() -{ - MESSAGE("SMESH_Gen_i::ComponentDataType"); - return strdup("SMESH"); +bool SMESH_Gen_i::LoadASCII( SALOMEDS::SComponent_ptr theComponent, + const SALOMEDS::TMPFile& theStream, + const char* theURL, + bool isMultiFile ) { + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::LoadASCII" ); + return Load( theComponent, theStream, theURL, isMultiFile ); } //============================================================================= /*! - * + * SMESH_Gen_i::Close + * + * Clears study-connected data when it is closed */ //============================================================================= -char *SMESH_Gen_i::IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject, - const char *IORString, CORBA::Boolean isMultiFile, CORBA::Boolean isASCII) +void SMESH_Gen_i::Close( SALOMEDS::SComponent_ptr theComponent ) { - MESSAGE("SMESH_Gen_i::IORToLocalPersistentID"); - - char objectId[10]; - - SMESH::SMESH_Algo_var myAlgo = - SMESH::SMESH_Algo::_narrow(_orb->string_to_object(IORString)); - if (!CORBA::is_nil(myAlgo)) - { - string prefix = "Hypo_"; - sprintf(objectId, "%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")); - } - } - } + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Close" ); + + // Clear study contexts data + int studyId = GetCurrentStudyID(); + if ( myStudyContextMap.find( studyId ) != myStudyContextMap.end() ) { + delete myStudyContextMap[ studyId ]; + myStudyContextMap.erase( studyId ); + } + return; } //============================================================================= /*! - * + * SMESH_Gen_i::ComponentDataType + * + * Get component data type */ //============================================================================= -char *SMESH_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject, - const char *aLocalPersistentID, - CORBA::Boolean isMultiFile, CORBA::Boolean isASCII) +char* SMESH_Gen_i::ComponentDataType() { - MESSAGE("SMESH_Gen_i::LocalPersistentIDToIOR"); - SCRUTE(aLocalPersistentID); - string clef = string(aLocalPersistentID); - SCRUTE(_SMESHCorbaObj[clef].c_str()); - return CORBA::string_dup(_SMESHCorbaObj[clef].c_str()); + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::ComponentDataType" ); + return CORBA::string_dup( "SMESH" ); } + //============================================================================= /*! + * SMESH_Gen_i::IORToLocalPersistentID * + * Transform data from transient form to persistent */ //============================================================================= -SMESH_topo *SMESH_Gen_i::ExploreMainShape(GEOM::GEOM_Gen_ptr geomEngine, - CORBA::Long studyId, GEOM::GEOM_Shape_ptr aShape) +char* SMESH_Gen_i::IORToLocalPersistentID( SALOMEDS::SObject_ptr /*theSObject*/, + const char* IORString, + CORBA::Boolean /*isMultiFile*/, + CORBA::Boolean /*isASCII*/ ) { - 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; + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IORToLocalPersistentID" ); + StudyContext* myStudyContext = GetCurrentStudyContext(); + + if ( myStudyContext && strcmp( IORString, "" ) != 0 ) { + int anId = myStudyContext->findId( IORString ); + if ( anId ) { + if(MYDEBUG) MESSAGE( "VSR " << anId ) + char strId[ 20 ]; + sprintf( strId, "%d", anId ); + return CORBA::string_dup( strId ); + } + } + return CORBA::string_dup( "" ); } -/** - * 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_Gen_i::LocalPersistentIDToIOR + * + * Transform data from persistent form to transient */ -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 - SMESH_Mesh * meshImpl=_impl.Import(studyId, fileName, fileType); - - // create a new mesh object servant, store it in a map in study context - meshServant = new SMESH_Mesh_i(this, NULL, studyId, meshImpl); - myStudyContext->mapMesh_i[meshImpl->GetId()] = meshServant; - } - catch(SALOME_Exception & S_ex) - { - THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); - } +//============================================================================= - // activate the CORBA servant of Mesh +char* SMESH_Gen_i::LocalPersistentIDToIOR( SALOMEDS::SObject_ptr /*theSObject*/, + const char* aLocalPersistentID, + CORBA::Boolean /*isMultiFile*/, + CORBA::Boolean /*isASCII*/ ) +{ + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::LocalPersistentIDToIOR(): id = " << aLocalPersistentID ); + StudyContext* myStudyContext = GetCurrentStudyContext(); + + if ( myStudyContext && strcmp( aLocalPersistentID, "" ) != 0 ) { + int anId = atoi( aLocalPersistentID ); + return CORBA::string_dup( myStudyContext->getIORbyOldId( anId ).c_str() ); + } + return CORBA::string_dup( "" ); +} - SMESH::SMESH_Mesh_var mesh - = SMESH::SMESH_Mesh::_narrow(meshServant->_this()); +//======================================================================= +//function : RegisterObject +//purpose : +//======================================================================= - meshServant->SetIor(mesh); - return SMESH::SMESH_Mesh::_duplicate(mesh); +int SMESH_Gen_i::RegisterObject(CORBA::Object_ptr theObject) +{ + StudyContext* myStudyContext = GetCurrentStudyContext(); + if ( myStudyContext && !CORBA::is_nil( theObject )) { + string iorString = GetORB()->object_to_string( theObject ); + return myStudyContext->addObject( iorString ); + } + return 0; } - + //============================================================================= /*! - * C factory, accessible with dlsym, after dlopen + * SMESHEngine_factory + * + * C factory, accessible with dlsym, after dlopen */ //============================================================================= 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 ) + { + if(MYDEBUG) MESSAGE( "PortableServer::ObjectId* SMESHEngine_factory()" ); + if(MYDEBUG) SCRUTE(interfaceName); + SMESH_Gen_i* aSMESHGen = new SMESH_Gen_i(orb, poa, contId, instanceName, interfaceName); + return aSMESHGen->getId() ; + } }