libMesh
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes | Friends | List of all members
libMesh::FEMap Class Reference

Class contained in FE that encapsulates mapping (i.e. More...

#include <fe_map.h>

Inheritance diagram for libMesh::FEMap:
[legend]

Public Member Functions

 FEMap ()
 
virtual ~FEMap ()
 
template<unsigned int Dim>
void init_reference_to_physical_map (const std::vector< Point > &qp, const Elem *elem)
 
void compute_single_point_map (const unsigned int dim, const std::vector< Real > &qw, const Elem *elem, unsigned int p, const std::vector< const Node *> &elem_nodes, bool compute_second_derivatives)
 Compute the jacobian and some other additional data fields at the single point with index p. More...
 
virtual void compute_affine_map (const unsigned int dim, const std::vector< Real > &qw, const Elem *elem)
 Compute the jacobian and some other additional data fields. More...
 
virtual void compute_null_map (const unsigned int dim, const std::vector< Real > &qw)
 Assign a fake jacobian and some other additional data fields. More...
 
virtual void compute_map (const unsigned int dim, const std::vector< Real > &qw, const Elem *elem, bool calculate_d2phi)
 Compute the jacobian and some other additional data fields. More...
 
virtual void compute_face_map (int dim, const std::vector< Real > &qw, const Elem *side)
 Same as compute_map, but for a side. More...
 
void compute_edge_map (int dim, const std::vector< Real > &qw, const Elem *side)
 Same as before, but for an edge. More...
 
template<unsigned int Dim>
void init_face_shape_functions (const std::vector< Point > &qp, const Elem *side)
 Initializes the reference to physical element map for a side. More...
 
template<unsigned int Dim>
void init_edge_shape_functions (const std::vector< Point > &qp, const Elem *edge)
 Same as before, but for an edge. More...
 
const std::vector< Point > & get_xyz () const
 
const std::vector< Real > & get_jacobian () const
 
const std::vector< Real > & get_JxW () const
 
const std::vector< RealGradient > & get_dxyzdxi () const
 
const std::vector< RealGradient > & get_dxyzdeta () const
 
const std::vector< RealGradient > & get_dxyzdzeta () const
 
const std::vector< RealGradient > & get_d2xyzdxi2 () const
 
const std::vector< RealGradient > & get_d2xyzdeta2 () const
 
const std::vector< RealGradient > & get_d2xyzdzeta2 () const
 
const std::vector< RealGradient > & get_d2xyzdxideta () const
 
const std::vector< RealGradient > & get_d2xyzdxidzeta () const
 
const std::vector< RealGradient > & get_d2xyzdetadzeta () const
 
const std::vector< Real > & get_dxidx () const
 
const std::vector< Real > & get_dxidy () const
 
const std::vector< Real > & get_dxidz () const
 
const std::vector< Real > & get_detadx () const
 
const std::vector< Real > & get_detady () const
 
const std::vector< Real > & get_detadz () const
 
const std::vector< Real > & get_dzetadx () const
 
const std::vector< Real > & get_dzetady () const
 
const std::vector< Real > & get_dzetadz () const
 
const std::vector< std::vector< Real > > & get_d2xidxyz2 () const
 Second derivatives of "xi" reference coordinate wrt physical coordinates. More...
 
const std::vector< std::vector< Real > > & get_d2etadxyz2 () const
 Second derivatives of "eta" reference coordinate wrt physical coordinates. More...
 
const std::vector< std::vector< Real > > & get_d2zetadxyz2 () const
 Second derivatives of "zeta" reference coordinate wrt physical coordinates. More...
 
const std::vector< std::vector< Real > > & get_psi () const
 
const std::vector< std::vector< Real > > & get_phi_map () const
 
const std::vector< std::vector< Real > > & get_dphidxi_map () const
 
const std::vector< std::vector< Real > > & get_dphideta_map () const
 
const std::vector< std::vector< Real > > & get_dphidzeta_map () const
 
const std::vector< std::vector< Point > > & get_tangents () const
 
const std::vector< Point > & get_normals () const
 
const std::vector< Real > & get_curvatures () const
 
void print_JxW (std::ostream &os) const
 Prints the Jacobian times the weight for each quadrature point. More...
 
void print_xyz (std::ostream &os) const
 Prints the spatial location of each quadrature point (on the physical element). More...
 
std::vector< std::vector< Real > > & get_psi ()
 
std::vector< std::vector< Real > > & get_dpsidxi ()
 
std::vector< std::vector< Real > > & get_dpsideta ()
 
std::vector< std::vector< Real > > & get_d2psidxi2 ()
 
std::vector< std::vector< Real > > & get_d2psidxideta ()
 
std::vector< std::vector< Real > > & get_d2psideta2 ()
 
std::vector< std::vector< Real > > & get_phi_map ()
 
std::vector< std::vector< Real > > & get_dphidxi_map ()
 
std::vector< std::vector< Real > > & get_dphideta_map ()
 
std::vector< std::vector< Real > > & get_dphidzeta_map ()
 
std::vector< std::vector< Real > > & get_d2phidxi2_map ()
 
std::vector< std::vector< Real > > & get_d2phidxideta_map ()
 
std::vector< std::vector< Real > > & get_d2phidxidzeta_map ()
 
std::vector< std::vector< Real > > & get_d2phideta2_map ()
 
std::vector< std::vector< Real > > & get_d2phidetadzeta_map ()
 
std::vector< std::vector< Real > > & get_d2phidzeta2_map ()
 
std::vector< Real > & get_JxW ()
 

Static Public Member Functions

static std::unique_ptr< FEMapbuild (FEType fe_type)
 

Protected Member Functions

void determine_calculations ()
 Determine which values are to be calculated. More...
 
void resize_quadrature_map_vectors (const unsigned int dim, unsigned int n_qp)
 A utility function for use by compute_*_map. More...
 
Real dxdxi_map (const unsigned int p) const
 Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected. More...
 
Real dydxi_map (const unsigned int p) const
 Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected. More...
 
Real dzdxi_map (const unsigned int p) const
 Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected. More...
 
Real dxdeta_map (const unsigned int p) const
 Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected. More...
 
Real dydeta_map (const unsigned int p) const
 Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected. More...
 
Real dzdeta_map (const unsigned int p) const
 Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected. More...
 
Real dxdzeta_map (const unsigned int p) const
 Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected. More...
 
Real dydzeta_map (const unsigned int p) const
 Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected. More...
 
Real dzdzeta_map (const unsigned int p) const
 Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected. More...
 

Protected Attributes

std::vector< Pointxyz
 The spatial locations of the quadrature points. More...
 
std::vector< RealGradientdxyzdxi_map
 Vector of partial derivatives: d(x)/d(xi), d(y)/d(xi), d(z)/d(xi) More...
 
std::vector< RealGradientdxyzdeta_map
 Vector of partial derivatives: d(x)/d(eta), d(y)/d(eta), d(z)/d(eta) More...
 
std::vector< RealGradientdxyzdzeta_map
 Vector of partial derivatives: d(x)/d(zeta), d(y)/d(zeta), d(z)/d(zeta) More...
 
std::vector< RealGradientd2xyzdxi2_map
 Vector of second partial derivatives in xi: d^2(x)/d(xi)^2, d^2(y)/d(xi)^2, d^2(z)/d(xi)^2. More...
 
std::vector< RealGradientd2xyzdxideta_map
 Vector of mixed second partial derivatives in xi-eta: d^2(x)/d(xi)d(eta) d^2(y)/d(xi)d(eta) d^2(z)/d(xi)d(eta) More...
 
std::vector< RealGradientd2xyzdeta2_map
 Vector of second partial derivatives in eta: d^2(x)/d(eta)^2. More...
 
std::vector< RealGradientd2xyzdxidzeta_map
 Vector of second partial derivatives in xi-zeta: d^2(x)/d(xi)d(zeta), d^2(y)/d(xi)d(zeta), d^2(z)/d(xi)d(zeta) More...
 
std::vector< RealGradientd2xyzdetadzeta_map
 Vector of mixed second partial derivatives in eta-zeta: d^2(x)/d(eta)d(zeta) d^2(y)/d(eta)d(zeta) d^2(z)/d(eta)d(zeta) More...
 
std::vector< RealGradientd2xyzdzeta2_map
 Vector of second partial derivatives in zeta: d^2(x)/d(zeta)^2. More...
 
std::vector< Realdxidx_map
 Map for partial derivatives: d(xi)/d(x). More...
 
std::vector< Realdxidy_map
 Map for partial derivatives: d(xi)/d(y). More...
 
std::vector< Realdxidz_map
 Map for partial derivatives: d(xi)/d(z). More...
 
std::vector< Realdetadx_map
 Map for partial derivatives: d(eta)/d(x). More...
 
std::vector< Realdetady_map
 Map for partial derivatives: d(eta)/d(y). More...
 
std::vector< Realdetadz_map
 Map for partial derivatives: d(eta)/d(z). More...
 
std::vector< Realdzetadx_map
 Map for partial derivatives: d(zeta)/d(x). More...
 
std::vector< Realdzetady_map
 Map for partial derivatives: d(zeta)/d(y). More...
 
std::vector< Realdzetadz_map
 Map for partial derivatives: d(zeta)/d(z). More...
 
std::vector< std::vector< Real > > d2xidxyz2_map
 Second derivatives of "xi" reference coordinate wrt physical coordinates. More...
 
std::vector< std::vector< Real > > d2etadxyz2_map
 Second derivatives of "eta" reference coordinate wrt physical coordinates. More...
 
std::vector< std::vector< Real > > d2zetadxyz2_map
 Second derivatives of "zeta" reference coordinate wrt physical coordinates. More...
 
std::vector< std::vector< Real > > phi_map
 Map for the shape function phi. More...
 
std::vector< std::vector< Real > > dphidxi_map
 Map for the derivative, d(phi)/d(xi). More...
 
std::vector< std::vector< Real > > dphideta_map
 Map for the derivative, d(phi)/d(eta). More...
 
std::vector< std::vector< Real > > dphidzeta_map
 Map for the derivative, d(phi)/d(zeta). More...
 
std::vector< std::vector< Real > > d2phidxi2_map
 Map for the second derivative, d^2(phi)/d(xi)^2. More...
 
std::vector< std::vector< Real > > d2phidxideta_map
 Map for the second derivative, d^2(phi)/d(xi)d(eta). More...
 
std::vector< std::vector< Real > > d2phidxidzeta_map
 Map for the second derivative, d^2(phi)/d(xi)d(zeta). More...
 
std::vector< std::vector< Real > > d2phideta2_map
 Map for the second derivative, d^2(phi)/d(eta)^2. More...
 
std::vector< std::vector< Real > > d2phidetadzeta_map
 Map for the second derivative, d^2(phi)/d(eta)d(zeta). More...
 
std::vector< std::vector< Real > > d2phidzeta2_map
 Map for the second derivative, d^2(phi)/d(zeta)^2. More...
 
std::vector< std::vector< Real > > psi_map
 Map for the side shape functions, psi. More...
 
std::vector< std::vector< Real > > dpsidxi_map
 Map for the derivative of the side functions, d(psi)/d(xi). More...
 
std::vector< std::vector< Real > > dpsideta_map
 Map for the derivative of the side function, d(psi)/d(eta). More...
 
std::vector< std::vector< Real > > d2psidxi2_map
 Map for the second derivatives (in xi) of the side shape functions. More...
 
std::vector< std::vector< Real > > d2psidxideta_map
 Map for the second (cross) derivatives in xi, eta of the side shape functions. More...
 
std::vector< std::vector< Real > > d2psideta2_map
 Map for the second derivatives (in eta) of the side shape functions. More...
 
std::vector< std::vector< Point > > tangents
 Tangent vectors on boundary at quadrature points. More...
 
std::vector< Pointnormals
 Normal vectors on boundary at quadrature points. More...
 
std::vector< Realcurvatures
 The mean curvature (= one half the sum of the principal curvatures) on the boundary at the quadrature points. More...
 
std::vector< Realjac
 Jacobian values at quadrature points. More...
 
std::vector< RealJxW
 Jacobian*Weight values at quadrature points. More...
 
bool calculations_started
 Have calculations with this object already been started? Then all get_* functions should already have been called. More...
 
bool calculate_xyz
 Should we calculate physical point locations? More...
 
bool calculate_dxyz
 Should we calculate mapping gradients? More...
 
bool calculate_d2xyz
 Should we calculate mapping hessians? More...
 

Private Member Functions

void compute_inverse_map_second_derivs (unsigned p)
 A helper function used by FEMap::compute_single_point_map() to compute second derivatives of the inverse map. More...
 

Private Attributes

std::vector< const Node * > _elem_nodes
 Work vector for compute_affine_map() More...
 

Friends

template<unsigned int Dim, FEFamily T>
class FE
 FE classes should be able to reset calculations_started in a few special cases. More...
 

Detailed Description

Class contained in FE that encapsulates mapping (i.e.

from physical space to reference space and vice-versa) quantities and operations.

Author
Paul Bauman
Date
2012 Computes finite element mapping function values, gradients, etc.

Definition at line 48 of file fe_map.h.

Constructor & Destructor Documentation

◆ FEMap()

libMesh::FEMap::FEMap ( )

◆ ~FEMap()

virtual libMesh::FEMap::~FEMap ( )
virtual

Definition at line 53 of file fe_map.h.

53 {}

Member Function Documentation

◆ build()

static std::unique_ptr<FEMap> libMesh::FEMap::build ( FEType  fe_type)
static

◆ compute_affine_map()

virtual void libMesh::FEMap::compute_affine_map ( const unsigned int  dim,
const std::vector< Real > &  qw,
const Elem elem 
)
virtual

Compute the jacobian and some other additional data fields.

Takes the integration weights as input, along with a pointer to the element. The element is assumed to have a constant Jacobian

◆ compute_edge_map()

void libMesh::FEMap::compute_edge_map ( int  dim,
const std::vector< Real > &  qw,
const Elem side 
)

Same as before, but for an edge.

Useful for some projections.

◆ compute_face_map()

virtual void libMesh::FEMap::compute_face_map ( int  dim,
const std::vector< Real > &  qw,
const Elem side 
)
virtual

Same as compute_map, but for a side.

Useful for boundary integration.

Reimplemented in libMesh::FEXYZMap.

◆ compute_inverse_map_second_derivs()

void libMesh::FEMap::compute_inverse_map_second_derivs ( unsigned  p)
private

A helper function used by FEMap::compute_single_point_map() to compute second derivatives of the inverse map.

◆ compute_map()

virtual void libMesh::FEMap::compute_map ( const unsigned int  dim,
const std::vector< Real > &  qw,
const Elem elem,
bool  calculate_d2phi 
)
virtual

Compute the jacobian and some other additional data fields.

Takes the integration weights as input, along with a pointer to the element. Also takes a boolean parameter indicating whether second derivatives need to be calculated, allowing us to potentially skip unnecessary, expensive computations.

◆ compute_null_map()

virtual void libMesh::FEMap::compute_null_map ( const unsigned int  dim,
const std::vector< Real > &  qw 
)
virtual

Assign a fake jacobian and some other additional data fields.

Takes the integration weights as input. For use on non-element evaluations.

◆ compute_single_point_map()

void libMesh::FEMap::compute_single_point_map ( const unsigned int  dim,
const std::vector< Real > &  qw,
const Elem elem,
unsigned int  p,
const std::vector< const Node *> &  elem_nodes,
bool  compute_second_derivatives 
)

Compute the jacobian and some other additional data fields at the single point with index p.

Takes the integration weights as input, along with a pointer to the element and a list of points that contribute to the element. Also takes a boolean flag telling whether second derivatives should actually be computed.

◆ determine_calculations()

void libMesh::FEMap::determine_calculations ( )
protected

Determine which values are to be calculated.

Definition at line 527 of file fe_map.h.

References calculate_d2xyz, calculate_dxyz, and calculations_started.

527  {
528  calculations_started = true;
529 
530 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
531  // Second derivative calculations currently have first derivative
532  // calculations as a prerequisite
533  if (calculate_d2xyz)
534  calculate_dxyz = true;
535 #endif
536  }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ dxdeta_map()

Real libMesh::FEMap::dxdeta_map ( const unsigned int  p) const
protected

Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.

Returns
The x value of the pth entry of the dxzydeta_map.

Definition at line 573 of file fe_map.h.

References dxyzdeta_map.

573 { return dxyzdeta_map[p](0); }
std::vector< RealGradient > dxyzdeta_map
Vector of partial derivatives: d(x)/d(eta), d(y)/d(eta), d(z)/d(eta)
Definition: fe_map.h:630

◆ dxdxi_map()

Real libMesh::FEMap::dxdxi_map ( const unsigned int  p) const
protected

Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.

Returns
The x value of the pth entry of the dxzydxi_map.

Definition at line 549 of file fe_map.h.

References dxyzdxi_map.

549 { return dxyzdxi_map[p](0); }
std::vector< RealGradient > dxyzdxi_map
Vector of partial derivatives: d(x)/d(xi), d(y)/d(xi), d(z)/d(xi)
Definition: fe_map.h:624

◆ dxdzeta_map()

Real libMesh::FEMap::dxdzeta_map ( const unsigned int  p) const
protected

Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.

Returns
The x value of the pth entry of the dxzydzeta_map.

Definition at line 597 of file fe_map.h.

References dxyzdzeta_map.

597 { return dxyzdzeta_map[p](0); }
std::vector< RealGradient > dxyzdzeta_map
Vector of partial derivatives: d(x)/d(zeta), d(y)/d(zeta), d(z)/d(zeta)
Definition: fe_map.h:636

◆ dydeta_map()

Real libMesh::FEMap::dydeta_map ( const unsigned int  p) const
protected

Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.

Returns
The y value of the pth entry of the dxzydeta_map.

Definition at line 581 of file fe_map.h.

References dxyzdeta_map.

581 { return dxyzdeta_map[p](1); }
std::vector< RealGradient > dxyzdeta_map
Vector of partial derivatives: d(x)/d(eta), d(y)/d(eta), d(z)/d(eta)
Definition: fe_map.h:630

◆ dydxi_map()

Real libMesh::FEMap::dydxi_map ( const unsigned int  p) const
protected

Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.

Returns
The y value of the pth entry of the dxzydxi_map.

Definition at line 557 of file fe_map.h.

References dxyzdxi_map.

557 { return dxyzdxi_map[p](1); }
std::vector< RealGradient > dxyzdxi_map
Vector of partial derivatives: d(x)/d(xi), d(y)/d(xi), d(z)/d(xi)
Definition: fe_map.h:624

◆ dydzeta_map()

Real libMesh::FEMap::dydzeta_map ( const unsigned int  p) const
protected

Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.

Returns
The y value of the pth entry of the dxzydzeta_map.

Definition at line 605 of file fe_map.h.

References dxyzdzeta_map.

605 { return dxyzdzeta_map[p](1); }
std::vector< RealGradient > dxyzdzeta_map
Vector of partial derivatives: d(x)/d(zeta), d(y)/d(zeta), d(z)/d(zeta)
Definition: fe_map.h:636

◆ dzdeta_map()

Real libMesh::FEMap::dzdeta_map ( const unsigned int  p) const
protected

Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.

Returns
The z value of the pth entry of the dxzydeta_map.

Definition at line 589 of file fe_map.h.

References dxyzdeta_map.

589 { return dxyzdeta_map[p](2); }
std::vector< RealGradient > dxyzdeta_map
Vector of partial derivatives: d(x)/d(eta), d(y)/d(eta), d(z)/d(eta)
Definition: fe_map.h:630

◆ dzdxi_map()

Real libMesh::FEMap::dzdxi_map ( const unsigned int  p) const
protected

Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.

Returns
The z value of the pth entry of the dxzydxi_map.

Definition at line 565 of file fe_map.h.

References dxyzdxi_map.

565 { return dxyzdxi_map[p](2); }
std::vector< RealGradient > dxyzdxi_map
Vector of partial derivatives: d(x)/d(xi), d(y)/d(xi), d(z)/d(xi)
Definition: fe_map.h:624

◆ dzdzeta_map()

Real libMesh::FEMap::dzdzeta_map ( const unsigned int  p) const
protected

Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.

Returns
The z value of the pth entry of the dxzydzeta_map.

Definition at line 613 of file fe_map.h.

References dxyzdzeta_map.

613 { return dxyzdzeta_map[p](2); }
std::vector< RealGradient > dxyzdzeta_map
Vector of partial derivatives: d(x)/d(zeta), d(y)/d(zeta), d(z)/d(zeta)
Definition: fe_map.h:636

◆ get_curvatures()

const std::vector<Real>& libMesh::FEMap::get_curvatures ( ) const
Returns
The curvatures for use in face integration.

Definition at line 380 of file fe_map.h.

References calculate_d2xyz, calculations_started, and curvatures.

381  { libmesh_assert(!calculations_started || calculate_d2xyz);
382  calculate_d2xyz = true; return curvatures;}
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< Real > curvatures
The mean curvature (= one half the sum of the principal curvatures) on the boundary at the quadrature...
Definition: fe_map.h:861

◆ get_d2etadxyz2()

const std::vector<std::vector<Real> >& libMesh::FEMap::get_d2etadxyz2 ( ) const

Second derivatives of "eta" reference coordinate wrt physical coordinates.

Definition at line 317 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2etadxyz2_map.

318  { libmesh_assert(!calculations_started || calculate_d2xyz);
319  calculate_d2xyz = true; return d2etadxyz2_map; }
std::vector< std::vector< Real > > d2etadxyz2_map
Second derivatives of "eta" reference coordinate wrt physical coordinates.
Definition: fe_map.h:745
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_d2phideta2_map()

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2phideta2_map ( )
Returns
The reference to physical map 2nd derivative

Definition at line 493 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2phideta2_map.

494  { libmesh_assert(!calculations_started || calculate_d2xyz);
495  calculate_d2xyz = true; return d2phideta2_map; }
std::vector< std::vector< Real > > d2phideta2_map
Map for the second derivative, d^2(phi)/d(eta)^2.
Definition: fe_map.h:794
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_d2phidetadzeta_map()

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2phidetadzeta_map ( )
Returns
The reference to physical map 2nd derivative

Definition at line 500 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2phidetadzeta_map.

501  { libmesh_assert(!calculations_started || calculate_d2xyz);
502  calculate_d2xyz = true; return d2phidetadzeta_map; }
std::vector< std::vector< Real > > d2phidetadzeta_map
Map for the second derivative, d^2(phi)/d(eta)d(zeta).
Definition: fe_map.h:799
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_d2phidxi2_map()

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2phidxi2_map ( )
Returns
The reference to physical map 2nd derivative

Definition at line 472 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2phidxi2_map.

473  { libmesh_assert(!calculations_started || calculate_d2xyz);
474  calculate_d2xyz = true; return d2phidxi2_map; }
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< std::vector< Real > > d2phidxi2_map
Map for the second derivative, d^2(phi)/d(xi)^2.
Definition: fe_map.h:779

◆ get_d2phidxideta_map()

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2phidxideta_map ( )
Returns
The reference to physical map 2nd derivative

Definition at line 479 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2phidxideta_map.

480  { libmesh_assert(!calculations_started || calculate_d2xyz);
481  calculate_d2xyz = true; return d2phidxideta_map; }
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< std::vector< Real > > d2phidxideta_map
Map for the second derivative, d^2(phi)/d(xi)d(eta).
Definition: fe_map.h:784

◆ get_d2phidxidzeta_map()

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2phidxidzeta_map ( )
Returns
The reference to physical map 2nd derivative

Definition at line 486 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2phidxidzeta_map.

487  { libmesh_assert(!calculations_started || calculate_d2xyz);
488  calculate_d2xyz = true; return d2phidxidzeta_map; }
std::vector< std::vector< Real > > d2phidxidzeta_map
Map for the second derivative, d^2(phi)/d(xi)d(zeta).
Definition: fe_map.h:789
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_d2phidzeta2_map()

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2phidzeta2_map ( )
Returns
The reference to physical map 2nd derivative

Definition at line 507 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2phidzeta2_map.

508  { libmesh_assert(!calculations_started || calculate_d2xyz);
509  calculate_d2xyz = true; return d2phidzeta2_map; }
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< std::vector< Real > > d2phidzeta2_map
Map for the second derivative, d^2(phi)/d(zeta)^2.
Definition: fe_map.h:804

◆ get_d2psideta2()

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2psideta2 ( )
Returns
The reference to physical map 2nd derivative for the side/edge

Definition at line 436 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2psideta2_map.

437  { libmesh_assert(!calculations_started || calculate_d2xyz);
438  calculate_d2xyz = true; return d2psideta2_map; }
std::vector< std::vector< Real > > d2psideta2_map
Map for the second derivatives (in eta) of the side shape functions.
Definition: fe_map.h:844
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_d2psidxi2()

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2psidxi2 ( )
Returns
The reference to physical map 2nd derivative for the side/edge

Definition at line 422 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2psidxi2_map.

423  { libmesh_assert(!calculations_started || calculate_d2xyz);
424  calculate_d2xyz = true; return d2psidxi2_map; }
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< std::vector< Real > > d2psidxi2_map
Map for the second derivatives (in xi) of the side shape functions.
Definition: fe_map.h:830

◆ get_d2psidxideta()

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2psidxideta ( )
Returns
The reference to physical map 2nd derivative for the side/edge

Definition at line 429 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2psidxideta_map.

430  { libmesh_assert(!calculations_started || calculate_d2xyz);
431  calculate_d2xyz = true; return d2psidxideta_map; }
std::vector< std::vector< Real > > d2psidxideta_map
Map for the second (cross) derivatives in xi, eta of the side shape functions.
Definition: fe_map.h:837
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_d2xidxyz2()

const std::vector<std::vector<Real> >& libMesh::FEMap::get_d2xidxyz2 ( ) const

Second derivatives of "xi" reference coordinate wrt physical coordinates.

Definition at line 310 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2xidxyz2_map.

311  { libmesh_assert(!calculations_started || calculate_d2xyz);
312  calculate_d2xyz = true; return d2xidxyz2_map; }
std::vector< std::vector< Real > > d2xidxyz2_map
Second derivatives of "xi" reference coordinate wrt physical coordinates.
Definition: fe_map.h:739
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_d2xyzdeta2()

const std::vector<RealGradient>& libMesh::FEMap::get_d2xyzdeta2 ( ) const
Returns
The second partial derivatives in eta.

Definition at line 194 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2xyzdeta2_map.

195  { libmesh_assert(!calculations_started || calculate_d2xyz);
196  calculate_d2xyz = true; return d2xyzdeta2_map; }
std::vector< RealGradient > d2xyzdeta2_map
Vector of second partial derivatives in eta: d^2(x)/d(eta)^2.
Definition: fe_map.h:654
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_d2xyzdetadzeta()

const std::vector<RealGradient>& libMesh::FEMap::get_d2xyzdetadzeta ( ) const
Returns
The second partial derivatives in eta-zeta.

Definition at line 228 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2xyzdetadzeta_map.

229  { libmesh_assert(!calculations_started || calculate_d2xyz);
230  calculate_d2xyz = true; return d2xyzdetadzeta_map; }
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< RealGradient > d2xyzdetadzeta_map
Vector of mixed second partial derivatives in eta-zeta: d^2(x)/d(eta)d(zeta) d^2(y)/d(eta)d(zeta) d^2...
Definition: fe_map.h:668

◆ get_d2xyzdxi2()

const std::vector<RealGradient>& libMesh::FEMap::get_d2xyzdxi2 ( ) const
Returns
The second partial derivatives in xi.

Definition at line 187 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2xyzdxi2_map.

188  { libmesh_assert(!calculations_started || calculate_d2xyz);
189  calculate_d2xyz = true; return d2xyzdxi2_map; }
std::vector< RealGradient > d2xyzdxi2_map
Vector of second partial derivatives in xi: d^2(x)/d(xi)^2, d^2(y)/d(xi)^2, d^2(z)/d(xi)^2.
Definition: fe_map.h:642
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_d2xyzdxideta()

const std::vector<RealGradient>& libMesh::FEMap::get_d2xyzdxideta ( ) const
Returns
The second partial derivatives in xi-eta.

Definition at line 212 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2xyzdxideta_map.

213  { libmesh_assert(!calculations_started || calculate_d2xyz);
214  calculate_d2xyz = true; return d2xyzdxideta_map; }
std::vector< RealGradient > d2xyzdxideta_map
Vector of mixed second partial derivatives in xi-eta: d^2(x)/d(xi)d(eta) d^2(y)/d(xi)d(eta) d^2(z)/d(...
Definition: fe_map.h:648
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_d2xyzdxidzeta()

const std::vector<RealGradient>& libMesh::FEMap::get_d2xyzdxidzeta ( ) const
Returns
The second partial derivatives in xi-zeta.

Definition at line 221 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2xyzdxidzeta_map.

222  { libmesh_assert(!calculations_started || calculate_d2xyz);
223  calculate_d2xyz = true; return d2xyzdxidzeta_map; }
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< RealGradient > d2xyzdxidzeta_map
Vector of second partial derivatives in xi-zeta: d^2(x)/d(xi)d(zeta), d^2(y)/d(xi)d(zeta), d^2(z)/d(xi)d(zeta)
Definition: fe_map.h:662

◆ get_d2xyzdzeta2()

const std::vector<RealGradient>& libMesh::FEMap::get_d2xyzdzeta2 ( ) const
Returns
The second partial derivatives in zeta.

Definition at line 203 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2xyzdzeta2_map.

204  { libmesh_assert(!calculations_started || calculate_d2xyz);
205  calculate_d2xyz = true; return d2xyzdzeta2_map; }
std::vector< RealGradient > d2xyzdzeta2_map
Vector of second partial derivatives in zeta: d^2(x)/d(zeta)^2.
Definition: fe_map.h:674
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_d2zetadxyz2()

const std::vector<std::vector<Real> >& libMesh::FEMap::get_d2zetadxyz2 ( ) const

Second derivatives of "zeta" reference coordinate wrt physical coordinates.

Definition at line 324 of file fe_map.h.

References calculate_d2xyz, calculations_started, and d2zetadxyz2_map.

325  { libmesh_assert(!calculations_started || calculate_d2xyz);
326  calculate_d2xyz = true; return d2zetadxyz2_map; }
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:892
std::vector< std::vector< Real > > d2zetadxyz2_map
Second derivatives of "zeta" reference coordinate wrt physical coordinates.
Definition: fe_map.h:751
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_detadx()

const std::vector<Real>& libMesh::FEMap::get_detadx ( ) const
Returns
The deta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 262 of file fe_map.h.

References calculate_dxyz, calculations_started, and detadx_map.

263  { libmesh_assert(!calculations_started || calculate_dxyz);
264  calculate_dxyz = true; return detadx_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< Real > detadx_map
Map for partial derivatives: d(eta)/d(x).
Definition: fe_map.h:701

◆ get_detady()

const std::vector<Real>& libMesh::FEMap::get_detady ( ) const
Returns
The deta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 270 of file fe_map.h.

References calculate_dxyz, calculations_started, and detady_map.

271  { libmesh_assert(!calculations_started || calculate_dxyz);
272  calculate_dxyz = true; return detady_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< Real > detady_map
Map for partial derivatives: d(eta)/d(y).
Definition: fe_map.h:707

◆ get_detadz()

const std::vector<Real>& libMesh::FEMap::get_detadz ( ) const
Returns
The deta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 278 of file fe_map.h.

References calculate_dxyz, calculations_started, and detadz_map.

279  { libmesh_assert(!calculations_started || calculate_dxyz);
280  calculate_dxyz = true; return detadz_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< Real > detadz_map
Map for partial derivatives: d(eta)/d(z).
Definition: fe_map.h:713

◆ get_dphideta_map() [1/2]

const std::vector<std::vector<Real> >& libMesh::FEMap::get_dphideta_map ( ) const
Returns
The reference to physical map derivative

Definition at line 352 of file fe_map.h.

References calculate_dxyz, calculations_started, and dphideta_map.

353  { libmesh_assert(!calculations_started || calculate_dxyz);
354  calculate_dxyz = true; return dphideta_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< std::vector< Real > > dphideta_map
Map for the derivative, d(phi)/d(eta).
Definition: fe_map.h:767

◆ get_dphideta_map() [2/2]

std::vector<std::vector<Real> >& libMesh::FEMap::get_dphideta_map ( )
Returns
The reference to physical map derivative

Definition at line 457 of file fe_map.h.

References calculate_dxyz, calculations_started, and dphideta_map.

458  { libmesh_assert(!calculations_started || calculate_dxyz);
459  calculate_dxyz = true; return dphideta_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< std::vector< Real > > dphideta_map
Map for the derivative, d(phi)/d(eta).
Definition: fe_map.h:767

◆ get_dphidxi_map() [1/2]

const std::vector<std::vector<Real> >& libMesh::FEMap::get_dphidxi_map ( ) const
Returns
The reference to physical map derivative

Definition at line 345 of file fe_map.h.

References calculate_dxyz, calculations_started, and dphidxi_map.

346  { libmesh_assert(!calculations_started || calculate_dxyz);
347  calculate_dxyz = true; return dphidxi_map; }
std::vector< std::vector< Real > > dphidxi_map
Map for the derivative, d(phi)/d(xi).
Definition: fe_map.h:762
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_dphidxi_map() [2/2]

std::vector<std::vector<Real> >& libMesh::FEMap::get_dphidxi_map ( )
Returns
The reference to physical map derivative

Definition at line 450 of file fe_map.h.

References calculate_dxyz, calculations_started, and dphidxi_map.

451  { libmesh_assert(!calculations_started || calculate_dxyz);
452  calculate_dxyz = true; return dphidxi_map; }
std::vector< std::vector< Real > > dphidxi_map
Map for the derivative, d(phi)/d(xi).
Definition: fe_map.h:762
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_dphidzeta_map() [1/2]

const std::vector<std::vector<Real> >& libMesh::FEMap::get_dphidzeta_map ( ) const
Returns
The reference to physical map derivative

Definition at line 359 of file fe_map.h.

References calculate_dxyz, calculations_started, and dphidzeta_map.

360  { libmesh_assert(!calculations_started || calculate_dxyz);
361  calculate_dxyz = true; return dphidzeta_map; }
std::vector< std::vector< Real > > dphidzeta_map
Map for the derivative, d(phi)/d(zeta).
Definition: fe_map.h:772
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_dphidzeta_map() [2/2]

std::vector<std::vector<Real> >& libMesh::FEMap::get_dphidzeta_map ( )
Returns
The reference to physical map derivative

Definition at line 464 of file fe_map.h.

References calculate_dxyz, calculations_started, and dphidzeta_map.

465  { libmesh_assert(!calculations_started || calculate_dxyz);
466  calculate_dxyz = true; return dphidzeta_map; }
std::vector< std::vector< Real > > dphidzeta_map
Map for the derivative, d(phi)/d(zeta).
Definition: fe_map.h:772
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_dpsideta()

std::vector<std::vector<Real> >& libMesh::FEMap::get_dpsideta ( )
Returns
The reference to physical map derivative for the side/edge

Definition at line 415 of file fe_map.h.

References calculate_dxyz, calculations_started, and dpsideta_map.

416  { libmesh_assert(!calculations_started || calculate_dxyz);
417  calculate_dxyz = true; return dpsideta_map; }
std::vector< std::vector< Real > > dpsideta_map
Map for the derivative of the side function, d(psi)/d(eta).
Definition: fe_map.h:823
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_dpsidxi()

std::vector<std::vector<Real> >& libMesh::FEMap::get_dpsidxi ( )
Returns
The reference to physical map derivative for the side/edge

Definition at line 408 of file fe_map.h.

References calculate_dxyz, calculations_started, and dpsidxi_map.

409  { libmesh_assert(!calculations_started || calculate_dxyz);
410  calculate_dxyz = true; return dpsidxi_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< std::vector< Real > > dpsidxi_map
Map for the derivative of the side functions, d(psi)/d(xi).
Definition: fe_map.h:817

◆ get_dxidx()

const std::vector<Real>& libMesh::FEMap::get_dxidx ( ) const
Returns
The dxi/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 238 of file fe_map.h.

References calculate_dxyz, calculations_started, and dxidx_map.

239  { libmesh_assert(!calculations_started || calculate_dxyz);
240  calculate_dxyz = true; return dxidx_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< Real > dxidx_map
Map for partial derivatives: d(xi)/d(x).
Definition: fe_map.h:682

◆ get_dxidy()

const std::vector<Real>& libMesh::FEMap::get_dxidy ( ) const
Returns
The dxi/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 246 of file fe_map.h.

References calculate_dxyz, calculations_started, and dxidy_map.

247  { libmesh_assert(!calculations_started || calculate_dxyz);
248  calculate_dxyz = true; return dxidy_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< Real > dxidy_map
Map for partial derivatives: d(xi)/d(y).
Definition: fe_map.h:688

◆ get_dxidz()

const std::vector<Real>& libMesh::FEMap::get_dxidz ( ) const
Returns
The dxi/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 254 of file fe_map.h.

References calculate_dxyz, calculations_started, and dxidz_map.

255  { libmesh_assert(!calculations_started || calculate_dxyz);
256  calculate_dxyz = true; return dxidz_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
std::vector< Real > dxidz_map
Map for partial derivatives: d(xi)/d(z).
Definition: fe_map.h:694
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_dxyzdeta()

const std::vector<RealGradient>& libMesh::FEMap::get_dxyzdeta ( ) const
Returns
The element tangents in eta-direction at the quadrature points.

Definition at line 172 of file fe_map.h.

References calculate_dxyz, calculations_started, and dxyzdeta_map.

173  { libmesh_assert(!calculations_started || calculate_dxyz);
174  calculate_dxyz = true; return dxyzdeta_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< RealGradient > dxyzdeta_map
Vector of partial derivatives: d(x)/d(eta), d(y)/d(eta), d(z)/d(eta)
Definition: fe_map.h:630

◆ get_dxyzdxi()

const std::vector<RealGradient>& libMesh::FEMap::get_dxyzdxi ( ) const
Returns
The element tangents in xi-direction at the quadrature points.

Definition at line 164 of file fe_map.h.

References calculate_dxyz, calculations_started, and dxyzdxi_map.

165  { libmesh_assert(!calculations_started || calculate_dxyz);
166  calculate_dxyz = true; return dxyzdxi_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
std::vector< RealGradient > dxyzdxi_map
Vector of partial derivatives: d(x)/d(xi), d(y)/d(xi), d(z)/d(xi)
Definition: fe_map.h:624
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_dxyzdzeta()

const std::vector<RealGradient>& libMesh::FEMap::get_dxyzdzeta ( ) const
Returns
The element tangents in zeta-direction at the quadrature points.

Definition at line 180 of file fe_map.h.

References calculate_dxyz, calculations_started, and dxyzdzeta_map.

181  { libmesh_assert(!calculations_started || calculate_dxyz);
182  calculate_dxyz = true; return dxyzdzeta_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
std::vector< RealGradient > dxyzdzeta_map
Vector of partial derivatives: d(x)/d(zeta), d(y)/d(zeta), d(z)/d(zeta)
Definition: fe_map.h:636
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_dzetadx()

const std::vector<Real>& libMesh::FEMap::get_dzetadx ( ) const
Returns
The dzeta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 286 of file fe_map.h.

References calculate_dxyz, calculations_started, and dzetadx_map.

287  { libmesh_assert(!calculations_started || calculate_dxyz);
288  calculate_dxyz = true; return dzetadx_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
std::vector< Real > dzetadx_map
Map for partial derivatives: d(zeta)/d(x).
Definition: fe_map.h:720
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_dzetady()

const std::vector<Real>& libMesh::FEMap::get_dzetady ( ) const
Returns
The dzeta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 294 of file fe_map.h.

References calculate_dxyz, calculations_started, and dzetady_map.

295  { libmesh_assert(!calculations_started || calculate_dxyz);
296  calculate_dxyz = true; return dzetady_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
std::vector< Real > dzetady_map
Map for partial derivatives: d(zeta)/d(y).
Definition: fe_map.h:726
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_dzetadz()

const std::vector<Real>& libMesh::FEMap::get_dzetadz ( ) const
Returns
The dzeta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 302 of file fe_map.h.

References calculate_dxyz, calculations_started, and dzetadz_map.

303  { libmesh_assert(!calculations_started || calculate_dxyz);
304  calculate_dxyz = true; return dzetadz_map; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
std::vector< Real > dzetadz_map
Map for partial derivatives: d(zeta)/d(z).
Definition: fe_map.h:732
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877

◆ get_jacobian()

const std::vector<Real>& libMesh::FEMap::get_jacobian ( ) const
Returns
The element Jacobian for each quadrature point.

Definition at line 148 of file fe_map.h.

References calculate_dxyz, calculations_started, and jac.

149  { libmesh_assert(!calculations_started || calculate_dxyz);
150  calculate_dxyz = true; return jac; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< Real > jac
Jacobian values at quadrature points.
Definition: fe_map.h:866

◆ get_JxW() [1/2]

const std::vector<Real>& libMesh::FEMap::get_JxW ( ) const
Returns
The element Jacobian times the quadrature weight for each quadrature point.

Definition at line 156 of file fe_map.h.

References calculate_dxyz, calculations_started, and JxW.

157  { libmesh_assert(!calculations_started || calculate_dxyz);
158  calculate_dxyz = true; return JxW; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< Real > JxW
Jacobian*Weight values at quadrature points.
Definition: fe_map.h:871

◆ get_JxW() [2/2]

std::vector<Real>& libMesh::FEMap::get_JxW ( )
Returns
Writable reference to the element Jacobian times the quadrature weight for each quadrature point.

Definition at line 518 of file fe_map.h.

References calculate_dxyz, calculations_started, and JxW.

519  { libmesh_assert(!calculations_started || calculate_dxyz);
520  calculate_dxyz = true; return JxW; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< Real > JxW
Jacobian*Weight values at quadrature points.
Definition: fe_map.h:871

◆ get_normals()

const std::vector<Point>& libMesh::FEMap::get_normals ( ) const
Returns
The outward pointing normal vectors for face integration.

Definition at line 373 of file fe_map.h.

References calculate_dxyz, calculations_started, and normals.

374  { libmesh_assert(!calculations_started || calculate_dxyz);
375  calculate_dxyz = true; return normals; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< Point > normals
Normal vectors on boundary at quadrature points.
Definition: fe_map.h:854

◆ get_phi_map() [1/2]

const std::vector<std::vector<Real> >& libMesh::FEMap::get_phi_map ( ) const
Returns
The reference to physical map for the element

Definition at line 338 of file fe_map.h.

References calculate_xyz, calculations_started, and phi_map.

339  { libmesh_assert(!calculations_started || calculate_xyz);
340  calculate_xyz = true; return phi_map; }
std::vector< std::vector< Real > > phi_map
Map for the shape function phi.
Definition: fe_map.h:757
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
bool calculate_xyz
Should we calculate physical point locations?
Definition: fe_map.h:882

◆ get_phi_map() [2/2]

std::vector<std::vector<Real> >& libMesh::FEMap::get_phi_map ( )
Returns
The reference to physical map for the element

Definition at line 443 of file fe_map.h.

References calculate_xyz, calculations_started, and phi_map.

444  { libmesh_assert(!calculations_started || calculate_xyz);
445  calculate_xyz = true; return phi_map; }
std::vector< std::vector< Real > > phi_map
Map for the shape function phi.
Definition: fe_map.h:757
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
bool calculate_xyz
Should we calculate physical point locations?
Definition: fe_map.h:882

◆ get_psi() [1/2]

const std::vector<std::vector<Real> >& libMesh::FEMap::get_psi ( ) const
Returns
The reference to physical map for the side/edge

Definition at line 332 of file fe_map.h.

References psi_map.

333  { return psi_map; }
std::vector< std::vector< Real > > psi_map
Map for the side shape functions, psi.
Definition: fe_map.h:811

◆ get_psi() [2/2]

std::vector<std::vector<Real> >& libMesh::FEMap::get_psi ( )
Returns
The reference to physical map for the side/edge

Definition at line 402 of file fe_map.h.

References psi_map.

403  { return psi_map; }
std::vector< std::vector< Real > > psi_map
Map for the side shape functions, psi.
Definition: fe_map.h:811

◆ get_tangents()

const std::vector<std::vector<Point> >& libMesh::FEMap::get_tangents ( ) const
Returns
The tangent vectors for face integration.

Definition at line 366 of file fe_map.h.

References calculate_dxyz, calculations_started, and tangents.

367  { libmesh_assert(!calculations_started || calculate_dxyz);
368  calculate_dxyz = true; return tangents; }
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:887
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
std::vector< std::vector< Point > > tangents
Tangent vectors on boundary at quadrature points.
Definition: fe_map.h:849

◆ get_xyz()

const std::vector<Point>& libMesh::FEMap::get_xyz ( ) const
Returns
The xyz spatial locations of the quadrature points on the element.

Definition at line 141 of file fe_map.h.

References calculate_xyz, calculations_started, and xyz.

142  { libmesh_assert(!calculations_started || calculate_xyz);
143  calculate_xyz = true; return xyz; }
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:877
bool calculate_xyz
Should we calculate physical point locations?
Definition: fe_map.h:882
std::vector< Point > xyz
The spatial locations of the quadrature points.
Definition: fe_map.h:618

◆ init_edge_shape_functions()

template<unsigned int Dim>
void libMesh::FEMap::init_edge_shape_functions ( const std::vector< Point > &  qp,
const Elem edge 
)

Same as before, but for an edge.

This is used for some projection operators.

◆ init_face_shape_functions()

template<unsigned int Dim>
void libMesh::FEMap::init_face_shape_functions ( const std::vector< Point > &  qp,
const Elem side 
)

Initializes the reference to physical element map for a side.

This is used for boundary integration.

◆ init_reference_to_physical_map()

template<unsigned int Dim>
void libMesh::FEMap::init_reference_to_physical_map ( const std::vector< Point > &  qp,
const Elem elem 
)

◆ print_JxW()

void libMesh::FEMap::print_JxW ( std::ostream &  os) const

Prints the Jacobian times the weight for each quadrature point.

◆ print_xyz()

void libMesh::FEMap::print_xyz ( std::ostream &  os) const

Prints the spatial location of each quadrature point (on the physical element).

◆ resize_quadrature_map_vectors()

void libMesh::FEMap::resize_quadrature_map_vectors ( const unsigned int  dim,
unsigned int  n_qp 
)
protected

A utility function for use by compute_*_map.

Friends And Related Function Documentation

◆ FE

template<unsigned int Dim, FEFamily T>
friend class FE
friend

FE classes should be able to reset calculations_started in a few special cases.

Definition at line 899 of file fe_map.h.

Member Data Documentation

◆ _elem_nodes

std::vector<const Node *> libMesh::FEMap::_elem_nodes
private

Work vector for compute_affine_map()

Definition at line 911 of file fe_map.h.

◆ calculate_d2xyz

bool libMesh::FEMap::calculate_d2xyz
mutableprotected

◆ calculate_dxyz

bool libMesh::FEMap::calculate_dxyz
mutableprotected

◆ calculate_xyz

bool libMesh::FEMap::calculate_xyz
mutableprotected

Should we calculate physical point locations?

Definition at line 882 of file fe_map.h.

Referenced by libMesh::FEXYZMap::FEXYZMap(), get_phi_map(), and get_xyz().

◆ calculations_started

bool libMesh::FEMap::calculations_started
mutableprotected

◆ curvatures

std::vector<Real> libMesh::FEMap::curvatures
protected

The mean curvature (= one half the sum of the principal curvatures) on the boundary at the quadrature points.

The mean curvature is a scalar value.

Definition at line 861 of file fe_map.h.

Referenced by get_curvatures().

◆ d2etadxyz2_map

std::vector<std::vector<Real> > libMesh::FEMap::d2etadxyz2_map
protected

Second derivatives of "eta" reference coordinate wrt physical coordinates.

At each qp: (eta_{xx}, eta_{xy}, eta_{xz}, eta_{yy}, eta_{yz}, eta_{zz})

Definition at line 745 of file fe_map.h.

Referenced by get_d2etadxyz2().

◆ d2phideta2_map

std::vector<std::vector<Real> > libMesh::FEMap::d2phideta2_map
protected

Map for the second derivative, d^2(phi)/d(eta)^2.

Definition at line 794 of file fe_map.h.

Referenced by get_d2phideta2_map().

◆ d2phidetadzeta_map

std::vector<std::vector<Real> > libMesh::FEMap::d2phidetadzeta_map
protected

Map for the second derivative, d^2(phi)/d(eta)d(zeta).

Definition at line 799 of file fe_map.h.

Referenced by get_d2phidetadzeta_map().

◆ d2phidxi2_map

std::vector<std::vector<Real> > libMesh::FEMap::d2phidxi2_map
protected

Map for the second derivative, d^2(phi)/d(xi)^2.

Definition at line 779 of file fe_map.h.

Referenced by get_d2phidxi2_map().

◆ d2phidxideta_map

std::vector<std::vector<Real> > libMesh::FEMap::d2phidxideta_map
protected

Map for the second derivative, d^2(phi)/d(xi)d(eta).

Definition at line 784 of file fe_map.h.

Referenced by get_d2phidxideta_map().

◆ d2phidxidzeta_map

std::vector<std::vector<Real> > libMesh::FEMap::d2phidxidzeta_map
protected

Map for the second derivative, d^2(phi)/d(xi)d(zeta).

Definition at line 789 of file fe_map.h.

Referenced by get_d2phidxidzeta_map().

◆ d2phidzeta2_map

std::vector<std::vector<Real> > libMesh::FEMap::d2phidzeta2_map
protected

Map for the second derivative, d^2(phi)/d(zeta)^2.

Definition at line 804 of file fe_map.h.

Referenced by get_d2phidzeta2_map().

◆ d2psideta2_map

std::vector<std::vector<Real> > libMesh::FEMap::d2psideta2_map
protected

Map for the second derivatives (in eta) of the side shape functions.

Useful for computing the curvature at the quadrature points.

Definition at line 844 of file fe_map.h.

Referenced by get_d2psideta2().

◆ d2psidxi2_map

std::vector<std::vector<Real> > libMesh::FEMap::d2psidxi2_map
protected

Map for the second derivatives (in xi) of the side shape functions.

Useful for computing the curvature at the quadrature points.

Definition at line 830 of file fe_map.h.

Referenced by get_d2psidxi2().

◆ d2psidxideta_map

std::vector<std::vector<Real> > libMesh::FEMap::d2psidxideta_map
protected

Map for the second (cross) derivatives in xi, eta of the side shape functions.

Useful for computing the curvature at the quadrature points.

Definition at line 837 of file fe_map.h.

Referenced by get_d2psidxideta().

◆ d2xidxyz2_map

std::vector<std::vector<Real> > libMesh::FEMap::d2xidxyz2_map
protected

Second derivatives of "xi" reference coordinate wrt physical coordinates.

At each qp: (xi_{xx}, xi_{xy}, xi_{xz}, xi_{yy}, xi_{yz}, xi_{zz})

Definition at line 739 of file fe_map.h.

Referenced by get_d2xidxyz2().

◆ d2xyzdeta2_map

std::vector<RealGradient> libMesh::FEMap::d2xyzdeta2_map
protected

Vector of second partial derivatives in eta: d^2(x)/d(eta)^2.

Definition at line 654 of file fe_map.h.

Referenced by get_d2xyzdeta2().

◆ d2xyzdetadzeta_map

std::vector<RealGradient> libMesh::FEMap::d2xyzdetadzeta_map
protected

Vector of mixed second partial derivatives in eta-zeta: d^2(x)/d(eta)d(zeta) d^2(y)/d(eta)d(zeta) d^2(z)/d(eta)d(zeta)

Definition at line 668 of file fe_map.h.

Referenced by get_d2xyzdetadzeta().

◆ d2xyzdxi2_map

std::vector<RealGradient> libMesh::FEMap::d2xyzdxi2_map
protected

Vector of second partial derivatives in xi: d^2(x)/d(xi)^2, d^2(y)/d(xi)^2, d^2(z)/d(xi)^2.

Definition at line 642 of file fe_map.h.

Referenced by get_d2xyzdxi2().

◆ d2xyzdxideta_map

std::vector<RealGradient> libMesh::FEMap::d2xyzdxideta_map
protected

Vector of mixed second partial derivatives in xi-eta: d^2(x)/d(xi)d(eta) d^2(y)/d(xi)d(eta) d^2(z)/d(xi)d(eta)

Definition at line 648 of file fe_map.h.

Referenced by get_d2xyzdxideta().

◆ d2xyzdxidzeta_map

std::vector<RealGradient> libMesh::FEMap::d2xyzdxidzeta_map
protected

Vector of second partial derivatives in xi-zeta: d^2(x)/d(xi)d(zeta), d^2(y)/d(xi)d(zeta), d^2(z)/d(xi)d(zeta)

Definition at line 662 of file fe_map.h.

Referenced by get_d2xyzdxidzeta().

◆ d2xyzdzeta2_map

std::vector<RealGradient> libMesh::FEMap::d2xyzdzeta2_map
protected

Vector of second partial derivatives in zeta: d^2(x)/d(zeta)^2.

Definition at line 674 of file fe_map.h.

Referenced by get_d2xyzdzeta2().

◆ d2zetadxyz2_map

std::vector<std::vector<Real> > libMesh::FEMap::d2zetadxyz2_map
protected

Second derivatives of "zeta" reference coordinate wrt physical coordinates.

At each qp: (zeta_{xx}, zeta_{xy}, zeta_{xz}, zeta_{yy}, zeta_{yz}, zeta_{zz})

Definition at line 751 of file fe_map.h.

Referenced by get_d2zetadxyz2().

◆ detadx_map

std::vector<Real> libMesh::FEMap::detadx_map
protected

Map for partial derivatives: d(eta)/d(x).

Needed for the Jacobian.

Definition at line 701 of file fe_map.h.

Referenced by get_detadx().

◆ detady_map

std::vector<Real> libMesh::FEMap::detady_map
protected

Map for partial derivatives: d(eta)/d(y).

Needed for the Jacobian.

Definition at line 707 of file fe_map.h.

Referenced by get_detady().

◆ detadz_map

std::vector<Real> libMesh::FEMap::detadz_map
protected

Map for partial derivatives: d(eta)/d(z).

Needed for the Jacobian.

Definition at line 713 of file fe_map.h.

Referenced by get_detadz().

◆ dphideta_map

std::vector<std::vector<Real> > libMesh::FEMap::dphideta_map
protected

Map for the derivative, d(phi)/d(eta).

Definition at line 767 of file fe_map.h.

Referenced by get_dphideta_map().

◆ dphidxi_map

std::vector<std::vector<Real> > libMesh::FEMap::dphidxi_map
protected

Map for the derivative, d(phi)/d(xi).

Definition at line 762 of file fe_map.h.

Referenced by get_dphidxi_map().

◆ dphidzeta_map

std::vector<std::vector<Real> > libMesh::FEMap::dphidzeta_map
protected

Map for the derivative, d(phi)/d(zeta).

Definition at line 772 of file fe_map.h.

Referenced by get_dphidzeta_map().

◆ dpsideta_map

std::vector<std::vector<Real> > libMesh::FEMap::dpsideta_map
protected

Map for the derivative of the side function, d(psi)/d(eta).

Definition at line 823 of file fe_map.h.

Referenced by get_dpsideta().

◆ dpsidxi_map

std::vector<std::vector<Real> > libMesh::FEMap::dpsidxi_map
protected

Map for the derivative of the side functions, d(psi)/d(xi).

Definition at line 817 of file fe_map.h.

Referenced by get_dpsidxi().

◆ dxidx_map

std::vector<Real> libMesh::FEMap::dxidx_map
protected

Map for partial derivatives: d(xi)/d(x).

Needed for the Jacobian.

Definition at line 682 of file fe_map.h.

Referenced by get_dxidx().

◆ dxidy_map

std::vector<Real> libMesh::FEMap::dxidy_map
protected

Map for partial derivatives: d(xi)/d(y).

Needed for the Jacobian.

Definition at line 688 of file fe_map.h.

Referenced by get_dxidy().

◆ dxidz_map

std::vector<Real> libMesh::FEMap::dxidz_map
protected

Map for partial derivatives: d(xi)/d(z).

Needed for the Jacobian.

Definition at line 694 of file fe_map.h.

Referenced by get_dxidz().

◆ dxyzdeta_map

std::vector<RealGradient> libMesh::FEMap::dxyzdeta_map
protected

Vector of partial derivatives: d(x)/d(eta), d(y)/d(eta), d(z)/d(eta)

Definition at line 630 of file fe_map.h.

Referenced by dxdeta_map(), dydeta_map(), dzdeta_map(), and get_dxyzdeta().

◆ dxyzdxi_map

std::vector<RealGradient> libMesh::FEMap::dxyzdxi_map
protected

Vector of partial derivatives: d(x)/d(xi), d(y)/d(xi), d(z)/d(xi)

Definition at line 624 of file fe_map.h.

Referenced by dxdxi_map(), dydxi_map(), dzdxi_map(), and get_dxyzdxi().

◆ dxyzdzeta_map

std::vector<RealGradient> libMesh::FEMap::dxyzdzeta_map
protected

Vector of partial derivatives: d(x)/d(zeta), d(y)/d(zeta), d(z)/d(zeta)

Definition at line 636 of file fe_map.h.

Referenced by dxdzeta_map(), dydzeta_map(), dzdzeta_map(), and get_dxyzdzeta().

◆ dzetadx_map

std::vector<Real> libMesh::FEMap::dzetadx_map
protected

Map for partial derivatives: d(zeta)/d(x).

Needed for the Jacobian.

Definition at line 720 of file fe_map.h.

Referenced by get_dzetadx().

◆ dzetady_map

std::vector<Real> libMesh::FEMap::dzetady_map
protected

Map for partial derivatives: d(zeta)/d(y).

Needed for the Jacobian.

Definition at line 726 of file fe_map.h.

Referenced by get_dzetady().

◆ dzetadz_map

std::vector<Real> libMesh::FEMap::dzetadz_map
protected

Map for partial derivatives: d(zeta)/d(z).

Needed for the Jacobian.

Definition at line 732 of file fe_map.h.

Referenced by get_dzetadz().

◆ jac

std::vector<Real> libMesh::FEMap::jac
protected

Jacobian values at quadrature points.

Definition at line 866 of file fe_map.h.

Referenced by get_jacobian().

◆ JxW

std::vector<Real> libMesh::FEMap::JxW
protected

Jacobian*Weight values at quadrature points.

Definition at line 871 of file fe_map.h.

Referenced by get_JxW().

◆ normals

std::vector<Point> libMesh::FEMap::normals
protected

Normal vectors on boundary at quadrature points.

Definition at line 854 of file fe_map.h.

Referenced by get_normals().

◆ phi_map

std::vector<std::vector<Real> > libMesh::FEMap::phi_map
protected

Map for the shape function phi.

Definition at line 757 of file fe_map.h.

Referenced by get_phi_map().

◆ psi_map

std::vector<std::vector<Real> > libMesh::FEMap::psi_map
protected

Map for the side shape functions, psi.

Definition at line 811 of file fe_map.h.

Referenced by get_psi().

◆ tangents

std::vector<std::vector<Point> > libMesh::FEMap::tangents
protected

Tangent vectors on boundary at quadrature points.

Definition at line 849 of file fe_map.h.

Referenced by get_tangents().

◆ xyz

std::vector<Point> libMesh::FEMap::xyz
protected

The spatial locations of the quadrature points.

Definition at line 618 of file fe_map.h.

Referenced by get_xyz().


The documentation for this class was generated from the following file: