fe::HexElem Class Reference

Trilinear hexahedron (VTK type 12) on reference cube [-1,1]^3. More...

#include <hexElem.h>

Inheritance diagram for fe::HexElem:

Collaboration diagram for fe::HexElem:

Public Member Functions
	HexElem (size_t order)
double	elemSize (const std::vector< util::Point > &nodes) override
	Returns the size of element (length in 1-d, area in 2-d, volume in 3-d element)
Public Member Functions inherited from fe::BaseElem
	BaseElem (size_t order, size_t element_type)
	Constructor.
size_t	getElemType ()
	Get element type.
size_t	getQuadOrder ()
	Get order of quadrature approximation.
size_t	getNumQuadPoints ()
	Get number of quadrature points in the data.
virtual std::vector< double >	getShapes (const util::Point &p, const std::vector< util::Point > &nodes)
	Returns the values of shape function at point p.
virtual std::vector< std::vector< double > >	getDerShapes (const util::Point &p, const std::vector< util::Point > &nodes)
	Returns the values of derivative of shape function at point p.
std::vector< fe::QuadData >	getQuadDatas (const std::vector< util::Point > &nodes)
	Get quadrature data mapped to the physical element (N, dN/dx, x, w, J). Shared isoparametric map; types only fill reference N, dN/dξ, and w.
std::vector< fe::QuadData >	getQuadPoints (const std::vector< util::Point > &nodes)
	Same as getQuadDatas without transforming dN/dξ to dN/dx.

Private Member Functions
std::vector< double >	getShapes (const util::Point &p) override
	Returns the values of shape function at point p on reference element.
std::vector< std::vector< double > >	getDerShapes (const util::Point &p) override
	Returns the values of derivative of shape function at point p on reference element.
double	getJacobian (const util::Point &p, const std::vector< util::Point > &nodes, std::vector< std::vector< double > > *J) override
	Computes Jacobian of map from reference element \( T^0 \) to given element \( T \).
void	init () override
	Compute the quadrature points.

Additional Inherited Members
Protected Member Functions inherited from fe::BaseElem
virtual util::Point	mapPointToRefElem (const util::Point &p, const std::vector< util::Point > &nodes)
	Maps point p in a given element to the reference element and returns the mapped point.
Protected Attributes inherited from fe::BaseElem
size_t	d_quadOrder
	Order of quadrature point integration approximation.
size_t	d_elemType
	Element type.
std::vector< fe::QuadData >	d_quads
	Quadrature data collection.

Detailed Description

Trilinear hexahedron (VTK type 12) on reference cube [-1,1]^3.

Node ordering matches VTK / createUniformMesh: bottom face 0-1-2-3 (ξ,η at ζ=-1), top face 4-5-6-7 (ζ=+1).

Definition at line 24 of file hexElem.h.

Constructor & Destructor Documentation

HexElem()

fe::HexElem::HexElem ( size_t  order )

explicit

Definition at line 27 of file hexElem.cpp.

    : fe::BaseElem(order, util::vtk_type_hexahedron) {
  this->init();
}

References init().

Here is the call graph for this function:

Member Function Documentation

elemSize()

double fe::HexElem::elemSize ( const std::vector< util::Point > &  nodes )

overridevirtual

Returns the size of element (length in 1-d, area in 2-d, volume in 3-d element)

Parameters

nodes

Vertices of element

Returns

size Size of the element

Implements fe::BaseElem.

Definition at line 32 of file hexElem.cpp.

                                                            {
  // Reference cube volume is 8; for a parallelepiped V = 8 * det(J(0,0,0)).
  // General hex: integrate |det J| with the stored reference quadrature.
  if (d_quads.empty())
    return 8. * getJacobian(util::Point(0., 0., 0.), nodes, nullptr);
  double vol = 0.;
  for (const auto &qd : d_quads)
    vol += qd.d_w * getJacobian(qd.d_p, nodes, nullptr);
  return vol;
}

getDerShapes()

std::vector< std::vector< double > > fe::HexElem::getDerShapes ( const util::Point &  p )

overrideprivatevirtual

Returns the values of derivative of shape function at point p on reference element.

Parameters

p	Location of point

Returns

vector Vector of derivative of shape functions

Implements fe::BaseElem.

Definition at line 52 of file hexElem.cpp.

                                          {
  std::vector<std::vector<double>> r(8, std::vector<double>(3, 0.));
  for (size_t i = 0; i < 8; ++i) {
    r[i][0] = 0.125 * SX[i] * (1. + SY[i] * p.d_y) * (1. + SZ[i] * p.d_z);
    r[i][1] = 0.125 * SY[i] * (1. + SX[i] * p.d_x) * (1. + SZ[i] * p.d_z);
    r[i][2] = 0.125 * SZ[i] * (1. + SX[i] * p.d_x) * (1. + SY[i] * p.d_y);
  }
  return r;
}

References util::Point::d_x, util::Point::d_y, and util::Point::d_z.

getJacobian()

double fe::HexElem::getJacobian ( const util::Point &  p, const std::vector< util::Point > &  nodes, std::vector< std::vector< double > > *  J  )

overrideprivatevirtual

Computes Jacobian of map from reference element \( T^0 \) to given element \( T \).

Parameters

p	Location of point in reference element
nodes	Vertices of element
J	Matrix to store the Jacobian

Returns

det(J) Determinant of the Jacobain

Implements fe::BaseElem.

Definition at line 62 of file hexElem.cpp.

                                                                 {
  auto der = getDerShapes(p);
  std::vector<std::vector<double>> Jloc(3, std::vector<double>(3, 0.));
  for (size_t a = 0; a < 8; ++a) {
    Jloc[0][0] += der[a][0] * nodes[a].d_x;
    Jloc[0][1] += der[a][0] * nodes[a].d_y;
    Jloc[0][2] += der[a][0] * nodes[a].d_z;
    Jloc[1][0] += der[a][1] * nodes[a].d_x;
    Jloc[1][1] += der[a][1] * nodes[a].d_y;
    Jloc[1][2] += der[a][1] * nodes[a].d_z;
    Jloc[2][0] += der[a][2] * nodes[a].d_x;
    Jloc[2][1] += der[a][2] * nodes[a].d_y;
    Jloc[2][2] += der[a][2] * nodes[a].d_z;
  }
  if (J != nullptr)
    *J = Jloc;
  return util::det(Jloc);
}

References util::det().

Here is the call graph for this function:

getShapes()

std::vector< double > fe::HexElem::getShapes ( const util::Point &  p )

overrideprivatevirtual

Returns the values of shape function at point p on reference element.

Parameters

p	Location of point

Returns

vector Vector of shape functions at point p

Implements fe::BaseElem.

Definition at line 43 of file hexElem.cpp.

                                                         {
  std::vector<double> N(8);
  for (size_t i = 0; i < 8; ++i)
    N[i] = 0.125 * (1. + SX[i] * p.d_x) * (1. + SY[i] * p.d_y) *
           (1. + SZ[i] * p.d_z);
  return N;
}

References util::Point::d_x, util::Point::d_y, and util::Point::d_z.

init()

void fe::HexElem::init ( )

overrideprivatevirtual

Compute the quadrature points.

This must be implemented by inheriting classes.

Implements fe::BaseElem.

Definition at line 83 of file hexElem.cpp.

                     {
  if (!d_quads.empty())
    return;
 
  if (d_quadOrder == 0) {
    d_quads.resize(0);
    return;
  }
 
  std::vector<std::vector<double>> ident(3, std::vector<double>(3, 0.));
  ident[0][0] = ident[1][1] = ident[2][2] = 1.;
 
  std::vector<double> x;
  std::vector<double> w;
  if (d_quadOrder == 1) {
    x = {0.};
    w = {2.};
  } else if (d_quadOrder == 2) {
    x = {-1. / std::sqrt(3.), 1. / std::sqrt(3.)};
    w = {1., 1.};
  } else {
    // order >= 3: 3-point Gauss on [-1,1]
    x = {-std::sqrt(3.) / std::sqrt(5.), 0., std::sqrt(3.) / std::sqrt(5.)};
    w = {5. / 9., 8. / 9., 5. / 9.};
  }
 
  const size_t npts = x.size();
  d_quads.clear();
  d_quads.reserve(npts * npts * npts);
  for (size_t i = 0; i < npts; ++i)
    for (size_t j = 0; j < npts; ++j)
      for (size_t k = 0; k < npts; ++k) {
        fe::QuadData qd;
        qd.d_w = w[i] * w[j] * w[k];
        qd.d_p = util::Point(x[i], x[j], x[k]);
        qd.d_shapes = getShapes(qd.d_p);
        qd.d_derShapes = getDerShapes(qd.d_p);
        qd.d_J = ident;
        qd.d_detJ = 1.;
        d_quads.push_back(qd);
      }
}

References fe::QuadData::d_derShapes, fe::QuadData::d_detJ, fe::QuadData::d_J, fe::QuadData::d_p, fe::QuadData::d_shapes, and fe::QuadData::d_w.

Referenced by HexElem().

Here is the caller graph for this function:

---

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

• /home/user/project/src/fe/hexElem.h
• /home/user/project/src/fe/hexElem.cpp