#include <SMESH_Gen_i.hxx>
Inheritance diagram for SMESH_Gen_i:
Public Member Functions | |
| GEOM::GEOM_Object_ptr | ShapeToGeomObject (const TopoDS_Shape &theShape) |
| TopoDS_Shape | GeomObjectToShape (GEOM::GEOM_Object_ptr theGeomObject) |
| SMESH_Gen_i () | |
| SMESH_Gen_i.SMESH_Gen_i. | |
| SMESH_Gen_i (CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, PortableServer::ObjectId *contId, const char *instanceName, const char *interfaceName) | |
| SMESH_Gen_i.SMESH_Gen_i. | |
| virtual | ~SMESH_Gen_i () |
| SMESH_Gen_i.~SMESH_Gen_i. | |
| void | SetName (const char *theIOR, const char *theName) |
| SMESH_Gen_i.SetName. | |
| void | SetGeomEngine (GEOM::GEOM_Gen_ptr geomcompo) |
| SMESH_Gen_i.SetGeomEngine. | |
| void | SetEmbeddedMode (CORBA::Boolean theMode) |
| SMESH_Gen_i.SetEmbeddedMode. | |
| CORBA::Boolean | IsEmbeddedMode () |
| SMESH_Gen_i.IsEmbeddedMode. | |
| void | SetCurrentStudy (SALOMEDS::Study_ptr theStudy) |
| SMESH_Gen_i.SetCurrentStudy. | |
| SALOMEDS::Study_ptr | GetCurrentStudy () |
| SMESH_Gen_i.GetCurrentStudy. | |
| SMESH::SMESH_Hypothesis_ptr | CreateHypothesis (const char *theHypType, const char *theLibName) throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.CreateHypothesis. | |
| SMESH::SMESH_Hypothesis_ptr | GetHypothesisParameterValues (const char *theHypType, const char *theLibName, SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr theGeom, CORBA::Boolean byMesh) throw ( SALOME::SALOME_Exception ) |
| Return a hypothesis holding parameter values corresponding either to the mesh existing on the given geometry or to size of the geometry. | |
| void | SetBoundaryBoxSegmentation (CORBA::Long theNbSegments) throw ( SALOME::SALOME_Exception ) |
| Sets number of segments per diagonal of boundary box of geometry by which default segment length of appropriate 1D hypotheses is defined. | |
| void | SetDefaultNbSegments (CORBA::Long theNbSegments) throw ( SALOME::SALOME_Exception ) |
| Sets default number of segments per edge. | |
| SMESH::SMESH_Mesh_ptr | CreateMesh (GEOM::GEOM_Object_ptr theShapeObject) throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.CreateMesh. | |
| SMESH::SMESH_Mesh_ptr | CreateEmptyMesh () throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.CreateEmptyMesh. | |
| SMESH::SMESH_Mesh_ptr | CreateMeshesFromUNV (const char *theFileName) throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.CreateMeshFromUNV. | |
| SMESH::mesh_array * | CreateMeshesFromMED (const char *theFileName, SMESH::DriverMED_ReadStatus &theStatus) throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.CreateMeshFromMED. | |
| SMESH::SMESH_Mesh_ptr | CreateMeshesFromSTL (const char *theFileName) throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.CreateMeshFromSTL. | |
| SMESH::SMESH_Mesh_ptr | CopyMesh (SMESH::SMESH_IDSource_ptr meshPart, const char *meshName, CORBA::Boolean toCopyGroups, CORBA::Boolean toKeepIDs) |
| Create a mesh by copying a part of another mesh. | |
| CORBA::Boolean | Compute (SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr theShapeObject) throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.Compute. | |
| void | CancelCompute (SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr theShapeObject) |
| SMESH_Gen_i.CancelCompute. | |
| SMESH::compute_error_array * | GetComputeErrors (SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr theShapeObject) throw ( SALOME::SALOME_Exception ) |
| Return errors of mesh computation. | |
| SMESH::long_array * | Evaluate (SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr theShapeObject) throw ( SALOME::SALOME_Exception ) |
| Evaluate mesh on a shape and returns statistic of mesh elements Result array of number enityties. | |
| CORBA::Boolean | IsReadyToCompute (SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr theShapeObject) throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.IsReadyToCompute. | |
| SMESH::MeshPreviewStruct * | Precompute (SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr theSubObject, SMESH::Dimension theDimension, SMESH::long_array &theShapesId) throw ( SALOME::SALOME_Exception ) |
| Calculate Mesh as preview till indicated dimension on shape First, verify list of hypothesis associated with the subShape. | |
| SMESH::algo_error_array * | GetAlgoState (SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr theSubObject) throw ( SALOME::SALOME_Exception ) |
| Returns errors of hypotheses definintion. | |
| SMESH::MeshPreviewStruct * | GetBadInputElements (SMESH::SMESH_Mesh_ptr theMesh, CORBA::Short theSubShapeID) throw ( SALOME::SALOME_Exception ) |
| Return mesh elements preventing computation of a subshape. | |
| SMESH::long_array * | GetSubShapesId (GEOM::GEOM_Object_ptr theMainShapeObject, const SMESH::object_array &theListOfSubShape) throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.GetSubShapesId. | |
| GEOM::GEOM_Object_ptr | GetGeometryByMeshElement (SMESH::SMESH_Mesh_ptr theMesh, CORBA::Long theElementID, const char *theGeomName) throw ( SALOME::SALOME_Exception ) |
| Return geometrical object the given element is built on. | |
| GEOM::GEOM_Object_ptr | FindGeometryByMeshElement (SMESH::SMESH_Mesh_ptr theMesh, CORBA::Long theElementID) throw ( SALOME::SALOME_Exception ) |
| Return geometrical object the given element is built on. | |
| SMESH::SMESH_Mesh_ptr | ConcatenateCommon (const SMESH::mesh_array &theMeshesArray, CORBA::Boolean theUniteIdenticalGroups, CORBA::Boolean theMergeNodesAndElements, CORBA::Double theMergeTolerance, CORBA::Boolean theCommonGroups) throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.ConcatenateCommon. | |
| SMESH::SMESH_Mesh_ptr | Concatenate (const SMESH::mesh_array &theMeshesArray, CORBA::Boolean theUniteIdenticalGroups, CORBA::Boolean theMergeNodesAndElements, CORBA::Double theMergeTolerance) throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.Concatenate. | |
| SMESH::SMESH_Mesh_ptr | ConcatenateWithGroups (const SMESH::mesh_array &theMeshesArray, CORBA::Boolean theUniteIdenticalGroups, CORBA::Boolean theMergeNodesAndElements, CORBA::Double theMergeTolerance) throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.ConcatenateWithGroups. | |
| CORBA::Boolean | GetMEDVersion (const char *theFileName, SMESH::MED_VERSION &theVersion) |
| SMESH_Gen_i.GetMEDVersion. | |
| SMESH::string_array * | GetMeshNames (const char *theFileName) |
| SMESH_Gen_i.GetMeshNames. | |
| SALOMEDS::TMPFile * | Save (SALOMEDS::SComponent_ptr theComponent, const char *theURL, bool isMultiFile) |
| SMESH_Gen_i.Save. | |
| bool | Load (SALOMEDS::SComponent_ptr theComponent, const SALOMEDS::TMPFile &theStream, const char *theURL, bool isMultiFile) |
| SMESH_Gen_i.Load. | |
| SALOMEDS::TMPFile * | SaveASCII (SALOMEDS::SComponent_ptr theComponent, const char *theURL, bool isMultiFile) |
| SMESH_Gen_i.SaveASCII. | |
| bool | LoadASCII (SALOMEDS::SComponent_ptr theComponent, const SALOMEDS::TMPFile &theStream, const char *theURL, bool isMultiFile) |
| SMESH_Gen_i.LoadASCII. | |
| SMESH::FilterManager_ptr | CreateFilterManager () |
| SMESH_Gen_i.CreateFilterManager. | |
| SMESH::SMESH_Pattern_ptr | GetPattern () |
| SMESH_Gen_i.GetPattern. | |
| SMESH::Measurements_ptr | CreateMeasurements () |
| SMESH_Gen_i.CreateMeasurements. | |
| void | Close (SALOMEDS::SComponent_ptr theComponent) |
| SMESH_Gen_i.Close. | |
| char * | ComponentDataType () |
| SMESH_Gen_i.ComponentDataType. | |
| char * | IORToLocalPersistentID (SALOMEDS::SObject_ptr theSObject, const char *IORString, CORBA::Boolean isMultiFile, CORBA::Boolean isASCII) |
| SMESH_Gen_i.IORToLocalPersistentID. | |
| char * | LocalPersistentIDToIOR (SALOMEDS::SObject_ptr theSObject, const char *aLocalPersistentID, CORBA::Boolean isMultiFile, CORBA::Boolean isASCII) |
| SMESH_Gen_i.LocalPersistentIDToIOR. | |
| bool | CanPublishInStudy (CORBA::Object_ptr theIOR) |
| SMESH_Gen_i.CanPublishInStudy. | |
| SALOMEDS::SObject_ptr | PublishInStudy (SALOMEDS::Study_ptr theStudy, SALOMEDS::SObject_ptr theSObject, CORBA::Object_ptr theObject, const char *theName) throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.PublishInStudy. | |
| CORBA::Boolean | CanCopy (SALOMEDS::SObject_ptr theObject) |
| SALOMEDS::TMPFile * | CopyFrom (SALOMEDS::SObject_ptr theObject, CORBA::Long &theObjectID) |
| CORBA::Boolean | CanPaste (const char *theComponentName, CORBA::Long theObjectID) |
| SALOMEDS::SObject_ptr | PasteInto (const SALOMEDS::TMPFile &theStream, CORBA::Long theObjectID, SALOMEDS::SObject_ptr theObject) |
| virtual Engines::TMPFile * | DumpPython (CORBA::Object_ptr theStudy, CORBA::Boolean isPublished, CORBA::Boolean isMultiFile, CORBA::Boolean &isValidScript) |
| void | AddToPythonScript (int theStudyID, const TCollection_AsciiString &theString) |
| AddToPythonScript. | |
| void | RemoveLastFromPythonScript (int theStudyID) |
| RemoveLastFromPythonScript. | |
| void | SavePython (SALOMEDS::Study_ptr theStudy) |
| TCollection_AsciiString | DumpPython_impl (SALOMEDS::Study_ptr theStudy, Resource_DataMapOfAsciiStringAsciiString &theObjectNames, Resource_DataMapOfAsciiStringAsciiString &theNames, bool isPublished, bool isMultiFile, bool &aValidScript, const TCollection_AsciiString &theSavedTrace) |
| DumpPython. | |
| TCollection_AsciiString | GetNewPythonLines (int theStudyID) |
| GetNewPythonLines. | |
| void | CleanPythonTrace (int theStudyID) |
| CleanPythonTrace. | |
| GEOM_Client * | GetShapeReader () |
| SMESH_Gen_i.GetShapeReader. | |
| SALOMEDS::SComponent_ptr | PublishComponent (SALOMEDS::Study_ptr theStudy) |
| SALOMEDS::SObject_ptr | PublishMesh (SALOMEDS::Study_ptr theStudy, SMESH::SMESH_Mesh_ptr theMesh, const char *theName=0) |
| SALOMEDS::SObject_ptr | PublishHypothesis (SALOMEDS::Study_ptr theStudy, SMESH::SMESH_Hypothesis_ptr theHyp, const char *theName=0) |
| SALOMEDS::SObject_ptr | PublishSubMesh (SALOMEDS::Study_ptr theStudy, SMESH::SMESH_Mesh_ptr theMesh, SMESH::SMESH_subMesh_ptr theSubMesh, GEOM::GEOM_Object_ptr theShapeObject, const char *theName=0) |
| SALOMEDS::SObject_ptr | PublishGroup (SALOMEDS::Study_ptr theStudy, SMESH::SMESH_Mesh_ptr theMesh, SMESH::SMESH_GroupBase_ptr theGroup, GEOM::GEOM_Object_ptr theShapeObject, const char *theName=0) |
| bool | AddHypothesisToShape (SALOMEDS::Study_ptr theStudy, SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr theShapeObject, SMESH::SMESH_Hypothesis_ptr theHyp) |
| bool | RemoveHypothesisFromShape (SALOMEDS::Study_ptr theStudy, SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr theShapeObject, SMESH::SMESH_Hypothesis_ptr theHyp) |
| SALOMEDS::SObject_ptr | GetMeshOrSubmeshByShape (SALOMEDS::Study_ptr theStudy, SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr theShape) |
| StudyContext * | GetCurrentStudyContext () |
| SMESH_Gen_i.GetCurrentStudyContext. | |
| int | RegisterObject (CORBA::Object_ptr theObject) |
| CORBA::Long | GetObjectId (CORBA::Object_ptr theObject) |
| Return id of registered object. | |
| template<class TInterface > | |
| TInterface::_var_type | GetObjectByOldId (const int oldID) |
| int | GetCurrentStudyID () |
| SALOMEDS::SObject_ptr | GetAlgoSO (const ::SMESH_Algo *algo) |
| Find SObject for an algo. | |
| void | UpdateParameters (CORBA::Object_ptr theObject, const char *theParameters) |
| char * | GetParameters (CORBA::Object_ptr theObject) |
| char * | ParseParameters (const char *theParameters) |
Static Public Member Functions | |
| static SMESH_Gen_i * | GetSMESHGen () |
| static CORBA::ORB_var | GetORB () |
| static PortableServer::POA_var | GetPOA () |
| static SALOME_NamingService * | GetNS () |
| GetNS [ static ]. | |
| static SALOME_LifeCycleCORBA * | GetLCC () |
| GetLCC [ static ]. | |
| static GEOM::GEOM_Gen_ptr | GetGeomEngine () |
| GetGeomEngine [ static ]. | |
| static PortableServer::ServantBase_var | GetServant (CORBA::Object_ptr theObject) |
| GetServant [ static ]. | |
| static CORBA::Object_var | SObjectToObject (SALOMEDS::SObject_ptr theSObject) |
| SObjectToObject [ static ]. | |
| static SALOMEDS::SObject_ptr | ObjectToSObject (SALOMEDS::Study_ptr theStudy, CORBA::Object_ptr theObject) |
| static long | GetHypothesisRootTag () |
| Get...Tag [ static ]. | |
| static long | GetAlgorithmsRootTag () |
| static long | GetRefOnShapeTag () |
| static long | GetRefOnAppliedHypothesisTag () |
| static long | GetRefOnAppliedAlgorithmsTag () |
| static long | GetSubMeshOnVertexTag () |
| static long | GetSubMeshOnEdgeTag () |
| static long | GetSubMeshOnFaceTag () |
| static long | GetSubMeshOnSolidTag () |
| static long | GetSubMeshOnCompoundTag () |
| static long | GetSubMeshOnWireTag () |
| static long | GetSubMeshOnShellTag () |
| static long | GetNodeGroupsTag () |
| static long | GetEdgeGroupsTag () |
| static long | GetFaceGroupsTag () |
| static long | GetVolumeGroupsTag () |
| static long | Get0DElementsGroupsTag () |
| static void | SetName (SALOMEDS::SObject_ptr theSObject, const char *theName, const char *theDefaultName=0) |
| static void | SetPixMap (SALOMEDS::SObject_ptr theSObject, const char *thePixMap) |
Private Member Functions | |
| SMESH::SMESH_Hypothesis_ptr | createHypothesis (const char *theHypName, const char *theLibName) throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.createHypothesis. | |
| SMESH::SMESH_Mesh_ptr | createMesh () throw ( SALOME::SALOME_Exception ) |
| SMESH_Gen_i.createMesh. | |
Static Private Member Functions | |
| static void | loadGeomData (SALOMEDS::SComponent_ptr theCompRoot) |
| SMESH_Gen_i.loadGeomData. | |
Private Attributes | |
| ::SMESH_Gen | myGen |
| map< string, GenericHypothesisCreator_i * > | myHypCreatorMap |
| map< int, StudyContext * > | myStudyContextMap |
| GEOM_Client * | myShapeReader |
| SALOMEDS::Study_var | myCurrentStudy |
| CORBA::Boolean | myIsEmbeddedMode |
| std::map< int, Handle(TColStd_HSequenceOfAsciiString) > | myPythonScripts |
Static Private Attributes | |
| static GEOM::GEOM_Gen_var | myGeomGen = GEOM::GEOM_Gen::_nil() |
| static CORBA::ORB_var | myOrb |
| static PortableServer::POA_var | myPoa |
| static SALOME_NamingService * | myNS = NULL |
| static SALOME_LifeCycleCORBA * | myLCC = NULL |
| static SMESH_Gen_i * | mySMESHGen = NULL |
Detailed Description
Definition at line 133 of file SMESH_Gen_i.hxx.
Constructor & Destructor Documentation
| SMESH_Gen_i::SMESH_Gen_i | ( | ) |
Default constructor: not for use
Definition at line 252 of file SMESH_Gen_i.cxx.
{
INFOS( "SMESH_Gen_i::SMESH_Gen_i : default constructor" );
}
| SMESH_Gen_i::SMESH_Gen_i | ( | CORBA::ORB_ptr | orb, |
| PortableServer::POA_ptr | poa, | ||
| PortableServer::ObjectId * | contId, | ||
| const char * | instanceName, | ||
| const char * | interfaceName | ||
| ) |
Standard constructor, used with Container
Definition at line 265 of file SMESH_Gen_i.cxx.
References GetNS(), MESSAGE, myIsEmbeddedMode, myOrb, myPoa, myShapeReader, mySMESHGen, and SetEmbeddedMode().
: Engines_Component_i( orb, poa, contId, instanceName, interfaceName ) { MESSAGE( "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 ); myIsEmbeddedMode = false; myShapeReader = NULL; // shape reader mySMESHGen = this; // set it in standalone mode only //OSD::SetSignal( true ); // 0020605: EDF 1190 SMESH: Display performance. 80 seconds for 52000 cells. // find out mode (embedded or standalone) here else // meshes created before calling SMESH_Client::GetSMESHGen(), which calls // SMESH_Gen_i::SetEmbeddedMode(), have wrong IsEmbeddedMode flag if ( SALOME_NamingService* ns = GetNS() ) { CORBA::Object_var obj = ns->Resolve( "/Kernel/Session" ); SALOME::Session_var session = SALOME::Session::_narrow( obj ) ; if ( !session->_is_nil() ) { CORBA::String_var s_host = session->getHostname(); CORBA::Long s_pid = session->getPID(); string my_host = Kernel_Utils::GetHostname(); #ifdef WNT long my_pid = (long)_getpid(); #else long my_pid = (long) getpid(); #endif SetEmbeddedMode( s_pid == my_pid && my_host == s_host.in() ); } } }
| SMESH_Gen_i::~SMESH_Gen_i | ( | ) | [virtual] |
Destructor
Definition at line 318 of file SMESH_Gen_i.cxx.
References MESSAGE, myHypCreatorMap, myShapeReader, and myStudyContextMap.
{
MESSAGE( "SMESH_Gen_i::~SMESH_Gen_i" );
// delete hypothesis creators
map<string, GenericHypothesisCreator_i*>::iterator itHyp;
for (itHyp = myHypCreatorMap.begin(); itHyp != myHypCreatorMap.end(); itHyp++)
{
delete (*itHyp).second;
}
myHypCreatorMap.clear();
// Clear study contexts data
map<int, StudyContext*>::iterator it;
for ( it = myStudyContextMap.begin(); it != myStudyContextMap.end(); ++it ) {
delete it->second;
}
myStudyContextMap.clear();
// delete shape reader
if ( !myShapeReader )
delete myShapeReader;
}
Member Function Documentation
| bool SMESH_Gen_i::AddHypothesisToShape | ( | SALOMEDS::Study_ptr | theStudy, |
| SMESH::SMESH_Mesh_ptr | theMesh, | ||
| GEOM::GEOM_Object_ptr | theShapeObject, | ||
| SMESH::SMESH_Hypothesis_ptr | theHyp | ||
| ) |
Definition at line 809 of file SMESH_Gen_i_1.cxx.
References addReference(), SMESH_fixation.aShape, GeomObjectToShape(), SMESH_Mesh_i.GetImpl(), SMESH_Mesh.GetMeshDS(), GetMeshOrSubmeshByShape(), GetRefOnAppliedAlgorithmsTag(), GetRefOnAppliedHypothesisTag(), SMESH_Mesh_i.getSubMesh(), MESSAGE, ObjectToSObject(), publish(), PublishHypothesis(), PublishMesh(), PublishSubMesh(), SetName(), and SMESHDS_Mesh.ShapeToIndex().
Referenced by PublishMesh(), and PublishSubMesh().
{
if(MYDEBUG) MESSAGE("AddHypothesisToShape")
if (theStudy->_is_nil() || theMesh->_is_nil() ||
theHyp->_is_nil() || (theShape->_is_nil()
&& theMesh->HasShapeToMesh()) )
return false;
SALOMEDS::SObject_var aMeshSO = ObjectToSObject( theStudy, theMesh );
if ( aMeshSO->_is_nil() )
aMeshSO = PublishMesh( theStudy, theMesh );
SALOMEDS::SObject_var aHypSO = PublishHypothesis( theStudy, theHyp );
if ( aMeshSO->_is_nil() || aHypSO->_is_nil())
return false;
// Find a mesh or submesh refering to theShape
SALOMEDS::SObject_var aMeshOrSubMesh =
GetMeshOrSubmeshByShape( theStudy, theMesh, theShape );
if ( aMeshOrSubMesh->_is_nil() )
{
// publish submesh
TopoDS_Shape aShape = GeomObjectToShape( theShape );
SMESH_Mesh_i* mesh_i = objectToServant<SMESH_Mesh_i>( theMesh );
if ( !aShape.IsNull() && mesh_i && mesh_i->GetImpl().GetMeshDS() ) {
SMESHDS_Mesh* meshDS = mesh_i->GetImpl().GetMeshDS();
int shapeID = meshDS->ShapeToIndex( aShape );
SMESH::SMESH_subMesh_var aSubMesh = mesh_i->getSubMesh(shapeID);
aMeshOrSubMesh = PublishSubMesh( theStudy, theMesh, aSubMesh, theShape );
}
if ( aMeshOrSubMesh->_is_nil() )
return false;
}
//Find or Create Applied Hypothesis root
bool aIsAlgo = !SMESH::SMESH_Algo::_narrow( theHyp )->_is_nil();
SALOMEDS::SObject_var AHR =
publish (theStudy, CORBA::Object::_nil(), aMeshOrSubMesh,
aIsAlgo ? GetRefOnAppliedAlgorithmsTag() : GetRefOnAppliedHypothesisTag(),
aIsAlgo ? "ICON_SMESH_TREE_ALGO" : "ICON_SMESH_TREE_HYPO", false);
SetName( AHR, aIsAlgo ? "Applied algorithms" : "Applied hypotheses" );
if ( AHR->_is_nil() )
return false;
addReference( theStudy, AHR, theHyp );
if(MYDEBUG) MESSAGE("AddHypothesisToShape--END")
return true;
}
| void SMESH_Gen_i::AddToPythonScript | ( | int | theStudyID, |
| const TCollection_AsciiString & | theString | ||
| ) |
AddToPythonScript.
Definition at line 577 of file SMESH_DumpPython.cxx.
References myPythonScripts.
Referenced by SMESH.TPythonDump.~TPythonDump().
{
if (myPythonScripts.find(theStudyID) == myPythonScripts.end()) {
myPythonScripts[theStudyID] = new TColStd_HSequenceOfAsciiString;
}
myPythonScripts[theStudyID]->Append(theString);
}
| void SMESH_Gen_i::CancelCompute | ( | SMESH::SMESH_Mesh_ptr | theMesh, |
| GEOM::GEOM_Object_ptr | theShapeObject | ||
| ) |
Cancel Compute mesh on a shape
Definition at line 1464 of file SMESH_Gen_i.cxx.
References GeomObjectToShape(), SMESH_Mesh_i.GetImpl(), GetServant(), myGen, and SMESH_Mesh.PseudoShape().
{
#ifdef WITH_SMESH_CANCEL_COMPUTE
SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
TopoDS_Shape myLocShape;
if(theMesh->HasShapeToMesh())
myLocShape = GeomObjectToShape( theShapeObject );
else
myLocShape = SMESH_Mesh::PseudoShape();
myGen.CancelCompute( myLocMesh, myLocShape);
#endif
}
| CORBA::Boolean SMESH_Gen_i.CanCopy | ( | SALOMEDS::SObject_ptr | theObject | ) |
Definition at line 399 of file SMESH_Gen_i.hxx.
{ return false; }
| CORBA::Boolean SMESH_Gen_i.CanPaste | ( | const char * | theComponentName, |
| CORBA::Long | theObjectID | ||
| ) |
Definition at line 403 of file SMESH_Gen_i.hxx.
{ return false; }
| bool SMESH_Gen_i::CanPublishInStudy | ( | CORBA::Object_ptr | theIOR | ) |
SMESH_Gen_i.CanPublishInStudy.
Returns true if object can be published in the study
Definition at line 152 of file SMESH_Gen_i_1.cxx.
References SMESH_controls.aGroup, MESSAGE, and myCurrentStudy.
Referenced by CreateEmptyMesh(), and SMESH.TPythonDump.operator<<().
{
if(MYDEBUG) MESSAGE("CanPublishInStudy - "<<!CORBA::is_nil(myCurrentStudy));
if(CORBA::is_nil(myCurrentStudy))
return false;
SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow(theIOR);
if( !aMesh->_is_nil() )
return true;
SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow(theIOR);
if( !aSubMesh->_is_nil() )
return true;
SMESH::SMESH_Hypothesis_var aHyp = SMESH::SMESH_Hypothesis::_narrow(theIOR);
if( !aHyp->_is_nil() )
return true;
SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow(theIOR);
if( !aGroup->_is_nil() )
return true;
if(MYDEBUG) MESSAGE("CanPublishInStudy--CANT");
return false;
}
| void SMESH_Gen_i::CleanPythonTrace | ( | int | theStudyID | ) |
CleanPythonTrace.
Definition at line 1031 of file SMESH_DumpPython.cxx.
References myPythonScripts.
Referenced by SavePython().
{
TCollection_AsciiString aScript;
// Clean trace of API methods calls
if (myPythonScripts.find(theStudyID) != myPythonScripts.end()) {
myPythonScripts[theStudyID]->Clear();
}
}
| void SMESH_Gen_i::Close | ( | SALOMEDS::SComponent_ptr | theComponent | ) |
Clears study-connected data when it is closed
Definition at line 4632 of file SMESH_Gen_i.cxx.
References GetCurrentStudyID(), MESSAGE, myCurrentStudy, MYDEBUG, myStudyContextMap, and SetCurrentStudy().
{
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Close" );
// set correct current study
if (theComponent->GetStudy()->StudyId() != GetCurrentStudyID())
SetCurrentStudy(theComponent->GetStudy());
// Clear study contexts data
int studyId = GetCurrentStudyID();
if ( myStudyContextMap.find( studyId ) != myStudyContextMap.end() ) {
delete myStudyContextMap[ studyId ];
myStudyContextMap.erase( studyId );
}
// delete SMESH_Mesh's
// See bug IPAL19437.
//
// StudyContextStruct* context = myGen.GetStudyContext( studyId );
// map< int, SMESH_Mesh* >::iterator i_mesh = context->mapMesh.begin();
// for ( ; i_mesh != context->mapMesh.end(); ++i_mesh ) {
// printf( "--------------------------- SMESH_Gen_i::Close, delete aGroup = %p \n", i_mesh->second );
// delete i_mesh->second;
// }
// delete SMESHDS_Mesh's
// it's too long on big meshes
// if ( context->myDocument ) {
// delete context->myDocument;
// context->myDocument = 0;
// }
myCurrentStudy = SALOMEDS::Study::_nil();
return;
}
| char * SMESH_Gen_i::ComponentDataType | ( | ) |
SMESH_Gen_i.ComponentDataType.
Get component data type
Definition at line 4677 of file SMESH_Gen_i.cxx.
References MESSAGE, and MYDEBUG.
Referenced by DumpPython(), GetAlgoSO(), SMESH_NoteBook.InitObjectMap(), PublishComponent(), SavePython(), and SetCurrentStudy().
| CORBA::Boolean SMESH_Gen_i::Compute | ( | SMESH::SMESH_Mesh_ptr | theMesh, |
| GEOM::GEOM_Object_ptr | theShapeObject | ||
| ) | throw ( SALOME::SALOME_Exception ) |
Compute mesh on a shape
Definition at line 1400 of file SMESH_Gen_i.cxx.
References SMESH_Mesh_i.CheckGeomGroupModif(), SMESH_Mesh_i.CreateGroupServants(), SMESH_Mesh_i.GetImpl(), MEMOSTAT, MESSAGE, MYDEBUG, and SMESH_Mesh.PseudoShape().
{
MEMOSTAT;
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Compute" );
if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
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
TPythonDump() << "isDone = " << this << ".Compute( "
<< theMesh << ", " << theShapeObject << ")";
try {
// get mesh servant
SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
ASSERT( meshServant );
if ( meshServant ) {
// NPAL16168: "geometrical group edition from a submesh don't modifiy mesh computation"
meshServant->CheckGeomGroupModif();
// get local TopoDS_Shape
TopoDS_Shape myLocShape;
if(theMesh->HasShapeToMesh())
myLocShape = GeomObjectToShape( theShapeObject );
else
myLocShape = SMESH_Mesh::PseudoShape();
// call implementation compute
::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
#ifdef WITH_SMESH_CANCEL_COMPUTE
myGen.PrepareCompute( myLocMesh, myLocShape);
#endif
bool ok = myGen.Compute( myLocMesh, myLocShape);
meshServant->CreateGroupServants(); // algos can create groups (issue 0020918)
myLocMesh.GetMeshDS()->Modified();
return ok;
}
}
catch ( std::bad_alloc ) {
INFOS( "Compute(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
INFOS( "Compute(): catch exception "<< S_ex.what() );
}
catch ( ... ) {
INFOS( "Compute(): unknown exception " );
}
return false;
}
| SMESH::SMESH_Mesh_ptr SMESH_Gen_i::Concatenate | ( | const SMESH::mesh_array & | theMeshesArray, |
| CORBA::Boolean | theUniteIdenticalGroups, | ||
| CORBA::Boolean | theMergeNodesAndElements, | ||
| CORBA::Double | theMergeTolerance | ||
| ) | throw ( SALOME::SALOME_Exception ) |
Concatenate the given meshes into one mesh
Definition at line 1890 of file SMESH_Gen_i.cxx.
{
return ConcatenateCommon(theMeshesArray,
theUniteIdenticalGroups,
theMergeNodesAndElements,
theMergeTolerance,
false);
}
| SMESH::SMESH_Mesh_ptr SMESH_Gen_i::ConcatenateCommon | ( | const SMESH::mesh_array & | theMeshesArray, |
| CORBA::Boolean | theUniteIdenticalGroups, | ||
| CORBA::Boolean | theMergeNodesAndElements, | ||
| CORBA::Double | theMergeTolerance, | ||
| CORBA::Boolean | theCommonGroups | ||
| ) | throw ( SALOME::SALOME_Exception ) |
SMESH_Gen_i.ConcatenateCommon.
Concatenate the given meshes into one mesh
Definition at line 1935 of file SMESH_Gen_i.cxx.
References SMESHDS_Mesh.AddNode(), SMESHDS_Mesh.AddPolyhedralVolume(), SMESH_controls.aGroup, SMESH_BelongToGeom.anElemType, batchmode_smesh.aPixmap, SMESH_Mesh_i.CreateGroup(), SMESH.EDGE, SMDS_Mesh.elementsIterator(), SMESH.FACE, SMDS_Mesh.FindNode(), SMESH_Mesh_i.GetGroups(), SMDS_MeshElement.GetID(), SMESH_Mesh_i.GetImpl(), SMDS_VtkVolume.GetQuantities(), SMDS_MeshElement.GetType(), SMDS_MeshElement.IsPoly(), SMDS_Mesh.Modified(), SMDS_Mesh.NbEdges(), SMDS_Mesh.NbFaces(), SMDS_MeshNode.NbInverseElements(), SMDS_MeshElement.NbNodes(), SMDS_Mesh.NbNodes(), SMDS_Mesh.NbVolumes(), SMESH.NODE, SMDS_Mesh.nodesIterator(), SMDS_MeshElement.nodesIterator(), SMDSAbs_Edge, SMDSAbs_Face, SMDSAbs_Volume, SMESH.VOLUME, SMDS_MeshNode.X(), SMDS_MeshNode.Y(), and SMDS_MeshNode.Z().
{
typedef map<int, int> TIDsMap;
typedef list<SMESH::SMESH_Group_var> TListOfNewGroups;
typedef map< pair<string, SMESH::ElementType>, TListOfNewGroups > TGroupsMap;
typedef std::set<SMESHDS_GroupBase*> TGroups;
TPythonDump* pPythonDump = new TPythonDump;
TPythonDump& aPythonDump = *pPythonDump; // prevent dump of called methods
// create mesh
SMESH::SMESH_Mesh_var aNewMesh = CreateEmptyMesh();
SMESHDS_Mesh* aNewMeshDS = 0;
if ( !aNewMesh->_is_nil() ) {
SMESH_Mesh_i* aNewImpl = dynamic_cast<SMESH_Mesh_i*>( GetServant( aNewMesh ).in() );
if ( aNewImpl ) {
::SMESH_Mesh& aLocMesh = aNewImpl->GetImpl();
aNewMeshDS = aLocMesh.GetMeshDS();
TGroupsMap aGroupsMap;
TListOfNewGroups aListOfNewGroups;
SMESH_MeshEditor aNewEditor = ::SMESH_MeshEditor(&aLocMesh);
SMESH::ListOfGroups_var aListOfGroups = new SMESH::ListOfGroups();
// loop on meshes
for ( int i = 0; i < theMeshesArray.length(); i++) {
SMESH::SMESH_Mesh_var anInitMesh = theMeshesArray[i];
if ( !anInitMesh->_is_nil() ) {
SMESH_Mesh_i* anInitImpl = dynamic_cast<SMESH_Mesh_i*>( GetServant( anInitMesh ).in() );
if ( anInitImpl ) {
::SMESH_Mesh& aInitLocMesh = anInitImpl->GetImpl();
SMESHDS_Mesh* anInitMeshDS = aInitLocMesh.GetMeshDS();
TIDsMap nodesMap;
TIDsMap elemsMap;
// loop on elements of mesh
SMDS_ElemIteratorPtr itElems = anInitMeshDS->elementsIterator();
const SMDS_MeshElement* anElem = 0;
const SMDS_MeshElement* aNewElem = 0;
int anElemNbNodes = 0;
int anNbNodes = 0;
int anNbEdges = 0;
int anNbFaces = 0;
int anNbVolumes = 0;
SMESH::long_array_var anIDsNodes = new SMESH::long_array();
SMESH::long_array_var anIDsEdges = new SMESH::long_array();
SMESH::long_array_var anIDsFaces = new SMESH::long_array();
SMESH::long_array_var anIDsVolumes = new SMESH::long_array();
if( theCommonGroups ) {
anIDsNodes->length( anInitMeshDS->NbNodes() );
anIDsEdges->length( anInitMeshDS->NbEdges() );
anIDsFaces->length( anInitMeshDS->NbFaces() );
anIDsVolumes->length( anInitMeshDS->NbVolumes() );
}
for ( int j = 0; itElems->more(); j++) {
anElem = itElems->next();
SMDSAbs_ElementType anElemType = anElem->GetType();
anElemNbNodes = anElem->NbNodes();
std::vector<const SMDS_MeshNode*> aNodesArray (anElemNbNodes);
// loop on nodes of element
const SMDS_MeshNode* aNode = 0;
const SMDS_MeshNode* aNewNode = 0;
SMDS_ElemIteratorPtr itNodes = anElem->nodesIterator();
for ( int k = 0; itNodes->more(); k++) {
aNode = static_cast<const SMDS_MeshNode*>(itNodes->next());
if ( nodesMap.find(aNode->GetID()) == nodesMap.end() ) {
aNewNode = aNewMeshDS->AddNode(aNode->X(), aNode->Y(), aNode->Z());
nodesMap.insert( make_pair(aNode->GetID(), aNewNode->GetID()) );
if( theCommonGroups )
anIDsNodes[anNbNodes++] = aNewNode->GetID();
}
else
aNewNode = aNewMeshDS->FindNode( nodesMap.find(aNode->GetID())->second );
aNodesArray[k] = aNewNode;
}//nodes loop
// creates a corresponding element on existent nodes in new mesh
if ( anElem->IsPoly() && anElemType == SMDSAbs_Volume )
{
const SMDS_VtkVolume* aVolume =
dynamic_cast<const SMDS_VtkVolume*> (anElem);
if ( aVolume ) {
aNewElem = aNewMeshDS->AddPolyhedralVolume(aNodesArray,
aVolume->GetQuantities());
elemsMap.insert(make_pair(anElem->GetID(), aNewElem->GetID()));
if( theCommonGroups )
anIDsVolumes[anNbVolumes++] = aNewElem->GetID();
}
}
else {
aNewElem = aNewEditor.AddElement(aNodesArray,
anElemType,
anElem->IsPoly());
elemsMap.insert(make_pair(anElem->GetID(), aNewElem->GetID()));
if( theCommonGroups ) {
if( anElemType == SMDSAbs_Edge )
anIDsEdges[anNbEdges++] = aNewElem->GetID();
else if( anElemType == SMDSAbs_Face )
anIDsFaces[anNbFaces++] = aNewElem->GetID();
else if( anElemType == SMDSAbs_Volume )
anIDsVolumes[anNbVolumes++] = aNewElem->GetID();
}
}
}//elems loop
// copy orphan nodes
SMDS_NodeIteratorPtr itNodes = anInitMeshDS->nodesIterator();
while ( itNodes->more() )
{
const SMDS_MeshNode* aNode = itNodes->next();
if ( aNode->NbInverseElements() == 0 )
{
const SMDS_MeshNode* aNewNode =
aNewMeshDS->AddNode(aNode->X(), aNode->Y(), aNode->Z());
nodesMap.insert( make_pair(aNode->GetID(), aNewNode->GetID()) );
if( theCommonGroups )
anIDsNodes[anNbNodes++] = aNewNode->GetID();
}
}
aListOfGroups = anInitImpl->GetGroups();
SMESH::SMESH_GroupBase_ptr aGroup;
// loop on groups of mesh
SMESH::long_array_var anInitIDs = new SMESH::long_array();
SMESH::long_array_var anNewIDs = new SMESH::long_array();
SMESH::SMESH_Group_var aNewGroup;
SMESH::ElementType aGroupType;
CORBA::String_var aGroupName;
if ( theCommonGroups ) {
for(aGroupType=SMESH::NODE;aGroupType<=SMESH::VOLUME;aGroupType=(SMESH::ElementType)(aGroupType+1)) {
string str = "Gr";
SALOMEDS::SObject_var aMeshSObj = ObjectToSObject( myCurrentStudy, anInitMesh );
if(aMeshSObj)
str += aMeshSObj->GetName();
str += "_";
int anLen = 0;
switch(aGroupType) {
case SMESH::NODE:
str += "Nodes";
anIDsNodes->length(anNbNodes);
anLen = anNbNodes;
break;
case SMESH::EDGE:
str += "Edges";
anIDsEdges->length(anNbEdges);
anLen = anNbEdges;
break;
case SMESH::FACE:
str += "Faces";
anIDsFaces->length(anNbFaces);
anLen = anNbFaces;
break;
case SMESH::VOLUME:
str += "Volumes";
anIDsVolumes->length(anNbVolumes);
anLen = anNbVolumes;
break;
default:
break;
}
if(anLen) {
aGroupName = str.c_str();
// add a new group in the mesh
aNewGroup = aNewImpl->CreateGroup(aGroupType, aGroupName);
switch(aGroupType) {
case SMESH::NODE:
aNewGroup->Add( anIDsNodes );
break;
case SMESH::EDGE:
aNewGroup->Add( anIDsEdges );
break;
case SMESH::FACE:
aNewGroup->Add( anIDsFaces );
break;
case SMESH::VOLUME:
aNewGroup->Add( anIDsVolumes );
break;
default:
break;
}
aListOfNewGroups.clear();
aListOfNewGroups.push_back(aNewGroup);
aGroupsMap.insert(make_pair( make_pair(aGroupName, aGroupType), aListOfNewGroups ));
}
}
}
// check that current group name and type don't have identical ones in union mesh
for (int i = 0; i < aListOfGroups->length(); i++) {
aGroup = aListOfGroups[i];
aListOfNewGroups.clear();
aGroupType = aGroup->GetType();
aGroupName = aGroup->GetName();
TGroupsMap::iterator anIter = aGroupsMap.find(make_pair(aGroupName, aGroupType));
// convert a list of IDs
anInitIDs = aGroup->GetListOfID();
anNewIDs->length(anInitIDs->length());
if ( aGroupType == SMESH::NODE )
for (int j = 0; j < anInitIDs->length(); j++) {
anNewIDs[j] = nodesMap.find(anInitIDs[j])->second;
}
else
for (int j = 0; j < anInitIDs->length(); j++) {
anNewIDs[j] = elemsMap.find(anInitIDs[j])->second;
}
// check that current group name and type don't have identical ones in union mesh
if ( anIter == aGroupsMap.end() ) {
// add a new group in the mesh
aNewGroup = aNewImpl->CreateGroup(aGroupType, aGroupName);
// add elements into new group
aNewGroup->Add( anNewIDs );
aListOfNewGroups.push_back(aNewGroup);
aGroupsMap.insert(make_pair( make_pair(aGroupName, aGroupType), aListOfNewGroups ));
}
else if ( theUniteIdenticalGroups ) {
// unite identical groups
TListOfNewGroups& aNewGroups = anIter->second;
aNewGroups.front()->Add( anNewIDs );
}
else {
// rename identical groups
aNewGroup = aNewImpl->CreateGroup(aGroupType, aGroupName);
aNewGroup->Add( anNewIDs );
TListOfNewGroups& aNewGroups = anIter->second;
string aNewGroupName;
if (aNewGroups.size() == 1) {
aNewGroupName = string(aGroupName) + "_1";
aNewGroups.front()->SetName(aNewGroupName.c_str());
}
char aGroupNum[128];
sprintf(aGroupNum, "%u", aNewGroups.size()+1);
aNewGroupName = string(aGroupName) + "_" + string(aGroupNum);
aNewGroup->SetName(aNewGroupName.c_str());
aNewGroups.push_back(aNewGroup);
}
}//groups loop
}
}
}//meshes loop
if (theMergeNodesAndElements) {
// merge nodes
TIDSortedNodeSet aMeshNodes; // no input nodes
SMESH_MeshEditor::TListOfListOfNodes aGroupsOfNodes;
aNewEditor.FindCoincidentNodes( aMeshNodes, theMergeTolerance, aGroupsOfNodes );
aNewEditor.MergeNodes( aGroupsOfNodes );
// merge elements
aNewEditor.MergeEqualElements();
}
}
}
// Update Python script
aPythonDump << aNewMesh << " = " << this;
if( !theCommonGroups )
aPythonDump << ".Concatenate(";
else
aPythonDump << ".ConcatenateWithGroups(";
aPythonDump << "[";
for ( int i = 0; i < theMeshesArray.length(); i++) {
if (i > 0) aPythonDump << ", ";
aPythonDump << theMeshesArray[i];
}
aPythonDump << "], ";
aPythonDump << theUniteIdenticalGroups << ", "
<< theMergeNodesAndElements << ", "
<< theMergeTolerance << ")";
delete pPythonDump; // enable python dump from GetGroups()
// 0020577: EDF 1164 SMESH: Bad dump of concatenate with create common groups
if ( !aNewMesh->_is_nil() )
{
SMESH::ListOfGroups_var groups = aNewMesh->GetGroups();
}
// IPAL21468 Change icon of compound because it need not be computed.
SALOMEDS::SObject_var aMeshSObj = ObjectToSObject( myCurrentStudy, aNewMesh );
if( !aMeshSObj->_is_nil() ) {
SALOMEDS::GenericAttribute_var anAttr;
SALOMEDS::StudyBuilder_var aBuilder = myCurrentStudy->NewBuilder();
anAttr = aBuilder->FindOrCreateAttribute( aMeshSObj,"AttributePixMap" );
SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
aPixmap->SetPixMap("ICON_SMESH_TREE_MESH");
}
if (aNewMeshDS)
aNewMeshDS->Modified();
return aNewMesh._retn();
}
| SMESH::SMESH_Mesh_ptr SMESH_Gen_i::ConcatenateWithGroups | ( | const SMESH::mesh_array & | theMeshesArray, |
| CORBA::Boolean | theUniteIdenticalGroups, | ||
| CORBA::Boolean | theMergeNodesAndElements, | ||
| CORBA::Double | theMergeTolerance | ||
| ) | throw ( SALOME::SALOME_Exception ) |
SMESH_Gen_i.ConcatenateWithGroups.
Concatenate the given meshes into one mesh Create the groups of all elements from initial meshes
Definition at line 1913 of file SMESH_Gen_i.cxx.
{
return ConcatenateCommon(theMeshesArray,
theUniteIdenticalGroups,
theMergeNodesAndElements,
theMergeTolerance,
true);
}
| SALOMEDS::TMPFile* SMESH_Gen_i.CopyFrom | ( | SALOMEDS::SObject_ptr | theObject, |
| CORBA::Long & | theObjectID | ||
| ) |
Definition at line 401 of file SMESH_Gen_i.hxx.
{ return false; }
| SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh | ( | SMESH::SMESH_IDSource_ptr | meshPart, |
| const char * | meshName, | ||
| CORBA::Boolean | toCopyGroups, | ||
| CORBA::Boolean | toKeepIDs | ||
| ) |
Create a mesh by copying a part of another mesh.
- Parameters:
-
meshPart - a part of mesh to copy toCopyGroups - to create in the new mesh groups the copied elements belongs to toKeepIDs - to preserve IDs of the copied elements or not
- Return values:
-
SMESH.SMESH_Mesh_ptr - the new mesh
Definition at line 2266 of file SMESH_Gen_i.cxx.
References SMDS_MeshGroup.Add(), SMESHDS_Mesh.AddNode(), SMESHDS_Mesh.AddNodeWithID(), CreateMesh(), SMDS_Mesh.elementsIterator(), SMDS_Mesh.FindElement(), SMDS_Mesh.FindNode(), SMESHDS_GroupBase.GetElements(), SMDS_MeshElement.GetID(), SMESH_Mesh_i.GetImpl(), SMDS_Mesh.GetMeshInfo(), SMESHDS_GroupBase.GetType(), SMDS_MeshElement.GetType(), ex21_lamp.group, SMESH_test.ids, SMDS_MeshElement.IsPoly(), SMDS_Mesh.Modified(), myCurrentStudy, SMDS_MeshInfo.NbElements(), SMDS_MeshElement.NbNodes(), SMESH.NODE, SMESH_AdvancedEditor.nodes, SMDS_MeshElement.nodesIterator(), ObjectToSObject(), SetName(), SetPixMap(), SMDSAbs_NbElementTypes, SMDSAbs_Node, SMDS_MeshNode.X(), SMDS_MeshNode.Y(), and SMDS_MeshNode.Z().
Referenced by SMESH_MeshEditor_i.MakeBoundaryElements().
{
Unexpect aCatch(SALOME_SalomeException);
TPythonDump* pyDump = new TPythonDump; // prevent dump from CreateMesh()
// 1. Get source mesh
if ( CORBA::is_nil( meshPart ))
THROW_SALOME_CORBA_EXCEPTION( "bad IDSource", SALOME::BAD_PARAM );
SMESH::SMESH_Mesh_var srcMesh = meshPart->GetMesh();
SMESH_Mesh_i* srcMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( srcMesh );
if ( !srcMesh_i )
THROW_SALOME_CORBA_EXCEPTION( "bad mesh of IDSource", SALOME::BAD_PARAM );
SMESHDS_Mesh* srcMeshDS = srcMesh_i->GetImpl().GetMeshDS();
// 2. Make a new mesh
SMESH::SMESH_Mesh_var newMesh = CreateMesh(GEOM::GEOM_Object::_nil());
SMESH_Mesh_i* newMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( newMesh );
if ( !newMesh_i )
THROW_SALOME_CORBA_EXCEPTION( "can't create a mesh", SALOME::INTERNAL_ERROR );
SALOMEDS::SObject_var meshSO = ObjectToSObject(myCurrentStudy, newMesh );
if ( !meshSO->_is_nil() )
{
SetName( meshSO, meshName, "Mesh" );
SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED");
}
SMESHDS_Mesh* newMeshDS = newMesh_i->GetImpl().GetMeshDS();
::SMESH_MeshEditor editor( &newMesh_i->GetImpl() );
// 3. Get elements to copy
SMDS_ElemIteratorPtr srcElemIt;
TIDSortedElemSet srcElems;
SMESH::array_of_ElementType_var srcElemTypes = meshPart->GetTypes();
if ( SMESH::DownCast<SMESH_Mesh_i*>( meshPart ))
{
srcElemIt = srcMeshDS->elementsIterator();
}
else
{
SMESH::long_array_var ids = meshPart->GetIDs();
if ( srcElemTypes->length() == 1 && srcElemTypes[0] == SMESH::NODE ) // group of nodes
{
for (int i=0; i < ids->length(); i++)
if ( const SMDS_MeshElement * elem = srcMeshDS->FindNode( ids[i] ))
srcElems.insert( elem );
}
else
{
for (int i=0; i < ids->length(); i++)
if ( const SMDS_MeshElement * elem = srcMeshDS->FindElement( ids[i] ))
srcElems.insert( elem );
}
if ( srcElems.empty() )
return newMesh._retn();
typedef SMDS_SetIterator< SMDS_pElement, TIDSortedElemSet::const_iterator > ElIter;
srcElemIt = SMDS_ElemIteratorPtr( new ElIter( srcElems.begin(), srcElems.end() ));
}
// 4. Copy elements
typedef map<SMDS_pElement, SMDS_pElement, TIDCompare> TE2EMap;
TE2EMap e2eMapByType[ SMDSAbs_NbElementTypes ];
TE2EMap& n2nMap = e2eMapByType[ SMDSAbs_Node ];
int iN;
const SMDS_MeshNode *nSrc, *nTgt;
vector< const SMDS_MeshNode* > nodes;
while ( srcElemIt->more() )
{
const SMDS_MeshElement * elem = srcElemIt->next();
nodes.resize( elem->NbNodes());
SMDS_ElemIteratorPtr nIt = elem->nodesIterator();
if ( toKeepIDs ) {
for ( iN = 0; nIt->more(); ++iN )
{
nSrc = static_cast<const SMDS_MeshNode*>( nIt->next() );
nTgt = newMeshDS->FindNode( nSrc->GetID());
if ( !nTgt )
nTgt = newMeshDS->AddNodeWithID( nSrc->X(), nSrc->Y(), nSrc->Z(), nSrc->GetID());
nodes[ iN ] = nTgt;
}
}
else {
for ( iN = 0; nIt->more(); ++iN )
{
nSrc = static_cast<const SMDS_MeshNode*>( nIt->next() );
TE2EMap::iterator n2n = n2nMap.insert( make_pair( nSrc, SMDS_pNode(0) )).first;
if ( !n2n->second )
n2n->second = newMeshDS->AddNode( nSrc->X(), nSrc->Y(), nSrc->Z() );
nodes[ iN ] = (const SMDS_MeshNode*) n2n->second;
}
}
if ( elem->GetType() != SMDSAbs_Node )
{
int ID = toKeepIDs ? elem->GetID() : 0;
const SMDS_MeshElement * newElem = editor.AddElement( nodes,
elem->GetType(),
elem->IsPoly(),
ID);
if ( toCopyGroups && !toKeepIDs )
e2eMapByType[ elem->GetType() ].insert( make_pair( elem, newElem ));
}
}
// 5. Copy groups
int nbNewGroups = 0;
if ( toCopyGroups )
{
SMESH_Mesh::GroupIteratorPtr gIt = srcMesh_i->GetImpl().GetGroups();
while ( gIt->more() )
{
SMESH_Group* group = gIt->next();
const SMESHDS_GroupBase* groupDS = group->GetGroupDS();
// Check group type. We copy nodal groups containing nodes of copied element
SMDSAbs_ElementType groupType = groupDS->GetType();
if ( groupType != SMDSAbs_Node &&
newMeshDS->GetMeshInfo().NbElements( groupType ) == 0 )
continue; // group type differs from types of meshPart
// Find copied elements in the group
vector< const SMDS_MeshElement* > groupElems;
SMDS_ElemIteratorPtr eIt = groupDS->GetElements();
if ( toKeepIDs )
{
const SMDS_MeshElement* foundElem;
if ( groupType == SMDSAbs_Node )
{
while ( eIt->more() )
if (( foundElem = newMeshDS->FindNode( eIt->next()->GetID() )))
groupElems.push_back( foundElem );
}
else
{
while ( eIt->more() )
if (( foundElem = newMeshDS->FindElement( eIt->next()->GetID() )))
groupElems.push_back( foundElem );
}
}
else
{
TE2EMap & e2eMap = e2eMapByType[ groupDS->GetType() ];
if ( e2eMap.empty() ) continue;
int minID = e2eMap.begin()->first->GetID();
int maxID = e2eMap.rbegin()->first->GetID();
TE2EMap::iterator e2e;
while ( eIt->more() && groupElems.size() < e2eMap.size())
{
const SMDS_MeshElement* e = eIt->next();
if ( e->GetID() < minID || e->GetID() > maxID ) continue;
if ((e2e = e2eMap.find( e )) != e2eMap.end())
groupElems.push_back( e2e->second );
}
}
// Make a new group
if ( !groupElems.empty() )
{
SMESH::SMESH_Group_var newGroupObj =
newMesh->CreateGroup( SMESH::ElementType(groupType), group->GetName() );
if ( SMESH_GroupBase_i* newGroup_i = SMESH::DownCast<SMESH_GroupBase_i*>( newGroupObj))
{
SMESHDS_GroupBase * newGroupDS = newGroup_i->GetGroupDS();
SMDS_MeshGroup& smdsGroup = ((SMESHDS_Group*)newGroupDS)->SMDSGroup();
for ( unsigned i = 0; i < groupElems.size(); ++i )
smdsGroup.Add( groupElems[i] );
nbNewGroups++;
}
}
}
}
newMeshDS->Modified();
*pyDump << newMesh << " = " << this
<< ".CopyMesh( " << meshPart << ", "
<< "'" << meshName << "', "
<< toCopyGroups << ", "
<< toKeepIDs << ")";
delete pyDump; pyDump = 0; // allow dump in GetGroups()
if ( nbNewGroups > 0 ) // dump created groups
SMESH::ListOfGroups_var groups = newMesh->GetGroups();
return newMesh._retn();
}
| SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh | ( | ) | throw ( SALOME::SALOME_Exception ) |
Create empty mesh
Definition at line 847 of file SMESH_Gen_i.cxx.
References CanPublishInStudy(), createMesh(), PAL_MESH_041_mesh.mesh, MESSAGE, myCurrentStudy, MYDEBUG, and PublishMesh().
Referenced by SMESH_MeshEditor_i.makeMesh().
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
// create mesh
SMESH::SMESH_Mesh_var mesh = this->createMesh();
// 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
TPythonDump() << aSO << " = " << this << ".CreateEmptyMesh()";
}
}
return mesh._retn();
}
| SMESH::FilterManager_ptr SMESH_Gen_i::CreateFilterManager | ( | ) |
SMESH_Gen_i.CreateFilterManager.
Create filter manager
Definition at line 2243 of file SMESH_Filter_i.cxx.
{
SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
SMESH::FilterManager_var anObj = aFilter->_this();
return anObj._retn();
}
| SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis | ( | const char * | theHypName, |
| const char * | theLibName | ||
| ) | throw ( SALOME::SALOME_Exception ) |
Create hypothesis/algorothm of given type and publish it in the study
Definition at line 662 of file SMESH_Gen_i.cxx.
References SMESH_demo_hexa2_upd.hyp.
Referenced by StdMeshers_LayerDistribution_i.LoadFrom().
{
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
TPythonDump() << aSO << " = " << this << ".CreateHypothesis('"
<< theHypName << "', '" << theLibName << "')";
}
}
return hyp._retn();
}
| SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis | ( | const char * | theHypName, |
| const char * | theLibName | ||
| ) | throw ( SALOME::SALOME_Exception ) [private] |
Create hypothesis of given type
Definition at line 348 of file SMESH_Gen_i.cxx.
References SMESH.GetHypothesisCreator(), GetProc, LibHandle, LoadLib, MESSAGE, MYDEBUG, SMESH_Hypothesis_i.SetLibName(), and UnLoadLib.
Referenced by Load().
{
/* It's Need to tranlate lib name for WIN32 or X platform */
char* aPlatformLibName = 0;
if ( theLibName && theLibName[0] != '\0' )
{
int libNameLen = strlen(theLibName);
//check for old format "libXXXXXXX.so"
if (libNameLen > 7 &&
!strncmp( theLibName, "lib", 3 ) &&
!strcmp( theLibName+libNameLen-3, ".so" ))
{
//the old format
#ifdef WNT
aPlatformLibName = new char[libNameLen - 1];
aPlatformLibName[0] = '\0';
aPlatformLibName = strncat( aPlatformLibName, theLibName+3, libNameLen-6 );
aPlatformLibName = strcat( aPlatformLibName, ".dll" );
aPlatformLibName[libNameLen - 2] = '\0';
#else
aPlatformLibName = new char[ libNameLen + 1];
aPlatformLibName[0] = '\0';
aPlatformLibName = strcat( aPlatformLibName, theLibName );
aPlatformLibName[libNameLen] = '\0';
#endif
}
else
{
//try to use new format
#ifdef WNT
aPlatformLibName = new char[ libNameLen + 5 ];
aPlatformLibName[0] = '\0';
aPlatformLibName = strcat( aPlatformLibName, theLibName );
aPlatformLibName = strcat( aPlatformLibName, ".dll" );
#else
aPlatformLibName = new char[ libNameLen + 7 ];
aPlatformLibName[0] = '\0';
aPlatformLibName = strcat( aPlatformLibName, "lib" );
aPlatformLibName = strcat( aPlatformLibName, theLibName );
aPlatformLibName = strcat( aPlatformLibName, ".so" );
#endif
}
}
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "Create Hypothesis <" << theHypName << "> from " << aPlatformLibName/*theLibName*/);
// create a new hypothesis object servant
SMESH_Hypothesis_i* myHypothesis_i = 0;
SMESH::SMESH_Hypothesis_var hypothesis_i;
try
{
// check, if creator for this hypothesis type already exists
if (myHypCreatorMap.find(string(theHypName)) == myHypCreatorMap.end())
{
// load plugin library
if(MYDEBUG) MESSAGE("Loading server meshers plugin library ...");
LibHandle libHandle = LoadLib( aPlatformLibName/*theLibName*/ );
if (!libHandle)
{
// report any error, if occured
#ifndef WNT
const char* anError = dlerror();
throw(SALOME_Exception(anError));
#else
throw(SALOME_Exception(LOCALIZED( "Can't load server meshers plugin library" )));
#endif
}
// get method, returning hypothesis creator
if(MYDEBUG) MESSAGE("Find GetHypothesisCreator() method ...");
typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char* theHypName);
GetHypothesisCreator procHandle =
(GetHypothesisCreator)GetProc( libHandle, "GetHypothesisCreator" );
if (!procHandle)
{
throw(SALOME_Exception(LOCALIZED("bad hypothesis plugin library")));
UnLoadLib(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);
myHypothesis_i->SetLibName(aPlatformLibName/*theLibName*/); // for persistency assurance
}
catch (SALOME_Exception& S_ex)
{
THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
}
if ( aPlatformLibName )
delete[] aPlatformLibName;
if (!myHypothesis_i)
return hypothesis_i._retn();
// activate the CORBA servant of hypothesis
hypothesis_i = SMESH::SMESH_Hypothesis::_narrow( myHypothesis_i->_this() );
int nextId = RegisterObject( hypothesis_i );
if(MYDEBUG) MESSAGE( "Add hypo to map with id = "<< nextId );
return hypothesis_i._retn();
}
| SMESH::Measurements_ptr SMESH_Gen_i::CreateMeasurements | ( | ) |
SMESH_Gen_i.CreateMeasurements.
Create measurement instance
Definition at line 61 of file SMESH_Measurements_i.cxx.
{
SMESH::Measurements_i* aMeasure = new SMESH::Measurements_i();
SMESH::Measurements_var anObj = aMeasure->_this();
return anObj._retn();
}
| SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh | ( | GEOM::GEOM_Object_ptr | theShapeObject | ) | throw ( SALOME::SALOME_Exception ) |
Create empty mesh on a shape and publish it in the study
Definition at line 812 of file SMESH_Gen_i.cxx.
References PAL_MESH_041_mesh.mesh, MESSAGE, MYDEBUG, and SMESH_Mesh_i.SetShape().
Referenced by CopyMesh().
{
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 = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
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
TPythonDump() << aSO << " = " << this << ".CreateMesh(" << theShapeObject << ")";
}
}
return mesh._retn();
}
| SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh | ( | ) | throw ( SALOME::SALOME_Exception ) [private] |
Create empty mesh on shape
Definition at line 476 of file SMESH_Gen_i.cxx.
References GetCurrentStudyID(), GetPOA(), PAL_MESH_041_mesh.mesh, MESSAGE, MYDEBUG, myGen, myIsEmbeddedMode, RegisterObject(), and SMESH_Mesh_i.SetImpl().
Referenced by CreateEmptyMesh(), and Load().
{
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
MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);
meshServant->SetImpl( myGen.CreateMesh( GetCurrentStudyID(), myIsEmbeddedMode ));
// 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_array * SMESH_Gen_i::CreateMeshesFromMED | ( | const char * | theFileName, |
| SMESH::DriverMED_ReadStatus & | theStatus | ||
| ) | throw ( SALOME::SALOME_Exception ) |
SMESH_Gen_i.CreateMeshFromMED.
Create mesh and import data from MED file
Definition at line 917 of file SMESH_Gen_i.cxx.
References SMESH.DRS_OK, SMESH_Mesh_i.GetImpl(), DriverMED_R_SMESHDS_Mesh.GetMeshNames(), SMESH_Mesh_i.ImportMEDFile(), PAL_MESH_041_mesh.mesh, MESSAGE, MYDEBUG, Driver_Mesh.SetFile(), Driver_Mesh.SetMeshId(), and SMESH_Nut.theFileName.
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshFromMED" );
// Retrieve mesh names from the file
DriverMED_R_SMESHDS_Mesh myReader;
myReader.SetFile( theFileName );
myReader.SetMeshId( -1 );
Driver_Mesh::Status aStatus;
list<string> aNames = myReader.GetMeshNames(aStatus);
SMESH::mesh_array_var aResult = new SMESH::mesh_array();
theStatus = (SMESH::DriverMED_ReadStatus)aStatus;
{ // open a new scope to make aPythonDump die before PythonDump in SMESH_Mesh::GetGroups()
// Python Dump
TPythonDump aPythonDump;
aPythonDump << "([";
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<string>::iterator it = aNames.begin(); it != aNames.end(); it++ ) {
// Python Dump
if (i > 0) aPythonDump << ", ";
// 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
aPythonDump << aSO;
} else {
// Python Dump
aPythonDump << "mesh_" << i;
}
// Read mesh data (groups are published automatically by ImportMEDFile())
SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( 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 );
meshServant->GetImpl().GetMeshDS()->Modified();
}
aStudyBuilder->CommitCommand();
}
// Update Python script
aPythonDump << "], status) = " << this << ".CreateMeshesFromMED(r'" << theFileName << "')";
}
// Dump creation of groups
for ( int i = 0; i < aResult->length(); ++i )
SMESH::ListOfGroups_var groups = aResult[ i ]->GetGroups();
return aResult._retn();
}
| SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL | ( | const char * | theFileName | ) | throw ( SALOME::SALOME_Exception ) |
SMESH_Gen_i.CreateMeshFromSTL.
Create mesh and import data from STL file
Definition at line 997 of file SMESH_Gen_i.cxx.
References SMESH_test5.aFileName, SMESH_Mesh_i.GetImpl(), SMESH_Mesh_i.ImportSTLFile(), MESSAGE, MYDEBUG, and SMESH_Nut.theFileName.
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshesFromSTL" );
SMESH::SMESH_Mesh_var aMesh = createMesh();
string aFileName;
// 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
TPythonDump() << aSO << " = " << this << ".CreateMeshesFromSTL(r'" << theFileName << "')";
}
}
SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() );
ASSERT( aServant );
aServant->ImportSTLFile( theFileName );
aServant->GetImpl().GetMeshDS()->Modified();
return aMesh._retn();
}
| SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromUNV | ( | const char * | theFileName | ) | throw ( SALOME::SALOME_Exception ) |
SMESH_Gen_i.CreateMeshFromUNV.
Create mesh and import data from UNV file
Definition at line 878 of file SMESH_Gen_i.cxx.
References SMESH_test5.aFileName, SMESH_Mesh_i.GetGroups(), SMESH_Mesh_i.GetImpl(), SMESH_Mesh_i.ImportUNVFile(), MESSAGE, MYDEBUG, and SMESH_Nut.theFileName.
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshesFromUNV" );
SMESH::SMESH_Mesh_var aMesh = createMesh();
string aFileName;
// 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
TPythonDump() << aSO << " = smeshgen.CreateMeshesFromUNV(r'" << theFileName << "')";
}
}
SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() );
ASSERT( aServant );
aServant->ImportUNVFile( theFileName );
// Dump creation of groups
SMESH::ListOfGroups_var groups = aServant->GetGroups();
aServant->GetImpl().GetMeshDS()->Modified();
return aMesh._retn();
}
| Engines::TMPFile * SMESH_Gen_i::DumpPython | ( | CORBA::Object_ptr | theStudy, |
| CORBA::Boolean | isPublished, | ||
| CORBA::Boolean | isMultiFile, | ||
| CORBA::Boolean & | isValidScript | ||
| ) | [virtual] |
Definition at line 514 of file SMESH_DumpPython.cxx.
References ComponentDataType(), DumpPython_impl(), and NotPublishedObjectName().
{
SALOMEDS::Study_var aStudy = SALOMEDS::Study::_narrow(theStudy);
if (CORBA::is_nil(aStudy))
return new Engines::TMPFile(0);
SALOMEDS::SObject_var aSO = aStudy->FindComponent(ComponentDataType());
if (CORBA::is_nil(aSO))
return new Engines::TMPFile(0);
// Map study entries to object names
Resource_DataMapOfAsciiStringAsciiString aMap;
Resource_DataMapOfAsciiStringAsciiString aMapNames;
//TCollection_AsciiString s ("qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPLKJHGFDSAZXCVBNM0987654321_");
SALOMEDS::ChildIterator_var Itr = aStudy->NewChildIterator(aSO);
for (Itr->InitEx(true); Itr->More(); Itr->Next()) {
SALOMEDS::SObject_var aValue = Itr->Value();
CORBA::String_var anID = aValue->GetID();
CORBA::String_var aName = aValue->GetName();
TCollection_AsciiString aGUIName ( (char*) aName.in() );
TCollection_AsciiString anEnrty ( (char*) anID.in() );
if (aGUIName.Length() > 0) {
aMapNames.Bind( anEnrty, aGUIName );
aMap.Bind( anEnrty, aGUIName );
}
}
// Get trace of restored study
//SALOMEDS::SObject_var aSO = SMESH_Gen_i::ObjectToSObject(theStudy, _this());
SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr =
aStudyBuilder->FindOrCreateAttribute(aSO, "AttributePythonObject");
char* oldValue = SALOMEDS::AttributePythonObject::_narrow(anAttr)->GetObject();
TCollection_AsciiString aSavedTrace (oldValue);
// Add trace of API methods calls and replace study entries by names
TCollection_AsciiString aScript;
aScript += DumpPython_impl(aStudy, aMap, aMapNames,
isPublished, isMultiFile, isValidScript, aSavedTrace);
int aLen = aScript.Length();
unsigned char* aBuffer = new unsigned char[aLen+1];
strcpy((char*)aBuffer, aScript.ToCString());
CORBA::Octet* anOctetBuf = (CORBA::Octet*)aBuffer;
Engines::TMPFile_var aStreamFile = new Engines::TMPFile(aLen+1, aLen+1, anOctetBuf, 1);
bool hasNotPublishedObjects = aScript.Location( NotPublishedObjectName(), 1, aLen);
isValidScript = isValidScript && !hasNotPublishedObjects;
return aStreamFile._retn();
}
| TCollection_AsciiString SMESH_Gen_i::DumpPython_impl | ( | SALOMEDS::Study_ptr | theStudy, |
| Resource_DataMapOfAsciiStringAsciiString & | theObjectNames, | ||
| Resource_DataMapOfAsciiStringAsciiString & | theNames, | ||
| bool | isPublished, | ||
| bool | isMultiFile, | ||
| bool & | aValidScript, | ||
| const TCollection_AsciiString & | theSavedTrace | ||
| ) |
DumpPython.
Definition at line 717 of file SMESH_DumpPython.cxx.
References SMESH_2smeshpy.ConvertScript(), SMESH.TPythonDump.CutoutLongString(), SMESH_2smeshpy.GenName(), SMESH_box.geom, Handle(), SMESH_test.ir, RemoveTabulation(), SMESH.TPythonDump.SMESHGenName(), and SMESH_2smeshpy.SmeshpyName().
Referenced by DumpPython().
{
int aStudyID = theStudy->StudyId();
TCollection_AsciiString helper; // to comfortably concatenate C strings
TCollection_AsciiString aSmeshpy( SMESH_2smeshpy::SmeshpyName() );
TCollection_AsciiString aSMESHGen( SMESH_2smeshpy::GenName() );
TCollection_AsciiString anOldGen( SMESH::TPythonDump::SMESHGenName() );
TCollection_AsciiString aScript;
if( isMultiFile )
aScript += "def RebuildData(theStudy):";
aScript += "\n\t";
aScript += helper + "aFilterManager = " + aSMESHGen + ".CreateFilterManager()\n\t";
aScript += helper + "aMeasurements = " + aSMESHGen + ".CreateMeasurements()\n\t";
if ( isPublished )
aScript += aSMESHGen + ".SetCurrentStudy(theStudy)";
else
aScript += aSMESHGen + ".SetCurrentStudy(None)";
// import python files corresponding to plugins
set<string> moduleNameSet;
map<string, GenericHypothesisCreator_i*>::iterator hyp_creator = myHypCreatorMap.begin();
for ( ; hyp_creator != myHypCreatorMap.end(); ++hyp_creator ) {
string moduleName = hyp_creator->second->GetModuleName();
bool newModule = moduleNameSet.insert( moduleName ).second;
if ( newModule )
aScript += helper + "\n\t" + "import " + (char*) moduleName.c_str();
}
// Dump trace of restored study
if (theSavedTrace.Length() > 0) {
// For the convertion of IDL API calls -> smesh.py API, "smesh" standing for SMESH_Gen
// was replaces with "smeshgen" (==TPythonDump::SMESHGenName()).
// Change "smesh" -> "smeshgen" in the trace saved before passage to smesh.py API
bool isNewVersion =
theSavedTrace.Location( anOldGen + ".", 1, theSavedTrace.Length() );
if ( !isNewVersion ) {
TCollection_AsciiString aSavedTrace( theSavedTrace );
TCollection_AsciiString aSmeshCall ( "smesh." ), gen( "gen" );
int beg, end = aSavedTrace.Length(), from = 1;
while ( from < end && ( beg = aSavedTrace.Location( aSmeshCall, from, end ))) {
char charBefore = ( beg == 1 ) ? ' ' : aSavedTrace.Value( beg - 1 );
if ( isspace( charBefore ) || charBefore == '=' ) { // "smesh." is not a part of a long word
aSavedTrace.Insert( beg + aSmeshCall.Length() - 1, gen );// "smesh" -> "smeshgen"
end += gen.Length();
}
from = beg + aSmeshCall.Length();
}
aScript += helper + "\n" + aSavedTrace;
}
else
// append a saved trace to the script
aScript += helper + "\n" + theSavedTrace;
}
// Dump trace of API methods calls
TCollection_AsciiString aNewLines = GetNewPythonLines(aStudyID);
if (aNewLines.Length() > 0) {
aScript += helper + "\n" + aNewLines;
}
// Convert IDL API calls into smesh.py API.
// Some objects are wrapped with python classes and
// Resource_DataMapOfAsciiStringAsciiString holds methods returning wrapped objects
Resource_DataMapOfAsciiStringAsciiString anEntry2AccessorMethod;
aScript = SMESH_2smeshpy::ConvertScript( aScript, anEntry2AccessorMethod, theObjectNames );
// Find entries to be replaced by names
Handle(TColStd_HSequenceOfInteger) aSeq = FindEntries(aScript);
Standard_Integer aLen = aSeq->Length();
if (aLen == 0)
return aScript;
// Replace entries by the names
GEOM::GEOM_Gen_ptr geom = GetGeomEngine();
TColStd_SequenceOfAsciiString seqRemoved;
Resource_DataMapOfAsciiStringAsciiString mapRemoved;
Standard_Integer objectCounter = 0, aStart = 1, aScriptLength = aScript.Length();
TCollection_AsciiString anUpdatedScript, anEntry, aName, aBaseName("smeshObj_");
// Collect names of GEOM objects to exclude same names for SMESH objects
GEOM::string_array_var aGeomNames = geom->GetAllDumpNames();
int ign = 0, nbgn = aGeomNames->length();
for (; ign < nbgn; ign++) {
aName = aGeomNames[ign];
theObjectNames.Bind(aName, "1");
}
bool importGeom = false;
for (Standard_Integer i = 1; i <= aLen; i += 2) {
anUpdatedScript += aScript.SubString(aStart, aSeq->Value(i) - 1);
anEntry = aScript.SubString(aSeq->Value(i), aSeq->Value(i + 1));
// is a GEOM object?
aName = geom->GetDumpName( anEntry.ToCString() );
if (aName.IsEmpty()) {
// is a SMESH object
if (theObjectNames.IsBound(anEntry)) {
// The Object is in Study
aName = theObjectNames.Find(anEntry);
// check validity of aName
bool isValidName = fixPythonName( aName );
if (theObjectNames.IsBound(aName) && anEntry != theObjectNames(aName)) {
// diff objects have same name - make a new name by appending a digit
TCollection_AsciiString aName2;
Standard_Integer i = 0;
do {
aName2 = aName + "_" + ++i;
} while (theObjectNames.IsBound(aName2) && anEntry != theObjectNames(aName2));
aName = aName2;
isValidName = false;
}
if ( !isValidName )
theObjectNames(anEntry) = aName;
} else {
// Removed Object
do {
aName = aBaseName + (++objectCounter);
} while (theObjectNames.IsBound(aName));
seqRemoved.Append(aName);
mapRemoved.Bind(anEntry, "1");
theObjectNames.Bind(anEntry, aName);
}
theObjectNames.Bind(aName, anEntry); // to detect same name of diff objects
}
else
{
importGeom = true;
}
anUpdatedScript += aName;
aStart = aSeq->Value(i + 1) + 1;
}
// set initial part of aSript
TCollection_AsciiString initPart = "import ";
if ( isMultiFile )
initPart += helper + "salome, ";
initPart += aSmeshpy + ", SMESH, SALOMEDS\n";
if ( importGeom && isMultiFile )
{
initPart += ("\n## import GEOM dump file ## \n"
"import string, os, sys, re\n"
"sys.path.insert( 0, os.path.dirname(__file__) )\n"
"exec(\"from \"+re.sub(\"SMESH$\",\"GEOM\",__name__)+\" import *\")\n");
}
anUpdatedScript.Insert ( 1, initPart );
// add final part of aScript
if (aSeq->Value(aLen) < aScriptLength)
anUpdatedScript += aScript.SubString(aSeq->Value(aLen) + 1, aScriptLength);
// Remove removed objects
if ( seqRemoved.Length() > 0 ) {
anUpdatedScript += "\n\t## some objects were removed";
anUpdatedScript += "\n\taStudyBuilder = theStudy.NewBuilder()";
}
for (int ir = 1; ir <= seqRemoved.Length(); ir++) {
anUpdatedScript += "\n\tSO = theStudy.FindObjectIOR(theStudy.ConvertObjectToIOR(";
anUpdatedScript += seqRemoved.Value(ir);
// for object wrapped by class of smesh.py
anEntry = theObjectNames( seqRemoved.Value(ir) );
if ( anEntry2AccessorMethod.IsBound( anEntry ) )
anUpdatedScript += helper + "." + anEntry2AccessorMethod( anEntry );
anUpdatedScript += "))\n\tif SO is not None: aStudyBuilder.RemoveObjectWithChildren(SO)";
}
// Set object names
anUpdatedScript += "\n\t## set object names";
// anUpdatedScript += "\n\t\tsmeshgui = salome.ImportComponentGUI(\"SMESH\")";
// anUpdatedScript += "\n\t\tsmeshgui.Init(theStudy._get_StudyId())";
// anUpdatedScript += "\n";
TCollection_AsciiString aGUIName;
Resource_DataMapOfAsciiStringAsciiString mapEntries;
for (Standard_Integer i = 1; i <= aLen; i += 2)
{
anEntry = aScript.SubString(aSeq->Value(i), aSeq->Value(i + 1));
aName = geom->GetDumpName( anEntry.ToCString() );
if (aName.IsEmpty() && // Not a GEOM object
theNames.IsBound(anEntry) &&
!mapEntries.IsBound(anEntry) && // Not yet processed
!mapRemoved.IsBound(anEntry)) // Was not removed
{
aName = theObjectNames.Find(anEntry);
aGUIName = theNames.Find(anEntry);
mapEntries.Bind(anEntry, aName);
anUpdatedScript += helper + "\n\t" + aSMESHGen + ".SetName(" + aName;
if ( anEntry2AccessorMethod.IsBound( anEntry ) )
anUpdatedScript += helper + "." + anEntry2AccessorMethod( anEntry );
anUpdatedScript += helper + ", '" + aGUIName + "')";
}
}
// Issue 0021249: removed (a similar block is dumped by SALOMEDSImpl_Study)
//anUpdatedScript += "\n\tif salome.sg.hasDesktop():";
//anUpdatedScript += "\n\t\tsalome.sg.updateObjBrowser(0)";
// -----------------------------------------------------------------
// store visual properties of displayed objects
// -----------------------------------------------------------------
if (isPublished)
{
//Output the script that sets up the visual parameters.
char* script = theStudy->GetDefaultScript(ComponentDataType(), "\t");
if (script && strlen(script) > 0) {
anUpdatedScript += "\n\n\t### Store presentation parameters of displayed objects\n";
anUpdatedScript += script;
CORBA::string_free(script);
}
}
if( isMultiFile )
anUpdatedScript += "\n\tpass";
anUpdatedScript += "\n";
if( !isMultiFile ) // remove unnecessary tabulation
RemoveTabulation( anUpdatedScript );
// -----------------------------------------------------------------
// put string literals describing patterns into separate functions
// -----------------------------------------------------------------
TCollection_AsciiString aLongString, aFunctionType;
int where = 1;
set< string > functionNameSet;
while ( SMESH::TPythonDump::CutoutLongString( anUpdatedScript, where, aLongString, aFunctionType ))
{
// make a python string literal
aLongString.Prepend(":\n\treturn '''\n");
aLongString += "\n\t'''\n\tpass\n";
TCollection_AsciiString functionName;
// check if the function returning this literal is already defined
int posAlready = anUpdatedScript.Location( aLongString, where, anUpdatedScript.Length() );
if ( posAlready ) // already defined
{
// find the function name
int functBeg = posAlready;
char* script = (char*) anUpdatedScript.ToCString() + posAlready - 1; // look at ":" after "def fuction()"
while ( *script != ' ' ) {
script--;
functBeg--;
}
functBeg++; // do not take ' '
posAlready--; // do not take ':'
functionName = anUpdatedScript.SubString( functBeg, posAlready );
}
else // not defined yet
{
// find a unique function name
fixPythonName( aFunctionType );
Standard_Integer nb = 0;
do functionName = aFunctionType + "_" + ( nb++ ) + "()";
while ( !functionNameSet.insert( functionName.ToCString() ).second );
// define function
TCollection_AsciiString funDef = helper + "def " + functionName + aLongString;
if ( isMultiFile )
{
anUpdatedScript += helper + "\n\n" + funDef;
}
else
{
funDef += "\n\n";
anUpdatedScript.Insert( 1, funDef);
where += funDef.Length();
}
}
anUpdatedScript.InsertBefore( where, functionName ); // call function
}
aValidScript = true;
return anUpdatedScript;
}
| SMESH::long_array * SMESH_Gen_i::Evaluate | ( | SMESH::SMESH_Mesh_ptr | theMesh, |
| GEOM::GEOM_Object_ptr | theShapeObject | ||
| ) | throw ( SALOME::SALOME_Exception ) |
Evaluate mesh on a shape and returns statistic of mesh elements Result array of number enityties.
Evaluate mesh on a shape
Definition at line 1675 of file SMESH_Gen_i.cxx.
References ex01_cube2build.algo, SMESH_Mesh_i.CheckGeomGroupModif(), COMPERR_ALGO_FAILED, SMESH.Entity_Last, SMESH.Entity_Node, SMESH_Mesh_i.GetImpl(), MESSAGE, MYDEBUG, and SMESH_Mesh.PseudoShape().
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Evaluate" );
if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
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 );
SMESH::long_array_var nbels = new SMESH::long_array;
nbels->length(SMESH::Entity_Last);
int i = SMESH::Entity_Node;
for (; i < SMESH::Entity_Last; i++)
nbels[i] = 0;
// Update Python script
TPythonDump() << "theNbElems = " << this << ".Evaluate( "
<< theMesh << ", " << theShapeObject << ")";
try {
// get mesh servant
SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
ASSERT( meshServant );
if ( meshServant ) {
// NPAL16168: "geometrical group edition from a submesh don't modifiy mesh computation"
meshServant->CheckGeomGroupModif();
// get local TopoDS_Shape
TopoDS_Shape myLocShape;
if(theMesh->HasShapeToMesh())
myLocShape = GeomObjectToShape( theShapeObject );
else
myLocShape = SMESH_Mesh::PseudoShape();
// call implementation compute
::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
MapShapeNbElems aResMap;
/*CORBA::Boolean ret =*/ myGen.Evaluate( myLocMesh, myLocShape, aResMap);
MapShapeNbElemsItr anIt = aResMap.begin();
for(; anIt!=aResMap.end(); anIt++) {
const vector<int>& aVec = (*anIt).second;
for(i = SMESH::Entity_Node; i < aVec.size(); i++) {
int nbElem = aVec[i];
if ( nbElem < 0 ) // algo failed, check that it has reported a message
{
SMESH_subMesh* sm = anIt->first;
SMESH_ComputeErrorPtr& error = sm->GetComputeError();
const SMESH_Algo* algo = myGen.GetAlgo( myLocMesh, sm->GetSubShape());
if ( (algo && !error.get()) || error->IsOK() )
error.reset( new SMESH_ComputeError( COMPERR_ALGO_FAILED,"Failed to evaluate",algo));
}
else
{
nbels[i] += aVec[i];
}
}
}
return nbels._retn();
}
}
catch ( std::bad_alloc ) {
INFOS( "Evaluate(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
INFOS( "Evaluate(): catch exception "<< S_ex.what() );
}
catch ( ... ) {
INFOS( "Evaluate(): unknown exception " );
}
return nbels._retn();
}
| GEOM::GEOM_Object_ptr SMESH_Gen_i::FindGeometryByMeshElement | ( | SMESH::SMESH_Mesh_ptr | theMesh, |
| CORBA::Long | theElementID | ||
| ) | throw ( SALOME::SALOME_Exception ) |
Return geometrical object the given element is built on.
- Parameters:
-
theMesh - the mesh the element is in theElementID - the element ID
- Return values:
-
GEOM.GEOM_Object_ptr - the found geom object
Definition at line 1822 of file SMESH_Gen_i.cxx.
References SMDS_Mesh.FindElement(), SMESH_box.geom, SMESH_Mesh_i.GetImpl(), SMESHDS_Mesh.IndexToShape(), PAL_MESH_041_mesh.mesh, and SMESH.SObjectToObject().
{
Unexpect aCatch(SALOME_SalomeException);
if ( CORBA::is_nil( theMesh ) )
THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference", SALOME::BAD_PARAM );
GEOM::GEOM_Object_var mainShape = theMesh->GetShapeToMesh();
GEOM::GEOM_Gen_ptr geomGen = GetGeomEngine();
// get a core mesh DS
SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
if ( meshServant && !geomGen->_is_nil() && !mainShape->_is_nil() )
{
::SMESH_Mesh & mesh = meshServant->GetImpl();
SMESHDS_Mesh* meshDS = mesh.GetMeshDS();
// find the element in mesh
if ( const SMDS_MeshElement * elem = meshDS->FindElement( theElementID ) ) {
// find a shape id by the element
if ( int shapeID = ::SMESH_MeshEditor( &mesh ).FindShape( elem )) {
// get a geom object by the shape id
GEOM::GEOM_Object_var geom = ShapeToGeomObject( meshDS->IndexToShape( shapeID ));
if ( geom->_is_nil() ) {
// try to find a published sub-shape
SALOMEDS::SObject_var mainSO = ObjectToSObject( myCurrentStudy, mainShape );
SALOMEDS::ChildIterator_var it;
if ( !mainSO->_is_nil() )
it = myCurrentStudy->NewChildIterator( mainSO );
if ( !it->_is_nil() ) {
for ( it->InitEx(true); it->More(); it->Next() ) {
GEOM::GEOM_Object_var subGeom =
GEOM::GEOM_Object::_narrow( SObjectToObject( it->Value() ));
if ( !subGeom->_is_nil() ) {
GEOM::ListOfLong_var subList = subGeom->GetSubShapeIndices();
if ( subList->length() == 1 && shapeID == subList[0] ) {
geom = subGeom;
break;
}
}
}
}
}
if ( geom->_is_nil() ) {
// explode
GEOM::GEOM_IShapesOperations_var op =
geomGen->GetIShapesOperations( GetCurrentStudyID() );
if ( !op->_is_nil() )
geom = op->GetSubShape( mainShape, shapeID );
}
if ( !geom->_is_nil() ) {
GeomObjectToShape( geom ); // let geom client remember the found shape
return geom._retn();
}
}
}
}
return GEOM::GEOM_Object::_nil();
}
| TopoDS_Shape SMESH_Gen_i::GeomObjectToShape | ( | GEOM::GEOM_Object_ptr | theGeomObject | ) |
Definition at line 230 of file SMESH_Gen_i_1.cxx.
References GetGeomEngine(), and GetShapeReader().
Referenced by SMESH_Mesh_i.addHypothesis(), AddHypothesisToShape(), SMESH_Pattern_i.ApplyTo3DBlock(), SMESH_Pattern_i.ApplyToFace(), CancelCompute(), SMESH_Mesh_i.createSubMesh(), SMESH_MeshEditor_i.DoubleNodeElemGroupInRegion(), SMESH_MeshEditor_i.DoubleNodeElemGroupsInRegion(), SMESH_MeshEditor_i.DoubleNodeElemInRegion(), SMESH_MeshEditor_i.extrusionAlongPath(), GetMeshOrSubmeshByShape(), SMESH_MeshEditor_i.LinearAnglesVariation(), Load(), SMESH_Pattern_i.LoadFrom3DBlock(), SMESH_Pattern_i.LoadFromFace(), SMESH_Mesh_i.newGroupShape(), SMESH_Mesh_i.removeHypothesis(), and SMESH.BelongToGenSurface_i.SetSurface().
{
TopoDS_Shape S;
if ( !theGeomObject->_is_nil() ) {
GEOM_Client* aClient = GetShapeReader();
GEOM::GEOM_Gen_ptr aGeomEngine = GetGeomEngine();
if ( aClient && !aGeomEngine->_is_nil () )
S = aClient->GetShape( aGeomEngine, theGeomObject );
}
return S;
}
| long SMESH_Gen_i::Get0DElementsGroupsTag | ( | ) | [static] |
Definition at line 139 of file SMESH_Gen_i_1.cxx.
References SMESH.Tag_0DElementsGroups.
Referenced by Load(), and Save().
{
return SMESH::Tag_0DElementsGroups;
}
| long SMESH_Gen_i::GetAlgorithmsRootTag | ( | ) | [static] |
Definition at line 64 of file SMESH_Gen_i_1.cxx.
References batchmode_smesh.Tag_AlgorithmsRoot.
Referenced by GetAlgoSO(), PublishHypothesis(), PublishMesh(), and Save().
{
return SMESH::Tag_AlgorithmsRoot;
}
| SALOMEDS::SObject_ptr SMESH_Gen_i::GetAlgoSO | ( | const ::SMESH_Algo * | algo | ) |
Find SObject for an algo.
Definition at line 1072 of file SMESH_Gen_i.cxx.
References ex01_cube2build.algo, ComponentDataType(), batchmode_smesh.father, GetAlgorithmsRootTag(), SMESH_Hypothesis_i.GetImpl(), myCurrentStudy, and SObjectToObject().
{
if ( algo ) {
if ( !myCurrentStudy->_is_nil() ) {
// find algo in the study
SALOMEDS::SComponent_var father = SALOMEDS::SComponent::_narrow
( myCurrentStudy->FindComponent( ComponentDataType() ) );
if ( !father->_is_nil() ) {
SALOMEDS::ChildIterator_var itBig = myCurrentStudy->NewChildIterator( father );
for ( ; itBig->More(); itBig->Next() ) {
SALOMEDS::SObject_var gotBranch = itBig->Value();
if ( gotBranch->Tag() == GetAlgorithmsRootTag() ) {
SALOMEDS::ChildIterator_var algoIt = myCurrentStudy->NewChildIterator( gotBranch );
for ( ; algoIt->More(); algoIt->Next() ) {
SALOMEDS::SObject_var algoSO = algoIt->Value();
CORBA::Object_var algoIOR = SObjectToObject( algoSO );
if ( !CORBA::is_nil( algoIOR )) {
SMESH_Hypothesis_i* impl = SMESH::DownCast<SMESH_Hypothesis_i*>( algoIOR );
if ( impl && impl->GetImpl() == algo )
return algoSO._retn();
}
} // loop on algo SO's
break;
} // if algo tag
} // SMESH component iterator
}
}
}
return SALOMEDS::SObject::_nil();
}
| SMESH::algo_error_array * SMESH_Gen_i::GetAlgoState | ( | SMESH::SMESH_Mesh_ptr | theMesh, |
| GEOM::GEOM_Object_ptr | theSubObject | ||
| ) | throw ( SALOME::SALOME_Exception ) |
Returns errors of hypotheses definintion.
- Parameters:
-
theMesh - the mesh theSubObject - the main or sub- shape
- Return values:
-
SMESH.algo_error_array* - sequence of errors
Definition at line 1266 of file SMESH_Gen_i.cxx.
References SMESH.AlgoStateError.algoDim, SMESH.AlgoStateError.algoName, SMESH_Mesh_i.ConvertHypothesisStatus(), SMESH_Mesh_i.GetImpl(), SMESH.AlgoStateError.isGlobalAlgo, MESSAGE, MYDEBUG, SMESH_Mesh.PseudoShape(), and SMESH.AlgoStateError.state.
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetAlgoState()" );
if ( CORBA::is_nil( theSubObject ) && theMesh->HasShapeToMesh())
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 );
SMESH::algo_error_array_var error_array = new SMESH::algo_error_array;
try {
SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
ASSERT( meshServant );
if ( meshServant ) {
TopoDS_Shape myLocShape;
if(theMesh->HasShapeToMesh())
myLocShape = GeomObjectToShape( theSubObject );
else
myLocShape = SMESH_Mesh::PseudoShape();
::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
list< ::SMESH_Gen::TAlgoStateError > error_list;
list< ::SMESH_Gen::TAlgoStateError >::iterator error;
// call ::SMESH_Gen::GetAlgoState()
myGen.GetAlgoState( myLocMesh, myLocShape, error_list );
error_array->length( error_list.size() );
int i = 0;
for ( error = error_list.begin(); error != error_list.end(); ++error )
{
// fill AlgoStateError structure
SMESH::AlgoStateError & errStruct = error_array[ i++ ];
errStruct.state = SMESH_Mesh_i::ConvertHypothesisStatus( error->_name );
errStruct.algoDim = error->_algoDim;
errStruct.isGlobalAlgo = error->_isGlobalAlgo;
errStruct.algoName = "";
SALOMEDS::SObject_var algoSO = GetAlgoSO( error->_algo );
if ( !algoSO->_is_nil() )
errStruct.algoName = algoSO->GetName();
}
}
}
catch ( SALOME_Exception& S_ex ) {
INFOS( "catch exception "<< S_ex.what() );
}
return error_array._retn();
}
| SMESH::MeshPreviewStruct * SMESH_Gen_i::GetBadInputElements | ( | SMESH::SMESH_Mesh_ptr | theMesh, |
| CORBA::Short | theSubShapeID | ||
| ) | throw ( SALOME::SALOME_Exception ) |
Return mesh elements preventing computation of a subshape.
Definition at line 1179 of file SMESH_Gen_i.cxx.
References SMDS_MeshElement.GetType(), SMDS_MeshElement.IsPoly(), PAL_MESH_041_mesh.mesh, MESSAGE, MYDEBUG, SMDS_MeshElement.NbNodes(), ex29_refine.node(), SMDS_MeshNode.X(), SMDS_MeshNode.Y(), and SMDS_MeshNode.Z().
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetBadInputElements()" );
if ( CORBA::is_nil( theMesh ) )
THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",SALOME::BAD_PARAM );
SMESH::MeshPreviewStruct_var result = new SMESH::MeshPreviewStruct;
try {
// mesh servant
if ( SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh ))
{
// mesh implementation
::SMESH_Mesh& mesh = meshServant->GetImpl();
// submesh by subshape id
if ( SMESH_subMesh * sm = mesh.GetSubMeshContaining( theSubShapeID ))
{
// compute error
SMESH_ComputeErrorPtr error = sm->GetComputeError();
if ( error && !error->myBadElements.empty())
{
typedef map<const SMDS_MeshElement*, int > TNode2LocalIDMap;
typedef TNode2LocalIDMap::iterator TNodeLocalID;
// get nodes of elements and count elements
TNode2LocalIDMap mapNode2LocalID;
list< TNodeLocalID > connectivity;
int i, nbElements = 0, nbConnNodes = 0;
list<const SMDS_MeshElement*>::iterator elemIt = error->myBadElements.begin();
list<const SMDS_MeshElement*>::iterator elemEnd = error->myBadElements.end();
for ( ; elemIt != elemEnd; ++elemIt, ++nbElements )
{
SMDS_ElemIteratorPtr nIt = (*elemIt)->nodesIterator();
while ( nIt->more() )
connectivity.push_back
( mapNode2LocalID.insert( make_pair( nIt->next(), ++nbConnNodes)).first );
}
// fill node coords and assign local ids to the nodes
int nbNodes = mapNode2LocalID.size();
result->nodesXYZ.length( nbNodes );
TNodeLocalID node2ID = mapNode2LocalID.begin();
for ( i = 0; i < nbNodes; ++i, ++node2ID ) {
node2ID->second = i;
const SMDS_MeshNode* node = (const SMDS_MeshNode*) node2ID->first;
result->nodesXYZ[i].x = node->X();
result->nodesXYZ[i].y = node->Y();
result->nodesXYZ[i].z = node->Z();
}
// fill connectivity
result->elementConnectivities.length( nbConnNodes );
list< TNodeLocalID >::iterator connIt = connectivity.begin();
for ( i = 0; i < nbConnNodes; ++i, ++connIt ) {
result->elementConnectivities[i] = (*connIt)->second;
}
// fill element types
result->elementTypes.length( nbElements );
for ( i = 0, elemIt = error->myBadElements.begin(); i <nbElements; ++i, ++elemIt )
{
const SMDS_MeshElement* elem = *elemIt;
result->elementTypes[i].SMDS_ElementType = (SMESH::ElementType) elem->GetType();
result->elementTypes[i].isPoly = elem->IsPoly();
result->elementTypes[i].nbNodesInElement = elem->NbNodes();
}
}
}
}
}
catch ( SALOME_Exception& S_ex ) {
INFOS( "catch exception "<< S_ex.what() );
}
return result._retn();
}
| SMESH::compute_error_array * SMESH_Gen_i::GetComputeErrors | ( | SMESH::SMESH_Mesh_ptr | theMesh, |
| GEOM::GEOM_Object_ptr | theShapeObject | ||
| ) | throw ( SALOME::SALOME_Exception ) |
Return errors of mesh computation.
Definition at line 1109 of file SMESH_Gen_i.cxx.
References SMESH.ComputeError.algoName, SMESH.ComputeError.code, SMESH.ComputeError.comment, SMESH.ComputeError.hasBadMesh, PAL_MESH_041_mesh.mesh, MESSAGE, MYDEBUG, SMESH_Mesh.PseudoShape(), SMESH_fixation.shape, and SMESH.ComputeError.subShapeID.
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetComputeErrors()" );
if ( CORBA::is_nil( theSubObject ) && theMesh->HasShapeToMesh())
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 );
SMESH::compute_error_array_var error_array = new SMESH::compute_error_array;
try {
if ( SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh ))
{
TopoDS_Shape shape;
if(theMesh->HasShapeToMesh())
shape = GeomObjectToShape( theSubObject );
else
shape = SMESH_Mesh::PseudoShape();
::SMESH_Mesh& mesh = meshServant->GetImpl();
error_array->length( mesh.GetMeshDS()->MaxShapeIndex() );
int nbErr = 0;
SMESH_subMesh *sm = mesh.GetSubMesh(shape);
const bool includeSelf = true, complexShapeFirst = true;
SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(includeSelf,
complexShapeFirst);
while ( smIt->more() )
{
sm = smIt->next();
if ( sm->GetSubShape().ShapeType() == TopAbs_VERTEX )
break;
SMESH_ComputeErrorPtr error = sm->GetComputeError();
if ( error && !error->IsOK() && error->myAlgo )
{
SMESH::ComputeError & errStruct = error_array[ nbErr++ ];
errStruct.code = -( error->myName < 0 ? error->myName + 1: error->myName ); // -1 -> 0
errStruct.comment = error->myComment.c_str();
errStruct.subShapeID = sm->GetId();
SALOMEDS::SObject_var algoSO = GetAlgoSO( error->myAlgo );
if ( !algoSO->_is_nil() )
errStruct.algoName = algoSO->GetName();
else
errStruct.algoName = error->myAlgo->GetName();
errStruct.hasBadMesh = !error->myBadElements.empty();
}
}
error_array->length( nbErr );
}
}
catch ( SALOME_Exception& S_ex ) {
INFOS( "catch exception "<< S_ex.what() );
}
return error_array._retn();
}
| SALOMEDS::Study_ptr SMESH_Gen_i::GetCurrentStudy | ( | ) |
Get current study
Definition at line 632 of file SMESH_Gen_i.cxx.
References GetCurrentStudyID(), MESSAGE, myCurrentStudy, and MYDEBUG.
Referenced by SMESH_Mesh_i.addGeomGroupData(), SMESH_Mesh_i.CheckGeomGroupModif(), SMESH_Mesh_i.checkGroupNames(), SMESH_Mesh_i.ConvertToStandalone(), SMESH_Mesh_i.CreateGroupServants(), SMESH_Mesh_i.GetLastParameters(), SMESH_Hypothesis_i.GetLastParameters(), SMESH_MEDMesh_i.getName(), GetParameters(), SMESH_NoteBook.GetReal(), getShapeByID(), getShapeByName(), getShapeNameByID(), SMESH_NoteBook.InitObjectMap(), SMESH_Hypothesis_i.IsPublished(), StdMeshers_LayerDistribution_i.LoadFrom(), SMESH_MeshEditor_i.makeMesh(), SMESH_Mesh_i.newGroupShape(), SMESH.TPythonDump.operator<<(), ParseParameters(), StdMeshers_ImportSource2D_i.SaveTo(), StdMeshers_ImportSource1D_i.SaveTo(), SMESH_GroupBase_i.SetName(), StdMeshers.StdMeshers_ImportSource1D.SetSourceEdges(), StdMeshers.StdMeshers_ImportSource2D.SetSourceFaces(), UpdateParameters(), and SMESH.TPythonDump.~TPythonDump().
{
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetCurrentStudy: study Id = " << GetCurrentStudyID() );
return SALOMEDS::Study::_duplicate( myCurrentStudy );
}
| StudyContext * SMESH_Gen_i::GetCurrentStudyContext | ( | ) |
SMESH_Gen_i.GetCurrentStudyContext.
Get current study context
Definition at line 645 of file SMESH_Gen_i.cxx.
References GetCurrentStudyID(), myCurrentStudy, and myStudyContextMap.
Referenced by GetObjectId(), IORToLocalPersistentID(), Load(), LocalPersistentIDToIOR(), RegisterObject(), and Save().
{
if ( !CORBA::is_nil( myCurrentStudy ) &&
myStudyContextMap.find( GetCurrentStudyID() ) != myStudyContextMap.end() )
return myStudyContextMap[ myCurrentStudy->StudyId() ];
else
return 0;
}
| int SMESH_Gen_i::GetCurrentStudyID | ( | ) |
Definition at line 4787 of file SMESH_Gen_i.cxx.
References myCurrentStudy.
Referenced by SMESH_Mesh_i.addGeomGroupData(), Close(), createMesh(), GetCurrentStudy(), GetCurrentStudyContext(), SMESH_Mesh_i.newGroupShape(), and SetCurrentStudy().
{
return myCurrentStudy->_is_nil() || myCurrentStudy->_non_existent() ? -1 : myCurrentStudy->StudyId();
}
| long SMESH_Gen_i::GetEdgeGroupsTag | ( | ) | [static] |
Definition at line 124 of file SMESH_Gen_i_1.cxx.
References SMESH.Tag_EdgeGroups.
Referenced by Load(), and Save().
{
return SMESH::Tag_EdgeGroups;
}
| long SMESH_Gen_i::GetFaceGroupsTag | ( | ) | [static] |
Definition at line 129 of file SMESH_Gen_i_1.cxx.
References SMESH.Tag_FaceGroups.
Referenced by Load(), and Save().
{
return SMESH::Tag_FaceGroups;
}
| GEOM::GEOM_Gen_ptr SMESH_Gen_i::GetGeomEngine | ( | ) | [static] |
GetGeomEngine [ static ].
Get GEOM.GEOM_Gen reference
Definition at line 232 of file SMESH_Gen_i.cxx.
Referenced by SMESH_Mesh_i.addGeomGroupData(), GeomObjectToShape(), getShapeByID(), getShapeByName(), loadGeomData(), SMESH_Mesh_i.newGroupShape(), SetCurrentStudy(), SMESH.LyingOnGeom_i.SetGeom(), SMESH.BelongToGeom_i.SetGeom(), and SMESH.BelongToSurface_i.SetSurface().
{
//CCRT GEOM::GEOM_Gen_var aGeomEngine =
//CCRT GEOM::GEOM_Gen::_narrow( GetLCC()->FindOrLoad_Component("FactoryServer","GEOM") );
//CCRT return aGeomEngine._retn();
if(CORBA::is_nil(myGeomGen))
{
Engines::EngineComponent_ptr temp=GetLCC()->FindOrLoad_Component("FactoryServer","GEOM");
myGeomGen=GEOM::GEOM_Gen::_narrow(temp);
}
return myGeomGen;
}
| GEOM::GEOM_Object_ptr SMESH_Gen_i::GetGeometryByMeshElement | ( | SMESH::SMESH_Mesh_ptr | theMesh, |
| CORBA::Long | theElementID, | ||
| const char * | theGeomName | ||
| ) | throw ( SALOME::SALOME_Exception ) |
Return geometrical object the given element is built on.
- Parameters:
-
theMesh - the mesh the element is in theElementID - the element ID theGeomName - the name of the result geom object if it is not yet published
- Return values:
-
GEOM.GEOM_Object_ptr - the found or just published geom object
Definition at line 1764 of file SMESH_Gen_i.cxx.
References SMESH_box.geom, SMESH_demo_hexa2_upd.list, and SMESH.SObjectToObject().
{
Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_var geom = FindGeometryByMeshElement(theMesh, theElementID);
if ( !geom->_is_nil() ) {
GEOM::GEOM_Object_var mainShape = theMesh->GetShapeToMesh();
GEOM::GEOM_Gen_ptr geomGen = GetGeomEngine();
// try to find the corresponding SObject
SALOMEDS::SObject_var SObj = ObjectToSObject( myCurrentStudy, geom.in() );
if ( SObj->_is_nil() ) // submesh can be not found even if published
{
// try to find published submesh
GEOM::ListOfLong_var list = geom->GetSubShapeIndices();
if ( !geom->IsMainShape() && list->length() == 1 ) {
SALOMEDS::SObject_var mainSO = ObjectToSObject( myCurrentStudy, mainShape );
SALOMEDS::ChildIterator_var it;
if ( !mainSO->_is_nil() )
it = myCurrentStudy->NewChildIterator( mainSO );
if ( !it->_is_nil() ) {
for ( it->InitEx(true); SObj->_is_nil() && it->More(); it->Next() ) {
GEOM::GEOM_Object_var subGeom =
GEOM::GEOM_Object::_narrow( SObjectToObject( it->Value() ));
if ( !subGeom->_is_nil() ) {
GEOM::ListOfLong_var subList = subGeom->GetSubShapeIndices();
if ( subList->length() == 1 && list[0] == subList[0] ) {
SObj = it->Value();
geom = subGeom;
}
}
}
}
}
}
if ( SObj->_is_nil() ) // publish a new subshape
SObj = geomGen->AddInStudy( myCurrentStudy, geom, theGeomName, mainShape );
// return only published geometry
if ( !SObj->_is_nil() )
return geom._retn();
}
return GEOM::GEOM_Object::_nil();
}
| SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::GetHypothesisParameterValues | ( | const char * | theHypType, |
| const char * | theLibName, | ||
| SMESH::SMESH_Mesh_ptr | theMesh, | ||
| GEOM::GEOM_Object_ptr | theGeom, | ||
| CORBA::Boolean | byMesh | ||
| ) | throw ( SALOME::SALOME_Exception ) |
Return a hypothesis holding parameter values corresponding either to the mesh existing on the given geometry or to size of the geometry.
- Parameters:
-
theHypType - hypothesis type name theLibName - plugin library name theMesh - The mesh of interest theGeom - The shape to get parameter values from
- Return values:
-
SMESH.SMESH_Hypothesis_ptr - The returned hypothesis may be the one existing in a study and used to compute the mesh, or a temporary one created just to pass parameter values
Definition at line 698 of file SMESH_Gen_i.cxx.
References SMESH_Hypothesis.TDefaults._elemLength, SMESH_Hypothesis_i.GetImpl(), SMESH_Mesh_i.GetImpl(), smeshDC.GetName(), SMESH_Mesh.GetShapeDiagonalSize(), SMESH_demo_hexa2_upd.hyp, PAL_MESH_041_mesh.mesh, SMESH_Mesh_i.NbNodes(), and SMESH_fixation.shape.
{
Unexpect aCatch(SALOME_SalomeException);
if ( byMesh && CORBA::is_nil( theMesh ) )
return SMESH::SMESH_Hypothesis::_nil();
if ( byMesh && CORBA::is_nil( theGeom ) )
return SMESH::SMESH_Hypothesis::_nil();
// -----------------------------------------------
// find hypothesis used to mesh theGeom
// -----------------------------------------------
// get mesh and shape
SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
TopoDS_Shape shape = GeomObjectToShape( theGeom );
if ( byMesh && ( !meshServant || meshServant->NbNodes()==0 || shape.IsNull() ))
return SMESH::SMESH_Hypothesis::_nil();
::SMESH_Mesh* mesh = meshServant ? &meshServant->GetImpl() : (::SMESH_Mesh*)0;
// create a temporary hypothesis to know its dimention
SMESH::SMESH_Hypothesis_var tmpHyp = this->createHypothesis( theHypType, theLibName );
SMESH_Hypothesis_i* hypServant = SMESH::DownCast<SMESH_Hypothesis_i*>( tmpHyp );
if ( !hypServant )
return SMESH::SMESH_Hypothesis::_nil();
::SMESH_Hypothesis* hyp = hypServant->GetImpl();
if ( byMesh ) {
// look for a hypothesis of theHypType used to mesh the shape
if ( myGen.GetShapeDim( shape ) == hyp->GetDim() )
{
// check local shape
SMESH::ListOfHypothesis_var aHypList = theMesh->GetHypothesisList( theGeom );
int nbLocalHyps = aHypList->length();
for ( int i = 0; i < nbLocalHyps; i++ )
if ( strcmp( theHypType, aHypList[i]->GetName() ) == 0 ) // FOUND local!
return SMESH::SMESH_Hypothesis::_duplicate( aHypList[i] );
// check super shapes
TopTools_ListIteratorOfListOfShape itShape( mesh->GetAncestors( shape ));
while ( nbLocalHyps == 0 && itShape.More() ) {
GEOM::GEOM_Object_ptr geomObj = ShapeToGeomObject( itShape.Value() );
if ( ! CORBA::is_nil( geomObj )) {
SMESH::ListOfHypothesis_var aHypList = theMesh->GetHypothesisList( geomObj );
nbLocalHyps = aHypList->length();
for ( int i = 0; i < nbLocalHyps; i++ )
if ( strcmp( theHypType, aHypList[i]->GetName() ) == 0 ) // FOUND global!
return SMESH::SMESH_Hypothesis::_duplicate( aHypList[i] );
}
itShape.Next();
}
}
// let the temporary hypothesis find out some how parameter values by mesh
if ( hyp->SetParametersByMesh( mesh, shape ))
return SMESH::SMESH_Hypothesis::_duplicate( tmpHyp );
}
else {
double diagonal = 0;
if ( mesh )
diagonal = mesh->GetShapeDiagonalSize();
else
diagonal = ::SMESH_Mesh::GetShapeDiagonalSize( shape );
::SMESH_Hypothesis::TDefaults dflts;
dflts._elemLength = diagonal / myGen.GetBoundaryBoxSegmentation();
dflts._nbSegments = myGen.GetDefaultNbSegments();
// let the temporary hypothesis initialize it's values
if ( hyp->SetParametersByDefaults( dflts, mesh ))
return SMESH::SMESH_Hypothesis::_duplicate( tmpHyp );
}
return SMESH::SMESH_Hypothesis::_nil();
}
| long SMESH_Gen_i::GetHypothesisRootTag | ( | ) | [static] |
Get...Tag [ static ].
Methods which determine SMESH data model structure
Definition at line 59 of file SMESH_Gen_i_1.cxx.
References batchmode_smesh.Tag_HypothesisRoot.
Referenced by PublishHypothesis(), and Save().
{
return SMESH::Tag_HypothesisRoot;
}
| SALOME_LifeCycleCORBA * SMESH_Gen_i::GetLCC | ( | ) | [static] |
| CORBA::Boolean SMESH_Gen_i::GetMEDVersion | ( | const char * | theFileName, |
| SMESH::MED_VERSION & | theVersion | ||
| ) |
Get MED version of the file by its name
Definition at line 2470 of file SMESH_Gen_i.cxx.
References SMESH.MED_V2_1, and SMESH.MED_V2_2.
{
theVersion = SMESH::MED_V2_1;
MED::EVersion aVersion = MED::GetVersionId( theFileName );
switch( aVersion ) {
case MED::eV2_1 : theVersion = SMESH::MED_V2_1; return true;
case MED::eV2_2 : theVersion = SMESH::MED_V2_2; return true;
case MED::eVUnknown : return false;
}
return false;
}
| SMESH::string_array * SMESH_Gen_i::GetMeshNames | ( | const char * | theFileName | ) |
Get names of meshes defined in file with the specified name
Definition at line 2490 of file SMESH_Gen_i.cxx.
{
SMESH::string_array_var aResult = new SMESH::string_array();
MED::PWrapper aMed = MED::CrWrapper( theFileName );
MED::TErr anErr;
MED::TInt aNbMeshes = aMed->GetNbMeshes( &anErr );
if( anErr >= 0 ) {
aResult->length( aNbMeshes );
for( MED::TInt i = 0; i < aNbMeshes; i++ ) {
MED::PMeshInfo aMeshInfo = aMed->GetPMeshInfo( i+1 );
aResult[i] = CORBA::string_dup( aMeshInfo->GetName().c_str() );
}
}
return aResult._retn();
}
| SALOMEDS::SObject_ptr SMESH_Gen_i::GetMeshOrSubmeshByShape | ( | SALOMEDS::Study_ptr | theStudy, |
| SMESH::SMESH_Mesh_ptr | theMesh, | ||
| GEOM::GEOM_Object_ptr | theShape | ||
| ) |
Definition at line 772 of file SMESH_Gen_i_1.cxx.
References SMESH_fixation.aShape, GeomObjectToShape(), SMESH_Mesh_i.GetImpl(), SMESH_Mesh.GetMeshDS(), SMESH_Mesh_i.getSubMesh(), MESSAGE, ObjectToSObject(), SMESH_Mesh.PseudoShape(), SMESHDS_Mesh.ShapeToIndex(), and SMESHDS_Mesh.ShapeToMesh().
Referenced by AddHypothesisToShape(), and RemoveHypothesisFromShape().
{
if(MYDEBUG) MESSAGE("GetMeshOrSubmeshByShape")
SALOMEDS::SObject_var aMeshOrSubMesh;
if (theMesh->_is_nil() || ( theShape->_is_nil() && theMesh->HasShapeToMesh()))
return aMeshOrSubMesh._retn();
TopoDS_Shape aShape;
if(theMesh->HasShapeToMesh())
aShape = GeomObjectToShape( theShape );
else
aShape = SMESH_Mesh::PseudoShape();
SMESH_Mesh_i* mesh_i = objectToServant<SMESH_Mesh_i>( theMesh );
if ( !aShape.IsNull() && mesh_i && mesh_i->GetImpl().GetMeshDS() ) {
SMESHDS_Mesh* meshDS = mesh_i->GetImpl().GetMeshDS();
if ( aShape.IsSame( meshDS->ShapeToMesh() ))
aMeshOrSubMesh = ObjectToSObject( theStudy, theMesh );
else {
int shapeID = meshDS->ShapeToIndex( aShape );
SMESH::SMESH_subMesh_var aSubMesh = mesh_i->getSubMesh(shapeID);
if ( !aSubMesh->_is_nil() )
aMeshOrSubMesh = ObjectToSObject( theStudy, aSubMesh );
}
}
if(MYDEBUG) MESSAGE("GetMeshOrSubmeshByShape--END")
return aMeshOrSubMesh._retn();
}
| TCollection_AsciiString SMESH_Gen_i::GetNewPythonLines | ( | int | theStudyID | ) |
GetNewPythonLines.
Definition at line 1008 of file SMESH_DumpPython.cxx.
References Handle(), and myPythonScripts.
Referenced by SavePython().
{
TCollection_AsciiString aScript;
// Dump trace of API methods calls
if (myPythonScripts.find(theStudyID) != myPythonScripts.end()) {
Handle(TColStd_HSequenceOfAsciiString) aPythonScript = myPythonScripts[theStudyID];
Standard_Integer istr, aLen = aPythonScript->Length();
for (istr = 1; istr <= aLen; istr++) {
aScript += "\n\t";
aScript += aPythonScript->Value(istr);
}
aScript += "\n";
}
return aScript;
}
| long SMESH_Gen_i::GetNodeGroupsTag | ( | ) | [static] |
Definition at line 119 of file SMESH_Gen_i_1.cxx.
References SMESH.Tag_NodeGroups.
Referenced by Load(), PublishGroup(), and Save().
{
return SMESH::Tag_NodeGroups;
}
| SALOME_NamingService * SMESH_Gen_i::GetNS | ( | ) | [static] |
GetNS [ static ].
Get SALOME_NamingService object
Definition at line 200 of file SMESH_Gen_i.cxx.
Referenced by PublishComponent(), and SMESH_Gen_i().
template<class TInterface >
| TInterface::_var_type SMESH_Gen_i.GetObjectByOldId | ( | const int | oldID | ) |
Definition at line 513 of file SMESH_Gen_i.hxx.
{
if ( StudyContext* myStudyContext = GetCurrentStudyContext() ) {
string ior = myStudyContext->getIORbyOldId( oldID );
if ( !ior.empty() )
return TInterface::_narrow(GetORB()->string_to_object( ior.c_str() ));
}
return TInterface::_nil();
}
| CORBA::Long SMESH_Gen_i::GetObjectId | ( | CORBA::Object_ptr | theObject | ) |
Return id of registered object.
- Parameters:
-
theObject - the Object
- Return values:
-
int - Object id
Definition at line 4758 of file SMESH_Gen_i.cxx.
References StudyContext.findId(), GetCurrentStudyContext(), and GetORB().
{
StudyContext* myStudyContext = GetCurrentStudyContext();
if ( myStudyContext && !CORBA::is_nil( theObject )) {
string iorString = GetORB()->object_to_string( theObject );
return myStudyContext->findId( iorString );
}
return 0;
}
| static CORBA::ORB_var SMESH_Gen_i.GetORB | ( | ) | [static] |
Definition at line 141 of file SMESH_Gen_i.hxx.
Referenced by SMESH_Mesh_i.ConvertToStandalone(), GetObjectId(), Load(), ObjectToSObject(), publish(), RegisterObject(), Save(), SetName(), and ShapeToGeomObject().
{ return myOrb;}
| char * SMESH_Gen_i::GetParameters | ( | CORBA::Object_ptr | theObject | ) |
Definition at line 1024 of file SMESH_Gen_i_1.cxx.
References GetCurrentStudy(), and ObjectToSObject().
Referenced by SMESH_Mesh_i.GetParameters(), and SMESH_Hypothesis_i.GetParameters().
{
TCollection_AsciiString aResult;
SALOMEDS::Study_ptr aStudy = GetCurrentStudy();
SALOMEDS::SObject_var aSObj = ObjectToSObject(aStudy,theObject);
if(!aStudy->_is_nil() &&
!CORBA::is_nil(theObject) &&
!aSObj->_is_nil()){
SALOMEDS::GenericAttribute_var anAttr;
if ( aSObj->FindAttribute(anAttr, "AttributeString")) {
aResult = TCollection_AsciiString(SALOMEDS::AttributeString::_narrow(anAttr)->Value());
}
}
return CORBA::string_dup( aResult.ToCString() );
}
| SMESH::SMESH_Pattern_ptr SMESH_Gen_i::GetPattern | ( | ) |
Create pattern mapper
Definition at line 70 of file SMESH_Pattern_i.cxx.
{
// Update Python script
TPythonDump() << "pattern = " << this << ".GetPattern()";
SMESH_Pattern_i* i = new SMESH_Pattern_i( this );
SMESH::SMESH_Pattern_var anObj = i->_this();
return anObj._retn();
}
| static PortableServer::POA_var SMESH_Gen_i.GetPOA | ( | ) | [static] |
Definition at line 143 of file SMESH_Gen_i.hxx.
Referenced by SMESH_Mesh_i.ConvertToStandalone(), SMESH_Mesh_i.createGroup(), SMESH_Mesh_i.CreateGroupServants(), and createMesh().
{ return myPoa;}
| long SMESH_Gen_i::GetRefOnAppliedAlgorithmsTag | ( | ) | [static] |
Definition at line 79 of file SMESH_Gen_i_1.cxx.
References batchmode_smesh.Tag_RefOnAppliedAlgorithms.
Referenced by AddHypothesisToShape(), and Save().
{
return SMESH::Tag_RefOnAppliedAlgorithms;
}
| long SMESH_Gen_i::GetRefOnAppliedHypothesisTag | ( | ) | [static] |
Definition at line 74 of file SMESH_Gen_i_1.cxx.
References batchmode_smesh.Tag_RefOnAppliedHypothesis.
Referenced by AddHypothesisToShape(), and Save().
{
return SMESH::Tag_RefOnAppliedHypothesis;
}
| long SMESH_Gen_i::GetRefOnShapeTag | ( | ) | [static] |
Definition at line 69 of file SMESH_Gen_i_1.cxx.
References batchmode_smesh.Tag_RefOnShape.
Referenced by PublishMesh(), SMESH_Mesh_i.RemoveSubMesh(), and Save().
{
return SMESH::Tag_RefOnShape;
}
| PortableServer::ServantBase_var SMESH_Gen_i::GetServant | ( | CORBA::Object_ptr | theObject | ) | [static] |
GetServant [ static ].
Get servant of the CORBA object
Definition at line 150 of file SMESH_Gen_i.cxx.
Referenced by SMESH_MeshEditor_i.BestSplit(), CancelCompute(), SMESH_Mesh_i.ConvertToStandalone(), SMESH.DownCast(), SMESH_Pattern_i.getMesh(), Load(), objectToServant(), SMESH_MeshEditor_i.QuadToTri(), SMESH_Mesh_i.RemoveGroup(), SMESH_Mesh_i.RemoveGroupWithContents(), Save(), SMESH_MeshEditor_i.TriToQuad(), and SMESH_Mesh_i.~SMESH_Mesh_i().
| GEOM_Client * SMESH_Gen_i::GetShapeReader | ( | ) |
Get shape reader
Definition at line 509 of file SMESH_Gen_i.cxx.
References myShapeReader.
Referenced by GeomObjectToShape(), getShapeByID(), getShapeByName(), SMESH_Mesh_i.newGroupShape(), SMESH.LyingOnGeom_i.SetGeom(), SMESH.BelongToGeom_i.SetGeom(), SMESH.BelongToSurface_i.SetSurface(), and ShapeToGeomObject().
{
// create shape reader if necessary
if ( !myShapeReader )
myShapeReader = new GEOM_Client(GetContainerRef());
ASSERT( myShapeReader );
return myShapeReader;
}
| static SMESH_Gen_i* SMESH_Gen_i.GetSMESHGen | ( | ) | [static] |
Definition at line 139 of file SMESH_Gen_i.hxx.
Referenced by SMESH_MeshEditor_i.DoubleNodeElemGroupInRegion(), SMESH_MeshEditor_i.DoubleNodeElemGroupsInRegion(), SMESH_MeshEditor_i.DoubleNodeElemInRegion(), SMESH_MeshEditor_i.extrusionAlongPath(), StdMeshers_ObjRefUlils.GeomObjectToShape(), SMESH_Mesh_i.GetLastParameters(), SMESH_Hypothesis_i.GetLastParameters(), SMESH_MEDMesh_i.getName(), SMESH_Mesh_i.GetParameters(), SMESH_Hypothesis_i.GetParameters(), SMESH_NoteBook.GetReal(), getShapeByID(), getShapeByName(), getShapeNameByID(), SMESH_NoteBook.InitObjectMap(), SMESH_Hypothesis_i.IsPublished(), SMESH_MeshEditor_i.LinearAnglesVariation(), StdMeshers_LayerDistribution_i.LoadFrom(), StdMeshers_ObjRefUlils.LoadFromStream(), StdMeshers_ObjRefUlils.LoadObjectFromStream(), SMESH_MeshEditor_i.MakeBoundaryElements(), SMESH_MeshEditor_i.makeMesh(), SMESH.TPythonDump.operator<<(), StdMeshers_ImportSource2D_i.SaveTo(), StdMeshers_ImportSource1D_i.SaveTo(), StdMeshers_ObjRefUlils.SaveToStream(), SMESH.LyingOnGeom_i.SetGeom(), SMESH.BelongToGeom_i.SetGeom(), StdMeshers_LayerDistribution_i.SetLayerDistribution(), SMESH_Mesh_i.SetParameters(), SMESH_Hypothesis_i.SetParameters(), StdMeshers.StdMeshers_ImportSource1D.SetSourceEdges(), StdMeshers.StdMeshers_ImportSource2D.SetSourceFaces(), SMESH.BelongToGenSurface_i.SetSurface(), SMESH.BelongToSurface_i.SetSurface(), StdMeshers_ObjRefUlils.ShapeToGeomObject(), and SMESH.TPythonDump.~TPythonDump().
{ return mySMESHGen;}
| long SMESH_Gen_i::GetSubMeshOnCompoundTag | ( | ) | [static] |
Definition at line 104 of file SMESH_Gen_i_1.cxx.
References batchmode_smesh.Tag_SubMeshOnCompound.
Referenced by Load(), PublishSubMesh(), and Save().
{
return SMESH::Tag_SubMeshOnCompound;
}
| long SMESH_Gen_i::GetSubMeshOnEdgeTag | ( | ) | [static] |
Definition at line 89 of file SMESH_Gen_i_1.cxx.
References batchmode_smesh.Tag_SubMeshOnEdge.
Referenced by Load(), PublishSubMesh(), and Save().
{
return SMESH::Tag_SubMeshOnEdge;
}
| long SMESH_Gen_i::GetSubMeshOnFaceTag | ( | ) | [static] |
Definition at line 94 of file SMESH_Gen_i_1.cxx.
References batchmode_smesh.Tag_SubMeshOnFace.
Referenced by Load(), PublishSubMesh(), and Save().
{
return SMESH::Tag_SubMeshOnFace;
}
| long SMESH_Gen_i::GetSubMeshOnShellTag | ( | ) | [static] |
Definition at line 114 of file SMESH_Gen_i_1.cxx.
References SMESH.Tag_SubMeshOnShell.
Referenced by Load(), PublishSubMesh(), and Save().
{
return SMESH::Tag_SubMeshOnShell;
}
| long SMESH_Gen_i::GetSubMeshOnSolidTag | ( | ) | [static] |
Definition at line 99 of file SMESH_Gen_i_1.cxx.
References batchmode_smesh.Tag_SubMeshOnSolid.
Referenced by Load(), PublishSubMesh(), and Save().
{
return SMESH::Tag_SubMeshOnSolid;
}
| long SMESH_Gen_i::GetSubMeshOnVertexTag | ( | ) | [static] |
Definition at line 84 of file SMESH_Gen_i_1.cxx.
References batchmode_smesh.Tag_SubMeshOnVertex.
Referenced by Load(), PublishSubMesh(), and Save().
{
return SMESH::Tag_SubMeshOnVertex;
}
| long SMESH_Gen_i::GetSubMeshOnWireTag | ( | ) | [static] |
Definition at line 109 of file SMESH_Gen_i_1.cxx.
References SMESH.Tag_SubMeshOnWire.
Referenced by Load(), PublishSubMesh(), and Save().
{
return SMESH::Tag_SubMeshOnWire;
}
| SMESH::long_array * SMESH_Gen_i::GetSubShapesId | ( | GEOM::GEOM_Object_ptr | theMainShapeObject, |
| const SMESH::object_array & | theListOfSubShapeObject | ||
| ) | throw ( SALOME::SALOME_Exception ) |
Get sub-shapes unique ID's list
Definition at line 1325 of file SMESH_Gen_i.cxx.
References MESSAGE, and MYDEBUG.
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetSubShapesId" );
SMESH::long_array_var shapesId = new SMESH::long_array;
set<int> setId;
if ( CORBA::is_nil( theMainShapeObject ) )
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
SALOME::BAD_PARAM );
try
{
TopoDS_Shape myMainShape = GeomObjectToShape(theMainShapeObject);
TopTools_IndexedMapOfShape myIndexToShape;
TopExp::MapShapes(myMainShape,myIndexToShape);
for ( int i = 0; i < theListOfSubShapeObject.length(); i++ )
{
GEOM::GEOM_Object_var aShapeObject
= GEOM::GEOM_Object::_narrow(theListOfSubShapeObject[i]);
if ( CORBA::is_nil( aShapeObject ) )
THROW_SALOME_CORBA_EXCEPTION ("bad shape object reference", \
SALOME::BAD_PARAM );
TopoDS_Shape locShape = GeomObjectToShape(aShapeObject);
for (TopExp_Explorer exp(locShape,TopAbs_FACE); exp.More(); exp.Next())
{
const TopoDS_Face& F = TopoDS::Face(exp.Current());
setId.insert(myIndexToShape.FindIndex(F));
if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(F));
}
for (TopExp_Explorer exp(locShape,TopAbs_EDGE); exp.More(); exp.Next())
{
const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
setId.insert(myIndexToShape.FindIndex(E));
if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(E));
}
for (TopExp_Explorer exp(locShape,TopAbs_VERTEX); exp.More(); exp.Next())
{
const TopoDS_Vertex& V = TopoDS::Vertex(exp.Current());
setId.insert(myIndexToShape.FindIndex(V));
if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(V));
}
}
shapesId->length(setId.size());
set<int>::iterator iind;
int i=0;
for (iind = setId.begin(); iind != setId.end(); iind++)
{
if(MYDEBUG) SCRUTE((*iind));
shapesId[i] = (*iind);
if(MYDEBUG) SCRUTE(shapesId[i]);
i++;
}
}
catch (SALOME_Exception& S_ex)
{
THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
}
return shapesId._retn();
}
| long SMESH_Gen_i::GetVolumeGroupsTag | ( | ) | [static] |
Definition at line 134 of file SMESH_Gen_i_1.cxx.
References SMESH.Tag_VolumeGroups.
Referenced by Load(), and Save().
{
return SMESH::Tag_VolumeGroups;
}
| char * SMESH_Gen_i::IORToLocalPersistentID | ( | SALOMEDS::SObject_ptr | theSObject, |
| const char * | IORString, | ||
| CORBA::Boolean | isMultiFile, | ||
| CORBA::Boolean | isASCII | ||
| ) |
SMESH_Gen_i.IORToLocalPersistentID.
Transform data from transient form to persistent
Definition at line 4692 of file SMESH_Gen_i.cxx.
References StudyContext.findId(), GetCurrentStudyContext(), MESSAGE, and MYDEBUG.
{
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( "" );
}
| CORBA::Boolean SMESH_Gen_i::IsEmbeddedMode | ( | ) |
Get current mode
Definition at line 575 of file SMESH_Gen_i.cxx.
References myIsEmbeddedMode.
{
return myIsEmbeddedMode;
}
| CORBA::Boolean SMESH_Gen_i::IsReadyToCompute | ( | SMESH::SMESH_Mesh_ptr | theMesh, |
| GEOM::GEOM_Object_ptr | theShapeObject | ||
| ) | throw ( SALOME::SALOME_Exception ) |
Returns true if mesh contains enough data to be computed
Definition at line 1033 of file SMESH_Gen_i.cxx.
References SMESH_Mesh_i.GetImpl(), MESSAGE, and MYDEBUG.
{
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<SMESH_Mesh_i*>( 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;
}
| bool SMESH_Gen_i::Load | ( | SALOMEDS::SComponent_ptr | theComponent, |
| const SALOMEDS::TMPFile & | theStream, | ||
| const char * | theURL, | ||
| bool | isMultiFile | ||
| ) |
Load SMESH module's data
Definition at line 3563 of file SMESH_Gen_i.cxx.
References SMESHDS_SubMesh.AddElement(), SMESH_Mesh_i.addHypothesis(), SMESHDS_SubMesh.AddNode(), SMESH_controls.aGroup, SMESH_fixation.aShape, DriverMED_R_SMESHDS_Mesh.CreateAllSubMeshes(), SMESH_Mesh_i.createGroup(), createHypothesis(), createMesh(), SMESH_Mesh_i.createSubMesh(), SMDS_Mesh.elementsIterator(), SMESH_flight_skin.filename, StudyContext.findId(), SMDS_Mesh.FindNode(), GeomObjectToShape(), Get0DElementsGroupsTag(), GetCurrentStudyContext(), GetEdgeGroupsTag(), GetFaceGroupsTag(), DriverMED_R_SMESHDS_Mesh.GetGroup(), SMESH_Mesh_i.GetImpl(), StudyContext.getIORbyOldId(), SMESH_GroupBase_i.GetLocalID(), GetNodeGroupsTag(), StudyContext.getOldId(), GetORB(), SMDS_MeshNode.GetPosition(), GetServant(), SMESH_Mesh_i.GetShapeToMesh(), GetSubMeshOnCompoundTag(), GetSubMeshOnEdgeTag(), GetSubMeshOnFaceTag(), GetSubMeshOnShellTag(), GetSubMeshOnSolidTag(), GetSubMeshOnVertexTag(), GetSubMeshOnWireTag(), SMDS_Position.GetTypeOfPosition(), GetVolumeGroupsTag(), SMESH_Mesh_i.HasShapeToMesh(), SMESH_demo_hexa2_upd.hyp, SMESH_test.ids, SMESH_test.ii, SMESHDS_Mesh.IndexToShape(), SMESH_Hypothesis_i.LoadFrom(), PositionCreator.MakePosition(), StudyContext.mapOldToNew(), Max(), SMESHDS_Mesh.MaxShapeIndex(), SMESHDS_Mesh.MaxSubMeshIndex(), MESSAGE, myCurrentStudy, MYDEBUG, SMESHDS_Mesh.NewSubMesh(), ex29_refine.node(), SMDS_Mesh.nodesIterator(), DriverMED_R_SMESHDS_Mesh.Perform(), SMESH_Mesh.PseudoShape(), SMESHDS_Mesh.RemoveElement(), SMESHDS_GroupBase.SetColor(), SetCurrentStudy(), Driver_Mesh.SetFile(), Driver_SMESHDS_Mesh.SetMesh(), Driver_Mesh.SetMeshId(), SMDS_MeshNode.SetPosition(), SMESH_Mesh_i.SetShape(), SMESHDS_GroupBase.SetStoreName(), SMDS_EdgePosition.SetUParameter(), SMDS_FacePosition.SetUParameter(), SMDS_FacePosition.SetVParameter(), ex21_lamp.size, SMDS_TOP_EDGE, SMDS_TOP_FACE, SObjectToObject(), SMESH_subMesh.SUBMESH_RESTORED, and SMESH_Hypothesis_i.UpdateAsMeshesRestored().
Referenced by LoadASCII().
{
INFOS( "SMESH_Gen_i::Load" );
if ( myCurrentStudy->_is_nil() ||
theComponent->GetStudy()->StudyId() != myCurrentStudy->StudyId() )
SetCurrentStudy( theComponent->GetStudy() );
/* if( !theComponent->_is_nil() )
{
//SALOMEDS::Study_var aStudy = SALOMEDS::Study::_narrow( theComponent->GetStudy() );
if( !myCurrentStudy->FindComponent( "GEOM" )->_is_nil() )
loadGeomData( myCurrentStudy->FindComponent( "GEOM" ) );
}*/
StudyContext* myStudyContext = GetCurrentStudyContext();
// Get temporary files location
TCollection_AsciiString tmpDir =
isMultiFile ? TCollection_AsciiString( ( char* )theURL ) : ( char* )SALOMEDS_Tool::GetTmpDir().c_str();
INFOS( "THE URL++++++++++++++" )
INFOS( theURL );
INFOS( "THE TMP PATH+++++++++" );
INFOS( tmpDir );
// Convert the stream into sequence of files to process
SALOMEDS::ListOfFileNames_var aFileSeq = SALOMEDS_Tool::PutStreamToFiles( theStream,
tmpDir.ToCString(),
isMultiFile );
TCollection_AsciiString aStudyName( "" );
if ( isMultiFile )
aStudyName = ( (char*)SALOMEDS_Tool::GetNameFromPath( myCurrentStudy->URL() ).c_str() );
// Set names of temporary files
TCollection_AsciiString filename = tmpDir + aStudyName + TCollection_AsciiString( "_SMESH.hdf" );
TCollection_AsciiString meshfile = tmpDir + aStudyName + TCollection_AsciiString( "_SMESH_Mesh.med" );
int size;
HDFfile* aFile;
HDFdataset* aDataset;
HDFgroup* aTopGroup;
HDFgroup* aGroup;
HDFgroup* aSubGroup;
HDFgroup* aSubSubGroup;
// Read data
// ---> open HDF file
aFile = new HDFfile( (char*) filename.ToCString() );
try {
aFile->OpenOnDisk( HDF_RDONLY );
}
catch ( HDFexception ) {
INFOS( "Load(): " << filename << " not found!" );
return false;
}
DriverMED_R_SMESHDS_Mesh myReader;
myReader.SetFile( meshfile.ToCString() );
// For PAL13473 ("Repetitive mesh") implementation.
// New dependencies between SMESH objects are established:
// now hypotheses can refer to meshes, shapes and other hypotheses.
// To keep data consistent, the following order of data restoration
// imposed:
// 1. Create hypotheses
// 2. Create all meshes
// 3. Load hypotheses' data
// 4. All the rest
list< pair< SMESH_Hypothesis_i*, string > > hypDataList;
list< pair< SMESH_Mesh_i*, HDFgroup* > > meshGroupList;
// get total number of top-level groups
int aNbGroups = aFile->nInternalObjects();
if ( aNbGroups > 0 ) {
// --> in first turn we should read&create hypotheses
if ( aFile->ExistInternalObject( "Hypotheses" ) ) {
// open hypotheses root HDF group
aTopGroup = new HDFgroup( "Hypotheses", aFile );
aTopGroup->OpenOnDisk();
// get number of hypotheses
int aNbObjects = aTopGroup->nInternalObjects();
for ( int j = 0; j < aNbObjects; j++ ) {
// try to identify hypothesis
char hypGrpName[ HDF_NAME_MAX_LEN+1 ];
aTopGroup->InternalObjectIndentify( j, hypGrpName );
if ( string( hypGrpName ).substr( 0, 10 ) == string( "Hypothesis" ) ) {
// open hypothesis group
aGroup = new HDFgroup( hypGrpName, aTopGroup );
aGroup->OpenOnDisk();
// --> get hypothesis id
int id = atoi( string( hypGrpName ).substr( 10 ).c_str() );
string hypname;
string libname;
string hypdata;
// get number of datasets
int aNbSubObjects = aGroup->nInternalObjects();
for ( int k = 0; k < aNbSubObjects; k++ ) {
// identify dataset
char name_of_subgroup[ HDF_NAME_MAX_LEN+1 ];
aGroup->InternalObjectIndentify( k, name_of_subgroup );
// --> get hypothesis name
if ( strcmp( name_of_subgroup, "Name" ) == 0 ) {
aDataset = new HDFdataset( name_of_subgroup, aGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
char* hypname_str = new char[ size ];
aDataset->ReadFromDisk( hypname_str );
hypname = string( hypname_str );
delete [] hypname_str;
aDataset->CloseOnDisk();
}
// --> get hypothesis plugin library name
if ( strcmp( name_of_subgroup, "LibName" ) == 0 ) {
aDataset = new HDFdataset( name_of_subgroup, aGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
char* libname_str = new char[ size ];
aDataset->ReadFromDisk( libname_str );
if(MYDEBUG) SCRUTE( libname_str );
libname = string( libname_str );
delete [] libname_str;
aDataset->CloseOnDisk();
}
// --> get hypothesis data
if ( strcmp( name_of_subgroup, "Data" ) == 0 ) {
aDataset = new HDFdataset( name_of_subgroup, aGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
char* hypdata_str = new char[ size ];
aDataset->ReadFromDisk( hypdata_str );
hypdata = string( hypdata_str );
delete [] hypdata_str;
aDataset->CloseOnDisk();
}
}
// close hypothesis HDF group
aGroup->CloseOnDisk();
// --> restore hypothesis from data
if ( id > 0 && !hypname.empty()/* && !hypdata.empty()*/ ) { // VSR : persistent data can be empty
if(MYDEBUG) MESSAGE("VSR - load hypothesis : id = " << id <<
", name = " << hypname.c_str() << ", persistent string = " << hypdata.c_str());
SMESH::SMESH_Hypothesis_var myHyp;
try { // protect persistence mechanism against exceptions
myHyp = this->createHypothesis( hypname.c_str(), libname.c_str() );
}
catch (...) {
INFOS( "Exception during hypothesis creation" );
}
SMESH_Hypothesis_i* myImpl = dynamic_cast<SMESH_Hypothesis_i*>( GetServant( myHyp ).in() );
if ( myImpl ) {
// myImpl->LoadFrom( hypdata.c_str() );
hypDataList.push_back( make_pair( myImpl, hypdata ));
string iorString = GetORB()->object_to_string( myHyp );
int newId = myStudyContext->findId( iorString );
myStudyContext->mapOldToNew( id, newId );
}
else
if(MYDEBUG) MESSAGE( "VSR - SMESH_Gen::Load - can't get servant" );
}
}
}
// close hypotheses root HDF group
aTopGroup->CloseOnDisk();
aTopGroup = 0;
}
// --> 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<SMESH_Hypothesis_i*>( GetServant( myHyp ).in() );
if ( myImpl ) {
//myImpl->LoadFrom( hypdata.c_str() );
hypDataList.push_back( make_pair( myImpl, hypdata ));
string iorString = GetORB()->object_to_string( myHyp );
int newId = myStudyContext->findId( iorString );
myStudyContext->mapOldToNew( id, newId );
}
else
if(MYDEBUG) MESSAGE( "VSR - SMESH_Gen::Load - can't get servant" );
}
}
}
// close algorithms root HDF group
aTopGroup->CloseOnDisk();
aTopGroup = 0;
}
// --> 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;
// 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<SMESH_Mesh_i*>( GetServant( myNewMesh ).in() );
if ( !myNewMeshImpl )
continue;
meshGroupList.push_back( make_pair( myNewMeshImpl, aTopGroup ));
string iorString = GetORB()->object_to_string( myNewMesh );
int newId = myStudyContext->findId( iorString );
myStudyContext->mapOldToNew( id, newId );
// ouv : NPAL12872
// try to read and set auto color flag
char aMeshAutoColorName[ 30 ];
sprintf( aMeshAutoColorName, "AutoColorMesh %d", id);
if( aTopGroup->ExistInternalObject( aMeshAutoColorName ) )
{
aDataset = new HDFdataset( aMeshAutoColorName, aTopGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
int* anAutoColor = new int[ size ];
aDataset->ReadFromDisk( anAutoColor );
aDataset->CloseOnDisk();
myNewMeshImpl->GetImpl().SetAutoColor( (bool)anAutoColor[0] );
}
// 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 );
}
}
}
// issue 0020693. Restore _isModified flag
if( aTopGroup->ExistInternalObject( "_isModified" ) )
{
aDataset = new HDFdataset( "_isModified", aTopGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
int* isModified = new int[ size ];
aDataset->ReadFromDisk( isModified );
aDataset->CloseOnDisk();
myNewMeshImpl->GetImpl().SetIsModified( bool(*isModified));
}
// issue 20918. Restore Persistent Id of SMESHDS_Mesh
if( aTopGroup->ExistInternalObject( "meshPersistentId" ) )
{
aDataset = new HDFdataset( "meshPersistentId", aTopGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
int* meshPersistentId = new int[ size ];
aDataset->ReadFromDisk( meshPersistentId );
aDataset->CloseOnDisk();
myNewMeshImpl->GetImpl().GetMeshDS()->SetPersistentId( *meshPersistentId );
}
}
}
}
// As all object that can be referred by hypothesis are created,
// we can restore hypothesis data
list< pair< SMESH_Hypothesis_i*, string > >::iterator hyp_data;
for ( hyp_data = hypDataList.begin(); hyp_data != hypDataList.end(); ++hyp_data )
{
SMESH_Hypothesis_i* hyp = hyp_data->first;
string & data = hyp_data->second;
hyp->LoadFrom( data.c_str() );
}
// Restore the rest mesh data
list< pair< SMESH_Mesh_i*, HDFgroup* > >::iterator meshi_group;
for ( meshi_group = meshGroupList.begin(); meshi_group != meshGroupList.end(); ++meshi_group )
{
aTopGroup = meshi_group->second;
SMESH_Mesh_i* myNewMeshImpl = meshi_group->first;
::SMESH_Mesh& myLocMesh = myNewMeshImpl->GetImpl();
SMESHDS_Mesh* mySMESHDSMesh = myLocMesh.GetMeshDS();
GEOM::GEOM_Object_var aShapeObject = myNewMeshImpl->GetShapeToMesh();
bool hasData = false;
// get mesh old id
string iorString = GetORB()->object_to_string( myNewMeshImpl->_this() );
int newId = myStudyContext->findId( iorString );
int id = myStudyContext->getOldId( newId );
// try to find mesh data dataset
if ( aTopGroup->ExistInternalObject( "Has data" ) ) {
// load mesh "has data" flag
aDataset = new HDFdataset( "Has data", aTopGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
char* strHasData = new char[ size ];
aDataset->ReadFromDisk( strHasData );
aDataset->CloseOnDisk();
if ( strcmp( strHasData, "1") == 0 ) {
// read mesh data from MED file
myReader.SetMesh( mySMESHDSMesh );
myReader.SetMeshId( id );
myReader.Perform();
hasData = true;
}
}
// Try to get applied ALGORITHMS (mesh is not cleared by algo addition because
// nodes and elements are not yet put into sub-meshes)
if ( aTopGroup->ExistInternalObject( "Applied Algorithms" ) ) {
aGroup = new HDFgroup( "Applied Algorithms", aTopGroup );
aGroup->OpenOnDisk();
// get number of applied algorithms
int aNbSubObjects = aGroup->nInternalObjects();
if(MYDEBUG) MESSAGE( "VSR - number of applied algos " << aNbSubObjects );
for ( int j = 0; j < aNbSubObjects; j++ ) {
char name_dataset[ HDF_NAME_MAX_LEN+1 ];
aGroup->InternalObjectIndentify( j, name_dataset );
// check if it is an algorithm
if ( string( name_dataset ).substr( 0, 4 ) == string( "Algo" ) ) {
aDataset = new HDFdataset( name_dataset, aGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
char* refFromFile = new char[ size ];
aDataset->ReadFromDisk( refFromFile );
aDataset->CloseOnDisk();
// san - it is impossible to recover applied algorithms using their entries within Load() method
//SALOMEDS::SObject_var hypSO = myCurrentStudy->FindObjectID( refFromFile );
//CORBA::Object_var hypObject = SObjectToObject( hypSO );
int id = atoi( refFromFile );
string anIOR = myStudyContext->getIORbyOldId( id );
if ( !anIOR.empty() ) {
CORBA::Object_var hypObject = GetORB()->string_to_object( anIOR.c_str() );
if ( !CORBA::is_nil( hypObject ) ) {
SMESH::SMESH_Hypothesis_var anHyp = SMESH::SMESH_Hypothesis::_narrow( hypObject );
if ( !anHyp->_is_nil() && (!aShapeObject->_is_nil()
|| !myNewMeshImpl->HasShapeToMesh()) )
myNewMeshImpl->addHypothesis( aShapeObject, anHyp );
}
}
}
}
aGroup->CloseOnDisk();
}
// try to get applied hypotheses
if ( aTopGroup->ExistInternalObject( "Applied Hypotheses" ) ) {
aGroup = new HDFgroup( "Applied Hypotheses", aTopGroup );
aGroup->OpenOnDisk();
// get number of applied hypotheses
int aNbSubObjects = aGroup->nInternalObjects();
for ( int j = 0; j < aNbSubObjects; j++ ) {
char name_dataset[ HDF_NAME_MAX_LEN+1 ];
aGroup->InternalObjectIndentify( j, name_dataset );
// check if it is a hypothesis
if ( string( name_dataset ).substr( 0, 3 ) == string( "Hyp" ) ) {
aDataset = new HDFdataset( name_dataset, aGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
char* refFromFile = new char[ size ];
aDataset->ReadFromDisk( refFromFile );
aDataset->CloseOnDisk();
// san - it is impossible to recover applied hypotheses using their entries within Load() method
//SALOMEDS::SObject_var hypSO = myCurrentStudy->FindObjectID( refFromFile );
//CORBA::Object_var hypObject = SObjectToObject( hypSO );
int id = atoi( refFromFile );
string anIOR = myStudyContext->getIORbyOldId( id );
if ( !anIOR.empty() ) {
CORBA::Object_var hypObject = GetORB()->string_to_object( anIOR.c_str() );
if ( !CORBA::is_nil( hypObject ) ) {
SMESH::SMESH_Hypothesis_var anHyp = SMESH::SMESH_Hypothesis::_narrow( hypObject );
if ( !anHyp->_is_nil() && (!aShapeObject->_is_nil()
|| !myNewMeshImpl->HasShapeToMesh()) )
myNewMeshImpl->addHypothesis( aShapeObject, anHyp );
}
}
}
}
aGroup->CloseOnDisk();
}
// --> try to find submeshes containers for each type of submesh
for ( int j = GetSubMeshOnVertexTag(); j <= GetSubMeshOnCompoundTag(); j++ ) {
char name_meshgroup[ 30 ];
if ( j == GetSubMeshOnVertexTag() )
strcpy( name_meshgroup, "SubMeshes On Vertex" );
else if ( j == GetSubMeshOnEdgeTag() )
strcpy( name_meshgroup, "SubMeshes On Edge" );
else if ( j == GetSubMeshOnWireTag() )
strcpy( name_meshgroup, "SubMeshes On Wire" );
else if ( j == GetSubMeshOnFaceTag() )
strcpy( name_meshgroup, "SubMeshes On Face" );
else if ( j == GetSubMeshOnShellTag() )
strcpy( name_meshgroup, "SubMeshes On Shell" );
else if ( j == GetSubMeshOnSolidTag() )
strcpy( name_meshgroup, "SubMeshes On Solid" );
else if ( j == GetSubMeshOnCompoundTag() )
strcpy( name_meshgroup, "SubMeshes On Compound" );
// try to get submeshes container HDF group
if ( aTopGroup->ExistInternalObject( name_meshgroup ) ) {
// open submeshes containers HDF group
aGroup = new HDFgroup( name_meshgroup, aTopGroup );
aGroup->OpenOnDisk();
// get number of submeshes
int aNbSubMeshes = aGroup->nInternalObjects();
for ( int k = 0; k < aNbSubMeshes; k++ ) {
// identify submesh
char name_submeshgroup[ HDF_NAME_MAX_LEN+1 ];
aGroup->InternalObjectIndentify( k, name_submeshgroup );
if ( string( name_submeshgroup ).substr( 0, 7 ) == string( "SubMesh" ) ) {
// --> get submesh id
int subid = atoi( string( name_submeshgroup ).substr( 7 ).c_str() );
if ( subid <= 0 )
continue;
// open submesh HDF group
aSubGroup = new HDFgroup( name_submeshgroup, aGroup );
aSubGroup->OpenOnDisk();
// try to read and set reference to subshape
GEOM::GEOM_Object_var aSubShapeObject;
SMESH::SMESH_subMesh_var aSubMesh;
if ( aSubGroup->ExistInternalObject( "Ref on shape" ) ) {
// load submesh "Ref on shape" - it's an entry to SObject
aDataset = new HDFdataset( "Ref on shape", aSubGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
char* refFromFile = new char[ size ];
aDataset->ReadFromDisk( refFromFile );
aDataset->CloseOnDisk();
if ( strlen( refFromFile ) > 0 ) {
SALOMEDS::SObject_var subShapeSO = myCurrentStudy->FindObjectID( refFromFile );
CORBA::Object_var subShapeObject = SObjectToObject( subShapeSO );
if ( !CORBA::is_nil( subShapeObject ) ) {
aSubShapeObject = GEOM::GEOM_Object::_narrow( subShapeObject );
if ( !aSubShapeObject->_is_nil() )
aSubMesh = SMESH::SMESH_subMesh::_duplicate
( myNewMeshImpl->createSubMesh( aSubShapeObject ) );
if ( aSubMesh->_is_nil() )
continue;
string iorSubString = GetORB()->object_to_string( aSubMesh );
int newSubId = myStudyContext->findId( iorSubString );
myStudyContext->mapOldToNew( subid, newSubId );
}
}
}
if ( aSubMesh->_is_nil() )
continue;
// 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();
int id = atoi( refFromFile );
string anIOR = myStudyContext->getIORbyOldId( id );
if ( !anIOR.empty() ) {
CORBA::Object_var hypObject = GetORB()->string_to_object( anIOR.c_str() );
if ( !CORBA::is_nil( hypObject ) ) {
SMESH::SMESH_Hypothesis_var anHyp = SMESH::SMESH_Hypothesis::_narrow( hypObject );
if ( !anHyp->_is_nil() && !aShapeObject->_is_nil() )
myNewMeshImpl->addHypothesis( aSubShapeObject, anHyp );
}
}
}
}
// close "applied algorithms" HDF group
aSubSubGroup->CloseOnDisk();
}
// 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();
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();
}
// close submesh HDF group
aSubGroup->CloseOnDisk();
}
}
// close submeshes containers HDF group
aGroup->CloseOnDisk();
}
}
if(hasData) {
// Read sub-meshes
// ----------------
if(MYDEBUG) MESSAGE("Create all sub-meshes");
bool submeshesInFamilies = ( ! aTopGroup->ExistInternalObject( "Submeshes" ));
if ( submeshesInFamilies ) // from MED
{
// old way working before fix of PAL 12992
myReader.CreateAllSubMeshes();
}
else
{
// open a group
aGroup = new HDFgroup( "Submeshes", aTopGroup );
aGroup->OpenOnDisk();
int maxID = Max( mySMESHDSMesh->MaxSubMeshIndex(), mySMESHDSMesh->MaxShapeIndex() );
vector< SMESHDS_SubMesh * > subMeshes( maxID + 1, (SMESHDS_SubMesh*) 0 );
vector< TopAbs_ShapeEnum > smType ( maxID + 1, TopAbs_SHAPE );
PositionCreator aPositionCreator;
SMDS_NodeIteratorPtr nIt = mySMESHDSMesh->nodesIterator();
SMDS_ElemIteratorPtr eIt = mySMESHDSMesh->elementsIterator();
for ( int isNode = 0; isNode < 2; ++isNode )
{
string aDSName( isNode ? "Node Submeshes" : "Element Submeshes");
if ( aGroup->ExistInternalObject( (char*) aDSName.c_str() ))
{
aDataset = new HDFdataset( (char*) aDSName.c_str(), aGroup );
aDataset->OpenOnDisk();
// read submesh IDs for all elements sorted by ID
int nbElems = aDataset->GetSize();
int* smIDs = new int [ nbElems ];
aDataset->ReadFromDisk( smIDs );
aDataset->CloseOnDisk();
// get elements sorted by ID
TIDSortedElemSet elemSet;
if ( isNode )
while ( nIt->more() ) elemSet.insert( nIt->next() );
else
while ( eIt->more() ) elemSet.insert( eIt->next() );
//ASSERT( elemSet.size() == nbElems ); -- issue 20182
// -- Most probably a bad study was saved when there were
// not fixed bugs in SMDS_MeshInfo
if ( elemSet.size() < nbElems ) {
#ifdef _DEBUG_
cout << "SMESH_Gen_i::Load(), warning: Node position data is invalid" << endl;
#endif
nbElems = elemSet.size();
}
// add elements to submeshes
TIDSortedElemSet::iterator iE = elemSet.begin();
for ( int i = 0; i < nbElems; ++i, ++iE )
{
int smID = smIDs[ i ];
if ( smID == 0 ) continue;
const SMDS_MeshElement* elem = *iE;
if( smID > maxID ) {
// corresponding subshape no longer exists: maybe geom group has been edited
if ( myNewMeshImpl->HasShapeToMesh() )
mySMESHDSMesh->RemoveElement( elem );
continue;
}
// get or create submesh
SMESHDS_SubMesh* & sm = subMeshes[ smID ];
if ( ! sm ) {
sm = mySMESHDSMesh->NewSubMesh( smID );
smType[ smID ] = mySMESHDSMesh->IndexToShape( smID ).ShapeType();
}
// add
if ( isNode ) {
SMDS_PositionPtr pos = aPositionCreator.MakePosition( smType[ smID ]);
SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( static_cast<const SMDS_MeshNode*>( elem ));
node->SetPosition( pos );
sm->AddNode( node );
} else {
sm->AddElement( elem );
}
}
delete [] smIDs;
}
}
} // end reading submeshes
// 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
const char* aEid_DSName = "Nodes on Edges";
const char* aEu_DSName = "Edge positions";
const 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;
}
}
aDataset->CloseOnDisk();
} // 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 ]);
if ( !node ) continue; // maybe removed while Loading() if geometry changed
SMDS_PositionPtr aPos = node->GetPosition();
ASSERT( aPos );
if ( onFace ) {
// ASSERT( aPos->GetTypeOfPosition() == SMDS_TOP_FACE );-- issue 20182
// -- Most probably a bad study was saved when there were
// not fixed bugs in SMDS_MeshInfo
if ( aPos->GetTypeOfPosition() == SMDS_TOP_FACE ) {
SMDS_FacePosition* fPos = const_cast<SMDS_FacePosition*>
( static_cast<const SMDS_FacePosition*>( aPos ));
fPos->SetUParameter( aUPos[ iNode ]);
fPos->SetVParameter( aVPos[ iNode ]);
}
}
else {
// ASSERT( aPos->GetTypeOfPosition() == SMDS_TOP_EDGE );-- issue 20182
if ( aPos->GetTypeOfPosition() == SMDS_TOP_EDGE ) {
SMDS_EdgePosition* fPos = const_cast<SMDS_EdgePosition*>
( static_cast<const SMDS_EdgePosition*>( aPos ));
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 )
// try to get groups
for ( int ii = GetNodeGroupsTag(); ii <= Get0DElementsGroupsTag(); 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" );
else if ( ii == Get0DElementsGroupsTag() )
strcpy( name_group, "Groups of 0D Elements" );
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<SMESH_GroupBase_i*>( 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 );
// ouv : NPAL12872
// Read color of the group
char aGroupColorName[ 30 ];
sprintf( aGroupColorName, "ColorGroup %d", subid);
if ( aGroup->ExistInternalObject( aGroupColorName ) )
{
aDataset = new HDFdataset( aGroupColorName, aGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
double* anRGB = new double[ size ];
aDataset->ReadFromDisk( anRGB );
aDataset->CloseOnDisk();
Quantity_Color aColor( anRGB[0], anRGB[1], anRGB[2], Quantity_TOC_RGB );
aGroupBaseDS->SetColor( aColor );
}
// Fill group with contents from MED file
SMESHDS_Group* aGrp = dynamic_cast<SMESHDS_Group*>( aGroupBaseDS );
if ( aGrp )
myReader.GetGroup( aGrp );
}
}
aGroup->CloseOnDisk();
}
}
// read submeh order if any
if( aTopGroup->ExistInternalObject( "Mesh Order" ) ) {
aDataset = new HDFdataset( "Mesh Order", aTopGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
int* smIDs = new int[ size ];
aDataset->ReadFromDisk( smIDs );
aDataset->CloseOnDisk();
TListOfListOfInt anOrderIds;
anOrderIds.push_back( TListOfInt() );
for ( int i = 0; i < size; i++ )
if ( smIDs[ i ] < 0 ) // is separator
anOrderIds.push_back( TListOfInt() );
else
anOrderIds.back().push_back(smIDs[ i ]);
myNewMeshImpl->GetImpl().SetMeshOrder( anOrderIds );
}
} // loop on meshes
// notify algos on completed restoration
for ( meshi_group = meshGroupList.begin(); meshi_group != meshGroupList.end(); ++meshi_group )
{
SMESH_Mesh_i* myNewMeshImpl = meshi_group->first;
::SMESH_Mesh& myLocMesh = myNewMeshImpl->GetImpl();
TopoDS_Shape myLocShape;
if(myLocMesh.HasShapeToMesh())
myLocShape = myLocMesh.GetShapeToMesh();
else
myLocShape = SMESH_Mesh::PseudoShape();
myLocMesh.GetSubMesh(myLocShape)->
ComputeStateEngine (SMESH_subMesh::SUBMESH_RESTORED);
}
for ( hyp_data = hypDataList.begin(); hyp_data != hypDataList.end(); ++hyp_data )
{
SMESH_Hypothesis_i* hyp = hyp_data->first;
hyp->UpdateAsMeshesRestored(); // for hyps needing full mesh data restored (issue 20918)
}
// close mesh group
if(aTopGroup)
aTopGroup->CloseOnDisk();
}
// close HDF file
aFile->CloseOnDisk();
delete aFile;
// Remove temporary files created from the stream
if ( !isMultiFile )
SALOMEDS_Tool::RemoveTemporaryFiles( tmpDir.ToCString(), aFileSeq.in(), true );
INFOS( "SMESH_Gen_i::Load completed" );
return true;
}
| bool SMESH_Gen_i::LoadASCII | ( | SALOMEDS::SComponent_ptr | theComponent, |
| const SALOMEDS::TMPFile & | theStream, | ||
| const char * | theURL, | ||
| bool | isMultiFile | ||
| ) |
Load SMESH module's data in ASCII format
Definition at line 4593 of file SMESH_Gen_i.cxx.
References Load(), MESSAGE, MYDEBUG, and ex21_lamp.size.
{
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::LoadASCII" );
return Load( theComponent, theStream, theURL, isMultiFile );
//before call main ::Load method it's need for decipher text format to
//binary ( "|xx" => x' )
int size = theStream.length();
if ( int((size / 3 )*3) != size ) //error size of buffer
return false;
int real_size = int(size / 3);
_CORBA_Octet* buffer = new _CORBA_Octet[real_size];
char tmp[3];
tmp[2]='\0';
int c = -1;
for ( int i = 0; i < real_size; i++ )
{
memcpy( &(tmp[0]), &(theStream[i*3+1]), 2 );
sscanf( tmp, "%x", &c );
sprintf( (char*)&(buffer[i]), "%c", (char)c );
}
SALOMEDS::TMPFile_var aRealStreamFile = new SALOMEDS::TMPFile(real_size, real_size, buffer, 1);
return Load( theComponent, *(aRealStreamFile._retn()), theURL, isMultiFile );
}
| void SMESH_Gen_i::loadGeomData | ( | SALOMEDS::SComponent_ptr | theCompRoot | ) | [static, private] |
Load GEOM module data
Definition at line 3515 of file SMESH_Gen_i.cxx.
References GetGeomEngine().
{
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() );
}
| char * SMESH_Gen_i::LocalPersistentIDToIOR | ( | SALOMEDS::SObject_ptr | theSObject, |
| const char * | aLocalPersistentID, | ||
| CORBA::Boolean | isMultiFile, | ||
| CORBA::Boolean | isASCII | ||
| ) |
SMESH_Gen_i.LocalPersistentIDToIOR.
Transform data from persistent form to transient
Definition at line 4720 of file SMESH_Gen_i.cxx.
References GetCurrentStudyContext(), StudyContext.getIORbyOldId(), MESSAGE, and MYDEBUG.
{
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( "" );
}
| SALOMEDS::SObject_ptr SMESH_Gen_i::ObjectToSObject | ( | SALOMEDS::Study_ptr | theStudy, |
| CORBA::Object_ptr | theObject | ||
| ) | [static] |
Definition at line 183 of file SMESH_Gen_i_1.cxx.
References GetORB().
Referenced by SMESH_Mesh_i.addGeomGroupData(), AddHypothesisToShape(), addReference(), SMESH_Mesh_i.CheckGeomGroupModif(), SMESH_Mesh_i.checkGroupNames(), SMESH_Mesh_i.ConvertToStandalone(), CopyMesh(), GetMeshOrSubmeshByShape(), SMESH_MEDMesh_i.getName(), GetParameters(), SMESH_Hypothesis_i.IsPublished(), SMESH_MeshEditor_i.makeMesh(), SMESH.TPythonDump.operator<<(), publish(), PublishGroup(), PublishHypothesis(), PublishMesh(), PublishSubMesh(), RemoveHypothesisFromShape(), SMESH_GroupBase_i.SetName(), SetName(), StdMeshers.StdMeshers_ImportSource1D.SetSourceEdges(), StdMeshers.StdMeshers_ImportSource2D.SetSourceFaces(), and UpdateParameters().
{
SALOMEDS::SObject_var aSO;
if ( !CORBA::is_nil( theStudy ) && !CORBA::is_nil( theObject ))
{
CORBA::String_var objStr = SMESH_Gen_i::GetORB()->object_to_string( theObject );
aSO = theStudy->FindObjectIOR( objStr.in() );
}
return aSO._retn();
}
| char * SMESH_Gen_i::ParseParameters | ( | const char * | theParameters | ) |
Definition at line 974 of file SMESH_Gen_i_1.cxx.
References GetCurrentStudy().
Referenced by SMESH_Hypothesis_i.SetParameters(), and UpdateParameters().
{
//const char* aParameters = theParameters;
// const char* aParameters = CORBA::string_dup(theParameters);
TCollection_AsciiString anInputParams;
SALOMEDS::Study_var aStudy = GetCurrentStudy();
if( !aStudy->_is_nil() ) {
// SALOMEDS::ListOfListOfStrings_var aSections = aStudy->ParseVariables(theParameters);
// for(int j=0;j<aSections->length();j++) {
// SALOMEDS::ListOfStrings aVars= aSections[j];
// for(int i=0;i<aVars.length();i++ ) {
// anInputParams += aStudy->IsVariable(aVars[i].in()) ?
// TCollection_AsciiString(aVars[i].in()) : TCollection_AsciiString("");
// if(i != aVars.length()-1)
// anInputParams+=":";
// }
// if(j!=aSections->length()-1)
// anInputParams+="|";
// }
TCollection_AsciiString paramStr( theParameters );
static TCollection_AsciiString separators(":|");
int beg = 0, end;
char sep, *pParams = (char*)paramStr.ToCString();
while ( beg < paramStr.Length() )
{
end = beg-1;
while ( ++end < paramStr.Length() )
if ( pParams[end] == ':' || pParams[end] == '|')
break;
if ( end < paramStr.Length())
{
sep = pParams[end];
pParams[end] = '\0';
}
if ( aStudy->IsVariable( pParams+beg ))
anInputParams += pParams+beg;
if ( end < paramStr.Length() )
anInputParams += sep;
else
break;
beg = end + 1;
}
}
return CORBA::string_dup(anInputParams.ToCString());
}
| SALOMEDS::SObject_ptr SMESH_Gen_i.PasteInto | ( | const SALOMEDS::TMPFile & | theStream, |
| CORBA::Long | theObjectID, | ||
| SALOMEDS::SObject_ptr | theObject | ||
| ) |
Definition at line 405 of file SMESH_Gen_i.hxx.
{
SALOMEDS::SObject_var aResultSO;
return aResultSO._retn();
}
| SMESH::MeshPreviewStruct * SMESH_Gen_i::Precompute | ( | SMESH::SMESH_Mesh_ptr | theMesh, |
| GEOM::GEOM_Object_ptr | theShapeObject, | ||
| SMESH::Dimension | theDimension, | ||
| SMESH::long_array & | theShapesId | ||
| ) | throw ( SALOME::SALOME_Exception ) |
Calculate Mesh as preview till indicated dimension on shape First, verify list of hypothesis associated with the subShape.
Return mesh preview structure
Compute mesh as preview till indicated dimension on shape
Definition at line 1487 of file SMESH_Gen_i.cxx.
References SMESH_Mesh_i.CheckGeomGroupModif(), SMESH.DIM_1D, SMESH.DIM_2D, PAL_MESH_043_3D.face, SMESHDS_SubMesh.GetElements(), SMESH_Mesh_i.GetImpl(), SMDS_MeshElement.GetNode(), SMESHDS_SubMesh.GetNodes(), MESSAGE, MYDEBUG, SMDS_MeshElement.NbNodes(), ex29_refine.node(), SMDSAbs_Edge, SMDSAbs_Node, SMDS_MeshNode.X(), SMDS_MeshNode.Y(), and SMDS_MeshNode.Z().
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Precompute" );
if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
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 );
SMESH::MeshPreviewStruct_var result = new SMESH::MeshPreviewStruct;
try {
// get mesh servant
SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
ASSERT( meshServant );
if ( meshServant ) {
// NPAL16168: "geometrical group edition from a submesh don't modifiy mesh computation"
meshServant->CheckGeomGroupModif();
// get local TopoDS_Shape
TopoDS_Shape myLocShape;
if(theMesh->HasShapeToMesh())
myLocShape = GeomObjectToShape( theShapeObject );
else
return result._retn();;
// call implementation compute
::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
TSetOfInt shapeIds;
::MeshDimension aDim = (MeshDimension)theDimension;
if ( myGen.Compute( myLocMesh, myLocShape, false, aDim, &shapeIds ) )
{
int nbShapeId = shapeIds.size();
theShapesId.length( nbShapeId );
// iterates on shapes and collect mesh entities into mesh preview
TSetOfInt::const_iterator idIt = shapeIds.begin();
TSetOfInt::const_iterator idEnd = shapeIds.end();
std::map< int, int > mapOfShIdNb;
std::set< SMESH_TLink > setOfEdge;
std::list< SMDSAbs_ElementType > listOfElemType;
typedef map<const SMDS_MeshElement*, int > TNode2LocalIDMap;
typedef TNode2LocalIDMap::iterator TNodeLocalID;
TNode2LocalIDMap mapNode2LocalID;
list< TNodeLocalID > connectivity;
int i, nbConnNodes = 0;
std::set< const SMESH_subMesh* > setOfVSubMesh;
// iterates on shapes
for ( ; idIt != idEnd; idIt++ )
{
if ( mapOfShIdNb.find( *idIt ) != mapOfShIdNb.end() )
continue;
SMESH_subMesh* sm = myLocMesh.GetSubMeshContaining(*idIt);
if ( !sm || !sm->IsMeshComputed() )
continue;
const TopoDS_Shape& aSh = sm->GetSubShape();
const int shDim = myGen.GetShapeDim( aSh );
if ( shDim < 1 || shDim > theDimension )
continue;
mapOfShIdNb[ *idIt ] = 0;
theShapesId[ mapOfShIdNb.size() - 1 ] = *idIt;
SMESHDS_SubMesh* smDS = sm->GetSubMeshDS();
if ( !smDS ) continue;
if ( theDimension == SMESH::DIM_2D )
{
SMDS_ElemIteratorPtr faceIt = smDS->GetElements();
while ( faceIt->more() )
{
const SMDS_MeshElement* face = faceIt->next();
int aNbNode = face->NbNodes();
if ( aNbNode > 4 )
aNbNode /= 2; // do not take into account additional middle nodes
SMDS_MeshNode* node1 = (SMDS_MeshNode*)face->GetNode( 0 );
for ( int nIndx = 0; nIndx < aNbNode; nIndx++ )
{
SMDS_MeshNode* node2 = (SMDS_MeshNode*)face->GetNode( nIndx+1 < aNbNode ? nIndx+1 : 0 );
if ( setOfEdge.insert( SMESH_TLink ( node1, node2 ) ).second )
{
listOfElemType.push_back( SMDSAbs_Edge );
connectivity.push_back
( mapNode2LocalID.insert( make_pair( node1, ++nbConnNodes)).first );
connectivity.push_back
( mapNode2LocalID.insert( make_pair( node2, ++nbConnNodes)).first );
}
node1 = node2;
}
}
}
else if ( theDimension == SMESH::DIM_1D )
{
SMDS_NodeIteratorPtr nodeIt = smDS->GetNodes();
while ( nodeIt->more() )
{
listOfElemType.push_back( SMDSAbs_Node );
connectivity.push_back
( mapNode2LocalID.insert( make_pair( nodeIt->next(), ++nbConnNodes)).first );
}
// add corner nodes by first vertex from edge
SMESH_subMeshIteratorPtr edgeSmIt =
sm->getDependsOnIterator(/*includeSelf*/false,
/*complexShapeFirst*/false);
while ( edgeSmIt->more() )
{
SMESH_subMesh* vertexSM = edgeSmIt->next();
// check that vertex is not already treated
if ( !setOfVSubMesh.insert( vertexSM ).second )
continue;
if ( vertexSM->GetSubShape().ShapeType() != TopAbs_VERTEX )
continue;
const SMESHDS_SubMesh* vertexSmDS = vertexSM->GetSubMeshDS();
SMDS_NodeIteratorPtr nodeIt = vertexSmDS->GetNodes();
while ( nodeIt->more() )
{
listOfElemType.push_back( SMDSAbs_Node );
connectivity.push_back
( mapNode2LocalID.insert( make_pair( nodeIt->next(), ++nbConnNodes)).first );
}
}
}
}
// fill node coords and assign local ids to the nodes
int nbNodes = mapNode2LocalID.size();
result->nodesXYZ.length( nbNodes );
TNodeLocalID node2ID = mapNode2LocalID.begin();
for ( i = 0; i < nbNodes; ++i, ++node2ID ) {
node2ID->second = i;
const SMDS_MeshNode* node = (const SMDS_MeshNode*) node2ID->first;
result->nodesXYZ[i].x = node->X();
result->nodesXYZ[i].y = node->Y();
result->nodesXYZ[i].z = node->Z();
}
// fill connectivity
result->elementConnectivities.length( nbConnNodes );
list< TNodeLocalID >::iterator connIt = connectivity.begin();
for ( i = 0; i < nbConnNodes; ++i, ++connIt ) {
result->elementConnectivities[i] = (*connIt)->second;
}
// fill element types
result->elementTypes.length( listOfElemType.size() );
std::list< SMDSAbs_ElementType >::const_iterator typeIt = listOfElemType.begin();
std::list< SMDSAbs_ElementType >::const_iterator typeEnd = listOfElemType.end();
for ( i = 0; typeIt != typeEnd; ++i, ++typeIt )
{
SMDSAbs_ElementType elemType = *typeIt;
result->elementTypes[i].SMDS_ElementType = (SMESH::ElementType)elemType;
result->elementTypes[i].isPoly = false;
result->elementTypes[i].nbNodesInElement = elemType == SMDSAbs_Edge ? 2 : 1;
}
// correct number of shapes
theShapesId.length( mapOfShIdNb.size() );
}
}
}
catch ( std::bad_alloc ) {
INFOS( "Precompute(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
INFOS( "Precompute(): catch exception "<< S_ex.what() );
}
catch ( ... ) {
INFOS( "Precompute(): unknown exception " );
}
return result._retn();
}
| SALOMEDS::SComponent_ptr SMESH_Gen_i::PublishComponent | ( | SALOMEDS::Study_ptr | theStudy | ) |
Definition at line 424 of file SMESH_Gen_i_1.cxx.
References SMESH_freebord.aComp, batchmode_smesh.aPixmap, ComponentDataType(), batchmode_smesh.father, GetNS(), MESSAGE, and SetName().
Referenced by PublishHypothesis(), and PublishMesh().
{
if ( CORBA::is_nil( theStudy ))
return SALOMEDS::SComponent::_nil();
if(MYDEBUG) MESSAGE("PublishComponent");
SALOMEDS::SComponent_var father =
SALOMEDS::SComponent::_narrow( theStudy->FindComponent( ComponentDataType() ) );
if ( !CORBA::is_nil( father ) )
return father._retn();
SALOME_ModuleCatalog::ModuleCatalog_var aCat =
SALOME_ModuleCatalog::ModuleCatalog::_narrow( GetNS()->Resolve("/Kernel/ModulCatalog") );
if ( CORBA::is_nil( aCat ) )
return father._retn();
SALOME_ModuleCatalog::Acomponent_var aComp = aCat->GetComponent( ComponentDataType() );
if ( CORBA::is_nil( aComp ) )
return father._retn();
SALOMEDS::StudyBuilder_var aStudyBuilder = theStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr;
SALOMEDS::AttributePixMap_var aPixmap;
father = aStudyBuilder->NewComponent( ComponentDataType() );
aStudyBuilder->DefineComponentInstance( father, SMESH_Gen::_this() );
anAttr = aStudyBuilder->FindOrCreateAttribute( father, "AttributePixMap" );
aPixmap = SALOMEDS::AttributePixMap::_narrow( anAttr );
aPixmap ->SetPixMap( "ICON_OBJBROWSER_SMESH" );
SetName( father, aComp->componentusername(), "MESH" );
if(MYDEBUG) MESSAGE("PublishComponent--END");
return father._retn();
}
| SALOMEDS::SObject_ptr SMESH_Gen_i::PublishGroup | ( | SALOMEDS::Study_ptr | theStudy, |
| SMESH::SMESH_Mesh_ptr | theMesh, | ||
| SMESH::SMESH_GroupBase_ptr | theGroup, | ||
| GEOM::GEOM_Object_ptr | theShapeObject, | ||
| const char * | theName = 0 |
||
| ) |
Definition at line 666 of file SMESH_Gen_i_1.cxx.
References addReference(), SMESH.ALL, GetNodeGroupsTag(), ObjectToSObject(), publish(), PublishInStudy(), and SetName().
Referenced by SMESH_Mesh_i.CreateGroupServants(), and PublishMesh().
{
if (theStudy->_is_nil() || theMesh->_is_nil() || theGroup->_is_nil() )
return SALOMEDS::SObject::_nil();
SALOMEDS::SObject_var aGroupSO = ObjectToSObject( theStudy, theGroup );
if ( aGroupSO->_is_nil() )
{
SALOMEDS::SObject_var aMeshSO = ObjectToSObject( theStudy, theMesh );
if ( aMeshSO->_is_nil() ) {
aMeshSO = PublishInStudy( theStudy, SALOMEDS::SObject::_nil(), theMesh, "");
if ( aMeshSO->_is_nil())
return SALOMEDS::SObject::_nil();
}
int aType = (int)theGroup->GetType();
const char* aRootNames[] = {
"Compound Groups", "Groups of Nodes", "Groups of Edges",
"Groups of Faces", "Groups of Volumes", "Groups of 0D Elements" };
// Currently, groups with heterogenous content are not supported
if ( aType != SMESH::ALL ) {
long aRootTag = GetNodeGroupsTag() + aType - 1;
// Find or create groups root
SALOMEDS::SObject_var aRootSO = publish (theStudy, CORBA::Object::_nil(),
aMeshSO, aRootTag, 0, false );
if ( aType < 6 )
SetName( aRootSO, aRootNames[aType] );
// Add new group to corresponding sub-tree
SMESH::array_of_ElementType_var elemTypes = theGroup->GetTypes();
const int isEmpty = ( elemTypes->length() == 0 );
const char* pm[2] = { "ICON_SMESH_TREE_GROUP", "ICON_SMESH_TREE_MESH_WARN" };
aGroupSO = publish (theStudy, theGroup, aRootSO, 0, pm[ isEmpty ] );
}
if ( aGroupSO->_is_nil() )
return aGroupSO._retn();
}
SetName( aGroupSO, theName, "Group" );
//Add reference to geometry
if ( !theShapeObject->_is_nil() )
addReference( theStudy, aGroupSO, theShapeObject, 1 );
return aGroupSO._retn();
}
| SALOMEDS::SObject_ptr SMESH_Gen_i::PublishHypothesis | ( | SALOMEDS::Study_ptr | theStudy, |
| SMESH::SMESH_Hypothesis_ptr | theHyp, | ||
| const char * | theName = 0 |
||
| ) |
Definition at line 724 of file SMESH_Gen_i_1.cxx.
References batchmode_smesh.father, GetAlgorithmsRootTag(), GetHypothesisRootTag(), MESSAGE, myHypCreatorMap, ObjectToSObject(), publish(), PublishComponent(), and SetName().
Referenced by AddHypothesisToShape(), PublishMesh(), and PublishSubMesh().
{
if(MYDEBUG) MESSAGE("PublishHypothesis")
if (theStudy->_is_nil() || theHyp->_is_nil())
return SALOMEDS::SObject::_nil();
SALOMEDS::SObject_var aHypSO = ObjectToSObject( theStudy, theHyp );
if ( aHypSO->_is_nil() )
{
SALOMEDS::SComponent_var father = PublishComponent( theStudy );
if ( father->_is_nil() )
return aHypSO._retn();
//Find or Create Hypothesis root
bool isAlgo = ( !SMESH::SMESH_Algo::_narrow( theHyp )->_is_nil() );
int aRootTag = isAlgo ? GetAlgorithmsRootTag() : GetHypothesisRootTag();
SALOMEDS::SObject_var aRootSO =
publish (theStudy, CORBA::Object::_nil(),father, aRootTag,
isAlgo ? "ICON_SMESH_TREE_ALGO" : "ICON_SMESH_TREE_HYPO", false);
SetName( aRootSO, isAlgo ? "Algorithms" : "Hypotheses" );
// Add New Hypothesis
string aPmName = isAlgo ? "ICON_SMESH_TREE_ALGO_" : "ICON_SMESH_TREE_HYPO_";
aPmName += theHyp->GetName();
// prepend plugin name to pixmap name
string pluginName = myHypCreatorMap[string(theHyp->GetName())]->GetModuleName();
if ( pluginName != "StdMeshers" )
aPmName = pluginName + "::" + aPmName;
aHypSO = publish( theStudy, theHyp, aRootSO, 0, aPmName.c_str() );
}
if ( !aHypSO->_is_nil() ) {
CORBA::String_var aHypName = CORBA::string_dup( theHyp->GetName() );
SetName( aHypSO, theName, aHypName );
}
if(MYDEBUG) MESSAGE("PublishHypothesis--END")
return aHypSO._retn();
}
| SALOMEDS::SObject_ptr SMESH_Gen_i::PublishInStudy | ( | SALOMEDS::Study_ptr | theStudy, |
| SALOMEDS::SObject_ptr | theSObject, | ||
| CORBA::Object_ptr | theIOR, | ||
| const char * | theName | ||
| ) | throw ( SALOME::SALOME_Exception ) |
Publish object in the study
Definition at line 377 of file SMESH_Gen_i_1.cxx.
References SMESH_controls.aGroup, and MESSAGE.
Referenced by PublishGroup().
{
Unexpect aCatch(SALOME_SalomeException);
SALOMEDS::SObject_var aSO;
if ( CORBA::is_nil( theStudy ) || CORBA::is_nil( theIOR ))
return aSO._retn();
if(MYDEBUG) MESSAGE("PublishInStudy");
// Publishing a mesh
SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( theIOR );
if( !aMesh->_is_nil() )
aSO = PublishMesh( theStudy, aMesh, theName );
// Publishing a sub-mesh
SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( theIOR );
if( aSO->_is_nil() && !aSubMesh->_is_nil() ) {
GEOM::GEOM_Object_var aShapeObject = aSubMesh->GetSubShape();
aMesh = aSubMesh->GetFather();
aSO = PublishSubMesh( theStudy, aMesh, aSubMesh, aShapeObject, theName );
}
// Publishing a hypothesis or algorithm
SMESH::SMESH_Hypothesis_var aHyp = SMESH::SMESH_Hypothesis::_narrow( theIOR );
if ( aSO->_is_nil() && !aHyp->_is_nil() )
aSO = PublishHypothesis( theStudy, aHyp );
// Publishing a group
SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow(theIOR);
if ( aSO->_is_nil() && !aGroup->_is_nil() ) {
GEOM::GEOM_Object_var aShapeObject;
aMesh = aGroup->GetMesh();
aSO = PublishGroup( theStudy, aMesh, aGroup, aShapeObject, theName );
}
if(MYDEBUG) MESSAGE("PublishInStudy_END");
return aSO._retn();
}
| SALOMEDS::SObject_ptr SMESH_Gen_i::PublishMesh | ( | SALOMEDS::Study_ptr | theStudy, |
| SMESH::SMESH_Mesh_ptr | theMesh, | ||
| const char * | theName = 0 |
||
| ) |
Definition at line 489 of file SMESH_Gen_i_1.cxx.
References SMESH_Mesh_i._mapSubMesh_i, AddHypothesisToShape(), addReference(), SMESH_controls.aGroup, batchmode_smesh.father, findMaxChildTag(), GetAlgorithmsRootTag(), SMESH_Mesh_i.getGroups(), GetRefOnShapeTag(), MESSAGE, ObjectToSObject(), publish(), PublishComponent(), PublishGroup(), PublishHypothesis(), PublishSubMesh(), and SetName().
Referenced by AddHypothesisToShape(), CreateEmptyMesh(), and PublishSubMesh().
{
if ( CORBA::is_nil( theStudy ) ||
CORBA::is_nil( theMesh ))
return SALOMEDS::SComponent::_nil();
if(MYDEBUG) MESSAGE("PublishMesh--IN");
// find or publish a mesh
SALOMEDS::SObject_var aMeshSO = ObjectToSObject( theStudy, theMesh );
if ( aMeshSO->_is_nil() )
{
SALOMEDS::SComponent_var father = PublishComponent( theStudy );
if ( father->_is_nil() )
return aMeshSO._retn();
// Find correct free tag
long aTag = findMaxChildTag( father.in() );
if ( aTag <= GetAlgorithmsRootTag() )
aTag = GetAlgorithmsRootTag() + 1;
else
aTag++;
aMeshSO = publish (theStudy, theMesh, father, aTag, "ICON_SMESH_TREE_MESH_WARN" );
if ( aMeshSO->_is_nil() )
return aMeshSO._retn();
}
SetName( aMeshSO, theName, "Mesh" );
// Add shape reference
GEOM::GEOM_Object_var aShapeObject = theMesh->GetShapeToMesh();
if ( !CORBA::is_nil( aShapeObject )) {
addReference( theStudy, aMeshSO, aShapeObject, GetRefOnShapeTag() );
// Publish global hypotheses
SMESH::ListOfHypothesis_var hypList = theMesh->GetHypothesisList( aShapeObject );
for ( int i = 0; i < hypList->length(); i++ ) {
SMESH::SMESH_Hypothesis_var aHyp = SMESH::SMESH_Hypothesis::_narrow( hypList[ i ]);
PublishHypothesis( theStudy, aHyp );
AddHypothesisToShape( theStudy, theMesh, aShapeObject, aHyp );
}
}
// Publish submeshes
SMESH_Mesh_i* mesh_i = objectToServant<SMESH_Mesh_i>( theMesh );
if ( !mesh_i )
return aMeshSO._retn();
map<int, SMESH_subMesh_i*>& subMap = mesh_i->_mapSubMesh_i;
map<int, SMESH_subMesh_i*>::iterator subIt = subMap.begin();
for ( ; subIt != subMap.end(); subIt++ ) {
SMESH::SMESH_subMesh_ptr aSubMesh = (*subIt).second->_this();
if ( !CORBA::is_nil( aSubMesh )) {
aShapeObject = aSubMesh->GetSubShape();
PublishSubMesh( theStudy, theMesh, aSubMesh, aShapeObject );
}
}
// Publish groups
const map<int, SMESH::SMESH_GroupBase_ptr>& grMap = mesh_i->getGroups();
map<int, SMESH::SMESH_GroupBase_ptr>::const_iterator it = grMap.begin();
for ( ; it != grMap.end(); it++ )
{
SMESH::SMESH_GroupBase_ptr aGroup = (*it).second;
if ( !aGroup->_is_nil() ) {
GEOM::GEOM_Object_var aShapeObj;
SMESH::SMESH_GroupOnGeom_var aGeomGroup =
SMESH::SMESH_GroupOnGeom::_narrow( aGroup );
if ( !aGeomGroup->_is_nil() )
aShapeObj = aGeomGroup->GetShape();
PublishGroup( theStudy, theMesh, aGroup, aShapeObj );
}
}
if(MYDEBUG) MESSAGE("PublishMesh_END");
return aMeshSO._retn();
}
| SALOMEDS::SObject_ptr SMESH_Gen_i::PublishSubMesh | ( | SALOMEDS::Study_ptr | theStudy, |
| SMESH::SMESH_Mesh_ptr | theMesh, | ||
| SMESH::SMESH_subMesh_ptr | theSubMesh, | ||
| GEOM::GEOM_Object_ptr | theShapeObject, | ||
| const char * | theName = 0 |
||
| ) |
Definition at line 576 of file SMESH_Gen_i_1.cxx.
References AddHypothesisToShape(), addReference(), EDGE, FACE, GetSubMeshOnCompoundTag(), GetSubMeshOnEdgeTag(), GetSubMeshOnFaceTag(), GetSubMeshOnShellTag(), GetSubMeshOnSolidTag(), GetSubMeshOnVertexTag(), GetSubMeshOnWireTag(), ObjectToSObject(), publish(), PublishHypothesis(), PublishMesh(), and SetName().
Referenced by AddHypothesisToShape(), and PublishMesh().
{
if (theStudy->_is_nil() || theMesh->_is_nil() ||
theSubMesh->_is_nil() || theShapeObject->_is_nil() )
return SALOMEDS::SObject::_nil();
SALOMEDS::SObject_var aSubMeshSO = ObjectToSObject( theStudy, theSubMesh );
if ( aSubMeshSO->_is_nil() )
{
SALOMEDS::SObject_var aMeshSO = ObjectToSObject( theStudy, theMesh );
if ( aMeshSO->_is_nil() ) {
aMeshSO = PublishMesh( theStudy, theMesh );
if ( aMeshSO->_is_nil())
return SALOMEDS::SObject::_nil();
}
// Find submesh sub-tree tag
long aRootTag;
const char* aRootName = "";
switch ( theShapeObject->GetShapeType() ) {
case GEOM::VERTEX:
aRootTag = GetSubMeshOnVertexTag();
aRootName = "SubMeshes on Vertex";
break;
case GEOM::EDGE:
aRootTag = GetSubMeshOnEdgeTag();
aRootName = "SubMeshes on Edge";
break;
case GEOM::WIRE:
aRootTag = GetSubMeshOnWireTag();
aRootName = "SubMeshes on Wire";
break;
case GEOM::FACE:
aRootTag = GetSubMeshOnFaceTag();
aRootName = "SubMeshes on Face";
break;
case GEOM::SHELL:
aRootTag = GetSubMeshOnShellTag();
aRootName = "SubMeshes on Shell";
break;
case GEOM::SOLID:
aRootTag = GetSubMeshOnSolidTag();
aRootName = "SubMeshes on Solid";
break;
default:
aRootTag = GetSubMeshOnCompoundTag();
aRootName = "SubMeshes on Compound";
break;
}
// Find or create submesh root
SALOMEDS::SObject_var aRootSO = publish (theStudy, CORBA::Object::_nil(),
aMeshSO, aRootTag, 0, false );
SetName( aRootSO, aRootName );
// Add new submesh to corresponding sub-tree
SMESH::array_of_ElementType_var elemTypes = theSubMesh->GetTypes();
const int isEmpty = ( elemTypes->length() == 0 );
const char* pm[2] = { "ICON_SMESH_TREE_MESH", "ICON_SMESH_TREE_MESH_WARN" };
aSubMeshSO = publish (theStudy, theSubMesh, aRootSO, 0, pm[isEmpty] );
if ( aSubMeshSO->_is_nil() )
return aSubMeshSO._retn();
}
SetName( aSubMeshSO, theName, "SubMesh" );
// Add reference to theShapeObject
addReference( theStudy, aSubMeshSO, theShapeObject, 1 );
// Publish hypothesis
SMESH::ListOfHypothesis * hypList = theMesh->GetHypothesisList( theShapeObject );
if ( hypList )
for ( int i = 0; i < hypList->length(); i++ ) {
SMESH::SMESH_Hypothesis_var aHyp = SMESH::SMESH_Hypothesis::_narrow( (*hypList)[ i ]);
PublishHypothesis( theStudy, aHyp );
AddHypothesisToShape( theStudy, theMesh, theShapeObject, aHyp );
}
return aSubMeshSO._retn();
}
| int SMESH_Gen_i::RegisterObject | ( | CORBA::Object_ptr | theObject | ) |
Definition at line 4740 of file SMESH_Gen_i.cxx.
References StudyContext.addObject(), GetCurrentStudyContext(), and GetORB().
Referenced by SMESH_Mesh_i.ConvertToStandalone(), SMESH_Mesh_i.createGroup(), SMESH_Mesh_i.CreateGroupServants(), createMesh(), and SMESH_Mesh_i.createSubMesh().
{
StudyContext* myStudyContext = GetCurrentStudyContext();
if ( myStudyContext && !CORBA::is_nil( theObject )) {
CORBA::String_var iorString = GetORB()->object_to_string( theObject );
return myStudyContext->addObject( string( iorString.in() ) );
}
return 0;
}
| bool SMESH_Gen_i::RemoveHypothesisFromShape | ( | SALOMEDS::Study_ptr | theStudy, |
| SMESH::SMESH_Mesh_ptr | theMesh, | ||
| GEOM::GEOM_Object_ptr | theShapeObject, | ||
| SMESH::SMESH_Hypothesis_ptr | theHyp | ||
| ) |
Definition at line 865 of file SMESH_Gen_i_1.cxx.
References GetMeshOrSubmeshByShape(), and ObjectToSObject().
{
if (theStudy->_is_nil() || theMesh->_is_nil() ||
theHyp->_is_nil() || (theShape->_is_nil()
&& theMesh->HasShapeToMesh()))
return false;
SALOMEDS::SObject_var aHypSO = ObjectToSObject( theStudy, theHyp );
if ( aHypSO->_is_nil() )
return false;
// Find a mesh or submesh refering to theShape
SALOMEDS::SObject_var aMeshOrSubMesh =
GetMeshOrSubmeshByShape( theStudy, theMesh, theShape );
if ( aMeshOrSubMesh->_is_nil() )
return false;
// Find and remove a reference to aHypSO
SALOMEDS::SObject_var aRef, anObj;
CORBA::String_var anID = CORBA::string_dup( aHypSO->GetID() );
SALOMEDS::ChildIterator_var it = theStudy->NewChildIterator( aMeshOrSubMesh );
for ( it->InitEx( true ); it->More(); it->Next() ) {
anObj = it->Value();
if (anObj->ReferencedObject( aRef ) && strcmp( aRef->GetID(), anID ) == 0 ) {
theStudy->NewBuilder()->RemoveObject( anObj );
break;
}
}
return true;
}
| void SMESH_Gen_i::RemoveLastFromPythonScript | ( | int | theStudyID | ) |
RemoveLastFromPythonScript.
Definition at line 590 of file SMESH_DumpPython.cxx.
References myPythonScripts.
{
if (myPythonScripts.find(theStudyID) != myPythonScripts.end()) {
int aLen = myPythonScripts[theStudyID]->Length();
myPythonScripts[theStudyID]->Remove(aLen);
}
}
| SALOMEDS::TMPFile * SMESH_Gen_i::Save | ( | SALOMEDS::SComponent_ptr | theComponent, |
| const char * | theURL, | ||
| bool | isMultiFile | ||
| ) |
Save SMESH module's data
Definition at line 2513 of file SMESH_Gen_i.cxx.
References SMESH_controls.aGroup, SMDS_Mesh.elementsIterator(), SMESH_flight_skin.filename, StudyContext.findId(), Get0DElementsGroupsTag(), GetAlgorithmsRootTag(), SMESH_Mesh_i.GetAutoColor(), SMESH_GroupBase_i.GetColor(), GetCurrentStudyContext(), GetEdgeGroupsTag(), SMESHDS_SubMesh.GetElements(), GetFaceGroupsTag(), SMESH_GroupBase_i.GetGroupDS(), SMESHDS_Mesh.GetHypothesis(), GetHypothesisRootTag(), SMDS_MeshElement.GetID(), SMESHDS_GroupBase.GetID(), SMESH_Mesh_i.GetImpl(), SMESH_GroupBase_i.GetName(), GetNodeGroupsTag(), SMESHDS_SubMesh.GetNodes(), GetORB(), SMESHDS_Mesh.GetPersistentId(), SMDS_MeshNode.GetPosition(), GetRefOnAppliedAlgorithmsTag(), GetRefOnAppliedHypothesisTag(), GetRefOnShapeTag(), GetServant(), SMESHDS_GroupBase.GetStoreName(), GetSubMeshOnCompoundTag(), GetSubMeshOnEdgeTag(), GetSubMeshOnFaceTag(), GetSubMeshOnShellTag(), GetSubMeshOnSolidTag(), GetSubMeshOnVertexTag(), GetSubMeshOnWireTag(), SMDS_EdgePosition.GetUParameter(), SMDS_FacePosition.GetUParameter(), GetVolumeGroupsTag(), SMDS_FacePosition.GetVParameter(), SMESH_demo_hexa2_upd.hyp, SMESHDS_Mesh.IndexToShape(), SMESHDS_SubMesh.IsComplexSubmesh(), SMESHDS_Mesh.MaxShapeIndex(), myCurrentStudy, SMDS_Mesh.NbEdges(), SMDS_Mesh.NbFaces(), SMESHDS_SubMesh.NbNodes(), SMDS_Mesh.NbNodes(), SMDS_Mesh.NbVolumes(), ex29_refine.node(), SMDS_Mesh.nodesIterator(), NUM_TMP_FILES, SavePython(), SMESH_Hypothesis_i.SaveTo(), SetCurrentStudy(), DriverMED_W_SMESHDS_Mesh.SetFile(), SMESHDS_GroupBase.SetStoreName(), SMESHDS_Mesh.ShapeToMesh(), SObjectToObject(), and SMESHDS_Mesh.SubMeshes().
Referenced by SaveASCII().
{
INFOS( "SMESH_Gen_i::Save" );
// ASSERT( theComponent->GetStudy()->StudyId() == myCurrentStudy->StudyId() )
// san -- in case <myCurrentStudy> 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 ) : ( char* )SALOMEDS_Tool::GetTmpDir().c_str();
// Create a sequence of files processed
SALOMEDS::ListOfFileNames_var aFileSeq = new SALOMEDS::ListOfFileNames;
aFileSeq->length( NUM_TMP_FILES );
TCollection_AsciiString aStudyName( "" );
if ( isMultiFile )
aStudyName = ( (char*)SALOMEDS_Tool::GetNameFromPath( myCurrentStudy->URL() ).c_str() );
// Set names of temporary files
TCollection_AsciiString filename =
aStudyName + TCollection_AsciiString( "_SMESH.hdf" ); // for SMESH data itself
TCollection_AsciiString meshfile =
aStudyName + TCollection_AsciiString( "_SMESH_Mesh.med" ); // for mesh data to be stored in MED file
aFileSeq[ 0 ] = CORBA::string_dup( filename.ToCString() );
aFileSeq[ 1 ] = CORBA::string_dup( meshfile.ToCString() );
filename = tmpDir + filename;
meshfile = tmpDir + meshfile;
HDFfile* aFile;
HDFdataset* aDataset;
HDFgroup* aTopGroup;
HDFgroup* aGroup;
HDFgroup* aSubGroup;
HDFgroup* aSubSubGroup;
hdf_size aSize[ 1 ];
//Remove the files if they exist: BugID: 11225
#ifndef WNT /* unix functionality */
TCollection_AsciiString cmd("rm -f \"");
#else /* windows */
TCollection_AsciiString cmd("del /F \"");
#endif
cmd+=filename;
cmd+="\" \"";
cmd+=meshfile;
cmd+="\"";
system(cmd.ToCString());
// MED writer to be used by storage process
DriverMED_W_SMESHDS_Mesh myWriter;
myWriter.SetFile( meshfile.ToCString() );
// IMP issue 20918
// SetStoreName() to groups before storing hypotheses to let them refer to
// groups using "store name", which is "Group <group_persistent_id>"
{
SALOMEDS::ChildIterator_var itBig = myCurrentStudy->NewChildIterator( theComponent );
for ( ; itBig->More(); itBig->Next() ) {
SALOMEDS::SObject_var gotBranch = itBig->Value();
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::ListOfGroups_var groups = myMesh->GetGroups();
for ( int i = 0; i < groups->length(); ++i )
{
SMESH_GroupBase_i* grImpl = SMESH::DownCast<SMESH_GroupBase_i*>( groups[i]);
if ( grImpl )
{
CORBA::String_var objStr = GetORB()->object_to_string( grImpl->_this() );
int anId = myStudyContext->findId( string( objStr.in() ) );
char grpName[ 30 ];
sprintf( grpName, "Group %d", anId );
SMESHDS_GroupBase* aGrpBaseDS = grImpl->GetGroupDS();
aGrpBaseDS->SetStoreName( grpName );
}
}
}
}
}
}
}
// Write data
// ---> create HDF file
aFile = new HDFfile( (char*) filename.ToCString() );
aFile->CreateOnDisk();
// --> iterator for top-level objects
SALOMEDS::ChildIterator_var itBig = myCurrentStudy->NewChildIterator( theComponent );
for ( ; itBig->More(); itBig->Next() ) {
SALOMEDS::SObject_var gotBranch = itBig->Value();
// --> hypotheses root branch (only one for the study)
if ( gotBranch->Tag() == GetHypothesisRootTag() ) {
// create hypotheses root HDF group
aTopGroup = new HDFgroup( "Hypotheses", aFile );
aTopGroup->CreateOnDisk();
// iterator for all hypotheses
SALOMEDS::ChildIterator_var it = myCurrentStudy->NewChildIterator( gotBranch );
for ( ; it->More(); it->Next() ) {
SALOMEDS::SObject_var mySObject = it->Value();
CORBA::Object_var anObject = SObjectToObject( mySObject );
if ( !CORBA::is_nil( anObject ) ) {
SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow( anObject );
if ( !myHyp->_is_nil() ) {
SMESH_Hypothesis_i* myImpl = dynamic_cast<SMESH_Hypothesis_i*>( GetServant( myHyp ).in() );
if ( myImpl ) {
string hypname = string( myHyp->GetName() );
string libname = string( myHyp->GetLibName() );
// BUG SWP13062
// Needs for save crossplatform libname, i.e. parth of name ( ".dll" for
// WNT and ".so" for X-system) must be deleted
int libname_len = libname.length();
#ifdef WNT
if( libname_len > 4 )
libname.resize( libname_len - 4 );
#else
// PAL17753 (Regresion: missing hypothesis in restored study)
// "lib" also should be removed from the beginning
//if( libname_len > 3 )
//libname.resize( libname_len - 3 );
if( libname_len > 6 )
libname = libname.substr( 3, libname_len - 3 - 3 );
#endif
CORBA::String_var objStr = GetORB()->object_to_string( anObject );
int id = myStudyContext->findId( string( objStr.in() ) );
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();
}
}
}
}
// close hypotheses root HDF group
aTopGroup->CloseOnDisk();
}
// --> algorithms root branch (only one for the study)
else if ( gotBranch->Tag() == GetAlgorithmsRootTag() ) {
// create algorithms root HDF group
aTopGroup = new HDFgroup( "Algorithms", aFile );
aTopGroup->CreateOnDisk();
// iterator for all algorithms
SALOMEDS::ChildIterator_var it = myCurrentStudy->NewChildIterator( gotBranch );
for ( ; it->More(); it->Next() ) {
SALOMEDS::SObject_var mySObject = it->Value();
CORBA::Object_var anObject = SObjectToObject( mySObject );
if ( !CORBA::is_nil( anObject ) ) {
SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow( anObject );
if ( !myHyp->_is_nil() ) {
SMESH_Hypothesis_i* myImpl = dynamic_cast<SMESH_Hypothesis_i*>( GetServant( myHyp ).in() );
if ( myImpl ) {
string hypname = string( myHyp->GetName() );
string libname = string( myHyp->GetLibName() );
// BUG SWP13062
// Needs for save crossplatform libname, i.e. parth of name ( ".dll" for
// WNT and ".so" for X-system) must be deleted
int libname_len = libname.length();
#ifdef WNT
if( libname_len > 4 )
libname.resize( libname_len - 4 );
#else
// PAL17753 (Regresion: missing hypothesis in restored study)
// "lib" also should be removed from the beginning
//if( libname_len > 3 )
//libname.resize( libname_len - 3 );
if( libname_len > 6 )
libname = libname.substr( 3, libname_len - 3 - 3 );
#endif
CORBA::String_var objStr = GetORB()->object_to_string( anObject );
int id = myStudyContext->findId( string( objStr.in() ) );
string hypdata = string( myImpl->SaveTo() );
// for each algorithm create HDF group basing on its id
char hypGrpName[30];
sprintf( hypGrpName, "Algorithm %d", id );
aGroup = new HDFgroup( hypGrpName, aTopGroup );
aGroup->CreateOnDisk();
// --> type name of algorithm
aSize[0] = hypname.length() + 1;
aDataset = new HDFdataset( "Name", aGroup, HDF_STRING, aSize, 1 );
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( ( char* )( hypname.c_str() ) );
aDataset->CloseOnDisk();
// --> server plugin library name of hypothesis
aSize[0] = libname.length() + 1;
aDataset = new HDFdataset( "LibName", aGroup, HDF_STRING, aSize, 1 );
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( ( char* )( libname.c_str() ) );
aDataset->CloseOnDisk();
// --> persistent data of algorithm
aSize[0] = hypdata.length() + 1;
aDataset = new HDFdataset( "Data", aGroup, HDF_STRING, aSize, 1 );
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( ( char* )( hypdata.c_str() ) );
aDataset->CloseOnDisk();
// close algorithm HDF group
aGroup->CloseOnDisk();
}
}
}
}
// close algorithms root HDF group
aTopGroup->CloseOnDisk();
}
// --> mesh objects roots branches
else if ( gotBranch->Tag() > GetAlgorithmsRootTag() ) {
CORBA::Object_var anObject = SObjectToObject( gotBranch );
if ( !CORBA::is_nil( anObject ) ) {
SMESH::SMESH_Mesh_var myMesh = SMESH::SMESH_Mesh::_narrow( anObject ) ;
if ( !myMesh->_is_nil() ) {
SMESH_Mesh_i* myImpl = dynamic_cast<SMESH_Mesh_i*>( GetServant( myMesh ).in() );
if ( myImpl ) {
CORBA::String_var objStr = GetORB()->object_to_string( anObject );
int id = myStudyContext->findId( string( objStr.in() ) );
::SMESH_Mesh& myLocMesh = myImpl->GetImpl();
SMESHDS_Mesh* mySMESHDSMesh = myLocMesh.GetMeshDS();
bool hasShape = myLocMesh.HasShapeToMesh();
// for each mesh open the HDF group basing on its id
char meshGrpName[ 30 ];
sprintf( meshGrpName, "Mesh %d", id );
aTopGroup = new HDFgroup( meshGrpName, aFile );
aTopGroup->CreateOnDisk();
// --> put dataset to hdf file which is a flag that mesh has data
string strHasData = "0";
// check if the mesh is not empty
if ( mySMESHDSMesh->NbNodes() > 0 ) {
// write mesh data to med file
myWriter.SetMesh( mySMESHDSMesh );
myWriter.SetMeshId( id );
strHasData = "1";
}
aSize[ 0 ] = strHasData.length() + 1;
aDataset = new HDFdataset( "Has data", aTopGroup, HDF_STRING, aSize, 1 );
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( ( char* )( strHasData.c_str() ) );
aDataset->CloseOnDisk();
// ouv : NPAL12872
// for each mesh open the HDF group basing on its auto color parameter
char meshAutoColorName[ 30 ];
sprintf( meshAutoColorName, "AutoColorMesh %d", id );
int anAutoColor[1];
anAutoColor[0] = myImpl->GetAutoColor();
aSize[ 0 ] = 1;
aDataset = new HDFdataset( meshAutoColorName, aTopGroup, HDF_INT32, aSize, 1 );
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( anAutoColor );
aDataset->CloseOnDisk();
// issue 0020693. Store _isModified flag
int isModified = myLocMesh.GetIsModified();
aSize[ 0 ] = 1;
aDataset = new HDFdataset( "_isModified", aTopGroup, HDF_INT32, aSize, 1 );
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( &isModified );
aDataset->CloseOnDisk();
// issue 20918. Store Persistent Id of SMESHDS_Mesh
int meshPersistentId = mySMESHDSMesh->GetPersistentId();
aSize[ 0 ] = 1;
aDataset = new HDFdataset( "meshPersistentId", aTopGroup, HDF_INT32, aSize, 1 );
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( &meshPersistentId );
aDataset->CloseOnDisk();
// write reference on a shape if exists
SALOMEDS::SObject_var myRef;
bool shapeRefFound = false;
bool found = gotBranch->FindSubObject( GetRefOnShapeTag(), myRef );
if ( found ) {
SALOMEDS::SObject_var myShape;
bool ok = myRef->ReferencedObject( myShape );
if ( ok ) {
shapeRefFound = (! CORBA::is_nil( myShape->GetObject() ));
string myRefOnObject = myShape->GetID();
if ( shapeRefFound && myRefOnObject.length() > 0 ) {
aSize[ 0 ] = myRefOnObject.length() + 1;
aDataset = new HDFdataset( "Ref on shape", aTopGroup, HDF_STRING, aSize, 1 );
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( ( char* )( myRefOnObject.c_str() ) );
aDataset->CloseOnDisk();
}
}
}
// write applied hypotheses if exist
SALOMEDS::SObject_var myHypBranch;
found = gotBranch->FindSubObject( GetRefOnAppliedHypothesisTag(), myHypBranch );
if ( found && !shapeRefFound && hasShape) { // remove applied hyps
myCurrentStudy->NewBuilder()->RemoveObjectWithChildren( myHypBranch );
}
if ( found && (shapeRefFound || !hasShape) ) {
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 );
CORBA::String_var objStr = GetORB()->object_to_string( anObject );
int id = myStudyContext->findId( string( objStr.in() ) );
//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();
//}
}
}
aGroup->CloseOnDisk();
}
// write applied algorithms if exist
SALOMEDS::SObject_var myAlgoBranch;
found = gotBranch->FindSubObject( GetRefOnAppliedAlgorithmsTag(), myAlgoBranch );
if ( found && !shapeRefFound && hasShape) { // remove applied algos
myCurrentStudy->NewBuilder()->RemoveObjectWithChildren( myAlgoBranch );
}
if ( found && (shapeRefFound || !hasShape)) {
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 );
CORBA::String_var objStr = GetORB()->object_to_string( anObject );
int id = myStudyContext->findId( string( objStr.in() ) );
//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<const SMESHDS_Hypothesis*>& hypList =
mySMESHDSMesh->GetHypothesis( S );
list<const SMESHDS_Hypothesis*>::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" );
// 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 ) ;
CORBA::String_var objStr = GetORB()->object_to_string( anSubObject );
int subid = myStudyContext->findId( string( objStr.in() ) );
// 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 );
CORBA::String_var objStr = GetORB()->object_to_string( anObject );
int id = myStudyContext->findId( string( objStr.in() ) );
//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 );
CORBA::String_var objStr = GetORB()->object_to_string( anObject );
int id = myStudyContext->findId( string( objStr.in() ) );
//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();
}
}
// close container of submeshes by type HDF group
aGroup->CloseOnDisk();
}
}
// All sub-meshes will be stored in MED file
// .. will NOT (PAL 12992)
//if ( shapeRefFound )
//myWriter.AddAllSubMeshes();
// store submesh order if any
const TListOfListOfInt& theOrderIds = myLocMesh.GetMeshOrder();
if ( theOrderIds.size() ) {
char order_list[ 30 ];
strcpy( order_list, "Mesh Order" );
// count number of submesh ids
int nbIDs = 0;
TListOfListOfInt::const_iterator idIt = theOrderIds.begin();
for ( ; idIt != theOrderIds.end(); idIt++ )
nbIDs += (*idIt).size();
// number of values = number of IDs +
// number of lists (for separators) - 1
int* smIDs = new int [ nbIDs + theOrderIds.size() - 1 ];
idIt = theOrderIds.begin();
for ( int i = 0; idIt != theOrderIds.end(); idIt++ ) {
const TListOfInt& idList = *idIt;
if (idIt != theOrderIds.begin()) // not first list
smIDs[ i++ ] = -1/* *idList.size()*/; // separator between lists
// dump submesh ids from current list
TListOfInt::const_iterator id_smId = idList.begin();
for( ; id_smId != idList.end(); id_smId++ )
smIDs[ i++ ] = *id_smId;
}
// write HDF group
aSize[ 0 ] = nbIDs + theOrderIds.size() - 1;
aDataset = new HDFdataset( order_list, aTopGroup, HDF_INT32, aSize, 1 );
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( smIDs );
aDataset->CloseOnDisk();
//
delete[] smIDs;
}
// groups root sub-branch
SALOMEDS::SObject_var myGroupsBranch;
for ( int i = GetNodeGroupsTag(); i <= Get0DElementsGroupsTag(); 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" );
else if ( i == Get0DElementsGroupsTag() )
strcpy( name_group, "Groups of 0D Elements" );
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<SMESH_GroupBase_i*>( GetServant( aSubObject ).in() );
if ( !myGroupImpl )
continue;
SMESHDS_GroupBase* aGrpBaseDS = myGroupImpl->GetGroupDS();
if ( !aGrpBaseDS )
continue;
CORBA::String_var objStr = GetORB()->object_to_string( aSubObject );
int anId = myStudyContext->findId( string( objStr.in() ) );
// For each group, create a dataset named "Group <group_persistent_id>"
// and store the group's user name into it
const char* grpName = aGrpBaseDS->GetStoreName();
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();
// ouv : NPAL12872
// For each group, create a dataset named "Group <group_persistent_id> Color"
// and store the group's color into it
char grpColorName[ 30 ];
sprintf( grpColorName, "ColorGroup %d", anId );
SALOMEDS::Color aColor = myGroupImpl->GetColor();
double anRGB[3];
anRGB[ 0 ] = aColor.R;
anRGB[ 1 ] = aColor.G;
anRGB[ 2 ] = aColor.B;
aSize[ 0 ] = 3;
aDataset = new HDFdataset( grpColorName, aGroup, HDF_FLOAT64, aSize, 1 );
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( anRGB );
aDataset->CloseOnDisk();
// Pass SMESHDS_Group to MED writer
SMESHDS_Group* aGrpDS = dynamic_cast<SMESHDS_Group*>( aGrpBaseDS );
if ( aGrpDS )
myWriter.AddGroup( aGrpDS );
// write reference on a shape if exists
SMESHDS_GroupOnGeom* aGeomGrp =
dynamic_cast<SMESHDS_GroupOnGeom*>( 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() && hasShape) {
TopoDS_Shape nullShape;
myLocMesh.ShapeToMesh( nullShape ); // remove shape referring data
}
if ( !mySMESHDSMesh->SubMeshes().empty() )
{
// Store submeshes
// ----------------
aGroup = new HDFgroup( "Submeshes", aTopGroup );
aGroup->CreateOnDisk();
// each element belongs to one or none submesh,
// so for each node/element, we store a submesh ID
// Make maps of submesh IDs of elements sorted by element IDs
typedef int TElemID;
typedef int TSubMID;
map< TElemID, TSubMID > eId2smId, nId2smId;
map< TElemID, TSubMID >::iterator hint; // insertion to map is done before hint
const map<int,SMESHDS_SubMesh*>& aSubMeshes = mySMESHDSMesh->SubMeshes();
map<int,SMESHDS_SubMesh*>::const_iterator itSubM ( aSubMeshes.begin() );
SMDS_NodeIteratorPtr itNode;
SMDS_ElemIteratorPtr itElem;
for ( itSubM = aSubMeshes.begin(); itSubM != aSubMeshes.end() ; itSubM++ )
{
TSubMID aSubMeID = itSubM->first;
SMESHDS_SubMesh* aSubMesh = itSubM->second;
if ( aSubMesh->IsComplexSubmesh() )
continue; // submesh containing other submeshs
// nodes
hint = nId2smId.begin(); // optimize insertion basing on increasing order of elem Ids in submesh
for ( itNode = aSubMesh->GetNodes(); itNode->more(); ++hint)
hint = nId2smId.insert( hint, make_pair( itNode->next()->GetID(), aSubMeID ));
// elements
hint = eId2smId.begin();
for ( itElem = aSubMesh->GetElements(); itElem->more(); ++hint)
hint = eId2smId.insert( hint, make_pair( itElem->next()->GetID(), aSubMeID ));
}
// Care of elements that are not on submeshes
if ( mySMESHDSMesh->NbNodes() != nId2smId.size() ) {
for ( itNode = mySMESHDSMesh->nodesIterator(); itNode->more(); )
/* --- stl_map.h says : */
/* A %map relies on unique keys and thus a %pair is only inserted if its */
/* first element (the key) is not already present in the %map. */
nId2smId.insert( make_pair( itNode->next()->GetID(), 0 ));
}
int nbElems = mySMESHDSMesh->NbEdges() + mySMESHDSMesh->NbFaces() + mySMESHDSMesh->NbVolumes();
if ( nbElems != eId2smId.size() ) {
for ( itElem = mySMESHDSMesh->elementsIterator(); itElem->more(); )
eId2smId.insert( make_pair( itElem->next()->GetID(), 0 ));
}
// Store submesh IDs
for ( int isNode = 0; isNode < 2; ++isNode )
{
map< TElemID, TSubMID >& id2smId = isNode ? nId2smId : eId2smId;
if ( id2smId.empty() ) continue;
map< TElemID, TSubMID >::const_iterator id_smId = id2smId.begin();
// make and fill array of submesh IDs
int* smIDs = new int [ id2smId.size() ];
for ( int i = 0; id_smId != id2smId.end(); ++id_smId, ++i )
smIDs[ i ] = id_smId->second;
// write HDF group
aSize[ 0 ] = id2smId.size();
string aDSName( isNode ? "Node Submeshes" : "Element Submeshes");
aDataset = new HDFdataset( (char*)aDSName.c_str(), aGroup, HDF_INT32, aSize, 1 );
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( smIDs );
aDataset->CloseOnDisk();
//
delete[] smIDs;
}
// Store node positions on sub-shapes (SMDS_Position):
// ----------------------------------------------------
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<SMESHDS_SubMesh*> aEdgeSM, aFaceSM;
// loop on SMESHDS_SubMesh'es
for ( itSubM = aSubMeshes.begin(); 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;
if ( aShapeID < 1 || aShapeID > mySMESHDSMesh->MaxShapeIndex() )
continue;
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<SMESHDS_SubMesh*> * pListSM = ( onFace ? &aFaceSM : &aEdgeSM );
list<SMESHDS_SubMesh*>::iterator itSM = pListSM->begin();
for ( ; itSM != pListSM->end(); itSM++ )
{
SMESHDS_SubMesh* aSubMesh = (*itSM);
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<const SMDS_FacePosition*>( pos );
if ( fPos ) {
aUPos[ iNode ] = fPos->GetUParameter();
aVPos[ iNode ] = fPos->GetVParameter();
iNode++;
}
else
nbNodes--;
}
else { // on EDGE
const SMDS_EdgePosition* ePos =
dynamic_cast<const SMDS_EdgePosition*>( pos );
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();
}
}
}
}
}
// close HDF file
aFile->CloseOnDisk();
delete aFile;
// Convert temporary files to stream
aStreamFile = SALOMEDS_Tool::PutFilesToStream( tmpDir.ToCString(), aFileSeq.in(), isMultiFile );
// Remove temporary files and directory
if ( !isMultiFile )
SALOMEDS_Tool::RemoveTemporaryFiles( tmpDir.ToCString(), aFileSeq.in(), true );
INFOS( "SMESH_Gen_i::Save() completed" );
return aStreamFile._retn();
}
| SALOMEDS::TMPFile * SMESH_Gen_i::SaveASCII | ( | SALOMEDS::SComponent_ptr | theComponent, |
| const char * | theURL, | ||
| bool | isMultiFile | ||
| ) |
Save SMESH module's data in ASCII format
Definition at line 3486 of file SMESH_Gen_i.cxx.
References MESSAGE, MYDEBUG, Save(), and ex21_lamp.size.
{
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::SaveASCII" );
SALOMEDS::TMPFile_var aStreamFile = Save( theComponent, theURL, isMultiFile );
return aStreamFile._retn();
//after usual saving needs to encipher binary to text string
//Any binary symbol will be represent as "|xx" () hexadecimal format number
int size = aStreamFile.in().length();
_CORBA_Octet* buffer = new _CORBA_Octet[size*3+1];
for ( int i = 0; i < size; i++ )
sprintf( (char*)&(buffer[i*3]), "|%02x", aStreamFile[i] );
buffer[size * 3] = '\0';
SALOMEDS::TMPFile_var anAsciiStreamFile = new SALOMEDS::TMPFile(size*3, size*3, buffer, 1);
return anAsciiStreamFile._retn();
}
| void SMESH_Gen_i::SavePython | ( | SALOMEDS::Study_ptr | theStudy | ) |
Definition at line 602 of file SMESH_DumpPython.cxx.
References CleanPythonTrace(), ComponentDataType(), and GetNewPythonLines().
Referenced by Save().
{
// Dump trace of API methods calls
TCollection_AsciiString aScript = GetNewPythonLines(theStudy->StudyId());
// Check contents of PythonObject attribute
SALOMEDS::SObject_var aSO = theStudy->FindComponent(ComponentDataType());
//SALOMEDS::SObject_var aSO = SMESH_Gen_i::ObjectToSObject(theStudy, _this());
SALOMEDS::StudyBuilder_var aStudyBuilder = theStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr =
aStudyBuilder->FindOrCreateAttribute(aSO, "AttributePythonObject");
char* oldValue = SALOMEDS::AttributePythonObject::_narrow(anAttr)->GetObject();
TCollection_AsciiString oldScript (oldValue);
if (oldScript.Length() > 0) {
oldScript += "\n";
oldScript += aScript;
} else {
oldScript = aScript;
}
// Store in PythonObject attribute
SALOMEDS::AttributePythonObject::_narrow(anAttr)->SetObject(oldScript.ToCString(), 1);
// Clean trace of API methods calls
CleanPythonTrace(theStudy->StudyId());
}
| void SMESH_Gen_i::SetBoundaryBoxSegmentation | ( | CORBA::Long | theNbSegments | ) | throw ( SALOME::SALOME_Exception ) |
Sets number of segments per diagonal of boundary box of geometry by which default segment length of appropriate 1D hypotheses is defined.
Definition at line 782 of file SMESH_Gen_i.cxx.
{
if ( theNbSegments > 0 )
myGen.SetBoundaryBoxSegmentation( int( theNbSegments ));
else
THROW_SALOME_CORBA_EXCEPTION( "non-positive number of segments", SALOME::BAD_PARAM );
}
| void SMESH_Gen_i::SetCurrentStudy | ( | SALOMEDS::Study_ptr | theStudy | ) |
Set current study
Definition at line 588 of file SMESH_Gen_i.cxx.
References ComponentDataType(), GetCurrentStudyID(), GetGeomEngine(), PAL_MESH_041_mesh.mesh, myCurrentStudy, myStudyContextMap, and SObjectToObject().
Referenced by Close(), Load(), StdMeshers_LayerDistribution_i.LoadFrom(), and Save().
{
int curStudyId = GetCurrentStudyID();
myCurrentStudy = SALOMEDS::Study::_duplicate( theStudy );
// create study context, if it doesn't exist and set current study
int studyId = GetCurrentStudyID();
if ( myStudyContextMap.find( studyId ) == myStudyContextMap.end() ) {
myStudyContextMap[ studyId ] = new StudyContext;
}
// myCurrentStudy may be nil
if ( !CORBA::is_nil( myCurrentStudy ) ) {
SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
if( !myCurrentStudy->FindComponent( "GEOM" )->_is_nil() )
aStudyBuilder->LoadWith( myCurrentStudy->FindComponent( "GEOM" ), GetGeomEngine() );
// NPAL16168, issue 0020210
// Let meshes update their data depending on GEOM groups that could change
if ( curStudyId != studyId )
{
//SALOMEDS::SComponent_var me = PublishComponent( myCurrentStudy );
SALOMEDS::SComponent_var me = SALOMEDS::SComponent::_narrow
( myCurrentStudy->FindComponent( ComponentDataType() ) );
if ( !me->_is_nil() ) {
SALOMEDS::ChildIterator_var anIter = myCurrentStudy->NewChildIterator( me );
for ( ; anIter->More(); anIter->Next() ) {
SALOMEDS::SObject_var so = anIter->Value();
CORBA::Object_var ior = SObjectToObject( so );
if ( SMESH_Mesh_i* mesh = SMESH::DownCast<SMESH_Mesh_i*>( ior ))
mesh->CheckGeomGroupModif();
}
}
}
}
}
| void SMESH_Gen_i::SetDefaultNbSegments | ( | CORBA::Long | theNbSegments | ) | throw ( SALOME::SALOME_Exception ) |
Sets default number of segments per edge.
Definition at line 795 of file SMESH_Gen_i.cxx.
{
if ( theNbSegments > 0 )
myGen.SetDefaultNbSegments( int(theNbSegments) );
else
THROW_SALOME_CORBA_EXCEPTION( "non-positive number of segments", SALOME::BAD_PARAM );
}
| void SMESH_Gen_i::SetEmbeddedMode | ( | CORBA::Boolean | theMode | ) |
Set current mode
Definition at line 542 of file SMESH_Gen_i.cxx.
References MESSAGE, and myIsEmbeddedMode.
Referenced by SMESH_Gen_i().
{
myIsEmbeddedMode = theMode;
MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);
if ( !myIsEmbeddedMode ) {
//PAL10867: disable signals catching with "noexcepthandler" option
char* envNoCatchSignals = getenv("NOT_INTERCEPT_SIGNALS");
if (!envNoCatchSignals || !atoi(envNoCatchSignals))
{
bool raiseFPE;
#ifdef _DEBUG_
raiseFPE = true;
char* envDisableFPE = getenv("DISABLE_FPE");
if (envDisableFPE && atoi(envDisableFPE))
raiseFPE = false;
#else
raiseFPE = false;
#endif
OSD::SetSignal( raiseFPE );
}
// else OSD::SetSignal() is called in GUI
}
}
| void SMESH_Gen_i::SetGeomEngine | ( | GEOM::GEOM_Gen_ptr | geomcompo | ) |
Set GEOM.GEOM_Gen reference
Definition at line 526 of file SMESH_Gen_i.cxx.
References myGeomGen.
{
//Engines::Component_ptr temp=GetLCC()->FindOrLoad_Component(containerLoc,"GEOM");
//myGeomGen=GEOM::GEOM_Gen::_narrow(temp);
myGeomGen=GEOM::GEOM_Gen::_duplicate(geomcompo);
//return myGeomGen;
}
| void SMESH_Gen_i::SetName | ( | SALOMEDS::SObject_ptr | theSObject, |
| const char * | theName, | ||
| const char * | theDefaultName = 0 |
||
| ) | [static] |
Definition at line 286 of file SMESH_Gen_i_1.cxx.
{
if ( !theSObject->_is_nil() ) {
SALOMEDS::StudyBuilder_var aStudyBuilder = theSObject->GetStudy()->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr =
aStudyBuilder->FindOrCreateAttribute( theSObject, "AttributeName" );
SALOMEDS::AttributeName_var aNameAttr = SALOMEDS::AttributeName::_narrow( anAttr );
if ( theName && strlen( theName ) != 0 )
aNameAttr->SetValue( theName );
else {
CORBA::String_var curName = CORBA::string_dup( aNameAttr->Value() );
if ( strlen( curName ) == 0 ) {
TCollection_AsciiString aName( (char*) theDefaultName );
aName += TCollection_AsciiString("_") + TCollection_AsciiString( theSObject->Tag() );
aNameAttr->SetValue( aName.ToCString() );
}
}
}
}
| void SMESH_Gen_i::SetName | ( | const char * | theIOR, |
| const char * | theName | ||
| ) |
Set a new object name
Definition at line 4775 of file SMESH_Gen_i.cxx.
References GetORB(), myCurrentStudy, and ObjectToSObject().
Referenced by AddHypothesisToShape(), CopyMesh(), SMESH_MeshEditor_i.makeMesh(), PublishComponent(), PublishGroup(), PublishHypothesis(), PublishMesh(), PublishSubMesh(), and SMESH_GroupBase_i.SetName().
{
if ( theIOR && strcmp( theIOR, "" ) ) {
CORBA::Object_var anObject = GetORB()->string_to_object( theIOR );
SALOMEDS::SObject_var aSO = ObjectToSObject( myCurrentStudy, anObject );
if ( !aSO->_is_nil() ) {
SetName( aSO, theName );
}
}
}
| void SMESH_Gen_i::SetPixMap | ( | SALOMEDS::SObject_ptr | theSObject, |
| const char * | thePixMap | ||
| ) | [static] |
Definition at line 313 of file SMESH_Gen_i_1.cxx.
Referenced by SMESH_Mesh_i.CheckGeomGroupModif(), CopyMesh(), and SMESH_MeshEditor_i.makeMesh().
{
if ( !theSObject->_is_nil() && thePixMap && strlen( thePixMap ))
{
SALOMEDS::Study_var aStudy = theSObject->GetStudy();
SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr =
aStudyBuilder->FindOrCreateAttribute( theSObject, "AttributePixMap" );
SALOMEDS::AttributePixMap_var aPMAttr = SALOMEDS::AttributePixMap::_narrow( anAttr );
aPMAttr->SetPixMap( thePixMap );
}
}
| GEOM::GEOM_Object_ptr SMESH_Gen_i::ShapeToGeomObject | ( | const TopoDS_Shape & | theShape | ) |
Definition at line 210 of file SMESH_Gen_i_1.cxx.
References GetORB(), and GetShapeReader().
Referenced by SMESH_Mesh_i.createGroup(), SMESH_Mesh_i.CreateGroupServants(), SMESH_GroupOnGeom_i.GetShape(), SMESH_Mesh_i.GetShapeToMesh(), and SMESH_subMesh_i.GetSubShape().
{
GEOM::GEOM_Object_var aShapeObj;
if ( !theShape.IsNull() ) {
GEOM_Client* aClient = GetShapeReader();
TCollection_AsciiString IOR;
if ( aClient && aClient->Find( theShape, IOR ))
{
CORBA::Object_var obj = GetORB()->string_to_object( IOR.ToCString() );
aShapeObj = GEOM::GEOM_Object::_narrow ( obj );
}
}
return aShapeObj._retn();
}
| CORBA::Object_var SMESH_Gen_i::SObjectToObject | ( | SALOMEDS::SObject_ptr | theSObject | ) | [static] |
SObjectToObject [ static ].
Get CORBA object corresponding to the SALOMEDS.SObject
Definition at line 172 of file SMESH_Gen_i.cxx.
Referenced by GetAlgoSO(), Load(), SMESH_Mesh_i.newGroupShape(), Save(), and SetCurrentStudy().
{
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;
}
| void SMESH_Gen_i::UpdateParameters | ( | CORBA::Object_ptr | theObject, |
| const char * | theParameters | ||
| ) |
Definition at line 903 of file SMESH_Gen_i_1.cxx.
References GetCurrentStudy(), ObjectToSObject(), and ParseParameters().
Referenced by SMESH_Mesh_i.SetParameters(), and SMESH_Hypothesis_i.SetParameters().
{
if(VARIABLE_DEBUG)
cout<<"UpdateParameters : "<<theParameters<<endl;
SALOMEDS::Study_ptr aStudy = GetCurrentStudy();
if(aStudy->_is_nil() || CORBA::is_nil(theObject))
return;
SALOMEDS::SObject_var aSObj = ObjectToSObject(aStudy,theObject);
if(aSObj->_is_nil())
return;
SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
SALOMEDS::GenericAttribute_var aFindAttr;
bool hasAttr = aSObj->FindAttribute(aFindAttr, "AttributeString");
if(VARIABLE_DEBUG)
cout<<"Find Attribute "<<hasAttr<<endl;
SALOMEDS::GenericAttribute_var anAttr;
anAttr = aStudyBuilder->FindOrCreateAttribute( aSObj, "AttributeString");
SALOMEDS::AttributeString_var aStringAttr = SALOMEDS::AttributeString::_narrow(anAttr);
CORBA::String_var oldparVar = aStringAttr->Value();
CORBA::String_var inpparVar = ParseParameters(theParameters);
TCollection_AsciiString aNewParams;
TCollection_AsciiString aOldParameters(oldparVar.inout());
TCollection_AsciiString anInputParams(inpparVar.inout());
if(!hasAttr)
aNewParams = anInputParams;
else
{
int pos = aOldParameters.SearchFromEnd("|");
if(pos==-1) pos = 0;
TCollection_AsciiString previousParamFull(aOldParameters.Split(pos));
TCollection_AsciiString previousParam(previousParamFull);
TCollection_AsciiString theRepet("1");
pos = previousParam.SearchFromEnd(";*=");
if(pos >= 0)
{
theRepet = previousParam.Split(pos+2);
pos = pos-1;
if(pos==-1) pos = 0;
previousParam.Split(pos);
}
if(previousParam == anInputParams)
{
theRepet = theRepet.IntegerValue()+1;
aNewParams = aOldParameters + previousParam + ";*=" + theRepet;
}
else
{
aNewParams = aOldParameters + previousParamFull + "|" + anInputParams;
}
}
if(VARIABLE_DEBUG)
{
cout<<"Input Parameters : "<<anInputParams<<endl;
cout<<"Old Parameters : "<<aOldParameters<<endl;
cout<<"New Parameters : "<<aNewParams<<endl;
}
aStringAttr->SetValue( aNewParams.ToCString() );
}
Field Documentation
SALOMEDS::Study_var SMESH_Gen_i.myCurrentStudy [private] |
Definition at line 563 of file SMESH_Gen_i.hxx.
Referenced by CanPublishInStudy(), Close(), CopyMesh(), CreateEmptyMesh(), GetAlgoSO(), GetCurrentStudy(), GetCurrentStudyContext(), GetCurrentStudyID(), Load(), Save(), SetCurrentStudy(), and SetName().
::SMESH_Gen SMESH_Gen_i.myGen [private] |
Definition at line 555 of file SMESH_Gen_i.hxx.
Referenced by CancelCompute(), and createMesh().
GEOM::GEOM_Gen_var SMESH_Gen_i::myGeomGen = GEOM::GEOM_Gen::_nil() [static, private] |
Definition at line 549 of file SMESH_Gen_i.hxx.
Referenced by SetGeomEngine().
map<string, GenericHypothesisCreator_i*> SMESH_Gen_i.myHypCreatorMap [private] |
Definition at line 558 of file SMESH_Gen_i.hxx.
Referenced by PublishHypothesis(), and ~SMESH_Gen_i().
CORBA::Boolean SMESH_Gen_i.myIsEmbeddedMode [private] |
Definition at line 564 of file SMESH_Gen_i.hxx.
Referenced by createMesh(), IsEmbeddedMode(), SetEmbeddedMode(), and SMESH_Gen_i().
SALOME_LifeCycleCORBA * SMESH_Gen_i::myLCC = NULL [static, private] |
Definition at line 553 of file SMESH_Gen_i.hxx.
SALOME_NamingService * SMESH_Gen_i::myNS = NULL [static, private] |
Definition at line 552 of file SMESH_Gen_i.hxx.
CORBA::ORB_var SMESH_Gen_i::myOrb [static, private] |
Definition at line 550 of file SMESH_Gen_i.hxx.
Referenced by SMESH_Gen_i().
PortableServer::POA_var SMESH_Gen_i::myPoa [static, private] |
Definition at line 551 of file SMESH_Gen_i.hxx.
Referenced by SMESH_Gen_i().
std::map< int, Handle(TColStd_HSequenceOfAsciiString) > SMESH_Gen_i.myPythonScripts [private] |
Definition at line 567 of file SMESH_Gen_i.hxx.
Referenced by AddToPythonScript(), CleanPythonTrace(), GetNewPythonLines(), and RemoveLastFromPythonScript().
GEOM_Client* SMESH_Gen_i.myShapeReader [private] |
Definition at line 562 of file SMESH_Gen_i.hxx.
Referenced by GetShapeReader(), SMESH_Gen_i(), and ~SMESH_Gen_i().
SMESH_Gen_i * SMESH_Gen_i::mySMESHGen = NULL [static, private] |
Definition at line 554 of file SMESH_Gen_i.hxx.
Referenced by SMESH_Gen_i().
map<int, StudyContext*> SMESH_Gen_i.myStudyContextMap [private] |
Definition at line 560 of file SMESH_Gen_i.hxx.
Referenced by Close(), GetCurrentStudyContext(), SetCurrentStudy(), and ~SMESH_Gen_i().