xlifepp – Functions – D#

d0#

OperatorOnUnknown &xlifepp::d0(const Unknown &un)#

d1#

OperatorOnUnknown &xlifepp::d1(const Unknown &un)#

d11#

OperatorOnUnknown &xlifepp::d11(const Unknown &un)#

d12#

OperatorOnUnknown &xlifepp::d12(const Unknown &un)#

d13#

OperatorOnUnknown &xlifepp::d13(const Unknown &un)#

d2#

OperatorOnUnknown &xlifepp::d2(const Unknown &un)#

d22#

OperatorOnUnknown &xlifepp::d22(const Unknown &un)#

d23#

OperatorOnUnknown &xlifepp::d23(const Unknown &un)#

d2G#

OperatorOnUnknown &xlifepp::d2G(const Unknown &un, const complex_t &axx, const complex_t &axy, const complex_t &ayy, const complex_t &axz, const complex_t &ayz, const complex_t &azz)#

OperatorOnUnknown &xlifepp::d2G(const Unknown &un, const Matrix<complex_t> &a)#

d3#

OperatorOnUnknown &xlifepp::d3(const Unknown &un)#

d33#

OperatorOnUnknown &xlifepp::d33(const Unknown &un)#

deceol#

inline void xlifepp::deceol(number_t n)#: decrease blanks

defaultColoringRule#

real_t xlifepp::defaultColoringRule(const GeomElement &gelt, const std::vector<real_t> &val)#

the default GeomElement coloring rule is the following let np the number of strictly positive values (v_i) on the n vertices of the geomelement if(np>n/2) then color =1 else color =0 for a triangle: color is 1 if at least 2 vertex values are >0 for a quadrangle: color is 1 if at least 3 vertex values are >0 for a tetrahedron: color is 1 if at least 3 vertex values are >0 for a hexahedron: color is 1 if at least 5 vertex values are >0

default Geomelement coloring rule

gelt: geom element val: real values on vertices

defaultVectorColoringRule#

real_t xlifepp::defaultVectorColoringRule(const GeomElement &gelt, const std::vector<Vector<real_t>> &val)#: default Geomelement vector coloring rule

defineMap#

void xlifepp::defineMap(const GeomDomain&, const GeomDomain&, const Function&, bool nearest = false)#: define a map between 2 geomdomains, default name

void xlifepp::defineMap(const GeomDomain&, const GeomDomain&, const Function&, const string_t&, bool nearest = false)#: define a map between 2 geomdomains with explicit name

deleteClusterTreeFeDof#

void xlifepp::deleteClusterTreeFeDof(void *p)#

deleteFunction#

void xlifepp::deleteFunction(void *p)#

deleteGeomDomain#

void xlifepp::deleteGeomDomain(void *p)#

deleteIntegrationMethod#

void xlifepp::deleteIntegrationMethod(void *p)#

deleteIntegrationMethods#

void xlifepp::deleteIntegrationMethods(void *p)#

deleteMapOfPair#

static void xlifepp::deleteMapOfPair(const GeomDomain &d1, const GeomDomain &d2)#

deleteParametrization#

void xlifepp::deleteParametrization(void *p)#

deleteSpline#

void xlifepp::deleteSpline(void *p)#

deleteTermVectors#

void xlifepp::deleteTermVectors(void *p)#

deleteTransformation#

void xlifepp::deleteTransformation(void *p)#

delSpace#

string_t xlifepp::delSpace(const string_t &s)#

convert “ a b c d e f “ to “abcefd”

delete all white space from string_t

derivative#

SymbolicFunction &xlifepp::derivative(const SymbolicFunction &f, const SymbolicFunction &v)#

SymbolicFunction &xlifepp::derivative(const SymbolicFunction &f, VariableName v)#

template<typename K> PolynomialT<K> xlifepp::derivative(VariableName vn, const MonomialT<K> &m)#

template<typename K> PolynomialT<K> xlifepp::derivative(VariableName vn, const PolynomialT<K> &p)#

template<typename K> std::vector<PolynomialT<K>> xlifepp::derivative(VariableName vn, const std::vector<PolynomialT<K>> &ps)#

diag#

inline complex_t xlifepp::diag(const complex_t&)#

inline real_t xlifepp::diag(const real_t&)#

template<typename K> void xlifepp::diag(Matrix<K> &m)#: change matrix into diagonal matrix made of diagonal of matrix

diagonalLumping#

SuTermMatrix xlifepp::diagonalLumping(const SuTermMatrix&, AccessType = _row)#: diagonal matrix sum_j aij (_row) or sum_i aij (col)

inline TermMatrix xlifepp::diagonalLumping(const TermMatrix &A, AccessType at = _row)#: create diagonal TermMatrix dii= sum_j Aij (at=_row) or djj= sum_i Aij (at=col), works only for single unknown TermMatrix

