X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH%2FSMESH_subMesh.cxx;h=13423354e3e970966276fa0291dd3aa4afea7516;hp=2b78950b92e092d929ce7fe13efe4dde4c516758;hb=57b43b4d010e2d0a1529d3c131bbb9d416e63258;hpb=bc37f0b49f9713347749b6325e1c7062de8857ae diff --git a/src/SMESH/SMESH_subMesh.cxx b/src/SMESH/SMESH_subMesh.cxx index 2b78950b9..13423354e 100644 --- a/src/SMESH/SMESH_subMesh.cxx +++ b/src/SMESH/SMESH_subMesh.cxx @@ -1,23 +1,23 @@ // SMESH SMESH : implementaion of SMESH idl descriptions // // 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org // // // @@ -32,16 +32,29 @@ using namespace std; #include "SMESH_Mesh.hxx" #include "SMESH_Hypothesis.hxx" #include "SMESH_Algo.hxx" +#include "SMESH_HypoFilter.hxx" + #include "utilities.h" #include "OpUtil.hxx" +#include + #include -#include +#include +#include #include #include -#include -#include -#include +#include + +#ifdef _DEBUG_ +#include +#include +#include +#include +#endif + +#include +#include //============================================================================= /*! @@ -57,7 +70,6 @@ SMESH_subMesh::SMESH_subMesh(int Id, SMESH_Mesh * father, SMESHDS_Mesh * meshDS, _subMeshDS = meshDS->MeshElements(_subShape); // may be null ... _father = father; _Id = Id; - _vertexSet = false; // only for Vertex subMesh _dependenceAnalysed = false; if (_subShape.ShapeType() == TopAbs_VERTEX) @@ -67,61 +79,58 @@ SMESH_subMesh::SMESH_subMesh(int Id, SMESH_Mesh * father, SMESHDS_Mesh * meshDS, } else { - _algoState = NO_ALGO; - _computeState = NOT_READY; + _algoState = NO_ALGO; + _computeState = NOT_READY; } } //============================================================================= /*! - * + * */ //============================================================================= SMESH_subMesh::~SMESH_subMesh() { - MESSAGE("SMESH_subMesh::~SMESH_subMesh"); - // **** + MESSAGE("SMESH_subMesh::~SMESH_subMesh"); + // **** } //============================================================================= /*! - * + * */ //============================================================================= int SMESH_subMesh::GetId() const { - //MESSAGE("SMESH_subMesh::GetId"); - return _Id; + //MESSAGE("SMESH_subMesh::GetId"); + return _Id; } //============================================================================= /*! - * + * */ //============================================================================= SMESHDS_SubMesh * SMESH_subMesh::GetSubMeshDS() { - //MESSAGE("SMESH_subMesh::GetSubMeshDS"); - if (_subMeshDS==NULL) - { - //MESSAGE("subMesh pointer still null, trying to get it..."); - _subMeshDS = _meshDS->MeshElements(_subShape); // may be null ... - if (_subMeshDS==NULL) - { - MESSAGE("problem... subMesh still empty"); - //NRI ASSERT(0); - //NRI throw SALOME_Exception(LOCALIZED(subMesh still empty)); - } - } - return _subMeshDS; + // submesh appears in DS only when a mesher set nodes and elements on it + if (_subMeshDS==NULL) + { + _subMeshDS = _meshDS->MeshElements(_subShape); // may be null ... +// if (_subMeshDS==NULL) +// { +// MESSAGE("problem... subMesh still empty"); +// } + } + return _subMeshDS; } //============================================================================= /*! - * + * */ //============================================================================= @@ -135,156 +144,159 @@ SMESHDS_SubMesh* SMESH_subMesh::CreateSubMeshDS() //============================================================================= /*! - * + * */ //============================================================================= SMESH_subMesh *SMESH_subMesh::GetFirstToCompute() { - //MESSAGE("SMESH_subMesh::GetFirstToCompute"); - const map < int, SMESH_subMesh * >&subMeshes = DependsOn(); - SMESH_subMesh *firstToCompute = 0; + const map < int, SMESH_subMesh * >&subMeshes = DependsOn(); + SMESH_subMesh *firstToCompute = 0; - map < int, SMESH_subMesh * >::const_iterator itsub; - for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++) - { - SMESH_subMesh *sm = (*itsub).second; -// SCRUTE(sm->GetId()); -// SCRUTE(sm->GetComputeState()); - bool readyToCompute = (sm->GetComputeState() == READY_TO_COMPUTE); - if (readyToCompute) - { - firstToCompute = sm; - //SCRUTE(sm->GetId()); - break; - } - } - if (firstToCompute) - { - //MESSAGE("--- submesh to compute"); - return firstToCompute; // a subMesh of this - } - if (_computeState == READY_TO_COMPUTE) - { - //MESSAGE("--- this to compute"); - return this; // this - } - //MESSAGE("--- nothing to compute"); - return 0; // nothing to compute + map < int, SMESH_subMesh * >::const_iterator itsub; + for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++) + { + SMESH_subMesh *sm = (*itsub).second; + bool readyToCompute = (sm->GetComputeState() == READY_TO_COMPUTE); + if (readyToCompute) + { + firstToCompute = sm; + break; + } + } + if (firstToCompute) + { + return firstToCompute; // a subMesh of this + } + if (_computeState == READY_TO_COMPUTE) + { + return this; // this + } + return 0; // nothing to compute } //============================================================================= /*! - * + * */ //============================================================================= bool SMESH_subMesh::SubMeshesComputed() { - //MESSAGE("SMESH_subMesh::SubMeshesComputed"); - const map < int, SMESH_subMesh * >&subMeshes = DependsOn(); + //MESSAGE("SMESH_subMesh::SubMeshesComputed"); + const map < int, SMESH_subMesh * >&subMeshes = DependsOn(); + + int myDim = SMESH_Gen::GetShapeDim( _subShape ); + int dimToCheck = myDim - 1; + bool subMeshesComputed = true; + map < int, SMESH_subMesh * >::const_iterator itsub; + for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++) + { + SMESH_subMesh *sm = (*itsub).second; + const TopoDS_Shape & ss = sm->GetSubShape(); + // MSV 07.04.2006: restrict checking to myDim-1 only. Ex., there is no sense + // in checking of existence of edges if the algo needs only faces. Moreover, + // degenerated edges may have no submesh, as after computing NETGEN_2D. + int dim = SMESH_Gen::GetShapeDim( ss ); + if (dim < dimToCheck) + continue; + SMESHDS_SubMesh * ds = sm->GetSubMeshDS(); + // PAL10974. + // There are some tricks with compute states, e.g. Penta_3D leaves + // one face with READY_TO_COMPUTE state in order to be able to + // recompute 3D when a locale triangle hypo changes (see PAL7428). + // So we check if mesh is really present + bool computeOk = (sm->GetComputeState() == COMPUTE_OK || + (ds && ( ds->GetNodes()->more() || ds->GetElements()->more() ))); + if (!computeOk) + { + int type = ss.ShapeType(); - bool subMeshesComputed = true; - map < int, SMESH_subMesh * >::const_iterator itsub; - for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++) - { - SMESH_subMesh *sm = (*itsub).second; - - const TopoDS_Shape & ss = sm->GetSubShape(); - int type = ss.ShapeType(); -// SCRUTE(sm->GetId()); -// SCRUTE(sm->GetComputeState()); - bool computeOk = (sm->GetComputeState() == COMPUTE_OK); - if (!computeOk) - { - subMeshesComputed = false; - - switch (type) - { - case TopAbs_COMPOUND: - { - MESSAGE("The not computed sub mesh is a COMPOUND"); - break; - } - case TopAbs_COMPSOLID: - { - MESSAGE("The not computed sub mesh is a COMPSOLID"); - break; - } - case TopAbs_SHELL: - { - MESSAGE("The not computed sub mesh is a SHEL"); - break; - } - case TopAbs_WIRE: - { - MESSAGE("The not computed sub mesh is a WIRE"); - break; - } - case TopAbs_SOLID: - { - MESSAGE("The not computed sub mesh is a SOLID"); - break; - } - case TopAbs_FACE: - { - MESSAGE("The not computed sub mesh is a FACE"); - break; - } - case TopAbs_EDGE: - { - MESSAGE("The not computed sub mesh is a EDGE"); - break; - } - default: - { - MESSAGE("The not computed sub mesh is of unknown type"); - break; - } - } - - SCRUTE(sm->GetId()); - break; - } - } - return subMeshesComputed; + subMeshesComputed = false; + + switch (type) + { + case TopAbs_COMPOUND: + { + MESSAGE("The not computed sub mesh is a COMPOUND"); + break; + } + case TopAbs_COMPSOLID: + { + MESSAGE("The not computed sub mesh is a COMPSOLID"); + break; + } + case TopAbs_SHELL: + { + MESSAGE("The not computed sub mesh is a SHEL"); + break; + } + case TopAbs_WIRE: + { + MESSAGE("The not computed sub mesh is a WIRE"); + break; + } + case TopAbs_SOLID: + { + MESSAGE("The not computed sub mesh is a SOLID"); + break; + } + case TopAbs_FACE: + { + MESSAGE("The not computed sub mesh is a FACE"); + break; + } + case TopAbs_EDGE: + { + MESSAGE("The not computed sub mesh is a EDGE"); + break; + } + default: + { + MESSAGE("The not computed sub mesh is of unknown type"); + break; + } + } + + break; + } + } + return subMeshesComputed; } //============================================================================= /*! - * + * */ //============================================================================= bool SMESH_subMesh::SubMeshesReady() { - MESSAGE("SMESH_subMesh::SubMeshesReady"); - const map < int, SMESH_subMesh * >&subMeshes = DependsOn(); + MESSAGE("SMESH_subMesh::SubMeshesReady"); + const map < int, SMESH_subMesh * >&subMeshes = DependsOn(); - bool subMeshesReady = true; - map < int, SMESH_subMesh * >::const_iterator itsub; - for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++) - { - SMESH_subMesh *sm = (*itsub).second; -// SCRUTE(sm->GetId()); -// SCRUTE(sm->GetComputeState()); - bool computeOk = ((sm->GetComputeState() == COMPUTE_OK) - || (sm->GetComputeState() == READY_TO_COMPUTE)); - if (!computeOk) - { - subMeshesReady = false; - SCRUTE(sm->GetId()); - break; - } - } - return subMeshesReady; + bool subMeshesReady = true; + map < int, SMESH_subMesh * >::const_iterator itsub; + for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++) + { + SMESH_subMesh *sm = (*itsub).second; + bool computeOk = ((sm->GetComputeState() == COMPUTE_OK) + || (sm->GetComputeState() == READY_TO_COMPUTE)); + if (!computeOk) + { + subMeshesReady = false; + SCRUTE(sm->GetId()); + break; + } + } + return subMeshesReady; } //============================================================================= /*! - * Construct dependence on first level subMeshes. complex shapes (compsolid, + * Construct dependence on first level subMeshes. complex shapes (compsolid, * shell, wire) are not analysed the same way as simple shapes (solid, face, - * edge). + * edge). * For collection shapes (compsolid, shell, wire) prepare a list of submeshes * with possible multiples occurences. Multiples occurences corresponds to * internal frontiers within shapes of the collection and must not be keeped. @@ -294,167 +306,111 @@ bool SMESH_subMesh::SubMeshesReady() const map < int, SMESH_subMesh * >&SMESH_subMesh::DependsOn() { - if (_dependenceAnalysed) - return _mapDepend; + if (_dependenceAnalysed) + return _mapDepend; - //MESSAGE("SMESH_subMesh::DependsOn"); + //MESSAGE("SMESH_subMesh::DependsOn"); - int type = _subShape.ShapeType(); - //SCRUTE(type); - switch (type) - { - case TopAbs_COMPOUND: - { - //MESSAGE("compound"); - list < TopoDS_Shape > shellInSolid; - for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More(); - exp.Next()) - { - InsertDependence(exp.Current()); - for (TopExp_Explorer - exp2(exp.Current(), TopAbs_SHELL); exp2.More(); exp2.Next()) - { - shellInSolid.push_back(exp2.Current()); - } - } - for (TopExp_Explorer exp(_subShape, TopAbs_SHELL); exp.More(); - exp.Next()) - { - list < TopoDS_Shape >::iterator it1; - bool isInSolid = false; - for (it1 = shellInSolid.begin(); it1 != shellInSolid.end(); it1++) - { - TopoDS_Shape aShape = (*it1); - if (aShape.IsSame(exp.Current())) - { - isInSolid = true; - break; - } - } - if (!isInSolid) - InsertDependence(exp.Current()); //only shell not in solid - } - for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More(); - exp.Next()) - { - InsertDependence(exp.Current()); - } - for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More(); - exp.Next()) - { - InsertDependence(exp.Current()); - } - break; - } - case TopAbs_COMPSOLID: - { + int type = _subShape.ShapeType(); + //SCRUTE(type); + switch (type) + { + case TopAbs_COMPOUND: + { + //MESSAGE("compound"); + for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More(); + exp.Next()) + { + InsertDependence(exp.Current()); + } + for (TopExp_Explorer exp(_subShape, TopAbs_SHELL, TopAbs_SOLID); exp.More(); + exp.Next()) + { + InsertDependence(exp.Current()); //only shell not in solid + } + for (TopExp_Explorer exp(_subShape, TopAbs_FACE, TopAbs_SHELL); exp.More(); + exp.Next()) + { + InsertDependence(exp.Current()); + } + for (TopExp_Explorer exp(_subShape, TopAbs_EDGE, TopAbs_FACE); exp.More(); + exp.Next()) + { + InsertDependence(exp.Current()); + } + break; + } + case TopAbs_COMPSOLID: + { //MESSAGE("compsolid"); - for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More(); - exp.Next()) - { - InsertDependence(exp.Current()); - } -// list shapeList; -// for (TopExp_Explorer exp(_subShape,TopAbs_SOLID);exp.More();exp.Next()) -// { -// for (TopExp_Explorer -// exp2(exp.Current(),TopAbs_FACE);exp2.More();exp2.Next()) -// { -// shapeList.push_back(exp2.Current()); -// } -// } -// FinalizeDependence(shapeList); - break; - } - case TopAbs_SHELL: - { - //MESSAGE("shell"); - for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More(); - exp.Next()) - { - InsertDependence(exp.Current()); - } -// list shapeList; -// for (TopExp_Explorer exp(_subShape,TopAbs_FACE);exp.More();exp.Next()) -// { -// for (TopExp_Explorer -// exp2(exp.Current(),TopAbs_EDGE);exp2.More();exp2.Next()) -// { -// shapeList.push_back(exp2.Current()); -// } -// } -// FinalizeDependence(shapeList); - break; - } - case TopAbs_WIRE: - { - //MESSAGE("wire"); - for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More(); - exp.Next()) - { - InsertDependence(exp.Current()); - } -// list shapeList; -// for (TopExp_Explorer exp(_subShape,TopAbs_EDGE);exp.More();exp.Next()) -// { -// for (TopExp_Explorer -// exp2(exp.Current(),TopAbs_VERTEX);exp2.More();exp2.Next()) -// { -// shapeList.push_back(exp2.Current()); -// } -// } -// FinalizeDependence(shapeList); - break; - } - case TopAbs_SOLID: - { - //MESSAGE("solid"); -// for (TopExp_Explorer exp(_subShape,TopAbs_SHELL);exp.More();exp.Next()) -// { -// InsertDependence(exp.Current()); -// } - for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More(); - exp.Next()) - { - InsertDependence(exp.Current()); - } - break; - } - case TopAbs_FACE: - { - //MESSAGE("face"); -// for (TopExp_Explorer exp(_subShape,TopAbs_WIRE);exp.More();exp.Next()) -// { -// InsertDependence(exp.Current()); -// } - for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More(); - exp.Next()) - { - InsertDependence(exp.Current()); - } - break; - } - case TopAbs_EDGE: - { - //MESSAGE("edge"); - for (TopExp_Explorer exp(_subShape, TopAbs_VERTEX); exp.More(); - exp.Next()) - { + for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More(); + exp.Next()) + { + InsertDependence(exp.Current()); + } + break; + } + case TopAbs_SHELL: + { + //MESSAGE("shell"); + for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More(); + exp.Next()) + { + InsertDependence(exp.Current()); + } + break; + } + case TopAbs_WIRE: + { + //MESSAGE("wire"); + for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More(); + exp.Next()) + { + InsertDependence(exp.Current()); + } + break; + } + case TopAbs_SOLID: + { + //MESSAGE("solid"); + for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More(); + exp.Next()) + { + InsertDependence(exp.Current()); + } + break; + } + case TopAbs_FACE: + { + //MESSAGE("face"); + for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More(); + exp.Next()) + { + InsertDependence(exp.Current()); + } + break; + } + case TopAbs_EDGE: + { + //MESSAGE("edge"); + for (TopExp_Explorer exp(_subShape, TopAbs_VERTEX); exp.More(); + exp.Next()) + { InsertDependence(exp.Current()); - } - break; - } - case TopAbs_VERTEX: - { - break; - } - default: - { - break; - } - } - _dependenceAnalysed = true; - return _mapDepend; + } + break; + } + case TopAbs_VERTEX: + { + break; + } + default: + { + break; + } + } + _dependenceAnalysed = true; + return _mapDepend; } //============================================================================= @@ -465,35 +421,27 @@ const map < int, SMESH_subMesh * >&SMESH_subMesh::DependsOn() void SMESH_subMesh::InsertDependence(const TopoDS_Shape aSubShape) { - //MESSAGE("SMESH_subMesh::InsertDependence"); - SMESH_subMesh *aSubMesh = _father->GetSubMesh(aSubShape); - int type = aSubShape.ShapeType(); - int ordType = 9 - type; // 2 = Vertex, 8 = CompSolid - int cle = aSubMesh->GetId(); - cle += 10000000 * ordType; // sort map by ordType then index - if (_mapDepend.find(cle) == _mapDepend.end()) - { - _mapDepend[cle] = aSubMesh; - const map < int, SMESH_subMesh * >&subMap = aSubMesh->DependsOn(); - map < int, SMESH_subMesh * >::const_iterator im; - for (im = subMap.begin(); im != subMap.end(); im++) - { - int clesub = (*im).first; - SMESH_subMesh *sm = (*im).second; - if (_mapDepend.find(clesub) == _mapDepend.end()) - _mapDepend[clesub] = sm; - } - } - + //MESSAGE("SMESH_subMesh::InsertDependence"); + SMESH_subMesh *aSubMesh = _father->GetSubMesh(aSubShape); + int type = aSubShape.ShapeType(); + int ordType = 9 - type; // 2 = Vertex, 8 = CompSolid + int cle = aSubMesh->GetId(); + cle += 10000000 * ordType; // sort map by ordType then index + if ( _mapDepend.find( cle ) == _mapDepend.end()) + { + _mapDepend[cle] = aSubMesh; + const map < int, SMESH_subMesh * > & subMap = aSubMesh->DependsOn(); + _mapDepend.insert( subMap.begin(), subMap.end() ); + } } //============================================================================= /*! - * + * */ //============================================================================= -const TopoDS_Shape & SMESH_subMesh::GetSubShape() +const TopoDS_Shape & SMESH_subMesh::GetSubShape() const { //MESSAGE("SMESH_subMesh::GetSubShape"); return _subShape; @@ -514,45 +462,40 @@ bool SMESH_subMesh::CanAddHypothesis(const SMESH_Hypothesis* theHypothesis) cons return true; // if ( aHypDim < aShapeDim ) // return ( _father->IsMainShape( _subShape )); - + return false; } //======================================================================= //function : IsApplicableHypotesis -//purpose : return true if theHypothesis can be used to mesh me: -// its shape type is checked +//purpose : //======================================================================= -bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis) const +bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis, + const TopAbs_ShapeEnum theShapeType) { if ( theHypothesis->GetType() > SMESHDS_Hypothesis::PARAM_ALGO) // algorithm - return ( theHypothesis->GetShapeType() & (1<< _subShape.ShapeType())); + return ( theHypothesis->GetShapeType() & (1<< theShapeType)); // hypothesis - switch ( _subShape.ShapeType() ) { - case TopAbs_EDGE: - case TopAbs_FACE: + switch ( theShapeType ) { + case TopAbs_EDGE: + case TopAbs_FACE: case TopAbs_SHELL: - case TopAbs_SOLID: { - int aHypDim = theHypothesis->GetDim(); - int aShapeDim = SMESH_Gen::GetShapeDim(_subShape); - return ( aHypDim == aShapeDim ); - } -// case TopAbs_VERTEX: + case TopAbs_SOLID: + return SMESH_Gen::GetShapeDim( theShapeType ) == theHypothesis->GetDim(); // case TopAbs_WIRE: // case TopAbs_COMPSOLID: // case TopAbs_COMPOUND: default:; } - return false; } //============================================================================= /*! - * + * */ //============================================================================= @@ -566,14 +509,19 @@ SMESH_Hypothesis::Hypothesis_Status // **** les retour des evenement shape sont significatifs // (add ou remove fait ou non) // le retour des evenement father n'indiquent pas que add ou remove fait - int dim = SMESH_Gen::GetShapeDim(_subShape); SMESH_Hypothesis::Hypothesis_Status aux_ret, ret = SMESH_Hypothesis::HYP_OK; + + int dim = SMESH_Gen::GetShapeDim(_subShape); + if (dim < 1) - { - _algoState = HYP_OK; - return ret; - } + { + _algoState = HYP_OK; + if (event == ADD_HYP || event == ADD_ALGO) + return SMESH_Hypothesis::HYP_BAD_DIM; // do not allow to assign any hyp + else + return SMESH_Hypothesis::HYP_OK; + } SMESH_Gen* gen =_father->GetGen(); // bool ret = false; @@ -591,7 +539,7 @@ SMESH_Hypothesis::Hypothesis_Status !IsConform( static_cast< SMESH_Algo* >( anHyp ))) return SMESH_Hypothesis::HYP_NOTCONFORM; } - + // ---------------------------------- // add a hypothesis to DS if possible // ---------------------------------- @@ -600,11 +548,53 @@ SMESH_Hypothesis::Hypothesis_Status if ( ! CanAddHypothesis( anHyp )) return SMESH_Hypothesis::HYP_BAD_DIM; - if ( GetNbAttached( _subShape, anHyp ) > 0 ) + if ( /*!anHyp->IsAuxiliary() &&*/ GetSimilarAttached( _subShape, anHyp ) ) return SMESH_Hypothesis::HYP_ALREADY_EXIST; if ( !_meshDS->AddHypothesis(_subShape, anHyp)) return SMESH_Hypothesis::HYP_ALREADY_EXIST; + + // Serve Propagation of 1D hypothesis + if (event == ADD_HYP) { + bool isPropagationOk = true; + bool isPropagationHyp = ( strcmp( "Propagation", anHyp->GetName() ) == 0 ); + + if ( isPropagationHyp ) { + TopExp_Explorer exp (_subShape, TopAbs_EDGE); + TopTools_MapOfShape aMap; + for (; exp.More(); exp.Next()) { + if (aMap.Add(exp.Current())) { + if (!_father->BuildPropagationChain(exp.Current())) { + isPropagationOk = false; + } + } + } + } + else if (anHyp->GetDim() == 1) { // Only 1D hypothesis can be propagated + TopExp_Explorer exp (_subShape, TopAbs_EDGE); + TopTools_MapOfShape aMap; + for (; exp.More(); exp.Next()) { + if (aMap.Add(exp.Current())) { + TopoDS_Shape aMainEdge; + if (_father->IsPropagatedHypothesis(exp.Current(), aMainEdge)) { + isPropagationOk = _father->RebuildPropagationChains(); + } else if (_father->IsPropagationHypothesis(exp.Current())) { + isPropagationOk = _father->BuildPropagationChain(exp.Current()); + } else { + } + } + } + } else { + } + + if ( isPropagationOk ) { + if ( isPropagationHyp ) + return ret; // nothing more to do for "Propagation" hypothesis + } + else if ( ret < SMESH_Hypothesis::HYP_CONCURENT) { + ret = SMESH_Hypothesis::HYP_CONCURENT; + } + } // Serve Propagation of 1D hypothesis } // -------------------------- @@ -614,6 +604,57 @@ SMESH_Hypothesis::Hypothesis_Status { if (!_meshDS->RemoveHypothesis(_subShape, anHyp)) return SMESH_Hypothesis::HYP_OK; // nothing changes + + // Serve Propagation of 1D hypothesis + if (event == REMOVE_HYP) + { + bool isPropagationOk = true; + SMESH_HypoFilter propagFilter( SMESH_HypoFilter::HasName( "Propagation" )); + bool isPropagationHyp = propagFilter.IsOk( anHyp, _subShape ); + + if ( isPropagationHyp ) + { + TopExp_Explorer exp (_subShape, TopAbs_EDGE); + TopTools_MapOfShape aMap; + for (; exp.More(); exp.Next()) { + if (aMap.Add(exp.Current()) && + !_father->GetHypothesis( exp.Current(), propagFilter, true )) { + // no more Propagation on the current edge + if (!_father->RemovePropagationChain(exp.Current())) { + return SMESH_Hypothesis::HYP_UNKNOWN_FATAL; + } + } + } + // rebuild propagation chains, because removing one + // chain can resolve concurention, existing before + isPropagationOk = _father->RebuildPropagationChains(); + } + else if (anHyp->GetDim() == 1) // Only 1D hypothesis can be propagated + { + isPropagationOk = _father->RebuildPropagationChains(); + } + + if ( isPropagationOk ) { + if ( isPropagationHyp ) + return ret; // nothing more to do for "Propagation" hypothesis + } + else if ( ret < SMESH_Hypothesis::HYP_CONCURENT) { + ret = SMESH_Hypothesis::HYP_CONCURENT; + } + } // Serve Propagation of 1D hypothesis + else // event == REMOVE_ALGO + { + SMESH_Algo* algo = dynamic_cast (anHyp); + if (!algo->NeedDescretBoundary()) + { + // clean all mesh in the tree of the current submesh; + // we must perform it now because later + // we will have no information about the type of the removed algo + CleanDependants(); + ComputeStateEngine( CLEAN ); + CleanDependsOn(); + } + } } // ------------------ @@ -634,7 +675,7 @@ SMESH_Hypothesis::Hypothesis_Status case ADD_ALGO: { SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape); ASSERT(algo); - if (algo->CheckHypothesis((*_father),_subShape, ret)) + if (algo->CheckHypothesis((*_father),_subShape, aux_ret)) SetAlgoState(HYP_OK); else SetAlgoState(MISSING_HYP); @@ -688,7 +729,7 @@ SMESH_Hypothesis::Hypothesis_Status SetAlgoState(HYP_OK); if (SMESH_Hypothesis::IsStatusFatal( ret )) _meshDS->RemoveHypothesis(_subShape, anHyp); - else if (!_father->IsUsedHypothesis( anHyp, _subShape )) + else if (!_father->IsUsedHypothesis( anHyp, this )) { _meshDS->RemoveHypothesis(_subShape, anHyp); ret = SMESH_Hypothesis::HYP_INCOMPATIBLE; @@ -765,7 +806,7 @@ SMESH_Hypothesis::Hypothesis_Status break; // ---------------------------------------------------------------------- - + case HYP_OK: switch (event) { @@ -774,27 +815,39 @@ SMESH_Hypothesis::Hypothesis_Status ASSERT(algo); if (!algo->CheckHypothesis((*_father),_subShape, ret )) { - MESSAGE("two applying algo on the same shape not allowed"); - _meshDS->RemoveHypothesis(_subShape, anHyp); - //ret = SMESH_Hypothesis::HYP_ALREADY_EXIST; + if ( !SMESH_Hypothesis::IsStatusFatal( ret )) + // ret should be fatal: anHyp was not added + ret = SMESH_Hypothesis::HYP_INCOMPATIBLE; } - else if (SMESH_Hypothesis::IsStatusFatal( ret )) - _meshDS->RemoveHypothesis(_subShape, anHyp); - else if (!_father->IsUsedHypothesis( anHyp, _subShape )) + else if (!_father->IsUsedHypothesis( anHyp, this )) + ret = SMESH_Hypothesis::HYP_INCOMPATIBLE; + + if (SMESH_Hypothesis::IsStatusFatal( ret )) { + MESSAGE("do not add extra hypothesis"); _meshDS->RemoveHypothesis(_subShape, anHyp); - ret = SMESH_Hypothesis::HYP_INCOMPATIBLE; } - modifiedHyp = _father->IsUsedHypothesis( anHyp, _subShape ); // new Hyp? + else + { + modifiedHyp = true; + } break; } case ADD_ALGO: { //already existing algo : on father ? SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape); - if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { + // check if algo changes + SMESH_HypoFilter f; + f.Init( SMESH_HypoFilter::IsAlgo() ); + f.And( SMESH_HypoFilter::IsApplicableTo( _subShape )); + f.AndNot( SMESH_HypoFilter::Is( algo )); + const SMESH_Hypothesis * prevAlgo = _father->GetHypothesis( _subShape, f, true ); + if (prevAlgo && + string(algo->GetName()) != string(prevAlgo->GetName()) ) + modifiedHyp = true; + } else SetAlgoState(MISSING_HYP); - modifiedHyp = true; break; } case REMOVE_HYP: { @@ -805,9 +858,6 @@ SMESH_Hypothesis::Hypothesis_Status else SetAlgoState(MISSING_HYP); modifiedHyp = true; - // report only severe errors - if ( SMESH_Hypothesis::IsStatusFatal( aux_ret )) - ret = aux_ret; break; } case REMOVE_ALGO: { // perhaps a father algo applies ? @@ -818,14 +868,13 @@ SMESH_Hypothesis::Hypothesis_Status } else { - if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { + // check if algo remains + if ( anHyp != algo && strcmp( anHyp->GetName(), algo->GetName()) ) + modifiedHyp = true; + } else SetAlgoState(MISSING_HYP); - modifiedHyp = true; - // report only severe errors - if ( SMESH_Hypothesis::IsStatusFatal( aux_ret )) - ret = aux_ret; } break; } @@ -834,33 +883,42 @@ SMESH_Hypothesis::Hypothesis_Status ASSERT(algo); if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { - SetAlgoState(HYP_OK); - if (_father->IsUsedHypothesis( anHyp, _subShape )) // new Hyp + if (_father->IsUsedHypothesis( anHyp, this )) // new Hyp modifiedHyp = true; } else SetAlgoState(MISSING_HYP); break; } - case ADD_FATHER_ALGO: { // a new algo on father + case ADD_FATHER_ALGO: { SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape); - if ( algo == anHyp ) { - if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + if ( algo == anHyp ) { // a new algo on father + if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { + // check if algo changes + SMESH_HypoFilter f; + f.Init( SMESH_HypoFilter::IsAlgo() ); + f.And( SMESH_HypoFilter::IsApplicableTo( _subShape )); + f.AndNot( SMESH_HypoFilter::Is( algo )); + const SMESH_Hypothesis* prevAlgo = _father->GetHypothesis( _subShape, f, true ); + if (prevAlgo && + string(algo->GetName()) != string(prevAlgo->GetName()) ) + modifiedHyp = true; + } else SetAlgoState(MISSING_HYP); - modifiedHyp = true; } break; } case REMOVE_FATHER_HYP: { SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape); ASSERT(algo); - if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { + // is there the same local hyp or maybe a new father algo applied? + if ( !GetSimilarAttached( _subShape, anHyp ) ) + modifiedHyp = true; + } else SetAlgoState(MISSING_HYP); - modifiedHyp = true; break; } case REMOVE_FATHER_ALGO: { @@ -871,11 +929,13 @@ SMESH_Hypothesis::Hypothesis_Status } else { - if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { + // check if algo changes + if ( string(algo->GetName()) != string( anHyp->GetName()) ) + modifiedHyp = true; + } else SetAlgoState(MISSING_HYP); - modifiedHyp = true; } break; } @@ -884,29 +944,16 @@ SMESH_Hypothesis::Hypothesis_Status break; } break; - + // ---------------------------------------------------------------------- - + default: ASSERT(0); break; } - // ---------------------------------------- - // check concurent hypotheses on ansestors - // ---------------------------------------- - if (ret < SMESH_Hypothesis::HYP_CONCURENT && - (event == ADD_FATHER_HYP || - event == ADD_FATHER_ALGO || - event == REMOVE_FATHER_HYP || - event == REMOVE_FATHER_ALGO || - event == REMOVE_ALGO || - event == REMOVE_HYP)) - { - ret = CheckConcurentHypothesis( anHyp->GetType() ); - } if ((_algoState != oldAlgoState) || modifiedHyp) - int retc = ComputeStateEngine(MODIF_ALGO_STATE); + ComputeStateEngine(MODIF_ALGO_STATE); return ret; } @@ -919,7 +966,7 @@ SMESH_Hypothesis::Hypothesis_Status bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo) { - MESSAGE( "SMESH_subMesh::IsConform" ); +// MESSAGE( "SMESH_subMesh::IsConform" ); if ( !theAlgo ) return false; @@ -929,9 +976,9 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo) return true; SMESH_Gen* gen =_father->GetGen(); - + // only local algo is to be checked - if ( gen->IsGlobalAlgo( theAlgo, *_father )) + if ( gen->IsGlobalHypothesis( theAlgo, *_father )) return true; // check algo attached to adjacent shapes @@ -954,7 +1001,7 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo) if (algo && //algo != theAlgo && !algo->NeedDescretBoundary() /*&& - !gen->IsGlobalAlgo( algo, *_father )*/) + !gen->IsGlobalHypothesis( algo, *_father )*/) return false; // NOT CONFORM MESH WILL BE PRODUCED } } @@ -964,73 +1011,67 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo) //============================================================================= /*! - * + * */ //============================================================================= void SMESH_subMesh::SetAlgoState(int state) { -// if (state != _oldAlgoState) -// int retc = ComputeStateEngine(MODIF_ALGO_STATE); - _algoState = state; + _algoState = state; } //============================================================================= /*! - * + * */ //============================================================================= -SMESH_Hypothesis::Hypothesis_Status - SMESH_subMesh::SubMeshesAlgoStateEngine(int event, - SMESH_Hypothesis * anHyp) +SMESH_Hypothesis::Hypothesis_Status + SMESH_subMesh::SubMeshesAlgoStateEngine(int event, + SMESH_Hypothesis * anHyp) { - //MESSAGE("SMESH_subMesh::SubMeshesAlgoStateEngine"); + //MESSAGE("SMESH_subMesh::SubMeshesAlgoStateEngine"); SMESH_Hypothesis::Hypothesis_Status ret = SMESH_Hypothesis::HYP_OK; - //EAP: a wire (dim==1) should notify edges (dim==1) - //EAP: int dim = SMESH_Gen::GetShapeDim(_subShape); - if (/*EAP:dim > 1*/ _subShape.ShapeType() < TopAbs_EDGE ) - { - const map < int, SMESH_subMesh * >&subMeshes = DependsOn(); + //EAP: a wire (dim==1) should notify edges (dim==1) + //EAP: int dim = SMESH_Gen::GetShapeDim(_subShape); + if (_subShape.ShapeType() < TopAbs_EDGE ) // wire,face etc + { + const map < int, SMESH_subMesh * >&subMeshes = DependsOn(); - map < int, SMESH_subMesh * >::const_iterator itsub; - for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++) - { - SMESH_subMesh *sm = (*itsub).second; - SMESH_Hypothesis::Hypothesis_Status ret2 = - sm->AlgoStateEngine(event, anHyp); - if ( ret2 > ret ) - ret = ret2; - } - } + map < int, SMESH_subMesh * >::const_iterator itsub; + for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++) + { + SMESH_subMesh *sm = (*itsub).second; + SMESH_Hypothesis::Hypothesis_Status ret2 = + sm->AlgoStateEngine(event, anHyp); + if ( ret2 > ret ) + ret = ret2; + } + } return ret; } //============================================================================= /*! - * + * */ //============================================================================= void SMESH_subMesh::CleanDependsOn() { - MESSAGE("SMESH_subMesh::CleanDependsOn"); - // **** parcourir les ancetres dans l'ordre de dépendance - - ComputeStateEngine(CLEAN); + //MESSAGE("SMESH_subMesh::CleanDependsOn"); - const map < int, SMESH_subMesh * >&dependson = DependsOn(); - map < int, SMESH_subMesh * >::const_iterator its; - for (its = dependson.begin(); its != dependson.end(); its++) - { - SMESH_subMesh *sm = (*its).second; - SCRUTE((*its).first); - sm->ComputeStateEngine(CLEAN); - } + const map < int, SMESH_subMesh * >&dependson = DependsOn(); + map < int, SMESH_subMesh * >::const_iterator its; + for (its = dependson.begin(); its != dependson.end(); its++) + { + SMESH_subMesh *sm = (*its).second; + sm->ComputeStateEngine(CLEAN); + } } //============================================================================= /*! - * + * */ //============================================================================= @@ -1080,9 +1121,40 @@ void SMESH_subMesh::DumpAlgoState(bool isMain) } } +//================================================================================ +/*! + * \brief Remove nodes and elements bound to submesh + * \param subMesh - submesh containing nodes and elements + */ +//================================================================================ + +static void cleanSubMesh( SMESH_subMesh * subMesh ) +{ + if (subMesh) { + if (SMESHDS_SubMesh * subMeshDS = subMesh->GetSubMeshDS()) { + SMESHDS_Mesh * meshDS = subMesh->GetFather()->GetMeshDS(); + SMDS_ElemIteratorPtr ite = subMeshDS->GetElements(); + while (ite->more()) { + const SMDS_MeshElement * elt = ite->next(); + //MESSAGE( " RM elt: "<GetID()<<" ( "<NbNodes()<<" )" ); + //meshDS->RemoveElement(elt); + meshDS->RemoveFreeElement(elt, subMeshDS); + } + + SMDS_NodeIteratorPtr itn = subMeshDS->GetNodes(); + while (itn->more()) { + const SMDS_MeshNode * node = itn->next(); + //MESSAGE( " RM node: "<GetID()); + //meshDS->RemoveNode(node); + meshDS->RemoveFreeNode(node, subMeshDS); + } + } + } +} + //============================================================================= /*! - * + * */ //============================================================================= @@ -1096,16 +1168,15 @@ bool SMESH_subMesh::ComputeStateEngine(int event) if (dim < 1) { - if (_vertexSet) + if ( IsMeshComputed() ) _computeState = COMPUTE_OK; else _computeState = READY_TO_COMPUTE; - //SCRUTE(_computeState); return true; } SMESH_Gen *gen = _father->GetGen(); SMESH_Algo *algo = 0; - bool ret; + bool ret = true; SMESH_Hypothesis::Hypothesis_Status hyp_status; switch (_computeState) @@ -1116,26 +1187,32 @@ bool SMESH_subMesh::ComputeStateEngine(int event) case NOT_READY: switch (event) { - case MODIF_HYP: // nothing to do - break; + case MODIF_HYP: case MODIF_ALGO_STATE: - if (_algoState == HYP_OK) + algo = gen->GetAlgo((*_father), _subShape); + if (algo && !algo->NeedDescretBoundary()) + CleanDependsOn(); // clean sub-meshes with event CLEAN + if (event == MODIF_ALGO_STATE && _algoState == HYP_OK) { _computeState = READY_TO_COMPUTE; } break; - case COMPUTE: // nothing to do + case COMPUTE: // nothing to do break; case CLEAN: - RemoveSubMeshElementsAndNodes(); - break; - case CLEANDEP: CleanDependants(); + RemoveSubMeshElementsAndNodes(); break; case SUBMESH_COMPUTED: // nothing to do break; case SUBMESH_RESTORED: - ComputeSubMeshStateEngine( SUBMESH_RESTORED ); + ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE ); + break; + case MESH_ENTITY_REMOVED: + break; + case CHECK_COMPUTE_STATE: + if ( IsMeshComputed() ) + _computeState = COMPUTE_OK; break; default: ASSERT(0); @@ -1148,11 +1225,14 @@ bool SMESH_subMesh::ComputeStateEngine(int event) case READY_TO_COMPUTE: switch (event) { - case MODIF_HYP: // nothing to do - break; + case MODIF_HYP: case MODIF_ALGO_STATE: - _computeState = NOT_READY; algo = gen->GetAlgo((*_father), _subShape); + if (algo && !algo->NeedDescretBoundary()) + CleanDependsOn(); // clean sub-meshes with event CLEAN + if (event == MODIF_HYP) + break; // nothing else to do when MODIF_HYP + _computeState = NOT_READY; if (algo) { ret = algo->CheckHypothesis((*_father), _subShape, hyp_status); @@ -1181,17 +1261,37 @@ bool SMESH_subMesh::ComputeStateEngine(int event) break; } // compute - if (!algo->NeedDescretBoundary() && !algo->OnlyUnaryInput()) - ret = ApplyToCollection( algo, GetCollection( gen, algo ) ); - else - ret = algo->Compute((*_father), _subShape); - + CleanDependants(); + RemoveSubMeshElementsAndNodes(); + { + try { + if (!algo->NeedDescretBoundary() && !algo->OnlyUnaryInput()) + ret = ApplyToCollection( algo, GetCollection( gen, algo ) ); + else + ret = algo->Compute((*_father), _subShape); + } + catch (Standard_Failure) { + MESSAGE( "Exception in algo->Compute() "); + ret = false; + } + } if (!ret) { MESSAGE("problem in algo execution: failed to compute"); _computeState = FAILED_TO_COMPUTE; if (!algo->NeedDescretBoundary()) UpdateSubMeshState( FAILED_TO_COMPUTE ); + +#ifdef _DEBUG_ + // Show vertices location of a failed shape + cout << algo->GetName() << " failed on shape with the following vertices:" << endl; + TopTools_IndexedMapOfShape vMap; + TopExp::MapShapes( _subShape, TopAbs_VERTEX, vMap ); + for ( int iv = 1; iv <= vMap.Extent(); ++iv ) { + gp_Pnt P( BRep_Tool::Pnt( TopoDS::Vertex( vMap( iv ) ))); + cout << P.X() << " " << P.Y() << " " << P.Z() << " " << endl; + } +#endif break; } else @@ -1204,6 +1304,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event) } break; case CLEAN: + CleanDependants(); RemoveSubMeshElementsAndNodes(); _computeState = NOT_READY; algo = gen->GetAlgo((*_father), _subShape); @@ -1214,18 +1315,19 @@ bool SMESH_subMesh::ComputeStateEngine(int event) _computeState = READY_TO_COMPUTE; } break; - case CLEANDEP: - CleanDependants(); - break; case SUBMESH_COMPUTED: // nothing to do break; case SUBMESH_RESTORED: // check if a mesh is already computed that may // happen after retrieval from a file - if ( IsMeshComputed() ) { + ComputeStateEngine( CHECK_COMPUTE_STATE ); + ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE ); + break; + case MESH_ENTITY_REMOVED: + break; + case CHECK_COMPUTE_STATE: + if ( IsMeshComputed() ) _computeState = COMPUTE_OK; - } - ComputeSubMeshStateEngine( SUBMESH_RESTORED ); break; default: ASSERT(0); @@ -1239,20 +1341,16 @@ bool SMESH_subMesh::ComputeStateEngine(int event) switch (event) { case MODIF_HYP: - CleanDependants(); // recursive recall with event CLEANDEP - algo = gen->GetAlgo((*_father), _subShape); - if (algo && !algo->NeedDescretBoundary()) - CleanDependsOn(); // remove sub-mesh with event CLEANDEP - break; case MODIF_ALGO_STATE: - CleanDependants(); // recursive recall with event CLEANDEP + ComputeStateEngine( CLEAN ); algo = gen->GetAlgo((*_father), _subShape); if (algo && !algo->NeedDescretBoundary()) - CleanDependsOn(); // remove sub-mesh with event CLEANDEP + CleanDependsOn(); // clean sub-meshes with event CLEAN break; - case COMPUTE: // nothing to do + case COMPUTE: // nothing to do break; case CLEAN: + CleanDependants(); // clean sub-meshes, dependant on this one, with event CLEAN RemoveSubMeshElementsAndNodes(); _computeState = NOT_READY; algo = gen->GetAlgo((*_father), _subShape); @@ -1263,13 +1361,23 @@ bool SMESH_subMesh::ComputeStateEngine(int event) _computeState = READY_TO_COMPUTE; } break; - case CLEANDEP: - CleanDependants(); // recursive recall with event CLEANDEP - break; case SUBMESH_COMPUTED: // nothing to do break; case SUBMESH_RESTORED: - ComputeSubMeshStateEngine( SUBMESH_RESTORED ); + ComputeStateEngine( CHECK_COMPUTE_STATE ); + ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE ); + break; + case MESH_ENTITY_REMOVED: + UpdateDependantsState( CHECK_COMPUTE_STATE ); + ComputeStateEngine( CHECK_COMPUTE_STATE ); + ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE ); + break; + case CHECK_COMPUTE_STATE: + if ( !IsMeshComputed() ) + if (_algoState == HYP_OK) + _computeState = READY_TO_COMPUTE; + else + _computeState = NOT_READY; break; default: ASSERT(0); @@ -1294,18 +1402,16 @@ bool SMESH_subMesh::ComputeStateEngine(int event) else _computeState = NOT_READY; break; - case COMPUTE: // nothing to do + case COMPUTE: // nothing to do break; case CLEAN: + CleanDependants(); // submeshes dependent on me should be cleaned as well RemoveSubMeshElementsAndNodes(); if (_algoState == HYP_OK) _computeState = READY_TO_COMPUTE; else _computeState = NOT_READY; break; - case CLEANDEP: - CleanDependants(); - break; case SUBMESH_COMPUTED: // allow retry compute if (_algoState == HYP_OK) _computeState = READY_TO_COMPUTE; @@ -1313,7 +1419,18 @@ bool SMESH_subMesh::ComputeStateEngine(int event) _computeState = NOT_READY; break; case SUBMESH_RESTORED: - ComputeSubMeshStateEngine( SUBMESH_RESTORED ); + ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE ); + break; + case MESH_ENTITY_REMOVED: + break; + case CHECK_COMPUTE_STATE: + if ( IsMeshComputed() ) + _computeState = COMPUTE_OK; + else + if (_algoState == HYP_OK) + _computeState = READY_TO_COMPUTE; + else + _computeState = NOT_READY; break; default: ASSERT(0); @@ -1373,7 +1490,7 @@ bool SMESH_subMesh::ApplyToCollection (SMESH_Algo* theAlgo, //======================================================================= //function : UpdateSubMeshState -//purpose : +//purpose : //======================================================================= void SMESH_subMesh::UpdateSubMeshState(const compute_state theState) @@ -1389,7 +1506,7 @@ void SMESH_subMesh::UpdateSubMeshState(const compute_state theState) //======================================================================= //function : ComputeSubMeshStateEngine -//purpose : +//purpose : //======================================================================= void SMESH_subMesh::ComputeSubMeshStateEngine(int event) @@ -1405,7 +1522,7 @@ void SMESH_subMesh::ComputeSubMeshStateEngine(int event) //======================================================================= //function : UpdateDependantsState -//purpose : +//purpose : //======================================================================= void SMESH_subMesh::UpdateDependantsState(const compute_event theEvent) @@ -1424,81 +1541,57 @@ void SMESH_subMesh::UpdateDependantsState(const compute_event theEvent) //============================================================================= /*! - * + * */ //============================================================================= void SMESH_subMesh::CleanDependants() { - //MESSAGE("SMESH_subMesh::CleanDependants: shape type " << _subShape.ShapeType() ); + int dimToClean = SMESH_Gen::GetShapeDim( _subShape ) + 1; TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape )); for (; it.More(); it.Next()) { const TopoDS_Shape& ancestor = it.Value(); - //MESSAGE("ancestor shape type " << ancestor.ShapeType() ); - SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor); - if (aSubMesh) - aSubMesh->ComputeStateEngine(CLEANDEP); - } - ComputeStateEngine(CLEAN); -} - - -//============================================================================= -/*! - * - */ -//============================================================================= - -static void removeSubMesh( SMESHDS_Mesh * meshDS, const TopoDS_Shape& subShape) -{ - SMESHDS_SubMesh * subMeshDS = meshDS->MeshElements(subShape); - if (subMeshDS!=NULL) - { - SMDS_ElemIteratorPtr ite=subMeshDS->GetElements(); - while(ite->more()) - { - const SMDS_MeshElement * elt = ite->next(); - //MESSAGE( " RM elt: "<GetID()<<" ( "<NbNodes()<<" )" ); - meshDS->RemoveElement(elt); - } - - SMDS_NodeIteratorPtr itn=subMeshDS->GetNodes(); - while(itn->more()) - { - const SMDS_MeshNode * node = itn->next(); - meshDS->RemoveNode(node); + if ( SMESH_Gen::GetShapeDim( ancestor ) == dimToClean ) { + // PAL8021. do not go upper than SOLID, else ComputeStateEngine(CLEAN) + // will erase mesh on other shapes in a compound + if ( ancestor.ShapeType() >= TopAbs_SOLID ) { + SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor); + if (aSubMesh) + aSubMesh->ComputeStateEngine(CLEAN); + } } } } //============================================================================= /*! - * + * */ //============================================================================= void SMESH_subMesh::RemoveSubMeshElementsAndNodes() { - SCRUTE(_subShape.ShapeType()); + //SCRUTE(_subShape.ShapeType()); - removeSubMesh( _meshDS, _subShape ); + cleanSubMesh( this ); // algo may bind a submesh not to _subShape, eg 3D algo // sets nodes on SHELL while _subShape may be SOLID int dim = SMESH_Gen::GetShapeDim( _subShape ); int type = _subShape.ShapeType() + 1; - for ( ; type <= TopAbs_EDGE; type++) + for ( ; type <= TopAbs_EDGE; type++) { if ( dim == SMESH_Gen::GetShapeDim( (TopAbs_ShapeEnum) type )) { TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type ); for ( ; exp.More(); exp.Next() ) - removeSubMesh( _meshDS, exp.Current() ); + cleanSubMesh( _father->GetSubMeshContaining( exp.Current() )); } else break; + } } //======================================================================= @@ -1544,15 +1637,16 @@ TopoDS_Shape SMESH_subMesh::GetCollection(SMESH_Gen * theGen, SMESH_Algo* theAlg { MESSAGE("SMESH_subMesh::GetCollection"); ASSERT (!theAlgo->NeedDescretBoundary()); - + TopoDS_Shape mainShape = _father->GetMeshDS()->ShapeToMesh(); if ( mainShape.IsSame( _subShape )) return _subShape; + const bool ignoreAuxiliaryHyps = false; list aUsedHyp = - theAlgo->GetUsedHypothesis( *_father, _subShape ); // copy - + theAlgo->GetUsedHypothesis( *_father, _subShape, ignoreAuxiliaryHyps ); // copy + // put in a compound all shapes with the same hypothesis assigned // and a good ComputState @@ -1569,7 +1663,7 @@ TopoDS_Shape SMESH_subMesh::GetCollection(SMESH_Gen * theGen, SMESH_Algo* theAlg if (subMesh->GetComputeState() == READY_TO_COMPUTE && anAlgo == theAlgo && - anAlgo->GetUsedHypothesis( *_father, S ) == aUsedHyp) + anAlgo->GetUsedHypothesis( *_father, S, ignoreAuxiliaryHyps ) == aUsedHyp) { aBuilder.Add( aCompound, S ); } @@ -1579,49 +1673,38 @@ TopoDS_Shape SMESH_subMesh::GetCollection(SMESH_Gen * theGen, SMESH_Algo* theAlg } //======================================================================= -//function : GetNbAttached -//purpose : return nb of hypotheses attached to theShape. +//function : GetSimilarAttached +//purpose : return a hypothesis attached to theShape. // If theHyp is provided, similar but not same hypotheses -// are countered; else only applicable ones are countered -// depending on theAlgos flag +// is returned; else only applicable ones having theHypType +// is returned //======================================================================= -int SMESH_subMesh::GetNbAttached(const TopoDS_Shape& theShape, - const SMESH_Hypothesis * theHyp, - const bool theAlgos) +const SMESH_Hypothesis* SMESH_subMesh::GetSimilarAttached(const TopoDS_Shape& theShape, + const SMESH_Hypothesis * theHyp, + const int theHypType) { - int nb = 0; - - const list& aHypList = - _father->GetHypothesisList( theShape ); - list::const_iterator it = aHypList.begin(); - while (it!=aHypList.end()) - { - const SMESH_Hypothesis* hyp = static_cast< const SMESH_Hypothesis *>( *it ); - it++; - - if ( theHyp ) - { - // count similar - if (hyp != theHyp && - hyp->GetType() == theHyp->GetType() && - hyp->GetDim() == theHyp->GetDim()) - nb++; - } + SMESH_HypoFilter hypoKind; + hypoKind.Init( hypoKind.HasType( theHyp ? theHyp->GetType() : theHypType )); + if ( theHyp ) { + hypoKind.And ( hypoKind.HasDim( theHyp->GetDim() )); + hypoKind.AndNot( hypoKind.Is( theHyp )); + if ( theHyp->IsAuxiliary() ) + hypoKind.And( hypoKind.HasName( theHyp->GetName() )); else - { - bool isAlgo = ( hyp->GetType() > SMESHDS_Hypothesis::PARAM_ALGO ); - if ( theAlgos == isAlgo && IsApplicableHypotesis( hyp )) - nb++; - } + hypoKind.AndNot( hypoKind.IsAuxiliary()); + } + else { + hypoKind.And( hypoKind.IsApplicableTo( theShape )); } - return nb; + return _father->GetHypothesis( theShape, hypoKind, false ); } //======================================================================= //function : CheckConcurentHypothesis -//purpose : check if there are several applicable hypothesis on fathers +//purpose : check if there are several applicable hypothesis attached to +// ansestors //======================================================================= SMESH_Hypothesis::Hypothesis_Status @@ -1630,20 +1713,25 @@ SMESH_Hypothesis::Hypothesis_Status MESSAGE ("SMESH_subMesh::CheckConcurentHypothesis"); // is there local hypothesis on me? - if ( GetNbAttached( _subShape, 0, theHypType > SMESHDS_Hypothesis::PARAM_ALGO ) > 0 ) + if ( GetSimilarAttached( _subShape, 0, theHypType ) ) return SMESH_Hypothesis::HYP_OK; - + TopoDS_Shape aPrevWithHyp; + const SMESH_Hypothesis* aPrevHyp = 0; TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape )); for (; it.More(); it.Next()) { const TopoDS_Shape& ancestor = it.Value(); - if ( GetNbAttached( ancestor, 0, theHypType > SMESHDS_Hypothesis::PARAM_ALGO ) > 0 ) + const SMESH_Hypothesis* hyp = GetSimilarAttached( ancestor, 0, theHypType ); + if ( hyp ) { if ( aPrevWithHyp.IsNull() || aPrevWithHyp.IsSame( ancestor )) + { aPrevWithHyp = ancestor; - else if ( aPrevWithHyp.ShapeType() == ancestor.ShapeType() ) + aPrevHyp = hyp; + } + else if ( aPrevWithHyp.ShapeType() == ancestor.ShapeType() && aPrevHyp != hyp ) return SMESH_Hypothesis::HYP_CONCURENT; else return SMESH_Hypothesis::HYP_OK;