ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-29 10:50:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

0021893: EDF 2133 SMESH : Improvement of 3D extrusion algorithm

Browse Source 
Not to clear sub-meshes computed by local algos when an
   all-dimensional global algorithm is assigned

-  void cleanDependsOn();
+  void cleanDependsOn( bool keepSupportedsubMeshes = false );
This commit is contained in:
eap 2013-02-18 12:58:39 +00:00
parent 779bf3653a
commit 12443c9c47
2 changed files with 61 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
src/SMESH/SMESH_subMesh.cxx
View File

@ -601,10 +601,6 @@ bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis,
SMESH_Hypothesis::Hypothesis_Status
SMESH_subMesh::AlgoStateEngine(int event, SMESH_Hypothesis * anHyp)
{
// MESSAGE("SMESH_subMesh::AlgoStateEngine");
//SCRUTE(_algoState);
//SCRUTE(event);
// **** 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
@ -612,7 +608,6 @@ SMESH_Hypothesis::Hypothesis_Status
SMESH_Hypothesis::Hypothesis_Status aux_ret, ret = SMESH_Hypothesis::HYP_OK;
SMESHDS_Mesh* meshDS =_father->GetMeshDS();
//SMESH_Gen* gen =_father->GetGen();
SMESH_Algo* algo = 0;
if (_subShape.ShapeType() == TopAbs_VERTEX )
@ -642,7 +637,7 @@ SMESH_Hypothesis::Hypothesis_Status
int oldAlgoState = _algoState;
bool modifiedHyp = (event == MODIF_HYP); // if set to true, force event MODIF_ALGO_STATE
bool needFullClean = false;
bool needFullClean = false, subMeshesSupported = false;
bool isApplicableHyp = IsApplicableHypotesis( anHyp );
@ -665,7 +660,7 @@ SMESH_Hypothesis::Hypothesis_Status
SMESH_HypoFilter filter( SMESH_HypoFilter::HasType( algo->GetType() ));
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 ))
if ( SMESH_Algo * curAlgo = (SMESH_Algo*)_father->GetHypothesis(_subShape, filter, true ))
needFullClean = ( !curAlgo->NeedDiscreteBoundary() );
}
}
@ -702,6 +697,7 @@ SMESH_Hypothesis::Hypothesis_Status
// we must perform it now because later
// we will have no information about the type of the removed algo
needFullClean = true;
subMeshesSupported = algo->SupportSubmeshes();
}
}
}
@ -984,8 +980,10 @@ SMESH_Hypothesis::Hypothesis_Status
// CLEAN was not called at event REMOVE_ALGO because the algo is not applicable to SOLID.
algo = dynamic_cast<SMESH_Algo*> (anHyp);
if (!algo->NeedDiscreteBoundary())
{
needFullClean = true;
subMeshesSupported = algo->SupportSubmeshes();
}
algo = GetAlgo();
if (algo == NULL) // no more applying algo on father
{
@ -1064,7 +1062,7 @@ SMESH_Hypothesis::Hypothesis_Status
if ( needFullClean ) {
// added or removed algo is all-dimensional
ComputeStateEngine( CLEAN );
cleanDependsOn();
cleanDependsOn( subMeshesSupported );
ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
}
@ -1163,17 +1161,59 @@ SMESH_Hypothesis::Hypothesis_Status
return ret;
}
//=============================================================================
//================================================================================
/*!
*
* \brief Remove elements from sub-meshes.
* \param keepSupportedsubMeshes - if true, the sub-meshes computed using more
* local algorithms are not cleaned
*/
//=============================================================================
//================================================================================
void SMESH_subMesh::cleanDependsOn()
void SMESH_subMesh::cleanDependsOn( bool keepSupportedsubMeshes )
{
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() )
smIt->next()->ComputeStateEngine(CLEAN);
if ( _father->NbNodes() == 0 ) return;
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,
/*complexShapeFirst=*/true);
if ( !keepSupportedsubMeshes )
{
while ( smIt->more() )
smIt->next()->ComputeStateEngine(CLEAN);
}
else
{
// find sub-meshes to keep elements on
set< SMESH_subMesh* > smToKeep;
SMESHDS_Mesh* meshDS = _father->GetMeshDS();
while ( smIt->more() )
{
SMESH_subMesh* sm = smIt->next();
if ( sm->IsEmpty() ) continue;
// look for an algo assigned to sm
bool algoFound = false;
const list<const SMESHDS_Hypothesis*>& hyps = meshDS->GetHypothesis( sm->_subShape );
list<const SMESHDS_Hypothesis*>::const_iterator h = hyps.begin();
for ( ; ( !algoFound && h != hyps.end() ); ++h )
algoFound = ((*h)->GetType() != SMESHDS_Hypothesis::PARAM_ALGO );
// remember all sub-meshes of sm
if ( algoFound )
{
SMESH_subMeshIteratorPtr smIt2 = getDependsOnIterator(false,true);
while ( smIt2->more() )
smToKeep.insert( smIt2->next() );
}
}
// remove elements
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true);
while ( smIt->more() )
{
SMESH_subMesh* sm = smIt->next();
if ( !smToKeep.count( sm ))
sm->ComputeStateEngine(CLEAN);
}
}
}
//=============================================================================
@ -1328,7 +1368,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
case MODIF_ALGO_STATE:
algo = GetAlgo();
if (algo && !algo->NeedDiscreteBoundary())
cleanDependsOn(); // clean sub-meshes with event CLEAN
cleanDependsOn( algo->SupportSubmeshes() ); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE;
break;
@ -1374,7 +1414,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
if (algo)
{
if (!algo->NeedDiscreteBoundary())
cleanDependsOn(); // clean sub-meshes with event CLEAN
cleanDependsOn( algo->SupportSubmeshes() ); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE;
}
@ -1597,7 +1637,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
ComputeStateEngine( CLEAN );
algo = GetAlgo();
if (algo && !algo->NeedDiscreteBoundary())
cleanDependsOn(); // clean sub-meshes with event CLEAN
cleanDependsOn( algo->SupportSubmeshes() ); // clean sub-meshes with event CLEAN
break;
case COMPUTE: // nothing to do
break;
@ -1652,7 +1692,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
ComputeStateEngine( CLEAN );
algo = GetAlgo();
if (algo && !algo->NeedDiscreteBoundary())
cleanDependsOn(); // clean sub-meshes with event CLEAN
cleanDependsOn( algo->SupportSubmeshes() ); // clean sub-meshes with event CLEAN
if (_algoState == HYP_OK)
_computeState = READY_TO_COMPUTE;
else

2
src/SMESH/SMESH_subMesh.hxx
View File

@ -273,7 +273,7 @@ protected:
void updateDependantsState(const compute_event theEvent);
void updateSubMeshState(const compute_state theState);
void cleanDependants();
void cleanDependsOn();
void cleanDependsOn( bool keepSupportedsubMeshes = false );
void setAlgoState(algo_state state);
/*!