Packages
package	STLEXT
Data Structures
class	AutoPtr
class	Exception
struct	hash
struct	hash< char * >
struct	hash< const char * >
struct	hash< char >
struct	hash< unsigned char >
struct	hash< signed char >
struct	hash< short >
struct	hash< unsigned short >
struct	hash< int >
struct	hash< unsigned int >
struct	hash< long >
struct	hash< unsigned long >
class	HashMap
class	HashMultiMap
struct	_Hashtable_node
struct	_Hashtable_iterator
struct	_Hashtable_const_iterator
class	hashtable
class	GenericMesh
class	BoundingBox
	Class representing the bounding box of a number of points. More...
class	CellModel
class	ConvexIntersector
class	CurveIntersector
class	CurveIntersectorP0P0
class	CurveIntersectorP0P1
class	CurveIntersectorP1P0
class	CurveIntersectorP1P1
class	DirectedBoundingBox
	Class representing the bounding box of a number of points with box axes parallel to principal axes of inertia of points. More...
class	AsmX86
class	LeafExpr
class	LeafExprVal
class	LeafExprVar
class	ExprParser
class	FunctionsFactory
class	Function
class	UnaryFunction
class	IdentityFunction
class	PositiveFunction
class	NegateFunction
class	CosFunction
class	SinFunction
class	TanFunction
class	SqrtFunction
class	AbsFunction
class	ExpFunction
class	LnFunction
class	LogFunction
class	Log10Function
class	BinaryFunction
class	PlusFunction
class	MinusFunction
class	MultFunction
class	DivFunction
class	PowFunction
class	MaxFunction
class	MinFunction
class	GreaterThanFunction
class	LowerThanFunction
class	TernaryFunction
class	IfFunction
class	UnitDataBase
class	DecompositionInUnitBase
class	Unit
class	Value
class	ValueDouble
class	ValueUnit
class	ValueDoubleExpr
class	GaussInfo
class	GaussCoords
class	IteratorOnComposedEdge
class	Bounds
class	ComposedEdge
class	MergePoints
class	IntersectElement
class	EdgeIntersector
class	SameTypeEdgeIntersector
class	CrossTypeEdgeIntersector
class	Edge
class	ArcCArcCIntersector
class	ArcCSegIntersector
class	EdgeArcCircle
class	EdgeInfLin
class	SegSegIntersector
class	EdgeLin
class	ElementaryEdge
class	Node
class	QUADRATIC_PLANAR
class	QuadraticPolygon
class	Geometric2DIntersector
class	IntegralUniformIntersector
class	IntegralUniformIntersectorP0
class	IntegralUniformIntersectorP1
class	CellSimplify
class	Matrix
class	Interpolation
class	Interpolation1D
class	Interpolation2D
class	Interpolation2DCurve
class	Interpolation3D
	Class used to calculate the volumes of intersection between the elements of two 3D meshes. More...
class	Interpolation3DSurf
class	InterpolationCC
	Interpolator of cartesian/cartesian meshes. More...
class	InterpolationCU
class	InterpolationCurve
class	InterpolationOptions
class	InterpolationPlanar
class	OTT
class	OTT< ConnType, ALL_C_MODE >
class	OTT< ConnType, ALL_FORTRAN_MODE >
class	AngleLess
class	Intersector3D
class	Intersector3DP0P0
class	Intersector3DP0P1
class	Intersector3DP1P0
class	Intersector3DP1P0Bary
class	Intersector3DP1P1
class	IntersectorCU
class	_StabIntersector
class	IntersectorCU1D
class	IntersectorCU2D
class	IntersectorCU3D
class	MeshElement
	Class representing a single element of a mesh together with its bounding box. More...
class	ElementBBoxOrder
	Class defining an order for MeshElements based on their bounding boxes. More...
class	MeshRegion
	Class representing a set of elements in a mesh together with their bounding box. More...
class	PlanarIntersector
class	PlanarIntersectorP0P0
class	PlanarIntersectorP0P1
class	PlanarIntersectorP0P1PL
class	PlanarIntersectorP1P0
class	PlanarIntersectorP1P0Bary
class	PlanarIntersectorP1P0PL
class	PlanarIntersectorP1P1
class	PlanarIntersectorP1P1PL
class	PointLocator2DIntersector
class	PointLocator3DIntersectorP0P0
class	PointLocator3DIntersectorP0P1
class	PointLocator3DIntersectorP1P0
class	PointLocator3DIntersectorP1P1
class	VertexLess
class	PolygonAlgorithms
class	PolyhedronIntersectorP0P0
	Class responsible for calculating intersection between a hexahedron target element and the source elements. More...
class	PolyhedronIntersectorP0P1
	Class responsible for calculating intersection between a hexahedron target element and the source elements. More...
class	PolyhedronIntersectorP1P0
	Class responsible for calculating intersection between a hexahedron target element and the source elements. More...
class	PolyhedronIntersectorP1P0Bary
	Class responsible for calculating intersection between a hexahedron target element and the source elements. More...
class	PolyhedronIntersectorP1P1
	Class responsible for calculating intersection between a hexahedron target element and the source elements. More...
class	RegionNode
	Class containing a tuplet of a source region and a target region. More...
class	TriangleFaceKey
	Class representing a triangular face, used as key in caching hash map in SplitterTetra. More...
class	hash< INTERP_KERNEL::TriangleFaceKey >
	Template specialization of INTERP_KERNEL.hash<T> function object for use with a with TriangleFaceKey as key class. More...
class	SplitterTetra
	Class calculating the volume of intersection between a tetrahedral target element and source elements with triangular or quadratilateral faces. More...
class	SplitterTetra2
class	TargetIntersector
	Abstract base class of Intersector classes. More...
class	TetraAffineTransform
	Class representing an affine transformation x -> Ax + b that transforms a given tetrahedron into the unit tetrahedron. More...
class	ProjectedCentralCircularSortOrder
	Class representing a circular order of a set of points around their barycenter. More...
class	TransformedTriangle
	Class representing one of the faces of the triangulated source polyhedron after having been transformed with the affine transform that takes the target tetrahedron to the unit tetrahedron. More...
