-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2022 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_SMESH.hxx"
-#include "SMESHDS_Mesh.hxx"
-#include "SMESHDS_SubMesh.hxx"
-#include "SMESH_Hypothesis.hxx"
+#include "SMDS_Iterator.hxx"
#include "SMESH_ComputeError.hxx"
#include "SMESH_Algo.hxx"
#include "Utils_SALOME_Exception.hxx"
#include <TopoDS_Shape.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
#include <list>
#include <map>
-class SMESH_Mesh;
-class SMESH_Hypothesis;
+class SMESHDS_Mesh;
+class SMESHDS_SubMesh;
class SMESH_Algo;
class SMESH_Gen;
-class SMESH_subMeshEventListener;
-class SMESH_subMeshEventListenerData;
+class SMESH_Hypothesis;
+class SMESH_Mesh;
class SMESH_subMesh;
+class SMESH_subMeshEventListener;
+struct SMESH_subMeshEventListenerData;
typedef SMESH_subMeshEventListener EventListener;
typedef SMESH_subMeshEventListenerData EventListenerData;
const std::map < int, SMESH_subMesh * >& DependsOn();
bool DependsOn( const SMESH_subMesh* other ) const;
+ bool DependsOn( const int shapeID ) const;
/*!
* \brief Return iterator on the sub-meshes this one depends on. By default
* most simple sub-meshes go first.
enum compute_state
{
- NOT_READY, READY_TO_COMPUTE,
- COMPUTE_OK, FAILED_TO_COMPUTE
+ NOT_READY, READY_TO_COMPUTE, COMPUTE_OK, FAILED_TO_COMPUTE
};
enum algo_state
{
};
enum compute_event
{
- MODIF_ALGO_STATE, COMPUTE, COMPUTE_SUBMESH, COMPUTE_CANCELED,
+ MODIF_ALGO_STATE, COMPUTE, COMPUTE_SUBMESH, COMPUTE_NOGEOM, COMPUTE_CANCELED,
CLEAN, SUBMESH_COMPUTED, SUBMESH_RESTORED, SUBMESH_LOADED,
MESH_ENTITY_REMOVED, CHECK_COMPUTE_STATE
};
};
// ==================================================================
- // Members to track non hierarchical dependencies between submeshes
+ // Members to track non hierarchical dependencies between sub-meshes
// ==================================================================
/*!
- * \brief Sets an event listener and its data to a submesh
+ * \brief Set an event listener and its data to a submesh
* \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
void setEventListener(EventListener* listener, EventListenerData* data);
/*!
- * \brief Notify stored event listeners on the occured event
+ * \brief Notify stored event listeners on the occurred event
* \param event - algo_event or compute_event itself
* \param eventType - algo_event or compute_event
* \param hyp - hypothesis, if eventType is algo_event
public:
SMESH_Hypothesis::Hypothesis_Status
- AlgoStateEngine(int event, SMESH_Hypothesis * anHyp);
+ AlgoStateEngine(algo_event event, SMESH_Hypothesis * anHyp);
SMESH_Hypothesis::Hypothesis_Status
- SubMeshesAlgoStateEngine(int event, SMESH_Hypothesis * anHyp, bool exitOnFatal=false);
+ SubMeshesAlgoStateEngine(algo_event event, SMESH_Hypothesis * anHyp, bool exitOnFatal=false);
algo_state GetAlgoState() const { return _algoState; }
compute_state GetComputeState() const { return _computeState; }
void DumpAlgoState(bool isMain);
- bool ComputeStateEngine(int event);
- void ComputeSubMeshStateEngine(int event, const bool includeSelf=false);
+ bool ComputeStateEngine(compute_event event);
+ void ComputeSubMeshStateEngine(compute_event event, const bool includeSelf=false);
bool Evaluate(MapShapeNbElems& aResMap);
bool CanAddHypothesis(const SMESH_Hypothesis* theHypothesis) const;
// return true if theHypothesis can be attached to me:
- // its dimention is checked
+ // its dimension is checked
- static bool IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis,
+ static bool IsApplicableHypothesis(const SMESH_Hypothesis* theHypothesis,
const TopAbs_ShapeEnum theShapeType);
- bool IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis) const
- { return IsApplicableHypotesis( theHypothesis, _subShape.ShapeType() ); }
+ bool IsApplicableHypothesis(const SMESH_Hypothesis* theHypothesis) const;
// return true if theHypothesis can be used to mesh me:
// its shape type is checked
- SMESH_Hypothesis::Hypothesis_Status CheckConcurentHypothesis (const int theHypType);
+ SMESH_Hypothesis::Hypothesis_Status CheckConcurrentHypothesis (const int theHypType);
// check if there are several applicable hypothesis on fathers
/*!
bool IsMeshComputed() const;
// check if _subMeshDS contains mesh elements unless _alwaysComputed==true
+ bool IsComputedPartially() const;
+ // check if any upper level sub-shape is not computed
+
+ /*!
+ * \brief Set sub-shapes that are allowed to compute at once by a multidimensional algo
+ */
+ void SetAllowedSubShapes( const TopTools_IndexedMapOfShape* subShapes )
+ { _allowedSubShapes = subShapes; }
+
/*!
* \brief Allow algo->Compute() if a subshape of lower dim is meshed but
* none mesh entity is bound to it
*/
void SetIsAlwaysComputed(bool isAlCo);
- bool IsAlwaysComputed() { return _alwaysComputed; }
+ bool IsAlwaysComputed() const { return _alwaysComputed; }
bool SubMeshesComputed(bool * isFailedToCompute=0) const;
protected:
// ==================================================================
- void insertDependence(const TopoDS_Shape aShape, TopAbs_ShapeEnum aSubType );
+ void insertDependence(const TopoDS_Shape aShape,
+ TopAbs_ShapeEnum aSubType,
+ TopAbs_ShapeEnum avoidType=TopAbs_SHAPE);
void removeSubMeshElementsAndNodes();
void updateDependantsState(const compute_event theEvent);
std::vector< SMESH_subMesh * > _ancestors;
SMESH_Algo * _algo; // the algorithm found by last *StateEngine() call
+ TopoDS_Shape _algoShape; // shape the algorithm is assigned to
algo_state _algoState;
compute_state _computeState;
SMESH_ComputeErrorPtr _computeError;
// mesh several edges as a whole and leave some of them without mesh entities
bool _alwaysComputed;
+ const TopTools_IndexedMapOfShape* _allowedSubShapes; // allowed to be returned by getCollection()
+
};
#endif
