Back to index

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

1D Hypothesis to compute segment length free of thinking More...

#include <StdMeshers_Arithmetic1D.hxx>

Collaboration diagram for STDMESHERS_EXPORT:
Collaboration graph
[legend]

List of all members.

Classes

protocol  STDMESHERS_EXPORT
 Class emulating geometry of a vertical edge. More...
class  TSideFace
 Class representing a part of a geom face or a union of seleral faces. More...

Public Types

enum  DistrType { DT_Regular, DT_Scale, DT_TabFunc, DT_ExprFunc }
 This enumeration presents available types of distribution. More...
typedef std::map< const
SMDS_MeshNode *, const
SMDS_MeshNode *, TIDCompare
TNodeNodeMap
typedef std::map< const
SMDS_MeshElement *, const
SMDS_MeshElement *, TIDCompare
TElemElemMap
typedef boost::shared_ptr
< StdMeshers_FaceSide
StdMeshers_FaceSidePtr
typedef std::vector
< StdMeshers_FaceSidePtr
TWireVector

Public Member Functions

 StdMeshers_Arithmetic1D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_Arithmetic1D ()
void SetLength (double length, bool isStartLength) throw (SALOME_Exception)
double GetLength (bool isStartLength) const
void SetReversedEdges (std::vector< int > &ids)
void SetObjectEntry (const char *entry)
const char * GetObjectEntry ()
const std::vector< int > & GetReversedEdges () const
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize start and end length by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_AutomaticLength (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_AutomaticLength ()
double GetLength (const SMESH_Mesh *aMesh, const TopoDS_Shape &anEdge) throw (SALOME_Exception)
 Computes segment for a given edge.
double GetLength (const SMESH_Mesh *aMesh, const double edgeLength) throw (SALOME_Exception)
 Computes segment length for an edge of given length.
void SetFineness (double theFineness) throw (SALOME_Exception)
 Set Fineness.
double GetFineness () const
 Return mesh Fineness.
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize Fineness by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_Cartesian_3D (int hypId, int studyId, SMESH_Gen *gen)
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
virtual void SetEventListener (SMESH_subMesh *subMesh)
 StdMeshers_CartesianParameters3D (int hypId, int studyId, SMESH_Gen *gen)
void SetGrid (std::vector< double > &xNodes, int axis) throw ( SALOME_Exception )
 Sets coordinates of node positions along an axis (countered from 0)
void GetGrid (std::vector< double > &xNodes, int axis) const throw ( SALOME_Exception )
 Return coordinates of node positions along the three axes.
void SetGridSpacing (std::vector< std::string > &spaceFunctions, std::vector< double > &internalPoints, const int axis) throw ( SALOME_Exception )
 Set grid spacing along the three axes.
void GetGridSpacing (std::vector< std::string > &spaceFunctions, std::vector< double > &internalPoints, const int axis) const throw ( SALOME_Exception )
bool IsGridBySpacing (const int axis) const throw ( SALOME_Exception )
void GetCoordinates (std::vector< double > &xNodes, std::vector< double > &yNodes, std::vector< double > &zNodes, const Bnd_Box &bndBox) const throw ( SALOME_Exception )
 Return coordinates of node positions along the three axes.
void SetSizeThreshold (const double threshold) throw ( SALOME_Exception )
 Set size threshold.
double GetSizeThreshold () const
 Return size threshold.
bool IsDefined () const
 Return true if parameters are well defined.
virtual std::ostream & SaveTo (std::ostream &save)
 Persistence methods.
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize my parameter values by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_CompositeHexa_3D (int hypId, int studyId, SMESH_Gen *gen)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, Hypothesis_Status &aStatus)
 StdMeshers_CompositeSegment_1D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_CompositeSegment_1D ()
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual void SetEventListener (SMESH_subMesh *subMesh)
 Sets event listener to submeshes if necessary.
 StdMeshers_Deflection1D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_Deflection1D ()
void SetDeflection (double value) throw (SALOME_Exception)
double GetDeflection () const
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize deflection value by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 Function (const int)
virtual ~Function ()
virtual bool value (const double, double &) const
virtual double integral (const double, const double) const =0
 FunctionIntegral (const Function *, const double)
virtual ~FunctionIntegral ()
virtual bool value (const double, double &) const
virtual double integral (const double, const double) const
 FunctionTable (const std::vector< double > &, const int)
virtual ~FunctionTable ()
virtual bool value (const double, double &) const
virtual double integral (const double, const double) const
 FunctionExpr (const char *, const int)
virtual ~FunctionExpr ()
virtual Standard_Boolean Value (const Standard_Real, Standard_Real &)
virtual bool value (const double, double &) const
virtual double integral (const double, const double) const
 StdMeshers_FaceSide (const TopoDS_Face &theFace, const TopoDS_Edge &theEdge, SMESH_Mesh *theMesh, const bool theIsForward, const bool theIgnoreMediumNodes)
 Wrap one edge.
 StdMeshers_FaceSide (const TopoDS_Face &theFace, std::list< TopoDS_Edge > &theEdges, SMESH_Mesh *theMesh, const bool theIsForward, const bool theIgnoreMediumNodes)
 Wrap several edges.
 StdMeshers_FaceSide (const SMDS_MeshNode *theNode, const gp_Pnt2d thePnt2d, const StdMeshers_FaceSide *theSide)
 Simulate a side from a vertex using data from other FaceSide.
void Reverse ()
 Change orientation of side geometry.
int NbPoints () const
 Return nb nodes on edges and vertices (+1 to be == GetUVPtStruct().size() )
int NbSegments () const
 Return nb edges.
SMESH_Mesh * GetMesh () const
 Return mesh.
bool MissVertexNode () const
 Return true if there are vertices without nodes.
const std::vector< UVPtStruct > & GetUVPtStruct (bool isXConst=0, double constValue=0) const
 Return detailed data on nodes.
const std::vector< UVPtStruct > & SimulateUVPtStruct (int nbSeg, bool isXConst=0, double constValue=0) const
 Simulates detailed data on nodes.
std::vector< const
SMDS_MeshNode * > 
GetOrderedNodes () const
 Return nodes in the order they encounter while walking along the side.
double Parameter (double U, TopoDS_Edge &edge) const
 Return edge and parameter on edge by normalized parameter.
gp_Pnt2d Value2d (double U) const
 Return UV by normalized parameter.
Adaptor2d_Curve2d * GetCurve2d () const
 Creates a Adaptor2d_Curve2d to be used in SMESH_Block.
BRepAdaptor_CompCurve * GetCurve3d () const
 Creates a fully functional Adaptor_Curve.
int NbEdges () const
 Return nb of wrapped edges.
const TopoDS_Edge & Edge (int i) const
 Return i-th wrapped edge (count starts from zero)
const std::vector< TopoDS_Edge > & Edges () const
 Return all edges.
TopoDS_Vertex FirstVertex (int i=0) const
 Return 1st vertex of the i-the edge (count starts from zero)
TopoDS_Vertex LastVertex (int i=-1) const
 Return last vertex of the i-the edge (count starts from zero)
double FirstParameter (int i) const
 Return first normalized parameter of the i-the edge (count starts from zero)
double LastParameter (int i) const
 Return ast normalized parameter of the i-the edge (count starts from zero)
double Length () const
 Return side length.
int EdgeIndex (double U) const
 Return edge index corresponding to normalized parameter.
void dump (const char *msg=0) const
 StdMeshers_FixedPoints1D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_FixedPoints1D ()
void SetPoints (std::vector< double > &listParams) throw (SALOME_Exception)
void SetNbSegments (std::vector< int > &listNbSeg) throw (SALOME_Exception)
const std::vector< double > & GetPoints () const
const std::vector< int > & GetNbSegments () const
void SetReversedEdges (std::vector< int > &ids)
void SetObjectEntry (const char *entry)
const char * GetObjectEntry ()
const std::vector< int > & GetReversedEdges () const
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize start and end length by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_Hexa_3D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_Hexa_3D ()
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Compute (SMESH_Mesh &aMesh, SMESH_MesherHelper *aHelper)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
 StdMeshers_HexaFromSkin_3D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_HexaFromSkin_3D ()
virtual bool Compute (SMESH_Mesh &aMesh, SMESH_MesherHelper *aHelper)
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
 StdMeshers_Import_1D (int hypId, int studyId, SMESH_Gen *gen)
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
virtual void SetEventListener (SMESH_subMesh *subMesh)
virtual void SubmeshRestored (SMESH_subMesh *subMesh)
 StdMeshers_Import_1D2D (int hypId, int studyId, SMESH_Gen *gen)
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
virtual void SetEventListener (SMESH_subMesh *subMesh)
virtual void SubmeshRestored (SMESH_subMesh *subMesh)
 StdMeshers_ImportSource1D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_ImportSource1D ()
