-// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2021 CEA/DEN, EDF R&D, 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_subMeshEventListener.hxx"
#include "utilities.h"
-#include "OpUtil.hxx"
#include "Basics_Utils.hxx"
#include <BRep_Builder.hxx>
}
_computeCost = 0; // how costly is to compute this sub-mesh
_realComputeCost = 0;
+ _allowedSubShapes = nullptr;
}
//=============================================================================
return false;
}
+//================================================================================
+/*!
+ * \brief Check if any upper level sub-shape is not computed.
+ * Used to update a sub-mesh icon
+ */
+//================================================================================
+
+bool SMESH_subMesh::IsComputedPartially() const
+{
+ SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(/*includeSelf=*/true,
+ /*SolidFirst=*/true);
+ bool allComputed = true;
+ TopAbs_ShapeEnum readyType = TopAbs_VERTEX; // max value
+ while ( smIt->more() && allComputed )
+ {
+ SMESH_subMesh* sm = smIt->next();
+
+ if ( sm->GetSubShape().ShapeType() > readyType )
+ break; // lower dimension -> stop
+ if ( sm->GetComputeState() != SMESH_subMesh::NOT_READY )
+ readyType = sm->GetSubShape().ShapeType();
+
+ switch ( sm->GetComputeState() )
+ {
+ case SMESH_subMesh::READY_TO_COMPUTE:
+ case SMESH_subMesh::FAILED_TO_COMPUTE:
+ allComputed = false;// sm->IsMeshComputed();
+ break;
+ case SMESH_subMesh::NOT_READY:
+ case SMESH_subMesh::COMPUTE_OK:
+ continue;
+ }
+ }
+ return !allComputed;
+}
+
//=============================================================================
/*!
* Return true if all sub-meshes have been meshed
* \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?
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 );
- int nbNodes = subMeshDS->NbNodes();
+ smIdType nbNodes = subMeshDS->NbNodes();
if ( nbNodes > 0 )
for ( SMDS_NodeIteratorPtr itn = subMeshDS->GetNodes(); itn->more() ; )
{
else if (( event == COMPUTE || event == COMPUTE_SUBMESH )
&& !_alwaysComputed )
{
+ _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();
}
if ( event == MODIF_ALGO_STATE )
cleanDependants();
loadDependentMeshes();
ComputeSubMeshStateEngine( SUBMESH_LOADED );
//break;
+ // fall through
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
}
break;
}
+ // fall through
case COMPUTE:
case COMPUTE_SUBMESH:
{
+ _father->Lock();
algo = GetAlgo();
ASSERT(algo);
ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
if (_father->HasShapeToMesh() ) {
bool subComputed = false, subFailed = false;
if (!algo->OnlyUnaryInput()) {
- if ( event == COMPUTE /*&&
- ( algo->NeedDiscreteBoundary() || algo->SupportSubmeshes() )*/)
- shape = getCollection( gen, algo, subComputed, subFailed, algo->SubMeshesToCompute());
- else
- subComputed = SubMeshesComputed( & subFailed );
+ // --- commented for bos#22320 to compute all sub-shapes at once if possible;
+ // --- in case COMPUTE_SUBMESH, set of sub-shapes is limited
+ // --- by calling SetAllowedSubShapes()
+ // if ( event == COMPUTE )
+ // shape = getCollection( gen, algo, subComputed, subFailed, algo->SubMeshesToComput;
+ // else
+ // subComputed = SubMeshesComputed( & subFailed );
+ shape = getCollection( gen, algo, subComputed, subFailed, algo->SubMeshesToCompute());
}
else {
subComputed = SubMeshesComputed();
break; // goto exit
}
}
+ _father->Unlock();
// Compute
// to restore cout that may be redirected by algo
}
else
{
+ std::cout<<"Running compute for " << _father << " of shape type " << shape.ShapeType() << std::endl;
ret = algo->Compute((*_father), shape);
}
// algo can set _computeError of submesh
((SMESHDS_Hypothesis*)hyps.front())->SaveTo( hypStr.Stream() );
hypStr << " ";
}
- cout << _algo->GetName()
- << " " << _father->GetSubMesh( subS.Current() )->GetId()
+ cout << _father->GetSubMesh( subS.Current() )->GetId()
+ << " " << ( ret ? "OK" : "FAIL" )
+ << " " << _algo->GetName()
<< " " << hypStr << endl;
}
#endif
updateDependantsState( SUBMESH_COMPUTED );
}
// let algo clear its data gathered while algo->Compute()
+ _father->Lock();
algo->CheckHypothesis((*_father), _subShape, hyp_status);
+ _father->Unlock();
}
break;
case COMPUTE_CANCELED: // nothing to do
loadDependentMeshes();
ComputeSubMeshStateEngine( SUBMESH_LOADED );
//break;
+ // fall through
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
break;
case COMPUTE: // nothing to do
break;
+ case COMPUTE_SUBMESH: // nothing to do
+ break;
case COMPUTE_CANCELED: // nothing to do
break;
case CLEAN:
break;
}
- notifyListenersOnEvent( event, COMPUTE_EVENT );
+ //notifyListenersOnEvent( event, COMPUTE_EVENT );
return ret;
}
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;
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 )
if ( IsMeshComputed() )
{
- vector<int> & nbEntities = aResMap[ this ];
+ vector<smIdType> & nbEntities = aResMap[ this ];
nbEntities.resize( SMDSEntity_Last, 0 );
if ( SMESHDS_SubMesh* sm = GetSubMeshDS() )
{
{
ret = algo->Evaluate((*_father), _subShape, aResMap);
}
- aResMap.insert( make_pair( this,vector<int>(0)));
+ aResMap.insert( make_pair( this,vector<smIdType>(0)));
}
return ret;
//=======================================================================
//function : cleanDependants
-//purpose :
+//purpose :
//=======================================================================
void SMESH_subMesh::cleanDependants()
//=======================================================================
//function : removeSubMeshElementsAndNodes
-//purpose :
+//purpose :
//=======================================================================
void SMESH_subMesh::removeSubMeshElementsAndNodes()
// 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,
const TopoDS_Shape& S = subMesh->_subShape;
if ( S.ShapeType() != this->_subShape.ShapeType() )
continue;
+ if ( _allowedSubShapes && !_allowedSubShapes->IsEmpty() && !_allowedSubShapes->Contains( S ))
+ continue;
if ( subMesh == this )
{
aBuilder.Add( aCompound, S );
}
}
- return aCompound;
+ return theSubs.size() == 1 ? theSubs[0]->GetSubShape() : aCompound;
}
//=======================================================================
* \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.