diagonalMatrix#

template<typename T> LargeMatrix<T> xlifepp::diagonalMatrix(const LargeMatrix<T> &mat, const T v)#

template<typename T> LargeMatrix<T> xlifepp::diagonalMatrix(StorageType st, AccessType at, number_t nbr, number_t nbc, const T v)#

diagonalPart#

SuTermMatrix xlifepp::diagonalPart(const SuTermMatrix&)#: diagonal matrix from aii

inline TermMatrix xlifepp::diagonalPart(const TermMatrix &A)#: create diagonal TermMatrix dii from Aii, works only for single unknown TermMatrix

diGamma#

complex_t xlifepp::diGamma(const complex_t &z)#

real_t xlifepp::diGamma(int_t n)#: return \(-gamma + \sum_1^{n-1} 1/n\) where gamma is Euler-Mascheroni constant

real_t xlifepp::diGamma(real_t x)#

dim#

dimen_t xlifepp::dim(const Element &elt)#

dimen_t xlifepp::dim(const FeDof &fed)#

dimen_t xlifepp::dim(const Point &p)#

template<typename T> dimen_t xlifepp::dim(const T&)#

dimsOf#

std::pair<dimen_t, dimen_t> xlifepp::dimsOf(const complex_t &v)#

template<typename K> std::pair<dimen_t, dimen_t> xlifepp::dimsOf(const Matrix<K> &v)#

std::pair<dimen_t, dimen_t> xlifepp::dimsOf(const real_t &v)#

template<typename K> std::pair<dimen_t, dimen_t> xlifepp::dimsOf(const SparseMatrix<K> &v)#

template<typename T> std::pair<dimen_t, dimen_t> xlifepp::dimsOf(const Vector<T> &v)#: useful dimension functions

directSolve#

TermVectors xlifepp::directSolve(TermMatrix &A, const std::vector<TermVector> &Bs, bool keepA)#

TermVector xlifepp::directSolve(TermMatrix &A, const TermVector &B, bool keepA)#

solve linear system by direct method, trying to find the well adapted direct method if A is already factorized goto upper-lower solver (factSolve) if umfpack is available, it is used (umfpackSolve) if A is single unknown dense matrix use pivoting gauss elimination process (gaussSolve) else factorize LU, LDLt or LDL* and goto upper-lower solver (factSolve)

if keepA is false (default) the matrix A is modified else it is not modified

TermMatrix xlifepp::directSolve(TermMatrix &A, TermMatrix &B, KeepStatus k)#

dirname#

string_t xlifepp::dirname(const string_t &f)#: return dirname of a file name using last slash as delimiter

dist#

real_t xlifepp::dist(const BoundingBox &bb1, const BoundingBox &bb2)#: distance from two bounding boxes

real_t xlifepp::dist(const Point &p, const Point &q)#

returns Point as Point in polar coordinates/cylindrical (r,theta,z) r=sqrt(x*x+y*y) theta = atan2(y,x) in ]-pi,pi], z unchanged reverse map: x= r cos(theta) y = r sin(theta) z= z

returns the euclidian distance between 2 points

distance#

real_t xlifepp::distance(const MeshElement &elt1, const MeshElement &elt2)#

distance from two MeshElement, assuming not intersection and using first order, i.e vertices under these assumptions dist(e1,e2)= min{dist(p1,p2), p1 in e1, p2 in e2} = min{dist(p1,p2), p1 any vertex of e1, p2 any vertex of e2}

distance from two MeshElement

div#

template<typename K> PolynomialBasisT<K> xlifepp::div(const PolynomialsBasisT<K> &ps)#

template<typename K> PolynomialT<K> xlifepp::div(const std::vector<PolynomialT<K>> &p)#

OperatorOnUnknown &xlifepp::div(const Unknown &un)#

div_x#

OperatorOnKernel &xlifepp::div_x(const Kernel&)#: grad_x(k)

OperatorOnKernel &xlifepp::div_x(OperatorOnKernel&)#: grad_x(opk)

div_y#

OperatorOnKernel &xlifepp::div_y(const Kernel&)#: grad_y(k)

OperatorOnKernel &xlifepp::div_y(OperatorOnKernel&)#: grad_y(opk)

divG#

OperatorOnUnknown &xlifepp::divG(const Unknown &un, const complex_t &ax, const complex_t &ay, const complex_t &az, const complex_t &at)#

divS#

OperatorOnUnknown &xlifepp::divS(const Unknown &un)#

doesQuadrangleIntersectsQuadrangle#

bool xlifepp::doesQuadrangleIntersectsQuadrangle(const Point &P, const Point &Q, const Point &R, const Point &S, const Point &A, const Point &B, const Point &C, const Point &D, real_t tol)#: determines if quadrangles PQRS and ABCD have a intersection or not