void SetGroups (const std::vector< SMESH_Group * > &groups)
const std::vector< SMESH_Group * > & GetGroups () const
void SetCopySourceMesh (bool toCopyMesh, bool toCopyGroups)
void GetCopySourceMesh (bool &toCopyMesh, bool &toCopyGroups) const
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
void RestoreGroups (const std::vector< SMESH_Group * > &groups)
void StoreResultGroups (const std::vector< SMESH_Group * > &groups, const SMESHDS_Mesh &srcMesh, const SMESHDS_Mesh &tgtMesh)
std::vector< SMESH_Group * > * GetResultGroups (const SMESHDS_Mesh &srcMesh, const SMESHDS_Mesh &tgtMesh)
std::vector< SMESH_Mesh * > GetSourceMeshes () const
std::vector< SMESH_subMesh * > GetSourceSubMeshes (const SMESH_Mesh *srcMesh) const
 StdMeshers_ImportSource2D (int hypId, int studyId, SMESH_Gen *gen)
 StdMeshers_LayerDistribution (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_LayerDistribution ()
void SetLayerDistribution (SMESH_Hypothesis *hyp1D) throw ( SALOME_Exception )
 Sets 1D hypothesis specifying distribution of layers.
SMESH_Hypothesis * GetLayerDistribution () const
 Returns 1D hypothesis specifying distribution of layers.
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize parameters by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_LayerDistribution2D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_LayerDistribution2D ()
 StdMeshers_LengthFromEdges (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_LengthFromEdges ()
void SetMode (int mode) throw (SALOME_Exception)
int GetMode ()
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize my parameter values by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_LocalLength (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_LocalLength ()
void SetLength (double length) throw (SALOME_Exception)
void SetPrecision (double precision) throw (SALOME_Exception)
double GetLength () const
double GetPrecision () const
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize segment length by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_MaxElementArea (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_MaxElementArea ()
void SetMaxArea (double maxArea) throw (SALOME_Exception)
double GetMaxArea () const
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize maximal area by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_MaxElementVolume (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_MaxElementVolume ()
void SetMaxVolume (double maxVolume) throw (SALOME_Exception)
double GetMaxVolume () const
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize maximal volume by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_MaxLength (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_MaxLength ()
void SetLength (double length) throw (SALOME_Exception)
double GetLength () const
bool HavePreestimatedLength () const
double GetPreestimatedLength () const
void SetPreestimatedLength (double length)
void SetUsePreestimatedLength (bool toUse)
bool GetUsePreestimatedLength () const
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize segment length by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_MEFISTO_2D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_MEFISTO_2D ()
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
bool LoadPoints (TWireVector &wires, R2 *uvslf, std::vector< const SMDS_MeshNode * > &mefistoToDS, double scalex, double scaley)
void ComputeScaleOnFace (SMESH_Mesh &aMesh, const TopoDS_Face &aFace, double &scalex, double &scaley)
void StoreResult (Z nbst, R2 *uvst, Z nbt, Z *nust, std::vector< const SMDS_MeshNode * > &mefistoToDS, double scalex, double scaley)
 StdMeshers_NotConformAllowed (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_NotConformAllowed ()
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize my parameter values by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_NumberOfLayers (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_NumberOfLayers ()
void SetNumberOfLayers (int numberOfLayers) throw ( SALOME_Exception )
int GetNumberOfLayers () const
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize parameters by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_NumberOfLayers2D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_NumberOfLayers2D ()
 StdMeshers_NumberOfSegments (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_NumberOfSegments ()
const std::vector< double > & BuildDistributionExpr (const char *, int, int) throw ( SALOME_Exception )
const std::vector< double > & BuildDistributionTab (const std::vector< double > &, int, int) throw ( SALOME_Exception )
void SetNumberOfSegments (int segmentsNumber) throw (SALOME_Exception)
 Set the number of segments.
int GetNumberOfSegments () const
 Get the number of segments.
void SetDistrType (DistrType typ) throw (SALOME_Exception)
 Set distribution type.
DistrType GetDistrType () const
 Get distribution type.
virtual void SetScaleFactor (double scaleFactor) throw (SALOME_Exception)
 Set scale factor for scale distribution.
double GetScaleFactor () const throw (SALOME_Exception)
 Get scale factor for scale distribution.
void SetTableFunction (const std::vector< double > &table) throw (SALOME_Exception)
 Set table function for distribution DT_TabFunc.
const std::vector< double > & GetTableFunction () const throw (SALOME_Exception)
 Get table function for distribution DT_TabFunc.
void SetExpressionFunction (const char *expr) throw (SALOME_Exception)
 Set expression function for distribution DT_ExprFunc.
const char * GetExpressionFunction () const throw (SALOME_Exception)
 Get expression function for distribution DT_ExprFunc.
void SetConversionMode (int conv) throw (SALOME_Exception)
 Set conversion mode.
int ConversionMode () const throw (SALOME_Exception)
 Returns conversion mode.
void SetReversedEdges (std::vector< int > &ids)
void SetObjectEntry (const char *entry)
const char * GetObjectEntry ()
const std::vector< int > & GetReversedEdges () const
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize number of segments by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
 StdMeshers_SMESHBlock ()
void Load (const TopoDS_Shell &theShell)
void Load (const TopoDS_Shell &theShell, const TopoDS_Vertex &theV000, const TopoDS_Vertex &theV001)
void ComputeParameters (const gp_Pnt &thePnt, gp_XYZ &theXYZ)
void ComputeParameters (const gp_Pnt &thePnt, const TopoDS_Shape &theShape, gp_XYZ &theXYZ)
void ComputeParameters (const double &theU, const TopoDS_Shape &theShape, gp_XYZ &theXYZ)
void Point (const gp_XYZ &theParams, gp_Pnt &thePnt)
void Point (const gp_XYZ &theParams, const TopoDS_Shape &theShape, gp_Pnt &thePnt)
int ShapeID (const TopoDS_Shape &theShape)
const TopoDS_Shape & Shape (const int theID)
SMESH_Block & Block ()
bool IsForwadEdge (const int theEdgeID)
int ErrorStatus () const
SMESH_ComputeErrorPtr GetError () const
 StdMeshers_TNode ()
void SetNode (const SMDS_MeshNode *theNode)
const SMDS_MeshNode * Node () const
void SetShapeSupportID (const int theID)
int ShapeSupportID () const
void SetNormCoord (const gp_XYZ &theXYZ)
const gp_XYZ & NormCoord () const
void SetBaseNodeID (const int theID)
int BaseNodeID () const
 StdMeshers_Penta_3D ()
 ~StdMeshers_Penta_3D ()
bool Compute (SMESH_Mesh &, const TopoDS_Shape &)
int ErrorStatus () const
SMESH_ComputeErrorPtr GetComputeError () const
void SetTolerance (const double theTol3D)
double Tolerance () const
bool LoadIJNodes (StdMeshers_IJNodeMap &theIJNodes, const TopoDS_Face &theFace, const TopoDS_Edge &theBaseEdge, SMESHDS_Mesh *theMesh)
bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
 StdMeshers_PrismAsBlock ()
 Constructor.
 ~StdMeshers_PrismAsBlock ()
bool Init (SMESH_MesherHelper *helper, const TopoDS_Shape &shape3D)
 Initialization.
SMESH_ComputeErrorPtr GetError () const
 Return problem description.
void Clear ()
 Free allocated memory.
int VerticalSize () const
 Return number of nodes on every vertical edge.
bool HasNotQuadElemOnTop () const
const TNodeColumnGetNodeColumn (const SMDS_MeshNode *node) const
 Return pointer to column of nodes.
const TParam2ColumnMapGetParam2ColumnMap (const int baseEdgeID, bool &isReverse) const
 Return TParam2ColumnMap for a base edge.
bool GetLayersTransformation (std::vector< gp_Trsf > &trsf) const
 Return transformations to get coordinates of nodes of each internal layer by nodes of the bottom.
SMESH_Mesh * Mesh () const
 Return pointer to mesh.
SMESHDS_Mesh * MeshDS () const
 Return pointer to mesh DS.
SMESH_subMesh * SubMesh (const int shapeID) const
 Return submesh of a shape.
SMESHDS_SubMesh * SubMeshDS (const int shapeID) const
 Return submesh DS of a shape.
const TopoDS_Shape & Shape (const int shapeID) const
 Return a in-block shape.
int ShapeID (const TopoDS_Shape &shape) const
 Return in-block ID of a shape.
bool GetWallFaces (SMESH_Mesh *mesh, const TopoDS_Shape &mainShape, const TopoDS_Shape &bottomFace, std::list< TopoDS_Edge > &bottomEdges, std::list< int > &nbEInW, std::list< TopoDS_Face > &wallFaces)
 Find wall faces by bottom edges.
 StdMeshers_Prism_3D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_Prism_3D ()
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
void ProjectTriangles ()
 Enable removal of quadrangles from the bottom face and triangles creation there by projection from the top (sole face meshed with triangles is considered to be a bottom one).
 StdMeshers_Projection_1D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_Projection_1D ()
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
virtual void SetEventListener (SMESH_subMesh *whenSetToSubMesh)
 Sets a default event listener to submesh of the source edge.
 StdMeshers_Projection_1D2D (int hypId, int studyId, SMESH_Gen *gen)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
virtual void SetEventListener (SMESH_subMesh *whenSetToSubMesh)
 Sets a default event listener to submesh of the source face.
 StdMeshers_Projection_2D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_Projection_2D ()
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
virtual void SetEventListener (SMESH_subMesh *whenSetToSubMesh)
 Sets a default event listener to submesh of the source face.
 StdMeshers_Projection_3D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_Projection_3D ()
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
virtual void SetEventListener (SMESH_subMesh *whenSetToSubMesh)
 Sets a default event listener to submesh of the source shape.
 StdMeshers_ProjectionSource1D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_ProjectionSource1D ()
void SetSourceEdge (const TopoDS_Shape &edge) throw ( SALOME_Exception )
 Sets source <edge> to take a mesh pattern from.
TopoDS_Shape GetSourceEdge () const
 Returns the source edge or a group containing edges.
bool IsCompoundSource () const
 Returns true the source edge is a group of edges.
void SetSourceMesh (SMESH_Mesh *mesh)
 Sets source <mesh> to take a mesh pattern from.
SMESH_Mesh * GetSourceMesh () const
 Return source mesh.
void SetVertexAssociation (const TopoDS_Shape &sourceVertex, const TopoDS_Shape &targetVertex) throw ( SALOME_Exception )
 Sets vertex association between the source edge and the target one.
TopoDS_Vertex GetSourceVertex () const
 Returns the vertex associated with the target vertex.
TopoDS_Vertex GetTargetVertex () const
 Returns the vertex associated with the source vertex.
bool HasVertexAssociation () const
 Test if vertex association defined.
void GetStoreParams (TopoDS_Shape &s1, TopoDS_Shape &s2, TopoDS_Shape &s3) const
 Return all parameters.
void RestoreParams (const TopoDS_Shape &s1, const TopoDS_Shape &s2, const TopoDS_Shape &s3, SMESH_Mesh *mesh)
 Set all parameters without notifying on modification.
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize parameters by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_ProjectionSource2D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_ProjectionSource2D ()
void SetSourceFace (const TopoDS_Shape &face) throw ( SALOME_Exception )
 Sets a source <face> to take a mesh pattern from.
TopoDS_Shape GetSourceFace () const
 Returns the source face or a group containing faces.
bool IsCompoundSource () const
 Returns true the source face is a group of faces.
void SetSourceMesh (SMESH_Mesh *mesh)
 Sets source <mesh> to take a mesh pattern from.
SMESH_Mesh * GetSourceMesh () const
 Return source mesh.
void SetVertexAssociation (const TopoDS_Shape &sourceVertex1, const TopoDS_Shape &sourceVertex2, const TopoDS_Shape &targetVertex1, const TopoDS_Shape &targetVertex2) throw ( SALOME_Exception )
 Sets vertex association between the source face and the target one.
TopoDS_Vertex GetSourceVertex (int i) const throw ( SALOME_Exception )
 Returns the -th source vertex associated with the -th target vertex.
TopoDS_Vertex GetTargetVertex (int i) const throw ( SALOME_Exception )
 Returns the -th target vertex associated with the -th source vertex.
bool HasVertexAssociation () const
 Test if vertex association defined.
void GetStoreParams (TopoDS_Shape &s1, TopoDS_Shape &s2, TopoDS_Shape &s3, TopoDS_Shape &s4, TopoDS_Shape &s5) const
 Return all parameters.
void RestoreParams (const TopoDS_Shape &s1, const TopoDS_Shape &s2, const TopoDS_Shape &s3, const TopoDS_Shape &s4, const TopoDS_Shape &s5, SMESH_Mesh *mesh)
 Set all parameters without notifying on modification.
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize parameters by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_ProjectionSource3D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_ProjectionSource3D ()
void SetSource3DShape (const TopoDS_Shape &shape) throw ( SALOME_Exception )
 Sets a source <shape> to take a mesh pattern from.
TopoDS_Shape GetSource3DShape () const
 Returns the source shape.
void SetSourceMesh (SMESH_Mesh *mesh)
 Sets source <mesh> to take a mesh pattern from.
SMESH_Mesh * GetSourceMesh () const
 Return source mesh.
void SetVertexAssociation (const TopoDS_Shape &sourceVertex1, const TopoDS_Shape &sourceVertex2, const TopoDS_Shape &targetVertex1, const TopoDS_Shape &targetVertex2) throw ( SALOME_Exception )
 Sets vertex association between the source shape and the target one.
TopoDS_Vertex GetSourceVertex (int i) const throw ( SALOME_Exception )
 Returns the -th source vertex associated with the -th target vertex.
TopoDS_Vertex GetTargetVertex (int i) const throw ( SALOME_Exception )
 Returns the -th target vertex associated with the -th source vertex.
bool HasVertexAssociation () const
 Test if vertex association defined.
void GetStoreParams (TopoDS_Shape &s1, TopoDS_Shape &s2, TopoDS_Shape &s3, TopoDS_Shape &s4, TopoDS_Shape &s5) const
 Return all parameters.
void RestoreParams (const TopoDS_Shape &s1, const TopoDS_Shape &s2, const TopoDS_Shape &s3, const TopoDS_Shape &s4, const TopoDS_Shape &s5, SMESH_Mesh *mesh)
 Set all parameters without notifying on modification.
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize parameters by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_Propagation (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_Propagation ()
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize my parameter values by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_Quadrangle_2D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_Quadrangle_2D ()
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
FaceQuadStructCheckAnd2Dcompute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, const bool CreateQuadratic)
FaceQuadStructCheckNbEdges (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
 StdMeshers_QuadrangleParams (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_QuadrangleParams ()
void SetTriaVertex (int id)
int GetTriaVertex () const
void SetObjectEntry (const char *entry)
const char * GetObjectEntry ()
void SetQuadType (StdMeshers_QuadType type)
StdMeshers_QuadType GetQuadType () const
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize start and end length by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_QuadranglePreference (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_QuadranglePreference ()
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize my parameter values by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_QuadraticMesh (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_QuadraticMesh ()
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize my parameter values by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_QuadToTriaAdaptor ()
 ~StdMeshers_QuadToTriaAdaptor ()
bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_ProxyMesh *aProxyMesh=0)
bool Compute (SMESH_Mesh &aMesh)
 StdMeshers_RadialPrism_3D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_RadialPrism_3D ()
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
 StdMeshers_RadialQuadrangle_1D2D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_RadialQuadrangle_1D2D ()
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
virtual void SubmeshRestored (SMESH_subMesh *subMesh)
 Allow algo to do something after persistent restoration.
 StdMeshers_Regular_1D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_Regular_1D ()
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
virtual const std::list< const
SMESHDS_Hypothesis * > & 
GetUsedHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, const bool=true)
virtual void SetEventListener (SMESH_subMesh *subMesh)
 Sets event listener to submeshes if necessary.
void SubmeshRestored (SMESH_subMesh *subMesh)
 Allow algo to do something after persistent restoration.
 StdMeshers_SegmentAroundVertex_0D (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_SegmentAroundVertex_0D ()
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
 StdMeshers_SegmentLengthAroundVertex (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_SegmentLengthAroundVertex ()
void SetLength (double length) throw (SALOME_Exception)
double GetLength () const
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize segment length by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_StartEndLength (int hypId, int studyId, SMESH_Gen *gen)
virtual ~StdMeshers_StartEndLength ()
void SetLength (double length, bool isStartLength) throw (SALOME_Exception)
double GetLength (bool isStartLength) const
void SetReversedEdges (std::vector< int > &ids)
const std::vector< int > & GetReversedEdges () const
void SetObjectEntry (const char *entry)
const char * GetObjectEntry ()
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize start and end length by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.
 StdMeshers_UseExisting_2D (int hypId, int studyId, SMESH_Gen *gen)
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
 StdMeshers_UseExisting_1D (int hypId, int studyId, SMESH_Gen *gen)
virtual bool CheckHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, SMESH_Hypothesis::Hypothesis_Status &aStatus)
virtual bool Compute (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape)
virtual bool Evaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap)
 StdMeshers_ViscousLayers (int hypId, int studyId, SMESH_Gen *gen)
void SetIgnoreFaces (const std::vector< int > &faceIds)
std::vector< int > GetIgnoreFaces () const
void SetTotalThickness (double thickness)
double GetTotalThickness () const
void SetNumberLayers (int nb)
int GetNumberLayers () const
void SetStretchFactor (double factor)
double GetStretchFactor () const
SMESH_ProxyMesh::Ptr Compute (SMESH_Mesh &theMesh, const TopoDS_Shape &theShape, const bool toMakeN2NMap=false) const
virtual std::ostream & SaveTo (std::ostream &save)
virtual std::istream & LoadFrom (std::istream &load)
virtual bool SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
 Initialize my parameter values by the mesh built on the geometry.
virtual bool SetParametersByDefaults (const TDefaults &dflts, const SMESH_Mesh *theMesh=0)
 Initialize my parameter values by default parameters.

Static Public Member Functions

static void ComputeCoordinates (const double x0, const double x1, std::vector< std::string > &spaceFuns, std::vector< double > &points, std::vector< double > &coords, const std::string &axis) throw (SALOME_Exception)
 Computes node coordinates by spacing functions.
static StdMeshers_FaceSideGetFaceSide (SMESH_Mesh &aMesh, const TopoDS_Edge &anEdge, const TopoDS_Face &aFace, const bool ignoreMeshed)
 Return a face side the edge belongs to.
static std::string AlgoName ()
 Returns algo type name.
static TSideVector GetFaceWires (const TopoDS_Face &theFace, SMESH_Mesh &theMesh, const bool theIgnoreMediumNodes, TError &theError)
 Return wires of a face as StdMeshers_FaceSide's.
static void getMaps (const SMESH_Mesh *srcMesh, SMESH_Mesh *tgtMesh, TNodeNodeMap *&n2n, TElemElemMap *&e2e)
static void importMesh (const SMESH_Mesh *srcMesh, SMESH_Mesh &tgtMesh, StdMeshers_ImportSource1D *srcHyp, const TopoDS_Shape &tgtShape)
static void setEventListener (SMESH_subMesh *subMesh, StdMeshers_ImportSource1D *sourceHyp)
static SMESH_subMesh * getSubMeshOfCopiedMesh (SMESH_Mesh &tgtMesh, SMESH_Mesh &srcMesh)
static std::string CheckExpressionFunction (const std::string &expr, const int convMode) throw (SALOME_Exception)
 Checks validity of the expression of the function f(t), e.g.
static bool IsForwardEdge (SMESHDS_Mesh *meshDS, const TParam2ColumnMap &columnsMap, const TopoDS_Edge &bottomEdge, const int sideFaceID)
 Check curve orientation of a bootom edge.
static void AddPrisms (std::vector< const TNodeColumn * > &nodeColumns, SMESH_MesherHelper *helper)
 Create prisms.
static std::string GetName ()
static void SetPropagationMgr (SMESH_subMesh *subMesh)
 Set EventListener managing propagation of hypotheses.
static TopoDS_Edge GetPropagationSource (SMESH_Mesh &theMesh, const TopoDS_Shape &theEdge)
 Return an edge from which hypotheses are propagated.
static const char * GetHypType ()

Protected Types

enum  HypothesisType {
  LOCAL_LENGTH, MAX_LENGTH, NB_SEGMENTS, BEG_END_LENGTH,
  DEFLECTION, ARITHMETIC_1D, FIXED_POINTS_1D, NONE
}
enum  ValueIndex {
  SCALE_FACTOR_IND = 0, BEG_LENGTH_IND = 0, END_LENGTH_IND = 1, DEFLECTION_IND = 0,
  PRECISION_IND = 1
}
enum  IValueIndex { NB_SEGMENTS_IND = 0, DISTR_TYPE_IND = 1, CONV_MODE_IND = 2 }
enum  VValueIndex { TAB_FUNC_IND = 0 }
enum  SValueIndex { EXPR_FUNC_IND = 0 }
typedef std::vector< const
SMDS_MeshNode * > 
TNodeColumn
typedef std::map< const
SMDS_MeshNode *, TNodeColumn
TNode2ColumnMap

Protected Member Functions

void CheckData ()
void MakeBlock ()
void MakeNodes ()
double SetHorizEdgeXYZ (const gp_XYZ &aBNXYZ, const int aFaceID, std::vector< const SMDS_MeshNode * > *&aCol1, std::vector< const SMDS_MeshNode * > *&aCol2)
void ShapeSupportID (const bool theIsUpperLayer, const SMESH_Block::TShapeID theBNSSID, SMESH_Block::TShapeID &theSSID)
void FindNodeOnShape (const TopoDS_Shape &aS, const gp_XYZ &aParams, const int z, StdMeshers_TNode &aTN)
void CreateNode (const bool theIsUpperLayer, const gp_XYZ &aParams, StdMeshers_TNode &aTN)
void ClearMeshOnFxy1 ()
void MakeMeshOnFxy1 ()
void MakeConnectingMap ()
int GetIndexOnLayer (const int aID)
void MakeVolumeMesh ()
void SetMesh (SMESH_Mesh &theMesh)
SMESH_Mesh * GetMesh () const
bool CheckNbEdgesForEvaluate (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, MapShapeNbElems &aResMap, std::vector< int > &aNbNodes, bool &IsQuadratic)
bool SetNormalizedGrid (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, FaceQuadStruct *&quad)
void SplitQuad (SMESHDS_Mesh *theMeshDS, const int theFaceID, const SMDS_MeshNode *theNode1, const SMDS_MeshNode *theNode2, const SMDS_MeshNode *theNode3, const SMDS_MeshNode *theNode4)
bool ComputeQuadPref (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, FaceQuadStruct *quad)
bool EvaluateQuadPref (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, std::vector< int > &aNbNodes, MapShapeNbElems &aResMap, bool IsQuadratic)
bool ComputeReduced (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, FaceQuadStruct *quad)
void UpdateDegenUV (FaceQuadStruct *quad)
void Smooth (FaceQuadStruct *quad)
int Preparation (const SMDS_MeshElement *face, Handle_TColgp_HArray1OfPnt &PN, Handle_TColgp_HArray1OfVec &VN, std::vector< const SMDS_MeshNode * > &FNodes, gp_Pnt &PC, gp_Vec &VNorm, const SMDS_MeshElement **volumes=0)
bool CheckIntersection (const gp_Pnt &P, const gp_Pnt &PC, gp_Pnt &Pint, SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, const SMDS_MeshElement *NotCheckedFace)
bool Compute2ndPart (SMESH_Mesh &aMesh, const std::vector< const SMDS_MeshElement * > &pyramids)
void MergePiramids (const SMDS_MeshElement *PrmI, const SMDS_MeshElement *PrmJ, std::set< const SMDS_MeshNode * > &nodesToMove)
void MergeAdjacent (const SMDS_MeshElement *PrmI, std::set< const SMDS_MeshNode * > &nodesToMove)
TNodeColumnmakeNodeColumn (TNode2ColumnMap &n2ColMap, const SMDS_MeshNode *outNode, const SMDS_MeshNode *inNode)
bool computeLayerPositions (const gp_Pnt &pIn, const gp_Pnt &pOut)
bool computeLayerPositions (const gp_Pnt &p1, const gp_Pnt &p2, const TopoDS_Edge &linEdge=TopoDS_Edge(), bool *linEdgeComputed=0)
virtual bool computeInternalParameters (SMESH_Mesh &theMesh, Adaptor3d_Curve &theC3d, double theLength, double theFirstU, double theLastU, std::list< double > &theParameters, const bool theReverse, bool theConsiderPropagation=false)
virtual void redistributeNearVertices (SMESH_Mesh &theMesh, Adaptor3d_Curve &theC3d, double theLength, std::list< double > &theParameters, const TopoDS_Vertex &theVf, const TopoDS_Vertex &theVl)

Static Protected Member Functions

static const
StdMeshers_SegmentLengthAroundVertex
getVertexHyp (SMESH_Mesh &theMesh, const TopoDS_Vertex &theV)
 Return StdMeshers_SegmentLengthAroundVertex assigned to vertex.

Protected Attributes

double _begLength
double _endLength
std::vector< int > _edgeIDs
 list of reversed edges ids
std::string _objEntry
 Entry of the main object to reverse edges.
std::map< const TopoDS_TShape
*, double > 
_TShapeToLength
const SMESH_Mesh * _mesh
double _fineness
double _S0
double _minLen
std::vector< double > _coords [3]
std::vector< std::string > _spaceFunctions [3]
std::vector< double > _internalPoints [3]
double _sizeThreshold
SMESH_subMeshEventListener * _EventListener
double _value
std::vector< uvPtStructmyPoints
std::vector< uvPtStructmyFalsePoints
std::vector< TopoDS_Edge > myEdge
std::vector< int > myEdgeID
std::vector< Handle(Geom2d_Curve)> myC2d
std::vector< GeomAdaptor_Curve > myC3dAdaptor
std::vector< double > myFirst
std::vector< double > myLast
std::vector< double > myNormPar
std::vector< double > myEdgeLength
std::vector< double > myIsUniform
double myLength
int myNbPonits
int myNbSegments
SMESH_Mesh * myMesh
bool myMissingVertexNodes
bool myIgnoreMediumNodes
gp_Pnt2d myDefaultPnt2d
std::vector< double > _params
std::vector< int > _nbsegs
const StdMeshers_ViscousLayers_viscousLayersHyp
SMESH_Hypothesis * myHyp
std::string mySavedHyp
int _mode
double _length
double _precision
double _maxArea
double _maxVolume
double _preestimated
bool _preestimation
double _edgeLength
double _maxElementArea
const StdMeshers_MaxElementArea_hypMaxElementArea
const StdMeshers_LengthFromEdges_hypLengthFromEdges
std::list< const SMDS_MeshNode * > myNodesOnCommonV
SMESH_MesherHelper * myTool
int _nbLayers
int _numberOfSegments
 an edge will be split on to this number of segments
DistrType _distrType
 the type of distribution of density function
double _scaleFactor
 the scale parameter for DT_Scale
std::vector< double > _table
std::vector< double > _distr
 the table for DT_TabFunc, a sequence of pairs of numbers
std::string _func
 the expression of the function for DT_ExprFunc
int _convMode
 flag of conversion mode: 0=exponent, 1=cut negative
TopoDS_Shell myShell
TopTools_IndexedMapOfOrientedShape myShapeIDMap
SMESH_Block myTBlock
TopoDS_Shape myEmptyShape
std::vector< int > myIsEdgeForward
int myErrorStatus
TopoDS_Shape myShape
StdMeshers_SMESHBlock myBlock
void * myMesh
SMESH_ComputeErrorPtr myErrorStatus
std::vector< StdMeshers_TNodemyTNodes
int myISize
int myJSize
double myTol3D
std::map< int, int > myConnectingMap
std::vector< StdMeshers_IJNodeMapmyWallNodesMaps
std::vector< gp_XYZ > myShapeXYZ
bool myCreateQuadratic
const
StdMeshers_ProjectionSource1D
_sourceHypo
const
StdMeshers_ProjectionSource2D
_sourceHypo
const
StdMeshers_ProjectionSource3D
_sourceHypo
TopoDS_Shape _sourceEdge
SMESH_Mesh * _sourceMesh
TopoDS_Vertex _sourceVertex
TopoDS_Vertex _targetVertex
TopoDS_Shape _sourceFace
TopoDS_Vertex _sourceVertex1
TopoDS_Vertex _sourceVertex2
TopoDS_Vertex _targetVertex1
TopoDS_Vertex _targetVertex2
TopoDS_Shape _sourceShape
bool myQuadranglePreference
bool myTrianglePreference
int myTriaVertexID
StdMeshers_QuadType myQuadType
bool myNeedSmooth
int _triaVertexID
StdMeshers_QuadType _quadType
std::set< const
SMDS_MeshElement * > 
myRemovedTrias
std::list< const SMDS_MeshNode * > myDegNodes
const SMESH_ElementSearchermyElemSearcher
const StdMeshers_NumberOfLayersmyNbLayerHypo
const
StdMeshers_LayerDistribution
myDistributionHypo
std::vector< double > myLayerPositions
HypothesisType _hypType
const StdMeshers_FixedPoints1D_fpHyp
int _ivalue [3]
std::vector< double > _vvalue [1]
std::string _svalue [1]
std::vector< int > _revEdgesIDs
TopoDS_Shape _mainEdge

Private Types

typedef std::map< std::pair
< int, int >, std::vector
< SMESH_Group * > > 
TResGroupMap

Private Member Functions

void setSubmeshesComputed (SMESH_Mesh &aMesh, const TopoDS_Shape &theShape)
bool findBounds (const double, int &, int &) const
double integral (const int i) const
double integral (const int i, const double d) const
 Handle (ExprIntrp_GenExp) myExpr
void resultGroupsToIntVec ()
bool error (int error, const SMESH_Comment &comment="")
 store error and comment and then return ( error == COMPERR_OK )
bool assocOrProjBottom2Top ()
 Find correspondence between bottom and top nodes.
bool projectBottomToTop ()
 Remove quadrangles from the top face and create triangles there by projection from the bottom.
bool setFaceAndEdgesXYZ (const int faceID, const gp_XYZ &params, int z)
 Set projection coordinates of a node to a face and it's sub-shapes.

Private Attributes

const
StdMeshers_CartesianParameters3D
_hyp
int myConv
FunctionmyFunc
double myStart
std::vector< double > myData
Expr_Array1OfNamedUnknown myVars
TColStd_Array1OfReal myValues
StdMeshers_ImportSource1D_sourceHyp
std::vector< SMESH_Group * > _groups
bool _toCopyMesh
bool _toCopyGroups
TResGroupMap _resultGroups
std::vector< int > _resultGroupsStorage
SMDS_MeshNode * myNode
int myShapeSupportID
gp_XYZ myXYZ
int myBaseNodeID
bool myNotQuadOnTop
SMESH_MesherHelper * myHelper
TBlockShapes myShapeIDMap
SMESH_ComputeErrorPtr myError
TSideFacemySide
std::vector< TParam2ColumnMapmyParam2ColumnMaps
std::map< int, std::pair
< TParam2ColumnMap *, bool > > 
myShapeIndex2ColumnMap
bool myProjectTriangles
StdMeshers_PrismAsBlock myBlock
TNode2ColumnMap myBotToColumnMap
std::vector< int > _ignoreFaceIds
double _thickness
double _stretchFactor

Friends

std::ostream & operator<< (std::ostream &save, StdMeshers_Arithmetic1D &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_Arithmetic1D &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_AutomaticLength &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_AutomaticLength &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_Deflection1D &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_Deflection1D &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_FixedPoints1D &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_FixedPoints1D &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_LayerDistribution &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_LayerDistribution &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_LengthFromEdges &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_LengthFromEdges &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_LocalLength &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_LocalLength &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_MaxElementArea &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_MaxElementArea &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_MaxElementVolume &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_MaxElementVolume &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_NotConformAllowed &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_NotConformAllowed &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_NumberOfLayers &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_NumberOfLayers &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_NumberOfSegments &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_NumberOfSegments &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_ProjectionSource1D &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_ProjectionSource1D &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_ProjectionSource2D &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_ProjectionSource2D &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_ProjectionSource3D &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_ProjectionSource3D &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_Propagation &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_Propagation &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_QuadrangleParams &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_QuadrangleParams &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_QuadraticMesh &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_QuadraticMesh &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_SegmentLengthAroundVertex &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_SegmentLengthAroundVertex &hyp)
std::ostream & operator<< (std::ostream &save, StdMeshers_StartEndLength &hyp)
std::istream & operator>> (std::istream &load, StdMeshers_StartEndLength &hyp)

Detailed Description

1D Hypothesis to compute segment length free of thinking

Hypothesis defining parameters of viscous layers.

1D and 2D algorithms doing nothing to allow mesh generation by mesh edition functions in TUI mode

This hypothesis specifies length of segments adjacent to the vertex the hypothesis is assigned to.

Algorithm existing in order just to enable assignation of StdMeshers_SegmentLengthAroundVertex hypothesis.

"Transforms" quadrilateral faces into triangular ones by creation of pyramids

Hypothesis for StdMeshers_Regular_1D, forcing construction of quadratic edges.

Hypothesis for StdMeshers_Quadrangle_2D, forcing construction of quadrangles if the number of nodes on opposite edges is not the same.

Propagation hypothesis.

This hypothesis specifies a meshed shell or solid to take a mesh pattern from and optionally association of vertices between the source shape and a target one (where a hipothesis is assigned to)

This hypothesis specifies a meshed face to take a mesh pattern from and optionally association of vertices between the source face and a target one (where a hipothesis is assigned to)

This hypothesis specifies a meshed edge to take a mesh pattern from and optionally association of vertices between the source edge and a target one (where a hipothesis is assigned to)

Algo building prisms on a prism shape.

Tool analyzing and giving access to a prism geometry treating it like a block, i.e.

This class represents hypothesis for 1d algorithm.

This hypothesis is used by "Radial quadrangle" algorithm.

This hypothesis is used by "Radial prism" algorithm.

Redefines name and dimension of inherited StdMeshers_ImportSource1D.

Stores groups to import elements from.

Copy elements from other the mesh.

Alorithm generating hexahedral mesh from 2D skin of block.

Represents a side of a quasi quadrilateral face.

Computes hexahedral mesh on a box with composite sides.

This hypothesis specifies.

It computes segment length basing on max shape size to shortest edge length ratio: S = S0 * f(L/Lmin) where f(x) = 1 + (2/Pi * 7 * atan(x/5) )

The algorithm expects faces of a box to be meshed with quadrangles so that opposite box sides have equal number of quadrangles.

It can be composed of several edges. Gives access to geometry and 1D mesh of a side.

It specifies 1D hypothesis defining distribution of segments between the internal and the external surfaces.

It specifies number of segments between the internal and the external surfaces.

It provides parameters for subdivision an edge by various distribution types, considering the given number of resulting segments

the four side faces are emulated by division/uniting of missing/excess faces. It also manage associations between block sub-shapes and a mesh.

GIBI can do it if the global number of nodes is even (DALL operator). See PAL10467

If the 2D mesher sees that all boundary edges are quadratic ones, it generates quadratic faces, else it generates linear faces using medium nodes as if they were vertex ones. The 3D mesher generates quadratic volumes only if all boundary faces are quadratic ones, else it fails.

Definition at line 40 of file StdMeshers_Arithmetic1D.hxx.


Member Typedef Documentation

Definition at line 64 of file StdMeshers_MEFISTO_2D.hxx.

typedef std::map<const SMDS_MeshElement*,const SMDS_MeshElement*,TIDCompare> STDMESHERS_EXPORT::TElemElemMap

Definition at line 58 of file StdMeshers_Import_1D.hxx.

typedef std::map< const SMDS_MeshNode*, TNodeColumn > STDMESHERS_EXPORT::TNode2ColumnMap [protected]

Definition at line 61 of file StdMeshers_RadialPrism_3D.hxx.

typedef std::vector<const SMDS_MeshNode* > STDMESHERS_EXPORT::TNodeColumn [protected]

Definition at line 60 of file StdMeshers_RadialPrism_3D.hxx.

typedef std::map<const SMDS_MeshNode*, const SMDS_MeshNode*, TIDCompare> STDMESHERS_EXPORT::TNodeNodeMap

Definition at line 57 of file StdMeshers_Import_1D.hxx.

typedef std::map< std::pair<int, int>, std::vector<SMESH_Group*> > STDMESHERS_EXPORT::TResGroupMap [private]

Definition at line 81 of file StdMeshers_ImportSource.hxx.

Definition at line 65 of file StdMeshers_MEFISTO_2D.hxx.


Member Enumeration Documentation

This enumeration presents available types of distribution.

Enumerator:
DT_Regular 

equidistant distribution

DT_Scale 

scale distribution

DT_TabFunc 

distribution with density function presented by table

DT_ExprFunc 

distribution with density function presented by expression

Definition at line 70 of file StdMeshers_NumberOfSegments.hxx.

Enumerator:
LOCAL_LENGTH 
MAX_LENGTH 
NB_SEGMENTS 
BEG_END_LENGTH 
DEFLECTION 
ARITHMETIC_1D 
FIXED_POINTS_1D 
NONE 

Definition at line 103 of file StdMeshers_Regular_1D.hxx.

Enumerator:
NB_SEGMENTS_IND 
DISTR_TYPE_IND 
CONV_MODE_IND 

Definition at line 113 of file StdMeshers_Regular_1D.hxx.

Enumerator:
EXPR_FUNC_IND 

Definition at line 123 of file StdMeshers_Regular_1D.hxx.

                   {
    EXPR_FUNC_IND  = 0
  };
Enumerator:
SCALE_FACTOR_IND 
BEG_LENGTH_IND 
END_LENGTH_IND 
DEFLECTION_IND 
PRECISION_IND 

Definition at line 105 of file StdMeshers_Regular_1D.hxx.

Enumerator:
TAB_FUNC_IND 

Definition at line 119 of file StdMeshers_Regular_1D.hxx.

                   {
    TAB_FUNC_IND  = 0
  };

Constructor & Destructor Documentation

virtual STDMESHERS_EXPORT::~Function ( ) [virtual]
virtual STDMESHERS_EXPORT::~FunctionIntegral ( ) [virtual]
virtual STDMESHERS_EXPORT::~FunctionTable ( ) [virtual]
virtual STDMESHERS_EXPORT::~FunctionExpr ( ) [virtual]

Member Function Documentation

static void STDMESHERS_EXPORT::AddPrisms ( std::vector< const TNodeColumn * > &  nodeColumns,
SMESH_MesherHelper *  helper 
) [static]

Create prisms.

Parameters:
nodeColumns- columns of nodes generated from nodes of a mesh face
helper- helper initialized by mesh and shape to add prisms to
static std::string STDMESHERS_EXPORT::AlgoName ( ) [static]

Returns algo type name.

Find correspondence between bottom and top nodes.

If elements on the bottom and top faces are topologically different, and projection is possible and allowed, perform the projection

Return values:
bool- is a success or not
int STDMESHERS_EXPORT::BaseNodeID ( ) const [inline]

Definition at line 152 of file StdMeshers_Penta_3D.hxx.

                        {
    return myBaseNodeID;
  }
SMESH_Block& STDMESHERS_EXPORT::Block ( ) [inline]

Definition at line 87 of file StdMeshers_Penta_3D.hxx.

{ return myTBlock; }
const std::vector<double>& STDMESHERS_EXPORT::BuildDistributionExpr ( const char *  ,
int  ,
int   
) throw ( SALOME_Exception )
const std::vector<double>& STDMESHERS_EXPORT::BuildDistributionTab ( const std::vector< double > &  ,
int  ,
int   
) throw ( SALOME_Exception )
FaceQuadStruct* STDMESHERS_EXPORT::CheckAnd2Dcompute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
const bool  CreateQuadratic 
)
void STDMESHERS_EXPORT::CheckData ( ) [protected]
static std::string STDMESHERS_EXPORT::CheckExpressionFunction ( const std::string &  expr,
const int  convMode 
) throw (SALOME_Exception) [static]

Checks validity of the expression of the function f(t), e.g.

"sin(t)". In case of validity returns a cleaned expression

Parameters:
convMode- 0 for "Exponent mode", 1 for "Cut negative mode"
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
virtual bool STDMESHERS_EXPORT::CheckHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_Hypothesis::Hypothesis_Status &  aStatus 
) [virtual]
bool STDMESHERS_EXPORT::CheckIntersection ( const gp_Pnt &  P,
const gp_Pnt &  PC,
gp_Pnt &  Pint,
SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
const SMDS_MeshElement *  NotCheckedFace 
) [protected]
FaceQuadStruct* STDMESHERS_EXPORT::CheckNbEdges ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
)
bool STDMESHERS_EXPORT::CheckNbEdgesForEvaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap,
std::vector< int > &  aNbNodes,
bool &  IsQuadratic 
) [protected]

Free allocated memory.

void STDMESHERS_EXPORT::ClearMeshOnFxy1 ( ) [protected]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
SMESH_MesherHelper *  aHelper 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
SMESH_MesherHelper *  aHelper 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
SMESH_ProxyMesh *  aProxyMesh = 0 
)
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh)
SMESH_ProxyMesh::Ptr STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  theMesh,
const TopoDS_Shape &  theShape,
const bool  toMakeN2NMap = false 
) const
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  ,
const TopoDS_Shape &   
)
virtual bool STDMESHERS_EXPORT::Compute ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape 
) [virtual]
bool STDMESHERS_EXPORT::Compute2ndPart ( SMESH_Mesh &  aMesh,
const std::vector< const SMDS_MeshElement * > &  pyramids 
) [protected]
static void STDMESHERS_EXPORT::ComputeCoordinates ( const double  x0,
const double  x1,
std::vector< std::string > &  spaceFuns,
std::vector< double > &  points,
std::vector< double > &  coords,
const std::string &  axis 
) throw (SALOME_Exception) [static]

Computes node coordinates by spacing functions.

Parameters:
x0- lower coordinate
x1- upper coordinate
spaceFuns- space functions
points- internal points
coords- the computed coordinates
virtual bool STDMESHERS_EXPORT::computeInternalParameters ( SMESH_Mesh &  theMesh,
Adaptor3d_Curve &  theC3d,
double  theLength,
double  theFirstU,
double  theLastU,
std::list< double > &  theParameters,
const bool  theReverse,
bool  theConsiderPropagation = false 
) [protected, virtual]
bool STDMESHERS_EXPORT::computeLayerPositions ( const gp_Pnt &  p1,
const gp_Pnt &  p2,
const TopoDS_Edge &  linEdge = TopoDS_Edge(),
bool *  linEdgeComputed = 0 
) [protected]
bool STDMESHERS_EXPORT::computeLayerPositions ( const gp_Pnt &  pIn,
const gp_Pnt &  pOut 
) [protected]
void STDMESHERS_EXPORT::ComputeParameters ( const gp_Pnt &  thePnt,
gp_XYZ &  theXYZ 
)
void STDMESHERS_EXPORT::ComputeParameters ( const gp_Pnt &  thePnt,
const TopoDS_Shape &  theShape,
gp_XYZ &  theXYZ 
)
void STDMESHERS_EXPORT::ComputeParameters ( const double &  theU,
const TopoDS_Shape &  theShape,
gp_XYZ &  theXYZ 
)
bool STDMESHERS_EXPORT::ComputeQuadPref ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
FaceQuadStruct quad 
) [protected]
bool STDMESHERS_EXPORT::ComputeReduced ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
FaceQuadStruct quad 
) [protected]
void STDMESHERS_EXPORT::ComputeScaleOnFace ( SMESH_Mesh &  aMesh,
const TopoDS_Face &  aFace,
double &  scalex,
double &  scaley 
)
int STDMESHERS_EXPORT::ConversionMode ( ) const throw (SALOME_Exception)

Returns conversion mode.

Throws SALOME_Exception if distribution type is not functional

void STDMESHERS_EXPORT::CreateNode ( const bool  theIsUpperLayer,
const gp_XYZ &  aParams,
StdMeshers_TNode aTN 
) [protected]
void STDMESHERS_EXPORT::dump ( const char *  msg = 0) const
const TopoDS_Edge& STDMESHERS_EXPORT::Edge ( int  i) const [inline]

Return i-th wrapped edge (count starts from zero)

Definition at line 173 of file StdMeshers_FaceSide.hxx.

{ return myEdge[i]; }
int STDMESHERS_EXPORT::EdgeIndex ( double  U) const [inline]

Return edge index corresponding to normalized parameter.

const std::vector<TopoDS_Edge>& STDMESHERS_EXPORT::Edges ( ) const [inline]

Return all edges.

Definition at line 177 of file StdMeshers_FaceSide.hxx.

{ return myEdge; }
bool STDMESHERS_EXPORT::error ( int  error,
const SMESH_Comment comment = "" 
) [inline, private]

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

Definition at line 380 of file StdMeshers_Prism_3D.hxx.

                                                           {
    myError = SMESH_ComputeError::New(error,comment);
    return myError->IsOK();
  }

Here is the call graph for this function:

int STDMESHERS_EXPORT::ErrorStatus ( ) const [inline]

Definition at line 180 of file StdMeshers_Penta_3D.hxx.

                            {
      if (myErrorStatus->IsOK())
        return 0;
      return myErrorStatus->myName;
    }
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
)
virtual bool STDMESHERS_EXPORT::Evaluate ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
MapShapeNbElems aResMap 
) [virtual]
bool STDMESHERS_EXPORT::EvaluateQuadPref ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
std::vector< int > &  aNbNodes,
MapShapeNbElems aResMap,
bool  IsQuadratic 
) [protected]
bool STDMESHERS_EXPORT::findBounds ( const double  ,
int &  ,
int &   
) const [private]
void STDMESHERS_EXPORT::FindNodeOnShape ( const TopoDS_Shape &  aS,
const gp_XYZ &  aParams,
const int  z,
StdMeshers_TNode aTN 
) [protected]
double STDMESHERS_EXPORT::FirstParameter ( int  i) const [inline]

Return first normalized parameter of the i-the edge (count starts from zero)

TopoDS_Vertex STDMESHERS_EXPORT::FirstVertex ( int  i = 0) const

Return 1st vertex of the i-the edge (count starts from zero)

STDMESHERS_EXPORT::Function ( const int  )
STDMESHERS_EXPORT::FunctionExpr ( const char *  ,
const int   
)

Here is the caller graph for this function:

STDMESHERS_EXPORT::FunctionIntegral ( const Function ,
const double   
)

Here is the caller graph for this function:

STDMESHERS_EXPORT::FunctionTable ( const std::vector< double > &  ,
const int   
)

Here is the caller graph for this function:

Definition at line 186 of file StdMeshers_Penta_3D.hxx.

                                                  {
      return myErrorStatus;
    }
void STDMESHERS_EXPORT::GetCoordinates ( std::vector< double > &  xNodes,
std::vector< double > &  yNodes,
std::vector< double > &  zNodes,
const Bnd_Box &  bndBox 
) const throw ( SALOME_Exception )

Return coordinates of node positions along the three axes.

If the grid is defined by spacing functions, the coordinates are computed

void STDMESHERS_EXPORT::GetCopySourceMesh ( bool &  toCopyMesh,
bool &  toCopyGroups 
) const
Adaptor2d_Curve2d* STDMESHERS_EXPORT::GetCurve2d ( ) const

Creates a Adaptor2d_Curve2d to be used in SMESH_Block.

BRepAdaptor_CompCurve* STDMESHERS_EXPORT::GetCurve3d ( ) const

Creates a fully functional Adaptor_Curve.

Get distribution type.

Return problem description.

Definition at line 125 of file StdMeshers_Prism_3D.hxx.

{ return myError; }
const char* STDMESHERS_EXPORT::GetExpressionFunction ( ) const throw (SALOME_Exception)

Get expression function for distribution DT_ExprFunc.

Throws SALOME_Exception if distribution type is not DT_ExprFunc

static StdMeshers_FaceSide* STDMESHERS_EXPORT::GetFaceSide ( SMESH_Mesh &  aMesh,
const TopoDS_Edge &  anEdge,
const TopoDS_Face &  aFace,
const bool  ignoreMeshed 
) [static]

Return a face side the edge belongs to.

static TSideVector STDMESHERS_EXPORT::GetFaceWires ( const TopoDS_Face &  theFace,
SMESH_Mesh &  theMesh,
const bool  theIgnoreMediumNodes,
TError theError 
) [static]

Return wires of a face as StdMeshers_FaceSide's.

double STDMESHERS_EXPORT::GetFineness ( ) const [inline]

Return mesh Fineness.

Return values:
double- Fineness value [0.0-1.0]

Definition at line 84 of file StdMeshers_AutomaticLength.hxx.

{ return _fineness; }
void STDMESHERS_EXPORT::GetGrid ( std::vector< double > &  xNodes,
int  axis 
) const throw ( SALOME_Exception )

Return coordinates of node positions along the three axes.

void STDMESHERS_EXPORT::GetGridSpacing ( std::vector< std::string > &  spaceFunctions,
std::vector< double > &  internalPoints,
const int  axis 
) const throw ( SALOME_Exception )
const std::vector<SMESH_Group*>& STDMESHERS_EXPORT::GetGroups ( ) const
static const char* STDMESHERS_EXPORT::GetHypType ( ) [inline, static]

Definition at line 84 of file StdMeshers_ViscousLayers.hxx.

{ return "ViscousLayers"; }
std::vector<int> STDMESHERS_EXPORT::GetIgnoreFaces ( ) const [inline]

Definition at line 44 of file StdMeshers_ViscousLayers.hxx.

{ return _ignoreFaceIds; }
int STDMESHERS_EXPORT::GetIndexOnLayer ( const int  aID) [protected]
SMESH_Hypothesis* STDMESHERS_EXPORT::GetLayerDistribution ( ) const [inline]

Returns 1D hypothesis specifying distribution of layers.

Return values:
SMESH::SMESH_Hypothesis_ptr- 1D hypothesis

Definition at line 69 of file StdMeshers_LayerDistribution.hxx.

{ return myHyp; }
bool STDMESHERS_EXPORT::GetLayersTransformation ( std::vector< gp_Trsf > &  trsf) const

Return transformations to get coordinates of nodes of each internal layer by nodes of the bottom.

Layer is a set of nodes at a certain step from bottom to top.

double STDMESHERS_EXPORT::GetLength ( ) const
double STDMESHERS_EXPORT::GetLength ( bool  isStartLength) const
double STDMESHERS_EXPORT::GetLength ( ) const
double STDMESHERS_EXPORT::GetLength ( ) const
double STDMESHERS_EXPORT::GetLength ( bool  isStartLength) const
double STDMESHERS_EXPORT::GetLength ( const SMESH_Mesh *  aMesh,
const TopoDS_Shape &  anEdge 
) throw (SALOME_Exception)

Computes segment for a given edge.

double STDMESHERS_EXPORT::GetLength ( const SMESH_Mesh *  aMesh,
const double  edgeLength 
) throw (SALOME_Exception)

Computes segment length for an edge of given length.

static void STDMESHERS_EXPORT::getMaps ( const SMESH_Mesh *  srcMesh,
SMESH_Mesh *  tgtMesh,
TNodeNodeMap *&  n2n,
TElemElemMap *&  e2e 
) [static]
SMESH_Mesh* STDMESHERS_EXPORT::GetMesh ( ) const [inline]

Return mesh.

Definition at line 123 of file StdMeshers_FaceSide.hxx.

{ return myMesh; }
SMESH_Mesh* STDMESHERS_EXPORT::GetMesh ( ) const [inline, protected]

Definition at line 253 of file StdMeshers_Penta_3D.hxx.

                               {
      return (SMESH_Mesh*)myMesh;
    }
static std::string STDMESHERS_EXPORT::GetName ( ) [static]
const std::vector<int>& STDMESHERS_EXPORT::GetNbSegments ( ) const [inline]

Definition at line 52 of file StdMeshers_FixedPoints1D.hxx.

{ return _nbsegs; }
const TNodeColumn* STDMESHERS_EXPORT::GetNodeColumn ( const SMDS_MeshNode *  node) const

Return pointer to column of nodes.

Parameters:
node- bottom node from which the returned column goes up
Return values:
constTNodeColumn* - the found column
int STDMESHERS_EXPORT::GetNumberLayers ( ) const [inline]

Definition at line 52 of file StdMeshers_ViscousLayers.hxx.

{ return _nbLayers; }

Get the number of segments.

const char* STDMESHERS_EXPORT::GetObjectEntry ( ) [inline]

Definition at line 52 of file StdMeshers_QuadrangleParams.hxx.

{ return _objEntry.c_str(); }
const char* STDMESHERS_EXPORT::GetObjectEntry ( ) [inline]

Definition at line 53 of file StdMeshers_StartEndLength.hxx.

{ return _objEntry.c_str(); }
const char* STDMESHERS_EXPORT::GetObjectEntry ( ) [inline]

Definition at line 55 of file StdMeshers_Arithmetic1D.hxx.

{ return _objEntry.c_str(); }
const char* STDMESHERS_EXPORT::GetObjectEntry ( ) [inline]

Definition at line 58 of file StdMeshers_FixedPoints1D.hxx.

{ return _objEntry.c_str(); }
const char* STDMESHERS_EXPORT::GetObjectEntry ( ) [inline]

Definition at line 178 of file StdMeshers_NumberOfSegments.hxx.

{ return _objEntry.c_str(); }
std::vector<const SMDS_MeshNode*> STDMESHERS_EXPORT::GetOrderedNodes ( ) const

Return nodes in the order they encounter while walking along the side.

For a closed side, the 1st point repeats at end

const TParam2ColumnMap* STDMESHERS_EXPORT::GetParam2ColumnMap ( const int  baseEdgeID,
bool &  isReverse 
) const [inline]

Return TParam2ColumnMap for a base edge.

Parameters:
baseEdgeID- base edge SMESHDS Index
isReverse- columns in-block orientation
Return values:
constTParam2ColumnMap* - map

Definition at line 153 of file StdMeshers_Prism_3D.hxx.

  {
    std::map< int, std::pair< TParam2ColumnMap*, bool > >::const_iterator i_mo =
      myShapeIndex2ColumnMap.find( baseEdgeID );
    if ( i_mo == myShapeIndex2ColumnMap.end() ) return 0;

    const std::pair< TParam2ColumnMap*, bool >& col_frw = i_mo->second;
    isReverse = !col_frw.second;
    return col_frw.first;
  }
const std::vector<double>& STDMESHERS_EXPORT::GetPoints ( ) const [inline]

Definition at line 50 of file StdMeshers_FixedPoints1D.hxx.

{ return _params; }
double STDMESHERS_EXPORT::GetPreestimatedLength ( ) const [inline]

Definition at line 42 of file StdMeshers_MaxLength.hxx.

{ return _preestimated; }
static TopoDS_Edge STDMESHERS_EXPORT::GetPropagationSource ( SMESH_Mesh &  theMesh,
const TopoDS_Shape &  theEdge 
) [static]

Return an edge from which hypotheses are propagated.

Parameters:
theMesh- mesh
theEdge- edge to which hypotheses are propagated
Return values:
TopoDS_Edge- source edge, also passing orientation

Definition at line 55 of file StdMeshers_QuadrangleParams.hxx.

{ return _quadType; }
std::vector<SMESH_Group*>* STDMESHERS_EXPORT::GetResultGroups ( const SMESHDS_Mesh &  srcMesh,
const SMESHDS_Mesh &  tgtMesh 
)
const std::vector<int>& STDMESHERS_EXPORT::GetReversedEdges ( ) const [inline]

Definition at line 49 of file StdMeshers_StartEndLength.hxx.

{ return _edgeIDs; }
const std::vector<int>& STDMESHERS_EXPORT::GetReversedEdges ( ) const [inline]

Definition at line 57 of file StdMeshers_Arithmetic1D.hxx.

{ return _edgeIDs; }
const std::vector<int>& STDMESHERS_EXPORT::GetReversedEdges ( ) const [inline]

Definition at line 60 of file StdMeshers_FixedPoints1D.hxx.

{ return _edgeIDs; }
const std::vector<int>& STDMESHERS_EXPORT::GetReversedEdges ( ) const [inline]

Definition at line 180 of file StdMeshers_NumberOfSegments.hxx.

{ return _edgeIDs; }
double STDMESHERS_EXPORT::GetScaleFactor ( ) const throw (SALOME_Exception)

Get scale factor for scale distribution.

Throws SALOME_Exception if distribution type is not DT_Scale

Return size threshold.

TopoDS_Shape STDMESHERS_EXPORT::GetSource3DShape ( ) const

Returns the source shape.

TopoDS_Shape STDMESHERS_EXPORT::GetSourceEdge ( ) const [inline]

Returns the source edge or a group containing edges.

Definition at line 65 of file StdMeshers_ProjectionSource1D.hxx.

{ return _sourceEdge; }
TopoDS_Shape STDMESHERS_EXPORT::GetSourceFace ( ) const

Returns the source face or a group containing faces.

SMESH_Mesh* STDMESHERS_EXPORT::GetSourceMesh ( ) const [inline]

Return source mesh.

Definition at line 75 of file StdMeshers_ProjectionSource3D.hxx.

{ return _sourceMesh; }
SMESH_Mesh* STDMESHERS_EXPORT::GetSourceMesh ( ) const [inline]

Return source mesh.

Definition at line 81 of file StdMeshers_ProjectionSource1D.hxx.

{ return _sourceMesh; }
SMESH_Mesh* STDMESHERS_EXPORT::GetSourceMesh ( ) const [inline]

Return source mesh.

Definition at line 81 of file StdMeshers_ProjectionSource2D.hxx.

{ return _sourceMesh; }
std::vector<SMESH_Mesh*> STDMESHERS_EXPORT::GetSourceMeshes ( ) const
std::vector<SMESH_subMesh*> STDMESHERS_EXPORT::GetSourceSubMeshes ( const SMESH_Mesh *  srcMesh) const
TopoDS_Vertex STDMESHERS_EXPORT::GetSourceVertex ( int  i) const throw ( SALOME_Exception )

Returns the -th source vertex associated with the -th target vertex.

Result may be nil if association not set.

TopoDS_Vertex STDMESHERS_EXPORT::GetSourceVertex ( ) const [inline]

Returns the vertex associated with the target vertex.

Result may be nil if association not set

Definition at line 95 of file StdMeshers_ProjectionSource1D.hxx.

{ return _sourceVertex; }
TopoDS_Vertex STDMESHERS_EXPORT::GetSourceVertex ( int  i) const throw ( SALOME_Exception )

Returns the -th source vertex associated with the -th target vertex.

Result may be nil if association not set. Valid indices are 1 and 2

void STDMESHERS_EXPORT::GetStoreParams ( TopoDS_Shape &  s1,
TopoDS_Shape &  s2,
TopoDS_Shape &  s3 
) const

Return all parameters.

void STDMESHERS_EXPORT::GetStoreParams ( TopoDS_Shape &  s1,
TopoDS_Shape &  s2,
TopoDS_Shape &  s3,
TopoDS_Shape &  s4,
TopoDS_Shape &  s5 
) const

Return all parameters.

void STDMESHERS_EXPORT::GetStoreParams ( TopoDS_Shape &  s1,
TopoDS_Shape &  s2,
TopoDS_Shape &  s3,
TopoDS_Shape &  s4,
TopoDS_Shape &  s5 
) const

Return all parameters.

double STDMESHERS_EXPORT::GetStretchFactor ( ) const [inline]

Definition at line 56 of file StdMeshers_ViscousLayers.hxx.

{ return _stretchFactor; }
static SMESH_subMesh* STDMESHERS_EXPORT::getSubMeshOfCopiedMesh ( SMESH_Mesh &  tgtMesh,
SMESH_Mesh &  srcMesh 
) [static]
const std::vector<double>& STDMESHERS_EXPORT::GetTableFunction ( ) const throw (SALOME_Exception)

Get table function for distribution DT_TabFunc.

Throws SALOME_Exception if distribution type is not DT_TabFunc

TopoDS_Vertex STDMESHERS_EXPORT::GetTargetVertex ( int  i) const throw ( SALOME_Exception )

Returns the -th target vertex associated with the -th source vertex.

Result may be nil if association not set.

TopoDS_Vertex STDMESHERS_EXPORT::GetTargetVertex ( ) const [inline]

Returns the vertex associated with the source vertex.

Result may be nil if association not set

Definition at line 101 of file StdMeshers_ProjectionSource1D.hxx.

{ return _targetVertex; }
TopoDS_Vertex STDMESHERS_EXPORT::GetTargetVertex ( int  i) const throw ( SALOME_Exception )

Returns the -th target vertex associated with the -th source vertex.

Result may be nil if association not set. Valid indices are 1 and 2

double STDMESHERS_EXPORT::GetTotalThickness ( ) const [inline]

Definition at line 48 of file StdMeshers_ViscousLayers.hxx.

{ return _thickness; }
int STDMESHERS_EXPORT::GetTriaVertex ( ) const [inline]

Definition at line 49 of file StdMeshers_QuadrangleParams.hxx.

{ return _triaVertexID; }
virtual const std::list<const SMESHDS_Hypothesis *>& STDMESHERS_EXPORT::GetUsedHypothesis ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
const bool  = true 
) [virtual]
const std::vector<UVPtStruct>& STDMESHERS_EXPORT::GetUVPtStruct ( bool  isXConst = 0,
double  constValue = 0 
) const

Return detailed data on nodes.

Parameters:
isXConst- true if normalized parameter X is constant
constValue- constant parameter value

Missing nodes are allowed only on internal vertices. For a closed side, the 1st point repeats at end

static const StdMeshers_SegmentLengthAroundVertex* STDMESHERS_EXPORT::getVertexHyp ( SMESH_Mesh &  theMesh,
const TopoDS_Vertex &  theV 
) [static, protected]

Return StdMeshers_SegmentLengthAroundVertex assigned to vertex.

bool STDMESHERS_EXPORT::GetWallFaces ( SMESH_Mesh *  mesh,
const TopoDS_Shape &  mainShape,
const TopoDS_Shape &  bottomFace,
std::list< TopoDS_Edge > &  bottomEdges,
std::list< int > &  nbEInW,
std::list< TopoDS_Face > &  wallFaces 
)

Find wall faces by bottom edges.

Parameters:
mesh- the mesh
mainShape- the prism
bottomFace- the bottom face
bottomEdges- edges bounding the bottom face
wallFaces- faces list to fill in
STDMESHERS_EXPORT::Handle ( ExprIntrp_GenExp  ) [private]
bool STDMESHERS_EXPORT::HasNotQuadElemOnTop ( ) const [inline]

Definition at line 138 of file StdMeshers_Prism_3D.hxx.

{ return myNotQuadOnTop; }
bool STDMESHERS_EXPORT::HasVertexAssociation ( ) const [inline]

Test if vertex association defined.

Return values:
bool- test result

Definition at line 104 of file StdMeshers_ProjectionSource3D.hxx.

  { return ( !_sourceVertex1.IsNull() && !_targetVertex1.IsNull() &&
             !_sourceVertex2.IsNull() && !_targetVertex2.IsNull()); }
bool STDMESHERS_EXPORT::HasVertexAssociation ( ) const [inline]

Test if vertex association defined.

Return values:
bool- test result

Definition at line 107 of file StdMeshers_ProjectionSource1D.hxx.

  { return ( !_sourceVertex.IsNull() && !_targetVertex.IsNull() ); }
bool STDMESHERS_EXPORT::HasVertexAssociation ( ) const [inline]

Test if vertex association defined.

Return values:
bool- test result

Definition at line 112 of file StdMeshers_ProjectionSource2D.hxx.

  { return ( !_sourceVertex1.IsNull() && !_targetVertex1.IsNull() &&
             !_sourceVertex2.IsNull() && !_targetVertex2.IsNull()); }

Definition at line 41 of file StdMeshers_MaxLength.hxx.

{ return _preestimated > 0.; }
static void STDMESHERS_EXPORT::importMesh ( const SMESH_Mesh *  srcMesh,
SMESH_Mesh &  tgtMesh,
StdMeshers_ImportSource1D srcHyp,
const TopoDS_Shape &  tgtShape 
) [static]
bool STDMESHERS_EXPORT::Init ( SMESH_MesherHelper *  helper,
const TopoDS_Shape &  shape3D 
)

Initialization.

Parameters:
helper- helper loaded with mesh and 3D shape
shape3D- a closed shell or solid
Return values:
bool- false if a mesh or a shape are KO

Analyse shape geometry and mesh. If there are triangles on one of faces, it becomes 'bottom'

virtual double STDMESHERS_EXPORT::integral ( const double  ,
const double   
) const [pure virtual]
virtual double STDMESHERS_EXPORT::integral ( const double  ,
const double   
) const [virtual]
virtual double STDMESHERS_EXPORT::integral ( const double  ,
const double   
) const [virtual]
double STDMESHERS_EXPORT::integral ( const int  i) const [private]
double STDMESHERS_EXPORT::integral ( const int  i,
const double  d 
) const [private]
virtual double STDMESHERS_EXPORT::integral ( const double  ,
const double   
) const [virtual]
bool STDMESHERS_EXPORT::IsCompoundSource ( ) const [inline]

Returns true the source edge is a group of edges.

Definition at line 70 of file StdMeshers_ProjectionSource1D.hxx.

  { return !_sourceEdge.IsNull() && _sourceEdge.ShapeType() == TopAbs_COMPOUND; }
bool STDMESHERS_EXPORT::IsCompoundSource ( ) const [inline]

Returns true the source face is a group of faces.

Definition at line 70 of file StdMeshers_ProjectionSource2D.hxx.

  { return !_sourceFace.IsNull() && _sourceFace.ShapeType() == TopAbs_COMPOUND; }

Return true if parameters are well defined.

bool STDMESHERS_EXPORT::IsForwadEdge ( const int  theEdgeID)
static bool STDMESHERS_EXPORT::IsForwardEdge ( SMESHDS_Mesh *  meshDS,
const TParam2ColumnMap columnsMap,
const TopoDS_Edge &  bottomEdge,
const int  sideFaceID 
) [static]

Check curve orientation of a bootom edge.

Parameters:
meshDS- mesh DS
columnsMap- node columns map of side face
bottomEdge- the bootom edge
sideFaceID- side face in-block ID
Return values:
bool- true if orienation coinside with in-block froward orienation
bool STDMESHERS_EXPORT::IsGridBySpacing ( const int  axis) const throw ( SALOME_Exception )
double STDMESHERS_EXPORT::LastParameter ( int  i) const [inline]

Return ast normalized parameter of the i-the edge (count starts from zero)

TopoDS_Vertex STDMESHERS_EXPORT::LastVertex ( int  i = -1) const

Return last vertex of the i-the edge (count starts from zero)

double STDMESHERS_EXPORT::Length ( ) const [inline]

Return side length.

Definition at line 197 of file StdMeshers_FaceSide.hxx.

{ return myLength; }
void STDMESHERS_EXPORT::Load ( const TopoDS_Shell &  theShell)
void STDMESHERS_EXPORT::Load ( const TopoDS_Shell &  theShell,
const TopoDS_Vertex &  theV000,
const TopoDS_Vertex &  theV001 
)
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
virtual std::istream& STDMESHERS_EXPORT::LoadFrom ( std::istream &  load) [virtual]
bool STDMESHERS_EXPORT::LoadIJNodes ( StdMeshers_IJNodeMap theIJNodes,
const TopoDS_Face &  theFace,
const TopoDS_Edge &  theBaseEdge,
SMESHDS_Mesh *  theMesh 
)
bool STDMESHERS_EXPORT::LoadPoints ( TWireVector wires,
R2 uvslf,
std::vector< const SMDS_MeshNode * > &  mefistoToDS,
double  scalex,
double  scaley 
)
void STDMESHERS_EXPORT::MakeBlock ( ) [protected]
void STDMESHERS_EXPORT::MakeMeshOnFxy1 ( ) [protected]
TNodeColumn* STDMESHERS_EXPORT::makeNodeColumn ( TNode2ColumnMap n2ColMap,
const SMDS_MeshNode *  outNode,
const SMDS_MeshNode *  inNode 
) [protected]
void STDMESHERS_EXPORT::MakeNodes ( ) [protected]
void STDMESHERS_EXPORT::MakeVolumeMesh ( ) [protected]
void STDMESHERS_EXPORT::MergeAdjacent ( const SMDS_MeshElement *  PrmI,
std::set< const SMDS_MeshNode * > &  nodesToMove 
) [protected]
void STDMESHERS_EXPORT::MergePiramids ( const SMDS_MeshElement *  PrmI,
const SMDS_MeshElement *  PrmJ,
std::set< const SMDS_MeshNode * > &  nodesToMove 
) [protected]
SMESH_Mesh* STDMESHERS_EXPORT::Mesh ( ) const [inline]

Return pointer to mesh.

Return values:
SMESH_Mesh- mesh

Definition at line 176 of file StdMeshers_Prism_3D.hxx.

{ return myHelper->GetMesh(); }

Here is the caller graph for this function:

SMESHDS_Mesh* STDMESHERS_EXPORT::MeshDS ( ) const [inline]

Return pointer to mesh DS.

Return values:
SMESHDS_Mesh- mesh DS

Definition at line 182 of file StdMeshers_Prism_3D.hxx.

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

Here is the call graph for this function:

bool STDMESHERS_EXPORT::MissVertexNode ( ) const [inline]

Return true if there are vertices without nodes.

Definition at line 127 of file StdMeshers_FaceSide.hxx.

int STDMESHERS_EXPORT::NbEdges ( ) const [inline]

Return nb of wrapped edges.

Definition at line 169 of file StdMeshers_FaceSide.hxx.

{ return myEdge.size(); }
int STDMESHERS_EXPORT::NbPoints ( ) const [inline]

Return nb nodes on edges and vertices (+1 to be == GetUVPtStruct().size() )

Definition at line 115 of file StdMeshers_FaceSide.hxx.

{ return myNbPonits; }
int STDMESHERS_EXPORT::NbSegments ( ) const [inline]

Return nb edges.

Definition at line 119 of file StdMeshers_FaceSide.hxx.

{ return myNbSegments; }
const SMDS_MeshNode* STDMESHERS_EXPORT::Node ( ) const [inline]

Definition at line 128 of file StdMeshers_Penta_3D.hxx.

                                   {
    return myNode;
  }
const gp_XYZ& STDMESHERS_EXPORT::NormCoord ( ) const [inline]

Definition at line 144 of file StdMeshers_Penta_3D.hxx.

                                 {
    return myXYZ;
  }
double STDMESHERS_EXPORT::Parameter ( double  U,
TopoDS_Edge &  edge 
) const [inline]

Return edge and parameter on edge by normalized parameter.

void STDMESHERS_EXPORT::Point ( const gp_XYZ &  theParams,
gp_Pnt &  thePnt 
)
void STDMESHERS_EXPORT::Point ( const gp_XYZ &  theParams,
const TopoDS_Shape &  theShape,
gp_Pnt &  thePnt 
)
int STDMESHERS_EXPORT::Preparation ( const SMDS_MeshElement *  face,
Handle_TColgp_HArray1OfPnt &  PN,
Handle_TColgp_HArray1OfVec &  VN,
std::vector< const SMDS_MeshNode * > &  FNodes,
gp_Pnt &  PC,
gp_Vec &  VNorm,
const SMDS_MeshElement **  volumes = 0 
) [protected]

Remove quadrangles from the top face and create triangles there by projection from the bottom.

Return values:
bool- a success or not

Enable removal of quadrangles from the bottom face and triangles creation there by projection from the top (sole face meshed with triangles is considered to be a bottom one).

If there are two faces with triangles, triangles must be of the same topology, else the algo fails. The method must be called before Compute()

Definition at line 415 of file StdMeshers_Prism_3D.hxx.

{ myProjectTriangles = true; }
virtual void STDMESHERS_EXPORT::redistributeNearVertices ( SMESH_Mesh &  theMesh,
Adaptor3d_Curve &  theC3d,
double  theLength,
std::list< double > &  theParameters,
const TopoDS_Vertex &  theVf,
const TopoDS_Vertex &  theVl 
) [protected, virtual]
void STDMESHERS_EXPORT::RestoreGroups ( const std::vector< SMESH_Group * > &  groups)
void STDMESHERS_EXPORT::RestoreParams ( const TopoDS_Shape &  s1,
const TopoDS_Shape &  s2,
const TopoDS_Shape &  s3,
SMESH_Mesh *  mesh 
)

Set all parameters without notifying on modification.

void STDMESHERS_EXPORT::RestoreParams ( const TopoDS_Shape &  s1,
const TopoDS_Shape &  s2,
const TopoDS_Shape &  s3,
const TopoDS_Shape &  s4,
const TopoDS_Shape &  s5,
SMESH_Mesh *  mesh 
)

Set all parameters without notifying on modification.

void STDMESHERS_EXPORT::RestoreParams ( const TopoDS_Shape &  s1,
const TopoDS_Shape &  s2,
const TopoDS_Shape &  s3,
const TopoDS_Shape &  s4,
const TopoDS_Shape &  s5,
SMESH_Mesh *  mesh 
)

Set all parameters without notifying on modification.

Change orientation of side geometry.

virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]

Persistence methods.

virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
virtual std::ostream& STDMESHERS_EXPORT::SaveTo ( std::ostream &  save) [virtual]
void STDMESHERS_EXPORT::SetBaseNodeID ( const int  theID) [inline]

Definition at line 148 of file StdMeshers_Penta_3D.hxx.

                                       {
    myBaseNodeID=theID;
  }
void STDMESHERS_EXPORT::SetConversionMode ( int  conv) throw (SALOME_Exception)

Set conversion mode.

When it is 0, it means "exponent mode": the function of distribution of density is used as an exponent of 10, i,e, 10^f(t). When it is 1, it means "cut negative mode". The function of distribution is used as F(t), where F(t0)=f(t0), if f(t0)>=0, otherwise F(t0) = 0. This mode is sensible only when function distribution is used (DT_TabFunc or DT_ExprFunc)

Throws SALOME_Exception if distribution type is not functional

void STDMESHERS_EXPORT::SetCopySourceMesh ( bool  toCopyMesh,
bool  toCopyGroups 
)
void STDMESHERS_EXPORT::SetDeflection ( double  value) throw (SALOME_Exception)
void STDMESHERS_EXPORT::SetDistrType ( DistrType  typ) throw (SALOME_Exception)

Set distribution type.

virtual void STDMESHERS_EXPORT::SetEventListener ( SMESH_subMesh *  whenSetToSubMesh) [virtual]

Sets a default event listener to submesh of the source face.

Parameters:
whenSetToSubMesh- submesh where algo is set

After being set, event listener is notified on each event of a submesh. This method is called when a submesh gets HYP_OK algo_state. Arranges that CLEAN event is translated from source submesh to the whenSetToSubMesh submesh.

virtual void STDMESHERS_EXPORT::SetEventListener ( SMESH_subMesh *  subMesh) [virtual]
virtual void STDMESHERS_EXPORT::SetEventListener ( SMESH_subMesh *  subMesh) [virtual]
virtual void STDMESHERS_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.

virtual void STDMESHERS_EXPORT::SetEventListener ( SMESH_subMesh *  subMesh) [virtual]
virtual void STDMESHERS_EXPORT::SetEventListener ( SMESH_subMesh *  whenSetToSubMesh) [virtual]

Sets a default event listener to submesh of the source shape.

Parameters:
whenSetToSubMesh- submesh where algo is set

Arranges that CLEAN event is translated from source submesh to the whenSetToSubMesh submesh.

virtual void STDMESHERS_EXPORT::SetEventListener ( SMESH_subMesh *  whenSetToSubMesh) [virtual]

Sets a default event listener to submesh of the source face.

Parameters:
whenSetToSubMesh- submesh where algo is set

After being set, event listener is notified on each event of a submesh. This method is called when a submesh gets HYP_OK algo_state. Arranges that CLEAN event is translated from source submesh to the whenSetToSubMesh submesh.

virtual void STDMESHERS_EXPORT::SetEventListener ( SMESH_subMesh *  whenSetToSubMesh) [virtual]

Sets a default event listener to submesh of the source edge.

Parameters:
whenSetToSubMesh- submesh where algo is set

After being set, event listener is notified on each event of a submesh. This method is called when a submesh gets HYP_OK algo_state. Arranges that CLEAN event is translated from source submesh to the whenSetToSubMesh submesh.

virtual void STDMESHERS_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.

static void STDMESHERS_EXPORT::setEventListener ( SMESH_subMesh *  subMesh,
StdMeshers_ImportSource1D sourceHyp 
) [static]
void STDMESHERS_EXPORT::SetExpressionFunction ( const char *  expr) throw (SALOME_Exception)

Set expression function for distribution DT_ExprFunc.

Parameters:
expr- string containing the expression of the function f(t), e.g. "sin(t)"

Throws SALOME_Exception if distribution type is not DT_ExprFunc

bool STDMESHERS_EXPORT::setFaceAndEdgesXYZ ( const int  faceID,
const gp_XYZ &  params,
int  z 
) [private]

Set projection coordinates of a node to a face and it's sub-shapes.

Parameters:
faceID- the face given by in-block ID
params- node normalized parameters
Return values:
bool- is a success
void STDMESHERS_EXPORT::SetFineness ( double  theFineness) throw (SALOME_Exception)

Set Fineness.

Parameters:
theFineness- The Fineness value [0.0-1.0], 0 - coarse mesh 1 - fine mesh

Raise if theFineness is out of range The "Initial Number of Elements on the Shortest Edge" (S0) is divided by (0.5 + 4.5 x theFineness)

void STDMESHERS_EXPORT::SetGrid ( std::vector< double > &  xNodes,
int  axis 
) throw ( SALOME_Exception )

Sets coordinates of node positions along an axis (countered from 0)

void STDMESHERS_EXPORT::SetGridSpacing ( std::vector< std::string > &  spaceFunctions,
std::vector< double > &  internalPoints,
const int  axis 
) throw ( SALOME_Exception )

Set grid spacing along the three axes.

Parameters:
spaceFunctions- functions defining spacing values at given point on axis
internalPoints- points dividing a grid into parts along each direction

Parameter t of spaceFunction f(t) is a position [0,1] withing bounding box of the shape to mesh

void STDMESHERS_EXPORT::SetGroups ( const std::vector< SMESH_Group * > &  groups)
double STDMESHERS_EXPORT::SetHorizEdgeXYZ ( const gp_XYZ &  aBNXYZ,
const int  aFaceID,
std::vector< const SMDS_MeshNode * > *&  aCol1,
std::vector< const SMDS_MeshNode * > *&  aCol2 
) [protected]
void STDMESHERS_EXPORT::SetIgnoreFaces ( const std::vector< int > &  faceIds)
void STDMESHERS_EXPORT::SetLayerDistribution ( SMESH_Hypothesis *  hyp1D) throw ( SALOME_Exception )

Sets 1D hypothesis specifying distribution of layers.

Parameters:
hyp1D- 1D hypothesis
void STDMESHERS_EXPORT::SetLength ( double  length) throw (SALOME_Exception)
void STDMESHERS_EXPORT::SetLength ( double  length) throw (SALOME_Exception)
void STDMESHERS_EXPORT::SetLength ( double  length,
bool  isStartLength 
) throw (SALOME_Exception)
void STDMESHERS_EXPORT::SetLength ( double  length) throw (SALOME_Exception)
void STDMESHERS_EXPORT::SetLength ( double  length,
bool  isStartLength 
) throw (SALOME_Exception)
void STDMESHERS_EXPORT::SetMaxArea ( double  maxArea) throw (SALOME_Exception)
void STDMESHERS_EXPORT::SetMaxVolume ( double  maxVolume) throw (SALOME_Exception)
void STDMESHERS_EXPORT::SetMesh ( SMESH_Mesh &  theMesh) [inline, protected]

Definition at line 249 of file StdMeshers_Penta_3D.hxx.

                                      {
      myMesh=(void *)&theMesh;
    }
void STDMESHERS_EXPORT::SetMode ( int  mode) throw (SALOME_Exception)
void STDMESHERS_EXPORT::SetNbSegments ( std::vector< int > &  listNbSeg) throw (SALOME_Exception)
void STDMESHERS_EXPORT::SetNode ( const SMDS_MeshNode *  theNode) [inline]

Definition at line 124 of file StdMeshers_Penta_3D.hxx.

                                             {
    myNode=(SMDS_MeshNode*) theNode;
  }
bool STDMESHERS_EXPORT::SetNormalizedGrid ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  aShape,
FaceQuadStruct *&  quad 
) [protected]
void STDMESHERS_EXPORT::SetNormCoord ( const gp_XYZ &  theXYZ) [inline]

Definition at line 140 of file StdMeshers_Penta_3D.hxx.

                                           {
    myXYZ=theXYZ;
  }
void STDMESHERS_EXPORT::SetNumberOfLayers ( int  numberOfLayers) throw ( SALOME_Exception )
void STDMESHERS_EXPORT::SetNumberOfSegments ( int  segmentsNumber) throw (SALOME_Exception)

Set the number of segments.

Parameters:
segmentsNumber- must be greater than zero
void STDMESHERS_EXPORT::SetObjectEntry ( const char *  entry) [inline]

Definition at line 51 of file StdMeshers_StartEndLength.hxx.

{ _objEntry = entry; }
void STDMESHERS_EXPORT::SetObjectEntry ( const char *  entry) [inline]

Definition at line 51 of file StdMeshers_QuadrangleParams.hxx.

{ _objEntry = entry; }
void STDMESHERS_EXPORT::SetObjectEntry ( const char *  entry) [inline]

Definition at line 53 of file StdMeshers_Arithmetic1D.hxx.

{ _objEntry = entry; }
void STDMESHERS_EXPORT::SetObjectEntry ( const char *  entry) [inline]

Definition at line 56 of file StdMeshers_FixedPoints1D.hxx.

{ _objEntry = entry; }
void STDMESHERS_EXPORT::SetObjectEntry ( const char *  entry) [inline]

Definition at line 176 of file StdMeshers_NumberOfSegments.hxx.

{ _objEntry = entry; }
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [inline, virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined

Definition at line 81 of file StdMeshers_ViscousLayers.hxx.

  { return false; }
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByDefaults ( const TDefaults &  dflts,
const SMESH_Mesh *  theMesh = 0 
) [virtual]

Initialize my parameter values by default parameters.

Return values:
bool- true if parameter values have been successfully defined
virtual bool STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [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

Just return false as this hypothesis does not have parameters values

virtual bool STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize deflection value 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 STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize segment length 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 STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize maximal area 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 STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [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

Just return false as this hypothesis does not have parameters values

virtual bool STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize maximal volume 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 STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize segment length 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 STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize segment length 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 STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [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

Just return false as this hypothesis does not have parameters values

virtual bool STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]
virtual bool STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [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

Just return false as this hypothesis does not have parameters values

virtual bool STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize start and end length 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 STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize start and end length 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 STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize start and end length 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 STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize start and end length 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 STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize parameters 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

Implementation does noting

virtual bool STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [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

Just return false as this hypothesis does not have parameters values

virtual bool STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [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

Just return false as this hypothesis does not have parameters values

virtual bool STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize parameters 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

Implementation does noting

virtual bool STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize Fineness 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 STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

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

virtual bool STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize parameters 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

Implementation does noting

virtual bool STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize parameters 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

Implementation does noting

virtual bool STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize parameters 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

Implementation does noting

virtual bool STDMESHERS_EXPORT::SetParametersByMesh ( const SMESH_Mesh *  theMesh,
const TopoDS_Shape &  theShape 
) [virtual]

Initialize number of segments 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
void STDMESHERS_EXPORT::SetPoints ( std::vector< double > &  listParams) throw (SALOME_Exception)
void STDMESHERS_EXPORT::SetPrecision ( double  precision) throw (SALOME_Exception)
static void STDMESHERS_EXPORT::SetPropagationMgr ( SMESH_subMesh *  subMesh) [static]

Set EventListener managing propagation of hypotheses.

Parameters:
subMesh- edge submesh to set event listener on

1D algo is expected to call this method from it's SetEventListener()

void STDMESHERS_EXPORT::SetReversedEdges ( std::vector< int > &  ids)
void STDMESHERS_EXPORT::SetReversedEdges ( std::vector< int > &  ids)
void STDMESHERS_EXPORT::SetReversedEdges ( std::vector< int > &  ids)
void STDMESHERS_EXPORT::SetReversedEdges ( std::vector< int > &  ids)
virtual void STDMESHERS_EXPORT::SetScaleFactor ( double  scaleFactor) throw (SALOME_Exception) [virtual]

Set scale factor for scale distribution.

Parameters:
scaleFactor- positive value different from 1

Throws SALOME_Exception if distribution type is not DT_Scale, or scaleFactor is not a positive value different from 1

void STDMESHERS_EXPORT::SetShapeSupportID ( const int  theID) [inline]

Definition at line 132 of file StdMeshers_Penta_3D.hxx.

                                           {
    myShapeSupportID=theID;
  }
void STDMESHERS_EXPORT::SetSizeThreshold ( const double  threshold) throw ( SALOME_Exception )

Set size threshold.

A polyhedral cell got by cutting an initial hexahedron by geometry boundary is considered small and is removed if it's size is times less than the size of the initial hexahedron.

void STDMESHERS_EXPORT::SetSource3DShape ( const TopoDS_Shape &  shape) throw ( SALOME_Exception )

Sets a source <shape> to take a mesh pattern from.

void STDMESHERS_EXPORT::SetSourceEdge ( const TopoDS_Shape &  edge) throw ( SALOME_Exception )

Sets source <edge> to take a mesh pattern from.

void STDMESHERS_EXPORT::SetSourceFace ( const TopoDS_Shape &  face) throw ( SALOME_Exception )

Sets a source <face> to take a mesh pattern from.

void STDMESHERS_EXPORT::SetSourceMesh ( SMESH_Mesh *  mesh)

Sets source <mesh> to take a mesh pattern from.

void STDMESHERS_EXPORT::SetSourceMesh ( SMESH_Mesh *  mesh)

Sets source <mesh> to take a mesh pattern from.

void STDMESHERS_EXPORT::SetSourceMesh ( SMESH_Mesh *  mesh)

Sets source <mesh> to take a mesh pattern from.

void STDMESHERS_EXPORT::SetStretchFactor ( double  factor)
void STDMESHERS_EXPORT::setSubmeshesComputed ( SMESH_Mesh &  aMesh,
const TopoDS_Shape &  theShape 
) [private]
void STDMESHERS_EXPORT::SetTableFunction ( const std::vector< double > &  table) throw (SALOME_Exception)

Set table function for distribution DT_TabFunc.

Parameters:
table- this vector contains the pairs (parameter, value) following each by other, so the number of elements in the vector must be even. The parameters must be in range [0,1] and sorted in increase order. The values of function must be positive.

Throws SALOME_Exception if distribution type is not DT_TabFunc

void STDMESHERS_EXPORT::SetTolerance ( const double  theTol3D) [inline]

Definition at line 190 of file StdMeshers_Penta_3D.hxx.

                                             {
      myTol3D=theTol3D;
    }
void STDMESHERS_EXPORT::SetTotalThickness ( double  thickness)
void STDMESHERS_EXPORT::SetVertexAssociation ( const TopoDS_Shape &  sourceVertex1,
const TopoDS_Shape &  sourceVertex2,
const TopoDS_Shape &  targetVertex1,
const TopoDS_Shape &  targetVertex2 
) throw ( SALOME_Exception )

Sets vertex association between the source shape and the target one.

This parameter is optional. Two vertices must belong to one edge of a shape

void STDMESHERS_EXPORT::SetVertexAssociation ( const TopoDS_Shape &  sourceVertex,
const TopoDS_Shape &  targetVertex 
) throw ( SALOME_Exception )

Sets vertex association between the source edge and the target one.

This parameter is optional

void STDMESHERS_EXPORT::SetVertexAssociation ( const TopoDS_Shape &  sourceVertex1,
const TopoDS_Shape &  sourceVertex2,
const TopoDS_Shape &  targetVertex1,
const TopoDS_Shape &  targetVertex2 
) throw ( SALOME_Exception )

Sets vertex association between the source face and the target one.

This parameter is optional. Two vertices must belong to one edge of a face

const TopoDS_Shape& STDMESHERS_EXPORT::Shape ( const int  theID)

Here is the caller graph for this function:

const TopoDS_Shape& STDMESHERS_EXPORT::Shape ( const int  shapeID) const [inline]

Return a in-block shape.

Parameters:
shapeID- shape given by in-block index
Return values:
SMESHDS_SubMesh*- found submesh

Definition at line 205 of file StdMeshers_Prism_3D.hxx.

  { return myShapeIDMap( shapeID ); }
int STDMESHERS_EXPORT::ShapeID ( const TopoDS_Shape &  theShape)
int STDMESHERS_EXPORT::ShapeID ( const TopoDS_Shape &  shape) const [inline]

Return in-block ID of a shape.

Parameters:
shape- block sub-shape
Return values:
int- ID or zero if the shape has no ID

Definition at line 213 of file StdMeshers_Prism_3D.hxx.

  { return myShapeIDMap.FindIndex( shape ); }
int STDMESHERS_EXPORT::ShapeSupportID ( ) const [inline]

Definition at line 136 of file StdMeshers_Penta_3D.hxx.

                            {
    return myShapeSupportID;
  }
void STDMESHERS_EXPORT::ShapeSupportID ( const bool  theIsUpperLayer,
const SMESH_Block::TShapeID  theBNSSID,
SMESH_Block::TShapeID &  theSSID 
) [protected]
const std::vector<UVPtStruct>& STDMESHERS_EXPORT::SimulateUVPtStruct ( int  nbSeg,
bool  isXConst = 0,
double  constValue = 0 
) const

Simulates detailed data on nodes.

Parameters:
isXConst- true if normalized parameter X is constant
constValue- constant parameter value
void STDMESHERS_EXPORT::Smooth ( FaceQuadStruct quad) [protected]
void STDMESHERS_EXPORT::SplitQuad ( SMESHDS_Mesh *  theMeshDS,
const int  theFaceID,
const SMDS_MeshNode *  theNode1,
const SMDS_MeshNode *  theNode2,
const SMDS_MeshNode *  theNode3,
const SMDS_MeshNode *  theNode4 
) [protected]
STDMESHERS_EXPORT::StdMeshers_Arithmetic1D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_AutomaticLength ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_Cartesian_3D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_CartesianParameters3D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_CompositeHexa_3D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_CompositeSegment_1D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_Deflection1D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_FaceSide ( const TopoDS_Face &  theFace,
const TopoDS_Edge &  theEdge,
SMESH_Mesh *  theMesh,
const bool  theIsForward,
const bool  theIgnoreMediumNodes 
)

Wrap one edge.

STDMESHERS_EXPORT::StdMeshers_FaceSide ( const TopoDS_Face &  theFace,
std::list< TopoDS_Edge > &  theEdges,
SMESH_Mesh *  theMesh,
const bool  theIsForward,
const bool  theIgnoreMediumNodes 
)

Wrap several edges.

Edges must be properly ordered and oriented.

STDMESHERS_EXPORT::StdMeshers_FaceSide ( const SMDS_MeshNode *  theNode,
const gp_Pnt2d  thePnt2d,
const StdMeshers_FaceSide theSide 
)

Simulate a side from a vertex using data from other FaceSide.

STDMESHERS_EXPORT::StdMeshers_FixedPoints1D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_Hexa_3D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_HexaFromSkin_3D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_Import_1D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_Import_1D2D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_ImportSource1D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_ImportSource2D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_LayerDistribution ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_LayerDistribution2D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_LengthFromEdges ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_LocalLength ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_MaxElementArea ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_MaxElementVolume ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_MaxLength ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_MEFISTO_2D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_NotConformAllowed ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_NumberOfLayers ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_NumberOfLayers2D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_NumberOfSegments ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_Prism_3D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)

Constructor.

Initialization is needed

STDMESHERS_EXPORT::StdMeshers_Projection_1D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_Projection_1D2D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_Projection_2D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_Projection_3D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_ProjectionSource1D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_ProjectionSource2D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_ProjectionSource3D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_Propagation ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_Quadrangle_2D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_QuadrangleParams ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_QuadranglePreference ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_QuadraticMesh ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_RadialPrism_3D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_RadialQuadrangle_1D2D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_Regular_1D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_SegmentAroundVertex_0D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_SegmentLengthAroundVertex ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_StartEndLength ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)

Definition at line 117 of file StdMeshers_Penta_3D.hxx.

                    {
    myNode=NULL;
    myXYZ.SetCoord(99., 99., 99.);
    myShapeSupportID=-1;
    myBaseNodeID=-1;
  }
STDMESHERS_EXPORT::StdMeshers_UseExisting_1D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_UseExisting_2D ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
STDMESHERS_EXPORT::StdMeshers_ViscousLayers ( int  hypId,
int  studyId,
SMESH_Gen *  gen 
)
void STDMESHERS_EXPORT::StoreResult ( Z  nbst,
R2 uvst,
Z  nbt,
Z nust,
std::vector< const SMDS_MeshNode * > &  mefistoToDS,
double  scalex,
double  scaley 
)
void STDMESHERS_EXPORT::StoreResultGroups ( const std::vector< SMESH_Group * > &  groups,
const SMESHDS_Mesh &  srcMesh,
const SMESHDS_Mesh &  tgtMesh 
)
SMESH_subMesh* STDMESHERS_EXPORT::SubMesh ( const int  shapeID) const [inline]

Return submesh of a shape.

Parameters:
shapeID- shape given by in-block index
Return values:
SMESH_subMesh*- found submesh

Definition at line 189 of file StdMeshers_Prism_3D.hxx.

  { return Mesh()->GetSubMesh( Shape( shapeID )); }

Here is the call graph for this function:

Here is the caller graph for this function:

SMESHDS_SubMesh* STDMESHERS_EXPORT::SubMeshDS ( const int  shapeID) const [inline]

Return submesh DS of a shape.

Parameters:
shapeID- shape given by in-block index
Return values:
SMESHDS_SubMesh*- found submesh DS

Definition at line 197 of file StdMeshers_Prism_3D.hxx.

  { return SubMesh(shapeID)->GetSubMeshDS(); }

Here is the call graph for this function:

virtual void STDMESHERS_EXPORT::SubmeshRestored ( SMESH_subMesh *  subMesh) [virtual]
virtual void STDMESHERS_EXPORT::SubmeshRestored ( SMESH_subMesh *  subMesh) [virtual]
virtual void STDMESHERS_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.

void STDMESHERS_EXPORT::SubmeshRestored ( SMESH_subMesh *  subMesh)

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.

double STDMESHERS_EXPORT::Tolerance ( ) const [inline]

Definition at line 194 of file StdMeshers_Penta_3D.hxx.

                             {
      return myTol3D;
    }
void STDMESHERS_EXPORT::UpdateDegenUV ( FaceQuadStruct quad) [protected]
virtual bool STDMESHERS_EXPORT::value ( const double  ,
double &   
) const [virtual]
virtual bool STDMESHERS_EXPORT::value ( const double  ,
double &   
) const [virtual]
virtual bool STDMESHERS_EXPORT::value ( const double  ,
double &   
) const [virtual]
virtual Standard_Boolean STDMESHERS_EXPORT::Value ( const Standard_Real  ,
Standard_Real &   
) [virtual]
virtual bool STDMESHERS_EXPORT::value ( const double  ,
double &   
) const [virtual]
gp_Pnt2d STDMESHERS_EXPORT::Value2d ( double  U) const

Return UV by normalized parameter.

int STDMESHERS_EXPORT::VerticalSize ( ) const [inline]

Return number of nodes on every vertical edge.

Return values:
int- number of nodes including end nodes

Definition at line 136 of file StdMeshers_Prism_3D.hxx.

{ return myParam2ColumnMaps[0].begin()->second.size(); }

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  save,
StdMeshers_NotConformAllowed hyp 
) [friend]

Definition at line 84 of file StdMeshers_NotConformAllowed.cxx.

{
  return save;
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_Deflection1D hyp 
) [friend]

Definition at line 134 of file StdMeshers_Deflection1D.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_MaxElementArea hyp 
) [friend]

Definition at line 131 of file StdMeshers_MaxElementArea.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_LengthFromEdges hyp 
) [friend]

Definition at line 123 of file StdMeshers_LengthFromEdges.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_QuadraticMesh hyp 
) [friend]

Definition at line 85 of file StdMeshers_QuadraticMesh.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_MaxElementVolume hyp 
) [friend]

Definition at line 133 of file StdMeshers_MaxElementVolume.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_LocalLength hyp 
) [friend]

Definition at line 176 of file StdMeshers_LocalLength.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_SegmentLengthAroundVertex hyp 
) [friend]

Definition at line 134 of file StdMeshers_SegmentLengthAroundVertex.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_Propagation hyp 
) [friend]

Definition at line 97 of file StdMeshers_Propagation.cxx.

{ return hyp.SaveTo(save); }
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_StartEndLength hyp 
) [friend]

Definition at line 176 of file StdMeshers_StartEndLength.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_QuadrangleParams hyp 
) [friend]

Definition at line 133 of file StdMeshers_QuadrangleParams.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_Arithmetic1D hyp 
) [friend]

Definition at line 174 of file StdMeshers_Arithmetic1D.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_NumberOfLayers hyp 
) [friend]

Definition at line 133 of file StdMeshers_NumberOfLayers.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_FixedPoints1D hyp 
) [friend]

Definition at line 194 of file StdMeshers_FixedPoints1D.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_LayerDistribution hyp 
) [friend]

Definition at line 118 of file StdMeshers_LayerDistribution.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_AutomaticLength hyp 
) [friend]

Definition at line 290 of file StdMeshers_AutomaticLength.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_ProjectionSource1D hyp 
) [friend]

Definition at line 170 of file StdMeshers_ProjectionSource1D.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_ProjectionSource3D hyp 
) [friend]

Definition at line 230 of file StdMeshers_ProjectionSource3D.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_ProjectionSource2D hyp 
) [friend]

Definition at line 241 of file StdMeshers_ProjectionSource2D.cxx.

{
  return hyp.SaveTo( save );
}
std::ostream& operator<< ( std::ostream &  save,
StdMeshers_NumberOfSegments hyp 
) [friend]

Definition at line 670 of file StdMeshers_NumberOfSegments.cxx.

{
  return hyp.SaveTo( save );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_NotConformAllowed hyp 
) [friend]

Definition at line 95 of file StdMeshers_NotConformAllowed.cxx.

{
  return load;
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_Deflection1D hyp 
) [friend]

Definition at line 145 of file StdMeshers_Deflection1D.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_MaxElementArea hyp 
) [friend]

Definition at line 142 of file StdMeshers_MaxElementArea.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_LocalLength hyp 
) [friend]

Definition at line 187 of file StdMeshers_LocalLength.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_QuadraticMesh hyp 
) [friend]

Definition at line 96 of file StdMeshers_QuadraticMesh.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_LengthFromEdges hyp 
) [friend]

Definition at line 134 of file StdMeshers_LengthFromEdges.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_MaxElementVolume hyp 
) [friend]

Definition at line 144 of file StdMeshers_MaxElementVolume.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_SegmentLengthAroundVertex hyp 
) [friend]

Definition at line 145 of file StdMeshers_SegmentLengthAroundVertex.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_Propagation hyp 
) [friend]

Definition at line 98 of file StdMeshers_Propagation.cxx.

{ return hyp.LoadFrom(load); }
std::istream& operator>> ( std::istream &  load,
StdMeshers_StartEndLength hyp 
) [friend]

Definition at line 187 of file StdMeshers_StartEndLength.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_Arithmetic1D hyp 
) [friend]

Definition at line 185 of file StdMeshers_Arithmetic1D.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_QuadrangleParams hyp 
) [friend]

Definition at line 143 of file StdMeshers_QuadrangleParams.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_FixedPoints1D hyp 
) [friend]

Definition at line 205 of file StdMeshers_FixedPoints1D.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_NumberOfLayers hyp 
) [friend]

Definition at line 144 of file StdMeshers_NumberOfLayers.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_LayerDistribution hyp 
) [friend]

Definition at line 129 of file StdMeshers_LayerDistribution.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_AutomaticLength hyp 
) [friend]

Definition at line 301 of file StdMeshers_AutomaticLength.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_ProjectionSource1D hyp 
) [friend]

Definition at line 181 of file StdMeshers_ProjectionSource1D.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_ProjectionSource3D hyp 
) [friend]

Definition at line 241 of file StdMeshers_ProjectionSource3D.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_ProjectionSource2D hyp 
) [friend]

Definition at line 252 of file StdMeshers_ProjectionSource2D.cxx.

{
  return hyp.LoadFrom( load );
}
std::istream& operator>> ( std::istream &  load,
StdMeshers_NumberOfSegments hyp 
) [friend]

Definition at line 681 of file StdMeshers_NumberOfSegments.cxx.

{
  return hyp.LoadFrom( load );
}

Member Data Documentation

double STDMESHERS_EXPORT::_begLength [protected]

Definition at line 79 of file StdMeshers_Arithmetic1D.hxx.

flag of conversion mode: 0=exponent, 1=cut negative

Definition at line 207 of file StdMeshers_NumberOfSegments.hxx.

std::vector<double> STDMESHERS_EXPORT::_coords[3] [protected]

Definition at line 137 of file StdMeshers_CartesianParameters3D.hxx.

std::vector<double> STDMESHERS_EXPORT::_distr [protected]

the table for DT_TabFunc, a sequence of pairs of numbers

Definition at line 205 of file StdMeshers_NumberOfSegments.hxx.

the type of distribution of density function

Definition at line 203 of file StdMeshers_NumberOfSegments.hxx.

std::vector< int > STDMESHERS_EXPORT::_edgeIDs [protected]

list of reversed edges ids

Definition at line 80 of file StdMeshers_Arithmetic1D.hxx.

double STDMESHERS_EXPORT::_edgeLength [protected]

Definition at line 82 of file StdMeshers_MEFISTO_2D.hxx.

double STDMESHERS_EXPORT::_endLength [protected]

Definition at line 79 of file StdMeshers_Arithmetic1D.hxx.

SMESH_subMeshEventListener* STDMESHERS_EXPORT::_EventListener [protected]