class	TranslationRotationMatrix
class	TriangulationIntersector
class	UnitTetraIntersectionBary
struct	hash< pair< int, int > >
Typedefs
typedef std::vector< double >	DataVector
typedef std::vector< int >	IndexVector
Enumerations
enum	{ _S_num_primes = 28 }
enum	NumberingPolicy { ALL_C_MODE, ALL_FORTRAN_MODE }
enum	NormalizedCellType { NORM_POINT1 = 0, NORM_SEG2 = 1, NORM_SEG3 = 2, NORM_TRI3 = 3, NORM_QUAD4 = 4, NORM_POLYGON = 5, NORM_TRI6 = 6, NORM_QUAD8 = 8, NORM_TETRA4 = 14, NORM_PYRA5 = 15, NORM_PENTA6 = 16, NORM_HEXA8 = 18, NORM_TETRA10 = 20, NORM_HEXGP12 = 22, NORM_PYRA13 = 23, NORM_PENTA15 = 25, NORM_HEXA20 = 30, NORM_POLYHED = 31, NORM_ERROR = 40 }
enum	Position { IN = 0, OUT = 1, ON_BOUNDARY_POS = 2, ON_BOUNDARY_NEG = 3 }
enum	TypeOfFunction { SEG = 1, ARC_CIRCLE = 4, ARC_PARABOL = 8 }
enum	TypeOfMod4QuadEdge { CIRCLE = 0, PARABOL = 1 }
enum	TypeOfLocInEdge { START = 5, END = 1, INSIDE = 2, OUT_BEFORE = 3, OUT_AFTER = 4 }
enum	TypeOfEdgeLocInPolygon { FULL_IN_1 = 1, FULL_ON_1 = 4, FULL_OUT_1 = 2, FULL_UNKNOWN = 3 }
enum	TypeOfLocInPolygon { IN_1 = 7, ON_1 = 8, ON_LIM_1 = 12, ON_TANG_1 = 9, OUT_1 = 10, UNKNOWN = 11 }
enum	IntersectionType { Triangulation, Convex, Geometric2D, PointLocator }
enum	SplittingPolicy { PLANAR_FACE_5 = 5, PLANAR_FACE_6 = 6, GENERAL_24 = 24, GENERAL_48 = 48 }
	Type describing the different ways in which the hexahedron can be split into tetrahedra. More...
enum	{ _X = 0, _Y, _Z }
Functions
std::size_t	__stl_hash_string (const char *__s)
template<class _Key , class _Tp , class _HashFn , class _EqlKey , class _Alloc >
bool	operator== (const HashMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm1, const HashMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm2)
template<class _Key , class _Tp , class _HashFn , class _EqlKey , class _Alloc >
bool	operator!= (const HashMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm1, const HashMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm2)
template<class _Key , class _Tp , class _HashFn , class _EqlKey , class _Alloc >
void	swap (HashMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm1, HashMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm2)
template<class _Key , class _Tp , class _HF , class _EqKey , class _Alloc >
bool	operator== (const HashMultiMap< _Key, _Tp, _HF, _EqKey, _Alloc > &__hm1, const HashMultiMap< _Key, _Tp, _HF, _EqKey, _Alloc > &__hm2)
template<class _Key , class _Tp , class _HF , class _EqKey , class _Alloc >
bool	operator!= (const HashMultiMap< _Key, _Tp, _HF, _EqKey, _Alloc > &__hm1, const HashMultiMap< _Key, _Tp, _HF, _EqKey, _Alloc > &__hm2)
template<class _Key , class _Tp , class _HashFn , class _EqlKey , class _Alloc >
void	swap (HashMultiMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm1, HashMultiMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm2)
unsigned long	__stl_next_prime (unsigned long __n)
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
bool	operator== (const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &__ht1, const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &__ht2)
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
bool	operator!= (const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &__ht1, const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &__ht2)
template<class _Val , class _Key , class _HF , class _Extract , class _EqKey , class _All >
void	swap (hashtable< _Val, _Key, _HF, _Extract, _EqKey, _All > &__ht1, hashtable< _Val, _Key, _HF, _Extract, _EqKey, _All > &__ht2)
void	computeEigenValues6 (const double matrix, double eigenVals)
void	computeEigenVectorForEigenValue6 (const double matrix, double eigenVal, double eps, double eigenVector) throw (INTERP_KERNEL::Exception)
template<class U , NumberingPolicy type>
std::ostream &	operator<< (std::ostream &in, const Matrix< U, type > &m)
template<class U , NumberingPolicy type>
std::istream &	operator>> (std::istream &in, Matrix< U, type > &m)
template<class T , NumberingPolicy type>
std::ostream &	operator<< (std::ostream &out, const Matrix< T, type > &m)
template<class T , NumberingPolicy type>
std::istream &	operator>> (std::istream &in, Matrix< T, type > &m)
double	quadSkew (const double *coo)
double	quadEdgeRatio (const double *coo)
double	quadAspectRatio (const double *coo)
double	quadWarp (const double *coo)
double	triEdgeRatio (const double *coo)
double	triAspectRatio (const double *coo)
double	tetraEdgeRatio (const double *coo)
double	tetraAspectRatio (const double *coo)
double	Surf_Tri (const double P_1, const double P_2, const double *P_3)
double	mon_determinant (const double P_1, const double P_2, const double *P_3)
double	norme_vecteur (const double P_1, const double P_2)
std::vector< double >	calcul_cos_et_sin (const double P_1, const double P_2, const double *P_3)
template<int SPACEDIM>
void	fillDualCellOfTri (const double triIn, double quadOut)
template<int SPACEDIM>
void	fillDualCellOfPolyg (const double polygIn, int nPtsPolygonIn, double polygOut)
std::vector< double >	bary_poly (const std::vector< double > &V)
double	computeTria6RefBase (const double coeffs, const double pos)
void	computeWeightedCoeffsInTria6FromRefBase (const double refCoo, double weightedPos)
double	computeTetra10RefBase (const double coeffs, const double pos)
void	computeWeightedCoeffsInTetra10FromRefBase (const double refCoo, double weightedPos)
template<unsigned nbRow>
bool	solveSystemOfEquations (double M[nbRow][nbRow+1], double *sol)
	Solve system equation in matrix form using Gaussian elimination algorithm.
template<unsigned SZ, unsigned NB_OF_RES>
bool	solveSystemOfEquations2 (const double matrix, double solutions, double eps)
	Solve system equation in matrix form using Gaussian elimination algorithm.
template<int SPACEDIM>
void	barycentric_coords (const double triaCoords, const double p, double *bc)
void	barycentric_coords (const std::vector< const double * > &n, const double p, double bc)
double	Surf_Poly (const std::vector< double > &Poly)
bool	point_dans_triangle (const double P_0, const double P_1, const double P_2, const double P_3, double eps)
void	verif_point_dans_vect (const double *P, std::vector< double > &V, double absolute_precision)
void	rajou_sommet_triangl (const double P_1, const double P_2, const double P_3, const double P_4, const double P_5, const double P_6, std::vector< double > &V, double dim_caracteristic, double precision)
void	inters_de_segment (const double P_1, const double P_2, const double P_3, const double P_4, std::vector< double > &Vect, double dim_caracteristic, double precision)
void	intersec_de_triangle (const double P_1, const double P_2, const double P_3, const double P_4, const double P_5, const double P_6, std::vector< double > &Vect, double dim_caracteristic, double precision)
void	verif_maill_dans_vect (int Num, std::vector< int > &V)
std::vector< double >	reconstruct_polygon (const std::vector< double > &V)
template<int DIM, NumberingPolicy numPol, class MyMeshType >
void	getElemBB (double bb, const double coordsOfMesh, int iP, int nb_nodes)
template<int dim>
double	dotprod (const double a, const double b)
template<int dim>
double	norm (const double *v)
	Calculates norm of a double[3] vector.
