Back to index

salome-smesh  6.5.0
Classes | Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Protected Types | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | Friends
SMESH_EXPORT Protocol Reference

Root of all algorithms. More...

#include <SMESH_0D_Algo.hxx>

Inheritance diagram for SMESH_EXPORT:
Inheritance graph
[legend]
Collaboration diagram for SMESH_EXPORT:
Collaboration graph
[legend]

List of all members.

Classes

struct  ApplicablePredicate
struct  DimPredicate
struct  ExtrusParam
 special structure for control of extrusion functionality More...
struct  InstancePredicate
struct  IsAssignedToPredicate
struct  IsAuxiliaryPredicate
struct  IsMoreLocalThanPredicate
struct  NamePredicate
struct  OwnListenerData
struct  SMESH_MeshEditor_PathPoint
class  SubMesh
 Proxy sub-mesh. More...
struct  TAlgoStateError
struct  TCallUp
struct  TDefaults
struct  templPredicate
struct  TPoint
struct  TypePredicate

Public Types

enum  EMeshError { MEr_OK = 0, MEr_HOLES, MEr_BAD_ORI, MEr_EMPTY }
enum  Hypothesis_Status {
  HYP_OK = 0, HYP_MISSING, HYP_CONCURENT, HYP_BAD_PARAMETER,
  HYP_HIDDEN_ALGO, HYP_HIDING_ALGO, HYP_UNKNOWN_FATAL, HYP_INCOMPATIBLE,
  HYP_NOTCONFORM, HYP_ALREADY_EXIST, HYP_BAD_DIM, HYP_BAD_SUBSHAPE,
  HYP_BAD_GEOMETRY, HYP_NEED_SHAPE
}
enum  SplitVolumToTetraFlags { HEXA_TO_5 = 1, HEXA_TO_6 = 2, HEXA_TO_24 = 3 }
enum  SmoothMethod { LAPLACIAN = 0, CENTROIDAL }
enum  ExtrusionFlags { EXTRUSION_FLAG_BOUNDARY = 0x01, EXTRUSION_FLAG_SEW = 0x02 }
 Auxilary flag for advanced extrusion. More...
enum  Extrusion_Error {
  EXTR_OK, EXTR_NO_ELEMENTS, EXTR_PATH_NOT_EDGE, EXTR_BAD_PATH_SHAPE,
  EXTR_BAD_STARTING_NODE, EXTR_BAD_ANGLES_NUMBER, EXTR_CANT_GET_TANGENT
}
enum  Sew_Error {
  SEW_OK, SEW_BORDER1_NOT_FOUND, SEW_BORDER2_NOT_FOUND, SEW_BOTH_BORDERS_NOT_FOUND,
  SEW_BAD_SIDE_NODES, SEW_VOLUMES_TO_SPLIT, SEW_DIFF_NB_OF_ELEMENTS, SEW_TOPO_DIFF_SETS_OF_ELEMENTS,
  SEW_BAD_SIDE1_NODES, SEW_BAD_SIDE2_NODES, SEW_INTERNAL_ERROR
}
enum  Bnd_Dimension { BND_2DFROM3D, BND_1DFROM3D, BND_1DFROM2D }
enum  MType { LINEAR, QUADRATIC, COMP }
 Check mesh without geometry for: if all elements on this shape are quadratic, quadratic elements will be created. More...
enum  ErrorCode {
  ERR_OK, ERR_READ_NB_POINTS, ERR_READ_POINT_COORDS, ERR_READ_TOO_FEW_POINTS,
  ERR_READ_3D_COORD, ERR_READ_NO_KEYPOINT, ERR_READ_BAD_INDEX, ERR_READ_ELEM_POINTS,
  ERR_READ_NO_ELEMS, ERR_READ_BAD_KEY_POINT, ERR_SAVE_NOT_LOADED, ERR_LOAD_EMPTY_SUBMESH,
  ERR_LOADF_NARROW_FACE, ERR_LOADF_CLOSED_FACE, ERR_LOADF_CANT_PROJECT, ERR_LOADV_BAD_SHAPE,
  ERR_LOADV_COMPUTE_PARAMS, ERR_APPL_NOT_COMPUTED, ERR_APPL_NOT_LOADED, ERR_APPL_BAD_DIMENTION,
  ERR_APPL_BAD_NB_VERTICES, ERR_APPLF_BAD_TOPOLOGY, ERR_APPLF_BAD_VERTEX, ERR_APPLF_INTERNAL_EEROR,
  ERR_APPLV_BAD_SHAPE, ERR_APPLF_BAD_FACE_GEOM, ERR_MAKEM_NOT_COMPUTED, ERR_UNEXPECTED
}
enum  compute_state { NOT_READY, READY_TO_COMPUTE, COMPUTE_OK, FAILED_TO_COMPUTE }
enum  algo_state { NO_ALGO, MISSING_HYP, HYP_OK = 0 }
enum  algo_event {
  ADD_HYP, ADD_ALGO, REMOVE_HYP, REMOVE_ALGO,
  ADD_FATHER_HYP, ADD_FATHER_ALGO, REMOVE_FATHER_HYP, REMOVE_FATHER_ALGO,
  MODIF_HYP
}
enum  compute_event {
  MODIF_ALGO_STATE, COMPUTE, CLEAN, SUBMESH_COMPUTED,
  SUBMESH_RESTORED, SUBMESH_LOADED, MESH_ENTITY_REMOVED, CHECK_COMPUTE_STATE
}
enum  event_type { ALGO_EVENT, COMPUTE_EVENT }
typedef
TopTools_IndexedDataMapOfShapeListOfShape 
TAncestorMap
 Return data map of descendant to ancestor shapes.
typedef boost::shared_ptr
< SMDS_Iterator< SMESH_Group * > > 
GroupIteratorPtr
typedef std::auto_ptr
< std::list< int > > 
PGroupIDs
typedef std::list< std::list
< const SMDS_MeshNode * > > 
TListOfListOfNodes
typedef std::list< std::list
< int > > 
TListOfListOfElementsID
typedef boost::shared_ptr
< SMESH_ProxyMesh
Ptr
typedef std::map< const
SMDS_MeshNode *, const
SMDS_MeshNode *, TIDCompare
TN2NMap

Public Member Functions

 SMESH_0D_Algo (int hypId, int studyId, SMESH_Gen *gen)
virtual ~SMESH_0D_Algo ()
 SMESH_1D_Algo (int hypId, int studyId, SMESH_Gen *gen)
virtual ~SMESH_1D_Algo ()
 SMESH_2D_Algo (int hypId, int studyId, SMESH_Gen *gen)
virtual ~SMESH_2D_Algo ()
int NumberOfWires (const TopoDS_Shape &S)
int NumberOfPoints (SMESH_Mesh &aMesh, const TopoDS_Wire &W)
 SMESH_3D_Algo (int hypId, int studyId, SMESH_Gen *gen)
virtual ~SMESH_3D_Algo ()
 SMESH_Algo (int hypId, int studyId, SMESH_Gen *gen)
 Creates algorithm.
virtual ~SMESH_Algo ()
 Destructor.
virtual std::ostream & SaveTo (std::ostream &save)
 Saves nothing in a stream.
virtual std::istream & LoadFrom (std::istream &load)
 Loads nothing from a stream.
const std::vector< std::string > & GetCompatibleHypothesis ()
 Returns all types of compatible hypotheses.
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)=0
 Check hypothesis definition to mesh a shape.
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)=0
 Computes mesh on a shape.
virtual bool Compute (SMESH_Mesh &aMesh, SMESH_MesherHelper *aHelper)
 Computes mesh without geometry.
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)=0
 evaluates size of prospective mesh on a shape
virtual const std::list< const
SMESHDS_Hypothesis * > & 
GetUsedHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, const bool ignoreAuxiliary=true)
 Returns a list of compatible hypotheses used to mesh a shape.
const list< const
SMESHDS_Hypothesis * > & 
GetAppliedHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, const bool ignoreAuxiliary=true)
 Returns a list of compatible hypotheses assigned to a shape in a mesh.
bool InitCompatibleHypoFilter (SMESH_HypoFilter &theFilter, const bool ignoreAuxiliary) const
 Make the filter recognize only compatible hypotheses.
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Just return false as the algorithm does not hold parameters values.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
SMESH_ComputeErrorPtr GetComputeError () const
 return compute error
void InitComputeError ()
 initialize compute error
bool OnlyUnaryInput () const
bool NeedDiscreteBoundary () const
bool NeedShape () const
bool SupportSubmeshes () const
virtual void SetEventListener (SMESH_subMesh *subMesh)
 Sets event listener to submeshes if necessary.
virtual void SubmeshRestored (SMESH_subMesh *subMesh)
 Allow algo to do something after persistent restoration.
 SMESH_Gen ()
 ~SMESH_Gen ()
SMESH_MeshCreateMesh (int theStudyId, bool theIsEmbeddedMode) throw (SALOME_Exception)
bool Compute (::SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, const bool anUpward=false, const ::MeshDimension aDim=::MeshDim_3D, TSetOfInt *aShapesId=0)
 Computes aMesh on aShape.
bool Evaluate (::SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap, const bool anUpward=false, TSetOfInt *aShapesId=0)
 evaluates size of prospective mesh on a shape
bool CheckAlgoState (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
void SetBoundaryBoxSegmentation (int theNbSegments)
 Sets number of segments per diagonal of boundary box of geometry by which default segment length of appropriate 1D hypotheses is defined.
int GetBoundaryBoxSegmentation () const
void SetDefaultNbSegments (int nb)
 Sets default number of segments per edge.
int GetDefaultNbSegments () const
bool GetAlgoState (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, std::list< SMESH_Gen::TAlgoStateError > &theErrors)
StudyContextStructGetStudyContext (int studyId)
SMESH_AlgoGetAlgo (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, TopoDS_Shape *assignedTo=0)
int GetANewId ()
 SMESH_Group (int theID, const SMESH_Mesh *theMesh, const SMDSAbs_ElementType theType, const char *theName, const TopoDS_Shape &theShape=TopoDS_Shape(), const SMESH_PredicatePtr &thePredicate=SMESH_PredicatePtr())
 SMESH_Group (SMESHDS_GroupBase *groupDS)
 ~SMESH_Group ()
void SetName (const char *theName)
const char * GetName () const
SMESHDS_GroupBase * GetGroupDS ()
virtual bool IsOk (const SMESH_Hypothesis *aHyp, const TopoDS_Shape &aShape) const =0
virtual ~SMESH_HypoPredicate ()
 SMESH_HypoFilter ()
 SMESH_HypoFilter (SMESH_HypoPredicate *aPredicate, bool notNagate=true)
SMESH_HypoFilterInit (SMESH_HypoPredicate *aPredicate, bool notNagate=true)
SMESH_HypoFilterAnd (SMESH_HypoPredicate *aPredicate)
SMESH_HypoFilterAndNot (SMESH_HypoPredicate *aPredicate)
SMESH_HypoFilterOr (SMESH_HypoPredicate *aPredicate)
SMESH_HypoFilterOrNot (SMESH_HypoPredicate *aPredicate)
bool IsEmpty () const
bool IsOk (const SMESH_Hypothesis *aHyp, const TopoDS_Shape &aShape) const
 check aHyp or/and aShape it is assigned to
bool IsAny () const
 return true if contains no predicates
 ~SMESH_HypoFilter ()
 SMESH_Hypothesis (int hypId, int studyId, SMESH_Gen *gen)
virtual ~SMESH_Hypothesis ()
virtual int GetDim () const
int GetStudyId () const
virtual void NotifySubMeshesHypothesisModification ()
virtual int GetShapeType () const
virtual const char * GetLibName () const
void SetLibName (const char *theLibName)
void SetParameters (const char *theParameters)
char * GetParameters () const
void SetLastParameters (const char *theParameters)
char * GetLastParameters () const
void ClearParameters ()
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)=0
 Initialize my parameter values by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)=0
 Initialize my parameter values by default parameters.
virtual bool IsAuxiliary () const
 Return true if me is an auxiliary hypothesis.
SMESH_MeshGetMeshByPersistentID (int id)
 Find a mesh with given persistent ID.
 SMESH_Mesh (int theLocalId, int theStudyId, SMESH_Gen *theGen, bool theIsEmbeddedMode, SMESHDS_Document *theDocument)
virtual ~SMESH_Mesh ()
void ShapeToMesh (const TopoDS_Shape &aShape)
 Set geometry to be meshed.
TopoDS_Shape GetShapeToMesh () const
 Return geometry to be meshed.
bool HasShapeToMesh () const
 Return true if there is a geometry to be meshed, not PseudoShape()
double GetShapeDiagonalSize () const
 Return diagonal size of bounding box of shape to mesh.
void Load ()
 Load mesh from study file.
void Clear ()
 Remove all nodes and elements.
void ClearSubMesh (const int theShapeId)
 Remove all nodes and elements of indicated shape.
int UNVToMesh (const char *theFileName)
 consult DriverMED_R_SMESHDS_Mesh::ReadStatus for returned value
int MEDToMesh (const char *theFileName, const char *theMeshName)
int STLToMesh (const char *theFileName)
int CGNSToMesh (const char *theFileName, const int theMeshIndex, std::string &theMeshName)
SMESH_Hypothesis::Hypothesis_Status AddHypothesis (const TopoDS_Shape &aSubShape, int anHypId) throw (SALOME_Exception)
SMESH_Hypothesis::Hypothesis_Status RemoveHypothesis (const TopoDS_Shape &aSubShape, int anHypId) throw (SALOME_Exception)
const std::list< const
SMESHDS_Hypothesis * > & 
GetHypothesisList (const TopoDS_Shape &aSubShape) const throw (SALOME_Exception)
const SMESH_HypothesisGetHypothesis (const TopoDS_Shape &aSubShape, const SMESH_HypoFilter &aFilter, const bool andAncestors, TopoDS_Shape *assignedTo=0) const
int GetHypotheses (const TopoDS_Shape &aSubShape, const SMESH_HypoFilter &aFilter, std::list< const SMESHDS_Hypothesis * > &aHypList, const bool andAncestors) const
const std::list
< SMESHDS_Command * > & 
GetLog () throw (SALOME_Exception)
void ClearLog () throw (SALOME_Exception)
int GetId () const
bool MeshExists (int meshId) const
SMESHDS_Mesh * GetMeshDS ()
const SMESHDS_Mesh * GetMeshDS () const
SMESH_GenGetGen ()
SMESH_subMeshGetSubMesh (const TopoDS_Shape &aSubShape) throw (SALOME_Exception)
SMESH_subMeshGetSubMeshContaining (const TopoDS_Shape &aSubShape) const throw (SALOME_Exception)
SMESH_subMeshGetSubMeshContaining (const int aShapeID) const throw (SALOME_Exception)
std::list< SMESH_subMesh * > GetGroupSubMeshesContaining (const TopoDS_Shape &shape) const throw (SALOME_Exception)
 Return submeshes of groups containing the given subshape.
void NotifySubMeshesHypothesisModification (const SMESH_Hypothesis *theChangedHyp)
 Say all submeshes that theChangedHyp has been modified.
const std::list< SMESH_subMesh * > & GetSubMeshUsingHypothesis (SMESHDS_Hypothesis *anHyp) throw (SALOME_Exception)
bool IsUsedHypothesis (SMESHDS_Hypothesis *anHyp, const SMESH_subMesh *aSubMesh)
 Return True if anHyp is used to mesh aSubShape.
bool IsNotConformAllowed () const
 check if a hypothesis alowing notconform mesh is present
bool IsMainShape (const TopoDS_Shape &theShape) const
const TopTools_ListOfShape & GetAncestors (const TopoDS_Shape &theSubShape) const
 Return list of ancestors of theSubShape in the order that lower dimention shapes come first.
void SetAutoColor (bool theAutoColor) throw (SALOME_Exception)
bool GetAutoColor () throw (SALOME_Exception)
void SetIsModified (bool isModified)
 Set the flag meaning that the mesh has been edited "manually".
bool GetIsModified () const
bool HasModificationsToDiscard () const
 Return true if the mesh has been edited since a total re-compute and those modifications may prevent successful partial re-compute.
const TAncestorMapGetAncestorMap () const
bool HasDuplicatedGroupNamesMED ()
 Check group names for duplications.
void ExportMED (const char *file, const char *theMeshName=NULL, bool theAutoGroups=true, int theVersion=0, const SMESHDS_Mesh *meshPart=0) throw (SALOME_Exception)
void ExportDAT (const char *file, const SMESHDS_Mesh *meshPart=0) throw (SALOME_Exception)
void ExportUNV (const char *file, const SMESHDS_Mesh *meshPart=0) throw (SALOME_Exception)
void ExportSTL (const char *file, const bool isascii, const SMESHDS_Mesh *meshPart=0) throw (SALOME_Exception)
void ExportCGNS (const char *file, const SMESHDS_Mesh *mesh)
void ExportSAUV (const char *file, const char *theMeshName=NULL, bool theAutoGroups=true) throw (SALOME_Exception)
int NbNodes () const throw (SALOME_Exception)
int Nb0DElements () const throw (SALOME_Exception)
int NbEdges (SMDSAbs_ElementOrder order=ORDER_ANY) const throw (SALOME_Exception)
int NbFaces (SMDSAbs_ElementOrder order=ORDER_ANY) const throw (SALOME_Exception)
int NbTriangles (SMDSAbs_ElementOrder order=ORDER_ANY) const throw (SALOME_Exception)
int NbQuadrangles (SMDSAbs_ElementOrder order=ORDER_ANY) const throw (SALOME_Exception)
int NbBiQuadQuadrangles () const throw (SALOME_Exception)
int NbPolygons () const throw (SALOME_Exception)
int NbVolumes (SMDSAbs_ElementOrder order=ORDER_ANY) const throw (SALOME_Exception)
int NbTetras (SMDSAbs_ElementOrder order=ORDER_ANY) const throw (SALOME_Exception)
int NbHexas (SMDSAbs_ElementOrder order=ORDER_ANY) const throw (SALOME_Exception)
int NbTriQuadraticHexas () const throw (SALOME_Exception)
int NbPyramids (SMDSAbs_ElementOrder order=ORDER_ANY) const throw (SALOME_Exception)
int NbPrisms (SMDSAbs_ElementOrder order=ORDER_ANY) const throw (SALOME_Exception)
int NbHexagonalPrisms () const throw (SALOME_Exception)
int NbPolyhedrons () const throw (SALOME_Exception)
int NbSubMesh () const throw (SALOME_Exception)
int NbGroup () const
SMESH_GroupAddGroup (const SMDSAbs_ElementType theType, const char *theName, int &theId, const TopoDS_Shape &theShape=TopoDS_Shape(), const SMESH_PredicatePtr &thePredicate=SMESH_PredicatePtr())
GroupIteratorPtr GetGroups () const
std::list< int > GetGroupIds () const
SMESH_GroupGetGroup (const int theGroupID)
bool RemoveGroup (const int theGroupID)
SMESH_GroupConvertToStandalone (int theGroupID)
void SetCallUp (TCallUp *upCaller)
bool SynchronizeGroups ()
SMDSAbs_ElementType GetElementType (const int id, const bool iselem)
void ClearMeshOrder ()
void SetMeshOrder (const TListOfListOfInt &theOrder)
const TListOfListOfIntGetMeshOrder () const
bool SortByMeshOrder (std::list< SMESH_subMesh * > &theListToSort) const
 sort submeshes according to stored mesh order
ostream & Dump (ostream &save)
 SMESH_MeshEditor (SMESH_Mesh *theMesh)
SMDS_MeshElement * AddElement (const std::vector< const SMDS_MeshNode * > &nodes, const SMDSAbs_ElementType type, const bool isPoly, const int ID=-1)
 Add element.
SMDS_MeshElement * AddElement (const std::vector< int > &nodeIDs, const SMDSAbs_ElementType type, const bool isPoly, const int ID=-1)
 Add element.
int Remove (const std::list< int > &theElemIDs, const bool isNodes)
bool InverseDiag (const SMDS_MeshElement *theTria1, const SMDS_MeshElement *theTria2)
bool InverseDiag (const SMDS_MeshNode *theNode1, const SMDS_MeshNode *theNode2)
bool DeleteDiag (const SMDS_MeshNode *theNode1, const SMDS_MeshNode *theNode2)
bool Reorient (const SMDS_MeshElement *theElement)
bool TriToQuad (TIDSortedElemSet &theElems, SMESH::Controls::NumericalFunctorPtr theCriterion, const double theMaxAngle)
 Fuse neighbour triangles into quadrangles.
bool QuadToTri (TIDSortedElemSet &theElems, SMESH::Controls::NumericalFunctorPtr theCriterion)
 Split quadrangles into triangles.
bool QuadToTri (TIDSortedElemSet &theElems, const bool the13Diag)
 Split quadrangles into triangles.
int BestSplit (const SMDS_MeshElement *theQuad, SMESH::Controls::NumericalFunctorPtr theCriterion)
 Find better diagonal for splitting.
void SplitVolumesIntoTetra (const TIDSortedElemSet &theElems, const int theMethodFlags)
 Split volumic elements into tetrahedra.
void Smooth (TIDSortedElemSet &theElements, std::set< const SMDS_MeshNode * > &theFixedNodes, const SmoothMethod theSmoothMethod, const int theNbIterations, double theTgtAspectRatio=1.0, const bool the2D=true)
PGroupIDs RotationSweep (TIDSortedElemSet &theElements, const gp_Ax1 &theAxis, const double theAngle, const int theNbSteps, const double theToler, const bool theMakeGroups, const bool theMakeWalls=true)
const SMDS_MeshNode * CreateNode (const double x, const double y, const double z, const double tolnode, SMESH_SequenceOfNode &aNodes)
 Create new node in the mesh with given coordinates (auxiliary for advanced extrusion)
PGroupIDs ExtrusionSweep (TIDSortedElemSet &theElems, const gp_Vec &theStep, const int theNbSteps, TElemOfElemListMap &newElemsMap, const bool theMakeGroups, const int theFlags=EXTRUSION_FLAG_BOUNDARY, const double theTolerance=1.e-6)
 Generate new elements by extrusion of theElements It is a method used in .idl file.
PGroupIDs ExtrusionSweep (TIDSortedElemSet &theElems, ExtrusParam &theParams, TElemOfElemListMap &newElemsMap, const bool theMakeGroups, const int theFlags, const double theTolerance)
 Generate new elements by extrusion of theElements.
Extrusion_Error ExtrusionAlongTrack (TIDSortedElemSet &theElements, SMESH_subMesh *theTrackPattern, const SMDS_MeshNode *theNodeStart, const bool theHasAngles, std::list< double > &theAngles, const bool theLinearVariation, const bool theHasRefPoint, const gp_Pnt &theRefPoint, const bool theMakeGroups)
Extrusion_Error ExtrusionAlongTrack (TIDSortedElemSet &theElements, SMESH_Mesh *theTrackPattern, const SMDS_MeshNode *theNodeStart, const bool theHasAngles, std::list< double > &theAngles, const bool theLinearVariation, const bool theHasRefPoint, const gp_Pnt &theRefPoint, const bool theMakeGroups)
PGroupIDs Transform (TIDSortedElemSet &theElements, const gp_Trsf &theTrsf, const bool theCopy, const bool theMakeGroups, SMESH_Mesh *theTargetMesh=0)
void FindCoincidentNodes (TIDSortedNodeSet &theNodes, const double theTolerance, TListOfListOfNodes &theGroupsOfNodes)
SMESH_NodeSearcherGetNodeSearcher ()
 Return SMESH_NodeSearcher.
SMESH_ElementSearcherGetElementSearcher ()
 Return SMESH_ElementSearcher.
SMESH_ElementSearcherGetElementSearcher (SMDS_ElemIteratorPtr elemIt)
int SimplifyFace (const std::vector< const SMDS_MeshNode * > faceNodes, std::vector< const SMDS_MeshNode * > &poly_nodes, std::vector< int > &quantities) const
void MergeNodes (TListOfListOfNodes &theNodeGroups)
void FindEqualElements (std::set< const SMDS_MeshElement * > &theElements, TListOfListOfElementsID &theGroupsOfElementsID)
void MergeElements (TListOfListOfElementsID &theGroupsOfElementsID)
void MergeEqualElements ()
Sew_Error SewFreeBorder (const SMDS_MeshNode *theBorderFirstNode, const SMDS_MeshNode *theBorderSecondNode, const SMDS_MeshNode *theBorderLastNode, const SMDS_MeshNode *theSide2FirstNode, const SMDS_MeshNode *theSide2SecondNode, const SMDS_MeshNode *theSide2ThirdNode=0, const bool theSide2IsFreeBorder=true, const bool toCreatePolygons=false, const bool toCreatePolyedrs=false)
Sew_Error SewSideElements (TIDSortedElemSet &theSide1, TIDSortedElemSet &theSide2, const SMDS_MeshNode *theFirstNode1ToMerge, const SMDS_MeshNode *theFirstNode2ToMerge, const SMDS_MeshNode *theSecondNode1ToMerge, const SMDS_MeshNode *theSecondNode2ToMerge)
void InsertNodesIntoLink (const SMDS_MeshElement *theFace, const SMDS_MeshNode *theBetweenNode1, const SMDS_MeshNode *theBetweenNode2, std::list< const SMDS_MeshNode * > &theNodesToInsert, const bool toCreatePoly=false)
void UpdateVolumes (const SMDS_MeshNode *theBetweenNode1, const SMDS_MeshNode *theBetweenNode2, std::list< const SMDS_MeshNode * > &theNodesToInsert)
void ConvertToQuadratic (const bool theForce3d)
void ConvertToQuadratic (const bool theForce3d, TIDSortedElemSet &theElements)
bool ConvertFromQuadratic ()
void ConvertFromQuadratic (TIDSortedElemSet &theElements)
int FindShape (const SMDS_MeshElement *theElem)
SMESH_MeshGetMesh ()
SMESHDS_Mesh * GetMeshDS ()
const SMESH_SequenceOfElemPtr & GetLastCreatedNodes () const
const SMESH_SequenceOfElemPtr & GetLastCreatedElems () const
bool DoubleNodes (const std::list< int > &theListOfNodes, const std::list< int > &theListOfModifiedElems)
bool DoubleNodes (const TIDSortedElemSet &theElems, const TIDSortedElemSet &theNodesNot, const TIDSortedElemSet &theAffectedElems)
bool DoubleNodesInRegion (const TIDSortedElemSet &theElems, const TIDSortedElemSet &theNodesNot, const TopoDS_Shape &theShape)
double OrientedAngle (const gp_Pnt &p0, const gp_Pnt &p1, const gp_Pnt &g1, const gp_Pnt &g2)
bool DoubleNodesOnGroupBoundaries (const std::vector< TIDSortedElemSet > &theElems, bool createJointElems)
bool CreateFlatElementsOnFacesGroups (const std::vector< TIDSortedElemSet > &theElems)
bool Make2DMeshFrom3D ()
 Generated skin mesh (containing 2D cells) from 3D mesh The created 2D mesh elements based on nodes of free faces of boundary volumes.
int MakeBoundaryMesh (const TIDSortedElemSet &elements, Bnd_Dimension dimension, SMESH_Group *group=0, SMESH_Mesh *targetMesh=0, bool toCopyElements=false, bool toCopyExistingBondary=false, bool toAddExistingBondary=false, bool aroundElements=false)
 SMESH_MesherHelper (SMESH_Mesh &theMesh)
SMESH_MeshGetMesh () const
SMESHDS_Mesh * GetMeshDS () const
bool IsQuadraticSubMesh (const TopoDS_Shape &theShape)
 Check submesh for given shape: if all elements on this shape are quadratic, quadratic elements will be created.
void SetIsQuadratic (const bool theBuildQuadratic)
 Set order of elements to create without calling IsQuadraticSubMesh()
bool GetIsQuadratic () const
 Return myCreateQuadratic flag.
void FixQuadraticElements (bool volumeOnly=true)
 Move medium nodes of faces and volumes to fix distorted elements.
void SetElementsOnShape (bool toSet)
 To set created elements on the shape set by IsQuadraticSubMesh() or the next methods.
void SetSubShape (const int subShapeID)
 Set shape to make elements on without calling IsQuadraticSubMesh()
void SetSubShape (const TopoDS_Shape &subShape)
 ==SMESHDS_Mesh::ShapeToIndex(shape)
int GetSubShapeID () const
 Return ID of the shape set by IsQuadraticSubMesh() or SetSubShape()
const TopoDS_Shape & GetSubShape () const
 Return the shape set by IsQuadraticSubMesh() or SetSubShape()
SMDS_MeshNode * AddNode (double x, double y, double z, int ID=0)
 Creates a node.
SMDS_MeshEdge * AddEdge (const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const int id=0, const bool force3d=true)
 Creates quadratic or linear edge.
SMDS_MeshFace * AddFace (const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3, const int id=0, const bool force3d=false)
 Creates quadratic or linear triangle.
SMDS_MeshFace * AddFace (const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3, const SMDS_MeshNode *n4, const int id=0, const bool force3d=false)
 Creates quadratic or linear quadrangle.
SMDS_MeshFace * AddPolygonalFace (const std::vector< const SMDS_MeshNode * > &nodes, const int id=0, const bool force3d=false)
 Creates polygon, with additional nodes in quadratic mesh.
SMDS_MeshVolume * AddVolume (const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3, const SMDS_MeshNode *n4, const int id=0, const bool force3d=true)
 Creates quadratic or linear tetrahedron.
SMDS_MeshVolume * AddVolume (const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3, const SMDS_MeshNode *n4, const SMDS_MeshNode *n5, const int id=0, const bool force3d=true)
 Creates quadratic or linear pyramid.
SMDS_MeshVolume * AddVolume (const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3, const SMDS_MeshNode *n4, const SMDS_MeshNode *n5, const SMDS_MeshNode *n6, const int id=0, const bool force3d=true)
 Creates quadratic or linear pentahedron.
SMDS_MeshVolume * AddVolume (const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3, const SMDS_MeshNode *n4, const SMDS_MeshNode *n5, const SMDS_MeshNode *n6, const SMDS_MeshNode *n7, const SMDS_MeshNode *n8, const int id=0, bool force3d=true)
 Creates quadratic or linear hexahedron.
SMDS_MeshVolume * AddPolyhedralVolume (const std::vector< const SMDS_MeshNode * > &nodes, const std::vector< int > &quantities, const int ID=0, const bool force3d=true)
 Creates polyhedron.
double GetNodeU (const TopoDS_Edge &theEdge, const SMDS_MeshNode *theNode, const SMDS_MeshNode *inEdgeNode=0, bool *check=0)
 Return U of the given node on the edge.
gp_XY GetNodeUV (const TopoDS_Face &F, const SMDS_MeshNode *n, const SMDS_MeshNode *inFaceNode=0, bool *check=0) const
 Return node UV on face.
bool CheckNodeUV (const TopoDS_Face &F, const SMDS_MeshNode *n, gp_XY &uv, const double tol, const bool force=false, double distXYZ[4]=0) const
 Check and fix node UV on a face.
bool CheckNodeU (const TopoDS_Edge &E, const SMDS_MeshNode *n, double &u, const double tol, const bool force=false, double distXYZ[4]=0) const
 Check and fix node U on an edge.
bool GetNodeUVneedInFaceNode (const TopoDS_Face &F=TopoDS_Face()) const
 Check if inFaceNode argument is necessary for call GetNodeUV(F,..)
GeomAPI_ProjectPointOnSurf & GetProjector (const TopoDS_Face &F, TopLoc_Location &loc, double tol=0) const
 Return projector intitialized by given face without location, which is returned.
bool IsDegenShape (const int subShape) const
 Check if shape is a degenerated edge or it's vertex.
bool HasDegeneratedEdges () const
 Check if the shape set through IsQuadraticSubMesh() or SetSubShape() has a degenerated edges.
bool IsSeamShape (const int subShape) const
 Check if shape is a seam edge or it's vertex.
bool IsSeamShape (const TopoDS_Shape &subShape) const
 Check if shape is a seam edge or it's vertex.
bool IsRealSeam (const int subShape) const
 Return true if an edge or a vertex encounters twice in face wire.
bool IsRealSeam (const TopoDS_Shape &subShape) const
 Return true if an edge or a vertex encounters twice in face wire.
bool HasSeam () const
 Check if the shape set through IsQuadraticSubMesh() or SetSubShape() has a seam edge.
int GetPeriodicIndex () const
 Return index of periodic parametric direction of a closed face.
double GetOtherParam (const double param) const
 Return an alternative parameter for a node on seam.
const SMDS_MeshNode * GetMediumNode (const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const bool force3d)
 Return existing or create new medium nodes between given ones.
std::pair< int, TopAbs_ShapeEnum > GetMediumPos (const SMDS_MeshNode *n1, const SMDS_MeshNode *n2)
 Return index and type of the shape (EDGE or FACE only) to set a medium node on.
void AddTLinkNode (const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n12)
 Add a link in my data structure.
void AddTLinkNodeMap (const TLinkNodeMap &aMap)
 Add many links in my data structure.
void AddTLinks (const SMDS_MeshEdge *edge)
void AddTLinks (const SMDS_MeshFace *face)
void AddTLinks (const SMDS_MeshVolume *vol)
const TLinkNodeMapGetTLinkNodeMap () const
 Returns myTLinkNodeMap.
MType IsQuadraticMesh ()
virtual ~SMESH_MesherHelper ()
 SMESH_Pattern ()
void Clear ()
bool Load (const char *theFileContents)
bool Load (SMESH_Mesh *theMesh, const TopoDS_Face &theFace, bool theProject=false)
bool Load (SMESH_Mesh *theMesh, const TopoDS_Shell &theBlock)
bool Save (std::ostream &theFile)
bool Apply (const TopoDS_Face &theFace, const TopoDS_Vertex &theVertexOnKeyPoint1, const bool theReverse)
bool Apply (const TopoDS_Shell &theBlock, const TopoDS_Vertex &theVertex000, const TopoDS_Vertex &theVertex001)
bool Apply (const SMDS_MeshFace *theFace, const int theNodeIndexOnKeyPoint1, const bool theReverse)
bool Apply (SMESH_Mesh *theMesh, const SMDS_MeshFace *theFace, const TopoDS_Shape &theSurface, const int theNodeIndexOnKeyPoint1, const bool theReverse)
bool Apply (SMESH_Mesh *theMesh, std::set< const SMDS_MeshFace * > &theFaces, const int theNodeIndexOnKeyPoint1, const bool theReverse)
bool Apply (const SMDS_MeshVolume *theVolume, const int theNode000Index, const int theNode001Index)
bool Apply (std::set< const SMDS_MeshVolume * > &theVolumes, const int theNode000Index, const int theNode001Index)
bool GetMappedPoints (std::list< const gp_XYZ * > &thePoints) const
bool MakeMesh (SMESH_Mesh *theMesh, const bool toCreatePolygons=false, const bool toCreatePolyedrs=false)
ErrorCode GetErrorCode () const
bool IsLoaded () const
bool Is2D () const
bool GetPoints (std::list< const gp_XYZ * > &thePoints) const
const std::list< int > & GetKeyPointIDs () const
const std::list< std::list
< int > > & 
GetElementPointIDs (bool applied) const
void DumpPoints () const
TopoDS_Shape GetSubShape (const int i) const
 SMESH_ProxyMesh ()
 SMESH_ProxyMesh (std::vector< SMESH_ProxyMesh::Ptr > &components)
 SMESH_ProxyMesh (const SMESH_Mesh &mesh)
virtual ~SMESH_ProxyMesh ()
const SMESHDS_SubMesh * GetSubMesh (const TopoDS_Shape &face) const
const SubMeshGetProxySubMesh (const TopoDS_Shape &face) const
const SMDS_MeshNode * GetProxyNode (const SMDS_MeshNode *node) const
SMDS_ElemIteratorPtr GetFaces () const
SMDS_ElemIteratorPtr GetFaces (const TopoDS_Shape &face) const
int NbFaces () const
bool IsTemporary (const SMDS_MeshElement *elem) const
const SMESH_MeshGetMesh () const
SMESHDS_Mesh * GetMeshDS () const
 SMESH_subMesh (int Id, SMESH_Mesh *father, SMESHDS_Mesh *meshDS, const TopoDS_Shape &aSubShape)
virtual ~SMESH_subMesh ()
int GetId () const
SMESH_MeshGetFather ()
SMESHDS_SubMesh * GetSubMeshDS ()
SMESHDS_SubMesh * CreateSubMeshDS ()
SMESH_subMeshGetFirstToCompute ()
SMESH_AlgoGetAlgo () const
const std::map< int,
SMESH_subMesh * > & 
DependsOn ()
SMESH_subMeshIteratorPtr getDependsOnIterator (const bool includeSelf, const bool complexShapeFirst)
 Return iterator on the submeshes this one depends on.
const TopoDS_Shape & GetSubShape () const
void SetEventListener (EventListener *listener, EventListenerData *data, SMESH_subMesh *where)
 Sets an event listener and its data to a submesh.
EventListenerDataGetEventListenerData (EventListener *listener) const
 Return an event listener data.
void DeleteEventListener (EventListener *listener)
 Unregister the listener and delete it and it's data.
SMESH_Hypothesis::Hypothesis_Status AlgoStateEngine (int event, SMESH_Hypothesis *anHyp)
SMESH_Hypothesis::Hypothesis_Status SubMeshesAlgoStateEngine (int event, SMESH_Hypothesis *anHyp)
int GetAlgoState () const
int GetComputeState () const
SMESH_ComputeErrorPtrGetComputeError ()
void DumpAlgoState (bool isMain)
bool ComputeStateEngine (int event)
void ComputeSubMeshStateEngine (int event, const bool includeSelf=false)
bool Evaluate (MapShapeNbElems &aResMap)
bool IsConform (const SMESH_Algo *theAlgo)
bool CanAddHypothesis (const SMESH_Hypothesis *theHypothesis) const
bool IsApplicableHypotesis (const SMESH_Hypothesis *theHypothesis) const
SMESH_Hypothesis::Hypothesis_Status CheckConcurentHypothesis (const int theHypType)
bool IsEmpty () const
 Return true if no mesh entities is bound to the submesh.
bool IsMeshComputed () const
void SetIsAlwaysComputed (bool isAlCo)
 Allow algo->Compute() if a subshape of lower dim is meshed but none mesh entity is bound to it.
