-// Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2021 CEA/DEN, EDF R&D, 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>
-
#ifdef WIN32
#include <windows.h>
#include <process.h>
#include "SMESH_PreMeshInfo.hxx"
#include "SMESH_PythonDump.hxx"
#include "SMESH_ControlsDef.hxx"
+#include <SMESH_BoostTxtArchive.hxx>
// to pass CORBA exception through SMESH_TRY
#define SMY_OWN_CATCH catch( SALOME::SALOME_Exception& se ) { throw se; }
#include <cstdlib>
#include <memory>
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/serialization/list.hpp>
+#include <boost/serialization/string.hpp>
+
using namespace std;
using SMESH::TPythonDump;
using SMESH::TVar;
GEOM::GEOM_Gen_var SMESH_Gen_i::myGeomGen;
CORBA::ORB_var SMESH_Gen_i::myOrb;
PortableServer::POA_var SMESH_Gen_i::myPoa;
-SALOME_NamingService* SMESH_Gen_i::myNS = NULL;
-SALOME_LifeCycleCORBA* SMESH_Gen_i::myLCC = NULL;
-SMESH_Gen_i* SMESH_Gen_i::mySMESHGen = NULL;
+SALOME_NamingService_Abstract* SMESH_Gen_i::myNS = nullptr;
+SALOME_LifeCycleCORBA* SMESH_Gen_i::myLCC = nullptr;
+SMESH_Gen_i* SMESH_Gen_i::mySMESHGen = nullptr;
const int nbElemPerDiagonal = 10;
}
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* SMESH_Gen_i::GetNS()
+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() );
*/
//=============================================================================
-GEOM::GEOM_Gen_var SMESH_Gen_i::GetGeomEngine( bool isShaper )
-{
- Engines::EngineComponent_ptr temp =
- GetLCC()->FindOrLoad_Component( isShaper ? "FactoryServer" : "FactoryServer",
- isShaper ? "SHAPERSTUDY" : "GEOM" );
- myGeomGen = GEOM::GEOM_Gen::_narrow( temp );
-
- return myGeomGen;
-}
-
-//=============================================================================
-/*!
- * GetGeomEngine [ static ]
- *
- * Get GEOM::GEOM_Gen reference
- */
-//=============================================================================
-
GEOM::GEOM_Gen_var SMESH_Gen_i::GetGeomEngine( GEOM::GEOM_Object_ptr go )
{
- GEOM::GEOM_Gen_ptr gen;
+ GEOM::GEOM_Gen_ptr gen = GEOM::GEOM_Gen::_nil();
if ( !CORBA::is_nil( go ))
gen = go->GetGen();
return gen;
PortableServer::POA_ptr poa,
PortableServer::ObjectId* contId,
const char* instanceName,
- const char* interfaceName )
- : Engines_Component_i( orb, poa, contId, instanceName, interfaceName )
+ const char* interfaceName,
+ bool checkNS)
+ : Engines_Component_i( orb, poa, contId, instanceName, interfaceName, false, checkNS )
{
myOrb = CORBA::ORB::_duplicate(orb);
// 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() )
+ if(checkNS)
{
- CORBA::Object_var obj = ns->Resolve( "/Kernel/Session" );
- SALOME::Session_var session = SALOME::Session::_narrow( obj ) ;
- if ( !session->_is_nil() )
+ if ( SALOME_NamingService_Abstract* ns = GetNS() )
{
- CORBA::String_var str_host = session->getHostname();
- CORBA::Long s_pid = session->getPID();
- string my_host = Kernel_Utils::GetHostname();
+ CORBA::Object_var obj = ns->Resolve( "/Kernel/Session" );
+ SALOME::Session_var session = SALOME::Session::_narrow( obj ) ;
+ if ( !session->_is_nil() )
+ {
+ CORBA::String_var str_host = session->getHostname();
+ CORBA::Long s_pid = session->getPID();
+ string my_host = Kernel_Utils::GetHostname();
#ifdef WIN32
- long my_pid = (long)_getpid();
+ long my_pid = (long)_getpid();
#else
- long my_pid = (long) getpid();
+ long my_pid = (long) getpid();
#endif
- SetEmbeddedMode( s_pid == my_pid && my_host == str_host.in() );
+ SetEmbeddedMode( s_pid == my_pid && my_host == str_host.in() );
+ }
}
}
}
GenericHypothesisCreator_i* SMESH_Gen_i::getHypothesisCreator(const char* theHypName,
const char* theLibName,
std::string& thePlatformLibName)
- throw (SALOME::SALOME_Exception)
{
std::string aPlatformLibName;
/* It's Need to translate lib name for WIN32 or X platform */
// load plugin library
if(MYDEBUG) 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
hypothesis_i = myHypothesis_i->_this();
int nextId = RegisterObject( hypothesis_i );
if(MYDEBUG) { MESSAGE( "Add hypo to map with id = "<< nextId ); }
- else { nextId = 0; } // avoid "unused variable" warning in release mode
+ else { (void)nextId; } // avoid "unused variable" warning in release mode
}
return hypothesis_i._retn();
}
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh()
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::createMesh" );
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 { nextId = 0; } // avoid "unused variable" warning in release mode
+ else { (void)nextId; } // avoid "unused variable" warning in release mode
return mesh._retn();
}
catch (SALOME_Exception& S_ex) {
SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis( const char* theHypName,
const char* theLibName )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
// Create hypothesis/algorithm
SALOMEDS::SObject_wrap aSO = PublishHypothesis( hyp );
if ( !aSO->_is_nil() ) {
// Update Python script
- TPythonDump() << aSO << " = " << this << ".CreateHypothesis('"
+ TPythonDump(this) << aSO << " = " << this << ".CreateHypothesis('"
<< theHypName << "', '" << theLibName << "')";
}
}
const char* theLibName,
CORBA::Double theAverageLength,
CORBA::Boolean theQuadDominated)
- throw ( SALOME::SALOME_Exception )
{
SMESH::HypInitParams initParams = { ::SMESH_Hypothesis::BY_AVERAGE_LENGTH,
theAverageLength, theQuadDominated };
initParams );
SALOMEDS::SObject_wrap so = PublishHypothesis( hyp );
- TPythonDump() << hyp << " = " << this << ".CreateHypothesisByAverageLength( '"
+ TPythonDump(this) << hyp << " = " << this << ".CreateHypothesisByAverageLength( '"
<< theHypType << "', '"
<< theLibName << "', "
<< theAverageLength << ", "
SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theGeom,
const SMESH::HypInitParams& theParams)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
//=============================================================================
void SMESH_Gen_i::SetBoundaryBoxSegmentation( CORBA::Long theNbSegments )
- throw ( SALOME::SALOME_Exception )
{
if ( theNbSegments > 0 )
myGen.SetBoundaryBoxSegmentation( int( theNbSegments ));
//=============================================================================
void SMESH_Gen_i::SetDefaultNbSegments(CORBA::Long theNbSegments)
- throw ( SALOME::SALOME_Exception )
{
if ( theNbSegments > 0 )
myGen.SetDefaultNbSegments( int(theNbSegments) );
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
// Update Python script
- TPythonDump() << aSO << " = " << this << ".CreateMesh(" << theShapeObject << ")";
+ TPythonDump(this) << aSO << " = " << this << ".CreateMesh(" << theShapeObject << ")";
}
}
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh()
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
// Update Python script
- TPythonDump() << aSO << " = " << this << ".CreateEmptyMesh()";
+ TPythonDump(this) << aSO << " = " << this << ".CreateEmptyMesh()";
}
}
*/
//================================================================================
- void checkFileReadable( const char* theFileName ) throw ( SALOME::SALOME_Exception )
+ void checkFileReadable( const char* theFileName )
{
SMESH_File f ( theFileName );
if ( !f )
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromUNV( const char* theFileName )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
// Update Python script
- TPythonDump() << aSO << " = " << this << ".CreateMeshesFromUNV(r'" << theFileName << "')";
+ TPythonDump(this) << aSO << " = " << this << ".CreateMeshesFromUNV(r'" << theFileName << "')";
}
}
*/
//=============================================================================
-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;
- 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 << ", ";
-
- // 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;
- }
+ // Iterate through all meshes and create mesh objects
+ for ( const std::string & meshName : aNames )
+ {
+ // Python Dump
+ if (i > 0) aPythonDump << ", ";
- // 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;
+ // create mesh
+ SMESH::SMESH_Mesh_var mesh = createMesh();
- aResult[i++] = SMESH::SMESH_Mesh::_duplicate( mesh );
- meshServant->GetImpl().GetMeshDS()->Modified();
+ // publish mesh in the study
+ SALOMEDS::SObject_wrap aSO;
+ if ( CanPublishInStudy( mesh ) )
+ aSO = PublishMesh( mesh.in(), meshName.c_str() );
+
+ // Python Dump
+ if ( !aSO->_is_nil() ) {
+ aPythonDump << aSO;
+ } else {
+ 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, 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)
- throw ( SALOME::SALOME_Exception )
-{
- 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)
- throw ( SALOME::SALOME_Exception )
-{
- 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
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
// Update Python script
- TPythonDump() << aSO << " = " << this << ".CreateMeshesFromSTL(r'" << theFileName << "')";
+ TPythonDump(this) << aSO << " = " << this << ".CreateMeshesFromSTL(r'" << theFileName << "')";
}
}
SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromCGNS( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
{ // open a new scope to make aPythonDump die before PythonDump in SMESH_Mesh::GetGroups()
// Python Dump
- TPythonDump aPythonDump;
+ TPythonDump aPythonDump(this);
aPythonDump << "([";
if (theStatus == SMESH::DRS_OK)
SMESH_Gen_i::CreateMeshesFromGMF( const char* theFileName,
CORBA::Boolean theMakeRequiredGroups,
SMESH::ComputeError_out theError)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
// Update Python script
- TPythonDump() << "("<< aSO << ", error) = " << this << ".CreateMeshesFromGMF(r'"
+ TPythonDump(this) << "("<< aSO << ", error) = " << this << ".CreateMeshesFromGMF(r'"
<< theFileName << "', "
<< theMakeRequiredGroups << " )";
}
CORBA::Boolean SMESH_Gen_i::IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IsReadyToCompute" );
SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetComputeErrors()" );
SMESH::MeshPreviewStruct*
SMESH_Gen_i::GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Short theSubShapeID )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetBadInputElements()" );
SMESH_Gen_i::MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Short theSubShapeID,
const char* theGroupName )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if ( SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh ))
{
groups = meshServant->MakeGroupsOfBadInputElements( theSubShapeID, theGroupName );
- TPythonDump() << groups << " = " << this
+ TPythonDump(this) << groups << " = " << this
<< ".MakeGroupsOfBadInputElements( "
<< theMesh << ", " << theSubShapeID << ", '" << theGroupName << "' )";
}
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()" );
SMESH::long_array*
SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject,
const SMESH::object_array& theListOfSubShapeObject )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetSubShapesId" );
CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception )
{
//MEMOSTAT;
Unexpect aCatch(SALOME_SalomeException);
SALOME::BAD_PARAM );
// Update Python script
- TPythonDump() << "isDone = " << this << ".Compute( "
+ TPythonDump(this) << "isDone = " << this << ".Compute( "
<< theMesh << ", " << theShapeObject << ")";
try {
return ok;
}
}
- catch ( std::bad_alloc ) {
+ catch ( std::bad_alloc& ) {
INFOS( "Compute(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
GEOM::GEOM_Object_ptr theShapeObject,
SMESH::Dimension theDimension,
SMESH::long_array& theShapesId)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Precompute" );
}
}
}
- catch ( std::bad_alloc ) {
+ catch ( std::bad_alloc& ) {
INFOS( "Precompute(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
*/
//=============================================================================
-SMESH::long_array* SMESH_Gen_i::Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
- GEOM::GEOM_Object_ptr theShapeObject)
-// SMESH::long_array& theNbElems)
- throw ( SALOME::SALOME_Exception )
+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" );
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++)
nbels[i] = 0;
// Update Python script
- TPythonDump() << "theNbElems = " << this << ".Evaluate( "
+ TPythonDump(this) << "theNbElems = " << this << ".Evaluate( "
<< theMesh << ", " << theShapeObject << ")";
try {
/*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;
return nbels._retn();
}
}
- catch ( std::bad_alloc ) {
+ catch ( std::bad_alloc& ) {
INFOS( "Evaluate(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
GEOM::GEOM_Object_ptr
SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
- CORBA::Long theElementID,
+ SMESH::smIdType theElementID,
const char* theGeomName)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_ptr
SMESH_Gen_i::FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
- CORBA::Long theElementID)
- throw ( SALOME::SALOME_Exception )
+ SMESH::smIdType theElementID)
{
Unexpect aCatch(SALOME_SalomeException);
if ( CORBA::is_nil( theMesh ) )
CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
- throw ( SALOME::SALOME_Exception )
{
return ConcatenateCommon(theMeshesArray,
theUniteIdenticalGroups,
CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
- throw ( SALOME::SALOME_Exception )
{
return ConcatenateCommon(theMeshesArray,
theUniteIdenticalGroups,
CORBA::Double theMergeTolerance,
CORBA::Boolean theCommonGroups,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
- throw ( SALOME::SALOME_Exception )
{
- std::unique_ptr< TPythonDump > pPythonDump( new TPythonDump );
+ std::unique_ptr< TPythonDump > pPythonDump( new TPythonDump(this) );
TPythonDump& pythonDump = *pPythonDump; // prevent dump of called methods
// create mesh if theMeshToAppendTo not provided
}
// remember nb of elements before filling in
- SMESH::long_array_var prevState = newMesh->GetNbElementsByType();
+ SMESH::smIdType_array_var prevState = newMesh->GetNbElementsByType();
// copy nodes
{
// 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();
const char* meshName,
CORBA::Boolean toCopyGroups,
CORBA::Boolean toKeepIDs)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
- TPythonDump* pyDump = new TPythonDump; // prevent dump from CreateMesh()
+ TPythonDump* pyDump = new TPythonDump(this); // prevent dump from CreateMesh()
std::unique_ptr<TPythonDump> pyDumpDeleter( pyDump );
// 1. Get source 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())
{
SMESH::submesh_array_out theNewSubmeshes,
SMESH::ListOfHypothesis_out theNewHypotheses,
SMESH::string_array_out theInvalidEntries)
-throw ( SALOME::SALOME_Exception )
{
if ( CORBA::is_nil( theSourceMesh ) ||
CORBA::is_nil( theNewGeometry ))
bool ok = true;
SMESH_TRY;
- TPythonDump pyDump; // prevent dump from CreateMesh()
+ TPythonDump pyDump(this); // prevent dump from CreateMesh()
theNewMesh = CreateMesh( theNewGeometry );
theNewGroups = new SMESH::ListOfGroups();
{
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
SMESH::SMESH_Mesh_var myMesh = SMESH::SMESH_Mesh::_narrow( anObject ) ;
if ( !myMesh->_is_nil() ) {
myMesh->Load(); // load from study file if not yet done
- TPythonDump pd; // not to dump GetGroups()
+ TPythonDump pd(this); // not to dump GetGroups()
SMESH::ListOfGroups_var groups = myMesh->GetGroups();
for ( CORBA::ULong i = 0; i < groups->length(); ++i )
{
// 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 );
}
// store submesh order if any
const TListOfListOfInt& theOrderIds = myLocMesh.GetMeshOrder();
- if ( theOrderIds.size() ) {
+ const bool isNewOrederVersion = true; // old version saves ids, new one, entries
+ if ( !theOrderIds.empty() && !isNewOrederVersion ) { // keep old version for reference
char order_list[ 30 ];
strcpy( order_list, "Mesh Order" );
// count number of submesh ids
//
delete[] smIDs;
}
+ if ( !theOrderIds.empty() && isNewOrederVersion )
+ {
+ // convert ids to entries
+ std::list< std::list< std::string > > orderEntryLists;
+ for ( const TListOfInt& idList : theOrderIds )
+ {
+ orderEntryLists.emplace_back();
+ std::list< std::string > & entryList = orderEntryLists.back();
+ for ( const int& id : idList )
+ {
+ const TopoDS_Shape& shape = mySMESHDSMesh->IndexToShape( id );
+ GEOM::GEOM_Object_var go = ShapeToGeomObject( shape );
+ SALOMEDS::SObject_var so = ObjectToSObject( go );
+ if ( !so->_is_nil() )
+ {
+ CORBA::String_var entry = so->GetID();
+ entryList.emplace_back( entry.in() );
+ }
+ }
+ }
+ // convert orderEntryLists to string
+ std::ostringstream ostream;
+ boost::archive::text_oarchive( ostream ) << orderEntryLists;
+ std::string orderEntryString = ostream.str();
+
+ // write HDF group
+ aSize[ 0 ] = orderEntryString.size() + 1;
+ aDataset = new HDFdataset( "MeshOrder_new", aTopGroup, HDF_STRING, aSize, 1 );
+ aDataset->CreateOnDisk();
+ aDataset->WriteOnDisk((char*) orderEntryString.data() );
+ aDataset->CloseOnDisk();
+ }
// groups root sub-branch
SALOMEDS::SObject_wrap myGroupsBranch;
// 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();
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";
return false;
}
- TPythonDump pd; // prevent dump during loading
+ TPythonDump pd(this); // prevent dump during loading
// For PAL13473 ("Repetitive mesh") implementation.
// New dependencies between SMESH objects are established:
}
} // 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;
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 );
}
// read Sub-Mesh ORDER if any
- if ( aTopGroup->ExistInternalObject( "Mesh Order" )) {
+ if ( aTopGroup->ExistInternalObject( "Mesh Order" )) { // old version keeps ids
aDataset = new HDFdataset( "Mesh Order", aTopGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
myNewMeshImpl->GetImpl().SetMeshOrder( anOrderIds );
delete [] smIDs;
}
+ if ( aTopGroup->ExistInternalObject( "MeshOrder_new" )) // new version keeps entries
+ {
+ aDataset = new HDFdataset( "MeshOrder_new", aTopGroup );
+ aDataset->OpenOnDisk();
+ size = aDataset->GetSize();
+ std::string dataString; dataString.resize( size );
+ aDataset->ReadFromDisk((char*) dataString.data() );
+ aDataset->CloseOnDisk();
+
+ std::list< std::list< std::string > > orderEntryLists;
+ SMESHUtils::BoostTxtArchive( dataString ) >> orderEntryLists;
+
+ TListOfListOfInt anOrderIds;
+ for ( const std::list< std::string >& entryList : orderEntryLists )
+ {
+ anOrderIds.emplace_back();
+ for ( const std::string & entry : entryList )
+ {
+ GEOM::GEOM_Object_var go = GetGeomObjectByEntry( entry );
+ TopoDS_Shape shape = GeomObjectToShape( go );
+ if ( SMESH_subMesh* sm = myNewMeshImpl->GetImpl().GetSubMesh( shape ))
+ anOrderIds.back().emplace_back( sm->GetId() );
+ }
+ }
+ myNewMeshImpl->GetImpl().SetMeshOrder( anOrderIds );
+ }
} // loop on meshes
// update hyps needing full mesh data restored (issue 20918)
}
}
}
- pd << ""; // prevent optimizing pd out
// creation of tree nodes for all data objects in the study
// to support tree representation customization and drag-n-drop:
*/
//================================================================================
-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;
}
SMESH_TRY;
std::string aPlatformLibName;
- typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char*);
GenericHypothesisCreator_i* aCreator =
getHypothesisCreator(theAlgoType, theLibName, aPlatformLibName);
if (aCreator)
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;
}
-
-//=============================================================================
-/*!
- * SMESHEngine_factory
- *
- * C factory, accessible with dlsym, after dlopen
- */
-//=============================================================================
-
-extern "C"
-{ SMESH_I_EXPORT
- PortableServer::ObjectId* SMESHEngine_factory( CORBA::ORB_ptr orb,
- PortableServer::POA_ptr poa,
- PortableServer::ObjectId* contId,
- const char* instanceName,
- const char* interfaceName )
- {
- if(MYDEBUG) MESSAGE( "PortableServer::ObjectId* SMESHEngine_factory()" );
- if(MYDEBUG) SCRUTE(interfaceName);
- SMESH_Gen_i* aSMESHGen = new SMESH_Gen_i(orb, poa, contId, instanceName, interfaceName);
- return aSMESHGen->getId() ;
- }
-}
