xlifepp – Functions – E#

e1Test#

void xlifepp::e1Test(std::ostream&)#

For tests.

e1z#

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

return E1(z)

earcut#

template<typename Polygon>
std::vector<size_t> xlifepp::earcut(const Polygon &poly)#

earcutTriangulation#

template<typename P>
std::vector<std::vector<size_t>> xlifepp::earcutTriangulation(const std::vector<P> &vertices)#

edgeNumbering#

template<class ST_>
number_t *xlifepp::edgeNumbering()#

Termination of the construction of a mesh object of 2D elements by transferring data from a subdivision::xxxMesh object into XLiFE++ objects.

eigenDavidsonSolve#

template<typename ST>
number_t xlifepp::eigenDavidsonSolve(const LargeMatrix<ST> *pA, const LargeMatrix<ST> *pB, std::vector<std::pair<complex_t, Vector<complex_t>>> &res, number_t nev, real_t tol, string_t which, bool isInverted, FactorizationType fac, bool isShift)#

Resolve an eigen problem with block davidson method.

Parameters:

  • pA – [in] Pointer to large matrix A of the eigen problem A*X = lambda*B*X. It MUSTN’T be nullptr

  • pB – [in] Pointer to large matrix B of the eigen problem A*X = lambda*B*X. If it’s nullptr. Eigen problem is standard: A*X=lambda*X

  • res – [inout] result

  • nev – [in] The number of eigen values and eigenSolver searched for

  • tol – [in] Tolerance

  • which – [in] Specification of which eigen values are returned. Largest-LM, Smallest-SM,

  • isInverted – [in] true if inverted matrix

  • fac – [in] factorization type

  • isShift – [in] true if eigen problem with shift or not

eigenInternGen#

EigenElements xlifepp::eigenInternGen(TermMatrix *pA, TermMatrix *ptB, number_t nev, string_t which, real_t tol, EigenComputationalMode eigCompMode, complex_t sigma, bool isShift, string_t nam, EigenSortKind esortk = _incr_module)#

Internal eigen solver.

eigenInternSolve#

EigenElements xlifepp::eigenInternSolve(TermMatrix *A, TermMatrix *B, const std::vector<Parameter> &ps)#

Main entry point for intern eigenvalue solver.

eigenKrylovSchurSolve#

template<typename ST>
number_t xlifepp::eigenKrylovSchurSolve(const LargeMatrix<ST> *pA, const LargeMatrix<ST> *pB, std::vector<std::pair<complex_t, Vector<complex_t>>> &res, number_t nev, real_t tol, string_t which, bool isInverted, FactorizationType fac, bool isShift)#

Resolve an eigen problem with block Krylov-Schur method.

Parameters:

  • pA – [in] Pointer to large matrix A of the eigen problem A*X = lambda*B*X. It MUSTN’T be nullptr

  • pB – [in] Pointer to large matrix B of the eigen problem A*X = lambda*B*X. If it’s nullptr. Eigen problem is standard: A*X=lambda*X

  • res – [inout] result

  • nev – [in] The number of eigen values and eigenSolver searched for

  • tol – [in] Tolerance

  • which – [in] Specification of which eigen values are returned. Largest-LM, Smallest-SM,

  • isInverted – [in] true if inverted matrix

  • fac – [in] factorization type

  • isShift – [in] true if eigen problem with shift or not

eigenSolve#

EigenElements xlifepp::eigenSolve(TermMatrix *A, TermMatrix *B, std::vector<Parameter> ps)#

Main entry point for non specific eigenvalue solver.

eigs#

template<typename T>
void xlifepp::eigs(const Matrix<T> &A, const Matrix<T> &B, Vector<complex_t> &ls, Matrix<complex_t> &Xs)#

computation of generalized eigen values A*X=lambda*B*X

eigen vectors are stored by row in Xs matrix !

currently works only for REAL matrices

