X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH%2FSMESH_subMesh.cxx;h=7485f18fb71446d16ce476309a1f2a7013e0b33f;hb=d5a3c3b28a0fb00764647c068791f585bf6f1b37;hp=73bd794f52a9ed8944e0ae67de0653fd22ce4fda;hpb=493747e8ea338a2d88204a5f12ba924d72ecbb5b;p=modules%2Fsmesh.git diff --git a/src/SMESH/SMESH_subMesh.cxx b/src/SMESH/SMESH_subMesh.cxx index 73bd794f5..7485f18fb 100644 --- a/src/SMESH/SMESH_subMesh.cxx +++ b/src/SMESH/SMESH_subMesh.cxx @@ -115,7 +115,7 @@ SMESH_subMesh::~SMESH_subMesh() { MESSAGE("SMESH_subMesh::~SMESH_subMesh"); // **** - DeleteOwnListeners(); + deleteOwnListeners(); } //============================================================================= @@ -187,7 +187,7 @@ SMESH_Algo* SMESH_subMesh::GetAlgo() const //================================================================================ /*! - * \brief Allow algo->Compute() if a subshape of lower dim is meshed but + * \brief Allow algo->Compute() if a sub-shape of lower dim is meshed but * none mesh entity is bound to it (PAL13615, 2nd part) */ //================================================================================ @@ -256,7 +256,7 @@ bool SMESH_subMesh::IsMeshComputed() const */ //============================================================================= -bool SMESH_subMesh::SubMeshesComputed() +bool SMESH_subMesh::subMeshesComputed() { int myDim = SMESH_Gen::GetShapeDim( _subShape ); int dimToCheck = myDim - 1; @@ -340,23 +340,23 @@ bool SMESH_subMesh::SubMeshesComputed() */ //============================================================================= -bool SMESH_subMesh::SubMeshesReady() -{ - bool subMeshesReady = true; - SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true); - while ( smIt->more() ) { - SMESH_subMesh *sm = smIt->next(); - bool computeOk = (sm->GetComputeState() == COMPUTE_OK || - sm->GetComputeState() == READY_TO_COMPUTE); - if (!computeOk) - { - subMeshesReady = false; - SCRUTE(sm->GetId()); - break; - } - } - return subMeshesReady; -} +// bool SMESH_subMesh::SubMeshesReady() +// { +// bool subMeshesReady = true; +// SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true); +// while ( smIt->more() ) { +// SMESH_subMesh *sm = smIt->next(); +// bool computeOk = (sm->GetComputeState() == COMPUTE_OK || +// sm->GetComputeState() == READY_TO_COMPUTE); +// if (!computeOk) +// { +// subMeshesReady = false; +// SCRUTE(sm->GetId()); +// break; +// } +// } +// return subMeshesReady; +// } //============================================================================= /*! @@ -386,24 +386,24 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn() //MESSAGE("compound"); for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More();exp.Next()) { - InsertDependence(exp.Current()); + insertDependence(exp.Current()); } for (TopExp_Explorer exp(_subShape, TopAbs_SHELL, TopAbs_SOLID); exp.More(); exp.Next()) { if ( BRep_Tool::IsClosed(exp.Current() )) - InsertDependence(exp.Current()); //only shell not in solid + insertDependence(exp.Current()); //only shell not in solid else for (TopExp_Explorer expF(exp.Current(), TopAbs_FACE); expF.More();expF.Next()) - InsertDependence(expF.Current()); // issue 0020959: HEXA_3D fails on shell + insertDependence(expF.Current()); // issue 0020959: HEXA_3D fails on shell } for (TopExp_Explorer exp(_subShape, TopAbs_FACE, TopAbs_SHELL); exp.More();exp.Next()) { - InsertDependence(exp.Current()); + insertDependence(exp.Current()); } for (TopExp_Explorer exp(_subShape, TopAbs_EDGE, TopAbs_FACE); exp.More();exp.Next()) { - InsertDependence(exp.Current()); + insertDependence(exp.Current()); } break; } @@ -412,7 +412,7 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn() //MESSAGE("compsolid"); for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More(); exp.Next()) { - InsertDependence(exp.Current()); + insertDependence(exp.Current()); } break; } @@ -421,7 +421,7 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn() //MESSAGE("shell"); for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More(); exp.Next()) { - InsertDependence(exp.Current()); + insertDependence(exp.Current()); } break; } @@ -430,7 +430,7 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn() //MESSAGE("wire"); for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More(); exp.Next()) { - InsertDependence(exp.Current()); + insertDependence(exp.Current()); } break; } @@ -440,7 +440,7 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn() if(_father->HasShapeToMesh()) { for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More();exp.Next()) { - InsertDependence(exp.Current()); + insertDependence(exp.Current()); } } break; @@ -450,7 +450,7 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn() //MESSAGE("face"); for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More();exp.Next()) { - InsertDependence(exp.Current()); + insertDependence(exp.Current()); } break; } @@ -459,7 +459,7 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn() //MESSAGE("edge"); for (TopExp_Explorer exp(_subShape, TopAbs_VERTEX); exp.More(); exp.Next()) { - InsertDependence(exp.Current()); + insertDependence(exp.Current()); } break; } @@ -482,9 +482,8 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn() */ //============================================================================= -void SMESH_subMesh::InsertDependence(const TopoDS_Shape aSubShape) +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 @@ -651,7 +650,7 @@ SMESH_Hypothesis::Hypothesis_Status filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+1 )); filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+2 )); if ( SMESH_Algo * curAlgo = (SMESH_Algo*) _father->GetHypothesis( _subShape, filter, true )) - needFullClean = ( !curAlgo->NeedDescretBoundary() ); + needFullClean = ( !curAlgo->NeedDiscreteBoundary() ); } } @@ -663,7 +662,7 @@ SMESH_Hypothesis::Hypothesis_Status if ( ! CanAddHypothesis( anHyp )) // check dimension return SMESH_Hypothesis::HYP_BAD_DIM; - if ( /*!anHyp->IsAuxiliary() &&*/ GetSimilarAttached( _subShape, anHyp ) ) + if ( /*!anHyp->IsAuxiliary() &&*/ getSimilarAttached( _subShape, anHyp ) ) return SMESH_Hypothesis::HYP_ALREADY_EXIST; if ( !meshDS->AddHypothesis(_subShape, anHyp)) @@ -681,7 +680,7 @@ SMESH_Hypothesis::Hypothesis_Status if (event == REMOVE_ALGO) { algo = dynamic_cast (anHyp); - if (!algo->NeedDescretBoundary()) + if (!algo->NeedDiscreteBoundary()) { // clean all mesh in the tree of the current submesh; // we must perform it now because later @@ -710,13 +709,13 @@ SMESH_Hypothesis::Hypothesis_Status algo = GetAlgo(); ASSERT(algo); if (algo->CheckHypothesis((*_father),_subShape, aux_ret)) - SetAlgoState(HYP_OK); + setAlgoState(HYP_OK); else if ( algo->IsStatusFatal( aux_ret )) { meshDS->RemoveHypothesis(_subShape, anHyp); ret = aux_ret; } else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); break; } case REMOVE_HYP: @@ -728,9 +727,9 @@ SMESH_Hypothesis::Hypothesis_Status ASSERT(algo); if ( algo == anHyp ) { if ( algo->CheckHypothesis((*_father),_subShape, aux_ret)) - SetAlgoState(HYP_OK); + setAlgoState(HYP_OK); else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); } break; } @@ -741,9 +740,9 @@ SMESH_Hypothesis::Hypothesis_Status if (algo) { if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + setAlgoState(HYP_OK); else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); } break; } @@ -763,7 +762,7 @@ SMESH_Hypothesis::Hypothesis_Status algo = GetAlgo(); ASSERT(algo); if ( algo->CheckHypothesis((*_father),_subShape, ret )) - SetAlgoState(HYP_OK); + setAlgoState(HYP_OK); if (SMESH_Hypothesis::IsStatusFatal( ret )) meshDS->RemoveHypothesis(_subShape, anHyp); else if (!_father->IsUsedHypothesis( anHyp, this )) @@ -777,29 +776,29 @@ SMESH_Hypothesis::Hypothesis_Status algo = GetAlgo(); ASSERT(algo); if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))// ignore hyp status - SetAlgoState(HYP_OK); + setAlgoState(HYP_OK); else if ( algo->IsStatusFatal( aux_ret )) { meshDS->RemoveHypothesis(_subShape, anHyp); ret = aux_ret; } else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); break; } case REMOVE_HYP: break; case REMOVE_ALGO: { // perhaps a father algo applies ? algo = GetAlgo(); - if (algo == NULL) // no more algo applying on subShape... + if (algo == NULL) // no more algo applying on sub-shape... { - SetAlgoState(NO_ALGO); + setAlgoState(NO_ALGO); } else { if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + setAlgoState(HYP_OK); else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); } break; } @@ -808,9 +807,9 @@ SMESH_Hypothesis::Hypothesis_Status algo = GetAlgo(); ASSERT(algo); if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + setAlgoState(HYP_OK); else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); break; } case ADD_FATHER_ALGO: { // new father algo @@ -818,9 +817,9 @@ SMESH_Hypothesis::Hypothesis_Status ASSERT( algo ); if ( algo == anHyp ) { if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + setAlgoState(HYP_OK); else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); } break; } @@ -830,14 +829,14 @@ SMESH_Hypothesis::Hypothesis_Status algo = GetAlgo(); if (algo == NULL) // no more applying algo on father { - SetAlgoState(NO_ALGO); + setAlgoState(NO_ALGO); } else { if ( algo->CheckHypothesis((*_father),_subShape , aux_ret )) - SetAlgoState(HYP_OK); + setAlgoState(HYP_OK); else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); } break; } @@ -889,24 +888,24 @@ SMESH_Hypothesis::Hypothesis_Status modifiedHyp = true; } else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); break; } case REMOVE_HYP: { algo = GetAlgo(); ASSERT(algo); if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + setAlgoState(HYP_OK); else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); modifiedHyp = true; break; } case REMOVE_ALGO: { // perhaps a father algo applies ? algo = GetAlgo(); - if (algo == NULL) // no more algo applying on subShape... + if (algo == NULL) // no more algo applying on sub-shape... { - SetAlgoState(NO_ALGO); + setAlgoState(NO_ALGO); } else { @@ -916,7 +915,7 @@ SMESH_Hypothesis::Hypothesis_Status modifiedHyp = true; } else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); } break; } @@ -930,7 +929,7 @@ SMESH_Hypothesis::Hypothesis_Status modifiedHyp = true; } else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); break; } case ADD_FATHER_ALGO: { @@ -948,7 +947,7 @@ SMESH_Hypothesis::Hypothesis_Status modifiedHyp = true; } else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); } break; } @@ -957,24 +956,24 @@ SMESH_Hypothesis::Hypothesis_Status ASSERT(algo); if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { // is there the same local hyp or maybe a new father algo applied? - if ( !GetSimilarAttached( _subShape, anHyp ) ) + if ( !getSimilarAttached( _subShape, anHyp ) ) modifiedHyp = true; } else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); break; } case REMOVE_FATHER_ALGO: { // IPAL21346. Edges not removed when Netgen 1d-2d is removed from a SOLID. // CLEAN was not called at event REMOVE_ALGO because the algo is not applicable to SOLID. algo = dynamic_cast (anHyp); - if (!algo->NeedDescretBoundary()) + if (!algo->NeedDiscreteBoundary()) needFullClean = true; algo = GetAlgo(); if (algo == NULL) // no more applying algo on father { - SetAlgoState(NO_ALGO); + setAlgoState(NO_ALGO); } else { @@ -984,7 +983,7 @@ SMESH_Hypothesis::Hypothesis_Status modifiedHyp = true; } else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); } break; } @@ -1012,12 +1011,12 @@ SMESH_Hypothesis::Hypothesis_Status TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape )); for ( ; ( ret == SMESH_Hypothesis::HYP_OK && it.More()); it.Next() ) { if ( SMESH_Algo* upperAlgo = gen->GetAlgo( *_father, it.Value() )) - if ( !upperAlgo->NeedDescretBoundary() && !upperAlgo->SupportSubmeshes()) + if ( !upperAlgo->NeedDiscreteBoundary() && !upperAlgo->SupportSubmeshes()) ret = SMESH_Hypothesis::HYP_HIDDEN_ALGO; } // is algo hiding? if ( ret == SMESH_Hypothesis::HYP_OK && - !algo->NeedDescretBoundary() && + !algo->NeedDiscreteBoundary() && !algo->SupportSubmeshes()) { TopoDS_Shape algoAssignedTo, otherAssignedTo; gen->GetAlgo( *_father, _subShape, &algoAssignedTo ); @@ -1034,10 +1033,10 @@ SMESH_Hypothesis::Hypothesis_Status if ( stateChange && _algoState == HYP_OK ) // hyp becomes OK algo->SetEventListener( this ); - NotifyListenersOnEvent( event, ALGO_EVENT, anHyp ); + notifyListenersOnEvent( event, ALGO_EVENT, anHyp ); if ( stateChange && oldAlgoState == HYP_OK ) { // hyp becomes KO - DeleteOwnListeners(); + deleteOwnListeners(); SetIsAlwaysComputed( false ); if (_subShape.ShapeType() == TopAbs_VERTEX ) { // restore default states @@ -1049,7 +1048,7 @@ SMESH_Hypothesis::Hypothesis_Status if ( needFullClean ) { // added or removed algo is all-dimensional ComputeStateEngine( CLEAN ); - CleanDependsOn(); + cleanDependsOn(); ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE ); } @@ -1072,9 +1071,9 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo) // Suppose that theAlgo is applicable to _subShape, do not check it here //if ( !IsApplicableHypotesis( theAlgo )) return false; - // check only algo that doesn't NeedDescretBoundary(): because mesh made + // check only algo that doesn't NeedDiscreteBoundary(): because mesh made // on a sub-shape will be ignored by theAlgo - if ( theAlgo->NeedDescretBoundary() || + if ( theAlgo->NeedDiscreteBoundary() || !theAlgo->OnlyUnaryInput() ) // all adjacent shapes will be meshed by this algo? return true; @@ -1103,7 +1102,7 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo) // check algo attached to smAdjacent SMESH_Algo * algo = gen->GetAlgo((*_father), adjacent); if (algo && - !algo->NeedDescretBoundary() && + !algo->NeedDiscreteBoundary() && algo->OnlyUnaryInput()) return false; // NOT CONFORM MESH WILL BE PRODUCED } @@ -1118,7 +1117,7 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo) */ //============================================================================= -void SMESH_subMesh::SetAlgoState(int state) +void SMESH_subMesh::setAlgoState(int state) { _algoState = state; } @@ -1154,7 +1153,7 @@ SMESH_Hypothesis::Hypothesis_Status */ //============================================================================= -void SMESH_subMesh::CleanDependsOn() +void SMESH_subMesh::cleanDependsOn() { SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false); while ( smIt->more() ) @@ -1266,7 +1265,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event) SMESHDS_SubMesh* smDS = GetSubMeshDS(); if ( smDS && smDS->NbNodes() ) { if ( event == CLEAN ) { - CleanDependants(); + cleanDependants(); cleanSubMesh( this ); } else @@ -1281,7 +1280,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event) } } if ( event == MODIF_ALGO_STATE ) - CleanDependants(); + cleanDependants(); return true; } SMESH_Gen *gen = _father->GetGen(); @@ -1300,8 +1299,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event) { case MODIF_ALGO_STATE: algo = GetAlgo(); - if (algo && !algo->NeedDescretBoundary()) - CleanDependsOn(); // clean sub-meshes with event CLEAN + if (algo && !algo->NeedDiscreteBoundary()) + cleanDependsOn(); // clean sub-meshes with event CLEAN if ( _algoState == HYP_OK ) _computeState = READY_TO_COMPUTE; break; @@ -1312,8 +1311,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event) break; #endif case CLEAN: - CleanDependants(); - RemoveSubMeshElementsAndNodes(); + cleanDependants(); + removeSubMeshElementsAndNodes(); break; case SUBMESH_COMPUTED: // nothing to do break; @@ -1322,6 +1321,10 @@ bool SMESH_subMesh::ComputeStateEngine(int event) break; case MESH_ENTITY_REMOVED: break; + case SUBMESH_LOADED: + loadDependentMeshes(); + ComputeSubMeshStateEngine( SUBMESH_LOADED ); + //break; case CHECK_COMPUTE_STATE: if ( IsMeshComputed() ) _computeState = COMPUTE_OK; @@ -1342,8 +1345,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event) algo = GetAlgo(); if (algo) { - if (!algo->NeedDescretBoundary()) - CleanDependsOn(); // clean sub-meshes with event CLEAN + if (!algo->NeedDiscreteBoundary()) + cleanDependsOn(); // clean sub-meshes with event CLEAN if ( _algoState == HYP_OK ) _computeState = READY_TO_COMPUTE; } @@ -1357,7 +1360,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event) { MESSAGE("***** verify compute state *****"); _computeState = NOT_READY; - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); break; } TopoDS_Shape shape = _subShape; @@ -1365,15 +1368,15 @@ bool SMESH_subMesh::ComputeStateEngine(int event) if (_father->HasShapeToMesh() ) { bool subComputed = false; if (!algo->OnlyUnaryInput()) - shape = GetCollection( gen, algo, subComputed ); + shape = getCollection( gen, algo, subComputed ); else - subComputed = SubMeshesComputed(); - ret = ( algo->NeedDescretBoundary() ? subComputed : + subComputed = subMeshesComputed(); + ret = ( algo->NeedDiscreteBoundary() ? subComputed : algo->SupportSubmeshes() ? true : ( !subComputed || _father->IsNotConformAllowed() )); if (!ret) { _computeState = FAILED_TO_COMPUTE; - if ( !algo->NeedDescretBoundary() ) + if ( !algo->NeedDiscreteBoundary() ) _computeError = SMESH_ComputeError::New(COMPERR_BAD_INPUT_MESH, "Unexpected computed submesh",algo); @@ -1381,8 +1384,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event) } } // compute -// CleanDependants(); for "UseExisting_*D" algos -// RemoveSubMeshElementsAndNodes(); +// cleanDependants(); for "UseExisting_*D" algos +// removeSubMeshElementsAndNodes(); ret = false; _computeState = FAILED_TO_COMPUTE; _computeError = SMESH_ComputeError::New(COMPERR_OK,"",algo); @@ -1462,7 +1465,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event) for (; ret && subS.More(); subS.Next()) ret = _father->GetSubMesh( subS.Current() )->IsMeshComputed(); } - bool isComputeErrorSet = !CheckComputeError( algo, shape ); + bool isComputeErrorSet = !checkComputeError( algo, shape ); if (!ret && !isComputeErrorSet) { // Set _computeError @@ -1484,7 +1487,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event) { _computeError.reset(); } - UpdateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED + updateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED } break; #ifdef WITH_SMESH_CANCEL_COMPUTE @@ -1492,8 +1495,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event) break; #endif case CLEAN: - CleanDependants(); - RemoveSubMeshElementsAndNodes(); + cleanDependants(); + removeSubMeshElementsAndNodes(); _computeState = NOT_READY; algo = GetAlgo(); if (algo) @@ -1502,7 +1505,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event) if (ret) _computeState = READY_TO_COMPUTE; else - SetAlgoState(MISSING_HYP); + setAlgoState(MISSING_HYP); } break; case SUBMESH_COMPUTED: // nothing to do @@ -1517,6 +1520,10 @@ bool SMESH_subMesh::ComputeStateEngine(int event) break; case MESH_ENTITY_REMOVED: break; + case SUBMESH_LOADED: + loadDependentMeshes(); + ComputeSubMeshStateEngine( SUBMESH_LOADED ); + //break; case CHECK_COMPUTE_STATE: if ( IsMeshComputed() ) _computeState = COMPUTE_OK; @@ -1535,8 +1542,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event) case MODIF_ALGO_STATE: ComputeStateEngine( CLEAN ); algo = GetAlgo(); - if (algo && !algo->NeedDescretBoundary()) - CleanDependsOn(); // clean sub-meshes with event CLEAN + if (algo && !algo->NeedDiscreteBoundary()) + cleanDependsOn(); // clean sub-meshes with event CLEAN break; case COMPUTE: // nothing to do break; @@ -1545,8 +1552,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event) break; #endif case CLEAN: - CleanDependants(); // clean sub-meshes, dependant on this one, with event CLEAN - RemoveSubMeshElementsAndNodes(); + cleanDependants(); // clean sub-meshes, dependant on this one, with event CLEAN + removeSubMeshElementsAndNodes(); _computeState = NOT_READY; if ( _algoState == HYP_OK ) _computeState = READY_TO_COMPUTE; @@ -1560,8 +1567,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event) if (algo) algo->SubmeshRestored( this ); break; case MESH_ENTITY_REMOVED: - UpdateDependantsState( CHECK_COMPUTE_STATE ); - ComputeStateEngine( CHECK_COMPUTE_STATE ); + updateDependantsState ( CHECK_COMPUTE_STATE ); + ComputeStateEngine ( CHECK_COMPUTE_STATE ); ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE ); break; case CHECK_COMPUTE_STATE: @@ -1572,6 +1579,9 @@ bool SMESH_subMesh::ComputeStateEngine(int event) _computeState = NOT_READY; } break; + case SUBMESH_LOADED: + // already treated event, thanks to which _computeState == COMPUTE_OK + break; default: ASSERT(0); break; @@ -1587,8 +1597,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event) if ( !IsEmpty() ) ComputeStateEngine( CLEAN ); algo = GetAlgo(); - if (algo && !algo->NeedDescretBoundary()) - CleanDependsOn(); // clean sub-meshes with event CLEAN + if (algo && !algo->NeedDiscreteBoundary()) + cleanDependsOn(); // clean sub-meshes with event CLEAN if (_algoState == HYP_OK) _computeState = READY_TO_COMPUTE; else @@ -1605,8 +1615,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event) break; #endif case CLEAN: - CleanDependants(); // submeshes dependent on me should be cleaned as well - RemoveSubMeshElementsAndNodes(); + cleanDependants(); // submeshes dependent on me should be cleaned as well + removeSubMeshElementsAndNodes(); break; case SUBMESH_COMPUTED: // allow retry compute if (_algoState == HYP_OK) @@ -1640,7 +1650,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event) break; } - NotifyListenersOnEvent( event, COMPUTE_EVENT ); + notifyListenersOnEvent( event, COMPUTE_EVENT ); return ret; } @@ -1675,7 +1685,7 @@ bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap) ret = algo->CheckHypothesis((*_father), _subShape, hyp_status); if (!ret) return false; - if (_father->HasShapeToMesh() && algo->NeedDescretBoundary()) + if (_father->HasShapeToMesh() && algo->NeedDiscreteBoundary()) { // check submeshes needed bool subMeshEvaluated = true; @@ -1710,18 +1720,18 @@ bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap) */ //======================================================================= -bool SMESH_subMesh::CheckComputeError(SMESH_Algo* theAlgo, const TopoDS_Shape& theShape) +bool SMESH_subMesh::checkComputeError(SMESH_Algo* theAlgo, const TopoDS_Shape& theShape) { bool noErrors = true; if ( !theShape.IsNull() ) { // Check state of submeshes - if ( !theAlgo->NeedDescretBoundary()) + if ( !theAlgo->NeedDiscreteBoundary()) { SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false); while ( smIt->more() ) - if ( !smIt->next()->CheckComputeError( theAlgo )) + if ( !smIt->next()->checkComputeError( theAlgo )) noErrors = false; } @@ -1733,9 +1743,9 @@ bool SMESH_subMesh::CheckComputeError(SMESH_Algo* theAlgo, const TopoDS_Shape& t for (TopoDS_Iterator subIt( theShape ); subIt.More(); subIt.Next()) { SMESH_subMesh* sm = _father->GetSubMesh( subIt.Value() ); if ( sm != this ) { - if ( !sm->CheckComputeError( theAlgo, sm->GetSubShape() )) + if ( !sm->checkComputeError( theAlgo, sm->GetSubShape() )) noErrors = false; - UpdateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED + updateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED } } } @@ -1754,7 +1764,7 @@ bool SMESH_subMesh::CheckComputeError(SMESH_Algo* theAlgo, const TopoDS_Shape& t // Show error SMESH_Comment text; - text << theAlgo->GetName() << " failed on subshape #" << _Id << " with error "; + text << theAlgo->GetName() << " failed on sub-shape #" << _Id << " with error "; if (_computeError->IsCommon() ) text << _computeError->CommonName(); else @@ -1773,11 +1783,11 @@ bool SMESH_subMesh::CheckComputeError(SMESH_Algo* theAlgo, const TopoDS_Shape& t } //======================================================================= -//function : UpdateSubMeshState +//function : updateSubMeshState //purpose : //======================================================================= -void SMESH_subMesh::UpdateSubMeshState(const compute_state theState) +void SMESH_subMesh::updateSubMeshState(const compute_state theState) { SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false); while ( smIt->more() ) @@ -1797,13 +1807,12 @@ void SMESH_subMesh::ComputeSubMeshStateEngine(int event) } //======================================================================= -//function : UpdateDependantsState +//function : updateDependantsState //purpose : //======================================================================= -void SMESH_subMesh::UpdateDependantsState(const compute_event theEvent) +void SMESH_subMesh::updateDependantsState(const compute_event theEvent) { - //MESSAGE("SMESH_subMesh::UpdateDependantsState"); TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape )); for (; it.More(); it.Next()) { @@ -1821,7 +1830,7 @@ void SMESH_subMesh::UpdateDependantsState(const compute_event theEvent) */ //============================================================================= -void SMESH_subMesh::CleanDependants() +void SMESH_subMesh::cleanDependants() { int dimToClean = SMESH_Gen::GetShapeDim( _subShape ) + 1; @@ -1848,10 +1857,8 @@ void SMESH_subMesh::CleanDependants() */ //============================================================================= -void SMESH_subMesh::RemoveSubMeshElementsAndNodes() +void SMESH_subMesh::removeSubMeshElementsAndNodes() { - //SCRUTE(_subShape.ShapeType()); - cleanSubMesh( this ); // algo may bind a submesh not to _subShape, eg 3D algo @@ -1872,18 +1879,16 @@ void SMESH_subMesh::RemoveSubMeshElementsAndNodes() } //======================================================================= -//function : GetCollection +//function : getCollection //purpose : return a shape containing all sub-shapes of the MainShape that can be // meshed at once along with _subShape //======================================================================= -TopoDS_Shape SMESH_subMesh::GetCollection(SMESH_Gen * theGen, +TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen, SMESH_Algo* theAlgo, bool & theSubComputed) { - MESSAGE("SMESH_subMesh::GetCollection"); - - theSubComputed = SubMeshesComputed(); + theSubComputed = subMeshesComputed(); TopoDS_Shape mainShape = _father->GetMeshDS()->ShapeToMesh(); @@ -1916,7 +1921,7 @@ TopoDS_Shape SMESH_subMesh::GetCollection(SMESH_Gen * theGen, if (strcmp( anAlgo->GetName(), theAlgo->GetName()) == 0 && // same algo anAlgo->GetUsedHypothesis( *_father, S, ignoreAuxiliaryHyps ) == aUsedHyp) // same hyps aBuilder.Add( aCompound, S ); - if ( !subMesh->SubMeshesComputed() ) + if ( !subMesh->subMeshesComputed() ) theSubComputed = false; } } @@ -1925,14 +1930,14 @@ TopoDS_Shape SMESH_subMesh::GetCollection(SMESH_Gen * theGen, } //======================================================================= -//function : GetSimilarAttached +//function : getSimilarAttached //purpose : return a hypothesis attached to theShape. // If theHyp is provided, similar but not same hypotheses // is returned; else only applicable ones having theHypType // is returned //======================================================================= -const SMESH_Hypothesis* SMESH_subMesh::GetSimilarAttached(const TopoDS_Shape& theShape, +const SMESH_Hypothesis* SMESH_subMesh::getSimilarAttached(const TopoDS_Shape& theShape, const SMESH_Hypothesis * theHyp, const int theHypType) { @@ -1965,7 +1970,7 @@ SMESH_Hypothesis::Hypothesis_Status MESSAGE ("SMESH_subMesh::CheckConcurentHypothesis"); // is there local hypothesis on me? - if ( GetSimilarAttached( _subShape, 0, theHypType ) ) + if ( getSimilarAttached( _subShape, 0, theHypType ) ) return SMESH_Hypothesis::HYP_OK; @@ -1975,7 +1980,7 @@ SMESH_Hypothesis::Hypothesis_Status for (; it.More(); it.Next()) { const TopoDS_Shape& ancestor = it.Value(); - const SMESH_Hypothesis* hyp = GetSimilarAttached( ancestor, 0, theHypType ); + const SMESH_Hypothesis* hyp = getSimilarAttached( ancestor, 0, theHypType ); if ( hyp ) { if ( aPrevWithHyp.IsNull() || aPrevWithHyp.IsSame( ancestor )) @@ -1992,14 +1997,26 @@ SMESH_Hypothesis::Hypothesis_Status return SMESH_Hypothesis::HYP_OK; } +//================================================================================ +/*! + * \brief Constructor of OwnListenerData + */ +//================================================================================ + +SMESH_subMesh::OwnListenerData::OwnListenerData( SMESH_subMesh* sm, EventListener* el): + mySubMesh( sm ), + myMeshID( sm ? sm->GetFather()->GetId() : -1 ), + mySubMeshID( sm ? sm->GetId() : -1 ), + myListener( el ) +{ +} + //================================================================================ /*! * \brief Sets an event listener and its data to a submesh * \param listener - the listener to store * \param data - the listener data to store * \param where - the submesh to store the listener and it's data - * \param deleteListener - if true then the listener will be deleted as - * it is removed from where submesh * * It remembers the submesh where it puts the listener in order to delete * them when HYP_OK algo_state is lost @@ -2012,8 +2029,8 @@ void SMESH_subMesh::SetEventListener(EventListener* listener, SMESH_subMesh* where) { if ( listener && where ) { - where->SetEventListener( listener, data ); - myOwnListeners.push_back( make_pair( where, listener )); + where->setEventListener( listener, data ); + _ownListeners.push_back( OwnListenerData( where, listener )); } } @@ -2027,18 +2044,18 @@ void SMESH_subMesh::SetEventListener(EventListener* listener, */ //================================================================================ -void SMESH_subMesh::SetEventListener(EventListener* listener, EventListenerData* data) +void SMESH_subMesh::setEventListener(EventListener* listener, EventListenerData* data) { map< EventListener*, EventListenerData* >::iterator l_d = - myEventListeners.find( listener ); - if ( l_d != myEventListeners.end() ) { + _eventListeners.find( listener ); + if ( l_d != _eventListeners.end() ) { EventListenerData* curData = l_d->second; if ( curData && curData != data && curData->IsDeletable() ) delete curData; l_d->second = data; } else - myEventListeners.insert( make_pair( listener, data )); + _eventListeners.insert( make_pair( listener, data )); } //================================================================================ @@ -2052,8 +2069,8 @@ void SMESH_subMesh::SetEventListener(EventListener* listener, EventListenerData* EventListenerData* SMESH_subMesh::GetEventListenerData(EventListener* listener) const { map< EventListener*, EventListenerData* >::const_iterator l_d = - myEventListeners.find( listener ); - if ( l_d != myEventListeners.end() ) + _eventListeners.find( listener ); + if ( l_d != _eventListeners.end() ) return l_d->second; return 0; } @@ -2067,16 +2084,16 @@ EventListenerData* SMESH_subMesh::GetEventListenerData(EventListener* listener) */ //================================================================================ -void SMESH_subMesh::NotifyListenersOnEvent( const int event, +void SMESH_subMesh::notifyListenersOnEvent( const int event, const event_type eventType, SMESH_Hypothesis* hyp) { - map< EventListener*, EventListenerData* >::iterator l_d = myEventListeners.begin(); - for ( ; l_d != myEventListeners.end(); ++l_d ) + map< EventListener*, EventListenerData* >::iterator l_d = _eventListeners.begin(); + for ( ; l_d != _eventListeners.end(); ++l_d ) { std::pair< EventListener*, EventListenerData* > li_da = *l_d; /* copy to enable removal of a listener from - myEventListeners by + _eventListeners by its ProcessEvent() */ if ( li_da.first->myBusySM.insert( this ).second ) { @@ -2096,11 +2113,11 @@ void SMESH_subMesh::NotifyListenersOnEvent( const int event, void SMESH_subMesh::DeleteEventListener(EventListener* listener) { map< EventListener*, EventListenerData* >::iterator l_d = - myEventListeners.find( listener ); - if ( l_d != myEventListeners.end() ) { + _eventListeners.find( listener ); + if ( l_d != _eventListeners.end() ) { if ( l_d->first && l_d->first->IsDeletable() ) delete l_d->first; if ( l_d->second && l_d->second->IsDeletable() ) delete l_d->second; - myEventListeners.erase( l_d ); + _eventListeners.erase( l_d ); } } @@ -2110,12 +2127,42 @@ void SMESH_subMesh::DeleteEventListener(EventListener* listener) */ //================================================================================ -void SMESH_subMesh::DeleteOwnListeners() +void SMESH_subMesh::deleteOwnListeners() +{ + list< OwnListenerData >::iterator d; + for ( d = _ownListeners.begin(); d != _ownListeners.end(); ++d ) + { + if ( !_father->MeshExists( d->myMeshID )) + continue; + if ( _father->GetId() == d->myMeshID && !_father->GetSubMeshContaining( d->mySubMeshID )) + continue; + d->mySubMesh->DeleteEventListener( d->myListener ); + } + _ownListeners.clear(); +} + +//======================================================================= +//function : loadDependentMeshes +//purpose : loads dependent meshes on SUBMESH_LOADED event +//======================================================================= + +void SMESH_subMesh::loadDependentMeshes() { - list< pair< SMESH_subMesh*, EventListener* > >::iterator sm_l; - for ( sm_l = myOwnListeners.begin(); sm_l != myOwnListeners.end(); ++sm_l) - sm_l->first->DeleteEventListener( sm_l->second ); - myOwnListeners.clear(); + list< OwnListenerData >::iterator d; + for ( d = _ownListeners.begin(); d != _ownListeners.end(); ++d ) + if ( _father != d->mySubMesh->_father ) + d->mySubMesh->_father->Load(); + + // map< EventListener*, EventListenerData* >::iterator l_d = _eventListeners.begin(); + // for ( ; l_d != _eventListeners.end(); ++l_d ) + // if ( l_d->second ) + // { + // const list& smList = l_d->second->mySubMeshes; + // list::const_iterator sm = smList.begin(); + // for ( ; sm != smList.end(); ++sm ) + // if ( _father != (*sm)->_father ) + // (*sm)->_father->Load(); + // } } //================================================================================ @@ -2229,7 +2276,7 @@ SMESH_subMeshIteratorPtr SMESH_subMesh::getDependsOnIterator(const bool includeS //================================================================================ /*! - * \brief Find common submeshes (based on shared subshapes with other + * \brief Find common submeshes (based on shared sub-shapes with other * \param theOther submesh to check * \param theSetOfCommon set of common submesh */