//#define PRINT_WHO_COMPUTE_WHAT
#endif
-#define PRINT_WHO_COMPUTE_WHAT
//=============================================================================
/*!
* \brief Allocate some memory at construction and release it at destruction.
return _algo;
}
-//================================================================================
-/*!
- * \brief Returns a current algorithm
- */
-//================================================================================
-
-SMESH_Algo* SMESH_subMesh::CopyAlgo() const
-{
- //SMESH_Algo* algo = (SMESH_Algo*) new StdMeshers_Regular_1D(666, _father->GetGent());
- SMESH_Algo* algo;
-
- return algo;
-}
-
//================================================================================
/*!
* \brief Allow algo->Compute() if a sub-shape of lower dim is meshed but
TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type );
for ( ; exp.More(); exp.Next() )
{
- if ( SMESHDS_SubMesh * smDS = meshDS->MeshElements( exp.Current() ) )
+ if ( SMESHDS_SubMesh * smDS = meshDS->MeshElements( exp.Current() ))
{
bool computed = (dim > 0) ? smDS->NbElements() : smDS->NbNodes();
if ( computed )
* \param [in] event - what happens
* \param [in] anHyp - a hypothesis
* \return SMESH_Hypothesis::Hypothesis_Status - a treatment result.
- *
+ *
* Optional description of a problematic situation (if any) can be retrieved
* via GetComputeError().
*/
// detect algorithm hiding
//
- if ( ret == SMESH_Hypothesis::HYP_OK &&
- ( event == ADD_ALGO || event == ADD_FATHER_ALGO ) && algo &&
+ if ( ret == SMESH_Hypothesis::HYP_OK &&
+ ( event == ADD_ALGO || event == ADD_FATHER_ALGO ) && algo &&
algo->GetName() == anHyp->GetName() )
{
// is algo hidden?
else if (( event == COMPUTE || event == COMPUTE_SUBMESH )
&& !_alwaysComputed )
{
- // LOCK: Adding node to mesh
- _father->Lock();
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;
}
- _father->Unlock();
- // UNLOCK
}
if ( event == MODIF_ALGO_STATE )
cleanDependants();
case COMPUTE_SUBMESH:
{
algo = GetAlgo();
- SMESH_Algo* algo2 = CopyAlgo();
- cout << "Algo2" << algo2;
ASSERT(algo);
- //_father->Lock();
- //ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
- //_father->Unlock();
+ ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
if (!ret)
{
MESSAGE("***** verify compute state *****");
TopoDS_Shape shape = _subShape;
algo->SubMeshesToCompute().assign( 1, this );
// check submeshes needed
- // Forcing to false for parallel run
- // TODO: Remove forced false
- if (_father->HasShapeToMesh() && false) {
+ if (_father->HasShapeToMesh() ) {
bool subComputed = false, subFailed = false;
if (!algo->OnlyUnaryInput()) {
// --- commented for bos#22320 to compute all sub-shapes at once if possible;
#ifdef PRINT_WHO_COMPUTE_WHAT
for (subS.ReInit(); subS.More(); subS.Next())
{
- _father->Lock();
- const std::list <const SMESHDS_Hypothesis *> hyps =
+ const std::list <const SMESHDS_Hypothesis *> & hyps =
_algo->GetUsedHypothesis( *_father, _subShape );
- _father->Unlock();
SMESH_Comment hypStr;
if ( !hyps.empty() )
{
updateDependantsState( SUBMESH_COMPUTED );
}
// let algo clear its data gathered while algo->Compute()
- //_father->Lock();
- //algo->CheckHypothesis((*_father), _subShape, hyp_status);
- //_father->Unlock();
+ algo->CheckHypothesis((*_father), _subShape, hyp_status);
}
break;
case COMPUTE_CANCELED: // nothing to do
break;
}
- //notifyListenersOnEvent( event, COMPUTE_EVENT );
+ notifyListenersOnEvent( event, COMPUTE_EVENT );
return ret;
}
//=======================================================================
//function : cleanDependants
-//purpose :
+//purpose :
//=======================================================================
void SMESH_subMesh::cleanDependants()
//=======================================================================
//function : removeSubMeshElementsAndNodes
-//purpose :
+//purpose :
//=======================================================================
void SMESH_subMesh::removeSubMeshElementsAndNodes()
return _subShape;
const bool skipAuxHyps = false;
- _father->Lock();
list<const SMESHDS_Hypothesis*> usedHyps =
theAlgo->GetUsedHypothesis( *_father, _subShape, skipAuxHyps ); // copy
- _father->Lock();
std::list < TopoDS_Shape > assiShapes = theAlgo->GetAssignedShapes();
// put in a compound all shapes with the same hypothesis assigned
}
else if ( subMesh->GetComputeState() == READY_TO_COMPUTE )
{
- _father->Lock();
SMESH_Algo* anAlgo = subMesh->GetAlgo();
if (( anAlgo->IsSameName( *theAlgo )) && // same algo
( anAlgo->GetUsedHypothesis( *_father, S, skipAuxHyps ) == usedHyps ) && // same hyps
theSubComputed = false;
theSubs.push_back( subMesh );
}
- _father->Unlock();
}
}
* \param listener - the listener to store
* \param data - the listener data to store
* \param where - the submesh to store the listener and it's data
- *
+ *
* 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.
* \brief Sets an event listener and its data to a submesh
* \param listener - the listener to store
* \param data - the listener data to store
- *
+ *
* After being set, event listener is notified on each event of a submesh.
*/
//================================================================================
* \param subMesh - the submesh where the event occurs
* \param data - listener data stored in the subMesh
* \param hyp - hypothesis, if eventType is algo_event
- *
+ *
* The base implementation translates CLEAN event to the subMesh
* stored in listener data. Also it sends SUBMESH_COMPUTED event in case of
* successful COMPUTE event.