template<typename T>
void xlifepp::eigs(const Matrix<T> &A, const Matrix<T> &B, Vector<complex_t> &ls, Vector<Vector<complex_t>> &Xs)#
template<typename T>
void xlifepp::eigs(const Matrix<T> &A, Vector<complex_t> &ls, Matrix<complex_t> &Xs)#

computation of eigen values A*X=lambda*X

eigen vectors are stored by row in Xs matrix !

template<typename T>
void xlifepp::eigs(const Matrix<T> &A, Vector<complex_t> &ls, Vector<Vector<complex_t>> &Xs)#
template<typename T>
void xlifepp::eigs(const T *A, number_t m, complex_t *Xs, complex_t *ls)#

general template eigenvector computation using Eigen, assuming A, U are pointers to first value of DENSE ROW matrix A, B: pointers to dense row squared matrix m: matrix size Xs: pointer to a dense row matrix, storing eigen vectors ls: pointer to a vector, storing eigen values

template<typename Ta, typename Tb>
void xlifepp::eigs(const Ta *A, const Tb *B, number_t m, complex_t *Xs, complex_t *lambda)#

eInz#

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

return \(E1(z) + gamma + log(z) = \sum_{n>0} (-z)^n / n n!\)

elapsedTime#

real_t xlifepp::elapsedTime()#

returns elapsed time interval since last runtime ‘call’ according to unit defined in Time::deltaTime

returns elapsed time interval in sec.

since last runtime ‘call’

real_t xlifepp::elapsedTime(const string_t &comment, CoutStream &out)#
real_t xlifepp::elapsedTime(const string_t &comment, PrintStream &out)#
real_t xlifepp::elapsedTime(const string_t &comment, std::ostream &out = std::cout)#

returns elapsed time interval in sec.

since last runtime ‘call’ and prints it with comment

eliminatedPositions#

static std::vector<number_t> xlifepp::eliminatedPositions(const Constraints &cs, const std::map<DofComponent, number_t> &melcdofs)#

eolpm#

inline void xlifepp::eolpm(int_t n)#

adding n blank (may be negatif) to eol

epsilon#

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

epsilonG#

OperatorOnUnknown &xlifepp::epsilonG(const Unknown &un, const complex_t &id, const complex_t &ax, const complex_t &ay, const complex_t &az)#

epsilonR#

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

eqtOfPlane#

std::vector<real_t> xlifepp::eqtOfPlane(const Point &S1, const Point &S2, const Point &S3)#

returns coefficients (a,b,c,d) of the equation of the plane (ax+by+cz+d=0) defined by the 3 non aligned given points S1, S2, and S3

returns equation of the plane defined by the 3 non aligned given points

erf#

complex_t xlifepp::erf(complex_t z)#

error#

template<typename T>
void xlifepp::error(const string_t &msgIds, const T &v, Messages *msgSrc = theMessages_p)#
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
void xlifepp::error(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, Messages *msgSrc = theMessages_p)#
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
void xlifepp::error(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, Messages *msgSrc = theMessages_p)#
template<typename T1, typename T2, typename T3, typename T4, typename T5>
void xlifepp::error(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, Messages *msgSrc = theMessages_p)#
template<typename T1, typename T2, typename T3, typename T4>
void xlifepp::error(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, Messages *msgSrc = theMessages_p)#
template<typename T1, typename T2, typename T3>
void xlifepp::error(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, Messages *msgSrc = theMessages_p)#
template<typename T1, typename T2>
void xlifepp::error(const string_t &msgIds, const T1 &v1, const T2 &v2, Messages *msgSrc = theMessages_p)#
void xlifepp::error(const string_t &msgIds, MsgData &msgData, Messages *msgSrc)#

shortcut of msg for error type messages

throw error messages

euler#

template<typename T>
Vector<T> xlifepp::euler(T &(*f)(real_t, const T&, T&), real_t a, real_t b, real_t dt, const T &y0)#
template<typename T, typename P>
Vector<T> xlifepp::euler(T &(*f)(real_t, const T&, T&, P&), real_t a, real_t b, real_t dt, const T &y0, P &pars)#

eval#

template<typename K>
std::vector<K> xlifepp::eval(const std::vector<PolynomialT<K>> &p, const K &x1, const K &x2 = K(1), const K &x3 = K(1))#

evalContractedProduct#

template<>
inline void xlifepp::evalContractedProduct(const Matrix<real_t> &mat, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)#
template<typename T, typename R>
inline void xlifepp::evalContractedProduct(const Matrix<T> &mat, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)#

Contracted product.

evalCrossProduct#

template<>
inline void xlifepp::evalCrossProduct(const Vector<real_t> &vec, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res, bool right)#
template<typename T, typename R>
void xlifepp::evalCrossProduct(const Vector<T> &vec, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res, bool right)#

Cross product.

evalFun#

inline complex_t xlifepp::evalFun(SymbolicOperation op, const complex_t &z, const complex_t &p = 0.)#
inline real_t xlifepp::evalFun(SymbolicOperation op, const real_t &x, const real_t &p = 0.)#

evalInnerProduct#

template<>
inline void xlifepp::evalInnerProduct(const Vector<real_t> &vec, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)#
template<typename T, typename R>
void xlifepp::evalInnerProduct(const Vector<T> &vec, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)#

Inner product.

evalMatrixMatrixProduct#

template<>
inline void xlifepp::evalMatrixMatrixProduct(const Matrix<real_t> &vec, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)#
template<typename T, typename R>
inline void xlifepp::evalMatrixMatrixProduct(const Matrix<T> &mat, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)#

evalMatrixMatrixProduct2#

template<>
inline void xlifepp::evalMatrixMatrixProduct2(const Matrix<real_t> &mat, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)#
template<typename T, typename R>
inline void xlifepp::evalMatrixMatrixProduct2(const Matrix<T> &mat, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)#

evalMatrixVectorProduct#

template<>
inline void xlifepp::evalMatrixVectorProduct(const Matrix<real_t> &mat, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)#
template<typename T, typename R>
inline void xlifepp::evalMatrixVectorProduct(const Matrix<T> &mat, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)#

Matrix product.

template<>
inline void xlifepp::evalMatrixVectorProduct(const Vector<real_t> &vec, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)#
template<typename T, typename R>
inline void xlifepp::evalMatrixVectorProduct(const Vector<T> &vec, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)#

Matrix product using vector representation of matrix.

evalOp#

inline complex_t xlifepp::evalOp(SymbolicOperation op, const complex_t &x, const complex_t &y)#
inline real_t xlifepp::evalOp(SymbolicOperation op, const real_t &x, const real_t &y)#

evalScalarProduct#

template<>
inline void xlifepp::evalScalarProduct(const Matrix<real_t> &mat, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)#
template<typename T, typename R>
inline void xlifepp::evalScalarProduct(const Matrix<T> &mat, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)#
template<>
inline void xlifepp::evalScalarProduct(const real_t &val, const Vector<complex_t> &v, Vector<real_t> &res)#
template<typename T, typename R>
inline void xlifepp::evalScalarProduct(const T &val, const Vector<R> &v, Vector<T> &res)#

Product by a scalar.

template<>
inline void xlifepp::evalScalarProduct(const Vector<real_t> &vec, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)#
template<typename T, typename R>
inline void xlifepp::evalScalarProduct(const Vector<T> &vec, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)#

evalVectorMatrixProduct#

template<>
inline void xlifepp::evalVectorMatrixProduct(const Matrix<real_t> &mat, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)#
template<typename T, typename R>
inline void xlifepp::evalVectorMatrixProduct(const Matrix<T> &mat, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)#
template<>
inline void xlifepp::evalVectorMatrixProduct(const Vector<real_t> &vec, const Vector<complex_t> &v, dimen_t &d, dimen_t &n, number_t m, Vector<real_t> &res)#
template<typename T, typename R>
inline void xlifepp::evalVectorMatrixProduct(const Vector<T> &vec, const Vector<R> &v, dimen_t &d, dimen_t &n, number_t m, Vector<T> &res)#

