fe Namespace Reference

Data Structures
class	B
class	BaseElem
	A base class which provides methods to map points to/from reference element and to compute quadrature data. More...
class	HexElem
	Trilinear hexahedron (VTK type 12) on reference cube [-1,1]^3. More...
class	LineElem
	A class for mapping and quadrature related operations for linear 2-node line element. More...
struct	QuadData
	A struct to store the quadrature data. List of data are. More...
class	QuadElem
	A class for mapping and quadrature related operations for bi-linear quadrangle element. More...
class	TetElem
	A class for mapping and quadrature related operations for linear tetrahedron element. More...
class	TriElem
	A class for mapping and quadrature related operations for linear triangle element. More...

Functions
std::unique_ptr< BaseElem >	elem (size_t type, size_t order)
void	mapToPhysical (std::vector< QuadData > &qds, const std::vector< util::Point > &nodes, bool derivatives)

Function Documentation

elem()

std::unique_ptr< BaseElem > fe::elem ( size_t  type, size_t  order  )

inline

Definition at line 31 of file elemIncludes.h.

                                                               {
  if (type == util::vtk_type_line)
    return std::make_unique<LineElem>(order);
  if (type == util::vtk_type_triangle)
    return std::make_unique<TriElem>(order);
  if (type == util::vtk_type_quad)
    return std::make_unique<QuadElem>(order);
  if (type == util::vtk_type_tetra)
    return std::make_unique<TetElem>(order);
  if (type == util::vtk_type_hexahedron)
    return std::make_unique<HexElem>(order);
  throw std::runtime_error(
      util::io::Msg()
      << std::format("Error: element type = {} is not supported.\n", type));
}

References util::vtk_type_hexahedron, util::vtk_type_line, util::vtk_type_quad, util::vtk_type_tetra, and util::vtk_type_triangle.

Referenced by mesh::Mesh::computeVol(), mesh::getCurrentQuadPoints(), mesh::getMaxShearStressAndLoc(), mesh::getStrainStress(), and anonymous_namespace{quadratureData.cpp}::numQuadPoints().

Here is the caller graph for this function:

mapToPhysical()

void fe::mapToPhysical	(	std::vector< QuadData > &	qds,
		const std::vector< util::Point > &	nodes,
		bool	derivatives
	)

Isoparametric map for quadrature data already filled on the reference element (N, dN/dξ, w_ref, ξ). Writes J, det(J), physical x, w = w_ref det(J), and (if derivatives) dN/dx = J^{-1} dN/dξ.

Definition at line 14 of file map.cpp.

                                                                            {
  for (auto &qd : qds) {
    const auto n = qd.d_shapes.size();
    if (qd.d_derShapes.size() != n || n == 0 || qd.d_derShapes[0].empty())
      continue;
    const int dim = static_cast<int>(qd.d_derShapes[0].size());
 
    std::vector<std::vector<double>> J(dim, std::vector<double>(dim, 0.));
    for (int a = 0; a < static_cast<int>(n); a++)
      for (int alpha = 0; alpha < dim; alpha++)
        for (int j = 0; j < dim; j++)
          J[alpha][j] += qd.d_derShapes[a][alpha] * nodes[a][j];
 
    qd.d_J = J;
    qd.d_detJ = util::det(J);
    qd.d_w *= qd.d_detJ;
 
    qd.d_p = util::Point();
    for (size_t a = 0; a < n; a++)
      for (int j = 0; j < dim; j++)
        qd.d_p[j] += qd.d_shapes[a] * nodes[a][j];
 
    if (!derivatives)
      continue;
 
    const auto Jinv = util::inv(J);
    for (size_t a = 0; a < n; a++)
      qd.d_derShapes[a] = util::dot(Jinv, qd.d_derShapes[a]);
  }
}

References util::det(), util::dot(), and util::inv().

Referenced by fe::BaseElem::getQuadDatas(), and fe::BaseElem::getQuadPoints().

Here is the call graph for this function:

Here is the caller graph for this function: