X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH%2FSMESH_Mesh.cxx;h=13747255c7afff32fca9f70317b74800fa29c528;hb=dad744364c27f488c40d4357699ac6cd9d779330;hp=0b361a52ba302c4eb2285dee267a39119f3fe326;hpb=79b1ac2b6df9117f16f11d444b1f165d477a1813;p=modules%2Fsmesh.git diff --git a/src/SMESH/SMESH_Mesh.cxx b/src/SMESH/SMESH_Mesh.cxx index 0b361a52b..8d0d9392b 100644 --- a/src/SMESH/SMESH_Mesh.cxx +++ b/src/SMESH/SMESH_Mesh.cxx @@ -1,56 +1,67 @@ -// SMESH SMESH : implementaion of SMESH idl descriptions +// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE // -// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. // +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // + // File : SMESH_Mesh.cxx // Author : Paul RASCLE, EDF // Module : SMESH -// $Header$ - +// #include "SMESH_Mesh.hxx" -#include "SMESH_subMesh.hxx" +#include "SMESH_MesherHelper.hxx" +#include "SMDS_MeshVolume.hxx" +#include "SMDS_SetIterator.hxx" +#include "SMESHDS_Document.hxx" +#include "SMESHDS_Group.hxx" +#include "SMESHDS_GroupOnGeom.hxx" +#include "SMESHDS_Script.hxx" +#include "SMESHDS_TSubMeshHolder.hxx" #include "SMESH_Gen.hxx" -#include "SMESH_Hypothesis.hxx" #include "SMESH_Group.hxx" #include "SMESH_HypoFilter.hxx" -#include "SMESHDS_Group.hxx" -#include "SMESHDS_Script.hxx" -#include "SMESHDS_GroupOnGeom.hxx" -#include "SMESHDS_Document.hxx" -#include "SMDS_MeshVolume.hxx" -#include "SMDS_SetIterator.hxx" +#include "SMESH_Hypothesis.hxx" +#include "SMESH_subMesh.hxx" #include "utilities.h" -#include "DriverMED_W_SMESHDS_Mesh.h" #include "DriverDAT_W_SMDS_Mesh.h" -#include "DriverUNV_W_SMDS_Mesh.h" -#include "DriverSTL_W_SMDS_Mesh.h" - +#include "DriverGMF_Read.hxx" +#include "DriverGMF_Write.hxx" #include "DriverMED_R_SMESHDS_Mesh.h" -#include "DriverUNV_R_SMDS_Mesh.h" +#include "DriverMED_W_SMESHDS_Mesh.h" #include "DriverSTL_R_SMDS_Mesh.h" +#include "DriverSTL_W_SMDS_Mesh.h" +#include "DriverUNV_R_SMDS_Mesh.h" +#include "DriverUNV_W_SMDS_Mesh.h" +#ifdef WITH_CGNS +#include "DriverCGNS_Read.hxx" +#include "DriverCGNS_Write.hxx" +#endif + +#include +#undef _Precision_HeaderFile +#include #include +#include +#include #include #include #include @@ -58,8 +69,17 @@ #include #include +#include "SMESH_TryCatch.hxx" // include after OCCT headers! + #include "Utils_ExceptHandlers.hxx" +#ifndef WIN32 +#include +#include +#else +#include +#endif + // maximum stored group name length in MED file #define MAX_MED_GROUP_NAME_LENGTH 80 @@ -73,47 +93,179 @@ static int MYDEBUG = 0; typedef SMESH_HypoFilter THypType; +class SMESH_Mesh::SubMeshHolder : public SMESHDS_TSubMeshHolder< SMESH_subMesh > +{ +}; + //============================================================================= /*! * */ //============================================================================= -SMESH_Mesh::SMESH_Mesh(int theLocalId, - int theStudyId, - SMESH_Gen* theGen, - bool theIsEmbeddedMode, - SMESHDS_Document* theDocument): - _groupId( 0 ) +SMESH_Mesh::SMESH_Mesh(int theLocalId, + SMESH_Gen* theGen, + bool theIsEmbeddedMode, + SMESHDS_Document* theDocument): + _groupId( 0 ), _nbSubShapes( 0 ) { - MESSAGE("SMESH_Mesh::SMESH_Mesh(int localId)"); + if(MYDEBUG) MESSAGE("SMESH_Mesh::SMESH_Mesh(int localId)"); _id = theLocalId; - _studyId = theStudyId; _gen = theGen; - _myDocument = theDocument; - _idDoc = theDocument->NewMesh(theIsEmbeddedMode); - _myMeshDS = theDocument->GetMesh(_idDoc); + _document = theDocument; + _meshDS = theDocument->NewMesh(theIsEmbeddedMode,theLocalId); _isShapeToMesh = false; _isAutoColor = false; - _myMeshDS->ShapeToMesh( PseudoShape() ); + _isModified = false; + _shapeDiagonal = 0.0; + _callUp = NULL; + _meshDS->ShapeToMesh( PseudoShape() ); + _subMeshHolder = new SubMeshHolder; + + // assure unique persistent ID + if ( _document->NbMeshes() > 1 ) + { + std::set< int > ids; + for ( _document->InitMeshesIterator(); _document->MoreMesh(); ) + { + SMESHDS_Mesh * meshDS =_document->NextMesh(); + if ( meshDS != _meshDS ) + ids.insert( meshDS->GetPersistentId() ); + } + + if ( ids.count( _meshDS->GetPersistentId() )) + { + int uniqueID = *ids.rbegin() + 1; + _meshDS->SetPersistentId( uniqueID ); + } + } +} + +//================================================================================ +/*! + * \brief Constructor of SMESH_Mesh being a base of some descendant class + */ +//================================================================================ + +SMESH_Mesh::SMESH_Mesh(): + _id(-1), + _groupId( 0 ), + _nbSubShapes( 0 ), + _isShapeToMesh( false ), + _document( 0 ), + _meshDS( 0 ), + _gen( 0 ), + _isAutoColor( false ), + _isModified( false ), + _shapeDiagonal( 0.0 ), + _callUp( 0 ) +{ + _subMeshHolder = new SubMeshHolder; +} + +namespace +{ +#ifndef WIN32 + void deleteMeshDS(SMESHDS_Mesh* meshDS) + { + //cout << "deleteMeshDS( " << meshDS << endl; + delete meshDS; + } +#else + static void* deleteMeshDS(void* meshDS) + { + //cout << "deleteMeshDS( " << meshDS << endl; + SMESHDS_Mesh* m = (SMESHDS_Mesh*)meshDS; + if(m) { + delete m; + } + return 0; + } +#endif } //============================================================================= /*! - * + * */ //============================================================================= SMESH_Mesh::~SMESH_Mesh() { - INFOS("SMESH_Mesh::~SMESH_Mesh"); + if(MYDEBUG) MESSAGE("SMESH_Mesh::~SMESH_Mesh"); + + if ( _document ) // avoid destructing _meshDS from ~SMESH_Gen() + _document->RemoveMesh( _id ); + _document = 0; + + // remove self from studyContext + if ( _gen ) + { + StudyContextStruct * studyContext = _gen->GetStudyContext(); + studyContext->mapMesh.erase( _id ); + } + + _meshDS->ClearMesh(); + + // issue 0020340: EDF 1022 SMESH : Crash with FindNodeClosestTo in a second new study + // Notify event listeners at least that something happens + if ( SMESH_subMesh * sm = GetSubMeshContaining(1)) + sm->ComputeStateEngine( SMESH_subMesh::MESH_ENTITY_REMOVED ); // delete groups - map < int, SMESH_Group * >::iterator itg; + std::map < int, SMESH_Group * >::iterator itg; for (itg = _mapGroup.begin(); itg != _mapGroup.end(); itg++) { SMESH_Group *aGroup = (*itg).second; delete aGroup; } + _mapGroup.clear(); + + // delete sub-meshes + delete _subMeshHolder; + + if ( _callUp) delete _callUp; + _callUp = 0; + + if ( _meshDS ) { + // delete _meshDS, in a thread in order not to block closing a study with large meshes +#ifndef WIN32 + boost::thread aThread(boost::bind( & deleteMeshDS, _meshDS )); +#else + pthread_t thread; + int result=pthread_create(&thread, NULL, deleteMeshDS, (void*)_meshDS); +#endif + } +} + +//================================================================================ +/*! + * \brief Return true if a mesh with given id exists + */ +//================================================================================ + +bool SMESH_Mesh::MeshExists( int meshId ) const +{ + return _document ? bool( _document->GetMesh( meshId )) : false; +} + +//================================================================================ +/*! + * \brief Return a mesh by id + */ +//================================================================================ + +SMESH_Mesh* SMESH_Mesh::FindMesh( int meshId ) const +{ + if ( _id == meshId ) + return (SMESH_Mesh*) this; + + if ( StudyContextStruct *aStudyContext = _gen->GetStudyContext()) + { + std::map < int, SMESH_Mesh * >::iterator i_m = aStudyContext->mapMesh.find( meshId ); + if ( i_m != aStudyContext->mapMesh.end() ) + return i_m->second; + } + return NULL; } //============================================================================= @@ -126,23 +278,22 @@ void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape) { if(MYDEBUG) MESSAGE("SMESH_Mesh::ShapeToMesh"); - if ( !aShape.IsNull() && _isShapeToMesh ) - throw SALOME_Exception(LOCALIZED ("a shape to mesh has already been defined")); - + if ( !aShape.IsNull() && _isShapeToMesh ) { + if ( aShape.ShapeType() != TopAbs_COMPOUND && // group contents is allowed to change + _meshDS->ShapeToMesh().ShapeType() != TopAbs_COMPOUND ) + throw SALOME_Exception(LOCALIZED ("a shape to mesh has already been defined")); + } // clear current data - if ( !_myMeshDS->ShapeToMesh().IsNull() ) + if ( !_meshDS->ShapeToMesh().IsNull() ) { // removal of a shape to mesh, delete objects referring to sub-shapes: // - sub-meshes - map ::iterator i_sm = _mapSubMesh.begin(); - for ( ; i_sm != _mapSubMesh.end(); ++i_sm ) - delete i_sm->second; - _mapSubMesh.clear(); + _subMeshHolder->DeleteAll(); // - groups on geometry - map ::iterator i_gr = _mapGroup.begin(); + std::map ::iterator i_gr = _mapGroup.begin(); while ( i_gr != _mapGroup.end() ) { if ( dynamic_cast( i_gr->second->GetGroupDS() )) { - _myMeshDS->RemoveGroup( i_gr->second->GetGroupDS() ); + _meshDS->RemoveGroup( i_gr->second->GetGroupDS() ); delete i_gr->second; _mapGroup.erase( i_gr++ ); } @@ -153,24 +304,28 @@ void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape) // clear SMESHDS TopoDS_Shape aNullShape; - _myMeshDS->ShapeToMesh( aNullShape ); + _meshDS->ShapeToMesh( aNullShape ); + + _shapeDiagonal = 0.0; } // set a new geometry if ( !aShape.IsNull() ) { - _myMeshDS->ShapeToMesh(aShape); + _meshDS->ShapeToMesh(aShape); _isShapeToMesh = true; + _nbSubShapes = _meshDS->MaxShapeIndex(); - // fill _mapAncestors - int desType, ancType; - for ( desType = TopAbs_VERTEX; desType > TopAbs_COMPOUND; desType-- ) - for ( ancType = desType - 1; ancType >= TopAbs_COMPOUND; ancType-- ) - TopExp::MapShapesAndAncestors ( aShape, - (TopAbs_ShapeEnum) desType, - (TopAbs_ShapeEnum) ancType, - _mapAncestors ); + // fill map of ancestors + fillAncestorsMap(aShape); + } + else + { + _isShapeToMesh = false; + _shapeDiagonal = 0.0; + _meshDS->ShapeToMesh( PseudoShape() ); } + _isModified = false; } //======================================================================= @@ -181,7 +336,7 @@ void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape) TopoDS_Shape SMESH_Mesh::GetShapeToMesh() const { - return _myMeshDS->ShapeToMesh(); + return _meshDS->ShapeToMesh(); } //======================================================================= @@ -201,94 +356,192 @@ const TopoDS_Solid& SMESH_Mesh::PseudoShape() return aSolid; } +//======================================================================= +/*! + * \brief Return diagonal size of bounding box of a shape + */ +//======================================================================= + +double SMESH_Mesh::GetShapeDiagonalSize(const TopoDS_Shape & aShape) +{ + if ( !aShape.IsNull() ) { + Bnd_Box Box; + // avoid too long waiting on large shapes. PreciseBoundingBox() was added + // to assure same result which else depends on presence of triangulation (IPAL52557). + const int maxNbFaces = 4000; + int nbFaces = 0; + for ( TopExp_Explorer f( aShape, TopAbs_FACE ); f.More() && nbFaces < maxNbFaces; f.Next() ) + ++nbFaces; + bool isPrecise = false; + if ( nbFaces < maxNbFaces ) + try { + OCC_CATCH_SIGNALS; + GEOMUtils::PreciseBoundingBox( aShape, Box ); + isPrecise = true; + } + catch (...) { + isPrecise = false; + } + if ( !isPrecise ) + { + BRepBndLib::Add( aShape, Box ); + } + if ( !Box.IsVoid() ) + return sqrt( Box.SquareExtent() ); + } + return 0; +} + +//======================================================================= +/*! + * \brief Return diagonal size of bounding box of shape to mesh + */ +//======================================================================= + +double SMESH_Mesh::GetShapeDiagonalSize() const +{ + if ( _shapeDiagonal == 0. && _isShapeToMesh ) + const_cast(this)->_shapeDiagonal = GetShapeDiagonalSize( GetShapeToMesh() ); + + return _shapeDiagonal; +} + +//================================================================================ +/*! + * \brief Load mesh from study file + */ +//================================================================================ + +void SMESH_Mesh::Load() +{ + if (_callUp) + _callUp->Load(); +} + +//======================================================================= +/*! + * \brief Remove all nodes and elements + */ +//======================================================================= + +void SMESH_Mesh::Clear() +{ + if ( HasShapeToMesh() ) // remove all nodes and elements + { + // clear mesh data + _meshDS->ClearMesh(); + + // update compute state of submeshes + if ( SMESH_subMesh *sm = GetSubMeshContaining( GetShapeToMesh() ) ) + { + sm->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE ); + sm->ComputeSubMeshStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE ); + sm->ComputeStateEngine( SMESH_subMesh::CLEAN ); // for event listeners (issue 0020918) + sm->ComputeSubMeshStateEngine( SMESH_subMesh::CLEAN ); + } + } + else // remove only nodes/elements computed by algorithms + { + if ( SMESH_subMesh *sm = GetSubMeshContaining( GetShapeToMesh() ) ) + { + sm->ComputeStateEngine( SMESH_subMesh::CLEAN ); + sm->ComputeSubMeshStateEngine( SMESH_subMesh::CLEAN ); + sm->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE ); + sm->ComputeSubMeshStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE ); + } + } + GetMeshDS()->Modified(); + _isModified = false; +} + +//======================================================================= +/*! + * \brief Remove all nodes and elements of indicated shape + */ +//======================================================================= + +void SMESH_Mesh::ClearSubMesh(const int theShapeId) +{ + // clear sub-meshes; get ready to re-compute as a side-effect + if ( SMESH_subMesh *sm = GetSubMeshContaining( theShapeId ) ) + { + SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/true, + /*complexShapeFirst=*/false); + while ( smIt->more() ) + { + sm = smIt->next(); + TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType(); + if ( shapeType == TopAbs_VERTEX || shapeType < TopAbs_SOLID ) + // all other shapes depends on vertices so they are already cleaned + sm->ComputeStateEngine( SMESH_subMesh::CLEAN ); + // to recompute even if failed + sm->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE ); + } + } +} + //======================================================================= //function : UNVToMesh -//purpose : +//purpose : //======================================================================= int SMESH_Mesh::UNVToMesh(const char* theFileName) { - if(MYDEBUG) MESSAGE("UNVToMesh - theFileName = "<NbNodes() = "<<_myMeshDS->NbNodes()); - MESSAGE("UNVToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges()); - MESSAGE("UNVToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces()); - MESSAGE("UNVToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes()); - } - SMDS_MeshGroup* aGroup = (SMDS_MeshGroup*) myReader.GetGroup(); - if (aGroup != 0) { - TGroupNamesMap aGroupNames = myReader.GetGroupNamesMap(); - //const TGroupIdMap& aGroupId = myReader.GetGroupIdMap(); - aGroup->InitSubGroupsIterator(); - while (aGroup->MoreSubGroups()) { - SMDS_MeshGroup* aSubGroup = (SMDS_MeshGroup*) aGroup->NextSubGroup(); - std::string aName = aGroupNames[aSubGroup]; - int aId; - - SMESH_Group* aSMESHGroup = AddGroup( aSubGroup->GetType(), aName.c_str(), aId ); - if ( aSMESHGroup ) { - if(MYDEBUG) MESSAGE("UNVToMesh - group added: "<( aSMESHGroup->GetGroupDS() ); - if ( aGroupDS ) { - aGroupDS->SetStoreName(aName.c_str()); - aSubGroup->InitIterator(); - const SMDS_MeshElement* aElement = 0; - while (aSubGroup->More()) { - aElement = aSubGroup->Next(); - if (aElement) { - aGroupDS->SMDSGroup().Add(aElement); - } - } - if (aElement) - aGroupDS->SetType(aElement->GetType()); - } - } - } + + TGroupNamesMap& aGroupNames = myReader.GetGroupNamesMap(); + TGroupNamesMap::iterator gr2names; + int anId = 1 + ( _mapGroup.empty() ? 0 : _mapGroup.rbegin()->first ); + for ( gr2names = aGroupNames.begin(); gr2names != aGroupNames.end(); ++gr2names ) + { + SMDS_MeshGroup* aGroup = gr2names->first; + const std::string& aName = gr2names->second; + SMESHDS_Group* aGroupDS = new SMESHDS_Group( anId++, _meshDS, aGroup->GetType() ); + aGroupDS->SMDSGroup() = std::move( *aGroup ); + aGroupDS->SetStoreName( aName.c_str() ); + AddGroup( aGroupDS ); } + return 1; } //======================================================================= //function : MEDToMesh -//purpose : +//purpose : //======================================================================= int SMESH_Mesh::MEDToMesh(const char* theFileName, const char* theMeshName) { - if(MYDEBUG) MESSAGE("MEDToMesh - theFileName = "<NbNodes() = "<<_myMeshDS->NbNodes()); - MESSAGE("MEDToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges()); - MESSAGE("MEDToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces()); - MESSAGE("MEDToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes()); - } +#ifdef _DEBUG_ + SMESH_ComputeErrorPtr er = myReader.GetError(); + if ( er && !er->IsOK() ) std::cout << er->myComment << std::endl; +#endif // Reading groups (sub-meshes are out of scope of MED import functionality) - list aGroupNames = myReader.GetGroupNamesAndTypes(); - if(MYDEBUG) MESSAGE("MEDToMesh - Nb groups = "<::iterator name_type = aGroupNames.begin(); - for ( ; name_type != aGroupNames.end(); name_type++ ) { - SMESH_Group* aGroup = AddGroup( name_type->second, name_type->first.c_str(), anId ); + std::list aGroupNames = myReader.GetGroupNamesAndTypes(); + std::list::iterator name_type = aGroupNames.begin(); + for ( ; name_type != aGroupNames.end(); name_type++ ) + { + SMESH_Group* aGroup = AddGroup( name_type->second, name_type->first.c_str() ); if ( aGroup ) { - if(MYDEBUG) MESSAGE("MEDToMesh - group added: "<first.c_str()); SMESHDS_Group* aGroupDS = dynamic_cast( aGroup->GetGroupDS() ); if ( aGroupDS ) { aGroupDS->SetStoreName( name_type->first.c_str() ); @@ -296,32 +549,82 @@ int SMESH_Mesh::MEDToMesh(const char* theFileName, const char* theMeshName) } } } + + _meshDS->Modified(); + _meshDS->CompactMesh(); + return (int) status; } //======================================================================= //function : STLToMesh -//purpose : +//purpose : //======================================================================= -int SMESH_Mesh::STLToMesh(const char* theFileName) +std::string SMESH_Mesh::STLToMesh(const char* theFileName) { - if(MYDEBUG) MESSAGE("STLToMesh - theFileName = "<NbNodes() = "<<_myMeshDS->NbNodes()); - MESSAGE("STLToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges()); - MESSAGE("STLToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces()); - MESSAGE("STLToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes()); - } - return 1; + + return myReader.GetName(); +} + +//================================================================================ +/*! + * \brief Reads the given mesh from the CGNS file + * \param theFileName - name of the file + * \retval int - Driver_Mesh::Status + */ +//================================================================================ + +int SMESH_Mesh::CGNSToMesh(const char* theFileName, + const int theMeshIndex, + std::string& theMeshName) +{ + int res = Driver_Mesh::DRS_FAIL; +#ifdef WITH_CGNS + + DriverCGNS_Read myReader; + myReader.SetMesh(_meshDS); + myReader.SetFile(theFileName); + myReader.SetMeshId(theMeshIndex); + res = myReader.Perform(); + theMeshName = myReader.GetMeshName(); + + // create groups + SynchronizeGroups(); + +#endif + return res; +} + +//================================================================================ +/*! + * \brief Fill its data by reading a GMF file + */ +//================================================================================ + +SMESH_ComputeErrorPtr SMESH_Mesh::GMFToMesh(const char* theFileName, + bool theMakeRequiredGroups) +{ + DriverGMF_Read myReader; + myReader.SetMesh(_meshDS); + myReader.SetFile(theFileName); + myReader.SetMakeRequiredGroups( theMakeRequiredGroups ); + myReader.Perform(); + //theMeshName = myReader.GetMeshName(); + + // create groups + SynchronizeGroups(); + + return myReader.GetError(); } //============================================================================= @@ -331,96 +634,78 @@ int SMESH_Mesh::STLToMesh(const char* theFileName) //============================================================================= SMESH_Hypothesis::Hypothesis_Status - SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape, - int anHypId ) throw(SALOME_Exception) +SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape, + int anHypId, + std::string* anError ) { - Unexpect aCatch(SalomeException); if(MYDEBUG) MESSAGE("SMESH_Mesh::AddHypothesis"); + if ( anError ) + anError->clear(); + SMESH_subMesh *subMesh = GetSubMesh(aSubShape); if ( !subMesh || !subMesh->GetId()) return SMESH_Hypothesis::HYP_BAD_SUBSHAPE; - SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS(); - if ( subMeshDS && subMeshDS->IsComplexSubmesh() ) // group of sub-shapes and maybe of not sub- - { - MESSAGE("AddHypothesis() to complex submesh"); - // return the worst but not fatal state of all group memebers - SMESH_Hypothesis::Hypothesis_Status aBestRet, aWorstNotFatal, ret; - aBestRet = SMESH_Hypothesis::HYP_BAD_DIM; - aWorstNotFatal = SMESH_Hypothesis::HYP_OK; - for ( TopoDS_Iterator itS ( aSubShape ); itS.More(); itS.Next()) - { - if ( !GetMeshDS()->ShapeToIndex( itS.Value() )) - continue; // not sub-shape - ret = AddHypothesis( itS.Value(), anHypId ); - if ( !SMESH_Hypothesis::IsStatusFatal( ret ) && ret > aWorstNotFatal ) - aWorstNotFatal = ret; - if ( ret < aBestRet ) - aBestRet = ret; - } - // bind hypotheses to a group just to know - SMESH_Hypothesis *anHyp = _gen->GetStudyContext(_studyId)->mapHypothesis[anHypId]; - GetMeshDS()->AddHypothesis( aSubShape, anHyp ); - - if ( SMESH_Hypothesis::IsStatusFatal( aBestRet )) - return aBestRet; - return aWorstNotFatal; - } - - StudyContextStruct *sc = _gen->GetStudyContext(_studyId); - if (sc->mapHypothesis.find(anHypId) == sc->mapHypothesis.end()) - { - if(MYDEBUG) MESSAGE("Hypothesis ID does not give an hypothesis"); - if(MYDEBUG) { - SCRUTE(_studyId); - SCRUTE(anHypId); - } + SMESH_Hypothesis *anHyp = GetHypothesis( anHypId ); + if ( !anHyp ) throw SALOME_Exception(LOCALIZED("hypothesis does not exist")); - } - - SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId]; - MESSAGE( "SMESH_Mesh::AddHypothesis " << anHyp->GetName() ); bool isGlobalHyp = IsMainShape( aSubShape ); // NotConformAllowed can be only global if ( !isGlobalHyp ) { - string hypName = anHyp->GetName(); + // NOTE: this is not a correct way to check a name of hypothesis, + // there should be an attribute of hypothesis saying that it can/can't + // be global/local + std::string hypName = anHyp->GetName(); if ( hypName == "NotConformAllowed" ) { - if(MYDEBUG) MESSAGE( "Hypotesis can be only global" ); + if(MYDEBUG) MESSAGE( "Hypothesis can be only global" ); return SMESH_Hypothesis::HYP_INCOMPATIBLE; } } - // shape + // shape - bool isAlgo = ( !anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO ); - int event = isAlgo ? SMESH_subMesh::ADD_ALGO : SMESH_subMesh::ADD_HYP; + bool isAlgo = ( anHyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO ); + SMESH_subMesh::algo_event event = isAlgo ? SMESH_subMesh::ADD_ALGO : SMESH_subMesh::ADD_HYP; SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp); - // subShapes - if (!SMESH_Hypothesis::IsStatusFatal(ret) && - anHyp->GetDim() <= SMESH_Gen::GetShapeDim(aSubShape)) // is added on father + if ( anError && SMESH_Hypothesis::IsStatusFatal(ret) && subMesh->GetComputeError() ) + *anError = subMesh->GetComputeError()->myComment; + + // sub-shapes + if ( !SMESH_Hypothesis::IsStatusFatal(ret) && + anHyp->GetDim() <= SMESH_Gen::GetShapeDim(aSubShape)) // is added on father { event = isAlgo ? SMESH_subMesh::ADD_FATHER_ALGO : SMESH_subMesh::ADD_FATHER_HYP; SMESH_Hypothesis::Hypothesis_Status ret2 = - subMesh->SubMeshesAlgoStateEngine(event, anHyp); + subMesh->SubMeshesAlgoStateEngine(event, anHyp, /*exitOnFatal=*/true); if (ret2 > ret) + { ret = ret2; + if ( SMESH_Hypothesis::IsStatusFatal( ret )) + { + if ( anError && subMesh->GetComputeError() ) + *anError = subMesh->GetComputeError()->myComment; + // remove anHyp + event = isAlgo ? SMESH_subMesh::REMOVE_ALGO : SMESH_subMesh::REMOVE_HYP; + subMesh->AlgoStateEngine(event, anHyp); + } + } - // check concurent hypotheses on ansestors - if (ret < SMESH_Hypothesis::HYP_CONCURENT && !isGlobalHyp ) + // check concurrent hypotheses on ancestors + if (ret < SMESH_Hypothesis::HYP_CONCURRENT && !isGlobalHyp ) { SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(false,false); while ( smIt->more() ) { SMESH_subMesh* sm = smIt->next(); - if ( sm->IsApplicableHypotesis( anHyp )) { - ret2 = sm->CheckConcurentHypothesis( anHyp->GetType() ); + if ( sm->IsApplicableHypothesis( anHyp )) { + ret2 = sm->CheckConcurrentHypothesis( anHyp ); if (ret2 > ret) { ret = ret2; break; @@ -429,9 +714,11 @@ SMESH_Hypothesis::Hypothesis_Status } } } + HasModificationsToDiscard(); // to reset _isModified flag if a mesh becomes empty + GetMeshDS()->Modified(); if(MYDEBUG) subMesh->DumpAlgoState(true); - SCRUTE(ret); + if(MYDEBUG) SCRUTE(ret); return ret; } @@ -442,60 +729,34 @@ SMESH_Hypothesis::Hypothesis_Status //============================================================================= SMESH_Hypothesis::Hypothesis_Status - SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape, - int anHypId)throw(SALOME_Exception) +SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape, + int anHypId) { - Unexpect aCatch(SalomeException); if(MYDEBUG) MESSAGE("SMESH_Mesh::RemoveHypothesis"); - - SMESH_subMesh *subMesh = GetSubMesh(aSubShape); - SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS(); - if ( subMeshDS && subMeshDS->IsComplexSubmesh() ) - { - // return the worst but not fatal state of all group memebers - SMESH_Hypothesis::Hypothesis_Status aBestRet, aWorstNotFatal, ret; - aBestRet = SMESH_Hypothesis::HYP_BAD_DIM; - aWorstNotFatal = SMESH_Hypothesis::HYP_OK; - for ( TopoDS_Iterator itS ( aSubShape ); itS.More(); itS.Next()) - { - if ( !GetMeshDS()->ShapeToIndex( itS.Value() )) - continue; // not sub-shape - ret = RemoveHypothesis( itS.Value(), anHypId ); - if ( !SMESH_Hypothesis::IsStatusFatal( ret ) && ret > aWorstNotFatal ) - aWorstNotFatal = ret; - if ( ret < aBestRet ) - aBestRet = ret; - } - SMESH_Hypothesis *anHyp = _gen->GetStudyContext(_studyId)->mapHypothesis[anHypId]; - GetMeshDS()->RemoveHypothesis( aSubShape, anHyp ); - - if ( SMESH_Hypothesis::IsStatusFatal( aBestRet )) - return aBestRet; - return aWorstNotFatal; - } - StudyContextStruct *sc = _gen->GetStudyContext(_studyId); + StudyContextStruct *sc = _gen->GetStudyContext(); if (sc->mapHypothesis.find(anHypId) == sc->mapHypothesis.end()) throw SALOME_Exception(LOCALIZED("hypothesis does not exist")); - + SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId]; - int hypType = anHyp->GetType(); - if(MYDEBUG) SCRUTE(hypType); - + if(MYDEBUG) { SCRUTE(anHyp->GetType()); } + // shape - - bool isAlgo = ( !anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO ); - int event = isAlgo ? SMESH_subMesh::REMOVE_ALGO : SMESH_subMesh::REMOVE_HYP; + + bool isAlgo = ( !anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO ); + SMESH_subMesh::algo_event event = isAlgo ? SMESH_subMesh::REMOVE_ALGO : SMESH_subMesh::REMOVE_HYP; + + SMESH_subMesh *subMesh = GetSubMesh(aSubShape); SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp); // there may appear concurrent hyps that were covered by the removed hyp - if (ret < SMESH_Hypothesis::HYP_CONCURENT && - subMesh->IsApplicableHypotesis( anHyp ) && - subMesh->CheckConcurentHypothesis( anHyp->GetType() ) != SMESH_Hypothesis::HYP_OK) - ret = SMESH_Hypothesis::HYP_CONCURENT; + if (ret < SMESH_Hypothesis::HYP_CONCURRENT && + subMesh->IsApplicableHypothesis( anHyp ) && + subMesh->CheckConcurrentHypothesis( anHyp ) != SMESH_Hypothesis::HYP_OK) + ret = SMESH_Hypothesis::HYP_CONCURRENT; - // subShapes + // sub-shapes if (!SMESH_Hypothesis::IsStatusFatal(ret) && anHyp->GetDim() <= SMESH_Gen::GetShapeDim(aSubShape)) // is removed from father { @@ -506,14 +767,14 @@ SMESH_Hypothesis::Hypothesis_Status if (ret2 > ret) // more severe ret = ret2; - // check concurent hypotheses on ansestors - if (ret < SMESH_Hypothesis::HYP_CONCURENT && !IsMainShape( aSubShape ) ) + // check concurrent hypotheses on ancestors + if (ret < SMESH_Hypothesis::HYP_CONCURRENT && !IsMainShape( aSubShape ) ) { SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(false,false); while ( smIt->more() ) { SMESH_subMesh* sm = smIt->next(); - if ( sm->IsApplicableHypotesis( anHyp )) { - ret2 = sm->CheckConcurentHypothesis( anHyp->GetType() ); + if ( sm->IsApplicableHypothesis( anHyp )) { + ret2 = sm->CheckConcurrentHypothesis( anHyp ); if (ret2 > ret) { ret = ret2; break; @@ -522,7 +783,10 @@ SMESH_Hypothesis::Hypothesis_Status } } } - + + HasModificationsToDiscard(); // to reset _isModified flag if mesh become empty + GetMeshDS()->Modified(); + if(MYDEBUG) subMesh->DumpAlgoState(true); if(MYDEBUG) SCRUTE(ret); return ret; @@ -534,48 +798,81 @@ SMESH_Hypothesis::Hypothesis_Status */ //============================================================================= -const list& +const std::list& SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const - throw(SALOME_Exception) { - Unexpect aCatch(SalomeException); - return _myMeshDS->GetHypothesis(aSubShape); + return _meshDS->GetHypothesis(aSubShape); } //======================================================================= /*! * \brief Return the hypothesis assigned to the shape - * \param aSubShape - the shape to check - * \param aFilter - the hypothesis filter - * \param andAncestors - flag to check hypos assigned to ancestors of the shape - * \retval SMESH_Hypothesis* - the first hypo passed through aFilter + * \param aSubShape - the shape to check + * \param aFilter - the hypothesis filter + * \param andAncestors - flag to check hypos assigned to ancestors of the shape + * \param assignedTo - to return the shape the found hypo is assigned to + * \retval SMESH_Hypothesis* - the first hypo passed through aFilter */ //======================================================================= const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const TopoDS_Shape & aSubShape, const SMESH_HypoFilter& aFilter, - const bool andAncestors) const + const bool andAncestors, + TopoDS_Shape* assignedTo) const +{ + return GetHypothesis( const_cast< SMESH_Mesh* >(this)->GetSubMesh( aSubShape ), + aFilter, andAncestors, assignedTo ); +} + +//======================================================================= +/*! + * \brief Return the hypothesis assigned to the shape of a sub-mesh + * \param aSubMesh - the sub-mesh to check + * \param aFilter - the hypothesis filter + * \param andAncestors - flag to check hypos assigned to ancestors of the shape + * \param assignedTo - to return the shape the found hypo is assigned to + * \retval SMESH_Hypothesis* - the first hypo passed through aFilter + */ +//======================================================================= + +const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const SMESH_subMesh * aSubMesh, + const SMESH_HypoFilter& aFilter, + const bool andAncestors, + TopoDS_Shape* assignedTo) const { + if ( !aSubMesh ) return 0; + { - const list& hypList = _myMeshDS->GetHypothesis(aSubShape); - list::const_iterator hyp = hypList.begin(); + const TopoDS_Shape & aSubShape = aSubMesh->GetSubShape(); + const std::list& hypList = _meshDS->GetHypothesis(aSubShape); + std::list::const_iterator hyp = hypList.begin(); for ( ; hyp != hypList.end(); hyp++ ) { const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp ); - if ( aFilter.IsOk( h, aSubShape)) + if ( aFilter.IsOk( h, aSubShape)) { + if ( assignedTo ) *assignedTo = aSubShape; return h; + } } } if ( andAncestors ) { - TopTools_ListIteratorOfListOfShape it( GetAncestors( aSubShape )); - for (; it.More(); it.Next() ) + // user sorted submeshes of ancestors, according to stored submesh priority + std::vector< SMESH_subMesh * > & ancestors = + const_cast< std::vector< SMESH_subMesh * > & > ( aSubMesh->GetAncestors() ); + SortByMeshOrder( ancestors ); + + std::vector::const_iterator smIt = ancestors.begin(); + for ( ; smIt != ancestors.end(); smIt++ ) { - const list& hypList = _myMeshDS->GetHypothesis(it.Value()); - list::const_iterator hyp = hypList.begin(); + const TopoDS_Shape& curSh = (*smIt)->GetSubShape(); + const std::list& hypList = _meshDS->GetHypothesis(curSh); + std::list::const_iterator hyp = hypList.begin(); for ( ; hyp != hypList.end(); hyp++ ) { const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp ); - if (aFilter.IsOk( h, it.Value() )) + if (aFilter.IsOk( h, curSh )) { + if ( assignedTo ) *assignedTo = curSh; return h; + } } } } @@ -584,7 +881,7 @@ const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const TopoDS_Shape & aSubS //================================================================================ /*! - * \brief Return hypothesis assigned to the shape + * \brief Return hypotheses assigned to the shape * \param aSubShape - the shape to check * \param aFilter - the hypothesis filter * \param aHypList - the list of the found hypotheses @@ -593,19 +890,43 @@ const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const TopoDS_Shape & aSubS */ //================================================================================ -int SMESH_Mesh::GetHypotheses(const TopoDS_Shape & aSubShape, - const SMESH_HypoFilter& aFilter, - list & aHypList, - const bool andAncestors) const +int SMESH_Mesh::GetHypotheses(const TopoDS_Shape & aSubShape, + const SMESH_HypoFilter& aFilter, + std::list & aHypList, + const bool andAncestors, + std::list< TopoDS_Shape > * assignedTo/*=0*/) const { - set hypTypes; // to exclude same type hypos from the result list + return GetHypotheses( const_cast< SMESH_Mesh* >(this)->GetSubMesh( aSubShape ), + aFilter, aHypList, andAncestors, assignedTo ); +} + +//================================================================================ +/*! + * \brief Return hypotheses assigned to the shape of a sub-mesh + * \param aSubShape - the sub-mesh to check + * \param aFilter - the hypothesis filter + * \param aHypList - the list of the found hypotheses + * \param andAncestors - flag to check hypos assigned to ancestors of the shape + * \retval int - number of unique hypos in aHypList + */ +//================================================================================ + +int SMESH_Mesh::GetHypotheses(const SMESH_subMesh * aSubMesh, + const SMESH_HypoFilter& aFilter, + std::list & aHypList, + const bool andAncestors, + std::list< TopoDS_Shape > * assignedTo/*=0*/) const +{ + if ( !aSubMesh ) return 0; + + std::set< std::string > hypTypes; // to exclude same type hypos from the result list int nbHyps = 0; // only one main hypothesis is allowed bool mainHypFound = false; // fill in hypTypes - list::const_iterator hyp; + std::list::const_iterator hyp; for ( hyp = aHypList.begin(); hyp != aHypList.end(); hyp++ ) { if ( hypTypes.insert( (*hyp)->GetName() ).second ) nbHyps++; @@ -615,55 +936,81 @@ int SMESH_Mesh::GetHypotheses(const TopoDS_Shape & aSubShape, // get hypos from aSubShape { - const list& hypList = _myMeshDS->GetHypothesis(aSubShape); + const TopoDS_Shape & aSubShape = aSubMesh->GetSubShape(); + const std::list& hypList = _meshDS->GetHypothesis(aSubShape); for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ ) - if ( aFilter.IsOk (cSMESH_Hyp( *hyp ), aSubShape) && - ( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) && - hypTypes.insert( (*hyp)->GetName() ).second ) + { + const SMESH_Hypothesis* h = cSMESH_Hyp( *hyp ); + if (( aFilter.IsOk( h, aSubShape )) && + ( h->IsAuxiliary() || !mainHypFound ) && + ( h->IsAuxiliary() || hypTypes.insert( h->GetName() ).second )) { aHypList.push_back( *hyp ); nbHyps++; - if ( !cSMESH_Hyp(*hyp)->IsAuxiliary() ) + if ( !h->IsAuxiliary() ) mainHypFound = true; + if ( assignedTo ) assignedTo->push_back( aSubShape ); } + } } // get hypos from ancestors of aSubShape if ( andAncestors ) { - TopTools_MapOfShape map; - TopTools_ListIteratorOfListOfShape it( GetAncestors( aSubShape )); - for (; it.More(); it.Next() ) + // user sorted submeshes of ancestors, according to stored submesh priority + std::vector< SMESH_subMesh * > & ancestors = + const_cast< std::vector< SMESH_subMesh * > & > ( aSubMesh->GetAncestors() ); + SortByMeshOrder( ancestors ); + + std::vector::const_iterator smIt = ancestors.begin(); + for ( ; smIt != ancestors.end(); smIt++ ) { - if ( !map.Add( it.Value() )) - continue; - const list& hypList = _myMeshDS->GetHypothesis(it.Value()); + const TopoDS_Shape& curSh = (*smIt)->GetSubShape(); + const std::list& hypList = _meshDS->GetHypothesis(curSh); for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ ) - if (aFilter.IsOk( cSMESH_Hyp( *hyp ), it.Value() ) && - ( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) && - hypTypes.insert( (*hyp)->GetName() ).second ) + { + const SMESH_Hypothesis* h = cSMESH_Hyp( *hyp ); + if (( aFilter.IsOk( h, curSh )) && + ( h->IsAuxiliary() || !mainHypFound ) && + ( h->IsAuxiliary() || hypTypes.insert( h->GetName() ).second )) { aHypList.push_back( *hyp ); nbHyps++; - if ( !cSMESH_Hyp(*hyp)->IsAuxiliary() ) + if ( !h->IsAuxiliary() ) mainHypFound = true; + if ( assignedTo ) assignedTo->push_back( curSh ); } + } } } return nbHyps; } +//================================================================================ +/*! + * \brief Return a hypothesis by its ID + */ +//================================================================================ + +SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const int anHypId) const +{ + StudyContextStruct *sc = _gen->GetStudyContext(); + if (sc->mapHypothesis.find(anHypId) == sc->mapHypothesis.end()) + return NULL; + + SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId]; + return anHyp; +} + //============================================================================= /*! * */ //============================================================================= -const list & SMESH_Mesh::GetLog() throw(SALOME_Exception) +const std::list & SMESH_Mesh::GetLog() { - Unexpect aCatch(SalomeException); - if(MYDEBUG) MESSAGE("SMESH_Mesh::GetLog"); - return _myMeshDS->GetScript()->GetCommands(); + return _meshDS->GetScript()->GetCommands(); } //============================================================================= @@ -671,11 +1018,9 @@ const list & SMESH_Mesh::GetLog() throw(SALOME_Exception) * */ //============================================================================= -void SMESH_Mesh::ClearLog() throw(SALOME_Exception) +void SMESH_Mesh::ClearLog() { - Unexpect aCatch(SalomeException); - if(MYDEBUG) MESSAGE("SMESH_Mesh::ClearLog"); - _myMeshDS->GetScript()->Clear(); + _meshDS->GetScript()->Clear(); } //============================================================================= @@ -684,106 +1029,125 @@ void SMESH_Mesh::ClearLog() throw(SALOME_Exception) */ //============================================================================= -SMESH_subMesh *SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape) - throw(SALOME_Exception) +SMESH_subMesh * SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape) { - Unexpect aCatch(SalomeException); - SMESH_subMesh *aSubMesh; - int index = _myMeshDS->ShapeToIndex(aSubShape); + int index = _meshDS->ShapeToIndex(aSubShape); + if ( !index && aSubShape.IsNull() ) + return 0; // for submeshes on GEOM Group - if ( !index && aSubShape.ShapeType() == TopAbs_COMPOUND ) { + if (( !index || index > _nbSubShapes ) && aSubShape.ShapeType() == TopAbs_COMPOUND ) + { TopoDS_Iterator it( aSubShape ); if ( it.More() ) - index = _myMeshDS->AddCompoundSubmesh( aSubShape, it.Value().ShapeType() ); + { + index = _meshDS->AddCompoundSubmesh( aSubShape, it.Value().ShapeType() ); + // fill map of Ancestors + while ( _nbSubShapes < index ) + fillAncestorsMap( _meshDS->IndexToShape( ++_nbSubShapes )); + } } -// if ( !index ) -// return NULL; // neither sub-shape nor a group + // if ( !index ) + // return NULL; // neither sub-shape nor a group - map ::iterator i_sm = _mapSubMesh.find(index); - if ( i_sm != _mapSubMesh.end()) - { - aSubMesh = i_sm->second; - } - else + SMESH_subMesh* aSubMesh = _subMeshHolder->Get( index ); + if ( !aSubMesh ) { - aSubMesh = new SMESH_subMesh(index, this, _myMeshDS, aSubShape); - _mapSubMesh[index] = aSubMesh; + aSubMesh = new SMESH_subMesh(index, this, _meshDS, aSubShape); + _subMeshHolder->Add( index, aSubMesh ); + + // include non-computable sub-meshes in SMESH_subMesh::_ancestors of sub-submeshes + switch ( aSubShape.ShapeType() ) { + case TopAbs_COMPOUND: + case TopAbs_WIRE: + case TopAbs_SHELL: + for ( TopoDS_Iterator subIt( aSubShape ); subIt.More(); subIt.Next() ) + { + SMESH_subMesh* sm = GetSubMesh( subIt.Value() ); + SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*inclideSelf=*/true); + while ( smIt->more() ) + smIt->next()->ClearAncestors(); + } + default:; + } } return aSubMesh; } //============================================================================= /*! - * Get the SMESH_subMesh object implementation. Dont create it, return null + * Get the SMESH_subMesh object implementation. Don't create it, return null * if it does not exist. */ //============================================================================= SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape) const - throw(SALOME_Exception) { - Unexpect aCatch(SalomeException); - SMESH_subMesh *aSubMesh = NULL; - - int index = _myMeshDS->ShapeToIndex(aSubShape); - - map ::const_iterator i_sm = _mapSubMesh.find(index); - if ( i_sm != _mapSubMesh.end()) - aSubMesh = i_sm->second; - - return aSubMesh; + int index = _meshDS->ShapeToIndex(aSubShape); + return GetSubMeshContaining( index ); } + //============================================================================= /*! - * Get the SMESH_subMesh object implementation. Dont create it, return null + * Get the SMESH_subMesh object implementation. Don't create it, return null * if it does not exist. */ //============================================================================= SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const int aShapeID) const -throw(SALOME_Exception) { - Unexpect aCatch(SalomeException); - - map ::const_iterator i_sm = _mapSubMesh.find(aShapeID); - if (i_sm == _mapSubMesh.end()) - return NULL; - return i_sm->second; + SMESH_subMesh *aSubMesh = _subMeshHolder->Get( aShapeID ); + return aSubMesh; } + //================================================================================ /*! - * \brief Return submeshes of groups containing the given subshape + * \brief Return sub-meshes of groups containing the given sub-shape */ //================================================================================ -list +std::list SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const - throw(SALOME_Exception) { - Unexpect aCatch(SalomeException); - list found; + std::list found; SMESH_subMesh * subMesh = GetSubMeshContaining(aSubShape); if ( !subMesh ) return found; - // submeshes of groups have max IDs, so search from the map end - map::const_reverse_iterator i_sm; - for ( i_sm = _mapSubMesh.rbegin(); i_sm != _mapSubMesh.rend(); ++i_sm) { - SMESHDS_SubMesh * ds = i_sm->second->GetSubMeshDS(); + // sub-meshes of groups have max IDs, so search from the map end + SMESH_subMeshIteratorPtr smIt( _subMeshHolder->GetIterator( /*reverse=*/true ) ); + while ( smIt->more() ) { + SMESH_subMesh* sm = smIt->next(); + SMESHDS_SubMesh * ds = sm->GetSubMeshDS(); if ( ds && ds->IsComplexSubmesh() ) { - TopExp_Explorer exp( i_sm->second->GetSubShape(), aSubShape.ShapeType() ); - for ( ; exp.More(); exp.Next() ) { - if ( aSubShape.IsSame( exp.Current() )) { - found.push_back( i_sm->second ); - break; - } + if ( SMESH_MesherHelper::IsSubShape( aSubShape, sm->GetSubShape() )) + { + found.push_back( sm ); + //break; } } else { - break; + break; // the rest sub-meshes are not those of groups } } + + if ( found.empty() ) // maybe the main shape is a COMPOUND (issue 0021530) + { + if ( SMESH_subMesh * mainSM = GetSubMeshContaining(1) ) + if ( mainSM->GetSubShape().ShapeType() == TopAbs_COMPOUND ) + { + TopoDS_Iterator it( mainSM->GetSubShape() ); + if ( it.Value().ShapeType() == aSubShape.ShapeType() && + SMESH_MesherHelper::IsSubShape( aSubShape, mainSM->GetSubShape() )) + found.push_back( mainSM ); + } + } + else // issue 0023068 + { + if ( SMESH_subMesh * mainSM = GetSubMeshContaining(1) ) + if ( mainSM->GetSubShape().ShapeType() == TopAbs_COMPOUND ) + found.push_back( mainSM ); + } return found; } //======================================================================= @@ -797,12 +1161,10 @@ bool SMESH_Mesh::IsUsedHypothesis(SMESHDS_Hypothesis * anHyp, SMESH_Hypothesis* hyp = static_cast(anHyp); // check if anHyp can be used to mesh aSubMesh - if ( !aSubMesh || !aSubMesh->IsApplicableHypotesis( hyp )) + if ( !aSubMesh || !aSubMesh->IsApplicableHypothesis( hyp )) return false; - const TopoDS_Shape & aSubShape = const_cast( aSubMesh )->GetSubShape(); - - SMESH_Algo *algo = _gen->GetAlgo(*this, aSubShape ); + SMESH_Algo *algo = aSubMesh->GetAlgo(); // algorithm if (anHyp->GetType() > SMESHDS_Hypothesis::PARAM_ALGO) @@ -811,41 +1173,16 @@ bool SMESH_Mesh::IsUsedHypothesis(SMESHDS_Hypothesis * anHyp, // algorithm parameter if (algo) { - // look trough hypotheses used by algo - SMESH_HypoFilter hypoKind; - if ( algo->InitCompatibleHypoFilter( hypoKind, !hyp->IsAuxiliary() )) { - list usedHyps; - if ( GetHypotheses( aSubShape, hypoKind, usedHyps, true )) + // look through hypotheses used by algo + const SMESH_HypoFilter* hypoKind; + if (( hypoKind = algo->GetCompatibleHypoFilter( !hyp->IsAuxiliary() ))) { + std::list usedHyps; + if ( GetHypotheses( aSubMesh, *hypoKind, usedHyps, true )) return ( find( usedHyps.begin(), usedHyps.end(), anHyp ) != usedHyps.end() ); } } - // look through all assigned hypotheses - //SMESH_HypoFilter filter( SMESH_HypoFilter::Is( hyp )); - return false; //GetHypothesis( aSubShape, filter, true ); -} - -//============================================================================= -/*! - * - */ -//============================================================================= - -const list < SMESH_subMesh * >& -SMESH_Mesh::GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp) - throw(SALOME_Exception) -{ - Unexpect aCatch(SalomeException); - if(MYDEBUG) MESSAGE("SMESH_Mesh::GetSubMeshUsingHypothesis"); - map < int, SMESH_subMesh * >::iterator itsm; - _subMeshesUsingHypothesisList.clear(); - for (itsm = _mapSubMesh.begin(); itsm != _mapSubMesh.end(); itsm++) - { - SMESH_subMesh *aSubMesh = (*itsm).second; - if ( IsUsedHypothesis ( anHyp, aSubMesh )) - _subMeshesUsingHypothesisList.push_back(aSubMesh); - } - return _subMeshesUsingHypothesisList; + return false; } //======================================================================= @@ -855,50 +1192,87 @@ SMESH_Mesh::GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp) void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* hyp) { - Unexpect aCatch(SalomeException); - const SMESH_Algo *foundAlgo = 0; - SMESH_HypoFilter algoKind, compatibleHypoKind; - list usedHyps; + if ( !GetMeshDS()->IsUsedHypothesis( hyp )) + return; + smIdType nbEntities = ( _meshDS->NbNodes() + _meshDS->NbElements() ); + if ( hyp && _callUp && !_callUp->IsLoaded() ) // for not loaded mesh (#16648) + { + _callUp->HypothesisModified( hyp->GetID(), /*updateIcons=*/true ); + nbEntities = ( _meshDS->NbNodes() + _meshDS->NbElements() ); // after loading mesh + } - map < int, SMESH_subMesh * >::iterator itsm; - for (itsm = _mapSubMesh.begin(); itsm != _mapSubMesh.end(); itsm++) + SMESH_Algo *algo; + const SMESH_HypoFilter* compatibleHypoKind; + std::list usedHyps; + std::vector< SMESH_subMesh* > smToNotify; + bool allMeshedEdgesNotified = true; + + SMESH_subMeshIteratorPtr smIt( _subMeshHolder->GetIterator() ); + while ( smIt->more() ) { - SMESH_subMesh *aSubMesh = (*itsm).second; - if ( aSubMesh->IsApplicableHypotesis( hyp )) + SMESH_subMesh* aSubMesh = smIt->next(); + bool toNotify = false; + + // if aSubMesh meshing depends on hyp, + // we call aSubMesh->AlgoStateEngine( MODIF_HYP, hyp ) that causes either + // 1) clearing already computed aSubMesh or + // 2) changing algo_state from MISSING_HYP to HYP_OK when parameters of hyp becomes valid, + // other possible changes are not interesting. (IPAL0052457 - assigning hyp performance pb) + if ( aSubMesh->GetComputeState() == SMESH_subMesh::COMPUTE_OK || + aSubMesh->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE || + aSubMesh->GetAlgoState() == SMESH_subMesh::MISSING_HYP || + hyp->DataDependOnParams() ) { const TopoDS_Shape & aSubShape = aSubMesh->GetSubShape(); - if ( !foundAlgo ) // init filter for algo search - algoKind.Init( THypType::IsAlgo() ).And( THypType::IsApplicableTo( aSubShape )); - - const SMESH_Algo *algo = static_cast - ( GetHypothesis( aSubShape, algoKind, true )); - - if ( algo ) + if (( aSubMesh->IsApplicableHypothesis( hyp )) && + ( algo = aSubMesh->GetAlgo() ) && + ( compatibleHypoKind = algo->GetCompatibleHypoFilter( !hyp->IsAuxiliary() )) && + ( compatibleHypoKind->IsOk( hyp, aSubShape ))) { - bool sameAlgo = ( algo == foundAlgo ); - if ( !sameAlgo && foundAlgo ) - sameAlgo = ( strcmp( algo->GetName(), foundAlgo->GetName() ) == 0); - - if ( !sameAlgo ) { // init filter for used hypos search - if ( !algo->InitCompatibleHypoFilter( compatibleHypoKind, !hyp->IsAuxiliary() )) - continue; // algo does not use any hypothesis - foundAlgo = algo; - } - // check if hyp is used by algo usedHyps.clear(); - if ( GetHypotheses( aSubShape, compatibleHypoKind, usedHyps, true ) && - find( usedHyps.begin(), usedHyps.end(), hyp ) != usedHyps.end() ) - { - aSubMesh->AlgoStateEngine(SMESH_subMesh::MODIF_HYP, - const_cast< SMESH_Hypothesis*>( hyp )); - } + toNotify = ( GetHypotheses( aSubMesh, *compatibleHypoKind, usedHyps, true ) && + std::find( usedHyps.begin(), usedHyps.end(), hyp ) != usedHyps.end() ); } } + if ( toNotify ) + { + smToNotify.push_back( aSubMesh ); + if ( aSubMesh->GetAlgoState() == SMESH_subMesh::MISSING_HYP ) + allMeshedEdgesNotified = false; // update of algo state needed, not mesh clearing + } + else + { + if ( !aSubMesh->IsEmpty() && + aSubMesh->GetSubShape().ShapeType() == TopAbs_EDGE ) + allMeshedEdgesNotified = false; + } } + if ( smToNotify.empty() ) + return; + + // if all meshed EDGEs will be notified then the notification is equivalent + // to the whole mesh clearing, which is usually faster + if ( allMeshedEdgesNotified && NbNodes() > 0 ) + { + Clear(); + } + else + { + // notify in reverse order to avoid filling the pool of IDs + for ( int i = smToNotify.size()-1; i >= 0; --i ) + smToNotify[i]->AlgoStateEngine(SMESH_subMesh::MODIF_HYP, + const_cast< SMESH_Hypothesis*>( hyp )); + } + HasModificationsToDiscard(); // to reset _isModified flag if mesh becomes empty + GetMeshDS()->Modified(); + + smIdType newNbEntities = ( _meshDS->NbNodes() + _meshDS->NbElements() ); + if ( hyp && _callUp ) + _callUp->HypothesisModified( hyp->GetID(), newNbEntities != nbEntities ); } //============================================================================= @@ -906,128 +1280,512 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h * Auto color functionality */ //============================================================================= -void SMESH_Mesh::SetAutoColor(bool theAutoColor) throw(SALOME_Exception) +void SMESH_Mesh::SetAutoColor(bool theAutoColor) { - Unexpect aCatch(SalomeException); _isAutoColor = theAutoColor; } -bool SMESH_Mesh::GetAutoColor() throw(SALOME_Exception) +bool SMESH_Mesh::GetAutoColor() { - Unexpect aCatch(SalomeException); return _isAutoColor; } +//======================================================================= +//function : SetIsModified +//purpose : Set the flag meaning that the mesh has been edited "manually" +//======================================================================= + +void SMESH_Mesh::SetIsModified(bool isModified) +{ + _isModified = isModified; + + if ( _isModified ) + // check if mesh becomes empty as result of modification + HasModificationsToDiscard(); +} + +//======================================================================= +//function : HasModificationsToDiscard +//purpose : Return true if the mesh has been edited since a total re-compute +// and those modifications may prevent successful partial re-compute. +// As a side effect reset _isModified flag if mesh is empty +//issue : 0020693 +//======================================================================= + +bool SMESH_Mesh::HasModificationsToDiscard() const +{ + if ( ! _isModified ) + return false; + + // return true if the next Compute() will be partial and + // existing but changed elements may prevent successful re-compute + bool hasComputed = false, hasNotComputed = false; + SMESH_subMeshIteratorPtr smIt( _subMeshHolder->GetIterator() ); + while ( smIt->more() ) + { + const SMESH_subMesh* aSubMesh = smIt->next(); + switch ( aSubMesh->GetSubShape().ShapeType() ) + { + case TopAbs_EDGE: + case TopAbs_FACE: + case TopAbs_SOLID: + if ( aSubMesh->IsMeshComputed() ) + hasComputed = true; + else + hasNotComputed = true; + if ( hasComputed && hasNotComputed) + return true; + + default:; + } + } + if ( NbNodes() < 1 ) + const_cast(this)->_isModified = false; + + return false; +} + //============================================================================= -/*! Export* methods. - * To store mesh contents on disk in different formats. +/*! + * \brief Return true if all sub-meshes are computed OK - to update an icon */ //============================================================================= +bool SMESH_Mesh::IsComputedOK() +{ + if ( NbNodes() == 0 ) + return false; + + // if ( !HasShapeToMesh() ) + // return true; + + if ( SMESH_subMesh* mainSM = GetSubMeshContaining( 1 )) + { + SMESH_subMeshIteratorPtr smIt = mainSM->getDependsOnIterator(/*includeSelf=*/true); + while ( smIt->more() ) + { + const SMESH_subMesh* sm = smIt->next(); + if ( !sm->IsAlwaysComputed() ) + switch ( sm->GetComputeState() ) + { + case SMESH_subMesh::NOT_READY: + case SMESH_subMesh::COMPUTE_OK: + continue; // ok + case SMESH_subMesh::FAILED_TO_COMPUTE: + case SMESH_subMesh::READY_TO_COMPUTE: + return false; + } + } + } + return true; +} + +//================================================================================ +/*! + * \brief Check if any groups of the same type have equal names + */ +//================================================================================ + bool SMESH_Mesh::HasDuplicatedGroupNamesMED() { - set aGroupNames; - for ( map::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) { - SMESH_Group* aGroup = it->second; - string aGroupName = aGroup->GetName(); - aGroupName.resize(MAX_MED_GROUP_NAME_LENGTH); - if (!aGroupNames.insert(aGroupName).second) + // Corrected for Mantis issue 0020028 + std::map< SMDSAbs_ElementType, std::set< std::string > > aGroupNames; + for ( std::map::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) + { + SMESH_Group* aGroup = it->second; + SMDSAbs_ElementType aType = aGroup->GetGroupDS()->GetType(); + std::string aGroupName = aGroup->GetName(); + aGroupName.resize( MAX_MED_GROUP_NAME_LENGTH ); + if ( !aGroupNames[aType].insert(aGroupName).second ) return true; } return false; } -void SMESH_Mesh::ExportMED(const char *file, - const char* theMeshName, - bool theAutoGroups, - int theVersion) - throw(SALOME_Exception) +//================================================================================ +/*! + * \brief Export the mesh to a writer + */ +//================================================================================ + +void SMESH_Mesh::exportMEDCommmon(DriverMED_W_SMESHDS_Mesh& theWriter, + const char* theMeshName, + bool theAutoGroups, + const SMESHDS_Mesh* theMeshPart, + bool theAutoDimension, + bool theAddODOnVertices, + double theZTolerance, + bool theSaveNumbers) { - Unexpect aCatch(SalomeException); + Driver_Mesh::Status status = Driver_Mesh::DRS_OK; + + SMESH_TRY; - DriverMED_W_SMESHDS_Mesh myWriter; - myWriter.SetFile ( file, MED::EVersion(theVersion) ); - myWriter.SetMesh ( _myMeshDS ); - if ( !theMeshName ) - myWriter.SetMeshId ( _idDoc ); + theWriter.SetMesh ( theMeshPart ? (SMESHDS_Mesh*) theMeshPart : _meshDS ); + theWriter.SetAutoDimension( theAutoDimension ); + theWriter.AddODOnVertices ( theAddODOnVertices ); + theWriter.SetZTolerance ( theZTolerance ); + theWriter.SetSaveNumbers ( theSaveNumbers ); + if ( !theMeshName ) + theWriter.SetMeshId ( _id ); else { - myWriter.SetMeshId ( -1 ); - myWriter.SetMeshName( theMeshName ); + theWriter.SetMeshId ( -1 ); + theWriter.SetMeshName ( theMeshName ); } if ( theAutoGroups ) { - myWriter.AddGroupOfNodes(); - myWriter.AddGroupOfEdges(); - myWriter.AddGroupOfFaces(); - myWriter.AddGroupOfVolumes(); + theWriter.AddGroupOfNodes(); + theWriter.AddGroupOfEdges(); + theWriter.AddGroupOfFaces(); + theWriter.AddGroupOfVolumes(); + theWriter.AddGroupOf0DElems(); + theWriter.AddGroupOfBalls(); } // Pass groups to writer. Provide unique group names. - set aGroupNames; - char aString [256]; - int maxNbIter = 10000; // to guarantee cycle finish - for ( map::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) { - SMESH_Group* aGroup = it->second; - SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS(); - if ( aGroupDS ) { - string aGroupName0 = aGroup->GetName(); - aGroupName0.resize(MAX_MED_GROUP_NAME_LENGTH); - string aGroupName = aGroupName0; - for (int i = 1; !aGroupNames.insert(aGroupName).second && i < maxNbIter; i++) { - sprintf(&aString[0], "GR_%d_%s", i, aGroupName0.c_str()); - aGroupName = aString; - aGroupName.resize(MAX_MED_GROUP_NAME_LENGTH); + //set aGroupNames; // Corrected for Mantis issue 0020028 + if ( !theMeshPart ) + { + std::map< SMDSAbs_ElementType, std::set > aGroupNames; + char aString [256]; + int maxNbIter = 10000; // to guarantee cycle finish + for ( std::map::iterator it = _mapGroup.begin(); + it != _mapGroup.end(); + it++ ) { + SMESH_Group* aGroup = it->second; + SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS(); + if ( aGroupDS ) { + SMDSAbs_ElementType aType = aGroupDS->GetType(); + std::string aGroupName0 = aGroup->GetName(); + aGroupName0.resize(MAX_MED_GROUP_NAME_LENGTH); + std::string aGroupName = aGroupName0; + for (int i = 1; !aGroupNames[aType].insert(aGroupName).second && i < maxNbIter; i++) { + sprintf(&aString[0], "GR_%d_%s", i, aGroupName0.c_str()); + aGroupName = aString; + aGroupName.resize(MAX_MED_GROUP_NAME_LENGTH); + } + aGroupDS->SetStoreName( aGroupName.c_str() ); + theWriter.AddGroup( aGroupDS ); } - aGroupDS->SetStoreName( aGroupName.c_str() ); - myWriter.AddGroup( aGroupDS ); } } - // Perform export - myWriter.Perform(); + status = theWriter.Perform(); + + SMESH_CATCH( SMESH::throwSalomeEx ); + + if ( status == Driver_Mesh::DRS_TOO_LARGE_MESH ) + throw TooLargeForExport("MED"); +} + +//================================================================================ +/*! + * Same as SMESH_Mesh::ExportMED except for \a file and \a theVersion + */ +//================================================================================ + +MEDCoupling::MCAuto +SMESH_Mesh::ExportMEDCoupling(const char* theMeshName, + bool theAutoGroups, + const SMESHDS_Mesh* theMeshPart, + bool theAutoDimension, + bool theAddODOnVertices, + double theZTolerance, + bool theSaveNumbers) +{ + DriverMED_W_SMESHDS_Mesh_Mem writer; + this->exportMEDCommmon( writer, theMeshName, theAutoGroups, theMeshPart, theAutoDimension, + theAddODOnVertices, theZTolerance, theSaveNumbers); + return writer.getData(); +} + +//================================================================================ +/*! + * \brief Export the mesh to a med file + * \param [in] theFile - name of the MED file + * \param [in] theMeshName - name of this mesh + * \param [in] theAutoGroups - boolean parameter for creating/not creating + * the groups Group_On_All_Nodes, Group_On_All_Faces, ... ; + * the typical use is auto_groups=false. + * \param [in] theVersion - define the minor (xy, where version is x.y.z) of MED file format. + * If theVersion is equal to -1, the minor version is not changed (default). + * \param [in] theMeshPart - mesh data to export + * \param [in] theAutoDimension - if \c true, a space dimension of a MED mesh can be either + * - 1D if all mesh nodes lie on OX coordinate axis, or + * - 2D if all mesh nodes lie on XOY coordinate plane, or + * - 3D in the rest cases. + * If \a theAutoDimension is \c false, the space dimension is always 3. + * \param [in] theAddODOnVertices - to create 0D elements on all vertices + * \param [in] theZTolerance - tolerance in Z direction. If Z coordinate of a node is close to zero + * within a given tolerance, the coordinate is set to zero. + * If \a ZTolerance is negative, the node coordinates are kept as is. + * \param [in] theSaveNumbers : enable saving numbers of nodes and cells. + * \return int - mesh index in the file + */ +//================================================================================ + +void SMESH_Mesh::ExportMED(const char * theFile, + const char* theMeshName, + bool theAutoGroups, + int theVersion, + const SMESHDS_Mesh* theMeshPart, + bool theAutoDimension, + bool theAddODOnVertices, + double theZTolerance, + bool theSaveNumbers) +{ + MESSAGE("MED_VERSION:"<< theVersion); + DriverMED_W_SMESHDS_Mesh writer; + writer.SetFile( theFile, theVersion ); + this->exportMEDCommmon( writer, theMeshName, theAutoGroups, theMeshPart, theAutoDimension, theAddODOnVertices, theZTolerance, theSaveNumbers ); +} + +//================================================================================ +/*! + * \brief Export the mesh to a DAT file + */ +//================================================================================ + +void SMESH_Mesh::ExportDAT(const char * file, + const SMESHDS_Mesh* meshPart, + const bool renumber) +{ + Driver_Mesh::Status status; + SMESH_TRY; + + DriverDAT_W_SMDS_Mesh writer; + writer.SetFile( file ); + writer.SetMesh( meshPart ? (SMESHDS_Mesh*) meshPart : _meshDS ); + writer.SetMeshId(_id); + writer.SetRenumber( renumber ); + status = writer.Perform(); + + SMESH_CATCH( SMESH::throwSalomeEx ); + + if ( status == Driver_Mesh::DRS_TOO_LARGE_MESH ) + throw TooLargeForExport("DAT"); } -void SMESH_Mesh::ExportDAT(const char *file) throw(SALOME_Exception) +//================================================================================ +/*! + * \brief Export the mesh to an UNV file + */ +//================================================================================ + +void SMESH_Mesh::ExportUNV(const char * file, + const SMESHDS_Mesh* meshPart, + const bool renumber) { - Unexpect aCatch(SalomeException); - DriverDAT_W_SMDS_Mesh myWriter; - myWriter.SetFile(string(file)); - myWriter.SetMesh(_myMeshDS); - myWriter.SetMeshId(_idDoc); - myWriter.Perform(); + Driver_Mesh::Status status; + + SMESH_TRY; + DriverUNV_W_SMDS_Mesh writer; + writer.SetFile( file ); + writer.SetMesh( meshPart ? (SMESHDS_Mesh*) meshPart : _meshDS ); + writer.SetMeshId(_id); + writer.SetRenumber( renumber ); + + // pass group names to SMESHDS + if ( !meshPart ) + { + std::map::iterator it = _mapGroup.begin(); + for ( ; it != _mapGroup.end(); it++ ) { + SMESH_Group* aGroup = it->second; + SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS(); + if ( aGroupDS ) { + std::string aGroupName = aGroup->GetName(); + aGroupDS->SetStoreName( aGroupName.c_str() ); + writer.AddGroup( aGroupDS ); + } + } + } + status = writer.Perform(); + + SMESH_CATCH( SMESH::throwSalomeEx ); + + if ( status == Driver_Mesh::DRS_TOO_LARGE_MESH ) + throw TooLargeForExport("UNV"); } -void SMESH_Mesh::ExportUNV(const char *file) throw(SALOME_Exception) +//================================================================================ +/*! + * \brief Export the mesh to an STL file + */ +//================================================================================ + +void SMESH_Mesh::ExportSTL(const char * file, + const bool isascii, + const char * name, + const SMESHDS_Mesh* meshPart) { - Unexpect aCatch(SalomeException); - DriverUNV_W_SMDS_Mesh myWriter; - myWriter.SetFile(string(file)); - myWriter.SetMesh(_myMeshDS); - myWriter.SetMeshId(_idDoc); - // myWriter.SetGroups(_mapGroup); + Driver_Mesh::Status status; + SMESH_TRY; - for ( map::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) { - SMESH_Group* aGroup = it->second; - SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS(); - if ( aGroupDS ) { - string aGroupName = aGroup->GetName(); - aGroupDS->SetStoreName( aGroupName.c_str() ); - myWriter.AddGroup( aGroupDS ); + DriverSTL_W_SMDS_Mesh writer; + writer.SetFile( file ); + writer.SetIsAscii( isascii ); + writer.SetMesh( meshPart ? (SMESHDS_Mesh*) meshPart : _meshDS); + writer.SetMeshId(_id); + if ( name ) writer.SetName( name ); + status = writer.Perform(); + + SMESH_CATCH( SMESH::throwSalomeEx ); + + if ( status == Driver_Mesh::DRS_TOO_LARGE_MESH ) + throw TooLargeForExport("STL"); +} + +//================================================================================ +/*! + * \brief Export the mesh to the CGNS file + */ +//================================================================================ + +void SMESH_Mesh::ExportCGNS(const char * file, + const SMESHDS_Mesh* meshDS, + const char * meshName, + const bool groupElemsByType) +{ + + int res = Driver_Mesh::DRS_FAIL; + SMESH_TRY; + + // pass group names to SMESHDS + std::map::iterator it = _mapGroup.begin(); + for ( ; it != _mapGroup.end(); it++ ) { + SMESH_Group* group = it->second; + SMESHDS_GroupBase* groupDS = group->GetGroupDS(); + if ( groupDS ) { + std::string groupName = group->GetName(); + groupDS->SetStoreName( groupName.c_str() ); } } - myWriter.Perform(); +#ifdef WITH_CGNS + + DriverCGNS_Write writer; + writer.SetFile( file ); + writer.SetMesh( const_cast( meshDS )); + writer.SetMeshName( SMESH_Comment("Mesh_") << meshDS->GetPersistentId()); + if ( meshName && meshName[0] ) + writer.SetMeshName( meshName ); + writer.SetElementsByType( groupElemsByType ); + res = writer.Perform(); + if ( res != Driver_Mesh::DRS_OK ) + { + SMESH_ComputeErrorPtr err = writer.GetError(); + if ( err && !err->IsOK() && !err->myComment.empty() ) + throw SALOME_Exception(("Export failed: " + err->myComment ).c_str() ); + } + +#endif + SMESH_CATCH( SMESH::throwSalomeEx ); + + if ( res == Driver_Mesh::DRS_TOO_LARGE_MESH ) + throw TooLargeForExport("CGNS"); + + if ( res != Driver_Mesh::DRS_OK ) + throw SALOME_Exception("Export failed"); } -void SMESH_Mesh::ExportSTL(const char *file, const bool isascii) throw(SALOME_Exception) +//================================================================================ +/*! + * \brief Export the mesh to a GMF file + */ +//================================================================================ + +void SMESH_Mesh::ExportGMF(const char * file, + const SMESHDS_Mesh* meshDS, + bool withRequiredGroups) { - Unexpect aCatch(SalomeException); - DriverSTL_W_SMDS_Mesh myWriter; - myWriter.SetFile(string(file)); - myWriter.SetIsAscii( isascii ); - myWriter.SetMesh(_myMeshDS); - myWriter.SetMeshId(_idDoc); - myWriter.Perform(); + Driver_Mesh::Status status; + SMESH_TRY; + + DriverGMF_Write writer; + writer.SetFile( file ); + writer.SetMesh( const_cast( meshDS )); + writer.SetExportRequiredGroups( withRequiredGroups ); + + status = writer.Perform(); + + SMESH_CATCH( SMESH::throwSalomeEx ); + + if ( status == Driver_Mesh::DRS_TOO_LARGE_MESH ) + throw TooLargeForExport("GMF"); +} + +//================================================================================ +/*! + * \brief Return a ratio of "compute cost" of computed sub-meshes to the whole + * "compute cost". + */ +//================================================================================ + +double SMESH_Mesh::GetComputeProgress() const +{ + double totalCost = 1e-100, computedCost = 0; + const SMESH_subMesh* curSM = _gen->GetCurrentSubMesh(); + + // get progress of a current algo + TColStd_MapOfInteger currentSubIds; + if ( curSM ) + if ( SMESH_Algo* algo = curSM->GetAlgo() ) + { + int algoNotDoneCost = 0, algoDoneCost = 0; + const std::vector& smToCompute = algo->SubMeshesToCompute(); + for ( size_t i = 0; i < smToCompute.size(); ++i ) + { + if ( smToCompute[i]->IsEmpty() || smToCompute.size() == 1 ) + algoNotDoneCost += smToCompute[i]->GetComputeCost(); + else + algoDoneCost += smToCompute[i]->GetComputeCost(); + currentSubIds.Add( smToCompute[i]->GetId() ); + } + double rate = 0; + try + { + OCC_CATCH_SIGNALS; + rate = algo->GetProgress(); + } + catch (...) { +#ifdef _DEBUG_ + std::cerr << "Exception in " << algo->GetName() << "::GetProgress()" << std::endl; +#endif + } + if ( 0. < rate && rate < 1.001 ) + { + computedCost += rate * ( algoDoneCost + algoNotDoneCost ); + } + else + { + rate = algo->GetProgressByTic(); + computedCost += algoDoneCost + rate * algoNotDoneCost; + } + // cout << "rate: "<getDependsOnIterator(/*includeSelf=*/true); + while ( smIt->more() ) + { + const SMESH_subMesh* sm = smIt->next(); + const int smCost = sm->GetComputeCost(); + totalCost += smCost; + if ( !currentSubIds.Contains( sm->GetId() ) ) + { + if (( !sm->IsEmpty() ) || + ( sm->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE && + !sm->DependsOn( curSM ) )) + computedCost += smCost; + } + } + } + // cout << "Total: " << totalCost + // << " computed: " << computedCost << " progress: " << computedCost / totalCost + // << " nbElems: " << GetMeshDS()->GetMeshInfo().NbElements() << endl; + return computedCost / totalCost; } //================================================================================ @@ -1036,10 +1794,9 @@ void SMESH_Mesh::ExportSTL(const char *file, const bool isascii) throw(SALOME_Ex */ //================================================================================ -int SMESH_Mesh::NbNodes() throw(SALOME_Exception) +smIdType SMESH_Mesh::NbNodes() const { - Unexpect aCatch(SalomeException); - return _myMeshDS->NbNodes(); + return _meshDS->NbNodes(); } //================================================================================ @@ -1048,10 +1805,20 @@ int SMESH_Mesh::NbNodes() throw(SALOME_Exception) */ //================================================================================ -int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) throw(SALOME_Exception) +smIdType SMESH_Mesh::Nb0DElements() const { - Unexpect aCatch(SalomeException); - return _myMeshDS->GetMeshInfo().NbEdges(order); + return _meshDS->GetMeshInfo().Nb0DElements(); +} + +//================================================================================ +/*! + * \brief Return number of edges of given order in the mesh + */ +//================================================================================ + +smIdType SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const +{ + return _meshDS->GetMeshInfo().NbEdges(order); } //================================================================================ @@ -1060,10 +1827,9 @@ int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) throw(SALOME_Exception) */ //================================================================================ -int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) throw(SALOME_Exception) +smIdType SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const { - Unexpect aCatch(SalomeException); - return _myMeshDS->GetMeshInfo().NbFaces(order); + return _meshDS->GetMeshInfo().NbFaces(order); } //================================================================================ @@ -1072,10 +1838,20 @@ int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) throw(SALOME_Exception) */ //================================================================================ -int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) throw(SALOME_Exception) +smIdType SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const { - Unexpect aCatch(SalomeException); - return _myMeshDS->GetMeshInfo().NbTriangles(order); + return _meshDS->GetMeshInfo().NbTriangles(order); +} + +//================================================================================ +/*! + * \brief Return number of biquadratic triangles in the mesh + */ +//================================================================================ + +smIdType SMESH_Mesh::NbBiQuadTriangles() const +{ + return _meshDS->GetMeshInfo().NbBiQuadTriangles(); } //================================================================================ @@ -1084,10 +1860,20 @@ int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) throw(SALOME_Exception) */ //================================================================================ -int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) throw(SALOME_Exception) +smIdType SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const { - Unexpect aCatch(SalomeException); - return _myMeshDS->GetMeshInfo().NbQuadrangles(order); + return _meshDS->GetMeshInfo().NbQuadrangles(order); +} + +//================================================================================ +/*! + * \brief Return number of biquadratic quadrangles in the mesh + */ +//================================================================================ + +smIdType SMESH_Mesh::NbBiQuadQuadrangles() const +{ + return _meshDS->GetMeshInfo().NbBiQuadQuadrangles(); } //================================================================================ @@ -1096,10 +1882,9 @@ int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) throw(SALOME_Exception */ //================================================================================ -int SMESH_Mesh::NbPolygons() throw(SALOME_Exception) +smIdType SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const { - Unexpect aCatch(SalomeException); - return _myMeshDS->GetMeshInfo().NbPolygons(); + return _meshDS->GetMeshInfo().NbPolygons(order); } //================================================================================ @@ -1108,10 +1893,9 @@ int SMESH_Mesh::NbPolygons() throw(SALOME_Exception) */ //================================================================================ -int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) throw(SALOME_Exception) +smIdType SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const { - Unexpect aCatch(SalomeException); - return _myMeshDS->GetMeshInfo().NbVolumes(order); + return _meshDS->GetMeshInfo().NbVolumes(order); } //================================================================================ @@ -1120,10 +1904,9 @@ int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) throw(SALOME_Exception) */ //================================================================================ -int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) throw(SALOME_Exception) +smIdType SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const { - Unexpect aCatch(SalomeException); - return _myMeshDS->GetMeshInfo().NbTetras(order); + return _meshDS->GetMeshInfo().NbTetras(order); } //================================================================================ @@ -1132,10 +1915,20 @@ int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) throw(SALOME_Exception) */ //================================================================================ -int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) throw(SALOME_Exception) +smIdType SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const +{ + return _meshDS->GetMeshInfo().NbHexas(order); +} + +//================================================================================ +/*! + * \brief Return number of triquadratic hexahedrons in the mesh + */ +//================================================================================ + +smIdType SMESH_Mesh::NbTriQuadraticHexas() const { - Unexpect aCatch(SalomeException); - return _myMeshDS->GetMeshInfo().NbHexas(order); + return _meshDS->GetMeshInfo().NbTriQuadHexas(); } //================================================================================ @@ -1144,10 +1937,9 @@ int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) throw(SALOME_Exception) */ //================================================================================ -int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) throw(SALOME_Exception) +smIdType SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const { - Unexpect aCatch(SalomeException); - return _myMeshDS->GetMeshInfo().NbPyramids(order); + return _meshDS->GetMeshInfo().NbPyramids(order); } //================================================================================ @@ -1156,10 +1948,31 @@ int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) throw(SALOME_Exception) */ //================================================================================ -int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) throw(SALOME_Exception) +smIdType SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const +{ + return _meshDS->GetMeshInfo().NbPrisms(order); +} + +smIdType SMESH_Mesh::NbQuadPrisms() const +{ + return _meshDS->GetMeshInfo().NbQuadPrisms(); +} + +smIdType SMESH_Mesh::NbBiQuadPrisms() const +{ + return _meshDS->GetMeshInfo().NbBiQuadPrisms(); +} + + +//================================================================================ +/*! + * \brief Return number of hexagonal prisms in the mesh + */ +//================================================================================ + +smIdType SMESH_Mesh::NbHexagonalPrisms() const { - Unexpect aCatch(SalomeException); - return _myMeshDS->GetMeshInfo().NbPrisms(order); + return _meshDS->GetMeshInfo().NbHexPrisms(); } //================================================================================ @@ -1168,10 +1981,20 @@ int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) throw(SALOME_Exception) */ //================================================================================ -int SMESH_Mesh::NbPolyhedrons() throw(SALOME_Exception) +smIdType SMESH_Mesh::NbPolyhedrons() const +{ + return _meshDS->GetMeshInfo().NbPolyhedrons(); +} + +//================================================================================ +/*! + * \brief Return number of ball elements in the mesh + */ +//================================================================================ + +smIdType SMESH_Mesh::NbBalls() const { - Unexpect aCatch(SalomeException); - return _myMeshDS->GetMeshInfo().NbPolyhedrons(); + return _meshDS->GetMeshInfo().NbBalls(); } //================================================================================ @@ -1180,15 +2003,26 @@ int SMESH_Mesh::NbPolyhedrons() throw(SALOME_Exception) */ //================================================================================ -int SMESH_Mesh::NbSubMesh() throw(SALOME_Exception) +smIdType SMESH_Mesh::NbSubMesh() const { - Unexpect aCatch(SalomeException); - return _myMeshDS->NbSubMesh(); + return _meshDS->NbSubMesh(); +} + +//================================================================================ +/*! + * \brief Returns number of meshes in the Study, that is supposed to be + * equal to SMESHDS_Document::NbMeshes() + */ +//================================================================================ + +int SMESH_Mesh::NbMeshes() const // nb meshes in the Study +{ + return _document->NbMeshes(); } //======================================================================= //function : IsNotConformAllowed -//purpose : check if a hypothesis alowing notconform mesh is present +//purpose : check if a hypothesis allowing notconform mesh is present //======================================================================= bool SMESH_Mesh::IsNotConformAllowed() const @@ -1196,7 +2030,7 @@ bool SMESH_Mesh::IsNotConformAllowed() const if(MYDEBUG) MESSAGE("SMESH_Mesh::IsNotConformAllowed"); static SMESH_HypoFilter filter( SMESH_HypoFilter::HasName( "NotConformAllowed" )); - return GetHypothesis( _myMeshDS->ShapeToMesh(), filter, false ); + return GetHypothesis( _meshDS->ShapeToMesh(), filter, false ); } //======================================================================= @@ -1206,7 +2040,17 @@ bool SMESH_Mesh::IsNotConformAllowed() const bool SMESH_Mesh::IsMainShape(const TopoDS_Shape& theShape) const { - return theShape.IsSame(_myMeshDS->ShapeToMesh() ); + return theShape.IsSame(_meshDS->ShapeToMesh() ); +} + +//======================================================================= +//function : GetShapeByEntry +//purpose : return TopoDS_Shape by its study entry +//======================================================================= + +TopoDS_Shape SMESH_Mesh::GetShapeByEntry(const std::string& entry) const +{ + return _callUp ? _callUp->GetShapeByEntry( entry ) : TopoDS_Shape(); } //============================================================================= @@ -1217,18 +2061,75 @@ bool SMESH_Mesh::IsMainShape(const TopoDS_Shape& theShape) const SMESH_Group* SMESH_Mesh::AddGroup (const SMDSAbs_ElementType theType, const char* theName, - int& theId, - const TopoDS_Shape& theShape) + const int theId, + const TopoDS_Shape& theShape, + const SMESH_PredicatePtr& thePredicate) { - if (_mapGroup.find(_groupId) != _mapGroup.end()) + if ( _mapGroup.count( theId )) return NULL; - theId = _groupId; - SMESH_Group* aGroup = new SMESH_Group (theId, this, theType, theName, theShape); + int id = ( theId < 0 ) ? _groupId : theId; + SMESH_Group* aGroup = new SMESH_Group ( id, this, theType, theName, theShape, thePredicate ); GetMeshDS()->AddGroup( aGroup->GetGroupDS() ); - _mapGroup[_groupId++] = aGroup; + _mapGroup[ id ] = aGroup; + _groupId = 1 + _mapGroup.rbegin()->first; return aGroup; } +//================================================================================ +/*! + * \brief Creates a group based on an existing SMESHDS group. Group ID should be unique + */ +//================================================================================ + +SMESH_Group* SMESH_Mesh::AddGroup (SMESHDS_GroupBase* groupDS) +{ + if ( !groupDS ) + throw SALOME_Exception(LOCALIZED ("SMESH_Mesh::AddGroup(): NULL SMESHDS_GroupBase")); + + std::map ::iterator i_g = _mapGroup.find( groupDS->GetID() ); + if ( i_g != _mapGroup.end() && i_g->second ) + { + if ( i_g->second->GetGroupDS() == groupDS ) + return i_g->second; + else + throw SALOME_Exception(LOCALIZED ("SMESH_Mesh::AddGroup() wrong ID of SMESHDS_GroupBase")); + } + SMESH_Group* aGroup = new SMESH_Group (groupDS); + _mapGroup[ groupDS->GetID() ] = aGroup; + GetMeshDS()->AddGroup( aGroup->GetGroupDS() ); + + _groupId = 1 + _mapGroup.rbegin()->first; + + return aGroup; +} + + +//================================================================================ +/*! + * \brief Creates SMESH_Groups for not wrapped SMESHDS_Groups + * \retval bool - true if new SMESH_Groups have been created + * + */ +//================================================================================ + +bool SMESH_Mesh::SynchronizeGroups() +{ + const size_t nbGroups = _mapGroup.size(); + const std::set& groups = _meshDS->GetGroups(); + std::set::const_iterator gIt = groups.begin(); + for ( ; gIt != groups.end(); ++gIt ) + { + SMESHDS_GroupBase* groupDS = (SMESHDS_GroupBase*) *gIt; + _groupId = groupDS->GetID(); + if ( !_mapGroup.count( _groupId )) + _mapGroup[_groupId] = new SMESH_Group( groupDS ); + } + if ( !_mapGroup.empty() ) + _groupId = 1 + _mapGroup.rbegin()->first; + + return nbGroups < _mapGroup.size(); +} + //================================================================================ /*! * \brief Return iterator on all existing groups @@ -1237,7 +2138,7 @@ SMESH_Group* SMESH_Mesh::AddGroup (const SMDSAbs_ElementType theType, SMESH_Mesh::GroupIteratorPtr SMESH_Mesh::GetGroups() const { - typedef map TMap; + typedef std::map TMap; return GroupIteratorPtr( new SMDS_mapIterator( _mapGroup )); } @@ -1247,11 +2148,12 @@ SMESH_Mesh::GroupIteratorPtr SMESH_Mesh::GetGroups() const */ //============================================================================= -SMESH_Group* SMESH_Mesh::GetGroup (const int theGroupID) +SMESH_Group* SMESH_Mesh::GetGroup (const int theGroupID) const { - if (_mapGroup.find(theGroupID) == _mapGroup.end()) + std::map ::const_iterator id_grp = _mapGroup.find( theGroupID ); + if ( id_grp == _mapGroup.end() ) return NULL; - return _mapGroup[theGroupID]; + return id_grp->second; } @@ -1261,15 +2163,28 @@ SMESH_Group* SMESH_Mesh::GetGroup (const int theGroupID) */ //============================================================================= -list SMESH_Mesh::GetGroupIds() const +std::list SMESH_Mesh::GetGroupIds() const { - list anIds; - for ( map::const_iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) + std::list anIds; + std::map::const_iterator it = _mapGroup.begin(); + for ( ; it != _mapGroup.end(); it++ ) anIds.push_back( it->first ); return anIds; } +//================================================================================ +/*! + * \brief Set a caller of methods at level of CORBA API implementation. + * The set upCaller will be deleted by SMESH_Mesh + */ +//================================================================================ + +void SMESH_Mesh::SetCallUp( TCallUp* upCaller ) +{ + if ( _callUp ) delete _callUp; + _callUp = upCaller; +} //============================================================================= /*! @@ -1277,19 +2192,22 @@ list SMESH_Mesh::GetGroupIds() const */ //============================================================================= -void SMESH_Mesh::RemoveGroup (const int theGroupID) +bool SMESH_Mesh::RemoveGroup( const int theGroupID ) { if (_mapGroup.find(theGroupID) == _mapGroup.end()) - return; + return false; GetMeshDS()->RemoveGroup( _mapGroup[theGroupID]->GetGroupDS() ); delete _mapGroup[theGroupID]; _mapGroup.erase (theGroupID); + if (_callUp) + _callUp->RemoveGroup( theGroupID ); + return true; } //======================================================================= //function : GetAncestors //purpose : return list of ancestors of theSubShape in the order -// that lower dimention shapes come first. +// that lower dimension shapes come first. //======================================================================= const TopTools_ListOfShape& SMESH_Mesh::GetAncestors(const TopoDS_Shape& theS) const @@ -1310,27 +2228,27 @@ ostream& SMESH_Mesh::Dump(ostream& save) { int clause = 0; save << "========================== Dump contents of mesh ==========================" << endl << endl; - save << ++clause << ") Total number of nodes: \t" << NbNodes() << endl; - save << ++clause << ") Total number of edges: \t" << NbEdges() << endl; - save << ++clause << ") Total number of faces: \t" << NbFaces() << endl; - save << ++clause << ") Total number of polygons:\t" << NbPolygons() << endl; - save << ++clause << ") Total number of volumes:\t" << NbVolumes() << endl; + save << ++clause << ") Total number of nodes: \t" << NbNodes() << endl; + save << ++clause << ") Total number of edges: \t" << NbEdges() << endl; + save << ++clause << ") Total number of faces: \t" << NbFaces() << endl; + save << ++clause << ") Total number of polygons: \t" << NbPolygons() << endl; + save << ++clause << ") Total number of volumes: \t" << NbVolumes() << endl; save << ++clause << ") Total number of polyhedrons:\t" << NbPolyhedrons() << endl << endl; for ( int isQuadratic = 0; isQuadratic < 2; ++isQuadratic ) { - string orderStr = isQuadratic ? "quadratic" : "linear"; + std::string orderStr = isQuadratic ? "quadratic" : "linear"; SMDSAbs_ElementOrder order = isQuadratic ? ORDER_QUADRATIC : ORDER_LINEAR; save << ++clause << ") Total number of " << orderStr << " edges:\t" << NbEdges(order) << endl; save << ++clause << ") Total number of " << orderStr << " faces:\t" << NbFaces(order) << endl; if ( NbFaces(order) > 0 ) { - int nb3 = NbTriangles(order); - int nb4 = NbQuadrangles(order); + smIdType nb3 = NbTriangles(order); + smIdType nb4 = NbQuadrangles(order); save << clause << ".1) Number of " << orderStr << " triangles: \t" << nb3 << endl; save << clause << ".2) Number of " << orderStr << " quadrangles:\t" << nb4 << endl; if ( nb3 + nb4 != NbFaces(order) ) { - map myFaceMap; - SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator(); + std::map myFaceMap; + SMDS_FaceIteratorPtr itFaces=_meshDS->facesIterator(); while( itFaces->more( ) ) { int nbNodes = itFaces->next()->NbNodes(); if ( myFaceMap.find( nbNodes ) == myFaceMap.end() ) @@ -1338,24 +2256,24 @@ ostream& SMESH_Mesh::Dump(ostream& save) myFaceMap[ nbNodes ] = myFaceMap[ nbNodes ] + 1; } save << clause << ".3) Faces in detail: " << endl; - map ::iterator itF; + std::map ::iterator itF; for (itF = myFaceMap.begin(); itF != myFaceMap.end(); itF++) - save << "--> nb nodes: " << itF->first << " - nb elemens:\t" << itF->second << endl; + save << "--> nb nodes: " << itF->first << " - nb elements:\t" << itF->second << endl; } } save << ++clause << ") Total number of " << orderStr << " volumes:\t" << NbVolumes(order) << endl; if ( NbVolumes(order) > 0 ) { - int nb8 = NbHexas(order); - int nb4 = NbTetras(order); - int nb5 = NbPyramids(order); - int nb6 = NbPrisms(order); - save << clause << ".1) Number of " << orderStr << " hexahedrons:\t" << nb8 << endl; + smIdType nb8 = NbHexas(order); + smIdType nb4 = NbTetras(order); + smIdType nb5 = NbPyramids(order); + smIdType nb6 = NbPrisms(order); + save << clause << ".1) Number of " << orderStr << " hexahedrons: \t" << nb8 << endl; save << clause << ".2) Number of " << orderStr << " tetrahedrons:\t" << nb4 << endl; save << clause << ".3) Number of " << orderStr << " prisms: \t" << nb6 << endl; - save << clause << ".4) Number of " << orderStr << " pyramids:\t" << nb5 << endl; + save << clause << ".4) Number of " << orderStr << " pyramids: \t" << nb5 << endl; if ( nb8 + nb4 + nb5 + nb6 != NbVolumes(order) ) { - map myVolumesMap; - SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator(); + std::map myVolumesMap; + SMDS_VolumeIteratorPtr itVolumes=_meshDS->volumesIterator(); while( itVolumes->more( ) ) { int nbNodes = itVolumes->next()->NbNodes(); if ( myVolumesMap.find( nbNodes ) == myVolumesMap.end() ) @@ -1363,9 +2281,9 @@ ostream& SMESH_Mesh::Dump(ostream& save) myVolumesMap[ nbNodes ] = myVolumesMap[ nbNodes ] + 1; } save << clause << ".5) Volumes in detail: " << endl; - map ::iterator itV; + std::map ::iterator itV; for (itV = myVolumesMap.begin(); itV != myVolumesMap.end(); itV++) - save << "--> nb nodes: " << itV->first << " - nb elemens:\t" << itV->second << endl; + save << "--> nb nodes: " << itV->first << " - nb elements:\t" << itV->second << endl; } } save << endl; @@ -1379,7 +2297,274 @@ ostream& SMESH_Mesh::Dump(ostream& save) //purpose : Returns type of mesh element with certain id //======================================================================= -SMDSAbs_ElementType SMESH_Mesh::GetElementType( const int id, const bool iselem ) +SMDSAbs_ElementType SMESH_Mesh::GetElementType( const smIdType id, const bool iselem ) +{ + return _meshDS->GetElementType( id, iselem ); +} + +//============================================================================= +/*! + * \brief Convert group on geometry into standalone group + */ +//============================================================================= + +SMESH_Group* SMESH_Mesh::ConvertToStandalone ( int theGroupID ) +{ + SMESH_Group* aGroup = 0; + std::map < int, SMESH_Group * >::iterator itg = _mapGroup.find( theGroupID ); + if ( itg == _mapGroup.end() ) + return aGroup; + + SMESH_Group* anOldGrp = (*itg).second; + if ( !anOldGrp || !anOldGrp->GetGroupDS() ) + return aGroup; + SMESHDS_GroupBase* anOldGrpDS = anOldGrp->GetGroupDS(); + + // create new standalone group + aGroup = new SMESH_Group (theGroupID, this, anOldGrpDS->GetType(), anOldGrp->GetName() ); + _mapGroup[theGroupID] = aGroup; + + SMESHDS_Group* aNewGrpDS = dynamic_cast( aGroup->GetGroupDS() ); + GetMeshDS()->RemoveGroup( anOldGrpDS ); + GetMeshDS()->AddGroup( aNewGrpDS ); + + // add elements (or nodes) into new created group + SMDS_ElemIteratorPtr anItr = anOldGrpDS->GetElements(); + while ( anItr->more() ) + aNewGrpDS->Add( (anItr->next())->GetID() ); + + // set color + aNewGrpDS->SetColor( anOldGrpDS->GetColor() ); + + // remove old group + delete anOldGrp; + + return aGroup; +} + +//============================================================================= +/*! + * \brief remove submesh order from Mesh + */ +//============================================================================= + +void SMESH_Mesh::ClearMeshOrder() +{ + _subMeshOrder.clear(); +} + +//============================================================================= +/*! + * \brief remove submesh order from Mesh + */ +//============================================================================= + +void SMESH_Mesh::SetMeshOrder(const TListOfListOfInt& theOrder ) +{ + _subMeshOrder = theOrder; +} + +//============================================================================= +/*! + * \brief return submesh order if any + */ +//============================================================================= + +const TListOfListOfInt& SMESH_Mesh::GetMeshOrder() const +{ + return _subMeshOrder; +} + +//============================================================================= +/*! + * \brief fill _mapAncestors + */ +//============================================================================= + +void SMESH_Mesh::fillAncestorsMap(const TopoDS_Shape& theShape) +{ + int desType, ancType; + if ( !theShape.IsSame( GetShapeToMesh()) && theShape.ShapeType() == TopAbs_COMPOUND ) + { + // a geom group is added. Insert it into lists of ancestors before + // the first ancestor more complex than group members + TopoDS_Iterator subIt( theShape ); + if ( !subIt.More() ) return; + int memberType = subIt.Value().ShapeType(); + for ( desType = TopAbs_VERTEX; desType >= memberType; desType-- ) + for (TopExp_Explorer des( theShape, TopAbs_ShapeEnum( desType )); des.More(); des.Next()) + { + if ( !_mapAncestors.Contains( des.Current() )) continue;// issue 0020982 + TopTools_ListOfShape& ancList = _mapAncestors.ChangeFromKey( des.Current() ); + TopTools_ListIteratorOfListOfShape ancIt (ancList); + while ( ancIt.More() && ancIt.Value().ShapeType() >= memberType ) + ancIt.Next(); + if ( ancIt.More() ) ancList.InsertBefore( theShape, ancIt ); + else ancList.Append( theShape ); + } + } + else // else added for 52457: Addition of hypotheses is 8 time longer than meshing + { + for ( desType = TopAbs_VERTEX; desType > TopAbs_COMPOUND; desType-- ) + for ( ancType = desType - 1; ancType >= TopAbs_COMPOUND; ancType-- ) + TopExp::MapShapesAndAncestors ( theShape, + (TopAbs_ShapeEnum) desType, + (TopAbs_ShapeEnum) ancType, + _mapAncestors ); + } + // visit COMPOUNDs inside a COMPOUND that are not reachable by TopExp_Explorer + if ( theShape.ShapeType() == TopAbs_COMPOUND ) + { + TopoDS_Iterator sIt(theShape); + if ( sIt.More() && sIt.Value().ShapeType() == TopAbs_COMPOUND ) + for ( ; sIt.More(); sIt.Next() ) + if ( sIt.Value().ShapeType() == TopAbs_COMPOUND ) + fillAncestorsMap( sIt.Value() ); + } +} + +//============================================================================= +/*! + * \brief sort submeshes according to stored mesh order + * \param theListToSort in out list to be sorted + * \return FALSE if nothing sorted + */ +//============================================================================= + +bool SMESH_Mesh::SortByMeshOrder(std::vector& theListToSort) const +{ + if ( _subMeshOrder.empty() || theListToSort.size() < 2 ) + return true; + + + // collect all ordered sub-meshes in smVec as pointers + // and get their positions within theListToSort + + std::vector smVec; + typedef std::vector::iterator TPosInList; + std::map< size_t, size_t > sortedPos; // index in theListToSort to order + TPosInList smBeg = theListToSort.begin(), smEnd = theListToSort.end(); + TListOfListOfInt::const_iterator listIdsIt = _subMeshOrder.begin(); + bool needSort = false; + for( ; listIdsIt != _subMeshOrder.end(); listIdsIt++) + { + const TListOfInt& listOfId = *listIdsIt; + // convert sm ids to sm's + smVec.clear(); + TListOfInt::const_iterator idIt = listOfId.begin(); + for ( ; idIt != listOfId.end(); idIt++ ) + { + if ( SMESH_subMesh * sm = GetSubMeshContaining( *idIt )) + { + smVec.push_back( sm ); + if ( sm->GetSubMeshDS() && sm->GetSubMeshDS()->IsComplexSubmesh() ) + { + smVec.reserve( smVec.size() + sm->GetSubMeshDS()->NbSubMeshes() ); + SMESHDS_SubMeshIteratorPtr smdsIt = sm->GetSubMeshDS()->GetSubMeshIterator(); + while ( smdsIt->more() ) + { + const SMESHDS_SubMesh* smDS = smdsIt->next(); + if (( sm = GetSubMeshContaining( smDS->GetID() ))) + smVec.push_back( sm ); + } + } + } + } + // find smVec items in theListToSort + for ( size_t i = 0; i < smVec.size(); ++i ) + { + TPosInList smPos = find( smBeg, smEnd, smVec[i] ); // position in theListToSort + if ( smPos != smEnd ) + { + size_t posInList = std::distance( smBeg, smPos ); + size_t order = sortedPos.size(); + sortedPos.insert( std::make_pair( posInList, order )); + if ( posInList != order ) + needSort = true; + } + } + } + if ( ! needSort ) + return false; + + // set sm of sortedPos from theListToSort to front of orderedSM + // and the rest of theListToSort to orderedSM end + + std::vector orderedSM; + orderedSM.reserve( theListToSort.size() ); + orderedSM.resize( sortedPos.size() ); + + size_t iPrev = 0; + sortedPos.insert( std::make_pair( theListToSort.size(), sortedPos.size() )); + for ( const auto & pos_order : sortedPos ) + { + const size_t& posInList = pos_order.first; + const size_t& order = pos_order.second; + if ( order < sortedPos.size() - 1 ) + orderedSM[ order ] = theListToSort[ posInList ]; + + if ( iPrev < posInList ) + orderedSM.insert( orderedSM.end(), + theListToSort.begin() + iPrev, + theListToSort.begin() + posInList ); + iPrev = posInList + 1; + } + + theListToSort.swap( orderedSM ); + + return true; +} + +//================================================================================ +/*! + * \brief Return true if given order of sub-meshes is OK + */ +//================================================================================ + +bool SMESH_Mesh::IsOrderOK( const SMESH_subMesh* smBefore, + const SMESH_subMesh* smAfter ) const +{ + TListOfListOfInt::const_iterator listIdsIt = _subMeshOrder.begin(); + for( ; listIdsIt != _subMeshOrder.end(); listIdsIt++) + { + const TListOfInt& listOfId = *listIdsIt; + int iB = -1, iA = -1, i = 0; + for ( TListOfInt::const_iterator id = listOfId.begin(); id != listOfId.end(); ++id, ++i ) + { + if ( *id == smBefore->GetId() ) + { + iB = i; + if ( iA > -1 ) + return iB < iA; + } + else if ( *id == smAfter->GetId() ) + { + iA = i; + if ( iB > -1 ) + return iB < iA; + } + } + } + return true; // no order imposed to given sub-meshes +} + +//============================================================================= +/*! + * \brief sort submeshes according to stored mesh order + * \param theListToSort in out list to be sorted + * \return FALSE if nothing sorted + */ +//============================================================================= + +void SMESH_Mesh::getAncestorsSubMeshes (const TopoDS_Shape& theSubShape, + std::vector< SMESH_subMesh* >& theSubMeshes) const { - return _myMeshDS->GetElementType( id, iselem ); + theSubMeshes.clear(); + TopTools_ListIteratorOfListOfShape it( GetAncestors( theSubShape )); + for (; it.More(); it.Next() ) + if ( SMESH_subMesh* sm = GetSubMeshContaining( it.Value() )) + theSubMeshes.push_back(sm); + + // sort submeshes according to stored mesh order + SortByMeshOrder( theSubMeshes ); }