exp#

inline SuTermVector xlifepp::exp(const SuTermVector &s)#
inline SymbolicFunction &xlifepp::exp(const SymbolicFunction &f)#
inline TermVector xlifepp::exp(const TermVector &s)#

expand#

GeoNode xlifepp::expand(const GeoNode &gn)#

create the expansion of a GeoNode (new object)

create the expansion of a GeoNode

expzE1z#

complex_t xlifepp::expzE1z(const complex_t&)#

return exp(z)*E1(z)

ext_Fock_s#

complex_t xlifepp::ext_Fock_s(real_t x, Parameters &pars)#

ext_Fock_s_app#

complex_t xlifepp::ext_Fock_s_app(real_t x, Parameters &pars)#

extendStorage#

void xlifepp::extendStorage(MatrixEntry *mat, std::vector<DofComponent> &cdofsr, std::vector<DofComponent> &cdofsc, const Constraints *cu, const Constraints *cv, bool keepSymmetry, bool doRow, bool doCol, bool doDiag, bool doPenal)#

extend storage of matrix when constraints are not local and have column/row combination, assuming scalar matrix entries ! mat: pointer to the matrix to be reduced cdofsr: row dof components cdofsc: col dof components cu: pointer to the constraints on the unknown u (col) cv: pointer to the constraints on test function v (row) keepSymmetry: flag to indicate to force symmetry of the extended storage (default not keeping symmetry) doRow, doCol, doDiag: flags to indicates which extensions are processed (default all) doPenal: if true, add the pattern of C’C (symmetric penalization, see Constraints::penalizationReduction)

extend matrix storage when constraints are not local and have column/row combination

extendVector#

template<typename I1, typename I2>
void xlifepp::extendVector(const std::vector<number_t> &renum, I1 it1, I2 it2)#

template extension method

extension#

TermVector xlifepp::extension(const Function &f, const Function &g, const GeomDomain &dom, const Unknown &u)#
TermVector xlifepp::extension(const Function &f, const Function &g, const GeomDomain &dom, const Unknown &u, const Function &h)#
Value xlifepp::extension(const Function &f, const Function &g, const Point &P)#
Value xlifepp::extension(const Function &f, const Function &g, const Point &P, const Function &h)#
TermVector xlifepp::extension(const TermVector &f, const Function &g, const GeomDomain &dom, const Unknown &u)#
TermVector xlifepp::extension(const TermVector &f, const Function &g, const GeomDomain &dom, const Unknown &u, const Function &h)#
Value xlifepp::extension(const TermVector &f, const Function &g, const Point &P)#
Value xlifepp::extension(const TermVector &f, const Function &g, const Point &P, const Function &h)#

extractComponents#

template<typename K>
Vector<K> xlifepp::extractComponents(const Vector<Vector<K>> &vov, number_t i)#
template<typename K>
void xlifepp::extractComponents(const Vector<Vector<K>> &vov, Vector<K> &v, number_t i)#

extract i-th components (i>0) of a Vector<Vector<K> > and store extract values in Vector<K> (index i>0 is not checked!)

extrude#

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, const char *domName, const char *sidenames)#

definition of a geometry by extrusion of another geometry, with name and side name

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, const char *domName, std::vector<string_t> sidenames = std::vector<string_t>())#

definition of a geometry by extrusion of another geometry, with name and side names

Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, const std::vector<Parameter> &ps)#

main routine for the definition of a geometry by extrusion of another geometry, with a list if parameters

main external routine for the definition of a geometry by extrusion of another geometry, with a list if parameters

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, number_t layers, const char *domName, const char *sidenames)#

definition of a geometry by extrusion of another geometry, with name and side name

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, number_t layers, const char *domName, std::vector<string_t> sidenames = std::vector<string_t>())#

