X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH%2FSMESH_subMesh.cxx;h=dd93a999fae7da7ed86e4e26c4c8bc17d0b50715;hb=1bc504bf901039d3cf41d8f1a65f1f955579cf34;hp=238bd22d92f547e07772855c49c8590e2de476ff;hpb=ed456586bfb1411c5bff73b221658766689a6253;p=modules%2Fsmesh.git diff --git a/src/SMESH/SMESH_subMesh.cxx b/src/SMESH/SMESH_subMesh.cxx index 238bd22d9..dd93a999f 100644 --- a/src/SMESH/SMESH_subMesh.cxx +++ b/src/SMESH/SMESH_subMesh.cxx @@ -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" @@ -465,34 +466,31 @@ 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: - case TopAbs_SHELL: - case TopAbs_SOLID: { - int aHypDim = theHypothesis->GetDim(); - int aShapeDim = SMESH_Gen::GetShapeDim(_subShape); - return ( aHypDim == aShapeDim ); - } + int aShapeDim = 100; + switch ( theShapeType ) { + case TopAbs_EDGE: aShapeDim = 1; break; + case TopAbs_FACE: aShapeDim = 2; break; + case TopAbs_SHELL:aShapeDim = 3; break; + case TopAbs_SOLID:aShapeDim = 3; break; // case TopAbs_VERTEX: // case TopAbs_WIRE: // case TopAbs_COMPSOLID: // case TopAbs_COMPOUND: - default:; + default: return false; } - return false; + return ( theHypothesis->GetDim() == aShapeDim ); } //============================================================================= @@ -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) @@ -561,27 +560,28 @@ SMESH_Hypothesis::Hypothesis_Status 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; - } + 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 { @@ -602,43 +602,30 @@ 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(); - - 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; - } + SMESH_HypoFilter propagFilter( SMESH_HypoFilter::HasName( "Propagation" )); + if ( propagFilter.IsOk( anHyp, _subShape )) + { + 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) { @@ -805,20 +792,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 )) + 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 +812,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 +845,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,7 +860,6 @@ SMESH_Hypothesis::Hypothesis_Status ASSERT(algo); if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { - SetAlgoState(HYP_OK); if (_father->IsUsedHypothesis( anHyp, _subShape )) // new Hyp modifiedHyp = true; } @@ -876,27 +867,35 @@ SMESH_Hypothesis::Hypothesis_Status 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 +906,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 +955,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 +978,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 } } @@ -1048,7 +1047,7 @@ void SMESH_subMesh::CleanDependsOn() for (its = dependson.begin(); its != dependson.end(); its++) { SMESH_subMesh *sm = (*its).second; - SCRUTE((*its).first); + //SCRUTE((*its).first); sm->ComputeStateEngine(CLEAN); } } @@ -1498,21 +1497,21 @@ void SMESH_subMesh::UpdateDependantsState(const compute_event theEvent) void SMESH_subMesh::CleanDependants() { - //MESSAGE("SMESH_subMesh::CleanDependants: shape type " << _subShape.ShapeType() ); - 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); + // PAL8021. do not go upper than SOLID, else ComputeStateEngine(CLEANDEP) + // will erase mesh on other shapes in a compound + if ( ancestor.ShapeType() >= TopAbs_SOLID ) { + SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor); + if (aSubMesh) + aSubMesh->ComputeStateEngine(CLEANDEP); + } } ComputeStateEngine(CLEAN); } - //============================================================================= /*! * @@ -1550,7 +1549,7 @@ static void removeSubMesh( SMESHDS_Mesh * meshDS, const TopoDS_Shape& subShape) void SMESH_subMesh::RemoveSubMeshElementsAndNodes() { - SCRUTE(_subShape.ShapeType()); + //SCRUTE(_subShape.ShapeType()); removeSubMesh( _meshDS, _subShape ); @@ -1659,28 +1658,16 @@ const SMESH_Hypothesis* SMESH_subMesh::GetSimilarAttached(const TopoDS_Shape& 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; - } - else - { - if ( hyp->GetType() == theHypType && IsApplicableHypotesis( hyp )) - return hyp; - } + SMESH_HypoFilter filter; + filter.Init( SMESH_HypoFilter::HasType( theHyp ? theHyp->GetType() : theHypType )); + if ( theHyp ) { + filter.And( SMESH_HypoFilter::HasDim( theHyp->GetDim() )); + filter.AndNot( SMESH_HypoFilter::Is( theHyp )); } + else + filter.And( SMESH_HypoFilter::IsApplicableTo( theShape )); - return 0; + return _father->GetHypothesis( theShape, filter, false ); } //=======================================================================