// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
-// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
//
#include <TopoDS_Shape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <gp_Pnt.hxx>
#include <BRep_Tool.hxx>
#include <TCollection_AsciiString.hxx>
+#include <OSD.hxx>
#include "Utils_CorbaException.hxx"
#include "SMESH_Hypothesis_i.hxx"
#include "SMESH_Algo_i.hxx"
#include "SMESH_Group_i.hxx"
+#include "SMESH_PythonDump.hxx"
#include "SMESHDS_Document.hxx"
#include "SMESHDS_Group.hxx"
#include "SMESHDS_GroupOnGeom.hxx"
+#include "SMESH_Mesh.hxx"
+#include "SMESH_Hypothesis.hxx"
#include "SMESH_Group.hxx"
+#include "SMESH_MeshEditor.hxx"
#include "SMDS_EdgePosition.hxx"
#include "SMDS_FacePosition.hxx"
+#include "SMDS_VertexPosition.hxx"
+#include "SMDS_SpacePosition.hxx"
#include CORBA_SERVER_HEADER(SMESH_Group)
#include CORBA_SERVER_HEADER(SMESH_Filter)
#include "Utils_ExceptHandlers.hxx"
#include <map>
-#include <boost/filesystem/path.hpp>
using namespace std;
+using SMESH::TPythonDump;
#define NUM_TMP_FILES 2
#ifdef _DEBUG_
-static int MYDEBUG = 0;
+static int MYDEBUG = 1;
#else
static int MYDEBUG = 0;
#endif
_thisObj = this ;
_id = myPoa->activate_object( _thisObj );
+ myIsEmbeddedMode = false;
myShapeReader = NULL; // shape reader
mySMESHGen = this;
+
+ // set it in standalone mode only
+ //OSD::SetSignal( true );
}
//=============================================================================
// create a new mesh object servant, store it in a map in study context
SMESH_Mesh_i* meshServant = new SMESH_Mesh_i( GetPOA(), this, GetCurrentStudyID() );
// create a new mesh object
- meshServant->SetImpl( myGen.CreateMesh( GetCurrentStudyID() ));
+ meshServant->SetImpl( myGen.CreateMesh( GetCurrentStudyID(), myIsEmbeddedMode ));
// activate the CORBA servant of Mesh
SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( meshServant->_this() );
return myShapeReader;
}
+//=============================================================================
+/*!
+ * SMESH_Gen_i::SetEmbeddedMode
+ *
+ * Set current mode
+ */
+//=============================================================================
+
+void SMESH_Gen_i::SetEmbeddedMode( CORBA::Boolean theMode )
+{
+ myIsEmbeddedMode = theMode;
+
+ 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
+ }
+}
+
+//=============================================================================
+/*!
+ * SMESH_Gen_i::IsEmbeddedMode
+ *
+ * Get current mode
+ */
+//=============================================================================
+
+CORBA::Boolean SMESH_Gen_i::IsEmbeddedMode()
+{
+ return myIsEmbeddedMode;
+}
+
//=============================================================================
/*!
* SMESH_Gen_i::SetCurrentStudy
void SMESH_Gen_i::SetCurrentStudy( SALOMEDS::Study_ptr theStudy )
{
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::SetCurrentStudy" );
+ //if(MYDEBUG)
+ //MESSAGE( "SMESH_Gen_i::SetCurrentStudy" );
myCurrentStudy = SALOMEDS::Study::_duplicate( theStudy );
// create study context, if it doesn't exist and set current study
int studyId = GetCurrentStudyID();
if ( 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() );
+
// set current study for geom engine
- /*
- if ( !CORBA::is_nil( GetGeomEngine() ) )
- GetGeomEngine()->GetCurrentStudy( myCurrentStudy->StudyId() );
- */
+ //if ( !CORBA::is_nil( GetGeomEngine() ) )
+ // GetGeomEngine()->GetCurrentStudy( myCurrentStudy->StudyId() );
+ }
}
//=============================================================================
SALOMEDS::SObject_var aSO = PublishHypothesis( myCurrentStudy, hyp );
if ( !aSO->_is_nil() ) {
// Update Python script
- TCollection_AsciiString aStr (aSO->GetID());
- aStr += " = smesh.CreateHypothesis(\"";
- aStr += Standard_CString(theHypName);
- aStr += "\", \"";
- aStr += Standard_CString(theLibName);
- aStr += "\")";
-
- AddToCurrentPyScript(aStr);
+ TPythonDump() << aSO << " = " << this << ".CreateHypothesis('"
+ << theHypName << "', '" << theLibName << "')";
}
}
return hyp._retn();
}
+//================================================================================
+/*!
+ * \brief Return hypothesis of given type holding parameter values of the existing mesh
+ * \param theHypType - hypothesis type name
+ * \param theLibName - plugin library name
+ * \param theMesh - The mesh of interest
+ * \param theGeom - The shape to get parameter values from
+ * \retval 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
+ */
+//================================================================================
+
+SMESH::SMESH_Hypothesis_ptr
+SMESH_Gen_i::GetHypothesisParameterValues (const char* theHypType,
+ const char* theLibName,
+ SMESH::SMESH_Mesh_ptr theMesh,
+ GEOM::GEOM_Object_ptr theGeom)
+ throw ( SALOME::SALOME_Exception )
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ if ( CORBA::is_nil( theMesh ) )
+ THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference", SALOME::BAD_PARAM );
+ if ( CORBA::is_nil( theGeom ) )
+ THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", SALOME::BAD_PARAM );
+
+ // -----------------------------------------------
+ // 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 ( !meshServant || shape.IsNull() )
+ return SMESH::SMESH_Hypothesis::_nil();
+ ::SMESH_Mesh& mesh = meshServant->GetImpl();
+
+ if ( mesh.NbNodes() == 0 ) // empty mesh
+ return SMESH::SMESH_Hypothesis::_nil();
+
+ // 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();
+
+ // 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
+ if ( hyp->SetParametersByMesh( &mesh, shape ))
+ return SMESH::SMESH_Hypothesis::_duplicate( tmpHyp );
+
+ return SMESH::SMESH_Hypothesis::_nil();
+}
+
//=============================================================================
/*!
* SMESH_Gen_i::CreateMesh
// create mesh
SMESH::SMESH_Mesh_var mesh = this->createMesh();
// set shape
- SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( mesh ).in() );
+ SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
ASSERT( meshServant );
meshServant->SetShape( theShapeObject );
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
// Update Python script
- TCollection_AsciiString aStr (aSO->GetID());
- aStr += " = smesh.CreateMesh(";
- SMESH_Gen_i::AddObject(aStr, theShapeObject) += ")";
-
- AddToCurrentPyScript(aStr);
+ TPythonDump() << aSO << " = " << this << ".CreateMesh(" << theShapeObject << ")";
+ }
+ }
+
+ return mesh._retn();
+}
+
+//=============================================================================
+/*!
+ * SMESH_Gen_i::CreateEmptyMesh
+ *
+ * Create empty mesh
+ */
+//=============================================================================
+
+SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh()
+ throw ( SALOME::SALOME_Exception )
+{
+ 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()";
}
}
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshesFromUNV" );
SMESH::SMESH_Mesh_var aMesh = createMesh();
- string aFileName; // = boost::filesystem::path(theFileName).leaf();
+ string aFileName;
// publish mesh in the study
if ( CanPublishInStudy( aMesh ) ) {
SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
// Update Python script
- TCollection_AsciiString aStr (aSO->GetID());
- aStr += " = smesh.CreateMeshesFromUNV(\"";
- aStr += Standard_CString(theFileName);
- aStr += "\")";
-
- AddToCurrentPyScript(aStr);
+ TPythonDump() << aSO << " = smeshgen.CreateMeshesFromUNV('" << theFileName << "')";
}
}
SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() );
ASSERT( aServant );
aServant->ImportUNVFile( theFileName );
+
+ // Dump creation of groups
+ aServant->GetGroups();
+
return aMesh._retn();
}
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshFromMED" );
- // Python Dump
- TCollection_AsciiString aStr ("([");
-
// Retrieve mesh names from the file
DriverMED_R_SMESHDS_Mesh myReader;
myReader.SetFile( theFileName );
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 << "([";
+ //TCollection_AsciiString aStr ("([");
+
if (theStatus == SMESH::DRS_OK) {
SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
aStudyBuilder->NewCommand(); // There is a transaction
// Iterate through all meshes and create mesh objects
for ( list<string>::iterator it = aNames.begin(); it != aNames.end(); it++ ) {
// Python Dump
- if (i > 0) aStr += ", ";
+ //if (i > 0) aStr += ", ";
+ if (i > 0) aPythonDump << ", ";
// create mesh
SMESH::SMESH_Mesh_var mesh = createMesh();
aSO = PublishMesh( myCurrentStudy, mesh.in(), (*it).c_str() );
if ( !aSO->_is_nil() ) {
// Python Dump
- aStr += aSO->GetID();
+ aPythonDump << aSO;
+ //aStr += aSO->GetID();
} else {
// Python Dump
- aStr += "mesh_";
- aStr += TCollection_AsciiString(i);
+ aPythonDump << "mesh_" << i;
+// aStr += "mesh_";
+// aStr += TCollection_AsciiString(i);
}
// Read mesh data (groups are published automatically by ImportMEDFile())
}
// Update Python script
- aStr += "], status) = smesh.CreateMeshesFromMED(\"";
- aStr += Standard_CString(theFileName);
- aStr += "\")";
-
- AddToCurrentPyScript(aStr);
+ aPythonDump << "], status) = " << this << ".CreateMeshesFromMED('" << theFileName << "')";
+ }
+ // Dump creation of groups
+ for ( int i = 0; i < aResult->length(); ++i )
+ aResult[ i ]->GetGroups();
return aResult._retn();
}
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshesFromSTL" );
SMESH::SMESH_Mesh_var aMesh = createMesh();
- string aFileName; // = boost::filesystem::path(theFileName).leaf();
+ string aFileName;
// publish mesh in the study
if ( CanPublishInStudy( aMesh ) ) {
SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
( myCurrentStudy, SALOMEDS::SObject::_nil(), aMesh.in(), aFileName.c_str() );
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
- // Update Python script
- TCollection_AsciiString aStr (aSO->GetID());
- aStr += " = smesh.CreateMeshesFromSTL(\"";
- aStr += Standard_CString(theFileName);
- aStr += "\")";
-
- AddToCurrentPyScript(aStr);
+ // Update Python script
+ TPythonDump() << aSO << " = " << this << ".CreateMeshesFromSTL('" << theFileName << "')";
}
}
return false;
}
+//================================================================================
+/*!
+ * \brief Returns errors of hypotheses definintion
+ * \param theMesh - the mesh
+ * \param theSubObject - the main or sub- shape
+ * \retval SMESH::algo_error_array* - sequence of errors
+ */
+//================================================================================
+
+SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
+ GEOM::GEOM_Object_ptr theSubObject )
+ throw ( SALOME::SALOME_Exception )
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetAlgoState()" );
+
+ if ( CORBA::is_nil( theSubObject ) )
+ 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 = GeomObjectToShape( theSubObject );
+ ::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 )
+ {
+ // error name
+ SMESH::AlgoStateErrorName errName;
+ switch ( error->_name ) {
+ case ::SMESH_Gen::MISSING_ALGO: errName = SMESH::MISSING_ALGO; break;
+ case ::SMESH_Gen::MISSING_HYPO: errName = SMESH::MISSING_HYPO; break;
+ case ::SMESH_Gen::NOT_CONFORM_MESH: errName = SMESH::NOT_CONFORM_MESH; break;
+ default:
+ THROW_SALOME_CORBA_EXCEPTION( "bad error name",SALOME::BAD_PARAM );
+ }
+ // algo name
+ CORBA::String_var algoName;
+ if ( error->_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* myImpl = SMESH::DownCast<SMESH_Hypothesis_i*>( algoIOR );
+ if ( myImpl && myImpl->GetImpl() == error->_algo ) {
+ algoName = algoSO->GetName();
+ break;
+ }
+ }
+ } // loop on algo SO's
+ break;
+ } // if algo tag
+ } // SMESH component iterator
+ }
+ }
+ if ( algoName.in() == 0 )
+ // use algo type name
+ algoName = CORBA::string_dup( error->_algo->GetName() );
+ }
+ // fill AlgoStateError structure
+ SMESH::AlgoStateError & errStruct = error_array[ i++ ];
+ errStruct.name = errName;
+ errStruct.algoName = algoName;
+ errStruct.algoDim = error->_algoDim;
+ errStruct.isGlobalAlgo = error->_isGlobalAlgo;
+ }
+ }
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ INFOS( "catch exception "<< S_ex.what() );
+ }
+ return error_array._retn();
+}
+
//=============================================================================
/*!
* SMESH_Gen_i::GetSubShapesId
SALOME::BAD_PARAM );
// Update Python script
- TCollection_AsciiString aStr ("isDone = smesh.Compute(");
- SMESH_Gen_i::AddObject(aStr, theMesh) += ", ";
- SMESH_Gen_i::AddObject(aStr, theShapeObject) += ")";
-
- AddToCurrentPyScript(aStr);
-
- aStr = "if isDone == 0: print \"Mesh ";
- SMESH_Gen_i::AddObject(aStr, theMesh) += " computation failed\"";
- AddToCurrentPyScript(aStr);
+ TPythonDump() << "isDone = " << this << ".Compute( "
+ << theMesh << ", " << theShapeObject << ")";
+ TPythonDump() << "if not isDone: print 'Mesh " << theMesh << " : computation failed'";
try {
// get mesh servant
return myGen.Compute( myLocMesh, myLocShape);
}
}
+ catch ( std::bad_alloc& exc ) {
+ THROW_SALOME_CORBA_EXCEPTION( "Memory allocation problem",
+ SALOME::INTERNAL_ERROR );
+ }
catch ( SALOME_Exception& S_ex ) {
INFOS( "Compute(): catch exception "<< S_ex.what() );
}
return false;
}
+//================================================================================
+/*!
+ * \brief Return geometrical object the given element is built on
+ * \param theMesh - the mesh the element is in
+ * \param theElementID - the element ID
+ * \param theGeomName - the name of the result geom object if it is not yet published
+ * \retval GEOM::GEOM_Object_ptr - the found or just published geom object
+ */
+//================================================================================
+
+GEOM::GEOM_Object_ptr
+SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
+ CORBA::Long theElementID,
+ const char* theGeomName)
+ throw ( SALOME::SALOME_Exception )
+{
+ 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_var geomGen = GetGeomEngine();
+
+ // try to find the corresponding SObject
+ GeomObjectToShape( geom ); // geom client remembers the found shape
+ SALOMEDS::SObject_var SObj = ObjectToSObject( myCurrentStudy, geom.in() );
+ 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();
+}
+
+
+//================================================================================
+/*!
+ * \brief Return geometrical object the given element is built on.
+ * \param theMesh - the mesh the element is in
+ * \param theElementID - the element ID
+ * \retval GEOM::GEOM_Object_ptr - the found geom object
+ */
+//================================================================================
+
+GEOM::GEOM_Object_ptr
+SMESH_Gen_i::FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
+ CORBA::Long theElementID)
+ throw ( SALOME::SALOME_Exception )
+{
+ 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_var 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() ) {
+ GEOM::GEOM_IShapesOperations_var op =
+ geomGen->GetIShapesOperations( GetCurrentStudyID() );
+ if ( !op->_is_nil() )
+ geom = op->GetSubShape( mainShape, shapeID );
+ }
+ if ( !geom->_is_nil() )
+ return geom._retn();
+ }
+ }
+ return GEOM::GEOM_Object::_nil();
+}
+
//=============================================================================
/*!
* SMESH_Gen_i::Save
*/
//=============================================================================
SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent,
- const char* theURL,
- bool isMultiFile )
+ const char* theURL,
+ bool isMultiFile )
{
INFOS( "SMESH_Gen_i::Save" );
HDFgroup* aSubSubGroup;
hdf_size aSize[ 1 ];
+
+ //Remove the files if they exist: BugID: 11225
+ TCollection_AsciiString cmd("rm -f \"");
+ 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() );
// ---> create HDF file
aFile = new HDFfile( filename.ToCString() );
aFile->CreateOnDisk();
-
+
// --> iterator for top-level objects
SALOMEDS::ChildIterator_var itBig = myCurrentStudy->NewChildIterator( theComponent );
for ( ; itBig->More(); itBig->Next() ) {
}
}
// All sub-meshes will be stored in MED file
- if ( shapeRefFound )
- myWriter.AddAllSubMeshes();
+ // .. will NOT (PAL 12992)
+ //if ( shapeRefFound )
+ //myWriter.AddAllSubMeshes();
// groups root sub-branch
SALOMEDS::SObject_var myGroupsBranch;
myLocMesh.ShapeToMesh( nullShape ); // remove shape referring data
}
- // Store node positions on sub-shapes (SMDS_Position):
-
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();
int nbEdgeNodes = 0, nbFaceNodes = 0;
list<SMESHDS_SubMesh*> aEdgeSM, aFaceSM;
// loop on SMESHDS_SubMesh'es
- const map<int,SMESHDS_SubMesh*>& aSubMeshes = mySMESHDSMesh->SubMeshes();
- map<int,SMESHDS_SubMesh*>::const_iterator itSubM ( aSubMeshes.begin() );
- for ( ; itSubM != aSubMeshes.end() ; itSubM++ )
+ for ( itSubM = aSubMeshes.begin(); itSubM != aSubMeshes.end() ; itSubM++ )
{
SMESHDS_SubMesh* aSubMesh = (*itSubM).second;
if ( aSubMesh->IsComplexSubmesh() )
for ( ; itSM != pListSM->end(); itSM++ )
{
SMESHDS_SubMesh* aSubMesh = (*itSM);
- if ( aSubMesh->IsComplexSubmesh() )
- continue; // submesh containing other submeshs
SMDS_NodeIteratorPtr itNode = aSubMesh->GetNodes();
// loop on nodes in aSubMesh
// Write datasets
if ( nbNodes )
{
- aSize[ 0 ] = nbNodes*sizeof(int);
+ aSize[ 0 ] = nbNodes;
// IDS
string aDSName( onFace ? "Nodes on Faces" : "Nodes on Edges");
- aDataset = new HDFdataset( (char*)aDSName.c_str(), aGroup, HDF_STRING, aSize, 1 );
+ aDataset = new HDFdataset( (char*)aDSName.c_str(), aGroup, HDF_INT32, aSize, 1 );
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( aNodeIDs );
aDataset->CloseOnDisk();
- aSize[ 0 ] = nbNodes;
// U Positions
aDSName = ( onFace ? "Face U positions" : "Edge positions");
aDataset = new HDFdataset( (char*)aDSName.c_str(), aGroup, HDF_FLOAT64, aSize, 1);
SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
aStudyBuilder->LoadWith( theCompRoot, GetGeomEngine() );
}
+//=============================================================================
+/*!
+ * \brief Creates SMDS_Position according to shape type
+ */
+//=============================================================================
+
+class PositionCreator {
+public:
+ SMDS_PositionPtr MakePosition(const TopAbs_ShapeEnum type) {
+ return (this->*myFuncTable[ type ])();
+ }
+ PositionCreator() {
+ myFuncTable.resize( (size_t) TopAbs_SHAPE, & PositionCreator::defaultPosition );
+ myFuncTable[ TopAbs_FACE ] = & PositionCreator::facePosition;
+ myFuncTable[ TopAbs_EDGE ] = & PositionCreator::edgePosition;
+ myFuncTable[ TopAbs_VERTEX ] = & PositionCreator::vertexPosition;
+ }
+private:
+ SMDS_PositionPtr edgePosition() const { return SMDS_PositionPtr( new SMDS_EdgePosition ); }
+ SMDS_PositionPtr facePosition() const { return SMDS_PositionPtr( new SMDS_FacePosition ); }
+ SMDS_PositionPtr vertexPosition() const { return SMDS_PositionPtr( new SMDS_VertexPosition); }
+ SMDS_PositionPtr defaultPosition() const { return SMDS_SpacePosition::originSpacePosition(); }
+ typedef SMDS_PositionPtr (PositionCreator:: * FmakePos)() const;
+ vector<FmakePos> myFuncTable;
+};
//=============================================================================
/*!
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
char* hypname_str = new char[ size ];
aDataset->ReadFromDisk( hypname_str );
hypname = string( hypname_str );
- delete hypname_str;
+ delete [] hypname_str;
aDataset->CloseOnDisk();
}
// --> get hypothesis plugin library name
aDataset->ReadFromDisk( libname_str );
if(MYDEBUG) SCRUTE( libname_str );
libname = string( libname_str );
- delete libname_str;
+ delete [] libname_str;
aDataset->CloseOnDisk();
}
// --> get hypothesis data
char* hypdata_str = new char[ size ];
aDataset->ReadFromDisk( hypdata_str );
hypdata = string( hypdata_str );
- delete hypdata_str;
+ delete [] hypdata_str;
aDataset->CloseOnDisk();
}
}
char* hypname_str = new char[ size ];
aDataset->ReadFromDisk( hypname_str );
hypname = string( hypname_str );
- delete hypname_str;
+ delete [] hypname_str;
aDataset->CloseOnDisk();
}
// --> get algorithm plugin library name
aDataset->ReadFromDisk( libname_str );
if(MYDEBUG) SCRUTE( libname_str );
libname = string( libname_str );
- delete libname_str;
+ delete [] libname_str;
aDataset->CloseOnDisk();
}
// --> get algorithm data
aDataset->ReadFromDisk( hypdata_str );
if(MYDEBUG) SCRUTE( hypdata_str );
hypdata = string( hypdata_str );
- delete hypdata_str;
+ delete [] hypdata_str;
aDataset->CloseOnDisk();
}
}
SALOMEDS::SObject_var shapeSO = myCurrentStudy->FindObjectID( refFromFile );
// Make sure GEOM data are loaded first
- loadGeomData( shapeSO->GetFatherComponent() );
+ //loadGeomData( shapeSO->GetFatherComponent() );
CORBA::Object_var shapeObject = SObjectToObject( shapeSO );
if ( !CORBA::is_nil( shapeObject ) ) {
}
if(hasData) {
+
// Read sub-meshes from MED
- if(MYDEBUG) MESSAGE("JFA - Create all sub-meshes");
- myReader.CreateAllSubMeshes();
+ // -------------------------
+ if(MYDEBUG) MESSAGE("Create all sub-meshes");
+ bool submeshesInFamilies = ( ! aTopGroup->ExistInternalObject( "Submeshes" ));
+ if ( submeshesInFamilies )
+ {
+ // old way working before fix of PAL 12992
+ myReader.CreateAllSubMeshes();
+ }
+ else
+ {
+ // open a group
+ aGroup = new HDFgroup( "Submeshes", aTopGroup );
+ aGroup->OpenOnDisk();
+
+ int maxID = 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
+ ::SMESH_MeshEditor::TIDSortedElemSet elemSet;
+ if ( isNode )
+ while ( nIt->more() ) elemSet.insert( nIt->next() );
+ else
+ while ( eIt->more() ) elemSet.insert( eIt->next() );
+ ASSERT( elemSet.size() == nbElems );
+ // add elements to submeshes
+ ::SMESH_MeshEditor::TIDSortedElemSet::iterator iE = elemSet.begin();
+ for ( int i = 0; i < nbElems; ++i, ++iE )
+ {
+ int smID = smIDs[ i ];
+ if ( smID == 0 ) continue;
+ ASSERT( smID <= maxID );
+ const SMDS_MeshElement* elem = *iE;
+ // 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 ]);
+ pos->SetShapeId( 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)
}
else // NODE IDS
{
- int aSize = aDataset->GetSize()/sizeof(int);
+ 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?
nbFids = aSize;
}
}
+ aDataset->CloseOnDisk();
} // loop on 5 datasets
// Set node positions on edges or faces
// Recompute State (as computed sub-meshes are restored from MED)
if ( !aShapeObject->_is_nil() ) {
- MESSAGE("JFA - Compute State Engine ...");
+ MESSAGE("Compute State Engine ...");
TopoDS_Shape myLocShape = GeomObjectToShape( aShapeObject );
myNewMeshImpl->GetImpl().GetSubMesh(myLocShape)->ComputeStateEngine
(SMESH_subMesh::SUBMESH_RESTORED);
- MESSAGE("JFA - Compute State Engine finished");
+ MESSAGE("Compute State Engine finished");
}
// try to get groups