doesSegmentCrossesQuadrangle#

bool xlifepp::doesSegmentCrossesQuadrangle(const Point &P, const Point &Q, const Point &A, const Point &B, const Point &C, const Point &D, real_t tol)#: determines if a segment [PQ] and a quadrangle ABCD have a unique intersection or not

doesSegmentCrossesSegment#

bool xlifepp::doesSegmentCrossesSegment(const Point &P, const Point &Q, const Point &A, const Point &B, real_t tol)#: determines if 2 segments [PQ] and [AB] have a unique intersection or not (2D or 3D)

doesSegmentCrossesSegment2D#

bool xlifepp::doesSegmentCrossesSegment2D(const Point &P, const Point &Q, const Point &A, const Point &B, real_t tol)#

determines if 2 2D segments [PQ] and [AB] have a unique intersection or not

determines if 2 segments [PQ] and [AB] have a intersection or not (faster 2D version)

doesSegmentCrossesTriangle#

bool xlifepp::doesSegmentCrossesTriangle(const Point &P, const Point &Q, const Point &A, const Point &B, const Point &C, real_t tol)#: determines if a segment [PQ] and a triangle ABC have a unique intersection or not

doesSegmentIntersectsQuadrangle#

bool xlifepp::doesSegmentIntersectsQuadrangle(const Point &P, const Point &Q, const Point &A, const Point &B, const Point &C, const Point &D, real_t tol)#: determines if a segment [PQ] and a triangle ABC have a intersection or not

doesSegmentIntersectsTriangle#

bool xlifepp::doesSegmentIntersectsTriangle(const Point &P, const Point &Q, const Point &A, const Point &B, const Point &C, real_t tol)#: determines if segments [PQ] and [AB] have a intersection or not

doesTriangleIntersectsQuadrangle#

bool xlifepp::doesTriangleIntersectsQuadrangle(const Point &P, const Point &Q, const Point &R, const Point &A, const Point &B, const Point &C, const Point &D, real_t tol)#: determines if a triangle PQR and a quadrangle ABCD have a intersection or not

doesTriangleIntersectsTriangle#

bool xlifepp::doesTriangleIntersectsTriangle(const Point &P, const Point &Q, const Point &R, const Point &A, const Point &B, const Point &C, real_t tol)#: determines if triangles PQR and ABC have a intersection or not

dofCoords#

std::vector<Point> xlifepp::dofCoords(Space &sp, const GeomDomain &dom)#: list of coordinates of ponctual dofs of Space on a given domain

domainFromParameters#

inline const GeomDomain *xlifepp::domainFromParameters(Parameters &pars)#

domainIdFromParameters#

inline number_t xlifepp::domainIdFromParameters(Parameters &pars)#

domainMap#

const DomainMap *xlifepp::domainMap(const GeomDomain&, const GeomDomain&)#: find DomainMap from dom1 to dom2

domainNameFromParameters#

inline string_t xlifepp::domainNameFromParameters(Parameters &pars)#: extract GeomDomain or GeomElement information from Parameters

Note

if pointer parameter does not exist, it is created with 0 value (see Parameters.get member function)

domainsFromLevelSet#

inline std::vector<number_t> xlifepp::domainsFromLevelSet(TermVector &tv, number_t mainDomNum, number_t insideDomNum, bool outside = true)#

std::vector<number_t> xlifepp::domainsFromLevelSet(TermVector &tv, number_t mainDomNum, std::vector<number_t> insideDomNums, bool outside)#

routine to update inner domains and main domain regarding some values on element

Parameters:

tv – : real single unknown TermVector containing the criteria : v(i)<0 -> inner domain v(i)>0 main domain
mainDomNum – domain number of the main domain (the domain number is the index in Mesh::domains_)
insideDomNums – domain numbers of inner domains (one or more)
outside – if true, elements of interface between main domain and inner domains (obstacles) are considered in the inner domain, in the main domain otherwise.

Returns:

vector<number_t> eltCol : new domain number for each element

domainTranslation#

Vector<real_t> xlifepp::domainTranslation(const Point&, Parameters &pa = defaultParameters)#: default translation for domain map

dot#

inline complex_t xlifepp::dot(const complex_t &x, const complex_t &y)#

inline complex_t xlifepp::dot(const complex_t &x, const real_t &y)#

real_t xlifepp::dot(const Point&, const Point&)#: returns the scalar product between 2 points

inline complex_t xlifepp::dot(const real_t &x, const complex_t &y)#

inline real_t xlifepp::dot(const real_t &x, const real_t &y)#: for template compilation reasons, fake definition of dot and crossproduct in 1D

template<typename K> PolynomialT<K> xlifepp::dot(const std::vector<PolynomialT<K>> &p, const std::vector<K> &v)#

template<typename K> PolynomialT<K> xlifepp::dot(const std::vector<PolynomialT<K>> &p, const std::vector<PolynomialT<K>> &q)#