template<int dim>
double	distance2 (const double a, const double b)
template<class T , int dim>
double	distance2 (T a, int inda, T b, int indb)
double	determinant (double a, double b)
double	determinant (double a, double b, double *c)
template<int dim>
void	crossprod (const double A, const double B, const double C, double V)
template<>
void	crossprod< 2 > (const double A, const double B, const double C, double V)
template<>
void	crossprod< 3 > (const double A, const double B, const double C, double V)
template<>
void	crossprod< 1 > (const double A, const double B, const double C, double V)
template<int dim>
double	check_inside (const double A, const double B, const double C, const double D, const double E, double ABC, double *ADE)
template<int dim>
double	angle (const double A, const double B, const double C, double n)
template<int dim>
double	direct_frame (const double A, const double B, const double C, double n)
template<>
double	direct_frame< 2 > (const double A, const double B, const double C, double n)
template<>
double	direct_frame< 3 > (const double A, const double B, const double C, double n)
template<int DIM>
void	intersec_de_polygone (const double Coords_A, const double Coords_B, int nb_NodesA, int nb_NodesB, std::vector< double > &inter, double dim_caracteristic, double precision)
template<int DIM>
double	polygon_area (std::vector< double > &inter)
template<int DIM>
double	polygon_area (std::deque< double > &inter)
double	triple_product (const double A, const double B, const double C, const double X)
template<class T , int dim>
bool	checkEqualPolygonsOneDirection (T L1, T L2, int size1, int size2, int istart1, int istart2, double epsilon, int sign)
template<class T , int dim>
bool	checkEqualPolygons (T L1, T L2, double epsilon)
template<class MyMeshType >
MyMeshType::MyConnType	getGlobalNumberOfNode (typename MyMeshType::MyConnType node, typename MyMeshType::MyConnType element, const MyMeshType &mesh)
	Returns the global number of the node of an element.
template<class MyMeshType >
const double *	getCoordsOfNode (typename MyMeshType::MyConnType node, typename MyMeshType::MyConnType element, const MyMeshType &mesh)
	Returns the coordinates of a node of an element.
template<class MyMeshType >
const double *	getCoordsOfNode2 (typename MyMeshType::MyConnType node, typename MyMeshType::MyConnType element, const MyMeshType &mesh, typename MyMeshType::MyConnType &nodeId)
	Returns the coordinates of a node of an element.
template<class MyMeshType , int NB_NODES>
void	getBarycentricCoordinates (const double point, typename MyMeshType::MyConnType element, const MyMeshType &mesh, double barycentricCoords)
	Returns the barycentric coordinates of a point within a triangle or tetrahedron.
bool	samePoint (const double p1, const double p2)
template<int SPACEDIM>
double	getDistanceBtw2Pts (const double a, const double b)
void	copyVector3 (const double src, double dest)
	Copies a double[3] vector from src to dest.
const std::string	vToStr (const double *pt)
	Creates a string representation of a double[3] vector.
void	cross (const double v1, const double v2, double *res)
	Calculates the cross product of two double[3] - vectors.
double	dot (const double v1, const double v2)
	Calculates the dot product of two double[3] - vectors.
bool	epsilonEqual (const double x, const double y, const double errTol=DEFAULT_ABS_TOL)
	Compares doubles using an absolute tolerance This is suitable mainly for comparisons with 0.0.
bool	epsilonEqualRelative (const double x, const double y, const double relTol=DEFAULT_REL_TOL, const double absTol=DEFAULT_ABS_TOL)
	Compares doubles using a relative tolerance This is suitable mainly for comparing larger values to each other.
void	calculateBarycenterDyn (const double *pts, int nbPts, int dim, double bary)
double	calculateAreaForPolyg (const double **coords, int nbOfPtsInPolygs, int spaceDim)
double	calculateLgthForSeg2 (const double p1, const double p2, int spaceDim)
double	calculateAreaForTria (const double p1, const double p2, const double *p3, int spaceDim)
double	calculateAreaForQuad (const double p1, const double p2, const double p3, const double p4, int spaceDim)
void	calculateNormalForTria (const double p1, const double p2, const double p3, double normal)
void	calculateNormalForQuad (const double p1, const double p2, const double p3, const double p4, double *normal)
void	calculateNormalForPolyg (const double *coords, int nbOfPtsInPolygs, double normal)
double	calculateVolumeForTetra (const double p1, const double p2, const double p3, const double p4)
double	calculateVolumeForPyra (const double p1, const double p2, const double p3, const double p4, const double *p5)
double	calculateVolumeForPenta (const double p1, const double p2, const double p3, const double p4, const double p5, const double p6)
double	calculateVolumeForHexa (const double pt1, const double pt2, const double pt3, const double pt4, const double pt5, const double pt6, const double pt7, const double pt8)
double	calculateVolumeForPolyh (const double **pts, const int nbOfNodesPerFaces, int nbOfFaces, const double *bary)
template<class ConnType , NumberingPolicy numPol>
double	calculateVolumeForPolyh2 (const ConnType connec, int lgth, const double coords)
template<class ConnType , NumberingPolicy numPol>
void	areaVectorOfPolygon (const ConnType connec, int lgth, const double coords, double *res)
double	integrationOverA3DLine (double u1, double v1, double u2, double v2, double A, double B, double C)
template<class ConnType , NumberingPolicy numPol>
void	barycenterOfPolyhedron (const ConnType connec, int lgth, const double coords, double *res)
double	calculateVolumeForPolyhAbs (const double **pts, const int nbOfNodesPerFaces, int nbOfFaces, const double *bary)
template<int N>
double	addComponentsOfVec (const double **pts, int rk)
template<>
double	addComponentsOfVec< 1 > (const double **pts, int rk)
template<int N, int DIM>
void	calculateBarycenter (const double *pts, double bary)
template<>
void	calculateBarycenter< 2, 0 > (const double *pts, double bary)
template<>
void	calculateBarycenter< 3, 0 > (const double *pts, double bary)
template<>
void	calculateBarycenter< 4, 0 > (const double *pts, double bary)
template<>
void	calculateBarycenter< 5, 0 > (const double *pts, double bary)
template<>
void	calculateBarycenter< 6, 0 > (const double *pts, double bary)
template<>
void	calculateBarycenter< 7, 0 > (const double *pts, double bary)
template<>
void	calculateBarycenter< 8, 0 > (const double *pts, double bary)
template<int SPACEDIM>
void	calculateBarycenterDyn2 (const double pts, int nbPts, double bary)
template<class ConnType , NumberingPolicy numPol>
void	computePolygonBarycenter2D (const ConnType connec, int lgth, const double coords, double *res)
template<class ConnType , NumberingPolicy numPol>
void	computePolygonBarycenter3D (const ConnType connec, int lgth, const double coords, double *res)
template<class ConnType , NumberingPolicy numPolConn, int SPACEDIM>
double	computeVolSurfOfCell (NormalizedCellType type, const ConnType connec, int lgth, const double coords)
template<class ConnType , NumberingPolicy numPolConn>
double	computeVolSurfOfCell2 (NormalizedCellType type, const ConnType connec, int lgth, const double coords, int spaceDim)
template<class ConnType , NumberingPolicy numPolConn, int SPACEDIM>
void	computeBarycenter (NormalizedCellType type, const ConnType connec, int lgth, const double coords, double *res)
template<class ConnType , NumberingPolicy numPolConn>
void	computeBarycenter2 (NormalizedCellType type, const ConnType connec, int lgth, const double coords, int spaceDim, double *res)
Variables
static const unsigned long	__stl_prime_list [_S_num_primes]
const unsigned	MAX_SIZE_OF_LINE_XFIG_FILE = 1024
const double	VOL_PREC = 1.0e-6
	Precision used for tests of 3D part of INTERP_KERNEL.
const double	DEFAULT_REL_TOL = 1.0e-6
	Default relative tolerance in epsilonEqualRelative.
const double	DEFAULT_ABS_TOL = 5.0e-12
	Default absolute tolerance in epsilonEqual and epsilonEqualRelative.

Typedef Documentation

typedef std::vector<double> INTERP_KERNEL.DataVector

typedef std::vector<int> INTERP_KERNEL.IndexVector

Enumeration Type Documentation

anonymous enum

Enumerator:

_S_num_primes

enum INTERP_KERNEL::NumberingPolicy

Enumerator:

ALL_C_MODE
ALL_FORTRAN_MODE

enum INTERP_KERNEL::NormalizedCellType

Enumerator:

NORM_POINT1
NORM_SEG2
NORM_SEG3
NORM_TRI3
NORM_QUAD4
NORM_POLYGON
NORM_TRI6
NORM_QUAD8
NORM_TETRA4
NORM_PYRA5
NORM_PENTA6
NORM_HEXA8
NORM_TETRA10
NORM_HEXGP12
NORM_PYRA13
NORM_PENTA15
NORM_HEXA20
NORM_POLYHED
NORM_ERROR

enum INTERP_KERNEL::Position

Relative LOC

Enumerator:

IN
OUT
ON_BOUNDARY_POS
ON_BOUNDARY_NEG

enum INTERP_KERNEL::TypeOfFunction

Enumerator:

SEG
ARC_CIRCLE
ARC_PARABOL

enum INTERP_KERNEL::TypeOfMod4QuadEdge

Enumerator:

CIRCLE
PARABOL

enum INTERP_KERNEL::TypeOfLocInEdge

Enumerator:

START
END
INSIDE
OUT_BEFORE
OUT_AFTER

enum INTERP_KERNEL::TypeOfEdgeLocInPolygon

Enumerator:

FULL_IN_1
FULL_ON_1
FULL_OUT_1
FULL_UNKNOWN

enum INTERP_KERNEL::TypeOfLocInPolygon

Enumerator:

IN_1
ON_1
ON_LIM_1
ON_TANG_1
OUT_1
UNKNOWN

enum INTERP_KERNEL::IntersectionType

Enumerator:

Triangulation
Convex
Geometric2D
PointLocator

enum INTERP_KERNEL::SplittingPolicy

Type describing the different ways in which the hexahedron can be split into tetrahedra.

The PLANAR_* policies persume that each face is to be considered planar, while the general policies make no such hypothesis. The integer at the end gives the number of tetrahedra that result from the split.

Enumerator:

PLANAR_FACE_5
PLANAR_FACE_6
GENERAL_24
GENERAL_48

anonymous enum

Enumerator:

_X
_Y
_Z

Function Documentation

std::size_t INTERP_KERNEL.__stl_hash_string ( const char * __s )

template<class _Key , class _Tp , class _HashFn , class _EqlKey , class _Alloc >

bool INTERP_KERNEL.operator==	(	const HashMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &	__hm1,
		const HashMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &	__hm2
	)

template<class _Key , class _Tp , class _HashFn , class _EqlKey , class _Alloc >

bool INTERP_KERNEL.operator!=	(	const HashMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &	__hm1,
		const HashMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &	__hm2
	)

template<class _Key , class _Tp , class _HashFn , class _EqlKey , class _Alloc >

void INTERP_KERNEL.swap	(	HashMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &	__hm1,
		HashMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &	__hm2
	)

template<class _Key , class _Tp , class _HF , class _EqKey , class _Alloc >

bool INTERP_KERNEL.operator==	(	const HashMultiMap< _Key, _Tp, _HF, _EqKey, _Alloc > &	__hm1,
		const HashMultiMap< _Key, _Tp, _HF, _EqKey, _Alloc > &	__hm2
	)

template<class _Key , class _Tp , class _HF , class _EqKey , class _Alloc >

bool INTERP_KERNEL.operator!=	(	const HashMultiMap< _Key, _Tp, _HF, _EqKey, _Alloc > &	__hm1,
		const HashMultiMap< _Key, _Tp, _HF, _EqKey, _Alloc > &	__hm2
	)

template<class _Key , class _Tp , class _HashFn , class _EqlKey , class _Alloc >

void INTERP_KERNEL.swap	(	HashMultiMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &	__hm1,
		HashMultiMap< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &	__hm2
	)

unsigned long INTERP_KERNEL.__stl_next_prime ( unsigned long __n )

References __stl_prime_list, and _S_num_primes.

template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >

bool INTERP_KERNEL::operator==	(	const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &	__ht1,
		const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &	__ht2
	)

References INTERP_KERNEL.hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >._M_buckets.

template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >

bool INTERP_KERNEL.operator!=	(	const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &	__ht1,
		const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &	__ht2
	)

template<class _Val , class _Key , class _HF , class _Extract , class _EqKey , class _All >

void INTERP_KERNEL.swap	(	hashtable< _Val, _Key, _HF, _Extract, _EqKey, _All > &	__ht1,
		hashtable< _Val, _Key, _HF, _Extract, _EqKey, _All > &	__ht2
	)

References INTERP_KERNEL.hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc >.swap().

void INTERP_KERNEL.computeEigenValues6	(	const double *	matrix,
		double *	eigenVals
	)

This method computes eigenvalues of a 3x3 symetric matrix stored with 6 values in 'matrix'. The convension chosen for 'matrix' is described here: matrix[0]=m_xx, matrix[1]=m_yy, matrix[2]=m_zz, matrix[3]=m_xy, matrix[4]=m_yz, matrix[5]=m_xz This method returns the 3 eigenvalues in 'eigenVals'.

References med_test_grid.K.

void INTERP_KERNEL.computeEigenVectorForEigenValue6	(	const double *	matrix,
		double	eigenVal,
		double	eps,
		double *	eigenVector
	)		throw (INTERP_KERNEL::Exception)

This method computes one eigenvector of a 3x3 symetric matrix stored with 6 values in 'matrix'. The convension chosen for 'matrix' is described here: matrix[0]=m_xx, matrix[1]=m_yy, matrix[2]=m_zz, matrix[3]=m_xy, matrix[4]=m_yz, matrix[5]=m_xz This method returns the eigenvector of the corresponding eigenvalue in 'eigenVal'. The returned eigenValue is normalized.

References norm().

template<class U , NumberingPolicy type>

std::ostream& INTERP_KERNEL.operator<<	(	std::ostream &	in,
		const Matrix< U, type > &	m
	)

template<class U , NumberingPolicy type>

std::istream& INTERP_KERNEL.operator>>	(	std::istream &	in,
		Matrix< U, type > &	m
	)

template<class T , NumberingPolicy type>

std::ostream& INTERP_KERNEL.operator<<	(	std::ostream &	out,
		const Matrix< T, type > &	m
	)

output to an ascii file only nonzero elements are written

the first line contains the indexing (0 or 1)
the second line contains the number of rows.
for each row, a line contains:
the number of nonzero coeffs
and for each coeff : icol, value

for instance, matrix | 1.0 0.0 0.5 | | 0.0 1.0 0.0 | | 0.2 0.0 1.0 | will be displayed in 0-indexing as 0 3 2 0 1.0 2 0.5 1 1 1.0 2 0 0.2 2 1.0

template<class T , NumberingPolicy type>

std::istream& INTERP_KERNEL.operator>>	(	std::istream &	in,
		Matrix< T, type > &	m
	)

References INTERP_KERNEL.Matrix< T, type >._auxiliary_matrix, INTERP_KERNEL.Matrix< T, type >._nb_rows, and batchmode_medcorba_test.value.

double INTERP_KERNEL::quadSkew ( const double * coo )

double INTERP_KERNEL::quadEdgeRatio ( const double * coo )

References TestMedCorba5.c2.

double INTERP_KERNEL::quadAspectRatio ( const double * coo )

References testGaussLocalization.a, testGaussLocalization.b, and TestMedCorba3.d.

double INTERP_KERNEL::quadWarp ( const double * coo )

References TestMedCorba4.e1, TestMedCorba4.e2, TestMedCorba4.n1, TestMedCorba4.n2, and med_test_grid.n3.

double INTERP_KERNEL::triEdgeRatio ( const double * coo )

References TestMedCorba5.c2.

double INTERP_KERNEL::triAspectRatio ( const double * coo )

References testGaussLocalization.a, testGaussLocalization.b, and TestMedCorba3.d.

double INTERP_KERNEL::tetraEdgeRatio ( const double * coo )

References testGaussLocalization.a, testGaussLocalization.b, TestMedCorba3.d, and MEDCouplingCorbaSwigTestClt.f.

double INTERP_KERNEL::tetraAspectRatio ( const double * coo )

References TestMedCorba1.C.

double INTERP_KERNEL.Surf_Tri	(	const double *	P_1,
		const double *	P_2,
		const double *	P_3
	)

double INTERP_KERNEL.mon_determinant	(	const double *	P_1,
		const double *	P_2,
		const double *	P_3
	)

double INTERP_KERNEL.norme_vecteur	(	const double *	P_1,
		const double *	P_2
	)

std::vector<double> INTERP_KERNEL.calcul_cos_et_sin	(	const double *	P_1,
		const double *	P_2,
		const double *	P_3
	)

References mon_determinant(), and norme_vecteur().

template<int SPACEDIM>

void INTERP_KERNEL.fillDualCellOfTri	(	const double *	triIn,
		double *	quadOut
	)

This method builds a quadrangle built with the first point of 'triIn' the barycenter of two edges starting or ending with the first point of 'triIn' and the barycenter of 'triIn'.

Parameters:

triIn	is a 6 doubles array in full interlace mode, that represents a triangle.
quadOut	is a 8 doubles array filled after the following call.

template<int SPACEDIM>

void INTERP_KERNEL.fillDualCellOfPolyg	(	const double *	polygIn,
		int	nPtsPolygonIn,
		double *	polygOut
	)

This method builds a potentially non-convex polygon cell built with the first point of 'triIn' the barycenter of two edges starting or ending with the first point of 'triIn' and the barycenter of 'triIn'.

Parameters:

triIn	is a 6 doubles array in full interlace mode, that represents a triangle.
quadOut	is a 8 doubles array filled after the following call.

std::vector<double> INTERP_KERNEL.bary_poly ( const std::vector< double > & V )

double INTERP_KERNEL.computeTria6RefBase	(	const double *	coeffs,
		const double *	pos
	)

Given 6 coeffs of a Tria6 returns the corresponding value of a given pos

void INTERP_KERNEL.computeWeightedCoeffsInTria6FromRefBase	(	const double *	refCoo,
		double *	weightedPos
	)

Given xsi,eta in refCoo (length==2) return 6 coeffs in weightedPos.

double INTERP_KERNEL.computeTetra10RefBase	(	const double *	coeffs,
		const double *	pos
	)

Given 10 coeffs of a Tetra10 returns the corresponding value of a given pos

void INTERP_KERNEL.computeWeightedCoeffsInTetra10FromRefBase	(	const double *	refCoo,
		double *	weightedPos
	)

Given xsi,eta,z in refCoo (length==3) return 10 coeffs in weightedPos.

template<unsigned nbRow>

bool INTERP_KERNEL.solveSystemOfEquations	(	double	M[nbRow][nbRow+1],
		double *	sol
	)

Solve system equation in matrix form using Gaussian elimination algorithm.

Parameters:

M	- N x N+1 matrix
sol	- vector of N solutions

Return values:

bool	- true if succeeded

References TestMedCorba2.m, and swap().

template<unsigned SZ, unsigned NB_OF_RES>

bool INTERP_KERNEL.solveSystemOfEquations2	(	const double *	matrix,
		double *	solutions,
		double	eps
	)

Solve system equation in matrix form using Gaussian elimination algorithm.

Parameters:

M	- N x N+NB_OF_VARS matrix
sol	- vector of N solutions

Return values:

bool	- true if succeeded

References TestMedCorba2.m, TestMedCorba2.n, TestMedCorba7.s, and swap().

template<int SPACEDIM>

void INTERP_KERNEL.barycentric_coords	(	const double *	triaCoords,
		const double *	p,
		double *	bc
	)

void INTERP_KERNEL.barycentric_coords	(	const std::vector< const double * > &	n,
		const double *	p,
		double *	bc
	)

Calculate barycentric coordinates of a point p with respect to triangle or tetra verices. This method makes 2 assumptions :

this is a simplex
spacedim == meshdim. For TRI3 and TRI6 spaceDim is expected to be equal to 2 and for TETRA4 spaceDim is expected to be equal to 3. If not the case (3D surf for example) a previous projection should be done before.

References _X, _Y, _Z, computeTetra10RefBase(), computeTria6RefBase(), computeWeightedCoeffsInTetra10FromRefBase(), computeWeightedCoeffsInTria6FromRefBase(), and testGaussLocalization.refCoo.

double INTERP_KERNEL.Surf_Poly ( const std::vector< double > & Poly )

References Surf_Tri().

bool INTERP_KERNEL.point_dans_triangle	(	const double *	P_0,
		const double *	P_1,
		const double *	P_2,
		const double *	P_3,
		double	eps
	)

References mon_determinant().

void INTERP_KERNEL.verif_point_dans_vect	(	const double *	P,
		std::vector< double > &	V,
		double	absolute_precision
	)

void INTERP_KERNEL.rajou_sommet_triangl	(	const double *	P_1,
		const double *	P_2,
		const double *	P_3,
		const double *	P_4,
		const double *	P_5,
		const double *	P_6,
		std::vector< double > &	V,
		double	dim_caracteristic,
		double	precision
	)

References point_dans_triangle(), and verif_point_dans_vect().

void INTERP_KERNEL.inters_de_segment	(	const double *	P_1,
		const double *	P_2,
		const double *	P_3,
		const double *	P_4,
		std::vector< double > &	Vect,
		double	dim_caracteristic,
		double	precision
	)

References verif_point_dans_vect().

void INTERP_KERNEL.intersec_de_triangle	(	const double *	P_1,
		const double *	P_2,
		const double *	P_3,
		const double *	P_4,
		const double *	P_5,
		const double *	P_6,
		std::vector< double > &	Vect,
		double	dim_caracteristic,
		double	precision
	)

References inters_de_segment(), and rajou_sommet_triangl().

void INTERP_KERNEL.verif_maill_dans_vect	(	int	Num,
		std::vector< int > &	V
	)

std::vector<double> INTERP_KERNEL.reconstruct_polygon ( const std::vector< double > & V )

References bary_poly(), and calcul_cos_et_sin().

template<int DIM, NumberingPolicy numPol, class MyMeshType >

void INTERP_KERNEL.getElemBB	(	double *	bb,
		const double *	coordsOfMesh,
		int	iP,
		int	nb_nodes
	)

template<int dim>

double INTERP_KERNEL.dotprod	(	const double *	a,
		const double *	b
	)

template<int dim>

double INTERP_KERNEL::norm ( const double * v )

Calculates norm of a double[3] vector.

Parameters:

v	a vector v

Returns:: euclidean norm of v

template<int dim>

double INTERP_KERNEL.distance2	(	const double *	a,
		const double *	b
	)

template<class T , int dim>

double INTERP_KERNEL.distance2	(	T *	a,
		int	inda,
		T *	b,
		int	indb
	)

double INTERP_KERNEL.determinant	(	double *	a,
		double *	b
	)

double INTERP_KERNEL.determinant	(	double *	a,
		double *	b,
		double *	c
	)

References determinant().

template<int dim>

void INTERP_KERNEL.crossprod	(	const double *	A,
		const double *	B,
		const double *	C,
		double *	V
	)

template<>

void INTERP_KERNEL.crossprod< 2 >	(	const double *	A,
		const double *	B,
		const double *	C,
		double *	V
	)

References TestMedCorba1.C, and determinant().

template<>

void INTERP_KERNEL.crossprod< 3 >	(	const double *	A,
		const double *	B,
		const double *	C,
		double *	V
	)

References TestMedCorba1.C.

template<>

void INTERP_KERNEL.crossprod< 1 >	(	const double *	A,
		const double *	B,
		const double *	C,
		double *	V
	)

template<int dim>

double INTERP_KERNEL.check_inside	(	const double *	A,
		const double *	B,
		const double *	C,
		const double *	D,
		const double *	E,
		double *	ABC,
		double *	ADE
	)

References TestMedCorba1.C.

template<int dim>

double INTERP_KERNEL.angle	(	const double *	A,
		const double *	B,
		const double *	C,
		double *	n
	)

template<int dim>

double INTERP_KERNEL.direct_frame	(	const double *	A,
		const double *	B,
		const double *	C,
		double *	n
	)

template<>

double INTERP_KERNEL.direct_frame< 2 >	(	const double *	A,
		const double *	B,
		const double *	C,
		double *	n
	)

References TestMedCorba1.C, determinant(), and TestMedCorba2.n.

template<>

double INTERP_KERNEL.direct_frame< 3 >	(	const double *	A,
		const double *	B,
		const double *	C,
		double *	n
	)

References TestMedCorba1.C, determinant(), and TestMedCorba2.n.

template<int DIM>

void INTERP_KERNEL.intersec_de_polygone	(	const double *	Coords_A,
		const double *	Coords_B,
		int	nb_NodesA,
		int	nb_NodesB,
		std::vector< double > &	inter,
		double	dim_caracteristic,
		double	precision
	)

References intersec_de_triangle(), and reconstruct_polygon().

template<int DIM>

double INTERP_KERNEL.polygon_area ( std::vector< double > & inter )

References med_test1.area.

template<int DIM>

double INTERP_KERNEL.polygon_area ( std::deque< double > & inter )

References med_test1.area.

double INTERP_KERNEL.triple_product	(	const double *	A,
		const double *	B,
		const double *	C,
		const double *	X
	)

Computes the triple product (XA^XB).XC (in 3D)

template<class T , int dim>

bool INTERP_KERNEL.checkEqualPolygonsOneDirection	(	T *	L1,
		T *	L2,
		int	size1,
		int	size2,
		int	istart1,
		int	istart2,
		double	epsilon,
		int	sign
	)

Subroutine of checkEqualPolygins that tests if two list of nodes (not necessarily distincts) describe the same polygon, assuming they share a comon point.

Indexes istart1 and istart2 designate two points P1 in L1 and P2 in L2 that have identical coordinates. Generally called with istart1=0.

Integer sign ( 1 or -1) indicate the direction used in going all over L2.

References test_NonCoincidentDEC.epsilon.

template<class T , int dim>

bool INTERP_KERNEL.checkEqualPolygons	(	T *	L1,
		T *	L2,
		double	epsilon
	)

Tests if two list of nodes (not necessarily distincts) describe the same polygon.

Existence of multiple points in the list is considered.

References test_NonCoincidentDEC.epsilon.

template<class MyMeshType >

MyMeshType::MyConnType INTERP_KERNEL.getGlobalNumberOfNode	(	typename MyMeshType::MyConnType	node,
		typename MyMeshType::MyConnType	element,
		const MyMeshType &	mesh
	)

Returns the global number of the node of an element.

Parameters:

node	the node for which the global number is sought (ALWAYS in C mode)
element	an element of the mesh (in numPol policy)
mesh	a mesh

Returns:: the node's global number so that (its coordinates in the coordinates array are at [SPACEDIM*globalNumber, SPACEDIM*globalNumber + SPACEDIM]

References NORM_POLYHED, and testMEDMEM.ret.

template<class MyMeshType >

const double* INTERP_KERNEL.getCoordsOfNode	(	typename MyMeshType::MyConnType	node,
		typename MyMeshType::MyConnType	element,
		const MyMeshType &	mesh
	)

Returns the coordinates of a node of an element.

Parameters:

node	the node for which the coordinates are sought. In C mode.
element	an element of the mesh. In mesh policy.
mesh	a mesh

Returns:: pointer to an array of 3 doubles containing the coordinates of the node

References getGlobalNumberOfNode(), and testMEDMEM.ret.

template<class MyMeshType >

const double* INTERP_KERNEL.getCoordsOfNode2	(	typename MyMeshType::MyConnType	node,
		typename MyMeshType::MyConnType	element,
		const MyMeshType &	mesh,
		typename MyMeshType::MyConnType &	nodeId
	)

Returns the coordinates of a node of an element.

Parameters:

node	the node for which the coordinates are sought. In C mode.
element	an element of the mesh. In mesh policy.
mesh	a mesh
nodeId	globale nodeId in whole mesh point of view in C mode.

Returns:: pointer to an array of 3 doubles containing the coordinates of the node

References getGlobalNumberOfNode().

template<class MyMeshType , int NB_NODES>

void INTERP_KERNEL.getBarycentricCoordinates	(	const double *	point,
		typename MyMeshType::MyConnType	element,
		const MyMeshType &	mesh,
		double *	barycentricCoords
	)

Returns the barycentric coordinates of a point within a triangle or tetrahedron.

Parameters:

point	the point for which the barycentric coordinates are sought
element	an element of the mesh
mesh	a mesh
barycentricCoords	an array of 3 doubles containing the coordinates of the node

References barycentric_coords(), getCoordsOfNode(), and nodes.

bool INTERP_KERNEL.samePoint	(	const double *	p1,
		const double *	p2
	)

References epsilonEqual().

template<int SPACEDIM>

double INTERP_KERNEL.getDistanceBtw2Pts	(	const double *	a,
		const double *	b
	)

Parameters:

a	first point. Should point on a array of size at least equal to SPACEDIM.
b	second point. Should point on a array of size at least equal to SPACEDIM.

void INTERP_KERNEL.copyVector3	(	const double *	src,
		double *	dest
	)

Copies a double[3] vector from src to dest.

Parameters:

src	source vector
dest	destination vector

const std::string INTERP_KERNEL.vToStr ( const double * pt )

Creates a string representation of a double[3] vector.

Parameters:

pt	a 3-vector

Returns:: a string of the form [x, y, z]

void INTERP_KERNEL.cross	(	const double *	v1,
		const double *	v2,
		double *	res
	)

Calculates the cross product of two double[3] - vectors.

Parameters:

v1	vector v1
v2	vector v2
res	vector in which to store the result v1 x v2. It should not be one of v1 and v2.

double INTERP_KERNEL.dot	(	const double *	v1,
		const double *	v2
	)

Calculates the dot product of two double[3] - vectors.

Parameters:

v1	vector v1
v2	vector v2

Returns:: dot (scalar) product v1.v2

bool INTERP_KERNEL.epsilonEqual	(	const double	x,
		const double	y,
		const double	errTol = `DEFAULT_ABS_TOL`
	)

Compares doubles using an absolute tolerance This is suitable mainly for comparisons with 0.0.

Parameters:

x	first value
y	second value
errTol	maximum allowed absolute difference that is to be treated as equality

Returns:: true if |x - y| < errTol, false otherwise

bool INTERP_KERNEL.epsilonEqualRelative	(	const double	x,
		const double	y,
		const double	relTol = `DEFAULT_REL_TOL`,
		const double	absTol = `DEFAULT_ABS_TOL`
	)

Compares doubles using a relative tolerance This is suitable mainly for comparing larger values to each other.

Before performing the relative test, an absolute test is performed to guard from problems when comparing to 0.0

Parameters:

x	first value
y	second value
relTol	maximum allowed relative difference that is to be treated as equality
absTol	maximum allowed absolute difference that is to be treated as equality

Returns:: true if |x - y| <= absTol or |x - y|/max(|x|,|y|) <= relTol, false otherwise

void INTERP_KERNEL::calculateBarycenterDyn	(	const double **	pts,
		int	nbPts,
		int	dim,
		double *	bary
	)

double INTERP_KERNEL::calculateAreaForPolyg	(	const double **	coords,
		int	nbOfPtsInPolygs,
		int	spaceDim
	)

References calculateAreaForTria(), calculateBarycenterDyn(), and testMEDMEM.ret.

double INTERP_KERNEL.calculateLgthForSeg2	(	const double *	p1,
		const double *	p2,
		int	spaceDim
	)

References testGaussLocalization.p1, testMEDMEM.ret, and batchmode_medcorba_test.spaceDim.

double INTERP_KERNEL.calculateAreaForTria	(	const double *	p1,
		const double *	p2,
		const double *	p3,
		int	spaceDim
	)

References med_test1.area.

double INTERP_KERNEL.calculateAreaForQuad	(	const double *	p1,
		const double *	p2,
		const double *	p3,
		const double *	p4,
		int	spaceDim
	)

References med_test1.area, TestMedCorba5.c1, and TestMedCorba5.c2.

void INTERP_KERNEL.calculateNormalForTria	(	const double *	p1,
		const double *	p2,
		const double *	p3,
		double *	normal
	)

void INTERP_KERNEL.calculateNormalForQuad	(	const double *	p1,
		const double *	p2,
		const double *	p3,
		const double *	p4,
		double *	normal
	)

References calculateAreaForQuad().

void INTERP_KERNEL.calculateNormalForPolyg	(	const double **	coords,
		int	nbOfPtsInPolygs,
		double *	normal
	)

References calculateAreaForPolyg(), and calculateBarycenterDyn().

double INTERP_KERNEL.calculateVolumeForTetra	(	const double *	p1,
		const double *	p2,
		const double *	p3,
		const double *	p4
	)

double INTERP_KERNEL.calculateVolumeForPyra	(	const double *	p1,
		const double *	p2,
		const double *	p3,
		const double *	p4,
		const double *	p5
	)

double INTERP_KERNEL.calculateVolumeForPenta	(	const double *	p1,
		const double *	p2,
		const double *	p3,
		const double *	p4,
		const double *	p5,
		const double *	p6
	)

References TestMedCorba1.C, TestMedCorba5.c1, TestMedCorba5.c2, TestMedCorba4.e1, TestMedCorba4.e2, and testDriverAscii.f1.

double INTERP_KERNEL.calculateVolumeForHexa	(	const double *	pt1,
		const double *	pt2,
		const double *	pt3,
		const double *	pt4,
		const double *	pt5,
		const double *	pt6,
		const double *	pt7,
		const double *	pt8
	)

References TestMedCorba1.C, TestMedCorba5.c1, TestMedCorba5.c2, TestMedCorba4.e1, TestMedCorba4.e2, testDriverAscii.f1, med_test_grid.I, med_test_grid.J, med_test_grid.K, testGaussLocalization.p1, testGaussLocalization.p2, TestMedCorba3.s1, and TestMedCorba3.s2.

double INTERP_KERNEL.calculateVolumeForPolyh	(	const double ***	pts,
		const int *	nbOfNodesPerFaces,
		int	nbOfFaces,
		const double *	bary
	)

References calculateNormalForPolyg(), med_test1.normal, and med_test1.volume.

template<class ConnType , NumberingPolicy numPol>

double INTERP_KERNEL.calculateVolumeForPolyh2	(	const ConnType *	connec,
		int	lgth,
		const double *	coords
	)

Calculate Volume for Generic Polyedron, even not convex one, WARNING !!! The polyedron's faces must be correctly ordered. 2nd API avoiding to create double** arrays. The returned value could be negative if polyhedrons faces are not oriented with normal outside of the polyhedron

References med_test1.volume.

template<class ConnType , NumberingPolicy numPol>

void INTERP_KERNEL.areaVectorOfPolygon	(	const ConnType *	connec,
		int	lgth,
		const double *	coords,
		double *	res
	)

This method returns the area oriented vector of a polygon. This method is useful for normal computation without any troubles if several edges are colinears.

Parameters:

res	must be of size at least 3 to store the result.

double INTERP_KERNEL.integrationOverA3DLine	(	double	u1,
		double	v1,
		double	u2,
		double	v2,
		double	A,
		double	B,
		double	C
	)

template<class ConnType , NumberingPolicy numPol>

void INTERP_KERNEL.barycenterOfPolyhedron	(	const ConnType *	connec,
		int	lgth,
		const double *	coords,
		double *	res
	)

References coords, integrationOverA3DLine(), med_test1.normal, testGaussLocalization.p1, testGaussLocalization.p2, and TestMedCorba7.s.

double INTERP_KERNEL.calculateVolumeForPolyhAbs	(	const double ***	pts,
		const int *	nbOfNodesPerFaces,
		int	nbOfFaces,
		const double *	bary
	)

References calculateNormalForPolyg(), med_test1.normal, and med_test1.volume.

template<int N>

double INTERP_KERNEL.addComponentsOfVec	(	const double **	pts,
		int	rk
	)

template<>

double INTERP_KERNEL.addComponentsOfVec< 1 >	(	const double **	pts,
		int	rk
	)

template<int N, int DIM>

void INTERP_KERNEL.calculateBarycenter	(	const double **	pts,
		double *	bary
	)

template<>

void INTERP_KERNEL.calculateBarycenter< 2, 0 >	(	const double **	pts,
		double *	bary
	)

template<>

void INTERP_KERNEL.calculateBarycenter< 3, 0 >	(	const double **	pts,
		double *	bary
	)

template<>

void INTERP_KERNEL.calculateBarycenter< 4, 0 >	(	const double **	pts,
		double *	bary
	)

template<>

void INTERP_KERNEL.calculateBarycenter< 5, 0 >	(	const double **	pts,
		double *	bary
	)

template<>

void INTERP_KERNEL.calculateBarycenter< 6, 0 >	(	const double **	pts,
		double *	bary
	)

template<>

void INTERP_KERNEL.calculateBarycenter< 7, 0 >	(	const double **	pts,
		double *	bary
	)

template<>

void INTERP_KERNEL.calculateBarycenter< 8, 0 >	(	const double **	pts,
		double *	bary
	)

template<int SPACEDIM>

void INTERP_KERNEL.calculateBarycenterDyn2	(	const double *	pts,
		int	nbPts,
		double *	bary
	)

template<class ConnType , NumberingPolicy numPol>

void INTERP_KERNEL.computePolygonBarycenter2D	(	const ConnType *	connec,
		int	lgth,
		const double *	coords,
		double *	res
	)

References med_test1.area.

template<class ConnType , NumberingPolicy numPol>

void INTERP_KERNEL.computePolygonBarycenter3D	(	const ConnType *	connec,
		int	lgth,
		const double *	coords,
		double *	res
	)

References med_test1.area, coords, and norm().

template<class ConnType , NumberingPolicy numPolConn, int SPACEDIM>

double INTERP_KERNEL.computeVolSurfOfCell	(	NormalizedCellType	type,
		const ConnType *	connec,
		int	lgth,
		const double *	coords
	)

template<class ConnType , NumberingPolicy numPolConn>

double INTERP_KERNEL.computeVolSurfOfCell2	(	NormalizedCellType	type,
		const ConnType *	connec,
		int	lgth,
		const double *	coords,
		int	spaceDim
	)

template<class ConnType , NumberingPolicy numPolConn, int SPACEDIM>

void INTERP_KERNEL.computeBarycenter	(	NormalizedCellType	type,
		const ConnType *	connec,
		int	lgth,
		const double *	coords,
		double *	res
	)

template<class ConnType , NumberingPolicy numPolConn>

void INTERP_KERNEL.computeBarycenter2	(	NormalizedCellType	type,
		const ConnType *	connec,
		int	lgth,
		const double *	coords,
		int	spaceDim,
		double *	res
	)

Variable Documentation

const unsigned long INTERP_KERNEL.__stl_prime_list[_S_num_primes] [static]

Initial value:

    {
      53ul,         97ul,         193ul,       389ul,       769ul,
      1543ul,       3079ul,       6151ul,      12289ul,     24593ul,
      49157ul,      98317ul,      196613ul,    393241ul,    786433ul,
      1572869ul,    3145739ul,    6291469ul,   12582917ul,  25165843ul,
      50331653ul,   100663319ul,  201326611ul, 402653189ul, 805306457ul,
      1610612741ul, 3221225473ul, 4294967291ul
    }

const unsigned INTERP_KERNEL::MAX_SIZE_OF_LINE_XFIG_FILE = 1024

const double INTERP_KERNEL.VOL_PREC = 1.0e-6

Precision used for tests of 3D part of INTERP_KERNEL.

const double INTERP_KERNEL.DEFAULT_REL_TOL = 1.0e-6

Default relative tolerance in epsilonEqualRelative.

const double INTERP_KERNEL.DEFAULT_ABS_TOL = 5.0e-12

Default absolute tolerance in epsilonEqual and epsilonEqualRelative.

Package INTERP_KERNEL

Packages

Data Structures

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation