ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-18 10:10:35 +05:00
Code Issues Packages Projects Releases Wiki Activity

0021208: Performance issue when loading SMESH with an hdf file containing a big mesh

Browse Source 
rename private methods to start from lower-case letters

  enum compute_event {
+     SUBMESH_LOADED

+  void loadDependentMeshes();
This commit is contained in:
eap 2012-02-24 10:38:22 +00:00
parent d8cd2598fc
commit d5a3c3b28a
2 changed files with 189 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

297
src/SMESH/SMESH_subMesh.cxx
View File

@ -115,7 +115,7 @@ SMESH_subMesh::~SMESH_subMesh()
{ {
MESSAGE("SMESH_subMesh::~SMESH_subMesh"); MESSAGE("SMESH_subMesh::~SMESH_subMesh");
// **** // ****
DeleteOwnListeners(); deleteOwnListeners();
} }
//============================================================================= //=============================================================================
@ -256,7 +256,7 @@ bool SMESH_subMesh::IsMeshComputed() const
*/ */
//============================================================================= //=============================================================================
bool SMESH_subMesh::SubMeshesComputed() bool SMESH_subMesh::subMeshesComputed()
{ {
int myDim = SMESH_Gen::GetShapeDim( _subShape ); int myDim = SMESH_Gen::GetShapeDim( _subShape );
int dimToCheck = myDim - 1; int dimToCheck = myDim - 1;
@ -340,23 +340,23 @@ bool SMESH_subMesh::SubMeshesComputed()
*/ */
//============================================================================= //=============================================================================
bool SMESH_subMesh::SubMeshesReady() // bool SMESH_subMesh::SubMeshesReady()
{ // {
bool subMeshesReady = true; // bool subMeshesReady = true;
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true); // SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true);
while ( smIt->more() ) { // while ( smIt->more() ) {
SMESH_subMesh *sm = smIt->next(); // SMESH_subMesh *sm = smIt->next();
bool computeOk = (sm->GetComputeState() == COMPUTE_OK || // bool computeOk = (sm->GetComputeState() == COMPUTE_OK ||
sm->GetComputeState() == READY_TO_COMPUTE); // sm->GetComputeState() == READY_TO_COMPUTE);
if (!computeOk) // if (!computeOk)
{ // {
subMeshesReady = false; // subMeshesReady = false;
SCRUTE(sm->GetId()); // SCRUTE(sm->GetId());
break; // break;
} // }
} // }
return subMeshesReady; // return subMeshesReady;
} // }
//============================================================================= //=============================================================================
/*! /*!
@ -386,24 +386,24 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
//MESSAGE("compound"); //MESSAGE("compound");
for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More();exp.Next()) 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()) for (TopExp_Explorer exp(_subShape, TopAbs_SHELL, TopAbs_SOLID); exp.More(); exp.Next())
{ {
if ( BRep_Tool::IsClosed(exp.Current() )) if ( BRep_Tool::IsClosed(exp.Current() ))
InsertDependence(exp.Current()); //only shell not in solid insertDependence(exp.Current()); //only shell not in solid
else else
for (TopExp_Explorer expF(exp.Current(), TopAbs_FACE); expF.More();expF.Next()) 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()) 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()) for (TopExp_Explorer exp(_subShape, TopAbs_EDGE, TopAbs_FACE); exp.More();exp.Next())
{ {
InsertDependence(exp.Current()); insertDependence(exp.Current());
} }
break; break;
} }
@ -412,7 +412,7 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
//MESSAGE("compsolid"); //MESSAGE("compsolid");
for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More(); exp.Next()) for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More(); exp.Next())
{ {
InsertDependence(exp.Current()); insertDependence(exp.Current());
} }
break; break;
} }
@ -421,7 +421,7 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
//MESSAGE("shell"); //MESSAGE("shell");
for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More(); exp.Next()) for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More(); exp.Next())
{ {
InsertDependence(exp.Current()); insertDependence(exp.Current());
} }
break; break;
} }
@ -430,7 +430,7 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
//MESSAGE("wire"); //MESSAGE("wire");
for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More(); exp.Next()) for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More(); exp.Next())
{ {
InsertDependence(exp.Current()); insertDependence(exp.Current());
} }
break; break;
} }
@ -440,7 +440,7 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
if(_father->HasShapeToMesh()) { if(_father->HasShapeToMesh()) {
for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More();exp.Next()) for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More();exp.Next())
{ {
InsertDependence(exp.Current()); insertDependence(exp.Current());
} }
} }
break; break;
@ -450,7 +450,7 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
//MESSAGE("face"); //MESSAGE("face");
for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More();exp.Next()) for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More();exp.Next())
{ {
InsertDependence(exp.Current()); insertDependence(exp.Current());
} }
break; break;
} }
@ -459,7 +459,7 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
//MESSAGE("edge"); //MESSAGE("edge");
for (TopExp_Explorer exp(_subShape, TopAbs_VERTEX); exp.More(); exp.Next()) for (TopExp_Explorer exp(_subShape, TopAbs_VERTEX); exp.More(); exp.Next())
{ {
InsertDependence(exp.Current()); insertDependence(exp.Current());
} }
break; 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); SMESH_subMesh *aSubMesh = _father->GetSubMesh(aSubShape);
int type = aSubShape.ShapeType(); int type = aSubShape.ShapeType();
int ordType = 9 - type; // 2 = Vertex, 8 = CompSolid int ordType = 9 - type; // 2 = Vertex, 8 = CompSolid
@ -663,7 +662,7 @@ SMESH_Hypothesis::Hypothesis_Status
if ( ! CanAddHypothesis( anHyp )) // check dimension if ( ! CanAddHypothesis( anHyp )) // check dimension
return SMESH_Hypothesis::HYP_BAD_DIM; return SMESH_Hypothesis::HYP_BAD_DIM;
if ( /*!anHyp->IsAuxiliary() &&*/ GetSimilarAttached( _subShape, anHyp ) ) if ( /*!anHyp->IsAuxiliary() &&*/ getSimilarAttached( _subShape, anHyp ) )
return SMESH_Hypothesis::HYP_ALREADY_EXIST; return SMESH_Hypothesis::HYP_ALREADY_EXIST;
if ( !meshDS->AddHypothesis(_subShape, anHyp)) if ( !meshDS->AddHypothesis(_subShape, anHyp))
@ -710,13 +709,13 @@ SMESH_Hypothesis::Hypothesis_Status
algo = GetAlgo(); algo = GetAlgo();
ASSERT(algo); ASSERT(algo);
if (algo->CheckHypothesis((*_father),_subShape, aux_ret)) if (algo->CheckHypothesis((*_father),_subShape, aux_ret))
SetAlgoState(HYP_OK); setAlgoState(HYP_OK);
else if ( algo->IsStatusFatal( aux_ret )) { else if ( algo->IsStatusFatal( aux_ret )) {
meshDS->RemoveHypothesis(_subShape, anHyp); meshDS->RemoveHypothesis(_subShape, anHyp);
ret = aux_ret; ret = aux_ret;
} }
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
break; break;
} }
case REMOVE_HYP: case REMOVE_HYP:
@ -728,9 +727,9 @@ SMESH_Hypothesis::Hypothesis_Status
ASSERT(algo); ASSERT(algo);
if ( algo == anHyp ) { if ( algo == anHyp ) {
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret)) if ( algo->CheckHypothesis((*_father),_subShape, aux_ret))
SetAlgoState(HYP_OK); setAlgoState(HYP_OK);
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
} }
break; break;
} }
@ -741,9 +740,9 @@ SMESH_Hypothesis::Hypothesis_Status
if (algo) if (algo)
{ {
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
SetAlgoState(HYP_OK); setAlgoState(HYP_OK);
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
} }
break; break;
} }
@ -763,7 +762,7 @@ SMESH_Hypothesis::Hypothesis_Status
algo = GetAlgo(); algo = GetAlgo();
ASSERT(algo); ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, ret )) if ( algo->CheckHypothesis((*_father),_subShape, ret ))
SetAlgoState(HYP_OK); setAlgoState(HYP_OK);
if (SMESH_Hypothesis::IsStatusFatal( ret )) if (SMESH_Hypothesis::IsStatusFatal( ret ))
meshDS->RemoveHypothesis(_subShape, anHyp); meshDS->RemoveHypothesis(_subShape, anHyp);
else if (!_father->IsUsedHypothesis( anHyp, this )) else if (!_father->IsUsedHypothesis( anHyp, this ))
@ -777,13 +776,13 @@ SMESH_Hypothesis::Hypothesis_Status
algo = GetAlgo(); algo = GetAlgo();
ASSERT(algo); ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))// ignore hyp status if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))// ignore hyp status
SetAlgoState(HYP_OK); setAlgoState(HYP_OK);
else if ( algo->IsStatusFatal( aux_ret )) { else if ( algo->IsStatusFatal( aux_ret )) {
meshDS->RemoveHypothesis(_subShape, anHyp); meshDS->RemoveHypothesis(_subShape, anHyp);
ret = aux_ret; ret = aux_ret;
} }
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
break; break;
} }
case REMOVE_HYP: case REMOVE_HYP:
@ -792,14 +791,14 @@ SMESH_Hypothesis::Hypothesis_Status
algo = GetAlgo(); algo = GetAlgo();
if (algo == NULL) // no more algo applying on sub-shape... if (algo == NULL) // no more algo applying on sub-shape...
{ {
SetAlgoState(NO_ALGO); setAlgoState(NO_ALGO);
} }
else else
{ {
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
SetAlgoState(HYP_OK); setAlgoState(HYP_OK);
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
} }
break; break;
} }
@ -808,9 +807,9 @@ SMESH_Hypothesis::Hypothesis_Status
algo = GetAlgo(); algo = GetAlgo();
ASSERT(algo); ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
SetAlgoState(HYP_OK); setAlgoState(HYP_OK);
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
break; break;
} }
case ADD_FATHER_ALGO: { // new father algo case ADD_FATHER_ALGO: { // new father algo
@ -818,9 +817,9 @@ SMESH_Hypothesis::Hypothesis_Status
ASSERT( algo ); ASSERT( algo );
if ( algo == anHyp ) { if ( algo == anHyp ) {
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
SetAlgoState(HYP_OK); setAlgoState(HYP_OK);
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
} }
break; break;
} }
@ -830,14 +829,14 @@ SMESH_Hypothesis::Hypothesis_Status
algo = GetAlgo(); algo = GetAlgo();
if (algo == NULL) // no more applying algo on father if (algo == NULL) // no more applying algo on father
{ {
SetAlgoState(NO_ALGO); setAlgoState(NO_ALGO);
} }
else else
{ {
if ( algo->CheckHypothesis((*_father),_subShape , aux_ret )) if ( algo->CheckHypothesis((*_father),_subShape , aux_ret ))
SetAlgoState(HYP_OK); setAlgoState(HYP_OK);
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
} }
break; break;
} }
@ -889,16 +888,16 @@ SMESH_Hypothesis::Hypothesis_Status
modifiedHyp = true; modifiedHyp = true;
} }
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
break; break;
} }
case REMOVE_HYP: { case REMOVE_HYP: {
algo = GetAlgo(); algo = GetAlgo();
ASSERT(algo); ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
SetAlgoState(HYP_OK); setAlgoState(HYP_OK);
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
modifiedHyp = true; modifiedHyp = true;
break; break;
} }
@ -906,7 +905,7 @@ SMESH_Hypothesis::Hypothesis_Status
algo = GetAlgo(); algo = GetAlgo();
if (algo == NULL) // no more algo applying on sub-shape... if (algo == NULL) // no more algo applying on sub-shape...
{ {
SetAlgoState(NO_ALGO); setAlgoState(NO_ALGO);
} }
else else
{ {
@ -916,7 +915,7 @@ SMESH_Hypothesis::Hypothesis_Status
modifiedHyp = true; modifiedHyp = true;
} }
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
} }
break; break;
} }
@ -930,7 +929,7 @@ SMESH_Hypothesis::Hypothesis_Status
modifiedHyp = true; modifiedHyp = true;
} }
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
break; break;
} }
case ADD_FATHER_ALGO: { case ADD_FATHER_ALGO: {
@ -948,7 +947,7 @@ SMESH_Hypothesis::Hypothesis_Status
modifiedHyp = true; modifiedHyp = true;
} }
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
} }
break; break;
} }
@ -957,11 +956,11 @@ SMESH_Hypothesis::Hypothesis_Status
ASSERT(algo); ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
// is there the same local hyp or maybe a new father algo applied? // is there the same local hyp or maybe a new father algo applied?
if ( !GetSimilarAttached( _subShape, anHyp ) ) if ( !getSimilarAttached( _subShape, anHyp ) )
modifiedHyp = true; modifiedHyp = true;
} }
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
break; break;
} }
case REMOVE_FATHER_ALGO: { case REMOVE_FATHER_ALGO: {
@ -974,7 +973,7 @@ SMESH_Hypothesis::Hypothesis_Status
algo = GetAlgo(); algo = GetAlgo();
if (algo == NULL) // no more applying algo on father if (algo == NULL) // no more applying algo on father
{ {
SetAlgoState(NO_ALGO); setAlgoState(NO_ALGO);
} }
else else
{ {
@ -984,7 +983,7 @@ SMESH_Hypothesis::Hypothesis_Status
modifiedHyp = true; modifiedHyp = true;
} }
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
} }
break; break;
} }
@ -1034,10 +1033,10 @@ SMESH_Hypothesis::Hypothesis_Status
if ( stateChange && _algoState == HYP_OK ) // hyp becomes OK if ( stateChange && _algoState == HYP_OK ) // hyp becomes OK
algo->SetEventListener( this ); algo->SetEventListener( this );
NotifyListenersOnEvent( event, ALGO_EVENT, anHyp ); notifyListenersOnEvent( event, ALGO_EVENT, anHyp );
if ( stateChange && oldAlgoState == HYP_OK ) { // hyp becomes KO if ( stateChange && oldAlgoState == HYP_OK ) { // hyp becomes KO
DeleteOwnListeners(); deleteOwnListeners();
SetIsAlwaysComputed( false ); SetIsAlwaysComputed( false );
if (_subShape.ShapeType() == TopAbs_VERTEX ) { if (_subShape.ShapeType() == TopAbs_VERTEX ) {
// restore default states // restore default states
@ -1049,7 +1048,7 @@ SMESH_Hypothesis::Hypothesis_Status
if ( needFullClean ) { if ( needFullClean ) {
// added or removed algo is all-dimensional // added or removed algo is all-dimensional
ComputeStateEngine( CLEAN ); ComputeStateEngine( CLEAN );
CleanDependsOn(); cleanDependsOn();
ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE ); ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
} }
@ -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; _algoState = state;
} }
@ -1154,7 +1153,7 @@ SMESH_Hypothesis::Hypothesis_Status
*/ */
//============================================================================= //=============================================================================
void SMESH_subMesh::CleanDependsOn() void SMESH_subMesh::cleanDependsOn()
{ {
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false); SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() ) while ( smIt->more() )
@ -1266,7 +1265,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
SMESHDS_SubMesh* smDS = GetSubMeshDS(); SMESHDS_SubMesh* smDS = GetSubMeshDS();
if ( smDS && smDS->NbNodes() ) { if ( smDS && smDS->NbNodes() ) {
if ( event == CLEAN ) { if ( event == CLEAN ) {
CleanDependants(); cleanDependants();
cleanSubMesh( this ); cleanSubMesh( this );
} }
else else
@ -1281,7 +1280,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
} }
} }
if ( event == MODIF_ALGO_STATE ) if ( event == MODIF_ALGO_STATE )
CleanDependants(); cleanDependants();
return true; return true;
} }
SMESH_Gen *gen = _father->GetGen(); SMESH_Gen *gen = _father->GetGen();
@ -1301,7 +1300,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
case MODIF_ALGO_STATE: case MODIF_ALGO_STATE:
algo = GetAlgo(); algo = GetAlgo();
if (algo && !algo->NeedDiscreteBoundary()) if (algo && !algo->NeedDiscreteBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN cleanDependsOn(); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK ) if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE; _computeState = READY_TO_COMPUTE;
break; break;
@ -1312,8 +1311,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
break; break;
#endif #endif
case CLEAN: case CLEAN:
CleanDependants(); cleanDependants();
RemoveSubMeshElementsAndNodes(); removeSubMeshElementsAndNodes();
break; break;
case SUBMESH_COMPUTED: // nothing to do case SUBMESH_COMPUTED: // nothing to do
break; break;
@ -1322,6 +1321,10 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
break; break;
case MESH_ENTITY_REMOVED: case MESH_ENTITY_REMOVED:
break; break;
case SUBMESH_LOADED:
loadDependentMeshes();
ComputeSubMeshStateEngine( SUBMESH_LOADED );
//break;
case CHECK_COMPUTE_STATE: case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() ) if ( IsMeshComputed() )
_computeState = COMPUTE_OK; _computeState = COMPUTE_OK;
@ -1343,7 +1346,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
if (algo) if (algo)
{ {
if (!algo->NeedDiscreteBoundary()) if (!algo->NeedDiscreteBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN cleanDependsOn(); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK ) if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE; _computeState = READY_TO_COMPUTE;
} }
@ -1357,7 +1360,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
{ {
MESSAGE("***** verify compute state *****"); MESSAGE("***** verify compute state *****");
_computeState = NOT_READY; _computeState = NOT_READY;
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
break; break;
} }
TopoDS_Shape shape = _subShape; TopoDS_Shape shape = _subShape;
@ -1365,9 +1368,9 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
if (_father->HasShapeToMesh() ) { if (_father->HasShapeToMesh() ) {
bool subComputed = false; bool subComputed = false;
if (!algo->OnlyUnaryInput()) if (!algo->OnlyUnaryInput())
shape = GetCollection( gen, algo, subComputed ); shape = getCollection( gen, algo, subComputed );
else else
subComputed = SubMeshesComputed(); subComputed = subMeshesComputed();
ret = ( algo->NeedDiscreteBoundary() ? subComputed : ret = ( algo->NeedDiscreteBoundary() ? subComputed :
algo->SupportSubmeshes() ? true : algo->SupportSubmeshes() ? true :
( !subComputed || _father->IsNotConformAllowed() )); ( !subComputed || _father->IsNotConformAllowed() ));
@ -1381,8 +1384,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
} }
} }
// compute // compute
// CleanDependants(); for "UseExisting_*D" algos // cleanDependants(); for "UseExisting_*D" algos
// RemoveSubMeshElementsAndNodes(); // removeSubMeshElementsAndNodes();
ret = false; ret = false;
_computeState = FAILED_TO_COMPUTE; _computeState = FAILED_TO_COMPUTE;
_computeError = SMESH_ComputeError::New(COMPERR_OK,"",algo); _computeError = SMESH_ComputeError::New(COMPERR_OK,"",algo);
@ -1462,7 +1465,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
for (; ret && subS.More(); subS.Next()) for (; ret && subS.More(); subS.Next())
ret = _father->GetSubMesh( subS.Current() )->IsMeshComputed(); ret = _father->GetSubMesh( subS.Current() )->IsMeshComputed();
} }
bool isComputeErrorSet = !CheckComputeError( algo, shape ); bool isComputeErrorSet = !checkComputeError( algo, shape );
if (!ret && !isComputeErrorSet) if (!ret && !isComputeErrorSet)
{ {
// Set _computeError // Set _computeError
@ -1484,7 +1487,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
{ {
_computeError.reset(); _computeError.reset();
} }
UpdateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED updateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
} }
break; break;
#ifdef WITH_SMESH_CANCEL_COMPUTE #ifdef WITH_SMESH_CANCEL_COMPUTE
@ -1492,8 +1495,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
break; break;
#endif #endif
case CLEAN: case CLEAN:
CleanDependants(); cleanDependants();
RemoveSubMeshElementsAndNodes(); removeSubMeshElementsAndNodes();
_computeState = NOT_READY; _computeState = NOT_READY;
algo = GetAlgo(); algo = GetAlgo();
if (algo) if (algo)
@ -1502,7 +1505,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
if (ret) if (ret)
_computeState = READY_TO_COMPUTE; _computeState = READY_TO_COMPUTE;
else else
SetAlgoState(MISSING_HYP); setAlgoState(MISSING_HYP);
} }
break; break;
case SUBMESH_COMPUTED: // nothing to do case SUBMESH_COMPUTED: // nothing to do
@ -1517,6 +1520,10 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
break; break;
case MESH_ENTITY_REMOVED: case MESH_ENTITY_REMOVED:
break; break;
case SUBMESH_LOADED:
loadDependentMeshes();
ComputeSubMeshStateEngine( SUBMESH_LOADED );
//break;
case CHECK_COMPUTE_STATE: case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() ) if ( IsMeshComputed() )
_computeState = COMPUTE_OK; _computeState = COMPUTE_OK;
@ -1536,7 +1543,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
ComputeStateEngine( CLEAN ); ComputeStateEngine( CLEAN );
algo = GetAlgo(); algo = GetAlgo();
if (algo && !algo->NeedDiscreteBoundary()) if (algo && !algo->NeedDiscreteBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN cleanDependsOn(); // clean sub-meshes with event CLEAN
break; break;
case COMPUTE: // nothing to do case COMPUTE: // nothing to do
break; break;
@ -1545,8 +1552,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
break; break;
#endif #endif
case CLEAN: case CLEAN:
CleanDependants(); // clean sub-meshes, dependant on this one, with event CLEAN cleanDependants(); // clean sub-meshes, dependant on this one, with event CLEAN
RemoveSubMeshElementsAndNodes(); removeSubMeshElementsAndNodes();
_computeState = NOT_READY; _computeState = NOT_READY;
if ( _algoState == HYP_OK ) if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE; _computeState = READY_TO_COMPUTE;
@ -1560,8 +1567,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
if (algo) algo->SubmeshRestored( this ); if (algo) algo->SubmeshRestored( this );
break; break;
case MESH_ENTITY_REMOVED: case MESH_ENTITY_REMOVED:
UpdateDependantsState( CHECK_COMPUTE_STATE ); updateDependantsState ( CHECK_COMPUTE_STATE );
ComputeStateEngine( CHECK_COMPUTE_STATE ); ComputeStateEngine ( CHECK_COMPUTE_STATE );
ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE ); ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
break; break;
case CHECK_COMPUTE_STATE: case CHECK_COMPUTE_STATE:
@ -1572,6 +1579,9 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
_computeState = NOT_READY; _computeState = NOT_READY;
} }
break; break;
case SUBMESH_LOADED:
// already treated event, thanks to which _computeState == COMPUTE_OK
break;
default: default:
ASSERT(0); ASSERT(0);
break; break;
@ -1588,7 +1598,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
ComputeStateEngine( CLEAN ); ComputeStateEngine( CLEAN );
algo = GetAlgo(); algo = GetAlgo();
if (algo && !algo->NeedDiscreteBoundary()) if (algo && !algo->NeedDiscreteBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN cleanDependsOn(); // clean sub-meshes with event CLEAN
if (_algoState == HYP_OK) if (_algoState == HYP_OK)
_computeState = READY_TO_COMPUTE; _computeState = READY_TO_COMPUTE;
else else
@ -1605,8 +1615,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
break; break;
#endif #endif
case CLEAN: case CLEAN:
CleanDependants(); // submeshes dependent on me should be cleaned as well cleanDependants(); // submeshes dependent on me should be cleaned as well
RemoveSubMeshElementsAndNodes(); removeSubMeshElementsAndNodes();
break; break;
case SUBMESH_COMPUTED: // allow retry compute case SUBMESH_COMPUTED: // allow retry compute
if (_algoState == HYP_OK) if (_algoState == HYP_OK)
@ -1640,7 +1650,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
break; break;
} }
NotifyListenersOnEvent( event, COMPUTE_EVENT ); notifyListenersOnEvent( event, COMPUTE_EVENT );
return ret; return ret;
} }
@ -1710,7 +1720,7 @@ 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; bool noErrors = true;
@ -1721,7 +1731,7 @@ bool SMESH_subMesh::CheckComputeError(SMESH_Algo* theAlgo, const TopoDS_Shape& t
{ {
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false); SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() ) while ( smIt->more() )
if ( !smIt->next()->CheckComputeError( theAlgo )) if ( !smIt->next()->checkComputeError( theAlgo ))
noErrors = false; 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()) { for (TopoDS_Iterator subIt( theShape ); subIt.More(); subIt.Next()) {
SMESH_subMesh* sm = _father->GetSubMesh( subIt.Value() ); SMESH_subMesh* sm = _father->GetSubMesh( subIt.Value() );
if ( sm != this ) { if ( sm != this ) {
if ( !sm->CheckComputeError( theAlgo, sm->GetSubShape() )) if ( !sm->checkComputeError( theAlgo, sm->GetSubShape() ))
noErrors = false; noErrors = false;
UpdateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED updateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
} }
} }
} }
@ -1773,11 +1783,11 @@ bool SMESH_subMesh::CheckComputeError(SMESH_Algo* theAlgo, const TopoDS_Shape& t
} }
//======================================================================= //=======================================================================
//function : UpdateSubMeshState //function : updateSubMeshState
//purpose : //purpose :
//======================================================================= //=======================================================================
void SMESH_subMesh::UpdateSubMeshState(const compute_state theState) void SMESH_subMesh::updateSubMeshState(const compute_state theState)
{ {
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false); SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() ) while ( smIt->more() )
@ -1797,13 +1807,12 @@ void SMESH_subMesh::ComputeSubMeshStateEngine(int event)
} }
//======================================================================= //=======================================================================
//function : UpdateDependantsState //function : updateDependantsState
//purpose : //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 )); TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
for (; it.More(); it.Next()) 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; 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 ); cleanSubMesh( this );
// algo may bind a submesh not to _subShape, eg 3D algo // 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 //purpose : return a shape containing all sub-shapes of the MainShape that can be
// meshed at once along with _subShape // 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, SMESH_Algo* theAlgo,
bool & theSubComputed) bool & theSubComputed)
{ {
MESSAGE("SMESH_subMesh::GetCollection"); theSubComputed = subMeshesComputed();
theSubComputed = SubMeshesComputed();
TopoDS_Shape mainShape = _father->GetMeshDS()->ShapeToMesh(); 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 if (strcmp( anAlgo->GetName(), theAlgo->GetName()) == 0 && // same algo
anAlgo->GetUsedHypothesis( *_father, S, ignoreAuxiliaryHyps ) == aUsedHyp) // same hyps anAlgo->GetUsedHypothesis( *_father, S, ignoreAuxiliaryHyps ) == aUsedHyp) // same hyps
aBuilder.Add( aCompound, S ); aBuilder.Add( aCompound, S );
if ( !subMesh->SubMeshesComputed() ) if ( !subMesh->subMeshesComputed() )
theSubComputed = false; 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. //purpose : return a hypothesis attached to theShape.
// If theHyp is provided, similar but not same hypotheses // If theHyp is provided, similar but not same hypotheses
// is returned; else only applicable ones having theHypType // is returned; else only applicable ones having theHypType
// is returned // 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 SMESH_Hypothesis * theHyp,
const int theHypType) const int theHypType)
{ {
@ -1965,7 +1970,7 @@ SMESH_Hypothesis::Hypothesis_Status
MESSAGE ("SMESH_subMesh::CheckConcurentHypothesis"); MESSAGE ("SMESH_subMesh::CheckConcurentHypothesis");
// is there local hypothesis on me? // is there local hypothesis on me?
if ( GetSimilarAttached( _subShape, 0, theHypType ) ) if ( getSimilarAttached( _subShape, 0, theHypType ) )
return SMESH_Hypothesis::HYP_OK; return SMESH_Hypothesis::HYP_OK;
@ -1975,7 +1980,7 @@ SMESH_Hypothesis::Hypothesis_Status
for (; it.More(); it.Next()) for (; it.More(); it.Next())
{ {
const TopoDS_Shape& ancestor = it.Value(); 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 ( hyp )
{ {
if ( aPrevWithHyp.IsNull() || aPrevWithHyp.IsSame( ancestor )) if ( aPrevWithHyp.IsNull() || aPrevWithHyp.IsSame( ancestor ))
@ -2024,8 +2029,8 @@ void SMESH_subMesh::SetEventListener(EventListener* listener,
SMESH_subMesh* where) SMESH_subMesh* where)
{ {
if ( listener && where ) { if ( listener && where ) {
where->SetEventListener( listener, data ); where->setEventListener( listener, data );
myOwnListeners.push_back( OwnListenerData( where, listener )); _ownListeners.push_back( OwnListenerData( where, listener ));
} }
} }
@ -2039,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 = map< EventListener*, EventListenerData* >::iterator l_d =
myEventListeners.find( listener ); _eventListeners.find( listener );
if ( l_d != myEventListeners.end() ) { if ( l_d != _eventListeners.end() ) {
EventListenerData* curData = l_d->second; EventListenerData* curData = l_d->second;
if ( curData && curData != data && curData->IsDeletable() ) if ( curData && curData != data && curData->IsDeletable() )
delete curData; delete curData;
l_d->second = data; l_d->second = data;
} }
else else
myEventListeners.insert( make_pair( listener, data )); _eventListeners.insert( make_pair( listener, data ));
} }
//================================================================================ //================================================================================
@ -2064,8 +2069,8 @@ void SMESH_subMesh::SetEventListener(EventListener* listener, EventListenerData*
EventListenerData* SMESH_subMesh::GetEventListenerData(EventListener* listener) const EventListenerData* SMESH_subMesh::GetEventListenerData(EventListener* listener) const
{ {
map< EventListener*, EventListenerData* >::const_iterator l_d = map< EventListener*, EventListenerData* >::const_iterator l_d =
myEventListeners.find( listener ); _eventListeners.find( listener );
if ( l_d != myEventListeners.end() ) if ( l_d != _eventListeners.end() )
return l_d->second; return l_d->second;
return 0; return 0;
} }
@ -2079,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, const event_type eventType,
SMESH_Hypothesis* hyp) SMESH_Hypothesis* hyp)
{ {
map< EventListener*, EventListenerData* >::iterator l_d = myEventListeners.begin(); map< EventListener*, EventListenerData* >::iterator l_d = _eventListeners.begin();
for ( ; l_d != myEventListeners.end(); ++l_d ) for ( ; l_d != _eventListeners.end(); ++l_d )
{ {
std::pair< EventListener*, EventListenerData* > li_da = *l_d; /* copy to enable removal std::pair< EventListener*, EventListenerData* > li_da = *l_d; /* copy to enable removal
of a listener from of a listener from
myEventListeners by _eventListeners by
its ProcessEvent() */ its ProcessEvent() */
if ( li_da.first->myBusySM.insert( this ).second ) if ( li_da.first->myBusySM.insert( this ).second )
{ {
@ -2108,11 +2113,11 @@ void SMESH_subMesh::NotifyListenersOnEvent( const int event,
void SMESH_subMesh::DeleteEventListener(EventListener* listener) void SMESH_subMesh::DeleteEventListener(EventListener* listener)
{ {
map< EventListener*, EventListenerData* >::iterator l_d = map< EventListener*, EventListenerData* >::iterator l_d =
myEventListeners.find( listener ); _eventListeners.find( listener );
if ( l_d != myEventListeners.end() ) { if ( l_d != _eventListeners.end() ) {
if ( l_d->first && l_d->first->IsDeletable() ) delete l_d->first; if ( l_d->first && l_d->first->IsDeletable() ) delete l_d->first;
if ( l_d->second && l_d->second->IsDeletable() ) delete l_d->second; if ( l_d->second && l_d->second->IsDeletable() ) delete l_d->second;
myEventListeners.erase( l_d ); _eventListeners.erase( l_d );
} }
} }
@ -2122,10 +2127,10 @@ void SMESH_subMesh::DeleteEventListener(EventListener* listener)
*/ */
//================================================================================ //================================================================================
void SMESH_subMesh::DeleteOwnListeners() void SMESH_subMesh::deleteOwnListeners()
{ {
list< OwnListenerData >::iterator d; list< OwnListenerData >::iterator d;
for ( d = myOwnListeners.begin(); d != myOwnListeners.end(); ++d ) for ( d = _ownListeners.begin(); d != _ownListeners.end(); ++d )
{ {
if ( !_father->MeshExists( d->myMeshID )) if ( !_father->MeshExists( d->myMeshID ))
continue; continue;
@ -2133,7 +2138,31 @@ void SMESH_subMesh::DeleteOwnListeners()
continue; continue;
d->mySubMesh->DeleteEventListener( d->myListener ); d->mySubMesh->DeleteEventListener( d->myListener );
} }
myOwnListeners.clear(); _ownListeners.clear();
}
//=======================================================================
//function : loadDependentMeshes
//purpose : loads dependent meshes on SUBMESH_LOADED event
//=======================================================================
void SMESH_subMesh::loadDependentMeshes()
{
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<SMESH_subMesh*>& smList = l_d->second->mySubMeshes;
// list<SMESH_subMesh*>::const_iterator sm = smList.begin();
// for ( ; sm != smList.end(); ++sm )
// if ( _father != (*sm)->_father )
// (*sm)->_father->Load();
// }
} }
//================================================================================ //================================================================================

47
src/SMESH/SMESH_subMesh.hxx
View File

@ -109,7 +109,7 @@ class SMESH_EXPORT SMESH_subMesh
#ifdef WITH_SMESH_CANCEL_COMPUTE #ifdef WITH_SMESH_CANCEL_COMPUTE
COMPUTE_CANCELED, COMPUTE_CANCELED,
#endif #endif
CLEAN, SUBMESH_COMPUTED, SUBMESH_RESTORED, CLEAN, SUBMESH_COMPUTED, SUBMESH_RESTORED, SUBMESH_LOADED,
MESH_ENTITY_REMOVED, CHECK_COMPUTE_STATE MESH_ENTITY_REMOVED, CHECK_COMPUTE_STATE
}; };
enum event_type enum event_type
@ -151,7 +151,8 @@ class SMESH_EXPORT SMESH_subMesh
protected: protected:
//!< event listeners to notify //!< event listeners to notify
std::map< EventListener*, EventListenerData* > myEventListeners; std::map< EventListener*, EventListenerData* > _eventListeners;
//!< event listeners to delete when HYP_OK algo_state is lost //!< event listeners to delete when HYP_OK algo_state is lost
struct OwnListenerData { struct OwnListenerData {
SMESH_subMesh* mySubMesh; SMESH_subMesh* mySubMesh;
@ -160,7 +161,7 @@ protected:
EventListener* myListener; EventListener* myListener;
OwnListenerData( SMESH_subMesh* sm=0, EventListener* el=0); OwnListenerData( SMESH_subMesh* sm=0, EventListener* el=0);
}; };
std::list< OwnListenerData > myOwnListeners; std::list< OwnListenerData > _ownListeners;
/*! /*!
* \brief Sets an event listener and its data to a submesh * \brief Sets an event listener and its data to a submesh
@ -169,7 +170,7 @@ protected:
* *
* After being set, event listener is notified on each event of a submesh. * After being set, event listener is notified on each event of a submesh.
*/ */
void SetEventListener(EventListener* listener, EventListenerData* data); void setEventListener(EventListener* listener, EventListenerData* data);
/*! /*!
* \brief Notify stored event listeners on the occured event * \brief Notify stored event listeners on the occured event
@ -177,16 +178,22 @@ protected:
* \param eventType - algo_event or compute_event * \param eventType - algo_event or compute_event
* \param hyp - hypothesis, if eventType is algo_event * \param hyp - hypothesis, if eventType is algo_event
*/ */
void NotifyListenersOnEvent( const int event, void notifyListenersOnEvent( const int event,
const event_type eventType, const event_type eventType,
SMESH_Hypothesis* hyp = 0); SMESH_Hypothesis* hyp = 0);
/*! /*!
* \brief Delete event listeners depending on algo of this submesh * \brief Delete event listeners depending on algo of this submesh
*/ */
void DeleteOwnListeners(); void deleteOwnListeners();
// ================================================================== /*!
* \brief loads dependent meshes on SUBMESH_LOADED event
*/
void loadDependentMeshes();
// END: Members to track non hierarchical dependencies between submeshes
// =====================================================================
public: public:
@ -252,32 +259,30 @@ public:
protected: protected:
// ================================================================== // ==================================================================
void InsertDependence(const TopoDS_Shape aSubShape); void insertDependence(const TopoDS_Shape aSubShape);
bool SubMeshesComputed(); bool subMeshesComputed();
//bool SubMeshesReady();
bool SubMeshesReady(); void removeSubMeshElementsAndNodes();
void updateDependantsState(const compute_event theEvent);
void RemoveSubMeshElementsAndNodes(); void updateSubMeshState(const compute_state theState);
void UpdateDependantsState(const compute_event theEvent); void cleanDependants();
void UpdateSubMeshState(const compute_state theState); void cleanDependsOn();
void CleanDependants(); void setAlgoState(int state);
void CleanDependsOn();
void SetAlgoState(int state);
/*! /*!
* \brief Return a shape containing all sub-shapes of the MainShape that can be * \brief Return a shape containing all sub-shapes of the MainShape that can be
* meshed at once along with _subShape * meshed at once along with _subShape
*/ */
TopoDS_Shape GetCollection(SMESH_Gen * theGen, TopoDS_Shape getCollection(SMESH_Gen * theGen,
SMESH_Algo* theAlgo, SMESH_Algo* theAlgo,
bool & theSubComputed); bool & theSubComputed);
/*! /*!
* \brief Update compute_state by _computeError * \brief Update compute_state by _computeError
* \retval bool - false if there are errors * \retval bool - false if there are errors
*/ */
bool CheckComputeError(SMESH_Algo* theAlgo, const TopoDS_Shape& theShape=TopoDS_Shape()); bool checkComputeError(SMESH_Algo* theAlgo, const TopoDS_Shape& theShape=TopoDS_Shape());
/*! /*!
* \brief Return a hypothesis attached to theShape. * \brief Return a hypothesis attached to theShape.
@ -286,7 +291,7 @@ protected:
* is returned; else an applicable ones having theHypType * is returned; else an applicable ones having theHypType
* is returned * is returned
*/ */
const SMESH_Hypothesis* GetSimilarAttached(const TopoDS_Shape& theShape, const SMESH_Hypothesis* getSimilarAttached(const TopoDS_Shape& theShape,
const SMESH_Hypothesis * theHyp, const SMESH_Hypothesis * theHyp,
const int theHypType = 0); const int theHypType = 0);
// //