definition of a geometry by extrusion of another geometry, with name and side names

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, number_t layers, std::vector<string_t> sidenames = std::vector<string_t>())#

definition of a geometry by extrusion of another geometry, with side names

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, number_t layers, string_t domName, std::vector<string_t> sidenames = std::vector<string_t>())#

definition of a geometry by extrusion of another geometry, with name and side names

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, number_t layers, string_t domName, string_t sidenames)#

definition of a geometry by extrusion of another geometry, with name and side name

Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, Parameter p)#

Definition of a geometry by extrusion of another geometry, with 1 Parameter.

Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, Parameter p1, Parameter p2)#

Definition of a geometry by extrusion of another geometry, with 2 Parameter.

Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, Parameter p1, Parameter p2, Parameter p3)#

Definition of a geometry by extrusion of another geometry, with 3 Parameter.

Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, Parameter p1, Parameter p2, Parameter p3, Parameter p4)#

Definition of a geometry by extrusion of another geometry, with 4 Parameter.

Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, Parameter p1, Parameter p2, Parameter p3, Parameter p4, Parameter p5)#

Definition of a geometry by extrusion of another geometry, with 5 Parameter.

Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, Parameter p1, Parameter p2, Parameter p3, Parameter p4, Parameter p5, Parameter p6)#

Definition of a geometry by extrusion of another geometry, with 6 Parameter.

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, std::vector<string_t> sidenames = std::vector<string_t>())#

definition of a geometry by extrusion of another geometry, with side names

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, string_t domName, std::vector<string_t> sidenames = std::vector<string_t>())#

definition of a geometry by extrusion of another geometry, with name and side names

inline Geometry xlifepp::extrude(const Geometry &g, const Transformation &t, string_t domName, string_t sidenames)#

definition of a geometry by extrusion of another geometry, with name and side name

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const std::vector<Transformation*> &trs, const Parameter &p)#

extrude a mesh using a list of transformations

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const std::vector<Transformation*> &trs, const Parameter &p1, const Parameter &p2)#
inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const std::vector<Transformation*> &trs, const Parameter &p1, const Parameter &p2, const Parameter &p3)#
inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const std::vector<Transformation*> &trs, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)#
inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const std::vector<Transformation*> &trs, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)#
Mesh xlifepp::extrude(const Mesh &sectionMesh, const std::vector<Transformation*> &trs, const std::vector<Parameter> &ps)#

external routine to apply an extrusion on a Mesh using a list of transformation

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const Transformation &tr, const Parameter &p)#

extrude a mesh using a transformation

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const Transformation &tr, const Parameter &p1, const Parameter &p2)#
inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const Transformation &tr, const Parameter &p1, const Parameter &p2, const Parameter &p3)#
inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const Transformation &tr, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)#
inline Mesh xlifepp::extrude(const Mesh &sectionMesh, const Transformation &tr, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)#
Mesh xlifepp::extrude(const Mesh &sectionMesh, const Transformation &tr, const std::vector<Parameter> &ps)#

external routine to apply an extrusion on a Mesh using an elementary transformation

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, par_fun f, const Parameter &p)#

extrude a mesh using a parametrization function

inline Mesh xlifepp::extrude(const Mesh &sectionMesh, par_fun f, const Parameter &p1, const Parameter &p2)#
inline Mesh xlifepp::extrude(const Mesh &sectionMesh, par_fun f, const Parameter &p1, const Parameter &p2, const Parameter &p3)#
inline Mesh xlifepp::extrude(const Mesh &sectionMesh, par_fun f, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)#
inline Mesh xlifepp::extrude(const Mesh &sectionMesh, par_fun f, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4, const Parameter &p5)#
Mesh xlifepp::extrude(const Mesh &sectionMesh, par_fun f, const std::vector<Parameter> &ps)#

external routine to apply an extrusion on a Mesh using a parametrisation function

eyeMatrix#

template<typename K>
void xlifepp::eyeMatrix(MatrixEigenDense<K> &mat)#

Reverse all elements of a matrix.

On this page