-// Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024 CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include <TopoDS_Wire.hxx>
#include <gp_Pnt.hxx>
+// Have to be included before std headers
+#include <Python.h>
+#include <structmember.h>
+
#ifdef WIN32
#include <windows.h>
#include <process.h>
#include "SMESH_Hypothesis.hxx"
#include "SMESH_Hypothesis_i.hxx"
#include "SMESH_Mesh.hxx"
+#include "SMESH_ParallelMesh.hxx"
#include "SMESH_MeshEditor.hxx"
#include "SMESH_Mesh_i.hxx"
+#include <SMESH_SequentialMesh_i.hxx>
+#include "SMESH_ParallelMesh_i.hxx"
#include "SMESH_PreMeshInfo.hxx"
#include "SMESH_PythonDump.hxx"
#include "SMESH_ControlsDef.hxx"
+#include <SMESH_BoostTxtArchive.hxx>
+#include <SMESH_SequentialMesh_i.hxx>
+#include <SMESH_ParallelMesh_i.hxx>
+#include "SMESH_Meshio.h"
// to pass CORBA exception through SMESH_TRY
#define SMY_OWN_CATCH catch( SALOME::SALOME_Exception& se ) { throw se; }
#include <memory>
#include <boost/archive/text_oarchive.hpp>
-#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/string.hpp>
+#include <boost/filesystem.hpp>
+
+namespace fs = boost::filesystem;
using namespace std;
using SMESH::TPythonDump;
#define NUM_TMP_FILES 2
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
-
// Static variables definition
GEOM::GEOM_Gen_var SMESH_Gen_i::myGeomGen;
CORBA::ORB_var SMESH_Gen_i::myOrb;
}
catch (PortableServer::POA::ObjectNotActive &ex)
{
- INFOS("GetServant: ObjectNotActive");
+ MESSAGE("GetServant: ObjectNotActive");
return NULL;
}
catch (PortableServer::POA::WrongAdapter &ex)
{
- INFOS("GetServant: WrongAdapter: OK when several servants used to build several mesh in parallel...");
+ MESSAGE("GetServant: WrongAdapter: OK when several servants used to build several mesh in parallel...");
return NULL;
}
catch (PortableServer::POA::WrongPolicy &ex)
{
- INFOS("GetServant: WrongPolicy");
+ MESSAGE("GetServant: WrongPolicy");
return NULL;
}
catch (...)
{
- INFOS( "GetServant - Unknown exception was caught!!!" );
+ MESSAGE( "GetServant - Unknown exception was caught!!!" );
return NULL;
}
}
return anObj;
}
+// Set Naming Service object
+void SMESH_Gen_i::SetNS(SALOME_NamingService_Abstract *ns)
+{
+ if(myNS)
+ delete myNS;
+ myNS = ns;
+}
+
//=============================================================================
/*!
* GetNS [ static ]
SALOME_NamingService_Abstract* SMESH_Gen_i::GetNS()
{
- if ( myNS == NULL ) {
+ if ( !myNS ) {
myNS = SINGLETON_<SALOME_NamingService>::Instance();
ASSERT(SINGLETON_<SALOME_NamingService>::IsAlreadyExisting());
myNS->init_orb( GetORB() );
thePlatformLibName = aPlatformLibName;
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "Create Hypothesis <" << theHypName << "> from " << aPlatformLibName);
+ MESSAGE( "Create Hypothesis <" << theHypName << "> from " << aPlatformLibName);
typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char* );
GenericHypothesisCreator_i* aCreator;
if (myHypCreatorMap.find(string(theHypName)) == myHypCreatorMap.end())
{
// load plugin library
- if(MYDEBUG) MESSAGE("Loading server meshers plugin library ...");
+ MESSAGE("Loading server meshers plugin library ...");
#ifdef WIN32
-#ifdef UNICODE
+# ifdef UNICODE
const wchar_t* path = Kernel_Utils::decode_s(aPlatformLibName);
-#else
+ SMESHUtils::ArrayDeleter<const wchar_t> deleter( path );
+# else
const char* path = aPlatformLibName.c_str();
-#endif
+# endif
#else
const char* path = aPlatformLibName.c_str();
#endif
LibHandle libHandle = LoadLib( path );
-#if defined(WIN32) && defined(UNICODE)
- delete path;
-#endif
+
if (!libHandle)
{
// report any error, if occurred
}
// get method, returning hypothesis creator
- if(MYDEBUG) MESSAGE("Find GetHypothesisCreator() method ...");
+ MESSAGE("Find GetHypothesisCreator() method ...");
GetHypothesisCreator procHandle =
(GetHypothesisCreator)GetProc( libHandle, "GetHypothesisCreator" );
if (!procHandle)
}
// get hypothesis creator
- if(MYDEBUG) MESSAGE("Get Hypothesis Creator for " << theHypName);
+ MESSAGE("Get Hypothesis Creator for " << theHypName);
aCreator = procHandle(theHypName);
if (!aCreator)
{
// activate the CORBA servant of hypothesis
hypothesis_i = myHypothesis_i->_this();
int nextId = RegisterObject( hypothesis_i );
- if(MYDEBUG) { MESSAGE( "Add hypo to map with id = "<< nextId ); }
- else { (void)nextId; } // avoid "unused variable" warning in release mode
+ MESSAGE( "Add hypo to map with id = "<< nextId );
}
return hypothesis_i._retn();
}
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh()
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::createMesh" );
+ 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 );
// create a new mesh object
- if(MYDEBUG) MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);
- meshServant->SetImpl( myGen.CreateMesh( myIsEmbeddedMode ));
+ MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);
+ SMESH_Mesh* myImpl = dynamic_cast<SMESH_Mesh*>(myGen.CreateMesh( myIsEmbeddedMode ));
+ if(myImpl == NULL )
+ THROW_SALOME_CORBA_EXCEPTION( "Could not cast SequentialMesh as Mesh", SALOME::INTERNAL_ERROR );
+ meshServant->SetImpl(myImpl);
// 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); }
- else { (void)nextId; } // avoid "unused variable" warning in release mode
+ MESSAGE( "Add mesh to map with id = "<< nextId);
+
return mesh._retn();
}
catch (SALOME_Exception& S_ex) {
return SMESH::SMESH_Mesh::_nil();
}
+//=============================================================================
+/*!
+ * SMESH_Gen_i::createParallelMesh
+ *
+ * Create empty parallel mesh on shape
+ */
+//=============================================================================
+SMESH::SMESH_ParallelMesh_ptr SMESH_Gen_i::createParallelMesh()
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ MESSAGE( "SMESH_Gen_i::createParallelMesh" );
+
+ // Get or create the GEOM_Client instance
+ try {
+ // create a new mesh object servant, store it in a map in study context
+ SMESH_ParallelMesh_i* meshServant = new SMESH_ParallelMesh_i( GetPOA(), this );
+ // create a new mesh object
+ MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);
+ SMESH_Mesh* myImpl = dynamic_cast<SMESH_Mesh*>(myGen.CreateParallelMesh( myIsEmbeddedMode ));
+ if(myImpl == NULL )
+ THROW_SALOME_CORBA_EXCEPTION( "Could not cast ParallelMesh as Mesh", SALOME::INTERNAL_ERROR );
+ meshServant->SetImpl(myImpl);
+
+ // activate the CORBA servant of Mesh
+ SMESH::SMESH_ParallelMesh_var mesh = SMESH::SMESH_ParallelMesh::_narrow( meshServant->_this() );
+ int nextId = RegisterObject( mesh );
+ 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_ParallelMesh::_nil();
+}
+
//=============================================================================
/*!
* SMESH_Gen_i::GetShapeReader
if (!envNoCatchSignals || !atoi(envNoCatchSignals))
{
bool raiseFPE;
-#ifdef _DEBUG_
- raiseFPE = true;
- char* envDisableFPE = getenv("DISABLE_FPE");
- if (envDisableFPE && atoi(envDisableFPE))
+
+ if (SALOME::VerbosityActivated())
+ {
+ raiseFPE = true;
+ char* envDisableFPE = getenv("DISABLE_FPE");
+ if (envDisableFPE && atoi(envDisableFPE))
+ raiseFPE = false;
+ }
+ else
+ {
raiseFPE = false;
-#else
- raiseFPE = false;
-#endif
+ }
+
OSD::SetSignal( raiseFPE );
}
// else OSD::SetSignal() is called in GUI
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObject )
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
+ MESSAGE( "SMESH_Gen_i::CreateMesh(GEOM_Object_ptr)" );
// create mesh
SMESH::SMESH_Mesh_var mesh = this->createMesh();
// set shape
return mesh._retn();
}
+//=============================================================================
+/*!
+ * SMESH_Gen_i::CreateParallelMesh
+ *
+ * Create empty parallel mesh on a shape and publish it in the study
+ */
+//=============================================================================
+
+SMESH::SMESH_ParallelMesh_ptr SMESH_Gen_i::CreateParallelMesh( GEOM::GEOM_Object_ptr theShapeObject )
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ MESSAGE( "SMESH_Gen_i::CreateParallelMesh" );
+ // create mesh
+ SMESH::SMESH_ParallelMesh_var mesh = this->createParallelMesh();
+ // set shape
+ SMESH_ParallelMesh_i* meshServant = SMESH::DownCast<SMESH_ParallelMesh_i*>( mesh );
+ ASSERT( meshServant );
+ meshServant->SetShape( theShapeObject );
+
+ // publish mesh in the study
+ if ( CanPublishInStudy( mesh ) ) {
+ SALOMEDS::StudyBuilder_var aStudyBuilder = getStudyServant()->NewBuilder();
+ aStudyBuilder->NewCommand(); // There is a transaction
+ SALOMEDS::SObject_wrap aSO = PublishMesh( mesh.in() );
+ aStudyBuilder->CommitCommand();
+ if ( !aSO->_is_nil() ) {
+ // Update Python script
+ TPythonDump(this) << aSO << " = " << this << ".CreateParallelMesh(" << theShapeObject << ")";
+ }
+ }
+
+ return mesh._retn();
+}
+
//=============================================================================
/*!
* SMESH_Gen_i::CreateEmptyMesh
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh()
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
+ MESSAGE( "SMESH_Gen_i::CreateEmptyMesh" );
// create mesh
SMESH::SMESH_Mesh_var mesh = this->createMesh();
SALOME::BAD_PARAM );
}
}
+
+ //================================================================================
+ /*!
+ * \brief Makes a python dump for a function by iterating the given SObjects
+ */
+ //================================================================================
+
+ void functionToPythonDump(
+ SMESH_Gen_i* smesh, const std::string& functionName, std::vector<SALOMEDS::SObject_wrap>& sobjects)
+ {
+ TPythonDump aPythonDump(smesh);
+ aPythonDump << "([";
+
+ int i = 0;
+ for (const SALOMEDS::SObject_wrap& so : sobjects)
+ {
+ if (i > 0)
+ {
+ aPythonDump << ", ";
+ }
+
+ if (!so->_is_nil())
+ {
+ aPythonDump << so;
+ }
+ else
+ {
+ aPythonDump << "mesh_" << i;
+ }
+ }
+
+ aPythonDump << "], status) = " << smesh << functionName;
+ }
}
//=============================================================================
*/
//=============================================================================
-SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMEDorSAUV( const char* theFileName,
- SMESH::DriverMED_ReadStatus& theStatus,
- const char* theCommandNameForPython,
- const char* theFileNameForPython)
+SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName,
+ SMESH::DriverMED_ReadStatus& theStatus )
{
+ checkFileReadable( theFileName );
+
#ifdef WIN32
char bname[ _MAX_FNAME ];
- _splitpath( theFileNameForPython, NULL, NULL, bname, NULL );
+ _splitpath( theFileName, NULL, NULL, bname, NULL );
string aFileName = bname;
#else
- string aFileName = basename( const_cast<char *>(theFileNameForPython) );
+ string aFileName = basename( const_cast<char *>( theFileName ));
#endif
// Retrieve mesh names from the file
DriverMED_R_SMESHDS_Mesh myReader;
{ // open a new scope to make aPythonDump die before PythonDump in SMESH_Mesh::GetGroups()
- // Python Dump
- TPythonDump aPythonDump(this);
- aPythonDump << "([";
+ // Python Dump
+ TPythonDump aPythonDump(this);
+ aPythonDump << "([";
- if (theStatus == SMESH::DRS_OK) {
- SALOMEDS::StudyBuilder_var aStudyBuilder;
- aStudyBuilder = getStudyServant()->NewBuilder();
- aStudyBuilder->NewCommand(); // There is a transaction
+ if (theStatus == SMESH::DRS_OK)
+ {
+ SALOMEDS::StudyBuilder_var aStudyBuilder;
+ aStudyBuilder = getStudyServant()->NewBuilder();
+ aStudyBuilder->NewCommand(); // There is a transaction
- aResult->length( aNames.size() );
- int i = 0;
+ 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 << ", ";
+ // Iterate through all meshes and create mesh objects
+ for ( const std::string & meshName : aNames )
+ {
+ // Python Dump
+ if (i > 0) aPythonDump << ", ";
- // create mesh
- SMESH::SMESH_Mesh_var mesh = createMesh();
+ // create mesh
+ SMESH::SMESH_Mesh_var mesh = createMesh();
- // publish mesh in the study
- SALOMEDS::SObject_wrap aSO;
- if ( CanPublishInStudy( mesh ) )
- // little trick: for MED file theFileName and theFileNameForPython are the same, but they are different for SAUV
- // - as names of meshes are stored in MED file, we use them for data publishing
- // - as mesh name is not stored in UNV file, we use file name as name of mesh when publishing data
- aSO = PublishMesh( mesh.in(), ( theFileName == theFileNameForPython ) ? (*it).c_str() : aFileName.c_str() );
-
- // Python Dump
- if ( !aSO->_is_nil() ) {
- aPythonDump << aSO;
- } else {
- aPythonDump << "mesh_" << i;
- }
+ // publish mesh in the study
+ SALOMEDS::SObject_wrap aSO;
+ if ( CanPublishInStudy( mesh ) )
+ aSO = PublishMesh( mesh.in(), meshName.c_str() );
- // 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;
+ // Python Dump
+ if ( !aSO->_is_nil() ) {
+ aPythonDump << aSO;
+ } else {
+ aPythonDump << "mesh_" << i;
+ }
- aResult[i++] = SMESH::SMESH_Mesh::_duplicate( mesh );
- meshServant->GetImpl().GetMeshDS()->Modified();
+ // 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, meshName.c_str() );
+ if (status1 > theStatus)
+ theStatus = status1;
+
+ aResult[i++] = SMESH::SMESH_Mesh::_duplicate( mesh );
+ meshServant->GetImpl().GetMeshDS()->Modified();
+ }
+ if ( !aStudyBuilder->_is_nil() )
+ aStudyBuilder->CommitCommand();
}
- if ( !aStudyBuilder->_is_nil() )
- aStudyBuilder->CommitCommand();
- }
- // Update Python script
- aPythonDump << "], status) = " << this << "." << theCommandNameForPython << "(r'" << theFileNameForPython << "')";
+ // Update Python script
+ aPythonDump << "], status) = " << this << ".CreateMeshesFromMED( r'" << theFileName << "' )";
}
// Dump creation of groups
for ( CORBA::ULong i = 0; i < aResult->length(); ++i )
return aResult._retn();
}
-//================================================================================
-/*!
- * \brief Create meshes by reading a MED file
- */
-//================================================================================
-
-SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName,
- SMESH::DriverMED_ReadStatus& theStatus)
-{
- Unexpect aCatch(SALOME_SalomeException);
- checkFileReadable( theFileName );
-
- SMESH::mesh_array* result = CreateMeshesFromMEDorSAUV(theFileName, theStatus,
- "CreateMeshesFromMED", theFileName);
- return result;
-}
-
-//=============================================================================
-/*!
- * SMESH_Gen_i::CreateMeshFromSAUV
- *
- * Create mesh and import data from SAUV file
- */
-//=============================================================================
-
-SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char* theFileName,
- SMESH::DriverMED_ReadStatus& theStatus)
-{
- Unexpect aCatch(SALOME_SalomeException);
- checkFileReadable( theFileName );
-
- std::string sauvfilename(theFileName);
- std::string medfilename(theFileName);
- medfilename += ".med";
- std::string cmd;
-#ifdef WIN32
- cmd = "%PYTHONBIN% ";
-#else
- cmd = "python3 ";
-#endif
- cmd += "-c \"";
- cmd += "from medutilities import convert ; convert(r'" + sauvfilename + "', 'GIBI', 'MED', 1, r'" + medfilename + "')";
- cmd += "\"";
- system(cmd.c_str());
- SMESH::mesh_array* result = CreateMeshesFromMEDorSAUV(medfilename.c_str(),
- theStatus,
- "CreateMeshesFromSAUV",
- sauvfilename.c_str());
-#ifdef WIN32
- cmd = "%PYTHONBIN% ";
-#else
- cmd = "python3 ";
-#endif
- cmd += "-c \"";
- cmd += "from medutilities import my_remove ; my_remove(r'" + medfilename + "')";
- cmd += "\"";
- system(cmd.c_str());
- return result;
-}
-
//=============================================================================
/*!
* SMESH_Gen_i::CreateMeshFromSTL
return aMesh._retn();
}
+//================================================================================
+/*!
+ * \brief Create a mesh and import data from any file supported by meshio library
+ */
+//================================================================================
+
+SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMESHIO(const char* theFileName,
+ SMESH::DriverMED_ReadStatus& theStatus)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ checkFileReadable(theFileName);
+
+ MESSAGE("Import part with meshio through an intermediate MED file");
+
+ // Create an object that holds a temp file name and
+ // removes the file when goes out of scope.
+ SMESH_Meshio meshio;
+ const QString tempFileName = meshio.CreateTempFileName(theFileName);
+
+ // Convert temp file into a target one with meshio command
+ meshio.Convert(theFileName, tempFileName);
+
+ // We don't need a python dump from SMESH_Gen_i::CreateMeshesFromMED(), so
+ // we can't use this method as is here. The followed code is an edited part of
+ // copy pasted CreateMeshesFromMED().
+
+ // Retrieve mesh names from the file
+ DriverMED_R_SMESHDS_Mesh myReader;
+ myReader.SetFile(tempFileName.toStdString());
+ 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;
+
+ if (theStatus == SMESH::DRS_OK)
+ {
+ SALOMEDS::StudyBuilder_var aStudyBuilder;
+ aStudyBuilder = getStudyServant()->NewBuilder();
+ aStudyBuilder->NewCommand(); // There is a transaction
+
+ aResult->length(aNames.size());
+ std::vector<SALOMEDS::SObject_wrap> sobjects;
+ int i = 0;
+
+ // Iterate through all meshes and create mesh objects
+ for (const std::string& meshName : aNames)
+ {
+ // create mesh
+ SMESH::SMESH_Mesh_var mesh = createMesh();
+
+ // publish mesh in the study
+ SALOMEDS::SObject_wrap aSO;
+ if (CanPublishInStudy(mesh))
+ aSO = PublishMesh(mesh.in(), meshName.c_str());
+
+ // Save SO to use in a python dump
+ sobjects.emplace_back(aSO);
+
+ // 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(tempFileName.toUtf8().data(), meshName.c_str());
+ if (status1 > theStatus)
+ theStatus = status1;
+
+ aResult[i++] = SMESH::SMESH_Mesh::_duplicate(mesh);
+ meshServant->GetImpl().GetMeshDS()->Modified();
+ }
+
+ if (!aStudyBuilder->_is_nil())
+ aStudyBuilder->CommitCommand();
+
+ // Python dump
+ const std::string functionName = std::string(".CreateMeshesFromMESHIO(r'") + theFileName + "')";
+ functionToPythonDump(this, functionName, sobjects);
+ }
+
+ // Dump creation of groups
+ for (CORBA::ULong i = 0; i < aResult->length(); ++i)
+ SMESH::ListOfGroups_var groups = aResult[i]->GetGroups();
+
+ return aResult._retn();
+}
//=============================================================================
/*!
GEOM::GEOM_Object_ptr theShapeObject )
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IsReadyToCompute" );
+ MESSAGE( "SMESH_Gen_i::IsReadyToCompute" );
if ( CORBA::is_nil( theShapeObject ) )
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
GEOM::GEOM_Object_ptr theSubObject )
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetComputeErrors()" );
+ MESSAGE( "SMESH_Gen_i::GetComputeErrors()" );
if ( CORBA::is_nil( theSubObject ) && theMesh->HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", SALOME::BAD_PARAM );
CORBA::Short theSubShapeID )
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetBadInputElements()" );
+ MESSAGE( "SMESH_Gen_i::GetBadInputElements()" );
if ( CORBA::is_nil( theMesh ) )
THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",SALOME::BAD_PARAM );
GEOM::GEOM_Object_ptr theSubObject )
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetAlgoState()" );
+ MESSAGE( "SMESH_Gen_i::GetAlgoState()" );
if ( CORBA::is_nil( theSubObject ) && theMesh->HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", SALOME::BAD_PARAM );
const SMESH::object_array& theListOfSubShapeObject )
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetSubShapesId" );
+ MESSAGE( "SMESH_Gen_i::GetSubShapesId" );
SMESH::long_array_var shapesId = new SMESH::long_array;
set<int> setId;
{
const TopoDS_Face& F = TopoDS::Face(exp.Current());
setId.insert(myIndexToShape.FindIndex(F));
- if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(F));
+ SCRUTE(myIndexToShape.FindIndex(F));
}
for (TopExp_Explorer exp(locShape,TopAbs_EDGE); exp.More(); exp.Next())
{
const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
setId.insert(myIndexToShape.FindIndex(E));
- if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(E));
+ SCRUTE(myIndexToShape.FindIndex(E));
}
for (TopExp_Explorer exp(locShape,TopAbs_VERTEX); exp.More(); exp.Next())
{
const TopoDS_Vertex& V = TopoDS::Vertex(exp.Current());
setId.insert(myIndexToShape.FindIndex(V));
- if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(V));
+ SCRUTE(myIndexToShape.FindIndex(V));
}
}
shapesId->length(setId.size());
int i=0;
for (iind = setId.begin(); iind != setId.end(); iind++)
{
- if(MYDEBUG) SCRUTE((*iind));
+ SCRUTE((*iind));
shapesId[i] = (*iind);
- if(MYDEBUG) SCRUTE(shapesId[i]);
+ SCRUTE(shapesId[i]);
i++;
}
}
{
//MEMOSTAT;
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Compute" );
+ MESSAGE( "SMESH_Gen_i::Compute" );
if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
// Update Python script
TPythonDump(this) << "isDone = " << this << ".Compute( "
- << theMesh << ", " << theShapeObject << ")";
+ << theMesh << ", " << theShapeObject << ")";
+ TPythonDump(this) << this << ".CheckCompute( "
+ << theMesh << ")";
try {
// get mesh servant
SMESH::long_array& theShapesId)
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Precompute" );
+ MESSAGE( "SMESH_Gen_i::Precompute" );
if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
*/
//=============================================================================
-SMESH::long_array* SMESH_Gen_i::Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
- GEOM::GEOM_Object_ptr theShapeObject)
-// SMESH::long_array& theNbElems)
+SMESH::smIdType_array* SMESH_Gen_i::Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
+ GEOM::GEOM_Object_ptr theShapeObject)
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Evaluate" );
+ 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;
+ SMESH::smIdType_array_var nbels = new SMESH::smIdType_array;
nbels->length(SMESH::Entity_Last);
int i = SMESH::Entity_Node;
for (; i < SMESH::Entity_Last; i++)
/*CORBA::Boolean ret =*/ myGen.Evaluate( myLocMesh, myLocShape, aResMap);
MapShapeNbElemsItr anIt = aResMap.begin();
for(; anIt!=aResMap.end(); anIt++) {
- const vector<int>& aVec = (*anIt).second;
+ const vector<smIdType>& aVec = (*anIt).second;
for ( i = SMESH::Entity_Node; i < (int)aVec.size(); i++ ) {
- int nbElem = aVec[i];
+ smIdType nbElem = aVec[i];
if ( nbElem < 0 ) // algo failed, check that it has reported a message
{
SMESH_subMesh* sm = anIt->first;
GEOM::GEOM_Object_ptr
SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
- CORBA::Long theElementID,
+ SMESH::smIdType theElementID,
const char* theGeomName)
{
Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_ptr
SMESH_Gen_i::FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
- CORBA::Long theElementID)
+ SMESH::smIdType theElementID)
{
Unexpect aCatch(SALOME_SalomeException);
if ( CORBA::is_nil( theMesh ) )
}
// remember nb of elements before filling in
- SMESH::long_array_var prevState = newMesh->GetNbElementsByType();
+ SMESH::smIdType_array_var prevState = newMesh->GetNbElementsByType();
// copy nodes
// copy elements
- SMESH::array_of_ElementType_var srcElemTypes = theMeshesArray[i]->GetTypes();
- if ( srcElemTypes->length() == 1 && srcElemTypes[0] == SMESH::NODE ) // group of nodes
- continue;
std::vector< const SMDS_MeshElement* > newElems( initMeshDS->NbElements() + 1, 0 );
- elemIt = initImpl->GetElements( theMeshesArray[i], SMESH::ALL );
- while ( elemIt->more() )
+ SMESH::array_of_ElementType_var srcElemTypes = theMeshesArray[i]->GetTypes();
+ bool hasElems = (( srcElemTypes->length() > 1 ) ||
+ ( srcElemTypes->length() == 1 && srcElemTypes[0] != SMESH::NODE ));
+ if ( hasElems )
{
- const SMDS_MeshElement* elem = elemIt->next();
- elemType.myNodes.resize( elem->NbNodes() );
-
- SMDS_NodeIteratorPtr itNodes = elem->nodeIterator();
- for ( int k = 0; itNodes->more(); k++)
+ elemIt = initImpl->GetElements( theMeshesArray[i], SMESH::ALL );
+ while ( elemIt->more() )
{
- const SMDS_MeshNode* node = itNodes->next();
- elemType.myNodes[ k ] = static_cast< const SMDS_MeshNode*> ( newNodes[ node->GetID() ]);
- }
+ const SMDS_MeshElement* elem = elemIt->next();
+ elemType.myNodes.resize( elem->NbNodes() );
+
+ SMDS_NodeIteratorPtr itNodes = elem->nodeIterator();
+ for ( int k = 0; itNodes->more(); k++)
+ {
+ const SMDS_MeshNode* node = itNodes->next();
+ elemType.myNodes[ k ] = static_cast< const SMDS_MeshNode*> ( newNodes[ node->GetID() ]);
+ }
- // creates a corresponding element on existent nodes in new mesh
- newElems[ elem->GetID() ] =
- newEditor.AddElement( elemType.myNodes, elemType.Init( elem, /*basicOnly=*/false ));
+ // creates a corresponding element on existent nodes in new mesh
+ newElems[ elem->GetID() ] =
+ newEditor.AddElement( elemType.myNodes, elemType.Init( elem, /*basicOnly=*/false ));
+ }
+ newEditor.ClearLastCreated(); // forget the history
}
- newEditor.ClearLastCreated(); // forget the history
// create groups of just added elements
{
// type names
const char* typeNames[] = { "All","Nodes","Edges","Faces","Volumes","0DElems","Balls" };
- { // check of typeNames: compilation failure mains that NB_ELEMENT_TYPES changed:
- const int nbNames = sizeof(typeNames) / sizeof(const char*);
- int _assert[( nbNames == SMESH::NB_ELEMENT_TYPES ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
- }
- SMESH::long_array_var curState = newMesh->GetNbElementsByType();
+ // check of typeNames: compilation failure mains that NB_ELEMENT_TYPES changed:
+ static_assert( sizeof(typeNames) / sizeof(const char*) ==SMESH::NB_ELEMENT_TYPES,
+ "Update names of ElementType's!!!" );
+
+ SMESH::smIdType_array_var curState = newMesh->GetNbElementsByType();
for( groupType = SMESH::NODE;
groupType < SMESH::NB_ELEMENT_TYPES;
SMESH::SMESH_GroupBase_ptr group;
CORBA::String_var groupName;
- SMESH::long_array_var newIDs = new SMESH::long_array();
+ SMESH::smIdType_array_var newIDs = new SMESH::smIdType_array();
// loop on groups of a source mesh
SMESH::ListOfGroups_var listOfGroups = initImpl->GetGroups();
return newMesh._retn();
}
+
+//================================================================================
+/*!
+ * \brief Create a mesh by copying a part of another mesh
+ * \param mesh - TetraHedron mesh
+ * \param meshName Name of the created mesh
+ * \retval SMESH::SMESH_Mesh_ptr - the new mesh
+ */
+//================================================================================
+
+SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateDualMesh(SMESH::SMESH_IDSource_ptr mesh,
+ const char* meshName,
+ CORBA::Boolean adapt_to_shape)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+
+ TPythonDump* pyDump = new TPythonDump(this); // prevent dump from CreateMesh()
+ std::unique_ptr<TPythonDump> pyDumpDeleter( pyDump );
+
+ // 1. Get source mesh
+
+ if ( CORBA::is_nil( mesh ))
+ THROW_SALOME_CORBA_EXCEPTION( "bad IDSource", SALOME::BAD_PARAM );
+
+ SMESH::SMESH_Mesh_var srcMesh = mesh->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 );
+
+ CORBA::String_var mesh_var=GetORB()->object_to_string(mesh);
+ std::string mesh_ior = mesh_var.in();
+
+ //temporary folder for the generation of the med file
+ fs::path tmp_folder = fs::temp_directory_path() / fs::unique_path(fs::path("dual_mesh-%%%%"));
+ fs::create_directories(tmp_folder);
+ fs::path dual_mesh_file = tmp_folder / fs::path("tmp_dual_mesh.med");
+ std::string mesh_name(meshName);
+ MESSAGE("Working in folder" + tmp_folder.string());
+
+ // Running Python script
+ assert(Py_IsInitialized());
+ PyGILState_STATE gstate;
+ gstate = PyGILState_Ensure();
+
+
+ std::string ats;
+ if(adapt_to_shape)
+ ats = "True";
+ else
+ ats = "False";
+
+ std::string cmd="import salome.smesh.smesh_tools as smt\n";
+ cmd +="smt.smesh_create_dual_mesh(\"" + mesh_ior + "\", r\"" +
+ dual_mesh_file.string() + "\", mesh_name=\"" + mesh_name + "\", adapt_to_shape=" + ats + ")";
+ MESSAGE(cmd);
+
+ PyObject *py_main = PyImport_AddModule("__main__");
+ PyObject *py_dict = PyModule_GetDict(py_main);
+ PyObject *local_dict = PyDict_New();
+
+ PyRun_String(cmd.c_str(), Py_file_input, py_dict, local_dict);
+
+ if (PyErr_Occurred()) {
+ // Restrieving python error
+ MESSAGE("Catching error");
+ PyObject *errtype, *errvalue, *traceback;
+ PyErr_Fetch(&errtype, &errvalue, &traceback);
+ if(errvalue != NULL) {
+ MESSAGE("Error has a value");
+ PyObject *s = PyObject_Str(errvalue);
+ Py_ssize_t size;
+ std::string msg = PyUnicode_AsUTF8AndSize(s, &size);
+ msg = "Issue with the execution of create_dual_mesh:\n"+msg;
+ MESSAGE("throwing exception");
+ // We need to deactivate the GIL before throwing the exception
+ PyGILState_Release(gstate);
+ THROW_SALOME_CORBA_EXCEPTION(msg.c_str(), SALOME::INTERNAL_ERROR );
+ Py_DECREF(s);
+ }
+ Py_XDECREF(errvalue);
+ Py_XDECREF(errtype);
+ Py_XDECREF(traceback);
+ }
+
+ PyGILState_Release(gstate);
+
+ MESSAGE("Mesh created in " + dual_mesh_file.string());
+
+ // Import created MED
+ 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_wrap meshSO = ObjectToSObject( newMesh );
+ if ( !meshSO->_is_nil() )
+ {
+ SetName( meshSO, meshName, meshName );
+ SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED");
+ }
+ int ret = newMesh_i->ImportMEDFile(dual_mesh_file.string().c_str(), meshName);
+ if(ret)
+ THROW_SALOME_CORBA_EXCEPTION( "Issue when importing mesh", SALOME::INTERNAL_ERROR );
+
+ /*
+ SMESH_Mesh& newMesh2 = newMesh_i->GetImpl();
+
+
+ MESSAGE("Loading file: " << dual_mesh_file.string() << " with mesh " << meshName);
+ int ret = newMesh2.MEDToMesh(dual_mesh_file.c_str(), meshName);
+ */
+
+ newMesh_i->GetImpl().GetMeshDS()->Modified();
+
+ *pyDump << newMesh << " = " << this
+ << ".CreateDualMesh("
+ << mesh << ", "
+ << "'" << mesh_name << "', "
+ << ats << ") ";
+
+ pyDumpDeleter.reset(); // allow dump in GetGroups()
+
+ if ( srcMesh_i->GetImpl().GetGroupIds().size() > 0 ) // dump created groups
+ MESSAGE("Dump of groups");
+ SMESH::ListOfGroups_var groups = newMesh->GetGroups();
+
+#ifndef _DEBUG_
+ fs::remove_all(tmp_folder);
+#endif
+
+ return newMesh._retn();
+}
+
//================================================================================
/*!
* \brief Create a mesh by copying a part of another mesh
}
else
{
- SMESH::long_array_var ids = meshPart->GetIDs();
+ SMESH::smIdType_array_var ids = meshPart->GetIDs();
if ( srcElemTypes->length() == 1 && srcElemTypes[0] == SMESH::NODE ) // group of nodes
{
for ( CORBA::ULong i=0; i < ids->length(); i++ )
{
TE2EMap & e2eMap = e2eMapByType[ groupDS->GetType() ];
if ( e2eMap.empty() ) continue;
- int minID = e2eMap.begin()->first->GetID();
- int maxID = e2eMap.rbegin()->first->GetID();
+ smIdType minID = e2eMap.begin()->first->GetID();
+ smIdType maxID = e2eMap.rbegin()->first->GetID();
TE2EMap::iterator e2e;
while ( eIt->more() && groupElems.size() < e2eMap.size())
{
{
if ( newMeshDS->GetMeshInfo().NbElements( SMDSAbs_ElementType( elemType )) > 0 )
{
- SMESH::long_array_var elemIDs = stdlGroup->GetIDs();
+ SMESH::smIdType_array_var elemIDs = stdlGroup->GetIDs();
const bool isElem = ( elemType != SMESH::NODE );
CORBA::ULong iE = 0;
for ( ; iE < elemIDs->length(); ++iE ) // check if any element has been copied
system(cmd.ToCString());
// MED writer to be used by storage process
- DriverMED_W_SMESHDS_Mesh myWriter;
- myWriter.SetFile( meshfile.ToCString() );
+ DriverMED_W_SMESHDS_Mesh writer;
+ writer.SetFile( meshfile.ToCString() );
+ //writer.SetSaveNumbers( false ); // bos #24400 -- it leads to change of element IDs
// IMP issue 20918
// SetStoreName() to groups before storing hypotheses to let them refer to
// check if the mesh is not empty
if ( mySMESHDSMesh->NbNodes() > 0 ) {
// write mesh data to med file
- myWriter.SetMesh( mySMESHDSMesh );
- myWriter.SetMeshId( id );
+ writer.SetMesh( mySMESHDSMesh );
+ writer.SetMeshId( id );
strHasData = "1";
}
aSize[ 0 ] = strHasData.length() + 1;
// write reference on a shape if exists
SALOMEDS::SObject_wrap myRef;
bool shapeRefFound = false;
- bool found = gotBranch->FindSubObject( GetRefOnShapeTag(), myRef.inout() );
+ bool found = gotBranch->FindSubObject( (CORBA::Long)GetRefOnShapeTag(), myRef.inout() );
if ( found ) {
SALOMEDS::SObject_wrap myShape;
bool ok = myRef->ReferencedObject( myShape.inout() );
// write applied hypotheses if exist
SALOMEDS::SObject_wrap myHypBranch;
- found = gotBranch->FindSubObject( GetRefOnAppliedHypothesisTag(), myHypBranch.inout() );
+ found = gotBranch->FindSubObject( (CORBA::Long)GetRefOnAppliedHypothesisTag(), myHypBranch.inout() );
if ( found && !shapeRefFound && hasShape ) { // remove applied hyps
aStudy->NewBuilder()->RemoveObjectWithChildren( myHypBranch );
}
// Pass SMESHDS_Group to MED writer
SMESHDS_Group* aGrpDS = dynamic_cast<SMESHDS_Group*>( aGrpBaseDS );
if ( aGrpDS )
- myWriter.AddGroup( aGrpDS );
+ writer.AddGroup( aGrpDS );
// write reference on a shape if exists
SMESHDS_GroupOnGeom* aGeomGrp =
else // shape ref is invalid:
{
// save a group on geometry as ordinary group
- myWriter.AddGroup( aGeomGrp );
+ writer.AddGroup( aGeomGrp );
}
}
else if ( SMESH_GroupOnFilter_i* aFilterGrp_i =
if ( strcmp( strHasData.c_str(), "1" ) == 0 )
{
// Flush current mesh information into MED file
- myWriter.Perform();
+ writer.Perform();
// save info on nb of elements
SMESH_PreMeshInfo::SaveToFile( myImpl, id, aFile );
{
SMDS_ElemIteratorPtr eIt =
mySMESHDSMesh->elementsIterator( isNode ? SMDSAbs_Node : SMDSAbs_All );
- int nbElems = isNode ? mySMESHDSMesh->NbNodes() : mySMESHDSMesh->GetMeshInfo().NbElements();
+ smIdType nbElems = isNode ? mySMESHDSMesh->NbNodes() : mySMESHDSMesh->GetMeshInfo().NbElements();
if ( nbElems < 1 )
continue;
std::vector<int> smIDs; smIDs.reserve( nbElems );
SMESHDS_SubMesh* aSubMesh = const_cast< SMESHDS_SubMesh* >( smIt->next() );
if ( aSubMesh->IsComplexSubmesh() )
continue; // submesh containing other submeshs
- int nbNodes = aSubMesh->NbNodes();
+ smIdType nbNodes = aSubMesh->NbNodes();
if ( nbNodes == 0 ) continue;
int aShapeID = aSubMesh->GetID();
SALOMEDS::TMPFile* SMESH_Gen_i::SaveASCII( SALOMEDS::SComponent_ptr theComponent,
const char* theURL,
bool isMultiFile ) {
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::SaveASCII" );
+ MESSAGE( "SMESH_Gen_i::SaveASCII" );
SALOMEDS::TMPFile_var aStreamFile = Save( theComponent, theURL, isMultiFile );
return aStreamFile._retn();
TCollection_AsciiString aStudyName( "" );
if ( isMultiFile ) {
CORBA::WString_var url = aStudy->URL();
- aStudyName = (char*)SALOMEDS_Tool::GetNameFromPath( Kernel_Utils::encode(url.in()) ).c_str();
+ SMESHUtils::ArrayDeleter<const char> urlMulibyte( Kernel_Utils::encode( url.in()) );
+ aStudyName = (char*)SALOMEDS_Tool::GetNameFromPath( urlMulibyte.get() ).c_str();
}
// Set names of temporary files
TCollection_AsciiString filename = tmpDir + aStudyName + "_SMESH.hdf";
size = aDataset->GetSize();
char* libname_str = new char[ size ];
aDataset->ReadFromDisk( libname_str );
- if(MYDEBUG) SCRUTE( libname_str );
+ SCRUTE( libname_str );
libname = string( libname_str );
delete [] libname_str;
aDataset->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 <<
+ MESSAGE("VSR - load hypothesis : id = " << id <<
", name = " << hypname.c_str() << ", persistent string = " << hypdata.c_str());
SMESH::SMESH_Hypothesis_var myHyp;
myStudyContext->mapOldToNew( id, newId );
}
else
- if(MYDEBUG) MESSAGE( "VSR - SMESH_Gen::Load - can't get servant" );
+ MESSAGE( "VSR - SMESH_Gen::Load - can't get servant" );
}
}
}
size = aDataset->GetSize();
char* libname_str = new char[ size ];
aDataset->ReadFromDisk( libname_str );
- if(MYDEBUG) SCRUTE( libname_str );
+ SCRUTE( libname_str );
libname = string( libname_str );
delete [] libname_str;
aDataset->CloseOnDisk();
size = aDataset->GetSize();
char* hypdata_str = new char[ size ];
aDataset->ReadFromDisk( hypdata_str );
- if(MYDEBUG) SCRUTE( hypdata_str );
+ SCRUTE( hypdata_str );
hypdata = string( hypdata_str );
delete [] hypdata_str;
aDataset->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 <<
+ MESSAGE("VSR - load algo : id = " << id <<
", name = " << hypname.c_str() << ", persistent string = " << hypdata.c_str());
SMESH::SMESH_Hypothesis_var myHyp;
myStudyContext->mapOldToNew( id, newId );
}
else
- if(MYDEBUG) MESSAGE( "VSR - SMESH_Gen::Load - can't get servant" );
+ MESSAGE( "VSR - SMESH_Gen::Load - can't get servant" );
}
}
}
int aNbObjects = aTopGroup->nInternalObjects();
if ( aNbObjects > 0 ) {
// create mesh
- if(MYDEBUG) MESSAGE( "VSR - load mesh : id = " << id );
+ 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 )
}
} // reading MESHes
- // As all object that can be referred by hypothesis are created,
+ // As all objects that can be referred by hypothesis are created,
// we can restore hypothesis data
list< pair< SMESH_Hypothesis_i*, string > >::iterator hyp_data;
aGroup->OpenOnDisk();
// get number of applied algorithms
int aNbSubObjects = aGroup->nInternalObjects();
- if(MYDEBUG) MESSAGE( "VSR - number of applied algos " << aNbSubObjects );
+ 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 );
if ( aSubMesh->_is_nil() )
continue;
string iorSubString = GetORB()->object_to_string( aSubMesh );
- int newSubId = myStudyContext->findId( iorSubString );
+ int newSubId = myStudyContext->findId( iorSubString );
myStudyContext->mapOldToNew( subid, newSubId );
}
}
if ( aNewGroup->_is_nil() )
continue;
- string iorSubString = GetORB()->object_to_string( aNewGroup );
+ CORBA::String_var iorSubStringVar = GetORB()->object_to_string( aNewGroup );
+ string iorSubString(iorSubStringVar.in());
int newSubId = myStudyContext->findId( iorSubString );
myStudyContext->mapOldToNew( subid, newSubId );
aDataset->ReadFromDisk((char*) dataString.data() );
aDataset->CloseOnDisk();
- std::istringstream istream( dataString.data() );
- boost::archive::text_iarchive archive( istream );
std::list< std::list< std::string > > orderEntryLists;
- try {
- archive >> orderEntryLists;
- }
- catch (...) {}
+ SMESHUtils::BoostTxtArchive( dataString ) >> orderEntryLists;
TListOfListOfInt anOrderIds;
for ( const std::list< std::string >& entryList : orderEntryLists )
const SALOMEDS::TMPFile& theStream,
const char* theURL,
bool isMultiFile ) {
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::LoadASCII" );
+ MESSAGE( "SMESH_Gen_i::LoadASCII" );
return Load( theComponent, theStream, theURL, isMultiFile );
//before call main ::Load method it's need for decipher text format to
void SMESH_Gen_i::Close( SALOMEDS::SComponent_ptr theComponent )
{
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Close" );
+ MESSAGE( "SMESH_Gen_i::Close" );
// Clear study contexts data
myStudyContext->Clear();
char* SMESH_Gen_i::ComponentDataType()
{
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::ComponentDataType" );
+ MESSAGE( "SMESH_Gen_i::ComponentDataType" );
return CORBA::string_dup( "SMESH" );
}
CORBA::Boolean /*isMultiFile*/,
CORBA::Boolean /*isASCII*/ )
{
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IORToLocalPersistentID" );
+ MESSAGE( "SMESH_Gen_i::IORToLocalPersistentID" );
if ( myStudyContext && strcmp( IORString, "" ) != 0 ) {
int anId = myStudyContext->findId( IORString );
if ( anId ) {
- if(MYDEBUG) MESSAGE( "VSR " << anId )
+ MESSAGE( "VSR " << anId );
char strId[ 20 ];
sprintf( strId, "%d", anId );
return CORBA::string_dup( strId );
CORBA::Boolean /*isMultiFile*/,
CORBA::Boolean /*isASCII*/ )
{
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::LocalPersistentIDToIOR(): id = " << aLocalPersistentID );
+ MESSAGE( "SMESH_Gen_i::LocalPersistentIDToIOR(): id = " << aLocalPersistentID );
if ( myStudyContext && strcmp( aLocalPersistentID, "" ) != 0 ) {
int anId = atoi( aLocalPersistentID );
*/
//================================================================================
-CORBA::Long SMESH_Gen_i::GetObjectId(CORBA::Object_ptr theObject)
+CORBA::Long SMESH_Gen_i::GetObjectId(CORBA::Object_ptr theObject)
{
if ( myStudyContext && !CORBA::is_nil( theObject )) {
- string iorString = GetORB()->object_to_string( theObject );
- return myStudyContext->findId( iorString );
+ CORBA::String_var iorString = GetORB()->object_to_string( theObject );
+ string iorStringCpp(iorString.in());
+ return myStudyContext->findId( iorStringCpp );
}
return 0;
}
useCaseBuilder->AppendTo( where, sobj ); // append to the end of list
}
}
-//================================================================================
-/*!
- * \brief Returns true if algorithm can be used to mesh a given geometry
- * \param [in] theAlgoType - the algorithm type
- * \param [in] theLibName - a name of the Plug-in library implementing the algorithm
- * \param [in] theGeomObject - the geometry to mesh
- * \param [in] toCheckAll - if \c True, returns \c True if all shapes are meshable,
- * else, returns \c True if at least one shape is meshable
- * \return CORBA::Boolean - can or can't
- */
-//================================================================================
-
-CORBA::Boolean SMESH_Gen_i::IsApplicable ( const char* theAlgoType,
- const char* theLibName,
- GEOM::GEOM_Object_ptr theGeomObject,
- CORBA::Boolean toCheckAll)
-{
- SMESH_TRY;
-
- std::string aPlatformLibName;
- GenericHypothesisCreator_i* aCreator =
- getHypothesisCreator(theAlgoType, theLibName, aPlatformLibName);
- if (aCreator)
- {
- TopoDS_Shape shape = GeomObjectToShape( theGeomObject );
- const SMESH_Algo::Features& feat = SMESH_Algo::GetFeatures( theAlgoType );
- return shape.IsNull() || aCreator->IsApplicable( shape, toCheckAll, feat._dim );
- }
- else
- {
- return false;
- }
-
- SMESH_CATCH( SMESH::doNothing );
-
-#ifdef _DEBUG_
- cout << "SMESH_Gen_i::IsApplicable(): exception in " << ( theAlgoType ? theAlgoType : "") << endl;
-#endif
- return true;
-}
//================================================================================
/*!
SMESH::SMESH_Group_var gsource = SMESH::SMESH_Group::_narrow(meshPart);
if ( !gsource->_is_nil() ) {
if(theElemType == SMESH::NODE) {
- SMESH::long_array_var nodes = gsource->GetNodeIDs();
+ SMESH::smIdType_array_var nodes = gsource->GetNodeIDs();
for ( CORBA::ULong i = 0; i < nodes->length(); ++i ) {
if ( const SMDS_MeshNode* node = meshDS->FindNode( nodes[i] )) {
long anId = node->GetID();
}
}
} else if (gsource->GetType() == theElemType || theElemType == SMESH::ALL ) {
- SMESH::long_array_var elems = gsource->GetListOfID();
+ SMESH::smIdType_array_var elems = gsource->GetListOfID();
for ( CORBA::ULong i = 0; i < elems->length(); ++i ) {
if ( const SMDS_MeshElement* elem = meshDS->FindElement( elems[i] )) {
long anId = elem->GetID();
}
SMESH::SMESH_subMesh_var smsource = SMESH::SMESH_subMesh::_narrow(meshPart);
if ( !smsource->_is_nil() ) {
- SMESH::long_array_var elems = smsource->GetElementsByType( theElemType );
+ SMESH::smIdType_array_var elems = smsource->GetElementsByType( theElemType );
for ( CORBA::ULong i = 0; i < elems->length(); ++i ) {
const SMDS_MeshElement* elem = ( theElemType == SMESH::NODE ) ? meshDS->FindNode( elems[i] ) : meshDS->FindElement( elems[i] );
if (elem) {
}
return res;
}
+
+//================================================================================
+/*!
+ * \brief Returns true if algorithm can be used to mesh a given geometry
+ * \param [in] theAlgoType - the algorithm type
+ * \param [in] theLibName - a name of the Plug-in library implementing the algorithm
+ * \param [in] theGeomObject - the geometry to mesh
+ * \param [in] toCheckAll - if \c True, returns \c True if all shapes are meshable,
+ * else, returns \c True if at least one shape is meshable
+ * \return CORBA::Boolean - can or can't
+ */
+//================================================================================
+
+#undef SMY_OWN_CATCH
+#define SMY_OWN_CATCH // prevent re-throwing SALOME::SALOME_Exception in IsApplicable()
+
+CORBA::Boolean SMESH_Gen_i::IsApplicable ( const char* theAlgoType,
+ const char* theLibName,
+ GEOM::GEOM_Object_ptr theGeomObject,
+ CORBA::Boolean toCheckAll)
+{
+ SMESH_TRY;
+
+ std::string aPlatformLibName;
+ GenericHypothesisCreator_i* aCreator =
+ getHypothesisCreator(theAlgoType, theLibName, aPlatformLibName);
+ if (aCreator)
+ {
+ TopoDS_Shape shape = GeomObjectToShape( theGeomObject );
+ const SMESH_Algo::Features& feat = SMESH_Algo::GetFeatures( theAlgoType );
+ return shape.IsNull() || aCreator->IsApplicable( shape, toCheckAll, feat._dim );
+ }
+ else
+ {
+ return false;
+ }
+
+ SMESH_CATCH( SMESH::doNothing );
+
+ MESSAGE("SMESH_Gen_i::IsApplicable(): exception in " << ( theAlgoType ? theAlgoType : ""));
+ return true;
+}
