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

An implementation of FEMap for "XYZ" elements. More...

#include <fe_xyz_map.h>

Inheritance diagram for libMesh::FEXYZMap:
[legend]

Public Member Functions

 FEXYZMap ()
 
virtual ~FEXYZMap ()
 
virtual void compute_face_map (int dim, const std::vector< Real > &qw, const Elem *side) override
 Special implementation for XYZ finite elements. More...
 
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...
 
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
 
std::vector< Real > & get_JxW ()
 
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
 
std::vector< std::vector< Real > > & get_psi ()
 
const std::vector< std::vector< Real > > & get_phi_map () const
 
std::vector< std::vector< Real > > & get_phi_map ()
 
const std::vector< std::vector< Real > > & get_dphidxi_map () const
 
std::vector< std::vector< Real > > & get_dphidxi_map ()
 
const std::vector< std::vector< Real > > & get_dphideta_map () const
 
std::vector< std::vector< Real > > & get_dphideta_map ()
 
const std::vector< std::vector< Real > > & get_dphidzeta_map () const
 
std::vector< std::vector< Real > > & get_dphidzeta_map ()
 
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_dpsidxi ()
 
const std::vector< std::vector< Real > > & get_dpsidxi () const
 
std::vector< std::vector< Real > > & get_dpsideta ()
 
const std::vector< std::vector< Real > > & get_dpsideta () const
 
std::vector< std::vector< Real > > & get_d2psidxi2 ()
 
const std::vector< std::vector< Real > > & get_d2psidxi2 () const
 
std::vector< std::vector< Real > > & get_d2psidxideta ()
 
const std::vector< std::vector< Real > > & get_d2psidxideta () const
 
std::vector< std::vector< Real > > & get_d2psideta2 ()
 
const std::vector< std::vector< Real > > & get_d2psideta2 () const
 
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 ()
 
void set_jacobian_tolerance (Real tol)
 Set the Jacobian tolerance used for determining when the mapping fails. More...
 

Static Public Member Functions

static std::unique_ptr< FEMap > build (FEType fe_type)
 
static FEFamily map_fe_type (const Elem &elem)
 
static Point map (const unsigned int dim, const Elem *elem, const Point &reference_point)
 
static Point map_deriv (const unsigned int dim, const Elem *elem, const unsigned int j, const Point &reference_point)
 
static Point inverse_map (const unsigned int dim, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
 
static void inverse_map (unsigned int dim, const Elem *elem, const std::vector< Point > &physical_points, std::vector< Point > &reference_points, const Real tolerance=TOLERANCE, const bool secure=true)
 Takes a number points in physical space (in the physical_points vector) and finds their location on the reference element for the input element elem. More...
 

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< Point > xyz
 The spatial locations of the quadrature points. More...
 
std::vector< RealGradient > dxyzdxi_map
 Vector of partial derivatives: d(x)/d(xi), d(y)/d(xi), d(z)/d(xi) More...
 
std::vector< RealGradient > dxyzdeta_map
 Vector of partial derivatives: d(x)/d(eta), d(y)/d(eta), d(z)/d(eta) More...
 
std::vector< RealGradient > dxyzdzeta_map
 Vector of partial derivatives: d(x)/d(zeta), d(y)/d(zeta), d(z)/d(zeta) More...
 
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. More...
 
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(xi)d(eta) More...
 
std::vector< RealGradient > d2xyzdeta2_map
 Vector of second partial derivatives in eta: d^2(x)/d(eta)^2. More...
 
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) More...
 
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(z)/d(eta)d(zeta) More...
 
std::vector< RealGradient > d2xyzdzeta2_map
 Vector of second partial derivatives in zeta: d^2(x)/d(zeta)^2. More...
 
std::vector< Real > dxidx_map
 Map for partial derivatives: d(xi)/d(x). More...
 
std::vector< Real > dxidy_map
 Map for partial derivatives: d(xi)/d(y). More...
 
std::vector< Real > dxidz_map
 Map for partial derivatives: d(xi)/d(z). More...
 
std::vector< Real > detadx_map
 Map for partial derivatives: d(eta)/d(x). More...
 
std::vector< Real > detady_map
 Map for partial derivatives: d(eta)/d(y). More...
 
std::vector< Real > detadz_map
 Map for partial derivatives: d(eta)/d(z). More...
 
std::vector< Real > dzetadx_map
 Map for partial derivatives: d(zeta)/d(x). More...
 
std::vector< Real > dzetady_map
 Map for partial derivatives: d(zeta)/d(y). More...
 
std::vector< Real > dzetadz_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< Point > normals
 Normal vectors on boundary at quadrature points. More...
 
std::vector< Real > curvatures
 The mean curvature (= one half the sum of the principal curvatures) on the boundary at the quadrature points. More...
 
std::vector< Real > jac
 Jacobian values at quadrature points. More...
 
std::vector< Real > JxW
 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...
 
Real jacobian_tolerance
 The Jacobian tolerance used for determining when the mapping fails. 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...
 

Detailed Description

An implementation of FEMap for "XYZ" elements.

Author
Paul Bauman
Date
2012

An implementation of FEMap for "XYZ" elements.

Definition at line 39 of file fe_xyz_map.h.

Constructor & Destructor Documentation

◆ FEXYZMap()

libMesh::FEXYZMap::FEXYZMap ( )
inline

Definition at line 43 of file fe_xyz_map.h.

44  : FEMap()
45  {
46  // All FEXYZ objects are going to be querying xyz coordinates
47  calculate_xyz = true;
48  }

References libMesh::FEMap::calculate_xyz.

◆ ~FEXYZMap()

virtual libMesh::FEXYZMap::~FEXYZMap ( )
inlinevirtual

Definition at line 50 of file fe_xyz_map.h.

50 {}

Member Function Documentation

◆ build()

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

Definition at line 76 of file fe_map.C.

77 {
78  switch( fe_type.family )
79  {
80  case XYZ:
81  return libmesh_make_unique<FEXYZMap>();
82 
83  default:
84  return libmesh_make_unique<FEMap>();
85  }
86 }

References libMesh::FEType::family, and libMesh::XYZ.

◆ compute_affine_map()

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

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

Definition at line 1277 of file fe_map.C.

1280 {
1281  // Start logging the map computation.
1282  LOG_SCOPE("compute_affine_map()", "FEMap");
1283 
1284  libmesh_assert(elem);
1285 
1286  const unsigned int n_qp = cast_int<unsigned int>(qw.size());
1287 
1288  // Resize the vectors to hold data at the quadrature points
1289  this->resize_quadrature_map_vectors(dim, n_qp);
1290 
1291  // Determine the nodes contributing to element elem
1292  unsigned int n_nodes = elem->n_nodes();
1293  _elem_nodes.resize(elem->n_nodes());
1294  for (unsigned int i=0; i<n_nodes; i++)
1295  _elem_nodes[i] = elem->node_ptr(i);
1296 
1297  // Compute map at quadrature point 0
1298  this->compute_single_point_map(dim, qw, elem, 0, _elem_nodes, /*compute_second_derivatives=*/false);
1299 
1300  // Compute xyz at all other quadrature points
1301  if (calculate_xyz)
1302  for (unsigned int p=1; p<n_qp; p++)
1303  {
1304  xyz[p].zero();
1305  for (auto i : index_range(phi_map)) // sum over the nodes
1306  xyz[p].add_scaled (*_elem_nodes[i], phi_map[i][p]);
1307  }
1308 
1309  // Copy other map data from quadrature point 0
1310  if (calculate_dxyz)
1311  for (unsigned int p=1; p<n_qp; p++) // for each extra quadrature point
1312  {
1313  dxyzdxi_map[p] = dxyzdxi_map[0];
1314  dxidx_map[p] = dxidx_map[0];
1315  dxidy_map[p] = dxidy_map[0];
1316  dxidz_map[p] = dxidz_map[0];
1317 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1318  // The map should be affine, so second derivatives are zero
1319  if (calculate_d2xyz)
1320  d2xyzdxi2_map[p] = 0.;
1321 #endif
1322  if (dim > 1)
1323  {
1324  dxyzdeta_map[p] = dxyzdeta_map[0];
1325  detadx_map[p] = detadx_map[0];
1326  detady_map[p] = detady_map[0];
1327  detadz_map[p] = detadz_map[0];
1328 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1329  if (calculate_d2xyz)
1330  {
1331  d2xyzdxideta_map[p] = 0.;
1332  d2xyzdeta2_map[p] = 0.;
1333  }
1334 #endif
1335  if (dim > 2)
1336  {
1337  dxyzdzeta_map[p] = dxyzdzeta_map[0];
1338  dzetadx_map[p] = dzetadx_map[0];
1339  dzetady_map[p] = dzetady_map[0];
1340  dzetadz_map[p] = dzetadz_map[0];
1341 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1342  if (calculate_d2xyz)
1343  {
1344  d2xyzdxidzeta_map[p] = 0.;
1345  d2xyzdetadzeta_map[p] = 0.;
1346  d2xyzdzeta2_map[p] = 0.;
1347  }
1348 #endif
1349  }
1350  }
1351  jac[p] = jac[0];
1352  JxW[p] = JxW[0] / qw[0] * qw[p];
1353  }
1354 }

References libMesh::FEMap::_elem_nodes, libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculate_xyz, libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::d2xyzdeta2_map, libMesh::FEMap::d2xyzdetadzeta_map, libMesh::FEMap::d2xyzdxi2_map, libMesh::FEMap::d2xyzdxideta_map, libMesh::FEMap::d2xyzdxidzeta_map, libMesh::FEMap::d2xyzdzeta2_map, libMesh::FEMap::detadx_map, libMesh::FEMap::detady_map, libMesh::FEMap::detadz_map, dim, libMesh::FEMap::dxidx_map, libMesh::FEMap::dxidy_map, libMesh::FEMap::dxidz_map, libMesh::FEMap::dxyzdeta_map, libMesh::FEMap::dxyzdxi_map, libMesh::FEMap::dxyzdzeta_map, libMesh::FEMap::dzetadx_map, libMesh::FEMap::dzetady_map, libMesh::FEMap::dzetadz_map, libMesh::index_range(), libMesh::FEMap::jac, libMesh::FEMap::JxW, libMesh::libmesh_assert(), n_nodes, libMesh::Elem::n_nodes(), libMesh::Elem::node_ptr(), libMesh::FEMap::phi_map, libMesh::FEMap::resize_quadrature_map_vectors(), and libMesh::FEMap::xyz.

Referenced by libMesh::FEMap::compute_map().

◆ compute_edge_map()

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

Same as before, but for an edge.

Useful for some projections.

Definition at line 950 of file fe_boundary.C.

953 {
954  libmesh_assert(edge);
955 
956  if (dim == 2)
957  {
958  // A 2D finite element living in either 2D or 3D space.
959  // The edges here are the sides of the element, so the
960  // (misnamed) compute_face_map function does what we want
961  this->compute_face_map(dim, qw, edge);
962  return;
963  }
964 
965  libmesh_assert_equal_to (dim, 3); // 1D is unnecessary and currently unsupported
966 
967  LOG_SCOPE("compute_edge_map()", "FEMap");
968 
969  // We're calculating now!
970  this->determine_calculations();
971 
972  // The number of quadrature points.
973  const unsigned int n_qp = cast_int<unsigned int>(qw.size());
974 
975  // Resize the vectors to hold data at the quadrature points
976  if (calculate_xyz)
977  this->xyz.resize(n_qp);
978  if (calculate_dxyz)
979  {
980  this->dxyzdxi_map.resize(n_qp);
981  this->dxyzdeta_map.resize(n_qp);
982  this->tangents.resize(n_qp);
983  this->normals.resize(n_qp);
984  this->JxW.resize(n_qp);
985  }
986 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
987  if (calculate_d2xyz)
988  {
989  this->d2xyzdxi2_map.resize(n_qp);
990  this->d2xyzdxideta_map.resize(n_qp);
991  this->d2xyzdeta2_map.resize(n_qp);
992  this->curvatures.resize(n_qp);
993  }
994 #endif
995 
996  // Clear the entities that will be summed
997  for (unsigned int p=0; p<n_qp; p++)
998  {
999  if (calculate_xyz)
1000  this->xyz[p].zero();
1001  if (calculate_dxyz)
1002  {
1003  this->tangents[p].resize(1);
1004  this->dxyzdxi_map[p].zero();
1005  this->dxyzdeta_map[p].zero();
1006  }
1007 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1008  if (calculate_d2xyz)
1009  {
1010  this->d2xyzdxi2_map[p].zero();
1011  this->d2xyzdxideta_map[p].zero();
1012  this->d2xyzdeta2_map[p].zero();
1013  }
1014 #endif
1015  }
1016 
1017  // compute x, dxdxi at the quadrature points
1018  for (unsigned int i=0,
1019  psi_map_size=cast_int<unsigned int>(psi_map.size());
1020  i != psi_map_size; i++) // sum over the nodes
1021  {
1022  const Point & edge_point = edge->point(i);
1023 
1024  for (unsigned int p=0; p<n_qp; p++) // for each quadrature point...
1025  {
1026  if (calculate_xyz)
1027  this->xyz[p].add_scaled (edge_point, this->psi_map[i][p]);
1028  if (calculate_dxyz)
1029  this->dxyzdxi_map[p].add_scaled (edge_point, this->dpsidxi_map[i][p]);
1030 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1031  if (calculate_d2xyz)
1032  this->d2xyzdxi2_map[p].add_scaled (edge_point, this->d2psidxi2_map[i][p]);
1033 #endif
1034  }
1035  }
1036 
1037  // Compute the tangents at the quadrature point
1038  // FIXME: normals (plural!) and curvatures are uncalculated
1039  if (calculate_dxyz)
1040  for (unsigned int p=0; p<n_qp; p++)
1041  {
1042  const Point n = this->dxyzdxi_map[p].cross(this->dxyzdeta_map[p]);
1043  this->tangents[p][0] = this->dxyzdxi_map[p].unit();
1044 
1045  // compute the jacobian at the quadrature points
1046  const Real the_jac = std::sqrt(this->dxdxi_map(p)*this->dxdxi_map(p) +
1047  this->dydxi_map(p)*this->dydxi_map(p) +
1048  this->dzdxi_map(p)*this->dzdxi_map(p));
1049 
1050  libmesh_assert_greater (the_jac, 0.);
1051 
1052  this->JxW[p] = the_jac*qw[p];
1053  }
1054 }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculate_xyz, libMesh::FEMap::compute_face_map(), libMesh::FEMap::curvatures, libMesh::FEMap::d2psidxi2_map, libMesh::FEMap::d2xyzdeta2_map, libMesh::FEMap::d2xyzdxi2_map, libMesh::FEMap::d2xyzdxideta_map, libMesh::FEMap::determine_calculations(), dim, libMesh::FEMap::dpsidxi_map, libMesh::FEMap::dxdxi_map(), libMesh::FEMap::dxyzdeta_map, libMesh::FEMap::dxyzdxi_map, libMesh::FEMap::dydxi_map(), libMesh::FEMap::dzdxi_map(), libMesh::FEMap::JxW, libMesh::libmesh_assert(), libMesh::FEMap::normals, libMesh::Elem::point(), libMesh::FEMap::psi_map, libMesh::Real, std::sqrt(), libMesh::FEMap::tangents, and libMesh::FEMap::xyz.

◆ compute_face_map()

void libMesh::FEXYZMap::compute_face_map ( int  dim,
const std::vector< Real > &  qw,
const Elem *  side 
)
overridevirtual

Special implementation for XYZ finite elements.

Reimplemented from libMesh::FEMap.

Definition at line 25 of file fe_xyz_map.C.

26 {
27  libmesh_assert(side);
28 
29  LOG_SCOPE("compute_face_map()", "FEXYZMap");
30 
31  // The number of quadrature points.
32  const unsigned int n_qp = cast_int<unsigned int>(qw.size());
33 
34  switch(dim)
35  {
36  case 2:
37  {
38 
39  // Resize the vectors to hold data at the quadrature points
40  {
41  this->xyz.resize(n_qp);
42  this->dxyzdxi_map.resize(n_qp);
43 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
44  this->d2xyzdxi2_map.resize(n_qp);
45  this->curvatures.resize(n_qp);
46 #endif
47  this->tangents.resize(n_qp);
48  this->normals.resize(n_qp);
49 
50  this->JxW.resize(n_qp);
51  }
52 
53  // Clear the entities that will be summed
54  // Compute the tangent & normal at the quadrature point
55  for (unsigned int p=0; p<n_qp; p++)
56  {
57  this->tangents[p].resize(LIBMESH_DIM-1); // 1 Tangent in 2D, 2 in 3D
58  this->xyz[p].zero();
59  this->dxyzdxi_map[p].zero();
60 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
61  this->d2xyzdxi2_map[p].zero();
62 #endif
63  }
64 
65  // compute x, dxdxi at the quadrature points
66  for (unsigned int i=0,
67  n_psi_map = cast_int<unsigned int>(this->psi_map.size());
68  i != n_psi_map; i++) // sum over the nodes
69  {
70  const Point & side_point = side->point(i);
71 
72  for (unsigned int p=0; p<n_qp; p++) // for each quadrature point...
73  {
74  this->xyz[p].add_scaled (side_point, this->psi_map[i][p]);
75  this->dxyzdxi_map[p].add_scaled (side_point, this->dpsidxi_map[i][p]);
76 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
77  this->d2xyzdxi2_map[p].add_scaled(side_point, this->d2psidxi2_map[i][p]);
78 #endif
79  }
80  }
81 
82  // Compute the tangent & normal at the quadrature point
83  for (unsigned int p=0; p<n_qp; p++)
84  {
85  const Point n(this->dxyzdxi_map[p](1), -this->dxyzdxi_map[p](0), 0.);
86 
87  this->normals[p] = n.unit();
88  this->tangents[p][0] = this->dxyzdxi_map[p].unit();
89 #if LIBMESH_DIM == 3 // Only good in 3D space
90  this->tangents[p][1] = this->dxyzdxi_map[p].cross(n).unit();
91 
92 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
93  // The curvature is computed via the familiar Frenet formula:
94  // curvature = [d^2(x) / d (xi)^2] dot [normal]
95  // For a reference, see:
96  // F.S. Merritt, Mathematics Manual, 1962, McGraw-Hill, p. 310
97  //
98  // Note: The sign convention here is different from the
99  // 3D case. Concave-upward curves (smiles) have a positive
100  // curvature. Concave-downward curves (frowns) have a
101  // negative curvature. Be sure to take that into account!
102  const Real numerator = this->d2xyzdxi2_map[p] * this->normals[p];
103  const Real denominator = this->dxyzdxi_map[p].norm_sq();
104  libmesh_assert_not_equal_to (denominator, 0);
105  this->curvatures[p] = numerator / denominator;
106 #endif
107 #endif
108  }
109 
110  // compute the jacobian at the quadrature points
111  for (unsigned int p=0; p<n_qp; p++)
112  {
113  const Real the_jac = std::sqrt(this->dxdxi_map(p)*this->dxdxi_map(p) +
114  this->dydxi_map(p)*this->dydxi_map(p));
115 
116  libmesh_assert_greater (the_jac, 0.);
117 
118  this->JxW[p] = the_jac*qw[p];
119  }
120 
121  break;
122  }
123 
124  case 3:
125  {
126  // Resize the vectors to hold data at the quadrature points
127  {
128  this->xyz.resize(n_qp);
129  this->dxyzdxi_map.resize(n_qp);
130  this->dxyzdeta_map.resize(n_qp);
131 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
132  this->d2xyzdxi2_map.resize(n_qp);
133  this->d2xyzdxideta_map.resize(n_qp);
134  this->d2xyzdeta2_map.resize(n_qp);
135  this->curvatures.resize(n_qp);
136 #endif
137  this->tangents.resize(n_qp);
138  this->normals.resize(n_qp);
139 
140  this->JxW.resize(n_qp);
141  }
142 
143  // Clear the entities that will be summed
144  for (unsigned int p=0; p<n_qp; p++)
145  {
146  this->tangents[p].resize(LIBMESH_DIM-1); // 1 Tangent in 2D, 2 in 3D
147  this->xyz[p].zero();
148  this->dxyzdxi_map[p].zero();
149  this->dxyzdeta_map[p].zero();
150 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
151  this->d2xyzdxi2_map[p].zero();
152  this->d2xyzdxideta_map[p].zero();
153  this->d2xyzdeta2_map[p].zero();
154 #endif
155  }
156 
157  // compute x, dxdxi at the quadrature points
158  for (unsigned int i=0,
159  n_psi_map = cast_int<unsigned int>(this->psi_map.size());
160  i != n_psi_map; i++) // sum over the nodes
161  {
162  const Point & side_point = side->point(i);
163 
164  for (unsigned int p=0; p<n_qp; p++) // for each quadrature point...
165  {
166  this->xyz[p].add_scaled (side_point, this->psi_map[i][p]);
167  this->dxyzdxi_map[p].add_scaled (side_point, this->dpsidxi_map[i][p]);
168  this->dxyzdeta_map[p].add_scaled (side_point, this->dpsideta_map[i][p]);
169 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
170  this->d2xyzdxi2_map[p].add_scaled (side_point, this->d2psidxi2_map[i][p]);
171  this->d2xyzdxideta_map[p].add_scaled(side_point, this->d2psidxideta_map[i][p]);
172  this->d2xyzdeta2_map[p].add_scaled (side_point, this->d2psideta2_map[i][p]);
173 #endif
174  }
175  }
176 
177  // Compute the tangents, normal, and curvature at the quadrature point
178  for (unsigned int p=0; p<n_qp; p++)
179  {
180  const Point n = this->dxyzdxi_map[p].cross(this->dxyzdeta_map[p]);
181  this->normals[p] = n.unit();
182  this->tangents[p][0] = this->dxyzdxi_map[p].unit();
183  this->tangents[p][1] = n.cross(this->dxyzdxi_map[p]).unit();
184 
185 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
186  // Compute curvature using the typical nomenclature
187  // of the first and second fundamental forms.
188  // For reference, see:
189  // 1) http://mathworld.wolfram.com/MeanCurvature.html
190  // (note -- they are using inward normal)
191  // 2) F.S. Merritt, Mathematics Manual, 1962, McGraw-Hill
192  const Real L = -this->d2xyzdxi2_map[p] * this->normals[p];
193  const Real M = -this->d2xyzdxideta_map[p] * this->normals[p];
194  const Real N = -this->d2xyzdeta2_map[p] * this->normals[p];
195  const Real E = this->dxyzdxi_map[p].norm_sq();
196  const Real F = this->dxyzdxi_map[p] * this->dxyzdeta_map[p];
197  const Real G = this->dxyzdeta_map[p].norm_sq();
198 
199  const Real numerator = E*N -2.*F*M + G*L;
200  const Real denominator = E*G - F*F;
201  libmesh_assert_not_equal_to (denominator, 0.);
202  this->curvatures[p] = 0.5*numerator/denominator;
203 #endif
204  }
205 
206  // compute the jacobian at the quadrature points, see
207  // http://sp81.msi.umn.edu:999/fluent/fidap/help/theory/thtoc.htm
208  for (unsigned int p=0; p<n_qp; p++)
209  {
210  const Real g11 = (this->dxdxi_map(p)*this->dxdxi_map(p) +
211  this->dydxi_map(p)*this->dydxi_map(p) +
212  this->dzdxi_map(p)*this->dzdxi_map(p));
213 
214  const Real g12 = (this->dxdxi_map(p)*this->dxdeta_map(p) +
215  this->dydxi_map(p)*this->dydeta_map(p) +
216  this->dzdxi_map(p)*this->dzdeta_map(p));
217 
218  const Real g21 = g12;
219 
220  const Real g22 = (this->dxdeta_map(p)*this->dxdeta_map(p) +
221  this->dydeta_map(p)*this->dydeta_map(p) +
222  this->dzdeta_map(p)*this->dzdeta_map(p));
223 
224 
225  const Real the_jac = std::sqrt(g11*g22 - g12*g21);
226 
227  libmesh_assert_greater (the_jac, 0.);
228 
229  this->JxW[p] = the_jac*qw[p];
230  }
231 
232  break;
233  }
234  default:
235  libmesh_error_msg("Invalid dim = " << dim);
236 
237  } // switch(dim)
238 }

References libMesh::TypeVector< T >::cross(), libMesh::FEMap::curvatures, libMesh::FEMap::d2psideta2_map, libMesh::FEMap::d2psidxi2_map, libMesh::FEMap::d2psidxideta_map, libMesh::FEMap::d2xyzdeta2_map, libMesh::FEMap::d2xyzdxi2_map, libMesh::FEMap::d2xyzdxideta_map, dim, libMesh::FEMap::dpsideta_map, libMesh::FEMap::dpsidxi_map, libMesh::FEMap::dxdeta_map(), libMesh::FEMap::dxdxi_map(), libMesh::FEMap::dxyzdeta_map, libMesh::FEMap::dxyzdxi_map, libMesh::FEMap::dydeta_map(), libMesh::FEMap::dydxi_map(), libMesh::FEMap::dzdeta_map(), libMesh::FEMap::dzdxi_map(), libMesh::FEMap::JxW, libMesh::libmesh_assert(), libMesh::FEMap::normals, libMesh::Elem::point(), libMesh::FEMap::psi_map, libMesh::Real, std::sqrt(), libMesh::FEMap::tangents, libMesh::TypeVector< T >::unit(), and libMesh::FEMap::xyz.

◆ compute_inverse_map_second_derivs()

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

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

Definition at line 1502 of file fe_map.C.

1503 {
1504 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1505  // Only certain second derivatives are valid depending on the
1506  // dimension...
1507  std::set<unsigned> valid_indices;
1508 
1509  // Construct J^{-1}, A, and B matrices (see JWP's notes for details)
1510  // for cases in which the element dimension matches LIBMESH_DIM.
1511 #if LIBMESH_DIM==1
1512  RealTensor
1513  Jinv(dxidx_map[p], 0., 0.,
1514  0., 0., 0.,
1515  0., 0., 0.),
1516 
1517  A(d2xyzdxi2_map[p](0), 0., 0.,
1518  0., 0., 0.,
1519  0., 0., 0.),
1520 
1521  B(0., 0., 0.,
1522  0., 0., 0.,
1523  0., 0., 0.);
1524 
1525  RealVectorValue
1526  dxi (dxidx_map[p], 0., 0.),
1527  deta (0., 0., 0.),
1528  dzeta(0., 0., 0.);
1529 
1530  // In 1D, we have only the xx second derivative
1531  valid_indices.insert(0);
1532 
1533 #elif LIBMESH_DIM==2
1534  RealTensor
1535  Jinv(dxidx_map[p], dxidy_map[p], 0.,
1536  detadx_map[p], detady_map[p], 0.,
1537  0., 0., 0.),
1538 
1539  A(d2xyzdxi2_map[p](0), d2xyzdeta2_map[p](0), 0.,
1540  d2xyzdxi2_map[p](1), d2xyzdeta2_map[p](1), 0.,
1541  0., 0., 0.),
1542 
1543  B(d2xyzdxideta_map[p](0), 0., 0.,
1544  d2xyzdxideta_map[p](1), 0., 0.,
1545  0., 0., 0.);
1546 
1547  RealVectorValue
1548  dxi (dxidx_map[p], dxidy_map[p], 0.),
1549  deta (detadx_map[p], detady_map[p], 0.),
1550  dzeta(0., 0., 0.);
1551 
1552  // In 2D, we have xx, xy, and yy second derivatives
1553  const unsigned tmp[3] = {0,1,3};
1554  valid_indices.insert(tmp, tmp+3);
1555 
1556 #elif LIBMESH_DIM==3
1557  RealTensor
1558  Jinv(dxidx_map[p], dxidy_map[p], dxidz_map[p],
1559  detadx_map[p], detady_map[p], detadz_map[p],
1560  dzetadx_map[p], dzetady_map[p], dzetadz_map[p]),
1561 
1562  A(d2xyzdxi2_map[p](0), d2xyzdeta2_map[p](0), d2xyzdzeta2_map[p](0),
1563  d2xyzdxi2_map[p](1), d2xyzdeta2_map[p](1), d2xyzdzeta2_map[p](1),
1564  d2xyzdxi2_map[p](2), d2xyzdeta2_map[p](2), d2xyzdzeta2_map[p](2)),
1565 
1566  B(d2xyzdxideta_map[p](0), d2xyzdxidzeta_map[p](0), d2xyzdetadzeta_map[p](0),
1567  d2xyzdxideta_map[p](1), d2xyzdxidzeta_map[p](1), d2xyzdetadzeta_map[p](1),
1568  d2xyzdxideta_map[p](2), d2xyzdxidzeta_map[p](2), d2xyzdetadzeta_map[p](2));
1569 
1570  RealVectorValue
1571  dxi (dxidx_map[p], dxidy_map[p], dxidz_map[p]),
1572  deta (detadx_map[p], detady_map[p], detadz_map[p]),
1573  dzeta(dzetadx_map[p], dzetady_map[p], dzetadz_map[p]);
1574 
1575  // In 3D, we have xx, xy, xz, yy, yz, and zz second derivatives
1576  const unsigned tmp[6] = {0,1,2,3,4,5};
1577  valid_indices.insert(tmp, tmp+6);
1578 
1579 #endif
1580 
1581  // For (s,t) in {(x,x), (x,y), (x,z), (y,y), (y,z), (z,z)}, compute the
1582  // vector of inverse map second derivatives [xi_{s t}, eta_{s t}, zeta_{s t}]
1583  unsigned ctr=0;
1584  for (unsigned s=0; s<3; ++s)
1585  for (unsigned t=s; t<3; ++t)
1586  {
1587  if (valid_indices.count(ctr))
1588  {
1589  RealVectorValue
1590  v1(dxi(s)*dxi(t),
1591  deta(s)*deta(t),
1592  dzeta(s)*dzeta(t)),
1593 
1594  v2(dxi(s)*deta(t) + deta(s)*dxi(t),
1595  dxi(s)*dzeta(t) + dzeta(s)*dxi(t),
1596  deta(s)*dzeta(t) + dzeta(s)*deta(t));
1597 
1598  // Compute the inverse map second derivatives
1599  RealVectorValue v3 = -Jinv*(A*v1 + B*v2);
1600 
1601  // Store them in the appropriate locations in the class data structures
1602  d2xidxyz2_map[p][ctr] = v3(0);
1603 
1604  if (LIBMESH_DIM > 1)
1605  d2etadxyz2_map[p][ctr] = v3(1);
1606 
1607  if (LIBMESH_DIM > 2)
1608  d2zetadxyz2_map[p][ctr] = v3(2);
1609  }
1610 
1611  // Increment the counter
1612  ctr++;
1613  }
1614 #else
1615  // to avoid compiler warnings:
1616  libmesh_ignore(p);
1617 #endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
1618 }

References A, libMesh::FEMap::d2etadxyz2_map, libMesh::FEMap::d2xidxyz2_map, libMesh::FEMap::d2xyzdeta2_map, libMesh::FEMap::d2xyzdetadzeta_map, libMesh::FEMap::d2xyzdxi2_map, libMesh::FEMap::d2xyzdxideta_map, libMesh::FEMap::d2xyzdxidzeta_map, libMesh::FEMap::d2xyzdzeta2_map, libMesh::FEMap::d2zetadxyz2_map, libMesh::FEMap::detadx_map, libMesh::FEMap::detady_map, libMesh::FEMap::detadz_map, libMesh::FEMap::dxidx_map, libMesh::FEMap::dxidy_map, libMesh::FEMap::dxidz_map, libMesh::FEMap::dzetadx_map, libMesh::FEMap::dzetady_map, libMesh::FEMap::dzetadz_map, and libMesh::libmesh_ignore().

Referenced by libMesh::FEMap::compute_single_point_map().

◆ compute_map()

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

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.

Definition at line 1433 of file fe_map.C.

1437 {
1438  if (!elem)
1439  {
1440  compute_null_map(dim, qw);
1441  return;
1442  }
1443 
1444  if (elem->has_affine_map())
1445  {
1446  compute_affine_map(dim, qw, elem);
1447  return;
1448  }
1449 #ifndef LIBMESH_ENABLE_SECOND_DERIVATIVES
1450  libmesh_assert(!calculate_d2phi);
1451 #endif
1452 
1453  // Start logging the map computation.
1454  LOG_SCOPE("compute_map()", "FEMap");
1455 
1456  libmesh_assert(elem);
1457 
1458  const unsigned int n_qp = cast_int<unsigned int>(qw.size());
1459 
1460  // Resize the vectors to hold data at the quadrature points
1461  this->resize_quadrature_map_vectors(dim, n_qp);
1462 
1463  // Determine the nodes contributing to element elem
1464  if (elem->type() == TRI3SUBDIVISION)
1465  {
1466  // Subdivision surface FE require the 1-ring around elem
1467  libmesh_assert_equal_to (dim, 2);
1468  const Tri3Subdivision * sd_elem = static_cast<const Tri3Subdivision *>(elem);
1469  MeshTools::Subdivision::find_one_ring(sd_elem, _elem_nodes);
1470  }
1471  else
1472  {
1473  // All other FE use only the nodes of elem itself
1474  _elem_nodes.resize(elem->n_nodes(), nullptr);
1475  for (auto i : elem->node_index_range())
1476  _elem_nodes[i] = elem->node_ptr(i);
1477  }
1478 
1479  // Compute map at all quadrature points
1480  for (unsigned int p=0; p!=n_qp; p++)
1481  this->compute_single_point_map(dim, qw, elem, p, _elem_nodes, calculate_d2phi);
1482 }

References libMesh::FEMap::_elem_nodes, libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), dim, libMesh::MeshTools::Subdivision::find_one_ring(), libMesh::Elem::has_affine_map(), libMesh::libmesh_assert(), libMesh::Elem::n_nodes(), libMesh::Elem::node_index_range(), libMesh::Elem::node_ptr(), libMesh::FEMap::resize_quadrature_map_vectors(), libMesh::TRI3SUBDIVISION, and libMesh::Elem::type().

◆ compute_null_map()

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

Assign a fake jacobian and some other additional data fields.

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

Definition at line 1358 of file fe_map.C.

1360 {
1361  // Start logging the map computation.
1362  LOG_SCOPE("compute_null_map()", "FEMap");
1363 
1364  const unsigned int n_qp = cast_int<unsigned int>(qw.size());
1365 
1366  // Resize the vectors to hold data at the quadrature points
1367  this->resize_quadrature_map_vectors(dim, n_qp);
1368 
1369  // Compute "fake" xyz
1370  for (unsigned int p=1; p<n_qp; p++)
1371  {
1372  if (calculate_xyz)
1373  xyz[p].zero();
1374 
1375  if (calculate_dxyz)
1376  {
1377  dxyzdxi_map[p] = 0;
1378  dxidx_map[p] = 0;
1379  dxidy_map[p] = 0;
1380  dxidz_map[p] = 0;
1381  }
1382 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1383  if (calculate_d2xyz)
1384  {
1385  d2xyzdxi2_map[p] = 0;
1386  }
1387 #endif
1388  if (dim > 1)
1389  {
1390  if (calculate_dxyz)
1391  {
1392  dxyzdeta_map[p] = 0;
1393  detadx_map[p] = 0;
1394  detady_map[p] = 0;
1395  detadz_map[p] = 0;
1396  }
1397 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1398  if (calculate_d2xyz)
1399  {
1400  d2xyzdxideta_map[p] = 0.;
1401  d2xyzdeta2_map[p] = 0.;
1402  }
1403 #endif
1404  if (dim > 2)
1405  {
1406  if (calculate_dxyz)
1407  {
1408  dxyzdzeta_map[p] = 0;
1409  dzetadx_map[p] = 0;
1410  dzetady_map[p] = 0;
1411  dzetadz_map[p] = 0;
1412  }
1413 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1414  if (calculate_d2xyz)
1415  {
1416  d2xyzdxidzeta_map[p] = 0;
1417  d2xyzdetadzeta_map[p] = 0;
1418  d2xyzdzeta2_map[p] = 0;
1419  }
1420 #endif
1421  }
1422  }
1423  if (calculate_dxyz)
1424  {
1425  jac[p] = 1;
1426  JxW[p] = qw[p];
1427  }
1428  }
1429 }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculate_xyz, libMesh::FEMap::d2xyzdeta2_map, libMesh::FEMap::d2xyzdetadzeta_map, libMesh::FEMap::d2xyzdxi2_map, libMesh::FEMap::d2xyzdxideta_map, libMesh::FEMap::d2xyzdxidzeta_map, libMesh::FEMap::d2xyzdzeta2_map, libMesh::FEMap::detadx_map, libMesh::FEMap::detady_map, libMesh::FEMap::detadz_map, dim, libMesh::FEMap::dxidx_map, libMesh::FEMap::dxidy_map, libMesh::FEMap::dxidz_map, libMesh::FEMap::dxyzdeta_map, libMesh::FEMap::dxyzdxi_map, libMesh::FEMap::dxyzdzeta_map, libMesh::FEMap::dzetadx_map, libMesh::FEMap::dzetady_map, libMesh::FEMap::dzetadz_map, libMesh::FEMap::jac, libMesh::FEMap::JxW, libMesh::FEMap::resize_quadrature_map_vectors(), and libMesh::FEMap::xyz.

Referenced by libMesh::FEMap::compute_map().

◆ 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 
)
inherited

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.

Definition at line 446 of file fe_map.C.

452 {
453  libmesh_assert(elem);
454  libmesh_assert(calculations_started);
455 #ifndef LIBMESH_ENABLE_SECOND_DERIVATIVES
456  libmesh_assert(!compute_second_derivatives);
457 #endif
458 
459  if (calculate_xyz)
460  libmesh_assert_equal_to(phi_map.size(), elem_nodes.size());
461 
462  switch (dim)
463  {
464  //--------------------------------------------------------------------
465  // 0D
466  case 0:
467  {
468  libmesh_assert(elem_nodes[0]);
469  if (calculate_xyz)
470  xyz[p] = *elem_nodes[0];
471  if (calculate_dxyz)
472  {
473  jac[p] = 1.0;
474  JxW[p] = qw[p];
475  }
476  break;
477  }
478 
479  //--------------------------------------------------------------------
480  // 1D
481  case 1:
482  {
483  // Clear the entities that will be summed
484  if (calculate_xyz)
485  xyz[p].zero();
486  if (calculate_dxyz)
487  dxyzdxi_map[p].zero();
488 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
489  if (calculate_d2xyz)
490  {
491  d2xyzdxi2_map[p].zero();
492  // Inverse map second derivatives
493  d2xidxyz2_map[p].assign(6, 0.);
494  }
495 #endif
496 
497  // compute x, dx, d2x at the quadrature point
498  for (auto i : index_range(elem_nodes)) // sum over the nodes
499  {
500  // Reference to the point, helps eliminate
501  // excessive temporaries in the inner loop
502  libmesh_assert(elem_nodes[i]);
503  const Point & elem_point = *elem_nodes[i];
504 
505  if (calculate_xyz)
506  xyz[p].add_scaled (elem_point, phi_map[i][p] );
507  if (calculate_dxyz)
508  dxyzdxi_map[p].add_scaled (elem_point, dphidxi_map[i][p]);
509 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
510  if (calculate_d2xyz)
511  d2xyzdxi2_map[p].add_scaled(elem_point, d2phidxi2_map[i][p]);
512 #endif
513  }
514 
515  // Compute the jacobian
516  //
517  // 1D elements can live in 2D or 3D space.
518  // The transformation matrix from local->global
519  // coordinates is
520  //
521  // T = | dx/dxi |
522  // | dy/dxi |
523  // | dz/dxi |
524  //
525  // The generalized determinant of T (from the
526  // so-called "normal" eqns.) is
527  // jac = "det(T)" = sqrt(det(T'T))
528  //
529  // where T'= transpose of T, so
530  //
531  // jac = sqrt( (dx/dxi)^2 + (dy/dxi)^2 + (dz/dxi)^2 )
532 
533  if (calculate_dxyz)
534  {
535  jac[p] = dxyzdxi_map[p].norm();
536 
537  if (jac[p] <= jacobian_tolerance)
538  {
539  // Don't call print_info() recursively if we're already
540  // failing. print_info() calls Elem::volume() which may
541  // call FE::reinit() and trigger the same failure again.
542  static bool failing = false;
543  if (!failing)
544  {
545  failing = true;
546  elem->print_info(libMesh::err);
547  failing = false;
548  if (calculate_xyz)
549  {
550  libmesh_error_msg("ERROR: negative Jacobian " \
551  << jac[p] \
552  << " at point " \
553  << xyz[p] \
554  << " in element " \
555  << elem->id());
556  }
557  else
558  {
559  // In this case xyz[p] is not defined, so don't
560  // try to print it out.
561  libmesh_error_msg("ERROR: negative Jacobian " \
562  << jac[p] \
563  << " at point index " \
564  << p \
565  << " in element " \
566  << elem->id());
567  }
568  }
569  else
570  {
571  // We were already failing when we called this, so just
572  // stop the current computation and return with
573  // incomplete results.
574  return;
575  }
576  }
577 
578  // The inverse Jacobian entries also come from the
579  // generalized inverse of T (see also the 2D element
580  // living in 3D code).
581  const Real jacm2 = 1./jac[p]/jac[p];
582  dxidx_map[p] = jacm2*dxdxi_map(p);
583 #if LIBMESH_DIM > 1
584  dxidy_map[p] = jacm2*dydxi_map(p);
585 #endif
586 #if LIBMESH_DIM > 2
587  dxidz_map[p] = jacm2*dzdxi_map(p);
588 #endif
589 
590  JxW[p] = jac[p]*qw[p];
591  }
592 
593 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
594 
595  if (calculate_d2xyz)
596  {
597 #if LIBMESH_DIM == 1
598  // Compute inverse map second derivatives for 1D-element-living-in-1D case
599  this->compute_inverse_map_second_derivs(p);
600 #elif LIBMESH_DIM == 2
601  // Compute inverse map second derivatives for 1D-element-living-in-2D case
602  // See JWP notes for details
603 
604  // numer = x_xi*x_{xi xi} + y_xi*y_{xi xi}
605  Real numer =
606  dxyzdxi_map[p](0)*d2xyzdxi2_map[p](0) +
607  dxyzdxi_map[p](1)*d2xyzdxi2_map[p](1);
608 
609  // denom = (x_xi)^2 + (y_xi)^2 must be >= 0.0
610  Real denom =
611  dxyzdxi_map[p](0)*dxyzdxi_map[p](0) +
612  dxyzdxi_map[p](1)*dxyzdxi_map[p](1);
613 
614  if (denom <= 0.0)
615  {
616  // Don't call print_info() recursively if we're already
617  // failing. print_info() calls Elem::volume() which may
618  // call FE::reinit() and trigger the same failure again.
619  static bool failing = false;
620  if (!failing)
621  {
622  failing = true;
623  elem->print_info(libMesh::err);
624  failing = false;
625  libmesh_error_msg("Encountered invalid 1D element!");
626  }
627  else
628  {
629  // We were already failing when we called this, so just
630  // stop the current computation and return with
631  // incomplete results.
632  return;
633  }
634  }
635 
636  // xi_{x x}
637  d2xidxyz2_map[p][0] = -numer * dxidx_map[p]*dxidx_map[p] / denom;
638 
639  // xi_{x y}
640  d2xidxyz2_map[p][1] = -numer * dxidx_map[p]*dxidy_map[p] / denom;
641 
642  // xi_{y y}
643  d2xidxyz2_map[p][3] = -numer * dxidy_map[p]*dxidy_map[p] / denom;
644 
645 #elif LIBMESH_DIM == 3
646  // Compute inverse map second derivatives for 1D-element-living-in-3D case
647  // See JWP notes for details
648 
649  // numer = x_xi*x_{xi xi} + y_xi*y_{xi xi} + z_xi*z_{xi xi}
650  Real numer =
651  dxyzdxi_map[p](0)*d2xyzdxi2_map[p](0) +
652  dxyzdxi_map[p](1)*d2xyzdxi2_map[p](1) +
653  dxyzdxi_map[p](2)*d2xyzdxi2_map[p](2);
654 
655  // denom = (x_xi)^2 + (y_xi)^2 + (z_xi)^2 must be >= 0.0
656  Real denom =
657  dxyzdxi_map[p](0)*dxyzdxi_map[p](0) +
658  dxyzdxi_map[p](1)*dxyzdxi_map[p](1) +
659  dxyzdxi_map[p](2)*dxyzdxi_map[p](2);
660 
661  if (denom <= 0.0)
662  {
663  // Don't call print_info() recursively if we're already
664  // failing. print_info() calls Elem::volume() which may
665  // call FE::reinit() and trigger the same failure again.
666  static bool failing = false;
667  if (!failing)
668  {
669  failing = true;
670  elem->print_info(libMesh::err);
671  failing = false;
672  libmesh_error_msg("Encountered invalid 1D element!");
673  }
674  else
675  {
676  // We were already failing when we called this, so just
677  // stop the current computation and return with
678  // incomplete results.
679  return;
680  }
681  }
682 
683  // xi_{x x}
684  d2xidxyz2_map[p][0] = -numer * dxidx_map[p]*dxidx_map[p] / denom;
685 
686  // xi_{x y}
687  d2xidxyz2_map[p][1] = -numer * dxidx_map[p]*dxidy_map[p] / denom;
688 
689  // xi_{x z}
690  d2xidxyz2_map[p][2] = -numer * dxidx_map[p]*dxidz_map[p] / denom;
691 
692  // xi_{y y}
693  d2xidxyz2_map[p][3] = -numer * dxidy_map[p]*dxidy_map[p] / denom;
694 
695  // xi_{y z}
696  d2xidxyz2_map[p][4] = -numer * dxidy_map[p]*dxidz_map[p] / denom;
697 
698  // xi_{z z}
699  d2xidxyz2_map[p][5] = -numer * dxidz_map[p]*dxidz_map[p] / denom;
700 #endif //LIBMESH_DIM == 3
701  } // calculate_d2xyz
702 
703 #endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
704 
705  // done computing the map
706  break;
707  }
708 
709 
710  //--------------------------------------------------------------------
711  // 2D
712  case 2:
713  {
714  //------------------------------------------------------------------
715  // Compute the (x,y) values at the quadrature points,
716  // the Jacobian at the quadrature points
717 
718  if (calculate_xyz)
719  xyz[p].zero();
720 
721  if (calculate_dxyz)
722  {
723  dxyzdxi_map[p].zero();
724  dxyzdeta_map[p].zero();
725  }
726 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
727  if (calculate_d2xyz)
728  {
729  d2xyzdxi2_map[p].zero();
730  d2xyzdxideta_map[p].zero();
731  d2xyzdeta2_map[p].zero();
732  // Inverse map second derivatives
733  d2xidxyz2_map[p].assign(6, 0.);
734  d2etadxyz2_map[p].assign(6, 0.);
735  }
736 #endif
737 
738 
739  // compute (x,y) at the quadrature points, derivatives once
740  for (auto i : index_range(elem_nodes)) // sum over the nodes
741  {
742  // Reference to the point, helps eliminate
743  // excessive temporaries in the inner loop
744  libmesh_assert(elem_nodes[i]);
745  const Point & elem_point = *elem_nodes[i];
746 
747  if (calculate_xyz)
748  xyz[p].add_scaled (elem_point, phi_map[i][p] );
749 
750  if (calculate_dxyz)
751  {
752  dxyzdxi_map[p].add_scaled (elem_point, dphidxi_map[i][p] );
753  dxyzdeta_map[p].add_scaled (elem_point, dphideta_map[i][p]);
754  }
755 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
756  if (calculate_d2xyz)
757  {
758  d2xyzdxi2_map[p].add_scaled (elem_point, d2phidxi2_map[i][p]);
759  d2xyzdxideta_map[p].add_scaled (elem_point, d2phidxideta_map[i][p]);
760  d2xyzdeta2_map[p].add_scaled (elem_point, d2phideta2_map[i][p]);
761  }
762 #endif
763  }
764 
765  if (calculate_dxyz)
766  {
767  // compute the jacobian once
768  const Real dx_dxi = dxdxi_map(p),
769  dx_deta = dxdeta_map(p),
770  dy_dxi = dydxi_map(p),
771  dy_deta = dydeta_map(p);
772 
773 #if LIBMESH_DIM == 2
774  // Compute the Jacobian. This assumes the 2D face
775  // lives in 2D space
776  //
777  // Symbolically, the matrix determinant is
778  //
779  // | dx/dxi dx/deta |
780  // jac = | dy/dxi dy/deta |
781  //
782  // jac = dx/dxi*dy/deta - dx/deta*dy/dxi
783  jac[p] = (dx_dxi*dy_deta - dx_deta*dy_dxi);
784 
785  if (jac[p] <= jacobian_tolerance)
786  {
787  // Don't call print_info() recursively if we're already
788  // failing. print_info() calls Elem::volume() which may
789  // call FE::reinit() and trigger the same failure again.
790  static bool failing = false;
791  if (!failing)
792  {
793  failing = true;
794  elem->print_info(libMesh::err);
795  failing = false;
796  if (calculate_xyz)
797  {
798  libmesh_error_msg("ERROR: negative Jacobian " \
799  << jac[p] \
800  << " at point " \
801  << xyz[p] \
802  << " in element " \
803  << elem->id());
804  }
805  else
806  {
807  // In this case xyz[p] is not defined, so don't
808  // try to print it out.
809  libmesh_error_msg("ERROR: negative Jacobian " \
810  << jac[p] \
811  << " at point index " \
812  << p \
813  << " in element " \
814  << elem->id());
815  }
816  }
817  else
818  {
819  // We were already failing when we called this, so just
820  // stop the current computation and return with
821  // incomplete results.
822  return;
823  }
824  }
825 
826  JxW[p] = jac[p]*qw[p];
827 
828  // Compute the shape function derivatives wrt x,y at the
829  // quadrature points
830  const Real inv_jac = 1./jac[p];
831 
832  dxidx_map[p] = dy_deta*inv_jac; //dxi/dx = (1/J)*dy/deta
833  dxidy_map[p] = -dx_deta*inv_jac; //dxi/dy = -(1/J)*dx/deta
834  detadx_map[p] = -dy_dxi* inv_jac; //deta/dx = -(1/J)*dy/dxi
835  detady_map[p] = dx_dxi* inv_jac; //deta/dy = (1/J)*dx/dxi
836 
837  dxidz_map[p] = detadz_map[p] = 0.;
838 
839 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
840  if (compute_second_derivatives)
841  this->compute_inverse_map_second_derivs(p);
842 #endif
843 #else // LIBMESH_DIM == 3
844 
845  const Real dz_dxi = dzdxi_map(p),
846  dz_deta = dzdeta_map(p);
847 
848  // Compute the Jacobian. This assumes a 2D face in
849  // 3D space.
850  //
851  // The transformation matrix T from local to global
852  // coordinates is
853  //
854  // | dx/dxi dx/deta |
855  // T = | dy/dxi dy/deta |
856  // | dz/dxi dz/deta |
857  // note det(T' T) = det(T')det(T) = det(T)det(T)
858  // so det(T) = std::sqrt(det(T' T))
859  //
860  //----------------------------------------------
861  // Notes:
862  //
863  // dX = R dXi -> R'dX = R'R dXi
864  // (R^-1)dX = dXi [(R'R)^-1 R']dX = dXi
865  //
866  // so R^-1 = (R'R)^-1 R'
867  //
868  // and R^-1 R = (R'R)^-1 R'R = I.
869  //
870  const Real g11 = (dx_dxi*dx_dxi +
871  dy_dxi*dy_dxi +
872  dz_dxi*dz_dxi);
873 
874  const Real g12 = (dx_dxi*dx_deta +
875  dy_dxi*dy_deta +
876  dz_dxi*dz_deta);
877 
878  const Real g21 = g12;
879 
880  const Real g22 = (dx_deta*dx_deta +
881  dy_deta*dy_deta +
882  dz_deta*dz_deta);
883 
884  const Real det = (g11*g22 - g12*g21);
885 
886  if (det <= 0.)
887  {
888  // Don't call print_info() recursively if we're already
889  // failing. print_info() calls Elem::volume() which may
890  // call FE::reinit() and trigger the same failure again.
891  static bool failing = false;
892  if (!failing)
893  {
894  failing = true;
895  elem->print_info(libMesh::err);
896  failing = false;
897  if (calculate_xyz)
898  {
899  libmesh_error_msg("ERROR: negative Jacobian " \
900  << det \
901  << " at point " \
902  << xyz[p] \
903  << " in element " \
904  << elem->id());
905  }
906  else
907  {
908  // In this case xyz[p] is not defined, so don't
909  // try to print it out.
910  libmesh_error_msg("ERROR: negative Jacobian " \
911  << det \
912  << " at point index " \
913  << p \
914  << " in element " \
915  << elem->id());
916  }
917  }
918  else
919  {
920  // We were already failing when we called this, so just
921  // stop the current computation and return with
922  // incomplete results.
923  return;
924  }
925  }
926 
927  const Real inv_det = 1./det;
928  jac[p] = std::sqrt(det);
929 
930  JxW[p] = jac[p]*qw[p];
931 
932  const Real g11inv = g22*inv_det;
933  const Real g12inv = -g12*inv_det;
934  const Real g21inv = -g21*inv_det;
935  const Real g22inv = g11*inv_det;
936 
937  dxidx_map[p] = g11inv*dx_dxi + g12inv*dx_deta;
938  dxidy_map[p] = g11inv*dy_dxi + g12inv*dy_deta;
939  dxidz_map[p] = g11inv*dz_dxi + g12inv*dz_deta;
940 
941  detadx_map[p] = g21inv*dx_dxi + g22inv*dx_deta;
942  detady_map[p] = g21inv*dy_dxi + g22inv*dy_deta;
943  detadz_map[p] = g21inv*dz_dxi + g22inv*dz_deta;
944 
945 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
946 
947  if (calculate_d2xyz)
948  {
949  // Compute inverse map second derivative values for
950  // 2D-element-living-in-3D case. We pursue a least-squares
951  // solution approach for this "non-square" case, see JWP notes
952  // for details.
953 
954  // A = [ x_{xi xi} x_{eta eta} ]
955  // [ y_{xi xi} y_{eta eta} ]
956  // [ z_{xi xi} z_{eta eta} ]
957  DenseMatrix<Real> A(3,2);
958  A(0,0) = d2xyzdxi2_map[p](0); A(0,1) = d2xyzdeta2_map[p](0);
959  A(1,0) = d2xyzdxi2_map[p](1); A(1,1) = d2xyzdeta2_map[p](1);
960  A(2,0) = d2xyzdxi2_map[p](2); A(2,1) = d2xyzdeta2_map[p](2);
961 
962  // J^T, the transpose of the Jacobian matrix
963  DenseMatrix<Real> JT(2,3);
964  JT(0,0) = dx_dxi; JT(0,1) = dy_dxi; JT(0,2) = dz_dxi;
965  JT(1,0) = dx_deta; JT(1,1) = dy_deta; JT(1,2) = dz_deta;
966 
967  // (J^T J)^(-1), this has already been computed for us above...
968  DenseMatrix<Real> JTJinv(2,2);
969  JTJinv(0,0) = g11inv; JTJinv(0,1) = g12inv;
970  JTJinv(1,0) = g21inv; JTJinv(1,1) = g22inv;
971 
972  // Some helper variables
973  RealVectorValue
974  dxi (dxidx_map[p], dxidy_map[p], dxidz_map[p]),
975  deta (detadx_map[p], detady_map[p], detadz_map[p]);
976 
977  // To be filled in below
978  DenseVector<Real> tmp1(2);
979  DenseVector<Real> tmp2(3);
980  DenseVector<Real> tmp3(2);
981 
982  // For (s,t) in {(x,x), (x,y), (x,z), (y,y), (y,z), (z,z)}, compute the
983  // vector of inverse map second derivatives [xi_{s t}, eta_{s t}]
984  unsigned ctr=0;
985  for (unsigned s=0; s<3; ++s)
986  for (unsigned t=s; t<3; ++t)
987  {
988  // Construct tmp1 = [xi_s*xi_t, eta_s*eta_t]
989  tmp1(0) = dxi(s)*dxi(t);
990  tmp1(1) = deta(s)*deta(t);
991 
992  // Compute tmp2 = A * tmp1
993  A.vector_mult(tmp2, tmp1);
994 
995  // Compute scalar value "alpha"
996  Real alpha = dxi(s)*deta(t) + deta(s)*dxi(t);
997 
998  // Compute tmp2 <- tmp2 + alpha * x_{xi eta}
999  for (unsigned i=0; i<3; ++i)
1000  tmp2(i) += alpha*d2xyzdxideta_map[p](i);
1001 
1002  // Compute tmp3 = J^T * tmp2
1003  JT.vector_mult(tmp3, tmp2);
1004 
1005  // Compute tmp1 = (J^T J)^(-1) * tmp3. tmp1 is available for us to reuse.
1006  JTJinv.vector_mult(tmp1, tmp3);
1007 
1008  // Fill in appropriate entries, don't forget to multiply by -1!
1009  d2xidxyz2_map[p][ctr] = -tmp1(0);
1010  d2etadxyz2_map[p][ctr] = -tmp1(1);
1011 
1012  // Increment the counter
1013  ctr++;
1014  }
1015  }
1016 
1017 #endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
1018 
1019 #endif // LIBMESH_DIM == 3
1020  }
1021  // done computing the map
1022  break;
1023  }
1024 
1025 
1026 
1027  //--------------------------------------------------------------------
1028  // 3D
1029  case 3:
1030  {
1031  //------------------------------------------------------------------
1032  // Compute the (x,y,z) values at the quadrature points,
1033  // the Jacobian at the quadrature point
1034 
1035  // Clear the entities that will be summed
1036  if (calculate_xyz)
1037  xyz[p].zero ();
1038  if (calculate_dxyz)
1039  {
1040  dxyzdxi_map[p].zero ();
1041  dxyzdeta_map[p].zero ();
1042  dxyzdzeta_map[p].zero ();
1043  }
1044 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1045  if (calculate_d2xyz)
1046  {
1047  d2xyzdxi2_map[p].zero();
1048  d2xyzdxideta_map[p].zero();
1049  d2xyzdxidzeta_map[p].zero();
1050  d2xyzdeta2_map[p].zero();
1051  d2xyzdetadzeta_map[p].zero();
1052  d2xyzdzeta2_map[p].zero();
1053  // Inverse map second derivatives
1054  d2xidxyz2_map[p].assign(6, 0.);
1055  d2etadxyz2_map[p].assign(6, 0.);
1056  d2zetadxyz2_map[p].assign(6, 0.);
1057  }
1058 #endif
1059 
1060 
1061  // compute (x,y,z) at the quadrature points,
1062  // dxdxi, dydxi, dzdxi,
1063  // dxdeta, dydeta, dzdeta,
1064  // dxdzeta, dydzeta, dzdzeta all once
1065  for (auto i : index_range(elem_nodes)) // sum over the nodes
1066  {
1067  // Reference to the point, helps eliminate
1068  // excessive temporaries in the inner loop
1069  libmesh_assert(elem_nodes[i]);
1070  const Point & elem_point = *elem_nodes[i];
1071 
1072  if (calculate_xyz)
1073  xyz[p].add_scaled (elem_point, phi_map[i][p] );
1074  if (calculate_dxyz)
1075  {
1076  dxyzdxi_map[p].add_scaled (elem_point, dphidxi_map[i][p] );
1077  dxyzdeta_map[p].add_scaled (elem_point, dphideta_map[i][p] );
1078  dxyzdzeta_map[p].add_scaled (elem_point, dphidzeta_map[i][p]);
1079  }
1080 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1081  if (calculate_d2xyz)
1082  {
1083  d2xyzdxi2_map[p].add_scaled (elem_point,
1084  d2phidxi2_map[i][p]);
1085  d2xyzdxideta_map[p].add_scaled (elem_point,
1086  d2phidxideta_map[i][p]);
1087  d2xyzdxidzeta_map[p].add_scaled (elem_point,
1088  d2phidxidzeta_map[i][p]);
1089  d2xyzdeta2_map[p].add_scaled (elem_point,
1090  d2phideta2_map[i][p]);
1091  d2xyzdetadzeta_map[p].add_scaled (elem_point,
1092  d2phidetadzeta_map[i][p]);
1093  d2xyzdzeta2_map[p].add_scaled (elem_point,
1094  d2phidzeta2_map[i][p]);
1095  }
1096 #endif
1097  }
1098 
1099  if (calculate_dxyz)
1100  {
1101  // compute the jacobian
1102  const Real
1103  dx_dxi = dxdxi_map(p), dy_dxi = dydxi_map(p), dz_dxi = dzdxi_map(p),
1104  dx_deta = dxdeta_map(p), dy_deta = dydeta_map(p), dz_deta = dzdeta_map(p),
1105  dx_dzeta = dxdzeta_map(p), dy_dzeta = dydzeta_map(p), dz_dzeta = dzdzeta_map(p);
1106 
1107  // Symbolically, the matrix determinant is
1108  //
1109  // | dx/dxi dy/dxi dz/dxi |
1110  // jac = | dx/deta dy/deta dz/deta |
1111  // | dx/dzeta dy/dzeta dz/dzeta |
1112  //
1113  // jac = dx/dxi*(dy/deta*dz/dzeta - dz/deta*dy/dzeta) +
1114  // dy/dxi*(dz/deta*dx/dzeta - dx/deta*dz/dzeta) +
1115  // dz/dxi*(dx/deta*dy/dzeta - dy/deta*dx/dzeta)
1116 
1117  jac[p] = (dx_dxi*(dy_deta*dz_dzeta - dz_deta*dy_dzeta) +
1118  dy_dxi*(dz_deta*dx_dzeta - dx_deta*dz_dzeta) +
1119  dz_dxi*(dx_deta*dy_dzeta - dy_deta*dx_dzeta));
1120 
1121  if (jac[p] <= jacobian_tolerance)
1122  {
1123  // Don't call print_info() recursively if we're already
1124  // failing. print_info() calls Elem::volume() which may
1125  // call FE::reinit() and trigger the same failure again.
1126  static bool failing = false;
1127  if (!failing)
1128  {
1129  failing = true;
1130  elem->print_info(libMesh::err);
1131  failing = false;
1132  if (calculate_xyz)
1133  {
1134  libmesh_error_msg("ERROR: negative Jacobian " \
1135  << jac[p] \
1136  << " at point " \
1137  << xyz[p] \
1138  << " in element " \
1139  << elem->id());
1140  }
1141  else
1142  {
1143  // In this case xyz[p] is not defined, so don't
1144  // try to print it out.
1145  libmesh_error_msg("ERROR: negative Jacobian " \
1146  << jac[p] \
1147  << " at point index " \
1148  << p \
1149  << " in element " \
1150  << elem->id());
1151  }
1152  }
1153  else
1154  {
1155  // We were already failing when we called this, so just
1156  // stop the current computation and return with
1157  // incomplete results.
1158  return;
1159  }
1160  }
1161 
1162  JxW[p] = jac[p]*qw[p];
1163 
1164  // Compute the shape function derivatives wrt x,y at the
1165  // quadrature points
1166  const Real inv_jac = 1./jac[p];
1167 
1168  dxidx_map[p] = (dy_deta*dz_dzeta - dz_deta*dy_dzeta)*inv_jac;
1169  dxidy_map[p] = (dz_deta*dx_dzeta - dx_deta*dz_dzeta)*inv_jac;
1170  dxidz_map[p] = (dx_deta*dy_dzeta - dy_deta*dx_dzeta)*inv_jac;
1171 
1172  detadx_map[p] = (dz_dxi*dy_dzeta - dy_dxi*dz_dzeta )*inv_jac;
1173  detady_map[p] = (dx_dxi*dz_dzeta - dz_dxi*dx_dzeta )*inv_jac;
1174  detadz_map[p] = (dy_dxi*dx_dzeta - dx_dxi*dy_dzeta )*inv_jac;
1175 
1176  dzetadx_map[p] = (dy_dxi*dz_deta - dz_dxi*dy_deta )*inv_jac;
1177  dzetady_map[p] = (dz_dxi*dx_deta - dx_dxi*dz_deta )*inv_jac;
1178  dzetadz_map[p] = (dx_dxi*dy_deta - dy_dxi*dx_deta )*inv_jac;
1179  }
1180 
1181 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1182  if (compute_second_derivatives)
1183  this->compute_inverse_map_second_derivs(p);
1184 #endif
1185  // done computing the map
1186  break;
1187  }
1188 
1189  default:
1190  libmesh_error_msg("Invalid dim = " << dim);
1191  }
1192 }

References A, libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculate_xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::d2etadxyz2_map, libMesh::FEMap::d2phideta2_map, libMesh::FEMap::d2phidetadzeta_map, libMesh::FEMap::d2phidxi2_map, libMesh::FEMap::d2phidxideta_map, libMesh::FEMap::d2phidxidzeta_map, libMesh::FEMap::d2phidzeta2_map, libMesh::FEMap::d2xidxyz2_map, libMesh::FEMap::d2xyzdeta2_map, libMesh::FEMap::d2xyzdetadzeta_map, libMesh::FEMap::d2xyzdxi2_map, libMesh::FEMap::d2xyzdxideta_map, libMesh::FEMap::d2xyzdxidzeta_map, libMesh::FEMap::d2xyzdzeta2_map, libMesh::FEMap::d2zetadxyz2_map, libMesh::FEMap::detadx_map, libMesh::FEMap::detady_map, libMesh::FEMap::detadz_map, dim, libMesh::FEMap::dphideta_map, libMesh::FEMap::dphidxi_map, libMesh::FEMap::dphidzeta_map, libMesh::FEMap::dxdeta_map(), libMesh::FEMap::dxdxi_map(), libMesh::FEMap::dxdzeta_map(), libMesh::FEMap::dxidx_map, libMesh::FEMap::dxidy_map, libMesh::FEMap::dxidz_map, libMesh::FEMap::dxyzdeta_map, libMesh::FEMap::dxyzdxi_map, libMesh::FEMap::dxyzdzeta_map, libMesh::FEMap::dydeta_map(), libMesh::FEMap::dydxi_map(), libMesh::FEMap::dydzeta_map(), libMesh::FEMap::dzdeta_map(), libMesh::FEMap::dzdxi_map(), libMesh::FEMap::dzdzeta_map(), libMesh::FEMap::dzetadx_map, libMesh::FEMap::dzetady_map, libMesh::FEMap::dzetadz_map, libMesh::err, libMesh::DofObject::id(), libMesh::index_range(), libMesh::FEMap::jac, libMesh::FEMap::jacobian_tolerance, libMesh::FEMap::JxW, libMesh::libmesh_assert(), libMesh::FEMap::phi_map, libMesh::Elem::print_info(), libMesh::Real, std::sqrt(), libMesh::DenseMatrix< T >::vector_mult(), and libMesh::FEMap::xyz.

Referenced by libMesh::FEMap::compute_affine_map(), and libMesh::FEMap::compute_map().

◆ determine_calculations()

void libMesh::FEMap::determine_calculations ( )
inlineprotectedinherited

Determine which values are to be calculated.

Definition at line 621 of file fe_map.h.

621  {
622  calculations_started = true;
623 
624 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
625  // Second derivative calculations currently have first derivative
626  // calculations as a prerequisite
627  if (calculate_d2xyz)
628  calculate_dxyz = true;
629 #endif
630  }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculate_dxyz, and libMesh::FEMap::calculations_started.

Referenced by libMesh::FEMap::compute_edge_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::init_edge_shape_functions(), libMesh::FEMap::init_face_shape_functions(), libMesh::FEMap::init_reference_to_physical_map(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ dxdeta_map()

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

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 667 of file fe_map.h.

667 { return dxyzdeta_map[p](0); }

References libMesh::FEMap::dxyzdeta_map.

Referenced by compute_face_map(), libMesh::FEMap::compute_face_map(), and libMesh::FEMap::compute_single_point_map().

◆ dxdxi_map()

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

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 643 of file fe_map.h.

643 { return dxyzdxi_map[p](0); }

References libMesh::FEMap::dxyzdxi_map.

Referenced by libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), and libMesh::FEMap::compute_single_point_map().

◆ dxdzeta_map()

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

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 691 of file fe_map.h.

691 { return dxyzdzeta_map[p](0); }

References libMesh::FEMap::dxyzdzeta_map.

Referenced by libMesh::FEMap::compute_single_point_map().

◆ dydeta_map()

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

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 675 of file fe_map.h.

675 { return dxyzdeta_map[p](1); }

References libMesh::FEMap::dxyzdeta_map.

Referenced by compute_face_map(), libMesh::FEMap::compute_face_map(), and libMesh::FEMap::compute_single_point_map().

◆ dydxi_map()

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

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 651 of file fe_map.h.

651 { return dxyzdxi_map[p](1); }

References libMesh::FEMap::dxyzdxi_map.

Referenced by libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), and libMesh::FEMap::compute_single_point_map().

◆ dydzeta_map()

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

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 699 of file fe_map.h.

699 { return dxyzdzeta_map[p](1); }

References libMesh::FEMap::dxyzdzeta_map.

Referenced by libMesh::FEMap::compute_single_point_map().

◆ dzdeta_map()

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

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 683 of file fe_map.h.

683 { return dxyzdeta_map[p](2); }

References libMesh::FEMap::dxyzdeta_map.

Referenced by compute_face_map(), libMesh::FEMap::compute_face_map(), and libMesh::FEMap::compute_single_point_map().

◆ dzdxi_map()

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

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 659 of file fe_map.h.

659 { return dxyzdxi_map[p](2); }

References libMesh::FEMap::dxyzdxi_map.

Referenced by libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), and libMesh::FEMap::compute_single_point_map().

◆ dzdzeta_map()

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

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 707 of file fe_map.h.

707 { return dxyzdzeta_map[p](2); }

References libMesh::FEMap::dxyzdzeta_map.

Referenced by libMesh::FEMap::compute_single_point_map().

◆ get_curvatures()

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

Definition at line 432 of file fe_map.h.

433  { libmesh_assert(!calculations_started || calculate_d2xyz);
434  calculate_d2xyz = true; return curvatures;}

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::curvatures, and libMesh::libmesh_assert().

◆ get_d2etadxyz2()

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

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

Definition at line 367 of file fe_map.h.

368  { libmesh_assert(!calculations_started || calculate_d2xyz);
369  calculate_d2xyz = true; return d2etadxyz2_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2etadxyz2_map, and libMesh::libmesh_assert().

Referenced by libMesh::H1FETransformation< OutputShape >::map_d2phi().

◆ get_d2phideta2_map()

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

Definition at line 581 of file fe_map.h.

582  { libmesh_assert(!calculations_started || calculate_d2xyz);
583  calculate_d2xyz = true; return d2phideta2_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2phideta2_map, and libMesh::libmesh_assert().

◆ get_d2phidetadzeta_map()

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

Definition at line 588 of file fe_map.h.

589  { libmesh_assert(!calculations_started || calculate_d2xyz);
590  calculate_d2xyz = true; return d2phidetadzeta_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2phidetadzeta_map, and libMesh::libmesh_assert().

◆ get_d2phidxi2_map()

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

Definition at line 560 of file fe_map.h.

561  { libmesh_assert(!calculations_started || calculate_d2xyz);
562  calculate_d2xyz = true; return d2phidxi2_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2phidxi2_map, and libMesh::libmesh_assert().

◆ get_d2phidxideta_map()

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

Definition at line 567 of file fe_map.h.

568  { libmesh_assert(!calculations_started || calculate_d2xyz);
569  calculate_d2xyz = true; return d2phidxideta_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2phidxideta_map, and libMesh::libmesh_assert().

◆ get_d2phidxidzeta_map()

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

Definition at line 574 of file fe_map.h.

575  { libmesh_assert(!calculations_started || calculate_d2xyz);
576  calculate_d2xyz = true; return d2phidxidzeta_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2phidxidzeta_map, and libMesh::libmesh_assert().

◆ get_d2phidzeta2_map()

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

Definition at line 595 of file fe_map.h.

596  { libmesh_assert(!calculations_started || calculate_d2xyz);
597  calculate_d2xyz = true; return d2phidzeta2_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2phidzeta2_map, and libMesh::libmesh_assert().

◆ get_d2psideta2() [1/2]

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

Definition at line 514 of file fe_map.h.

515  { libmesh_assert(!calculations_started || calculate_d2xyz);
516  calculate_d2xyz = true; return d2psideta2_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2psideta2_map, and libMesh::libmesh_assert().

◆ get_d2psideta2() [2/2]

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

Definition at line 522 of file fe_map.h.

523  { libmesh_assert(!calculations_started || calculate_d2xyz);
524  calculate_d2xyz = true; return d2psideta2_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2psideta2_map, and libMesh::libmesh_assert().

◆ get_d2psidxi2() [1/2]

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

Definition at line 486 of file fe_map.h.

487  { libmesh_assert(!calculations_started || calculate_d2xyz);
488  calculate_d2xyz = true; return d2psidxi2_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2psidxi2_map, and libMesh::libmesh_assert().

◆ get_d2psidxi2() [2/2]

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

Definition at line 493 of file fe_map.h.

494  { libmesh_assert(!calculations_started || calculate_d2xyz);
495  calculate_d2xyz = true; return d2psidxi2_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2psidxi2_map, and libMesh::libmesh_assert().

◆ get_d2psidxideta() [1/2]

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

Definition at line 500 of file fe_map.h.

501  { libmesh_assert(!calculations_started || calculate_d2xyz);
502  calculate_d2xyz = true; return d2psidxideta_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2psidxideta_map, and libMesh::libmesh_assert().

◆ get_d2psidxideta() [2/2]

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

Definition at line 507 of file fe_map.h.

508  { libmesh_assert(!calculations_started || calculate_d2xyz);
509  calculate_d2xyz = true; return d2psidxideta_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2psidxideta_map, and libMesh::libmesh_assert().

◆ get_d2xidxyz2()

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

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

Definition at line 360 of file fe_map.h.

361  { libmesh_assert(!calculations_started || calculate_d2xyz);
362  calculate_d2xyz = true; return d2xidxyz2_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2xidxyz2_map, and libMesh::libmesh_assert().

Referenced by libMesh::HCurlFETransformation< OutputShape >::init_map_d2phi(), libMesh::H1FETransformation< OutputShape >::init_map_d2phi(), and libMesh::H1FETransformation< OutputShape >::map_d2phi().

◆ get_d2xyzdeta2()

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

Definition at line 250 of file fe_map.h.

251  { libmesh_assert(!calculations_started || calculate_d2xyz);
252  calculate_d2xyz = true; return d2xyzdeta2_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2xyzdeta2_map, and libMesh::libmesh_assert().

◆ get_d2xyzdetadzeta()

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

Definition at line 278 of file fe_map.h.

279  { libmesh_assert(!calculations_started || calculate_d2xyz);
280  calculate_d2xyz = true; return d2xyzdetadzeta_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2xyzdetadzeta_map, and libMesh::libmesh_assert().

◆ get_d2xyzdxi2()

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

Definition at line 243 of file fe_map.h.

244  { libmesh_assert(!calculations_started || calculate_d2xyz);
245  calculate_d2xyz = true; return d2xyzdxi2_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2xyzdxi2_map, and libMesh::libmesh_assert().

◆ get_d2xyzdxideta()

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

Definition at line 264 of file fe_map.h.

265  { libmesh_assert(!calculations_started || calculate_d2xyz);
266  calculate_d2xyz = true; return d2xyzdxideta_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2xyzdxideta_map, and libMesh::libmesh_assert().

◆ get_d2xyzdxidzeta()

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

Definition at line 271 of file fe_map.h.

272  { libmesh_assert(!calculations_started || calculate_d2xyz);
273  calculate_d2xyz = true; return d2xyzdxidzeta_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2xyzdxidzeta_map, and libMesh::libmesh_assert().

◆ get_d2xyzdzeta2()

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

Definition at line 257 of file fe_map.h.

258  { libmesh_assert(!calculations_started || calculate_d2xyz);
259  calculate_d2xyz = true; return d2xyzdzeta2_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2xyzdzeta2_map, and libMesh::libmesh_assert().

◆ get_d2zetadxyz2()

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

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

Definition at line 374 of file fe_map.h.

375  { libmesh_assert(!calculations_started || calculate_d2xyz);
376  calculate_d2xyz = true; return d2zetadxyz2_map; }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculations_started, libMesh::FEMap::d2zetadxyz2_map, and libMesh::libmesh_assert().

Referenced by libMesh::H1FETransformation< OutputShape >::map_d2phi().

◆ get_detadx()

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

Definition at line 312 of file fe_map.h.

313  { libmesh_assert(!calculations_started || calculate_dxyz);
314  calculate_dxyz = true; return detadx_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::detadx_map, and libMesh::libmesh_assert().

Referenced by libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_dphi(), and libMesh::HCurlFETransformation< OutputShape >::map_phi().

◆ get_detady()

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

Definition at line 320 of file fe_map.h.

321  { libmesh_assert(!calculations_started || calculate_dxyz);
322  calculate_dxyz = true; return detady_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::detady_map, and libMesh::libmesh_assert().

Referenced by libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_dphi(), and libMesh::HCurlFETransformation< OutputShape >::map_phi().

◆ get_detadz()

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

Definition at line 328 of file fe_map.h.

329  { libmesh_assert(!calculations_started || calculate_dxyz);
330  calculate_dxyz = true; return detadz_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::detadz_map, and libMesh::libmesh_assert().

Referenced by libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_dphi(), and libMesh::HCurlFETransformation< OutputShape >::map_phi().

◆ get_dphideta_map() [1/2]

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

Definition at line 545 of file fe_map.h.

546  { libmesh_assert(!calculations_started || calculate_dxyz);
547  calculate_dxyz = true; return dphideta_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dphideta_map, and libMesh::libmesh_assert().

◆ get_dphideta_map() [2/2]

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

Definition at line 402 of file fe_map.h.

403  { libmesh_assert(!calculations_started || calculate_dxyz);
404  calculate_dxyz = true; return dphideta_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dphideta_map, and libMesh::libmesh_assert().

◆ get_dphidxi_map() [1/2]

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

Definition at line 538 of file fe_map.h.

539  { libmesh_assert(!calculations_started || calculate_dxyz);
540  calculate_dxyz = true; return dphidxi_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dphidxi_map, and libMesh::libmesh_assert().

◆ get_dphidxi_map() [2/2]

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

Definition at line 395 of file fe_map.h.

396  { libmesh_assert(!calculations_started || calculate_dxyz);
397  calculate_dxyz = true; return dphidxi_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dphidxi_map, and libMesh::libmesh_assert().

◆ get_dphidzeta_map() [1/2]

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

Definition at line 552 of file fe_map.h.

553  { libmesh_assert(!calculations_started || calculate_dxyz);
554  calculate_dxyz = true; return dphidzeta_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dphidzeta_map, and libMesh::libmesh_assert().

◆ get_dphidzeta_map() [2/2]

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

Definition at line 409 of file fe_map.h.

410  { libmesh_assert(!calculations_started || calculate_dxyz);
411  calculate_dxyz = true; return dphidzeta_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dphidzeta_map, and libMesh::libmesh_assert().

◆ get_dpsideta() [1/2]

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

Definition at line 473 of file fe_map.h.

474  { libmesh_assert(!calculations_started || calculate_dxyz);
475  calculate_dxyz = true; return dpsideta_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dpsideta_map, and libMesh::libmesh_assert().

◆ get_dpsideta() [2/2]

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

Definition at line 477 of file fe_map.h.

478  { libmesh_assert(!calculations_started || calculate_dxyz);
479  calculate_dxyz = true; return dpsideta_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dpsideta_map, and libMesh::libmesh_assert().

◆ get_dpsidxi() [1/2]

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

Definition at line 462 of file fe_map.h.

463  { libmesh_assert(!calculations_started || calculate_dxyz);
464  calculate_dxyz = true; return dpsidxi_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dpsidxi_map, and libMesh::libmesh_assert().

◆ get_dpsidxi() [2/2]

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

Definition at line 466 of file fe_map.h.

467  { libmesh_assert(!calculations_started || calculate_dxyz);
468  calculate_dxyz = true; return dpsidxi_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dpsidxi_map, and libMesh::libmesh_assert().

◆ get_dxidx()

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

Definition at line 288 of file fe_map.h.

289  { libmesh_assert(!calculations_started || calculate_dxyz);
290  calculate_dxyz = true; return dxidx_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dxidx_map, and libMesh::libmesh_assert().

Referenced by libMesh::HCurlFETransformation< OutputShape >::init_map_d2phi(), libMesh::H1FETransformation< OutputShape >::init_map_d2phi(), libMesh::HCurlFETransformation< OutputShape >::init_map_dphi(), libMesh::H1FETransformation< OutputShape >::init_map_dphi(), libMesh::HCurlFETransformation< OutputShape >::init_map_phi(), libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_dphi(), and libMesh::HCurlFETransformation< OutputShape >::map_phi().

◆ get_dxidy()

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

Definition at line 296 of file fe_map.h.

297  { libmesh_assert(!calculations_started || calculate_dxyz);
298  calculate_dxyz = true; return dxidy_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dxidy_map, and libMesh::libmesh_assert().

Referenced by libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_dphi(), and libMesh::HCurlFETransformation< OutputShape >::map_phi().

◆ get_dxidz()

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

Definition at line 304 of file fe_map.h.

305  { libmesh_assert(!calculations_started || calculate_dxyz);
306  calculate_dxyz = true; return dxidz_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dxidz_map, and libMesh::libmesh_assert().

Referenced by libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_dphi(), and libMesh::HCurlFETransformation< OutputShape >::map_phi().

◆ get_dxyzdeta()

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

Definition at line 226 of file fe_map.h.

227  { libmesh_assert(!calculations_started || calculate_dxyz);
228  calculate_dxyz = true; return dxyzdeta_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dxyzdeta_map, and libMesh::libmesh_assert().

Referenced by libMesh::HCurlFETransformation< OutputShape >::map_curl().

◆ get_dxyzdxi()

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

Definition at line 218 of file fe_map.h.

219  { libmesh_assert(!calculations_started || calculate_dxyz);
220  calculate_dxyz = true; return dxyzdxi_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dxyzdxi_map, and libMesh::libmesh_assert().

Referenced by libMesh::HCurlFETransformation< OutputShape >::map_curl().

◆ get_dxyzdzeta()

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

Definition at line 234 of file fe_map.h.

235  { libmesh_assert(!calculations_started || calculate_dxyz);
236  calculate_dxyz = true; return dxyzdzeta_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dxyzdzeta_map, and libMesh::libmesh_assert().

Referenced by libMesh::HCurlFETransformation< OutputShape >::map_curl().

◆ get_dzetadx()

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

Definition at line 336 of file fe_map.h.

337  { libmesh_assert(!calculations_started || calculate_dxyz);
338  calculate_dxyz = true; return dzetadx_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dzetadx_map, and libMesh::libmesh_assert().

Referenced by libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_dphi(), and libMesh::HCurlFETransformation< OutputShape >::map_phi().

◆ get_dzetady()

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

Definition at line 344 of file fe_map.h.

345  { libmesh_assert(!calculations_started || calculate_dxyz);
346  calculate_dxyz = true; return dzetady_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dzetady_map, and libMesh::libmesh_assert().

Referenced by libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_dphi(), and libMesh::HCurlFETransformation< OutputShape >::map_phi().

◆ get_dzetadz()

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

Definition at line 352 of file fe_map.h.

353  { libmesh_assert(!calculations_started || calculate_dxyz);
354  calculate_dxyz = true; return dzetadz_map; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::dzetadz_map, and libMesh::libmesh_assert().

Referenced by libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_dphi(), and libMesh::HCurlFETransformation< OutputShape >::map_phi().

◆ get_jacobian()

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

Definition at line 202 of file fe_map.h.

203  { libmesh_assert(!calculations_started || calculate_dxyz);
204  calculate_dxyz = true; return jac; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::jac, and libMesh::libmesh_assert().

Referenced by libMesh::HCurlFETransformation< OutputShape >::map_curl().

◆ get_JxW() [1/2]

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

Definition at line 606 of file fe_map.h.

607  { libmesh_assert(!calculations_started || calculate_dxyz);
608  calculate_dxyz = true; return JxW; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::JxW, and libMesh::libmesh_assert().

◆ get_JxW() [2/2]

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

Definition at line 210 of file fe_map.h.

211  { libmesh_assert(!calculations_started || calculate_dxyz);
212  calculate_dxyz = true; return JxW; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::FEMap::JxW, and libMesh::libmesh_assert().

◆ get_normals()

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

Definition at line 423 of file fe_map.h.

424  { libmesh_assert(!calculations_started || calculate_dxyz);
425  calculate_dxyz = true; return normals; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::libmesh_assert(), and libMesh::FEMap::normals.

◆ get_phi_map() [1/2]

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

Definition at line 531 of file fe_map.h.

532  { libmesh_assert(!calculations_started || calculate_xyz);
533  calculate_xyz = true; return phi_map; }

References libMesh::FEMap::calculate_xyz, libMesh::FEMap::calculations_started, libMesh::libmesh_assert(), and libMesh::FEMap::phi_map.

◆ get_phi_map() [2/2]

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

Definition at line 388 of file fe_map.h.

389  { libmesh_assert(!calculations_started || calculate_xyz);
390  calculate_xyz = true; return phi_map; }

References libMesh::FEMap::calculate_xyz, libMesh::FEMap::calculations_started, libMesh::libmesh_assert(), and libMesh::FEMap::phi_map.

◆ get_psi() [1/2]

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

Definition at line 456 of file fe_map.h.

457  { return psi_map; }

References libMesh::FEMap::psi_map.

◆ get_psi() [2/2]

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

Definition at line 382 of file fe_map.h.

383  { return psi_map; }

References libMesh::FEMap::psi_map.

◆ get_tangents()

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

Definition at line 416 of file fe_map.h.

417  { libmesh_assert(!calculations_started || calculate_dxyz);
418  calculate_dxyz = true; return tangents; }

References libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculations_started, libMesh::libmesh_assert(), and libMesh::FEMap::tangents.

◆ get_xyz()

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

Definition at line 195 of file fe_map.h.

196  { libmesh_assert(!calculations_started || calculate_xyz);
197  calculate_xyz = true; return xyz; }

References libMesh::FEMap::calculate_xyz, libMesh::FEMap::calculations_started, libMesh::libmesh_assert(), and libMesh::FEMap::xyz.

◆ init_edge_shape_functions()

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

Same as before, but for an edge.

This is used for some projection operators.

Definition at line 510 of file fe_boundary.C.

512 {
513  // Start logging the shape function initialization
514  LOG_SCOPE("init_edge_shape_functions()", "FEMap");
515 
516  libmesh_assert(edge);
517 
518  // We're calculating now!
519  this->determine_calculations();
520 
521  // The element type and order to use in
522  // the map
523  const FEFamily mapping_family = FEMap::map_fe_type(*edge);
524  const Order mapping_order (edge->default_order());
525  const ElemType mapping_elem_type (edge->type());
526  const FEType map_fe_type(mapping_order, mapping_family);
527 
528  // The number of quadrature points.
529  const unsigned int n_qp = cast_int<unsigned int>(qp.size());
530 
531  const unsigned int n_mapping_shape_functions =
532  FEInterface::n_shape_functions(Dim, map_fe_type, mapping_elem_type);
533 
534  // resize the vectors to hold current data
535  // Psi are the shape functions used for the FE mapping
536  if (calculate_xyz)
537  this->psi_map.resize (n_mapping_shape_functions);
538  if (calculate_dxyz)
539  this->dpsidxi_map.resize (n_mapping_shape_functions);
540 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
541  if (calculate_d2xyz)
542  this->d2psidxi2_map.resize (n_mapping_shape_functions);
543 #endif
544 
545  FEInterface::shape_ptr shape_ptr =
546  FEInterface::shape_function(1, map_fe_type);
547 
548  FEInterface::shape_deriv_ptr shape_deriv_ptr =
549  FEInterface::shape_deriv_function(1, map_fe_type);
550 
551 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
552  FEInterface::shape_second_deriv_ptr shape_second_deriv_ptr =
553  FEInterface::shape_second_deriv_function(1, map_fe_type);
554 #endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
555 
556  for (unsigned int i=0; i<n_mapping_shape_functions; i++)
557  {
558  // Allocate space to store the values of the shape functions
559  // and their first and second derivatives at the quadrature points.
560  if (calculate_xyz)
561  this->psi_map[i].resize (n_qp);
562  if (calculate_dxyz)
563  this->dpsidxi_map[i].resize (n_qp);
564 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
565  if (calculate_d2xyz)
566  this->d2psidxi2_map[i].resize (n_qp);
567 #endif
568 
569  // Compute the value of mapping shape function i, and its first
570  // and second derivatives at quadrature point p
571  for (unsigned int p=0; p<n_qp; p++)
572  {
573  if (calculate_xyz)
574  this->psi_map[i][p] = shape_ptr (edge, mapping_order, i, qp[p], false);
575  if (calculate_dxyz)
576  this->dpsidxi_map[i][p] = shape_deriv_ptr (edge, mapping_order, i, 0, qp[p], false);
577 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
578  if (calculate_d2xyz)
579  this->d2psidxi2_map[i][p] = shape_second_deriv_ptr(edge, mapping_order, i, 0, qp[p], false);
580 #endif
581  }
582  }
583 }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculate_xyz, libMesh::FEMap::d2psidxi2_map, libMesh::Elem::default_order(), libMesh::FEMap::determine_calculations(), libMesh::FEMap::dpsidxi_map, libMesh::libmesh_assert(), libMesh::FEMap::map_fe_type(), libMesh::FEInterface::n_shape_functions(), libMesh::FEMap::psi_map, libMesh::FEInterface::shape_deriv_function(), libMesh::FEInterface::shape_function(), libMesh::FEInterface::shape_second_deriv_function(), and libMesh::Elem::type().

◆ init_face_shape_functions()

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

Initializes the reference to physical element map for a side.

This is used for boundary integration.

Definition at line 381 of file fe_boundary.C.

383 {
384  // Start logging the shape function initialization
385  LOG_SCOPE("init_face_shape_functions()", "FEMap");
386 
387  libmesh_assert(side);
388 
389  // We're calculating now!
390  this->determine_calculations();
391 
392  // The element type and order to use in
393  // the map
394  const FEFamily mapping_family = FEMap::map_fe_type(*side);
395  const Order mapping_order (side->default_order());
396  const ElemType mapping_elem_type (side->type());
397  const FEType map_fe_type(mapping_order, mapping_family);
398 
399  // The number of quadrature points.
400  const unsigned int n_qp = cast_int<unsigned int>(qp.size());
401 
402  const unsigned int n_mapping_shape_functions =
403  FEInterface::n_shape_functions(Dim, map_fe_type, mapping_elem_type);
404 
405  // resize the vectors to hold current data
406  // Psi are the shape functions used for the FE mapping
407  if (calculate_xyz)
408  this->psi_map.resize (n_mapping_shape_functions);
409 
410  if (Dim > 1)
411  {
412  if (calculate_dxyz)
413  this->dpsidxi_map.resize (n_mapping_shape_functions);
414 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
415  if (calculate_d2xyz)
416  this->d2psidxi2_map.resize (n_mapping_shape_functions);
417 #endif
418  }
419 
420  if (Dim == 3)
421  {
422  if (calculate_dxyz)
423  this->dpsideta_map.resize (n_mapping_shape_functions);
424 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
425  if (calculate_d2xyz)
426  {
427  this->d2psidxideta_map.resize (n_mapping_shape_functions);
428  this->d2psideta2_map.resize (n_mapping_shape_functions);
429  }
430 #endif
431  }
432 
433  FEInterface::shape_ptr shape_ptr =
434  FEInterface::shape_function(Dim-1, map_fe_type);
435 
436  FEInterface::shape_deriv_ptr shape_deriv_ptr =
437  FEInterface::shape_deriv_function(Dim-1, map_fe_type);
438 
439 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
440  FEInterface::shape_second_deriv_ptr shape_second_deriv_ptr =
441  FEInterface::shape_second_deriv_function(Dim-1, map_fe_type);
442 #endif
443 
444  for (unsigned int i=0; i<n_mapping_shape_functions; i++)
445  {
446  // Allocate space to store the values of the shape functions
447  // and their first and second derivatives at the quadrature points.
448  if (calculate_xyz)
449  this->psi_map[i].resize (n_qp);
450  if (Dim > 1)
451  {
452  if (calculate_dxyz)
453  this->dpsidxi_map[i].resize (n_qp);
454 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
455  if (calculate_d2xyz)
456  this->d2psidxi2_map[i].resize (n_qp);
457 #endif
458  }
459  if (Dim == 3)
460  {
461  if (calculate_dxyz)
462  this->dpsideta_map[i].resize (n_qp);
463 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
464  if (calculate_d2xyz)
465  {
466  this->d2psidxideta_map[i].resize (n_qp);
467  this->d2psideta2_map[i].resize (n_qp);
468  }
469 #endif
470  }
471 
472 
473  // Compute the value of mapping shape function i, and its first
474  // and second derivatives at quadrature point p
475  for (unsigned int p=0; p<n_qp; p++)
476  {
477  if (calculate_xyz)
478  this->psi_map[i][p] = shape_ptr (side, mapping_order, i, qp[p], false);
479  if (Dim > 1)
480  {
481  if (calculate_dxyz)
482  this->dpsidxi_map[i][p] = shape_deriv_ptr (side, mapping_order, i, 0, qp[p], false);
483 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
484  if (calculate_d2xyz)
485  this->d2psidxi2_map[i][p] = shape_second_deriv_ptr(side, mapping_order, i, 0, qp[p], false);
486 #endif
487  }
488  // libMesh::out << "this->d2psidxi2_map["<<i<<"][p]=" << d2psidxi2_map[i][p] << std::endl;
489 
490  // If we are in 3D, then our sides are 2D faces.
491  // For the second derivatives, we must also compute the cross
492  // derivative d^2() / dxi deta
493  if (Dim == 3)
494  {
495  if (calculate_dxyz)
496  this->dpsideta_map[i][p] = shape_deriv_ptr (side, mapping_order, i, 1, qp[p], false);
497 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
498  if (calculate_d2xyz)
499  {
500  this->d2psidxideta_map[i][p] = shape_second_deriv_ptr(side, mapping_order, i, 1, qp[p], false);
501  this->d2psideta2_map[i][p] = shape_second_deriv_ptr(side, mapping_order, i, 2, qp[p], false);
502  }
503 #endif
504  }
505  }
506  }
507 }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculate_xyz, libMesh::FEMap::d2psideta2_map, libMesh::FEMap::d2psidxi2_map, libMesh::FEMap::d2psidxideta_map, libMesh::Elem::default_order(), libMesh::FEMap::determine_calculations(), libMesh::FEMap::dpsideta_map, libMesh::FEMap::dpsidxi_map, libMesh::libmesh_assert(), libMesh::FEMap::map_fe_type(), libMesh::FEInterface::n_shape_functions(), libMesh::FEMap::psi_map, libMesh::FEInterface::shape_deriv_function(), libMesh::FEInterface::shape_function(), libMesh::FEInterface::shape_second_deriv_function(), and libMesh::Elem::type().

◆ init_reference_to_physical_map()

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

Definition at line 91 of file fe_map.C.

93 {
94  // Start logging the reference->physical map initialization
95  LOG_SCOPE("init_reference_to_physical_map()", "FEMap");
96 
97  // We're calculating now!
98  this->determine_calculations();
99 
100 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
101  if (elem->infinite())
102  {
103  //This mainly requires to change the FE<>-calls
104  // to FEInterface in this function.
105  libmesh_not_implemented();
106  }
107 #endif
108 
109  // The number of quadrature points.
110  const std::size_t n_qp = qp.size();
111 
112  // The element type and order to use in
113  // the map
114  const FEFamily mapping_family = FEMap::map_fe_type(*elem);
115  const Order mapping_order (elem->default_order());
116  const ElemType mapping_elem_type (elem->type());
117 
118  const FEType map_fe_type(mapping_order, mapping_family);
119 
120  // Number of shape functions used to construct the map
121  // (Lagrange shape functions are used for mapping)
122  const unsigned int n_mapping_shape_functions =
123  FEInterface::n_shape_functions (Dim, map_fe_type,
124  mapping_elem_type);
125 
126  if (calculate_xyz)
127  this->phi_map.resize (n_mapping_shape_functions);
128  if (Dim > 0)
129  {
130  if (calculate_dxyz)
131  this->dphidxi_map.resize (n_mapping_shape_functions);
132 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
133  if (calculate_d2xyz)
134  this->d2phidxi2_map.resize (n_mapping_shape_functions);
135 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
136  }
137 
138  if (Dim > 1)
139  {
140  if (calculate_dxyz)
141  this->dphideta_map.resize (n_mapping_shape_functions);
142 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
143  if (calculate_d2xyz)
144  {
145  this->d2phidxideta_map.resize (n_mapping_shape_functions);
146  this->d2phideta2_map.resize (n_mapping_shape_functions);
147  }
148 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
149  }
150 
151  if (Dim > 2)
152  {
153  if (calculate_dxyz)
154  this->dphidzeta_map.resize (n_mapping_shape_functions);
155 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
156  if (calculate_d2xyz)
157  {
158  this->d2phidxidzeta_map.resize (n_mapping_shape_functions);
159  this->d2phidetadzeta_map.resize (n_mapping_shape_functions);
160  this->d2phidzeta2_map.resize (n_mapping_shape_functions);
161  }
162 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
163  }
164 
165 
166  for (unsigned int i=0; i<n_mapping_shape_functions; i++)
167  {
168  if (calculate_xyz)
169  this->phi_map[i].resize (n_qp);
170  if (Dim > 0)
171  {
172  if (calculate_dxyz)
173  this->dphidxi_map[i].resize (n_qp);
174 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
175  if (calculate_d2xyz)
176  {
177  this->d2phidxi2_map[i].resize (n_qp);
178  if (Dim > 1)
179  {
180  this->d2phidxideta_map[i].resize (n_qp);
181  this->d2phideta2_map[i].resize (n_qp);
182  }
183  if (Dim > 2)
184  {
185  this->d2phidxidzeta_map[i].resize (n_qp);
186  this->d2phidetadzeta_map[i].resize (n_qp);
187  this->d2phidzeta2_map[i].resize (n_qp);
188  }
189  }
190 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
191 
192  if (Dim > 1 && calculate_dxyz)
193  this->dphideta_map[i].resize (n_qp);
194 
195  if (Dim > 2 && calculate_dxyz)
196  this->dphidzeta_map[i].resize (n_qp);
197  }
198  }
199 
200  // Optimize for the *linear* geometric elements case:
201  bool is_linear = elem->is_linear();
202 
203  FEInterface::shape_ptr shape_ptr =
204  FEInterface::shape_function(Dim, map_fe_type);
205 
206  FEInterface::shape_deriv_ptr shape_deriv_ptr =
207  FEInterface::shape_deriv_function(Dim, map_fe_type);
208 
209 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
210  FEInterface::shape_second_deriv_ptr shape_second_deriv_ptr =
211  FEInterface::shape_second_deriv_function(Dim, map_fe_type);
212 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
213 
214  switch (Dim)
215  {
216  //------------------------------------------------------------
217  // 0D
218  case 0:
219  {
220  if (calculate_xyz)
221  for (unsigned int i=0; i<n_mapping_shape_functions; i++)
222  for (std::size_t p=0; p<n_qp; p++)
223  this->phi_map[i][p] =
224  shape_ptr(elem, mapping_order, i, qp[p], false);
225 
226  break;
227  }
228 
229  //------------------------------------------------------------
230  // 1D
231  case 1:
232  {
233  // Compute the value of the mapping shape function i at quadrature point p
234  // (Lagrange shape functions are used for mapping)
235  if (is_linear)
236  {
237  for (unsigned int i=0; i<n_mapping_shape_functions; i++)
238  {
239  if (calculate_xyz)
240  this->phi_map[i][0] =
241  shape_ptr(elem, mapping_order, i, qp[0], false);
242 
243  if (calculate_dxyz)
244  this->dphidxi_map[i][0] =
245  shape_deriv_ptr(elem, mapping_order, i, 0, qp[0], false);
246 
247 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
248  if (calculate_d2xyz)
249  this->d2phidxi2_map[i][0] =
250  shape_second_deriv_ptr(elem, mapping_order, i, 0, qp[0], false);
251 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
252  for (std::size_t p=1; p<n_qp; p++)
253  {
254  if (calculate_xyz)
255  this->phi_map[i][p] =
256  shape_ptr(elem, mapping_order, i, qp[p], false);
257  if (calculate_dxyz)
258  this->dphidxi_map[i][p] = this->dphidxi_map[i][0];
259 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
260  if (calculate_d2xyz)
261  this->d2phidxi2_map[i][p] = this->d2phidxi2_map[i][0];
262 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
263  }
264  }
265  }
266  else
267  for (unsigned int i=0; i<n_mapping_shape_functions; i++)
268  for (std::size_t p=0; p<n_qp; p++)
269  {
270  if (calculate_xyz)
271  this->phi_map[i][p] =
272  shape_ptr (elem, mapping_order, i, qp[p], false);
273  if (calculate_dxyz)
274  this->dphidxi_map[i][p] = shape_deriv_ptr (elem, mapping_order, i, 0, qp[p], false);
275 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
276  if (calculate_d2xyz)
277  this->d2phidxi2_map[i][p] = shape_second_deriv_ptr (elem, mapping_order, i, 0, qp[p], false);
278 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
279  }
280 
281  break;
282  }
283  //------------------------------------------------------------
284  // 2D
285  case 2:
286  {
287  // Compute the value of the mapping shape function i at quadrature point p
288  // (Lagrange shape functions are used for mapping)
289  if (is_linear)
290  {
291  for (unsigned int i=0; i<n_mapping_shape_functions; i++)
292  {
293  if (calculate_xyz)
294  this->phi_map[i][0] =
295  shape_ptr (elem, mapping_order, i, qp[0], false);
296  if (calculate_dxyz)
297  {
298  this->dphidxi_map[i][0] = shape_deriv_ptr (elem, mapping_order, i, 0, qp[0], false);
299  this->dphideta_map[i][0] = shape_deriv_ptr (elem, mapping_order, i, 1, qp[0], false);
300  }
301 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
302  if (calculate_d2xyz)
303  {
304  this->d2phidxi2_map[i][0] = shape_second_deriv_ptr (elem, mapping_order, i, 0, qp[0], false);
305  this->d2phidxideta_map[i][0] = shape_second_deriv_ptr (elem, mapping_order, i, 1, qp[0], false);
306  this->d2phideta2_map[i][0] = shape_second_deriv_ptr (elem, mapping_order, i, 2, qp[0], false);
307  }
308 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
309  for (std::size_t p=1; p<n_qp; p++)
310  {
311  if (calculate_xyz)
312  this->phi_map[i][p] =
313  shape_ptr (elem, mapping_order, i, qp[p], false);
314  if (calculate_dxyz)
315  {
316  this->dphidxi_map[i][p] = this->dphidxi_map[i][0];
317  this->dphideta_map[i][p] = this->dphideta_map[i][0];
318  }
319 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
320  if (calculate_d2xyz)
321  {
322  this->d2phidxi2_map[i][p] = this->d2phidxi2_map[i][0];
323  this->d2phidxideta_map[i][p] = this->d2phidxideta_map[i][0];
324  this->d2phideta2_map[i][p] = this->d2phideta2_map[i][0];
325  }
326 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
327  }
328  }
329  }
330  else
331  for (unsigned int i=0; i<n_mapping_shape_functions; i++)
332  for (std::size_t p=0; p<n_qp; p++)
333  {
334  if (calculate_xyz)
335  this->phi_map[i][p] =
336  shape_ptr(elem, mapping_order, i, qp[p], false);
337  if (calculate_dxyz)
338  {
339  this->dphidxi_map[i][p] = shape_deriv_ptr (elem, mapping_order, i, 0, qp[p], false);
340  this->dphideta_map[i][p] = shape_deriv_ptr (elem, mapping_order, i, 1, qp[p], false);
341  }
342 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
343  if (calculate_d2xyz)
344  {
345  this->d2phidxi2_map[i][p] = shape_second_deriv_ptr (elem, mapping_order, i, 0, qp[p], false);
346  this->d2phidxideta_map[i][p] = shape_second_deriv_ptr (elem, mapping_order, i, 1, qp[p], false);
347  this->d2phideta2_map[i][p] = shape_second_deriv_ptr (elem, mapping_order, i, 2, qp[p], false);
348  }
349 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
350  }
351 
352  break;
353  }
354 
355  //------------------------------------------------------------
356  // 3D
357  case 3:
358  {
359  // Compute the value of the mapping shape function i at quadrature point p
360  // (Lagrange shape functions are used for mapping)
361  if (is_linear)
362  {
363  for (unsigned int i=0; i<n_mapping_shape_functions; i++)
364  {
365  if (calculate_xyz)
366  this->phi_map[i][0] =
367  shape_ptr (elem, mapping_order, i, qp[0], false);
368  if (calculate_dxyz)
369  {
370  this->dphidxi_map[i][0] = shape_deriv_ptr (elem, mapping_order, i, 0, qp[0], false);
371  this->dphideta_map[i][0] = shape_deriv_ptr (elem, mapping_order, i, 1, qp[0], false);
372  this->dphidzeta_map[i][0] = shape_deriv_ptr (elem, mapping_order, i, 2, qp[0], false);
373  }
374 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
375  if (calculate_d2xyz)
376  {
377  this->d2phidxi2_map[i][0] = shape_second_deriv_ptr (elem, mapping_order, i, 0, qp[0], false);
378  this->d2phidxideta_map[i][0] = shape_second_deriv_ptr (elem, mapping_order, i, 1, qp[0], false);
379  this->d2phideta2_map[i][0] = shape_second_deriv_ptr (elem, mapping_order, i, 2, qp[0], false);
380  this->d2phidxidzeta_map[i][0] = shape_second_deriv_ptr (elem, mapping_order, i, 3, qp[0], false);
381  this->d2phidetadzeta_map[i][0] = shape_second_deriv_ptr (elem, mapping_order, i, 4, qp[0], false);
382  this->d2phidzeta2_map[i][0] = shape_second_deriv_ptr (elem, mapping_order, i, 5, qp[0], false);
383  }
384 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
385  for (std::size_t p=1; p<n_qp; p++)
386  {
387  if (calculate_xyz)
388  this->phi_map[i][p] =
389  shape_ptr (elem, mapping_order, i, qp[p], false);
390  if (calculate_dxyz)
391  {
392  this->dphidxi_map[i][p] = this->dphidxi_map[i][0];
393  this->dphideta_map[i][p] = this->dphideta_map[i][0];
394  this->dphidzeta_map[i][p] = this->dphidzeta_map[i][0];
395  }
396 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
397  if (calculate_d2xyz)
398  {
399  this->d2phidxi2_map[i][p] = this->d2phidxi2_map[i][0];
400  this->d2phidxideta_map[i][p] = this->d2phidxideta_map[i][0];
401  this->d2phideta2_map[i][p] = this->d2phideta2_map[i][0];
402  this->d2phidxidzeta_map[i][p] = this->d2phidxidzeta_map[i][0];
403  this->d2phidetadzeta_map[i][p] = this->d2phidetadzeta_map[i][0];
404  this->d2phidzeta2_map[i][p] = this->d2phidzeta2_map[i][0];
405  }
406 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
407  }
408  }
409  }
410  else
411  for (unsigned int i=0; i<n_mapping_shape_functions; i++)
412  for (std::size_t p=0; p<n_qp; p++)
413  {
414  if (calculate_xyz)
415  this->phi_map[i][p] =
416  shape_ptr(elem, mapping_order, i, qp[p], false);
417  if (calculate_dxyz)
418  {
419  this->dphidxi_map[i][p] = shape_deriv_ptr (elem, mapping_order, i, 0, qp[p], false);
420  this->dphideta_map[i][p] = shape_deriv_ptr (elem, mapping_order, i, 1, qp[p], false);
421  this->dphidzeta_map[i][p] = shape_deriv_ptr (elem, mapping_order, i, 2, qp[p], false);
422  }
423 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
424  if (calculate_d2xyz)
425  {
426  this->d2phidxi2_map[i][p] = shape_second_deriv_ptr (elem, mapping_order, i, 0, qp[p], false);
427  this->d2phidxideta_map[i][p] = shape_second_deriv_ptr (elem, mapping_order, i, 1, qp[p], false);
428  this->d2phideta2_map[i][p] = shape_second_deriv_ptr (elem, mapping_order, i, 2, qp[p], false);
429  this->d2phidxidzeta_map[i][p] = shape_second_deriv_ptr (elem, mapping_order, i, 3, qp[p], false);
430  this->d2phidetadzeta_map[i][p] = shape_second_deriv_ptr (elem, mapping_order, i, 4, qp[p], false);
431  this->d2phidzeta2_map[i][p] = shape_second_deriv_ptr (elem, mapping_order, i, 5, qp[p], false);
432  }
433 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
434  }
435 
436  break;
437  }
438 
439  default:
440  libmesh_error_msg("Invalid Dim = " << Dim);
441  }
442 }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculate_xyz, libMesh::FEMap::d2phideta2_map, libMesh::FEMap::d2phidetadzeta_map, libMesh::FEMap::d2phidxi2_map, libMesh::FEMap::d2phidxideta_map, libMesh::FEMap::d2phidxidzeta_map, libMesh::FEMap::d2phidzeta2_map, libMesh::Elem::default_order(), libMesh::FEMap::determine_calculations(), libMesh::FEMap::dphideta_map, libMesh::FEMap::dphidxi_map, libMesh::FEMap::dphidzeta_map, libMesh::Elem::infinite(), libMesh::Elem::is_linear(), libMesh::FEMap::map_fe_type(), libMesh::FEInterface::n_shape_functions(), libMesh::FEMap::phi_map, libMesh::FEInterface::shape_deriv_function(), libMesh::FEInterface::shape_function(), libMesh::FEInterface::shape_second_deriv_function(), and libMesh::Elem::type().

◆ inverse_map() [1/2]

Point libMesh::FEMap::inverse_map ( const unsigned int  dim,
const Elem *  elem,
const Point &  p,
const Real  tolerance = TOLERANCE,
const bool  secure = true 
)
staticinherited
Returns
The location (on the reference element) of the point p located in physical space. This function requires inverting the (possibly nonlinear) transformation map, so it is not trivial. The optional parameter tolerance defines how close is "good enough." The map inversion iteration computes the sequence \( \{ p_n \} \), and the iteration is terminated when \( \|p - p_n\| < \mbox{\texttt{tolerance}} \) The parameter secure (always assumed false in non-debug mode) switches on integrity-checks on the mapped points.

Definition at line 1622 of file fe_map.C.

1627 {
1628  libmesh_assert(elem);
1629  libmesh_assert_greater_equal (tolerance, 0.);
1630 
1631 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
1632  if (elem->infinite())
1633  return InfFEMap::inverse_map(dim, elem, physical_point, tolerance,
1634  secure);
1635 #endif
1636 
1637  // Start logging the map inversion.
1638  LOG_SCOPE("inverse_map()", "FEMap");
1639 
1640  // How much did the point on the reference
1641  // element change by in this Newton step?
1642  Real inverse_map_error = 0.;
1643 
1644  // The point on the reference element. This is
1645  // the "initial guess" for Newton's method. The
1646  // centroid seems like a good idea, but computing
1647  // it is a little more intensive than, say taking
1648  // the zero point.
1649  //
1650  // Convergence should be insensitive of this choice
1651  // for "good" elements.
1652  Point p; // the zero point. No computation required
1653 
1654  // The number of iterations in the map inversion process.
1655  unsigned int cnt = 0;
1656 
1657  // The number of iterations after which we give up and declare
1658  // divergence
1659  const unsigned int max_cnt = 10;
1660 
1661  // The distance (in master element space) beyond which we give up
1662  // and declare divergence. This is no longer used...
1663  // Real max_step_length = 4.;
1664 
1665 
1666 
1667  // Newton iteration loop.
1668  do
1669  {
1670  // Where our current iterate \p p maps to.
1671  const Point physical_guess = map(dim, elem, p);
1672 
1673  // How far our current iterate is from the actual point.
1674  const Point delta = physical_point - physical_guess;
1675 
1676  // Increment in current iterate \p p, will be computed.
1677  Point dp;
1678 
1679 
1680  // The form of the map and how we invert it depends
1681  // on the dimension that we are in.
1682  switch (dim)
1683  {
1684  // ------------------------------------------------------------------
1685  // 0D map inversion is trivial
1686  case 0:
1687  {
1688  break;
1689  }
1690 
1691  // ------------------------------------------------------------------
1692  // 1D map inversion
1693  //
1694  // Here we find the point on a 1D reference element that maps to
1695  // the point \p physical_point in the domain. This is a bit tricky
1696  // since we do not want to assume that the point \p physical_point
1697  // is also in a 1D domain. In particular, this method might get
1698  // called on the edge of a 3D element, in which case
1699  // \p physical_point actually lives in 3D.
1700  case 1:
1701  {
1702  const Point dxi = map_deriv (dim, elem, 0, p);
1703 
1704  // Newton's method in this case looks like
1705  //
1706  // {X} - {X_n} = [J]*dp
1707  //
1708  // Where {X}, {X_n} are 3x1 vectors, [J] is a 3x1 matrix
1709  // d(x,y,z)/dxi, and we seek dp, a scalar. Since the above
1710  // system is either overdetermined or rank-deficient, we will
1711  // solve the normal equations for this system
1712  //
1713  // [J]^T ({X} - {X_n}) = [J]^T [J] {dp}
1714  //
1715  // which involves the trivial inversion of the scalar
1716  // G = [J]^T [J]
1717  const Real G = dxi*dxi;
1718 
1719  if (secure)
1720  libmesh_assert_greater (G, 0.);
1721 
1722  const Real Ginv = 1./G;
1723 
1724  const Real dxidelta = dxi*delta;
1725 
1726  dp(0) = Ginv*dxidelta;
1727 
1728  // No master elements have radius > 4, but sometimes we
1729  // can take a step that big while still converging
1730  // if (secure)
1731  // libmesh_assert_less (dp.size(), max_step_length);
1732 
1733  break;
1734  }
1735 
1736 
1737 
1738  // ------------------------------------------------------------------
1739  // 2D map inversion
1740  //
1741  // Here we find the point on a 2D reference element that maps to
1742  // the point \p physical_point in the domain. This is a bit tricky
1743  // since we do not want to assume that the point \p physical_point
1744  // is also in a 2D domain. In particular, this method might get
1745  // called on the face of a 3D element, in which case
1746  // \p physical_point actually lives in 3D.
1747  case 2:
1748  {
1749  const Point dxi = map_deriv (dim, elem, 0, p);
1750  const Point deta = map_deriv (dim, elem, 1, p);
1751 
1752  // Newton's method in this case looks like
1753  //
1754  // {X} - {X_n} = [J]*{dp}
1755  //
1756  // Where {X}, {X_n} are 3x1 vectors, [J] is a 3x2 matrix
1757  // d(x,y,z)/d(xi,eta), and we seek {dp}, a 2x1 vector. Since
1758  // the above system is either over-determined or rank-deficient,
1759  // we will solve the normal equations for this system
1760  //
1761  // [J]^T ({X} - {X_n}) = [J]^T [J] {dp}
1762  //
1763  // which involves the inversion of the 2x2 matrix
1764  // [G] = [J]^T [J]
1765  const Real
1766  G11 = dxi*dxi, G12 = dxi*deta,
1767  G21 = dxi*deta, G22 = deta*deta;
1768 
1769 
1770  const Real det = (G11*G22 - G12*G21);
1771 
1772  if (secure)
1773  libmesh_assert_not_equal_to (det, 0.);
1774 
1775  const Real inv_det = 1./det;
1776 
1777  const Real
1778  Ginv11 = G22*inv_det,
1779  Ginv12 = -G12*inv_det,
1780 
1781  Ginv21 = -G21*inv_det,
1782  Ginv22 = G11*inv_det;
1783 
1784 
1785  const Real dxidelta = dxi*delta;
1786  const Real detadelta = deta*delta;
1787 
1788  dp(0) = (Ginv11*dxidelta + Ginv12*detadelta);
1789  dp(1) = (Ginv21*dxidelta + Ginv22*detadelta);
1790 
1791  // No master elements have radius > 4, but sometimes we
1792  // can take a step that big while still converging
1793  // if (secure)
1794  // libmesh_assert_less (dp.size(), max_step_length);
1795 
1796  break;
1797  }
1798 
1799 
1800 
1801  // ------------------------------------------------------------------
1802  // 3D map inversion
1803  //
1804  // Here we find the point in a 3D reference element that maps to
1805  // the point \p physical_point in a 3D domain. Nothing special
1806  // has to happen here, since (unless the map is singular because
1807  // you have a BAD element) the map will be invertible and we can
1808  // apply Newton's method directly.
1809  case 3:
1810  {
1811  const Point dxi = map_deriv (dim, elem, 0, p);
1812  const Point deta = map_deriv (dim, elem, 1, p);
1813  const Point dzeta = map_deriv (dim, elem, 2, p);
1814 
1815  // Newton's method in this case looks like
1816  //
1817  // {X} = {X_n} + [J]*{dp}
1818  //
1819  // Where {X}, {X_n} are 3x1 vectors, [J] is a 3x3 matrix
1820  // d(x,y,z)/d(xi,eta,zeta), and we seek {dp}, a 3x1 vector.
1821  // Since the above system is nonsingular for invertible maps
1822  // we will solve
1823  //
1824  // {dp} = [J]^-1 ({X} - {X_n})
1825  //
1826  // which involves the inversion of the 3x3 matrix [J]
1827  libmesh_try
1828  {
1829  RealTensorValue(dxi(0), deta(0), dzeta(0),
1830  dxi(1), deta(1), dzeta(1),
1831  dxi(2), deta(2), dzeta(2)).solve(delta, dp);
1832  }
1833  libmesh_catch (ConvergenceFailure &)
1834  {
1835  // We encountered a singular Jacobian. The value of
1836  // dp is zero, since it was never changed during the
1837  // call to RealTensorValue::solve(). We don't want to
1838  // continue iterating until max_cnt since there is no
1839  // update to the Newton iterate, and we don't want to
1840  // print the inverse_map_error value since it will
1841  // confusingly be 0. Therefore, in the secure case we
1842  // need to throw an error message while in the !secure
1843  // case we can just return a far away point.
1844  if (secure)
1845  {
1846  libMesh::err << "ERROR: Newton scheme encountered a singular Jacobian in element: "
1847  << elem->id()
1848  << std::endl;
1849 
1850  elem->print_info(libMesh::err);
1851 
1852  libmesh_error_msg("Exiting...");
1853  }
1854  else
1855  {
1856  for (unsigned int i=0; i != dim; ++i)
1857  p(i) = 1e6;
1858  return p;
1859  }
1860  }
1861 
1862  // No master elements have radius > 4, but sometimes we
1863  // can take a step that big while still converging
1864  // if (secure)
1865  // libmesh_assert_less (dp.size(), max_step_length);
1866 
1867  break;
1868  }
1869 
1870 
1871  // Some other dimension?
1872  default:
1873  libmesh_error_msg("Invalid dim = " << dim);
1874  } // end switch(Dim), dp now computed
1875 
1876 
1877 
1878  // ||P_n+1 - P_n||
1879  inverse_map_error = dp.norm();
1880 
1881  // P_n+1 = P_n + dp
1882  p.add (dp);
1883 
1884  // Increment the iteration count.
1885  cnt++;
1886 
1887  // Watch for divergence of Newton's
1888  // method. Here's how it goes:
1889  // (1) For good elements, we expect convergence in 10
1890  // iterations, with no too-large steps.
1891  // - If called with (secure == true) and we have not yet converged
1892  // print out a warning message.
1893  // - If called with (secure == true) and we have not converged in
1894  // 20 iterations abort
1895  // (2) This method may be called in cases when the target point is not
1896  // inside the element and we have no business expecting convergence.
1897  // For these cases if we have not converged in 10 iterations forget
1898  // about it.
1899  if (cnt > max_cnt)
1900  {
1901  // Warn about divergence when secure is true - this
1902  // shouldn't happen
1903  if (secure)
1904  {
1905  // Print every time in devel/dbg modes
1906 #ifndef NDEBUG
1907  libmesh_here();
1908  libMesh::err << "WARNING: Newton scheme has not converged in "
1909  << cnt << " iterations:" << std::endl
1910  << " physical_point="
1911  << physical_point
1912  << " physical_guess="
1913  << physical_guess
1914  << " dp="
1915  << dp
1916  << " p="
1917  << p
1918  << " error=" << inverse_map_error
1919  << " in element " << elem->id()
1920  << std::endl;
1921 
1922  elem->print_info(libMesh::err);
1923 #else
1924  // In optimized mode, just print once that an inverse_map() call
1925  // had trouble converging its Newton iteration.
1926  libmesh_do_once(libMesh::err << "WARNING: At least one element took more than "
1927  << max_cnt
1928  << " iterations to converge in inverse_map()...\n"
1929  << "Rerun in devel/dbg mode for more details."
1930  << std::endl;);
1931 
1932 #endif // NDEBUG
1933 
1934  if (cnt > 2*max_cnt)
1935  {
1936  libMesh::err << "ERROR: Newton scheme FAILED to converge in "
1937  << cnt
1938  << " iterations in element "
1939  << elem->id()
1940  << " for physical point = "
1941  << physical_point
1942  << std::endl;
1943 
1944  elem->print_info(libMesh::err);
1945 
1946  libmesh_error_msg("Exiting...");
1947  }
1948  }
1949  // Return a far off point when secure is false - this
1950  // should only happen when we're trying to map a point
1951  // that's outside the element
1952  else
1953  {
1954  for (unsigned int i=0; i != dim; ++i)
1955  p(i) = 1e6;
1956 
1957  return p;
1958  }
1959  }
1960  }
1961  while (inverse_map_error > tolerance);
1962 
1963 
1964 
1965  // If we are in debug mode do two sanity checks.
1966 #ifdef DEBUG
1967 
1968  if (secure)
1969  {
1970  // Make sure the point \p p on the reference element actually
1971  // does map to the point \p physical_point within a tolerance.
1972 
1973  const Point check = map (dim, elem, p);
1974  const Point diff = physical_point - check;
1975 
1976  if (diff.norm() > tolerance)
1977  {
1978  libmesh_here();
1979  libMesh::err << "WARNING: diff is "
1980  << diff.norm()
1981  << std::endl
1982  << " point="
1983  << physical_point;
1984  libMesh::err << " local=" << check;
1985  libMesh::err << " lref= " << p;
1986 
1987  elem->print_info(libMesh::err);
1988  }
1989 
1990  // Make sure the point \p p on the reference element actually
1991  // is
1992 
1993  if (!FEAbstract::on_reference_element(p, elem->type(), 2*tolerance))
1994  {
1995  libmesh_here();
1996  libMesh::err << "WARNING: inverse_map of physical point "
1997  << physical_point
1998  << " is not on element." << '\n';
1999  elem->print_info(libMesh::err);
2000  }
2001  }
2002 
2003 #endif
2004 
2005  return p;
2006 }

References libMesh::TypeVector< T >::add(), dim, libMesh::err, libMesh::DofObject::id(), libMesh::Elem::infinite(), libMesh::InfFEMap::inverse_map(), libMesh::libmesh_assert(), libMesh::FEMap::map(), libMesh::FEMap::map_deriv(), libMesh::TypeVector< T >::norm(), libMesh::FEAbstract::on_reference_element(), libMesh::Elem::print_info(), libMesh::Real, and libMesh::Elem::type().

Referenced by libMesh::HPCoarsenTest::add_projection(), assemble_ellipticdg(), assemble_poisson(), libMesh::FEMContext::build_new_fe(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::FEMap::compute_face_map(), compute_jacobian(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), compute_residual(), libMesh::MeshFunction::discontinuous_gradient(), libMesh::MeshFunction::discontinuous_value(), libMesh::FE< Dim, LAGRANGE_VEC >::edge_reinit(), libMesh::DTKEvaluator::evaluate(), libMesh::MeshFunction::gradient(), libMesh::MeshFunction::hessian(), libMesh::InfFEMap::inverse_map(), libMesh::FEMap::inverse_map(), libMesh::FE< Dim, LAGRANGE_VEC >::inverse_map(), libMesh::DGFEMContext::neighbor_side_fe_reinit(), libMesh::MeshFunction::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectEdges::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectInteriors::operator()(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::Elem::point_test(), libMesh::System::point_value(), libMesh::JumpErrorEstimator::reinit_sides(), libMesh::HPCoarsenTest::select_refinement(), NavierSystem::side_constraint(), FETest< order, family, elem_type >::testGradU(), FETest< order, family, elem_type >::testGradUComp(), and FETest< order, family, elem_type >::testU().

◆ inverse_map() [2/2]

void libMesh::FEMap::inverse_map ( unsigned int  dim,
const Elem *  elem,
const std::vector< Point > &  physical_points,
std::vector< Point > &  reference_points,
const Real  tolerance = TOLERANCE,
const bool  secure = true 
)
staticinherited

Takes a number points in physical space (in the physical_points vector) and finds their location on the reference element for the input element elem.

The values on the reference element are returned in the vector reference_points. The optional parameter tolerance defines how close is "good enough." The map inversion iteration computes the sequence \( \{ p_n \} \), and the iteration is terminated when \( \|p - p_n\| < \mbox{\texttt{tolerance}} \) The parameter secure (always assumed false in non-debug mode) switches on integrity-checks on the mapped points.

Definition at line 2010 of file fe_map.C.

2016 {
2017 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
2018  if (elem->infinite())
2019  {
2020  InfFEMap::inverse_map(dim, elem, physical_points, reference_points, tolerance, secure);
2021  return;
2022  // libmesh_not_implemented();
2023  }
2024 #endif
2025 
2026  // The number of points to find the
2027  // inverse map of
2028  const std::size_t n_points = physical_points.size();
2029 
2030  // Resize the vector to hold the points
2031  // on the reference element
2032  reference_points.resize(n_points);
2033 
2034  // Find the coordinates on the reference
2035  // element of each point in physical space
2036  for (std::size_t p=0; p<n_points; p++)
2037  reference_points[p] =
2038  inverse_map (dim, elem, physical_points[p], tolerance, secure);
2039 }

References dim, libMesh::Elem::infinite(), libMesh::InfFEMap::inverse_map(), and libMesh::FEMap::inverse_map().

◆ map()

Point libMesh::FEMap::map ( const unsigned int  dim,
const Elem *  elem,
const Point &  reference_point 
)
staticinherited
Returns
The location (in physical space) of the point p located on the reference element.

Definition at line 2043 of file fe_map.C.

2046 {
2047  libmesh_assert(elem);
2048 
2049 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
2050  if (elem->infinite())
2051  return InfFEMap::map(dim, elem, reference_point);
2052 #endif
2053 
2054  Point p;
2055 
2056  const FEFamily mapping_family = FEMap::map_fe_type(*elem);
2057  const ElemType type = elem->type();
2058  const Order order = elem->default_order();
2059  const FEType fe_type (order, mapping_family);
2060 
2061  const unsigned int n_sf = FEInterface::n_shape_functions(dim, fe_type, type);
2062 
2063  FEInterface::shape_ptr shape_ptr =
2064  FEInterface::shape_function(dim, fe_type);
2065 
2066  // Lagrange basis functions are used for mapping
2067  for (unsigned int i=0; i<n_sf; i++)
2068  p.add_scaled (elem->point(i),
2069  shape_ptr(elem, order, i, reference_point, false));
2070 
2071  return p;
2072 }

References libMesh::TypeVector< T >::add_scaled(), libMesh::Elem::default_order(), dim, libMesh::Elem::infinite(), libMesh::libmesh_assert(), libMesh::InfFEMap::map(), libMesh::FEMap::map_fe_type(), libMesh::FEInterface::n_shape_functions(), libMesh::Elem::point(), libMesh::FEInterface::shape_function(), and libMesh::Elem::type().

Referenced by libMesh::FEMap::inverse_map(), libMesh::InfFEMap::map(), libMesh::FE< Dim, LAGRANGE_VEC >::map(), and libMesh::Elem::point_test().

◆ map_deriv()

Point libMesh::FEMap::map_deriv ( const unsigned int  dim,
const Elem *  elem,
const unsigned int  j,
const Point &  reference_point 
)
staticinherited
Returns
component j of d(xyz)/d(xi eta zeta) (in physical space) of the point p located on the reference element.

Definition at line 2076 of file fe_map.C.

2080 {
2081  libmesh_assert(elem);
2082 
2083 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
2084  if (elem->infinite())
2085  libmesh_not_implemented();
2086 #endif
2087 
2088  Point p;
2089 
2090  const FEFamily mapping_family = FEMap::map_fe_type(*elem);
2091  const ElemType type = elem->type();
2092  const Order order = elem->default_order();
2093  const FEType fe_type (order, mapping_family);
2094  const unsigned int n_sf = FEInterface::n_shape_functions(dim, fe_type, type);
2095 
2096  FEInterface::shape_deriv_ptr shape_deriv_ptr =
2097  FEInterface::shape_deriv_function(dim, fe_type);
2098 
2099  // Lagrange basis functions are used for mapping
2100  for (unsigned int i=0; i<n_sf; i++)
2101  p.add_scaled (elem->point(i),
2102  shape_deriv_ptr(elem, order, i, j, reference_point,
2103  false));
2104 
2105  return p;
2106 }

References libMesh::TypeVector< T >::add_scaled(), libMesh::Elem::default_order(), dim, libMesh::Elem::infinite(), libMesh::libmesh_assert(), libMesh::FEMap::map_fe_type(), libMesh::FEInterface::n_shape_functions(), libMesh::Elem::point(), libMesh::FEInterface::shape_deriv_function(), and libMesh::Elem::type().

Referenced by libMesh::FEMap::compute_face_map(), libMesh::FEMap::inverse_map(), libMesh::FE< Dim, LAGRANGE_VEC >::map_eta(), libMesh::FE< Dim, LAGRANGE_VEC >::map_xi(), and libMesh::FE< Dim, LAGRANGE_VEC >::map_zeta().

◆ map_fe_type()

FEFamily libMesh::FEMap::map_fe_type ( const Elem &  elem)
inlinestaticinherited

Definition at line 47 of file fe_map.C.

48 {
49  switch (elem.mapping_type())
50  {
51  case RATIONAL_BERNSTEIN_MAP:
52  return RATIONAL_BERNSTEIN;
53  case LAGRANGE_MAP:
54  return LAGRANGE;
55  default:
56  libmesh_error_msg("Unknown mapping type " << elem.mapping_type());
57  }
58  return LAGRANGE;
59 }

References libMesh::LAGRANGE, libMesh::LAGRANGE_MAP, libMesh::Elem::mapping_type(), libMesh::RATIONAL_BERNSTEIN, and libMesh::RATIONAL_BERNSTEIN_MAP.

Referenced by libMesh::FEMContext::_do_elem_position_set(), libMesh::FEMap::compute_face_map(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEMContext::elem_position_get(), libMesh::FEMap::init_edge_shape_functions(), libMesh::FEMap::init_face_shape_functions(), libMesh::FEMap::init_reference_to_physical_map(), libMesh::FEMap::map(), libMesh::FEMap::map_deriv(), and libMesh::Elem::volume().

◆ print_JxW()

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

Prints the Jacobian times the weight for each quadrature point.

Definition at line 1486 of file fe_map.C.

1487 {
1488  for (auto i : index_range(JxW))
1489  os << " [" << i << "]: " << JxW[i] << std::endl;
1490 }

References libMesh::index_range(), and libMesh::FEMap::JxW.

◆ print_xyz()

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

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

Definition at line 1494 of file fe_map.C.

1495 {
1496  for (auto i : index_range(xyz))
1497  os << " [" << i << "]: " << xyz[i];
1498 }

References libMesh::index_range(), and libMesh::FEMap::xyz.

◆ resize_quadrature_map_vectors()

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

A utility function for use by compute_*_map.

Definition at line 1196 of file fe_map.C.

1197 {
1198  // We're calculating now!
1199  this->determine_calculations();
1200 
1201  // Resize the vectors to hold data at the quadrature points
1202  if (calculate_xyz)
1203  xyz.resize(n_qp);
1204  if (calculate_dxyz)
1205  {
1206  dxyzdxi_map.resize(n_qp);
1207  dxidx_map.resize(n_qp);
1208  dxidy_map.resize(n_qp); // 1D element may live in 2D ...
1209  dxidz_map.resize(n_qp); // ... or 3D
1210  }
1211 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1212  if (calculate_d2xyz)
1213  {
1214  d2xyzdxi2_map.resize(n_qp);
1215 
1216  // Inverse map second derivatives
1217  d2xidxyz2_map.resize(n_qp);
1218  for (auto i : index_range(d2xidxyz2_map))
1219  d2xidxyz2_map[i].assign(6, 0.);
1220  }
1221 #endif
1222  if (dim > 1)
1223  {
1224  if (calculate_dxyz)
1225  {
1226  dxyzdeta_map.resize(n_qp);
1227  detadx_map.resize(n_qp);
1228  detady_map.resize(n_qp);
1229  detadz_map.resize(n_qp);
1230  }
1231 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1232  if (calculate_d2xyz)
1233  {
1234  d2xyzdxideta_map.resize(n_qp);
1235  d2xyzdeta2_map.resize(n_qp);
1236 
1237  // Inverse map second derivatives
1238  d2etadxyz2_map.resize(n_qp);
1239  for (auto i : index_range(d2etadxyz2_map))
1240  d2etadxyz2_map[i].assign(6, 0.);
1241  }
1242 #endif
1243  if (dim > 2)
1244  {
1245  if (calculate_dxyz)
1246  {
1247  dxyzdzeta_map.resize (n_qp);
1248  dzetadx_map.resize (n_qp);
1249  dzetady_map.resize (n_qp);
1250  dzetadz_map.resize (n_qp);
1251  }
1252 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
1253  if (calculate_d2xyz)
1254  {
1255  d2xyzdxidzeta_map.resize(n_qp);
1256  d2xyzdetadzeta_map.resize(n_qp);
1257  d2xyzdzeta2_map.resize(n_qp);
1258 
1259  // Inverse map second derivatives
1260  d2zetadxyz2_map.resize(n_qp);
1261  for (auto i : index_range(d2zetadxyz2_map))
1262  d2zetadxyz2_map[i].assign(6, 0.);
1263  }
1264 #endif
1265  }
1266  }
1267 
1268  if (calculate_dxyz)
1269  {
1270  jac.resize(n_qp);
1271  JxW.resize(n_qp);
1272  }
1273 }

References libMesh::FEMap::calculate_d2xyz, libMesh::FEMap::calculate_dxyz, libMesh::FEMap::calculate_xyz, libMesh::FEMap::d2etadxyz2_map, libMesh::FEMap::d2xidxyz2_map, libMesh::FEMap::d2xyzdeta2_map, libMesh::FEMap::d2xyzdetadzeta_map, libMesh::FEMap::d2xyzdxi2_map, libMesh::FEMap::d2xyzdxideta_map, libMesh::FEMap::d2xyzdxidzeta_map, libMesh::FEMap::d2xyzdzeta2_map, libMesh::FEMap::d2zetadxyz2_map, libMesh::FEMap::detadx_map, libMesh::FEMap::detady_map, libMesh::FEMap::detadz_map, libMesh::FEMap::determine_calculations(), dim, libMesh::FEMap::dxidx_map, libMesh::FEMap::dxidy_map, libMesh::FEMap::dxidz_map, libMesh::FEMap::dxyzdeta_map, libMesh::FEMap::dxyzdxi_map, libMesh::FEMap::dxyzdzeta_map, libMesh::FEMap::dzetadx_map, libMesh::FEMap::dzetady_map, libMesh::FEMap::dzetadz_map, libMesh::index_range(), libMesh::FEMap::jac, libMesh::FEMap::JxW, and libMesh::FEMap::xyz.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_map(), and libMesh::FEMap::compute_null_map().

◆ set_jacobian_tolerance()

void libMesh::FEMap::set_jacobian_tolerance ( Real  tol)
inlineinherited

Set the Jacobian tolerance used for determining when the mapping fails.

The mapping is determined to fail if jac <= jacobian_tolerance.

Definition at line 614 of file fe_map.h.

614 { jacobian_tolerance = tol; }

References libMesh::FEMap::jacobian_tolerance.

Member Data Documentation

◆ _elem_nodes

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

Work vector for compute_affine_map()

Definition at line 1023 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), and libMesh::FEMap::compute_map().

◆ calculate_d2xyz

bool libMesh::FEMap::calculate_d2xyz
mutableprotectedinherited

Should we calculate mapping hessians?

Definition at line 995 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_edge_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::determine_calculations(), libMesh::FEMap::get_curvatures(), libMesh::FEMap::get_d2etadxyz2(), libMesh::FEMap::get_d2phideta2_map(), libMesh::FEMap::get_d2phidetadzeta_map(), libMesh::FEMap::get_d2phidxi2_map(), libMesh::FEMap::get_d2phidxideta_map(), libMesh::FEMap::get_d2phidxidzeta_map(), libMesh::FEMap::get_d2phidzeta2_map(), libMesh::FEMap::get_d2psideta2(), libMesh::FEMap::get_d2psidxi2(), libMesh::FEMap::get_d2psidxideta(), libMesh::FEMap::get_d2xidxyz2(), libMesh::FEMap::get_d2xyzdeta2(), libMesh::FEMap::get_d2xyzdetadzeta(), libMesh::FEMap::get_d2xyzdxi2(), libMesh::FEMap::get_d2xyzdxideta(), libMesh::FEMap::get_d2xyzdxidzeta(), libMesh::FEMap::get_d2xyzdzeta2(), libMesh::FEMap::get_d2zetadxyz2(), libMesh::FEMap::init_edge_shape_functions(), libMesh::FEMap::init_face_shape_functions(), libMesh::FEMap::init_reference_to_physical_map(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ calculate_dxyz

bool libMesh::FEMap::calculate_dxyz
mutableprotectedinherited

Should we calculate mapping gradients?

Definition at line 988 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_edge_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::determine_calculations(), libMesh::FEMap::get_detadx(), libMesh::FEMap::get_detady(), libMesh::FEMap::get_detadz(), libMesh::FEMap::get_dphideta_map(), libMesh::FEMap::get_dphidxi_map(), libMesh::FEMap::get_dphidzeta_map(), libMesh::FEMap::get_dpsideta(), libMesh::FEMap::get_dpsidxi(), libMesh::FEMap::get_dxidx(), libMesh::FEMap::get_dxidy(), libMesh::FEMap::get_dxidz(), libMesh::FEMap::get_dxyzdeta(), libMesh::FEMap::get_dxyzdxi(), libMesh::FEMap::get_dxyzdzeta(), libMesh::FEMap::get_dzetadx(), libMesh::FEMap::get_dzetady(), libMesh::FEMap::get_dzetadz(), libMesh::FEMap::get_jacobian(), libMesh::FEMap::get_JxW(), libMesh::FEMap::get_normals(), libMesh::FEMap::get_tangents(), libMesh::FEMap::init_edge_shape_functions(), libMesh::FEMap::init_face_shape_functions(), libMesh::FEMap::init_reference_to_physical_map(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ calculate_xyz

bool libMesh::FEMap::calculate_xyz
mutableprotectedinherited

Should we calculate physical point locations?

Definition at line 983 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_edge_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), FEXYZMap(), libMesh::FEMap::get_phi_map(), libMesh::FEMap::get_xyz(), libMesh::FEMap::init_edge_shape_functions(), libMesh::FEMap::init_face_shape_functions(), libMesh::FEMap::init_reference_to_physical_map(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ calculations_started

bool libMesh::FEMap::calculations_started
mutableprotectedinherited

Have calculations with this object already been started? Then all get_* functions should already have been called.

Definition at line 978 of file fe_map.h.

Referenced by libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::determine_calculations(), libMesh::FEMap::get_curvatures(), libMesh::FEMap::get_d2etadxyz2(), libMesh::FEMap::get_d2phideta2_map(), libMesh::FEMap::get_d2phidetadzeta_map(), libMesh::FEMap::get_d2phidxi2_map(), libMesh::FEMap::get_d2phidxideta_map(), libMesh::FEMap::get_d2phidxidzeta_map(), libMesh::FEMap::get_d2phidzeta2_map(), libMesh::FEMap::get_d2psideta2(), libMesh::FEMap::get_d2psidxi2(), libMesh::FEMap::get_d2psidxideta(), libMesh::FEMap::get_d2xidxyz2(), libMesh::FEMap::get_d2xyzdeta2(), libMesh::FEMap::get_d2xyzdetadzeta(), libMesh::FEMap::get_d2xyzdxi2(), libMesh::FEMap::get_d2xyzdxideta(), libMesh::FEMap::get_d2xyzdxidzeta(), libMesh::FEMap::get_d2xyzdzeta2(), libMesh::FEMap::get_d2zetadxyz2(), libMesh::FEMap::get_detadx(), libMesh::FEMap::get_detady(), libMesh::FEMap::get_detadz(), libMesh::FEMap::get_dphideta_map(), libMesh::FEMap::get_dphidxi_map(), libMesh::FEMap::get_dphidzeta_map(), libMesh::FEMap::get_dpsideta(), libMesh::FEMap::get_dpsidxi(), libMesh::FEMap::get_dxidx(), libMesh::FEMap::get_dxidy(), libMesh::FEMap::get_dxidz(), libMesh::FEMap::get_dxyzdeta(), libMesh::FEMap::get_dxyzdxi(), libMesh::FEMap::get_dxyzdzeta(), libMesh::FEMap::get_dzetadx(), libMesh::FEMap::get_dzetady(), libMesh::FEMap::get_dzetadz(), libMesh::FEMap::get_jacobian(), libMesh::FEMap::get_JxW(), libMesh::FEMap::get_normals(), libMesh::FEMap::get_phi_map(), libMesh::FEMap::get_tangents(), and libMesh::FEMap::get_xyz().

◆ curvatures

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

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 960 of file fe_map.h.

Referenced by libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), and libMesh::FEMap::get_curvatures().

◆ d2etadxyz2_map

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

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 839 of file fe_map.h.

Referenced by libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2etadxyz2(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ d2phideta2_map

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

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

Definition at line 888 of file fe_map.h.

Referenced by libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2phideta2_map(), and libMesh::FEMap::init_reference_to_physical_map().

◆ d2phidetadzeta_map

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

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

Definition at line 893 of file fe_map.h.

Referenced by libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2phidetadzeta_map(), and libMesh::FEMap::init_reference_to_physical_map().

◆ d2phidxi2_map

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

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

Definition at line 873 of file fe_map.h.

Referenced by libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2phidxi2_map(), and libMesh::FEMap::init_reference_to_physical_map().

◆ d2phidxideta_map

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

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

Definition at line 878 of file fe_map.h.

Referenced by libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2phidxideta_map(), and libMesh::FEMap::init_reference_to_physical_map().

◆ d2phidxidzeta_map

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

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

Definition at line 883 of file fe_map.h.

Referenced by libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2phidxidzeta_map(), and libMesh::FEMap::init_reference_to_physical_map().

◆ d2phidzeta2_map

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

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

Definition at line 898 of file fe_map.h.

Referenced by libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2phidzeta2_map(), and libMesh::FEMap::init_reference_to_physical_map().

◆ d2psideta2_map

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

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

Useful for computing the curvature at the quadrature points.

Definition at line 940 of file fe_map.h.

Referenced by compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::get_d2psideta2(), and libMesh::FEMap::init_face_shape_functions().

◆ d2psidxi2_map

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

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

Useful for computing the curvature at the quadrature points.

Definition at line 926 of file fe_map.h.

Referenced by libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::get_d2psidxi2(), libMesh::FEMap::init_edge_shape_functions(), and libMesh::FEMap::init_face_shape_functions().

◆ d2psidxideta_map

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

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 933 of file fe_map.h.

Referenced by compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::get_d2psidxideta(), and libMesh::FEMap::init_face_shape_functions().

◆ d2xidxyz2_map

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

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 833 of file fe_map.h.

Referenced by libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2xidxyz2(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ d2xyzdeta2_map

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

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

Definition at line 750 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2xyzdeta2(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ d2xyzdetadzeta_map

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

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 762 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2xyzdetadzeta(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ d2xyzdxi2_map

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

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 738 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2xyzdxi2(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ d2xyzdxideta_map

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

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 744 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2xyzdxideta(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ d2xyzdxidzeta_map

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

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 756 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2xyzdxidzeta(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ d2xyzdzeta2_map

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

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

Definition at line 768 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2xyzdzeta2(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ d2zetadxyz2_map

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

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 845 of file fe_map.h.

Referenced by libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_d2zetadxyz2(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ detadx_map

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

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

Needed for the Jacobian.

Definition at line 795 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_detadx(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ detady_map

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

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

Needed for the Jacobian.

Definition at line 801 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_detady(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ detadz_map

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

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

Needed for the Jacobian.

Definition at line 807 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_detadz(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ dphideta_map

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

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

Definition at line 861 of file fe_map.h.

Referenced by libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_dphideta_map(), and libMesh::FEMap::init_reference_to_physical_map().

◆ dphidxi_map

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

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

Definition at line 856 of file fe_map.h.

Referenced by libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_dphidxi_map(), and libMesh::FEMap::init_reference_to_physical_map().

◆ dphidzeta_map

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

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

Definition at line 866 of file fe_map.h.

Referenced by libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_dphidzeta_map(), and libMesh::FEMap::init_reference_to_physical_map().

◆ dpsideta_map

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

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

Definition at line 917 of file fe_map.h.

Referenced by compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::get_dpsideta(), and libMesh::FEMap::init_face_shape_functions().

◆ dpsidxi_map

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

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

Definition at line 911 of file fe_map.h.

Referenced by libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::get_dpsidxi(), libMesh::FEMap::init_edge_shape_functions(), and libMesh::FEMap::init_face_shape_functions().

◆ dxidx_map

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

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

Needed for the Jacobian.

Definition at line 776 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_dxidx(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ dxidy_map

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

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

Needed for the Jacobian.

Definition at line 782 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_dxidy(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ dxidz_map

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

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

Needed for the Jacobian.

Definition at line 788 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_dxidz(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ dxyzdeta_map

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

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

Definition at line 724 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::dxdeta_map(), libMesh::FEMap::dydeta_map(), libMesh::FEMap::dzdeta_map(), libMesh::FEMap::get_dxyzdeta(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ dxyzdxi_map

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

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

Definition at line 718 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::dxdxi_map(), libMesh::FEMap::dydxi_map(), libMesh::FEMap::dzdxi_map(), libMesh::FEMap::get_dxyzdxi(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ dxyzdzeta_map

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

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

Definition at line 730 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::dxdzeta_map(), libMesh::FEMap::dydzeta_map(), libMesh::FEMap::dzdzeta_map(), libMesh::FEMap::get_dxyzdzeta(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ dzetadx_map

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

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

Needed for the Jacobian.

Definition at line 814 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_dzetadx(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ dzetady_map

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

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

Needed for the Jacobian.

Definition at line 820 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_dzetady(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ dzetadz_map

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

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

Needed for the Jacobian.

Definition at line 826 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_inverse_map_second_derivs(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_dzetadz(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ jac

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

Jacobian values at quadrature points.

Definition at line 967 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_jacobian(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ jacobian_tolerance

Real libMesh::FEMap::jacobian_tolerance
protectedinherited

The Jacobian tolerance used for determining when the mapping fails.

The mapping is determined to fail if jac <= jacobian_tolerance. If not set by the user, this number defaults to 0

Definition at line 1011 of file fe_map.h.

Referenced by libMesh::FEMap::compute_single_point_map(), and libMesh::FEMap::set_jacobian_tolerance().

◆ JxW

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

Jacobian*Weight values at quadrature points.

Definition at line 972 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_JxW(), libMesh::FEMap::print_JxW(), and libMesh::FEMap::resize_quadrature_map_vectors().

◆ normals

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

Normal vectors on boundary at quadrature points.

Definition at line 952 of file fe_map.h.

Referenced by libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), and libMesh::FEMap::get_normals().

◆ phi_map

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

Map for the shape function phi.

Definition at line 851 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_phi_map(), and libMesh::FEMap::init_reference_to_physical_map().

◆ psi_map

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

Map for the side shape functions, psi.

Definition at line 905 of file fe_map.h.

Referenced by libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::get_psi(), libMesh::FEMap::init_edge_shape_functions(), and libMesh::FEMap::init_face_shape_functions().

◆ tangents

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

Tangent vectors on boundary at quadrature points.

Definition at line 947 of file fe_map.h.

Referenced by libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), and libMesh::FEMap::get_tangents().

◆ xyz

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

The spatial locations of the quadrature points.

Definition at line 712 of file fe_map.h.

Referenced by libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_edge_map(), compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::get_xyz(), libMesh::FEMap::print_xyz(), and libMesh::FEMap::resize_quadrature_map_vectors().

The documentation for this class was generated from the following files:
libMesh::FEMap::d2psidxi2_map
std::vector< std::vector< Real > > d2psidxi2_map
Map for the second derivatives (in xi) of the side shape functions.
Definition: fe_map.h:926
libMesh::FEInterface::shape_function
static shape_ptr shape_function(const unsigned int dim, const FEType &fe_t)
Definition: fe_interface.C:838
libMesh::FEMap::dzetadx_map
std::vector< Real > dzetadx_map
Map for partial derivatives: d(zeta)/d(x).
Definition: fe_map.h:814
libMesh::FEMap::calculate_d2xyz
bool calculate_d2xyz
Should we calculate mapping hessians?
Definition: fe_map.h:995
libMesh::FEMap::d2xyzdetadzeta_map
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:762
libMesh::FEMap::dydeta_map
Real dydeta_map(const unsigned int p) const
Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.
Definition: fe_map.h:675
libMesh::FEInterface::n_shape_functions
static unsigned int n_shape_functions(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface.C:446
libMesh::MeshTools::Subdivision::find_one_ring
void find_one_ring(const Tri3Subdivision *elem, std::vector< const Node * > &nodes)
Determines the 1-ring of element elem, and writes it to the nodes vector.
Definition: mesh_subdivision_support.C:31
libMesh::FEMap::dpsidxi_map
std::vector< std::vector< Real > > dpsidxi_map
Map for the derivative of the side functions, d(psi)/d(xi).
Definition: fe_map.h:911
libMesh::FEMap::map_deriv
static Point map_deriv(const unsigned int dim, const Elem *elem, const unsigned int j, const Point &reference_point)
Definition: fe_map.C:2076
libMesh::FEMap::dzetadz_map
std::vector< Real > dzetadz_map
Map for partial derivatives: d(zeta)/d(z).
Definition: fe_map.h:826
libMesh::FEMap::dxidy_map
std::vector< Real > dxidy_map
Map for partial derivatives: d(xi)/d(y).
Definition: fe_map.h:782
libMesh::FEMap::FEMap
FEMap(Real jtol=0)
Definition: fe_map.C:64
libMesh::FEMap::calculate_xyz
bool calculate_xyz
Should we calculate physical point locations?
Definition: fe_map.h:983
libMesh::FEMap::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:738
libMesh::index_range
IntRange< std::size_t > index_range(const std::vector< T > &vec)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:106
B
Definition: assembly.h:38
libMesh::XYZ
Definition: enum_fe_family.h:46
libMesh::FEMap::jac
std::vector< Real > jac
Jacobian values at quadrature points.
Definition: fe_map.h:967
libMesh::RealTensor
RealTensorValue RealTensor
Definition: hp_coarsentest.h:50
libMesh::Order
Order
Definition: enum_order.h:40
libMesh::FEMap::dxdzeta_map
Real dxdzeta_map(const unsigned int p) const
Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.
Definition: fe_map.h:691
libMesh::FEMap::d2phidxideta_map
std::vector< std::vector< Real > > d2phidxideta_map
Map for the second derivative, d^2(phi)/d(xi)d(eta).
Definition: fe_map.h:878
libMesh::FEMap::JxW
std::vector< Real > JxW
Jacobian*Weight values at quadrature points.
Definition: fe_map.h:972
libMesh::FEMap::dxdxi_map
Real dxdxi_map(const unsigned int p) const
Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.
Definition: fe_map.h:643
libMesh::FEInterface::shape_deriv_function
static shape_deriv_ptr shape_deriv_function(const unsigned int dim, const FEType &fe_t)
Definition: fe_interface.C:916
std::sqrt
MetaPhysicL::DualNumber< T, D > sqrt(const MetaPhysicL::DualNumber< T, D > &in)
libMesh::FEMap::map
static Point map(const unsigned int dim, const Elem *elem, const Point &reference_point)
Definition: fe_map.C:2043
libMesh::FEMap::_elem_nodes
std::vector< const Node * > _elem_nodes
Work vector for compute_affine_map()
Definition: fe_map.h:1023
libMesh::FEMap::dydzeta_map
Real dydzeta_map(const unsigned int p) const
Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.
Definition: fe_map.h:699
libMesh::FEMap::dxyzdeta_map
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:724
libMesh::FEMap::dydxi_map
Real dydxi_map(const unsigned int p) const
Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.
Definition: fe_map.h:651
libMesh::FEInterface::shape_ptr
Real(* shape_ptr)(const Elem *elem, const Order o, const unsigned int i, const Point &p, const bool add_p_level)
Definition: fe_interface.h:296
libMesh::RealVectorValue
VectorValue< Real > RealVectorValue
Useful typedefs to allow transparent switching between Real and Complex data types.
Definition: hp_coarsentest.h:46
libMesh::FEMap::normals
std::vector< Point > normals
Normal vectors on boundary at quadrature points.
Definition: fe_map.h:952
libMesh::FEMap::xyz
std::vector< Point > xyz
The spatial locations of the quadrature points.
Definition: fe_map.h:712
libMesh::RATIONAL_BERNSTEIN_MAP
Definition: enum_elem_type.h:84
dim
unsigned int dim
Definition: adaptivity_ex3.C:113
libMesh::FEMap::compute_affine_map
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.
Definition: fe_map.C:1277
libMesh::FEMap::d2phidxi2_map
std::vector< std::vector< Real > > d2phidxi2_map
Map for the second derivative, d^2(phi)/d(xi)^2.
Definition: fe_map.h:873
libMesh::FEMap::compute_null_map
virtual void compute_null_map(const unsigned int dim, const std::vector< Real > &qw)
Assign a fake jacobian and some other additional data fields.
Definition: fe_map.C:1358
libMesh::FEMap::detady_map
std::vector< Real > detady_map
Map for partial derivatives: d(eta)/d(y).
Definition: fe_map.h:801
libMesh::FEMap::compute_single_point_map
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.
Definition: fe_map.C:446
libMesh::FEMap::compute_face_map
virtual void compute_face_map(int dim, const std::vector< Real > &qw, const Elem *side)
Same as compute_map, but for a side.
Definition: fe_boundary.C:587
libMesh::libmesh_assert
libmesh_assert(ctx)
libMesh::FEMap::determine_calculations
void determine_calculations()
Determine which values are to be calculated.
Definition: fe_map.h:621
libMesh::InfFEMap::inverse_map
static Point inverse_map(const unsigned int dim, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
Definition: inf_fe_map.C:88
libMesh::FEMap::d2xyzdxidzeta_map
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),...
Definition: fe_map.h:756
libMesh::FEMap::inverse_map
static Point inverse_map(const unsigned int dim, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
Definition: fe_map.C:1622
libMesh::FEMap::resize_quadrature_map_vectors
void resize_quadrature_map_vectors(const unsigned int dim, unsigned int n_qp)
A utility function for use by compute_*_map.
Definition: fe_map.C:1196
libMesh::FEMap::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:917
libMesh::FEMap::detadz_map
std::vector< Real > detadz_map
Map for partial derivatives: d(eta)/d(z).
Definition: fe_map.h:807
libMesh::FEMap::tangents
std::vector< std::vector< Point > > tangents
Tangent vectors on boundary at quadrature points.
Definition: fe_map.h:947
libMesh::RealTensorValue
TensorValue< Real > RealTensorValue
Useful typedefs to allow transparent switching between Real and Complex data types.
Definition: hp_coarsentest.h:48
libMesh::libmesh_ignore
void libmesh_ignore(const Args &...)
Definition: libmesh_common.h:526
libMesh::FEMap::psi_map
std::vector< std::vector< Real > > psi_map
Map for the side shape functions, psi.
Definition: fe_map.h:905
libMesh::FEMap::d2phidzeta2_map
std::vector< std::vector< Real > > d2phidzeta2_map
Map for the second derivative, d^2(phi)/d(zeta)^2.
Definition: fe_map.h:898
libMesh::FEMap::calculate_dxyz
bool calculate_dxyz
Should we calculate mapping gradients?
Definition: fe_map.h:988
libMesh::FEMap::d2xyzdzeta2_map
std::vector< RealGradient > d2xyzdzeta2_map
Vector of second partial derivatives in zeta: d^2(x)/d(zeta)^2.
Definition: fe_map.h:768
libMesh::FEMap::dphideta_map
std::vector< std::vector< Real > > dphideta_map
Map for the derivative, d(phi)/d(eta).
Definition: fe_map.h:861
libMesh::FEMap::d2xidxyz2_map
std::vector< std::vector< Real > > d2xidxyz2_map
Second derivatives of "xi" reference coordinate wrt physical coordinates.
Definition: fe_map.h:833
libMesh::FEMap::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:940
libMesh::FEMap::dzdeta_map
Real dzdeta_map(const unsigned int p) const
Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.
Definition: fe_map.h:683
libMesh::FEMap::map_fe_type
static FEFamily map_fe_type(const Elem &elem)
Definition: fe_map.C:47
libMesh::RATIONAL_BERNSTEIN
Definition: enum_fe_family.h:64
libMesh::FEMap::d2etadxyz2_map
std::vector< std::vector< Real > > d2etadxyz2_map
Second derivatives of "eta" reference coordinate wrt physical coordinates.
Definition: fe_map.h:839
n_nodes
const dof_id_type n_nodes
Definition: tecplot_io.C:68
A
static PetscErrorCode Mat * A
Definition: petscdmlibmeshimpl.C:1026
libMesh::FEInterface::shape_deriv_ptr
Real(* shape_deriv_ptr)(const Elem *elem, const Order o, const unsigned int i, const unsigned int j, const Point &p, const bool add_p_level)
Definition: fe_interface.h:345
libMesh::FEMap::detadx_map
std::vector< Real > detadx_map
Map for partial derivatives: d(eta)/d(x).
Definition: fe_map.h:795
libMesh::FEMap::jacobian_tolerance
Real jacobian_tolerance
The Jacobian tolerance used for determining when the mapping fails.
Definition: fe_map.h:1011
libMesh::FEAbstract::on_reference_element
static bool on_reference_element(const Point &p, const ElemType t, const Real eps=TOLERANCE)
Definition: fe_abstract.C:606
libMesh::LAGRANGE_MAP
Definition: enum_elem_type.h:83
libMesh::FEMap::dphidxi_map
std::vector< std::vector< Real > > dphidxi_map
Map for the derivative, d(phi)/d(xi).
Definition: fe_map.h:856
libMesh::FEMap::compute_inverse_map_second_derivs
void compute_inverse_map_second_derivs(unsigned p)
A helper function used by FEMap::compute_single_point_map() to compute second derivatives of the inve...
Definition: fe_map.C:1502
libMesh::InfFEMap::map
static Point map(const unsigned int dim, const Elem *inf_elem, const Point &reference_point)
Definition: inf_fe_map.C:40
libMesh::FEMap::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:893
libMesh::FEFamily
FEFamily
Definition: enum_fe_family.h:34
libMesh::FEMap::phi_map
std::vector< std::vector< Real > > phi_map
Map for the shape function phi.
Definition: fe_map.h:851
libMesh::FEMap::dxyzdzeta_map
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:730
libMesh::FEInterface::shape_second_deriv_ptr
Real(* shape_second_deriv_ptr)(const Elem *elem, const Order o, const unsigned int i, const unsigned int j, const Point &p, const bool add_p_level)
Definition: fe_interface.h:409
libMesh::FEMap::dzetady_map
std::vector< Real > dzetady_map
Map for partial derivatives: d(zeta)/d(y).
Definition: fe_map.h:820
libMesh::FEMap::dphidzeta_map
std::vector< std::vector< Real > > dphidzeta_map
Map for the derivative, d(phi)/d(zeta).
Definition: fe_map.h:866
libMesh::FEMap::d2phideta2_map
std::vector< std::vector< Real > > d2phideta2_map
Map for the second derivative, d^2(phi)/d(eta)^2.
Definition: fe_map.h:888
libMesh::FEMap::d2zetadxyz2_map
std::vector< std::vector< Real > > d2zetadxyz2_map
Second derivatives of "zeta" reference coordinate wrt physical coordinates.
Definition: fe_map.h:845
libMesh::FEMap::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:883
libMesh::err
OStreamProxy err
libMesh::LAGRANGE
Definition: enum_fe_family.h:36
libMesh::FEMap::dzdxi_map
Real dzdxi_map(const unsigned int p) const
Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.
Definition: fe_map.h:659
libMesh::FEMap::dzdzeta_map
Real dzdzeta_map(const unsigned int p) const
Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.
Definition: fe_map.h:707
libMesh::TRI3SUBDIVISION
Definition: enum_elem_type.h:69
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition: libmesh_common.h:121
libMesh::FEMap::dxdeta_map
Real dxdeta_map(const unsigned int p) const
Used in FEMap::compute_map(), which should be be usable in derived classes, and therefore protected.
Definition: fe_map.h:667
libMesh::FEMap::dxyzdxi_map
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:718
libMesh::FEMap::dxidx_map
std::vector< Real > dxidx_map
Map for partial derivatives: d(xi)/d(x).
Definition: fe_map.h:776
libMesh::FEInterface::shape_second_deriv_function
static shape_second_deriv_ptr shape_second_deriv_function(const unsigned int dim, const FEType &fe_t)
Definition: fe_interface.C:989
libMesh::FEMap::dxidz_map
std::vector< Real > dxidz_map
Map for partial derivatives: d(xi)/d(z).
Definition: fe_map.h:788
libMesh::FEMap::calculations_started
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_map.h:978
libMesh::FEMap::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:744
libMesh::FEMap::d2xyzdeta2_map
std::vector< RealGradient > d2xyzdeta2_map
Vector of second partial derivatives in eta: d^2(x)/d(eta)^2.
Definition: fe_map.h:750
libMesh::ElemType
ElemType
Defines an enum for geometric element types.
Definition: enum_elem_type.h:33
libMesh::FEMap::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:933
libMesh::FEMap::curvatures
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:960
Generated on Sat Jan 25 2020 12:08:16 for libMesh by   doxygen 1.8.16