#include <SMESH_subMesh.hxx>
Public Types | |
| enum | compute_state { NOT_READY, READY_TO_COMPUTE, COMPUTE_OK, FAILED_TO_COMPUTE } |
| enum | algo_state { NO_ALGO, MISSING_HYP, HYP_OK } |
| enum | algo_event { ADD_HYP, ADD_ALGO, REMOVE_HYP, REMOVE_ALGO, ADD_FATHER_HYP, ADD_FATHER_ALGO, REMOVE_FATHER_HYP, REMOVE_FATHER_ALGO, MODIF_HYP } |
| enum | compute_event { MODIF_ALGO_STATE, COMPUTE, CLEAN, SUBMESH_COMPUTED, SUBMESH_RESTORED, MESH_ENTITY_REMOVED, CHECK_COMPUTE_STATE } |
| enum | event_type { ALGO_EVENT, COMPUTE_EVENT } |
Public Member Functions | |
| SMESH_subMesh (int Id, SMESH_Mesh *father, SMESHDS_Mesh *meshDS, const TopoDS_Shape &aSubShape) | |
| default constructor: | |
| virtual | ~SMESH_subMesh () |
| int | GetId () const |
| SMESH_Mesh * | GetFather () |
| SMESHDS_SubMesh * | GetSubMeshDS () |
| SMESHDS_SubMesh * | CreateSubMeshDS () |
| SMESH_subMesh * | GetFirstToCompute () |
| const std::map< int, SMESH_subMesh * > & | DependsOn () |
| Construct dependence on first level subMeshes. | |
| SMESH_subMeshIteratorPtr | getDependsOnIterator (const bool includeSelf, const bool complexShapeFirst) |
| Return iterator on the submeshes this one depends on. | |
| const TopoDS_Shape & | GetSubShape () const |
| void | SetEventListener (EventListener *listener, EventListenerData *data, SMESH_subMesh *where) |
| Sets an event listener and its data to a submesh. | |
| EventListenerData * | GetEventListenerData (EventListener *listener) const |
| Return an event listener data. | |
| void | DeleteEventListener (EventListener *listener) |
| Unregister the listener and delete it and it's data. | |
| SMESH_Hypothesis::Hypothesis_Status | AlgoStateEngine (int event, SMESH_Hypothesis *anHyp) |
| SMESH_Hypothesis::Hypothesis_Status | SubMeshesAlgoStateEngine (int event, SMESH_Hypothesis *anHyp) |
| int | GetAlgoState () const |
| int | GetComputeState () const |
| SMESH_ComputeErrorPtr & | GetComputeError () |
| void | DumpAlgoState (bool isMain) |
| bool | ComputeStateEngine (int event) |
| void | ComputeSubMeshStateEngine (int event) |
| bool | Evaluate (MapShapeNbElems &aResMap) |
| bool | IsConform (const SMESH_Algo *theAlgo) |
| bool | CanAddHypothesis (const SMESH_Hypothesis *theHypothesis) const |
| bool | IsApplicableHypotesis (const SMESH_Hypothesis *theHypothesis) const |
| SMESH_Hypothesis::Hypothesis_Status | CheckConcurentHypothesis (const int theHypType) |
| bool | IsEmpty () const |
| Return true if no mesh entities is bound to the submesh. | |
| bool | IsMeshComputed () const |
| void | SetIsAlwaysComputed (bool isAlCo) |
| Allow algo->Compute() if a subshape of lower dim is meshed but none mesh entity is bound to it. | |
| bool | IsAlwaysComputed () |
| bool | FindIntersection (const SMESH_subMesh *theOther, std::set< const SMESH_subMesh * > &theSetOfCommon) const |
| Find common submeshes (based on shared subshapes with other. | |
Static Public Member Functions | |
| static bool | IsApplicableHypotesis (const SMESH_Hypothesis *theHypothesis, const TopAbs_ShapeEnum theShapeType) |
Protected Member Functions | |
| void | SetEventListener (EventListener *listener, EventListenerData *data) |
| Sets an event listener and its data to a submesh. | |
| void | NotifyListenersOnEvent (const int event, const event_type eventType, SMESH_Hypothesis *hyp=0) |
| Notify stored event listeners on the occured event. | |
| void | DeleteOwnListeners () |
| Delete event listeners depending on algo of this submesh. | |
| void | InsertDependence (const TopoDS_Shape aSubShape) |
| For simple Shapes (solid, face, edge): add subMesh into dependence list. | |
| bool | SubMeshesComputed () |
| bool | SubMeshesReady () |
| void | RemoveSubMeshElementsAndNodes () |
| void | UpdateDependantsState (const compute_event theEvent) |
| void | UpdateSubMeshState (const compute_state theState) |
| void | CleanDependants () |
| void | CleanDependsOn () |
| void | SetAlgoState (int state) |
| TopoDS_Shape | GetCollection (SMESH_Gen *theGen, SMESH_Algo *theAlgo, bool &theSubComputed) |
| Return a shape containing all sub-shapes of the MainShape that can be meshed at once along with _subShape. | |
| bool | ApplyToCollection (SMESH_Algo *theAlgo, const TopoDS_Shape &theCollection) |
| Apply theAlgo to all subshapes in theCollection. | |
| bool | CheckComputeError (SMESH_Algo *theAlgo, const TopoDS_Shape &theShape=TopoDS_Shape()) |
| Update compute_state by _computeError. | |
| const SMESH_Hypothesis * | GetSimilarAttached (const TopoDS_Shape &theShape, const SMESH_Hypothesis *theHyp, const int theHypType=0) |
| Return a hypothesis attached to theShape. | |
Protected Attributes | |
| std::map< EventListener *, EventListenerData * > | myEventListeners |
| < event listeners to notify | |
| std::list< std::pair < SMESH_subMesh *, EventListener * > > | myOwnListeners |
| TopoDS_Shape | _subShape |
| SMESHDS_SubMesh * | _subMeshDS |
| SMESH_Mesh * | _father |
| int | _Id |
| std::map< int, SMESH_subMesh * > | _mapDepend |
| bool | _dependenceAnalysed |
| int | _algoState |
| int | _computeState |
| SMESH_ComputeErrorPtr | _computeError |
| bool | _alwaysComputed |
Definition at line 61 of file SMESH_subMesh.hxx.
| ADD_HYP | |
| ADD_ALGO | |
| REMOVE_HYP | |
| REMOVE_ALGO | |
| ADD_FATHER_HYP | |
| ADD_FATHER_ALGO | |
| REMOVE_FATHER_HYP | |
| REMOVE_FATHER_ALGO | |
| MODIF_HYP |
Definition at line 98 of file SMESH_subMesh.hxx.
Definition at line 94 of file SMESH_subMesh.hxx.
{
NO_ALGO, MISSING_HYP, HYP_OK
};
| MODIF_ALGO_STATE | |
| COMPUTE | |
| CLEAN | |
| SUBMESH_COMPUTED | |
| SUBMESH_RESTORED | |
| MESH_ENTITY_REMOVED | |
| CHECK_COMPUTE_STATE |
Definition at line 106 of file SMESH_subMesh.hxx.
{
MODIF_ALGO_STATE, COMPUTE,
#ifdef WITH_SMESH_CANCEL_COMPUTE
COMPUTE_CANCELED,
#endif
CLEAN, SUBMESH_COMPUTED, SUBMESH_RESTORED,
MESH_ENTITY_REMOVED, CHECK_COMPUTE_STATE
};
Definition at line 89 of file SMESH_subMesh.hxx.
Definition at line 115 of file SMESH_subMesh.hxx.
{
ALGO_EVENT, COMPUTE_EVENT
};
| SMESH_subMesh::SMESH_subMesh | ( | int | Id, |
| SMESH_Mesh * | father, | ||
| SMESHDS_Mesh * | meshDS, | ||
| const TopoDS_Shape & | aSubShape | ||
| ) |
default constructor:
Definition at line 84 of file SMESH_subMesh.cxx.
References batchmode_smesh.father, SMESH.HYP_OK, and SMESHDS_Mesh.MeshElements().
{
_subShape = aSubShape;
_subMeshDS = meshDS->MeshElements(_subShape); // may be null ...
_father = father;
_Id = Id;
_dependenceAnalysed = _alwaysComputed = false;
if (_subShape.ShapeType() == TopAbs_VERTEX)
{
_algoState = HYP_OK;
_computeState = READY_TO_COMPUTE;
}
else
{
_algoState = NO_ALGO;
_computeState = NOT_READY;
}
}
| SMESH_subMesh::~SMESH_subMesh | ( | ) | [virtual] |
Definition at line 113 of file SMESH_subMesh.cxx.
References MESSAGE.
{
MESSAGE("SMESH_subMesh::~SMESH_subMesh");
// ****
DeleteOwnListeners();
}
| SMESH_Hypothesis::Hypothesis_Status SMESH_subMesh::AlgoStateEngine | ( | int | event, |
| SMESH_Hypothesis * | anHyp | ||
| ) |
anHyp->IsAuxiliary() &&
Definition at line 568 of file SMESH_subMesh.cxx.
References SMESHDS_Mesh.AddHypothesis(), ex01_cube2build.algo, SMESH_HypoFilter.And(), SMESH_HypoFilter.AndNot(), SMESH_HypoFilter.HasType(), SMESH_Hypothesis.HYP_ALREADY_EXIST, SMESH_Hypothesis.HYP_BAD_DIM, SMESH.HYP_BAD_DIM, SMESH_Hypothesis.HYP_HIDDEN_ALGO, SMESH_Hypothesis.HYP_HIDING_ALGO, SMESH_Hypothesis.HYP_INCOMPATIBLE, SMESH.HYP_INCOMPATIBLE, SMESH_Hypothesis.HYP_NEED_SHAPE, SMESH_Hypothesis.HYP_NOTCONFORM, SMESH_Hypothesis.HYP_OK, SMESH.HYP_OK, SMESH_HypoFilter.Init(), SMESH_HypoFilter.Is(), SMESH_HypoFilter.IsAlgo(), SMESH_HypoFilter.IsApplicableTo(), SMESH_Hypothesis.IsStatusFatal(), IsSubShape(), MESSAGE, SMESH_HypoFilter.Or(), SMESHDS_Mesh.RemoveHypothesis(), and PAL_MESH_041_mesh.ret.
{
// 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
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 )
{
if ( anHyp->GetDim() != 0) {
if (event == ADD_HYP || event == ADD_ALGO)
return SMESH_Hypothesis::HYP_BAD_DIM;
else
return SMESH_Hypothesis::HYP_OK;
}
// 0D hypothesis
else if ( _algoState == HYP_OK ) {
// update default _algoState
if ( event != REMOVE_FATHER_ALGO )
{
_algoState = NO_ALGO;
algo = gen->GetAlgo(*_father, _subShape);
if ( algo ) {
_algoState = MISSING_HYP;
if ( event == REMOVE_FATHER_HYP ||
algo->CheckHypothesis(*_father,_subShape, aux_ret))
_algoState = HYP_OK;
}
}
}
}
int oldAlgoState = _algoState;
bool modifiedHyp = (event == MODIF_HYP); // if set to true, force event MODIF_ALGO_STATE
bool needFullClean = false;
bool isApplicableHyp = IsApplicableHypotesis( anHyp );
if (event == ADD_ALGO || event == ADD_FATHER_ALGO)
{
// -------------------------------------------
// check if a shape needed by algo is present
// -------------------------------------------
algo = static_cast< SMESH_Algo* >( anHyp );
if ( !_father->HasShapeToMesh() && algo->NeedShape() )
return SMESH_Hypothesis::HYP_NEED_SHAPE;
// ----------------------
// check mesh conformity
// ----------------------
if (isApplicableHyp && !_father->IsNotConformAllowed() && !IsConform( algo ))
return SMESH_Hypothesis::HYP_NOTCONFORM;
// check if all-dimensional algo is hidden by other local one
if ( event == ADD_ALGO ) {
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 ))
needFullClean = ( !curAlgo->NeedDescretBoundary() );
}
}
// ----------------------------------
// add a hypothesis to DS if possible
// ----------------------------------
if (event == ADD_HYP || event == ADD_ALGO)
{
if ( ! CanAddHypothesis( anHyp )) // check dimension
return SMESH_Hypothesis::HYP_BAD_DIM;
if ( GetSimilarAttached( _subShape, anHyp ) )
return SMESH_Hypothesis::HYP_ALREADY_EXIST;
if ( !meshDS->AddHypothesis(_subShape, anHyp))
return SMESH_Hypothesis::HYP_ALREADY_EXIST;
}
// --------------------------
// remove a hypothesis from DS
// --------------------------
if (event == REMOVE_HYP || event == REMOVE_ALGO)
{
if (!meshDS->RemoveHypothesis(_subShape, anHyp))
return SMESH_Hypothesis::HYP_OK; // nothing changes
if (event == REMOVE_ALGO)
{
algo = dynamic_cast<SMESH_Algo*> (anHyp);
if (!algo->NeedDescretBoundary())
{
// clean all mesh in the tree of the current submesh;
// we must perform it now because later
// we will have no information about the type of the removed algo
needFullClean = true;
}
}
}
// ------------------
// analyse algo state
// ------------------
if (!isApplicableHyp)
return ret; // not applicable hypotheses do not change algo state
switch (_algoState)
{
// ----------------------------------------------------------------------
case NO_ALGO:
switch (event) {
case ADD_HYP:
break;
case ADD_ALGO: {
algo = gen->GetAlgo((*_father), _subShape);
ASSERT(algo);
if (algo->CheckHypothesis((*_father),_subShape, aux_ret))
SetAlgoState(HYP_OK);
else if ( algo->IsStatusFatal( aux_ret )) {
meshDS->RemoveHypothesis(_subShape, anHyp);
ret = aux_ret;
}
else
SetAlgoState(MISSING_HYP);
break;
}
case REMOVE_HYP:
case REMOVE_ALGO:
case ADD_FATHER_HYP:
break;
case ADD_FATHER_ALGO: { // Algo just added in father
algo = gen->GetAlgo((*_father), _subShape);
ASSERT(algo);
if ( algo == anHyp ) {
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret))
SetAlgoState(HYP_OK);
else
SetAlgoState(MISSING_HYP);
}
break;
}
case REMOVE_FATHER_HYP:
break;
case REMOVE_FATHER_ALGO: {
algo = gen->GetAlgo((*_father), _subShape);
if (algo)
{
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
SetAlgoState(HYP_OK);
else
SetAlgoState(MISSING_HYP);
}
break;
}
case MODIF_HYP: break;
default:
ASSERT(0);
break;
}
break;
// ----------------------------------------------------------------------
case MISSING_HYP:
switch (event)
{
case ADD_HYP: {
algo = gen->GetAlgo((*_father), _subShape);
ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, ret ))
SetAlgoState(HYP_OK);
if (SMESH_Hypothesis::IsStatusFatal( ret ))
meshDS->RemoveHypothesis(_subShape, anHyp);
else if (!_father->IsUsedHypothesis( anHyp, this ))
{
meshDS->RemoveHypothesis(_subShape, anHyp);
ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
}
break;
}
case ADD_ALGO: { //already existing algo : on father ?
algo = gen->GetAlgo((*_father), _subShape);
ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))// ignore hyp status
SetAlgoState(HYP_OK);
else if ( algo->IsStatusFatal( aux_ret )) {
meshDS->RemoveHypothesis(_subShape, anHyp);
ret = aux_ret;
}
else
SetAlgoState(MISSING_HYP);
break;
}
case REMOVE_HYP:
break;
case REMOVE_ALGO: { // perhaps a father algo applies ?
algo = gen->GetAlgo((*_father), _subShape);
if (algo == NULL) // no more algo applying on subShape...
{
SetAlgoState(NO_ALGO);
}
else
{
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
SetAlgoState(HYP_OK);
else
SetAlgoState(MISSING_HYP);
}
break;
}
case MODIF_HYP: // assigned hypothesis value may become good
case ADD_FATHER_HYP: {
algo = gen->GetAlgo((*_father), _subShape);
ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
SetAlgoState(HYP_OK);
else
SetAlgoState(MISSING_HYP);
break;
}
case ADD_FATHER_ALGO: { // new father algo
algo = gen->GetAlgo((*_father), _subShape);
ASSERT( algo );
if ( algo == anHyp ) {
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
SetAlgoState(HYP_OK);
else
SetAlgoState(MISSING_HYP);
}
break;
}
case REMOVE_FATHER_HYP: // nothing to do
break;
case REMOVE_FATHER_ALGO: {
algo = gen->GetAlgo((*_father), _subShape);
if (algo == NULL) // no more applying algo on father
{
SetAlgoState(NO_ALGO);
}
else
{
if ( algo->CheckHypothesis((*_father),_subShape , aux_ret ))
SetAlgoState(HYP_OK);
else
SetAlgoState(MISSING_HYP);
}
break;
}
default:
ASSERT(0);
break;
}
break;
// ----------------------------------------------------------------------
case HYP_OK:
switch (event)
{
case ADD_HYP: {
algo = gen->GetAlgo((*_father), _subShape);
ASSERT(algo);
if (!algo->CheckHypothesis((*_father),_subShape, ret ))
{
if ( !SMESH_Hypothesis::IsStatusFatal( ret ))
// ret should be fatal: anHyp was not added
ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
}
else if (!_father->IsUsedHypothesis( anHyp, this ))
ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
if (SMESH_Hypothesis::IsStatusFatal( ret ))
{
MESSAGE("do not add extra hypothesis");
meshDS->RemoveHypothesis(_subShape, anHyp);
}
else
{
modifiedHyp = true;
}
break;
}
case ADD_ALGO: { //already existing algo : on father ?
algo = gen->GetAlgo((*_father), _subShape);
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);
break;
}
case REMOVE_HYP: {
algo = gen->GetAlgo((*_father), _subShape);
ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
SetAlgoState(HYP_OK);
else
SetAlgoState(MISSING_HYP);
modifiedHyp = true;
break;
}
case REMOVE_ALGO: { // perhaps a father algo applies ?
algo = gen->GetAlgo((*_father), _subShape);
if (algo == NULL) // no more algo applying on subShape...
{
SetAlgoState(NO_ALGO);
}
else
{
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);
}
break;
}
case MODIF_HYP: // hypothesis value may become bad
case ADD_FATHER_HYP: { // new father hypothesis ?
algo = gen->GetAlgo((*_father), _subShape);
ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
{
if (_father->IsUsedHypothesis( anHyp, this )) // new Hyp
modifiedHyp = true;
}
else
SetAlgoState(MISSING_HYP);
break;
}
case ADD_FATHER_ALGO: {
algo = gen->GetAlgo((*_father), _subShape);
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);
}
break;
}
case REMOVE_FATHER_HYP: {
algo = gen->GetAlgo((*_father), _subShape);
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 ) )
modifiedHyp = true;
}
else
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<SMESH_Algo*> (anHyp);
if (!algo->NeedDescretBoundary())
needFullClean = true;
algo = gen->GetAlgo((*_father), _subShape);
if (algo == NULL) // no more applying algo on father
{
SetAlgoState(NO_ALGO);
}
else
{
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
// check if algo changes
if ( string(algo->GetName()) != string( anHyp->GetName()) )
modifiedHyp = true;
}
else
SetAlgoState(MISSING_HYP);
}
break;
}
default:
ASSERT(0);
break;
}
break;
// ----------------------------------------------------------------------
default:
ASSERT(0);
break;
}
// detect algorithm hiding
//
if ( ret == SMESH_Hypothesis::HYP_OK &&
( event == ADD_ALGO || event == ADD_FATHER_ALGO ) &&
algo->GetName() == anHyp->GetName() )
{
// is algo hidden?
SMESH_Gen* gen = _father->GetGen();
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())
ret = SMESH_Hypothesis::HYP_HIDDEN_ALGO;
}
// is algo hiding?
if ( ret == SMESH_Hypothesis::HYP_OK &&
!algo->NeedDescretBoundary() &&
!algo->SupportSubmeshes()) {
TopoDS_Shape algoAssignedTo, otherAssignedTo;
gen->GetAlgo( *_father, _subShape, &algoAssignedTo );
map<int, SMESH_subMesh*>::reverse_iterator i_sm = _mapDepend.rbegin();
for ( ; ( ret == SMESH_Hypothesis::HYP_OK && i_sm != _mapDepend.rend()) ; ++i_sm )
if ( gen->GetAlgo( *_father, i_sm->second->_subShape, &otherAssignedTo ) &&
SMESH_MesherHelper::IsSubShape( /*sub=*/otherAssignedTo, /*main=*/algoAssignedTo ))
ret = SMESH_Hypothesis::HYP_HIDING_ALGO;
}
}
bool stateChange = ( _algoState != oldAlgoState );
if ( stateChange && _algoState == HYP_OK ) // hyp becomes OK
algo->SetEventListener( this );
NotifyListenersOnEvent( event, ALGO_EVENT, anHyp );
if ( stateChange && oldAlgoState == HYP_OK ) { // hyp becomes KO
DeleteOwnListeners();
SetIsAlwaysComputed( false );
if (_subShape.ShapeType() == TopAbs_VERTEX ) {
// restore default states
_algoState = HYP_OK;
_computeState = READY_TO_COMPUTE;
}
}
if ( needFullClean ) {
// added or removed algo is all-dimensional
ComputeStateEngine( CLEAN );
CleanDependsOn();
ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
}
if (stateChange || modifiedHyp)
ComputeStateEngine(MODIF_ALGO_STATE);
return ret;
}
| bool SMESH_subMesh::ApplyToCollection | ( | SMESH_Algo * | theAlgo, |
| const TopoDS_Shape & | theCollection | ||
| ) | [protected] |
Apply theAlgo to all subshapes in theCollection.
Definition at line 1754 of file SMESH_subMesh.cxx.
References COMPERR_ALGO_FAILED, COMPERR_OK, MESSAGE, and SMESH_ComputeError.New().
{
MESSAGE("SMESH_subMesh::ApplyToCollection");
ASSERT ( !theAlgo->NeedDescretBoundary() );
if ( _computeError )
_computeError->myName = COMPERR_OK;
bool ok = theAlgo->Compute( *_father, theCollection );
// set _computeState of subshapes
TopExp_Explorer anExplorer( theCollection, _subShape.ShapeType() );
for ( ; anExplorer.More(); anExplorer.Next() )
{
if ( SMESH_subMesh* subMesh = _father->GetSubMeshContaining( anExplorer.Current() ))
{
bool localOK = subMesh->CheckComputeError( theAlgo );
if ( !ok && localOK && !subMesh->IsMeshComputed() )
{
subMesh->_computeError = theAlgo->GetComputeError();
if ( subMesh->_computeError->IsOK() )
_computeError = SMESH_ComputeError::New(COMPERR_ALGO_FAILED);
localOK = CheckComputeError( theAlgo );
}
if ( localOK )
subMesh->UpdateDependantsState( SUBMESH_COMPUTED );
subMesh->UpdateSubMeshState( localOK ? COMPUTE_OK : FAILED_TO_COMPUTE );
}
}
return true;
}
| bool SMESH_subMesh::CanAddHypothesis | ( | const SMESH_Hypothesis * | theHypothesis | ) | const |
Definition at line 508 of file SMESH_subMesh.cxx.
References SMESH_Gen.GetShapeDim().
{
int aHypDim = theHypothesis->GetDim();
int aShapeDim = SMESH_Gen::GetShapeDim(_subShape);
if (aHypDim == 3 && aShapeDim == 3) {
// check case of open shell
//if (_subShape.ShapeType() == TopAbs_SHELL && !_subShape.Closed())
if (_subShape.ShapeType() == TopAbs_SHELL && !BRep_Tool::IsClosed(_subShape))
return false;
}
if ( aHypDim <= aShapeDim )
return true;
return false;
}
| bool SMESH_subMesh::CheckComputeError | ( | SMESH_Algo * | theAlgo, |
| const TopoDS_Shape & | theShape = TopoDS_Shape() |
||
| ) | [protected] |
Update compute_state by _computeError.
Update compute_state by _computeError and send proper events to dependent submeshes.
| bool | - false if there are errors |
| bool | - true if _computeError is NOT set |
Definition at line 1689 of file SMESH_subMesh.cxx.
{
bool noErrors = true;
if ( !theShape.IsNull() )
{
// Check state of submeshes
if ( !theAlgo->NeedDescretBoundary())
{
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() )
if ( !smIt->next()->CheckComputeError( theAlgo ))
noErrors = false;
}
// Check state of neighbours
if ( !theAlgo->OnlyUnaryInput() &&
theShape.ShapeType() == TopAbs_COMPOUND &&
!theShape.IsSame( _subShape ))
{
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() ))
noErrors = false;
UpdateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
}
}
}
}
{
// Check my state
if ( !_computeError || _computeError->IsOK() )
{
_computeState = IsMeshComputed() ? COMPUTE_OK : FAILED_TO_COMPUTE;
}
else
{
if ( !_computeError->myAlgo )
_computeError->myAlgo = theAlgo;
// Show error
SMESH_Comment text;
text << theAlgo->GetName() << " failed on subshape #" << _Id << " with error ";
if (_computeError->IsCommon() )
text << _computeError->CommonName();
else
text << _computeError->myName;
if ( _computeError->myComment.size() > 0 )
text << " \"" << _computeError->myComment << "\"";
INFOS( text );
_computeState = FAILED_TO_COMPUTE;
noErrors = false;
}
}
return noErrors;
}
| SMESH_Hypothesis::Hypothesis_Status SMESH_subMesh::CheckConcurentHypothesis | ( | const int | theHypType | ) |
Definition at line 1976 of file SMESH_subMesh.cxx.
References SMESH_demo_hexa2_upd.hyp, SMESH_Hypothesis.HYP_CONCURENT, SMESH.HYP_OK, and MESSAGE.
{
MESSAGE ("SMESH_subMesh::CheckConcurentHypothesis");
// is there local hypothesis on me?
if ( GetSimilarAttached( _subShape, 0, theHypType ) )
return SMESH_Hypothesis::HYP_OK;
TopoDS_Shape aPrevWithHyp;
const SMESH_Hypothesis* aPrevHyp = 0;
TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
for (; it.More(); it.Next())
{
const TopoDS_Shape& ancestor = it.Value();
const SMESH_Hypothesis* hyp = GetSimilarAttached( ancestor, 0, theHypType );
if ( hyp )
{
if ( aPrevWithHyp.IsNull() || aPrevWithHyp.IsSame( ancestor ))
{
aPrevWithHyp = ancestor;
aPrevHyp = hyp;
}
else if ( aPrevWithHyp.ShapeType() == ancestor.ShapeType() && aPrevHyp != hyp )
return SMESH_Hypothesis::HYP_CONCURENT;
else
return SMESH_Hypothesis::HYP_OK;
}
}
return SMESH_Hypothesis::HYP_OK;
}
| void SMESH_subMesh::CleanDependants | ( | ) | [protected] |
Definition at line 1838 of file SMESH_subMesh.cxx.
References SMESH_Gen.GetShapeDim().
{
int dimToClean = SMESH_Gen::GetShapeDim( _subShape ) + 1;
TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
for (; it.More(); it.Next())
{
const TopoDS_Shape& ancestor = it.Value();
if ( SMESH_Gen::GetShapeDim( ancestor ) == dimToClean ) {
// PAL8021. do not go upper than SOLID, else ComputeStateEngine(CLEAN)
// will erase mesh on other shapes in a compound
if ( ancestor.ShapeType() >= TopAbs_SOLID ) {
SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor);
if (aSubMesh)
aSubMesh->ComputeStateEngine(CLEAN);
}
}
}
}
| void SMESH_subMesh::CleanDependsOn | ( | ) | [protected] |
Definition at line 1138 of file SMESH_subMesh.cxx.
{
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() )
smIt->next()->ComputeStateEngine(CLEAN);
}
Definition at line 1236 of file SMESH_subMesh.cxx.
References ex01_cube2build.algo, SMDS_Mesh.CheckMemory(), cleanSubMesh(), COMPERR_ALGO_FAILED, COMPERR_BAD_INPUT_MESH, COMPERR_EXCEPTION, COMPERR_MEMORY_PB, COMPERR_OCC_EXCEPTION, COMPERR_OK, COMPERR_SLM_EXCEPTION, COMPERR_STD_EXCEPTION, SMESH.HYP_OK, MESSAGE, SMESHDS_SubMesh.NbNodes(), SMESH_ComputeError.New(), PAL_MESH_041_mesh.ret, SMESH_MesherHelper.SetElementsOnShape(), SMESH_MesherHelper.SetSubShape(), and SMESH_fixation.shape.
{
_computeError.reset();
//MESSAGE("SMESH_subMesh::ComputeStateEngine");
//SCRUTE(_computeState);
//SCRUTE(event);
if (_subShape.ShapeType() == TopAbs_VERTEX)
{
_computeState = READY_TO_COMPUTE;
SMESHDS_SubMesh* smDS = GetSubMeshDS();
if ( smDS && smDS->NbNodes() ) {
if ( event == CLEAN ) {
CleanDependants();
cleanSubMesh( this );
}
else
_computeState = COMPUTE_OK;
}
else if ( event == COMPUTE && !_alwaysComputed ) {
const TopoDS_Vertex & V = TopoDS::Vertex( _subShape );
gp_Pnt P = BRep_Tool::Pnt(V);
if ( SMDS_MeshNode * n = _father->GetMeshDS()->AddNode(P.X(), P.Y(), P.Z()) ) {
_father->GetMeshDS()->SetNodeOnVertex(n,_Id);
_computeState = COMPUTE_OK;
}
}
if ( event == MODIF_ALGO_STATE )
CleanDependants();
return true;
}
SMESH_Gen *gen = _father->GetGen();
SMESH_Algo *algo = 0;
bool ret = true;
SMESH_Hypothesis::Hypothesis_Status hyp_status;
//algo_state oldAlgoState = (algo_state) GetAlgoState();
switch (_computeState)
{
// ----------------------------------------------------------------------
case NOT_READY:
switch (event)
{
case MODIF_ALGO_STATE:
algo = gen->GetAlgo((*_father), _subShape);
if (algo && !algo->NeedDescretBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE;
break;
case COMPUTE: // nothing to do
break;
#ifdef WITH_SMESH_CANCEL_COMPUTE
case COMPUTE_CANCELED: // nothing to do
break;
#endif
case CLEAN:
CleanDependants();
RemoveSubMeshElementsAndNodes();
break;
case SUBMESH_COMPUTED: // nothing to do
break;
case SUBMESH_RESTORED:
ComputeSubMeshStateEngine( SUBMESH_RESTORED );
break;
case MESH_ENTITY_REMOVED:
break;
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
break;
default:
ASSERT(0);
break;
}
break;
// ----------------------------------------------------------------------
case READY_TO_COMPUTE:
switch (event)
{
case MODIF_ALGO_STATE:
_computeState = NOT_READY;
algo = gen->GetAlgo((*_father), _subShape);
if (algo)
{
if (!algo->NeedDescretBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE;
}
break;
case COMPUTE:
{
algo = gen->GetAlgo((*_father), _subShape);
ASSERT(algo);
ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
if (!ret)
{
MESSAGE("***** verify compute state *****");
_computeState = NOT_READY;
SetAlgoState(MISSING_HYP);
break;
}
TopoDS_Shape shape = _subShape;
// check submeshes needed
if (_father->HasShapeToMesh() ) {
bool subComputed = false;
if (!algo->OnlyUnaryInput())
shape = GetCollection( gen, algo, subComputed );
else
subComputed = SubMeshesComputed();
ret = ( algo->NeedDescretBoundary() ? subComputed :
algo->SupportSubmeshes() ? true :
( !subComputed || _father->IsNotConformAllowed() ));
if (!ret) {
_computeState = FAILED_TO_COMPUTE;
if ( !algo->NeedDescretBoundary() )
_computeError =
SMESH_ComputeError::New(COMPERR_BAD_INPUT_MESH,
"Unexpected computed submesh",algo);
break;
}
}
// compute
// CleanDependants(); for "UseExisting_*D" algos
// RemoveSubMeshElementsAndNodes();
ret = false;
_computeState = FAILED_TO_COMPUTE;
_computeError = SMESH_ComputeError::New(COMPERR_OK,"",algo);
try {
#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
#endif
algo->InitComputeError();
MemoryReserve aMemoryReserve;
SMDS_Mesh::CheckMemory();
Kernel_Utils::Localizer loc;
if ( !_father->HasShapeToMesh() ) // no shape
{
SMESH_MesherHelper helper( *_father );
helper.SetSubShape( shape );
helper.SetElementsOnShape( true );
ret = algo->Compute(*_father, &helper );
}
else
{
ret = algo->Compute((*_father), shape);
}
if ( !_computeError || ( !ret && _computeError->IsOK() ) ) // algo can set _computeError of submesh
_computeError = algo->GetComputeError();
}
catch ( std::bad_alloc& exc ) {
MESSAGE("std::bad_alloc thrown inside algo->Compute()");
if ( _computeError ) {
_computeError->myName = COMPERR_MEMORY_PB;
//_computeError->myComment = exc.what();
}
cleanSubMesh( this );
throw exc;
}
catch ( Standard_OutOfMemory& exc ) {
MESSAGE("Standard_OutOfMemory thrown inside algo->Compute()");
if ( _computeError ) {
_computeError->myName = COMPERR_MEMORY_PB;
//_computeError->myComment = exc.what();
}
cleanSubMesh( this );
throw std::bad_alloc();
}
catch (Standard_Failure& ex) {
if ( !_computeError ) _computeError = SMESH_ComputeError::New();
_computeError->myName = COMPERR_OCC_EXCEPTION;
_computeError->myComment += ex.DynamicType()->Name();
if ( ex.GetMessageString() && strlen( ex.GetMessageString() )) {
_computeError->myComment += ": ";
_computeError->myComment += ex.GetMessageString();
}
}
catch ( SALOME_Exception& S_ex ) {
if ( !_computeError ) _computeError = SMESH_ComputeError::New();
_computeError->myName = COMPERR_SLM_EXCEPTION;
_computeError->myComment = S_ex.what();
}
catch ( std::exception& exc ) {
if ( !_computeError ) _computeError = SMESH_ComputeError::New();
_computeError->myName = COMPERR_STD_EXCEPTION;
_computeError->myComment = exc.what();
}
catch ( ... ) {
if ( _computeError )
_computeError->myName = COMPERR_EXCEPTION;
else
ret = false;
}
TopExp_Explorer subS(shape, _subShape.ShapeType());
if (ret) // check if anything was built
{
for (; ret && subS.More(); subS.Next())
ret = _father->GetSubMesh( subS.Current() )->IsMeshComputed();
}
bool isComputeErrorSet = !CheckComputeError( algo, shape );
if (!ret && !isComputeErrorSet)
{
// Set _computeError
for (subS.ReInit(); subS.More(); subS.Next())
{
SMESH_subMesh* sm = _father->GetSubMesh( subS.Current() );
if ( !sm->IsMeshComputed() )
{
if ( !sm->_computeError )
sm->_computeError = SMESH_ComputeError::New();
if ( sm->_computeError->IsOK() )
sm->_computeError->myName = COMPERR_ALGO_FAILED;
sm->_computeState = FAILED_TO_COMPUTE;
sm->_computeError->myAlgo = algo;
}
}
}
if (ret)
{
_computeError.reset();
}
UpdateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
}
break;
#ifdef WITH_SMESH_CANCEL_COMPUTE
case COMPUTE_CANCELED: // nothing to do
break;
#endif
case CLEAN:
CleanDependants();
RemoveSubMeshElementsAndNodes();
_computeState = NOT_READY;
algo = gen->GetAlgo((*_father), _subShape);
if (algo)
{
ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
if (ret)
_computeState = READY_TO_COMPUTE;
else
SetAlgoState(MISSING_HYP);
}
break;
case SUBMESH_COMPUTED: // nothing to do
break;
case SUBMESH_RESTORED:
// check if a mesh is already computed that may
// happen after retrieval from a file
ComputeStateEngine( CHECK_COMPUTE_STATE );
ComputeSubMeshStateEngine( SUBMESH_RESTORED );
algo = gen->GetAlgo(*_father, _subShape);
if (algo) algo->SubmeshRestored( this );
break;
case MESH_ENTITY_REMOVED:
break;
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
break;
default:
ASSERT(0);
break;
}
break;
// ----------------------------------------------------------------------
case COMPUTE_OK:
switch (event)
{
case MODIF_ALGO_STATE:
ComputeStateEngine( CLEAN );
algo = gen->GetAlgo((*_father), _subShape);
if (algo && !algo->NeedDescretBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN
break;
case COMPUTE: // nothing to do
break;
#ifdef WITH_SMESH_CANCEL_COMPUTE
case COMPUTE_CANCELED: // nothing to do
break;
#endif
case CLEAN:
CleanDependants(); // clean sub-meshes, dependant on this one, with event CLEAN
RemoveSubMeshElementsAndNodes();
_computeState = NOT_READY;
if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE;
break;
case SUBMESH_COMPUTED: // nothing to do
break;
case SUBMESH_RESTORED:
ComputeStateEngine( CHECK_COMPUTE_STATE );
ComputeSubMeshStateEngine( SUBMESH_RESTORED );
algo = gen->GetAlgo(*_father, _subShape);
if (algo) algo->SubmeshRestored( this );
break;
case MESH_ENTITY_REMOVED:
UpdateDependantsState( CHECK_COMPUTE_STATE );
ComputeStateEngine( CHECK_COMPUTE_STATE );
ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
break;
case CHECK_COMPUTE_STATE:
if ( !IsMeshComputed() ) {
if (_algoState == HYP_OK)
_computeState = READY_TO_COMPUTE;
else
_computeState = NOT_READY;
}
break;
default:
ASSERT(0);
break;
}
break;
// ----------------------------------------------------------------------
case FAILED_TO_COMPUTE:
switch (event)
{
case MODIF_ALGO_STATE:
if ( !IsEmpty() )
ComputeStateEngine( CLEAN );
algo = gen->GetAlgo((*_father), _subShape);
if (algo && !algo->NeedDescretBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN
if (_algoState == HYP_OK)
_computeState = READY_TO_COMPUTE;
else
_computeState = NOT_READY;
break;
case COMPUTE: // nothing to do
break;
#ifdef WITH_SMESH_CANCEL_COMPUTE
case COMPUTE_CANCELED:
{
algo = gen->GetAlgo((*_father), _subShape);
algo->CancelCompute();
}
break;
#endif
case CLEAN:
CleanDependants(); // submeshes dependent on me should be cleaned as well
RemoveSubMeshElementsAndNodes();
break;
case SUBMESH_COMPUTED: // allow retry compute
if (_algoState == HYP_OK)
_computeState = READY_TO_COMPUTE;
else
_computeState = NOT_READY;
break;
case SUBMESH_RESTORED:
ComputeSubMeshStateEngine( SUBMESH_RESTORED );
break;
case MESH_ENTITY_REMOVED:
break;
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
else
if (_algoState == HYP_OK)
_computeState = READY_TO_COMPUTE;
else
_computeState = NOT_READY;
break;
default:
ASSERT(0);
break;
}
break;
// ----------------------------------------------------------------------
default:
ASSERT(0);
break;
}
NotifyListenersOnEvent( event, COMPUTE_EVENT );
return ret;
}
| void SMESH_subMesh::ComputeSubMeshStateEngine | ( | int | event | ) |
Definition at line 1806 of file SMESH_subMesh.cxx.
{
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() )
smIt->next()->ComputeStateEngine(event);
}
| SMESHDS_SubMesh * SMESH_subMesh::CreateSubMeshDS | ( | ) |
Definition at line 150 of file SMESH_subMesh.cxx.
References SMESHDS_Mesh.NewSubMesh(), and SMESHDS_Mesh.ShapeToIndex().
{
if ( !GetSubMeshDS() ) {
SMESHDS_Mesh* meshDS = _father->GetMeshDS();
meshDS->NewSubMesh( meshDS->ShapeToIndex( _subShape ) );
}
return GetSubMeshDS();
}
| void SMESH_subMesh::DeleteEventListener | ( | EventListener * | listener | ) |
Unregister the listener and delete it and it's data.
Unregister the listener and delete listener's data.
| listener | - the event listener to delete |
| listener | - the event listener |
Definition at line 2103 of file SMESH_subMesh.cxx.
References SMESH.if().
{
map< EventListener*, EventListenerData* >::iterator l_d =
myEventListeners.find( listener );
if ( l_d != myEventListeners.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 );
}
}
| void SMESH_subMesh::DeleteOwnListeners | ( | ) | [protected] |
Delete event listeners depending on algo of this submesh.
Definition at line 2120 of file SMESH_subMesh.cxx.
{
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();
}
| const map< int, SMESH_subMesh * > & SMESH_subMesh::DependsOn | ( | ) |
Construct dependence on first level subMeshes.
complex shapes (compsolid, shell, wire) are not analysed the same way as simple shapes (solid, face, edge). For collection shapes (compsolid, shell, wire) prepare a list of submeshes with possible multiples occurences. Multiples occurences corresponds to internal frontiers within shapes of the collection and must not be keeped. See FinalizeDependence.
Definition at line 361 of file SMESH_subMesh.cxx.
{
if (_dependenceAnalysed)
return _mapDepend;
//MESSAGE("SMESH_subMesh::DependsOn");
int type = _subShape.ShapeType();
//SCRUTE(type);
switch (type)
{
case TopAbs_COMPOUND:
{
//MESSAGE("compound");
for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More();exp.Next())
{
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
else
for (TopExp_Explorer expF(exp.Current(), TopAbs_FACE); expF.More();expF.Next())
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());
}
for (TopExp_Explorer exp(_subShape, TopAbs_EDGE, TopAbs_FACE); exp.More();exp.Next())
{
InsertDependence(exp.Current());
}
break;
}
case TopAbs_COMPSOLID:
{
//MESSAGE("compsolid");
for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More(); exp.Next())
{
InsertDependence(exp.Current());
}
break;
}
case TopAbs_SHELL:
{
//MESSAGE("shell");
for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More(); exp.Next())
{
InsertDependence(exp.Current());
}
break;
}
case TopAbs_WIRE:
{
//MESSAGE("wire");
for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More(); exp.Next())
{
InsertDependence(exp.Current());
}
break;
}
case TopAbs_SOLID:
{
//MESSAGE("solid");
if(_father->HasShapeToMesh()) {
for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More();exp.Next())
{
InsertDependence(exp.Current());
}
}
break;
}
case TopAbs_FACE:
{
//MESSAGE("face");
for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More();exp.Next())
{
InsertDependence(exp.Current());
}
break;
}
case TopAbs_EDGE:
{
//MESSAGE("edge");
for (TopExp_Explorer exp(_subShape, TopAbs_VERTEX); exp.More(); exp.Next())
{
InsertDependence(exp.Current());
}
break;
}
case TopAbs_VERTEX:
{
break;
}
default:
{
break;
}
}
_dependenceAnalysed = true;
return _mapDepend;
}
| void SMESH_subMesh::DumpAlgoState | ( | bool | isMain | ) |
Definition at line 1151 of file SMESH_subMesh.cxx.
References SMESH_Gen.GetShapeDim(), SMESH.HYP_OK, and MESSAGE.
{
int dim = SMESH_Gen::GetShapeDim(_subShape);
// if (dim < 1) return;
if (isMain)
{
const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
map < int, SMESH_subMesh * >::const_iterator itsub;
for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
{
SMESH_subMesh *sm = (*itsub).second;
sm->DumpAlgoState(false);
}
}
int type = _subShape.ShapeType();
MESSAGE("dim = " << dim << " type of shape " << type);
switch (_algoState)
{
case NO_ALGO:
MESSAGE(" AlgoState = NO_ALGO");
break;
case MISSING_HYP:
MESSAGE(" AlgoState = MISSING_HYP");
break;
case HYP_OK:
MESSAGE(" AlgoState = HYP_OK");
break;
}
switch (_computeState)
{
case NOT_READY:
MESSAGE(" ComputeState = NOT_READY");
break;
case READY_TO_COMPUTE:
MESSAGE(" ComputeState = READY_TO_COMPUTE");
break;
case COMPUTE_OK:
MESSAGE(" ComputeState = COMPUTE_OK");
break;
case FAILED_TO_COMPUTE:
MESSAGE(" ComputeState = FAILED_TO_COMPUTE");
break;
}
}
| bool SMESH_subMesh.Evaluate | ( | MapShapeNbElems & | aResMap | ) |
| bool SMESH_subMesh.FindIntersection | ( | const SMESH_subMesh * | theOther, |
| std::set< const SMESH_subMesh * > & | theSetOfCommon | ||
| ) | const |
Find common submeshes (based on shared subshapes with other.
| theOther | submesh to check |
| theCommonIds | set of common submesh IDs NOTE: this method does not cleat set before collect common IDs |
| int SMESH_subMesh.GetAlgoState | ( | ) | const |
Definition at line 192 of file SMESH_subMesh.hxx.
{ return _algoState; }
| TopoDS_Shape SMESH_subMesh::GetCollection | ( | SMESH_Gen * | theGen, |
| SMESH_Algo * | theAlgo, | ||
| bool & | theSubComputed | ||
| ) | [protected] |
Return a shape containing all sub-shapes of the MainShape that can be meshed at once along with _subShape.
Definition at line 1893 of file SMESH_subMesh.cxx.
References MESSAGE.
{
MESSAGE("SMESH_subMesh::GetCollection");
theSubComputed = SubMeshesComputed();
TopoDS_Shape mainShape = _father->GetMeshDS()->ShapeToMesh();
if ( mainShape.IsSame( _subShape ))
return _subShape;
const bool ignoreAuxiliaryHyps = false;
list<const SMESHDS_Hypothesis*> aUsedHyp =
theAlgo->GetUsedHypothesis( *_father, _subShape, ignoreAuxiliaryHyps ); // copy
// put in a compound all shapes with the same hypothesis assigned
// and a good ComputState
TopoDS_Compound aCompound;
BRep_Builder aBuilder;
aBuilder.MakeCompound( aCompound );
TopExp_Explorer anExplorer( mainShape, _subShape.ShapeType() );
for ( ; anExplorer.More(); anExplorer.Next() )
{
const TopoDS_Shape& S = anExplorer.Current();
SMESH_subMesh* subMesh = _father->GetSubMesh( S );
if ( subMesh == this )
{
aBuilder.Add( aCompound, S );
}
else if ( subMesh->GetComputeState() == READY_TO_COMPUTE )
{
SMESH_Algo* anAlgo = theGen->GetAlgo( *_father, S );
if (strcmp( anAlgo->GetName(), theAlgo->GetName()) == 0 && // same algo
anAlgo->GetUsedHypothesis( *_father, S, ignoreAuxiliaryHyps ) == aUsedHyp) // same hyps
aBuilder.Add( aCompound, S );
if ( !subMesh->SubMeshesComputed() )
theSubComputed = false;
}
}
return aCompound;
}
| SMESH_ComputeErrorPtr& SMESH_subMesh.GetComputeError | ( | ) |
Definition at line 194 of file SMESH_subMesh.hxx.
{ return _computeError; }
| int SMESH_subMesh.GetComputeState | ( | ) | const |
Definition at line 193 of file SMESH_subMesh.hxx.
{ return _computeState; };
| SMESH_subMeshIteratorPtr SMESH_subMesh::getDependsOnIterator | ( | const bool | includeSelf, |
| const bool | reverse | ||
| ) |
Return iterator on the submeshes this one depends on.
| includeSelf | - this submesh to be returned also |
| reverse | - if true, complex shape submeshes go first |
Definition at line 2217 of file SMESH_subMesh.cxx.
{
SMESH_subMesh *prepend=0, *append=0;
if ( includeSelf ) {
if ( reverse ) prepend = this;
else append = this;
}
typedef map < int, SMESH_subMesh * > TMap;
if ( reverse )
{
return SMESH_subMeshIteratorPtr
( new _Iterator( new SMDS_mapReverseIterator<TMap>( DependsOn() ), prepend, append ));
}
{
return SMESH_subMeshIteratorPtr
( new _Iterator( new SMDS_mapIterator<TMap>( DependsOn() ), prepend, append ));
}
}
| EventListenerData * SMESH_subMesh::GetEventListenerData | ( | EventListener * | listener | ) | const |
Return an event listener data.
| listener | - the listener whose data is |
| EventListenerData* | - found data, maybe NULL |
Definition at line 2065 of file SMESH_subMesh.cxx.
{
map< EventListener*, EventListenerData* >::const_iterator l_d =
myEventListeners.find( listener );
if ( l_d != myEventListeners.end() )
return l_d->second;
return 0;
}
| SMESH_Mesh* SMESH_subMesh.GetFather | ( | ) |
Definition at line 70 of file SMESH_subMesh.hxx.
{ return _father; }
| SMESH_subMesh * SMESH_subMesh::GetFirstToCompute | ( | ) |
Definition at line 165 of file SMESH_subMesh.cxx.
{
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(true,false);
while ( smIt->more() ) {
SMESH_subMesh *sm = smIt->next();
if ( sm->GetComputeState() == READY_TO_COMPUTE )
return sm;
}
return 0; // nothing to compute
}
| int SMESH_subMesh.GetId | ( | ) | const |
| const SMESH_Hypothesis * SMESH_subMesh::GetSimilarAttached | ( | const TopoDS_Shape & | theShape, |
| const SMESH_Hypothesis * | theHyp, | ||
| const int | theHypType = 0 |
||
| ) | [protected] |
Return a hypothesis attached to theShape.
If theHyp is provided, similar but not same hypotheses is returned; else an applicable ones having theHypType is returned
Definition at line 1948 of file SMESH_subMesh.cxx.
References SMESH_HypoFilter.And(), SMESH_HypoFilter.AndNot(), SMESH_HypoFilter.HasDim(), SMESH_HypoFilter.HasName(), SMESH_HypoFilter.HasType(), SMESH_HypoFilter.Init(), SMESH_HypoFilter.Is(), SMESH_HypoFilter.IsApplicableTo(), and SMESH_HypoFilter.IsAuxiliary().
{
SMESH_HypoFilter hypoKind;
hypoKind.Init( hypoKind.HasType( theHyp ? theHyp->GetType() : theHypType ));
if ( theHyp ) {
hypoKind.And ( hypoKind.HasDim( theHyp->GetDim() ));
hypoKind.AndNot( hypoKind.Is( theHyp ));
if ( theHyp->IsAuxiliary() )
hypoKind.And( hypoKind.HasName( theHyp->GetName() ));
else
hypoKind.AndNot( hypoKind.IsAuxiliary());
}
else {
hypoKind.And( hypoKind.IsApplicableTo( theShape ));
}
return _father->GetHypothesis( theShape, hypoKind, false );
}
| SMESHDS_SubMesh * SMESH_subMesh::GetSubMeshDS | ( | ) |
Definition at line 138 of file SMESH_subMesh.cxx.
Referenced by StdMeshers_Projection_3D.Compute(), StdMeshers_Projection_3D.Evaluate(), _FaceSide.GetNbSegments(), and _QuadFaceGrid.LoadGrid().
{
// submesh appears in DS only when a mesher set nodes and elements on a shape
return _subMeshDS ? _subMeshDS : _subMeshDS = _father->GetMeshDS()->MeshElements(_subShape); // may be null
}
| const TopoDS_Shape& SMESH_subMesh.GetSubShape | ( | ) | const |
| void SMESH_subMesh::InsertDependence | ( | const TopoDS_Shape | aSubShape | ) | [protected] |
For simple Shapes (solid, face, edge): add subMesh into dependence list.
Definition at line 473 of file SMESH_subMesh.cxx.
{
//MESSAGE("SMESH_subMesh::InsertDependence");
SMESH_subMesh *aSubMesh = _father->GetSubMesh(aSubShape);
int type = aSubShape.ShapeType();
int ordType = 9 - type; // 2 = Vertex, 8 = CompSolid
int cle = aSubMesh->GetId();
cle += 10000000 * ordType; // sort map by ordType then index
if ( _mapDepend.find( cle ) == _mapDepend.end())
{
_mapDepend[cle] = aSubMesh;
const map < int, SMESH_subMesh * > & subMap = aSubMesh->DependsOn();
_mapDepend.insert( subMap.begin(), subMap.end() );
}
}
| bool SMESH_subMesh.IsAlwaysComputed | ( | ) |
Definition at line 234 of file SMESH_subMesh.hxx.
{ return _alwaysComputed; }
| bool SMESH_subMesh.IsApplicableHypotesis | ( | const SMESH_Hypothesis * | theHypothesis | ) | const |
Definition at line 213 of file SMESH_subMesh.hxx.
References IsApplicableHypotesis().
Referenced by IsApplicableHypotesis().
{ return IsApplicableHypotesis( theHypothesis, _subShape.ShapeType() ); }
| bool SMESH_subMesh::IsApplicableHypotesis | ( | const SMESH_Hypothesis * | theHypothesis, |
| const TopAbs_ShapeEnum | theShapeType | ||
| ) | [static] |
Definition at line 529 of file SMESH_subMesh.cxx.
References SMESH_Gen.GetShapeDim(), and SMESHDS_Hypothesis.PARAM_ALGO.
Referenced by SMESH_HypoFilter.ApplicablePredicate.IsOk().
{
if ( theHypothesis->GetType() > SMESHDS_Hypothesis::PARAM_ALGO)
// algorithm
return ( theHypothesis->GetShapeType() & (1<< theShapeType));
// hypothesis
switch ( theShapeType ) {
case TopAbs_VERTEX:
case TopAbs_EDGE:
case TopAbs_FACE:
case TopAbs_SOLID:
return SMESH_Gen::GetShapeDim( theShapeType ) == theHypothesis->GetDim();
case TopAbs_SHELL:
// Special case for algorithms, building 2D mesh on a whole shell.
// Before this fix there was a problem after restoring from study,
// because in that case algorithm is assigned before hypothesis
// (on shell in problem case) and hypothesis is checked on faces
// (because it is 2D), where we have NO_ALGO state.
// Now 2D hypothesis is also applicable to shells.
return (theHypothesis->GetDim() == 2 || theHypothesis->GetDim() == 3);
// case TopAbs_WIRE:
// case TopAbs_COMPSOLID:
// case TopAbs_COMPOUND:
default:;
}
return false;
}
| bool SMESH_subMesh::IsConform | ( | const SMESH_Algo * | theAlgo | ) |
Definition at line 1048 of file SMESH_subMesh.cxx.
References ex01_cube2build.algo.
{
// MESSAGE( "SMESH_subMesh::IsConform" );
if ( !theAlgo ) return false;
// 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
// on a sub-shape will be ignored by theAlgo
if ( theAlgo->NeedDescretBoundary() ||
!theAlgo->OnlyUnaryInput() ) // all adjacent shapes will be meshed by this algo?
return true;
SMESH_Gen* gen =_father->GetGen();
// only local algo is to be checked
//if ( gen->IsGlobalHypothesis( theAlgo, *_father ))
if ( _subShape.ShapeType() == _father->GetMeshDS()->ShapeToMesh().ShapeType() )
return true;
// check algo attached to adjacent shapes
// loop on one level down sub-meshes
TopoDS_Iterator itsub( _subShape );
for (; itsub.More(); itsub.Next())
{
// loop on adjacent subShapes
TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( itsub.Value() ));
for (; it.More(); it.Next())
{
const TopoDS_Shape& adjacent = it.Value();
if ( _subShape.IsSame( adjacent )) continue;
if ( adjacent.ShapeType() != _subShape.ShapeType())
break;
// check algo attached to smAdjacent
SMESH_Algo * algo = gen->GetAlgo((*_father), adjacent);
if (algo &&
!algo->NeedDescretBoundary() &&
algo->OnlyUnaryInput())
return false; // NOT CONFORM MESH WILL BE PRODUCED
}
}
return true;
}
| bool SMESH_subMesh.IsEmpty | ( | ) | const |
Return true if no mesh entities is bound to the submesh.
| bool SMESH_subMesh::IsMeshComputed | ( | ) | const |
Definition at line 210 of file SMESH_subMesh.cxx.
References SMESH_Gen.GetShapeDim(), and SMESHDS_Mesh.MeshElements().
Referenced by StdMeshers_Projection_3D.Compute(), and StdMeshers_Projection_3D.Evaluate().
{
if ( _alwaysComputed )
return true;
// algo may bind a submesh not to _subShape, eg 3D algo
// sets nodes on SHELL while _subShape may be SOLID
SMESHDS_Mesh* meshDS = _father->GetMeshDS();
int dim = SMESH_Gen::GetShapeDim( _subShape );
int type = _subShape.ShapeType();
for ( ; type <= TopAbs_VERTEX; type++) {
if ( dim == SMESH_Gen::GetShapeDim( (TopAbs_ShapeEnum) type ))
{
TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type );
for ( ; exp.More(); exp.Next() )
{
if ( SMESHDS_SubMesh * smDS = meshDS->MeshElements( exp.Current() ))
{
bool computed = (dim > 0) ? smDS->NbElements() : smDS->NbNodes();
if ( computed )
return true;
}
}
}
else
break;
}
return false;
}
| void SMESH_subMesh::NotifyListenersOnEvent | ( | const int | event, |
| const event_type | eventType, | ||
| SMESH_Hypothesis * | hyp = 0 |
||
| ) | [protected] |
Notify stored event listeners on the occured event.
| event | - algo_event or compute_event itself |
| eventType | - algo_event or compute_event |
| hyp | - hypothesis, if eventType is algo_event |
Definition at line 2083 of file SMESH_subMesh.cxx.
{
map< EventListener*, EventListenerData* >::iterator l_d = myEventListeners.begin();
for ( ; l_d != myEventListeners.end(); ++l_d )
if ( (*l_d).first->myBusySM.insert( this ).second )
{
l_d->first->ProcessEvent( event, eventType, this, l_d->second, hyp );
l_d->first->myBusySM.erase( this );
}
}
| void SMESH_subMesh::RemoveSubMeshElementsAndNodes | ( | ) | [protected] |
Definition at line 1864 of file SMESH_subMesh.cxx.
References cleanSubMesh(), and SMESH_Gen.GetShapeDim().
{
//SCRUTE(_subShape.ShapeType());
cleanSubMesh( this );
// algo may bind a submesh not to _subShape, eg 3D algo
// sets nodes on SHELL while _subShape may be SOLID
int dim = SMESH_Gen::GetShapeDim( _subShape );
int type = _subShape.ShapeType() + 1;
for ( ; type <= TopAbs_EDGE; type++) {
if ( dim == SMESH_Gen::GetShapeDim( (TopAbs_ShapeEnum) type ))
{
TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type );
for ( ; exp.More(); exp.Next() )
cleanSubMesh( _father->GetSubMeshContaining( exp.Current() ));
}
else
break;
}
}
| void SMESH_subMesh::SetAlgoState | ( | int | state | ) | [protected] |
Definition at line 1102 of file SMESH_subMesh.cxx.
{
_algoState = state;
}
| void SMESH_subMesh::SetEventListener | ( | EventListener * | listener, |
| EventListenerData * | data | ||
| ) | [protected] |
Sets an event listener and its data to a submesh.
| listener | - the listener to store |
| data | - the listener data to store |
After being set, event listener is notified on each event of a submesh.
Definition at line 2043 of file SMESH_subMesh.cxx.
References SMESH_subMeshEventListenerData.IsDeletable().
{
map< EventListener*, EventListenerData* >::iterator l_d =
myEventListeners.find( listener );
if ( l_d != myEventListeners.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 ));
}
| void SMESH_subMesh::SetEventListener | ( | EventListener * | listener, |
| EventListenerData * | data, | ||
| SMESH_subMesh * | where | ||
| ) |
Sets an event listener and its data to a submesh.
| listener | - the listener to store |
| data | - the listener data to store |
| where | - the submesh to store the listener and it's data |
The method remembers the submesh it puts the listener in order to delete them when HYP_OK algo_state is lost After being set, event listener is notified on each event of submesh.
| listener | - the listener to store |
| data | - the listener data to store |
| where | - the submesh to store the listener and it's data |
| 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 After being set, event listener is notified on each event of where submesh.
Definition at line 2023 of file SMESH_subMesh.cxx.
{
if ( listener && where ) {
where->SetEventListener( listener, data );
myOwnListeners.push_back( make_pair( where, listener ));
}
}
| void SMESH_subMesh::SetIsAlwaysComputed | ( | bool | isAlCo | ) |
Allow algo->Compute() if a subshape of lower dim is meshed but none mesh entity is bound to it.
Allow algo->Compute() if a subshape of lower dim is meshed but none mesh entity is bound to it (PAL13615, 2nd part)
Definition at line 183 of file SMESH_subMesh.cxx.
{
_alwaysComputed = isAlCo;
if ( _alwaysComputed )
_computeState = COMPUTE_OK;
else
ComputeStateEngine( CHECK_COMPUTE_STATE );
}
| SMESH_Hypothesis::Hypothesis_Status SMESH_subMesh::SubMeshesAlgoStateEngine | ( | int | event, |
| SMESH_Hypothesis * | anHyp | ||
| ) |
Definition at line 1113 of file SMESH_subMesh.cxx.
References SMESH.HYP_OK, and PAL_MESH_041_mesh.ret.
{
SMESH_Hypothesis::Hypothesis_Status ret = SMESH_Hypothesis::HYP_OK;
//EAP: a wire (dim==1) should notify edges (dim==1)
//EAP: int dim = SMESH_Gen::GetShapeDim(_subShape);
//if (_subShape.ShapeType() < TopAbs_EDGE ) // wire,face etc
{
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() ) {
SMESH_Hypothesis::Hypothesis_Status ret2 =
smIt->next()->AlgoStateEngine(event, anHyp);
if ( ret2 > ret )
ret = ret2;
}
}
return ret;
}
| bool SMESH_subMesh::SubMeshesComputed | ( | ) | [protected] |
Definition at line 247 of file SMESH_subMesh.cxx.
References SMESH_Gen.GetShapeDim(), MESSAGE, SMESHDS_SubMesh.NbElements(), and SMESHDS_SubMesh.NbNodes().
{
int myDim = SMESH_Gen::GetShapeDim( _subShape );
int dimToCheck = myDim - 1;
bool subMeshesComputed = true;
// check subMeshes with upper dimension => reverse iteration
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true);
while ( smIt->more() )
{
SMESH_subMesh *sm = smIt->next();
if ( sm->_alwaysComputed )
continue;
const TopoDS_Shape & ss = sm->GetSubShape();
// MSV 07.04.2006: restrict checking to myDim-1 only. Ex., there is no sense
// in checking of existence of edges if the algo needs only faces. Moreover,
// degenerated edges may have no submesh, as after computing NETGEN_2D.
int dim = SMESH_Gen::GetShapeDim( ss );
if (dim < dimToCheck)
break; // the rest subMeshes are all of less dimension
SMESHDS_SubMesh * ds = sm->GetSubMeshDS();
bool computeOk = (sm->GetComputeState() == COMPUTE_OK ||
(ds && ( dimToCheck ? ds->NbElements() : ds->NbNodes() )));
if (!computeOk)
{
int type = ss.ShapeType();
subMeshesComputed = false;
switch (type)
{
case TopAbs_COMPOUND:
{
MESSAGE("The not computed sub mesh is a COMPOUND");
break;
}
case TopAbs_COMPSOLID:
{
MESSAGE("The not computed sub mesh is a COMPSOLID");
break;
}
case TopAbs_SHELL:
{
MESSAGE("The not computed sub mesh is a SHEL");
break;
}
case TopAbs_WIRE:
{
MESSAGE("The not computed sub mesh is a WIRE");
break;
}
case TopAbs_SOLID:
{
MESSAGE("The not computed sub mesh is a SOLID");
break;
}
case TopAbs_FACE:
{
MESSAGE("The not computed sub mesh is a FACE");
break;
}
case TopAbs_EDGE:
{
MESSAGE("The not computed sub mesh is a EDGE");
break;
}
default:
{
MESSAGE("The not computed sub mesh is of unknown type");
break;
}
}
break;
}
}
return subMeshesComputed;
}
| bool SMESH_subMesh::SubMeshesReady | ( | ) | [protected] |
Definition at line 331 of file SMESH_subMesh.cxx.
{
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;
}
| void SMESH_subMesh::UpdateDependantsState | ( | const compute_event | theEvent | ) | [protected] |
Definition at line 1818 of file SMESH_subMesh.cxx.
{
//MESSAGE("SMESH_subMesh::UpdateDependantsState");
TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
for (; it.More(); it.Next())
{
const TopoDS_Shape& ancestor = it.Value();
SMESH_subMesh *aSubMesh =
_father->GetSubMeshContaining(ancestor);
if (aSubMesh)
aSubMesh->ComputeStateEngine( theEvent );
}
}
| void SMESH_subMesh::UpdateSubMeshState | ( | const compute_state | theState | ) | [protected] |
Definition at line 1794 of file SMESH_subMesh.cxx.
{
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() )
smIt->next()->_computeState = theState;
}
int SMESH_subMesh._algoState [protected] |
Definition at line 303 of file SMESH_subMesh.hxx.
bool SMESH_subMesh._alwaysComputed [protected] |
Definition at line 310 of file SMESH_subMesh.hxx.
SMESH_ComputeErrorPtr SMESH_subMesh._computeError [protected] |
Definition at line 305 of file SMESH_subMesh.hxx.
int SMESH_subMesh._computeState [protected] |
Definition at line 304 of file SMESH_subMesh.hxx.
bool SMESH_subMesh._dependenceAnalysed [protected] |
Definition at line 301 of file SMESH_subMesh.hxx.
SMESH_Mesh* SMESH_subMesh._father [protected] |
Definition at line 297 of file SMESH_subMesh.hxx.
int SMESH_subMesh._Id [protected] |
Definition at line 298 of file SMESH_subMesh.hxx.
std::map< int, SMESH_subMesh * > SMESH_subMesh._mapDepend [protected] |
Definition at line 300 of file SMESH_subMesh.hxx.
SMESHDS_SubMesh* SMESH_subMesh._subMeshDS [protected] |
Definition at line 296 of file SMESH_subMesh.hxx.
TopoDS_Shape SMESH_subMesh._subShape [protected] |
Definition at line 295 of file SMESH_subMesh.hxx.
std::map< EventListener*, EventListenerData* > SMESH_subMesh.myEventListeners [protected] |
< event listeners to notify
event listeners to delete when HYP_OK algo_state is lost
Definition at line 155 of file SMESH_subMesh.hxx.
std::list< std::pair< SMESH_subMesh*, EventListener* > > SMESH_subMesh.myOwnListeners [protected] |
Definition at line 156 of file SMESH_subMesh.hxx.