-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_subMesh.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH
if ( !_algo )
{
SMESH_subMesh* me = const_cast< SMESH_subMesh* >( this );
- me->_algo = _father->GetGen()->GetAlgo( me );
+ me->_algo = _father->GetGen()->GetAlgo( me, & me->_algoShape );
}
return _algo;
}
*/
//=============================================================================
-const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
+const std::map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
{
if ( _dependenceAnalysed || !_father->HasShapeToMesh() )
return _mapDepend;
}
//=======================================================================
-//function : IsApplicableHypotesis
+//function : IsApplicableHypothesis
//purpose : check if this sub-mesh can be computed using a hypothesis
//=======================================================================
-bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis) const
+bool SMESH_subMesh::IsApplicableHypothesis(const SMESH_Hypothesis* theHypothesis) const
{
if ( !_father->HasShapeToMesh() && _subShape.ShapeType() == TopAbs_SOLID )
return true; // true for the PseudoShape
- return IsApplicableHypotesis( theHypothesis, _subShape.ShapeType() );
+ return IsApplicableHypothesis( theHypothesis, _subShape.ShapeType() );
}
//=======================================================================
-//function : IsApplicableHypotesis
+//function : IsApplicableHypothesis
//purpose : compare shape type and hypothesis type
//=======================================================================
-bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis,
- const TopAbs_ShapeEnum theShapeType)
+bool SMESH_subMesh::IsApplicableHypothesis(const SMESH_Hypothesis* theHypothesis,
+ const TopAbs_ShapeEnum theShapeType)
{
if ( theHypothesis->GetType() > SMESHDS_Hypothesis::PARAM_ALGO)
{
bool modifiedHyp = (event == MODIF_HYP); // if set to true, force event MODIF_ALGO_STATE
SMESH_Algo* algoRequiringCleaning = 0;
- bool isApplicableHyp = IsApplicableHypotesis( anHyp );
+ bool isApplicableHyp = IsApplicableHypothesis( anHyp );
if (event == ADD_ALGO || event == ADD_FATHER_ALGO)
{
const SMESH_Hypothesis * prevAlgo = _father->GetHypothesis( this, f, true );
if (prevAlgo &&
string( algo->GetName()) != prevAlgo->GetName())
- modifiedHyp = true;
+ {
+ oldAlgoState = NO_ALGO; // force setting event listener (#16648)
+ modifiedHyp = true;
+ }
}
else
setAlgoState(MISSING_HYP);
if ( !theAlgo ) return false;
// Suppose that theAlgo is applicable to _subShape, do not check it here
- //if ( !IsApplicableHypotesis( theAlgo )) return false;
+ //if ( !IsApplicableHypothesis( theAlgo )) return false;
// check only algo that doesn't NeedDiscreteBoundary(): because mesh made
// on a sub-shape will be ignored by theAlgo
SMESHDS_Mesh * meshDS = subMesh->GetFather()->GetMeshDS();
int nbElems = subMeshDS->NbElements();
if ( nbElems > 0 )
- {
- // start from elem with max ID to avoid filling the pool of IDs
- bool rev = true;
- SMDS_ElemIteratorPtr ite = subMeshDS->GetElements( rev );
- const SMDS_MeshElement * lastElem = ite->next();
- rev = ( lastElem->GetID() == meshDS->MaxElementID() );
- if ( !rev )
- ite = subMeshDS->GetElements( rev );
- else
- meshDS->RemoveFreeElement( lastElem, subMeshDS );
- while (ite->more()) {
- const SMDS_MeshElement * elt = ite->next();
- meshDS->RemoveFreeElement( elt, subMeshDS );
- }
- }
+ for ( SMDS_ElemIteratorPtr ite = subMeshDS->GetElements(); ite->more(); )
+ meshDS->RemoveFreeElement( ite->next(), subMeshDS );
+
int nbNodes = subMeshDS->NbNodes();
if ( nbNodes > 0 )
- {
- bool rev = true;
- SMDS_NodeIteratorPtr itn = subMeshDS->GetNodes( rev );
- const SMDS_MeshNode * lastNode = itn->next();
- rev = ( lastNode->GetID() == meshDS->MaxNodeID() );
- if ( !rev )
- itn = subMeshDS->GetNodes( rev );
- else
- meshDS->RemoveNode( lastNode );
- while (itn->more()) {
+ for ( SMDS_NodeIteratorPtr itn = subMeshDS->GetNodes(); itn->more() ; )
+ {
const SMDS_MeshNode * node = itn->next();
if ( node->NbInverseElements() == 0 )
meshDS->RemoveFreeNode( node, subMeshDS );
else // for StdMeshers_CompositeSegment_1D: node in one submesh, edge in another
- meshDS->RemoveNode(node);
+ meshDS->RemoveNode( node );
}
- }
subMeshDS->Clear();
}
}
else
updateDependantsState( SUBMESH_COMPUTED );
}
+ // let algo clear its data gathered while algo->Compute()
+ algo->CheckHypothesis((*_father), _subShape, hyp_status);
}
break;
case COMPUTE_CANCELED: // nothing to do
return _subShape;
const bool skipAuxHyps = false;
- list<const SMESHDS_Hypothesis*> aUsedHyp =
+ list<const SMESHDS_Hypothesis*> usedHyps =
theAlgo->GetUsedHypothesis( *_father, _subShape, skipAuxHyps ); // copy
+ std::list < TopoDS_Shape > assiShapes = theAlgo->GetAssignedShapes();
// put in a compound all shapes with the same hypothesis assigned
// and a good ComputeState
{
SMESH_Algo* anAlgo = subMesh->GetAlgo();
if (( anAlgo->IsSameName( *theAlgo )) && // same algo
- ( anAlgo->GetUsedHypothesis( *_father, S, skipAuxHyps ) == aUsedHyp )) // same hyps
+ ( anAlgo->GetUsedHypothesis( *_father, S, skipAuxHyps ) == usedHyps ) && // same hyps
+ ( anAlgo->GetAssignedShapes() == assiShapes ) && // on same sub-shapes
+ ( _algoShape == subMesh->_algoShape ))
{
aBuilder.Add( aCompound, S );
if ( !subMesh->SubMeshesComputed() )
}
//=======================================================================
-//function : CheckConcurentHypothesis
+//function : CheckConcurrentHypothesis
//purpose : check if there are several applicable hypothesis attached to
// ancestors
//=======================================================================
SMESH_Hypothesis::Hypothesis_Status
- SMESH_subMesh::CheckConcurentHypothesis (const int theHypType)
+ SMESH_subMesh::CheckConcurrentHypothesis (const int theHypType)
{
// is there local hypothesis on me?
if ( getSimilarAttached( _subShape, 0, theHypType ) )
aPrevHyp = hyp;
}
else if ( aPrevWithHyp.ShapeType() == ancestor.ShapeType() && aPrevHyp != hyp )
- return SMESH_Hypothesis::HYP_CONCURENT;
+ return SMESH_Hypothesis::HYP_CONCURRENT;
else
return SMESH_Hypothesis::HYP_OK;
}
_eventListeners.find( listener );
if ( l_d != _eventListeners.end() ) {
EventListenerData* curData = l_d->second;
+ l_d->second = data;
if ( curData && curData != data && curData->IsDeletable() )
delete curData;
- l_d->second = data;
}
else
{
if ( listener->GetName() == l_d->first->GetName() )
{
EventListenerData* curData = l_d->second;
+ l_d->second = 0;
if ( curData && curData != data && curData->IsDeletable() )
delete curData;
if ( l_d->first != listener && l_d->first->IsDeletable() )
{
list< OwnListenerData >::iterator d;
for ( d = _ownListeners.begin(); d != _ownListeners.end(); ++d )
- if ( _father != d->mySubMesh->_father )
+ if ( _father != d->mySubMesh->_father &&
+ _father->FindMesh( d->myMeshID ))
d->mySubMesh->_father->Load();
// map< EventListener*, EventListenerData* >::iterator l_d = _eventListeners.begin();
//================================================================================
/*!
- * \brief Return iterator on the submeshes this one depends on
- * \param includeSelf - this submesh to be returned also
- * \param reverse - if true, complex shape submeshes go first
+ * \brief Return iterator on the submeshes this one depends on
+ * \param includeSelf - this submesh to be returned also
+ * \param reverse - if true, complex shape submeshes go first
*/
//================================================================================
SMESH_subMesh* me = const_cast< SMESH_subMesh* >( this );
me->_ancestors.reserve( ancShapes.Extent() );
+ // assure that all sub-meshes exist
+ TopoDS_Shape mainShape = _father->GetShapeToMesh();
+ if ( !mainShape.IsNull() )
+ _father->GetSubMesh( mainShape )->DependsOn();
+
TopTools_MapOfShape map;
-
+
for ( TopTools_ListIteratorOfListOfShape it( ancShapes ); it.More(); it.Next() )
if ( SMESH_subMesh* sm = _father->GetSubMeshContaining( it.Value() ))
if ( map.Add( it.Value() ))