#include <fe_xyz_map.h>

Inheritance diagram for libMesh::FEXYZMap:

Public Member Functions
	FEXYZMap ()
virtual	~FEXYZMap ()
virtual void	compute_face_map (int dim, const std::vector< Real > &qw, const Elem *side)
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< Node > &elem_nodes)
virtual void	compute_affine_map (const unsigned int dim, const std::vector< Real > &qw, const Elem *elem)
virtual void	compute_null_map (const unsigned int dim, const std::vector< Real > &qw)
virtual void	compute_map (const unsigned int dim, const std::vector< Real > &qw, const Elem *elem)
void	compute_edge_map (int dim, const std::vector< Real > &qw, const Elem *side)
template<unsigned int Dim>
void	init_face_shape_functions (const std::vector< Point > &qp, const Elem *side)
template<unsigned int Dim>
void	init_edge_shape_functions (const std::vector< Point > &qp, const Elem *edge)
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_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
void	print_xyz (std::ostream &os) const
std::vector< std::vector< Real > > &	get_dpsidxi ()
std::vector< std::vector< Real > > &	get_dpsideta ()
std::vector< std::vector< Real > > &	get_d2psidxi2 ()
std::vector< std::vector< Real > > &	get_d2psidxideta ()
std::vector< std::vector< Real > > &	get_d2psideta2 ()
std::vector< std::vector< Real > > &	get_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 ()
Static Public Member Functions
static UniquePtr< FEMap >	build (FEType fe_type)
Protected Member Functions
void	resize_quadrature_map_vectors (const unsigned int dim, unsigned int n_qp)
Real	dxdxi_map (const unsigned int p) const
Real	dydxi_map (const unsigned int p) const
Real	dzdxi_map (const unsigned int p) const
Real	dxdeta_map (const unsigned int p) const
Real	dydeta_map (const unsigned int p) const
Real	dzdeta_map (const unsigned int p) const
Real	dxdzeta_map (const unsigned int p) const
Real	dydzeta_map (const unsigned int p) const
Real	dzdzeta_map (const unsigned int p) const
Protected Attributes
std::vector< Point >	xyz
std::vector< RealGradient >	dxyzdxi_map
std::vector< RealGradient >	dxyzdeta_map
std::vector< RealGradient >	dxyzdzeta_map
std::vector< RealGradient >	d2xyzdxi2_map
std::vector< RealGradient >	d2xyzdxideta_map
std::vector< RealGradient >	d2xyzdeta2_map
std::vector< RealGradient >	d2xyzdxidzeta_map
std::vector< RealGradient >	d2xyzdetadzeta_map
std::vector< RealGradient >	d2xyzdzeta2_map
std::vector< Real >	dxidx_map
std::vector< Real >	dxidy_map
std::vector< Real >	dxidz_map
std::vector< Real >	detadx_map
std::vector< Real >	detady_map
std::vector< Real >	detadz_map
std::vector< Real >	dzetadx_map
std::vector< Real >	dzetady_map
std::vector< Real >	dzetadz_map
std::vector< std::vector< Real > >	phi_map
std::vector< std::vector< Real > >	dphidxi_map
std::vector< std::vector< Real > >	dphideta_map
std::vector< std::vector< Real > >	dphidzeta_map
std::vector< std::vector< Real > >	d2phidxi2_map
std::vector< std::vector< Real > >	d2phidxideta_map
std::vector< std::vector< Real > >	d2phidxidzeta_map
std::vector< std::vector< Real > >	d2phideta2_map
std::vector< std::vector< Real > >	d2phidetadzeta_map
std::vector< std::vector< Real > >	d2phidzeta2_map
std::vector< std::vector< Real > >	psi_map
std::vector< std::vector< Real > >	dpsidxi_map
std::vector< std::vector< Real > >	dpsideta_map
std::vector< std::vector< Real > >	d2psidxi2_map
std::vector< std::vector< Real > >	d2psidxideta_map
std::vector< std::vector< Real > >	d2psideta2_map
std::vector< std::vector< Point > >	tangents
std::vector< Point >	normals
std::vector< Real >	curvatures
std::vector< Real >	jac
std::vector< Real >	JxW

Detailed Description

Definition at line 30 of file fe_xyz_map.h.

Constructor & Destructor Documentation

libMesh::FEXYZMap::FEXYZMap ( ) [inline]

Definition at line 34 of file fe_xyz_map.h.

    : FEMap(){}

virtual libMesh::FEXYZMap::~FEXYZMap ( ) [inline, virtual]

Definition at line 37 of file fe_xyz_map.h.

{}

Member Function Documentation

UniquePtr< FEMap > libMesh::FEMap::build ( FEType fe_type ) [static, inherited]

Definition at line 42 of file fe_map.C.

References libMesh::FEType::family, libMesh::FEMap::FEMap(), and libMesh::XYZ.

{
  switch( fe_type.family )
    {
    case XYZ:
      return UniquePtr<FEMap>(new FEXYZMap);

    default:
      return UniquePtr<FEMap>(new FEMap);
    }

  libmesh_error_msg("We'll never get here!");
  return UniquePtr<FEMap>();
}

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

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 690 of file fe_map.C.

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

{
  // Start logging the map computation.
  START_LOG("compute_affine_map()", "FEMap");

  libmesh_assert(elem);

  const unsigned int n_qp = cast_int<unsigned int>(qw.size());

  // Resize the vectors to hold data at the quadrature points
  this->resize_quadrature_map_vectors(dim, n_qp);

  // Determine the nodes contributing to element elem
  std::vector<Node*> elem_nodes(elem->n_nodes(), NULL);
  for (unsigned int i=0; i<elem->n_nodes(); i++)
    elem_nodes[i] = elem->get_node(i);

  // Compute map at quadrature point 0
  this->compute_single_point_map(dim, qw, elem, 0, elem_nodes);

  // Compute xyz at all other quadrature points
  for (unsigned int p=1; p<n_qp; p++)
    {
      xyz[p].zero();
      for (unsigned int i=0; i<phi_map.size(); i++) // sum over the nodes
        xyz[p].add_scaled        (*elem_nodes[i], phi_map[i][p]    );
    }

  // Copy other map data from quadrature point 0
  for (unsigned int p=1; p<n_qp; p++) // for each extra quadrature point
    {
      dxyzdxi_map[p] = dxyzdxi_map[0];
      dxidx_map[p] = dxidx_map[0];
      dxidy_map[p] = dxidy_map[0];
      dxidz_map[p] = dxidz_map[0];
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
      // The map should be affine, so second derivatives are zero
      d2xyzdxi2_map[p] = 0.;
#endif
      if (dim > 1)
        {
          dxyzdeta_map[p] = dxyzdeta_map[0];
          detadx_map[p] = detadx_map[0];
          detady_map[p] = detady_map[0];
          detadz_map[p] = detadz_map[0];
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
          d2xyzdxideta_map[p] = 0.;
          d2xyzdeta2_map[p] = 0.;
#endif
          if (dim > 2)
            {
              dxyzdzeta_map[p] = dxyzdzeta_map[0];
              dzetadx_map[p] = dzetadx_map[0];
              dzetady_map[p] = dzetady_map[0];
              dzetadz_map[p] = dzetadz_map[0];
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
              d2xyzdxidzeta_map[p] = 0.;
              d2xyzdetadzeta_map[p] = 0.;
              d2xyzdzeta2_map[p] = 0.;
#endif
            }
        }
      jac[p] = jac[0];
      JxW[p] = JxW[0] / qw[0] * qw[p];
    }

  STOP_LOG("compute_affine_map()", "FEMap");
}

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 800 of file fe_boundary.C.

References 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::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, libMesh::START_LOG(), libMesh::FEMap::tangents, and libMesh::FEMap::xyz.

{
  libmesh_assert(edge);

  if (dim == 2)
    {
      // A 2D finite element living in either 2D or 3D space.
      // The edges here are the sides of the element, so the
      // (misnamed) compute_face_map function does what we want
      this->compute_face_map(dim, qw, edge);
      return;
    }

  libmesh_assert_equal_to (dim, 3);  // 1D is unnecessary and currently unsupported

  START_LOG("compute_edge_map()", "FEMap");

  // The number of quadrature points.
  const unsigned int n_qp = cast_int<unsigned int>(qw.size());

  // Resize the vectors to hold data at the quadrature points
  this->xyz.resize(n_qp);
  this->dxyzdxi_map.resize(n_qp);
  this->dxyzdeta_map.resize(n_qp);
  this->d2xyzdxi2_map.resize(n_qp);
  this->d2xyzdxideta_map.resize(n_qp);
  this->d2xyzdeta2_map.resize(n_qp);
  this->tangents.resize(n_qp);
  this->normals.resize(n_qp);
  this->curvatures.resize(n_qp);

  this->JxW.resize(n_qp);

  // Clear the entities that will be summed
  for (unsigned int p=0; p<n_qp; p++)
    {
      this->tangents[p].resize(1);
      this->xyz[p].zero();
      this->dxyzdxi_map[p].zero();
      this->dxyzdeta_map[p].zero();
      this->d2xyzdxi2_map[p].zero();
      this->d2xyzdxideta_map[p].zero();
      this->d2xyzdeta2_map[p].zero();
    }

  // compute x, dxdxi at the quadrature points
  for (unsigned int i=0; i<this->psi_map.size(); i++) // sum over the nodes
    {
      const Point& edge_point = edge->point(i);

      for (unsigned int p=0; p<n_qp; p++) // for each quadrature point...
        {
          this->xyz[p].add_scaled             (edge_point, this->psi_map[i][p]);
          this->dxyzdxi_map[p].add_scaled     (edge_point, this->dpsidxi_map[i][p]);
          this->d2xyzdxi2_map[p].add_scaled   (edge_point, this->d2psidxi2_map[i][p]);
        }
    }

  // Compute the tangents at the quadrature point
  // FIXME: normals (plural!) and curvatures are uncalculated
  for (unsigned int p=0; p<n_qp; p++)
    {
      const Point n  = this->dxyzdxi_map[p].cross(this->dxyzdeta_map[p]);
      this->tangents[p][0] = this->dxyzdxi_map[p].unit();

      // compute the jacobian at the quadrature points
      const Real the_jac = std::sqrt(this->dxdxi_map(p)*this->dxdxi_map(p) +
                                     this->dydxi_map(p)*this->dydxi_map(p) +
                                     this->dzdxi_map(p)*this->dzdxi_map(p));

      libmesh_assert_greater (the_jac, 0.);

      this->JxW[p] = the_jac*qw[p];
    }

  STOP_LOG("compute_edge_map()", "FEMap");
}

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