Definition at line 70 of file StdMeshers_CompositeSegment_1D.hxx.

double STDMESHERS_EXPORT::_fineness [protected]

Definition at line 108 of file StdMeshers_AutomaticLength.hxx.

Definition at line 129 of file StdMeshers_Regular_1D.hxx.

std::string STDMESHERS_EXPORT::_func [protected]

the expression of the function for DT_ExprFunc

Definition at line 206 of file StdMeshers_NumberOfSegments.hxx.

std::vector<SMESH_Group*> STDMESHERS_EXPORT::_groups [private]

Definition at line 77 of file StdMeshers_ImportSource.hxx.

Definition at line 61 of file StdMeshers_Cartesian_3D.hxx.

Definition at line 85 of file StdMeshers_MEFISTO_2D.hxx.

Definition at line 84 of file StdMeshers_MEFISTO_2D.hxx.

Definition at line 127 of file StdMeshers_Regular_1D.hxx.

std::vector<int> STDMESHERS_EXPORT::_ignoreFaceIds [private]

Definition at line 88 of file StdMeshers_ViscousLayers.hxx.

std::vector<double> STDMESHERS_EXPORT::_internalPoints[3] [protected]

Definition at line 139 of file StdMeshers_CartesianParameters3D.hxx.

int STDMESHERS_EXPORT::_ivalue[3] [protected]

Definition at line 132 of file StdMeshers_Regular_1D.hxx.

double STDMESHERS_EXPORT::_length [protected]

Definition at line 69 of file StdMeshers_LocalLength.hxx.

TopoDS_Shape STDMESHERS_EXPORT::_mainEdge [protected]

Definition at line 139 of file StdMeshers_Regular_1D.hxx.

double STDMESHERS_EXPORT::_maxArea [protected]

Definition at line 67 of file StdMeshers_MaxElementArea.hxx.

Definition at line 83 of file StdMeshers_MEFISTO_2D.hxx.

double STDMESHERS_EXPORT::_maxVolume [protected]

Definition at line 69 of file StdMeshers_MaxElementVolume.hxx.

const SMESH_Mesh* STDMESHERS_EXPORT::_mesh [protected]

Definition at line 107 of file StdMeshers_AutomaticLength.hxx.

double STDMESHERS_EXPORT::_minLen [protected]

Definition at line 108 of file StdMeshers_AutomaticLength.hxx.

int STDMESHERS_EXPORT::_mode [protected]

Definition at line 71 of file StdMeshers_LengthFromEdges.hxx.

Definition at line 84 of file StdMeshers_NumberOfLayers.hxx.

std::vector<int> STDMESHERS_EXPORT::_nbsegs [protected]

Definition at line 83 of file StdMeshers_FixedPoints1D.hxx.

an edge will be split on to this number of segments

Definition at line 202 of file StdMeshers_NumberOfSegments.hxx.

std::string STDMESHERS_EXPORT::_objEntry [protected]

Entry of the main object to reverse edges.

Definition at line 81 of file StdMeshers_Arithmetic1D.hxx.

std::vector<double> STDMESHERS_EXPORT::_params [protected]

Definition at line 82 of file StdMeshers_FixedPoints1D.hxx.

double STDMESHERS_EXPORT::_precision [protected]

Definition at line 70 of file StdMeshers_LocalLength.hxx.

Definition at line 66 of file StdMeshers_MaxLength.hxx.

Definition at line 67 of file StdMeshers_MaxLength.hxx.

Definition at line 83 of file StdMeshers_QuadrangleParams.hxx.

Definition at line 82 of file StdMeshers_ImportSource.hxx.

std::vector<int> STDMESHERS_EXPORT::_resultGroupsStorage [private]

Definition at line 83 of file StdMeshers_ImportSource.hxx.

std::vector<int> STDMESHERS_EXPORT::_revEdgesIDs [protected]

Definition at line 135 of file StdMeshers_Regular_1D.hxx.

double STDMESHERS_EXPORT::_S0 [protected]

Definition at line 108 of file StdMeshers_AutomaticLength.hxx.

double STDMESHERS_EXPORT::_scaleFactor [protected]

the scale parameter for DT_Scale

Definition at line 204 of file StdMeshers_NumberOfSegments.hxx.

Definition at line 141 of file StdMeshers_CartesianParameters3D.hxx.

TopoDS_Shape STDMESHERS_EXPORT::_sourceEdge [protected]

Definition at line 148 of file StdMeshers_ProjectionSource1D.hxx.

TopoDS_Shape STDMESHERS_EXPORT::_sourceFace [protected]

Definition at line 158 of file StdMeshers_ProjectionSource2D.hxx.

Definition at line 78 of file StdMeshers_Import_1D.hxx.

Definition at line 62 of file StdMeshers_Projection_3D.hxx.

Definition at line 64 of file StdMeshers_Projection_2D.hxx.

Definition at line 66 of file StdMeshers_Projection_1D.hxx.

SMESH_Mesh * STDMESHERS_EXPORT::_sourceMesh [protected]

Definition at line 149 of file StdMeshers_ProjectionSource1D.hxx.

TopoDS_Shape STDMESHERS_EXPORT::_sourceShape [protected]

Definition at line 150 of file StdMeshers_ProjectionSource3D.hxx.

TopoDS_Vertex STDMESHERS_EXPORT::_sourceVertex [protected]

Definition at line 150 of file StdMeshers_ProjectionSource1D.hxx.

TopoDS_Vertex STDMESHERS_EXPORT::_sourceVertex1 [protected]

Definition at line 160 of file StdMeshers_ProjectionSource2D.hxx.

TopoDS_Vertex STDMESHERS_EXPORT::_sourceVertex2 [protected]

Definition at line 161 of file StdMeshers_ProjectionSource2D.hxx.

std::vector<std::string> STDMESHERS_EXPORT::_spaceFunctions[3] [protected]

Definition at line 138 of file StdMeshers_CartesianParameters3D.hxx.

Definition at line 91 of file StdMeshers_ViscousLayers.hxx.

std::string STDMESHERS_EXPORT::_svalue[1] [protected]

Definition at line 134 of file StdMeshers_Regular_1D.hxx.

std::vector<double> STDMESHERS_EXPORT::_table [protected]

Definition at line 205 of file StdMeshers_NumberOfSegments.hxx.

TopoDS_Vertex STDMESHERS_EXPORT::_targetVertex [protected]

Definition at line 151 of file StdMeshers_ProjectionSource1D.hxx.

TopoDS_Vertex STDMESHERS_EXPORT::_targetVertex1 [protected]

Definition at line 162 of file StdMeshers_ProjectionSource2D.hxx.

TopoDS_Vertex STDMESHERS_EXPORT::_targetVertex2 [protected]

Definition at line 163 of file StdMeshers_ProjectionSource2D.hxx.

Definition at line 90 of file StdMeshers_ViscousLayers.hxx.

Definition at line 78 of file StdMeshers_ImportSource.hxx.

Definition at line 78 of file StdMeshers_ImportSource.hxx.

Definition at line 81 of file StdMeshers_QuadrangleParams.hxx.

std::map<const TopoDS_TShape*, double> STDMESHERS_EXPORT::_TShapeToLength [protected]

Definition at line 106 of file StdMeshers_AutomaticLength.hxx.

double STDMESHERS_EXPORT::_value [protected]

Definition at line 65 of file StdMeshers_Deflection1D.hxx.

Definition at line 59 of file StdMeshers_Hexa_3D.hxx.

std::vector<double> STDMESHERS_EXPORT::_vvalue[1] [protected]

Definition at line 133 of file StdMeshers_Regular_1D.hxx.

Definition at line 160 of file StdMeshers_Penta_3D.hxx.

Definition at line 259 of file StdMeshers_Penta_3D.hxx.

Definition at line 454 of file StdMeshers_Prism_3D.hxx.

Definition at line 461 of file StdMeshers_Prism_3D.hxx.

std::vector<Handle(Geom2d_Curve)> STDMESHERS_EXPORT::myC2d [protected]

Definition at line 214 of file StdMeshers_FaceSide.hxx.

std::vector<GeomAdaptor_Curve> STDMESHERS_EXPORT::myC3dAdaptor [protected]

Definition at line 215 of file StdMeshers_FaceSide.hxx.

std::map< int, int > STDMESHERS_EXPORT::myConnectingMap [protected]

Definition at line 267 of file StdMeshers_Penta_3D.hxx.

Definition at line 50 of file StdMeshers_Distribution.hxx.

Definition at line 272 of file StdMeshers_Penta_3D.hxx.

std::vector<double> STDMESHERS_EXPORT::myData [private]

Definition at line 86 of file StdMeshers_Distribution.hxx.

gp_Pnt2d STDMESHERS_EXPORT::myDefaultPnt2d [protected]

Definition at line 224 of file StdMeshers_FaceSide.hxx.

std::list< const SMDS_MeshNode* > STDMESHERS_EXPORT::myDegNodes [protected]

Definition at line 92 of file StdMeshers_QuadToTriaAdaptor.hxx.

Definition at line 72 of file StdMeshers_RadialPrism_3D.hxx.

std::vector<TopoDS_Edge> STDMESHERS_EXPORT::myEdge [protected]

Definition at line 212 of file StdMeshers_FaceSide.hxx.

std::vector<int> STDMESHERS_EXPORT::myEdgeID [protected]

Definition at line 213 of file StdMeshers_FaceSide.hxx.

std::vector<double> STDMESHERS_EXPORT::myEdgeLength [protected]

Definition at line 218 of file StdMeshers_FaceSide.hxx.

Definition at line 94 of file StdMeshers_QuadToTriaAdaptor.hxx.

TopoDS_Shape STDMESHERS_EXPORT::myEmptyShape [protected]

Definition at line 100 of file StdMeshers_Penta_3D.hxx.

Definition at line 368 of file StdMeshers_Prism_3D.hxx.

Definition at line 103 of file StdMeshers_Penta_3D.hxx.

Definition at line 261 of file StdMeshers_Penta_3D.hxx.

std::vector<uvPtStruct> STDMESHERS_EXPORT::myFalsePoints [protected]

Definition at line 211 of file StdMeshers_FaceSide.hxx.

std::vector<double> STDMESHERS_EXPORT::myFirst [protected]

Definition at line 216 of file StdMeshers_FaceSide.hxx.

Definition at line 62 of file StdMeshers_Distribution.hxx.

SMESH_MesherHelper * STDMESHERS_EXPORT::myHelper [private]

Definition at line 366 of file StdMeshers_Prism_3D.hxx.

SMESH_Hypothesis* STDMESHERS_EXPORT::myHyp [protected]

Definition at line 93 of file StdMeshers_LayerDistribution.hxx.

Definition at line 223 of file StdMeshers_FaceSide.hxx.

std::vector<int> STDMESHERS_EXPORT::myIsEdgeForward [protected]

Definition at line 101 of file StdMeshers_Penta_3D.hxx.

int STDMESHERS_EXPORT::myISize [protected]

Definition at line 264 of file StdMeshers_Penta_3D.hxx.

std::vector<double> STDMESHERS_EXPORT::myIsUniform [protected]

Definition at line 219 of file StdMeshers_FaceSide.hxx.

int STDMESHERS_EXPORT::myJSize [protected]

Definition at line 265 of file StdMeshers_Penta_3D.hxx.

std::vector<double> STDMESHERS_EXPORT::myLast [protected]

Definition at line 216 of file StdMeshers_FaceSide.hxx.

std::vector< double > STDMESHERS_EXPORT::myLayerPositions [protected]

Definition at line 74 of file StdMeshers_RadialPrism_3D.hxx.

double STDMESHERS_EXPORT::myLength [protected]

Definition at line 220 of file StdMeshers_FaceSide.hxx.

SMESH_Mesh* STDMESHERS_EXPORT::myMesh [protected]

Definition at line 222 of file StdMeshers_FaceSide.hxx.

void* STDMESHERS_EXPORT::myMesh [protected]

Definition at line 260 of file StdMeshers_Penta_3D.hxx.

Definition at line 223 of file StdMeshers_FaceSide.hxx.

Definition at line 71 of file StdMeshers_RadialPrism_3D.hxx.

Definition at line 221 of file StdMeshers_FaceSide.hxx.

Definition at line 221 of file StdMeshers_FaceSide.hxx.

Definition at line 133 of file StdMeshers_Quadrangle_2D.hxx.

SMDS_MeshNode* STDMESHERS_EXPORT::myNode [private]

Definition at line 157 of file StdMeshers_Penta_3D.hxx.

std::list<const SMDS_MeshNode*> STDMESHERS_EXPORT::myNodesOnCommonV [protected]

Definition at line 87 of file StdMeshers_MEFISTO_2D.hxx.

std::vector<double> STDMESHERS_EXPORT::myNormPar [protected]

Definition at line 217 of file StdMeshers_FaceSide.hxx.

Definition at line 365 of file StdMeshers_Prism_3D.hxx.

Definition at line 373 of file StdMeshers_Prism_3D.hxx.

std::vector<uvPtStruct> STDMESHERS_EXPORT::myPoints [protected]

Definition at line 211 of file StdMeshers_FaceSide.hxx.

Definition at line 452 of file StdMeshers_Prism_3D.hxx.

Definition at line 123 of file StdMeshers_Quadrangle_2D.hxx.

Definition at line 129 of file StdMeshers_Quadrangle_2D.hxx.

std::set<const SMDS_MeshElement*> STDMESHERS_EXPORT::myRemovedTrias [protected]

Definition at line 90 of file StdMeshers_QuadToTriaAdaptor.hxx.

std::string STDMESHERS_EXPORT::mySavedHyp [protected]

Definition at line 94 of file StdMeshers_LayerDistribution.hxx.

TopoDS_Shape STDMESHERS_EXPORT::myShape [protected]

Definition at line 258 of file StdMeshers_Penta_3D.hxx.

TopTools_IndexedMapOfOrientedShape STDMESHERS_EXPORT::myShapeIDMap [protected]

Definition at line 98 of file StdMeshers_Penta_3D.hxx.

Definition at line 367 of file StdMeshers_Prism_3D.hxx.

std::map< int, std::pair< TParam2ColumnMap*, bool > > STDMESHERS_EXPORT::myShapeIndex2ColumnMap [private]

Definition at line 375 of file StdMeshers_Prism_3D.hxx.

Definition at line 158 of file StdMeshers_Penta_3D.hxx.

std::vector< gp_XYZ > STDMESHERS_EXPORT::myShapeXYZ [protected]

Definition at line 270 of file StdMeshers_Penta_3D.hxx.

TopoDS_Shell STDMESHERS_EXPORT::myShell [protected]

Definition at line 97 of file StdMeshers_Penta_3D.hxx.

Definition at line 371 of file StdMeshers_Prism_3D.hxx.

double STDMESHERS_EXPORT::myStart [private]

Definition at line 63 of file StdMeshers_Distribution.hxx.

SMESH_Block STDMESHERS_EXPORT::myTBlock [protected]

Definition at line 99 of file StdMeshers_Penta_3D.hxx.

Definition at line 263 of file StdMeshers_Penta_3D.hxx.

double STDMESHERS_EXPORT::myTol3D [protected]

Definition at line 266 of file StdMeshers_Penta_3D.hxx.

SMESH_MesherHelper * STDMESHERS_EXPORT::myTool [protected]

Definition at line 89 of file StdMeshers_MEFISTO_2D.hxx.

Definition at line 125 of file StdMeshers_Quadrangle_2D.hxx.

Definition at line 127 of file StdMeshers_Quadrangle_2D.hxx.

TColStd_Array1OfReal STDMESHERS_EXPORT::myValues [private]

Definition at line 101 of file StdMeshers_Distribution.hxx.

Expr_Array1OfNamedUnknown STDMESHERS_EXPORT::myVars [private]

Definition at line 100 of file StdMeshers_Distribution.hxx.

Definition at line 269 of file StdMeshers_Penta_3D.hxx.

gp_XYZ STDMESHERS_EXPORT::myXYZ [private]

Definition at line 159 of file StdMeshers_Penta_3D.hxx.


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