bool IsAlwaysComputed ()
bool FindIntersection (const SMESH_subMesh *theOther, std::set< const SMESH_subMesh * > &theSetOfCommon) const
 Find common submeshes (based on shared subshapes with other.
 SMESH_subMeshEventListener (bool isDeletable, const char *name)
bool IsDeletable () const
virtual void ProcessEvent (const int event, const int eventType, SMESH_subMesh *subMesh, SMESH_subMeshEventListenerData *data, const SMESH_Hypothesis *hyp=0)
 Do something on a certain event.

Static Public Member Functions

static bool GetNodeParamOnEdge (const SMESHDS_Mesh *theMesh, const TopoDS_Edge &theEdge, std::vector< double > &theParams)
 Fill vector of node parameters on geometrical edge, including vertex nodes.
static bool GetSortedNodesOnEdge (const SMESHDS_Mesh *theMesh, const TopoDS_Edge &theEdge, const bool ignoreMediumNodes, std::map< double, const SMDS_MeshNode * > &theNodes)
 Fill map of node parameter on geometrical edge to node it-self.
static bool IsReversedSubMesh (const TopoDS_Face &theFace, SMESHDS_Mesh *theMeshDS)
 Find out elements orientation on a geometrical face.
static double EdgeLength (const TopoDS_Edge &E)
 Compute length of an edge.
static bool FaceNormal (const SMDS_MeshElement *F, gp_XYZ &normal, bool normalized=true)
 Calculate normal of a mesh face.
static GeomAbs_Shape Continuity (TopoDS_Edge E1, TopoDS_Edge E2)
 Return continuity of two edges.
static bool IsContinuous (const TopoDS_Edge &E1, const TopoDS_Edge &E2)
 Return true if an edge can be considered as a continuation of another.
static const SMDS_MeshNode * VertexNode (const TopoDS_Vertex &V, const SMESHDS_Mesh *meshDS)
 Return the node built on a vertex.
static std::vector< const
SMDS_MeshNode * > 
GetCommonNodes (const SMDS_MeshElement *e1, const SMDS_MeshElement *e2)
 Return nodes common to two elements.
static EMeshError GetMeshError (SMESH_subMesh *subMesh)
 Finds topological errors of a sub-mesh.
static int GetShapeDim (const TopAbs_ShapeEnum &aShapeType)
static int GetShapeDim (const TopoDS_Shape &aShape)
static bool IsGlobalHypothesis (const SMESH_Hypothesis *theHyp, SMESH_Mesh &aMesh)
static SMESH_HypoPredicateIsAlgo ()
static SMESH_HypoPredicateIsAuxiliary ()
static SMESH_HypoPredicateIsApplicableTo (const TopoDS_Shape &theShape)
static SMESH_HypoPredicateIsAssignedTo (const TopoDS_Shape &theShape)
static SMESH_HypoPredicateIs (const SMESH_Hypothesis *theHypo)
static SMESH_HypoPredicateIsGlobal (const TopoDS_Shape &theMainShape)
static SMESH_HypoPredicateIsMoreLocalThan (const TopoDS_Shape &theShape, const SMESH_Mesh &theMesh)
static SMESH_HypoPredicateHasName (const std::string &theName)
static SMESH_HypoPredicateHasDim (const int theDim)
static SMESH_HypoPredicateHasType (const int theHypType)
static bool IsStatusFatal (Hypothesis_Status theStatus)
static double GetShapeDiagonalSize (const TopoDS_Shape &aShape)
 Return diagonal size of bounding box of a shape.
static const TopoDS_Solid & PseudoShape ()
 Return a solid which is returned by GetShapeToMesh() if a real geometry to be meshed was not set.
static bool isOut (const SMDS_MeshElement *element, const gp_Pnt &point, double tol)
 Return true if the point is IN or ON of the element.
static bool CheckFreeBorderNodes (const SMDS_MeshNode *theNode1, const SMDS_MeshNode *theNode2, const SMDS_MeshNode *theNode3=0)
static bool FindFreeBorder (const SMDS_MeshNode *theFirstNode, const SMDS_MeshNode *theSecondNode, const SMDS_MeshNode *theLastNode, std::list< const SMDS_MeshNode * > &theNodes, std::list< const SMDS_MeshElement * > &theFaces)
static void AddToSameGroups (const SMDS_MeshElement *elemToAdd, const SMDS_MeshElement *elemInGroups, SMESHDS_Mesh *aMesh)
static void RemoveElemFromGroups (const SMDS_MeshElement *element, SMESHDS_Mesh *aMesh)
static void ReplaceElemInGroups (const SMDS_MeshElement *elemToRm, const SMDS_MeshElement *elemToAdd, SMESHDS_Mesh *aMesh)
static void ReplaceElemInGroups (const SMDS_MeshElement *elemToRm, const std::vector< const SMDS_MeshElement * > &elemToAdd, SMESHDS_Mesh *aMesh)
static void GetLinkedNodes (const SMDS_MeshNode *node, TIDSortedElemSet &linkedNodes, SMDSAbs_ElementType type=SMDSAbs_All)
 Return nodes linked to the given one in elements of the type.
static const SMDS_MeshElement * FindFaceInSet (const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const TIDSortedElemSet &elemSet, const TIDSortedElemSet &avoidSet, int *i1=0, int *i2=0)
static Sew_Error FindMatchingNodes (std::set< const SMDS_MeshElement * > &theSide1, std::set< const SMDS_MeshElement * > &theSide2, const SMDS_MeshNode *theFirstNode1, const SMDS_MeshNode *theFirstNode2, const SMDS_MeshNode *theSecondNode1, const SMDS_MeshNode *theSecondNode2, TNodeNodeMap &theNodeReplaceMap)
 Find corresponding nodes in two sets of faces.
static bool IsMedium (const SMDS_MeshNode *node, const SMDSAbs_ElementType typeToCheck=SMDSAbs_All)
 Returns true if given node is medium.
static bool IsMedium (const SMDS_MeshNode *node, const SMDSAbs_ElementType typeToCheck=SMDSAbs_All)
 Returns true if given node is medium.
static bool LoadNodeColumns (TParam2ColumnMap &theParam2ColumnMap, const TopoDS_Face &theFace, const std::list< TopoDS_Edge > &theBaseSide, SMESHDS_Mesh *theMesh, SMESH_ProxyMesh *theProxyMesh=0)
 Load nodes bound to face into a map of node columns.
static bool LoadNodeColumns (TParam2ColumnMap &theParam2ColumnMap, const TopoDS_Face &theFace, const TopoDS_Edge &theBaseEdge, SMESHDS_Mesh *theMesh, SMESH_ProxyMesh *theProxyMesh=0)
 Variant of LoadNodeColumns() above with theBaseSide given by one edge.
static TopoDS_Shape GetSubShapeByNode (const SMDS_MeshNode *node, const SMESHDS_Mesh *meshDS)
 Return support shape of a node.
static int WrapIndex (const int ind, const int nbNodes)
 Return a valid node index, fixing the given one if necessary.
static int NbAncestors (const TopoDS_Shape &shape, const SMESH_Mesh &mesh, TopAbs_ShapeEnum ancestorType=TopAbs_SHAPE)
 Return number of unique ancestors of the shape.
static PShapeIteratorPtr GetAncestors (const TopoDS_Shape &shape, const SMESH_Mesh &mesh, TopAbs_ShapeEnum ancestorType)
 Return iterator on ancestors of the given type.
static TopoDS_Shape GetCommonAncestor (const TopoDS_Shape &shape1, const TopoDS_Shape &shape2, const SMESH_Mesh &mesh, TopAbs_ShapeEnum ancestorType)
 Find a common ancestors of two shapes of the given type.
static TopAbs_Orientation GetSubShapeOri (const TopoDS_Shape &shape, const TopoDS_Shape &subShape)
 Return orientation of sub-shape in the main shape.
static bool IsSubShape (const TopoDS_Shape &shape, const TopoDS_Shape &mainShape)
static bool IsSubShape (const TopoDS_Shape &shape, SMESH_Mesh *aMesh)
static double MaxTolerance (const TopoDS_Shape &shape)
static bool IsClosedEdge (const TopoDS_Edge &anEdge)
static TopoDS_Vertex IthVertex (const bool is2nd, TopoDS_Edge anEdge, const bool CumOri=true)
static gp_XY GetMiddleUV (const Handle(Geom_Surface)&surface, const gp_XY &uv1, const gp_XY &uv2)
 Return middle UV taking in account surface period.
static gp_XY applyIn2D (const Handle(Geom_Surface)&surface, const gp_XY &uv1, const gp_XY &uv2, xyFunPtr fun, const bool resultInPeriod=true)
 Perform given operation on two 2d points in parameric space of given surface.
static bool IsApplicableHypotesis (const SMESH_Hypothesis *theHypothesis, const TopAbs_ShapeEnum theShapeType)

Public Attributes

std::map< int, SMESH_Algo * > _mapAlgo
std::map< int, SMESH_0D_Algo * > _map0D_Algo
std::map< int, SMESH_1D_Algo * > _map1D_Algo
std::map< int, SMESH_2D_Algo * > _map2D_Algo
std::map< int, SMESH_3D_Algo * > _map3D_Algo

Protected Types

enum  Logical { AND, AND_NOT, OR, OR_NOT }
enum  Comparison { EQUAL, NOT_EQUAL, MORE, LESS }

Protected Member Functions

bool error (int error, const SMESH_Comment &comment="")
 store error and comment and then return ( error == COMPERR_OK )
bool error (const SMESH_Comment &comment="")
 store COMPERR_ALGO_FAILED error and comment and then return false
bool error (SMESH_ComputeErrorPtr error)
 store error and return error->IsOK()
void addBadInputElement (const SMDS_MeshElement *elem)
 store a bad input element preventing computation, which may be a temporary one i.e.
 SMESH_HypoFilter (const SMESH_HypoFilter &other)
void add (Logical bool_op, SMESH_HypoPredicate *pred)
 SMESH_Mesh ()
 SMESH_Mesh (const SMESH_Mesh &)
gp_Pnt2d GetUVOnSeam (const gp_Pnt2d &uv1, const gp_Pnt2d &uv2) const
 Select UV on either of 2 pcurves of a seam edge, closest to the given UV.
const SMDS_MeshNode * getMediumNodeOnComposedWire (const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, bool force3d)
void setMesh (const SMESH_Mesh &mesh)
int shapeIndex (const TopoDS_Shape &shape) const
SubMeshfindProxySubMesh (int shapeIndex=0) const
SubMeshgetProxySubMesh (int shapeIndex)
SubMeshgetProxySubMesh (const TopoDS_Shape &shape=TopoDS_Shape())
bool takeProxySubMesh (const TopoDS_Shape &shape, SMESH_ProxyMesh *proxyMesh)
void takeTmpElemsInMesh (SMESH_ProxyMesh *proxyMesh)
void removeTmpElement (const SMDS_MeshElement *face)
void storeTmpElement (const SMDS_MeshElement *face)
void setNode2Node (const SMDS_MeshNode *srcNode, const SMDS_MeshNode *proxyNode, const SubMesh *subMesh)
void setEventListener (EventListener *listener, EventListenerData *data)
 Sets an event listener and its data to a submesh.
void notifyListenersOnEvent (const int event, const event_type eventType, SMESH_Hypothesis *hyp=0)
 Notify stored event listeners on the occured event.
void deleteOwnListeners ()
 Delete event listeners depending on algo of this submesh.
void loadDependentMeshes ()
 loads dependent meshes on SUBMESH_LOADED event
void insertDependence (const TopoDS_Shape aSubShape)
bool subMeshesComputed ()
void removeSubMeshElementsAndNodes ()
void updateDependantsState (const compute_event theEvent)
void updateSubMeshState (const compute_state theState)
void cleanDependants ()
void cleanDependsOn ()
void setAlgoState (int state)
TopoDS_Shape getCollection (SMESH_Gen *theGen, SMESH_Algo *theAlgo, bool &theSubComputed)
 Return a shape containing all sub-shapes of the MainShape that can be meshed at once along with _subShape.
bool checkComputeError (SMESH_Algo *theAlgo, const TopoDS_Shape &theShape=TopoDS_Shape())
 Update compute_state by _computeError.
const SMESH_HypothesisgetSimilarAttached (const TopoDS_Shape &theShape, const SMESH_Hypothesis *theHyp, const int theHypType=0)
 Return a hypothesis attached to theShape.

Protected Attributes

std::vector< std::string > _compatibleHypothesis
std::list< const
SMESHDS_Hypothesis * > 
_appliedHypList
std::list< const
SMESHDS_Hypothesis * > 
_usedHypList
bool _onlyUnaryInput
bool _requireDiscreteBoundary
bool _requireShape
bool _supportSubmeshes
bool _quadraticMesh
int _error
 SMESH_ComputeErrorName or anything algo specific.
std::string _comment
 any text explaining what is wrong in Compute()
std::list< const
SMDS_MeshElement * > 
_badInputElements
 to explain COMPERR_BAD_INPUT_MESH
std::list< SMESH_HypoPredicate * > myPredicates
SMESH_Gen_gen
int _studyId
int _shapeType
int _param_algo_dim
int _id
int _idDoc
int _groupId
int _nbSubShapes
bool _isShapeToMesh
std::list< SMESH_subMesh * > _subMeshesUsingHypothesisList
SMESHDS_Document * _myDocument
SMESHDS_Mesh * _myMeshDS
std::map< int, SMESH_subMesh * > _mapSubMesh
std::map< int, SMESH_Group * > _mapGroup
bool _isAutoColor
bool _isModified
 modified since last total re-compute, issue 0020693
double _shapeDiagonal
 diagonal size of bounding box of shape to mesh
TopTools_IndexedDataMapOfShapeListOfShape _mapAncestors
TListOfListOfInt _mySubMeshOrder
TCallUp_callUp
std::vector< SMDSAbs_EntityType_allowedTypes
std::map< EventListener
*, EventListenerData * > 
_eventListeners
 < event listeners to notify
std::list< OwnListenerData_ownListeners
TopoDS_Shape _subShape
SMESHDS_SubMesh * _subMeshDS
SMESH_Mesh_father
int _Id
std::map< int, SMESH_subMesh * > _mapDepend
bool _dependenceAnalysed
int _algoState
int _computeState
SMESH_ComputeErrorPtr _computeError
bool _alwaysComputed

Private Types

typedef std::map< const
SMDS_MeshNode *, std::list
< const SMDS_MeshNode * > > 
TNodeOfNodeListMap
typedef
TNodeOfNodeListMap::iterator 
TNodeOfNodeListMapItr
typedef std::vector
< TNodeOfNodeListMapItr
TVecOfNnlmiMap
typedef std::map< const
SMDS_MeshElement
*, TVecOfNnlmiMap
TElemOfVecOfNnlmiMap
typedef std::map< int,
GeomAPI_ProjectPointOnSurf * > 
TID2ProjectorOnSurf
typedef std::map< int,
GeomAPI_ProjectPointOnCurve * > 
TID2ProjectorOnCurve
typedef std::list< std::list
< TopoDS_Edge > > 
TListOfEdgesList
typedef std::set< const
SMDS_MeshNode * > 
TNodeSet
typedef std::list< int > TElemDef

Private Member Functions

 SMESH_Group (const SMESH_Group &theOther)
SMESH_Groupoperator= (const SMESH_Group &theOther)
void fillAncestorsMap (const TopoDS_Shape &theShape)
std::list< SMESH_subMesh * > getAncestorsSubMeshes (const TopoDS_Shape &theSubShape) const
int convertElemToQuadratic (SMESHDS_SubMesh *theSm, SMESH_MesherHelper &theHelper, const bool theForce3d)
 Convert elements contained in a submesh to quadratic.
int removeQuadElem (SMESHDS_SubMesh *theSm, SMDS_ElemIteratorPtr theItr, const int theShapeID)
 Convert quadratic elements to linear ones and remove quadratic nodes.
PGroupIDs generateGroups (const SMESH_SequenceOfElemPtr &nodeGens, const SMESH_SequenceOfElemPtr &elemGens, const std::string &postfix, SMESH_Mesh *targetMesh=0)
 Create groups of elements made during transformation.
void sweepElement (const SMDS_MeshElement *elem, const std::vector< TNodeOfNodeListMapItr > &newNodesItVec, std::list< const SMDS_MeshElement * > &newElems, const int nbSteps, SMESH_SequenceOfElemPtr &srcElements)
 Create elements by sweeping an element.
void makeWalls (TNodeOfNodeListMap &mapNewNodes, TElemOfElemListMap &newElemsMap, TElemOfVecOfNnlmiMap &elemNewNodesMap, TIDSortedElemSet &elemSet, const int nbSteps, SMESH_SequenceOfElemPtr &srcElements)
 Create 1D and 2D elements around swept elements.
Extrusion_Error MakeEdgePathPoints (std::list< double > &aPrms, const TopoDS_Edge &aTrackEdge, bool aFirstIsStart, std::list< SMESH_MeshEditor_PathPoint > &aLPP)
Extrusion_Error MakeExtrElements (TIDSortedElemSet &theElements, std::list< SMESH_MeshEditor_PathPoint > &theFullList, const bool theHasAngles, std::list< double > &theAngles, const bool theLinearVariation, const bool theHasRefPoint, const gp_Pnt &theRefPoint, const bool theMakeGroups)
void LinearAngleVariation (const int NbSteps, list< double > &theAngles)
bool doubleNodes (SMESHDS_Mesh *theMeshDS, const TIDSortedElemSet &theElems, const TIDSortedElemSet &theNodesNot, std::map< const SMDS_MeshNode *, const SMDS_MeshNode * > &theNodeNodeMap, const bool theIsDoubleElem)
 SMESH_MesherHelper (const SMESH_MesherHelper &theOther)
bool toCheckPosOnShape (int shapeID) const
void setPosOnShapeValidity (int shapeID, bool ok) const
bool setErrorCode (const ErrorCode theErrorCode)
bool setShapeToMesh (const TopoDS_Shape &theShape)
std::list< TPoint * > & getShapePoints (const TopoDS_Shape &theShape)
std::list< TPoint * > & getShapePoints (const int theShapeID)
bool findBoundaryPoints ()
void arrangeBoundaries (std::list< std::list< TPoint * > > &boundaryPoints)
void computeUVOnEdge (const TopoDS_Edge &theEdge, const std::list< TPoint * > &ePoints)
bool compUVByIsoIntersection (const std::list< std::list< TPoint * > > &boundaryPoints, const gp_XY &theInitUV, gp_XY &theUV, bool &theIsDeformed)
bool compUVByElasticIsolines (const std::list< std::list< TPoint * > > &boundaryPoints, const std::list< TPoint * > &pointsToCompute)
double setFirstEdge (std::list< TopoDS_Edge > &theWire, int theFirstEdgeID)
bool sortSameSizeWires (TListOfEdgesList &theWireList, const TListOfEdgesList::iterator &theFromWire, const TListOfEdgesList::iterator &theToWire, const int theFirstEdgeID, std::list< std::list< TPoint * > > &theEdgesPointsList)
void mergePoints (const bool uniteGroups)
void makePolyElements (const std::vector< const SMDS_MeshNode * > &theNodes, const bool toCreatePolygons, const bool toCreatePolyedrs)
void createElements (SMESH_Mesh *theMesh, const std::vector< const SMDS_MeshNode * > &theNodesVector, const std::list< std::list< int > > &theElemNodeIDs, const std::vector< const SMDS_MeshElement * > &theElements)
bool getFacesDefinition (const SMDS_MeshNode **theBndNodes, const int theNbBndNodes, const std::vector< const SMDS_MeshNode * > &theNodes, std::list< int > &theFaceDefs, std::vector< int > &theQuantity)
bool isReversed (const SMDS_MeshNode *theFirstNode, const std::list< int > &theIdsList) const
void clearMesh (SMESH_Mesh *theMesh) const

Static Private Member Functions

static SMESHDS_SubMesh * getSubmeshWithElements (SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)

Private Attributes

int _localId
std::map< int,
StudyContextStruct * > 
_mapStudyContext
int _hypId
int _segmentation
int _nbSegments
counters * _counters
SMESHDS_GroupBase * myGroupDS
std::string myName
int _logical_op
std::string _libName
std::string _parameters
std::string _lastParameters
SMESH_MeshmyMesh
SMESH_SequenceOfElemPtr myLastCreatedNodes
 Sequence for keeping nodes created during last operation.
SMESH_SequenceOfElemPtr myLastCreatedElems
 Sequence for keeping elements created during last operation.
TLinkNodeMap myTLinkNodeMap
std::set< int > myDegenShapeIds
std::set< int > mySeamShapeIds
double myPar1 [2]
double myPar2 [2]
int myParIndex
TID2ProjectorOnSurf myFace2Projector
TID2ProjectorOnCurve myEdge2Projector
TopoDS_Shape myShape
int myShapeID
bool myCreateQuadratic
bool mySetElemOnShape
std::map< int, bool > myNodePosShapesValidity
bool myIs2D
std::vector< TPointmyPoints
std::list< int > myKeyPointIDs
std::list< TElemDefmyElemPointIDs
ErrorCode myErrorCode
bool myIsComputed
bool myIsBoundaryPointsFound
TopTools_IndexedMapOfOrientedShape myShapeIDMap
std::map< int, std::list
< TPoint * > > 
myShapeIDToPointsMap
std::list< int > myNbKeyPntInBoundary
std::vector< gp_XYZ > myXYZ
std::list< TElemDefmyElemXYZIDs
std::map< int, const
SMDS_MeshNode * > 
myXYZIdToNodeMap
std::vector< const
SMDS_MeshElement * > 
myElements
std::vector< const
SMDS_MeshNode * > 
myOrderedNodes
std::vector< const
SMDS_MeshElement * > 
myPolyElems
std::list< TElemDefmyPolyElemXYZIDs
std::list< std::vector< int > > myPolyhedronQuantities
std::map< TNodeSet, std::list
< std::list< int > > > 
myIdsOnBoundary
std::map< int, std::list
< TElemDef * > > 
myReverseConnectivity
const SMESH_Mesh_mesh
std::vector< SubMesh * > _subMeshes
std::set< const
SMDS_MeshElement * > 
_elemsInMesh
SubMesh _subContainer
bool myIsDeletable
 if true, it will be deleted by SMESH_subMesh
std::set< SMESH_subMesh * > myBusySM
 to avoid infinite recursion via events

Friends

class SMESH_HypoFilter
class SMESH_subMesh
std::ostream & operator<< (std::ostream &OS, const TPoint &p)

Detailed Description

Root of all algorithms.

A base for objects reacting on submesh events.

Container of mesh faces substituting other faces in the input mesh of 3D algorithm.

It helps meshers to add elements.

Editor of a mesh.

Methods of the class are grouped into several parts:

It allow meshers not to care about creation of medium nodes when filling a quadratic mesh. Helper does it itself. It defines degree of elements to create when IsQuadraticSubMesh() is called.

Definition at line 35 of file SMESH_0D_Algo.hxx.


Class Documentation

struct SMESH_EXPORT::TDefaults

Definition at line 95 of file SMESH_Hypothesis.hxx.

Class Members
double _elemLength
int _nbSegments
TopoDS_Shape * _shape

Member Typedef Documentation

Definition at line 290 of file SMESH_Mesh.hxx.

typedef std::auto_ptr< std::list<int> > SMESH_EXPORT::PGroupIDs

Definition at line 210 of file SMESH_MeshEditor.hxx.

typedef boost::shared_ptr<SMESH_ProxyMesh> SMESH_EXPORT::Ptr

Definition at line 49 of file SMESH_ProxyMesh.hxx.

typedef TopTools_IndexedDataMapOfShapeListOfShape SMESH_EXPORT::TAncestorMap

Return data map of descendant to ancestor shapes.

Definition at line 220 of file SMESH_Mesh.hxx.

typedef std::list< int > SMESH_EXPORT::TElemDef [private]

Definition at line 344 of file SMESH_Pattern.hxx.

typedef std::map<const SMDS_MeshElement*, TVecOfNnlmiMap > SMESH_EXPORT::TElemOfVecOfNnlmiMap [private]

Definition at line 626 of file SMESH_MeshEditor.hxx.

typedef std::map< int, GeomAPI_ProjectPointOnCurve* > SMESH_EXPORT::TID2ProjectorOnCurve [private]

Definition at line 527 of file SMESH_MesherHelper.hxx.

typedef std::map< int, GeomAPI_ProjectPointOnSurf* > SMESH_EXPORT::TID2ProjectorOnSurf [private]

Definition at line 525 of file SMESH_MesherHelper.hxx.

typedef std::list< std::list< TopoDS_Edge > > SMESH_EXPORT::TListOfEdgesList [private]

Definition at line 291 of file SMESH_Pattern.hxx.

typedef std::list< std::list< int > > SMESH_EXPORT::TListOfListOfElementsID

Definition at line 365 of file SMESH_MeshEditor.hxx.

typedef std::list< std::list< const SMDS_MeshNode* > > SMESH_EXPORT::TListOfListOfNodes

Definition at line 331 of file SMESH_MeshEditor.hxx.

typedef std::map<const SMDS_MeshNode*, const SMDS_MeshNode*, TIDCompare > SMESH_EXPORT::TN2NMap

Definition at line 51 of file SMESH_ProxyMesh.hxx.

typedef std::map<const SMDS_MeshNode*, std::list<const SMDS_MeshNode*> > SMESH_EXPORT::TNodeOfNodeListMap [private]

Definition at line 623 of file SMESH_MeshEditor.hxx.

typedef TNodeOfNodeListMap::iterator SMESH_EXPORT::TNodeOfNodeListMapItr [private]

Definition at line 624 of file SMESH_MeshEditor.hxx.

typedef std::set<const SMDS_MeshNode*> SMESH_EXPORT::TNodeSet [private]

Definition at line 304 of file SMESH_Pattern.hxx.

typedef std::vector<TNodeOfNodeListMapItr> SMESH_EXPORT::TVecOfNnlmiMap [private]

Definition at line 625 of file SMESH_MeshEditor.hxx.


Member Enumeration Documentation

Enumerator:
ADD_HYP 
ADD_ALGO 
REMOVE_HYP 
REMOVE_ALGO 
ADD_FATHER_HYP 
ADD_FATHER_ALGO 
REMOVE_FATHER_HYP 
REMOVE_FATHER_ALGO 
MODIF_HYP 

Definition at line 98 of file SMESH_subMesh.hxx.

Enumerator:
NO_ALGO 
MISSING_HYP 
HYP_OK 

Definition at line 94 of file SMESH_subMesh.hxx.

Enumerator:
BND_2DFROM3D 
BND_1DFROM3D 
BND_1DFROM2D 

Definition at line 582 of file SMESH_MeshEditor.hxx.

enum SMESH_EXPORT::Comparison [protected]
Enumerator:
EQUAL 
NOT_EQUAL 
MORE 
LESS 

Definition at line 106 of file SMESH_HypoFilter.hxx.

Enumerator:
MODIF_ALGO_STATE 
COMPUTE 
CLEAN 
SUBMESH_COMPUTED 
SUBMESH_RESTORED 
SUBMESH_LOADED 
MESH_ENTITY_REMOVED 
CHECK_COMPUTE_STATE 

Definition at line 106 of file SMESH_subMesh.hxx.

  {
    MODIF_ALGO_STATE, COMPUTE,
#ifdef WITH_SMESH_CANCEL_COMPUTE
    COMPUTE_CANCELED,
#endif
    CLEAN, SUBMESH_COMPUTED, SUBMESH_RESTORED, SUBMESH_LOADED,
    MESH_ENTITY_REMOVED, CHECK_COMPUTE_STATE
    };
Enumerator:
NOT_READY 
READY_TO_COMPUTE 
COMPUTE_OK 
FAILED_TO_COMPUTE 

Definition at line 89 of file SMESH_subMesh.hxx.

Enumerator:
MEr_OK 
MEr_HOLES 
MEr_BAD_ORI 
MEr_EMPTY 

Definition at line 331 of file SMESH_Algo.hxx.

Enumerator:
ERR_OK 
ERR_READ_NB_POINTS 
ERR_READ_POINT_COORDS 
ERR_READ_TOO_FEW_POINTS 
ERR_READ_3D_COORD 
ERR_READ_NO_KEYPOINT 
ERR_READ_BAD_INDEX 
ERR_READ_ELEM_POINTS 
ERR_READ_NO_ELEMS 
ERR_READ_BAD_KEY_POINT 
ERR_SAVE_NOT_LOADED 
ERR_LOAD_EMPTY_SUBMESH 
ERR_LOADF_NARROW_FACE 
ERR_LOADF_CLOSED_FACE 
ERR_LOADF_CANT_PROJECT 
ERR_LOADV_BAD_SHAPE 
ERR_LOADV_COMPUTE_PARAMS 
ERR_APPL_NOT_COMPUTED 
ERR_APPL_NOT_LOADED 
ERR_APPL_BAD_DIMENTION 
ERR_APPL_BAD_NB_VERTICES 
ERR_APPLF_BAD_TOPOLOGY 
ERR_APPLF_BAD_VERTEX 
ERR_APPLF_INTERNAL_EEROR 
ERR_APPLV_BAD_SHAPE 
ERR_APPLF_BAD_FACE_GEOM 
ERR_MAKEM_NOT_COMPUTED 
ERR_UNEXPECTED 

Definition at line 157 of file SMESH_Pattern.hxx.

                 {
    ERR_OK,
    // Load(file)
    ERR_READ_NB_POINTS, // couldn't read nb of points
    ERR_READ_POINT_COORDS, // invalid nb of point coordinates
    ERR_READ_TOO_FEW_POINTS,  // too few points in a pattern
    ERR_READ_3D_COORD,  // coordinate of 3D point out of [0,1] range
    ERR_READ_NO_KEYPOINT, // no key-points in 2D pattern
    ERR_READ_BAD_INDEX, // invalid point index
    ERR_READ_ELEM_POINTS, // invalid nb of points in element
    ERR_READ_NO_ELEMS, // no elements in a pattern
    ERR_READ_BAD_KEY_POINT, // a key-point not on a boundary
    // Save(file)
    ERR_SAVE_NOT_LOADED, // pattern was not loaded
    // Load(shape)
    ERR_LOAD_EMPTY_SUBMESH, // no elements to load
    // Load(face)
    ERR_LOADF_NARROW_FACE, // too narrow face
    ERR_LOADF_CLOSED_FACE, // closed face
    ERR_LOADF_CANT_PROJECT, // impossible to project nodes
    // Load(volume)
    ERR_LOADV_BAD_SHAPE, // volume is not a brick of 6 faces
    ERR_LOADV_COMPUTE_PARAMS, // cant compute point parameters
    // Apply(shape)
    ERR_APPL_NOT_COMPUTED, // mapping failed
    ERR_APPL_NOT_LOADED, // pattern was not loaded
    ERR_APPL_BAD_DIMENTION, // wrong shape dimention
    ERR_APPL_BAD_NB_VERTICES, // keypoints - vertices mismatch
    // Apply(face)
    ERR_APPLF_BAD_TOPOLOGY, // bad pattern topology
    ERR_APPLF_BAD_VERTEX, // first vertex not on an outer face boundary
    ERR_APPLF_INTERNAL_EEROR, // program error
    // Apply(volume)
    ERR_APPLV_BAD_SHAPE, // volume is not a brick of 6 faces
    // Apply(mesh_face)
    ERR_APPLF_BAD_FACE_GEOM, // bad face geometry
    // MakeMesh
    ERR_MAKEM_NOT_COMPUTED, // mapping failed
    //Unexpected error 
    ERR_UNEXPECTED // Unexpected of the pattern mapping alorithm
  };
Enumerator:
ALGO_EVENT 
COMPUTE_EVENT 

Definition at line 115 of file SMESH_subMesh.hxx.

Enumerator:
EXTR_OK 
EXTR_NO_ELEMENTS 
EXTR_PATH_NOT_EDGE 
EXTR_BAD_PATH_SHAPE 
EXTR_BAD_STARTING_NODE 
EXTR_BAD_ANGLES_NUMBER 
EXTR_CANT_GET_TANGENT 

Definition at line 292 of file SMESH_MeshEditor.hxx.

Auxilary flag for advanced extrusion.

BOUNDARY: create or not boundary for result of extrusion SEW: try to use existing nodes or create new nodes in any case

Enumerator:
EXTRUSION_FLAG_BOUNDARY 
EXTRUSION_FLAG_SEW 

Definition at line 227 of file SMESH_MeshEditor.hxx.

Enumerator:
HYP_OK 
HYP_MISSING 
HYP_CONCURENT 
HYP_BAD_PARAMETER 
HYP_HIDDEN_ALGO 
HYP_HIDING_ALGO 
HYP_UNKNOWN_FATAL 
HYP_INCOMPATIBLE 
HYP_NOTCONFORM 
HYP_ALREADY_EXIST 
HYP_BAD_DIM 
HYP_BAD_SUBSHAPE 
HYP_BAD_GEOMETRY 
HYP_NEED_SHAPE 

Definition at line 50 of file SMESH_Hypothesis.hxx.

  {
    HYP_OK = 0,
    HYP_MISSING,      // algo misses a hypothesis
    HYP_CONCURENT,    // several applicable hypotheses
    HYP_BAD_PARAMETER,// hypothesis has a bad parameter value
    HYP_HIDDEN_ALGO,  // an algo is hidden by an upper dim algo generating all-dim elements
    HYP_HIDING_ALGO,  // an algo hides lower dim algos by generating all-dim elements
    HYP_UNKNOWN_FATAL,//  --- all statuses below should be considered as fatal
                      //      for Add/RemoveHypothesis operations
    HYP_INCOMPATIBLE, // hypothesis does not fit algo
    HYP_NOTCONFORM,   // not conform mesh is produced appling a hypothesis
    HYP_ALREADY_EXIST,// such hypothesis already exist
    HYP_BAD_DIM,      // bad dimension
    HYP_BAD_SUBSHAPE, // shape is neither the main one, nor its sub-shape, nor a group
    HYP_BAD_GEOMETRY, // shape geometry mismatches algorithm's expectation
    HYP_NEED_SHAPE    // algorithm can work on shape only
  };
enum SMESH_EXPORT::Logical [protected]
Enumerator:
AND 
AND_NOT 
OR 
OR_NOT 

Definition at line 105 of file SMESH_HypoFilter.hxx.

{ AND, AND_NOT, OR, OR_NOT };

Check mesh without geometry for: if all elements on this shape are quadratic, quadratic elements will be created.

Used then generated 3D mesh without geometry.

Enumerator:
LINEAR 
QUADRATIC 
COMP 

Definition at line 494 of file SMESH_MesherHelper.hxx.

Enumerator:
SEW_OK 
SEW_BORDER1_NOT_FOUND 
SEW_BORDER2_NOT_FOUND 
SEW_BOTH_BORDERS_NOT_FOUND 
SEW_BAD_SIDE_NODES 
SEW_VOLUMES_TO_SPLIT 
SEW_DIFF_NB_OF_ELEMENTS 
SEW_TOPO_DIFF_SETS_OF_ELEMENTS 
SEW_BAD_SIDE1_NODES 
SEW_BAD_SIDE2_NODES 
SEW_INTERNAL_ERROR 

Definition at line 391 of file SMESH_MeshEditor.hxx.

Enumerator:
LAPLACIAN 
CENTROIDAL 

Definition at line 193 of file SMESH_MeshEditor.hxx.

Enumerator:
HEXA_TO_5 
HEXA_TO_6 
HEXA_TO_24 

Definition at line 186 of file SMESH_MeshEditor.hxx.

{ HEXA_TO_5 = 1, HEXA_TO_6 = 2, HEXA_TO_24 = 3 };

Constructor & Destructor Documentation

virtual SMESH_EXPORT::~SMESH_0D_Algo ( ) [virtual]
virtual SMESH_EXPORT::~SMESH_1D_Algo ( ) [virtual]
virtual SMESH_EXPORT::~SMESH_2D_Algo ( ) [virtual]
virtual SMESH_EXPORT::~SMESH_3D_Algo ( ) [virtual]
virtual SMESH_EXPORT::~SMESH_Algo ( ) [virtual]

Destructor.

virtual SMESH_EXPORT::~SMESH_HypoPredicate ( ) [inline, virtual]

Definition at line 50 of file SMESH_HypoFilter.hxx.

{}
virtual SMESH_EXPORT::~SMESH_Hypothesis ( ) [virtual]
virtual SMESH_EXPORT::~SMESH_Mesh ( ) [virtual]
virtual SMESH_EXPORT::~SMESH_MesherHelper ( ) [virtual]
virtual SMESH_EXPORT::~SMESH_ProxyMesh ( ) [virtual]
virtual SMESH_EXPORT::~SMESH_subMesh ( ) [virtual]

Member Function Documentation

void SMESH_EXPORT::add ( Logical  bool_op,
SMESH_HypoPredicate pred 
) [inline, protected]

Definition at line 110 of file SMESH_HypoFilter.hxx.

  {
    if ( pred ) {
      pred->_logical_op = bool_op;
      myPredicates.push_back( pred );
    }
  }
void SMESH_EXPORT::addBadInputElement ( const SMDS_MeshElement *  elem) [protected]

store a bad input element preventing computation, which may be a temporary one i.e.

not residing the mesh, then it will be deleted by InitComputeError()

SMDS_MeshEdge* SMESH_EXPORT::AddEdge ( const SMDS_MeshNode *  n1,
const SMDS_MeshNode *  n2,
const int  id = 0,
const bool  force3d = true 
)

Creates quadratic or linear edge.

SMDS_MeshElement* SMESH_EXPORT::AddElement ( const std::vector< const SMDS_MeshNode * > &  nodes,
const SMDSAbs_ElementType  type,
const bool  isPoly,
const int  ID = -1 
)

Add element.

SMDS_MeshElement* SMESH_EXPORT::AddElement ( const std::vector< int > &  nodeIDs,
const SMDSAbs_ElementType  type,
const bool  isPoly,
const int  ID = -1 
)

Add element.

SMDS_MeshFace* SMESH_EXPORT::AddFace ( const SMDS_MeshNode *  n1,
const SMDS_MeshNode *  n2,
const SMDS_MeshNode *  n3,
const int  id = 0,
const bool  force3d = false 
)

Creates quadratic or linear triangle.

SMDS_MeshFace* SMESH_EXPORT::AddFace ( const SMDS_MeshNode *  n1,
const SMDS_MeshNode *  n2,
const SMDS_MeshNode *  n3,
const SMDS_MeshNode *  n4,
const int  id = 0,
const bool  force3d = false 
)

Creates quadratic or linear quadrangle.

SMESH_Group* SMESH_EXPORT::AddGroup ( const SMDSAbs_ElementType  theType,
const char *  theName,
int &  theId,
const TopoDS_Shape &  theShape = TopoDS_Shape(),
const SMESH_PredicatePtr thePredicate = SMESH_PredicatePtr() 
)
SMESH_Hypothesis::Hypothesis_Status SMESH_EXPORT::AddHypothesis ( const TopoDS_Shape &  aSubShape,
int  anHypId 
) throw (SALOME_Exception)
SMDS_MeshNode* SMESH_EXPORT::AddNode ( double  x,
double  y,
double  z,
int  ID = 0 
)

Creates a node.

SMDS_MeshFace* SMESH_EXPORT::AddPolygonalFace ( const std::vector< const SMDS_MeshNode * > &  nodes,
const int  id = 0,
const bool  force3d = false 
)

Creates polygon, with additional nodes in quadratic mesh.

SMDS_MeshVolume* SMESH_EXPORT::AddPolyhedralVolume ( const std::vector< const SMDS_MeshNode * > &  nodes,
const std::vector< int > &  quantities,
const int  ID = 0,
const bool  force3d = true 
)

Creates polyhedron.

In quadratic mesh, adds medium nodes

void SMESH_EXPORT::AddTLinkNode ( const SMDS_MeshNode *  n1,
const SMDS_MeshNode *  n2,
const SMDS_MeshNode *  n12 
)

Add a link in my data structure.

void SMESH_EXPORT::AddTLinkNodeMap ( const TLinkNodeMap aMap) [inline]

Add many links in my data structure.

Definition at line 477 of file SMESH_MesherHelper.hxx.

    { myTLinkNodeMap.insert(aMap.begin(), aMap.end()); }
void SMESH_EXPORT::AddTLinks ( const SMDS_MeshEdge *  edge)
void SMESH_EXPORT::AddTLinks ( const SMDS_MeshFace *  face)
void SMESH_EXPORT::AddTLinks ( const SMDS_MeshVolume *  vol)
static void SMESH_EXPORT::AddToSameGroups ( const SMDS_MeshElement *  elemToAdd,
const SMDS_MeshElement *  elemInGroups,
SMESHDS_Mesh *  aMesh 
) [static]
SMDS_MeshVolume* SMESH_EXPORT::AddVolume ( const SMDS_MeshNode *  n1,
const SMDS_MeshNode *  n2,
const SMDS_MeshNode *  n3,
const SMDS_MeshNode *  n4,
const int  id = 0,
const bool  force3d = true 
)

Creates quadratic or linear tetrahedron.

SMDS_MeshVolume* SMESH_EXPORT::AddVolume ( const SMDS_MeshNode *  n1,
const SMDS_MeshNode *  n2,
const SMDS_MeshNode *  n3,
const SMDS_MeshNode *  n4,
const SMDS_MeshNode *  n5,
const int  id = 0,
const bool  force3d = true 
)

Creates quadratic or linear pyramid.

SMDS_MeshVolume* SMESH_EXPORT::AddVolume ( const SMDS_MeshNode *  n1,
const SMDS_MeshNode *  n2,
const SMDS_MeshNode *  n3,
const SMDS_MeshNode *  n4,
const SMDS_MeshNode *  n5,
const SMDS_MeshNode *  n6,
const int  id = 0,
const bool  force3d = true 
)

Creates quadratic or linear pentahedron.

SMDS_MeshVolume* SMESH_EXPORT::AddVolume ( const SMDS_MeshNode *  n1,
const SMDS_MeshNode *  n2,
const SMDS_MeshNode *  n3,
const SMDS_MeshNode *  n4,
const SMDS_MeshNode *  n5,
const SMDS_MeshNode *  n6,
const SMDS_MeshNode *  n7,
const SMDS_MeshNode *  n8,
const int  id = 0,
bool  force3d = true 
)

Creates quadratic or linear hexahedron.

SMESH_Hypothesis::Hypothesis_Status SMESH_EXPORT::AlgoStateEngine ( int  event,
SMESH_Hypothesis anHyp 
)
bool SMESH_EXPORT::Apply ( const TopoDS_Face &  theFace,
const TopoDS_Vertex &  theVertexOnKeyPoint1,
const bool  theReverse 
)
bool SMESH_EXPORT::Apply ( const TopoDS_Shell &  theBlock,
const TopoDS_Vertex &  theVertex000,
const TopoDS_Vertex &  theVertex001 
)
bool SMESH_EXPORT::Apply ( const SMDS_MeshFace *  theFace,
const int  theNodeIndexOnKeyPoint1,
const bool  theReverse 
)
bool SMESH_EXPORT::Apply ( SMESH_Mesh theMesh,
const SMDS_MeshFace *  theFace,
const TopoDS_Shape &  theSurface,
const int  theNodeIndexOnKeyPoint1,
const bool  theReverse 
)
bool SMESH_EXPORT::Apply ( SMESH_Mesh theMesh,
std::set< const SMDS_MeshFace * > &  theFaces,
const int  theNodeIndexOnKeyPoint1,
const bool  theReverse 
)
bool SMESH_EXPORT::Apply ( const SMDS_MeshVolume *  theVolume,
const int  theNode000Index,
const int  theNode001Index 
)
bool SMESH_EXPORT::Apply ( std::set< const SMDS_MeshVolume * > &  theVolumes,
const int  theNode000Index,
const int  theNode001Index 
)
static gp_XY SMESH_EXPORT::applyIn2D ( const Handle(Geom_Surface)&  surface,
const gp_XY &  uv1,
const gp_XY &  uv2,
xyFunPtr  fun,
const bool  resultInPeriod = true 
) [static]

Perform given operation on two 2d points in parameric space of given surface.

It takes into account period of the surface. Use gp_XY_FunPtr macro to easily define pointer to function of gp_XY class.

void SMESH_EXPORT::arrangeBoundaries ( std::list< std::list< TPoint * > > &  boundaryPoints) [private]
int SMESH_EXPORT::BestSplit ( const SMDS_MeshElement *  theQuad,
SMESH::Controls::NumericalFunctorPtr  theCriterion 
)

Find better diagonal for splitting.

Parameters:
theQuad- The face to find better splitting of.
theCriterion- Is used to choose a diagonal for splitting.
Returns:
int - 1 for 1-3 diagonal, 2 for 2-4, -1 - for errors.
bool SMESH_EXPORT::CanAddHypothesis ( const SMESH_Hypothesis theHypothesis) const
int SMESH_EXPORT::CGNSToMesh ( const char *  theFileName,
const int  theMeshIndex,
std::string &  theMeshName 
)
bool SMESH_EXPORT::CheckAlgoState ( SMESH_Mesh aMesh,
const TopoDS_Shape &  aShape 
)
bool SMESH_EXPORT::checkComputeError ( SMESH_Algo theAlgo,
const TopoDS_Shape &  theShape = TopoDS_Shape() 
) [protected]

Update compute_state by _computeError.

Return values:
bool- false if there are errors
SMESH_Hypothesis::Hypothesis_Status SMESH_EXPORT::CheckConcurentHypothesis ( const int  theHypType)
static bool SMESH_EXPORT::CheckFreeBorderNodes ( const SMDS_MeshNode *  theNode1,
const SMDS_MeshNode *  theNode2,
const SMDS_MeshNode *  theNode3 = 0 
) [static]
virtual bool SMESH_EXPORT::CheckHypothesis ( SMESH_Mesh aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [pure virtual]

Check hypothesis definition to mesh a shape.

Parameters:
aMesh- the mesh
aShape- the shape
aStatus- check result
Return values:
bool- true if hypothesis is well defined
bool SMESH_EXPORT::CheckNodeU ( const TopoDS_Edge &  E,
const SMDS_MeshNode *  n,
double &  u,
const double  tol,
const bool  force = false,
double  distXYZ[4] = 0 
) const

Check and fix node U on an edge.

Parameters:
force- check even if checks of other nodes on this edge passed OK
distXYZ- returns result distance and point coordinates
Return values:
bool- false if U is bad and could not be fixed
bool SMESH_EXPORT::CheckNodeUV ( const TopoDS_Face &  F,
const SMDS_MeshNode *  n,
gp_XY &  uv,
const double  tol,
const bool  force = false,
double  distXYZ[4] = 0 
) const

Check and fix node UV on a face.

Parameters:
force- check even if checks of other nodes on this face passed OK
distXYZ- returns result distance and point coordinates
Return values:
bool- false if UV is bad and could not be fixed
void SMESH_EXPORT::cleanDependants ( ) [protected]
void SMESH_EXPORT::cleanDependsOn ( ) [protected]

Remove all nodes and elements.

void SMESH_EXPORT::ClearLog ( ) throw (SALOME_Exception)
void SMESH_EXPORT::clearMesh ( SMESH_Mesh theMesh) const [private]
void SMESH_EXPORT::ClearSubMesh ( const int  theShapeId)

Remove all nodes and elements of indicated shape.

bool SMESH_EXPORT::Compute ( ::SMESH_Mesh aMesh,
const TopoDS_Shape &  aShape,
const bool  anUpward = false,
const ::MeshDimension  aDim = ::MeshDim_3D,
TSetOfInt aShapesId = 0 
)

Computes aMesh on aShape.

Parameters:
anUpward- compute from vertices up to more complex shape (internal usage)
aDim- upper level dimension of the mesh computation
aShapesId- list of shapes with computed mesh entities (elements or nodes)
Return values:
bool- true if none submesh failed to compute

Here is the caller graph for this function:

virtual bool SMESH_EXPORT::Compute ( SMESH_Mesh aMesh,
const TopoDS_Shape &  aShape 
) [pure virtual]

Computes mesh on a shape.

Parameters:
aMesh- the mesh
aShape- the shape
Return values:
bool- is a success

Algorithms that !NeedDiscreteBoundary() || !OnlyUnaryInput() are to set SMESH_ComputeError returned by SMESH_submesh::GetComputeError() to report problematic sub-shapes

Here is the caller graph for this function:

virtual bool SMESH_EXPORT::Compute ( SMESH_Mesh aMesh,
SMESH_MesherHelper aHelper 
) [virtual]

Computes mesh without geometry.

Parameters:
aMesh- the mesh
aHelper- helper that must be used for adding elements to
Return values:
bool- is a success

The method is called if ( !aMesh->HasShapeToMesh() )

Here is the caller graph for this function:

bool SMESH_EXPORT::ComputeStateEngine ( int  event)
void SMESH_EXPORT::ComputeSubMeshStateEngine ( int  event,
const bool  includeSelf = false 
)
void SMESH_EXPORT::computeUVOnEdge ( const TopoDS_Edge &  theEdge,
const std::list< TPoint * > &  ePoints 
) [private]
bool SMESH_EXPORT::compUVByElasticIsolines ( const std::list< std::list< TPoint * > > &  boundaryPoints,
const std::list< TPoint * > &  pointsToCompute 
) [private]
bool SMESH_EXPORT::compUVByIsoIntersection ( const std::list< std::list< TPoint * > > &  boundaryPoints,
const gp_XY &  theInitUV,
gp_XY &  theUV,
bool &  theIsDeformed 
) [private]
static GeomAbs_Shape SMESH_EXPORT::Continuity ( TopoDS_Edge  E1,
TopoDS_Edge  E2 
) [static]

Return continuity of two edges.

Parameters:
E1- the 1st edge
E2- the 2nd edge
Return values:
GeomAbs_Shape- regularity at the junction between E1 and E2

Here is the caller graph for this function:

int SMESH_EXPORT::convertElemToQuadratic ( SMESHDS_SubMesh *  theSm,
SMESH_MesherHelper theHelper,
const bool  theForce3d 
) [private]

Convert elements contained in a submesh to quadratic.

Returns:
int - nb of checked elements
void SMESH_EXPORT::ConvertToQuadratic ( const bool  theForce3d)
void SMESH_EXPORT::ConvertToQuadratic ( const bool  theForce3d,
TIDSortedElemSet theElements 
)
void SMESH_EXPORT::createElements ( SMESH_Mesh theMesh,
const std::vector< const SMDS_MeshNode * > &  theNodesVector,
const std::list< std::list< int > > &  theElemNodeIDs,
const std::vector< const SMDS_MeshElement * > &  theElements 
) [private]
bool SMESH_EXPORT::CreateFlatElementsOnFacesGroups ( const std::vector< TIDSortedElemSet > &  theElems)
SMESH_Mesh* SMESH_EXPORT::CreateMesh ( int  theStudyId,
bool  theIsEmbeddedMode 
) throw (SALOME_Exception)
const SMDS_MeshNode* SMESH_EXPORT::CreateNode ( const double  x,
const double  y,
const double  z,
const double  tolnode,
SMESH_SequenceOfNode &  aNodes 
)

Create new node in the mesh with given coordinates (auxiliary for advanced extrusion)

SMESHDS_SubMesh* SMESH_EXPORT::CreateSubMeshDS ( )
bool SMESH_EXPORT::DeleteDiag ( const SMDS_MeshNode *  theNode1,
const SMDS_MeshNode *  theNode2 
)

Unregister the listener and delete it and it's data.

Parameters:
listener- the event listener to delete
void SMESH_EXPORT::deleteOwnListeners ( ) [protected]

Delete event listeners depending on algo of this submesh.

const std::map< int, SMESH_subMesh * >& SMESH_EXPORT::DependsOn ( )
bool SMESH_EXPORT::DoubleNodes ( const std::list< int > &  theListOfNodes,
const std::list< int > &  theListOfModifiedElems 
)
bool SMESH_EXPORT::DoubleNodes ( const TIDSortedElemSet theElems,
const TIDSortedElemSet theNodesNot,
const TIDSortedElemSet theAffectedElems 
)
bool SMESH_EXPORT::doubleNodes ( SMESHDS_Mesh *  theMeshDS,
const TIDSortedElemSet theElems,
const TIDSortedElemSet theNodesNot,
std::map< const SMDS_MeshNode *, const SMDS_MeshNode * > &  theNodeNodeMap,
const bool  theIsDoubleElem 
) [private]
bool SMESH_EXPORT::DoubleNodesInRegion ( const TIDSortedElemSet theElems,
const TIDSortedElemSet theNodesNot,
const TopoDS_Shape &  theShape 
)
bool SMESH_EXPORT::DoubleNodesOnGroupBoundaries ( const std::vector< TIDSortedElemSet > &  theElems,
bool  createJointElems 
)
ostream& SMESH_EXPORT::Dump ( ostream &  save)
void SMESH_EXPORT::DumpAlgoState ( bool  isMain)
void SMESH_EXPORT::DumpPoints ( ) const
static double SMESH_EXPORT::EdgeLength ( const TopoDS_Edge &  E) [static]

Compute length of an edge.

Parameters:
E- the edge
Return values:
double- the length
bool SMESH_EXPORT::error ( int  error,
const SMESH_Comment comment = "" 
) [protected]

store error and comment and then return ( error == COMPERR_OK )

bool SMESH_EXPORT::error ( const SMESH_Comment comment = "") [inline, protected]

store COMPERR_ALGO_FAILED error and comment and then return false

Definition at line 347 of file SMESH_Algo.hxx.

  { return error(COMPERR_ALGO_FAILED, comment); }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SMESH_EXPORT::error ( SMESH_ComputeErrorPtr  error) [protected]

store error and return error->IsOK()

bool SMESH_EXPORT::Evaluate ( ::SMESH_Mesh aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap,
const bool  anUpward = false,
TSetOfInt aShapesId = 0 
)

evaluates size of prospective mesh on a shape

Parameters:
aMesh- the mesh
aShape- the shape
aResMap- map for prospective numbers of elements
Return values:
bool- is a success
virtual bool SMESH_EXPORT::Evaluate ( SMESH_Mesh aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [pure virtual]

evaluates size of prospective mesh on a shape

Parameters:
aMesh- the mesh
aShape- the shape
aNbElems- prospective number of elements by types
Return values:
bool- is a success
void SMESH_EXPORT::ExportCGNS ( const char *  file,
const SMESHDS_Mesh *  mesh 
)
void SMESH_EXPORT::ExportDAT ( const char *  file,
const SMESHDS_Mesh *  meshPart = 0 
) throw (SALOME_Exception)
void SMESH_EXPORT::ExportMED ( const char *  file,
const char *  theMeshName = NULL,
bool  theAutoGroups = true,
int  theVersion = 0,
const SMESHDS_Mesh *  meshPart = 0 
) throw (SALOME_Exception)
void SMESH_EXPORT::ExportSAUV ( const char *  file,
const char *  theMeshName = NULL,
bool  theAutoGroups = true 
) throw (SALOME_Exception)
void SMESH_EXPORT::ExportSTL ( const char *  file,
const bool  isascii,
const SMESHDS_Mesh *  meshPart = 0 
) throw (SALOME_Exception)
void SMESH_EXPORT::ExportUNV ( const char *  file,
const SMESHDS_Mesh *  meshPart = 0 
) throw (SALOME_Exception)
Extrusion_Error SMESH_EXPORT::ExtrusionAlongTrack ( TIDSortedElemSet theElements,
SMESH_subMesh theTrackPattern,
const SMDS_MeshNode *  theNodeStart,
const bool  theHasAngles,
std::list< double > &  theAngles,
const bool  theLinearVariation,
const bool  theHasRefPoint,
const gp_Pnt &  theRefPoint,
const bool  theMakeGroups 
)
Extrusion_Error SMESH_EXPORT::ExtrusionAlongTrack ( TIDSortedElemSet theElements,
SMESH_Mesh theTrackPattern,
const SMDS_MeshNode *  theNodeStart,
const bool  theHasAngles,
std::list< double > &  theAngles,
const bool  theLinearVariation,
const bool  theHasRefPoint,
const gp_Pnt &  theRefPoint,
const bool  theMakeGroups 
)
PGroupIDs SMESH_EXPORT::ExtrusionSweep ( TIDSortedElemSet theElems,
const gp_Vec &  theStep,
const int  theNbSteps,
TElemOfElemListMap newElemsMap,
const bool  theMakeGroups,
const int  theFlags = EXTRUSION_FLAG_BOUNDARY,
const double  theTolerance = 1.e-6 
)

Generate new elements by extrusion of theElements It is a method used in .idl file.

All functionality is implemented in the next method (see below) which is used in the current method.

Parameters:
theElems- list of elements for extrusion
newElemsMapreturns history of extrusion
theFlagsset flags for performing extrusion (see description of enum ExtrusionFlags for additional information)
theTolerance- uses for comparing locations of nodes if flag EXTRUSION_FLAG_SEW is set
PGroupIDs SMESH_EXPORT::ExtrusionSweep ( TIDSortedElemSet theElems,
ExtrusParam theParams,
TElemOfElemListMap newElemsMap,
const bool  theMakeGroups,
const int  theFlags,
const double  theTolerance 
)

Generate new elements by extrusion of theElements.

Parameters:
theElems- list of elements for extrusion
newElemsMapreturns history of extrusion
theFlagsset flags for performing extrusion (see description of enum ExtrusionFlags for additional information)
theTolerance- uses for comparing locations of nodes if flag EXTRUSION_FLAG_SEW is set
theParams- special structure for manage of extrusion
static bool SMESH_EXPORT::FaceNormal ( const SMDS_MeshElement *  F,
gp_XYZ &  normal,
bool  normalized = true 
) [static]

Calculate normal of a mesh face.

void SMESH_EXPORT::fillAncestorsMap ( const TopoDS_Shape &  theShape) [private]
void SMESH_EXPORT::FindCoincidentNodes ( TIDSortedNodeSet theNodes,
const double  theTolerance,
TListOfListOfNodes theGroupsOfNodes 
)
void SMESH_EXPORT::FindEqualElements ( std::set< const SMDS_MeshElement * > &  theElements,
TListOfListOfElementsID theGroupsOfElementsID 
)
static const SMDS_MeshElement* SMESH_EXPORT::FindFaceInSet ( const SMDS_MeshNode *  n1,
const SMDS_MeshNode *  n2,
const TIDSortedElemSet elemSet,
const TIDSortedElemSet avoidSet,
int *  i1 = 0,
int *  i2 = 0 
) [static]
static bool SMESH_EXPORT::FindFreeBorder ( const SMDS_MeshNode *  theFirstNode,
const SMDS_MeshNode *  theSecondNode,
const SMDS_MeshNode *  theLastNode,
std::list< const SMDS_MeshNode * > &  theNodes,
std::list< const SMDS_MeshElement * > &  theFaces 
) [static]
bool SMESH_EXPORT::FindIntersection ( const SMESH_subMesh theOther,
std::set< const SMESH_subMesh * > &  theSetOfCommon 
) const

Find common submeshes (based on shared subshapes with other.

Parameters:
theOthersubmesh to check
theCommonIdsset of common submesh IDs NOTE: this method does not cleat set before collect common IDs
static Sew_Error SMESH_EXPORT::FindMatchingNodes ( std::set< const SMDS_MeshElement * > &  theSide1,
std::set< const SMDS_MeshElement * > &  theSide2,
const SMDS_MeshNode *  theFirstNode1,
const SMDS_MeshNode *  theFirstNode2,
const SMDS_MeshNode *  theSecondNode1,
const SMDS_MeshNode *  theSecondNode2,
TNodeNodeMap theNodeReplaceMap 
) [static]

Find corresponding nodes in two sets of faces.

Parameters:
theSide1- first face set
theSide2- second first face
theFirstNode1- a boundary node of set 1
theFirstNode2- a node of set 2 corresponding to theFirstNode1
theSecondNode1- a boundary node of set 1 linked with theFirstNode1
theSecondNode2- a node of set 2 corresponding to theSecondNode1
nReplaceMap- output map of corresponding nodes
Returns:
Sew_Error - is a success or not
SubMesh* SMESH_EXPORT::findProxySubMesh ( int  shapeIndex = 0) const [protected]
int SMESH_EXPORT::FindShape ( const SMDS_MeshElement *  theElem)
void SMESH_EXPORT::FixQuadraticElements ( bool  volumeOnly = true)

Move medium nodes of faces and volumes to fix distorted elements.

Parameters:
volumeOnly- fix nodes on geom faces or not if the shape is solid
PGroupIDs SMESH_EXPORT::generateGroups ( const SMESH_SequenceOfElemPtr &  nodeGens,
const SMESH_SequenceOfElemPtr &  elemGens,
const std::string &  postfix,
SMESH_Mesh targetMesh = 0 
) [private]

Create groups of elements made during transformation.

Parameters:
nodeGens- nodes making corresponding myLastCreatedNodes
elemGens- elements making corresponding myLastCreatedElems
postfix- to append to names of new groups
SMESH_Algo* SMESH_EXPORT::GetAlgo ( SMESH_Mesh aMesh,
const TopoDS_Shape &  aShape,
TopoDS_Shape *  assignedTo = 0 
)
bool SMESH_EXPORT::GetAlgoState ( SMESH_Mesh aMesh,
const TopoDS_Shape &  aShape,
std::list< SMESH_Gen::TAlgoStateError > &  theErrors 
)
int SMESH_EXPORT::GetAlgoState ( ) const [inline]

Definition at line 206 of file SMESH_subMesh.hxx.

{ return _algoState; }
const TAncestorMap& SMESH_EXPORT::GetAncestorMap ( ) const [inline]

Definition at line 221 of file SMESH_Mesh.hxx.

{ return _mapAncestors; }
static PShapeIteratorPtr SMESH_EXPORT::GetAncestors ( const TopoDS_Shape &  shape,
const SMESH_Mesh mesh,
TopAbs_ShapeEnum  ancestorType 
) [static]

Return iterator on ancestors of the given type.

const TopTools_ListOfShape& SMESH_EXPORT::GetAncestors ( const TopoDS_Shape &  theSubShape) const

Return list of ancestors of theSubShape in the order that lower dimention shapes come first.

std::list<SMESH_subMesh*> SMESH_EXPORT::getAncestorsSubMeshes ( const TopoDS_Shape &  theSubShape) const [private]
const list<const SMESHDS_Hypothesis *>& SMESH_EXPORT::GetAppliedHypothesis ( SMESH_Mesh aMesh,
const TopoDS_Shape &  aShape,
const bool  ignoreAuxiliary = true 
)

Returns a list of compatible hypotheses assigned to a shape in a mesh.

Parameters:
aMesh- the mesh
aShape- the shape
ignoreAuxiliary- do not include auxiliary hypotheses in the list
Return values:
conststd::list <const SMESHDS_Hypothesis*> - hypotheses list

List the relevant hypothesis associated to the shape. Relevant hypothesis have a name (type) listed in the algorithm. Hypothesis associated to father shape -are not- taken into account (see GetUsedHypothesis)

bool SMESH_EXPORT::GetAutoColor ( ) throw (SALOME_Exception)

Definition at line 115 of file SMESH_Gen.hxx.

{ return _segmentation; }
TopoDS_Shape SMESH_EXPORT::getCollection ( SMESH_Gen theGen,
SMESH_Algo theAlgo,
bool &  theSubComputed 
) [protected]

Return a shape containing all sub-shapes of the MainShape that can be meshed at once along with _subShape.

static TopoDS_Shape SMESH_EXPORT::GetCommonAncestor ( const TopoDS_Shape &  shape1,
const TopoDS_Shape &  shape2,
const SMESH_Mesh mesh,
TopAbs_ShapeEnum  ancestorType 
) [static]

Find a common ancestors of two shapes of the given type.

static std::vector< const SMDS_MeshNode*> SMESH_EXPORT::GetCommonNodes ( const SMDS_MeshElement *  e1,
const SMDS_MeshElement *  e2 
) [static]

Return nodes common to two elements.

const std::vector< std::string >& SMESH_EXPORT::GetCompatibleHypothesis ( )

Returns all types of compatible hypotheses.

Here is the caller graph for this function:

return compute error

Definition at line 208 of file SMESH_subMesh.hxx.

{ return _computeError; }
int SMESH_EXPORT::GetComputeState ( ) const [inline]

Definition at line 207 of file SMESH_subMesh.hxx.

{ return _computeState; };
int SMESH_EXPORT::GetDefaultNbSegments ( ) const [inline]

Definition at line 120 of file SMESH_Gen.hxx.

{ return _nbSegments; }
SMESH_subMeshIteratorPtr SMESH_EXPORT::getDependsOnIterator ( const bool  includeSelf,
const bool  complexShapeFirst 
)

Return iterator on the submeshes this one depends on.

virtual int SMESH_EXPORT::GetDim ( ) const [virtual]
const std::list< std::list< int > >& SMESH_EXPORT::GetElementPointIDs ( bool  applied) const [inline]

Definition at line 215 of file SMESH_Pattern.hxx.

  { return myElemXYZIDs.empty() || !applied ? myElemPointIDs : myElemXYZIDs; }

Return SMESH_ElementSearcher.

The caller is responsible for deleting it

SMDSAbs_ElementType SMESH_EXPORT::GetElementType ( const int  id,
const bool  iselem 
)

Here is the caller graph for this function:

Definition at line 199 of file SMESH_Pattern.hxx.

{ return myErrorCode; }

Return an event listener data.

Parameters:
listener- the listener whose data is
Return values:
EventListenerData*- found data, maybe NULL
SMDS_ElemIteratorPtr SMESH_EXPORT::GetFaces ( const TopoDS_Shape &  face) const
bool SMESH_EXPORT::getFacesDefinition ( const SMDS_MeshNode **  theBndNodes,
const int  theNbBndNodes,
const std::vector< const SMDS_MeshNode * > &  theNodes,
std::list< int > &  theFaceDefs,
std::vector< int > &  theQuantity 
) [private]

Definition at line 68 of file SMESH_subMesh.hxx.

{ return _father; }

Definition at line 159 of file SMESH_Mesh.hxx.

{ return _gen; }
SMESH_Group* SMESH_EXPORT::GetGroup ( const int  theGroupID)
SMESHDS_GroupBase* SMESH_EXPORT::GetGroupDS ( ) [inline]

Definition at line 59 of file SMESH_Group.hxx.

{ return myGroupDS; }
std::list<int> SMESH_EXPORT::GetGroupIds ( ) const

Here is the caller graph for this function:

std::list<SMESH_subMesh*> SMESH_EXPORT::GetGroupSubMeshesContaining ( const TopoDS_Shape &  shape) const throw (SALOME_Exception)

Return submeshes of groups containing the given subshape.

int SMESH_EXPORT::GetHypotheses ( const TopoDS_Shape &  aSubShape,
const SMESH_HypoFilter aFilter,
std::list< const SMESHDS_Hypothesis * > &  aHypList,
const bool  andAncestors 
) const
const SMESH_Hypothesis* SMESH_EXPORT::GetHypothesis ( const TopoDS_Shape &  aSubShape,
const SMESH_HypoFilter aFilter,
const bool  andAncestors,
TopoDS_Shape *  assignedTo = 0 
) const
const std::list<const SMESHDS_Hypothesis * >& SMESH_EXPORT::GetHypothesisList ( const TopoDS_Shape &  aSubShape) const throw (SALOME_Exception)

Here is the caller graph for this function:

int SMESH_EXPORT::GetId ( ) const
int SMESH_EXPORT::GetId ( ) const [inline]

Definition at line 151 of file SMESH_Mesh.hxx.

{ return _id; }
bool SMESH_EXPORT::GetIsModified ( ) const [inline]

Definition at line 208 of file SMESH_Mesh.hxx.

{ return _isModified; }
bool SMESH_EXPORT::GetIsQuadratic ( ) const [inline]

Return myCreateQuadratic flag.

Definition at line 191 of file SMESH_MesherHelper.hxx.

{ return myCreateQuadratic; }
const std::list< int >& SMESH_EXPORT::GetKeyPointIDs ( ) const [inline]

Definition at line 211 of file SMESH_Pattern.hxx.

{ return myKeyPointIDs; }
const SMESH_SequenceOfElemPtr& SMESH_EXPORT::GetLastCreatedElems ( ) const [inline]

Definition at line 555 of file SMESH_MeshEditor.hxx.

{ return myLastCreatedElems; }
const SMESH_SequenceOfElemPtr& SMESH_EXPORT::GetLastCreatedNodes ( ) const [inline]

Definition at line 553 of file SMESH_MeshEditor.hxx.

{ return myLastCreatedNodes; }
virtual const char* SMESH_EXPORT::GetLibName ( ) const [virtual]
static void SMESH_EXPORT::GetLinkedNodes ( const SMDS_MeshNode *  node,
TIDSortedElemSet linkedNodes,
SMDSAbs_ElementType  type = SMDSAbs_All 
) [static]

Return nodes linked to the given one in elements of the type.

const std::list<SMESHDS_Command*>& SMESH_EXPORT::GetLog ( ) throw (SALOME_Exception)
bool SMESH_EXPORT::GetMappedPoints ( std::list< const gp_XYZ * > &  thePoints) const
const SMDS_MeshNode* SMESH_EXPORT::GetMediumNode ( const SMDS_MeshNode *  n1,
const SMDS_MeshNode *  n2,
const bool  force3d 
)

Return existing or create new medium nodes between given ones.

Parameters:
force3d- true means node creation at the middle between the two given nodes, else node position is found on its supporting geometrical shape, if any.
const SMDS_MeshNode* SMESH_EXPORT::getMediumNodeOnComposedWire ( const SMDS_MeshNode *  n1,
const SMDS_MeshNode *  n2,
bool  force3d 
) [protected]
std::pair<int, TopAbs_ShapeEnum> SMESH_EXPORT::GetMediumPos ( const SMDS_MeshNode *  n1,
const SMDS_MeshNode *  n2 
)

Return index and type of the shape (EDGE or FACE only) to set a medium node on.

const SMESH_Mesh* SMESH_EXPORT::GetMesh ( ) const [inline]

Definition at line 116 of file SMESH_ProxyMesh.hxx.

{ return _mesh; }

Here is the caller graph for this function:

SMESH_Mesh* SMESH_EXPORT::GetMesh ( ) const [inline]

Definition at line 174 of file SMESH_MesherHelper.hxx.

{ return myMesh; }

Here is the caller graph for this function:

Definition at line 549 of file SMESH_MeshEditor.hxx.

{ return myMesh; }

Here is the caller graph for this function:

Find a mesh with given persistent ID.

SMESHDS_Mesh* SMESH_EXPORT::GetMeshDS ( ) const
SMESHDS_Mesh* SMESH_EXPORT::GetMeshDS ( ) [inline]

Definition at line 155 of file SMESH_Mesh.hxx.

{ return _myMeshDS; }

Here is the caller graph for this function:

const SMESHDS_Mesh* SMESH_EXPORT::GetMeshDS ( ) const [inline]

Definition at line 157 of file SMESH_Mesh.hxx.

{ return _myMeshDS; }
SMESHDS_Mesh* SMESH_EXPORT::GetMeshDS ( ) const [inline]

Definition at line 176 of file SMESH_MesherHelper.hxx.

{ return GetMesh()->GetMeshDS(); }

Here is the call graph for this function:

SMESHDS_Mesh* SMESH_EXPORT::GetMeshDS ( ) [inline]

Definition at line 551 of file SMESH_MeshEditor.hxx.

{ return myMesh->GetMeshDS(); }
static EMeshError SMESH_EXPORT::GetMeshError ( SMESH_subMesh subMesh) [static]

Finds topological errors of a sub-mesh.

static gp_XY SMESH_EXPORT::GetMiddleUV ( const Handle(Geom_Surface)&  surface,
const gp_XY &  uv1,
const gp_XY &  uv2 
) [static]

Return middle UV taking in account surface period.

const char* SMESH_EXPORT::GetName ( ) const [inline]

Definition at line 57 of file SMESH_Group.hxx.

{ return myName.c_str(); }
static bool SMESH_EXPORT::GetNodeParamOnEdge ( const SMESHDS_Mesh *  theMesh,
const TopoDS_Edge &  theEdge,
std::vector< double > &  theParams 
) [static]

Fill vector of node parameters on geometrical edge, including vertex nodes.

Parameters:
theMesh- The mesh containing nodes
theEdge- The geometrical edge of interest
theParams- The resulting vector of sorted node parameters
Return values:
bool- false if not all parameters are OK

Return SMESH_NodeSearcher.

The caller is responsible for deleteing it

double SMESH_EXPORT::GetNodeU ( const TopoDS_Edge &  theEdge,
const SMDS_MeshNode *  theNode,
const SMDS_MeshNode *  inEdgeNode = 0,
bool *  check = 0 
)

Return U of the given node on the edge.

gp_XY SMESH_EXPORT::GetNodeUV ( const TopoDS_Face &  F,
const SMDS_MeshNode *  n,
const SMDS_MeshNode *  inFaceNode = 0,
bool *  check = 0 
) const

Return node UV on face.

Parameters:
inFaceNode- a node of element being created located inside a face
bool SMESH_EXPORT::GetNodeUVneedInFaceNode ( const TopoDS_Face &  F = TopoDS_Face()) const

Check if inFaceNode argument is necessary for call GetNodeUV(F,..)

Return values:
bool- return true if the face is periodic

If F is Null, answer about subshape set through IsQuadraticSubMesh() or SetSubShape()

double SMESH_EXPORT::GetOtherParam ( const double  param) const

Return an alternative parameter for a node on seam.

char* SMESH_EXPORT::GetParameters ( ) const
int SMESH_EXPORT::GetPeriodicIndex ( ) const [inline]

Return index of periodic parametric direction of a closed face.

Return values:
int- 1 for U, 2 for V direction

Definition at line 448 of file SMESH_MesherHelper.hxx.

{ return myParIndex; }
bool SMESH_EXPORT::GetPoints ( std::list< const gp_XYZ * > &  thePoints) const
GeomAPI_ProjectPointOnSurf& SMESH_EXPORT::GetProjector ( const TopoDS_Face &  F,
TopLoc_Location &  loc,
double  tol = 0 
) const

Return projector intitialized by given face without location, which is returned.

const SMDS_MeshNode* SMESH_EXPORT::GetProxyNode ( const SMDS_MeshNode *  node) const
const SubMesh* SMESH_EXPORT::GetProxySubMesh ( const TopoDS_Shape &  face) const
SubMesh* SMESH_EXPORT::getProxySubMesh ( int  shapeIndex) [protected]
SubMesh* SMESH_EXPORT::getProxySubMesh ( const TopoDS_Shape &  shape = TopoDS_Shape()) [protected]

Return diagonal size of bounding box of shape to mesh.

static double SMESH_EXPORT::GetShapeDiagonalSize ( const TopoDS_Shape &  aShape) [static]

Return diagonal size of bounding box of a shape.

static int SMESH_EXPORT::GetShapeDim ( const TopAbs_ShapeEnum &  aShapeType) [static]
static int SMESH_EXPORT::GetShapeDim ( const TopoDS_Shape &  aShape) [inline, static]

Definition at line 145 of file SMESH_Gen.hxx.

  { return GetShapeDim( aShape.ShapeType() ); }

Here is the call graph for this function:

Here is the caller graph for this function:

std::list< TPoint* >& SMESH_EXPORT::getShapePoints ( const TopoDS_Shape &  theShape) [private]
std::list< TPoint* >& SMESH_EXPORT::getShapePoints ( const int  theShapeID) [private]
TopoDS_Shape SMESH_EXPORT::GetShapeToMesh ( ) const

Return geometry to be meshed.

(It may be a PseudoShape()!)

virtual int SMESH_EXPORT::GetShapeType ( ) const [virtual]
const SMESH_Hypothesis* SMESH_EXPORT::getSimilarAttached ( const TopoDS_Shape &  theShape,
const SMESH_Hypothesis theHyp,
const int  theHypType = 0 
) [protected]

Return a hypothesis attached to theShape.

If theHyp is provided, similar but not same hypotheses is returned; else an applicable ones having theHypType is returned

static bool SMESH_EXPORT::GetSortedNodesOnEdge ( const SMESHDS_Mesh *  theMesh,
const TopoDS_Edge &  theEdge,
const bool  ignoreMediumNodes,
std::map< double, const SMDS_MeshNode * > &  theNodes 
) [static]

Fill map of node parameter on geometrical edge to node it-self.

Parameters:
theMesh- The mesh containing nodes
theEdge- The geometrical edge of interest
theNodes- The resulting map
ignoreMediumNodes- to store medium nodes of quadratic elements or not
Return values:
bool- false if not all parameters are OK
int SMESH_EXPORT::GetStudyId ( ) const
const SMESHDS_SubMesh* SMESH_EXPORT::GetSubMesh ( const TopoDS_Shape &  face) const
SMESH_subMesh* SMESH_EXPORT::GetSubMesh ( const TopoDS_Shape &  aSubShape) throw (SALOME_Exception)
SMESH_subMesh* SMESH_EXPORT::GetSubMeshContaining ( const TopoDS_Shape &  aSubShape) const throw (SALOME_Exception)
SMESH_subMesh* SMESH_EXPORT::GetSubMeshContaining ( const int  aShapeID) const throw (SALOME_Exception)
SMESHDS_SubMesh* SMESH_EXPORT::GetSubMeshDS ( )
const std::list< SMESH_subMesh * >& SMESH_EXPORT::GetSubMeshUsingHypothesis ( SMESHDS_Hypothesis *  anHyp) throw (SALOME_Exception)
static SMESHDS_SubMesh* SMESH_EXPORT::getSubmeshWithElements ( SMESH_Mesh theMesh,
const TopoDS_Shape &  theShape 
) [static, private]
const TopoDS_Shape& SMESH_EXPORT::GetSubShape ( ) const
const TopoDS_Shape& SMESH_EXPORT::GetSubShape ( ) const [inline]

Return the shape set by IsQuadraticSubMesh() or SetSubShape()

Definition at line 219 of file SMESH_MesherHelper.hxx.

{ return myShape; }
TopoDS_Shape SMESH_EXPORT::GetSubShape ( const int  i) const [inline]

Definition at line 226 of file SMESH_Pattern.hxx.

                                                {
    if ( i < 1 || i > myShapeIDMap.Extent() ) return TopoDS_Shape();
    return myShapeIDMap( i );
  }
static TopoDS_Shape SMESH_EXPORT::GetSubShapeByNode ( const SMDS_MeshNode *  node,
const SMESHDS_Mesh *  meshDS 
) [static]

Return support shape of a node.

Parameters:
node- the node
meshDS- mesh DS
Return values:
TopoDS_Shape- found support shape
int SMESH_EXPORT::GetSubShapeID ( ) const [inline]

Return ID of the shape set by IsQuadraticSubMesh() or SetSubShape()

Return values:
int- shape index in SMESHDS

Definition at line 215 of file SMESH_MesherHelper.hxx.

{ return myShapeID; }
static TopAbs_Orientation SMESH_EXPORT::GetSubShapeOri ( const TopoDS_Shape &  shape,
const TopoDS_Shape &  subShape 
) [static]

Return orientation of sub-shape in the main shape.

const TLinkNodeMap& SMESH_EXPORT::GetTLinkNodeMap ( ) const [inline]

Returns myTLinkNodeMap.

Definition at line 487 of file SMESH_MesherHelper.hxx.

{ return myTLinkNodeMap; }
virtual const std::list<const SMESHDS_Hypothesis *>& SMESH_EXPORT::GetUsedHypothesis ( SMESH_Mesh aMesh,
const TopoDS_Shape &  aShape,
const bool  ignoreAuxiliary = true 
) [virtual]

Returns a list of compatible hypotheses used to mesh a shape.

Parameters:
aMesh- the mesh
aShape- the shape
ignoreAuxiliary- do not include auxiliary hypotheses in the list
Return values:
conststd::list <const SMESHDS_Hypothesis*> - hypotheses list

List the hypothesis used by the algorithm associated to the shape. Hypothesis associated to father shape -are- taken into account (see GetAppliedHypothesis). Relevant hypothesis have a name (type) listed in the algorithm. This method could be surcharged by specific algorithms, in case of several hypothesis simultaneously applicable.

gp_Pnt2d SMESH_EXPORT::GetUVOnSeam ( const gp_Pnt2d &  uv1,
const gp_Pnt2d &  uv2 
) const [protected]

Select UV on either of 2 pcurves of a seam edge, closest to the given UV.

Parameters:
uv1- UV on the seam
uv2- UV within a face
Return values:
gp_Pnt2d- selected UV
bool SMESH_EXPORT::HasDegeneratedEdges ( ) const [inline]

Check if the shape set through IsQuadraticSubMesh() or SetSubShape() has a degenerated edges.

Return values:
bool- true if it has

Definition at line 404 of file SMESH_MesherHelper.hxx.

{ return !myDegenShapeIds.empty(); }
static SMESH_HypoPredicate* SMESH_EXPORT::HasDim ( const int  theDim) [static]

Check group names for duplications.

Consider maximum group name length stored in MED file

Return true if the mesh has been edited since a total re-compute and those modifications may prevent successful partial re-compute.

As a side effect reset _isModified flag if mesh is empty

static SMESH_HypoPredicate* SMESH_EXPORT::HasName ( const std::string &  theName) [static]
bool SMESH_EXPORT::HasSeam ( ) const [inline]

Check if the shape set through IsQuadraticSubMesh() or SetSubShape() has a seam edge.

Return values:
bool- true if it has

Definition at line 443 of file SMESH_MesherHelper.hxx.

{ return !mySeamShapeIds.empty(); }
bool SMESH_EXPORT::HasShapeToMesh ( ) const [inline]

Return true if there is a geometry to be meshed, not PseudoShape()

Definition at line 86 of file SMESH_Mesh.hxx.

{ return _isShapeToMesh; }
static SMESH_HypoPredicate* SMESH_EXPORT::HasType ( const int  theHypType) [static]
SMESH_HypoFilter& SMESH_EXPORT::Init ( SMESH_HypoPredicate aPredicate,
bool  notNagate = true 
)
bool SMESH_EXPORT::InitCompatibleHypoFilter ( SMESH_HypoFilter theFilter,
const bool  ignoreAuxiliary 
) const

Make the filter recognize only compatible hypotheses.

Parameters:
theFilter- the filter to initialize
ignoreAuxiliary- make filter ignore compatible auxiliary hypotheses
Return values:
bool- true if the algo has compatible hypotheses

initialize compute error

void SMESH_EXPORT::insertDependence ( const TopoDS_Shape  aSubShape) [protected]
void SMESH_EXPORT::InsertNodesIntoLink ( const SMDS_MeshElement *  theFace,
const SMDS_MeshNode *  theBetweenNode1,
const SMDS_MeshNode *  theBetweenNode2,
std::list< const SMDS_MeshNode * > &  theNodesToInsert,
const bool  toCreatePoly = false 
)
bool SMESH_EXPORT::InverseDiag ( const SMDS_MeshElement *  theTria1,
const SMDS_MeshElement *  theTria2 
)
bool SMESH_EXPORT::InverseDiag ( const SMDS_MeshNode *  theNode1,
const SMDS_MeshNode *  theNode2 
)
static SMESH_HypoPredicate* SMESH_EXPORT::Is ( const SMESH_Hypothesis theHypo) [static]
bool SMESH_EXPORT::Is2D ( ) const [inline]

Definition at line 205 of file SMESH_Pattern.hxx.

{ return myIs2D; }
bool SMESH_EXPORT::IsAlwaysComputed ( ) [inline]

Definition at line 248 of file SMESH_subMesh.hxx.

{ return _alwaysComputed; }
bool SMESH_EXPORT::IsAny ( ) const [inline]

return true if contains no predicates

Definition at line 93 of file SMESH_HypoFilter.hxx.

{ return myPredicates.empty(); }
static bool SMESH_EXPORT::IsApplicableHypotesis ( const SMESH_Hypothesis theHypothesis,
const TopAbs_ShapeEnum  theShapeType 
) [static]
bool SMESH_EXPORT::IsApplicableHypotesis ( const SMESH_Hypothesis theHypothesis) const [inline]

Definition at line 227 of file SMESH_subMesh.hxx.

  { return IsApplicableHypotesis( theHypothesis, _subShape.ShapeType() ); }

Here is the call graph for this function:

Here is the caller graph for this function:

static SMESH_HypoPredicate* SMESH_EXPORT::IsApplicableTo ( const TopoDS_Shape &  theShape) [static]
static SMESH_HypoPredicate* SMESH_EXPORT::IsAssignedTo ( const TopoDS_Shape &  theShape) [static]
virtual bool SMESH_EXPORT::IsAuxiliary ( ) const [inline, virtual]

Return true if me is an auxiliary hypothesis.

Return values:
bool- auxiliary or not

An auxiliary hypothesis is optional, i.e. an algorithm can work without it and another hypothesis of the same dimention can be assigned to the shape

Definition at line 115 of file SMESH_Hypothesis.hxx.

  { return GetType() == PARAM_ALGO && _param_algo_dim < 0; }
static bool SMESH_EXPORT::IsClosedEdge ( const TopoDS_Edge &  anEdge) [static]
bool SMESH_EXPORT::IsConform ( const SMESH_Algo theAlgo)
static bool SMESH_EXPORT::IsContinuous ( const TopoDS_Edge &  E1,
const TopoDS_Edge &  E2 
) [inline, static]

Return true if an edge can be considered as a continuation of another.

Definition at line 313 of file SMESH_Algo.hxx.

                                                                           {
    return ( Continuity( E1, E2 ) >= GeomAbs_G1 );
  }

Here is the call graph for this function:

bool SMESH_EXPORT::IsDegenShape ( const int  subShape) const [inline]

Check if shape is a degenerated edge or it's vertex.

Parameters:
subShape- edge or vertex index in SMESHDS
Return values:
bool- true if subShape is a degenerated shape

It works only if IsQuadraticSubMesh() or SetSubShape() has been called

Definition at line 397 of file SMESH_MesherHelper.hxx.

  { return myDegenShapeIds.find( subShape ) != myDegenShapeIds.end(); }
bool SMESH_EXPORT::IsDeletable ( ) const [inline]

Definition at line 60 of file SMESH_subMeshEventListener.hxx.

{ return myIsDeletable; }
bool SMESH_EXPORT::IsEmpty ( ) const [inline]

Definition at line 83 of file SMESH_HypoFilter.hxx.

{ return myPredicates.empty(); }
bool SMESH_EXPORT::IsEmpty ( ) const

Return true if no mesh entities is bound to the submesh.

static SMESH_HypoPredicate* SMESH_EXPORT::IsGlobal ( const TopoDS_Shape &  theMainShape) [static]
static bool SMESH_EXPORT::IsGlobalHypothesis ( const SMESH_Hypothesis theHyp,
SMESH_Mesh aMesh 
) [static]
bool SMESH_EXPORT::IsLoaded ( ) const [inline]

Definition at line 202 of file SMESH_Pattern.hxx.

{ return !myPoints.empty() && !myElemPointIDs.empty(); }
bool SMESH_EXPORT::IsMainShape ( const TopoDS_Shape &  theShape) const
static bool SMESH_EXPORT::IsMedium ( const SMDS_MeshNode *  node,
const SMDSAbs_ElementType  typeToCheck = SMDSAbs_All 
) [static]

Returns true if given node is medium.

Parameters:
n- node to check
typeToCheck- type of elements containing the node to ask about node status
Return values:
bool- check result
static bool SMESH_EXPORT::IsMedium ( const SMDS_MeshNode *  node,
const SMDSAbs_ElementType  typeToCheck = SMDSAbs_All 
) [static]

Returns true if given node is medium.

Parameters:
n- node to check
typeToCheck- type of elements containing the node to ask about node status
Returns:
bool - check result
static SMESH_HypoPredicate* SMESH_EXPORT::IsMoreLocalThan ( const TopoDS_Shape &  theShape,
const SMESH_Mesh theMesh 
) [static]

check if a hypothesis alowing notconform mesh is present

virtual bool SMESH_EXPORT::IsOk ( const SMESH_Hypothesis aHyp,
const TopoDS_Shape &  aShape 
) const [pure virtual]
bool SMESH_EXPORT::IsOk ( const SMESH_Hypothesis aHyp,
const TopoDS_Shape &  aShape 
) const

check aHyp or/and aShape it is assigned to

static bool SMESH_EXPORT::isOut ( const SMDS_MeshElement *  element,
const gp_Pnt &  point,
double  tol 
) [static]

Return true if the point is IN or ON of the element.

bool SMESH_EXPORT::IsQuadraticSubMesh ( const TopoDS_Shape &  theShape)

Check submesh for given shape: if all elements on this shape are quadratic, quadratic elements will be created.

Also fill myTLinkNodeMap

bool SMESH_EXPORT::IsRealSeam ( const int  subShape) const [inline]

Return true if an edge or a vertex encounters twice in face wire.

Parameters:
subShape- Id of edge or vertex

Definition at line 430 of file SMESH_MesherHelper.hxx.

  { return mySeamShapeIds.find( -subShape ) != mySeamShapeIds.end(); }
bool SMESH_EXPORT::IsRealSeam ( const TopoDS_Shape &  subShape) const [inline]

Return true if an edge or a vertex encounters twice in face wire.

Parameters:
subShape- edge or vertex

Definition at line 436 of file SMESH_MesherHelper.hxx.

  { return IsRealSeam( GetMeshDS()->ShapeToIndex( subShape)); }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SMESH_EXPORT::isReversed ( const SMDS_MeshNode *  theFirstNode,
const std::list< int > &  theIdsList 
) const [private]
static bool SMESH_EXPORT::IsReversedSubMesh ( const TopoDS_Face &  theFace,
SMESHDS_Mesh *  theMeshDS 
) [static]

Find out elements orientation on a geometrical face.

Parameters:
theFace- The face correctly oriented in the shape being meshed
theMeshDS- The mesh data structure
Return values:
bool- true if the face normal and the normal of first element in the correspoding submesh point in different directions
bool SMESH_EXPORT::IsSeamShape ( const int  subShape) const [inline]

Check if shape is a seam edge or it's vertex.

Parameters:
subShape- edge or vertex index in SMESHDS
Return values:
bool- true if subShape is a seam shape

It works only if IsQuadraticSubMesh() or SetSubShape() has been called. Seam shape has two 2D alternative represenations on the face

Definition at line 414 of file SMESH_MesherHelper.hxx.

  { return mySeamShapeIds.find( subShape ) != mySeamShapeIds.end(); }
bool SMESH_EXPORT::IsSeamShape ( const TopoDS_Shape &  subShape) const [inline]

Check if shape is a seam edge or it's vertex.

Parameters:
subShape- edge or vertex
Return values:
bool- true if subShape is a seam shape

It works only if IsQuadraticSubMesh() or SetSubShape() has been called. Seam shape has two 2D alternative represenations on the face

Definition at line 424 of file SMESH_MesherHelper.hxx.

  { return IsSeamShape( GetMeshDS()->ShapeToIndex( subShape )); }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool SMESH_EXPORT::IsStatusFatal ( Hypothesis_Status  theStatus) [inline, static]

Definition at line 68 of file SMESH_Hypothesis.hxx.

  { return theStatus >= HYP_UNKNOWN_FATAL; }
static bool SMESH_EXPORT::IsSubShape ( const TopoDS_Shape &  shape,
const TopoDS_Shape &  mainShape 
) [static]
static bool SMESH_EXPORT::IsSubShape ( const TopoDS_Shape &  shape,
SMESH_Mesh aMesh 
) [static]
bool SMESH_EXPORT::IsTemporary ( const SMDS_MeshElement *  elem) const
bool SMESH_EXPORT::IsUsedHypothesis ( SMESHDS_Hypothesis *  anHyp,
const SMESH_subMesh aSubMesh 
)

Return True if anHyp is used to mesh aSubShape.

static TopoDS_Vertex SMESH_EXPORT::IthVertex ( const bool  is2nd,
TopoDS_Edge  anEdge,
const bool  CumOri = true 
) [static]
void SMESH_EXPORT::LinearAngleVariation ( const int  NbSteps,
list< double > &  theAngles 
) [private]
bool SMESH_EXPORT::Load ( const char *  theFileContents)
bool SMESH_EXPORT::Load ( SMESH_Mesh theMesh,
const TopoDS_Face &  theFace,
bool  theProject = false 
)
bool SMESH_EXPORT::Load ( SMESH_Mesh theMesh,
const TopoDS_Shell &  theBlock 
)

Load mesh from study file.

void SMESH_EXPORT::loadDependentMeshes ( ) [protected]

loads dependent meshes on SUBMESH_LOADED event

virtual std::istream& SMESH_EXPORT::LoadFrom ( std::istream &  load) [virtual]

Loads nothing from a stream.

Parameters:
load- the stream
Return values:
std::ostream& - the stream
static bool SMESH_EXPORT::LoadNodeColumns ( TParam2ColumnMap theParam2ColumnMap,
const TopoDS_Face &  theFace,
const std::list< TopoDS_Edge > &  theBaseSide,
SMESHDS_Mesh *  theMesh,
SMESH_ProxyMesh theProxyMesh = 0 
) [static]

Load nodes bound to face into a map of node columns.

Parameters:
theParam2ColumnMap- map of node columns to fill
theFace- the face on which nodes are searched for
theBaseSide- the edges holding nodes on which columns' bases
theMesh- the mesh containing nodes
Return values:
bool- false if something is wrong

The key of the map is a normalized parameter of each base node on theBaseSide. Edges in theBaseSide must be sequenced. This method works in supposition that nodes on the face forms a rectangular grid and elements can be quardrangles or triangles

static bool SMESH_EXPORT::LoadNodeColumns ( TParam2ColumnMap theParam2ColumnMap,
const TopoDS_Face &  theFace,
const TopoDS_Edge &  theBaseEdge,
SMESHDS_Mesh *  theMesh,
SMESH_ProxyMesh theProxyMesh = 0 
) [static]

Variant of LoadNodeColumns() above with theBaseSide given by one edge.

Generated skin mesh (containing 2D cells) from 3D mesh The created 2D mesh elements based on nodes of free faces of boundary volumes.

Returns:
TRUE if operation has been completed successfully, FALSE otherwise
int SMESH_EXPORT::MakeBoundaryMesh ( const TIDSortedElemSet elements,
Bnd_Dimension  dimension,
SMESH_Group group = 0,
SMESH_Mesh targetMesh = 0,
bool  toCopyElements = false,
bool  toCopyExistingBondary = false,
bool  toAddExistingBondary = false,
bool  aroundElements = false 
)
Extrusion_Error SMESH_EXPORT::MakeEdgePathPoints ( std::list< double > &  aPrms,
const TopoDS_Edge &  aTrackEdge,
bool  aFirstIsStart,
std::list< SMESH_MeshEditor_PathPoint > &  aLPP 
) [private]
Extrusion_Error SMESH_EXPORT::MakeExtrElements ( TIDSortedElemSet theElements,
std::list< SMESH_MeshEditor_PathPoint > &  theFullList,
const bool  theHasAngles,
std::list< double > &  theAngles,
const bool  theLinearVariation,
const bool  theHasRefPoint,
const gp_Pnt &  theRefPoint,
const bool  theMakeGroups 
) [private]
bool SMESH_EXPORT::MakeMesh ( SMESH_Mesh theMesh,
const bool  toCreatePolygons = false,
const bool  toCreatePolyedrs = false 
)
void SMESH_EXPORT::makePolyElements ( const std::vector< const SMDS_MeshNode * > &  theNodes,
const bool  toCreatePolygons,
const bool  toCreatePolyedrs 
) [private]
void SMESH_EXPORT::makeWalls ( TNodeOfNodeListMap mapNewNodes,
TElemOfElemListMap newElemsMap,
TElemOfVecOfNnlmiMap elemNewNodesMap,
TIDSortedElemSet elemSet,
const int  nbSteps,
SMESH_SequenceOfElemPtr &  srcElements 
) [private]

Create 1D and 2D elements around swept elements.

Parameters:
mapNewNodes- source nodes and ones generated from them
newElemsMap- source elements and ones generated from them
elemNewNodesMap- nodes generated from each node of each element
elemSet- all swept elements
nbSteps- number of sweeping steps
srcElements- to append elem for each generated element
static double SMESH_EXPORT::MaxTolerance ( const TopoDS_Shape &  shape) [static]
int SMESH_EXPORT::MEDToMesh ( const char *  theFileName,
const char *  theMeshName 
)
void SMESH_EXPORT::MergeElements ( TListOfListOfElementsID theGroupsOfElementsID)
void SMESH_EXPORT::MergeNodes ( TListOfListOfNodes theNodeGroups)
void SMESH_EXPORT::mergePoints ( const bool  uniteGroups) [private]
bool SMESH_EXPORT::MeshExists ( int  meshId) const
int SMESH_EXPORT::Nb0DElements ( ) const throw (SALOME_Exception)
static int SMESH_EXPORT::NbAncestors ( const TopoDS_Shape &  shape,
const SMESH_Mesh mesh,
TopAbs_ShapeEnum  ancestorType = TopAbs_SHAPE 
) [static]

Return number of unique ancestors of the shape.

int SMESH_EXPORT::NbBiQuadQuadrangles ( ) const throw (SALOME_Exception)
int SMESH_EXPORT::NbEdges ( SMDSAbs_ElementOrder  order = ORDER_ANY) const throw (SALOME_Exception)
int SMESH_EXPORT::NbFaces ( ) const
int SMESH_EXPORT::NbFaces ( SMDSAbs_ElementOrder  order = ORDER_ANY) const throw (SALOME_Exception)
int SMESH_EXPORT::NbGroup ( ) const [inline]

Definition at line 282 of file SMESH_Mesh.hxx.

{ return _mapGroup.size(); }
int SMESH_EXPORT::NbHexagonalPrisms ( ) const throw (SALOME_Exception)
int SMESH_EXPORT::NbHexas ( SMDSAbs_ElementOrder  order = ORDER_ANY) const throw (SALOME_Exception)
int SMESH_EXPORT::NbNodes ( ) const throw (SALOME_Exception)

Here is the caller graph for this function:

int SMESH_EXPORT::NbPolygons ( ) const throw (SALOME_Exception)
int SMESH_EXPORT::NbPolyhedrons ( ) const throw (SALOME_Exception)
int SMESH_EXPORT::NbPrisms ( SMDSAbs_ElementOrder  order = ORDER_ANY) const throw (SALOME_Exception)
int SMESH_EXPORT::NbPyramids ( SMDSAbs_ElementOrder  order = ORDER_ANY) const throw (SALOME_Exception)
int SMESH_EXPORT::NbQuadrangles ( SMDSAbs_ElementOrder  order = ORDER_ANY) const throw (SALOME_Exception)
int SMESH_EXPORT::NbSubMesh ( ) const throw (SALOME_Exception)
int SMESH_EXPORT::NbTetras ( SMDSAbs_ElementOrder  order = ORDER_ANY) const throw (SALOME_Exception)
int SMESH_EXPORT::NbTriangles ( SMDSAbs_ElementOrder  order = ORDER_ANY) const throw (SALOME_Exception)
int SMESH_EXPORT::NbTriQuadraticHexas ( ) const throw (SALOME_Exception)
int SMESH_EXPORT::NbVolumes ( SMDSAbs_ElementOrder  order = ORDER_ANY) const throw (SALOME_Exception)
bool SMESH_EXPORT::NeedDiscreteBoundary ( ) const [inline]

Definition at line 222 of file SMESH_Algo.hxx.

bool SMESH_EXPORT::NeedShape ( ) const [inline]

Definition at line 225 of file SMESH_Algo.hxx.

{ return _requireShape; }
void SMESH_EXPORT::notifyListenersOnEvent ( const int  event,
const event_type  eventType,
SMESH_Hypothesis hyp = 0 
) [protected]

Notify stored event listeners on the occured event.

Parameters:
event- algo_event or compute_event itself
eventType- algo_event or compute_event
hyp- hypothesis, if eventType is algo_event

Say all submeshes that theChangedHyp has been modified.

int SMESH_EXPORT::NumberOfPoints ( SMESH_Mesh aMesh,
const TopoDS_Wire &  W 
)
int SMESH_EXPORT::NumberOfWires ( const TopoDS_Shape &  S)
bool SMESH_EXPORT::OnlyUnaryInput ( ) const [inline]

Definition at line 214 of file SMESH_Algo.hxx.

{ return _onlyUnaryInput; }
SMESH_Group& SMESH_EXPORT::operator= ( const SMESH_Group theOther) [private]
double SMESH_EXPORT::OrientedAngle ( const gp_Pnt &  p0,
const gp_Pnt &  p1,
const gp_Pnt &  g1,
const gp_Pnt &  g2 
)
virtual void SMESH_EXPORT::ProcessEvent ( const int  event,
const int  eventType,
SMESH_subMesh subMesh,
SMESH_subMeshEventListenerData data,
const SMESH_Hypothesis hyp = 0 
) [virtual]

Do something on a certain event.

Parameters:
event- algo_event or compute_event itself (of SMESH_subMesh)
eventType- ALGO_EVENT or COMPUTE_EVENT (of SMESH_subMesh)
subMesh- the submesh where the event occures
data- listener data stored in the subMesh
hyp- hypothesis, if eventType is algo_event

The base implementation (see SMESH_subMesh.cxx) translates CLEAN event to the subMeshes stored in the listener data. Also it sends SUBMESH_COMPUTED event in case of successful COMPUTE event.

static const TopoDS_Solid& SMESH_EXPORT::PseudoShape ( ) [static]

Return a solid which is returned by GetShapeToMesh() if a real geometry to be meshed was not set.

Split quadrangles into triangles.

Parameters:
theElems- The faces to be splitted.
theCriterion- Is used to choose a diagonal for splitting.
Returns:
bool - Success or not.
bool SMESH_EXPORT::QuadToTri ( TIDSortedElemSet theElems,
const bool  the13Diag 
)

Split quadrangles into triangles.

Parameters:
theElems- The faces to be splitted.
the13Diag- Is used to choose a diagonal for splitting.
Returns:
bool - Success or not.
int SMESH_EXPORT::Remove ( const std::list< int > &  theElemIDs,
const bool  isNodes 
)
static void SMESH_EXPORT::RemoveElemFromGroups ( const SMDS_MeshElement *  element,
SMESHDS_Mesh *  aMesh 
) [static]
bool SMESH_EXPORT::RemoveGroup ( const int  theGroupID)
SMESH_Hypothesis::Hypothesis_Status SMESH_EXPORT::RemoveHypothesis ( const TopoDS_Shape &  aSubShape,
int  anHypId 
) throw (SALOME_Exception)
int SMESH_EXPORT::removeQuadElem ( SMESHDS_SubMesh *  theSm,
SMDS_ElemIteratorPtr  theItr,
const int  theShapeID 
) [private]

Convert quadratic elements to linear ones and remove quadratic nodes.

Returns:
nb of checked elements
void SMESH_EXPORT::removeTmpElement ( const SMDS_MeshElement *  face) [protected]
bool SMESH_EXPORT::Reorient ( const SMDS_MeshElement *  theElement)
static void SMESH_EXPORT::ReplaceElemInGroups ( const SMDS_MeshElement *  elemToRm,
const SMDS_MeshElement *  elemToAdd,
SMESHDS_Mesh *  aMesh 
) [static]
static void SMESH_EXPORT::ReplaceElemInGroups ( const SMDS_MeshElement *  elemToRm,
const std::vector< const SMDS_MeshElement * > &  elemToAdd,
SMESHDS_Mesh *  aMesh 
) [static]
PGroupIDs SMESH_EXPORT::RotationSweep ( TIDSortedElemSet theElements,
const gp_Ax1 &  theAxis,
const double  theAngle,
const int  theNbSteps,
const double  theToler,
const bool  theMakeGroups,
const bool  theMakeWalls = true 
)
bool SMESH_EXPORT::Save ( std::ostream &  theFile)
virtual std::ostream& SMESH_EXPORT::SaveTo ( std::ostream &  save) [virtual]

Saves nothing in a stream.

Parameters:
save- the stream
Return values:
std::ostream& - the stream
void SMESH_EXPORT::setAlgoState ( int  state) [protected]
void SMESH_EXPORT::SetAutoColor ( bool  theAutoColor) throw (SALOME_Exception)
void SMESH_EXPORT::SetBoundaryBoxSegmentation ( int  theNbSegments) [inline]

Sets number of segments per diagonal of boundary box of geometry by which default segment length of appropriate 1D hypotheses is defined.

Definition at line 114 of file SMESH_Gen.hxx.

{ _segmentation = theNbSegments; }
void SMESH_EXPORT::SetCallUp ( TCallUp upCaller)
void SMESH_EXPORT::SetDefaultNbSegments ( int  nb) [inline]

Sets default number of segments per edge.

Definition at line 119 of file SMESH_Gen.hxx.

{ _nbSegments = nb; }
void SMESH_EXPORT::SetElementsOnShape ( bool  toSet) [inline]

To set created elements on the shape set by IsQuadraticSubMesh() or the next methods.

By defaul elements are set on the shape if a mesh has no shape to be meshed

Definition at line 204 of file SMESH_MesherHelper.hxx.

{ mySetElemOnShape = toSet; }
bool SMESH_EXPORT::setErrorCode ( const ErrorCode  theErrorCode) [private]
void SMESH_EXPORT::SetEventListener ( EventListener listener,
EventListenerData data,
SMESH_subMesh where 
)

Sets an event listener and its data to a submesh.

Parameters:
listener- the listener to store
data- the listener data to store
where- the submesh to store the listener and it's data

The method remembers the submesh it puts the listener in order to delete it when HYP_OK algo_state is lost After being set, event listener is notified on each event of submesh.

void SMESH_EXPORT::setEventListener ( EventListener listener,
EventListenerData data 
) [protected]

Sets an event listener and its data to a submesh.

Parameters:
listener- the listener to store
data- the listener data to store

After being set, event listener is notified on each event of a submesh.

virtual void SMESH_EXPORT::SetEventListener ( SMESH_subMesh subMesh) [virtual]

Sets event listener to submeshes if necessary.

Parameters:
subMesh- submesh where algo is set

This method is called when a submesh gets HYP_OK algo_state. After being set, event listener is notified on each event of a submesh. By default none listener is set

double SMESH_EXPORT::setFirstEdge ( std::list< TopoDS_Edge > &  theWire,
int  theFirstEdgeID 
) [private]
void SMESH_EXPORT::SetIsAlwaysComputed ( bool  isAlCo)

Allow algo->Compute() if a subshape of lower dim is meshed but none mesh entity is bound to it.

void SMESH_EXPORT::SetIsModified ( bool  isModified)

Set the flag meaning that the mesh has been edited "manually".

It is to set to false after Clear() and to set to true by MeshEditor

void SMESH_EXPORT::SetIsQuadratic ( const bool  theBuildQuadratic) [inline]

Set order of elements to create without calling IsQuadraticSubMesh()

Definition at line 186 of file SMESH_MesherHelper.hxx.

  { myCreateQuadratic = theBuildQuadratic; }
void SMESH_EXPORT::SetLastParameters ( const char *  theParameters)

Here is the caller graph for this function:

void SMESH_EXPORT::SetLibName ( const char *  theLibName)
void SMESH_EXPORT::setMesh ( const SMESH_Mesh mesh) [inline, protected]

Definition at line 124 of file SMESH_ProxyMesh.hxx.

{ _mesh = &mesh; }
void SMESH_EXPORT::SetMeshOrder ( const TListOfListOfInt theOrder)
void SMESH_EXPORT::SetName ( const char *  theName) [inline]

Definition at line 55 of file SMESH_Group.hxx.

{ myName = theName; }
void SMESH_EXPORT::setNode2Node ( const SMDS_MeshNode *  srcNode,
const SMDS_MeshNode *  proxyNode,
const SubMesh subMesh 
) [protected]
void SMESH_EXPORT::SetParameters ( const char *  theParameters)
virtual bool SMESH_EXPORT::SetParametersByDefaults ( const TDefaults dflts,
const SMESH_Mesh theMesh = 0 
) [pure virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool SMESH_EXPORT::SetParametersByDefaults ( const TDefaults dflts,
const SMESH_Mesh theMesh = 0 
) [virtual]
virtual bool SMESH_EXPORT::SetParametersByMesh ( const SMESH_Mesh theMesh,
const TopoDS_Shape &  theShape 
) [pure virtual]

Initialize my parameter values by the mesh built on the geometry.

Parameters:
theMesh- the built mesh
theShape- the geometry of interest
Return values:
bool- true if parameter values have been successfully defined
virtual bool SMESH_EXPORT::SetParametersByMesh ( const SMESH_Mesh theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Just return false as the algorithm does not hold parameters values.

void SMESH_EXPORT::setPosOnShapeValidity ( int  shapeID,
bool  ok 
) const [private]
bool SMESH_EXPORT::setShapeToMesh ( const TopoDS_Shape &  theShape) [private]
void SMESH_EXPORT::SetSubShape ( const int  subShapeID)

Set shape to make elements on without calling IsQuadraticSubMesh()

void SMESH_EXPORT::SetSubShape ( const TopoDS_Shape &  subShape)

==SMESHDS_Mesh::ShapeToIndex(shape)

Sew_Error SMESH_EXPORT::SewFreeBorder ( const SMDS_MeshNode *  theBorderFirstNode,
const SMDS_MeshNode *  theBorderSecondNode,
const SMDS_MeshNode *  theBorderLastNode,
const SMDS_MeshNode *  theSide2FirstNode,
const SMDS_MeshNode *  theSide2SecondNode,
const SMDS_MeshNode *  theSide2ThirdNode = 0,
const bool  theSide2IsFreeBorder = true,
const bool  toCreatePolygons = false,
const bool  toCreatePolyedrs = false 
)
Sew_Error SMESH_EXPORT::SewSideElements ( TIDSortedElemSet theSide1,
TIDSortedElemSet theSide2,
const SMDS_MeshNode *  theFirstNode1ToMerge,
const SMDS_MeshNode *  theFirstNode2ToMerge,
const SMDS_MeshNode *  theSecondNode1ToMerge,
const SMDS_MeshNode *  theSecondNode2ToMerge 
)
int SMESH_EXPORT::shapeIndex ( const TopoDS_Shape &  shape) const [protected]
void SMESH_EXPORT::ShapeToMesh ( const TopoDS_Shape &  aShape)

Set geometry to be meshed.

int SMESH_EXPORT::SimplifyFace ( const std::vector< const SMDS_MeshNode * >  faceNodes,
std::vector< const SMDS_MeshNode * > &  poly_nodes,
std::vector< int > &  quantities 
) const
SMESH_EXPORT::SMESH_0D_Algo ( int  hypId,
int  studyId,
SMESH_Gen gen 
)
SMESH_EXPORT::SMESH_1D_Algo ( int  hypId,
int  studyId,
SMESH_Gen gen 
)
SMESH_EXPORT::SMESH_2D_Algo ( int  hypId,
int  studyId,
SMESH_Gen gen 
)
SMESH_EXPORT::SMESH_3D_Algo ( int  hypId,
int  studyId,
SMESH_Gen gen 
)
SMESH_EXPORT::SMESH_Algo ( int  hypId,
int  studyId,
SMESH_Gen gen 
)

Creates algorithm.

Parameters:
hypId- algorithm ID
studyId- study ID
gen- SMESH_Gen
SMESH_EXPORT::SMESH_Group ( int  theID,
const SMESH_Mesh theMesh,
const SMDSAbs_ElementType  theType,
const char *  theName,
const TopoDS_Shape &  theShape = TopoDS_Shape(),
const SMESH_PredicatePtr thePredicate = SMESH_PredicatePtr() 
)
SMESH_EXPORT::SMESH_Group ( SMESHDS_GroupBase *  groupDS)
SMESH_EXPORT::SMESH_Group ( const SMESH_Group theOther) [private]
SMESH_EXPORT::SMESH_HypoFilter ( SMESH_HypoPredicate aPredicate,
bool  notNagate = true 
)
SMESH_EXPORT::SMESH_HypoFilter ( const SMESH_HypoFilter other) [inline, protected]

Definition at line 108 of file SMESH_HypoFilter.hxx.

{}
SMESH_EXPORT::SMESH_Hypothesis ( int  hypId,
int  studyId,
SMESH_Gen gen 
)
SMESH_EXPORT::SMESH_Mesh ( int  theLocalId,
int  theStudyId,
SMESH_Gen theGen,
bool  theIsEmbeddedMode,
SMESHDS_Document *  theDocument 
)
SMESH_EXPORT::SMESH_Mesh ( ) [protected]
SMESH_EXPORT::SMESH_Mesh ( const SMESH_Mesh ) [inline, protected]

Definition at line 367 of file SMESH_Mesh.hxx.

{};
SMESH_EXPORT::SMESH_MesherHelper ( const SMESH_MesherHelper theOther) [inline, private]

Definition at line 515 of file SMESH_MesherHelper.hxx.

{};
SMESH_EXPORT::SMESH_ProxyMesh ( std::vector< SMESH_ProxyMesh::Ptr > &  components)
SMESH_EXPORT::SMESH_ProxyMesh ( const SMESH_Mesh mesh) [inline]

Definition at line 90 of file SMESH_ProxyMesh.hxx.

{ _mesh = &mesh; }
SMESH_EXPORT::SMESH_subMesh ( int  Id,
SMESH_Mesh father,
SMESHDS_Mesh *  meshDS,
const TopoDS_Shape &  aSubShape 
)
SMESH_EXPORT::SMESH_subMeshEventListener ( bool  isDeletable,
const char *  name 
) [inline]

Definition at line 55 of file SMESH_subMeshEventListener.hxx.

                                                                 :myIsDeletable(isDeletable)
#ifdef _DEBUG_
    ,myName(name)
#endif
  {}
void SMESH_EXPORT::Smooth ( TIDSortedElemSet theElements,
std::set< const SMDS_MeshNode * > &  theFixedNodes,
const SmoothMethod  theSmoothMethod,
const int  theNbIterations,
double  theTgtAspectRatio = 1.0,
const bool  the2D = true 
)
bool SMESH_EXPORT::SortByMeshOrder ( std::list< SMESH_subMesh * > &  theListToSort) const

sort submeshes according to stored mesh order

Parameters:
theListToSortin out list to be sorted
Returns:
FALSE if nothing sorted
bool SMESH_EXPORT::sortSameSizeWires ( TListOfEdgesList theWireList,
const TListOfEdgesList::iterator &  theFromWire,
const TListOfEdgesList::iterator &  theToWire,
const int  theFirstEdgeID,
std::list< std::list< TPoint * > > &  theEdgesPointsList 
) [private]
void SMESH_EXPORT::SplitVolumesIntoTetra ( const TIDSortedElemSet theElems,
const int  theMethodFlags 
)

Split volumic elements into tetrahedra.

int SMESH_EXPORT::STLToMesh ( const char *  theFileName)
void SMESH_EXPORT::storeTmpElement ( const SMDS_MeshElement *  face) [protected]
SMESH_Hypothesis::Hypothesis_Status SMESH_EXPORT::SubMeshesAlgoStateEngine ( int  event,
SMESH_Hypothesis anHyp 
)
bool SMESH_EXPORT::subMeshesComputed ( ) [protected]
virtual void SMESH_EXPORT::SubmeshRestored ( SMESH_subMesh subMesh) [virtual]

Allow algo to do something after persistent restoration.

Parameters:
subMesh- restored submesh

This method is called only if a submesh has HYP_OK algo_state.

bool SMESH_EXPORT::SupportSubmeshes ( ) const [inline]

Definition at line 228 of file SMESH_Algo.hxx.

{ return _supportSubmeshes; }
void SMESH_EXPORT::sweepElement ( const SMDS_MeshElement *  elem,
const std::vector< TNodeOfNodeListMapItr > &  newNodesItVec,
std::list< const SMDS_MeshElement * > &  newElems,
const int  nbSteps,
SMESH_SequenceOfElemPtr &  srcElements 
) [private]

Create elements by sweeping an element.

Parameters:
elem- element to sweep
newNodesItVec- nodes generated from each node of the element
newElems- generated elements
nbSteps- number of sweeping steps
srcElements- to append elem for each generated element
bool SMESH_EXPORT::takeProxySubMesh ( const TopoDS_Shape &  shape,
SMESH_ProxyMesh proxyMesh 
) [protected]
void SMESH_EXPORT::takeTmpElemsInMesh ( SMESH_ProxyMesh proxyMesh) [protected]
bool SMESH_EXPORT::toCheckPosOnShape ( int  shapeID) const [private]
PGroupIDs SMESH_EXPORT::Transform ( TIDSortedElemSet theElements,
const gp_Trsf &  theTrsf,
const bool  theCopy,
const bool  theMakeGroups,
SMESH_Mesh theTargetMesh = 0 
)
bool SMESH_EXPORT::TriToQuad ( TIDSortedElemSet theElems,
SMESH::Controls::NumericalFunctorPtr  theCriterion,
const double  theMaxAngle 
)

Fuse neighbour triangles into quadrangles.

Parameters:
theElems- The triangles to be fused.
theCriterion- Is used to choose a neighbour to fuse with.
theMaxAngle- Is a max angle between element normals at which fusion is still performed; theMaxAngle is mesured in radians.
Returns:
bool - Success or not.
int SMESH_EXPORT::UNVToMesh ( const char *  theFileName)

consult DriverMED_R_SMESHDS_Mesh::ReadStatus for returned value

void SMESH_EXPORT::updateDependantsState ( const compute_event  theEvent) [protected]
void SMESH_EXPORT::updateSubMeshState ( const compute_state  theState) [protected]
void SMESH_EXPORT::UpdateVolumes ( const SMDS_MeshNode *  theBetweenNode1,
const SMDS_MeshNode *  theBetweenNode2,
std::list< const SMDS_MeshNode * > &  theNodesToInsert 
)
static const SMDS_MeshNode* SMESH_EXPORT::VertexNode ( const TopoDS_Vertex &  V,
const SMESHDS_Mesh *  meshDS 
) [static]

Return the node built on a vertex.

Parameters:
V- the vertex
meshDS- mesh
Return values:
constSMDS_MeshNode* - found node or NULL
static int SMESH_EXPORT::WrapIndex ( const int  ind,
const int  nbNodes 
) [inline, static]

Return a valid node index, fixing the given one if necessary.

Parameters:
ind- node index
nbNodes- total nb of nodes
Return values:
int- valid node index

Definition at line 125 of file SMESH_MesherHelper.hxx.

                                                         {
    if ( ind < 0 ) return nbNodes + ind % nbNodes;
    if ( ind >= nbNodes ) return ind % nbNodes;
    return ind;
  }

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  OS,
const TPoint p 
) [friend]
friend class SMESH_HypoFilter [friend]

Definition at line 53 of file SMESH_HypoFilter.hxx.

friend class SMESH_subMesh [friend]

Definition at line 49 of file SMESH_subMeshEventListener.hxx.


Member Data Documentation

int SMESH_EXPORT::_algoState [protected]

Definition at line 309 of file SMESH_subMesh.hxx.

Definition at line 157 of file SMESH_ProxyMesh.hxx.

Definition at line 316 of file SMESH_subMesh.hxx.

std::list<const SMESHDS_Hypothesis *> SMESH_EXPORT::_appliedHypList [protected]

Definition at line 363 of file SMESH_Algo.hxx.

std::list<const SMDS_MeshElement*> SMESH_EXPORT::_badInputElements [protected]

to explain COMPERR_BAD_INPUT_MESH

Definition at line 380 of file SMESH_Algo.hxx.

Definition at line 363 of file SMESH_Mesh.hxx.

std::string SMESH_EXPORT::_comment [protected]

any text explaining what is wrong in Compute()

Definition at line 379 of file SMESH_Algo.hxx.

std::vector<std::string> SMESH_EXPORT::_compatibleHypothesis [protected]

Definition at line 362 of file SMESH_Algo.hxx.

Definition at line 311 of file SMESH_subMesh.hxx.

int SMESH_EXPORT::_computeState [protected]

Definition at line 310 of file SMESH_subMesh.hxx.

counters* SMESH_EXPORT::_counters [private]

Definition at line 171 of file SMESH_Gen.hxx.

Definition at line 307 of file SMESH_subMesh.hxx.

std::set< const SMDS_MeshElement* > SMESH_EXPORT::_elemsInMesh [private]

Definition at line 167 of file SMESH_ProxyMesh.hxx.

int SMESH_EXPORT::_error [protected]

SMESH_ComputeErrorName or anything algo specific.

Definition at line 378 of file SMESH_Algo.hxx.

< event listeners to notify

event listeners to delete when HYP_OK algo_state is lost

Definition at line 156 of file SMESH_subMesh.hxx.

Definition at line 303 of file SMESH_subMesh.hxx.

Definition at line 124 of file SMESH_Hypothesis.hxx.

int SMESH_EXPORT::_groupId [protected]

Definition at line 340 of file SMESH_Mesh.hxx.

int SMESH_EXPORT::_hypId [private]

Definition at line 164 of file SMESH_Gen.hxx.

int SMESH_EXPORT::_Id [protected]

Definition at line 304 of file SMESH_subMesh.hxx.

int SMESH_EXPORT::_id [protected]

Definition at line 337 of file SMESH_Mesh.hxx.

int SMESH_EXPORT::_idDoc [protected]

Definition at line 339 of file SMESH_Mesh.hxx.

bool SMESH_EXPORT::_isAutoColor [protected]

Definition at line 350 of file SMESH_Mesh.hxx.

bool SMESH_EXPORT::_isModified [protected]

modified since last total re-compute, issue 0020693

Definition at line 351 of file SMESH_Mesh.hxx.

bool SMESH_EXPORT::_isShapeToMesh [protected]

Definition at line 342 of file SMESH_Mesh.hxx.

std::string SMESH_EXPORT::_lastParameters [private]

Definition at line 132 of file SMESH_Hypothesis.hxx.

std::string SMESH_EXPORT::_libName [private]

Definition at line 130 of file SMESH_Hypothesis.hxx.

int SMESH_EXPORT::_localId [private]

Definition at line 160 of file SMESH_Gen.hxx.

Definition at line 52 of file SMESH_HypoFilter.hxx.

Definition at line 153 of file SMESH_Gen.hxx.

Definition at line 154 of file SMESH_Gen.hxx.

Definition at line 155 of file SMESH_Gen.hxx.

Definition at line 156 of file SMESH_Gen.hxx.

std::map< int, SMESH_Algo * > SMESH_EXPORT::_mapAlgo

Definition at line 152 of file SMESH_Gen.hxx.

TopTools_IndexedDataMapOfShapeListOfShape SMESH_EXPORT::_mapAncestors [protected]

Definition at line 355 of file SMESH_Mesh.hxx.

std::map< int, SMESH_subMesh * > SMESH_EXPORT::_mapDepend [protected]

Definition at line 306 of file SMESH_subMesh.hxx.

std::map<int, SMESH_Group*> SMESH_EXPORT::_mapGroup [protected]

Definition at line 348 of file SMESH_Mesh.hxx.

std::map< int, StudyContextStruct * > SMESH_EXPORT::_mapStudyContext [private]

Definition at line 161 of file SMESH_Gen.hxx.

std::map<int, SMESH_subMesh*> SMESH_EXPORT::_mapSubMesh [protected]

Definition at line 347 of file SMESH_Mesh.hxx.

const SMESH_Mesh* SMESH_EXPORT::_mesh [private]

Definition at line 161 of file SMESH_ProxyMesh.hxx.

SMESHDS_Document* SMESH_EXPORT::_myDocument [protected]

Definition at line 344 of file SMESH_Mesh.hxx.

SMESHDS_Mesh* SMESH_EXPORT::_myMeshDS [protected]

Definition at line 345 of file SMESH_Mesh.hxx.

Definition at line 357 of file SMESH_Mesh.hxx.

Definition at line 170 of file SMESH_Gen.hxx.

int SMESH_EXPORT::_nbSubShapes [protected]

Definition at line 341 of file SMESH_Mesh.hxx.

Definition at line 369 of file SMESH_Algo.hxx.

std::list< OwnListenerData > SMESH_EXPORT::_ownListeners [protected]

Definition at line 164 of file SMESH_subMesh.hxx.

Definition at line 127 of file SMESH_Hypothesis.hxx.

std::string SMESH_EXPORT::_parameters [private]

Definition at line 131 of file SMESH_Hypothesis.hxx.

bool SMESH_EXPORT::_quadraticMesh [protected]

Definition at line 376 of file SMESH_Algo.hxx.

Definition at line 370 of file SMESH_Algo.hxx.

bool SMESH_EXPORT::_requireShape [protected]

Definition at line 371 of file SMESH_Algo.hxx.

Definition at line 168 of file SMESH_Gen.hxx.

double SMESH_EXPORT::_shapeDiagonal [protected]

diagonal size of bounding box of shape to mesh

Definition at line 353 of file SMESH_Mesh.hxx.

int SMESH_EXPORT::_shapeType [protected]

Definition at line 126 of file SMESH_Hypothesis.hxx.

int SMESH_EXPORT::_studyId [protected]

Definition at line 125 of file SMESH_Hypothesis.hxx.

Definition at line 170 of file SMESH_ProxyMesh.hxx.

SMESHDS_SubMesh* SMESH_EXPORT::_subMeshDS [protected]

Definition at line 302 of file SMESH_subMesh.hxx.

std::vector< SubMesh* > SMESH_EXPORT::_subMeshes [private]

Definition at line 164 of file SMESH_ProxyMesh.hxx.

Definition at line 343 of file SMESH_Mesh.hxx.

TopoDS_Shape SMESH_EXPORT::_subShape [protected]

Definition at line 301 of file SMESH_subMesh.hxx.

Definition at line 372 of file SMESH_Algo.hxx.

std::list<const SMESHDS_Hypothesis *> SMESH_EXPORT::_usedHypList [protected]

Definition at line 364 of file SMESH_Algo.hxx.

std::set<SMESH_subMesh*> SMESH_EXPORT::myBusySM [mutable, private]

to avoid infinite recursion via events

Definition at line 48 of file SMESH_subMeshEventListener.hxx.

Definition at line 535 of file SMESH_MesherHelper.hxx.

std::set< int > SMESH_EXPORT::myDegenShapeIds [private]

Definition at line 520 of file SMESH_MesherHelper.hxx.

Definition at line 528 of file SMESH_MesherHelper.hxx.

std::vector<const SMDS_MeshElement*> SMESH_EXPORT::myElements [private]

Definition at line 371 of file SMESH_Pattern.hxx.

std::list< TElemDef > SMESH_EXPORT::myElemPointIDs [private]

Definition at line 349 of file SMESH_Pattern.hxx.

std::list< TElemDef > SMESH_EXPORT::myElemXYZIDs [private]

Definition at line 369 of file SMESH_Pattern.hxx.

Definition at line 351 of file SMESH_Pattern.hxx.

Definition at line 526 of file SMESH_MesherHelper.hxx.

SMESHDS_GroupBase* SMESH_EXPORT::myGroupDS [private]

Definition at line 67 of file SMESH_Group.hxx.

std::map<TNodeSet,std::list<std::list<int> > > SMESH_EXPORT::myIdsOnBoundary [private]

Definition at line 383 of file SMESH_Pattern.hxx.

bool SMESH_EXPORT::myIs2D [private]

Definition at line 346 of file SMESH_Pattern.hxx.

Definition at line 353 of file SMESH_Pattern.hxx.

Definition at line 352 of file SMESH_Pattern.hxx.

if true, it will be deleted by SMESH_subMesh

Definition at line 47 of file SMESH_subMeshEventListener.hxx.

std::list< int > SMESH_EXPORT::myKeyPointIDs [private]

Definition at line 348 of file SMESH_Pattern.hxx.

SMESH_SequenceOfElemPtr SMESH_EXPORT::myLastCreatedElems [private]

Sequence for keeping elements created during last operation.

Definition at line 707 of file SMESH_MeshEditor.hxx.

SMESH_SequenceOfElemPtr SMESH_EXPORT::myLastCreatedNodes [private]

Sequence for keeping nodes created during last operation.

Definition at line 702 of file SMESH_MeshEditor.hxx.

Definition at line 697 of file SMESH_MeshEditor.hxx.

std::string SMESH_EXPORT::myName [private]

Definition at line 68 of file SMESH_Group.hxx.

std::list< int > SMESH_EXPORT::myNbKeyPntInBoundary [private]

Definition at line 363 of file SMESH_Pattern.hxx.

std::map< int,bool > SMESH_EXPORT::myNodePosShapesValidity [private]

Definition at line 538 of file SMESH_MesherHelper.hxx.

std::vector<const SMDS_MeshNode*> SMESH_EXPORT::myOrderedNodes [private]

Definition at line 372 of file SMESH_Pattern.hxx.

double SMESH_EXPORT::myPar1[2] [private]

Definition at line 522 of file SMESH_MesherHelper.hxx.

double SMESH_EXPORT::myPar2[2] [private]

Definition at line 522 of file SMESH_MesherHelper.hxx.

int SMESH_EXPORT::myParIndex [private]

Definition at line 523 of file SMESH_MesherHelper.hxx.

std::vector< TPoint > SMESH_EXPORT::myPoints [private]

Definition at line 347 of file SMESH_Pattern.hxx.

std::vector<const SMDS_MeshElement*> SMESH_EXPORT::myPolyElems [private]

Definition at line 375 of file SMESH_Pattern.hxx.

std::list< TElemDef > SMESH_EXPORT::myPolyElemXYZIDs [private]

Definition at line 377 of file SMESH_Pattern.hxx.

std::list< std::vector<int> > SMESH_EXPORT::myPolyhedronQuantities [private]

Definition at line 378 of file SMESH_Pattern.hxx.

Definition at line 101 of file SMESH_HypoFilter.hxx.

std::map< int, std::list< TElemDef* > > SMESH_EXPORT::myReverseConnectivity [private]

Definition at line 385 of file SMESH_Pattern.hxx.

std::set< int > SMESH_EXPORT::mySeamShapeIds [private]

Definition at line 521 of file SMESH_MesherHelper.hxx.

Definition at line 536 of file SMESH_MesherHelper.hxx.

TopoDS_Shape SMESH_EXPORT::myShape [private]

Definition at line 530 of file SMESH_MesherHelper.hxx.

int SMESH_EXPORT::myShapeID [private]

Definition at line 532 of file SMESH_MesherHelper.hxx.

TopTools_IndexedMapOfOrientedShape SMESH_EXPORT::myShapeIDMap [private]

Definition at line 358 of file SMESH_Pattern.hxx.

std::map< int, std::list< TPoint* > > SMESH_EXPORT::myShapeIDToPointsMap [private]

Definition at line 359 of file SMESH_Pattern.hxx.

Definition at line 515 of file SMESH_MesherHelper.hxx.

std::vector<gp_XYZ> SMESH_EXPORT::myXYZ [private]

Definition at line 368 of file SMESH_Pattern.hxx.

std::map< int, const SMDS_MeshNode*> SMESH_EXPORT::myXYZIdToNodeMap [private]

Definition at line 370 of file SMESH_Pattern.hxx.


The documentation for this protocol was generated from the following files: