xlifepp – Functions – T#
tan#
-
inline SuTermVector xlifepp::tan(const SuTermVector &s)#
-
inline SymbolicFunction &xlifepp::tan(const SymbolicFunction &f)#
-
inline TermVector xlifepp::tan(const TermVector &s)#
tangent_Piecewise#
-
inline Vector<real_t> xlifepp::tangent_Piecewise(const Point &pt, Parameters &pars, DiffOpType d = _id)#
-
extern parametrization call
tanh#
-
inline SuTermVector xlifepp::tanh(const SuTermVector &s)#
-
inline SymbolicFunction &xlifepp::tanh(const SymbolicFunction &f)#
-
inline TermVector xlifepp::tanh(const TermVector &s)#
tensorCrossProduct#
-
SuTermVector xlifepp::tensorCrossProduct(const SuTermVector &tv1, const SuTermVector &tv2)#
-
tensor cross product => vector SuTermVector in 3D, scalar SuTermVector in 2D
tensor hermitian product => scalar SuTermVector
-
TermVector xlifepp::tensorCrossProduct(const TermVector &s1, const TermVector &s2)#
-
tensor cross product of single unknown vector TermVector => single unknown vector/scalar TermVector (in 3D/2D)
tensorHermitianProduct#
-
SuTermVector xlifepp::tensorHermitianProduct(const SuTermVector &tv1, const SuTermVector &tv2)#
-
tensor hermitian product => scalar SuTermVector (conjugate tv2 if it is complex) produce vector of hermitian product of components SuTermVector must have same same dofs and same number of components the SutermVector result has unknown and space of tv1
tensor inner product => scalar SuTermVector (not conjugate)
-
TermVector xlifepp::tensorHermitianProduct(const TermVector &s1, const TermVector &s2)#
-
tensor hermitian product of single unknown vector TermVector => single unknown scalar TermVector
tensorHexahedronSideNumbering#
-
void xlifepp::tensorHexahedronSideNumbering(number_t *&sh1, number_t *&sh2, number_t &p, const int interpNum, const number_t qq1, const number_t qq2, const number_t qq3, const number_t qq4, const short int sens)#
-
correspondence between segment and quadrangular face numbering
correspondence between segment and hexahedron face local numbering
Examples of local numbering of Lagrange Pk 1D elements
2----1 2---3---1 2---4---3---1 2---5---4---3---1 2---6---5---4---3---1 k=1 k=2 k=3 k=4 k=5
point number p has coordinates defined by
( x = coords[s2h[0][p]], y = coords[s2h[1][p]], z = coords[s2h[3][p]] )
where coords are coordinates of the associated 1D Lagrange reference element
and
shape functions are defined by tensor product of shape functions of the 1D reference element
w3_p(x,y,z) = w1_{s2h[0][p]}(x) * w1_{s2h[1][p]}(y) * w1_{s2h[2][p]}(z)
where w1_k is the k-th shape function of the associated 1D Lagrange reference element
tensorInnerProduct#
-
SuTermVector xlifepp::tensorInnerProduct(const SuTermVector &tv1, const SuTermVector &tv2)#
-
tensor inner product => scalar SuTermVector (not conjugate when tv2 is complex) produce vector of inner product of components SuTermVector must have same same dofs and same number of components the SutermVector result has unknown and space of tv1
-
TermVector xlifepp::tensorInnerProduct(const TermVector &s1, const TermVector &s2)#
-
tensor inner product of single unknown vector TermVector => single unknown scalar TermVector (not conjugate)
tensorNumbering#
tensorNumberingHexahedron#
tensorNumberingQuadrangle#
-
void xlifepp::tensorNumberingQuadrangle(const int interpNum, std::vector<number_t> &s2q)#
-
tensorNumberingQuadrangle: correspondence between segment and quadrangle local numbering
correspondence between segment and quadrangle local numbering
point number p has coordinates defined by ( x = coords[s2q[2*p]], y = coords[s2q[2*p+1]] ) where coords are coordinates of the associated 1D Lagrange reference element and shape functions are defined by tensor product of shape functions of the 1D reference element w2_p(x,y) = w1_{s2q[2*p]}(x) * w1_{s2q[2*p+1]}(y) where w1_k is the k-th shape function of the associated 1D Lagrange reference element
tensorNumberingTetrahedron#
-
void xlifepp::tensorNumberingTetrahedron(const int interpNum, number_t **&s2t)#
-
correspondance between segment and tetrahedron local numbering defined such that
correspondence between segment and hexahedron local numbering such that
point number p has coordinates defined by
( x = coords[s2h[0][p]], y = coords[s2h[1][p]], z = coords[s2h[3][p]] ) where coords are coordinates of the associated 1D Lagrange reference element -— No longer used –—
tensorNumberingTriangle#
-
void xlifepp::tensorNumberingTriangle(const int interpNum, std::vector<number_t> &s2t)#
-
point number p has coordinates defined by ( x = coords[s2q[2*p]], y = coords[s2q[2*p+1]] ) where coords are coordinates of the associated 1D Lagrange reference element
correspondence between segment and triangle local numbering
Examples of local numbering of Lagrange Pk 1D elements 2—1 2—3—1 2—4—3—1 2—5—4—3—1 2—6—5—4—3—1 2—7—6—5—4—3—1 . k=1 k=2 k=3 k=4 k=5 k=6 Examples of local numbering of Lagrange Pk triangles
2 2 2 2 2 2 | \ | \ | \ | \ | \ | \ 3—1 5 4 5 7 5 10 5 13 5 16 . k=1 | \ | \ | \ | \ | \ ……. 3—6—1 8 10 4 8 14 7 8 17 10 8 20 13 ………. k=2 | \ | | \ \ | | \ \ | | \ \ ……………… 3—6—9—1 11 15—13 4 11 20 19 7 11 23 25 10 …………………… k=3 | \ | | \ \ | | \ \ …………………………… 3—6—9—12—1 14 18—21—16 4 14 26 28 22 7 …………………………………… k=4 | \ | | \ \ ……………………………………………. 3—6—9—12—15—1 17 21—24—27—19 4 ……………………………………………………. k=5 | \ ………………………………………………………………… 3—6—9—12—15—18—1 ………………………………………………………………………….. k=6
tensorOpAdd#
-
template<typename T, typename KU, typename KV>
inline void xlifepp::tensorOpAdd(const AlgebraicOperator &op, const std::vector<KU> &u, number_t nu, const std::vector<KV> &v, number_t nv, Matrix<T> &mat, const T &alpha, bool isDiag = false)#
-
evaluate “tensor” operation between 2 small vectors, and add it to a given a nu x nv matrix mat (stored by rows)
op: algebraic operator involved (either product, inner product, cross product, contracted product) alpha is a coefficient applied to the added “tensor” matrix u (resp. v) is
either a list of nu scalar values (resp. nv scalar values)
or a list of nbu (resp. nbv) vector values (u_1,u_2,..u_nu) stored as (u_1)1 …(u_1)mu (u_2)1 … (u_2)mu …..(u_nu)1 …(u_nu)mu with mu=u.size()/nu for scalar case (mu=mv=1) all product are equivalent for vector case (mu=mv>1) only inner product is currently available for matrix case (mu=mv>1) only contracted product is currently available when isDiag=true deal only with diagonal coefficients
-
template<typename T, typename iteratorM, typename iteratorK>
inline void xlifepp::tensorOpAdd(const AlgebraicOperator &opu, const AlgebraicOperator &opv, const std::vector<T> &u, number_t nu, const std::vector<T> &v, number_t nv, iteratorM itm, iteratorK itk, number_t mk, number_t nk)#
-
evaluate “tensor” operation between 2 small vectors and “coefficient” ker, and add it to a given a nu x nv matrix mat (stored by rows) u opu ker opv v u (resp.
v) is
either a list of nu scalar values (resp. nv scalar values)
or a list of nbu (resp. nbv) vector values (u_1,u_2,..u_nu) stored as (u_1)1 …(u_1)mu (u_2)1 … (u_2)mu …..(u_nu)1 …(u_nu)mu with mu=u.size()/nu for scalar case (mu=mv=1) all product are equivalent for vector case (mu=mv>1) only inner product is currently available
itk is an iterator to the kernel part (either a scalar, a vector (mk or nk) or a matrix (mk x nk))
tensorProductTpl#
-
template<typename T1_iterator, typename T2_iterator, typename R_iterator>
void xlifepp::tensorProductTpl(T1_iterator b1, T1_iterator e1, T2_iterator b2, T2_iterator e2, R_iterator Rb)#
-
accumulated tensor product: “R[i,j] = R[i,j] + T1[i] * T2[j]”
tensorTetrahedronSideNumbering#
tetrahedraIntersect#
tetrahedraOverlap#
-
bool xlifepp::tetrahedraOverlap(const std::vector<Point> &t1, const std::vector<Point> &t2)#
-
implementation of the “Separating Axis Test” for a pair of tetrahedra
determines if 2 tetrahedra overlap
The main idea is that if tetrahedra does not overlap, there exists an axis where their projections does not overlap This axis has one of the following properties:
the axis is orthogonal to one face of one of the tetrahedra
the axis is orthogonal to an edge on each tetrahedron
overlapping means intersection has a non null measure
The main idea of the method is to test each face of both tetrahedra then test each pair of edges (one per tetrahedron) If one of these elementary tests separates, then false is returned (no overlap), else their is overlapping
tetrahedronCrouzeixRaviartStd#
-
RefElement *xlifepp::tetrahedronCrouzeixRaviartStd(const Interpolation *interp_p)#
-
tetrahedronCrouzeixRaviartStd construction of a CrouzeixRaviart Reference Element by interpolation number
tetrahedronLagrangeStd#
-
RefElement *xlifepp::tetrahedronLagrangeStd(const Interpolation *interp_p)#
-
tetrahedronLagrangeStd construction of a Lagrange standard Reference Element by interpolation number particular formulae up to P3 else general method using monomes basis
tetrahedronNedelecEdge#
-
RefElement *xlifepp::tetrahedronNedelecEdge(const Interpolation *interp_p)#
tetrahedronNedelecFace#
-
RefElement *xlifepp::tetrahedronNedelecFace(const Interpolation *interp_p)#
tetrahedronQuadrature#
-
Quadrature *xlifepp::tetrahedronQuadrature(QuadRule, number_t)#
-
find or create quadrature rule over the unit tetrahedron
tetrahedronVolume#
theDate#
-
string_t xlifepp::theDate()#
-
returns current date as dd.mmm.yyyy
returns current date as dd.mmm.yyyy e.g.
29.feb.2004
theIsoDate#
-
string_t xlifepp::theIsoDate()#
-
returns ISO8601 format of current date (yyyy-mm-dd)
returns ISO8601 format of current date (yyyy-mm-dd), e.g.
2004-02-29
theIsoTime#
-
string_t xlifepp::theIsoTime()#
-
returns ISO8601 format of current date (hh-mi-ss)
returns ISO8601 format of current time (hh-mi-ss), e.g.
04-39-51
theLongDate#
-
string_t xlifepp::theLongDate()#
-
returns current date as Month Day, Year (en) or Day Month Year (fr)
theShortDate#
-
string_t xlifepp::theShortDate()#
-
returns current date as mm/dd/yyyy (en) or dd/mm/yyyy (fr)
theTime#
-
string_t xlifepp::theTime()#
-
returns current time
returns current time e.g.
04h32
timerInit#
-
void xlifepp::timerInit()#
-
initialization procedure for time handling
initialization of engine for time handling
timesn#
-
OperatorOnFunction &xlifepp::timesn(const Function&)#
-
f*n
-
OperatorOnFunction &xlifepp::timesn(OperatorOnFunction&)#
-
opf*n
timesncrossn#
-
OperatorOnFunction &xlifepp::timesncrossn(const Function&)#
-
f*(n^n)
-
OperatorOnFunction &xlifepp::timesncrossn(OperatorOnFunction&)#
-
opf*(n^n)
to2D#
toBarycentric#
toBarycentricNocheck#
-
Point xlifepp::toBarycentricNocheck(const Point &M, const Point &S1, const Point &S2, const Point &S3, const Point &S4)#
-
return barycentric coordinates of a point M related to segment (S1,S2), to triangle (S1,S3,S3), to tetrahedron (S1,S2,S3,S4) works in 2D, 3D, does not require that M belongs to line (S1,S2) or plane (S1,S2,S3) in that case, it gives the barycentric coordinates of the orthogonal projection of M on line or plane if fails (degenerated simplex), return a void Point
toComplex#
-
inline SuTermVector xlifepp::toComplex(const SuTermVector &s)#
-
TermMatrix xlifepp::toComplex(const TermMatrix &tm)#
-
return the complex representation of the given TermMatrix
-
inline void xlifepp::toComplex(real_t x, real_t y, complex_t &z)#
-
load table from file
-
inline void xlifepp::toComplex(real_t x, real_t y, real_t &z)#
toComposite#
-
Geometry xlifepp::toComposite(const Geometry &g)#
-
conversion of a canonical or loop Geometry into a composite geometry with one component
return a composite geometry with only one component: g
if g is canonical, the components_ vector contains only g
if g is loop, the components_ vector contains every border of g and g itself
if g is composite, it does nothing
this function is necessary when initializing composite Geometry before using += and -= operators
-
Transformation xlifepp::toComposite(const Transformation &t)#
-
conversion of a canonical Transformation into a composite Transformation with one component
return a composite Transformation with only one component: t
if t is canonical, the components_ vector contains only t
if t is composite, it does nothing
this function is necessary when initializing composite Transformation before using += operator
toEllipticCoordinates#
-
Point xlifepp::toEllipticCoordinates(const Point &P, const Point &C, const Point &A1, const Point &A2)#
-
returns (r,theta,phi) coordinates of a point related to an ellipsoid (C center, A1,A2,A3 the three apogees) P-C = r(A1-C)) cos(theta) cos(phi) + r(A2-C) sin(theta) cos(phi) + r(A3-C) sin(phi) r >=0 , azymuth theta in ]-pi,pi], elevation phi in [-pi/2,pi/2] NB: if C=(0,0,0), A1=(1,0,0), A2=(0,1,0), A3=(0,0,1) then it gives the usual sperical coordinates r=1 on the boundary of the ellisoid
returns (r,theta) related to the ellipse (C,A1,A2)
-
Point xlifepp::toEllipticCoordinates(const Point &P, const Point &C, const Point &A1, const Point &A2, const Point &A3)#
-
returns (r,theta,phi) related to the ellipsoid (C,A1,A2,A3)
-
Point xlifepp::toEllipticCoordinates(const Point &P, real_t r1, real_t r2)#
-
returns (r,theta) coordinates of a point related to an a centered orthogonal ellipse with radius r1,r2 calls general case (not the fastest method)
returns (r,theta) related to the orthogonal ellipse of size (r1,r2)
-
Point xlifepp::toEllipticCoordinates(const Point &P, real_t r1, real_t r2, real_t r3)#
-
returns (r,theta,phi) coordinates of a point related to an a centered orthogonal ellipsoid with radius r1,r2,r3 calls general case (not the fastest method)
returns (r,theta,phi) related to the orthogonal ellipsoid of size (r1,r2,r3) compute barycentric coordinates related to segment, triangle or tetrahedron
toOperatorOnUnknown#
-
OperatorOnUnknown xlifepp::toOperatorOnUnknown(const KernelOperatorOnTermVector &koptv)#
-
OperatorOnUnknown xlifepp::toOperatorOnUnknown(const KernelOperatorOnUnknowns&)#
-
move partial KernelOperatorOnUnknowns to OperatorOnUnknown
toPolar#
toRealComplex#
toSpherical#
-
Point xlifepp::toSpherical(const Point &P)#
-
returns (r,theta) coordinates of a point related to an ellipse (C center, A1,A2, the two apogees) P-C = r(A1-C)) cos(theta) + r(A2-C) sin(theta) r >=0 , azymuth theta in ]-pi,pi] NB: if C=(0,0), A1=(1,0), A2=(0,1) then it gives the usual polar coordinates r=1 on the boundary of the ellipse
tostring#
totalCpuTime#
-
real_t xlifepp::totalCpuTime()#
-
returns user time (“cputime”) interval since first runtime ‘call’ according to unit defined in Time::deltacpuTime
returns elapsed time interval in sec.
since first runtime ‘call’
-
real_t xlifepp::totalCpuTime(const string_t &comment, CoutStream &out)#
-
real_t xlifepp::totalCpuTime(const string_t &comment, PrintStream &out)#
-
real_t xlifepp::totalCpuTime(const string_t &comment, std::ostream &out = std::cout)#
-
returns elapsed time interval in sec.
since first runtime ‘call’ and prints it with comment
totalElapsedTime#
-
real_t xlifepp::totalElapsedTime()#
-
returns elapsed time interval since first runtime ‘call’ according to unit defined in Time::deltaTime
returns elapsed time interval in sec.
since first runtime ‘call’
-
real_t xlifepp::totalElapsedTime(const string_t &comment, CoutStream &out)#
-
real_t xlifepp::totalElapsedTime(const string_t &comment, PrintStream &out)#
-
real_t xlifepp::totalElapsedTime(const string_t &comment, std::ostream &out = std::cout)#
-
returns elapsed time interval in sec.
since first runtime ‘call’ and prints it with comment
toVector#
trac_x#
-
OperatorOnKernel &xlifepp::trac_x(const Kernel&)#
-
trac_x(k)
-
OperatorOnKernel &xlifepp::trac_x(OperatorOnKernel&)#
-
trac_x(opk)
trac_y#
-
OperatorOnKernel &xlifepp::trac_y(const Kernel&)#
-
trac_y(k)
-
OperatorOnKernel &xlifepp::trac_y(OperatorOnKernel&)#
-
trac_y(opk)
traceInit#
-
void xlifepp::traceInit()#
-
initialization procedure for trace handling
initialization of engine for trace handling
tran#
-
inline complex_t xlifepp::tran(const complex_t&)#
-
inline real_t xlifepp::tran(const real_t&)#
-
template<typename K>
SparseMatrix<K> xlifepp::tran(const SparseMatrix<K> &m)#
-
transpose matrix
-
OperatorOnFunction &xlifepp::tran(Function&)#
-
transpose f
-
OperatorOnKernel &xlifepp::tran(Kernel&)#
-
transpose k
-
OperatorOnFunction &xlifepp::tran(OperatorOnFunction&)#
-
transpose opf
-
OperatorOnKernel &xlifepp::tran(OperatorOnKernel&)#
-
transpose opk
-
SymbolicTermMatrix &xlifepp::tran(SymbolicTermMatrix &S)#
-
template<typename T>
inline Function &xlifepp::tran(T (*fun)(const Point&, const Point&, Parameters&))#
-
template<typename T>
inline Function &xlifepp::tran(T (*fun)(const Point&, Parameters&))#
trans#
transform#
-
template<class Geom>
Geom xlifepp::transform(const Geom &g, const Transformation &t)#
-
apply a geometrical transformation on a Geom (template external)
-
Geometry xlifepp::transform(const Geometry &g, const Transformation &t)#
-
apply a geometrical transformation on a Geometry (external)
-
Mesh xlifepp::transform(const Mesh &m, const Transformation &t, const string_t &meshname = "", const string_t &suffix = "")#
-
apply a geometrical transformation on a Mesh (external)
-
inline Point xlifepp::transform(const Point &p, const Transformation &t)#
-
apply a geometrical transformation on a Point
transformMatrix#
-
template<typename K>
void xlifepp::transformMatrix(MatrixEigenDense<K> &mat)#
-
Reverse all elements of a matrix.
transformVectorDense#
-
template<typename K>
void xlifepp::transformVectorDense(VectorEigenDense<K> &v)#
translate#
-
template<class Geom>
Geom xlifepp::translate(const Geom &g, const Parameter &p1)#
-
apply a translation on a Geom (1 key) (template external)
-
template<class Geom>
Geom xlifepp::translate(const Geom &g, real_t ux, real_t uy, real_t uz = 0.)#
-
apply a translation on a Geom (3 reals version) (template external)
-
template<class Geom>
Geom xlifepp::translate(const Geom &g, std::vector<real_t> u = std::vector<real_t>(3, 0.))#
-
apply a translation on a Geom (vector version) (template external)
-
inline Geometry xlifepp::translate(const Geometry &g, const Parameter &p1)#
-
apply a translation on a Geometry (1 key) (template external)
-
inline Geometry xlifepp::translate(const Geometry &g, real_t ux, real_t uy, real_t uz = 0.)#
-
apply a translation on a Geometry (3 reals version) (template external)
-
inline Geometry xlifepp::translate(const Geometry &g, std::vector<real_t> u = std::vector<real_t>(3, 0.))#
-
apply a translation on a Geometry (vector version) (template external)
-
Mesh xlifepp::translate(const Mesh &m)#
-
apply a translation on a Mesh (vector version) (external)
apply a translation on a Mesh (no vector) (external)
-
Mesh xlifepp::translate(const Mesh &m, const Parameter &p1)#
-
apply a translation on a Mesh (1 key) (external)
-
Mesh xlifepp::translate(const Mesh &m, const Parameter &p1, const Parameter &p2)#
-
apply a translation on a Mesh (2 keys) (external)
-
Mesh xlifepp::translate(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3)#
-
apply a translation on a Mesh (3 keys) (external)
-
Mesh xlifepp::translate(const Mesh &m, real_t ux, real_t uy = 0., real_t uz = 0.)#
-
apply a translation on a Mesh (3 reals version) (external)
-
Mesh xlifepp::translate(const Mesh &m, std::vector<real_t> u)#
-
apply a translation on a Mesh (vector version) (external)
-
inline Point xlifepp::translate(const Point &g, const Parameter &p1)#
-
apply a translation on a Point (1 key) (template external)
transpose#
-
inline complex_t xlifepp::transpose(const complex_t &c)#
-
template<typename M_it, typename MM_it>
void xlifepp::transpose(const dimen_t nbr, const dimen_t nbc, M_it it_m1b, MM_it it_m2b)#
-
template<typename T>
LargeMatrix<T> xlifepp::transpose(const LargeMatrix<T> &L)#
-
template<typename K>
MatrixEigenDense<K> xlifepp::transpose(const MatrixEigenDense<K> &mat)#
-
inline real_t xlifepp::transpose(const real_t &r)#
-
template<typename K>
SparseMatrix<K> xlifepp::transpose(const SparseMatrix<K> &m)#
transposeVec#
-
template<typename K>
VectorEigenDense<K> xlifepp::transposeVec(const VectorEigenDense<K> &v)#
-
Transpose a vector.
- Parameters:
-
v – [in] source vector
- Returns:
-
transposed vector
trapz#
-
template<typename T, typename Iterator>
T xlifepp::trapz(number_t n, real_t h, Iterator itb, T &intg)#
-
uniform trapeze method from a list of n values uniformaly distributed (step h) n: number of values h: step itb: first position in the list of values intg: value of integral
-
template<typename T>
T xlifepp::trapz(T (*f)(real_t), real_t a, real_t b, number_t n)#
-
uniform trapeze method on [a,b] interval from a function and a number of points
-
template<typename T>
T xlifepp::trapz(T (*f)(real_t, Parameters&), Parameters &pars, real_t a, real_t b, number_t n)#
-
uniform trapeze method on [a,b] interval from a function with parameters and a number of points
treeToSet#
-
std::set<GeomElement*> xlifepp::treeToSet(Node<GeomElement> &tree)#
triangleArea#
triangleArgyris#
-
RefElement *xlifepp::triangleArgyris(const Interpolation *interp_p)#
-
triangleMorley construction of the Morley Reference Element
triangleCrouzeixRaviartStd#
-
RefElement *xlifepp::triangleCrouzeixRaviartStd(const Interpolation *interp_p)#
-
triangleCrouzeixRaviartStd construction of a Crouzeix_Raviart standard Reference Element by interpolation number
triangleEdgesLengths#
triangleHeightsLengths#
-
std::vector<real_t> xlifepp::triangleHeightsLengths(const Point &T1, const Point &T2, const Point &T3)#
-
lengths of heights of the triangle whose vertices are T1, T2 and T3 first height is from T1, second height from T2 and last height from T3
lengths of heights of the triangle whose vertices are given
triangleHermiteStd#
-
RefElement *xlifepp::triangleHermiteStd(const Interpolation *interp_p)#
-
triangleHermiteStd construction of a Hermite standard Reference Element by interpolation number
triangleLagrangeStd#
-
RefElement *xlifepp::triangleLagrangeStd(const Interpolation *interp_p)#
-
triangleLagrangeStd construction of a Lagrange standard Reference Element by interpolation number
triangleMorley#
-
RefElement *xlifepp::triangleMorley(const Interpolation *interp_p)#
-
triangleMorley construction of the Morley Reference Element
triangleNedelec#
-
RefElement *xlifepp::triangleNedelec(const Interpolation *interp_p)#
-
triangleNedelec construction of a Nedelec standard Reference Element by interpolation number
triangleQuadrature#
-
Quadrature *xlifepp::triangleQuadrature(QuadRule, number_t)#
-
find or create quadrature rule over the unit triangle
triangleRaviartThomasStd#
-
RefElement *xlifepp::triangleRaviartThomasStd(const Interpolation *interp_p)#
-
triangleRaviart_ThomasStd construction of a Raviart_Thomas standard Reference Element by interpolation number
trihedralOrientation#
-
std::vector<std::pair<real_t, dimen_t>> xlifepp::trihedralOrientation(const Point &o, const Point &px, const Point &py, const Point &pz)#
-
computes orientation of a trihedral, namely rotation angles around each axis to come from the standard trihedral to the given one basic idea:
computes orientation of a trihedral
first we determine the rotation Rz around z axis so that image (o, px1) of (o, px) is in the plane xOz with positive x coordinate
secondly we determine the rotation Ry around y axis so that image (o, px2) of (o, px1) is along x axis with positive coordinate
at last we determine the rotation Rx around x axis so that image (o, py1) of (o, py) is along y axis with positive coordinate
we store opposite values of found rotation angles when not null in opposite order (rotations does not commute)
angles are in degree and between 0. and 360.
trim#
-
string_t xlifepp::trim(const string_t &s, const char *delim)#
-
convert “ a b c d e f “ to “a b c d e f”
trims leading and trailing white space from string_t
trimLeading#
-
string_t xlifepp::trimLeading(const string_t &s, const char *delim)#
-
convert “ a b c d e f “ to “a b c d e f “
trims leading white space from string_t
trimTrailing#
-
string_t xlifepp::trimTrailing(const string_t &s, const char *delim)#
-
convert “ a b c d e f “ to “ a b c d e f”
trims trailing white space from string_t
trivialNumbering#
type2Str#
typeArg2Str#
typeFun2Str#
typeOf#
-
template<typename T>
structPair xlifepp::typeOf(const T &v)#