xlifepp – Functions – P#

parametrization_BezierSpline#

inline Vector<real_t> xlifepp::parametrization_BezierSpline(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_BSpline#

inline Vector<real_t> xlifepp::parametrization_BSpline(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_C2Spline#

inline Vector<real_t> xlifepp::parametrization_C2Spline(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_CatmullRomSpline#

inline Vector<real_t> xlifepp::parametrization_CatmullRomSpline(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_CircArc#

inline Vector<real_t> xlifepp::parametrization_CircArc(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_EllArc#

inline Vector<real_t> xlifepp::parametrization_EllArc(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_Ellipse#

inline Vector<real_t> xlifepp::parametrization_Ellipse(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_EllipsoidSidePart#

inline Vector<real_t> xlifepp::parametrization_EllipsoidSidePart(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_Nurbs#

inline Vector<real_t> xlifepp::parametrization_Nurbs(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_Parallelogram#

inline Vector<real_t> xlifepp::parametrization_Parallelogram(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_ParametrizedArc#

inline Vector<real_t> xlifepp::parametrization_ParametrizedArc(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_Piecewise#

inline Vector<real_t> xlifepp::parametrization_Piecewise(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_Quadrangle#

inline Vector<real_t> xlifepp::parametrization_Quadrangle(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_Segment#

inline Vector<real_t> xlifepp::parametrization_Segment(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_SplineArc#

inline Vector<real_t> xlifepp::parametrization_SplineArc(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_SplineSurface#

inline Vector<real_t> xlifepp::parametrization_SplineSurface(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parametrization_Triangle#

inline Vector<real_t> xlifepp::parametrization_Triangle(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call (Duffy)

parametrization_TrunkSidePart#

inline Vector<real_t> xlifepp::parametrization_TrunkSidePart(const Point &pt, Parameters &pars, DiffOpType d = _id)#: extern parametrization call

parfun_error#

inline void xlifepp::parfun_error(const string_t &com, DiffOpType d)#

parmap_error#

inline void xlifepp::parmap_error(const string_t &com, number_t d)#

parseEigenPars#

void xlifepp::parseEigenPars(const std::vector<Parameter> ps, const number_t nevmax, std::set<ParameterKey> &usedParams, EigPars &ep)#

Parser of user parameters for eigen solvers (internal tool) Returns the list of parameter keys specified by the user (usedParams) and the parameter values to be used (ep).

Nota: the solver parameter is skipped.

permute#

template<typename T> std::vector<T> &xlifepp::permute(std::vector<T> &v, std::vector<T> &vp, const std::vector<number_t> &p)#: permutation of a vector v: vector to be permuted vp: permuted vector p: permutation (index starts from 0) permutation is driven by the permutation vector p that may be smaller than the vector v (but not larger!): vp[i]= v[p[i]] i=0, p.size()

permuteInv#

template<typename T> std::vector<T> &xlifepp::permuteInv(std::vector<T> &v, std::vector<T> &vp, const std::vector<number_t> &p)#: inverse permutation of a vector v: vector to be permuted vp: permuted vector p: permutation (index starts from 0) permutation is driven by the permutation vector p that may be smaller than the vector v (but not larger!): vp[p[i]]= v[i] i=0, p.size()

physicalDomain#

string_t xlifepp::physicalDomain(const std::vector<string_t> &names, const string_t &sid, std::vector<PhysicalData> &pids)#

create geo Physical domain string from names and the type of domain sd = “P” or “L” or “E” or “S”

create geo Physical domain string from names and type of side domain sd = “P” or “L” or “E” or “S”

string_t xlifepp::physicalDomain(const std::vector<string_t> &sidenames, const Strings &sids, std::vector<PhysicalData> &pids)#

create geo Physical domain string from sidenames and the type of side domain sd = “P” or “L” or “E” or “S”

create geo Physical domain string from sidenames and type of side domain sd = “P” or “L” or “E” or “S”

string_t xlifepp::physicalDomain(const string_t &domName, const string_t &sid, dimen_t dim, std::vector<PhysicalData> &pids)#

create geo Physical domain string from sidenames and the type of side domain sd = “P” or “L” or “E” or “S”

create geo Physical domain string from domain name, surface id, and dimension

string_t xlifepp::physicalDomain(const string_t &domName, const Strings &sids, dimen_t dim, std::vector<PhysicalData> &pids)#

create geo Physical domain string from sidenames and the type of side domain sd = “P” or “L” or “E” or “S”

create geo Physical domain string from domain name, surface ids, and dimension

physicalDomainForExtrusion#

string_t xlifepp::physicalDomainForExtrusion(const Geometry &g, const std::vector<string_t> &sidenames, const std::vector<std::pair<number_t, number_t>> &nbSidesPerComponent, const string_t &sd, const std::map<string_t, Strings> &inputs, std::vector<PhysicalData> &pids, real_t angle)#

create geo Physical domain string from sidenames and the type of side domain sd = “P” or “L” or “E” or “S” for extrusion geometries

create geo Physical domain string from sidenames and the type of side domain sd = “P” or “L” or “E” or “S”

physicalDomains#

string_t xlifepp::physicalDomains(const std::vector<PhysicalData> &pids)#: create geo Physical domain string from sidenames and the type of side domain sd = “P” or “L” or “E” or “S”

pictureCrack#

void xlifepp::pictureCrack(const std::set<GeomElement*> &elts1, const std::set<GeomElement*> &elts2, const string_t &fn)#

planeNormal#

Vector<real_t> xlifepp::planeNormal(const Point &p, bool fromParameters, Parameters &pars)#: function returning the plane normal stored in Parameters pars

planeSurfaceFrom#

inline Geometry xlifepp::planeSurfaceFrom(const Geometry &c, string_t domName = "")#: definition of a geometry 2D from an union of boundaries 1D

plot#

void xlifepp::plot(const TermVector &tv, IOFormat iof)#

plot a TermVector using external call of appropriate viewer

plotting a TermVector

point_to_xyz#

inline Vector<real_t> xlifepp::point_to_xyz(const Point &p, Parameters &pa = defaultParameters)#

pointDistance#

real_t xlifepp::pointDistance(const Point&, const Point&)#: returns distance between two points

pointer#

const void *xlifepp::pointer(const Parameter&)#: cast to const void *

pointInElement#

bool xlifepp::pointInElement(const Point &P, const GeomElement &E, real_t tol)#

pointInPolygon#

bool xlifepp::pointInPolygon(const Point &p, const Geometry &g)#

pointInPolyhedron#

bool xlifepp::pointInPolyhedron(const Point &p, const Geometry &g)#

pointOrientation2D#

int xlifepp::pointOrientation2D(const Point &A, const Point &B, const Point &C, real_t tol)#

determines if points A, B and C are colinear (returns 0) or a clockwise triangle (returns 1) or a counter-clockwise triangle (returns 2). A, B and C are supposed to be 2D points (not checked)

determines if points A, B and C are colinear, a clockwise triangle or a counter-clockwise triangle

pointQuadrature#

Quadrature *xlifepp::pointQuadrature(QuadRule rule, number_t deg)#

pointReflect#

template<class Geom> Geom xlifepp::pointReflect(const Geom &g, const Parameter &p1)#: apply a point reflection on a Geom (1 key) (template external)

template<class Geom> Geom xlifepp::pointReflect(const Geom &g, const Point &c = Point(0., 0., 0.))#: apply a point reflection on a Geom (template external)

inline Geometry xlifepp::pointReflect(const Geometry &g, const Parameter &p1)#: apply a point reflection on a Geometry (1 key) (template external)

inline Geometry xlifepp::pointReflect(const Geometry &g, const Point &c = Point(0., 0., 0.))#: apply a point reflection on a Geometry (template external)

Mesh xlifepp::pointReflect(const Mesh &m, const Parameter &p1)#

apply a point reflection on a Mesh (1 key)

apply a point reflection on a Mesh (1 keys) (external)

Mesh xlifepp::pointReflect(const Mesh &m, const Parameter &p1, const Parameter &p2)#

apply a point reflection on a Mesh (2 keys)

apply a point reflection on a Mesh (2 keys) (external)

Mesh xlifepp::pointReflect(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3)#

apply a point reflection on a Mesh (3 keys)

apply a point reflection on a Mesh (3 keys) (external)

Mesh xlifepp::pointReflect(const Mesh &m, const Point &c)#: apply a point reflection on a Mesh (external)

inline Point xlifepp::pointReflect(const Point &g, const Parameter &p1)#: apply a point reflection on a Point (1 key) (template external)

inline Point xlifepp::pointReflect(const Point &g, const Point &c = Point(0., 0., 0.))#: apply a point reflection on a Point (template external)

pow#

inline SuTermVector xlifepp::pow(const SuTermVector &s, const real_t &p)#

inline SymbolicFunction &xlifepp::pow(const SymbolicFunction &f, const double &p)#

inline TermVector xlifepp::pow(const TermVector &s, const real_t &p)#

power#

inline SymbolicFunction &xlifepp::power(const real_t &r, const SymbolicFunction &f)#

inline SymbolicFunction &xlifepp::power(const SymbolicFunction &f, const real_t &r)#

inline SymbolicFunction &xlifepp::power(const SymbolicFunction &f1, const SymbolicFunction &f2)#

template<typename K> Vector<K> xlifepp::power(const Vector<K> &v, real_t n)#: log(v)

preComputationFE#

inline void xlifepp::preComputationFE(Space *subsp, const MeshDomain *dom, std::set<Quadrature*> &quads, dimen_t nbc, bool der1, bool der2, bool invertJacobian, bool nor, bool mapquad, bool useAux, bool isogeo)#

preComputationIE#

void xlifepp::preComputationIE(const GeomDomain &dom, const Space *subsp, std::set<Quadrature*> &quads, dimen_t nbc, bool useAux, bool der1, bool der2, bool nor, bool extendedDomain, bool isogeo)#

precompute geometry data and shape values on any element for any quadrature involved restricted to one order geometric element, take large place but computation is then faster in case of IE!!!

precompute geometry data and shape values on any element for any quadrature involved

dom: integration domain subsp: subspace providing the list of elements quads: list of quadratures nbc: number of components of the unknown useAux: use relt->qshvs_aux to store shapevalues (occurs when relt->qshvs_ is already used) der1: compute shape first derivatives if true der2: compute shape second derivatives if true nor: compute normal if true extendedDomain: true when dealing with an extended domain isogeo : if true, use domain parametrization in geometric computation

preComputationIE_old#

void xlifepp::preComputationIE_old(const Space *subsp, std::set<Quadrature*> &quads, dimen_t nbc, bool der1, bool der2, bool nor)#

precompute geometry data and shape values on any element for any quadrature involved restricted to one order geometric element, take large place but computation is then faster in case of IE!!!

subsp: subspace providing the list of elements quads: list of quadratures nbc: number of components of the unknown der1: compute shape first derivatives if true der2: compute shape second derivatives if true nor: compute normal if true

prepareLinearSystem#

TermVector xlifepp::prepareLinearSystem(TermMatrix&, TermVector&, MatrixEntry*&, VectorEntry*&, StorageType, AccessType, bool)#: prepare linear system AX=B (internal tool)

print#

void xlifepp::print(const Parameter &p)#

void xlifepp::print(const Parameters&)#: extern print to default ostream

printAllInMemory#

void xlifepp::printAllInMemory(PrintStream &os, size_t vb)#

void xlifepp::printAllInMemory(std::ostream &os, size_t vb)#

printCoo#

void xlifepp::printCoo(std::ostream &os, const complex_t &v, number_t i, number_t j, real_t tol)#

template<typename T> void xlifepp::printCoo(std::ostream &os, const Matrix<T> &v, number_t i, number_t j, real_t tol = theTolerance)#

void xlifepp::printCoo(std::ostream &os, const real_t &v, number_t i, number_t j, real_t tol)#

printDense#

void xlifepp::printDense(std::ostream&, const complex_t&, number_t)#: print complex scalar in dense format

void xlifepp::printDense(std::ostream&, const real_t&, number_t)#: print real scalar in dense format

template<typename T> void xlifepp::printDense(std::ostream &os, const Matrix<T> &v, number_t k)#: print row of Matrix in dense format

printListDiffOp#

void xlifepp::printListDiffOp(CoutStream&)#: print the list of differential operators (check utility)

void xlifepp::printListDiffOp(std::ostream&)#: print the list of differential operators (check utility)

printMatrixStorages#

inline void xlifepp::printMatrixStorages(PrintStream &os)#

void xlifepp::printMatrixStorages(std::ostream&)#: print list of MatrixStorage’s

printRowWise#

template<typename Iterator> void xlifepp::printRowWise(std::ostream &os, const string_t &title, number_t perRow, number_t width, Iterator it1, Iterator it2)#: prints container of integer type on opened ostream with a constant number of entries per row; requires “operator<<” this is a stl-like utility: iterators are either stl::iterators or C-pointers

template<typename Iterator> void xlifepp::printRowWise(std::ostream &os, const string_t &title, number_t perRow, number_t width, number_t prec, Iterator it1, Iterator it2)#: prints container of real or complex type on opened ostream with a constant number of entries per row; requires “operator<<” this is a stl-like utility: iterators are either stl::iterators or C-pointers

printVector#

template<typename K> void xlifepp::printVector(std::ostream &os, const string_t &s, const std::vector<K> &v)#

prismLagrangeStd#

RefElement *xlifepp::prismLagrangeStd(const Interpolation *interp_p)#

prismLagrangeStd construction of a prismatic Lagrange Reference Element by interpolation number

Extern class related functions and declarations.

prismQuadrature#

Quadrature *xlifepp::prismQuadrature(QuadRule, number_t)#: find or create quadrature rule over the unit prism

prismValid#

bool xlifepp::prismValid(const std::set<std::pair<number_t, Point>, SortPointsByXAndY> &face1, const std::set<std::pair<number_t, Point>, SortPointsByXAndY> &face2)#: determines if a prism defined by its triangular faces is valid or not faces must coincide first point of each face has coordinates xmin and ymin

projection#

TermVector xlifepp::projection(const TermVector &X, Space &W, const Unknown &u, ProjectorType pt, KeepStatus keep)#

TermVector xlifepp::projection(const TermVector &X, Space &W, dimen_t nbcW, const Unknown &u, ProjectorType pt, KeepStatus keep)#

TermVector xlifepp::projection(const TermVector &X, Space &W, dimen_t nbcW, ProjectorType pt, KeepStatus keep)#

TermVector xlifepp::projection(const TermVector &X, Space &W, ProjectorType pt, KeepStatus keep)#

projectionOfPointOnPlane#

Point xlifepp::projectionOfPointOnPlane(const Point &M, const Point &P1, const Point &P2, const Point &P3, real_t &h, bool only3D)#

orthogonal projection of point M on plane defined by 3 non aligned given points (P1, P2, and P3) returns the projected point P and the distance h between M and the plane

orthogonal projection of a point on a plane

projectionOfSegmentOnPlane#

std::pair<Point, Point> xlifepp::projectionOfSegmentOnPlane(const Point &S1, const Point &S2, const Point &P1, const Point &P2, const Point &P3, real_t &h)#

orthogonal projection of segment defined by the points T1 and T2 on the parallel plane defined by the 3 non aligned given points S1, S2, and S3 returns the projected points and the distance h between the segment and the plane

orthogonal projection of a segment on a parallel plane

projectionOfTriangleOnPlane#

std::vector<Point> xlifepp::projectionOfTriangleOnPlane(const Point &T1, const Point &T2, const Point &T3, const Point &P1, const Point &P2, const Point &P3, real_t &h)#

orthogonal projection of triangle defined by the points T1, T2 and T3 on the parallel plane defined by the 3 non aligned given points P1, P2, and P3 returns the projected points and the distance h between the triangle and the plane

orthogonal projection of a triangle on a parallel plane

projectionOnQuadrangle#

Point xlifepp::projectionOnQuadrangle(const Point &M, const Point &Q1, const Point &Q2, const Point &Q3, const Point &Q4, real_t &h)#

projection (minimal distance) of point M on quadrangle given by vertices Q1, Q2, Q3, Q4 (assuming Q1, Q2, Q3, Q4 are coplanar) returns the projected point P and the distance h=MP (2D-3D)

projection (minimal distance) of point M on quadrangle given points Q1, Q2, Q3 and Q4 (assuming Q1, Q2, Q3 and Q4 are coplanar)

projectionOnSegment#

Point xlifepp::projectionOnSegment(const Point &M, const Point &A, const Point &B, real_t &h)#

projection (minimal distance) of a point M on segment [AB] returns the projected point P and the distance h=MP

projection (minimal distance) of a point M on the segment defined points A, B

projectionOnStraightLine#

Point xlifepp::projectionOnStraightLine(const Point &M, const Point &A, const Point &B, real_t &h, bool only3D)#

orthogonal projection of a point M on a straight line defined by 2 points (A and B) returns the projected point P and the distance h=MP

orthogonal projection of a point on a straight line

projectionOnTetrahedron#

Point xlifepp::projectionOnTetrahedron(const Point &M, const Point &T1, const Point &T2, const Point &T3, const Point &T4, real_t &h)#

projection (minimal distance) of point M on tetrahedron given vertices T1, T2, T3 and T4 returns the projected point P and the distance h=MP (3D)

projection (minimal distance) of point M on tetrahedron given points T1, T2, T3 and T4

projectionOnTriangle#

Point xlifepp::projectionOnTriangle(const Point &M, const Point &T1, const Point &T2, const Point &T3, real_t &h)#

projection (minimal distance) of point M on triangle given vertices T1, T2, and T3 returns the projected point P and the distance h=MP (2D-3D)

projection (minimal distance) of point M on triangle given vertices T1, T2, and T3

pyramidLagrangeStd#

RefElement *xlifepp::pyramidLagrangeStd(const Interpolation *interp_p)#

pyramidLagrangeStd construction of a pyramidatic Lagrange Reference Element by interpolation number

Extern class related functions and declarations.

pyramidQuadrature#

Quadrature *xlifepp::pyramidQuadrature(QuadRule, number_t)#: find or create quadrature rule over the unit pyramid