complex_t xlifepp::dot(const Vector<complex_t> &u, const Vector<real_t> &v)#: Specialization of dot (complex_t real_t)

complex_t xlifepp::dot(const Vector<complex_t> &vecFirst, const Vector<complex_t> &vecSecond)#

template<typename K> K xlifepp::dot(const Vector<K> &u, const Vector<K> &v)#: inner product for real and complex

complex_t xlifepp::dot(const Vector<real_t> &u, const Vector<complex_t> &v)#

dotC#

complex_t xlifepp::dotC(const Vector<complex_t> &vecFirst, const Vector<real_t> &vecSecond)#

template<typename K1, typename K2> complex_t xlifepp::dotC(const Vector<K1> &vecFirst, const Vector<K2> &vecSecond)#: Hermitian Inner product.

complex_t xlifepp::dotC(const Vector<real_t> &vecFirst, const Vector<real_t> &vecSecond)#: Specialization of dotC (real_t real_t) and (complex_t real_t)

dotProduct#

template<typename T, typename K> T xlifepp::dotProduct(const std::vector<std::pair<number_t, T>> &u, const std::map<number_t, K> &v)#

dotRC#

complex_t xlifepp::dotRC(const TermVector &tv1, const TermVector &tv2)#: inner product when one TermVector is complex

template<typename K1, typename K2> complex_t xlifepp::dotRC(const Vector<K1> &vecFirst, const Vector<K2> &vecSecond)#: Inner product with COMPLEX result (not hermitian product)

complex_t xlifepp::dotRC(const Vector<real_t> &vecFirst, const Vector<real_t> &vecSecond)#: Specialization of dotRC (real_t real_t)

complex_t xlifepp::dotRC(const VectorEntry&, const VectorEntry&)#: same as inner product of two vectorentry’s

dt#

OperatorOnUnknown &xlifepp::dt(const Unknown &un)#

dualDofComponents#

std::vector<DofComponent> xlifepp::dualDofComponents(const std::vector<DofComponent> &cdofs)#: create dual cdofs list from cdofs list

dualOf#

inline TestFunctions xlifepp::dualOf(const PCollection<Unknown> &us, const Strings &names = Strings())#: to build a list of dual xlifepp::TestFunction of a list of xlifepp::Unknown

dx#

template<typename K> PolynomialT<K> xlifepp::dx(const MonomialT<K> &m)#

template<typename K> PolynomialBasisT<K> xlifepp::dx(const PolynomialBasisT<K> &ps)#

template<typename K> PolynomialsBasisT<K> xlifepp::dx(const PolynomialsBasisT<K> &ps)#

template<typename K> PolynomialT<K> xlifepp::dx(const PolynomialT<K> &p)#

template<typename K> std::vector<PolynomialT<K>> xlifepp::dx(const std::vector<PolynomialT<K>> &ps)#

OperatorOnUnknown &xlifepp::dx(const Unknown &un)#

dxx#

OperatorOnUnknown &xlifepp::dxx(const Unknown &un)#

dxy#

OperatorOnUnknown &xlifepp::dxy(const Unknown &un)#

dxz#

OperatorOnUnknown &xlifepp::dxz(const Unknown &un)#

dy#

template<typename K> PolynomialT<K> xlifepp::dy(const MonomialT<K> &m)#

template<typename K> PolynomialBasisT<K> xlifepp::dy(const PolynomialBasisT<K> &ps)#

template<typename K> PolynomialsBasisT<K> xlifepp::dy(const PolynomialsBasisT<K> &ps)#

template<typename K> PolynomialT<K> xlifepp::dy(const PolynomialT<K> &p)#

template<typename K> std::vector<PolynomialT<K>> xlifepp::dy(const std::vector<PolynomialT<K>> &ps)#

OperatorOnUnknown &xlifepp::dy(const Unknown &un)#

dyy#

OperatorOnUnknown &xlifepp::dyy(const Unknown &un)#

dyz#

OperatorOnUnknown &xlifepp::dyz(const Unknown &un)#

dz#

template<typename K> PolynomialT<K> xlifepp::dz(const MonomialT<K> &m)#

template<typename K> PolynomialBasisT<K> xlifepp::dz(const PolynomialBasisT<K> &ps)#

template<typename K> PolynomialsBasisT<K> xlifepp::dz(const PolynomialsBasisT<K> &ps)#

template<typename K> PolynomialT<K> xlifepp::dz(const PolynomialT<K> &p)#

template<typename K> std::vector<PolynomialT<K>> xlifepp::dz(const std::vector<PolynomialT<K>> &ps)#

OperatorOnUnknown &xlifepp::dz(const Unknown &un)#

dzz#

OperatorOnUnknown &xlifepp::dzz(const Unknown &un)#