-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2020 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 <cstdlib>
#include <memory>
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/serialization/list.hpp>
+#include <boost/serialization/string.hpp>
+
using namespace std;
using SMESH::TPythonDump;
using SMESH::TVar;
#endif
// Static variables definition
-GEOM::GEOM_Gen_var SMESH_Gen_i::myGeomGen = GEOM::GEOM_Gen::_nil();
+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;
* Get SALOME_LifeCycleCORBA object
*/
//=============================================================================
-SALOME_LifeCycleCORBA* SMESH_Gen_i::GetLCC() {
+
+SALOME_LifeCycleCORBA* SMESH_Gen_i::GetLCC()
+{
if ( myLCC == NULL ) {
myLCC = new SALOME_LifeCycleCORBA( GetNS() );
}
return myLCC;
}
-
//=============================================================================
/*!
* GetGeomEngine [ static ]
* Get GEOM::GEOM_Gen reference
*/
//=============================================================================
-GEOM::GEOM_Gen_var SMESH_Gen_i::GetGeomEngine() {
- //CCRT GEOM::GEOM_Gen_var aGeomEngine =
- //CCRT GEOM::GEOM_Gen::_narrow( GetLCC()->FindOrLoad_Component("FactoryServer","GEOM") );
- //CCRT return aGeomEngine._retn();
- if(CORBA::is_nil(myGeomGen))
- {
- Engines::EngineComponent_ptr temp=GetLCC()->FindOrLoad_Component("FactoryServer","GEOM");
- myGeomGen=GEOM::GEOM_Gen::_narrow(temp);
- }
+
+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::_nil();
+ if ( !CORBA::is_nil( go ))
+ gen = go->GetGen();
+ return gen;
+}
+
//=============================================================================
/*!
* SMESH_Gen_i::SMESH_Gen_i
if ( myShapeReader )
delete myShapeReader;
}
+
//=============================================================================
/*!
* SMESH_Gen_i::getHypothesisCreator
* Get hypothesis creator
*/
//=============================================================================
+
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 */
// report any error, if occurred
#ifndef WIN32
const char* anError = dlerror();
- throw(SALOME_Exception(anError));
+ throw(SALOME_Exception( anError ));
#else
- throw(SALOME_Exception(LOCALIZED( "Can't load server meshers plugin library" )));
+ throw(SALOME_Exception ( SMESH_Comment("Can't load meshers plugin library " )
+ << aPlatformLibName));
#endif
}
(GetHypothesisCreator)GetProc( libHandle, "GetHypothesisCreator" );
if (!procHandle)
{
- throw(SALOME_Exception(LOCALIZED("bad hypothesis plugin library")));
+ throw(SALOME_Exception(SMESH_Comment("bad hypothesis plugin library")
+ << aPlatformLibName ));
UnLoadLib(libHandle);
}
aCreator = procHandle(theHypName);
if (!aCreator)
{
- throw(SALOME_Exception(LOCALIZED("no such a hypothesis in this plugin")));
+ throw(SALOME_Exception( SMESH_Comment( theHypName ) << " is missing from "
+ << aPlatformLibName));
}
// map hypothesis creator to a hypothesis name
myHypCreatorMap[string(theHypName)] = aCreator;
* Create hypothesis of given type
*/
//=============================================================================
+
SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName,
const char* theLibName)
{
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();
}
* Create empty mesh on shape
*/
//=============================================================================
+
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) {
* Get shape reader
*/
//=============================================================================
+
GEOM_Client* SMESH_Gen_i::GetShapeReader()
{
// create shape reader if necessary
* Set GEOM::GEOM_Gen reference
*/
//=============================================================================
-//GEOM::GEOM_Gen_ptr SMESH_Gen_i::SetGeomEngine( const char* containerLoc )
+
void SMESH_Gen_i::SetGeomEngine( GEOM::GEOM_Gen_ptr geomcompo )
{
- //Engines::Component_ptr temp=GetLCC()->FindOrLoad_Component(containerLoc,"GEOM");
- //myGeomGen=GEOM::GEOM_Gen::_narrow(temp);
- myGeomGen=GEOM::GEOM_Gen::_duplicate(geomcompo);
- //return myGeomGen;
+ myGeomGen = GEOM::GEOM_Gen::_duplicate( geomcompo );
}
//=============================================================================
* Set enable publishing in the study
*/
//=============================================================================
+
void SMESH_Gen_i::SetEnablePublish( CORBA::Boolean theIsEnablePublish )
{
myIsEnablePublish = theIsEnablePublish;
myStudyContext = new StudyContext;
SALOMEDS::Study_var aStudy = getStudyServant();
- if ( !CORBA::is_nil( aStudy ) ) {
+ if ( !CORBA::is_nil( aStudy ) )
+ {
SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
+
SALOMEDS::SComponent_wrap GEOM_var = aStudy->FindComponent( "GEOM" );
if( !GEOM_var->_is_nil() )
- aStudyBuilder->LoadWith( GEOM_var, GetGeomEngine() );
+ aStudyBuilder->LoadWith( GEOM_var, GetGeomEngine( /*isShaper=*/false ) );
+
+ GEOM_var = aStudy->FindComponent( "SHAPERSTUDY" );
+ if( !GEOM_var->_is_nil() )
+ aStudyBuilder->LoadWith( GEOM_var, GetGeomEngine( /*isShaper=*/true ) );
+
// NPAL16168, issue 0020210
// Let meshes update their data depending on GEOM groups that could change
CORBA::String_var compDataType = ComponentDataType();
}
}
+//================================================================================
+/*!
+ * \brief Return true if mesh has ICON_SMESH_TREE_GEOM_MODIF icon
+ */
+//================================================================================
+
+bool SMESH_Gen_i::isGeomModifIcon( SMESH::SMESH_Mesh_ptr mesh )
+{
+ SALOMEDS::SObject_wrap so = ObjectToSObject( mesh );
+ SALOMEDS::GenericAttribute_wrap attr;
+ if ( ! so->_is_nil() && so->FindAttribute( attr.inout(), "AttributePixMap" ))
+ {
+ SALOMEDS::AttributePixMap_wrap pm = attr;
+ CORBA::String_var ico = pm->GetPixMap();
+ return ( strcmp( ico.in(), "ICON_SMESH_TREE_GEOM_MODIF" ) == 0 );
+ }
+ return false;
+}
+
+//=================================================================================
+// function : hasObjectInfo()
+// purpose : shows if module provides information for its objects
+//=================================================================================
+
+bool SMESH_Gen_i::hasObjectInfo()
+{
+ return true;
+}
+
+//=================================================================================
+// function : getObjectInfo()
+// purpose : returns an information for a given object by its entry
+//=================================================================================
+
+char* SMESH_Gen_i::getObjectInfo( const char* entry )
+{
+ // for a mesh with icon == ICON_SMESH_TREE_GEOM_MODIF show a warning;
+ // for the rest, "module 'SMESH', ID=0:1:2:*"
+
+ SMESH_Comment txt;
+
+ SALOMEDS::SObject_wrap so = getStudyServant()->FindObjectID( entry );
+ CORBA::Object_var obj = SObjectToObject( so );
+ SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( obj );
+ if ( isGeomModifIcon( mesh ))
+ {
+ txt << "The geometry was changed and the mesh needs to be recomputed";
+ }
+
+ if ( txt.empty() )
+ {
+ CORBA::String_var compType = ComponentDataType();
+ txt << "module '" << compType << "', ID=" << entry;
+ }
+ return CORBA::string_dup( txt );
+}
+
//=============================================================================
/*!
* SMESH_Gen_i::GetStudyContext
* Get study context
*/
//=============================================================================
+
StudyContext* SMESH_Gen_i::GetStudyContext()
{
return myStudyContext;
/*!
* SMESH_Gen_i::CreateHypothesis
*
- * Create hypothesis/algorothm of given type and publish it in the study
+ * Create hypothesis/algorithm of given type and publish it in the study
*/
//=============================================================================
SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis( const char* theHypName,
const char* theLibName )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
// Create hypothesis/algorithm
return hyp._retn();
}
+//================================================================================
+/*!
+ * \brief Return a hypothesis initialized by given average length.
+ * \param theHypType - hypothesis type name
+ * \param theLibName - plugin library name
+ * \param theAverageLength - average length
+ * \param theQuadDominated - is quad-dominated flag
+ * \retval SMESH::SMESH_Hypothesis_ptr - the new hypothesis
+ */
+//================================================================================
+
+SMESH::SMESH_Hypothesis_ptr
+SMESH_Gen_i::CreateHypothesisByAverageLength( const char* theHypType,
+ const char* theLibName,
+ CORBA::Double theAverageLength,
+ CORBA::Boolean theQuadDominated)
+{
+ SMESH::HypInitParams initParams = { ::SMESH_Hypothesis::BY_AVERAGE_LENGTH,
+ theAverageLength, theQuadDominated };
+
+ SMESH::SMESH_Hypothesis_var hyp =
+ GetHypothesisParameterValues( theHypType, theLibName,
+ SMESH::SMESH_Mesh::_nil(),
+ GEOM::GEOM_Object::_nil(),
+ initParams );
+ SALOMEDS::SObject_wrap so = PublishHypothesis( hyp );
+
+ TPythonDump() << hyp << " = " << this << ".CreateHypothesisByAverageLength( '"
+ << theHypType << "', '"
+ << theLibName << "', "
+ << theAverageLength << ", "
+ << theQuadDominated << " )";
+
+ return hyp._retn();
+}
+
//================================================================================
/*!
* \brief Return a hypothesis holding parameter values corresponding either to the mesh
//================================================================================
SMESH::SMESH_Hypothesis_ptr
-SMESH_Gen_i::GetHypothesisParameterValues (const char* theHypType,
- const char* theLibName,
- SMESH::SMESH_Mesh_ptr theMesh,
- GEOM::GEOM_Object_ptr theGeom,
- CORBA::Boolean byMesh)
- throw ( SALOME::SALOME_Exception )
+SMESH_Gen_i::GetHypothesisParameterValues( const char* theHypType,
+ const char* theLibName,
+ SMESH::SMESH_Mesh_ptr theMesh,
+ GEOM::GEOM_Object_ptr theGeom,
+ const SMESH::HypInitParams& theParams)
{
Unexpect aCatch(SALOME_SalomeException);
+
+ const bool byMesh = ( theParams.way == ::SMESH_Hypothesis::BY_MESH );
if ( byMesh && CORBA::is_nil( theMesh ) )
return SMESH::SMESH_Hypothesis::_nil();
if ( byMesh && CORBA::is_nil( theGeom ) )
if ( hyp->SetParametersByMesh( mesh, shape ))
return SMESH::SMESH_Hypothesis::_duplicate( tmpHyp );
}
- else {
- double diagonal = 0;
- if ( mesh )
- diagonal = mesh->GetShapeDiagonalSize();
- else
- diagonal = ::SMESH_Mesh::GetShapeDiagonalSize( shape );
+ else
+ {
::SMESH_Hypothesis::TDefaults dflts;
- dflts._elemLength = diagonal / myGen.GetBoundaryBoxSegmentation();
- dflts._nbSegments = myGen.GetDefaultNbSegments();
- dflts._shape = &shape;
- // let the temporary hypothesis initialize it's values
+ dflts._way = ( ::SMESH_Hypothesis::InitWay) theParams.way;
+ dflts._nbSegments = myGen.GetDefaultNbSegments();
+ dflts._elemLength = theParams.averageLength;
+ dflts._quadDominated = theParams.quadDominated;
+ if ( theParams.way == ::SMESH_Hypothesis::BY_GEOM )
+ {
+ if ( mesh )
+ dflts._diagonal = mesh->GetShapeDiagonalSize();
+ else
+ dflts._diagonal = ::SMESH_Mesh::GetShapeDiagonalSize( shape );
+ dflts._elemLength = dflts._diagonal / myGen.GetBoundaryBoxSegmentation();
+ dflts._shape = &shape;
+ }
+
+ // let the hypothesis initialize it's values
if ( hyp->SetParametersByDefaults( dflts, mesh ))
return SMESH::SMESH_Hypothesis::_duplicate( tmpHyp );
}
//=============================================================================
/*!
- * Sets number of segments per diagonal of boundary box of geometry by which
+ * Set number of segments per diagonal of boundary box of geometry by which
* default segment length of appropriate 1D hypotheses is defined
*/
//=============================================================================
void SMESH_Gen_i::SetBoundaryBoxSegmentation( CORBA::Long theNbSegments )
- throw ( SALOME::SALOME_Exception )
{
if ( theNbSegments > 0 )
myGen.SetBoundaryBoxSegmentation( int( theNbSegments ));
else
THROW_SALOME_CORBA_EXCEPTION( "non-positive number of segments", SALOME::BAD_PARAM );
}
+
//=============================================================================
- /*!
- * \brief Sets default number of segments per edge
- */
+/*!
+ * \brief Set default number of segments per edge
+ */
//=============================================================================
+
void SMESH_Gen_i::SetDefaultNbSegments(CORBA::Long theNbSegments)
- throw ( SALOME::SALOME_Exception )
{
if ( theNbSegments > 0 )
myGen.SetDefaultNbSegments( int(theNbSegments) );
//=============================================================================
/*!
- Set an option value
-*/
+ * Set an option value
+ */
//=============================================================================
void SMESH_Gen_i::SetOption(const char* name, const char* value)
//=============================================================================
/*!
- Return an option value
-*/
+ * Return an option value
+ */
//=============================================================================
char* SMESH_Gen_i::GetOption(const char* name)
//=============================================================================
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" );
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh()
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
{
//================================================================================
/*!
- * \brief Throws an exception in case if the file can't be read
+ * \brief Throw an exception in case if the file can't be read
*/
//================================================================================
- 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);
return aResult._retn();
}
-SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName,
+//================================================================================
+/*!
+ * \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);
+ SMESH::mesh_array* result = CreateMeshesFromMEDorSAUV(theFileName, theStatus,
+ "CreateMeshesFromMED", theFileName);
return result;
}
*/
//=============================================================================
-SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char* theFileName,
+SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
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());
+ SMESH::mesh_array* result = CreateMeshesFromMEDorSAUV(medfilename.c_str(),
+ theStatus,
+ "CreateMeshesFromSAUV",
+ sauvfilename.c_str());
#ifdef WIN32
cmd = "%PYTHONBIN% ";
#else
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
*/
//================================================================================
-SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromCGNS( const char* 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 );
SMESH_Gen_i::CreateMeshesFromGMF( const char* theFileName,
CORBA::Boolean theMakeRequiredGroups,
SMESH::ComputeError_out theError)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
/*!
* SMESH_Gen_i::IsReadyToCompute
*
- * Returns true if mesh contains enough data to be computed
+ * Return true if mesh contains enough data to be computed
*/
//=============================================================================
CORBA::Boolean SMESH_Gen_i::IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IsReadyToCompute" );
if ( CORBA::is_nil( theShapeObject ) )
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
SALOME::BAD_PARAM );
-
if ( CORBA::is_nil( theMesh ) )
THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",
SALOME::BAD_PARAM );
-
try {
// get mesh servant
SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
SALOMEDS::SObject_ptr SMESH_Gen_i::GetAlgoSO(const ::SMESH_Algo* algo)
{
if ( algo ) {
- SALOMEDS::Study_var aStudy = getStudyServant();
+ SALOMEDS::Study_var aStudy = getStudyServant();
if ( !aStudy->_is_nil() ) {
// find algo in the study
CORBA::String_var compDataType = ComponentDataType();
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);
//================================================================================
/*!
* \brief Returns errors of hypotheses definition
- * \param theMesh - the mesh
- * \param theSubObject - the main or sub- shape
- * \retval SMESH::algo_error_array* - sequence of errors
+ * \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()" );
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);
SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
ASSERT( meshServant );
if ( meshServant ) {
- meshServant->Load();
+ if ( isGeomModifIcon( theMesh ))
+ meshServant->Clear();
+ else
+ meshServant->Load();
// NPAL16168: "geometrical group edition from a submesh don't modify mesh computation"
meshServant->CheckGeomModif();
// get local TopoDS_Shape
return ok;
}
}
- catch ( std::bad_alloc ) {
+ catch ( std::bad_alloc& ) {
INFOS( "Compute(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
void SMESH_Gen_i::CancelCompute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject )
{
- SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
- ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
- TopoDS_Shape myLocShape;
- if(theMesh->HasShapeToMesh())
- myLocShape = GeomObjectToShape( theShapeObject );
- else
- myLocShape = SMESH_Mesh::PseudoShape();
- myGen.CancelCompute( myLocMesh, myLocShape);
+ if ( SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() ))
+ {
+ ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
+ TopoDS_Shape myLocShape;
+ if(theMesh->HasShapeToMesh())
+ myLocShape = GeomObjectToShape( theShapeObject );
+ else
+ myLocShape = SMESH_Mesh::PseudoShape();
+ myGen.CancelCompute( myLocMesh, myLocShape);
+ }
}
//=============================================================================
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" );
if(theMesh->HasShapeToMesh())
myLocShape = GeomObjectToShape( theShapeObject );
else
- return result._retn();;
+ return result._retn();
// call implementation compute
::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
}
}
}
- 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 )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Evaluate" );
if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
- THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
- SALOME::BAD_PARAM );
+ 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 );
+ THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference", SALOME::BAD_PARAM );
SMESH::long_array_var nbels = new SMESH::long_array;
nbels->length(SMESH::Entity_Last);
return nbels._retn();
}
}
- catch ( std::bad_alloc ) {
+ catch ( std::bad_alloc& ) {
INFOS( "Evaluate(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
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_wrap geom = FindGeometryByMeshElement(theMesh, theElementID);
if ( !geom->_is_nil() ) {
GEOM::GEOM_Object_var mainShape = theMesh->GetShapeToMesh();
- GEOM::GEOM_Gen_ptr geomGen = GetGeomEngine();
+ GEOM::GEOM_Gen_var geomGen = GetGeomEngine( geom );
// try to find the corresponding SObject
SALOMEDS::SObject_wrap SObj = ObjectToSObject( geom.in() );
}
}
}
- if ( SObj->_is_nil() ) // publish a new subshape
+ if ( SObj->_is_nil() && !geomGen->_is_nil() ) // publish a new subshape
SObj = geomGen->AddInStudy( geom, theGeomName, mainShape );
// return only published geometry
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_ptr geomGen = GetGeomEngine();
+ GEOM::GEOM_Gen_var geomGen = GetGeomEngine( mainShape );
// get a core mesh DS
SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
}
if ( !it->_is_nil() ) {
for ( it->InitEx(true); it->More(); it->Next() ) {
- SALOMEDS::SObject_wrap so = it->Value();
+ SALOMEDS::SObject_wrap so = it->Value();
CORBA::Object_var obj = SObjectToObject( so );
GEOM::GEOM_Object_var subGeom = GEOM::GEOM_Object::_narrow( obj );
if ( !subGeom->_is_nil() ) {
SMESH_Gen_i::Concatenate(const SMESH::ListOfIDSources& theMeshesArray,
CORBA::Boolean theUniteIdenticalGroups,
CORBA::Boolean theMergeNodesAndElements,
- CORBA::Double theMergeTolerance)
- throw ( SALOME::SALOME_Exception )
+ CORBA::Double theMergeTolerance,
+ SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
{
return ConcatenateCommon(theMeshesArray,
theUniteIdenticalGroups,
theMergeNodesAndElements,
theMergeTolerance,
- false);
+ false,
+ theMeshToAppendTo);
}
//================================================================================
SMESH_Gen_i::ConcatenateWithGroups(const SMESH::ListOfIDSources& theMeshesArray,
CORBA::Boolean theUniteIdenticalGroups,
CORBA::Boolean theMergeNodesAndElements,
- CORBA::Double theMergeTolerance)
- throw ( SALOME::SALOME_Exception )
+ CORBA::Double theMergeTolerance,
+ SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
{
return ConcatenateCommon(theMeshesArray,
theUniteIdenticalGroups,
theMergeNodesAndElements,
theMergeTolerance,
- true);
+ true,
+ theMeshToAppendTo);
}
//================================================================================
CORBA::Boolean theUniteIdenticalGroups,
CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance,
- CORBA::Boolean theCommonGroups)
- throw ( SALOME::SALOME_Exception )
+ CORBA::Boolean theCommonGroups,
+ SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
{
std::unique_ptr< TPythonDump > pPythonDump( new TPythonDump );
TPythonDump& pythonDump = *pPythonDump; // prevent dump of called methods
- // create mesh
- SMESH::SMESH_Mesh_var newMesh = CreateEmptyMesh();
- SMESH_Mesh_i* newImpl = SMESH::DownCast<SMESH_Mesh_i*>( newMesh );
+ // create mesh if theMeshToAppendTo not provided
+ SMESH::SMESH_Mesh_var newMesh;
+ if ( CORBA::is_nil( theMeshToAppendTo ))
+ newMesh = CreateEmptyMesh();
+ else
+ newMesh = SMESH::SMESH_Mesh::_duplicate( theMeshToAppendTo );
+ SMESH_Mesh_i* newImpl = SMESH::DownCast<SMESH_Mesh_i*>( newMesh );
if ( !newImpl ) return newMesh._retn();
+ newImpl->Load();
::SMESH_Mesh& locMesh = newImpl->GetImpl();
SMESHDS_Mesh* newMeshDS = locMesh.GetMeshDS();
TGroupsMap groupsMap;
TListOfNewGroups listOfNewGroups;
+ if ( !CORBA::is_nil( theMeshToAppendTo ))
+ {
+ // fill groupsMap with existing groups
+ SMESH::ListOfGroups_var groups = theMeshToAppendTo->GetGroups();
+ for ( CORBA::ULong i = 0; i < groups->length(); ++i )
+ {
+ SMESH::SMESH_Group_var group = SMESH::SMESH_Group::_narrow( groups[ i ]);
+ if ( !group->_is_nil() )
+ {
+ CORBA::String_var name = group->GetName();
+ SMESH::ElementType type = group->GetType();
+ groupsMap[ TNameAndType( name.in(), type ) ].push_back( group );
+ }
+ }
+ }
+
::SMESH_MeshEditor newEditor( &locMesh );
::SMESH_MeshEditor::ElemFeatures elemType;
SMESH::SMESH_Mesh_var initMesh = theMeshesArray[i]->GetMesh();
SMESH_Mesh_i* initImpl = SMESH::DownCast<SMESH_Mesh_i*>( initMesh );
if ( !initImpl ) continue;
+ if ( initMesh->_is_equivalent( theMeshToAppendTo ))
+ continue;
initImpl->Load();
- // assure that IDs increments by one during iteration
+ // assure that IDs increment by one during iteration
::SMESH_Mesh& initLocMesh = initImpl->GetImpl();
SMESHDS_Mesh* initMeshDS = initLocMesh.GetMeshDS();
if ( initMeshDS->MaxNodeID() > initMeshDS->NbNodes() ||
// 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() )
// Update Python script
pythonDump << newMesh << " = " << this
- << "." << ( theCommonGroups ? "ConcatenateWithGroups" : "Concatenate" ) << "("
+ << "." << ( theCommonGroups ? "ConcatenateWithGroups" : "Concatenate" ) << "( "
<< theMeshesArray << ", "
<< theUniteIdenticalGroups << ", "
<< theMergeNodesAndElements << ", "
- << TVar( theMergeTolerance ) << ")";
+ << TVar( theMergeTolerance ) << ", "
+ << theMeshToAppendTo << " )";
pPythonDump.reset(); // enable python dump from GetGroups()
const char* meshName,
CORBA::Boolean toCopyGroups,
CORBA::Boolean toKeepIDs)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
{
typedef std::map< std::string, std::string > TStr2StrMap;
typedef std::map< std::string, std::set< std::string > > TStr2StrSetMap;
+ typedef std::map< std::set<int>, int > TIdSet2IndexMap;
+ typedef std::map< std::string, int > TName2IndexMap;
//================================================================================
/*!
TStr2StrMap myOld2NewEntryMap; // map of study entries
+ GEOM::ListOfGO_var mySubshapes; // sub-shapes existing in the new geometry
+ TIdSet2IndexMap myIds2SubshapeIndex; // to find an existing sub-shape
+ TName2IndexMap myName2SubshapeIndex; // to find an existing sub-shape by name
+
bool myGIPMapDone;
GEOM::ListOfListOfLong_var myGIPMap; // filled by GetInPlaceMap()
CORBA::String_var newEntry = newSO->GetID();
myOld2NewEntryMap.insert( std::make_pair( std::string( oldEntry.in() ),
std::string( newEntry.in() )));
+ std::string newMainEntry = newEntry.in();
SALOMEDS::Study_var study = myGen_i->getStudyServant();
- GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine();
+ GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine( mainShapeNew );
GEOM::GEOM_IShapesOperations_wrap op = geomGen->GetIShapesOperations();
- GEOM::ListOfGO_var subShapes = op->GetExistingSubObjects( mainShapeNew,
+ mySubshapes = op->GetExistingSubObjects( mainShapeNew,
/*groupsOnly=*/false );
- for ( CORBA::ULong i = 0; i < subShapes->length(); ++i )
+ for ( CORBA::ULong i = 0; i < mySubshapes->length(); ++i )
{
- newSO = myGen_i->ObjectToSObject( subShapes[ i ]);
+ newSO = myGen_i->ObjectToSObject( mySubshapes[ i ]);
SALOMEDS::ChildIterator_wrap anIter = study->NewChildIterator( newSO );
+ bool refFound = false;
for ( ; anIter->More(); anIter->Next() )
{
SALOMEDS::SObject_wrap so = anIter->Value();
{
oldEntry = oldSO->GetID();
newEntry = newSO->GetID();
- myOld2NewEntryMap.insert( std::make_pair( std::string( oldEntry.in() ),
- std::string( newEntry.in() )));
+ if (( refFound = ( newMainEntry != oldEntry.in() )))
+ myOld2NewEntryMap.insert( std::make_pair( std::string( oldEntry.in() ),
+ std::string( newEntry.in() )));
+ }
+ }
+ if ( !refFound )
+ {
+ GEOM::GEOM_Object_var father = mySubshapes[ i ]->GetMainShape();
+ if ( father->_is_equivalent( mainShapeNew ))
+ {
+ GEOM::ListOfLong_var ids = mySubshapes[ i ]->GetSubShapeIndices();
+ std::set< int > idSet( &ids[0] , &ids[0] + ids->length() );
+ myIds2SubshapeIndex.insert( std::make_pair( idSet, i ));
+ CORBA::String_var name = newSO->GetName();
+ if ( name.in()[0] )
+ myName2SubshapeIndex.insert( std::make_pair( name.in(), i ));
}
}
}
return GEOM::GEOM_Object::_duplicate( oldShape ); // shape independent of the old shape
GEOM::GEOM_Object_var mainShapeNew = myNewMesh_i->GetShapeToMesh();
- GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine();
+ GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine( mainShapeNew );
- // try to find by entry
+ // try to find by entry or name
if ( myToPublish )
{
CORBA::String_var oldEntry = oldShape->GetStudyEntry();
{
newShape = getShapeByEntry( o2nID->second );
}
+ if ( newShape->_is_nil() )
+ {
+ CORBA::String_var name = oldShape->GetName();
+ TName2IndexMap::iterator n2ind = myName2SubshapeIndex.find( name.in() );
+ if ( n2ind != myName2SubshapeIndex.end() )
+ {
+ newShape = GEOM::GEOM_Object::_duplicate( mySubshapes[ n2ind->second ]);
+ GEOM::ListOfLong_var oldIndices = oldShape->GetSubShapeIndices();
+ GEOM::ListOfLong_var newIndices = newShape->GetSubShapeIndices();
+ if ( oldIndices->length() == 0 ||
+ newIndices->length() == 0 ||
+ getShapeType( myNewMesh_i, newIndices[0] ) !=
+ getShapeType( mySrcMesh_i, oldIndices[0] ))
+ newShape = GEOM::GEOM_Object::_nil();
+ }
+ }
}
if ( newShape->_is_nil() )
{
findNewIDs( oldIndices[i], newIndices );
}
- if ( !newIndices.empty() )
+ if ( newIndices.size() < oldIndices->length() ) // issue #17096
{
- try
- {
- if ( newIndices.size() > 1 || oldShape->GetType() == GEOM_GROUP )
+ newIndices.clear();
+ newShape = getInPlace( oldShape );
+ }
+ if ( !newIndices.empty() && newShape->_is_nil() )
+ {
+ // search for a sub-shape with same ids
+ std::set< int > idSet( newIndices.begin(), newIndices.end() );
+ TIdSet2IndexMap::iterator ids2ind = myIds2SubshapeIndex.find( idSet );
+ if ( ids2ind != myIds2SubshapeIndex.end() ) {
+ newShape = GEOM::GEOM_Object::_duplicate( mySubshapes[ ids2ind->second ]);
+ }
+ if ( newShape->_is_nil() )
+ try
{
- int groupType = getShapeType( myNewMesh_i, newIndices[0] );
+ // create a new shape
+ if ( newIndices.size() > 1 || oldShape->GetType() == GEOM_GROUP )
+ {
+ int groupType = getShapeType( myNewMesh_i, newIndices[0] );
- GEOM::GEOM_IGroupOperations_wrap grOp = geomGen->GetIGroupOperations();
- newShape = grOp->CreateGroup( mainShapeNew, groupType );
+ GEOM::GEOM_IGroupOperations_wrap grOp = geomGen->GetIGroupOperations();
+ newShape = grOp->CreateGroup( mainShapeNew, groupType );
- GEOM::ListOfLong_var newIndicesList = new GEOM::ListOfLong();
- newIndicesList->length( newIndices.size() );
- for ( size_t i = 0; i < newIndices.size(); ++i )
- newIndicesList[ i ] = newIndices[ i ];
- grOp->UnionIDs( newShape, newIndicesList );
+ GEOM::ListOfLong_var newIndicesList = new GEOM::ListOfLong();
+ newIndicesList->length( newIndices.size() );
+ for ( size_t i = 0; i < newIndices.size(); ++i )
+ newIndicesList[ i ] = newIndices[ i ];
+ grOp->UnionIDs( newShape, newIndicesList );
+ }
+ else
+ {
+ GEOM::GEOM_IShapesOperations_wrap shOp = geomGen->GetIShapesOperations();
+ newShape = shOp->GetSubShape( mainShapeNew, newIndices[0] );
+ }
}
- else
+ catch (...)
{
- GEOM::GEOM_IShapesOperations_wrap shOp = geomGen->GetIShapesOperations();
- newShape = shOp->GetSubShape( mainShapeNew, newIndices[0] );
}
- }
- catch (...)
- {
- }
}
}
if ( 0 < oldID && oldID < (int)myGIPMap->length() )
{
if ( myGIPMap[ oldID ].length() == 1 )
+ {
newID = myGIPMap[ oldID ][ 0 ];
+ }
+ else if ( myGIPMap[ oldID ].length() > 1 &&
+ getShapeType( mySrcMesh_i, oldID ) == TopAbs_VERTEX )
+ {
+ // select a meshed VERTEX
+ SMESH_subMesh* newSM;
+ for ( CORBA::ULong i = 0; i < myGIPMap[ oldID ].length() && !newID; ++i )
+ if (( newSM = myNewMesh_i->GetImpl().GetSubMeshContaining( myGIPMap[ oldID ][ i ] )) &&
+ ( !newSM->IsEmpty() ))
+ newID = myGIPMap[ oldID ][ i ];
+ }
}
return newID;
}
GEOM::GEOM_Object_var mainShapeNew = myNewMesh_i->GetShapeToMesh();
GEOM::GEOM_Object_var mainShapeOld = mySrcMesh_i->GetShapeToMesh();
- GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine();
+ GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine( mainShapeNew );
GEOM::GEOM_IShapesOperations_wrap op = geomGen->GetIShapesOperations();
try
{
}
}
+ //================================================================================
+ /*!
+ * \brief Get new sub-shape by calling GetInPlace()
+ */
+ GEOM::GEOM_Object_ptr getInPlace( GEOM::GEOM_Object_ptr oldShape )
+ {
+ GEOM::GEOM_Object_var newShape;
+
+ GEOM::GEOM_Object_var mainShapeNew = myNewMesh_i->GetShapeToMesh();
+ GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine( mainShapeNew );
+ GEOM::GEOM_IShapesOperations_wrap op = geomGen->GetIShapesOperations();
+ try
+ {
+ newShape = op->GetInPlace( mainShapeNew, oldShape );
+ }
+ catch( ... )
+ {
+ }
+ return newShape._retn();
+ }
+
//================================================================================
/*!
* \brief Find a new sub-shape indices by an old one in myGIPMap. Return
seq[ seq->length() - 1 ] = item;
}
}
-}
+} // namespace // utils for CopyMeshWithGeom()
//================================================================================
/*!
* \param [out] invalidEntries - return study entries of objects whose
* counterparts are not found in the newGeometry, followed by entries
* of mesh sub-objects that are invalid because they depend on a not found
- * preceeding sub-shape
+ * preceding sub-shape
* \return CORBA::Boolean - is a success
*/
//================================================================================
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 ))
SMESH_Mesh_i* srcMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( theSourceMesh );
SMESH_Mesh_i* newMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( theNewMesh );
+ srcMesh_i->Load();
ShapeMapper shapeMapper( srcMesh_i, newMesh_i, this );
// copy mesh elements, keeping IDs
+ SMESHDS_Mesh* newMeshDS = newMesh_i->GetImpl().GetMeshDS();
if ( theToCopyElements && theSourceMesh->NbNodes() > 0 )
{
- SMESHDS_Mesh* newMeshDS = newMesh_i->GetImpl().GetMeshDS();
::SMESH_MeshEditor editor( &newMesh_i->GetImpl() );
::SMESH_MeshEditor::ElemFeatures elemData;
if ( SMESH_subMesh* newSM = newMesh_i->GetImpl().GetSubMeshContaining( newID ))
newSM->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
}
+
+ newMeshDS->Modified();
}
SALOME::GenericObj_wrap< SMESH::FilterManager > filterMgr = CreateFilterManager();
SMESH::ListOfGroups_var groups = theSourceMesh->GetGroups();
- CORBA::ULong nbGroups = groups->length(), nbAddedGroups = 0;
+ CORBA::ULong nbGroups = theToCopyGroups ? groups->length() : 0, nbAddedGroups = 0;
for ( CORBA::ULong i = 0; i < nbGroups + nbAddedGroups; ++i )
{
SMESH::SMESH_Group_var stdlGroup = SMESH::SMESH_Group::_narrow ( groups[ i ]);
if ( !stdlGroup->_is_nil() )
{
- if ( theToCopyElements )
+ if ( newMeshDS->GetMeshInfo().NbElements( SMDSAbs_ElementType( elemType )) > 0 )
{
SMESH::long_array_var elemIDs = stdlGroup->GetIDs();
- stdlGroup = theNewMesh->CreateGroup( elemType, name );
- stdlGroup->Add( elemIDs );
- newGroup = SMESH::SMESH_GroupBase::_narrow( stdlGroup );
+ const bool isElem = ( elemType != SMESH::NODE );
+ CORBA::ULong iE = 0;
+ for ( ; iE < elemIDs->length(); ++iE ) // check if any element has been copied
+ if ( newMeshDS->GetElementType( elemIDs[ iE ], isElem ) != SMDSAbs_All )
+ break;
+ if ( iE < elemIDs->length() )
+ {
+ stdlGroup = theNewMesh->CreateGroup( elemType, name );
+ stdlGroup->Add( elemIDs );
+ newGroup = SMESH::SMESH_GroupBase::_narrow( stdlGroup );
+ }
}
}
else if ( !geomGroup->_is_nil() )
SALOMEDS::SObject_wrap newSO = ObjectToSObject( newGroup );
if ( !srcSO->_is_nil() )
{
- CORBA::String_var srcID, newID;
+ CORBA::String_var srcID, newID("");
srcID = srcSO->GetID();
if ( !newSO->_is_nil() )
newID = newSO->GetID();
} // loop on groups
+ newMeshDS->CompactMesh();
+
// set mesh name
if ( !theMeshName || !theMeshName[0] )
{
* Get MED version of the file by its name
*/
//================================================================================
+
char* SMESH_Gen_i::GetMEDVersion(const char* theFileName)
{
std::string version = MED::GetMEDVersion( theFileName );
* Check compatibility of file with MED format being used, read only.
*/
//================================================================================
+
CORBA::Boolean SMESH_Gen_i::CheckCompatibility(const char* theFileName)
{
return MED::CheckCompatibility( theFileName );
* Check compatibility of file with MED format being used, for append on write.
*/
//================================================================================
+
CORBA::Boolean SMESH_Gen_i::CheckWriteCompatibility(const char* theFileName)
{
return MED::CheckCompatibility( theFileName, true );
*/
//================================================================================
SMESH::string_array* SMESH_Gen_i::GetMeshNames(const char* theFileName)
+
{
- //MESSAGE("GetMeshNames " << theFileName);
SMESH::string_array_var aResult = new SMESH::string_array();
MED::PWrapper aMed = MED::CrWrapperR( theFileName );
MED::TErr anErr;
MED::TInt aNbMeshes = aMed->GetNbMeshes( &anErr );
- //MESSAGE("---" << aNbMeshes);
if( anErr >= 0 ) {
aResult->length( aNbMeshes );
for( MED::TInt i = 0; i < aNbMeshes; i++ ) {
* Save SMESH module's data
*/
//=============================================================================
+
SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent,
const char* theURL,
bool isMultiFile )
{
+ // localizing
+ Kernel_Utils::Localizer loc;
+
if (!myStudyContext)
UpdateStudy();
cmd+="\" \"";
cmd+=meshfile;
cmd+="\"";
+#ifdef WIN32
+ cmd+=" 2>NUL";
+#endif
system(cmd.ToCString());
// MED writer to be used by storage process
CORBA::String_var objStr = GetORB()->object_to_string( grImpl->_this() );
int anId = myStudyContext->findId( string( objStr.in() ) );
char grpName[ 30 ];
- sprintf( grpName, "Group %d", anId );
+ sprintf( grpName, "Group %d %d", anId, grImpl->GetLocalID() );
SMESHDS_GroupBase* aGrpBaseDS = grImpl->GetGroupDS();
aGrpBaseDS->SetStoreName( grpName );
}
#else
// PAL17753 (Regression: missing hypothesis in restored study)
// "lib" also should be removed from the beginning
- //if( libname_len > 3 )
- //libname.resize( libname_len - 3 );
if( libname_len > 6 )
libname = libname.substr( 3, libname_len - 3 - 3 );
#endif
#else
// PAL17753 (Regression: missing hypothesis in restored study)
// "lib" also should be removed from the beginning
- //if( libname_len > 3 )
- //libname.resize( libname_len - 3 );
if( libname_len > 6 )
libname = libname.substr( 3, libname_len - 3 - 3 );
#endif
aDataset->WriteOnDisk( &meshPersistentId );
aDataset->CloseOnDisk();
+ // Store SMESH_Mesh_i::_mainShapeTick
+ int shapeTick = myImpl->MainShapeTick();
+ aSize[ 0 ] = 1;
+ aDataset = new HDFdataset( "shapeTick", aTopGroup, HDF_INT32, aSize, 1 );
+ aDataset->CreateOnDisk();
+ aDataset->WriteOnDisk( &shapeTick );
+ aDataset->CloseOnDisk();
+
// write reference on a shape if exists
SALOMEDS::SObject_wrap myRef;
bool shapeRefFound = false;
aGroup->CloseOnDisk();
}
}
- // All sub-meshes will be stored in MED file
- // .. will NOT (PAL 12992)
- //if ( shapeRefFound )
- //myWriter.AddAllSubMeshes();
// store submesh order if any
const TListOfListOfInt& theOrderIds = myLocMesh.GetMeshOrder();
- if ( theOrderIds.size() ) {
+ 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;
return anAsciiStreamFile._retn();
}
-//=============================================================================
-/*!
- * SMESH_Gen_i::loadGeomData
- *
- * Load GEOM module data
- */
-//=============================================================================
-
-void SMESH_Gen_i::loadGeomData( SALOMEDS::SComponent_ptr theCompRoot )
-{
- if ( theCompRoot->_is_nil() )
- return;
-
- SALOMEDS::StudyBuilder_var aStudyBuilder = getStudyServant()->NewBuilder();
- aStudyBuilder->LoadWith( theCompRoot, GetGeomEngine() );
-}
-
//=============================================================================
/*!
* SMESH_Gen_i::Load
const char* theURL,
bool isMultiFile )
{
- //if (!myStudyContext)
- UpdateStudy();
+ UpdateStudy(); // load geom data
+ Kernel_Utils::Localizer loc;
+
SALOMEDS::Study_var aStudy = getStudyServant();
- /* if( !theComponent->_is_nil() )
- {
- if( !aStudy->FindComponent( "GEOM" )->_is_nil() )
- loadGeomData( aStudy->FindComponent( "GEOM" ) );
- }*/
// Get temporary files location
TCollection_AsciiString tmpDir =
TPythonDump pd; // prevent dump during loading
- // DriverMED_R_SMESHDS_Mesh myReader;
- // myReader.SetFile( meshfile.ToCString() );
-
// For PAL13473 ("Repetitive mesh") implementation.
// New dependencies between SMESH objects are established:
// now hypotheses can refer to meshes, shapes and other hypotheses.
try { // protect persistence mechanism against exceptions
myHyp = this->createHypothesis( hypname.c_str(), libname.c_str() );
}
+ catch( SALOME::SALOME_Exception& ex )
+ {
+ INFOS( "Exception during hypothesis creation: " << ex.details.text );
+ }
catch (...) {
INFOS( "Exception during hypothesis creation" );
}
aDataset->CloseOnDisk();
if ( strlen( refFromFile ) > 0 ) {
SALOMEDS::SObject_wrap shapeSO = aStudy->FindObjectID( refFromFile );
-
- // Make sure GEOM data are loaded first
- //loadGeomData( shapeSO->GetFatherComponent() );
-
- CORBA::Object_var shapeObject = SObjectToObject( shapeSO );
+ CORBA::Object_var shapeObject = SObjectToObject( shapeSO );
if ( !CORBA::is_nil( shapeObject ) ) {
aShapeObject = GEOM::GEOM_Object::_narrow( shapeObject );
if ( !aShapeObject->_is_nil() )
}
// issue 20918. Restore Persistent Id of SMESHDS_Mesh
- if( aTopGroup->ExistInternalObject( "meshPersistentId" ) )
+ if ( aTopGroup->ExistInternalObject( "meshPersistentId" ) )
{
aDataset = new HDFdataset( "meshPersistentId", aTopGroup );
aDataset->OpenOnDisk();
delete [] meshPersistentId;
}
+ // Restore SMESH_Mesh_i::_mainShapeTick
+ if ( aTopGroup->ExistInternalObject( "shapeTick" ))
+ {
+ aDataset = new HDFdataset( "shapeTick", aTopGroup );
+ aDataset->OpenOnDisk();
+ int* shapeTick = & myNewMeshImpl->MainShapeTick();
+ aDataset->ReadFromDisk( shapeTick );
+ aDataset->CloseOnDisk();
+ }
+
// Restore file info
if ( aTopGroup->ExistInternalObject( "file info" ))
{
{
aTopGroup = meshi_group->second;
SMESH_Mesh_i* myNewMeshImpl = meshi_group->first;
- //::SMESH_Mesh& myLocMesh = myNewMeshImpl->GetImpl();
- //SMESHDS_Mesh* mySMESHDSMesh = myLocMesh.GetMeshDS();
GEOM::GEOM_Object_var aShapeObject = myNewMeshImpl->GetShapeToMesh();
bool hasData = false;
// get mesh old id
CORBA::String_var iorString = GetORB()->object_to_string( myNewMeshImpl->_this() );
int newId = myStudyContext->findId( iorString.in() );
- int id = myStudyContext->getOldId( newId );
+ int meshOldId = myStudyContext->getOldId( newId );
// try to find mesh data dataset
if ( aTopGroup->ExistInternalObject( "Has data" ) ) {
aDataset->ReadFromDisk( strHasData );
aDataset->CloseOnDisk();
if ( strcmp( strHasData, "1") == 0 ) {
- // read mesh data from MED file
- // myReader.SetMesh( mySMESHDSMesh );
- // myReader.SetMeshId( id );
- // myReader.Perform();
hasData = true;
}
delete [] strHasData;
aDataset->ReadFromDisk( refFromFile );
aDataset->CloseOnDisk();
// san - it is impossible to recover applied algorithms using their entries within Load() method
- //SALOMEDS::SObject_wrap hypSO = aStudy->FindObjectID( refFromFile );
- //CORBA::Object_var hypObject = SObjectToObject( hypSO );
int id = atoi( refFromFile );
delete [] refFromFile;
string anIOR = myStudyContext->getIORbyOldId( id );
aDataset->ReadFromDisk( refFromFile );
aDataset->CloseOnDisk();
// san - it is impossible to recover applied hypotheses using their entries within Load() method
- //SALOMEDS::SObject_wrap hypSO = myStudy->FindObjectID( refFromFile );
- //CORBA::Object_var hypObject = SObjectToObject( hypSO );
int id = atoi( refFromFile );
delete [] refFromFile;
string anIOR = myStudyContext->getIORbyOldId( id );
// check if it is a group
if ( name_dataset.substr( 0, 5 ) == "Group" ) {
// --> get group id
- int subid = atoi( name_dataset.substr( 5 ).c_str() );
+ char * endptr;
+ int subid = strtol( name_dataset.data() + 5, &endptr, 10 );
if ( subid <= 0 )
continue;
+ int groupID = -1; // group local ID (also persistent)
+ if ( *endptr )
+ groupID = atoi( endptr + 1 );
aDataset = new HDFdataset( name_dataset.c_str(), aGroup );
aDataset->OpenOnDisk();
// Create group servant
SMESH::ElementType type = (SMESH::ElementType)(ii - GetNodeGroupsTag() + 1);
SMESH::SMESH_GroupBase_var aNewGroup = SMESH::SMESH_GroupBase::_duplicate
- ( myNewMeshImpl->createGroup( type, nameFromFile, aShape, predicate ) );
+ ( myNewMeshImpl->createGroup( type, nameFromFile, groupID, aShape, predicate ) );
delete [] nameFromFile;
// Obtain a SMESHDS_Group object
if ( aNewGroup->_is_nil() )
} // reading GROUPs
// instead of reading mesh data, we read only brief information of all
- // objects: mesh, groups, sub-meshes (issue 0021208 )
+ // objects: mesh, groups, sub-meshes (issue 0021208)
if ( hasData )
{
- SMESH_PreMeshInfo::LoadFromFile( myNewMeshImpl, id,
+ SMESH_PreMeshInfo::LoadFromFile( myNewMeshImpl, meshOldId,
meshfile.ToCString(), filename.ToCString(),
!isMultiFile );
}
// 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::istringstream istream( dataString.data() );
+ boost::archive::text_iarchive archive( istream );
+ std::list< std::list< std::string > > orderEntryLists;
+ try {
+ archive >> orderEntryLists;
+ }
+ catch (...) {}
+
+ 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:
* Set a new object name
*/
//=============================================================================
+
void SMESH_Gen_i::SetName(const char* theIOR,
const char* theName)
{
// purpose : Moves objects to the specified position.
// Is used in the drag-n-drop functionality.
//=================================================================================
+
void SMESH_Gen_i::Move( const SMESH::sobject_list& what,
SALOMEDS::SObject_ptr where,
CORBA::Long row )
SMESH_TRY;
std::string aPlatformLibName;
- typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char*);
GenericHypothesisCreator_i* aCreator =
getHypothesisCreator(theAlgoType, theLibName, aPlatformLibName);
if (aCreator)
{
TopoDS_Shape shape = GeomObjectToShape( theGeomObject );
- return shape.IsNull() || aCreator->IsApplicable( shape, toCheckAll );
+ const SMESH_Algo::Features& feat = SMESH_Algo::GetFeatures( theAlgoType );
+ return shape.IsNull() || aCreator->IsApplicable( shape, toCheckAll, feat._dim );
}
else
{
return true;
}
-//=================================================================================
-// function : GetInsideSphere
-// purpose : Collect indices of elements, which are located inside the sphere
-//=================================================================================
+//================================================================================
+/*!
+ * \brief Collect indices of elements, which are located inside the sphere
+ */
+//================================================================================
+
SMESH::long_array* SMESH_Gen_i::GetInsideSphere( SMESH::SMESH_IDSource_ptr meshPart,
SMESH::ElementType theElemType,
CORBA::Double theX,
return aResult._retn();
}
+//================================================================================
+/*!
+ * \brief Collect indices of elements, which are located inside the box
+ */
+//================================================================================
+
SMESH::long_array* SMESH_Gen_i::GetInsideBox( SMESH::SMESH_IDSource_ptr meshPart,
SMESH::ElementType theElemType,
CORBA::Double theX1,
CORBA::Double theZ1,
CORBA::Double theX2,
CORBA::Double theY2,
- CORBA::Double theZ2) {
+ CORBA::Double theZ2)
+{
SMESH::long_array_var aResult = new SMESH::long_array();
if( meshPart->_is_nil() )
return aResult._retn();
- TopoDS_Shape aShape = BRepPrimAPI_MakeBox( gp_Pnt( theX1, theY1, theZ1 ), gp_Pnt( theX2, theY2, theZ2 ) ).Shape();
+ TopoDS_Shape aShape = BRepPrimAPI_MakeBox( gp_Pnt( theX1, theY1, theZ1 ),
+ gp_Pnt( theX2, theY2, theZ2 ) ).Shape();
std::vector<long> lst =_GetInside(meshPart, theElemType, aShape);
return aResult._retn();
}
+//================================================================================
+/*!
+ * \brief Collect indices of elements, which are located inside the cylinder
+ */
+//================================================================================
+
SMESH::long_array* SMESH_Gen_i::GetInsideCylinder( SMESH::SMESH_IDSource_ptr meshPart,
SMESH::ElementType theElemType,
CORBA::Double theX,
CORBA::Double theDY,
CORBA::Double theDZ,
CORBA::Double theH,
- CORBA::Double theR ){
+ CORBA::Double theR )
+{
SMESH::long_array_var aResult = new SMESH::long_array();
if( meshPart->_is_nil() )
return aResult._retn();
return aResult._retn();
}
+//================================================================================
+/*!
+ * \brief Collect indices of elements, which are located inside the geom object
+ */
+//================================================================================
+
SMESH::long_array* SMESH_Gen_i::GetInside( SMESH::SMESH_IDSource_ptr meshPart,
SMESH::ElementType theElemType,
GEOM::GEOM_Object_ptr theGeom,
- CORBA::Double theTolerance ) {
+ CORBA::Double theTolerance )
+{
SMESH::long_array_var aResult = new SMESH::long_array();
if( meshPart->_is_nil() || theGeom->_is_nil() )
return aResult._retn();
return aResult._retn();
}
-
+//================================================================================
+/*!
+ * \brief Collect indices of elements, which are located inside the TopoDS_Shape
+ */
+//================================================================================
std::vector<long> SMESH_Gen_i::_GetInside( SMESH::SMESH_IDSource_ptr meshPart,
- SMESH::ElementType theElemType,
- TopoDS_Shape& aShape,
- double* theTolerance) {
+ SMESH::ElementType theElemType,
+ const TopoDS_Shape& theShape,
+ double* theTolerance) {
std::vector<long> res;
SMESH::SMESH_Mesh_var mesh = meshPart->GetMesh();
SMESH::Controls::ElementsOnShape* anElementsOnShape = new SMESH::Controls::ElementsOnShape();
anElementsOnShape->SetAllNodes( true );
anElementsOnShape->SetMesh( meshDS );
- anElementsOnShape->SetShape( aShape, aType );
+ anElementsOnShape->SetShape( theShape, aType );
if(theTolerance)
anElementsOnShape->SetTolerance(*theTolerance);
return res;
}
-
//=============================================================================
/*!
* SMESHEngine_factory