StdMeshers_Regular_1D Class Reference

#include <StdMeshers_Regular_1D.hxx>

Inheritance diagram for StdMeshers_Regular_1D:


Public Types
enum	Hypothesis_Status { HYP_OK, HYP_MISSING, HYP_CONCURENT, HYP_BAD_PARAMETER, HYP_UNKNOWN_FATAL, HYP_INCOMPATIBLE, HYP_NOTCONFORM, HYP_ALREADY_EXIST, HYP_BAD_DIM, HYP_BAD_SUBSHAPE }
enum	hypothesis_type { PARAM_ALGO, ALGO, ALGO_1D, ALGO_2D, ALGO_3D }
Public Member Functions
	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 const std::list< const SMESHDS_Hypothesis * > &	GetUsedHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, const bool=true)
ostream &	SaveTo (ostream &save)
istream &	LoadFrom (istream &load)
const std::vector< std::string > &	GetCompatibleHypothesis ()
const list< const SMESHDS_Hypothesis * > &	GetAppliedHypothesis (SMESH_Mesh &aMesh, const TopoDS_Shape &aShape, const bool ignoreAuxiliary=true)
bool	InitCompatibleHypoFilter (SMESH_HypoFilter &theFilter, const bool ignoreAuxiliary) const
	Make filter recognize only compatible hypotheses.
virtual bool	SetParametersByMesh (const SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)
	Initialize my parameter values by the mesh built on the geometry.
bool	OnlyUnaryInput () const
bool	NeedDescretBoundary () const
virtual int	GetDim () const
int	GetStudyId () const
virtual void	NotifySubMeshesHypothesisModification ()
virtual int	GetShapeType () const
virtual const char *	GetLibName () const
void	SetLibName (const char *theLibName)
virtual bool	IsAuxiliary () const
	Return true if me is an auxiliary hypothesis.
const char *	GetName () const
int	GetID () const
int	GetType () const
virtual std::ostream &	SaveTo (std::ostream &save)=0
virtual std::istream &	LoadFrom (std::istream &load)=0
Static Public Member Functions
static double	EdgeLength (const TopoDS_Edge &E)
static bool	GetNodeParamOnEdge (const SMESHDS_Mesh *theMesh, const TopoDS_Edge &theEdge, std::vector< double > &theParams)
	Fill vector of node parameters on geometrical edge, including vertex nodes.
static bool	IsReversedSubMesh (const TopoDS_Face &theFace, SMESHDS_Mesh *theMeshDS)
	Find out elements orientation on a geometrical face.
static bool	IsStatusFatal (Hypothesis_Status theStatus)
Protected Types
enum	HypothesisType { LOCAL_LENGTH, NB_SEGMENTS, BEG_END_LENGTH, DEFLECTION, ARITHMETIC_1D, NONE }
enum	ValueIndex { SCALE_FACTOR_IND = 0, BEG_LENGTH_IND = 0, END_LENGTH_IND = 1, DEFLECTION_IND = 0 }
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 }
Protected Member Functions
virtual bool	computeInternalParameters (const TopoDS_Edge &theEdge, std::list< double > &theParameters, const bool theReverse) const
Protected Attributes
HypothesisType	_hypType
double	_value [2]
int	_ivalue [3]
std::vector< double >	_vvalue [1]
std::string	_svalue [1]
TopoDS_Shape	_mainEdge
bool	_onlyUnaryInput
bool	_requireDescretBoundary
std::vector< std::string >	_compatibleHypothesis
std::list< const SMESHDS_Hypothesis * >	_appliedHypList
std::list< const SMESHDS_Hypothesis * >	_usedHypList
bool	_quadraticMesh
SMESH_Gen *	_gen
int	_studyId
int	_shapeType
int	_param_algo_dim
std::string	_name
int	_hypId
int	_type
Friends
ostream &	operator<< (ostream &save, StdMeshers_Regular_1D &hyp)
istream &	operator>> (istream &load, StdMeshers_Regular_1D &hyp)

Member Enumeration Documentation

enum StdMeshers_Regular_1D::HypothesisType [protected]

Enumerator:

LOCAL_LENGTH

NB_SEGMENTS

BEG_END_LENGTH

DEFLECTION

ARITHMETIC_1D

NONE

enum StdMeshers_Regular_1D::ValueIndex [protected]

Enumerator:

SCALE_FACTOR_IND

BEG_LENGTH_IND

END_LENGTH_IND

DEFLECTION_IND

enum StdMeshers_Regular_1D::IValueIndex [protected]

Enumerator:

NB_SEGMENTS_IND

DISTR_TYPE_IND

CONV_MODE_IND

enum StdMeshers_Regular_1D::VValueIndex [protected]

Enumerator:

TAB_FUNC_IND

enum StdMeshers_Regular_1D::SValueIndex [protected]

Enumerator:

EXPR_FUNC_IND

enum SMESH_Hypothesis::Hypothesis_Status [inherited]

Enumerator:

HYP_OK

HYP_MISSING

HYP_CONCURENT

HYP_BAD_PARAMETER

HYP_UNKNOWN_FATAL

HYP_INCOMPATIBLE

HYP_NOTCONFORM

HYP_ALREADY_EXIST

HYP_BAD_DIM

HYP_BAD_SUBSHAPE

enum SMESHDS_Hypothesis::hypothesis_type [inherited]

Enumerator:

PARAM_ALGO

ALGO

ALGO_1D

ALGO_2D

ALGO_3D

Constructor & Destructor Documentation

StdMeshers_Regular_1D.StdMeshers_Regular_1D ( int hypId,

int studyId,

SMESH_Gen * gen

)

virtual StdMeshers_Regular_1D.~StdMeshers_Regular_1D ( ) [virtual]

Member Function Documentation

virtual bool StdMeshers_Regular_1D.CheckHypothesis ( SMESH_Mesh & aMesh,

const TopoDS_Shape & aShape,

SMESH_Hypothesis::Hypothesis_Status & aStatus

) [virtual]

Implements SMESH_Algo.

virtual bool StdMeshers_Regular_1D.Compute ( SMESH_Mesh & aMesh,

const TopoDS_Shape & aShape

) [virtual]

Implements SMESH_Algo.

virtual const std::list<const SMESHDS_Hypothesis *>& StdMeshers_Regular_1D.GetUsedHypothesis ( SMESH_Mesh & aMesh,

const TopoDS_Shape & aShape,

const bool = true

) [virtual]

Reimplemented from SMESH_Algo.

ostream& StdMeshers_Regular_1D.SaveTo ( ostream & save )

istream& StdMeshers_Regular_1D.LoadFrom ( istream & load )

virtual bool StdMeshers_Regular_1D.computeInternalParameters ( const TopoDS_Edge & theEdge,

std::list< double > & theParameters,

const bool theReverse

) const [protected, virtual]

const std::vector< std::string >& SMESH_Algo.GetCompatibleHypothesis ( ) [inherited]

const list<const SMESHDS_Hypothesis *>& SMESH_Algo.GetAppliedHypothesis ( SMESH_Mesh & aMesh,

const TopoDS_Shape & aShape,

const bool ignoreAuxiliary = true

) [inherited]

static double SMESH_Algo.EdgeLength ( const TopoDS_Edge & E ) [static, inherited]

bool SMESH_Algo.InitCompatibleHypoFilter ( SMESH_HypoFilter & theFilter,

const bool ignoreAuxiliary

) const [inherited]

Parameters:

theFilter - the filter to initialize

ignoreAuxiliary - make filter ignore compatible auxiliary hypotheses

Return values:

bool - true if the algo has compatible hypotheses

static bool SMESH_Algo.GetNodeParamOnEdge ( const SMESHDS_Mesh * theMesh,

const TopoDS_Edge & theEdge,

std::vector< double > & theParams

) [static, inherited]

Parameters:

theMesh - The mesh containing nodes

theEdge - The geometrical edge of interest

theParams - The resulting vector of sorted node parameters

Return values:

bool - false if not all parameters are OK

static bool SMESH_Algo.IsReversedSubMesh ( const TopoDS_Face & theFace,

SMESHDS_Mesh * theMeshDS

) [static, inherited]

Parameters:

theFace - The face correctly oriented in the shape being meshed

theMeshDS - The mesh data structure

Return values:

bool - true if the face normal and the normal of first element in the correspoding submesh point in different directions

virtual bool SMESH_Algo.SetParametersByMesh ( const SMESH_Mesh * theMesh,

const TopoDS_Shape & theShape

) [virtual, inherited]

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 the algorithm does not hold parameters values
Implements SMESH_Hypothesis.

bool SMESH_Algo.OnlyUnaryInput ( ) const [inherited]

bool SMESH_Algo.NeedDescretBoundary ( ) const [inherited]

static bool SMESH_Hypothesis.IsStatusFatal ( Hypothesis_Status theStatus ) [static, inherited]

virtual int SMESH_Hypothesis.GetDim ( ) const [virtual, inherited]

int SMESH_Hypothesis.GetStudyId ( ) const [inherited]

virtual void SMESH_Hypothesis.NotifySubMeshesHypothesisModification ( ) [virtual, inherited]

virtual int SMESH_Hypothesis.GetShapeType ( ) const [virtual, inherited]

virtual const char* SMESH_Hypothesis.GetLibName ( ) const [virtual, inherited]

void SMESH_Hypothesis.SetLibName ( const char * theLibName ) [inherited]

virtual bool SMESH_Hypothesis.IsAuxiliary ( ) const [virtual, inherited]

Return values:

bool - auxiliary or not

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