Class xlifepp::GeomMapData#

class GeomMapData#

Collaboration diagram for xlifepp::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