X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH%2FSMESH_subMesh.cxx;h=6413b8031826769596f8d8c2a5ac8f9ca9dd8853;hp=9e4bc28b1a9326260be7ba43b682aae725e84f0c;hb=31282d88869470e2076e06357535c486971a8248;hpb=d9ce7a48c18bb6cddc877a8a02ff8e0efda13748 diff --git a/src/SMESH/SMESH_subMesh.cxx b/src/SMESH/SMESH_subMesh.cxx index 9e4bc28b1..6413b8031 100644 --- a/src/SMESH/SMESH_subMesh.cxx +++ b/src/SMESH/SMESH_subMesh.cxx @@ -17,7 +17,7 @@ // 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 +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // // // @@ -32,6 +32,7 @@ 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" @@ -45,14 +46,16 @@ using namespace std; #include #include -#include - #ifdef _DEBUG_ #include #include #include +#include #endif +#include +#include + //============================================================================= /*! * default constructor: @@ -76,8 +79,8 @@ 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; } } @@ -89,8 +92,8 @@ SMESH_subMesh::SMESH_subMesh(int Id, SMESH_Mesh * father, SMESHDS_Mesh * meshDS, SMESH_subMesh::~SMESH_subMesh() { - MESSAGE("SMESH_subMesh::~SMESH_subMesh"); - // **** + MESSAGE("SMESH_subMesh::~SMESH_subMesh"); + // **** } //============================================================================= @@ -101,8 +104,8 @@ SMESH_subMesh::~SMESH_subMesh() int SMESH_subMesh::GetId() const { - //MESSAGE("SMESH_subMesh::GetId"); - return _Id; + //MESSAGE("SMESH_subMesh::GetId"); + return _Id; } //============================================================================= @@ -113,19 +116,16 @@ int SMESH_subMesh::GetId() const 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; } //============================================================================= @@ -150,7 +150,6 @@ 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; @@ -158,13 +157,10 @@ SMESH_subMesh *SMESH_subMesh::GetFirstToCompute() 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; } } @@ -190,17 +186,32 @@ bool SMESH_subMesh::SubMeshesComputed() //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(); - int type = ss.ShapeType(); - bool computeOk = (sm->GetComputeState() == COMPUTE_OK); + // 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(); + subMeshesComputed = false; switch (type) @@ -416,20 +427,12 @@ void SMESH_subMesh::InsertDependence(const TopoDS_Shape aSubShape) 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()) + 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; - } + const map < int, SMESH_subMesh * > & subMap = aSubMesh->DependsOn(); + _mapDepend.insert( subMap.begin(), subMap.end() ); } - } //============================================================================= @@ -438,7 +441,7 @@ void SMESH_subMesh::InsertDependence(const TopoDS_Shape aSubShape) */ //============================================================================= -const TopoDS_Shape & SMESH_subMesh::GetSubShape() +const TopoDS_Shape & SMESH_subMesh::GetSubShape() const { //MESSAGE("SMESH_subMesh::GetSubShape"); return _subShape; @@ -465,33 +468,28 @@ bool SMESH_subMesh::CanAddHypothesis(const SMESH_Hypothesis* theHypothesis) cons //======================================================================= //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; } @@ -508,11 +506,12 @@ SMESH_Hypothesis::Hypothesis_Status //SCRUTE(_algoState); //SCRUTE(event); - SMESH_Hypothesis::Hypothesis_Status aux_ret, ret = SMESH_Hypothesis::HYP_OK; - // **** 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 + + SMESH_Hypothesis::Hypothesis_Status aux_ret, ret = SMESH_Hypothesis::HYP_OK; + int dim = SMESH_Gen::GetShapeDim(_subShape); if (dim < 1) @@ -549,7 +548,7 @@ SMESH_Hypothesis::Hypothesis_Status if ( ! CanAddHypothesis( anHyp )) return SMESH_Hypothesis::HYP_BAD_DIM; - if ( GetSimilarAttached( _subShape, anHyp ) ) + if ( /*!anHyp->IsAuxiliary() &&*/ GetSimilarAttached( _subShape, anHyp ) ) return SMESH_Hypothesis::HYP_ALREADY_EXIST; if ( !_meshDS->AddHypothesis(_subShape, anHyp)) @@ -558,36 +557,41 @@ SMESH_Hypothesis::Hypothesis_Status // Serve Propagation of 1D hypothesis if (event == ADD_HYP) { bool isPropagationOk = true; - string hypName = anHyp->GetName(); - - if (hypName == "Propagation") { - if (_subShape.ShapeType() == TopAbs_EDGE) { - isPropagationOk = _father->BuildPropagationChain(_subShape); - } else { - 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; - } + 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 - if (_subShape.ShapeType() == TopAbs_EDGE) { - TopoDS_Shape aMainEdge; - if (_father->IsPropagatedHypothesis(_subShape, aMainEdge)) { - isPropagationOk = _father->RebuildPropagationChains(); - } else if (_father->IsPropagationHypothesis(_subShape)) { - isPropagationOk = _father->BuildPropagationChain(_subShape); - } else { + } + 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 && ret < SMESH_Hypothesis::HYP_CONCURENT) { + 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 @@ -602,49 +606,55 @@ SMESH_Hypothesis::Hypothesis_Status return SMESH_Hypothesis::HYP_OK; // nothing changes // Serve Propagation of 1D hypothesis - if (event == REMOVE_HYP) { + if (event == REMOVE_HYP) + { bool isPropagationOk = true; - string hypName = anHyp->GetName(); + SMESH_HypoFilter propagFilter( SMESH_HypoFilter::HasName( "Propagation" )); + bool isPropagationHyp = propagFilter.IsOk( anHyp, _subShape ); - if (hypName == "Propagation") { - if (_subShape.ShapeType() == TopAbs_EDGE) { - if (!_father->RemovePropagationChain(_subShape)) { - return SMESH_Hypothesis::HYP_UNKNOWN_FATAL; - } - // rebuild propagation chains, because removing one - // chain can resolve concurention, existing before - isPropagationOk = _father->RebuildPropagationChains(); - } else { - TopExp_Explorer exp (_subShape, TopAbs_EDGE); - TopTools_MapOfShape aMap; - for (; exp.More(); exp.Next()) { - if (aMap.Add(exp.Current())) { - if (!_father->RemovePropagationChain(exp.Current())) { - return SMESH_Hypothesis::HYP_UNKNOWN_FATAL; - } + 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 - if (!_father->RebuildPropagationChains()) { - isPropagationOk = false; - } - } - } else { // if (hypName == "Propagation") - if (anHyp->GetDim() == 1) // Only 1D hypothesis can be propagated - { - if (_subShape.ShapeType() == TopAbs_EDGE) { - isPropagationOk = _father->RebuildPropagationChains(); - if (!isPropagationOk && ret < SMESH_Hypothesis::HYP_CONCURENT) - ret = SMESH_Hypothesis::HYP_CONCURENT; - } } + // 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 && ret < SMESH_Hypothesis::HYP_CONCURENT) { + 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(); + } + } } // ------------------ @@ -719,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; @@ -805,20 +815,17 @@ 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); 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; } else { @@ -828,11 +835,19 @@ SMESH_Hypothesis::Hypothesis_Status } 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: { @@ -853,13 +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); - // check if same algo remains - if ( anHyp != algo && strcmp( anHyp->GetName(), algo->GetName()) ) - modifiedHyp = true; } break; } @@ -868,35 +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); - // is there the same local hyp or maybe a new father algo applied? - if ( !GetSimilarAttached( _subShape, anHyp ) ) - modifiedHyp = true; break; } case REMOVE_FATHER_ALGO: { @@ -907,13 +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); - // is there the same local algo or maybe a new father algo applied? - if ( !GetSimilarAttached( _subShape, anHyp )) - modifiedHyp = true; } break; } @@ -956,7 +978,7 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo) 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 @@ -979,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 } } @@ -995,9 +1017,7 @@ 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; } //============================================================================= @@ -1013,7 +1033,7 @@ SMESH_Hypothesis::Hypothesis_Status 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 ) + if (_subShape.ShapeType() < TopAbs_EDGE ) // wire,face etc { const map < int, SMESH_subMesh * >&subMeshes = DependsOn(); @@ -1038,19 +1058,15 @@ SMESH_Hypothesis::Hypothesis_Status 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); + } } //============================================================================= @@ -1105,6 +1121,37 @@ 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); + } + } + } +} + //============================================================================= /*! * @@ -1140,21 +1187,21 @@ 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; @@ -1178,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); @@ -1210,13 +1260,24 @@ bool SMESH_subMesh::ComputeStateEngine(int event) _computeState = FAILED_TO_COMPUTE; break; } - RemoveSubMeshElementsAndNodes(); // compute - if (!algo->NeedDescretBoundary() && !algo->OnlyUnaryInput()) - ret = ApplyToCollection( algo, GetCollection( gen, algo ) ); - else - ret = algo->Compute((*_father), _subShape); - + CleanDependants(); + RemoveSubMeshElementsAndNodes(); + { + try { +#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100 + OCC_CATCH_SIGNALS; +#endif + 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"); @@ -1226,9 +1287,11 @@ bool SMESH_subMesh::ComputeStateEngine(int event) #ifdef _DEBUG_ // Show vertices location of a failed shape - TopExp_Explorer exp( _subShape, TopAbs_VERTEX); - for ( ; exp.More(); exp.Next() ) { - gp_Pnt P( BRep_Tool::Pnt( TopoDS::Vertex( exp.Current() ))); + 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 @@ -1244,6 +1307,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event) } break; case CLEAN: + CleanDependants(); RemoveSubMeshElementsAndNodes(); _computeState = NOT_READY; algo = gen->GetAlgo((*_father), _subShape); @@ -1254,9 +1318,6 @@ 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: @@ -1283,20 +1344,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); @@ -1307,9 +1364,6 @@ 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: @@ -1354,15 +1408,13 @@ bool SMESH_subMesh::ComputeStateEngine(int event) 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; @@ -1498,46 +1550,20 @@ 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(); - //MESSAGE( " RM node: "<GetID()); - 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); + } } } } @@ -1552,22 +1578,23 @@ void SMESH_subMesh::RemoveSubMeshElementsAndNodes() { //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; + } } //======================================================================= @@ -1619,8 +1646,9 @@ TopoDS_Shape SMESH_subMesh::GetCollection(SMESH_Gen * theGen, SMESH_Algo* theAlg 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 @@ -1638,7 +1666,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 ); } @@ -1649,38 +1677,31 @@ TopoDS_Shape SMESH_subMesh::GetCollection(SMESH_Gen * theGen, SMESH_Algo* theAlg //======================================================================= //function : GetSimilarAttached -//purpose : return nb of hypotheses attached to theShape. +//purpose : return a hypothesis attached to theShape. // If theHyp is provided, similar but not same hypotheses -// are countered; else only applicable ones having theHypType -// are countered +// is returned; else only applicable ones having theHypType +// is returned //======================================================================= const SMESH_Hypothesis* SMESH_subMesh::GetSimilarAttached(const TopoDS_Shape& theShape, const SMESH_Hypothesis * theHyp, const int theHypType) { - const list& aHypList = - _father->GetHypothesisList( theShape ); - list::const_iterator it = aHypList.begin(); - for ( ; it != aHypList.end(); it++ ) - { - const SMESH_Hypothesis* hyp = static_cast< const SMESH_Hypothesis *>( *it ); - if ( theHyp ) - { - // find similar - if (hyp != theHyp && - hyp->GetType() == theHyp->GetType() && - hyp->GetDim() == theHyp->GetDim()) - return hyp; - } + 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 - { - if ( hyp->GetType() == theHypType && IsApplicableHypotesis( hyp )) - return hyp; - } + hypoKind.AndNot( hypoKind.IsAuxiliary()); + } + else { + hypoKind.And( hypoKind.IsApplicableTo( theShape )); } - return 0; + return _father->GetHypothesis( theShape, hypoKind, false ); } //=======================================================================