_algoState = NO_ALGO;
_computeState = NOT_READY;
}
+ _computeCost = 0; // how costly is to compute this sub-mesh
+ _realComputeCost = 0;
}
//=============================================================================
return subMeshesComputed;
}
+//================================================================================
+/*!
+ * \brief Return cost of computing this sub-mesh. If hypotheses are not well defined,
+ * zero is returned
+ * \return int - the computation cost in abstract units.
+ */
+//================================================================================
+
+int SMESH_subMesh::GetComputeCost() const
+{
+ return _realComputeCost;
+}
+
+//================================================================================
+/*!
+ * \brief Return cost of computing this sub-mesh. The cost depends on the shape type
+ * and number of sub-meshes this one DependsOn().
+ * \return int - the computation cost in abstract units.
+ */
+//================================================================================
+
+int SMESH_subMesh::computeCost() const
+{
+ if ( !_computeCost )
+ {
+ int computeCost;
+ switch ( _subShape.ShapeType() ) {
+ case TopAbs_SOLID:
+ case TopAbs_SHELL: computeCost = 5000; break;
+ case TopAbs_FACE: computeCost = 500; break;
+ case TopAbs_EDGE: computeCost = 2; break;
+ default: computeCost = 1;
+ }
+ SMESH_subMeshIteratorPtr childIt = getDependsOnIterator(/*includeSelf=*/false);
+ while ( childIt->more() )
+ computeCost += childIt->next()->computeCost();
+
+ ((SMESH_subMesh*)this)->_computeCost = computeCost;
+ }
+ return _computeCost;
+}
+
//=============================================================================
/*!
*
return _mapDepend;
}
+//================================================================================
+/*!
+ * \brief Return a key for SMESH_subMesh::_mapDepend map
+ */
+//================================================================================
+
+namespace {
+ int dependsOnMapKey( const SMESH_subMesh* sm )
+ {
+ int type = sm->GetSubShape().ShapeType();
+ int ordType = 9 - type; // 2 = Vertex, 8 = CompSolid
+ int cle = sm->GetId();
+ cle += 10000000 * ordType; // sort map by ordType then index
+ return cle;
+ }
+}
+
//=============================================================================
/*!
* For simple Shapes (solid, face, edge): add subMesh into dependence list.
void SMESH_subMesh::insertDependence(const TopoDS_Shape aSubShape)
{
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
+ int cle = dependsOnMapKey( aSubMesh );
if ( _mapDepend.find( cle ) == _mapDepend.end())
{
_mapDepend[cle] = aSubMesh;
}
}
+//================================================================================
+/*!
+ * \brief Return \c true if \a this sub-mesh depends on \a other
+ */
+//================================================================================
+
+bool SMESH_subMesh::DependsOn( const SMESH_subMesh* other ) const
+{
+ return other ? _mapDepend.count( dependsOnMapKey( other )) : false;
+}
+
//=============================================================================
/*!
- *
+ * Return a shape of \a this sub-mesh
*/
//=============================================================================
const TopoDS_Shape & SMESH_subMesh::GetSubShape() const
{
- //MESSAGE("SMESH_subMesh::GetSubShape");
- return _subShape;
+ return _subShape;
}
-
//=======================================================================
//function : CanAddHypothesis
//purpose : return true if theHypothesis can be attached to me:
if ( stateChange && _algoState == HYP_OK ) // hyp becomes OK
algo->SetEventListener( this );
+ if ( event == REMOVE_ALGO || event == REMOVE_FATHER_ALGO )
+ _algo = 0;
+
notifyListenersOnEvent( event, ALGO_EVENT, anHyp );
if ( stateChange && oldAlgoState == HYP_OK ) { // hyp becomes KO
if (stateChange || modifiedHyp)
ComputeStateEngine(MODIF_ALGO_STATE);
+ _realComputeCost = ( _algoState == HYP_OK ) ? computeCost() : 0;
+
return ret;
}
void SMESH_subMesh::DumpAlgoState(bool isMain)
{
- int dim = SMESH_Gen::GetShapeDim(_subShape);
-// if (dim < 1) return;
+ // if (dim < 1) return;
if (isMain)
{
const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
sm->DumpAlgoState(false);
}
}
- int type = _subShape.ShapeType();
- MESSAGE("dim = " << dim << " type of shape " << type);
+ //int type = _subShape.ShapeType();
+ MESSAGE("dim = " << SMESH_Gen::GetShapeDim(_subShape) <<
+ " type of shape " << _subShape.ShapeType());
switch (_algoState)
{
case NO_ALGO:
const SMDS_MeshElement * elt = ite->next();
//MESSAGE( " RM elt: "<<elt->GetID()<<" ( "<<elt->NbNodes()<<" )" );
//meshDS->RemoveElement(elt);
- meshDS->RemoveFreeElement(elt, subMeshDS);
+ meshDS->RemoveFreeElement(elt, 0);
}
SMDS_NodeIteratorPtr itn = subMeshDS->GetNodes();
const SMDS_MeshNode * node = itn->next();
//MESSAGE( " RM node: "<<node->GetID());
if ( node->NbInverseElements() == 0 )
- meshDS->RemoveFreeNode(node, subMeshDS);
+ meshDS->RemoveFreeNode(node, 0);
else // for StdMeshers_CompositeSegment_1D: node in one submesh, edge in another
meshDS->RemoveNode(node);
}
+ subMeshDS->Clear();
}
}
}
break;
}
TopoDS_Shape shape = _subShape;
+ algo->SubMeshesToCompute().assign( 1, this );
// check submeshes needed
if (_father->HasShapeToMesh() ) {
bool subComputed = false, subFailed = false;
if (!algo->OnlyUnaryInput()) {
if ( event == COMPUTE /*&&
( algo->NeedDiscreteBoundary() || algo->SupportSubmeshes() )*/)
- shape = getCollection( gen, algo, subComputed, subFailed );
+ shape = getCollection( gen, algo, subComputed, subFailed, algo->SubMeshesToCompute());
else
subComputed = SubMeshesComputed( & subFailed );
}
}
// Compute
+ // to restore cout that may be redirected by algo
+ std::streambuf* coutBuffer = std::cout.rdbuf();
+
//cleanDependants(); for "UseExisting_*D" algos
//removeSubMeshElementsAndNodes();
loadDependentMeshes();
_computeState = FAILED_TO_COMPUTE;
_computeError = SMESH_ComputeError::New(COMPERR_OK,"",algo);
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
+
algo->InitComputeError();
+
MemoryReserve aMemoryReserve;
SMDS_Mesh::CheckMemory();
Kernel_Utils::Localizer loc;
{
ret = algo->Compute((*_father), shape);
}
- if ( !_computeError || ( !ret && _computeError->IsOK() ) ) // algo can set _computeError of submesh
+ if ( !_computeError || (/* !ret && */_computeError->IsOK() ) ) // algo can set _computeError of submesh
_computeError = algo->GetComputeError();
}
catch ( ::SMESH_ComputeError& comperr ) {
else
ret = false;
}
+ std::cout.rdbuf( coutBuffer ); // restore cout that could be redirected by algo
+
// check if an error reported on any sub-shape
bool isComputeErrorSet = !checkComputeError( algo, ret, shape );
if ( isComputeErrorSet )
if (ret)
{
for (; ret && subS.More(); subS.Next())
- ret = _father->GetSubMesh( subS.Current() )->IsMeshComputed();
+ if ( !_father->GetSubMesh( subS.Current() )->IsMeshComputed() &&
+ ( _subShape.ShapeType() != TopAbs_EDGE ||
+ !algo->isDegenerated( TopoDS::Edge( subS.Current() ))))
+ ret = false;
}
// Set _computeError
if (!ret && !isComputeErrorSet)
if ( _computeState != COMPUTE_OK )
{
if ( _subShape.ShapeType() == TopAbs_EDGE &&
- BRep_Tool::Degenerated( TopoDS::Edge( _subShape )) )
+ SMESH_Algo::isDegenerated( TopoDS::Edge( _subShape )) )
_computeState = COMPUTE_OK;
else if ( theComputeOK )
_computeError = SMESH_ComputeError::New(COMPERR_NO_MESH_ON_SHAPE,"",theAlgo);
TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
SMESH_Algo* theAlgo,
bool & theSubComputed,
- bool & theSubFailed)
+ bool & theSubFailed,
+ std::vector<SMESH_subMesh*>& theSubs)
{
theSubComputed = SubMeshesComputed( & theSubFailed );
BRep_Builder aBuilder;
aBuilder.MakeCompound( aCompound );
+ theSubs.clear();
+
TopExp_Explorer anExplorer( mainShape, _subShape.ShapeType() );
for ( ; anExplorer.More(); anExplorer.Next() )
{
const TopoDS_Shape& S = anExplorer.Current();
SMESH_subMesh* subMesh = _father->GetSubMesh( S );
+ theSubs.push_back( subMesh );
if ( subMesh == this )
{
aBuilder.Add( aCompound, S );
const event_type eventType,
SMESH_Hypothesis* hyp)
{
- map< EventListener*, EventListenerData* >::iterator l_d = _eventListeners.begin();
- for ( ; l_d != _eventListeners.end(); )
+ list< pair< EventListener*, EventListenerData* > > eventListeners( _eventListeners.begin(),
+ _eventListeners.end());
+ list< pair< EventListener*, EventListenerData* > >::iterator l_d = eventListeners.begin();
+ for ( ; l_d != eventListeners.end(); ++l_d )
{
- std::pair< EventListener*, EventListenerData* > li_da = *l_d++; /* copy to enable removal
- of a listener from
- _eventListeners by
- its ProcessEvent() */
+ std::pair< EventListener*, EventListenerData* > li_da = *l_d;
+ if ( !_eventListeners.count( li_da.first )) continue;
+
if ( li_da.first->myBusySM.insert( this ).second )
{
- const size_t nbListenersBefore = _eventListeners.size();
+ const bool isDeletable = li_da.first->IsDeletable();
+
li_da.first->ProcessEvent( event, eventType, this, li_da.second, hyp );
- if ( nbListenersBefore == _eventListeners.size() )
- li_da.first->myBusySM.erase( this ); // a listener hopefully not removed
+
+ if ( !isDeletable || _eventListeners.count( li_da.first ))
+ li_da.first->myBusySM.erase( this ); // a listener is hopefully not dead
}
}
}