X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_I%2FSMESH_Mesh_i.cxx;h=2fc681ef523f0e0e9d29c4fbe88f5d1c78b79b53;hp=8dc1b25b585e3bb0def9dcdef7cef4d507dc6adc;hb=60bb6273b99dc88e3d6f360d7ae5792a77c68d06;hpb=8d297d6698f361d4f2dde723050bcfbaea050920 diff --git a/src/SMESH_I/SMESH_Mesh_i.cxx b/src/SMESH_I/SMESH_Mesh_i.cxx index 8dc1b25b5..2fc681ef5 100644 --- a/src/SMESH_I/SMESH_Mesh_i.cxx +++ b/src/SMESH_I/SMESH_Mesh_i.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2016 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 @@ -72,6 +72,7 @@ #include #include #include +#include #include #include #include @@ -83,8 +84,15 @@ #include -// to pass CORBA exception through SMESH_TRY -#define SMY_OWN_CATCH catch( SALOME::SALOME_Exception& se ) { throw se; } +// to pass CORBA exception and TooLargeForExport exception through SMESH_TRY +#define SMY_OWN_CATCH \ + catch( SALOME::SALOME_Exception& se ) { throw se; } \ + catch( ::SMESH_Mesh::TooLargeForExport& ex ) \ + { SALOME::ExceptionStruct se = { \ + SALOME::COMM, \ + CORBA::string_dup(SMESH_Comment("Mesh is too large for export in format ") << ex.what()), \ + CORBA::string_dup(SMESH_Comment("format=") << ex.what() ), 0 }; \ + throw SALOME::SALOME_Exception( se ); } #include "SMESH_TryCatch.hxx" // include after OCCT headers! @@ -96,6 +104,7 @@ static int MYDEBUG = 0; using namespace std; using SMESH::TPythonDump; +using SMESH::TVar; int SMESH_Mesh_i::_idGenerator = 0; @@ -112,6 +121,7 @@ SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA, _impl = NULL; _gen_i = gen_i; _id = _idGenerator++; + _nbInvalidHypos= -1; _editor = NULL; _previewEditor = NULL; _preMeshInfo = NULL; @@ -173,14 +183,13 @@ SMESH_Mesh_i::~SMESH_Mesh_i() /*! * SetShape * - * Associates mesh with and puts a reference + * Associate mesh with and put a reference * to into the current study; * the previous shape is substituted by the new one. */ //============================================================================= void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject ) - throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); try { @@ -198,12 +207,11 @@ void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject ) //================================================================================ /*! - * \brief return true if mesh has a shape to build a shape on + * \brief Return true if mesh has a shape to build a shape on */ //================================================================================ CORBA::Boolean SMESH_Mesh_i::HasShapeToMesh() - throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); bool res = false; @@ -216,13 +224,13 @@ CORBA::Boolean SMESH_Mesh_i::HasShapeToMesh() return res; } -//======================================================================= -//function : GetShapeToMesh -//purpose : -//======================================================================= +//================================================================================ +/*! + * \brief Return the shape to mesh + */ +//================================================================================ GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh() - throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); GEOM::GEOM_Object_var aShapeObj; @@ -239,7 +247,7 @@ GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh() for ( ; data != _geomGroupData.end(); ++data ) if ( data->_smeshObject->_is_equivalent( _this() )) { - SALOMEDS::SObject_wrap so = SMESH_Gen_i::getStudyServant()->FindObjectID( data->_groupEntry.c_str() ); + SALOMEDS::SObject_wrap so = _gen_i->getStudyServant()->FindObjectID( data->_groupEntry.c_str() ); CORBA::Object_var obj = _gen_i->SObjectToObject( so ); aShapeObj = GEOM::GEOM_Object::_narrow( obj ); break; @@ -259,7 +267,7 @@ GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh() */ //================================================================================ -CORBA::Boolean SMESH_Mesh_i::IsLoaded() throw (SALOME::SALOME_Exception) +CORBA::Boolean SMESH_Mesh_i::IsLoaded() { Unexpect aCatch(SALOME_SalomeException); return !_preMeshInfo; @@ -271,7 +279,7 @@ CORBA::Boolean SMESH_Mesh_i::IsLoaded() throw (SALOME::SALOME_Exception) */ //================================================================================ -void SMESH_Mesh_i::Load() throw (SALOME::SALOME_Exception) +void SMESH_Mesh_i::Load() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -284,7 +292,7 @@ void SMESH_Mesh_i::Load() throw (SALOME::SALOME_Exception) */ //================================================================================ -void SMESH_Mesh_i::Clear() throw (SALOME::SALOME_Exception) +void SMESH_Mesh_i::Clear() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -311,7 +319,6 @@ void SMESH_Mesh_i::Clear() throw (SALOME::SALOME_Exception) //================================================================================ void SMESH_Mesh_i::ClearSubMesh(CORBA::Long ShapeID) - throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -384,13 +391,12 @@ static SMESH::ComputeError* ConvertComputeError( SMESH_ComputeErrorPtr errorPtr /*! * ImportMEDFile * - * Imports mesh data from MED file + * Import mesh data from MED file */ //============================================================================= SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName ) - throw ( SALOME::SALOME_Exception ) { Unexpect aCatch(SALOME_SalomeException); int status; @@ -422,14 +428,13 @@ SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName ) //================================================================================ /*! - * \brief Imports mesh data from the CGNS file + * \brief Import mesh data from the CGNS file */ //================================================================================ SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char* theFileName, const int theMeshIndex, std::string& theMeshName ) - throw ( SALOME::SALOME_Exception ) { Unexpect aCatch(SALOME_SalomeException); int status; @@ -463,21 +468,37 @@ SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char* theFileNa char* SMESH_Mesh_i::GetVersionString(CORBA::Long minor, CORBA::Short nbDigits) { - string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(minor, - nbDigits); + string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(minor, nbDigits); return CORBA::string_dup( ver.c_str() ); } +//================================================================================ +/*! + * Return the list of med versions compatibles for write/append, + * encoded in 10*major+minor (for instance, code for med 3.2.1 is 32) + */ +//================================================================================ + +SMESH::long_array* SMESH_Mesh_i::GetMEDVersionsCompatibleForAppend() +{ + SMESH::long_array_var aResult = new SMESH::long_array(); + std::vector mvok = MED::GetMEDVersionsAppendCompatible(); + long nbver = mvok.size(); + aResult->length( nbver ); + for ( int i = 0; i < nbver; i++ ) + aResult[i] = mvok[i]; + return aResult._retn(); +} + //============================================================================= /*! * ImportUNVFile * - * Imports mesh data from MED file + * Import mesh data from MED file */ //============================================================================= int SMESH_Mesh_i::ImportUNVFile( const char* theFileName ) - throw ( SALOME::SALOME_Exception ) { SMESH_TRY; @@ -502,11 +523,11 @@ int SMESH_Mesh_i::ImportUNVFile( const char* theFileName ) /*! * ImportSTLFile * - * Imports mesh data from STL file + * Import mesh data from STL file */ //============================================================================= + int SMESH_Mesh_i::ImportSTLFile( const char* theFileName ) - throw ( SALOME::SALOME_Exception ) { SMESH_TRY; @@ -545,13 +566,12 @@ namespace //================================================================================ /*! - * \brief Imports data from a GMF file and returns an error description + * \brief Import data from a GMF file and return an error description */ //================================================================================ SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName, bool theMakeRequiredGroups ) - throw (SALOME::SALOME_Exception) { SMESH_ComputeErrorPtr error; @@ -579,7 +599,7 @@ SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName, //============================================================================= /*! - * + * \brief Convert SMESH_Hypothesis::Hypothesis_Status into SMESH::Hypothesis_Status */ //============================================================================= @@ -613,7 +633,7 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::ConvertHypothesisStatus /*! * AddHypothesis * - * calls internal addHypothesis() and then adds a reference to under + * Call internal addHypothesis() and then add a reference to under * the SObject actually having a reference to . * NB: For this method to work, it is necessary to add a reference to sub-shape first. */ @@ -623,9 +643,11 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShape, SMESH::SMESH_Hypothesis_ptr anHyp, CORBA::String_out anErrorText) - throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + + const smIdType prevNbMeshEnt = NbNodes() + NbElements(); + if ( _preMeshInfo ) _preMeshInfo->ForgetOrLoad(); @@ -637,7 +659,10 @@ SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShape, if ( !SMESH_Hypothesis::IsStatusFatal(status) ) { _gen_i->AddHypothesisToShape( mesh, aSubShape, anHyp ); - _gen_i->UpdateIcons( mesh ); + + //int newNbMeshEnt = _impl->NbNodes() + _impl->GetMeshDS()->NbElements(); + if ( prevNbMeshEnt > 0 /*newNbMeshEnt != prevNbMeshEnt*/ ) + _gen_i->UpdateIcons( mesh ); } if(MYDEBUG) MESSAGE( " AddHypothesis(): status = " << status ); @@ -648,11 +673,11 @@ SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShape, return ConvertHypothesisStatus(status); } -//============================================================================= +//================================================================================ /*! - * + * \brief Create a sub-mesh and add a hypothesis to it */ -//============================================================================= +//================================================================================ SMESH_Hypothesis::Hypothesis_Status SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr aSubShape, @@ -674,9 +699,9 @@ SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr aSubShape, //use PseudoShape in case if mesh has no shape if(HasShapeToMesh()) myLocSubShape = _gen_i->GeomObjectToShape( aSubShape); - else + else myLocSubShape = _impl->GetShapeToMesh(); - + const int hypId = anHyp->GetId(); std::string error; status = _impl->AddHypothesis( myLocSubShape, hypId, &error ); @@ -703,15 +728,14 @@ SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr aSubShape, return status; } -//============================================================================= +//================================================================================ /*! - * + * \brief Un-assign a hypothesis from a sub-mesh dedicate to the given sub-shape */ -//============================================================================= +//================================================================================ -SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShape, +SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShape, SMESH::SMESH_Hypothesis_ptr anHyp) - throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -738,7 +762,7 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aS //============================================================================= /*! - * + * \brief Un-assign a hypothesis from a sub-mesh dedicate to the given sub-shape */ //============================================================================= @@ -754,6 +778,9 @@ SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShape, if (CORBA::is_nil( anHyp )) THROW_SALOME_CORBA_EXCEPTION("bad hypothesis reference", SALOME::BAD_PARAM); + if ( _preMeshInfo ) + _preMeshInfo->ForgetOrLoad(); + SMESH_Hypothesis::Hypothesis_Status status = SMESH_Hypothesis::HYP_OK; try { @@ -779,15 +806,14 @@ SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShape, return status; } -//============================================================================= +//================================================================================ /*! - * + * \brief Return hypotheses assigned to a given sub-shape */ -//============================================================================= +//================================================================================ SMESH::ListOfHypothesis * SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape) -throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); if (MYDEBUG) MESSAGE("GetHypothesisList"); @@ -821,7 +847,13 @@ throw(SALOME::SALOME_Exception) return aList._retn(); } -SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes() throw (SALOME::SALOME_Exception) +//================================================================================ +/*! + * \brief Return sub-meshes + */ +//================================================================================ + +SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes() { Unexpect aCatch(SALOME_SalomeException); if (MYDEBUG) MESSAGE("GetSubMeshes"); @@ -857,15 +889,14 @@ SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes() throw (SALOME::SALOME_Excepti return aList._retn(); } -//============================================================================= +//================================================================================ /*! - * + * \brief Create and return a sub-mesh on the given sub-shape */ -//============================================================================= +//================================================================================ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShape, const char* theName ) - throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); if (CORBA::is_nil(aSubShape)) @@ -878,13 +909,15 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShap //Get or Create the SMESH_subMesh object implementation - int subMeshId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape ); - - if ( !subMeshId && ! _impl->GetMeshDS()->IsGroupOfSubShapes( myLocSubShape )) + TopoDS_Iterator it( myLocSubShape ); + int subMeshId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape ); + bool isValidSub = ( subMeshId || _impl->GetMeshDS()->IsGroupOfSubShapes( myLocSubShape )); + if ( isValidSub && myLocSubShape.ShapeType() == TopAbs_COMPOUND ) + isValidSub = !it.Value().IsSame( _impl->GetShapeToMesh() ); + if ( !isValidSub ) { - TopoDS_Iterator it( myLocSubShape ); if ( it.More() ) - THROW_SALOME_CORBA_EXCEPTION("not sub-shape of the main shape", SALOME::BAD_PARAM); + THROW_SALOME_CORBA_EXCEPTION("Not a sub-shape of the main shape", SALOME::BAD_PARAM); } subMesh = getSubMesh( subMeshId ); @@ -908,14 +941,13 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShap return subMesh._retn(); } -//============================================================================= +//================================================================================ /*! - * + * \brief Remove a sub-mesh */ -//============================================================================= +//================================================================================ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh ) - throw (SALOME::SALOME_Exception) { SMESH_TRY; @@ -937,7 +969,7 @@ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh ) // if ( aSubShape->_is_nil() ) // not published shape (IPAL13617) // aSubShape = theSubMesh->GetSubShape(); - SALOMEDS::StudyBuilder_var builder = SMESH_Gen_i::getStudyServant()->NewBuilder(); + SALOMEDS::StudyBuilder_var builder = _gen_i->getStudyServant()->NewBuilder(); builder->RemoveObjectWithChildren( anSO ); // Update Python script @@ -951,15 +983,14 @@ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh ) SMESH_CATCH( SMESH::throwCorbaException ); } -//============================================================================= +//================================================================================ /*! - * + * \brief Create a standalone group */ -//============================================================================= +//================================================================================ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType, const char* theName ) - throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -981,16 +1012,16 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType return aNewGroup._retn(); } -//============================================================================= +//================================================================================ /*! - * + * \brief Create a group based on the given geometry */ -//============================================================================= +//================================================================================ + SMESH::SMESH_GroupOnGeom_ptr SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType theElemType, const char* theName, GEOM::GEOM_Object_ptr theGeomObj) - throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -1001,8 +1032,8 @@ SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType theElemType, TopoDS_Shape aShape = _gen_i->GeomObjectToShape( theGeomObj ); if ( !aShape.IsNull() ) { - aNewGroup = - SMESH::SMESH_GroupOnGeom::_narrow( createGroup( theElemType, theName, aShape )); + aNewGroup = + SMESH::SMESH_GroupOnGeom::_narrow( createGroup( theElemType, theName, /*id=*/-1, aShape )); if ( _gen_i->CanPublishInStudy( aNewGroup ) ) { @@ -1032,7 +1063,6 @@ SMESH::SMESH_GroupOnFilter_ptr SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType, const char* theName, SMESH::Filter_ptr theFilter ) - throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -1046,7 +1076,7 @@ SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType, THROW_SALOME_CORBA_EXCEPTION("Invalid filter", SALOME::BAD_PARAM); SMESH::SMESH_GroupOnFilter_var aNewGroup = SMESH::SMESH_GroupOnFilter::_narrow - ( createGroup( theElemType, theName, TopoDS_Shape(), predicate )); + ( createGroup( theElemType, theName, /*id=*/-1, TopoDS_Shape(), predicate )); TPythonDump pd; if ( !aNewGroup->_is_nil() ) @@ -1065,14 +1095,13 @@ SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType, return aNewGroup._retn(); } -//============================================================================= +//================================================================================ /*! - * + * \brief Remove a group */ -//============================================================================= +//================================================================================ void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup ) - throw (SALOME::SALOME_Exception) { if ( theGroup->_is_nil() ) return; @@ -1083,6 +1112,10 @@ void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup ) if ( !aGroup ) return; + if ( aGroup->GetMeshServant() != this ) + THROW_SALOME_CORBA_EXCEPTION( "RemoveGroup(): group does not belong to this mesh", + SALOME::BAD_PARAM ); + SALOMEDS::SObject_wrap aGroupSO = _gen_i->ObjectToSObject( theGroup ); if ( !aGroupSO->_is_nil() ) { @@ -1090,7 +1123,7 @@ void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup ) TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".RemoveGroup( " << aGroupSO << " )"; // Remove group's SObject - SALOMEDS::StudyBuilder_var builder = SMESH_Gen_i::getStudyServant()->NewBuilder(); + SALOMEDS::StudyBuilder_var builder = SMESH_Gen_i::GetSMESHGen()->getStudyServant()->NewBuilder(); builder->RemoveObjectWithChildren( aGroupSO ); } aGroup->Modified(/*removed=*/true); // notify dependent Filter with FT_BelongToMeshGroup criterion @@ -1108,7 +1141,6 @@ void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup ) //============================================================================= void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup ) - throw (SALOME::SALOME_Exception) { SMESH_TRY; if ( _preMeshInfo ) @@ -1117,11 +1149,16 @@ void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup if ( theGroup->_is_nil() ) return; - vector nodeIds; // to remove nodes becoming free + SMESH_GroupBase_i* groupImpl = SMESH::DownCast< SMESH_GroupBase_i* >( theGroup ); + if ( !groupImpl || groupImpl->GetMeshServant() != this ) + THROW_SALOME_CORBA_EXCEPTION( "RemoveGroupWithContents(): group does not belong to this mesh", + SALOME::BAD_PARAM); + + vector nodeIds; // to remove nodes becoming free bool isNodal = ( theGroup->GetType() == SMESH::NODE ); if ( !isNodal && !theGroup->IsEmpty() ) { - CORBA::Long elemID = theGroup->GetID( 1 ); + SMESH::smIdType elemID = theGroup->GetID( 1 ); int nbElemNodes = GetElemNbNodes( elemID ); if ( nbElemNodes > 0 ) nodeIds.reserve( theGroup->Size() * nbElemNodes ); @@ -1163,6 +1200,9 @@ void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup if ( n->NbInverseElements() == 0 ) _impl->GetMeshDS()->RemoveFreeNode( n, /*sm=*/0 ); + _impl->GetMeshDS()->Modified(); + _impl->SetIsModified( true ); + // Update Python script (theGroup must be alive for this) pyDump << SMESH::SMESH_Mesh_var(_this()) << ".RemoveGroupWithContents( " << theGroup << " )"; @@ -1177,7 +1217,7 @@ void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup */ //================================================================================ -SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups() throw(SALOME::SALOME_Exception) +SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups() { Unexpect aCatch(SALOME_SalomeException); if (MYDEBUG) MESSAGE("GetGroups"); @@ -1216,7 +1256,7 @@ SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups() throw(SALOME::SALOME_Exception) */ //============================================================================= -CORBA::Long SMESH_Mesh_i::NbGroups() throw (SALOME::SALOME_Exception) +CORBA::Long SMESH_Mesh_i::NbGroups() { Unexpect aCatch(SALOME_SalomeException); return _mapGroups.size(); @@ -1231,7 +1271,6 @@ CORBA::Long SMESH_Mesh_i::NbGroups() throw (SALOME::SALOME_Exception) SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1, SMESH::SMESH_GroupBase_ptr theGroup2, const char* theName ) - throw (SALOME::SALOME_Exception) { SMESH::SMESH_Group_var aResGrp; @@ -1275,7 +1314,6 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr the SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups& theGroups, const char* theName ) - throw (SALOME::SALOME_Exception) { SMESH::SMESH_Group_var aResGrp; @@ -1338,7 +1376,6 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1, SMESH::SMESH_GroupBase_ptr theGroup2, const char* theName ) - throw (SALOME::SALOME_Exception) { SMESH::SMESH_Group_var aResGrp; @@ -1393,17 +1430,17 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr //============================================================================= /*! - \brief Intersect list of groups. New group is created. All mesh elements that + \brief Intersect list of groups. New group is created. All mesh elements that are present in all initial groups simultaneously are added to the new one. \param theGroups list of groups \param theName name of group to be created \return pointer on the group */ //============================================================================= + SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups, const char* theName ) - throw (SALOME::SALOME_Exception) { SMESH::SMESH_Group_var aResGrp; @@ -1478,7 +1515,7 @@ SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups, } //============================================================================= -/*! +/*! * New group is created. All mesh elements that are present in * a main group but is not present in a tool group are added to the new one */ @@ -1487,7 +1524,6 @@ SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups, SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1, SMESH::SMESH_GroupBase_ptr theGroup2, const char* theName ) - throw (SALOME::SALOME_Exception) { SMESH::SMESH_Group_var aResGrp; @@ -1541,7 +1577,7 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGr //============================================================================= /*! - \brief Cut lists of groups. New group is created. All mesh elements that are + \brief Cut lists of groups. New group is created. All mesh elements that are present in main groups but do not present in tool groups are added to the new one \param theMainGroups list of main groups \param theToolGroups list of tool groups @@ -1549,11 +1585,11 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGr \return pointer on the group */ //============================================================================= + SMESH::SMESH_Group_ptr -SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups, - const SMESH::ListOfGroups& theToolGroups, +SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups, + const SMESH::ListOfGroups& theToolGroups, const char* theName ) - throw (SALOME::SALOME_Exception) { SMESH::SMESH_Group_var aResGrp; @@ -1642,25 +1678,25 @@ SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups, namespace // functions making checks according to SMESH::NB_COMMON_NODES_ENUM { - bool isAllNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners, + bool isAllNodesCommon(int nbChecked, int nbCommon, int nbNodes, int /*nbCorners*/, bool & toStopChecking ) { toStopChecking = ( nbCommon < nbChecked ); return nbCommon == nbNodes; } - bool isMainNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners, + bool isMainNodesCommon(int nbChecked, int nbCommon, int /*nbNodes*/, int nbCorners, bool & toStopChecking ) { toStopChecking = ( nbCommon < nbChecked || nbChecked >= nbCorners ); return nbCommon == nbCorners; } - bool isAtLeastOneNodeCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners, - bool & toStopChecking ) + bool isAtLeastOneNodeCommon(int /*nbChecked*/, int nbCommon, int /*nbNodes*/, int /*nbCorners*/, + bool & /*toStopChecking*/ ) { return nbCommon > 0; } - bool isMajorityOfNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners, - bool & toStopChecking ) + bool isMajorityOfNodesCommon(int /*nbChecked*/, int nbCommon, int nbNodes, int /*nbCorners*/, + bool & /*toStopChecking*/ ) { return nbCommon >= (nbNodes+1) / 2; } @@ -1686,7 +1722,6 @@ SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfIDSources& theGroups, const char* theName, SMESH::NB_COMMON_NODES_ENUM theNbCommonNodes, CORBA::Boolean theUnderlyingOnly) - throw (SALOME::SALOME_Exception) { SMESH::SMESH_Group_var aResGrp; @@ -1828,7 +1863,7 @@ SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfIDSources& theGroups, SMDS_ElemIteratorPtr nIt = elOfType->nodesIterator(); for ( nbChecked = 1; nIt->more() && !toStopChecking; ++nbChecked ) { - const int nID = nIt->next()->GetID(); + const smIdType nID = nIt->next()->GetID(); if ( nID < isNodeInGroupsSize && isNodeInGroups[ nID ] && isToInclude( nbChecked, ++nbCommon, nbNodes, nbCorners, toStopChecking )) { @@ -1851,6 +1886,88 @@ SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfIDSources& theGroups, return aResGrp._retn(); } +//================================================================================ +/*! + * \brief Distribute all faces of the mesh between groups using sharp edges and optionally + * existing 1D elements as group boundaries. + * \param [in] theSharpAngle - edge is considered sharp if an angle between normals of + * adjacent faces is more than \a sharpAngle in degrees. + * \param [in] theCreateEdges - to create 1D elements for detected sharp edges. + * \param [in] theUseExistingEdges - to use existing edges as group boundaries + * \return ListOfGroups - the created groups + */ +//================================================================================ + +SMESH::ListOfGroups* +SMESH_Mesh_i::FaceGroupsSeparatedByEdges( CORBA::Double theSharpAngle, + CORBA::Boolean theCreateEdges, + CORBA::Boolean theUseExistingEdges ) +{ + if ( theSharpAngle < 0 || theSharpAngle > 180 ) + THROW_SALOME_CORBA_EXCEPTION("Invalid sharp angle, it must be between 0 and 180 degrees", + SALOME::BAD_PARAM); + + SMESH::ListOfGroups_var resultGroups = new SMESH::ListOfGroups; + + TPythonDump pyDump; + + SMESH_TRY; + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + SMESHDS_Mesh* meshDS = _impl->GetMeshDS(); + + std::vector< SMESH_MeshAlgos::Edge > edges = + SMESH_MeshAlgos::FindSharpEdges( meshDS, theSharpAngle, theUseExistingEdges ); + + if ( theCreateEdges ) + { + std::vector nodes(2); + for ( size_t i = 0; i < edges.size(); ++i ) + { + nodes[0] = edges[i]._node1; + nodes[1] = edges[i]._node2; + if ( meshDS->FindElement( nodes, SMDSAbs_Edge )) + continue; + if ( edges[i]._medium ) + meshDS->AddEdge( edges[i]._node1, edges[i]._node2, edges[i]._medium ); + else + meshDS->AddEdge( edges[i]._node1, edges[i]._node2 ); + } + } + + std::vector< std::vector< const SMDS_MeshElement* > > faceGroups = + SMESH_MeshAlgos::SeparateFacesByEdges( meshDS, edges ); + + SMESH::SMESH_MeshEditor_var editor = GetMeshEditor(); // create _editor + + resultGroups->length( faceGroups.size() ); + for ( size_t iG = 0; iG < faceGroups.size(); ++iG ) + { + SMESH::SMESH_Group_var group = CreateGroup( SMESH::FACE, + _editor->GenerateGroupName("Group").c_str()); + resultGroups[iG] = SMESH::SMESH_Group::_duplicate( group ); + + SMESHDS_GroupBase* groupBaseDS = + SMESH::DownCast( group )->GetGroupDS(); + SMDS_MeshGroup& groupCore = static_cast< SMESHDS_Group* >( groupBaseDS )->SMDSGroup(); + + std::vector< const SMDS_MeshElement* >& faces = faceGroups[ iG ]; + for ( size_t i = 0; i < faces.size(); ++i ) + groupCore.Add( faces[i] ); + } + + pyDump << resultGroups << " = " << SMESH::SMESH_Mesh_var(_this()) + << ".FaceGroupsSeparatedByEdges( " + << TVar( theSharpAngle ) << ", " + << theCreateEdges << ", " + << theUseExistingEdges << " )"; + + SMESH_CATCH( SMESH::throwCorbaException ); + return resultGroups._retn(); + +} + //================================================================================ /*! * \brief Remember GEOM group data @@ -1867,10 +1984,9 @@ void SMESH_Mesh_i::addGeomGroupData(GEOM::GEOM_Object_ptr theGeomObj, if ( groupSO->_is_nil() ) return; // group indices - GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine(); - GEOM::GEOM_IGroupOperations_wrap groupOp = - geomGen->GetIGroupOperations(); - GEOM::ListOfLong_var ids = groupOp->GetObjects( theGeomObj ); + GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine( theGeomObj ); + GEOM::GEOM_IGroupOperations_wrap groupOp = geomGen->GetIGroupOperations(); + GEOM::ListOfLong_var ids = groupOp->GetObjects( theGeomObj ); // store data _geomGroupData.push_back( TGeomGroupData() ); @@ -1906,52 +2022,243 @@ void SMESH_Mesh_i::removeGeomGroupData(CORBA::Object_ptr theSmeshObj) } } +//================================================================================ +/*! +* \brief Replace a shape in the mesh upon Break Link +*/ +//================================================================================ + +void SMESH_Mesh_i::ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom) +{ + // check if geometry changed + bool geomChanged = true; + GEOM::GEOM_Object_var oldGeom = GetShapeToMesh(); + if ( !theNewGeom->_is_nil() && !oldGeom->_is_nil() ) + geomChanged = ( oldGeom->GetTick() != theNewGeom->GetTick() ); + + TopoDS_Shape S = _impl->GetShapeToMesh(); + GEOM_Client* geomClient = _gen_i->GetShapeReader(); + TCollection_AsciiString aIOR; + if ( geomClient->Find( S, aIOR )) + geomClient->RemoveShapeFromBuffer( aIOR ); + + // clear buffer also for sub-groups + SMESHDS_Mesh* meshDS = _impl->GetMeshDS(); + const std::set& groups = meshDS->GetGroups(); + std::set::const_iterator g = groups.begin(); + for (; g != groups.end(); ++g) + if (const SMESHDS_GroupOnGeom* group = dynamic_cast(*g)) + { + const TopoDS_Shape& s = group->GetShape(); + if ( geomClient->Find( s, aIOR )) + geomClient->RemoveShapeFromBuffer( aIOR ); + } + + // clear buffer also for sub-meshes + std::map::const_iterator aSubMeshIter = _mapSubMesh_i.cbegin(); + for(; aSubMeshIter != _mapSubMesh_i.cend(); aSubMeshIter++) { + int aShapeID = aSubMeshIter->first; + const TopoDS_Shape& aSubShape = meshDS->IndexToShape(aShapeID); + TCollection_AsciiString aShapeIOR; + if ( geomClient->Find( aSubShape, aShapeIOR )) + geomClient->RemoveShapeFromBuffer( aShapeIOR ); + } + + typedef struct { + int shapeID; smIdType fromID, toID; // indices of elements of a sub-mesh + } TRange; + std::vector< TRange > elemRanges, nodeRanges; // elements of sub-meshes + std::vector< SMDS_PositionPtr > positions; // node positions + if ( !geomChanged ) + { + // store positions of elements on geometry + Load(); + if ( meshDS->MaxNodeID() > meshDS->NbNodes() || + meshDS->MaxElementID() > meshDS->NbElements() ) + { + meshDS->Modified(); + meshDS->CompactMesh(); + } + positions.resize( meshDS->NbNodes() + 1 ); + for ( SMDS_NodeIteratorPtr nodeIt = meshDS->nodesIterator(); nodeIt->more(); ) + { + const SMDS_MeshNode* n = nodeIt->next(); + positions[ n->GetID() ] = n->GetPosition(); + } + + // remove elements from sub-meshes to avoid their removal at hypotheses addition + for ( int isNode = 0; isNode < 2; ++isNode ) + { + std::vector< TRange > & ranges = isNode ? nodeRanges : elemRanges; + ranges.reserve( meshDS->MaxShapeIndex() + 10 ); + ranges.push_back( TRange{ 0,0,0 }); + SMDS_ElemIteratorPtr elemIt = meshDS->elementsIterator( isNode ? SMDSAbs_Node : SMDSAbs_All ); + while ( elemIt->more() ) + { + const SMDS_MeshElement* e = elemIt->next(); + const smIdType elemID = e->GetID(); + const int shapeID = e->GetShapeID(); + TRange & lastRange = ranges.back(); + if ( lastRange.shapeID != shapeID || + lastRange.toID != elemID ) + ranges.push_back( TRange{ shapeID, elemID, elemID + 1 }); + else + lastRange.toID = elemID + 1; + + if ( SMESHDS_SubMesh* sm = meshDS->MeshElements( shapeID )) + { + if ( isNode ) sm->RemoveNode( static_cast< const SMDS_MeshNode *>( e )); + else sm->RemoveElement( e ); + } + } + } + } + + + // update the reference to theNewGeom (needed for correct execution of a dumped python script) + SMESH::SMESH_Mesh_var me = _this(); + SALOMEDS::SObject_wrap aSO = _gen_i->ObjectToSObject( me ); + CORBA::String_var entry = theNewGeom->GetStudyEntry(); + if ( !aSO->_is_nil() ) + { + SALOMEDS::SObject_wrap aShapeRefSO; + if ( aSO->FindSubObject( _gen_i->GetRefOnShapeTag(), aShapeRefSO.inout() )) + { + SALOMEDS::SObject_wrap aShapeSO = _gen_i->getStudyServant()->FindObjectID( entry ); + SALOMEDS::StudyBuilder_var builder = _gen_i->getStudyServant()->NewBuilder(); + builder->Addreference( aShapeRefSO, aShapeSO ); + } + } + + // re-assign global hypotheses to the new shape + _mainShapeTick = geomChanged ? -1 : theNewGeom->GetTick(); + CheckGeomModif( true ); + + if ( !geomChanged ) + { + // restore positions of elements on geometry + for ( int isNode = 0; isNode < 2; ++isNode ) + { + std::vector< TRange > & ranges = isNode ? nodeRanges : elemRanges; + for ( size_t i = 1; i < ranges.size(); ++i ) + { + int elemID = ranges[ i ].fromID; + int toID = ranges[ i ].toID; + SMESHDS_SubMesh * smDS = meshDS->NewSubMesh( ranges[ i ].shapeID ); + if ( isNode ) + for ( ; elemID < toID; ++elemID ) + smDS->AddNode( meshDS->FindNode( elemID )); + else + for ( ; elemID < toID; ++elemID ) + smDS->AddElement( meshDS->FindElement( elemID )); + + if ( SMESH_subMesh* sm = _impl->GetSubMeshContaining( ranges[ i ].shapeID )) + sm->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE ); + } + } + for ( unsigned int nodeID = 1; nodeID < positions.size(); ++nodeID ) + if ( positions[ nodeID ]) + if ( SMDS_MeshNode* n = const_cast< SMDS_MeshNode*>( meshDS->FindNode( nodeID ))) + n->SetPosition( positions[ nodeID ], n->GetShapeID() ); + + // restore icons + _gen_i->UpdateIcons( SMESH::SMESH_Mesh_var( _this() )); + } + + TPythonDump() << "SHAPERSTUDY.breakLinkForSubElements(salome.ObjectToSObject(" + << me <<".GetMesh()), " << entry.in() << ")"; + + TPythonDump() << me << ".ReplaceShape( " << entry.in() << " )"; + +} + //================================================================================ /*! * \brief Return new group contents if it has been changed and update group data */ //================================================================================ -TopoDS_Shape SMESH_Mesh_i::newGroupShape( TGeomGroupData & groupData) +enum { ONLY_IF_CHANGED, IS_BREAK_LINK, MAIN_TRANSFORMED }; + +TopoDS_Shape SMESH_Mesh_i::newGroupShape( TGeomGroupData & groupData, int how ) { TopoDS_Shape newShape; + SALOMEDS::SObject_wrap groupSO; - // get geom group - SALOMEDS::SObject_wrap groupSO = SMESH_Gen_i::getStudyServant()->FindObjectID( groupData._groupEntry.c_str() ); - if ( !groupSO->_is_nil() ) + if ( how == IS_BREAK_LINK ) { - CORBA::Object_var groupObj = _gen_i->SObjectToObject( groupSO ); - if ( CORBA::is_nil( groupObj )) return newShape; - GEOM::GEOM_Object_var geomGroup = GEOM::GEOM_Object::_narrow( groupObj ); + SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( groupData._smeshObject ); + SALOMEDS::SObject_wrap geomRefSO; + if ( !meshSO->_is_nil() && + meshSO->FindSubObject( SMESH::Tag_RefOnShape, geomRefSO.inout() )) + { + geomRefSO->ReferencedObject( groupSO.inout() ); + } + } + else + { + // get geom group + groupSO = _gen_i->getStudyServant()->FindObjectID( groupData._groupEntry.c_str() ); + } - // get indices of group items - set curIndices; - GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine(); - GEOM::GEOM_IGroupOperations_wrap groupOp = - geomGen->GetIGroupOperations(); - GEOM::ListOfLong_var ids = groupOp->GetObjects( geomGroup ); - for ( CORBA::ULong i = 0; i < ids->length(); ++i ) - curIndices.insert( ids[i] ); + if ( groupSO->_is_nil() ) + return newShape; + + CORBA::Object_var groupObj = _gen_i->SObjectToObject( groupSO ); + GEOM::GEOM_Object_var geomGroup = GEOM::GEOM_Object::_narrow( groupObj ); + if ( geomGroup->_is_nil() ) + return newShape; + + // get indices of group items + set curIndices; + GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine( geomGroup ); + GEOM::GEOM_IGroupOperations_wrap groupOp = geomGen->GetIGroupOperations(); + GEOM::ListOfLong_var ids = groupOp->GetObjects( geomGroup ); + for ( CORBA::ULong i = 0; i < ids->length(); ++i ) + curIndices.insert( ids[i] ); - if ( groupData._indices == curIndices ) - return newShape; // group not changed + bool sameIndices = ( groupData._indices == curIndices ); + if ( how == ONLY_IF_CHANGED && sameIndices ) + return newShape; // group not changed - // update data - groupData._indices = curIndices; + // update data + CORBA::String_var entry = geomGroup->GetStudyEntry(); + groupData._groupEntry = entry.in(); + groupData._indices = curIndices; - GEOM_Client* geomClient = _gen_i->GetShapeReader(); - if ( !geomClient ) return newShape; - CORBA::String_var groupIOR = geomGen->GetStringFromIOR( geomGroup ); - geomClient->RemoveShapeFromBuffer( groupIOR.in() ); - newShape = _gen_i->GeomObjectToShape( geomGroup ); - } + newShape = _gen_i->GeomObjectToShape( geomGroup ); - if ( newShape.IsNull() ) { + // check if newShape is up-to-date + if ( !newShape.IsNull() && ids->length() > 0 ) + { + bool toUpdate = ! _impl->GetMeshDS()->IsGroupOfSubShapes( newShape ); + if ( !toUpdate ) + { + TopExp_Explorer exp( newShape, (TopAbs_ShapeEnum)( groupOp->GetType( geomGroup ))); + for ( ; exp.More() && !toUpdate; exp.Next() ) + { + int ind = _impl->GetMeshDS()->ShapeToIndex( exp.Current() ); + toUpdate = ( curIndices.erase( ind ) == 0 ); + } + if ( !curIndices.empty() ) + toUpdate = true; + } + if ( toUpdate ) + { + GEOM_Client* geomClient = _gen_i->GetShapeReader(); + CORBA::String_var groupIOR = geomGen->GetStringFromIOR( geomGroup ); + geomClient->RemoveShapeFromBuffer( groupIOR.in() ); + newShape = _gen_i->GeomObjectToShape( geomGroup ); + } + } + else + { // geom group becomes empty - return empty compound TopoDS_Compound compound; BRep_Builder().MakeCompound(compound); newShape = compound; } + return newShape; } @@ -1974,11 +2281,66 @@ namespace struct TGroupOnGeomData { int _oldID; - int _shapeID; + TopoDS_Shape _shape; SMDSAbs_ElementType _type; std::string _name; Quantity_Color _color; + + TGroupOnGeomData( const SMESHDS_GroupOnGeom* group ) + { + _oldID = group->GetID(); + _type = group->GetType(); + _name = group->GetStoreName(); + _color = group->GetColor(); + } }; + + //----------------------------------------------------------------------------- + /*! + * \brief Check if a filter is still valid after geometry removal + */ + bool isValidGeomFilter( SMESH::Filter_var theFilter ) + { + if ( theFilter->_is_nil() ) + return false; + SMESH::Filter::Criteria_var criteria; + theFilter->GetCriteria( criteria.out() ); + + for ( CORBA::ULong iCr = 0; iCr < criteria->length(); ++iCr ) + { + const char* thresholdID = criteria[ iCr ].ThresholdID.in(); + std::string entry; + switch ( criteria[ iCr ].Type ) + { + case SMESH::FT_BelongToGeom: + case SMESH::FT_BelongToPlane: + case SMESH::FT_BelongToCylinder: + case SMESH::FT_BelongToGenSurface: + case SMESH::FT_LyingOnGeom: + entry = thresholdID; + break; + case SMESH::FT_ConnectedElements: + if ( thresholdID ) + { + entry = thresholdID; + break; + } + default: + continue; + } + SMESH_Gen_i* gen = SMESH_Gen_i::GetSMESHGen(); + SALOMEDS::SObject_wrap so = gen->getStudyServant()->FindObjectID( entry.c_str() ); + if ( so->_is_nil() ) + return false; + CORBA::Object_var obj = so->GetObject(); + GEOM::GEOM_Object_var geom = GEOM::GEOM_Object::_narrow( obj ); + if ( gen->GeomObjectToShape( geom ).IsNull() ) + return false; + + } // loop on criteria + + return true; + } } //============================================================================= @@ -1989,64 +2351,164 @@ namespace */ //============================================================================= -void SMESH_Mesh_i::CheckGeomModif() +void SMESH_Mesh_i::CheckGeomModif( bool theIsBreakLink ) { - if ( !_impl->HasShapeToMesh() ) return; + SMESH::SMESH_Mesh_var me = _this(); + GEOM::GEOM_Object_var mainGO = GetShapeToMesh(); - GEOM::GEOM_Object_var mainGO = _gen_i->ShapeToGeomObject( _impl->GetShapeToMesh() ); - //if ( mainGO->_is_nil() ) return; + TPythonDump dumpNothing; // prevent any dump - // Update after group modification + //bool removedFromClient = false; - if ( mainGO->_is_nil() || /* shape was removed from GEOM_Client by newGroupShape() - called by other mesh (IPAL52735) */ - mainGO->GetType() == GEOM_GROUP || - mainGO->GetTick() == _mainShapeTick ) + if ( mainGO->_is_nil() ) // GEOM_Client cleared or geometry removed? (IPAL52735, PAL23636) { - CheckGeomGroupModif(); - return; + //removedFromClient = _impl->HasShapeToMesh(); + + // try to find geometry by study reference + SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( me ); + SALOMEDS::SObject_wrap geomRefSO, geomSO; + if ( !meshSO->_is_nil() && + meshSO->FindSubObject( SMESH::Tag_RefOnShape, geomRefSO.inout() ) && + geomRefSO->ReferencedObject( geomSO.inout() )) + { + CORBA::Object_var geomObj = _gen_i->SObjectToObject( geomSO ); + mainGO = GEOM::GEOM_Object::_narrow( geomObj ); + } + + if ( mainGO->_is_nil() && // geometry removed ==> + !geomRefSO->_is_nil() ) // remove geom dependent data: sub-meshes etc. + { + // convert geom dependent groups into standalone ones + CheckGeomGroupModif(); + + _impl->ShapeToMesh( TopoDS_Shape() ); + + // remove sub-meshes + std::map::iterator i_sm = _mapSubMeshIor.begin(); + while ( i_sm != _mapSubMeshIor.end() ) + { + SMESH::SMESH_subMesh_ptr sm = i_sm->second; + ++i_sm; + RemoveSubMesh( sm ); + } + // remove all children except groups in the study + SALOMEDS::StudyBuilder_var builder = _gen_i->getStudyServant()->NewBuilder(); + SALOMEDS::SObject_wrap so; + for ( CORBA::Long tag = SMESH::Tag_RefOnShape; tag <= SMESH::Tag_LastSubMesh; ++tag ) + if ( meshSO->FindSubObject( tag, so.inout() )) + builder->RemoveObjectWithChildren( so ); + + _gen_i->SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED" ); + + return; + } } - // Update after shape transformation like Translate + if ( !_impl->HasShapeToMesh() ) return; + + + // Update after group modification + + const bool geomChanged = ( mainGO->GetTick() != _mainShapeTick ); + if ( !theIsBreakLink ) + if ( mainGO->GetType() == GEOM_GROUP || !geomChanged ) // is group or not modified + { + smIdType nb = NbNodes() + NbElements(); + CheckGeomGroupModif(); + if ( nb != NbNodes() + NbElements() ) // something removed due to hypotheses change + _gen_i->UpdateIcons( me ); + return; + } + + // Update after shape modification or breakLink w/o geometry change GEOM_Client* geomClient = _gen_i->GetShapeReader(); if ( !geomClient ) return; - GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine(); + GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine( mainGO ); if ( geomGen->_is_nil() ) return; + CORBA::String_var geomComponentType = geomGen->ComponentDataType(); + bool isShaper = ( strcmp( geomComponentType.in(), "SHAPERSTUDY" ) == 0 ); - CORBA::String_var ior = geomGen->GetStringFromIOR( mainGO ); - geomClient->RemoveShapeFromBuffer( ior.in() ); + SMESHDS_Mesh * meshDS = _impl->GetMeshDS(); - // Update data taking into account that + TopoDS_Shape newShape = _gen_i->GeomObjectToShape( mainGO ); + if ( meshDS->ShapeToIndex( newShape ) == 1 ) // not yet updated + { + CORBA::String_var ior = geomGen->GetStringFromIOR( mainGO ); + geomClient->RemoveShapeFromBuffer( ior.in() ); + newShape = _gen_i->GeomObjectToShape( mainGO ); + } + + // Update data taking into account that if topology doesn't change // all sub-shapes change but IDs of sub-shapes remain (except for geom groups) - _impl->Clear(); - TopoDS_Shape newShape = _gen_i->GeomObjectToShape( mainGO ); + if ( _preMeshInfo ) + _preMeshInfo->ForgetAllData(); + + if ( geomChanged || !isShaper ) + _impl->Clear(); if ( newShape.IsNull() ) return; _mainShapeTick = mainGO->GetTick(); - SMESHDS_Mesh * meshDS = _impl->GetMeshDS(); - - // store data of groups on geometry - vector< TGroupOnGeomData > groupsData; - const set& groups = meshDS->GetGroups(); + // store data of groups on geometry including new TopoDS_Shape's + std::vector< TGroupOnGeomData > groupsData; + const std::set& groups = meshDS->GetGroups(); groupsData.reserve( groups.size() ); - set::const_iterator g = groups.begin(); + TopTools_DataMapOfShapeShape old2newShapeMap; + std::set::const_iterator g = groups.begin(); for ( ; g != groups.end(); ++g ) + { if ( const SMESHDS_GroupOnGeom* group = dynamic_cast< SMESHDS_GroupOnGeom* >( *g )) { - TGroupOnGeomData data; - data._oldID = group->GetID(); - data._shapeID = meshDS->ShapeToIndex( group->GetShape() ); - data._type = group->GetType(); - data._name = group->GetStoreName(); - data._color = group->GetColor(); - groupsData.push_back( data ); + groupsData.push_back( TGroupOnGeomData( group )); + + // get a new shape + SMESH::SMESH_GroupOnGeom_var gog; + std::map::iterator i_grp = _mapGroups.find( group->GetID() ); + if ( i_grp != _mapGroups.end() ) + gog = SMESH::SMESH_GroupOnGeom::_narrow( i_grp->second ); + + GEOM::GEOM_Object_var geom; + if ( !gog->_is_nil() ) + { + if ( !theIsBreakLink ) + geom = gog->GetShape(); + + if ( theIsBreakLink || geom->_is_nil() ) + { + SALOMEDS::SObject_wrap grpSO = _gen_i->ObjectToSObject( gog ); + SALOMEDS::SObject_wrap geomRefSO, geomSO; + if ( !grpSO->_is_nil() && + grpSO->FindSubObject( SMESH::Tag_RefOnShape, geomRefSO.inout() ) && + geomRefSO->ReferencedObject( geomSO.inout() )) + { + CORBA::Object_var geomObj = _gen_i->SObjectToObject( geomSO ); + geom = GEOM::GEOM_Object::_narrow( geomObj ); + } + } + } + if ( old2newShapeMap.IsBound( group->GetShape() )) + { + groupsData.back()._shape = old2newShapeMap( group->GetShape() ); + } + else if ( !geom->_is_nil() ) + { + groupsData.back()._shape = _gen_i->GeomObjectToShape( geom ); + if ( meshDS->IsGroupOfSubShapes( groupsData.back()._shape )) + { + CORBA::String_var ior = geomGen->GetStringFromIOR( geom ); + geomClient->RemoveShapeFromBuffer( ior.in() ); + groupsData.back()._shape = _gen_i->GeomObjectToShape( geom ); + } + old2newShapeMap.Bind( group->GetShape(), groupsData.back()._shape ); + } + } + } // store assigned hypotheses - vector< pair< int, THypList > > ids2Hyps; + std::vector< pair< int, THypList > > ids2Hyps; const ShapeToHypothesis & hyps = meshDS->GetHypotheses(); for ( ShapeToHypothesis::Iterator s2hyps( hyps ); s2hyps.More(); s2hyps.Next() ) { @@ -2055,75 +2517,175 @@ void SMESH_Mesh_i::CheckGeomModif() ids2Hyps.push_back( make_pair( meshDS->ShapeToIndex( s ), hyps )); } - // change shape to mesh + std::multimap< std::set, int > ii2iMap; // group sub-ids to group id in SMESHDS + + // count shapes excluding compounds corresponding to geom groups int oldNbSubShapes = meshDS->MaxShapeIndex(); + for ( ; oldNbSubShapes > 0; --oldNbSubShapes ) + { + const TopoDS_Shape& s = meshDS->IndexToShape( oldNbSubShapes ); + if ( s.IsNull() || s.ShapeType() != TopAbs_COMPOUND ) + break; + // fill ii2iMap + std::set subIds; + for ( TopoDS_Iterator it( s ); it.More(); it.Next() ) + subIds.insert( meshDS->ShapeToIndex( it.Value() )); + ii2iMap.insert( std::make_pair( subIds, oldNbSubShapes )); + } + + // check if shape topology changes - save shape type per shape ID + std::vector< TopAbs_ShapeEnum > shapeTypes( Max( oldNbSubShapes + 1, 1 )); + for ( int shapeID = oldNbSubShapes; shapeID > 0; --shapeID ) + shapeTypes[ shapeID ] = meshDS->IndexToShape( shapeID ).ShapeType(); + + // change shape to mesh _impl->ShapeToMesh( TopoDS_Shape() ); _impl->ShapeToMesh( newShape ); - // re-add shapes of geom groups - list::iterator data = _geomGroupData.begin(); - for ( ; data != _geomGroupData.end(); ++data ) + // check if shape topology changes - check new shape types + bool sameTopology = ( oldNbSubShapes == meshDS->MaxShapeIndex() ); + for ( int shapeID = oldNbSubShapes; shapeID > 0 && sameTopology; --shapeID ) + { + const TopoDS_Shape& s = meshDS->IndexToShape( shapeID ); + sameTopology = ( !s.IsNull() && s.ShapeType() == shapeTypes[ shapeID ]); + } + + // re-add shapes (compounds) of geom groups + typedef std::map< std::vector< int >, TGeomGroupData* > TIndices2GroupData; + TIndices2GroupData ii2grData; + std::vector< int > ii; + std::map< int, int > old2newIDs; // group IDs + std::list::iterator dataIt = _geomGroupData.begin(); + for ( ; dataIt != _geomGroupData.end(); ++dataIt ) { - TopoDS_Shape newShape = newGroupShape( *data ); + TGeomGroupData* data = &(*dataIt); + ii.reserve( data->_indices.size() ); + ii.assign( data->_indices.begin(), data->_indices.end() ); + TIndices2GroupData::iterator ii2gd = ii2grData.insert( std::make_pair( ii, data )).first; + if ( ii2gd->second != data ) + { + data->_groupEntry = ii2gd->second->_groupEntry; + data->_indices = ii2gd->second->_indices; + continue; + } + const int oldNbSub = data->_indices.size(); + const int soleOldID = oldNbSub == 1 ? *data->_indices.begin() : 0; + int oldID = 0; + std::multimap< std::set, int >::iterator ii2i = ii2iMap.find( data->_indices ); + if ( ii2i != ii2iMap.end() ) + { + oldID = ii2i->second; + ii2iMap.erase( ii2i ); + } + if ( !oldID && oldNbSub == 1 ) + oldID = soleOldID; + if ( old2newIDs.count( oldID )) + continue; + + int how = ( theIsBreakLink || !sameTopology ) ? IS_BREAK_LINK : MAIN_TRANSFORMED; + newShape = newGroupShape( *data, how ); + if ( !newShape.IsNull() ) { - if ( meshDS->ShapeToIndex( newShape ) > 0 ) // a group reduced to one sub-shape + if ( oldNbSub > 1 && meshDS->ShapeToIndex( newShape ) > 0 ) // group reduced to one sub-shape { TopoDS_Compound compound; BRep_Builder().MakeCompound( compound ); BRep_Builder().Add( compound, newShape ); newShape = compound; } - _impl->GetSubMesh( newShape ); + int newID = _impl->GetSubMesh( newShape )->GetId(); + if ( oldID /*&& oldID != newID*/ ) + old2newIDs.insert( std::make_pair( oldID, newID )); + if ( oldNbSub == 1 ) + old2newIDs.insert( std::make_pair( soleOldID, newID )); } } - if ( oldNbSubShapes != meshDS->MaxShapeIndex() ) - THROW_SALOME_CORBA_EXCEPTION( "SMESH_Mesh_i::CheckGeomModif() bug", - SALOME::INTERNAL_ERROR ); // re-assign hypotheses for ( size_t i = 0; i < ids2Hyps.size(); ++i ) { - const TopoDS_Shape& s = meshDS->IndexToShape( ids2Hyps[i].first ); - const THypList& hyps = ids2Hyps[i].second; + int sID = ids2Hyps[i].first; + if ( sID != 1 ) + { + std::map< int, int >::iterator o2n = old2newIDs.find( sID ); + if ( o2n != old2newIDs.end() ) + sID = o2n->second; + else if ( !sameTopology ) + continue; + } + const TopoDS_Shape& s = meshDS->IndexToShape( sID ); + if ( s.IsNull() ) + continue; + const THypList& hyps = ids2Hyps[i].second; THypList::const_iterator h = hyps.begin(); for ( ; h != hyps.end(); ++h ) _impl->AddHypothesis( s, (*h)->GetID() ); } - // restore groups - for ( size_t i = 0; i < groupsData.size(); ++i ) { - const TGroupOnGeomData& data = groupsData[i]; + // restore groups on geometry + for ( size_t i = 0; i < groupsData.size(); ++i ) + { + const TGroupOnGeomData& data = groupsData[i]; + if ( data._shape.IsNull() ) + continue; - map::iterator i2g = _mapGroups.find( data._oldID ); - if ( i2g == _mapGroups.end() ) continue; + std::map::iterator i2g = _mapGroups.find( data._oldID ); + if ( i2g == _mapGroups.end() ) continue; - SMESH_GroupBase_i* gr_i = SMESH::DownCast( i2g->second ); - if ( !gr_i ) continue; + SMESH_GroupBase_i* gr_i = SMESH::DownCast( i2g->second ); + if ( !gr_i ) continue; - int id; - SMESH_Group* g = _impl->AddGroup( data._type, data._name.c_str(), id, - meshDS->IndexToShape( data._shapeID )); - if ( !g ) - { - _mapGroups.erase( i2g ); + SMESH_Group* g = _impl->AddGroup( data._type, data._name.c_str(), data._oldID, data._shape ); + if ( !g ) + _mapGroups.erase( i2g ); + else + g->GetGroupDS()->SetColor( data._color ); } - else + + if ( !sameTopology ) { - g->GetGroupDS()->SetColor( data._color ); - gr_i->changeLocalId( id ); - _mapGroups[ id ] = i2g->second; - if ( data._oldID != id ) - _mapGroups.erase( i2g ); + std::map< int, int >::iterator o2n = old2newIDs.begin(); + for ( ; o2n != old2newIDs.end(); ++o2n ) + { + int newID = o2n->second, oldID = o2n->first; + if ( newID == oldID || !_mapSubMesh.count( oldID )) + continue; + if ( newID > 0 ) + { + _mapSubMesh [ newID ] = _impl->GetSubMeshContaining( newID ); + _mapSubMesh_i [ newID ] = _mapSubMesh_i [ oldID ]; + _mapSubMeshIor[ newID ] = _mapSubMeshIor[ oldID ]; + } + _mapSubMesh. erase(oldID); + _mapSubMesh_i. erase(oldID); + _mapSubMeshIor.erase(oldID); + if ( newID > 0 ) + _mapSubMesh_i [ newID ]->changeLocalId( newID ); + } } + + // update _mapSubMesh + std::map::iterator i_sm = _mapSubMesh.begin(); + for ( ; i_sm != _mapSubMesh.end(); ++i_sm ) + i_sm->second = _impl->GetSubMesh( meshDS->IndexToShape( i_sm->first )); } - // update _mapSubMesh - map::iterator i_sm = _mapSubMesh.begin(); - for ( ; i_sm != _mapSubMesh.end(); ++i_sm ) - i_sm->second = _impl->GetSubMesh( meshDS->IndexToShape( i_sm->first )); + if ( !sameTopology ) + { + // remove invalid study sub-objects + CheckGeomGroupModif(); + } + _gen_i->UpdateIcons( me ); + + if ( !theIsBreakLink && isShaper ) + { + SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( me ); + if ( !meshSO->_is_nil() ) + _gen_i->SetPixMap(meshSO, "ICON_SMESH_TREE_GEOM_MODIF"); + } } //============================================================================= @@ -2137,9 +2699,109 @@ void SMESH_Mesh_i::CheckGeomModif() void SMESH_Mesh_i::CheckGeomGroupModif() { + // remove sub-meshes referring a removed sub-shapes (if main shape still exists) + SALOMEDS::StudyBuilder_var builder = _gen_i->getStudyServant()->NewBuilder(); + GEOM::GEOM_Object_var mainGO = GetShapeToMesh(); + SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( SMESH::SMESH_Mesh_var( _this() )); + if ( !mainGO->_is_nil() && !meshSO->_is_nil() ) + { + SALOMEDS::SObject_wrap rootSO, geomRefSO, geomSO; + for ( CORBA::Long tag = SMESH::Tag_FirstSubMesh; tag <= SMESH::Tag_LastSubMesh; ++tag ) + if ( meshSO->FindSubObject( tag, rootSO.inout() )) + { + int nbValid = 0, nbRemoved = 0; + SALOMEDS::ChildIterator_wrap chItr = _gen_i->getStudyServant()->NewChildIterator( rootSO ); + for ( ; chItr->More(); chItr->Next() ) + { + SALOMEDS::SObject_wrap smSO = chItr->Value(); // sub-mesh SO + if ( !smSO->_is_nil() && + smSO->FindSubObject( SMESH::Tag_RefOnShape, geomRefSO.inout() ) && + geomRefSO->ReferencedObject( geomSO.inout() )) // find geometry by reference + { + CORBA::Object_var geomObj = _gen_i->SObjectToObject( geomSO ); + GEOM::GEOM_Object_var geom = GEOM::GEOM_Object::_narrow( geomObj ); + if ( !geom->_non_existent() ) + { + ++nbValid; + continue; // keep the sub-mesh + } + } + CORBA::Object_var smObj = _gen_i->SObjectToObject( smSO ); + SMESH::SMESH_subMesh_var sm = SMESH::SMESH_subMesh::_narrow( smObj ); + if ( !sm->_is_nil() && !sm->_non_existent() ) + { + GEOM::GEOM_Object_var smGeom = sm->GetSubShape(); + if ( smGeom->_is_nil() ) + { + RemoveSubMesh( sm ); + ++nbRemoved; + } + } + else + { + if ( _preMeshInfo ) + _preMeshInfo->ForgetAllData(); // unknown hypothesis modified + builder->RemoveObjectWithChildren( smSO ); // sub-shape removed before loading SMESH + ++nbRemoved; + } + } + if ( /*nbRemoved > 0 &&*/ nbValid == 0 ) + builder->RemoveObjectWithChildren( rootSO ); + } + } + + // check for removed sub-shapes and convert geom dependent groups into standalone ones + std::map::iterator i_gr = _mapGroups.begin(); + while ( i_gr != _mapGroups.end()) + { + SMESH::SMESH_GroupBase_ptr group = i_gr->second; + ++i_gr; + SALOMEDS::SObject_wrap groupSO = _gen_i->ObjectToSObject( group ), refSO, geomSO; + SMESH::SMESH_GroupOnGeom_var onGeom = SMESH::SMESH_GroupOnGeom::_narrow ( group ); + SMESH::SMESH_GroupOnFilter_var onFilt = SMESH::SMESH_GroupOnFilter::_narrow( group ); + bool isValidGeom = false; + if ( !onGeom->_is_nil() ) + { + isValidGeom = ( ! GEOM::GEOM_Object_var( onGeom->GetShape() )->_is_nil() ); // check TopoDS + if ( !isValidGeom ) // check reference + { + isValidGeom = ( ! groupSO->_is_nil() && + groupSO->FindSubObject( SMESH::Tag_RefOnShape, refSO.inout() ) && + refSO->ReferencedObject( geomSO.inout() ) && + ! geomSO->_is_nil() && + !CORBA::is_nil( CORBA::Object_var( geomSO->GetObject() ))); + } + } + else if ( !onFilt->_is_nil() ) + { + isValidGeom = isValidGeomFilter( onFilt->GetFilter() ); + } + else // standalone + { + isValidGeom = ( !groupSO->_is_nil() && + !groupSO->FindSubObject( SMESH::Tag_RefOnShape, refSO.inout() )); + } + if ( !isValidGeom ) + { + if ( !IsLoaded() || group->IsEmpty() ) + { + RemoveGroup( group ); + } + else if ( !onGeom->_is_nil() || !onFilt->_is_nil() ) + { + SMESH::SMESH_Group_var ( ConvertToStandalone( group )); + } + else // is it possible? + { + builder->RemoveObjectWithChildren( refSO ); + } + } + } + + if ( !_impl->HasShapeToMesh() ) return; - CORBA::Long nbEntities = NbNodes() + NbElements(); + SMESH::smIdType nbEntities = NbNodes() + NbElements(); // Check if group contents changed @@ -2155,7 +2817,7 @@ void SMESH_Mesh_i::CheckGeomGroupModif() bool processedGroup = !it_new.second; TopoDS_Shape& newShape = it_new.first->second; if ( !processedGroup ) - newShape = newGroupShape( *data ); + newShape = newGroupShape( *data, ONLY_IF_CHANGED ); if ( newShape.IsNull() ) continue; // no changes @@ -2283,7 +2945,7 @@ void SMESH_Mesh_i::CheckGeomGroupModif() groupData.push_back ( make_pair( TIndexedShape( gog->GetID(),gog->GetShape()), gog->GetType())); } - // set new shape to mesh -> DS of sub-meshes and geom groups are deleted + // set new shape to mesh -> DS of sub-meshes and geom groups is deleted _impl->Clear(); _impl->ShapeToMesh( TopoDS_Shape() ); // IPAL52730 _impl->ShapeToMesh( newShape ); @@ -2328,10 +2990,10 @@ void SMESH_Mesh_i::CheckGeomGroupModif() SALOMEDS::SObject_wrap groupSO = _gen_i->ObjectToSObject( _mapGroups[oldID] ); CORBA::String_var name = groupSO->GetName(); // update - SMESH_GroupBase_i* group_i = SMESH::DownCast(_mapGroups[oldID] ); - int newID; - if ( group_i && _impl->AddGroup( geomType->second, name.in(), newID, geom._shape )) - group_i->changeLocalId( newID ); + if ( SMESH_GroupBase_i* group_i = SMESH::DownCast(_mapGroups[oldID])) + if ( SMESH_Group* group = _impl->AddGroup( geomType->second, name.in(), + /*id=*/-1, geom._shape )) + group_i->changeLocalId( group->GetID() ); } break; // everything has been updated @@ -2341,7 +3003,7 @@ void SMESH_Mesh_i::CheckGeomGroupModif() // Update icons - CORBA::Long newNbEntities = NbNodes() + NbElements(); + SMESH::smIdType newNbEntities = NbNodes() + NbElements(); list< SALOMEDS::SObject_wrap > soToUpdateIcons; if ( newNbEntities != nbEntities ) { @@ -2369,7 +3031,6 @@ void SMESH_Mesh_i::CheckGeomGroupModif() //============================================================================= SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroup ) - throw (SALOME::SALOME_Exception) { SMESH::SMESH_Group_var aGroup; @@ -2400,7 +3061,7 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase SALOMEDS::StudyBuilder_var builder; SALOMEDS::SObject_wrap aGroupSO; - SALOMEDS::Study_var aStudy = SMESH_Gen_i::getStudyServant(); + SALOMEDS::Study_var aStudy = SMESH_Gen_i::GetSMESHGen()->getStudyServant(); if ( !aStudy->_is_nil() ) { builder = aStudy->NewBuilder(); aGroupSO = _gen_i->ObjectToSObject( theGroup ); @@ -2409,9 +3070,11 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase // remove reference to geometry SALOMEDS::ChildIterator_wrap chItr = aStudy->NewChildIterator(aGroupSO); for ( ; chItr->More(); chItr->Next() ) + { // Remove group's child SObject - builder->RemoveObject( chItr->Value() ); - + SALOMEDS::SObject_wrap so = chItr->Value(); + builder->RemoveObject( so ); + } // Update Python script TPythonDump() << aGroupSO << " = " << SMESH::SMESH_Mesh_var(_this()) << ".ConvertToStandalone( " << aGroupSO << " )"; @@ -2419,9 +3082,9 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase // change icon of Group on Filter if ( isOnFilter ) { - SMESH::array_of_ElementType_var elemTypes = aGroupImpl->GetTypes(); - const int isEmpty = ( elemTypes->length() == 0 ); - if ( !isEmpty ) + // SMESH::array_of_ElementType_var elemTypes = aGroupImpl->GetTypes(); + // const int isEmpty = ( elemTypes->length() == 0 ); + // if ( !isEmpty ) { SALOMEDS::GenericAttribute_wrap anAttr = builder->FindOrCreateAttribute( aGroupSO, "AttributePixMap" ); @@ -2449,20 +3112,36 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase return aGroup._retn(); } -//============================================================================= +//================================================================================ /*! - * + * \brief Create a sub-mesh on a given sub-shape */ -//============================================================================= +//================================================================================ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::createSubMesh( GEOM::GEOM_Object_ptr theSubShapeObject ) { if(MYDEBUG) MESSAGE( "createSubMesh" ); TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(theSubShapeObject); ::SMESH_subMesh * mySubMesh = _impl->GetSubMesh(myLocSubShape); - const int subMeshId = mySubMesh->GetId(); + int subMeshId = 0; + + SMESH_subMesh_i * subMeshServant; + if ( mySubMesh ) + { + subMeshId = mySubMesh->GetId(); + subMeshServant = new SMESH_subMesh_i(myPOA, _gen_i, this, subMeshId); + } + else // "invalid sub-mesh" + { + // The invalid sub-mesh is created for the case where a valid sub-shape not found + // by SMESH_Gen_i::CopyMeshWithGeom(). The invalid sub-mesh has GetId() < 0. + if ( _mapSubMesh.empty() ) + subMeshId = -1; + else + subMeshId = _mapSubMesh.begin()->first - 1; + subMeshServant = new SMESH_Invalid_subMesh_i(myPOA, _gen_i, this, subMeshId, theSubShapeObject); + } - SMESH_subMesh_i * subMeshServant = new SMESH_subMesh_i(myPOA, _gen_i, this, subMeshId); SMESH::SMESH_subMesh_var subMesh = subMeshServant->_this(); _mapSubMesh [subMeshId] = mySubMesh; @@ -2474,18 +3153,20 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::createSubMesh( GEOM::GEOM_Object_ptr theS // register CORBA object for persistence int nextId = _gen_i->RegisterObject( subMesh ); if(MYDEBUG) { MESSAGE( "Add submesh to map with id = "<< nextId); } - else { nextId = 0; } // avoid "unused variable" warning + else { (void)nextId; } // avoid "unused variable" warning // to track changes of GEOM groups - addGeomGroupData( theSubShapeObject, subMesh ); + if ( subMeshId > 0 ) + addGeomGroupData( theSubShapeObject, subMesh ); return subMesh._retn(); } -//======================================================================= -//function : getSubMesh -//purpose : -//======================================================================= +//================================================================================ +/*! + * \brief Return an existing sub-mesh based on a sub-shape with the given ID + */ +//================================================================================ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::getSubMesh(int shapeID) { @@ -2496,11 +3177,11 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::getSubMesh(int shapeID) return SMESH::SMESH_subMesh::_duplicate( (*it).second ); } -//============================================================================= +//================================================================================ /*! - * + * \brief Remove a sub-mesh based on the given sub-shape */ -//============================================================================= +//================================================================================ bool SMESH_Mesh_i::removeSubMesh (SMESH::SMESH_subMesh_ptr theSubMesh, GEOM::GEOM_Object_ptr theSubShapeObject ) @@ -2513,13 +3194,17 @@ bool SMESH_Mesh_i::removeSubMesh (SMESH::SMESH_subMesh_ptr theSubMesh, if ( theSubShapeObject->_is_nil() ) // not published shape (IPAL13617) { - if ( _mapSubMesh.find( subMeshId ) != _mapSubMesh.end()) + SMESH_subMesh* sm; + if (( _mapSubMesh.count( subMeshId )) && + ( sm = _impl->GetSubMeshContaining( subMeshId ))) { - TopoDS_Shape S = _mapSubMesh[ subMeshId ]->GetSubShape(); + TopoDS_Shape S = sm->GetSubShape(); if ( !S.IsNull() ) { list hyps = _impl->GetHypothesisList( S ); isHypChanged = !hyps.empty(); + if ( isHypChanged && _preMeshInfo ) + _preMeshInfo->ForgetOrLoad(); list::const_iterator hyp = hyps.begin(); for ( ; hyp != hyps.end(); ++hyp ) _impl->RemoveHypothesis(S, (*hyp)->GetID()); @@ -2558,14 +3243,15 @@ bool SMESH_Mesh_i::removeSubMesh (SMESH::SMESH_subMesh_ptr theSubMesh, return isHypChanged; } -//============================================================================= +//================================================================================ /*! - * + * \brief Create a group. Group type depends on given arguments */ -//============================================================================= +//================================================================================ SMESH::SMESH_GroupBase_ptr SMESH_Mesh_i::createGroup (SMESH::ElementType theElemType, const char* theName, + const int theID, const TopoDS_Shape& theShape, const SMESH_PredicatePtr& thePredicate ) { @@ -2584,10 +3270,11 @@ SMESH::SMESH_GroupBase_ptr SMESH_Mesh_i::createGroup (SMESH::ElementType } while ( !presentNames.insert( newName ).second ); theName = newName.c_str(); } - int anId; SMESH::SMESH_GroupBase_var aGroup; - if ( _impl->AddGroup( (SMDSAbs_ElementType)theElemType, theName, anId, theShape, thePredicate )) + if ( SMESH_Group* g = _impl->AddGroup( (SMDSAbs_ElementType)theElemType, theName, + theID, theShape, thePredicate )) { + int anId = g->GetID(); SMESH_GroupBase_i* aGroupImpl; if ( !theShape.IsNull() ) aGroupImpl = new SMESH_GroupOnGeom_i( SMESH_Gen_i::GetPOA(), this, anId ); @@ -2603,7 +3290,7 @@ SMESH::SMESH_GroupBase_ptr SMESH_Mesh_i::createGroup (SMESH::ElementType // register CORBA object for persistence int nextId = _gen_i->RegisterObject( aGroup ); if(MYDEBUG) { MESSAGE( "Add group to map with id = "<< nextId); } - else { nextId = 0; } // avoid "unused variable" warning in release mode + else { nextId = ( nextId > 0 ); } // avoid "unused variable" warning in release mode // to track changes of GEOM groups if ( !theShape.IsNull() ) { @@ -2638,14 +3325,13 @@ void SMESH_Mesh_i::removeGroup( const int theId ) } } -//============================================================================= +//================================================================================ /*! - * + * \brief Return a log that can be used to move another mesh to the same state as this one */ -//============================================================================= +//================================================================================ SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet) - throw(SALOME::SALOME_Exception) { SMESH::log_array_var aLog; @@ -2657,22 +3343,17 @@ SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet) aLog = new SMESH::log_array; int indexLog = 0; int lg = logDS.size(); - SCRUTE(lg); aLog->length(lg); list < SMESHDS_Command * >::iterator its = logDS.begin(); while(its != logDS.end()){ SMESHDS_Command *com = *its; int comType = com->GetType(); - //SCRUTE(comType); - int lgcom = com->GetNumber(); - //SCRUTE(lgcom); - const list < int >&intList = com->GetIndexes(); + smIdType lgcom = com->GetNumber(); + const list < smIdType >&intList = com->GetIndexes(); int inum = intList.size(); - //SCRUTE(inum); - list < int >::const_iterator ii = intList.begin(); + list < smIdType >::const_iterator ii = intList.begin(); const list < double >&coordList = com->GetCoords(); int rnum = coordList.size(); - //SCRUTE(rnum); list < double >::const_iterator ir = coordList.begin(); aLog[indexLog].commandType = comType; aLog[indexLog].number = lgcom; @@ -2680,12 +3361,10 @@ SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet) aLog[indexLog].indexes.length(inum); for(int i = 0; i < rnum; i++){ aLog[indexLog].coords[i] = *ir; - //MESSAGE(" "<ClearLog(); SMESH_CATCH( SMESH::throwCorbaException ); } -//============================================================================= +//================================================================================ /*! - * + * \brief Return a mesh ID */ -//============================================================================= +//================================================================================ -CORBA::Long SMESH_Mesh_i::GetId()throw(SALOME::SALOME_Exception) +CORBA::Long SMESH_Mesh_i::GetId() { return _id; } @@ -2734,32 +3412,69 @@ namespace { SMESH_Mesh_i* _mesh; TCallUp_i(SMESH_Mesh_i* mesh):_mesh(mesh) {} - virtual void RemoveGroup (const int theGroupID) { _mesh->removeGroup( theGroupID ); } - virtual void HypothesisModified () { _mesh->onHypothesisModified(); } - virtual void Load () { _mesh->Load(); } + void RemoveGroup (const int theGroupID) override { _mesh->removeGroup( theGroupID ); } + void HypothesisModified( int hypID, + bool updIcons) override { _mesh->onHypothesisModified( hypID, + updIcons ); } + void Load () override { _mesh->Load(); } + bool IsLoaded() override { return _mesh->IsLoaded(); } + TopoDS_Shape GetShapeByEntry(const std::string& entry) override + { + GEOM::GEOM_Object_var go = SMESH_Gen_i::GetGeomObjectByEntry( entry ); + return SMESH_Gen_i::GeomObjectToShape( go ); + } }; } //================================================================================ /*! - * \brief callback from _impl to forget not loaded mesh data (issue 0021208) + * \brief callback from _impl to + * 1) forget not loaded mesh data (issue 0021208) + * 2) mark hypothesis as valid */ //================================================================================ -void SMESH_Mesh_i::onHypothesisModified() +void SMESH_Mesh_i::onHypothesisModified(int theHypID, bool theUpdateIcons) { if ( _preMeshInfo ) _preMeshInfo->ForgetOrLoad(); - SMESH::SMESH_Mesh_var mesh = _this(); - _gen_i->UpdateIcons( mesh ); + if ( theUpdateIcons ) + { + SMESH::SMESH_Mesh_var mesh = _this(); + _gen_i->UpdateIcons( mesh ); + } + + if ( _nbInvalidHypos != 0 ) + { + // mark a hypothesis as valid after edition + int nbInvalid = 0; + SALOMEDS::SComponent_wrap smeshComp = _gen_i->PublishComponent(); + SALOMEDS::SObject_wrap hypRoot; + if ( !smeshComp->_is_nil() && + smeshComp->FindSubObject( _gen_i->GetHypothesisRootTag(), hypRoot.inout() )) + { + SALOMEDS::ChildIterator_wrap anIter = _gen_i->getStudyServant()->NewChildIterator( hypRoot ); + for ( ; anIter->More(); anIter->Next() ) + { + SALOMEDS::SObject_wrap hypSO = anIter->Value(); + CORBA::Object_var obj = _gen_i->SObjectToObject( hypSO ); + SMESH::SMESH_Hypothesis_var hyp = SMESH::SMESH_Hypothesis::_narrow( obj ); + if ( !hyp->_is_nil() && hyp->GetId() == theHypID ) + _gen_i->HighLightInvalid( hyp, false ); + else + nbInvalid += _gen_i->IsInvalid( hypSO ); + } + } + _nbInvalidHypos = nbInvalid; + } } -//============================================================================= +//================================================================================ /*! - * + * \brief Set mesh implementation */ -//============================================================================= +//================================================================================ void SMESH_Mesh_i::SetImpl(::SMESH_Mesh * impl) { @@ -2771,7 +3486,7 @@ void SMESH_Mesh_i::SetImpl(::SMESH_Mesh * impl) //============================================================================= /*! - * + * Return a mesh implementation */ //============================================================================= @@ -2788,7 +3503,6 @@ void SMESH_Mesh_i::SetImpl(::SMESH_Mesh * impl) //============================================================================= SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor() - throw (SALOME::SALOME_Exception) { SMESH::SMESH_MeshEditor_var aMeshEdVar; @@ -2817,7 +3531,6 @@ SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor() //============================================================================= SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditPreviewer() - throw (SALOME::SALOME_Exception) { SMESH::SMESH_MeshEditor_var aMeshEdVar; @@ -2841,7 +3554,7 @@ SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditPreviewer() */ //================================================================================ -CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard() throw(SALOME::SALOME_Exception) +CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard() { Unexpect aCatch(SALOME_SalomeException); return _impl->HasModificationsToDiscard(); @@ -2849,7 +3562,7 @@ CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard() throw(SALOME::SALOME_Ex //================================================================================ /*! - * \brief Returns a random unique color + * \brief Return a random unique color */ //================================================================================ @@ -2885,11 +3598,11 @@ static SALOMEDS::Color getUniqueColor( const std::list& theRese //============================================================================= /*! - * Sets auto-color mode. If it is on, groups get unique random colors + * Set auto-color mode. If it is on, groups get unique random colors */ //============================================================================= -void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor) throw(SALOME::SALOME_Exception) +void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor) { Unexpect aCatch(SALOME_SalomeException); _impl->SetAutoColor(theAutoColor); @@ -2909,11 +3622,11 @@ void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor) throw(SALOME::SALOM //============================================================================= /*! - * Returns true if auto-color mode is on + * Return true if auto-color mode is on */ //============================================================================= -CORBA::Boolean SMESH_Mesh_i::GetAutoColor() throw(SALOME::SALOME_Exception) +CORBA::Boolean SMESH_Mesh_i::GetAutoColor() { Unexpect aCatch(SALOME_SalomeException); return _impl->GetAutoColor(); @@ -2921,7 +3634,7 @@ CORBA::Boolean SMESH_Mesh_i::GetAutoColor() throw(SALOME::SALOME_Exception) //============================================================================= /*! - * Checks if there are groups with equal names + * Check if there are groups with equal names */ //============================================================================= @@ -2938,9 +3651,9 @@ CORBA::Boolean SMESH_Mesh_i::HasDuplicatedGroupNamesMED() void SMESH_Mesh_i::PrepareForWriting (const char* file, bool overwrite) { - SMESH_File aFile( file ); + SMESH_File aFile( file, false ); SMESH_Comment msg; - if (aFile.exists()) { + if ( aFile.exists() ) { // existing filesystem node if ( !aFile.isDirectory() ) { if ( aFile.openForWriting() ) { @@ -2971,9 +3684,28 @@ void SMESH_Mesh_i::PrepareForWriting (const char* file, bool overwrite) } } +/*! + Return a MeshName + */ +std::string SMESH_Mesh_i::generateMeshName() +{ + string aMeshName = "Mesh"; + SALOMEDS::Study_var aStudy = SMESH_Gen_i::GetSMESHGen()->getStudyServant(); + if ( !aStudy->_is_nil() ) + { + SALOMEDS::SObject_wrap aMeshSO = _gen_i->ObjectToSObject( _this() ); + if ( !aMeshSO->_is_nil() ) + { + CORBA::String_var name = aMeshSO->GetName(); + aMeshName = name; + } + } + return aMeshName; +} + //================================================================================ /*! - * \brief Prepares a file for export and pass names of mesh groups from study to mesh DS + * \brief Prepare a file for export and pass names of mesh groups from study to mesh DS * \param file - file name * \param overwrite - to erase the file or not * \retval string - mesh name @@ -2985,13 +3717,11 @@ string SMESH_Mesh_i::prepareMeshNameAndGroups(const char* file, { // Perform Export PrepareForWriting(file, overwrite); - string aMeshName = "Mesh"; - SALOMEDS::Study_var aStudy = SMESH_Gen_i::getStudyServant(); + string aMeshName(this->generateMeshName()); + SALOMEDS::Study_var aStudy = SMESH_Gen_i::GetSMESHGen()->getStudyServant(); if ( !aStudy->_is_nil() ) { SALOMEDS::SObject_wrap aMeshSO = _gen_i->ObjectToSObject( _this() ); if ( !aMeshSO->_is_nil() ) { - CORBA::String_var name = aMeshSO->GetName(); - aMeshName = name; // asv : 27.10.04 : fix of 6903: check for StudyLocked before adding attributes if ( !aStudy->GetProperties()->IsLocked() ) { @@ -3025,12 +3755,11 @@ string SMESH_Mesh_i::prepareMeshNameAndGroups(const char* file, */ //================================================================================ -void SMESH_Mesh_i::ExportMED(const char* file, - CORBA::Boolean auto_groups, - CORBA::Long minor, - CORBA::Boolean overwrite, - CORBA::Boolean autoDimension) - throw(SALOME::SALOME_Exception) +void SMESH_Mesh_i::ExportMED(const char* file, + CORBA::Boolean auto_groups, + CORBA::Long version, + CORBA::Boolean overwrite, + CORBA::Boolean autoDimension) { //MESSAGE("MED minor version: "<< minor); SMESH_TRY; @@ -3038,12 +3767,12 @@ void SMESH_Mesh_i::ExportMED(const char* file, _preMeshInfo->FullLoadFromFile(); string aMeshName = prepareMeshNameAndGroups(file, overwrite); - _impl->ExportMED( file, aMeshName.c_str(), auto_groups, minor, 0, autoDimension ); + _impl->ExportMED( file, aMeshName.c_str(), auto_groups, version, 0, autoDimension ); TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportMED( r'" << file << "', " << "auto_groups=" < data; + SMESH_TRY; + // TODO : Fix me ! 2 next lines are required + //if( !this->_gen_i->IsEmbeddedMode() ) + // SMESH::throwCorbaException("SMESH_Mesh_i::ExportMEDCoupling : only for embedded mode !"); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + string aMeshName = this->generateMeshName(); + data = _impl->ExportMEDCoupling( aMeshName.c_str(), auto_groups, 0, autoDimension ); + SMESH_CATCH( SMESH::throwCorbaException ); + MEDCoupling::DataArrayByte *ret(data.retn()); + return reinterpret_cast(ret); +} + //================================================================================ /*! * \brief Export a mesh to a SAUV file */ //================================================================================ -void SMESH_Mesh_i::ExportSAUV (const char* file, - CORBA::Boolean auto_groups) - throw(SALOME::SALOME_Exception) +void SMESH_Mesh_i::ExportSAUV( const char* file, CORBA::Boolean auto_groups ) { - Unexpect aCatch(SALOME_SalomeException); + SMESH_TRY; if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -3069,6 +3813,8 @@ void SMESH_Mesh_i::ExportSAUV (const char* file, TPythonDump() << SMESH::SMESH_Mesh_var( _this()) << ".ExportSAUV( r'" << file << "', " << auto_groups << " )"; _impl->ExportSAUV(file, aMeshName.c_str(), auto_groups); + + SMESH_CATCH( SMESH::throwCorbaException ); } @@ -3079,20 +3825,21 @@ void SMESH_Mesh_i::ExportSAUV (const char* file, //================================================================================ void SMESH_Mesh_i::ExportDAT (const char *file) - throw(SALOME::SALOME_Exception) { - Unexpect aCatch(SALOME_SalomeException); + SMESH_TRY; if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); - // Update Python script // check names of groups checkGroupNames(); + // Update Python script TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportDAT( r'" << file << "' )"; // Perform Export PrepareForWriting(file); _impl->ExportDAT(file); + + SMESH_CATCH( SMESH::throwCorbaException ); } //================================================================================ @@ -3102,20 +3849,21 @@ void SMESH_Mesh_i::ExportDAT (const char *file) //================================================================================ void SMESH_Mesh_i::ExportUNV (const char *file) - throw(SALOME::SALOME_Exception) { - Unexpect aCatch(SALOME_SalomeException); + SMESH_TRY; if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); - // Update Python script // check names of groups checkGroupNames(); + // Update Python script TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportUNV( r'" << file << "' )"; // Perform Export PrepareForWriting(file); _impl->ExportUNV(file); + + SMESH_CATCH( SMESH::throwCorbaException ); } //================================================================================ @@ -3125,15 +3873,14 @@ void SMESH_Mesh_i::ExportUNV (const char *file) //================================================================================ void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii) - throw(SALOME::SALOME_Exception) { - Unexpect aCatch(SALOME_SalomeException); + SMESH_TRY; if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); - // Update Python script // check names of groups checkGroupNames(); + // Update Python script TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportSTL( r'" << file << "', " << isascii << " )"; @@ -3145,25 +3892,51 @@ void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii) // Perform Export PrepareForWriting( file ); _impl->ExportSTL( file, isascii, name.in() ); + + SMESH_CATCH( SMESH::throwCorbaException ); } -//================================================================================ -/*! - * \brief Export a part of mesh to a med file - */ -//================================================================================ +class MEDFileSpeCls +{ +public: + MEDFileSpeCls(const char *file, CORBA::Boolean overwrite, CORBA::Long version):_file(file),_overwrite(overwrite),_version(version) { } + std::string prepareMeshNameAndGroups(SMESH_Mesh_i& self) { return self.prepareMeshNameAndGroups(_file.c_str(),_overwrite); } + void exportTo(SMESH_Mesh *mesh, const std::string& aMeshName, CORBA::Boolean auto_groups, + SMESH_MeshPartDS* partDS, + CORBA::Boolean autoDimension, bool have0dField, + CORBA::Double ZTolerance) + { + mesh->ExportMED( _file.c_str(), aMeshName.c_str(), auto_groups, _version, + partDS, autoDimension,have0dField,ZTolerance); -void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart, - const char* file, - CORBA::Boolean auto_groups, - CORBA::Long minor, - CORBA::Boolean overwrite, - CORBA::Boolean autoDimension, - const GEOM::ListOfFields& fields, - const char* geomAssocFields) - throw (SALOME::SALOME_Exception) + } + + void exportField(SMESH_Mesh_i& self, const std::string& aMeshName, bool have0dField, SMESHDS_Mesh *meshDS, const GEOM::ListOfFields& fields, const char*geomAssocFields) + { + DriverMED_W_Field fieldWriter; + fieldWriter.SetFile( _file.c_str() ); + fieldWriter.SetMeshName( aMeshName ); + fieldWriter.AddODOnVertices( have0dField ); + self.exportMEDFields( fieldWriter, meshDS, fields, geomAssocFields ); + } + + void prepareForWriting(SMESH_Mesh_i& self) { self.PrepareForWriting(_file.c_str(), _overwrite); } +private: + std::string _file; + CORBA::Boolean _overwrite; + CORBA::Long _version; +}; + + +template +void SMESH_Mesh_i::ExportPartToMEDCommon(SPECLS& speCls, + SMESH::SMESH_IDSource_ptr meshPart, + CORBA::Boolean auto_groups, + CORBA::Boolean autoDimension, + const GEOM::ListOfFields& fields, + const char* geomAssocFields, + CORBA::Double ZTolerance) { - //MESSAGE("MED minor version: "<< minor); SMESH_TRY; if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -3209,9 +3982,8 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart, if ( CORBA::is_nil( meshPart ) || SMESH::DownCast< SMESH_Mesh_i* >( meshPart )) { - aMeshName = prepareMeshNameAndGroups(file, overwrite); - _impl->ExportMED( file, aMeshName.c_str(), auto_groups, minor, - 0, autoDimension, /*addODOnVertices=*/have0dField); + aMeshName = speCls.prepareMeshNameAndGroups(*this); + speCls.exportTo(_impl, aMeshName, auto_groups, nullptr, autoDimension, have0dField, ZTolerance); meshDS = _impl->GetMeshDS(); } else @@ -3219,7 +3991,7 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart, if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); - PrepareForWriting(file, overwrite); + speCls.prepareForWriting(*this); SALOMEDS::SObject_wrap SO = _gen_i->ObjectToSObject( meshPart ); if ( !SO->_is_nil() ) { @@ -3228,8 +4000,7 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart, } SMESH_MeshPartDS* partDS = new SMESH_MeshPartDS( meshPart ); - _impl->ExportMED( file, aMeshName.c_str(), auto_groups, minor, - partDS, autoDimension, /*addODOnVertices=*/have0dField); + speCls.exportTo(_impl, aMeshName, auto_groups, partDS, autoDimension, have0dField, ZTolerance); meshDS = tmpDSDeleter._obj = partDS; } @@ -3237,15 +4008,32 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart, if ( _impl->HasShapeToMesh() ) { - DriverMED_W_Field fieldWriter; - fieldWriter.SetFile( file ); - fieldWriter.SetMeshName( aMeshName ); - fieldWriter.AddODOnVertices( have0dField ); - - exportMEDFields( fieldWriter, meshDS, fields, geomAssocFields ); + speCls.exportField(*this,aMeshName,have0dField,meshDS,fields,geomAssocFields); } + SMESH_CATCH( SMESH::throwCorbaException ); +} + +//================================================================================ +/*! + * \brief Export a part of mesh to a med file + */ +//================================================================================ +void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart, + const char* file, + CORBA::Boolean auto_groups, + CORBA::Long version, + CORBA::Boolean overwrite, + CORBA::Boolean autoDimension, + const GEOM::ListOfFields& fields, + const char* geomAssocFields, + CORBA::Double ZTolerance) +{ + MESSAGE("MED version: "<< version); + MEDFileSpeCls spe(file,overwrite,version); + this->ExportPartToMEDCommon(spe,meshPart,auto_groups,autoDimension,fields,geomAssocFields,ZTolerance); // dump + SMESH_TRY; GEOM::ListOfGBO_var goList = new GEOM::ListOfGBO; goList->length( fields.length() ); for ( size_t i = 0; i < fields.length(); ++i ) @@ -3257,15 +4045,52 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart, << meshPart << ", r'" << file << "', " << auto_groups << ", " - << minor << ", " + << version << ", " << overwrite << ", " << autoDimension << ", " << goList << ", '" - << ( geomAssocFields ? geomAssocFields : "" ) << "'" << " )"; - + << ( geomAssocFields ? geomAssocFields : "" ) << "'," + << TVar( ZTolerance ) + << " )"; SMESH_CATCH( SMESH::throwCorbaException ); } +class MEDFileMemSpeCls +{ +public: + std::string prepareMeshNameAndGroups(SMESH_Mesh_i& self) { return self.generateMeshName(); } + void exportTo(SMESH_Mesh *mesh, const std::string& aMeshName, CORBA::Boolean auto_groups, + SMESH_MeshPartDS* partDS, + CORBA::Boolean autoDimension, bool have0dField, + CORBA::Double ZTolerance) + { + _res = mesh->ExportMEDCoupling(aMeshName.c_str(),auto_groups,partDS,autoDimension,have0dField,ZTolerance); + } + void prepareForWriting(SMESH_Mesh_i& self) { /* nothing here */ } + void exportField(SMESH_Mesh_i& self, const std::string& aMeshName, bool have0dField, SMESHDS_Mesh *meshDS, const GEOM::ListOfFields& fields, const char*geomAssocFields) + { + THROW_IK_EXCEPTION("exportField Not implemented yet for full memory !"); + } +public: + MEDCoupling::MCAuto getData() { return _res; } +private: + MEDCoupling::MCAuto _res; +}; + +CORBA::LongLong SMESH_Mesh_i::ExportPartToMEDCoupling(SMESH::SMESH_IDSource_ptr meshPart, + CORBA::Boolean auto_groups, + CORBA::Boolean autoDimension, + const GEOM::ListOfFields& fields, + const char* geomAssocFields, + CORBA::Double ZTolerance) +{ + MEDFileMemSpeCls spe; + this->ExportPartToMEDCommon(spe,meshPart,auto_groups,autoDimension,fields,geomAssocFields,ZTolerance); + MEDCoupling::MCAuto res( spe.getData() ); + MEDCoupling::DataArrayByte *ret(res.retn()); + return reinterpret_cast(ret); +} + //================================================================================ /*! * Write GEOM fields to MED file @@ -3543,9 +4368,8 @@ void SMESH_Mesh_i::exportMEDFields( DriverMED_W_Field& fieldWriter, void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart, const char* file) - throw (SALOME::SALOME_Exception) { - Unexpect aCatch(SALOME_SalomeException); + SMESH_TRY; if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -3556,6 +4380,8 @@ void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart, TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportPartToDAT( " << meshPart << ", r'" << file << "' )"; + + SMESH_CATCH( SMESH::throwCorbaException ); } //================================================================================ /*! @@ -3565,9 +4391,8 @@ void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart, void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart, const char* file) - throw (SALOME::SALOME_Exception) { - Unexpect aCatch(SALOME_SalomeException); + SMESH_TRY; if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -3578,6 +4403,8 @@ void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart, TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportPartToUNV( " << meshPart<< ", r'" << file << "' )"; + + SMESH_CATCH( SMESH::throwCorbaException ); } //================================================================================ /*! @@ -3588,9 +4415,8 @@ void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart, void SMESH_Mesh_i::ExportPartToSTL(::SMESH::SMESH_IDSource_ptr meshPart, const char* file, ::CORBA::Boolean isascii) - throw (SALOME::SALOME_Exception) { - Unexpect aCatch(SALOME_SalomeException); + SMESH_TRY; if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -3606,6 +4432,8 @@ void SMESH_Mesh_i::ExportPartToSTL(::SMESH::SMESH_IDSource_ptr meshPart, TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportPartToSTL( " << meshPart<< ", r'" << file << "', " << isascii << ")"; + + SMESH_CATCH( SMESH::throwCorbaException ); } //================================================================================ @@ -3618,10 +4446,9 @@ void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart, const char* file, CORBA::Boolean overwrite, CORBA::Boolean groupElemsByType) - throw (SALOME::SALOME_Exception) { #ifdef WITH_CGNS - Unexpect aCatch(SALOME_SalomeException); + SMESH_TRY; if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -3643,6 +4470,9 @@ void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart, TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportCGNS( " << meshPart<< ", r'" << file << "', " << overwrite << ")"; + + SMESH_CATCH( SMESH::throwCorbaException ); + #else THROW_SALOME_CORBA_EXCEPTION("CGNS library is unavailable", SALOME::INTERNAL_ERROR); #endif @@ -3657,9 +4487,8 @@ void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart, void SMESH_Mesh_i::ExportGMF(::SMESH::SMESH_IDSource_ptr meshPart, const char* file, bool withRequiredGroups) - throw (SALOME::SALOME_Exception) { - Unexpect aCatch(SALOME_SalomeException); + SMESH_TRY; if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -3672,6 +4501,8 @@ void SMESH_Mesh_i::ExportGMF(::SMESH::SMESH_IDSource_ptr meshPart, << meshPart<< ", r'" << file << "', " << withRequiredGroups << ")"; + + SMESH_CATCH( SMESH::throwCorbaException ); } //============================================================================= @@ -3690,7 +4521,13 @@ CORBA::Double SMESH_Mesh_i::GetComputeProgress() return 0.; } -CORBA::Long SMESH_Mesh_i::NbNodes()throw(SALOME::SALOME_Exception) +//================================================================================ +/*! + * \brief Return nb of nodes + */ +//================================================================================ + +SMESH::smIdType SMESH_Mesh_i::NbNodes() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3699,7 +4536,13 @@ CORBA::Long SMESH_Mesh_i::NbNodes()throw(SALOME::SALOME_Exception) return _impl->NbNodes(); } -CORBA::Long SMESH_Mesh_i::NbElements()throw (SALOME::SALOME_Exception) +//================================================================================ +/*! + * \brief Return nb of elements + */ +//================================================================================ + +SMESH::smIdType SMESH_Mesh_i::NbElements() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3708,7 +4551,13 @@ CORBA::Long SMESH_Mesh_i::NbElements()throw (SALOME::SALOME_Exception) return Nb0DElements() + NbEdges() + NbFaces() + NbVolumes() + NbBalls(); } -CORBA::Long SMESH_Mesh_i::Nb0DElements()throw (SALOME::SALOME_Exception) +//================================================================================ +/*! + * \brief Return nb of 0D elements + */ +//================================================================================ + +SMESH::smIdType SMESH_Mesh_i::Nb0DElements() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3717,7 +4566,13 @@ CORBA::Long SMESH_Mesh_i::Nb0DElements()throw (SALOME::SALOME_Exception) return _impl->Nb0DElements(); } -CORBA::Long SMESH_Mesh_i::NbBalls() throw (SALOME::SALOME_Exception) +//================================================================================ +/*! + * \brief Return nb of BALL elements + */ +//================================================================================ + +SMESH::smIdType SMESH_Mesh_i::NbBalls() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3726,7 +4581,13 @@ CORBA::Long SMESH_Mesh_i::NbBalls() throw (SALOME::SALOME_Exception) return _impl->NbBalls(); } -CORBA::Long SMESH_Mesh_i::NbEdges()throw(SALOME::SALOME_Exception) +//================================================================================ +/*! + * \brief Return nb of 1D elements + */ +//================================================================================ + +SMESH::smIdType SMESH_Mesh_i::NbEdges() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3735,8 +4596,13 @@ CORBA::Long SMESH_Mesh_i::NbEdges()throw(SALOME::SALOME_Exception) return _impl->NbEdges(); } -CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order) - throw(SALOME::SALOME_Exception) +//================================================================================ +/*! + * \brief Return nb of edges + */ +//================================================================================ + +SMESH::smIdType SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3745,9 +4611,13 @@ CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order) return _impl->NbEdges( (SMDSAbs_ElementOrder) order); } -//============================================================================= +//================================================================================ +/*! + * \brief Return nb of faces + */ +//================================================================================ -CORBA::Long SMESH_Mesh_i::NbFaces()throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbFaces() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3756,7 +4626,13 @@ CORBA::Long SMESH_Mesh_i::NbFaces()throw(SALOME::SALOME_Exception) return _impl->NbFaces(); } -CORBA::Long SMESH_Mesh_i::NbTriangles()throw(SALOME::SALOME_Exception) +//================================================================================ +/*! + * \brief Return nb of tringles + */ +//================================================================================ + +SMESH::smIdType SMESH_Mesh_i::NbTriangles() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3765,7 +4641,13 @@ CORBA::Long SMESH_Mesh_i::NbTriangles()throw(SALOME::SALOME_Exception) return _impl->NbTriangles(); } -CORBA::Long SMESH_Mesh_i::NbBiQuadTriangles()throw(SALOME::SALOME_Exception) +//================================================================================ +/*! + * \brief Return nb of bi-quadratic triangles + */ +//================================================================================ + +SMESH::smIdType SMESH_Mesh_i::NbBiQuadTriangles() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3774,7 +4656,7 @@ CORBA::Long SMESH_Mesh_i::NbBiQuadTriangles()throw(SALOME::SALOME_Exception) return _impl->NbBiQuadTriangles(); } -CORBA::Long SMESH_Mesh_i::NbQuadrangles()throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbQuadrangles() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3783,7 +4665,7 @@ CORBA::Long SMESH_Mesh_i::NbQuadrangles()throw(SALOME::SALOME_Exception) return _impl->NbQuadrangles(); } -CORBA::Long SMESH_Mesh_i::NbBiQuadQuadrangles()throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbBiQuadQuadrangles() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3792,7 +4674,7 @@ CORBA::Long SMESH_Mesh_i::NbBiQuadQuadrangles()throw(SALOME::SALOME_Exception) return _impl->NbBiQuadQuadrangles(); } -CORBA::Long SMESH_Mesh_i::NbPolygons() throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbPolygons() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3801,7 +4683,7 @@ CORBA::Long SMESH_Mesh_i::NbPolygons() throw(SALOME::SALOME_Exception) return _impl->NbPolygons(); } -CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order) throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3810,8 +4692,7 @@ CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order) throw(SAL return _impl->NbPolygons((SMDSAbs_ElementOrder)order); } -CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order) - throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3820,8 +4701,7 @@ CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order) return _impl->NbFaces( (SMDSAbs_ElementOrder) order); } -CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order) - throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3830,8 +4710,7 @@ CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order) return _impl->NbTriangles( (SMDSAbs_ElementOrder) order); } -CORBA::Long SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order) - throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3842,7 +4721,7 @@ CORBA::Long SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order) //============================================================================= -CORBA::Long SMESH_Mesh_i::NbVolumes()throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbVolumes() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3851,7 +4730,7 @@ CORBA::Long SMESH_Mesh_i::NbVolumes()throw(SALOME::SALOME_Exception) return _impl->NbVolumes(); } -CORBA::Long SMESH_Mesh_i::NbTetras()throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbTetras() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3860,7 +4739,7 @@ CORBA::Long SMESH_Mesh_i::NbTetras()throw(SALOME::SALOME_Exception) return _impl->NbTetras(); } -CORBA::Long SMESH_Mesh_i::NbHexas()throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbHexas() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3869,7 +4748,7 @@ CORBA::Long SMESH_Mesh_i::NbHexas()throw(SALOME::SALOME_Exception) return _impl->NbHexas(); } -CORBA::Long SMESH_Mesh_i::NbTriQuadraticHexas()throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbTriQuadraticHexas() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3878,7 +4757,7 @@ CORBA::Long SMESH_Mesh_i::NbTriQuadraticHexas()throw(SALOME::SALOME_Exception) return _impl->NbTriQuadraticHexas(); } -CORBA::Long SMESH_Mesh_i::NbPyramids()throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbPyramids() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3887,7 +4766,7 @@ CORBA::Long SMESH_Mesh_i::NbPyramids()throw(SALOME::SALOME_Exception) return _impl->NbPyramids(); } -CORBA::Long SMESH_Mesh_i::NbPrisms()throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbPrisms() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3896,7 +4775,7 @@ CORBA::Long SMESH_Mesh_i::NbPrisms()throw(SALOME::SALOME_Exception) return _impl->NbPrisms(); } -CORBA::Long SMESH_Mesh_i::NbHexagonalPrisms()throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbHexagonalPrisms() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3905,7 +4784,7 @@ CORBA::Long SMESH_Mesh_i::NbHexagonalPrisms()throw(SALOME::SALOME_Exception) return _impl->NbHexagonalPrisms(); } -CORBA::Long SMESH_Mesh_i::NbPolyhedrons()throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbPolyhedrons() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3914,8 +4793,7 @@ CORBA::Long SMESH_Mesh_i::NbPolyhedrons()throw(SALOME::SALOME_Exception) return _impl->NbPolyhedrons(); } -CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order) - throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3924,8 +4802,7 @@ CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order) return _impl->NbVolumes( (SMDSAbs_ElementOrder) order); } -CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order) - throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3934,8 +4811,7 @@ CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order) return _impl->NbTetras( (SMDSAbs_ElementOrder) order); } -CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order) - throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3944,8 +4820,7 @@ CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order) return _impl->NbHexas( (SMDSAbs_ElementOrder) order); } -CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order) - throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3954,8 +4829,7 @@ CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order) return _impl->NbPyramids( (SMDSAbs_ElementOrder) order); } -CORBA::Long SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order) - throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3966,11 +4840,11 @@ CORBA::Long SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order) //============================================================================= /*! - * Returns nb of published sub-meshes + * Return nb of published sub-meshes */ //============================================================================= -CORBA::Long SMESH_Mesh_i::NbSubMesh()throw(SALOME::SALOME_Exception) +SMESH::smIdType SMESH_Mesh_i::NbSubMesh() { Unexpect aCatch(SALOME_SalomeException); return _mapSubMesh_i.size(); @@ -3995,34 +4869,33 @@ char* SMESH_Mesh_i::Dump() */ //============================================================================= -SMESH::long_array* SMESH_Mesh_i::GetIDs() +SMESH::smIdType_array* SMESH_Mesh_i::GetIDs() { return GetElementsId(); } //============================================================================= /*! - * Returns ids of all elements + * Return ids of all elements */ //============================================================================= -SMESH::long_array* SMESH_Mesh_i::GetElementsId() - throw (SALOME::SALOME_Exception) +SMESH::smIdType_array* SMESH_Mesh_i::GetElementsId() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); - SMESH::long_array_var aResult = new SMESH::long_array(); + SMESH::smIdType_array_var aResult = new SMESH::smIdType_array(); SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS(); if ( aSMESHDS_Mesh == NULL ) return aResult._retn(); - long nbElements = NbElements(); + smIdType nbElements = NbElements(); aResult->length( nbElements ); SMDS_ElemIteratorPtr anIt = aSMESHDS_Mesh->elementsIterator(); - for ( int i = 0, n = nbElements; i < n && anIt->more(); i++ ) + for ( smIdType i = 0, n = nbElements; i < n && anIt->more(); i++ ) aResult[i] = anIt->next()->GetID(); return aResult._retn(); @@ -4031,24 +4904,23 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsId() //============================================================================= /*! - * Returns ids of all elements of given type + * Return ids of all elements of given type */ //============================================================================= -SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemType ) - throw (SALOME::SALOME_Exception) +SMESH::smIdType_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemType ) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); - SMESH::long_array_var aResult = new SMESH::long_array(); + SMESH::smIdType_array_var aResult = new SMESH::smIdType_array(); SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS(); if ( aSMESHDS_Mesh == NULL ) return aResult._retn(); - long nbElements = NbElements(); + smIdType nbElements = NbElements(); // No sense in returning ids of elements along with ids of nodes: // when theElemType == SMESH::ALL, return node ids only if @@ -4058,7 +4930,7 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemTy aResult->length( nbElements ); - int i = 0; + smIdType i = 0; SMDS_ElemIteratorPtr anIt = aSMESHDS_Mesh->elementsIterator( (SMDSAbs_ElementType)theElemType ); while ( i < nbElements && anIt->more() ) @@ -4071,27 +4943,26 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemTy //============================================================================= /*! - * Returns ids of all nodes + * Return ids of all nodes */ //============================================================================= -SMESH::long_array* SMESH_Mesh_i::GetNodesId() - throw (SALOME::SALOME_Exception) +SMESH::smIdType_array* SMESH_Mesh_i::GetNodesId() { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); - SMESH::long_array_var aResult = new SMESH::long_array(); + SMESH::smIdType_array_var aResult = new SMESH::smIdType_array(); SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS(); if ( aMeshDS == NULL ) return aResult._retn(); - long nbNodes = NbNodes(); + smIdType nbNodes = NbNodes(); aResult->length( nbNodes ); SMDS_NodeIteratorPtr anIt = aMeshDS->nodesIterator(); - for ( int i = 0, n = nbNodes; i < n && anIt->more(); i++ ) + for ( smIdType i = 0, n = nbNodes; i < n && anIt->more(); i++ ) aResult[i] = anIt->next()->GetID(); return aResult._retn(); @@ -4099,12 +4970,11 @@ SMESH::long_array* SMESH_Mesh_i::GetNodesId() //============================================================================= /*! - * + * Return type of the given element */ //============================================================================= -SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem ) - throw (SALOME::SALOME_Exception) +SMESH::ElementType SMESH_Mesh_i::GetElementType( const SMESH::smIdType id, const bool iselem ) { SMESH::ElementType type = SMESH::ALL; SMESH_TRY; @@ -4121,12 +4991,11 @@ SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const boo //============================================================================= /*! - * + * Return geometric type of the given element */ //============================================================================= -SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id ) - throw (SALOME::SALOME_Exception) +SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const SMESH::smIdType id ) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4140,12 +5009,11 @@ SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id ) //============================================================================= /*! - * + * Return type of the given element */ //============================================================================= -SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const CORBA::Long id ) - throw (SALOME::SALOME_Exception) +SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const SMESH::smIdType id ) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4159,13 +5027,13 @@ SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const CORBA::Long id ) //============================================================================= /*! - * Returns ID of elements for given submesh + * Return ID of elements for given submesh */ //============================================================================= -SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID) - throw (SALOME::SALOME_Exception) + +SMESH::smIdType_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID) { - SMESH::long_array_var aResult = new SMESH::long_array(); + SMESH::smIdType_array_var aResult = new SMESH::smIdType_array(); SMESH_TRY; if ( _preMeshInfo ) @@ -4180,7 +5048,7 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID) aResult->length(SDSM->NbElements()); SMDS_ElemIteratorPtr eIt = SDSM->GetElements(); - int i = 0; + smIdType i = 0; while ( eIt->more() ) { aResult[i++] = eIt->next()->GetID(); } @@ -4192,17 +5060,16 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID) //============================================================================= /*! - * Returns ID of nodes for given submesh - * If param all==true - returns all nodes, else - - * returns only nodes on shapes. + * Return ID of nodes for given sub-mesh + * If param all==true - return all nodes, else - + * Return only nodes on shapes. */ //============================================================================= -SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID, +SMESH::smIdType_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID, CORBA::Boolean all) - throw (SALOME::SALOME_Exception) { - SMESH::long_array_var aResult = new SMESH::long_array(); + SMESH::smIdType_array_var aResult = new SMESH::smIdType_array(); SMESH_TRY; if ( _preMeshInfo ) @@ -4214,7 +5081,7 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID, SMESHDS_SubMesh* SDSM = SM->GetSubMeshDS(); if(!SDSM) return aResult._retn(); - set theElems; + set theElems; if( !all || (SDSM->NbElements()==0) ) { // internal nodes or vertex submesh SMDS_NodeIteratorPtr nIt = SDSM->GetNodes(); while ( nIt->more() ) { @@ -4235,8 +5102,8 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID, } aResult->length(theElems.size()); - set::iterator itElem; - int i = 0; + set::iterator itElem; + smIdType i = 0; for ( itElem = theElems.begin(); itElem != theElems.end(); itElem++ ) aResult[i++] = *itElem; @@ -4244,15 +5111,14 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID, return aResult._retn(); } - + //============================================================================= /*! - * Returns type of elements for given submesh + * Return type of elements for given sub-mesh */ //============================================================================= SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID) - throw (SALOME::SALOME_Exception) { SMESH::ElementType type = SMESH::ALL; @@ -4276,13 +5142,13 @@ SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID SMESH_CATCH( SMESH::throwCorbaException ); - return type; + return type; } - + //============================================================================= /*! - * Returns pointer to _impl as an integer value. Is called from constructor of SMESH_Client + * Return pointer to _impl as an integer value. Is called from constructor of SMESH_Client */ //============================================================================= @@ -4300,11 +5166,11 @@ CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() //============================================================================= /*! * Get XYZ coordinates of node as list of double - * If there is not node for given ID - returns empty list + * If there is not node for given ID - return empty list */ //============================================================================= -SMESH::double_array* SMESH_Mesh_i::GetNodeXYZ(const CORBA::Long id) +SMESH::double_array* SMESH_Mesh_i::GetNodeXYZ(const SMESH::smIdType id) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4330,30 +5196,32 @@ SMESH::double_array* SMESH_Mesh_i::GetNodeXYZ(const CORBA::Long id) //============================================================================= /*! - * For given node returns list of IDs of inverse elements - * If there is not node for given ID - returns empty list + * For given node return list of IDs of inverse elements + * If there is not node for given ID - return empty list */ //============================================================================= -SMESH::long_array* SMESH_Mesh_i::GetNodeInverseElements(const CORBA::Long id) +SMESH::smIdType_array* SMESH_Mesh_i::GetNodeInverseElements(const SMESH::smIdType id, + SMESH::ElementType elemType) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); - SMESH::long_array_var aResult = new SMESH::long_array(); + SMESH::smIdType_array_var aResult = new SMESH::smIdType_array(); SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS(); if ( aMeshDS == NULL ) return aResult._retn(); // find node - const SMDS_MeshNode* aNode = aMeshDS->FindNode(id); - if(!aNode) + const SMDS_MeshNode* aNode = aMeshDS->FindNode( id ); + if ( !aNode ) return aResult._retn(); // find inverse elements - SMDS_ElemIteratorPtr eIt = aNode->GetInverseElementIterator(); - aResult->length( aNode->NbInverseElements() ); - for( int i = 0; eIt->more(); ++i ) + SMDSAbs_ElementType type = SMDSAbs_ElementType( elemType ); + SMDS_ElemIteratorPtr eIt = aNode->GetInverseElementIterator( type ); + aResult->length( aNode->NbInverseElements( type )); + for( smIdType i = 0; eIt->more(); ++i ) { const SMDS_MeshElement* elem = eIt->next(); aResult[ i ] = elem->GetID(); @@ -4367,7 +5235,7 @@ SMESH::long_array* SMESH_Mesh_i::GetNodeInverseElements(const CORBA::Long id) */ //============================================================================= -SMESH::NodePosition* SMESH_Mesh_i::GetNodePosition(CORBA::Long NodeID) +SMESH::NodePosition* SMESH_Mesh_i::GetNodePosition(SMESH::smIdType NodeID) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4420,7 +5288,7 @@ SMESH::NodePosition* SMESH_Mesh_i::GetNodePosition(CORBA::Long NodeID) */ //============================================================================= -SMESH::ElementPosition SMESH_Mesh_i::GetElementPosition(CORBA::Long ElemID) +SMESH::ElementPosition SMESH_Mesh_i::GetElementPosition(SMESH::smIdType ElemID) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4462,12 +5330,12 @@ SMESH::ElementPosition SMESH_Mesh_i::GetElementPosition(CORBA::Long ElemID) //============================================================================= /*! - * If given element is node returns IDs of shape from position - * If there is not node for given ID - returns -1 + * If given element is node return IDs of shape from position + * If there is not node for given ID - return -1 */ //============================================================================= -CORBA::Long SMESH_Mesh_i::GetShapeID(const CORBA::Long id) +CORBA::Long SMESH_Mesh_i::GetShapeID(const SMESH::smIdType id) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4488,13 +5356,13 @@ CORBA::Long SMESH_Mesh_i::GetShapeID(const CORBA::Long id) //============================================================================= /*! - * For given element returns ID of result shape after + * For given element return ID of result shape after * ::FindShape() from SMESH_MeshEditor - * If there is not element for given ID - returns -1 + * If there is not element for given ID - return -1 */ //============================================================================= -CORBA::Long SMESH_Mesh_i::GetShapeIDForElem(const CORBA::Long id) +CORBA::Long SMESH_Mesh_i::GetShapeIDForElem(const SMESH::smIdType id) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4519,12 +5387,12 @@ CORBA::Long SMESH_Mesh_i::GetShapeIDForElem(const CORBA::Long id) //============================================================================= /*! - * Returns number of nodes for given element - * If there is not element for given ID - returns -1 + * Return number of nodes for given element + * If there is not element for given ID - return -1 */ //============================================================================= -CORBA::Long SMESH_Mesh_i::GetElemNbNodes(const CORBA::Long id) +CORBA::Short SMESH_Mesh_i::GetElemNbNodes(const SMESH::smIdType id) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4540,13 +5408,13 @@ CORBA::Long SMESH_Mesh_i::GetElemNbNodes(const CORBA::Long id) //============================================================================= /*! - * Returns ID of node by given index for given element - * If there is not element for given ID - returns -1 - * If there is not node for given index - returns -2 + * Return ID of node by given index for given element + * If there is not element for given ID - return -1 + * If there is not node for given index - return -2 */ //============================================================================= -CORBA::Long SMESH_Mesh_i::GetElemNode(const CORBA::Long id, const CORBA::Long index) +SMESH::smIdType SMESH_Mesh_i::GetElemNode(const SMESH::smIdType id, const CORBA::Short index) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4561,23 +5429,24 @@ CORBA::Long SMESH_Mesh_i::GetElemNode(const CORBA::Long id, const CORBA::Long in //============================================================================= /*! - * Returns IDs of nodes of given element + * Return IDs of nodes of given element */ //============================================================================= -SMESH::long_array* SMESH_Mesh_i::GetElemNodes(const CORBA::Long id) +SMESH::smIdType_array* SMESH_Mesh_i::GetElemNodes(const SMESH::smIdType id) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); - SMESH::long_array_var aResult = new SMESH::long_array(); + SMESH::smIdType_array_var aResult = new SMESH::smIdType_array(); if ( SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS() ) { if ( const SMDS_MeshElement* elem = aMeshDS->FindElement(id) ) { aResult->length( elem->NbNodes() ); - for ( int i = 0; i < elem->NbNodes(); ++i ) - aResult[ i ] = elem->GetNode( i )->GetID(); + for ( SMESH::smIdType i = 0; i < aResult->length(); ++i ) + if ( const SMDS_MeshNode* n = elem->GetNode( i )) + aResult[ i ] = n->GetID(); } } return aResult._retn(); @@ -4585,12 +5454,12 @@ SMESH::long_array* SMESH_Mesh_i::GetElemNodes(const CORBA::Long id) //============================================================================= /*! - * Returns true if given node is medium node + * Return true if given node is medium node * in given quadratic element */ //============================================================================= -CORBA::Boolean SMESH_Mesh_i::IsMediumNode(const CORBA::Long ide, const CORBA::Long idn) +CORBA::Boolean SMESH_Mesh_i::IsMediumNode(const SMESH::smIdType ide, const SMESH::smIdType idn) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4610,12 +5479,12 @@ CORBA::Boolean SMESH_Mesh_i::IsMediumNode(const CORBA::Long ide, const CORBA::Lo //============================================================================= /*! - * Returns true if given node is medium node + * Return true if given node is medium node * in one of quadratic elements */ //============================================================================= -CORBA::Boolean SMESH_Mesh_i::IsMediumNodeOfAnyElem(const CORBA::Long idn, +CORBA::Boolean SMESH_Mesh_i::IsMediumNodeOfAnyElem(const SMESH::smIdType idn, SMESH::ElementType theElemType) { if ( _preMeshInfo ) @@ -4642,11 +5511,11 @@ CORBA::Boolean SMESH_Mesh_i::IsMediumNodeOfAnyElem(const CORBA::Long idn, //============================================================================= /*! - * Returns number of edges for given element + * Return number of edges for given element */ //============================================================================= -CORBA::Long SMESH_Mesh_i::ElemNbEdges(const CORBA::Long id) +CORBA::Long SMESH_Mesh_i::ElemNbEdges(const SMESH::smIdType id) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4661,11 +5530,11 @@ CORBA::Long SMESH_Mesh_i::ElemNbEdges(const CORBA::Long id) //============================================================================= /*! - * Returns number of faces for given element + * Return number of faces for given element */ //============================================================================= -CORBA::Long SMESH_Mesh_i::ElemNbFaces(const CORBA::Long id) +CORBA::Long SMESH_Mesh_i::ElemNbFaces(const SMESH::smIdType id) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4677,28 +5546,29 @@ CORBA::Long SMESH_Mesh_i::ElemNbFaces(const CORBA::Long id) return elem->NbFaces(); } -//======================================================================= -//function : GetElemFaceNodes -//purpose : Returns nodes of given face (counted from zero) for given element. -//======================================================================= +//================================================================================ +/*! + * \brief Return nodes of given face (counted from zero) for given element. + */ +//================================================================================ -SMESH::long_array* SMESH_Mesh_i::GetElemFaceNodes(CORBA::Long elemId, - CORBA::Short faceIndex) +SMESH::smIdType_array* SMESH_Mesh_i::GetElemFaceNodes(SMESH::smIdType elemId, + CORBA::Short faceIndex) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); - SMESH::long_array_var aResult = new SMESH::long_array(); + SMESH::smIdType_array_var aResult = new SMESH::smIdType_array(); if ( SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS() ) { if ( const SMDS_MeshElement* elem = aMeshDS->FindElement(elemId) ) { - SMDS_VolumeTool vtool( elem ); + SMDS_VolumeTool vtool( elem, /*skipCentralNodes = */false ); if ( faceIndex < vtool.NbFaces() ) { aResult->length( vtool.NbFaceNodes( faceIndex )); const SMDS_MeshNode** nn = vtool.GetFaceNodes( faceIndex ); - for ( CORBA::ULong i = 0; i < aResult->length(); ++i ) + for ( SMESH::smIdType i = 0; i < aResult->length(); ++i ) aResult[ i ] = nn[ i ]->GetID(); } } @@ -4706,10 +5576,11 @@ SMESH::long_array* SMESH_Mesh_i::GetElemFaceNodes(CORBA::Long elemId, return aResult._retn(); } -//======================================================================= -//function : GetElemFaceNodes -//purpose : Returns three components of normal of given mesh face. -//======================================================================= +//================================================================================ +/*! + * \brief Return three components of normal of given mesh face. + */ +//================================================================================ SMESH::double_array* SMESH_Mesh_i::GetFaceNormal(CORBA::Long elemId, CORBA::Boolean normalized) @@ -4733,12 +5604,13 @@ SMESH::double_array* SMESH_Mesh_i::GetFaceNormal(CORBA::Long elemId, return aResult._retn(); } -//======================================================================= -//function : FindElementByNodes -//purpose : Returns an element based on all given nodes. -//======================================================================= +//================================================================================ +/*! + * \brief Return an element based on all given nodes. + */ +//================================================================================ -CORBA::Long SMESH_Mesh_i::FindElementByNodes(const SMESH::long_array& nodes) +SMESH::smIdType SMESH_Mesh_i::FindElementByNodes(const SMESH::smIdType_array& nodes) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4768,18 +5640,18 @@ CORBA::Long SMESH_Mesh_i::FindElementByNodes(const SMESH::long_array& nodes) */ //================================================================================ -SMESH::long_array* SMESH_Mesh_i::GetElementsByNodes(const SMESH::long_array& nodes, - SMESH::ElementType elemType) +SMESH::smIdType_array* SMESH_Mesh_i::GetElementsByNodes(const SMESH::smIdType_array& nodes, + SMESH::ElementType elemType) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); - SMESH::long_array_var result = new SMESH::long_array(); + SMESH::smIdType_array_var result = new SMESH::smIdType_array(); if ( SMESHDS_Mesh* mesh = _impl->GetMeshDS() ) { vector< const SMDS_MeshNode * > nn( nodes.length() ); - for ( CORBA::ULong i = 0; i < nodes.length(); ++i ) + for ( SMESH::smIdType i = 0; i < nodes.length(); ++i ) nn[i] = mesh->FindNode( nodes[i] ); std::vector elems; @@ -4793,11 +5665,11 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsByNodes(const SMESH::long_array& nod //============================================================================= /*! - * Returns true if given element is polygon + * Return true if given element is polygon */ //============================================================================= -CORBA::Boolean SMESH_Mesh_i::IsPoly(const CORBA::Long id) +CORBA::Boolean SMESH_Mesh_i::IsPoly(const SMESH::smIdType id) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4812,11 +5684,11 @@ CORBA::Boolean SMESH_Mesh_i::IsPoly(const CORBA::Long id) //============================================================================= /*! - * Returns true if given element is quadratic + * Return true if given element is quadratic */ //============================================================================= -CORBA::Boolean SMESH_Mesh_i::IsQuadratic(const CORBA::Long id) +CORBA::Boolean SMESH_Mesh_i::IsQuadratic(const SMESH::smIdType id) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4830,11 +5702,11 @@ CORBA::Boolean SMESH_Mesh_i::IsQuadratic(const CORBA::Long id) //============================================================================= /*! - * Returns diameter of ball discrete element or zero in case of an invalid \a id + * Return diameter of ball discrete element or zero in case of an invalid \a id */ //============================================================================= -CORBA::Double SMESH_Mesh_i::GetBallDiameter(CORBA::Long id) +CORBA::Double SMESH_Mesh_i::GetBallDiameter(SMESH::smIdType id) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4848,11 +5720,11 @@ CORBA::Double SMESH_Mesh_i::GetBallDiameter(CORBA::Long id) //============================================================================= /*! - * Returns bary center for given element + * Return bary center for given element */ //============================================================================= -SMESH::double_array* SMESH_Mesh_i::BaryCenter(const CORBA::Long id) +SMESH::double_array* SMESH_Mesh_i::BaryCenter(const SMESH::smIdType id) { if ( _preMeshInfo ) _preMeshInfo->FullLoadFromFile(); @@ -4906,7 +5778,6 @@ SMESH::double_array* SMESH_Mesh_i::BaryCenter(const CORBA::Long id) SMESH::ListOfGroups* SMESH_Mesh_i::MakeGroupsOfBadInputElements( int theSubShapeID, const char* theGroupName ) - throw ( SALOME::SALOME_Exception ) { Unexpect aCatch(SALOME_SalomeException); @@ -5004,7 +5875,7 @@ void SMESH_Mesh_i::CreateGroupServants() while ( groupIt->more() ) { ::SMESH_Group* group = groupIt->next(); - int anId = group->GetGroupDS()->GetID(); + int anId = group->GetID(); map::iterator it = _mapGroups.find(anId); if ( it != _mapGroups.end() && !CORBA::is_nil( it->second )) @@ -5030,21 +5901,27 @@ void SMESH_Mesh_i::CreateGroupServants() // register CORBA object for persistence int nextId = _gen_i->RegisterObject( groupVar ); if(MYDEBUG) { MESSAGE( "Add group 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 // publishing the groups in the study GEOM::GEOM_Object_var shapeVar = _gen_i->ShapeToGeomObject( shape ); _gen_i->PublishGroup( aMesh, groupVar, shapeVar, group->GetName()); } + if ( !addedIDs.empty() ) { // python dump - set::iterator id = addedIDs.begin(); - for ( ; id != addedIDs.end(); ++id ) + map::iterator i_grp = _mapGroups.begin(); + for ( int index = 0; i_grp != _mapGroups.end(); ++index, ++i_grp ) { - map::iterator it = _mapGroups.find(*id); - int i = std::distance( _mapGroups.begin(), it ); - TPythonDump() << it->second << " = " << aMesh << ".GetGroups()[ "<< i << " ]"; + set::iterator it = addedIDs.find( i_grp->first ); + if ( it != addedIDs.end() ) + { + TPythonDump() << i_grp->second << " = " << aMesh << ".GetGroups()[ "<< index << " ]"; + addedIDs.erase( it ); + if ( addedIDs.empty() ) + break; + } } } } @@ -5153,7 +6030,7 @@ void SMESH_Mesh_i::checkGroupNames() int nbGrp = NbGroups(); if ( !nbGrp ) return; - + SMESH::ListOfGroups* grpList = 0; // avoid dump of "GetGroups" { @@ -5178,7 +6055,7 @@ void SMESH_Mesh_i::checkGroupNames() //============================================================================= /*! - * \brief Sets list of notebook variables used for Mesh operations separated by ":" symbol + * \brief Set list of notebook variables used for Mesh operations separated by ":" symbol */ //============================================================================= void SMESH_Mesh_i::SetParameters(const char* theParameters) @@ -5189,7 +6066,7 @@ void SMESH_Mesh_i::SetParameters(const char* theParameters) //============================================================================= /*! - * \brief Returns list of notebook variables used for Mesh operations separated by ":" symbol + * \brief Return list of notebook variables used for Mesh operations separated by ":" symbol */ //============================================================================= @@ -5200,7 +6077,7 @@ char* SMESH_Mesh_i::GetParameters() //============================================================================= /*! - * \brief Returns list of notebook variables used for last Mesh operation + * \brief Return list of notebook variables used for last Mesh operation */ //============================================================================= SMESH::string_array* SMESH_Mesh_i::GetLastParameters() @@ -5209,7 +6086,7 @@ SMESH::string_array* SMESH_Mesh_i::GetLastParameters() SMESH_Gen_i *gen = SMESH_Gen_i::GetSMESHGen(); if(gen) { CORBA::String_var aParameters = GetParameters(); - SALOMEDS::ListOfListOfStrings_var aSections = SMESH_Gen_i::getStudyServant()->ParseVariables(aParameters); + SALOMEDS::ListOfListOfStrings_var aSections = SMESH_Gen_i::GetSMESHGen()->getStudyServant()->ParseVariables(aParameters); if ( aSections->length() > 0 ) { SALOMEDS::ListOfStrings aVars = aSections[ aSections->length() - 1 ]; aResult->length( aVars.length() ); @@ -5220,10 +6097,11 @@ SMESH::string_array* SMESH_Mesh_i::GetLastParameters() return aResult._retn(); } -//======================================================================= -//function : GetTypes -//purpose : Returns types of elements it contains -//======================================================================= +//================================================================================ +/*! + * \brief Return types of elements it contains + */ +//================================================================================ SMESH::array_of_ElementType* SMESH_Mesh_i::GetTypes() { @@ -5246,21 +6124,25 @@ SMESH::array_of_ElementType* SMESH_Mesh_i::GetTypes() return types._retn(); } -//======================================================================= -//function : GetMesh -//purpose : Returns self -//======================================================================= +//================================================================================ +/*! + * \brief Return self + */ +//================================================================================ SMESH::SMESH_Mesh_ptr SMESH_Mesh_i::GetMesh() { return SMESH::SMESH_Mesh::_duplicate( _this() ); } -//======================================================================= -//function : IsMeshInfoCorrect -//purpose : * Returns false if GetMeshInfo() returns incorrect information that may -// * happen if mesh data is not yet fully loaded from the file of study. -//======================================================================= +//================================================================================ +/*! + * \brief Return false if GetMeshInfo() return incorrect information that may + * happen if mesh data is not yet fully loaded from the file of study. + * + * + */ +//================================================================================ bool SMESH_Mesh_i::IsMeshInfoCorrect() { @@ -5269,16 +6151,16 @@ bool SMESH_Mesh_i::IsMeshInfoCorrect() //============================================================================= /*! - * \brief Returns number of mesh elements per each \a EntityType + * \brief Return number of mesh elements per each \a EntityType */ //============================================================================= -SMESH::long_array* SMESH_Mesh_i::GetMeshInfo() +SMESH::smIdType_array* SMESH_Mesh_i::GetMeshInfo() { if ( _preMeshInfo ) return _preMeshInfo->GetMeshInfo(); - SMESH::long_array_var aRes = new SMESH::long_array(); + SMESH::smIdType_array_var aRes = new SMESH::smIdType_array(); aRes->length(SMESH::Entity_Last); for (int i = SMESH::Entity_Node; i < SMESH::Entity_Last; i++) aRes[i] = 0; @@ -5293,15 +6175,15 @@ SMESH::long_array* SMESH_Mesh_i::GetMeshInfo() //============================================================================= /*! - * \brief Returns number of mesh elements per each \a ElementType + * \brief Return number of mesh elements per each \a ElementType */ //============================================================================= -SMESH::long_array* SMESH_Mesh_i::GetNbElementsByType() +SMESH::smIdType_array* SMESH_Mesh_i::GetNbElementsByType() { - SMESH::long_array_var aRes = new SMESH::long_array(); + SMESH::smIdType_array_var aRes = new SMESH::smIdType_array(); aRes->length(SMESH::NB_ELEMENT_TYPES); - for (int i = 0; i < SMESH::NB_ELEMENT_TYPES; i++) + for (smIdType i = 0; i < SMESH::NB_ELEMENT_TYPES; i++) aRes[ i ] = 0; const SMDS_MeshInfo* meshInfo = 0; @@ -5311,7 +6193,7 @@ SMESH::long_array* SMESH_Mesh_i::GetNbElementsByType() meshInfo = & meshDS->GetMeshInfo(); if (meshInfo) - for (int i = 0; i < SMESH::NB_ELEMENT_TYPES; i++) + for (smIdType i = 0; i < SMESH::NB_ELEMENT_TYPES; i++) aRes[i] = meshInfo->NbElements((SMDSAbs_ElementType)i); return aRes._retn(); @@ -5324,7 +6206,7 @@ SMESH::long_array* SMESH_Mesh_i::GetNbElementsByType() //============================================================================= void SMESH_Mesh_i::CollectMeshInfo(const SMDS_ElemIteratorPtr theItr, - SMESH::long_array& theInfo) + SMESH::smIdType_array& theInfo) { if (!theItr) return; while (theItr->more()) @@ -5332,7 +6214,7 @@ void SMESH_Mesh_i::CollectMeshInfo(const SMDS_ElemIteratorPtr theItr, } //============================================================================= /* - * Returns mesh unstructed grid information. + * Return mesh unstructed grid information. */ //============================================================================= @@ -5349,10 +6231,10 @@ SALOMEDS::TMPFile* SMESH_Mesh_i::GetVtkUgStream() aWriter->Write(); char* str = aWriter->GetOutputString(); int size = aWriter->GetOutputStringLength(); - - //Allocate octect buffer of required size + + //Allocate octet buffer of required size CORBA::Octet* OctetBuf = SALOMEDS::TMPFile::allocbuf(size); - //Copy ostrstream content to the octect buffer + //Copy ostrstream content to the octet buffer memcpy(OctetBuf, str, size); //Create and return TMPFile SeqFile = new SALOMEDS::TMPFile(size, size, OctetBuf, 1); @@ -5373,10 +6255,12 @@ namespace /* Iterators used in SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_v SMDS_ElemIteratorPtr _elemIter; PredicatePtr _predicate; const SMDS_MeshElement* _elem; + SMDSAbs_ElementType _type; - PredicateIterator( SMDS_ElemIteratorPtr iterator, - PredicatePtr predicate): - _elemIter(iterator), _predicate(predicate) + PredicateIterator( SMDS_ElemIteratorPtr iterator, + PredicatePtr predicate, + SMDSAbs_ElementType type): + _elemIter(iterator), _predicate(predicate), _type(type) { next(); } @@ -5390,8 +6274,9 @@ namespace /* Iterators used in SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_v _elem = 0; while ( _elemIter->more() && !_elem ) { - _elem = _elemIter->next(); - if ( _elem && ( !_predicate->IsSatisfy( _elem->GetID() ))) + if ((_elem = _elemIter->next()) && + (( _type != SMDSAbs_All && _type != _elem->GetType() ) || + ( !_predicate->IsSatisfy( _elem->GetID() )))) _elem = 0; } return res; @@ -5401,25 +6286,25 @@ namespace /* Iterators used in SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_v //----------------------------------------------------------------------------- struct IDSourceIterator : public SMDS_ElemIterator { - const CORBA::Long* _idPtr; - const CORBA::Long* _idEndPtr; - SMESH::long_array_var _idArray; - const SMDS_Mesh* _mesh; - const SMDSAbs_ElementType _type; - const SMDS_MeshElement* _elem; - - IDSourceIterator( const SMDS_Mesh* mesh, - const CORBA::Long* ids, - const int nbIds, - SMDSAbs_ElementType type): + const SMESH::smIdType* _idPtr; + const SMESH::smIdType* _idEndPtr; + SMESH::smIdType_array_var _idArray; + const SMDS_Mesh* _mesh; + const SMDSAbs_ElementType _type; + const SMDS_MeshElement* _elem; + + IDSourceIterator( const SMDS_Mesh* mesh, + const SMESH::smIdType* ids, + const smIdType nbIds, + SMDSAbs_ElementType type): _idPtr( ids ), _idEndPtr( ids + nbIds ), _mesh( mesh ), _type( type ), _elem( 0 ) { if ( _idPtr && nbIds && _mesh ) next(); } - IDSourceIterator( const SMDS_Mesh* mesh, - SMESH::long_array* idArray, - SMDSAbs_ElementType type): + IDSourceIterator( const SMDS_Mesh* mesh, + SMESH::smIdType_array* idArray, + SMDSAbs_ElementType type): _idPtr( 0 ), _idEndPtr( 0 ), _idArray( idArray), _mesh( mesh ), _type( type ), _elem( 0 ) { if ( idArray && _mesh ) @@ -5545,6 +6430,7 @@ SMDS_ElemIteratorPtr SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_ptr theObje else if ( SMESH::Filter_i* filter_i = SMESH::DownCast( theObject )) { if ( filter_i->GetElementType() == theType || + filter_i->GetElementType() == SMESH::ALL || elemType == SMDSAbs_Node || elemType == SMDSAbs_All) { @@ -5553,8 +6439,10 @@ SMDS_ElemIteratorPtr SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_ptr theObje { SMDSAbs_ElementType filterType = SMDSAbs_ElementType( filter_i->GetElementType() ); SMDS_ElemIteratorPtr allElemIt = meshDS->elementsIterator( filterType ); - elemIt = SMDS_ElemIteratorPtr( new PredicateIterator( allElemIt, pred_i->GetPredicate() )); - typeOK = ( filterType == elemType || elemType == SMDSAbs_All ); + SMDSAbs_ElementType iterType = elemType == SMDSAbs_Node ? filterType : elemType; + elemIt = SMDS_ElemIteratorPtr + ( new PredicateIterator( allElemIt, pred_i->GetPredicate(), iterType )); + typeOK = ( elemType == SMDSAbs_Node ? filterType == SMDSAbs_Node : elemIt->more() ); } } } @@ -5564,16 +6452,17 @@ SMDS_ElemIteratorPtr SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_ptr theObje const bool isNodes = ( types->length() == 1 && types[0] == SMESH::NODE ); if ( isNodes && elemType != SMDSAbs_Node && elemType != SMDSAbs_All ) return elemIt; + SMDSAbs_ElementType iterType = isNodes ? SMDSAbs_Node : elemType; if ( SMESH_MeshEditor_i::IsTemporaryIDSource( theObject )) { - int nbIds; - if ( CORBA::Long* ids = SMESH_MeshEditor_i::GetTemporaryIDs( theObject, nbIds )) - elemIt = SMDS_ElemIteratorPtr( new IDSourceIterator( meshDS, ids, nbIds, elemType )); + SMESH::smIdType nbIds; + if ( SMESH::smIdType* ids = SMESH_MeshEditor_i::GetTemporaryIDs( theObject, nbIds )) + elemIt = SMDS_ElemIteratorPtr( new IDSourceIterator( meshDS, ids, nbIds, iterType )); } else { - SMESH::long_array_var ids = theObject->GetIDs(); - elemIt = SMDS_ElemIteratorPtr( new IDSourceIterator( meshDS, ids._retn(), elemType )); + SMESH::smIdType_array_var ids = theObject->GetIDs(); + elemIt = SMDS_ElemIteratorPtr( new IDSourceIterator( meshDS, ids._retn(), iterType )); } typeOK = ( isNodes == ( elemType == SMDSAbs_Node )) || ( elemType == SMDSAbs_All ); } @@ -5628,8 +6517,8 @@ class SMESH_DimHyp //! fields int _dim; //!< a dimension the algo can build (concurrent dimension) int _ownDim; //!< dimension of shape of _subMesh (>=_dim) - TopTools_MapOfShape _shapeMap; - SMESH_subMesh* _subMesh; + TopTools_MapOfShape _shapeMap; //!< [sub-]shapes of dimension == _dim + const SMESH_subMesh* _subMesh; list _hypotheses; //!< algo is first, then its parameters //----------------------------------------------------------------------------- @@ -5643,7 +6532,7 @@ class SMESH_DimHyp const int theDim, const TopoDS_Shape& theShape) { - _subMesh = (SMESH_subMesh*)theSubMesh; + _subMesh = theSubMesh; SetShape( theDim, theShape ); } @@ -5673,7 +6562,7 @@ class SMESH_DimHyp TopTools_MapIteratorOfMapOfShape anItr( theToCheck ); for (; !isShared && anItr.More(); anItr.Next() ) { - const TopoDS_Shape aSubSh = anItr.Key(); + const TopoDS_Shape& aSubSh = anItr.Key(); // check for case when concurrent dimensions are same isShared = theToFind.Contains( aSubSh ); // check for sub-shape with concurrent dimension @@ -5683,7 +6572,7 @@ class SMESH_DimHyp } return isShared; } - + //----------------------------------------------------------------------------- //! check algorithms static bool checkAlgo(const SMESHDS_Hypothesis* theA1, @@ -5697,7 +6586,7 @@ class SMESH_DimHyp return strcmp( theA1->GetName(), theA2->GetName() ) == 0; } - + //----------------------------------------------------------------------------- //! Check if sub-shape hypotheses are concurrent bool IsConcurrent(const SMESH_DimHyp* theOther) const @@ -5715,19 +6604,25 @@ class SMESH_DimHyp if ( (_ownDim == _dim || theOther->_ownDim == _dim ) && (!meIsCompound || !otherIsCompound)) return false; -// bool checkSubShape = ( _dim >= theOther->_dim ) -// ? isShareSubShapes( _shapeMap, theOther->_shapeMap, shapeTypeByDim(theOther->_dim) ) -// : isShareSubShapes( theOther->_shapeMap, _shapeMap, shapeTypeByDim(_dim) ) ; bool checkSubShape = isShareSubShapes( _shapeMap, theOther->_shapeMap, shapeTypeByDim(_dim)); if ( !checkSubShape ) - return false; + return false; // check algorithms to be same - if ( !checkAlgo( this->GetAlgo(), theOther->GetAlgo() )) - return true; // different algorithms -> concurrency ! + const SMESH_Algo* a1 = this->GetAlgo(); + const SMESH_Algo* a2 = theOther->GetAlgo(); + bool isSame = checkAlgo( a1, a2 ); + if ( !isSame ) + { + return true; + // commented off for IPAL54678 + // if ( !a1 || !a2 ) + // return false; // pb? + // return a1->GetDim() == a2->GetDim(); // different algorithms of same dim -> concurrency ! + } // check hypothesises for concurrence (skip first as algorithm) - int nbSame = 0; + size_t nbSame = 0; // pointers should be same, because it is referened from mesh hypothesis partition list ::const_iterator hypIt = _hypotheses.begin(); list ::const_iterator otheEndIt = theOther->_hypotheses.end(); @@ -5735,7 +6630,7 @@ class SMESH_DimHyp if ( find( theOther->_hypotheses.begin(), otheEndIt, *hypIt ) != otheEndIt ) nbSame++; // the submeshes are concurrent if their algorithms has different parameters - return nbSame != (int)theOther->_hypotheses.size() - 1; + return nbSame != theOther->_hypotheses.size() - 1; } // Return true if algorithm of this SMESH_DimHyp is used if no @@ -5749,7 +6644,7 @@ class SMESH_DimHyp return ( this->_subMesh->GetId() < theOther->_subMesh->GetId() ); } - + }; // end of SMESH_DimHyp //----------------------------------------------------------------------------- @@ -5757,20 +6652,24 @@ typedef list TDimHypList; //----------------------------------------------------------------------------- -void addDimHypInstance(const int theDim, +void addDimHypInstance(const int theDim, const TopoDS_Shape& theShape, const SMESH_Algo* theAlgo, const SMESH_subMesh* theSubMesh, const list & theHypList, TDimHypList* theDimHypListArr ) { + if ( !theAlgo->NeedDiscreteBoundary() && + theAlgo->NeedLowerHyps( theDim )) // IPAL54678 + return; TDimHypList& listOfdimHyp = theDimHypListArr[theDim]; - if ( listOfdimHyp.empty() || listOfdimHyp.back()->_subMesh != theSubMesh ) { + if ( listOfdimHyp.empty() || listOfdimHyp.back()->_subMesh != theSubMesh ) + { SMESH_DimHyp* dimHyp = new SMESH_DimHyp( theSubMesh, theDim, theShape ); dimHyp->_hypotheses.push_front(theAlgo); listOfdimHyp.push_back( dimHyp ); } - + SMESH_DimHyp* dimHyp = const_cast( listOfdimHyp.back() ); dimHyp->_hypotheses.insert( dimHyp->_hypotheses.end(), theHypList.begin(), theHypList.end() ); @@ -5816,12 +6715,16 @@ void findConcurrents(const SMESH_DimHyp* theDimHyp, } //----------------------------------------------------------------------------- -void unionLists(TListOfInt& theListOfId, +bool unionLists(TListOfInt& theListOfId, TListOfListOfInt& theListOfListOfId, const int theIndx ) { + bool changed = false; + if ( theListOfId.empty() ) + return changed; TListOfListOfInt::iterator it = theListOfListOfId.begin(); - for ( int i = 0; it != theListOfListOfId.end(); it++, i++ ) { + for ( int i = 0; it != theListOfListOfId.end(); it++, i++ ) + { if ( i < theIndx ) continue; //skip already treated lists // check if other list has any same submesh object @@ -5829,16 +6732,20 @@ void unionLists(TListOfInt& theListOfId, if ( find_first_of( theListOfId.begin(), theListOfId.end(), otherListOfId.begin(), otherListOfId.end() ) == theListOfId.end() ) continue; - + // union two lists (from source into target) TListOfInt::iterator it2 = otherListOfId.begin(); for ( ; it2 != otherListOfId.end(); it2++ ) { if ( find( theListOfId.begin(), theListOfId.end(), (*it2) ) == theListOfId.end() ) + { theListOfId.push_back(*it2); + changed = true; + } } // clear source list otherListOfId.clear(); } + return changed; } //----------------------------------------------------------------------------- @@ -5906,7 +6813,7 @@ CORBA::Boolean SMESH_Mesh_i::IsUnorderedSubMesh(CORBA::Long submeshID) //============================================================================= /*! - * \brief Return submesh objects list in meshing order + * \brief Return sub-mesh objects list in meshing order */ //============================================================================= @@ -5922,10 +6829,15 @@ SMESH::submesh_array_array* SMESH_Mesh_i::GetMeshOrder() TListOfListOfInt allConurrent = findConcurrentSubMeshes(); anOrder.splice( anOrder.end(), allConurrent ); - int listIndx = 0; - TListOfListOfInt::iterator listIt = anOrder.begin(); - for(; listIt != anOrder.end(); listIt++, listIndx++ ) - unionLists( *listIt, anOrder, listIndx + 1 ); + bool changed; + do { + changed = false; + TListOfListOfInt::iterator listIt = anOrder.begin(); + for ( int listIndx = 1; listIt != anOrder.end(); listIt++, listIndx++ ) + if ( unionLists( *listIt, anOrder, listIndx )) + changed = true; + } + while ( changed ); // convert submesh ids into interface instances // and dump command into python @@ -5944,82 +6856,87 @@ TListOfListOfInt SMESH_Mesh_i::findConcurrentSubMeshes() { TListOfListOfInt anOrder; ::SMESH_Mesh& mesh = GetImpl(); - { - // collect submeshes and detect concurrent algorithms and hypothesises - TDimHypList dimHypListArr[4]; // dimHyp list for each shape dimension - - map::iterator i_sm = _mapSubMesh.begin(); - for ( ; i_sm != _mapSubMesh.end(); i_sm++ ) { - ::SMESH_subMesh* sm = (*i_sm).second; - // shape of submesh - const TopoDS_Shape& aSubMeshShape = sm->GetSubShape(); - - // list of assigned hypothesises - const list & hypList = mesh.GetHypothesisList(aSubMeshShape); - // Find out dimensions where the submesh can be concurrent. - // We define the dimensions by algo of each of hypotheses in hypList - list ::const_iterator hypIt = hypList.begin(); - for( ; hypIt != hypList.end(); hypIt++ ) { - SMESH_Algo* anAlgo = 0; - const SMESH_Hypothesis* hyp = dynamic_cast(*hypIt); - if ( hyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO ) - // hyp it-self is algo - anAlgo = (SMESH_Algo*)dynamic_cast(hyp); - else { - // try to find algorithm with help of sub-shapes - TopExp_Explorer anExp( aSubMeshShape, shapeTypeByDim(hyp->GetDim()) ); - for ( ; !anAlgo && anExp.More(); anExp.Next() ) - anAlgo = mesh.GetGen()->GetAlgo( mesh, anExp.Current() ); - } - if (!anAlgo) - continue; // no algorithm assigned to a current submesh - int dim = anAlgo->GetDim(); // top concurrent dimension (see comment to SMESH_DimHyp) - // the submesh can concurrent at (or lower dims if !anAlgo->NeedDiscreteBoundary()) + // collect submeshes and detect concurrent algorithms and hypothesises + TDimHypList dimHypListArr[4]; // dimHyp list for each shape dimension - // create instance of dimension-hypothesis for found concurrent dimension(s) and algorithm - for ( int j = anAlgo->NeedDiscreteBoundary() ? dim : 1, jn = dim; j <= jn; j++ ) - addDimHypInstance( j, aSubMeshShape, anAlgo, sm, hypList, dimHypListArr ); + map::iterator i_sm = _mapSubMesh.begin(); + for ( ; i_sm != _mapSubMesh.end(); i_sm++ ) + { + ::SMESH_subMesh* sm = (*i_sm).second; + // shape of submesh + const TopoDS_Shape& aSubMeshShape = sm->GetSubShape(); + + // list of assigned hypothesises + const list & hypList = mesh.GetHypothesisList(aSubMeshShape); + // Find out dimensions where the submesh can be concurrent. + // We define the dimensions by algo of each of hypotheses in hypList + list ::const_iterator hypIt = hypList.begin(); + for( ; hypIt != hypList.end(); hypIt++ ) + { + SMESH_Algo* anAlgo = 0; + const SMESH_Hypothesis* hyp = dynamic_cast(*hypIt); + if ( hyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO ) + // hyp it-self is algo + anAlgo = (SMESH_Algo*)dynamic_cast(hyp); + else { + // try to find algorithm with help of sub-shapes + TopExp_Explorer anExp( aSubMeshShape, shapeTypeByDim(hyp->GetDim()) ); + for ( ; !anAlgo && anExp.More(); anExp.Next() ) + anAlgo = mesh.GetGen()->GetAlgo( mesh, anExp.Current() ); } - } // end iterations on submesh - + if (!anAlgo) + continue; // no algorithm assigned to a current submesh + + int dim = anAlgo->GetDim(); // top concurrent dimension (see comment to SMESH_DimHyp) + // the submesh can concurrent at (or lower dims if !anAlgo->NeedDiscreteBoundary() + // and !anAlgo->NeedLowerHyps( dim )) + + // create instance of dimension-hypothesis for found concurrent dimension(s) and algorithm + for ( int j = anAlgo->NeedDiscreteBoundary() ? dim : 1, jn = dim; j <= jn; j++ ) + addDimHypInstance( j, aSubMeshShape, anAlgo, sm, hypList, dimHypListArr ); + } + } // end iterations on submesh + // iterate on created dimension-hypotheses and check for concurrents - for ( int i = 0; i < 4; i++ ) { - const TDimHypList& listOfDimHyp = dimHypListArr[i]; - // check for concurrents in own and other dimensions (step-by-step) - TDimHypList::const_iterator dhIt = listOfDimHyp.begin(); - for ( ; dhIt != listOfDimHyp.end(); dhIt++ ) { - const SMESH_DimHyp* dimHyp = *dhIt; - TDimHypList listOfConcurr; - set setOfConcurrIds; - // looking for concurrents and collect into own list - for ( int j = i; j < 4; j++ ) - findConcurrents( dimHyp, dimHypListArr[j], listOfConcurr, setOfConcurrIds ); - // check if any concurrents found - if ( listOfConcurr.size() > 0 ) { - // add own submesh to list of concurrent - addInOrderOfPriority( dimHyp, listOfConcurr ); - list listOfConcurrIds; - TDimHypList::iterator hypIt = listOfConcurr.begin(); - for ( ; hypIt != listOfConcurr.end(); ++hypIt ) - listOfConcurrIds.push_back( (*hypIt)->_subMesh->GetId() ); - anOrder.push_back( listOfConcurrIds ); - } + for ( int i = 0; i < 4; i++ ) + { + const TDimHypList& listOfDimHyp = dimHypListArr[i]; + // check for concurrents in own and other dimensions (step-by-step) + TDimHypList::const_iterator dhIt = listOfDimHyp.begin(); + for ( ; dhIt != listOfDimHyp.end(); dhIt++ ) + { + const SMESH_DimHyp* dimHyp = *dhIt; + TDimHypList listOfConcurr; + set setOfConcurrIds; + // looking for concurrents and collect into own list + for ( int j = i; j < 4; j++ ) + findConcurrents( dimHyp, dimHypListArr[j], listOfConcurr, setOfConcurrIds ); + // check if any concurrents found + if ( listOfConcurr.size() > 0 ) + { + // add own submesh to list of concurrent + addInOrderOfPriority( dimHyp, listOfConcurr ); + list listOfConcurrIds; + TDimHypList::iterator hypIt = listOfConcurr.begin(); + for ( ; hypIt != listOfConcurr.end(); ++hypIt ) + listOfConcurrIds.push_back( (*hypIt)->_subMesh->GetId() ); + anOrder.push_back( listOfConcurrIds ); } } - - removeDimHyps(dimHypListArr); - - // now, minimize the number of concurrent groups - // Here we assume that lists of submeshes can have same submesh - // in case of multi-dimension algorithms, as result - // list with common submesh has to be united into one list - int listIndx = 0; - TListOfListOfInt::iterator listIt = anOrder.begin(); - for(; listIt != anOrder.end(); listIt++, listIndx++ ) - unionLists( *listIt, anOrder, listIndx + 1 ); } + removeDimHyps(dimHypListArr); + + // now, minimize the number of concurrent groups + // Here we assume that lists of submeshes can have same submesh + // in case of multi-dimension algorithms, as result + // list with common submesh has to be united into one list + int listIndx = 0; + TListOfListOfInt::iterator listIt = anOrder.begin(); + for(; listIt != anOrder.end(); listIt++, listIndx++ ) + unionLists( *listIt, anOrder, listIndx + 1 ); + return anOrder; } @@ -6068,17 +6985,21 @@ TListOfListOfInt SMESH_Mesh_i::findConcurrentSubMeshes() aPythonDump << " ]"; subMeshOrder.push_back( subMeshIds ); - // clear collected submeshes + // clear collected sub-meshes set::iterator clrIt = subMeshToClear.begin(); for ( ; clrIt != subMeshToClear.end(); clrIt++ ) if ( SMESH_subMesh* sm = (SMESH_subMesh*)*clrIt ) + { sm->ComputeStateEngine( SMESH_subMesh::CLEAN ); + if ( SMESH_Algo* algo = sm->GetAlgo() ) // #16748 + sm->AlgoStateEngine( SMESH_subMesh::MODIF_HYP, algo ); // to clear a cached algo + } } aPythonDump << " ])"; mesh.SetMeshOrder( subMeshOrder ); res = true; - + SMESH::SMESH_Mesh_var me = _this(); _gen_i->UpdateIcons( me ); @@ -6102,7 +7023,8 @@ void SMESH_Mesh_i::convertMeshOrder (const TListOfListOfInt& theIdsOrder, theResOrder.length(nbSet); TListOfListOfInt::const_iterator it = theIdsOrder.begin(); int listIndx = 0; - for( ; it != theIdsOrder.end(); it++ ) { + for( ; it != theIdsOrder.end(); it++ ) + { // translate submesh identificators into submesh objects // takeing into account real number of concurrent lists const TListOfInt& aSubOrder = (*it); @@ -6115,7 +7037,8 @@ void SMESH_Mesh_i::convertMeshOrder (const TListOfListOfInt& theIdsOrder, aResSubSet->length(aSubOrder.size()); TListOfInt::const_iterator subIt = aSubOrder.begin(); int j; - for( j = 0; subIt != aSubOrder.end(); subIt++ ) { + for( j = 0; subIt != aSubOrder.end(); subIt++ ) + { if ( _mapSubMeshIor.find(*subIt) == _mapSubMeshIor.end() ) continue; SMESH::SMESH_subMesh_var subMesh = @@ -6186,7 +7109,7 @@ SMESH_MeshPartDS::SMESH_MeshPartDS(SMESH::SMESH_IDSource_ptr meshPart): else { TMeshInfo tmpInfo; - SMESH::long_array_var anIDs = meshPart->GetIDs(); + SMESH::smIdType_array_var anIDs = meshPart->GetIDs(); SMESH::array_of_ElementType_var types = meshPart->GetTypes(); if ( types->length() == 1 && types[0] == SMESH::NODE ) // group of nodes { @@ -6255,6 +7178,48 @@ const SMDS_MeshElement * SMESH_MeshPartDS::FindElement(int IDelem) const return 0; } // ------------------------------------------------------------------------------------- +bool SMESH_MeshPartDS::HasNumerationHoles() +{ + if ( _meshDS ) return _meshDS->HasNumerationHoles(); + + return ( MinNodeID() != 1 || + MaxNodeID() != NbNodes() || + MinElementID() != 1 || + MaxElementID() != NbElements() ); +} +// ------------------------------------------------------------------------------------- +smIdType SMESH_MeshPartDS::MaxNodeID() const +{ + if ( _meshDS ) return _meshDS->MaxNodeID(); + return NbNodes() == 0 ? 0 : (*_elements[ SMDSAbs_Node ].rbegin())->GetID(); +} +// ------------------------------------------------------------------------------------- +smIdType SMESH_MeshPartDS::MinNodeID() const +{ + if ( _meshDS ) return _meshDS->MinNodeID(); + return NbNodes() == 0 ? 0 : (*_elements[ SMDSAbs_Node ].begin())->GetID(); +} +// ------------------------------------------------------------------------------------- +smIdType SMESH_MeshPartDS::MaxElementID() const +{ + if ( _meshDS ) return _meshDS->MaxElementID(); + smIdType maxID = 0; + for ( int iType = SMDSAbs_Edge; iType < SMDSAbs_NbElementTypes; ++iType ) + if ( !_elements[ iType ].empty() ) + maxID = std::max( maxID, (*_elements[ iType ].rbegin())->GetID() ); + return maxID; +} +// ------------------------------------------------------------------------------------- +smIdType SMESH_MeshPartDS::MinElementID() const +{ + if ( _meshDS ) return _meshDS->MinElementID(); + smIdType minID = 0; + for ( int iType = SMDSAbs_Edge; iType < SMDSAbs_NbElementTypes; ++iType ) + if ( !_elements[ iType ].empty() ) + minID = std::min( minID, (*_elements[ iType ].begin())->GetID() ); + return minID; +} +// ------------------------------------------------------------------------------------- SMDS_ElemIteratorPtr SMESH_MeshPartDS::elementGeomIterator(SMDSAbs_GeometryType geomType) const { if ( _meshDS ) return _meshDS->elementGeomIterator( geomType ); @@ -6327,5 +7292,3 @@ _GET_ITER_DEFINE( SMDS_VolumeIteratorPtr, volumesIterator, SMDS_MeshVolume, SMDS // END Implementation of SMESH_MeshPartDS // //================================================================================ - -