_algoState = NO_ALGO;
_computeState = NOT_READY;
}
+ _computeCost = 0; // how costly is to compute this sub-mesh
}
//=============================================================================
return subMeshesComputed;
}
+//================================================================================
+/*!
+ * \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::GetComputeCost() const
+{
+ if ( !_computeCost )
+ {
+ int computeCost;
+ switch ( _subShape.ShapeType() ) {
+ case TopAbs_SOLID:
+ case TopAbs_SHELL: computeCost = 1000; break;
+ case TopAbs_FACE: computeCost = 100; break;
+ case TopAbs_EDGE: computeCost = 10; break;
+ default: computeCost = 1;
+ }
+ SMESH_subMeshIteratorPtr childIt = getDependsOnIterator(/*includeSelf=*/false);
+ while ( childIt->more() )
+ computeCost += childIt->next()->GetComputeCost();
+
+ ((SMESH_subMesh*)this)->_computeCost = computeCost;
+ }
+ return _computeCost;
+}
+
//=============================================================================
/*!
*
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
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:
break;
}
TopoDS_Shape shape = _subShape;
+ int computeCost = GetComputeCost();
// 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, computeCost);
else
subComputed = SubMeshesComputed( & subFailed );
}
OCC_CATCH_SIGNALS;
#endif
algo->InitComputeError();
+ algo->GetComputeCost() = computeCost;
+
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 ) {
TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
SMESH_Algo* theAlgo,
bool & theSubComputed,
- bool & theSubFailed)
+ bool & theSubFailed,
+ int & theComputeCost)
{
theSubComputed = SubMeshesComputed( & theSubFailed );
BRep_Builder aBuilder;
aBuilder.MakeCompound( aCompound );
+ theComputeCost = 0;
+
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->GetComputeState() != NOT_READY )
+ theComputeCost += subMesh->GetComputeCost();
if ( subMesh == this )
{
aBuilder.Add( aCompound, S );
if ( !subMesh->SubMeshesComputed() )
theSubComputed = false;
}
+ if ( !theAlgo->NeedDiscreteBoundary() )
+ {
+ SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(/*includeSelf=*/false);
+ while ( smIt->more() )
+ {
+ SMESH_subMesh* sm = smIt->next();
+ if ( sm->GetComputeState() != NOT_READY &&
+ sm->IsEmpty() )
+ theComputeCost += sm->GetComputeCost();
+ }
+ }
}
return aCompound;
const event_type eventType,
SMESH_Hypothesis* hyp)
{
- set< EventListener* > notified;
- const size_t nbListeners = _eventListeners.size();
- while ( notified.size() != nbListeners )
+ 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 )
{
- map< EventListener*, EventListenerData* >::iterator l_d = _eventListeners.begin();
- for ( ; l_d != _eventListeners.end(); ++l_d )
- {
- std::pair< EventListener*, EventListenerData* > li_da = *l_d;
-
- if ( notified.insert( li_da.first ).second &&
- li_da.first->myBusySM.insert( this ).second )
- {
- const bool isDeletable = li_da.first->IsDeletable();
+ std::pair< EventListener*, EventListenerData* > li_da = *l_d;
+ if ( !_eventListeners.count( li_da.first )) continue;
- li_da.first->ProcessEvent( event, eventType, this, li_da.second, hyp );
+ if ( li_da.first->myBusySM.insert( this ).second )
+ {
+ const bool isDeletable = li_da.first->IsDeletable();
- const bool isRemoved = !_eventListeners.count( li_da.first );
- if ( !isDeletable || !isRemoved )
- li_da.first->myBusySM.erase( this ); // a listener is hopefully not dead
+ li_da.first->ProcessEvent( event, eventType, this, li_da.second, hyp );
- if ( isRemoved )
- break; // restart looping on _eventListeners
- }
+ if ( !isDeletable || _eventListeners.count( li_da.first ))
+ li_da.first->myBusySM.erase( this ); // a listener is hopefully not dead
}
}
}