// 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
#include "SMESH_MesherHelper.hxx"
#include "SMESH_subMeshEventListener.hxx"
-#include <Basics_OCCTVersion.hxx>
-
#include "utilities.h"
#include "OpUtil.hxx"
#include "Basics_Utils.hxx"
//=======================================================================
//function : CanAddHypothesis
//purpose : return true if theHypothesis can be attached to me:
-// its dimention is checked
+// its dimension is checked
//=======================================================================
bool SMESH_subMesh::CanAddHypothesis(const SMESH_Hypothesis* theHypothesis) const
}
//=======================================================================
-//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)
{
filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+1 ));
filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+2 ));
if ( SMESH_Algo * curAlgo = (SMESH_Algo*)_father->GetHypothesis( this, filter, true ))
- if ( !curAlgo->NeedDiscreteBoundary() )
+ if ( !curAlgo->NeedDiscreteBoundary() && curAlgo != anHyp )
algoRequiringCleaning = curAlgo;
}
}
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();
}
}
case COMPUTE_CANCELED: // nothing to do
break;
case CLEAN:
- cleanDependants(); // clean sub-meshes, dependant on this one, with event CLEAN
+ cleanDependants(); // clean sub-meshes, dependent on this one, with event CLEAN
removeSubMeshElementsAndNodes();
_computeState = NOT_READY;
if ( _algoState == HYP_OK )
}
//=======================================================================
-//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() )
//================================================================================
/*!
- * \brief Notify stored event listeners on the occured event
+ * \brief Notify stored event listeners on the occurred event
* \param event - algo_event or compute_event itself
* \param eventType - algo_event or compute_event
* \param hyp - hypothesis, if eventType is algo_event
* \brief Do something on a certain event
* \param event - algo_event or compute_event itself
* \param eventType - algo_event or compute_event
- * \param subMesh - the submesh where the event occures
+ * \param subMesh - the submesh where the event occurs
* \param data - listener data stored in the subMesh
* \param hyp - hypothesis, if eventType is algo_event
*
//================================================================================
/*!
- * \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
*/
//================================================================================
me->_ancestors.reserve( ancShapes.Extent() );
TopTools_MapOfShape map;
-
+
+ // assure that all sub-meshes exist
+ _father->GetSubMesh( _father->GetShapeToMesh() )->DependsOn();
+
for ( TopTools_ListIteratorOfListOfShape it( ancShapes ); it.More(); it.Next() )
if ( SMESH_subMesh* sm = _father->GetSubMeshContaining( it.Value() ))
if ( map.Add( it.Value() ))
