Class xlifepp::GeomMapData#

class GeomMapData#

object handles useful computational data of a geometric element It stores jacobian, its determinant, … depending of a point

Public Functions

GeomMapData(const MeshElement*, bool withJ = false, bool withInvJ = false, bool withN = false)#: basic constructor (element centroid as point)

GeomMapData(const MeshElement*, const Point&, bool withJ = false, bool withInvJ = false, bool withN = false)#: basic constructor

GeomMapData(const MeshElement*, std::vector<real_t>::const_iterator, bool withJ = false, bool withInvJ = false, bool withN = false)#: basic constructor

void computeDifferentialElement()#: compute differential element assuming jacobian matrix is update

real_t computeJacobianDeterminant()#: compute jacobian determinant (jacobian already computed)

void computeJacobianMatrix(const ShapeValues &shv, number_t side = 0)#: compute jacobian matrix (shape functions given)

void computeJacobianMatrix(const std::vector<real_t>&, number_t side = 0)#: compute jacobian matrix at a point given as vector or Point

void computeJacobianMatrix(std::vector<real_t>::const_iterator, number_t side = 0)#: compute jacobian matrix at a point given by iterator

void computeMetricTensor()#: compute metric tensor for surface differential geometry

void computeNormalVector()#: computes normal vector at a point of element

void computeOrientedNormal()#: compute oriented unit normal vector, assuming jacobian matrix is update

void computeSurfaceGradient(real_t, real_t, std::vector<real_t>&)#: compute surface gradient gradS from 2D reference gradient (grad0, grad1)

void computeTangentVector()#: computes tangent (and bitangent) vector at a point of element

Matrix<real_t> contravariantPiolaMap(const Point& = Point())#

return the contravariant Piola map matrix at current point

return the contravariant Piola map matrix at current point: J/|J| when mapping from 1d->2d or 2d->3d the matrix J/|J| is replace by J/sqrt|Jt*J| note: in that case computeJacobianDeterminant() compute sqrt|Jt*J|

Matrix<real_t> covariantPiolaMap(const Point& = Point())#

return the covariant Piola map matrix at current point

return the covariant Piola map matrix at current point: J^{-T} when mapping from 1d->2d or 2d->3d the matrix J^{-T} is replace by J*(J{T}*J)^{-1}{T} note: in that case invertJacobian() compute J*(J{T}*J)^{-1}

inline const MeshElement &geomElement() const#: access to related MeshElement

Point geomMap(const ShapeValues &shv, number_t side)#

access to measure of element(s=0) or measure of side s>0

mapping from ref. elt onto geom. elt. Element (shape functions given, thread safe)

Point geomMap(const std::vector<real_t> &p, number_t side = 0)#

mapping from ref.

elt onto geom. elt. Element of point p

Point geomMap(std::vector<real_t>::const_iterator p, number_t side = 0)#

mapping from ref.

elt onto geom. elt. Element of point p

Point geomMapInverse(const std::vector<real_t>&, real_t eps = theTolerance, number_t maxIter = 50)#

mapping from elt onto ref.

elt. of point p

elt. (inverse of GeomMap) mapping may be non linear: order >1 or not simplicial element (quadrangle, hexahedron) so to inverse it we have to use an iterative method (Newton for instance) first step: initialize Newton’s method with first order map say P_0=(JF1)^-1(P-F1(0)) if element is a 1 order simplicial element return P_0 second step: Newton’s iteration P_k+1=P_k - JF(P_k)^-1(P-F(Pk)) stop if ||F(P_k+1)-X||< eps or ||P_k+1-P_k+1||< eps stop also if the number of iteration k>50 (error)

void invertJacobianMatrix()#: compute inverse of jacobian matrix (jacobian already computed)

void normalize()#: normalize normal vector to element

Point piolaMap(number_t side = 0)#

Piola mapping from ref.

elt onto geom. elt. Element (shape functions known)

void print(std::ostream&) const#: print GeoMapData

std::vector<Vector<real_t>> &sideNV() const#: get normals to the sides of the element

Public Members

Vector<real_t> bitangentVector#: second unit tangent vector at a given boundary point

Point currentPoint#: point in reference element used for last computation

real_t differentialElement#

differential element for elementary integrals (abs(jac.

det.))

dimen_t elementDim#: dim of reference space

ExtensionData *extdata#: pointer to additionnal data used by extension

Matrix<real_t> inverseJacobianMatrix#: inverse jacobian matrix (when needed)

const Parametrization *isoPar_p#: pointer to isoGeometric parametrization (default 0)

real_t jacobianDeterminant#: jacobian determinant

Matrix<real_t> jacobianMatrix#: jacobian matrix of mapping from reference element to current one

Matrix<real_t> metricTensor#: symetric metric tensor (t_i|t_j)

real_t metricTensorDeterminant#: metric_tensor determinant for differential geometry

Vector<real_t> normalVector#: unit outward normal vector at a given boundary point

std::map<Quadrature*, std::vector<Point>> phyPoints#: to store image of quadrature points in physical space

mutable std::vector<Vector<real_t>> sideNormalVectors#: normal to the sides of the element (build if required)

dimen_t spaceDim#: dim of physical space

Vector<real_t> tangentVector#: unit tangent vector at a given boundary point

bool useIsoNodes#: if true use MeshElement::isoNodes (default false)

bool useParametrization#: if true take into account isogeometric parametrization (default false)

Friends

friend std::ostream &operator<<(std::ostream&, const GeomMapData&)#: print operator