-// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2023 CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include "SMESH_Mesh.hxx"
#include "SMESH_MesherHelper.hxx"
#include "SMESH_subMeshEventListener.hxx"
+#include "SMESH_MeshLocker.hxx"
#include "utilities.h"
#include "Basics_Utils.hxx"
#ifdef _DEBUG_
// enable printing algo + shape id + hypo used while meshing
-//#define PRINT_WHO_COMPUTE_WHAT
+#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() )
{
- SMESHDS_SubMesh * smDS = meshDS->MeshElements( exp.Current() );
- if ( smDS )
+ if ( SMESHDS_SubMesh * smDS = meshDS->MeshElements( exp.Current() ) )
{
bool computed = (dim > 0) ? smDS->NbElements() : smDS->NbNodes();
if ( computed )
else if (( event == COMPUTE || event == COMPUTE_SUBMESH )
&& !_alwaysComputed )
{
- // LOCK: Adding node to mesh
- _father->Lock();
+ SMESH_MeshLocker myLocker(_father);
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 *****");
break;
}
TopoDS_Shape shape = _subShape;
- algo->SubMeshesToCompute().assign( 1, this );
+ algo->setSubMeshesToCompute(this);
// check submeshes needed
- // Forcing to false for parallel run
- // TODO: Remove forced false
- if (_father->HasShapeToMesh() && false) {
+ // When computing in parallel mode we do not have a additional layer of submesh
+ // The check should not be done in parallel as that check is not thread-safe
+ if (_father->HasShapeToMesh() && !_father->IsParallel()) {
bool subComputed = false, subFailed = false;
if (!algo->OnlyUnaryInput()) {
// --- commented for bos#22320 to compute all sub-shapes at once if possible;
}
else
{
- // TODO: Replace by call to ParallelCompute
ret = algo->Compute((*_father), shape);
}
// algo can set _computeError of submesh
_computeError = SMESH_ComputeError::Worst( _computeError, algo->GetComputeError() );
}
catch ( ::SMESH_ComputeError& comperr ) {
- cout << " SMESH_ComputeError caught" << endl;
+ MESSAGE(" SMESH_ComputeError caught");
if ( !_computeError ) _computeError = SMESH_ComputeError::New();
*_computeError = comperr;
}
bool isComputeErrorSet = !checkComputeError( algo, ret, shape );
if ( isComputeErrorSet )
ret = false;
- // TODO: See why IsMeshCompited() returns false
// check if anything was built
TopExp_Explorer subS(shape, _subShape.ShapeType());
if ( ret )
#ifdef PRINT_WHO_COMPUTE_WHAT
for (subS.ReInit(); subS.More(); subS.Next())
{
- _father->Lock();
- const std::list <const SMESHDS_Hypothesis *> hyps =
- _algo->GetUsedHypothesis( *_father, _subShape );
- _father->Unlock();
+ SMESH_MeshLocker myLocker(_father);
+ const std::list <const SMESHDS_Hypothesis *> & hyps =
+ _algo->GetUsedHypothesis( *_father, _subShape );
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;
}
if ( !_computeError || _computeError->IsOK() )
{
// no error description is set to this sub-mesh, check if any mesh is computed
- //TODO: See why this does not work
- //_computeState = IsMeshComputed() ? COMPUTE_OK : FAILED_TO_COMPUTE;
- _computeState = COMPUTE_OK;
+ _computeState = IsMeshComputed() ? COMPUTE_OK : FAILED_TO_COMPUTE;
if ( _computeState != COMPUTE_OK )
{
if ( _subShape.ShapeType() == TopAbs_EDGE &&
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();
}
}