Salome HOME
projects
/
modules
/
smesh.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
[bos #41978][EDF] Edit table of density on wire discretization. Load properly the...
[modules/smesh.git]
/
src
/
SMESH
/
SMESH_subMesh.cxx
diff --git
a/src/SMESH/SMESH_subMesh.cxx
b/src/SMESH/SMESH_subMesh.cxx
index 4f9955cf3000d6258458fe1ab6b7c139ed86ac6f..18b6c3cdfe9687603d1dea4f8dacc19b5806ea71 100644
(file)
--- a/
src/SMESH/SMESH_subMesh.cxx
+++ b/
src/SMESH/SMESH_subMesh.cxx
@@
-1,4
+1,4
@@
-// Copyright (C) 2007-202
0 CEA/DEN, EDF R&D
, OPEN CASCADE
+// Copyright (C) 2007-202
4 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
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@
-37,9
+37,9
@@
#include "SMESH_Mesh.hxx"
#include "SMESH_MesherHelper.hxx"
#include "SMESH_subMeshEventListener.hxx"
#include "SMESH_Mesh.hxx"
#include "SMESH_MesherHelper.hxx"
#include "SMESH_subMeshEventListener.hxx"
+#include "SMESH_MeshLocker.hxx"
#include "utilities.h"
#include "utilities.h"
-#include "OpUtil.hxx"
#include "Basics_Utils.hxx"
#include <BRep_Builder.hxx>
#include "Basics_Utils.hxx"
#include <BRep_Builder.hxx>
@@
-63,7
+63,7
@@
using namespace std;
#ifdef _DEBUG_
// enable printing algo + shape id + hypo used while meshing
#ifdef _DEBUG_
// enable printing algo + shape id + hypo used while meshing
-
//
#define PRINT_WHO_COMPUTE_WHAT
+#define PRINT_WHO_COMPUTE_WHAT
#endif
//=============================================================================
#endif
//=============================================================================
@@
-257,7
+257,7
@@
bool SMESH_subMesh::IsMeshComputed() const
TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type );
for ( ; exp.More(); exp.Next() )
{
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 )
{
bool computed = (dim > 0) ? smDS->NbElements() : smDS->NbNodes();
if ( computed )
@@
-610,7
+610,7
@@
bool SMESH_subMesh::IsApplicableHypothesis(const SMESH_Hypothesis* theHypothesis
* \param [in] event - what happens
* \param [in] anHyp - a hypothesis
* \return SMESH_Hypothesis::Hypothesis_Status - a treatment result.
* \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().
*/
* Optional description of a problematic situation (if any) can be retrieved
* via GetComputeError().
*/
@@
-891,7
+891,10
@@
SMESH_Hypothesis::Hypothesis_Status
ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
}
else if (!_father->IsUsedHypothesis( anHyp, this ))
ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
}
else if (!_father->IsUsedHypothesis( anHyp, this ))
- ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
+ {
+ if ( anHyp->GetDim() == this->GetAlgo()->GetDim() )
+ ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
+ }
if (SMESH_Hypothesis::IsStatusFatal( ret ))
{
if (SMESH_Hypothesis::IsStatusFatal( ret ))
{
@@
-1034,8
+1037,8
@@
SMESH_Hypothesis::Hypothesis_Status
// detect algorithm hiding
//
// 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?
algo->GetName() == anHyp->GetName() )
{
// is algo hidden?
@@
-1331,12
+1334,12
@@
static void cleanSubMesh( SMESH_subMesh * subMesh )
if (SMESHDS_SubMesh * subMeshDS = subMesh->GetSubMeshDS())
{
SMESHDS_Mesh * meshDS = subMesh->GetFather()->GetMeshDS();
if (SMESHDS_SubMesh * subMeshDS = subMesh->GetSubMeshDS())
{
SMESHDS_Mesh * meshDS = subMesh->GetFather()->GetMeshDS();
-
int
nbElems = subMeshDS->NbElements();
+
smIdType
nbElems = subMeshDS->NbElements();
if ( nbElems > 0 )
for ( SMDS_ElemIteratorPtr ite = subMeshDS->GetElements(); ite->more(); )
meshDS->RemoveFreeElement( ite->next(), subMeshDS );
if ( nbElems > 0 )
for ( SMDS_ElemIteratorPtr ite = subMeshDS->GetElements(); ite->more(); )
meshDS->RemoveFreeElement( ite->next(), subMeshDS );
-
int
nbNodes = subMeshDS->NbNodes();
+
smIdType
nbNodes = subMeshDS->NbNodes();
if ( nbNodes > 0 )
for ( SMDS_NodeIteratorPtr itn = subMeshDS->GetNodes(); itn->more() ; )
{
if ( nbNodes > 0 )
for ( SMDS_NodeIteratorPtr itn = subMeshDS->GetNodes(); itn->more() ; )
{
@@
-1393,6
+1396,7
@@
bool SMESH_subMesh::ComputeStateEngine(compute_event event)
else if (( event == COMPUTE || event == COMPUTE_SUBMESH )
&& !_alwaysComputed )
{
else if (( event == COMPUTE || event == COMPUTE_SUBMESH )
&& !_alwaysComputed )
{
+ 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()) ) {
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()) ) {
@@
-1445,6
+1449,7
@@
bool SMESH_subMesh::ComputeStateEngine(compute_event event)
loadDependentMeshes();
ComputeSubMeshStateEngine( SUBMESH_LOADED );
//break;
loadDependentMeshes();
ComputeSubMeshStateEngine( SUBMESH_LOADED );
//break;
+ // fall through
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
@@
-1496,6
+1501,7
@@
bool SMESH_subMesh::ComputeStateEngine(compute_event event)
}
break;
}
}
break;
}
+ // fall through
case COMPUTE:
case COMPUTE_SUBMESH:
{
case COMPUTE:
case COMPUTE_SUBMESH:
{
@@
-1510,9
+1516,11
@@
bool SMESH_subMesh::ComputeStateEngine(compute_event event)
break;
}
TopoDS_Shape shape = _subShape;
break;
}
TopoDS_Shape shape = _subShape;
- algo->
SubMeshesToCompute().assign( 1, this
);
+ algo->
setSubMeshesToCompute(this
);
// check submeshes needed
// check submeshes needed
- if (_father->HasShapeToMesh() ) {
+ // 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() || shape.ShapeType() != _father->GetParallelElement() )) {
bool subComputed = false, subFailed = false;
if (!algo->OnlyUnaryInput()) {
// --- commented for bos#22320 to compute all sub-shapes at once if possible;
bool subComputed = false, subFailed = false;
if (!algo->OnlyUnaryInput()) {
// --- commented for bos#22320 to compute all sub-shapes at once if possible;
@@
-1574,7
+1582,7
@@
bool SMESH_subMesh::ComputeStateEngine(compute_event event)
_computeError = SMESH_ComputeError::Worst( _computeError, algo->GetComputeError() );
}
catch ( ::SMESH_ComputeError& comperr ) {
_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;
}
if ( !_computeError ) _computeError = SMESH_ComputeError::New();
*_computeError = comperr;
}
@@
-1641,8
+1649,9
@@
bool SMESH_subMesh::ComputeStateEngine(compute_event event)
#ifdef PRINT_WHO_COMPUTE_WHAT
for (subS.ReInit(); subS.More(); subS.Next())
{
#ifdef PRINT_WHO_COMPUTE_WHAT
for (subS.ReInit(); subS.More(); subS.Next())
{
+ SMESH_MeshLocker myLocker(_father);
const std::list <const SMESHDS_Hypothesis *> & hyps =
const std::list <const SMESHDS_Hypothesis *> & hyps =
- _algo->GetUsedHypothesis( *_father, _subShape );
+
_algo->GetUsedHypothesis( *_father, _subShape );
SMESH_Comment hypStr;
if ( !hyps.empty() )
{
SMESH_Comment hypStr;
if ( !hyps.empty() )
{
@@
-1763,6
+1772,7
@@
bool SMESH_subMesh::ComputeStateEngine(compute_event event)
loadDependentMeshes();
ComputeSubMeshStateEngine( SUBMESH_LOADED );
//break;
loadDependentMeshes();
ComputeSubMeshStateEngine( SUBMESH_LOADED );
//break;
+ // fall through
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
@@
-1914,7
+1924,7
@@
bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap)
bool ret = true;
if (_subShape.ShapeType() == TopAbs_VERTEX) {
bool ret = true;
if (_subShape.ShapeType() == TopAbs_VERTEX) {
- vector<
int
> aVec(SMDSEntity_Last,0);
+ vector<
smIdType
> aVec(SMDSEntity_Last,0);
aVec[SMDSEntity_Node] = 1;
aResMap.insert(make_pair(this,aVec));
return ret;
aVec[SMDSEntity_Node] = 1;
aResMap.insert(make_pair(this,aVec));
return ret;
@@
-1941,7
+1951,7
@@
bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap)
SMESH_subMesh* sm = smIt->next();
int dim = SMESH_Gen::GetShapeDim( sm->GetSubShape() );
if (dim < dimToCheck) break; // the rest subMeshes are all of less dimension
SMESH_subMesh* sm = smIt->next();
int dim = SMESH_Gen::GetShapeDim( sm->GetSubShape() );
if (dim < dimToCheck) break; // the rest subMeshes are all of less dimension
- const vector<
int
> & nbs = aResMap[ sm ];
+ const vector<
smIdType
> & nbs = aResMap[ sm ];
subMeshEvaluated = (std::accumulate( nbs.begin(), nbs.end(), 0 ) > 0 );
}
if ( !subMeshEvaluated )
subMeshEvaluated = (std::accumulate( nbs.begin(), nbs.end(), 0 ) > 0 );
}
if ( !subMeshEvaluated )
@@
-1951,7
+1961,7
@@
bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap)
if ( IsMeshComputed() )
{
if ( IsMeshComputed() )
{
- vector<
int
> & nbEntities = aResMap[ this ];
+ vector<
smIdType
> & nbEntities = aResMap[ this ];
nbEntities.resize( SMDSEntity_Last, 0 );
if ( SMESHDS_SubMesh* sm = GetSubMeshDS() )
{
nbEntities.resize( SMDSEntity_Last, 0 );
if ( SMESHDS_SubMesh* sm = GetSubMeshDS() )
{
@@
-1965,7
+1975,7
@@
bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap)
{
ret = algo->Evaluate((*_father), _subShape, aResMap);
}
{
ret = algo->Evaluate((*_father), _subShape, aResMap);
}
- aResMap.insert( make_pair( this,vector<
int
>(0)));
+ aResMap.insert( make_pair( this,vector<
smIdType
>(0)));
}
return ret;
}
return ret;
@@
-2095,7
+2105,7
@@
void SMESH_subMesh::updateDependantsState(const compute_event theEvent)
//=======================================================================
//function : cleanDependants
//=======================================================================
//function : cleanDependants
-//purpose :
+//purpose :
//=======================================================================
void SMESH_subMesh::cleanDependants()
//=======================================================================
void SMESH_subMesh::cleanDependants()
@@
-2119,7
+2129,7
@@
void SMESH_subMesh::cleanDependants()
//=======================================================================
//function : removeSubMeshElementsAndNodes
//=======================================================================
//function : removeSubMeshElementsAndNodes
-//purpose :
+//purpose :
//=======================================================================
void SMESH_subMesh::removeSubMeshElementsAndNodes()
//=======================================================================
void SMESH_subMesh::removeSubMeshElementsAndNodes()
@@
-2149,7
+2159,7
@@
void SMESH_subMesh::removeSubMeshElementsAndNodes()
// meshed at once along with _subShape
//=======================================================================
// meshed at once along with _subShape
//=======================================================================
-TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen *
theGen
,
+TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen *
/*theGen*/
,
SMESH_Algo* theAlgo,
bool & theSubComputed,
bool & theSubFailed,
SMESH_Algo* theAlgo,
bool & theSubComputed,
bool & theSubFailed,
@@
-2181,10
+2191,13
@@
TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
{
SMESH_subMesh* subMesh = smIt->next();
const TopoDS_Shape& S = subMesh->_subShape;
{
SMESH_subMesh* subMesh = smIt->next();
const TopoDS_Shape& S = subMesh->_subShape;
- if ( S.ShapeType() != this->_subShape.ShapeType() )
+
+ if ( S.ShapeType() != this->_subShape.ShapeType() ){
continue;
continue;
- if ( _allowedSubShapes && !_allowedSubShapes->IsEmpty() && !_allowedSubShapes->Contains( S ))
+ }
+ if ( _allowedSubShapes && !_allowedSubShapes->IsEmpty() && !_allowedSubShapes->Contains( S )){
continue;
continue;
+ }
if ( subMesh == this )
{
aBuilder.Add( aCompound, S );
if ( subMesh == this )
{
aBuilder.Add( aCompound, S );
@@
-2193,6
+2206,7
@@
TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
else if ( subMesh->GetComputeState() == READY_TO_COMPUTE )
{
SMESH_Algo* anAlgo = subMesh->GetAlgo();
else if ( subMesh->GetComputeState() == READY_TO_COMPUTE )
{
SMESH_Algo* anAlgo = subMesh->GetAlgo();
+
if (( anAlgo->IsSameName( *theAlgo )) && // same algo
( anAlgo->GetUsedHypothesis( *_father, S, skipAuxHyps ) == usedHyps ) && // same hyps
( anAlgo->GetAssignedShapes() == assiShapes ) && // on same sub-shapes
if (( anAlgo->IsSameName( *theAlgo )) && // same algo
( anAlgo->GetUsedHypothesis( *_father, S, skipAuxHyps ) == usedHyps ) && // same hyps
( anAlgo->GetAssignedShapes() == assiShapes ) && // on same sub-shapes
@@
-2206,7
+2220,7
@@
TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
}
}
}
}
- return aCompound;
+ return
theSubs.size() == 1 ? theSubs[0]->GetSubShape() :
aCompound;
}
//=======================================================================
}
//=======================================================================
@@
-2245,10
+2259,10
@@
const SMESH_Hypothesis* SMESH_subMesh::getSimilarAttached(const TopoDS_Shape&
//=======================================================================
SMESH_Hypothesis::Hypothesis_Status
//=======================================================================
SMESH_Hypothesis::Hypothesis_Status
- SMESH_subMesh::CheckConcurrentHypothesis
(const int theHypType
)
+ SMESH_subMesh::CheckConcurrentHypothesis
( SMESH_Hypothesis* theHypothesis
)
{
// is there local hypothesis on me?
{
// is there local hypothesis on me?
- if ( getSimilarAttached( _subShape,
0, theHypType
) )
+ if ( getSimilarAttached( _subShape,
theHypothesis
) )
return SMESH_Hypothesis::HYP_OK;
return SMESH_Hypothesis::HYP_OK;
@@
-2258,7
+2272,7
@@
SMESH_Hypothesis::Hypothesis_Status
for (; it.More(); it.Next())
{
const TopoDS_Shape& ancestor = it.Value();
for (; it.More(); it.Next())
{
const TopoDS_Shape& ancestor = it.Value();
- const SMESH_Hypothesis* hyp = getSimilarAttached( ancestor,
0, theHypType
);
+ const SMESH_Hypothesis* hyp = getSimilarAttached( ancestor,
theHypothesis
);
if ( hyp )
{
if ( aPrevWithHyp.IsNull() || aPrevWithHyp.IsSame( ancestor ))
if ( hyp )
{
if ( aPrevWithHyp.IsNull() || aPrevWithHyp.IsSame( ancestor ))
@@
-2295,7
+2309,7
@@
SMESH_subMesh::OwnListenerData::OwnListenerData( SMESH_subMesh* sm, EventListene
* \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
* \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.
* 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.
@@
-2317,7
+2331,7
@@
void SMESH_subMesh::SetEventListener(EventListener* listener,
* \brief Sets an event listener and its data to a submesh
* \param listener - the listener to store
* \param data - the listener data to store
* \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.
*/
//================================================================================
* After being set, event listener is notified on each event of a submesh.
*/
//================================================================================
@@
-2527,7
+2541,7
@@
void SMESH_subMesh::loadDependentMeshes()
* \param subMesh - the submesh where the event occurs
* \param data - listener data stored in the subMesh
* \param hyp - hypothesis, if eventType is algo_event
* \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.
* 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.