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=77abfc9e5285878013b6f0bc0b1e9a81464ebfd2;hp=1594966efb61da268bfc80a222ec7869c8211730;hb=1d0ad233cfb9576030f41a0d04ab46f33eaab17e;hpb=cae755c4b270cbfbe061312428ac77a564aa9607 diff --git a/src/SMESH_I/SMESH_Gen_i.cxx b/src/SMESH_I/SMESH_Gen_i.cxx index 1594966ef..77abfc9e5 100644 --- a/src/SMESH_I/SMESH_Gen_i.cxx +++ b/src/SMESH_I/SMESH_Gen_i.cxx @@ -26,7 +26,6 @@ // Module : SMESH // $Header$ -using namespace std; #include #include #include @@ -41,30 +40,39 @@ using namespace std; #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_Hypothesis_i.hxx" +#include "SMESH_Algo_i.hxx" +#include "SMESH_Group_i.hxx" #include "SMESHDS_Document.hxx" +#include "SMESHDS_Group.hxx" +#include "SMESHDS_GroupOnGeom.hxx" +#include "SMESH_Group.hxx" + +#include "SMDS_EdgePosition.hxx" +#include "SMDS_FacePosition.hxx" + +#include CORBA_SERVER_HEADER(SMESH_Group) +#include CORBA_SERVER_HEADER(SMESH_Filter) -#include "Document_Reader.h" #include "DriverMED_W_SMESHDS_Mesh.h" #include "DriverMED_R_SMESHDS_Mesh.h" -#include "DriverMED_R_SMESHDS_Document.h" -#include "DriverUNV_R_SMESHDS_Document.h" -#include "DriverDAT_R_SMESHDS_Document.h" - -#include "Utils_CorbaException.hxx" -#include "utilities.h" #include "SALOMEDS_Tool.hxx" #include "SALOME_NamingService.hxx" @@ -72,254 +80,705 @@ using namespace std; #include "Utils_SINGLETON.hxx" #include "OpUtil.hxx" -//#include +#include CORBA_CLIENT_HEADER(SALOME_ModuleCatalog) #include "GEOM_Client.hxx" +#include "Utils_ExceptHandlers.hxx" #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; - _localId = 0; // number of created objects & local id +//============================================================================= +/*! + * 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_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 ) +{ + 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; +} + //============================================================================= /*! - * + * SMESH_Gen_i::~SMESH_Gen_i + * + * Destructor */ //============================================================================= -SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis(const char* anHyp, - CORBA::Long studyId) - throw (SALOME::SALOME_Exception) +SMESH_Gen_i::~SMESH_Gen_i() { - MESSAGE("CreateHypothesis"); + INFOS( "SMESH_Gen_i::~SMESH_Gen_i" ); - // create a new hypothesis object servant + // 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; +} + +//============================================================================= +/*! + * SMESH_Gen_i::createHypothesis + * + * Create hypothesis of given type + */ +//============================================================================= +SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName, + const char* theLibName) + throw (SALOME::SALOME_Exception) +{ + 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()) { - myHypothesis_i = _hypothesisFactory_i.Create(anHyp, - studyId, - &_impl); + // 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); - } + { + 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 ); - SMESH::SMESH_Hypothesis_var hypothesis_i - = SMESH::SMESH_Hypothesis::_narrow(myHypothesis_i->_this()); - return SMESH::SMESH_Hypothesis::_duplicate(hypothesis_i); + return hypothesis_i._retn(); } //============================================================================= /*! - * + * 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) - 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); + 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_Mesh_i* meshServant = 0; - try - { - if (! _ShapeReader) _ShapeReader = new GEOM_Client(); - ASSERT(_ShapeReader); - - // explore main Shape, get local TopoDS_Shapes of all subShapes - // SMESH_topo* myTopo = ExploreMainShape(geom, studyId, myShape); - - // Get studyContext_i, create it if it does'nt exist - - if (_mapStudyContext_i.find(studyId) == _mapStudyContext_i.end()) - { - _mapStudyContext_i[studyId] = new StudyContext_iStruct; - } - StudyContext_iStruct* myStudyContext = _mapStudyContext_i[studyId]; - - // create a new mesh object servant, store it in a map in study context - - meshServant = new SMESH_Mesh_i(this, - geom, - studyId, - _localId); - myStudyContext->mapMesh_i[_localId] = meshServant; - _localId++; - - // create a new mesh object +//============================================================================= +/*! + * SMESH_Gen_i::GetShapeReader + * + * Get shape reader + */ +//============================================================================= +GEOM_Client* SMESH_Gen_i::GetShapeReader() +{ + // create shape reader if necessary + if ( !myShapeReader ) + myShapeReader = new GEOM_Client(GetContainerRef()); + ASSERT( myShapeReader ); + return myShapeReader; +} + +//============================================================================= +/*! + * SMESH_Gen_i::SetCurrentStudy + * + * Set current study + */ +//============================================================================= + +void SMESH_Gen_i::SetCurrentStudy( SALOMEDS::Study_ptr theStudy ) +{ + 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 + */ +//============================================================================= + +SALOMEDS::Study_ptr SMESH_Gen_i::GetCurrentStudy() +{ + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetCurrentStudy: study Id = " << GetCurrentStudyID() ); + return SALOMEDS::Study::_duplicate( myCurrentStudy ); +} + +//============================================================================= +/*! + * SMESH_Gen_i::GetCurrentStudyContext + * + * Get current study context + */ +//============================================================================= +StudyContext* SMESH_Gen_i::GetCurrentStudyContext() +{ + if ( !CORBA::is_nil( myCurrentStudy ) && + myStudyContextMap.find( GetCurrentStudyID() ) != myStudyContextMap.end() ) + return myStudyContextMap[ myCurrentStudy->StudyId() ]; + else + return 0; +} + +//============================================================================= +/*! + * SMESH_Gen_i::CreateHypothesis + * + * Create hypothesis/algorothm of given type and publish it in the study + */ +//============================================================================= + +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 ); + + // Publish hypothesis/algorithm in the study + if ( CanPublishInStudy( hyp ) ) { + SALOMEDS::SObject_var aSO = PublishHypothesis( myCurrentStudy, hyp ); + if ( !aSO->_is_nil() ) { + // Update Python script + TCollection_AsciiString aStr (aSO->GetID()); + aStr += " = smesh.CreateHypothesis(\""; + aStr += Standard_CString(theHypName); + aStr += "\", \""; + aStr += Standard_CString(theLibName); + aStr += "\")"; + + AddToCurrentPyScript(aStr); + } + } + + return hyp._retn(); +} + +//============================================================================= +/*! + * SMESH_Gen_i::CreateMesh + * + * Create empty mesh on a shape and publish it in the study + */ +//============================================================================= + +SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObject ) + throw ( SALOME::SALOME_Exception ) +{ + 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 ) ) { + SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder(); + aStudyBuilder->NewCommand(); // There is a transaction + SALOMEDS::SObject_var aSO = PublishMesh( myCurrentStudy, mesh.in() ); + aStudyBuilder->CommitCommand(); + if ( !aSO->_is_nil() ) { + // Update Python script + TCollection_AsciiString aStr (aSO->GetID()); + aStr += " = smesh.CreateMesh("; + SMESH_Gen_i::AddObject(aStr, theShapeObject) += ")"; - TopoDS_Shape myLocShape = _ShapeReader->GetShape(geom,myShape); - meshServant->SetImpl(_impl.Init(studyId, myLocShape)); + AddToCurrentPyScript(aStr); } - catch (SALOME_Exception& S_ex) - { - THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); + } + + return mesh._retn(); +} + +//============================================================================= +/*! + * 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 ) +{ + 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 ) ) { + SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder(); + aStudyBuilder->NewCommand(); // There is a transaction + SALOMEDS::SObject_var aSO = PublishMesh( myCurrentStudy, aMesh.in(), aFileName.c_str() ); + aStudyBuilder->CommitCommand(); + if ( !aSO->_is_nil() ) { + // Update Python script + TCollection_AsciiString aStr (aSO->GetID()); + aStr += " = smesh.CreateMeshesFromUNV(\""; + aStr += Standard_CString(theFileName); + aStr += "\")"; + + AddToCurrentPyScript(aStr); } + } - // activate the CORBA servant of Mesh - - SMESH::SMESH_Mesh_var mesh - = SMESH::SMESH_Mesh::_narrow(meshServant->_this()); - - meshServant->SetIor(mesh); + SMESH_Mesh_i* aServant = dynamic_cast( GetServant( aMesh ).in() ); + ASSERT( aServant ); + aServant->ImportUNVFile( theFileName ); + return aMesh._retn(); +} + +//============================================================================= +/*! + * 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 ) +{ + Unexpect aCatch(SALOME_SalomeException); + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshFromMED" ); + + // Python Dump + TCollection_AsciiString aStr ("(["); + + // 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) { + SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder(); + aStudyBuilder->NewCommand(); // There is a transaction + 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++ ) { + // Python Dump + if (i > 0) aStr += ", "; + + // create mesh + SMESH::SMESH_Mesh_var mesh = createMesh(); + + // publish mesh in the study + SALOMEDS::SObject_var aSO; + if ( CanPublishInStudy( mesh ) ) + aSO = PublishMesh( myCurrentStudy, mesh.in(), (*it).c_str() ); + if ( !aSO->_is_nil() ) { + // Python Dump + aStr += aSO->GetID(); + } else { + // Python Dump + aStr += "mesh_"; + aStr += TCollection_AsciiString(i); + } - return SMESH::SMESH_Mesh::_duplicate(mesh); + // 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 ); + } + aStudyBuilder->CommitCommand(); + } + + // Update Python script + aStr += "], status) = smesh.CreateMeshesFromMED(\""; + aStr += Standard_CString(theFileName); + aStr += "\")"; + + AddToCurrentPyScript(aStr); + + return aResult._retn(); } - //============================================================================= /*! - * + * SMESH_Gen_i::CreateMeshFromSTL + * + * Create mesh and import data from STL file */ //============================================================================= -CORBA::Boolean SMESH_Gen_i::IsReadyToCompute(SMESH::SMESH_Mesh_ptr aMesh, - GEOM::GEOM_Shape_ptr aShape) - throw (SALOME::SALOME_Exception) +SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName ) + throw ( SALOME::SALOME_Exception ) { - MESSAGE("SMESH_Gen_i::IsReadyToCompute"); - return true; + 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 ) ) { + SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder(); + aStudyBuilder->NewCommand(); // There is a transaction + SALOMEDS::SObject_var aSO = PublishInStudy + ( myCurrentStudy, SALOMEDS::SObject::_nil(), aMesh.in(), aFileName.c_str() ); + aStudyBuilder->CommitCommand(); + if ( !aSO->_is_nil() ) { + // Update Python script + TCollection_AsciiString aStr (aSO->GetID()); + aStr += " = smesh.CreateMeshesFromSTL(\""; + aStr += Standard_CString(theFileName); + aStr += "\")"; + + AddToCurrentPyScript(aStr); + } + } + + SMESH_Mesh_i* aServant = dynamic_cast( GetServant( aMesh ).in() ); + ASSERT( aServant ); + aServant->ImportSTLFile( theFileName ); + return aMesh._retn(); } //============================================================================= /*! - * + * SMESH_Gen_i::IsReadyToCompute + * + * Returns true if mesh contains enough data to be computed + */ +//============================================================================= + +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; +} + +//============================================================================= +/*! + * SMESH_Gen_i::GetSubShapesId + * + * Get sub-shapes unique ID's list */ //============================================================================= - SMESH::long_array* - SMESH_Gen_i::GetSubShapesId(GEOM::GEOM_Gen_ptr geomEngine, - CORBA::Long studyId, - GEOM::GEOM_Shape_ptr mainShape, - const SMESH::shape_array& listOfSubShape) - throw (SALOME::SALOME_Exception) +SMESH::long_array* SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject, + const SMESH::object_array& theListOfSubShapeObject ) + throw ( SALOME::SALOME_Exception ) { - MESSAGE("SMESH_Gen_i::GetSubShapesId"); + Unexpect aCatch(SALOME_SalomeException); + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetSubShapesId" ); + SMESH::long_array_var shapesId = new SMESH::long_array; set setId; - GEOM::GEOM_Gen_var geom = GEOM::GEOM_Gen::_narrow(geomEngine); - GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(mainShape); - - if (CORBA::is_nil(geom)) - THROW_SALOME_CORBA_EXCEPTION("bad geom reference", \ - SALOME::BAD_PARAM); - if (CORBA::is_nil(myShape)) - THROW_SALOME_CORBA_EXCEPTION("bad shape reference", \ - SALOME::BAD_PARAM); + if ( CORBA::is_nil( theMainShapeObject ) ) + THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", + SALOME::BAD_PARAM ); try { - if (! _ShapeReader) _ShapeReader = new GEOM_Client(); - ASSERT(_ShapeReader); - TopoDS_Shape myMainShape = _ShapeReader->GetShape(geom,myShape); + TopoDS_Shape myMainShape = GeomObjectToShape(theMainShapeObject); TopTools_IndexedMapOfShape myIndexToShape; TopExp::MapShapes(myMainShape,myIndexToShape); - for (int i=0; iGetShape(geom,aShape); + 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)); - SCRUTE(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)); - SCRUTE(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)); - SCRUTE(myIndexToShape.FindIndex(V)); + if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(V)); } } shapesId->length(setId.size()); @@ -327,9 +786,9 @@ CORBA::Boolean SMESH_Gen_i::IsReadyToCompute(SMESH::SMESH_Mesh_ptr aMesh, int i=0; for (iind = setId.begin(); iind != setId.end(); iind++) { - SCRUTE((*iind)); + if(MYDEBUG) SCRUTE((*iind)); shapesId[i] = (*iind); - SCRUTE(shapesId[i]); + if(MYDEBUG) SCRUTE(shapesId[i]); i++; } } @@ -343,1398 +802,1790 @@ CORBA::Boolean SMESH_Gen_i::IsReadyToCompute(SMESH::SMESH_Mesh_ptr aMesh, //============================================================================= /*! - * + * SMESH_Gen_i::Compute + * + * Compute mesh on a shape */ //============================================================================= -CORBA::Boolean SMESH_Gen_i::Compute(SMESH::SMESH_Mesh_ptr aMesh, - GEOM::GEOM_Shape_ptr aShape) - throw (SALOME::SALOME_Exception) +CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh, + GEOM::GEOM_Object_ptr theShapeObject ) + throw ( SALOME::SALOME_Exception ) { - MESSAGE("SMESH_Gen_i::Compute"); - GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(aShape); - if (CORBA::is_nil(myShape)) - THROW_SALOME_CORBA_EXCEPTION("bad shape reference", \ - SALOME::BAD_PARAM); - - SMESH::SMESH_Mesh_var myMesh = SMESH::SMESH_Mesh::_narrow(aMesh); - if (CORBA::is_nil(myMesh)) - THROW_SALOME_CORBA_EXCEPTION("bad Mesh reference", \ - SALOME::BAD_PARAM); - - bool ret = false; - try - { - - // get study context from studyId given by CORBA mesh object - - int studyId = myMesh->GetStudyId(); - ASSERT(_mapStudyContext_i.find(studyId) != _mapStudyContext_i.end()); - StudyContext_iStruct* myStudyContext = _mapStudyContext_i[studyId]; - - // get local Mesh_i object with Id and study context - - int meshId = myMesh->GetId(); - ASSERT(myStudyContext->mapMesh_i.find(meshId) != myStudyContext->mapMesh_i.end()); - SMESH_Mesh_i* meshServant = myStudyContext->mapMesh_i[meshId]; - ASSERT(meshServant); - - // get local TopoDS_Shape - - GEOM::GEOM_Gen_var geom = meshServant->GetGeomEngine(); - TopoDS_Shape myLocShape = _ShapeReader->GetShape(geom,myShape); + Unexpect aCatch(SALOME_SalomeException); + if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Compute" ); - // implementation 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 ); + + // Update Python script + TCollection_AsciiString aStr ("isDone = smesh.Compute("); + SMESH_Gen_i::AddObject(aStr, theMesh) += ", "; + SMESH_Gen_i::AddObject(aStr, theShapeObject) += ")"; + + AddToCurrentPyScript(aStr); + + aStr = "if isDone == 0: print \"Mesh "; + SMESH_Gen_i::AddObject(aStr, theMesh) += " computation failed\""; + AddToCurrentPyScript(aStr); + + 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(); - 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 myGen.Compute( myLocMesh, myLocShape); } - - return ret; + } + catch ( SALOME_Exception& S_ex ) { + INFOS( "Compute(): catch exception "<< S_ex.what() ); + } + catch ( ... ) { + INFOS( "Compute(): unknown exception " ); + } + return false; } - //============================================================================= /*! - * + * SMESH_Gen_i::Save + * + * Save SMESH module's data */ //============================================================================= - -SALOMEDS::TMPFile* SMESH_Gen_i::Save(SALOMEDS::SComponent_ptr theComponent, - const char* theURL, - bool isMultiFile) +SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent, + const char* theURL, + bool isMultiFile ) { - MESSAGE("SMESH_Gen_i::SAVE"); - SALOMEDS::Study_var Study = theComponent->GetStudy(); - int studyId; + 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() ); + + // Store study contents as a set of python commands + SavePython(myCurrentStudy); + + StudyContext* myStudyContext = GetCurrentStudyContext(); // Declare a byte stream SALOMEDS::TMPFile_var aStreamFile; // Obtain a temporary dir - TCollection_AsciiString tmpDir = (isMultiFile)?TCollection_AsciiString((char*)theURL):SALOMEDS_Tool::GetTmpDir(); + 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); + aFileSeq->length( NUM_TMP_FILES ); - TCollection_AsciiString aStudyName(SALOMEDS_Tool::GetNameFromPath(theComponent->GetStudy()->URL())); + 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"); - 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()); + 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; - hypofile = tmpDir + hypofile; - algofile = tmpDir + algofile; meshfile = tmpDir + meshfile; - HDFfile * hdf_file; - map hdf_group, hdf_subgroup; - map hdf_dataset; - FILE* destFile; - - SALOMEDS::ChildIterator_var itBig,it,itSM; - SALOMEDS::SObject_var mySObject,myBranch,mySObjectChild; - hdf_size size[1]; - int longueur,cmpt_ds = 0,cmpt_it; - char *name_group,name_dataset[30],name_meshgroup[30]; - bool ok,_found; - int cmpt_sm = 0, myTag; - -//************* HDF file creation - hdf_file = new HDFfile(filename.ToCString()); - hdf_file->CreateOnDisk(); -//**************************** - - itBig = Study->NewChildIterator(theComponent); - for (; itBig->More();itBig->Next()) { + 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(); -//************branch 1 : hypothesis - if (gotBranch->Tag()==Tag_HypothesisRoot) { //hypothesis = tag 1 - - double length,maxElementsArea; - int numberOfSegments; - - destFile = fopen( hypofile.ToCString() ,"w"); - it = Study->NewChildIterator(gotBranch); - for (; it->More();it->Next()) { - mySObject = it->Value(); - SALOMEDS::GenericAttribute_var anAttr; - SALOMEDS::AttributeIOR_var anIOR; - if ( mySObject->FindAttribute(anAttr, "AttributeIOR")) { - anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); - - SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(anIOR->Value())); - fprintf(destFile,"%s\n",myHyp->GetName()); - - if (strcmp(myHyp->GetName(),"LocalLength")==0) { - SMESH::SMESH_LocalLength_var LL = SMESH::SMESH_LocalLength::_narrow( myHyp ); - length = LL->GetLength(); - fprintf(destFile,"%f\n",length); - } - else if (strcmp(myHyp->GetName(),"NumberOfSegments")==0) { - SMESH::SMESH_NumberOfSegments_var NOS = SMESH::SMESH_NumberOfSegments::_narrow( myHyp ); - numberOfSegments = NOS->GetNumberOfSegments(); - fprintf(destFile,"%d\n",numberOfSegments); - } - else if (strcmp(myHyp->GetName(),"MaxElementArea")==0) { - SMESH::SMESH_MaxElementArea_var MEA = SMESH::SMESH_MaxElementArea::_narrow( myHyp ); - maxElementsArea = MEA->GetMaxElementArea(); - fprintf(destFile,"%f\n",maxElementsArea); - } - } + // --> 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(); + } + } + } } - 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"); - + // close hypotheses root HDF group + aTopGroup->CloseOnDisk(); } -//************branch 2 : algorithms - else if (gotBranch->Tag()==Tag_AlgorithmsRoot) {//algos = tag 2 - - destFile = fopen( algofile.ToCString() ,"w"); - it = Study->NewChildIterator(gotBranch); - for (; it->More();it->Next()) { - mySObject = it->Value(); - SALOMEDS::GenericAttribute_var anAttr; - SALOMEDS::AttributeIOR_var anIOR; - if (mySObject->FindAttribute(anAttr, "AttributeIOR")) { - anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); - SMESH::SMESH_Algo_var myAlgo = SMESH::SMESH_Algo::_narrow(_orb->string_to_object(anIOR->Value())); - fprintf(destFile,"%s\n",myAlgo->GetName()); - } - } - - fclose(destFile); - -//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(); - Handle(SMESHDS_Mesh) mySMESHDSMesh = myLocMesh.GetMeshDS(); - - SCRUTE(mySMESHDSMesh->NbNodes()); - if (mySMESHDSMesh->NbNodes()>0) {//checks if the mesh is not empty - - DriverMED_W_SMESHDS_Mesh* myWriter = new DriverMED_W_SMESHDS_Mesh; - myWriter->SetFile(meshfile.ToCString()); - - myWriter->SetMesh(mySMESHDSMesh); - myWriter->SetMeshId(gotBranch->Tag()); - myWriter->Add(); - } - else meshfile = "No data"; - - //********** opening of the HDF group - sprintf(name_meshgroup,"Mesh %d",gotBranch->Tag()); - SCRUTE(name_meshgroup); - hdf_group[gotBranch->Tag()] = new HDFgroup(name_meshgroup,hdf_file); - hdf_group[gotBranch->Tag()]->CreateOnDisk(); - //********** - - //********** file where the data are stored - longueur = strlen(meshfile.ToCString()) +1; - size[0]=longueur; - strcpy(name_dataset,"Mesh data"); - hdf_dataset[cmpt_ds]=new HDFdataset(name_dataset,hdf_group[gotBranch->Tag()],HDF_STRING,size,1); - hdf_dataset[cmpt_ds]->CreateOnDisk(); - hdf_dataset[cmpt_ds]->WriteOnDisk(meshfile.ToCString()); - hdf_dataset[cmpt_ds]->CloseOnDisk(); - cmpt_ds++; - //********** - - //********** ref on shape - Standard_CString myRefOnObject="" ; - SALOMEDS::SObject_var myRef,myShape; - _found = gotBranch->FindSubObject(Tag_RefOnShape,myRef); - if (_found) { - ok = myRef->ReferencedObject(myShape); - myRefOnObject = myShape->GetID(); - SCRUTE(myRefOnObject); - - longueur = strlen(myRefOnObject) +1; - if (longueur>1) { - size[0]=longueur; - strcpy(name_dataset,"Ref on shape"); - hdf_dataset[cmpt_ds]=new HDFdataset(name_dataset,hdf_group[gotBranch->Tag()],HDF_STRING,size,1); - hdf_dataset[cmpt_ds]->CreateOnDisk(); - hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject); - hdf_dataset[cmpt_ds]->CloseOnDisk(); - cmpt_ds++; - - } - } - //********** - - //********** ref on applied hypothesis - _found = gotBranch->FindSubObject(Tag_RefOnAppliedHypothesis,myBranch); - if (_found) { - - strcpy(name_meshgroup,"Applied Hypothesis"); - hdf_subgroup[Tag_RefOnAppliedHypothesis] = new HDFgroup(name_meshgroup,hdf_group[gotBranch->Tag()]); - hdf_subgroup[Tag_RefOnAppliedHypothesis]->CreateOnDisk(); - - it = Study->NewChildIterator(myBranch); - cmpt_it = 0; - for (; it->More();it->Next()) { - mySObject = it->Value(); - ok = mySObject->ReferencedObject(myRef); - myRefOnObject = myRef->GetID(); - - longueur = strlen(myRefOnObject) +1; - if (longueur>1) { - size[0]=longueur; - sprintf(name_dataset,"Hyp %d",cmpt_it); - hdf_dataset[cmpt_ds]=new HDFdataset(name_dataset,hdf_subgroup[Tag_RefOnAppliedHypothesis],HDF_STRING,size,1); - hdf_dataset[cmpt_ds]->CreateOnDisk(); - hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject); - hdf_dataset[cmpt_ds]->CloseOnDisk(); + // --> 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(); } - 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(); + } + // 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"; } - 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(); + 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(); - itSM = Study->NewChildIterator(myBranch); - for (; itSM->More();itSM->Next()) {//Loop on all submeshes - mySObject = itSM->Value(); - cmpt_sm++; - myTag = 10+cmpt_sm; - mySObject->FindAttribute(anAttr, "AttributeIOR"); - anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); - SMESH::SMESH_subMesh_var mySubMesh = SMESH::SMESH_subMesh::_narrow(_orb->string_to_object(anIOR->Value())) ; - - //sprintf(name_meshgroup,"SubMesh %d",myTag); - sprintf(name_meshgroup,"SubMesh %d",mySubMesh->GetId()); - SCRUTE(name_meshgroup); - - hdf_subgroup[myTag] = new HDFgroup(name_meshgroup,hdf_subgroup[myLevel1Tag]); - hdf_subgroup[myTag]->CreateOnDisk(); - - //********** ref on shape - Standard_CString myRefOnObject="" ; - SALOMEDS::SObject_var myRef,myShape; - bool _found2; - _found2 = mySObject->FindSubObject(Tag_RefOnShape,myRef); - if (_found2) { - ok = myRef->ReferencedObject(myShape); - myRefOnObject = myShape->GetID(); - SCRUTE(myRefOnObject); - - longueur = strlen(myRefOnObject) +1; - if (longueur>1) { - size[0]=longueur; - strcpy(name_dataset,"Ref on shape"); - hdf_dataset[cmpt_ds]=new HDFdataset(name_dataset,hdf_subgroup[myTag],HDF_STRING,size,1); - hdf_dataset[cmpt_ds]->CreateOnDisk(); - hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject); - hdf_dataset[cmpt_ds]->CloseOnDisk(); - cmpt_ds++; + // 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(); } } - //********** - - //********** 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++; + } + + // 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(); + //} } - 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(); + aGroup->CloseOnDisk(); + } + + // write applied algorithms if exist + SALOMEDS::SObject_var myAlgoBranch; + found = gotBranch->FindSubObject( GetRefOnAppliedAlgorithmsTag(), myAlgoBranch ); + if ( found && !shapeRefFound ) { // remove applied algos + 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(); + //} + } + } + 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 hyp 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" ); - 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(); + // 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(); } - cmpt_ds++; - cmpt_it++; } - hdf_subgroup[10+cmpt_sm]->CloseOnDisk(); + // close container of submeshes by type HDF group + aGroup->CloseOnDisk(); } - //MESSAGE("end of algo applied"); - //********** - - hdf_subgroup[myTag]->CloseOnDisk(); } - - hdf_subgroup[myLevel1Tag]->CloseOnDisk(); + // All sub-meshes will be stored in MED file + if ( shapeRefFound ) + 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(); + + // maybe a shape was deleted in the study + if ( !shapeRefFound && !mySMESHDSMesh->ShapeToMesh().IsNull() ) { + TopoDS_Shape nullShape; + myLocMesh.ShapeToMesh( nullShape ); // remove shape referring data + } + + // 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(); } - } - //********** - - //********** closing of the HDF group - hdf_group[gotBranch->Tag()]->CloseOnDisk(); - MESSAGE("End of Mesh Save"); - //********** - } + } } - MESSAGE("End of Meshes Save"); } - hdf_file->CloseOnDisk(); - delete hdf_file; - hdf_file = 0; + // close HDF file + aFile->CloseOnDisk(); + delete aFile; // Convert temporary files to stream - aStreamFile = SALOMEDS_Tool::PutFilesToStream(tmpDir.ToCString(), aFileSeq.in(), isMultiFile); + aStreamFile = SALOMEDS_Tool::PutFilesToStream( tmpDir.ToCString(), aFileSeq.in(), isMultiFile ); // Remove temporary files and directory - if (isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(tmpDir.ToCString(), aFileSeq.in(), true); - - MESSAGE("End SMESH_Gen_i::Save"); + if ( !isMultiFile ) + SALOMEDS_Tool::RemoveTemporaryFiles( tmpDir.ToCString(), aFileSeq.in(), true ); + INFOS( "SMESH_Gen_i::Save() completed" ); return aStreamFile._retn(); } -SALOMEDS::TMPFile* SMESH_Gen_i::SaveASCII(SALOMEDS::SComponent_ptr theComponent, - const char* theURL, - bool isMultiFile) { - SALOMEDS::TMPFile_var aStreamFile = Save(theComponent, theURL, isMultiFile); +//============================================================================= +/*! + * SMESH_Gen_i::SaveASCII + * + * Save SMESH module's data in ASCII format (not implemented yet) + */ +//============================================================================= + +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(); } //============================================================================= /*! - * + * SMESH_Gen_i::loadGeomData + * + * Load GEOM module data */ //============================================================================= -bool SMESH_Gen_i::Load(SALOMEDS::SComponent_ptr theComponent, - const SALOMEDS::TMPFile& theStream, - const char* theURL, - bool isMultiFile) +void SMESH_Gen_i::loadGeomData( SALOMEDS::SComponent_ptr theCompRoot ) { - MESSAGE("SMESH_Gen_i::Load\n"); + if ( theCompRoot->_is_nil() ) + return; + + SALOMEDS::Study_var aStudy = SALOMEDS::Study::_narrow( theCompRoot->GetStudy() ); + if ( aStudy->_is_nil() ) + return; + + SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder(); + aStudyBuilder->LoadWith( theCompRoot, GetGeomEngine() ); +} +//============================================================================= +/*! + * SMESH_Gen_i::Load + * + * Load SMESH module's data + */ +//============================================================================= + +bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent, + const SALOMEDS::TMPFile& theStream, + const char* theURL, + bool isMultiFile ) +{ + 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):SALOMEDS_Tool::GetTmpDir(); + 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); + 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 + aFileSeq[0];//"SMESH.hdf"; - TCollection_AsciiString hypofile = tmpDir + aFileSeq[1];//"SMESH_Hypo.txt"; - TCollection_AsciiString algofile = tmpDir + aFileSeq[2];//"SMESH_Algo.txt"; - TCollection_AsciiString meshfile = tmpDir + aFileSeq[3];//"SMESH_Mesh.med"; - - SALOMEDS::Study_var Study = theComponent->GetStudy(); - int studyId = Study->StudyId(); - SCRUTE(studyId); - - SALOMEDS::GenericAttribute_var anAttr; - SALOMEDS::AttributeName_var aName; - SALOMEDS::AttributeIOR_var anIOR; - - SALOMEDS::SComponent_var fathergeom = Study->FindComponent("GEOM"); - SALOMEDS::SComponent_var myGeomSComp = SALOMEDS::SComponent::_narrow( fathergeom ); - SCRUTE(fathergeom); - - //to get the geom engine !!! - //useful to define our new mesh - SALOME_NamingService* _NS = SINGLETON_::Instance() ; - ASSERT(SINGLETON_::IsAlreadyExisting()) ; - _NS->init_orb( _orb ) ; - SALOME_LifeCycleCORBA* myEnginesLifeCycle = new SALOME_LifeCycleCORBA(_NS); - Engines::Component_var geomEngine = - myEnginesLifeCycle->FindOrLoad_Component("FactoryServer","GEOM"); - GEOM::GEOM_Gen_var myGeomEngine = GEOM::GEOM_Gen::_narrow(geomEngine); - - - char* aLine; - bool ok; - char objectId[10],name_dataset[10]; - int nb_datasets,size,cmpt_ds=0; - int cmpt_sm = 0; - - char name[HDF_NAME_MAX_LEN+1]; - char sgname[HDF_NAME_MAX_LEN+1]; - char msgname[HDF_NAME_MAX_LEN+1]; - char name_of_group[HDF_NAME_MAX_LEN+1]; - char *name_meshgroup; - map hdf_group, hdf_subgroup; - map hdf_dataset; - FILE *loadedFile; - - //************* HDF file opening - HDFfile * hdf_file = new HDFfile(filename.ToCString()); + 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 { - hdf_file->OpenOnDisk(HDF_RDONLY); + aFile->OpenOnDisk( HDF_RDONLY ); } - catch (HDFexception) { - MESSAGE("Load(): " << filename << " not found!"); + 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" ); + } - int nb_group = hdf_file->nInternalObjects(); - SCRUTE(nb_group); - for (int i=0;iInternalObjectIndentify(i,name); - //SCRUTE(name); - -//*************** -// Loading of the Hypothesis Branch -//*************** - if (strcmp(name,"Hypothesis")==0) { - - double length,maxElementsArea; - int numberOfSegments; - - hdf_group[Tag_HypothesisRoot] = new HDFgroup(name,hdf_file); - hdf_group[Tag_HypothesisRoot]->OpenOnDisk(); - - hdf_group[Tag_HypothesisRoot]->InternalObjectIndentify(0,name_of_group); - hdf_dataset[cmpt_ds]=new HDFdataset(name_of_group,hdf_group[Tag_HypothesisRoot]); - hdf_dataset[cmpt_ds]->OpenOnDisk(); - size=hdf_dataset[cmpt_ds]->GetSize(); - - char * name_of_file =new char[size]; - hdf_dataset[cmpt_ds]->ReadFromDisk(name_of_file); - SCRUTE(name_of_file); - hdf_dataset[cmpt_ds]->CloseOnDisk(); - hdf_group[Tag_HypothesisRoot]->CloseOnDisk(); - cmpt_ds++; - delete[] name_of_file; - name_of_file = 0; - - aLine = new char[100]; - loadedFile = fopen( hypofile.ToCString() ,"r"); - while (!feof(loadedFile)) { - fscanf(loadedFile,"%s",aLine); - //SCRUTE(aLine); - if (strcmp(aLine,"LocalLength")==0) { - SMESH::SMESH_Hypothesis_var myHyp = this->CreateHypothesis(aLine,studyId); - SMESH::SMESH_LocalLength_var LL = SMESH::SMESH_LocalLength::_narrow( myHyp ); - fscanf(loadedFile,"%s",aLine); - length = atof(aLine); - LL->SetLength(length); - string iorString = _orb->object_to_string(LL); - sprintf(objectId,"%d",LL->GetId()); - _SMESHCorbaObj[string("Hypo_")+string(objectId)] = iorString; - } - else if (strcmp(aLine,"NumberOfSegments")==0) { - SMESH::SMESH_Hypothesis_var myHyp = this->CreateHypothesis(aLine,studyId); - SMESH::SMESH_NumberOfSegments_var NOS = SMESH::SMESH_NumberOfSegments::_narrow( myHyp ); - fscanf(loadedFile,"%s",aLine); - numberOfSegments = atoi(aLine); - NOS->SetNumberOfSegments(numberOfSegments); - string iorString = _orb->object_to_string(NOS); - sprintf(objectId,"%d",NOS->GetId()); - _SMESHCorbaObj[string("Hypo_")+string(objectId)] = iorString; - } - else if (strcmp(aLine,"MaxElementArea")==0) { - SMESH::SMESH_Hypothesis_var myHyp = this->CreateHypothesis(aLine,studyId); - SMESH::SMESH_MaxElementArea_var MEA = SMESH::SMESH_MaxElementArea::_narrow( myHyp ); - fscanf(loadedFile,"%s",aLine); - maxElementsArea = atof(aLine); - MEA->SetMaxElementArea(maxElementsArea); - string iorString = _orb->object_to_string(MEA); - sprintf(objectId,"%d",MEA->GetId()); - _SMESHCorbaObj[string("Hypo_")+string(objectId)] = iorString; + 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" ); } - - } - fclose(loadedFile); - delete[] aLine; - aLine = 0; - MESSAGE("End of Hypos Load"); - } -//*************** -// Loading of the Algorithms Branch -//*************** - else if (strcmp(name,"Algorithms")==0) { - - hdf_group[Tag_AlgorithmsRoot] = new HDFgroup(name,hdf_file); - hdf_group[Tag_AlgorithmsRoot]->OpenOnDisk(); - - hdf_group[Tag_AlgorithmsRoot]->InternalObjectIndentify(0,name_of_group); - hdf_dataset[cmpt_ds] = new HDFdataset(name_of_group,hdf_group[Tag_AlgorithmsRoot]); - hdf_dataset[cmpt_ds]->OpenOnDisk(); - size=hdf_dataset[cmpt_ds]->GetSize(); - - char * name_of_file =new char[size]; - hdf_dataset[cmpt_ds]->ReadFromDisk(name_of_file); - hdf_dataset[cmpt_ds]->CloseOnDisk(); - hdf_group[Tag_AlgorithmsRoot]->CloseOnDisk(); - cmpt_ds++; - delete[] name_of_file; - name_of_file = 0; - - aLine = new char[100]; - loadedFile = fopen( algofile.ToCString(),"r"); - while (!feof(loadedFile)) { - fscanf(loadedFile,"%s\n",aLine); - //SCRUTE(aLine); - if (strcmp(aLine,"")!=0) { - SMESH::SMESH_Hypothesis_var myHyp = this->CreateHypothesis(aLine,studyId); - SMESH::SMESH_Algo_var myAlgo = SMESH::SMESH_Algo::_narrow(myHyp); - string iorString = _orb->object_to_string(myAlgo); - sprintf(objectId,"%d",myAlgo->GetId()); - _SMESHCorbaObj[string("Hypo_")+string(objectId)] = iorString; + // 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" ); } } - fclose(loadedFile); - delete[] aLine; - aLine = 0; - MESSAGE("End of Algos Load"); - } + // close algorithms root HDF group + aTopGroup->CloseOnDisk(); + } -//*************** -// Loading of the Mesh Branch -//*************** - else if (string(name).substr(0,4)==string("Mesh")) { - MESSAGE("in mesh load"); - - Standard_Integer myMeshId = atoi((string(name).substr(5,5)).c_str()); - SCRUTE(myMeshId); - - hdf_group[myMeshId] = new HDFgroup(name,hdf_file); - hdf_group[myMeshId]->OpenOnDisk(); + // --> 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; + } + } - int nb_meshsubgroup = hdf_group[myMeshId]->nInternalObjects(); - SCRUTE(nb_meshsubgroup); - - //********** Loading of the file name where the data are stored - MESSAGE("Mesh data file"); - strcpy(name_of_group,"Mesh data"); - hdf_dataset[cmpt_ds]=new HDFdataset(name_of_group,hdf_group[myMeshId]); - hdf_dataset[cmpt_ds]->OpenOnDisk(); - size=hdf_dataset[cmpt_ds]->GetSize(); - - char * datafilename =new char[size]; - hdf_dataset[cmpt_ds]->ReadFromDisk(datafilename); - hdf_dataset[cmpt_ds]->CloseOnDisk(); - cmpt_ds++; - - //********** - //} - //else if (strcmp(msgname,"Ref on shape")==0) { - - //********** Loading of the reference on the shape - //********** and mesh initialization - MESSAGE("Ref on shape"); - strcpy(name_of_group,"Ref on shape"); - hdf_dataset[cmpt_ds] = new HDFdataset(name_of_group,hdf_group[myMeshId]); - hdf_dataset[cmpt_ds]->OpenOnDisk(); - size=hdf_dataset[cmpt_ds]->GetSize(); - - char * refFromFile =new char[size]; - hdf_dataset[cmpt_ds]->ReadFromDisk(refFromFile); - hdf_dataset[cmpt_ds]->CloseOnDisk(); - cmpt_ds++; - - Standard_CString myRefOnShape=""; //look for ref on shape - - bool _found = false; - SALOMEDS::SObject_var CSO = Study->FindObjectID(refFromFile); - SMESH::SMESH_Mesh_var myNewMesh; - GEOM::GEOM_Shape_var aShape; - - if (!CORBA::is_nil(CSO)) { - _found = true; - CSO->FindAttribute(anAttr, "AttributeIOR"); - anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); - char* ShapeIOR = anIOR->Value(); - aShape = GEOM::GEOM_Shape::_narrow(_orb->string_to_object(ShapeIOR)); - - myNewMesh = this->Init(myGeomEngine,studyId,aShape); - string iorString = _orb->object_to_string(myNewMesh); - sprintf(objectId,"%d",myNewMesh->GetId()); - _SMESHCorbaObj[string("Mesh_")+string(objectId)] = iorString; - - //********** - //********** Loading of mesh data - if (strcmp(datafilename,"No data")!=0) { - - med_idt fid; - int ret; - - //**************************************************************************** - //* OUVERTURE DU FICHIER EN LECTURE * - //**************************************************************************** - - fid = MEDouvrir(datafilename,MED_LECT); - if (fid < 0) - { - printf(">> ERREUR : ouverture du fichier %s \n",datafilename); - exit(EXIT_FAILURE); + // 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 ); } - else { - - StudyContext_iStruct* myStudyContext = _mapStudyContext_i[studyId]; - int meshId = myNewMesh->GetId(); - SMESH_Mesh_i* meshServant = myStudyContext->mapMesh_i[meshId]; - ::SMESH_Mesh& myLocMesh = meshServant->GetImpl(); - Handle(SMESHDS_Mesh) mySMESHDSMesh = myLocMesh.GetMeshDS(); - - DriverMED_R_SMESHDS_Mesh* myReader = new DriverMED_R_SMESHDS_Mesh; - - myReader->SetMesh(mySMESHDSMesh); - myReader->SetMeshId(myMeshId); - myReader->SetFileId(fid); - myReader->ReadMySelf(); - //SCRUTE(mySMESHDSMesh->NbNodes()); - //myNewMesh->ExportUNV("/tmp/test.unv");//only to check out - - //**************************************************************************** - //* FERMETURE DU FICHIER * - //**************************************************************************** - ret = MEDfermer(fid); - - if (ret != 0) - printf(">> ERREUR : erreur a la fermeture du fichier %s\n",datafilename); - } } - } - //********** - //} - //else if (strcmp(msgname,"Applied Hypothesis")==0) { - for (int ii=0;iiInternalObjectIndentify(ii,msgname); - if (strcmp(msgname,"Mesh data")==0) { - //nothing - } - else if (strcmp(msgname,"Ref on shape")==0) { - //nothing - } - else if (strcmp(msgname,"Applied Hypothesis")==0) { - //********** Loading of the applied hypothesis - strcpy(name_of_group,"Applied Hypothesis"); - hdf_subgroup[Tag_RefOnAppliedHypothesis] = new HDFgroup(name_of_group,hdf_group[myMeshId]); - hdf_subgroup[Tag_RefOnAppliedHypothesis]->OpenOnDisk(); - - nb_datasets = hdf_subgroup[Tag_RefOnAppliedHypothesis]->nInternalObjects(); - SCRUTE(nb_datasets); - - for (int j=0;jOpenOnDisk(); - size=hdf_dataset[cmpt_ds]->GetSize(); + + // 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 - char * refFromFile =new char[size]; - hdf_dataset[cmpt_ds]->ReadFromDisk(refFromFile); - //SCRUTE(refFromFile); - hdf_dataset[cmpt_ds]->CloseOnDisk(); - cmpt_ds++; - if (_found) { - SALOMEDS::SObject_var HypSO = Study->FindObjectID(refFromFile); - if (!CORBA::is_nil(HypSO)) { - HypSO->FindAttribute(anAttr, "AttributeIOR"); - anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); - if (!CORBA::is_nil(anIOR)) { - char* HypIOR = anIOR->Value(); - SMESH::SMESH_Hypothesis_var anHyp = SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(HypIOR)); - if (!CORBA::is_nil(anHyp)) { - myNewMesh->AddHypothesis(aShape,anHyp); - MESSAGE("Hypothesis added ..."); - } - } + //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 ); } } - } - - hdf_subgroup[Tag_RefOnAppliedHypothesis]->CloseOnDisk(); - //********** + } } - else if (strcmp(msgname,"Applied Algorithms")==0) { + aGroup->CloseOnDisk(); + } - //********** Loading of the applied algorithms - strcpy(name_of_group,"Applied Algorithms"); - hdf_subgroup[Tag_RefOnAppliedAlgorithms] = new HDFgroup(name_of_group,hdf_group[myMeshId]); - hdf_subgroup[Tag_RefOnAppliedAlgorithms]->OpenOnDisk(); - - nb_datasets = hdf_subgroup[Tag_RefOnAppliedAlgorithms]->nInternalObjects(); - SCRUTE(nb_datasets); - - for (int j=0;jOpenOnDisk(); - size=hdf_dataset[cmpt_ds]->GetSize(); - - char * refFromFile =new char[size]; - hdf_dataset[cmpt_ds]->ReadFromDisk(refFromFile); - hdf_dataset[cmpt_ds]->CloseOnDisk(); - cmpt_ds++; + // 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 - if (_found) { - SALOMEDS::SObject_var AlgoSO = Study->FindObjectID(refFromFile); - if (!CORBA::is_nil(AlgoSO)) { - AlgoSO->FindAttribute(anAttr, "AttributeIOR"); - anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); - if (!CORBA::is_nil(anIOR)) { - char* AlgoIOR = anIOR->Value(); - //SCRUTE(AlgoIOR); - SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(AlgoIOR)); - SMESH::SMESH_Algo_var anAlgo = SMESH::SMESH_Algo::_narrow(myHyp); - //SMESH::SMESH_Algo_var anAlgo = SMESH::SMESH_Algo::_narrow(_orb->string_to_object(AlgoIOR)); - if (!CORBA::is_nil(anAlgo)) { - myNewMesh->AddHypothesis(aShape,anAlgo);//essayer avec _SMESHCorbaObj - MESSAGE("Algorithms added ..."); - } - } + //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 ); } } - } - - hdf_subgroup[Tag_RefOnAppliedAlgorithms]->CloseOnDisk(); - - //********** + } } - else if (string(msgname).substr(0,9)==string("SubMeshes")) { - + 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(); - //********** Loading of the submeshes on subshapes - int myLevel1Tag, myTag; - SCRUTE(msgname); - cmpt_sm++; - myLevel1Tag = 10+cmpt_sm; - hdf_subgroup[myLevel1Tag] = new HDFgroup(name_of_group,hdf_group[myMeshId]); - hdf_subgroup[myLevel1Tag] = new HDFgroup(msgname,hdf_group[myMeshId]); - hdf_subgroup[myLevel1Tag]->OpenOnDisk(); - - int nb_submeshes = hdf_subgroup[myLevel1Tag]->nInternalObjects(); - SCRUTE(nb_submeshes); - - for (int j=0;jInternalObjectIndentify(j,name_meshgroup); - SCRUTE(name_meshgroup); - - hdf_subgroup[myTag] = new HDFgroup(name_meshgroup,hdf_subgroup[myLevel1Tag]); - hdf_subgroup[myTag]->OpenOnDisk(); - int subMeshId = atoi((string(name_meshgroup).substr(8,18)).c_str()); - - MESSAGE("Ref on shape"); - //********** ref on shape - sprintf(name_dataset,"Ref on shape"); - hdf_dataset[cmpt_ds] = new HDFdataset(name_dataset,hdf_subgroup[myTag]); - hdf_dataset[cmpt_ds]->OpenOnDisk(); - size=hdf_dataset[cmpt_ds]->GetSize(); - - char * refFromFile =new char[size]; - hdf_dataset[cmpt_ds]->ReadFromDisk(refFromFile); - hdf_dataset[cmpt_ds]->CloseOnDisk(); - cmpt_ds++; - - bool _found3 = false; - SALOMEDS::SObject_var GSO = Study->FindObjectID(refFromFile); - SMESH::SMESH_subMesh_var aSubMesh; - GEOM::GEOM_Shape_var aSubShape; - - if (!CORBA::is_nil(GSO)) { - GSO->FindAttribute(anAttr, "AttributeIOR"); - anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); - char* SubShapeIOR = anIOR->Value(); - aSubShape = GEOM::GEOM_Shape::_narrow(_orb->string_to_object(SubShapeIOR)); + // 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(); - if (!CORBA::is_nil(aSubShape)) { - aSubMesh = myNewMesh->GetElementsOnShape(aSubShape); - string iorString = _orb->object_to_string(aSubMesh); - sprintf(objectId,"%d",subMeshId); - _SMESHCorbaObj[string("SubMesh_")+string(objectId)] = iorString; - _found3 = true; - //SCRUTE(aSubMesh->GetNumberOfNodes()); - //MESSAGE("yes"); - //SCRUTE(aSubMesh->GetNumberOfElements()); + // 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 ); +// } - int nb_subgroup = hdf_subgroup[myTag]->nInternalObjects(); - SCRUTE(nb_subgroup); - for (int k=0;kInternalObjectIndentify(k,sgname); - if (strcmp(sgname,"Ref on shape")==0) { - //nothing - } - else if (strcmp(sgname,"Applied Hypothesis")==0) { - //********** ref on applied hypothesis - MESSAGE("Applied Hypothesis"); - strcpy(name_meshgroup,"Applied Hypothesis"); - cmpt_sm++; - hdf_subgroup[10+cmpt_sm] = new HDFgroup(name_meshgroup,hdf_subgroup[myTag]); - hdf_subgroup[10+cmpt_sm]->OpenOnDisk(); - nb_datasets = hdf_subgroup[10+cmpt_sm]->nInternalObjects(); - SCRUTE(nb_datasets); - - for (int l=0;lOpenOnDisk(); - size=hdf_dataset[cmpt_ds]->GetSize(); - - char * refFromFile =new char[size]; - hdf_dataset[cmpt_ds]->ReadFromDisk(refFromFile); - hdf_dataset[cmpt_ds]->CloseOnDisk(); - cmpt_ds++; - - if (_found3) { - SALOMEDS::SObject_var HypSO = Study->FindObjectID(refFromFile); - if (!CORBA::is_nil(HypSO)) { - HypSO->FindAttribute(anAttr, "AttributeIOR"); - anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); - if (!CORBA::is_nil(anIOR)) { - char* HypIOR = anIOR->Value(); - SMESH::SMESH_Hypothesis_var anHyp = SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(HypIOR)); - if (!CORBA::is_nil(anHyp)) { - SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather(); - aMesh->AddHypothesis(aSubShape,anHyp);//essayer avec _SMESHCorbaObj - MESSAGE("Hypothesis added ..."); - } - } + // 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 ); } } - } + } } - else if (strcmp(sgname,"Applied Algorithms")==0) { - //********** ref on applied algorithms - MESSAGE("Applied Algorithms"); - strcpy(name_meshgroup,"Applied Algorithms"); - cmpt_sm++; - hdf_subgroup[10+cmpt_sm] = new HDFgroup(name_meshgroup,hdf_subgroup[myTag]); - hdf_subgroup[10+cmpt_sm]->OpenOnDisk(); - nb_datasets = hdf_subgroup[10+cmpt_sm]->nInternalObjects(); - SCRUTE(nb_datasets); - - for (int l=0;lOpenOnDisk(); - size=hdf_dataset[cmpt_ds]->GetSize(); - - char * refFromFile =new char[size]; - hdf_dataset[cmpt_ds]->ReadFromDisk(refFromFile); - hdf_dataset[cmpt_ds]->CloseOnDisk(); - cmpt_ds++; + // close "applied algorithms" HDF group + aSubSubGroup->CloseOnDisk(); + } + + // 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(); - if (_found3) { - SALOMEDS::SObject_var AlgoSO = Study->FindObjectID(refFromFile); - if (!CORBA::is_nil(AlgoSO)) { - AlgoSO->FindAttribute(anAttr, "AttributeIOR"); - anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); - if (!CORBA::is_nil(anIOR)) { - char* AlgoIOR = anIOR->Value(); - //SCRUTE(AlgoIOR); - SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(AlgoIOR)); - SMESH::SMESH_Algo_var anAlgo = SMESH::SMESH_Algo::_narrow(myHyp); - //SMESH::SMESH_Algo_var anAlgo = SMESH::SMESH_Algo::_narrow(_orb->string_to_object(AlgoIOR)); - if (!CORBA::is_nil(anAlgo)) { - SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather(); - aMesh->AddHypothesis(aSubShape,anAlgo);//essayer avec _SMESHCorbaObj - MESSAGE("Algorithms added ..."); - } - } + //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(); } - hdf_subgroup[myTag]->CloseOnDisk(); + + // close submesh HDF group + aSubGroup->CloseOnDisk(); + } + } + // close submeshes containers HDF group + aGroup->CloseOnDisk(); + } + } + + if(hasData) { + // Read sub-meshes from MED + if(MYDEBUG) MESSAGE("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 aSize = aDataset->GetSize(); + + // for reading files, created from 18.07.2005 till 10.10.2005 + if (aDataset->GetType() == HDF_STRING) + aSize /= sizeof(int); + + int* ids = new int [aSize]; + aDataset->ReadFromDisk( ids ); + // on face or nodes? + if ( strncmp( aDSName, aEid_DSName, strlen( aEid_DSName )) == 0 ) { + aEids = ids; + nbEids = aSize; + } + else { + aFids = ids; + nbFids = aSize; + } + } + } // 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("Compute State Engine ..."); + TopoDS_Shape myLocShape = GeomObjectToShape( aShapeObject ); + myNewMeshImpl->GetImpl().GetSubMesh(myLocShape)->ComputeStateEngine + (SMESH_subMesh::SUBMESH_RESTORED); + MESSAGE("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 ); + } } - hdf_subgroup[myLevel1Tag]->CloseOnDisk(); + aGroup->CloseOnDisk(); } } - hdf_group[myMeshId]->CloseOnDisk(); - - MESSAGE("End of Meshes Load"); + } + // close mesh group + aTopGroup->CloseOnDisk(); } } - - MESSAGE("End of SMESH_Gen::Load"); - - hdf_file->CloseOnDisk(); - delete hdf_file; - hdf_file=0; + } + // close HDF file + aFile->CloseOnDisk(); + delete aFile; // Remove temporary files created from the stream - if (isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(tmpDir.ToCString(), aFileSeq.in(), true); + if ( !isMultiFile ) + SALOMEDS_Tool::RemoveTemporaryFiles( tmpDir.ToCString(), aFileSeq.in(), true ); + INFOS( "SMESH_Gen_i::Load completed" ); return true; } -bool SMESH_Gen_i::LoadASCII(SALOMEDS::SComponent_ptr theComponent, - const SALOMEDS::TMPFile& theStream, - const char* theURL, - bool isMultiFile) { - return Load(theComponent, theStream, theURL, isMultiFile); +//============================================================================= +/*! + * SMESH_Gen_i::LoadASCII + * + * Load SMESH module's data in ASCII format (not implemented yet) + */ +//============================================================================= + +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 */ //============================================================================= -void SMESH_Gen_i::Close(SALOMEDS::SComponent_ptr theComponent) +void SMESH_Gen_i::Close( SALOMEDS::SComponent_ptr theComponent ) { - MESSAGE("Close"); - SALOMEDS::Study_var aStudy = theComponent->GetStudy(); - SALOMEDS::ChildIterator_var itBig = aStudy->NewChildIterator(theComponent); - for (; itBig->More();itBig->Next()) { - SALOMEDS::SObject_var gotBranch = itBig->Value(); - - // branch 1 : hypothesis - if (gotBranch->Tag()==Tag_HypothesisRoot || gotBranch->Tag()==Tag_AlgorithmsRoot) { - SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(gotBranch); - for (; it->More();it->Next()) { - SALOMEDS::SObject_var mySObject = it->Value(); - SALOMEDS::GenericAttribute_var anAttr; - SALOMEDS::AttributeIOR_var anIOR; - if ( mySObject->FindAttribute(anAttr, "AttributeIOR")) { - anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); - SMESH::SMESH_Hypothesis_var myHyp = - SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(anIOR->Value())); - char objectId[10]; - sprintf(objectId,"%d",myHyp->GetId()); -// cout<<"********** delete Hyp "<string_to_object(anIOR->Value())); - } - } - } - // branch 2 : algorithms - else if (gotBranch->Tag()>=3) { - SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(gotBranch); - for (; it->More();it->Next()) { - SALOMEDS::SObject_var mySObject = it->Value(); - SALOMEDS::GenericAttribute_var anAttr; - SALOMEDS::AttributeIOR_var anIOR; - if ( mySObject->FindAttribute(anAttr, "AttributeIOR")) { - anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr); - SMESH::SMESH_Mesh_var myMesh = - SMESH::SMESH_Mesh::_narrow(_orb->string_to_object(anIOR->Value())); - if (!myMesh->_is_nil()) { - char objectId[10]; - sprintf(objectId,"%d",myMesh->GetId()); -// cout<<"********** delete Mesh "<string_to_object(anIOR->Value())); - if (!mySubMesh->_is_nil()) { - char objectId[10]; - sprintf(objectId,"%d",mySubMesh->GetId()); -// cout<<"********** delete SubMesh "<string_to_object(IORString)); - if (! CORBA::is_nil(myAlgo)) - { - string prefix = "Hypo_"; - sprintf(objectId,"%d",myAlgo->GetId()); - string lpID = prefix + string(objectId); - return CORBA::string_dup(lpID.c_str()); - } - else { - SMESH::SMESH_Hypothesis_var myHypo = SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(IORString)); - if (! CORBA::is_nil(myHypo)) - { - string prefix = "Hypo_"; - sprintf(objectId,"%d",myHypo->GetId()); - string lpID = prefix + string(objectId); - return CORBA::string_dup(lpID.c_str()); - } - else { - SMESH::SMESH_Mesh_var myMesh = SMESH::SMESH_Mesh::_narrow(_orb->string_to_object(IORString)); - if (! CORBA::is_nil(myMesh)) - { - string prefix = "Mesh_"; - sprintf(objectId,"%d",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,"%d",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::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( "" ); } //============================================================================= /*! - * + * SMESH_Gen_i::LocalPersistentIDToIOR + * + * Transform data from persistent form to transient */ //============================================================================= -char* SMESH_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject, - const char* aLocalPersistentID, - CORBA::Boolean isMultiFile, - CORBA::Boolean isASCII) +char* SMESH_Gen_i::LocalPersistentIDToIOR( SALOMEDS::SObject_ptr /*theSObject*/, + const char* aLocalPersistentID, + CORBA::Boolean /*isMultiFile*/, + CORBA::Boolean /*isASCII*/ ) { - MESSAGE("SMESH_Gen_i::LocalPersistentIDToIOR"); - SCRUTE(aLocalPersistentID); - string clef = string(aLocalPersistentID); - SCRUTE(_SMESHCorbaObj[clef].c_str()); - return CORBA::string_dup(_SMESHCorbaObj[clef].c_str()); + 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( "" ); } -//============================================================================= -/*! - * - */ -//============================================================================= +//======================================================================= +//function : RegisterObject +//purpose : +//======================================================================= -SMESH_topo* SMESH_Gen_i::ExploreMainShape(GEOM::GEOM_Gen_ptr geomEngine, - CORBA::Long studyId, - GEOM::GEOM_Shape_ptr aShape) +int SMESH_Gen_i::RegisterObject(CORBA::Object_ptr theObject) { - 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; + 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) + 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() ; + 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() ; } }