Special implementation for XYZ finite elements

Reimplemented from libMesh::FEMap.

Definition at line 22 of file fe_xyz_map.C.

{
  libmesh_assert(side);

  START_LOG("compute_face_map()", "FEXYZMap");

  // The number of quadrature points.
  const unsigned int n_qp = cast_int<unsigned int>(qw.size());

  switch(dim)
    {
    case 2:
      {

        // Resize the vectors to hold data at the quadrature points
        {
          this->xyz.resize(n_qp);
          this->dxyzdxi_map.resize(n_qp);
          this->d2xyzdxi2_map.resize(n_qp);
          this->tangents.resize(n_qp);
          this->normals.resize(n_qp);
          this->curvatures.resize(n_qp);

          this->JxW.resize(n_qp);
        }

        // Clear the entities that will be summed
        // Compute the tangent & normal at the quadrature point
        for (unsigned int p=0; p<n_qp; p++)
          {
            this->tangents[p].resize(LIBMESH_DIM-1); // 1 Tangent in 2D, 2 in 3D
            this->xyz[p].zero();
            this->dxyzdxi_map[p].zero();
            this->d2xyzdxi2_map[p].zero();
          }

        // compute x, dxdxi at the quadrature points
        for (unsigned int i=0; i<this->psi_map.size(); i++) // sum over the nodes
          {
            const Point& side_point = side->point(i);

            for (unsigned int p=0; p<n_qp; p++) // for each quadrature point...
              {
                this->xyz[p].add_scaled          (side_point, this->psi_map[i][p]);
                this->dxyzdxi_map[p].add_scaled  (side_point, this->dpsidxi_map[i][p]);
                this->d2xyzdxi2_map[p].add_scaled(side_point, this->d2psidxi2_map[i][p]);
              }
          }

        // Compute the tangent & normal at the quadrature point
        for (unsigned int p=0; p<n_qp; p++)
          {
            const Point n(this->dxyzdxi_map[p](1), -this->dxyzdxi_map[p](0), 0.);

            this->normals[p]     = n.unit();
            this->tangents[p][0] = this->dxyzdxi_map[p].unit();
#if LIBMESH_DIM == 3  // Only good in 3D space
            this->tangents[p][1] = this->dxyzdxi_map[p].cross(n).unit();
#endif
            // The curvature is computed via the familiar Frenet formula:
            // curvature = [d^2(x) / d (xi)^2] dot [normal]
            // For a reference, see:
            // F.S. Merritt, Mathematics Manual, 1962, McGraw-Hill, p. 310
            //
            // Note: The sign convention here is different from the
            // 3D case.  Concave-upward curves (smiles) have a positive
            // curvature.  Concave-downward curves (frowns) have a
            // negative curvature.  Be sure to take that into account!
            const Real numerator   = this->d2xyzdxi2_map[p] * this->normals[p];
            const Real denominator = this->dxyzdxi_map[p].size_sq();
            libmesh_assert_not_equal_to (denominator, 0);
            this->curvatures[p] = numerator / denominator;
          }

        // compute the jacobian at the quadrature points
        for (unsigned int p=0; p<n_qp; p++)
          {
            const Real the_jac = std::sqrt(this->dxdxi_map(p)*this->dxdxi_map(p) +
                                           this->dydxi_map(p)*this->dydxi_map(p));

            libmesh_assert_greater (the_jac, 0.);

            this->JxW[p] = the_jac*qw[p];
          }

        break;
      }

    case 3:
      {
        // Resize the vectors to hold data at the quadrature points
        {
          this->xyz.resize(n_qp);
          this->dxyzdxi_map.resize(n_qp);
          this->dxyzdeta_map.resize(n_qp);
          this->d2xyzdxi2_map.resize(n_qp);
          this->d2xyzdxideta_map.resize(n_qp);
          this->d2xyzdeta2_map.resize(n_qp);
          this->tangents.resize(n_qp);
          this->normals.resize(n_qp);
          this->curvatures.resize(n_qp);

          this->JxW.resize(n_qp);
        }

        // Clear the entities that will be summed
        for (unsigned int p=0; p<n_qp; p++)
          {
            this->tangents[p].resize(LIBMESH_DIM-1); // 1 Tangent in 2D, 2 in 3D
            this->xyz[p].zero();
            this->dxyzdxi_map[p].zero();
            this->dxyzdeta_map[p].zero();
            this->d2xyzdxi2_map[p].zero();
            this->d2xyzdxideta_map[p].zero();
            this->d2xyzdeta2_map[p].zero();
          }

        // compute x, dxdxi at the quadrature points
        for (unsigned int i=0; i<this->psi_map.size(); i++) // sum over the nodes
          {
            const Point& side_point = side->point(i);

            for (unsigned int p=0; p<n_qp; p++) // for each quadrature point...
              {
                this->xyz[p].add_scaled             (side_point, this->psi_map[i][p]);
                this->dxyzdxi_map[p].add_scaled     (side_point, this->dpsidxi_map[i][p]);
                this->dxyzdeta_map[p].add_scaled    (side_point, this->dpsideta_map[i][p]);
                this->d2xyzdxi2_map[p].add_scaled   (side_point, this->d2psidxi2_map[i][p]);
                this->d2xyzdxideta_map[p].add_scaled(side_point, this->d2psidxideta_map[i][p]);
                this->d2xyzdeta2_map[p].add_scaled  (side_point, this->d2psideta2_map[i][p]);
              }
          }

        // Compute the tangents, normal, and curvature at the quadrature point
        for (unsigned int p=0; p<n_qp; p++)
          {
            const Point n  = this->dxyzdxi_map[p].cross(this->dxyzdeta_map[p]);
            this->normals[p]     = n.unit();
            this->tangents[p][0] = this->dxyzdxi_map[p].unit();
            this->tangents[p][1] = n.cross(this->dxyzdxi_map[p]).unit();

            // Compute curvature using the typical nomenclature
            // of the first and second fundamental forms.
            // For reference, see:
            // 1) http://mathworld.wolfram.com/MeanCurvature.html
            //    (note -- they are using inward normal)
            // 2) F.S. Merritt, Mathematics Manual, 1962, McGraw-Hill
            const Real L  = -this->d2xyzdxi2_map[p]    * this->normals[p];
            const Real M  = -this->d2xyzdxideta_map[p] * this->normals[p];
            const Real N  = -this->d2xyzdeta2_map[p]   * this->normals[p];
            const Real E  =  this->dxyzdxi_map[p].size_sq();
            const Real F  =  this->dxyzdxi_map[p]      * this->dxyzdeta_map[p];
            const Real G  =  this->dxyzdeta_map[p].size_sq();

            const Real numerator   = E*N -2.*F*M + G*L;
            const Real denominator = E*G - F*F;
            libmesh_assert_not_equal_to (denominator, 0.);
            this->curvatures[p] = 0.5*numerator/denominator;
          }

        // compute the jacobian at the quadrature points, see
        // http://sp81.msi.umn.edu:999/fluent/fidap/help/theory/thtoc.htm
        for (unsigned int p=0; p<n_qp; p++)
          {
            const Real g11 = (this->dxdxi_map(p)*this->dxdxi_map(p) +
                              this->dydxi_map(p)*this->dydxi_map(p) +
                              this->dzdxi_map(p)*this->dzdxi_map(p));

            const Real g12 = (this->dxdxi_map(p)*this->dxdeta_map(p) +
                              this->dydxi_map(p)*this->dydeta_map(p) +
                              this->dzdxi_map(p)*this->dzdeta_map(p));

            const Real g21 = g12;

            const Real g22 = (this->dxdeta_map(p)*this->dxdeta_map(p) +
                              this->dydeta_map(p)*this->dydeta_map(p) +
                              this->dzdeta_map(p)*this->dzdeta_map(p));


            const Real the_jac = std::sqrt(g11*g22 - g12*g21);

            libmesh_assert_greater (the_jac, 0.);

            this->JxW[p] = the_jac*qw[p];
          }

        break;
      }
    default:
      libmesh_error_msg("Invalid dim = " << dim);

    } // switch(dim)

  STOP_LOG("compute_face_map()", "FEXYZMap");

  return;
}

void libMesh::FEMap::compute_map	(	const unsigned int	dim,
		const std::vector< Real > &	qw,
		const Elem *	elem
	)		`[virtual, inherited]`

Compute the jacobian and some other additional data fields. Takes the integration weights as input, along with a pointer to the element.

Definition at line 818 of file fe_map.C.

References libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_null_map(), libMesh::FEMap::compute_single_point_map(), libMesh::MeshTools::Subdivision::find_one_ring(), libMesh::Elem::get_node(), libMesh::Elem::has_affine_map(), libMesh::libmesh_assert(), libMesh::Elem::n_nodes(), libMesh::FEMap::resize_quadrature_map_vectors(), libMesh::START_LOG(), libMesh::TRI3SUBDIVISION, and libMesh::Elem::type().

{
  if (!elem)
    {
      compute_null_map(dim, qw);
      return;
    }

  if (elem->has_affine_map())
    {
      compute_affine_map(dim, qw, elem);
      return;
    }

  // Start logging the map computation.
  START_LOG("compute_map()", "FEMap");

  libmesh_assert(elem);

  const unsigned int n_qp = cast_int<unsigned int>(qw.size());

  // Resize the vectors to hold data at the quadrature points
  this->resize_quadrature_map_vectors(dim, n_qp);

  // Determine the nodes contributing to element elem
  std::vector<Node*> elem_nodes;
  if (elem->type() == TRI3SUBDIVISION)
    {
      // Subdivision surface FE require the 1-ring around elem
      libmesh_assert_equal_to (dim, 2);
      const Tri3Subdivision* sd_elem = static_cast<const Tri3Subdivision*>(elem);
      MeshTools::Subdivision::find_one_ring(sd_elem, elem_nodes);
    }
  else
    {
      // All other FE use only the nodes of elem itself
      elem_nodes.resize(elem->n_nodes(), NULL);
      for (unsigned int i=0; i<elem->n_nodes(); i++)
        elem_nodes[i] = elem->get_node(i);
    }

  // Compute map at all quadrature points
  for (unsigned int p=0; p!=n_qp; p++)
    this->compute_single_point_map(dim, qw, elem, p, elem_nodes);

  // Stop logging the map computation.
  STOP_LOG("compute_map()", "FEMap");
}

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

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 763 of file fe_map.C.

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

{
  // Start logging the map computation.
  START_LOG("compute_null_map()", "FEMap");

  const unsigned int n_qp = cast_int<unsigned int>(qw.size());

  // Resize the vectors to hold data at the quadrature points
  this->resize_quadrature_map_vectors(dim, n_qp);

  // Compute "fake" xyz
  for (unsigned int p=1; p<n_qp; p++)
    {
      xyz[p].zero();

      dxyzdxi_map[p] = 0;
      dxidx_map[p] = 0;
      dxidy_map[p] = 0;
      dxidz_map[p] = 0;
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
      d2xyzdxi2_map[p] = 0;
#endif
      if (dim > 1)
        {
          dxyzdeta_map[p] = 0;
          detadx_map[p] = 0;
          detady_map[p] = 0;
          detadz_map[p] = 0;
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
          d2xyzdxideta_map[p] = 0.;
          d2xyzdeta2_map[p] = 0.;
#endif
          if (dim > 2)
            {
              dxyzdzeta_map[p] = 0;
              dzetadx_map[p] = 0;
              dzetady_map[p] = 0;
              dzetadz_map[p] = 0;
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
              d2xyzdxidzeta_map[p] = 0;
              d2xyzdetadzeta_map[p] = 0;
              d2xyzdzeta2_map[p] = 0;
#endif
            }
        }
      jac[p] = 1;
      JxW[p] = qw[p];
    }

  STOP_LOG("compute_null_map()", "FEMap");
}

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< Node * > &	elem_nodes
	)		`[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.

Definition at line 312 of file fe_map.C.

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

{
  libmesh_assert(elem);
  libmesh_assert_equal_to(phi_map.size(), elem_nodes.size());

  switch (dim)
    {
      //--------------------------------------------------------------------
      // 0D
    case 0:
      {
        libmesh_assert(elem_nodes[0]);
        xyz[p] = *elem_nodes[0];
        jac[p] = 1.0;
        JxW[p] = qw[p];
        break;
      }

      //--------------------------------------------------------------------
      // 1D
    case 1:
      {
        // Clear the entities that will be summed
        xyz[p].zero();
        dxyzdxi_map[p].zero();
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
        d2xyzdxi2_map[p].zero();
#endif

        // compute x, dx, d2x at the quadrature point
        for (unsigned int i=0; i<phi_map.size(); i++) // sum over the nodes
          {
            // Reference to the point, helps eliminate
            // exessive temporaries in the inner loop
            libmesh_assert(elem_nodes[i]);
            const Point& elem_point = *elem_nodes[i];

            xyz[p].add_scaled          (elem_point, phi_map[i][p]    );
            dxyzdxi_map[p].add_scaled  (elem_point, dphidxi_map[i][p]);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
            d2xyzdxi2_map[p].add_scaled(elem_point, d2phidxi2_map[i][p]);
#endif
          }

        // Compute the jacobian
        //
        // 1D elements can live in 2D or 3D space.
        // The transformation matrix from local->global
        // coordinates is
        //
        // T = | dx/dxi |
        //     | dy/dxi |
        //     | dz/dxi |
        //
        // The generalized determinant of T (from the
        // so-called "normal" eqns.) is
        // jac = "det(T)" = sqrt(det(T'T))
        //
        // where T'= transpose of T, so
        //
        // jac = sqrt( (dx/dxi)^2 + (dy/dxi)^2 + (dz/dxi)^2 )
        jac[p] = dxyzdxi_map[p].size();

        if (jac[p] <= 0.)
          libmesh_error_msg("ERROR: negative Jacobian: " << jac[p] << " in element " << elem->id());

        // The inverse Jacobian entries also come from the
        // generalized inverse of T (see also the 2D element
        // living in 3D code).
        const Real jacm2 = 1./jac[p]/jac[p];
        dxidx_map[p] = jacm2*dxdxi_map(p);
#if LIBMESH_DIM > 1
        dxidy_map[p] = jacm2*dydxi_map(p);
#endif
#if LIBMESH_DIM > 2
        dxidz_map[p] = jacm2*dzdxi_map(p);
#endif

        JxW[p] = jac[p]*qw[p];

        // done computing the map
        break;
      }


      //--------------------------------------------------------------------
      // 2D
    case 2:
      {
        //------------------------------------------------------------------
        // Compute the (x,y) values at the quadrature points,
        // the Jacobian at the quadrature points

        xyz[p].zero();

        dxyzdxi_map[p].zero();
        dxyzdeta_map[p].zero();
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
        d2xyzdxi2_map[p].zero();
        d2xyzdxideta_map[p].zero();
        d2xyzdeta2_map[p].zero();
#endif


        // compute (x,y) at the quadrature points, derivatives once
        for (unsigned int i=0; i<phi_map.size(); i++) // sum over the nodes
          {
            // Reference to the point, helps eliminate
            // exessive temporaries in the inner loop
            libmesh_assert(elem_nodes[i]);
            const Point& elem_point = *elem_nodes[i];

            xyz[p].add_scaled          (elem_point, phi_map[i][p]     );

            dxyzdxi_map[p].add_scaled      (elem_point, dphidxi_map[i][p] );
            dxyzdeta_map[p].add_scaled     (elem_point, dphideta_map[i][p]);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
            d2xyzdxi2_map[p].add_scaled    (elem_point, d2phidxi2_map[i][p]);
            d2xyzdxideta_map[p].add_scaled (elem_point, d2phidxideta_map[i][p]);
            d2xyzdeta2_map[p].add_scaled   (elem_point, d2phideta2_map[i][p]);
#endif
          }

        // compute the jacobian once
        const Real dx_dxi = dxdxi_map(p),
          dx_deta = dxdeta_map(p),
          dy_dxi = dydxi_map(p),
          dy_deta = dydeta_map(p);

#if LIBMESH_DIM == 2
        // Compute the Jacobian.  This assumes the 2D face
        // lives in 2D space
        //
        // Symbolically, the matrix determinant is
        //
        //         | dx/dxi  dx/deta |
        // jac =   | dy/dxi  dy/deta |
        //
        // jac = dx/dxi*dy/deta - dx/deta*dy/dxi
        jac[p] = (dx_dxi*dy_deta - dx_deta*dy_dxi);

        if (jac[p] <= 0.)
          libmesh_error_msg("ERROR: negative Jacobian: " << jac[p] << " in element " << elem->id());

        JxW[p] = jac[p]*qw[p];

        // Compute the shape function derivatives wrt x,y at the
        // quadrature points
        const Real inv_jac = 1./jac[p];

        dxidx_map[p]  =  dy_deta*inv_jac; //dxi/dx  =  (1/J)*dy/deta
        dxidy_map[p]  = -dx_deta*inv_jac; //dxi/dy  = -(1/J)*dx/deta
        detadx_map[p] = -dy_dxi* inv_jac; //deta/dx = -(1/J)*dy/dxi
        detady_map[p] =  dx_dxi* inv_jac; //deta/dy =  (1/J)*dx/dxi

        dxidz_map[p] = detadz_map[p] = 0.;
#else

        const Real dz_dxi = dzdxi_map(p),
          dz_deta = dzdeta_map(p);

        // Compute the Jacobian.  This assumes a 2D face in
        // 3D space.
        //
        // The transformation matrix T from local to global
        // coordinates is
        //
        //         | dx/dxi  dx/deta |
        //     T = | dy/dxi  dy/deta |
        //         | dz/dxi  dz/deta |
        // note det(T' T) = det(T')det(T) = det(T)det(T)
        // so det(T) = std::sqrt(det(T' T))
        //
        //----------------------------------------------
        // Notes:
        //
        //       dX = R dXi -> R'dX = R'R dXi
        // (R^-1)dX =   dXi    [(R'R)^-1 R']dX = dXi
        //
        // so R^-1 = (R'R)^-1 R'
        //
        // and R^-1 R = (R'R)^-1 R'R = I.
        //
        const Real g11 = (dx_dxi*dx_dxi +
                          dy_dxi*dy_dxi +
                          dz_dxi*dz_dxi);

        const Real g12 = (dx_dxi*dx_deta +
                          dy_dxi*dy_deta +
                          dz_dxi*dz_deta);

        const Real g21 = g12;

        const Real g22 = (dx_deta*dx_deta +
                          dy_deta*dy_deta +
                          dz_deta*dz_deta);

        const Real det = (g11*g22 - g12*g21);

        if (det <= 0.)
          libmesh_error_msg("ERROR: negative Jacobian! " << " in element " << elem->id());

        const Real inv_det = 1./det;
        jac[p] = std::sqrt(det);

        JxW[p] = jac[p]*qw[p];

        const Real g11inv =  g22*inv_det;
        const Real g12inv = -g12*inv_det;
        const Real g21inv = -g21*inv_det;
        const Real g22inv =  g11*inv_det;

        dxidx_map[p]  = g11inv*dx_dxi + g12inv*dx_deta;
        dxidy_map[p]  = g11inv*dy_dxi + g12inv*dy_deta;
        dxidz_map[p]  = g11inv*dz_dxi + g12inv*dz_deta;

        detadx_map[p] = g21inv*dx_dxi + g22inv*dx_deta;
        detady_map[p] = g21inv*dy_dxi + g22inv*dy_deta;
        detadz_map[p] = g21inv*dz_dxi + g22inv*dz_deta;

#endif
        // done computing the map
        break;
      }



      //--------------------------------------------------------------------
      // 3D
    case 3:
      {
        //------------------------------------------------------------------
        // Compute the (x,y,z) values at the quadrature points,
        // the Jacobian at the quadrature point

        // Clear the entities that will be summed
        xyz[p].zero           ();
        dxyzdxi_map[p].zero   ();
        dxyzdeta_map[p].zero  ();
        dxyzdzeta_map[p].zero ();
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
        d2xyzdxi2_map[p].zero();
        d2xyzdxideta_map[p].zero();
        d2xyzdxidzeta_map[p].zero();
        d2xyzdeta2_map[p].zero();
        d2xyzdetadzeta_map[p].zero();
        d2xyzdzeta2_map[p].zero();
#endif


        // compute (x,y,z) at the quadrature points,
        // dxdxi,   dydxi,   dzdxi,
        // dxdeta,  dydeta,  dzdeta,
        // dxdzeta, dydzeta, dzdzeta  all once
        for (unsigned int i=0; i<phi_map.size(); i++) // sum over the nodes
          {
            // Reference to the point, helps eliminate
            // exessive temporaries in the inner loop
            libmesh_assert(elem_nodes[i]);
            const Point& elem_point = *elem_nodes[i];

            xyz[p].add_scaled           (elem_point, phi_map[i][p]      );
            dxyzdxi_map[p].add_scaled   (elem_point, dphidxi_map[i][p]  );
            dxyzdeta_map[p].add_scaled  (elem_point, dphideta_map[i][p] );
            dxyzdzeta_map[p].add_scaled (elem_point, dphidzeta_map[i][p]);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
            d2xyzdxi2_map[p].add_scaled      (elem_point,
                                              d2phidxi2_map[i][p]);
            d2xyzdxideta_map[p].add_scaled   (elem_point,
                                              d2phidxideta_map[i][p]);
            d2xyzdxidzeta_map[p].add_scaled  (elem_point,
                                              d2phidxidzeta_map[i][p]);
            d2xyzdeta2_map[p].add_scaled     (elem_point,
                                              d2phideta2_map[i][p]);
            d2xyzdetadzeta_map[p].add_scaled (elem_point,
                                              d2phidetadzeta_map[i][p]);
            d2xyzdzeta2_map[p].add_scaled    (elem_point,
                                              d2phidzeta2_map[i][p]);
#endif
          }

        // compute the jacobian
        const Real
          dx_dxi   = dxdxi_map(p),   dy_dxi   = dydxi_map(p),   dz_dxi   = dzdxi_map(p),
          dx_deta  = dxdeta_map(p),  dy_deta  = dydeta_map(p),  dz_deta  = dzdeta_map(p),
          dx_dzeta = dxdzeta_map(p), dy_dzeta = dydzeta_map(p), dz_dzeta = dzdzeta_map(p);

        // Symbolically, the matrix determinant is
        //
        //         | dx/dxi   dy/dxi   dz/dxi   |
        // jac =   | dx/deta  dy/deta  dz/deta  |
        //         | dx/dzeta dy/dzeta dz/dzeta |
        //
        // jac = dx/dxi*(dy/deta*dz/dzeta - dz/deta*dy/dzeta) +
        //       dy/dxi*(dz/deta*dx/dzeta - dx/deta*dz/dzeta) +
        //       dz/dxi*(dx/deta*dy/dzeta - dy/deta*dx/dzeta)

        jac[p] = (dx_dxi*(dy_deta*dz_dzeta - dz_deta*dy_dzeta)  +
                  dy_dxi*(dz_deta*dx_dzeta - dx_deta*dz_dzeta)  +
                  dz_dxi*(dx_deta*dy_dzeta - dy_deta*dx_dzeta));

        if (jac[p] <= 0.)
          libmesh_error_msg("ERROR: negative Jacobian: " << jac[p] << " in element " << elem->id());

        JxW[p] = jac[p]*qw[p];

        // Compute the shape function derivatives wrt x,y at the
        // quadrature points
        const Real inv_jac  = 1./jac[p];

        dxidx_map[p]   = (dy_deta*dz_dzeta - dz_deta*dy_dzeta)*inv_jac;
        dxidy_map[p]   = (dz_deta*dx_dzeta - dx_deta*dz_dzeta)*inv_jac;
        dxidz_map[p]   = (dx_deta*dy_dzeta - dy_deta*dx_dzeta)*inv_jac;

        detadx_map[p]  = (dz_dxi*dy_dzeta  - dy_dxi*dz_dzeta )*inv_jac;
        detady_map[p]  = (dx_dxi*dz_dzeta  - dz_dxi*dx_dzeta )*inv_jac;
        detadz_map[p]  = (dy_dxi*dx_dzeta  - dx_dxi*dy_dzeta )*inv_jac;

        dzetadx_map[p] = (dy_dxi*dz_deta   - dz_dxi*dy_deta  )*inv_jac;
        dzetady_map[p] = (dz_dxi*dx_deta   - dx_dxi*dz_deta  )*inv_jac;
        dzetadz_map[p] = (dx_dxi*dy_deta   - dy_dxi*dx_deta  )*inv_jac;

        // done computing the map
        break;
      }

    default:
      libmesh_error_msg("Invalid dim = " << dim);
    }
}

Real libMesh::FEMap::dxdeta_map ( const unsigned int p ) const [inline, protected, inherited]

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

References libMesh::FEMap::dxyzdeta_map.

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

{ return dxyzdeta_map[p](0); }

Real libMesh::FEMap::dxdxi_map ( const unsigned int p ) const [inline, protected, inherited]

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

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().

{ return dxyzdxi_map[p](0); }

Real libMesh::FEMap::dxdzeta_map ( const unsigned int p ) const [inline, protected, inherited]

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

References libMesh::FEMap::dxyzdzeta_map.

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

{ return dxyzdzeta_map[p](0); }

Real libMesh::FEMap::dydeta_map ( const unsigned int p ) const [inline, protected, inherited]

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

References libMesh::FEMap::dxyzdeta_map.

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

{ return dxyzdeta_map[p](1); }

Real libMesh::FEMap::dydxi_map ( const unsigned int p ) const [inline, protected, inherited]

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

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().

{ return dxyzdxi_map[p](1); }

Real libMesh::FEMap::dydzeta_map ( const unsigned int p ) const [inline, protected, inherited]

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

References libMesh::FEMap::dxyzdzeta_map.

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

{ return dxyzdzeta_map[p](1); }

Real libMesh::FEMap::dzdeta_map ( const unsigned int p ) const [inline, protected, inherited]

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

References libMesh::FEMap::dxyzdeta_map.

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

{ return dxyzdeta_map[p](2); }

Real libMesh::FEMap::dzdxi_map ( const unsigned int p ) const [inline, protected, inherited]

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

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().

{ return dxyzdxi_map[p](2); }

Real libMesh::FEMap::dzdzeta_map ( const unsigned int p ) const [inline, protected, inherited]

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

References libMesh::FEMap::dxyzdzeta_map.

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

{ return dxyzdzeta_map[p](2); }

const std::vector<Real>& libMesh::FEMap::get_curvatures ( ) const [inline, inherited]

Returns:: the curvatures for use in face integration.

Definition at line 314 of file fe_map.h.

References libMesh::FEMap::curvatures.

  { return curvatures;}

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2phideta2_map ( ) [inline, inherited]

Returns:: the reference to physical map 2nd derivative

Definition at line 414 of file fe_map.h.

References libMesh::FEMap::d2phideta2_map.

  { return d2phideta2_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2phidetadzeta_map ( ) [inline, inherited]

Returns:: the reference to physical map 2nd derivative

Definition at line 420 of file fe_map.h.

References libMesh::FEMap::d2phidetadzeta_map.

  { return d2phidetadzeta_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2phidxi2_map ( ) [inline, inherited]

Returns:: the reference to physical map 2nd derivative

Definition at line 396 of file fe_map.h.

References libMesh::FEMap::d2phidxi2_map.

  { return d2phidxi2_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2phidxideta_map ( ) [inline, inherited]

Returns:: the reference to physical map 2nd derivative

Definition at line 402 of file fe_map.h.

References libMesh::FEMap::d2phidxideta_map.

  { return d2phidxideta_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2phidxidzeta_map ( ) [inline, inherited]

Returns:: the reference to physical map 2nd derivative

Definition at line 408 of file fe_map.h.

References libMesh::FEMap::d2phidxidzeta_map.

  { return d2phidxidzeta_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2phidzeta2_map ( ) [inline, inherited]

Returns:: the reference to physical map 2nd derivative

Definition at line 426 of file fe_map.h.

References libMesh::FEMap::d2phidzeta2_map.

  { return d2phidzeta2_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2psideta2 ( ) [inline, inherited]

Returns:: the reference to physical map 2nd derivative for the side/edge

Definition at line 365 of file fe_map.h.

References libMesh::FEMap::d2psideta2_map.

  { return d2psideta2_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2psidxi2 ( ) [inline, inherited]

Returns:: the reference to physical map 2nd derivative for the side/edge

Definition at line 353 of file fe_map.h.

References libMesh::FEMap::d2psidxi2_map.

  { return d2psidxi2_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_d2psidxideta ( ) [inline, inherited]

Returns:: the reference to physical map 2nd derivative for the side/edge

Definition at line 359 of file fe_map.h.

References libMesh::FEMap::d2psidxideta_map.

  { return d2psidxideta_map; }

const std::vector<RealGradient>& libMesh::FEMap::get_d2xyzdeta2 ( ) const [inline, inherited]

Returns:: the second partial derivatives in eta.

Definition at line 171 of file fe_map.h.

References libMesh::FEMap::d2xyzdeta2_map.

  { return d2xyzdeta2_map; }

const std::vector<RealGradient>& libMesh::FEMap::get_d2xyzdetadzeta ( ) const [inline, inherited]

Returns:: the second partial derivatives in eta-zeta.

Definition at line 201 of file fe_map.h.

References libMesh::FEMap::d2xyzdetadzeta_map.

  { return d2xyzdetadzeta_map; }

const std::vector<RealGradient>& libMesh::FEMap::get_d2xyzdxi2 ( ) const [inline, inherited]

Returns:: the second partial derivatives in xi.

Definition at line 165 of file fe_map.h.

References libMesh::FEMap::d2xyzdxi2_map.

  { return d2xyzdxi2_map; }

const std::vector<RealGradient>& libMesh::FEMap::get_d2xyzdxideta ( ) const [inline, inherited]

Returns:: the second partial derivatives in xi-eta.

Definition at line 187 of file fe_map.h.

References libMesh::FEMap::d2xyzdxideta_map.

  { return d2xyzdxideta_map; }

const std::vector<RealGradient>& libMesh::FEMap::get_d2xyzdxidzeta ( ) const [inline, inherited]

Returns:: the second partial derivatives in xi-zeta.

Definition at line 195 of file fe_map.h.

References libMesh::FEMap::d2xyzdxidzeta_map.

  { return d2xyzdxidzeta_map; }

const std::vector<RealGradient>& libMesh::FEMap::get_d2xyzdzeta2 ( ) const [inline, inherited]

Returns:: the second partial derivatives in zeta.

Definition at line 179 of file fe_map.h.

References libMesh::FEMap::d2xyzdzeta2_map.

  { return d2xyzdzeta2_map; }

const std::vector<Real>& libMesh::FEMap::get_detadx ( ) const [inline, inherited]

Returns:: the deta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 231 of file fe_map.h.

References libMesh::FEMap::detadx_map.

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().

  { return detadx_map; }

const std::vector<Real>& libMesh::FEMap::get_detady ( ) const [inline, inherited]

Returns:: the deta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 238 of file fe_map.h.

References libMesh::FEMap::detady_map.

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().

  { return detady_map; }

const std::vector<Real>& libMesh::FEMap::get_detadz ( ) const [inline, inherited]

Returns:: the deta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 245 of file fe_map.h.

References libMesh::FEMap::detadz_map.

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().

  { return detadz_map; }

const std::vector<std::vector<Real> >& libMesh::FEMap::get_dphideta_map ( ) const [inline, inherited]

Returns:: the reference to physical map derivative

Definition at line 290 of file fe_map.h.

References libMesh::FEMap::dphideta_map.

  { return dphideta_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_dphideta_map ( ) [inline, inherited]

Returns:: the reference to physical map derivative

Definition at line 383 of file fe_map.h.

References libMesh::FEMap::dphideta_map.

  { return dphideta_map; }

const std::vector<std::vector<Real> >& libMesh::FEMap::get_dphidxi_map ( ) const [inline, inherited]

Returns:: the reference to physical map derivative

Definition at line 284 of file fe_map.h.

References libMesh::FEMap::dphidxi_map.

  { return dphidxi_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_dphidxi_map ( ) [inline, inherited]

Returns:: the reference to physical map derivative

Definition at line 377 of file fe_map.h.

References libMesh::FEMap::dphidxi_map.

  { return dphidxi_map; }

const std::vector<std::vector<Real> >& libMesh::FEMap::get_dphidzeta_map ( ) const [inline, inherited]

Returns:: the reference to physical map derivative

Definition at line 296 of file fe_map.h.

References libMesh::FEMap::dphidzeta_map.

  { return dphidzeta_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_dphidzeta_map ( ) [inline, inherited]

Returns:: the reference to physical map derivative

Definition at line 389 of file fe_map.h.

References libMesh::FEMap::dphidzeta_map.

  { return dphidzeta_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_dpsideta ( ) [inline, inherited]

Returns:: the reference to physical map derivative for the side/edge

Definition at line 347 of file fe_map.h.

References libMesh::FEMap::dpsideta_map.

  { return dpsideta_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_dpsidxi ( ) [inline, inherited]

Returns:: the reference to physical map derivative for the side/edge

Definition at line 341 of file fe_map.h.

References libMesh::FEMap::dpsidxi_map.

  { return dpsidxi_map; }

const std::vector<Real>& libMesh::FEMap::get_dxidx ( ) const [inline, inherited]

Returns:: the dxi/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 210 of file fe_map.h.

References libMesh::FEMap::dxidx_map.

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().

  { return dxidx_map; }

const std::vector<Real>& libMesh::FEMap::get_dxidy ( ) const [inline, inherited]

Returns:: the dxi/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 217 of file fe_map.h.

References libMesh::FEMap::dxidy_map.

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().

  { return dxidy_map; }

const std::vector<Real>& libMesh::FEMap::get_dxidz ( ) const [inline, inherited]

Returns:: the dxi/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 224 of file fe_map.h.

References libMesh::FEMap::dxidz_map.

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().

  { return dxidz_map; }

const std::vector<RealGradient>& libMesh::FEMap::get_dxyzdeta ( ) const [inline, inherited]

Returns:: the element tangents in eta-direction at the quadrature points.

Definition at line 152 of file fe_map.h.

References libMesh::FEMap::dxyzdeta_map.

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

  { return dxyzdeta_map; }

const std::vector<RealGradient>& libMesh::FEMap::get_dxyzdxi ( ) const [inline, inherited]

Returns:: the element tangents in xi-direction at the quadrature points.

Definition at line 145 of file fe_map.h.

References libMesh::FEMap::dxyzdxi_map.

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

  { return dxyzdxi_map; }

const std::vector<RealGradient>& libMesh::FEMap::get_dxyzdzeta ( ) const [inline, inherited]

Returns:: the element tangents in zeta-direction at the quadrature points.

Definition at line 159 of file fe_map.h.

References libMesh::FEMap::dxyzdzeta_map.

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

  { return dxyzdzeta_map; }

const std::vector<Real>& libMesh::FEMap::get_dzetadx ( ) const [inline, inherited]

Returns:: the dzeta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 252 of file fe_map.h.

References libMesh::FEMap::dzetadx_map.

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().

  { return dzetadx_map; }

const std::vector<Real>& libMesh::FEMap::get_dzetady ( ) const [inline, inherited]

Returns:: the dzeta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 259 of file fe_map.h.

References libMesh::FEMap::dzetady_map.

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().

  { return dzetady_map; }

const std::vector<Real>& libMesh::FEMap::get_dzetadz ( ) const [inline, inherited]

Returns:: the dzeta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 266 of file fe_map.h.

References libMesh::FEMap::dzetadz_map.

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().

  { return dzetadz_map; }

const std::vector<Real>& libMesh::FEMap::get_jacobian ( ) const [inline, inherited]

Returns:: the element Jacobian for each quadrature point.

Definition at line 131 of file fe_map.h.

References libMesh::FEMap::jac.

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

  { return jac; }

const std::vector<Real>& libMesh::FEMap::get_JxW ( ) const [inline, inherited]

Returns:: the element Jacobian times the quadrature weight for each quadrature point.

Definition at line 138 of file fe_map.h.

References libMesh::FEMap::JxW.

  { return JxW; }

std::vector<Real>& libMesh::FEMap::get_JxW ( ) [inline, inherited]

Returns:: writable reference to the element Jacobian times the quadrature weight for each quadrature point.

Definition at line 436 of file fe_map.h.

References libMesh::FEMap::JxW.

  { return JxW; }

const std::vector<Point>& libMesh::FEMap::get_normals ( ) const [inline, inherited]

Returns:: the normal vectors for face integration.

Definition at line 308 of file fe_map.h.

References libMesh::FEMap::normals.

  { return normals; }

const std::vector<std::vector<Real> >& libMesh::FEMap::get_phi_map ( ) const [inline, inherited]

Returns:: the reference to physical map for the element

Definition at line 278 of file fe_map.h.

References libMesh::FEMap::phi_map.

  { return phi_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_phi_map ( ) [inline, inherited]

Returns:: the reference to physical map for the element

Definition at line 371 of file fe_map.h.

References libMesh::FEMap::phi_map.

  { return phi_map; }

const std::vector<std::vector<Real> >& libMesh::FEMap::get_psi ( ) const [inline, inherited]

Returns:: the reference to physical map for the side/edge

Definition at line 272 of file fe_map.h.

References libMesh::FEMap::psi_map.

  { return psi_map; }

std::vector<std::vector<Real> >& libMesh::FEMap::get_psi ( ) [inline, inherited]

Returns:: the reference to physical map for the side/edge

Definition at line 335 of file fe_map.h.

References libMesh::FEMap::psi_map.

  { return psi_map; }

const std::vector<std::vector<Point> >& libMesh::FEMap::get_tangents ( ) const [inline, inherited]

Returns:: the tangent vectors for face integration.

Definition at line 302 of file fe_map.h.

References libMesh::FEMap::tangents.

  { return tangents; }

const std::vector<Point>& libMesh::FEMap::get_xyz ( ) const [inline, inherited]

Returns:: the xyz spatial locations of the quadrature points on the element.

Definition at line 125 of file fe_map.h.

References libMesh::FEMap::xyz.

  { return xyz; }

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.

Start logging the shape function initialization

Stop logging the shape function initialization

Definition at line 469 of file fe_boundary.C.

References libMesh::FEMap::d2psidxi2_map, libMesh::Elem::default_order(), libMesh::FEMap::dpsidxi_map, libMesh::libmesh_assert(), libMesh::FEMap::psi_map, libMesh::START_LOG(), and libMesh::Elem::type().

{
  libmesh_assert(edge);

  START_LOG("init_edge_shape_functions()", "FEMap");

  // The element type and order to use in
  // the map
  const Order    mapping_order     (edge->default_order());
  const ElemType mapping_elem_type (edge->type());

  // The number of quadrature points.
  const unsigned int n_qp = cast_int<unsigned int>(qp.size());

  const unsigned int n_mapping_shape_functions =
    FE<Dim,LAGRANGE>::n_shape_functions (mapping_elem_type,
                                         mapping_order);

  // resize the vectors to hold current data
  // Psi are the shape functions used for the FE mapping
  this->psi_map.resize        (n_mapping_shape_functions);
  this->dpsidxi_map.resize    (n_mapping_shape_functions);
  this->d2psidxi2_map.resize  (n_mapping_shape_functions);

  for (unsigned int i=0; i<n_mapping_shape_functions; i++)
    {
      // Allocate space to store the values of the shape functions
      // and their first and second derivatives at the quadrature points.
      this->psi_map[i].resize        (n_qp);
      this->dpsidxi_map[i].resize    (n_qp);
      this->d2psidxi2_map[i].resize  (n_qp);

      // Compute the value of shape function i, and its first and
      // second derivatives at quadrature point p
      // (Lagrange shape functions are used for the mapping)
      for (unsigned int p=0; p<n_qp; p++)
        {
          this->psi_map[i][p]        = FE<1,LAGRANGE>::shape             (mapping_elem_type, mapping_order, i,    qp[p]);
          this->dpsidxi_map[i][p]    = FE<1,LAGRANGE>::shape_deriv       (mapping_elem_type, mapping_order, i, 0, qp[p]);
          this->d2psidxi2_map[i][p]  = FE<1,LAGRANGE>::shape_second_deriv(mapping_elem_type, mapping_order, i, 0, qp[p]);
        }
    }

  STOP_LOG("init_edge_shape_functions()", "FEMap");
}

template<unsigned int Dim>

void libMesh::FEMap::init_face_shape_functions	(	const std::vector< Point > &	qp,
		const Elem *	side
	)		`[inherited]`

Initalizes the reference to physical element map for a side. This is used for boundary integration.

Start logging the shape function initialization

Stop logging the shape function initialization

Definition at line 380 of file fe_boundary.C.

References libMesh::FEMap::d2psideta2_map, libMesh::FEMap::d2psidxi2_map, libMesh::FEMap::d2psidxideta_map, libMesh::Elem::default_order(), libMesh::FEMap::dpsideta_map, libMesh::FEMap::dpsidxi_map, libMesh::libmesh_assert(), libMesh::FEMap::psi_map, libMesh::START_LOG(), and libMesh::Elem::type().

{
  libmesh_assert(side);

  START_LOG("init_face_shape_functions()", "FEMap");

  // The element type and order to use in
  // the map
  const Order    mapping_order     (side->default_order());
  const ElemType mapping_elem_type (side->type());

  // The number of quadrature points.
  const unsigned int n_qp = cast_int<unsigned int>(qp.size());

  const unsigned int n_mapping_shape_functions =
    FE<Dim,LAGRANGE>::n_shape_functions (mapping_elem_type,
                                         mapping_order);

  // resize the vectors to hold current data
  // Psi are the shape functions used for the FE mapping
  this->psi_map.resize        (n_mapping_shape_functions);

  if (Dim > 1)
    {
      this->dpsidxi_map.resize    (n_mapping_shape_functions);
      this->d2psidxi2_map.resize  (n_mapping_shape_functions);
    }

  if (Dim == 3)
    {
      this->dpsideta_map.resize     (n_mapping_shape_functions);
      this->d2psidxideta_map.resize (n_mapping_shape_functions);
      this->d2psideta2_map.resize   (n_mapping_shape_functions);
    }

  for (unsigned int i=0; i<n_mapping_shape_functions; i++)
    {
      // Allocate space to store the values of the shape functions
      // and their first and second derivatives at the quadrature points.
      this->psi_map[i].resize        (n_qp);
      if (Dim > 1)
        {
          this->dpsidxi_map[i].resize    (n_qp);
          this->d2psidxi2_map[i].resize  (n_qp);
        }
      if (Dim == 3)
        {
          this->dpsideta_map[i].resize     (n_qp);
          this->d2psidxideta_map[i].resize (n_qp);
          this->d2psideta2_map[i].resize   (n_qp);
        }

      // Compute the value of shape function i, and its first and
      // second derivatives at quadrature point p
      // (Lagrange shape functions are used for the mapping)
      for (unsigned int p=0; p<n_qp; p++)
        {
          this->psi_map[i][p]        = FE<Dim-1,LAGRANGE>::shape             (mapping_elem_type, mapping_order, i,    qp[p]);
          if (Dim > 1)
            {
              this->dpsidxi_map[i][p]    = FE<Dim-1,LAGRANGE>::shape_deriv       (mapping_elem_type, mapping_order, i, 0, qp[p]);
              this->d2psidxi2_map[i][p]  = FE<Dim-1,LAGRANGE>::shape_second_deriv(mapping_elem_type, mapping_order, i, 0, qp[p]);
            }
          // libMesh::out << "this->d2psidxi2_map["<<i<<"][p]=" << d2psidxi2_map[i][p] << std::endl;

          // If we are in 3D, then our sides are 2D faces.
          // For the second derivatives, we must also compute the cross
          // derivative d^2() / dxi deta
          if (Dim == 3)
            {
              this->dpsideta_map[i][p]     = FE<Dim-1,LAGRANGE>::shape_deriv       (mapping_elem_type, mapping_order, i, 1, qp[p]);
              this->d2psidxideta_map[i][p] = FE<Dim-1,LAGRANGE>::shape_second_deriv(mapping_elem_type, mapping_order, i, 1, qp[p]);
              this->d2psideta2_map[i][p]   = FE<Dim-1,LAGRANGE>::shape_second_deriv(mapping_elem_type, mapping_order, i, 2, qp[p]);
            }
        }
    }


  STOP_LOG("init_face_shape_functions()", "FEMap");
}

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 60 of file fe_map.C.

References 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::dphideta_map, libMesh::FEMap::dphidxi_map, libMesh::FEMap::dphidzeta_map, libMesh::Elem::is_linear(), libMesh::FEMap::phi_map, libMesh::START_LOG(), and libMesh::Elem::type().

{
  // Start logging the reference->physical map initialization
  START_LOG("init_reference_to_physical_map()", "FEMap");

  // The number of quadrature points.
  const std::size_t n_qp = qp.size();

  // The element type and order to use in
  // the map
  const Order    mapping_order     (elem->default_order());
  const ElemType mapping_elem_type (elem->type());

  // Number of shape functions used to construt the map
  // (Lagrange shape functions are used for mapping)
  const unsigned int n_mapping_shape_functions =
    FE<Dim,LAGRANGE>::n_shape_functions (mapping_elem_type,
                                         mapping_order);

  this->phi_map.resize         (n_mapping_shape_functions);
  if (Dim > 0)
    {
      this->dphidxi_map.resize     (n_mapping_shape_functions);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
      this->d2phidxi2_map.resize   (n_mapping_shape_functions);
#endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
    }

  if (Dim > 1)
    {
      this->dphideta_map.resize  (n_mapping_shape_functions);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
      this->d2phidxideta_map.resize   (n_mapping_shape_functions);
      this->d2phideta2_map.resize     (n_mapping_shape_functions);
#endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
    }

  if (Dim > 2)
    {
      this->dphidzeta_map.resize (n_mapping_shape_functions);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
      this->d2phidxidzeta_map.resize  (n_mapping_shape_functions);
      this->d2phidetadzeta_map.resize (n_mapping_shape_functions);
      this->d2phidzeta2_map.resize    (n_mapping_shape_functions);
#endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
    }


  for (unsigned int i=0; i<n_mapping_shape_functions; i++)
    {
      this->phi_map[i].resize         (n_qp);
      if (Dim > 0)
        {
          this->dphidxi_map[i].resize     (n_qp);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
          this->d2phidxi2_map[i].resize     (n_qp);
          if (Dim > 1)
            {
              this->d2phidxideta_map[i].resize (n_qp);
              this->d2phideta2_map[i].resize (n_qp);
            }
          if (Dim > 2)
            {
              this->d2phidxidzeta_map[i].resize  (n_qp);
              this->d2phidetadzeta_map[i].resize (n_qp);
              this->d2phidzeta2_map[i].resize    (n_qp);
            }
#endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES

          if (Dim > 1)
            this->dphideta_map[i].resize  (n_qp);

          if (Dim > 2)
            this->dphidzeta_map[i].resize (n_qp);
        }
    }

  // Optimize for the *linear* geometric elements case:
  bool is_linear = elem->is_linear();

  switch (Dim)
    {

      //------------------------------------------------------------
      // 0D
    case 0:
      {
        for (unsigned int i=0; i<n_mapping_shape_functions; i++)
          for (std::size_t p=0; p<n_qp; p++)
            this->phi_map[i][p]      = FE<Dim,LAGRANGE>::shape (mapping_elem_type, mapping_order, i,    qp[p]);

        break;
      }

      //------------------------------------------------------------
      // 1D
    case 1:
      {
        // Compute the value of the mapping shape function i at quadrature point p
        // (Lagrange shape functions are used for mapping)
        if (is_linear)
          {
            for (unsigned int i=0; i<n_mapping_shape_functions; i++)
              {
                this->phi_map[i][0]      = FE<Dim,LAGRANGE>::shape       (mapping_elem_type, mapping_order, i,    qp[0]);
                this->dphidxi_map[i][0]  = FE<Dim,LAGRANGE>::shape_deriv (mapping_elem_type, mapping_order, i, 0, qp[0]);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                this->d2phidxi2_map[i][0] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 0, qp[0]);
#endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                for (std::size_t p=1; p<n_qp; p++)
                  {
                    this->phi_map[i][p]      = FE<Dim,LAGRANGE>::shape (mapping_elem_type, mapping_order, i,    qp[p]);
                    this->dphidxi_map[i][p]  = this->dphidxi_map[i][0];
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                    this->d2phidxi2_map[i][p] = this->d2phidxi2_map[i][0];
#endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                  }
              }
          }
        else
          for (unsigned int i=0; i<n_mapping_shape_functions; i++)
            for (std::size_t p=0; p<n_qp; p++)
              {
                this->phi_map[i][p]      = FE<Dim,LAGRANGE>::shape       (mapping_elem_type, mapping_order, i,    qp[p]);
                this->dphidxi_map[i][p]  = FE<Dim,LAGRANGE>::shape_deriv (mapping_elem_type, mapping_order, i, 0, qp[p]);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                this->d2phidxi2_map[i][p] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 0, qp[p]);
#endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
              }

        break;
      }
      //------------------------------------------------------------
      // 2D
    case 2:
      {
        // Compute the value of the mapping shape function i at quadrature point p
        // (Lagrange shape functions are used for mapping)
        if (is_linear)
          {
            for (unsigned int i=0; i<n_mapping_shape_functions; i++)
              {
                this->phi_map[i][0]      = FE<Dim,LAGRANGE>::shape       (mapping_elem_type, mapping_order, i,    qp[0]);
                this->dphidxi_map[i][0]  = FE<Dim,LAGRANGE>::shape_deriv (mapping_elem_type, mapping_order, i, 0, qp[0]);
                this->dphideta_map[i][0] = FE<Dim,LAGRANGE>::shape_deriv (mapping_elem_type, mapping_order, i, 1, qp[0]);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                this->d2phidxi2_map[i][0] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 0, qp[0]);
                this->d2phidxideta_map[i][0] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 1, qp[0]);
                this->d2phideta2_map[i][0] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 2, qp[0]);
#endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                for (std::size_t p=1; p<n_qp; p++)
                  {
                    this->phi_map[i][p]      = FE<Dim,LAGRANGE>::shape (mapping_elem_type, mapping_order, i,    qp[p]);
                    this->dphidxi_map[i][p]  = this->dphidxi_map[i][0];
                    this->dphideta_map[i][p] = this->dphideta_map[i][0];
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                    this->d2phidxi2_map[i][p] = this->d2phidxi2_map[i][0];
                    this->d2phidxideta_map[i][p] = this->d2phidxideta_map[i][0];
                    this->d2phideta2_map[i][p] = this->d2phideta2_map[i][0];
#endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                  }
              }
          }
        else
          for (unsigned int i=0; i<n_mapping_shape_functions; i++)
            for (std::size_t p=0; p<n_qp; p++)
              {
                this->phi_map[i][p]      = FE<Dim,LAGRANGE>::shape       (mapping_elem_type, mapping_order, i,    qp[p]);
                this->dphidxi_map[i][p]  = FE<Dim,LAGRANGE>::shape_deriv (mapping_elem_type, mapping_order, i, 0, qp[p]);
                this->dphideta_map[i][p] = FE<Dim,LAGRANGE>::shape_deriv (mapping_elem_type, mapping_order, i, 1, qp[p]);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                this->d2phidxi2_map[i][p] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 0, qp[p]);
                this->d2phidxideta_map[i][p] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 1, qp[p]);
                this->d2phideta2_map[i][p] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 2, qp[p]);
#endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
              }

        break;
      }

      //------------------------------------------------------------
      // 3D
    case 3:
      {
        // Compute the value of the mapping shape function i at quadrature point p
        // (Lagrange shape functions are used for mapping)
        if (is_linear)
          {
            for (unsigned int i=0; i<n_mapping_shape_functions; i++)
              {
                this->phi_map[i][0]      = FE<Dim,LAGRANGE>::shape       (mapping_elem_type, mapping_order, i,    qp[0]);
                this->dphidxi_map[i][0]  = FE<Dim,LAGRANGE>::shape_deriv (mapping_elem_type, mapping_order, i, 0, qp[0]);
                this->dphideta_map[i][0] = FE<Dim,LAGRANGE>::shape_deriv (mapping_elem_type, mapping_order, i, 1, qp[0]);
                this->dphidzeta_map[i][0] = FE<Dim,LAGRANGE>::shape_deriv (mapping_elem_type, mapping_order, i, 2, qp[0]);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                this->d2phidxi2_map[i][0] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 0, qp[0]);
                this->d2phidxideta_map[i][0] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 1, qp[0]);
                this->d2phideta2_map[i][0] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 2, qp[0]);
                this->d2phidxidzeta_map[i][0] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 3, qp[0]);
                this->d2phidetadzeta_map[i][0] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 4, qp[0]);
                this->d2phidzeta2_map[i][0] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 5, qp[0]);
#endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                for (std::size_t p=1; p<n_qp; p++)
                  {
                    this->phi_map[i][p]      = FE<Dim,LAGRANGE>::shape (mapping_elem_type, mapping_order, i,    qp[p]);
                    this->dphidxi_map[i][p]  = this->dphidxi_map[i][0];
                    this->dphideta_map[i][p] = this->dphideta_map[i][0];
                    this->dphidzeta_map[i][p] = this->dphidzeta_map[i][0];
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                    this->d2phidxi2_map[i][p] = this->d2phidxi2_map[i][0];
                    this->d2phidxideta_map[i][p] = this->d2phidxideta_map[i][0];
                    this->d2phideta2_map[i][p] = this->d2phideta2_map[i][0];
                    this->d2phidxidzeta_map[i][p] = this->d2phidxidzeta_map[i][0];
                    this->d2phidetadzeta_map[i][p] = this->d2phidetadzeta_map[i][0];
                    this->d2phidzeta2_map[i][p] = this->d2phidzeta2_map[i][0];
#endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                  }
              }
          }
        else
          for (unsigned int i=0; i<n_mapping_shape_functions; i++)
            for (std::size_t p=0; p<n_qp; p++)
              {
                this->phi_map[i][p]       = FE<Dim,LAGRANGE>::shape       (mapping_elem_type, mapping_order, i,    qp[p]);
                this->dphidxi_map[i][p]   = FE<Dim,LAGRANGE>::shape_deriv (mapping_elem_type, mapping_order, i, 0, qp[p]);
                this->dphideta_map[i][p]  = FE<Dim,LAGRANGE>::shape_deriv (mapping_elem_type, mapping_order, i, 1, qp[p]);
                this->dphidzeta_map[i][p] = FE<Dim,LAGRANGE>::shape_deriv (mapping_elem_type, mapping_order, i, 2, qp[p]);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
                this->d2phidxi2_map[i][p] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 0, qp[p]);
                this->d2phidxideta_map[i][p] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 1, qp[p]);
                this->d2phideta2_map[i][p] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 2, qp[p]);
                this->d2phidxidzeta_map[i][p] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 3, qp[p]);
                this->d2phidetadzeta_map[i][p] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 4, qp[p]);
                this->d2phidzeta2_map[i][p] = FE<Dim,LAGRANGE>::shape_second_deriv (mapping_elem_type, mapping_order, i, 5, qp[p]);
#endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
              }

        break;
      }

    default:
      libmesh_error_msg("Invalid Dim = " << Dim);
    }

  // Stop logging the reference->physical map initialization
  STOP_LOG("init_reference_to_physical_map()", "FEMap");
  return;
}

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

Prints the Jacobian times the weight for each quadrature point.

Definition at line 871 of file fe_map.C.

References libMesh::FEMap::JxW.

{
  for (unsigned int i=0; i<JxW.size(); ++i)
    os << " [" << i << "]: " <<  JxW[i] << std::endl;
}

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 879 of file fe_map.C.

References libMesh::FEMap::xyz.

{
  for (unsigned int i=0; i<xyz.size(); ++i)
    os << " [" << i << "]: " << xyz[i];
}

void libMesh::FEMap::resize_quadrature_map_vectors	(	const unsigned int	dim,
		unsigned int	n_qp
	)		`[protected, inherited]`

A utility function for use by compute_*_map

Definition at line 649 of file fe_map.C.

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

{
  // Resize the vectors to hold data at the quadrature points
  xyz.resize(n_qp);
  dxyzdxi_map.resize(n_qp);
  dxidx_map.resize(n_qp);
  dxidy_map.resize(n_qp); // 1D element may live in 2D ...
  dxidz_map.resize(n_qp); // ... or 3D
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
  d2xyzdxi2_map.resize(n_qp);
#endif
  if (dim > 1)
    {
      dxyzdeta_map.resize(n_qp);
      detadx_map.resize(n_qp);
      detady_map.resize(n_qp);
      detadz_map.resize(n_qp);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
      d2xyzdxideta_map.resize(n_qp);
      d2xyzdeta2_map.resize(n_qp);
#endif
      if (dim > 2)
        {
          dxyzdzeta_map.resize (n_qp);
          dzetadx_map.resize   (n_qp);
          dzetady_map.resize   (n_qp);
          dzetadz_map.resize   (n_qp);
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
          d2xyzdxidzeta_map.resize(n_qp);
          d2xyzdetadzeta_map.resize(n_qp);
          d2xyzdzeta2_map.resize(n_qp);
#endif
        }
    }

  jac.resize(n_qp);
  JxW.resize(n_qp);
}

Member Data Documentation

std::vector<Real> libMesh::FEMap::curvatures [protected, inherited]

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 735 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().

std::vector<std::vector<Real> > libMesh::FEMap::d2phideta2_map [protected, inherited]

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

Definition at line 668 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().

std::vector<std::vector<Real> > libMesh::FEMap::d2phidetadzeta_map [protected, inherited]

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

Definition at line 673 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().

std::vector<std::vector<Real> > libMesh::FEMap::d2phidxi2_map [protected, inherited]

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

Definition at line 653 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().

std::vector<std::vector<Real> > libMesh::FEMap::d2phidxideta_map [protected, inherited]

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

Definition at line 658 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().

std::vector<std::vector<Real> > libMesh::FEMap::d2phidxidzeta_map [protected, inherited]

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

Definition at line 663 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().

std::vector<std::vector<Real> > libMesh::FEMap::d2phidzeta2_map [protected, inherited]

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

Definition at line 678 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().

std::vector<std::vector<Real> > libMesh::FEMap::d2psideta2_map [protected, inherited]

Map for the second derivatives (in eta) of the side shape functions. Useful for computing the curvature at the quadrature points.

Definition at line 718 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().

std::vector<std::vector<Real> > libMesh::FEMap::d2psidxi2_map [protected, inherited]

Map for the second derivatives (in xi) of the side shape functions. Useful for computing the curvature at the quadrature points.

Definition at line 704 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().

std::vector<std::vector<Real> > libMesh::FEMap::d2psidxideta_map [protected, inherited]

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 711 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().

std::vector<RealGradient> libMesh::FEMap::d2xyzdeta2_map [protected, inherited]

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

Definition at line 548 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_d2xyzdeta2(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<RealGradient> libMesh::FEMap::d2xyzdetadzeta_map [protected, inherited]

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 562 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_d2xyzdetadzeta(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<RealGradient> libMesh::FEMap::d2xyzdxi2_map [protected, inherited]

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 536 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_d2xyzdxi2(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<RealGradient> libMesh::FEMap::d2xyzdxideta_map [protected, inherited]

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 542 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_d2xyzdxideta(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<RealGradient> libMesh::FEMap::d2xyzdxidzeta_map [protected, inherited]

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 556 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_d2xyzdxidzeta(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<RealGradient> libMesh::FEMap::d2xyzdzeta2_map [protected, inherited]

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

Definition at line 568 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_d2xyzdzeta2(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<Real> libMesh::FEMap::detadx_map [protected, inherited]

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

Definition at line 595 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_detadx(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<Real> libMesh::FEMap::detady_map [protected, inherited]

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

Definition at line 601 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_detady(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<Real> libMesh::FEMap::detadz_map [protected, inherited]

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

Definition at line 607 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_detadz(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<std::vector<Real> > libMesh::FEMap::dphideta_map [protected, inherited]

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

Definition at line 641 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().

std::vector<std::vector<Real> > libMesh::FEMap::dphidxi_map [protected, inherited]

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

Definition at line 636 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().

std::vector<std::vector<Real> > libMesh::FEMap::dphidzeta_map [protected, inherited]

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

Definition at line 646 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().

std::vector<std::vector<Real> > libMesh::FEMap::dpsideta_map [protected, inherited]

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

Definition at line 697 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().

std::vector<std::vector<Real> > libMesh::FEMap::dpsidxi_map [protected, inherited]

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

Definition at line 691 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().

std::vector<Real> libMesh::FEMap::dxidx_map [protected, inherited]

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

Definition at line 576 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_dxidx(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<Real> libMesh::FEMap::dxidy_map [protected, inherited]

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

Definition at line 582 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_dxidy(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<Real> libMesh::FEMap::dxidz_map [protected, inherited]

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

Definition at line 588 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_dxidz(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<RealGradient> libMesh::FEMap::dxyzdeta_map [protected, inherited]

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

Definition at line 524 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().

std::vector<RealGradient> libMesh::FEMap::dxyzdxi_map [protected, inherited]

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

Definition at line 518 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().

std::vector<RealGradient> libMesh::FEMap::dxyzdzeta_map [protected, inherited]

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

Definition at line 530 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().

std::vector<Real> libMesh::FEMap::dzetadx_map [protected, inherited]

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

Definition at line 614 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_dzetadx(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<Real> libMesh::FEMap::dzetady_map [protected, inherited]

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

Definition at line 620 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_dzetady(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<Real> libMesh::FEMap::dzetadz_map [protected, inherited]

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

Definition at line 626 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_dzetadz(), and libMesh::FEMap::resize_quadrature_map_vectors().

std::vector<Real> libMesh::FEMap::jac [protected, inherited]

Jacobian values at quadrature points

Definition at line 740 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().

std::vector<Real> libMesh::FEMap::JxW [protected, inherited]

Jacobian*Weight values at quadrature points

Definition at line 745 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().

std::vector<Point> libMesh::FEMap::normals [protected, inherited]

Normal vectors on boundary at quadrature points

Definition at line 728 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().

std::vector<std::vector<Real> > libMesh::FEMap::phi_map [protected, inherited]

Map for the shape function phi.

Definition at line 631 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().

std::vector<std::vector<Real> > libMesh::FEMap::psi_map [protected, inherited]

Map for the side shape functions, psi.

Definition at line 685 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().

std::vector<std::vector<Point> > libMesh::FEMap::tangents [protected, inherited]

Tangent vectors on boundary at quadrature points.

Definition at line 723 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().

std::vector<Point> libMesh::FEMap::xyz [protected, inherited]

The spatial locations of the quadrature points

Definition at line 512 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:

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation