MoFEM::Tools Struct Reference

Auxiliary tools. More...

#include <src/interfaces/Tools.hpp>

Inheritance diagram for MoFEM::Tools:

Collaboration diagram for MoFEM::Tools:

Public Member Functions
MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
	Tools (const MoFEM::Core &core)
Public Member Functions inherited from MoFEM::UnknownInterface
virtual MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const =0
template<class IFACE >
MoFEMErrorCode	registerInterface (bool error_if_registration_failed=true)
	Register interface. More...
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface refernce to pointer of interface. More...
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE **const iface) const
	Get interface pointer to pointer of interface. More...
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get interface pointer to pointer of interface. More...
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get reference to interface. More...
template<class IFACE >
IFACE *	getInterface () const
	Function returning pointer to interface. More...
virtual	~UnknownInterface ()=default

Static Public Member Functions
static MoFEMErrorCode	outerProductOfEdgeIntegrationPtsForQuad (MatrixDouble &pts, const int edge0, const int edge1)
static MoFEMErrorCode	outerProductOfEdgeIntegrationPtsForHex (MatrixDouble &pts, const int edge0, const int edge1, const int edge2)
Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode	getLibVersion (Version &version)
	Get library version. More...
static MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version)
	Get database major version. More...
static MoFEMErrorCode	setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
	Get database major version. More...
static MoFEMErrorCode	getInterfaceVersion (Version &version)
	Get database major version. More...

Public Attributes
MoFEM::Core &	cOre

Computational
enum	SEGMENT_MIN_DISTANCE {   SOLUTION_EXIST , SEGMENT_ONE_IS_POINT , SEGMENT_TWO_IS_POINT , SEGMENT_TWO_AND_TWO_ARE_POINT ,   NO_SOLUTION }
static constexpr double	shapeFunMBEDGE0At00 = N_MBEDGE0(0)
static constexpr double	shapeFunMBEDGE1At00 = N_MBEDGE1(0)
static constexpr std::array< double, 2 >	shapeFunMBEDGEAt00
	Array of shape function at zero local point on reference element. More...
static constexpr double	diffN_MBEDGE0x = diffN_MBEDGE0
static constexpr double	diffN_MBEDGE1x = diffN_MBEDGE1
static constexpr std::array< double, 2 >	diffShapeFunMBEDGE
static constexpr double	diffShapeFunMBTRI0x
	derivative of triangle shape function More...
static constexpr double	diffShapeFunMBTRI0y
	derivative of triangle shape function More...
static constexpr double	diffShapeFunMBTRI1x
	derivative of triangle shape function More...
static constexpr double	diffShapeFunMBTRI1y
	derivative of triangle shape function More...
static constexpr double	diffShapeFunMBTRI2x
	derivative of triangle shape function More...
static constexpr double	diffShapeFunMBTRI2y
	derivative of triangle shape function More...
static constexpr std::array< double, 6 >	diffShapeFunMBTRI
static constexpr double	shapeFunMBTRI0At00 = N_MBTRI0(0, 0)
static constexpr double	shapeFunMBTRI1At00 = N_MBTRI1(0, 0)
static constexpr double	shapeFunMBTRI2At00 = N_MBTRI2(0, 0)
static constexpr std::array< double, 3 >	shapeFunMBTRIAt00
	Array of shape function at zero local point on reference element. More...
static constexpr double	diffShapeFunMBQUADAtCenter0x
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBQUADAtCenter0y
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBQUADAtCenter1x
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBQUADAtCenter1y
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBQUADAtCenter2x
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBQUADAtCenter2y
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBQUADAtCenter3x
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBQUADAtCenter3y
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter0x
	derivative of HEX shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter0y
	derivative of HEX shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter0z
	derivative of HEX shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter1x
	derivative of HEX shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter1y
	derivative of HEX shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter1z
	derivative of HEX shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter2x
	derivative of HEX shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter2y
	derivative of HEX shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter2z
	derivative of HEX shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter3x
	derivative of HEX shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter3y
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter3z
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter4x
	derivative of HEX shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter4y
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter4z
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter5x
	derivative of HEX shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter5y
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter5z
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter6x
	derivative of HEX shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter6y
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter6z
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter7x
	derivative of HEX shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter7y
	derivative of quad shape function More...
static constexpr double	diffShapeFunMBHEXAtCenter7z
	derivative of quad shape function More...
static constexpr std::array< double, 8 >	diffShapeFunMBQUADAtCenter
static constexpr std::array< double, 24 >	diffShapeFunMBHEXAtCenter
static constexpr double	diffShapeFunMBTET0x
	derivative of tetrahedral shape function More...
static constexpr double	diffShapeFunMBTET0y
	derivative of tetrahedral shape function More...
static constexpr double	diffShapeFunMBTET0z
	derivative of tetrahedral shape function More...
static constexpr double	diffShapeFunMBTET1x
	derivative of tetrahedral shape function More...
static constexpr double	diffShapeFunMBTET1y
	derivative of tetrahedral shape function More...
static constexpr double	diffShapeFunMBTET1z
	derivative of tetrahedral shape function More...
static constexpr double	diffShapeFunMBTET2x
	derivative of tetrahedral shape function More...
static constexpr double	diffShapeFunMBTET2y
	derivative of tetrahedral shape function More...
static constexpr double	diffShapeFunMBTET2z
	derivative of tetrahedral shape function More...
static constexpr double	diffShapeFunMBTET3x
	derivative of tetrahedral shape function More...
static constexpr double	diffShapeFunMBTET3y
	derivative of tetrahedral shape function More...
static constexpr double	diffShapeFunMBTET3z
	derivative of tetrahedral shape function More...
static constexpr std::array< double, 12 >	diffShapeFunMBTET
static constexpr double	shapeFunMBTET0At000 = N_MBTET0(0, 0, 0)
static constexpr double	shapeFunMBTET1At000 = N_MBTET1(0, 0, 0)
static constexpr double	shapeFunMBTET2At000 = N_MBTET2(0, 0, 0)
static constexpr double	shapeFunMBTET3At000 = N_MBTET3(0, 0, 0)
static constexpr double	shapeFunMBTET0AtOneThird
static constexpr double	shapeFunMBTET1AtOneThird
static constexpr double	shapeFunMBTET2AtOneThird
static constexpr double	shapeFunMBTET3AtOneThird
static constexpr std::array< double, 4 >	shapeFunMBTETAt000
	Array of shape function at zero local point on reference element. More...
static constexpr std::array< double, 4 >	shapeFunMBTETAtOneThird
	Array of shape function at center on reference element. More...
MoFEMErrorCode	minTetsQuality (const Range &tets, double &min_quality, Tag th=nullptr, boost::function< double(double, double)> f=[](double a, double b) -> double { return std::min(a, b);})
	calculate minimal quality of tetrahedra in range More...
MoFEMErrorCode	getTetsWithQuality (Range &out_tets, const Range &tets, Tag th=nullptr, boost::function< bool(double)> f=[](double q) -> bool { if(q<=0) return true;else return false;})
	Get the Tets With Quality. More...
MoFEMErrorCode	writeTetsWithQuality (const char *file_name, const char *file_type, const char *options, const Range &tets, Tag th=nullptr, boost::function< bool(double)> f=[](double q) -> bool { if(q<=0) return true;else return false;})
	Write file with tetrahedral of given quality. More...
MoFEMErrorCode	getTriNormal (const EntityHandle tri, double *normal) const
	Get triangle normal. More...
double	getTriArea (const EntityHandle tri) const
	Get triangle area. More...
double	getEdgeLength (const EntityHandle edge)
	Get edge length. More...
MoFEMErrorCode	findMinDistanceFromTheEdges (const double *v_ptr, const int nb, Range edges, double *min_dist_ptr, double *o_ptr=nullptr, EntityHandle *o_segments=nullptr) const
	Find minimal distance to edges. More...
static double	volumeLengthQuality (const double *coords)
	Calculate tetrahedron volume length quality. More...
static double	tetVolume (const double *coords)
	Calculate volume of tetrahedron. More...
static double	shapeFunMBEDGE0 (const double x)
static double	shapeFunMBEDGE1 (const double x)
template<int LDB = 1>
static MoFEMErrorCode	shapeFunMBEDGE (double *shape, const double *ksi, const int nb)
	Calculate shape functions on edge. More...
static double	shapeFunMBTRI0 (const double x, const double y)
static double	shapeFunMBTRI1 (const double x, const double y)
static double	shapeFunMBTRI2 (const double x, const double y)
template<int LDB = 1>
static MoFEMErrorCode	shapeFunMBTRI (double *shape, const double *ksi, const double *eta, const int nb)
	Calculate shape functions on triangle. More...
static double	shapeFunMBTET0 (const double x, const double y, const double z)
static double	shapeFunMBTET1 (const double x, const double y, const double z)
static double	shapeFunMBTET2 (const double x, const double y, const double z)
static double	shapeFunMBTET3 (const double x, const double y, const double z)
template<int LDB = 1>
static MoFEMErrorCode	shapeFunMBTET (double *shape, const double *ksi, const double *eta, const double *zeta, const double nb)
	Calculate shape functions on tetrahedron. More...
static MoFEMErrorCode	getLocalCoordinatesOnReferenceFourNodeTet (const double *elem_coords, const double *glob_coords, const int nb_nodes, double *local_coords)
	Get the Local Coordinates On Reference Four Node Tet object. More...
static MoFEMErrorCode	getLocalCoordinatesOnReferenceTriNodeTri (const double *elem_coords, const double *glob_coords, const int nb_nodes, double *local_coords)
	Get the Local Coordinates On Reference Four Node Tet object. More...
static MoFEMErrorCode	getLocalCoordinatesOnReferenceEdgeNodeEdge (const double *elem_coords, const double *glob_coords, const int nb_nodes, double *local_coords)
	Get the Local Coordinates On Reference Four Node Tet object. More...
static MoFEMErrorCode	checkIfPointIsInTet (const double tet_coords[], const double global_coord[], const double tol, bool &result)
	Check of point is in tetrahedral. More...
static MoFEMErrorCode	getTriNormal (const double *coords, double *normal)
	Get the Tri Normal objectGet triangle normal. More...
static double	getEdgeLength (const double *edge_coords)
	Get edge length. More...
static SEGMENT_MIN_DISTANCE	minDistancePointFromOnSegment (const double *w_ptr, const double *v_ptr, const double *p_ptr, double *const t_ptr=nullptr)
	Find closet point on the segment from the point. More...
static SEGMENT_MIN_DISTANCE	minDistanceFromSegments (const double *w_ptr, const double *v_ptr, const double *k_ptr, const double *l_ptr, double *const tvw_ptr=nullptr, double *const tlk_ptr=nullptr)
	Find points on two segments in closest distance. More...

Debugging
MoFEMErrorCode	checkVectorForNotANumber (const Problem *prb_ptr, const RowColData row_or_col, Vec v)
	Print all DOFs for which element of vector is not a number. More...

Detailed Description

Auxiliary tools.

Definition at line 19 of file Tools.hpp.

Member Enumeration Documentation

SEGMENT_MIN_DISTANCE

enum MoFEM::Tools::SEGMENT_MIN_DISTANCE

Enumerator
SOLUTION_EXIST
SEGMENT_ONE_IS_POINT
SEGMENT_TWO_IS_POINT
SEGMENT_TWO_AND_TWO_ARE_POINT
NO_SOLUTION

Definition at line 507 of file Tools.hpp.

                            {
    SOLUTION_EXIST,
    SEGMENT_ONE_IS_POINT,
    SEGMENT_TWO_IS_POINT,
    SEGMENT_TWO_AND_TWO_ARE_POINT,
    NO_SOLUTION
  };

Constructor & Destructor Documentation

Tools()

MoFEM::Tools::Tools ( const MoFEM::Core &  core )

inline

Definition at line 25 of file Tools.hpp.

: cOre(const_cast<MoFEM::Core &>(core)) {}

Member Function Documentation

checkIfPointIsInTet()

MoFEMErrorCode MoFEM::Tools::checkIfPointIsInTet ( const double  tet_coords[], const double  global_coord[], const double  tol, bool &  result  )

static

Check of point is in tetrahedral.

Parameters

tet_coords
global_coord
tol
result

Returns

MoFEMErrorCode

Definition at line 286 of file Tools.cpp.

                                                                          {
  double loc_coord[] = {0, 0, 0};
  double N[4], diffN[12];
  MoFEMFunctionBegin;
  CHKERR ShapeDiffMBTET(diffN);
  CHKERR ShapeMBTET(N, &loc_coord[0], &loc_coord[1], &loc_coord[2], 1);
  CHKERR ShapeMBTET_inverse(N, diffN, tet_coords, global_coord, loc_coord);
  CHKERR ShapeMBTET(N, &loc_coord[0], &loc_coord[1], &loc_coord[2], 1);
  result = true;
  for (int n = 0; n != 4; ++n) {
    if (N[n] < -tol || (N[n] - 1) > tol) {
      result = false;
      break;
    }
  }
  MoFEMFunctionReturn(0);
}

checkVectorForNotANumber()

MoFEMErrorCode MoFEM::Tools::checkVectorForNotANumber	(	const Problem *	prb_ptr,
		const RowColData	row_or_col,
		Vec	v
	)

Print all DOFs for which element of vector is not a number.

Definition at line 306 of file Tools.cpp.

                                                      {
  MoFEMFunctionBegin;
  int loc_size;
  CHKERR VecGetLocalSize(v, &loc_size);
  int prb_loc_size = 0;
  boost::shared_ptr<NumeredDofEntity_multiIndex> prb_dofs;
  switch (row_or_col) {
  case ROW:
    prb_loc_size = prb_ptr->getNbLocalDofsRow();
    prb_dofs = prb_ptr->getNumeredRowDofsPtr();
    break;
  case COL:
    prb_loc_size = prb_ptr->getNbLocalDofsCol();
    prb_dofs = prb_ptr->getNumeredColDofsPtr();
    break;
    break;
  default:
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Wrong argument, row_or_col should be row or column");
  }
  if (loc_size != prb_loc_size) {
    SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "Inconsistent size of vector and problem %d != %d", loc_size,
             prb_loc_size);
  }
  const double *a;
  CHKERR VecGetArrayRead(v, &a);
  MPI_Comm comm = PetscObjectComm((PetscObject)v);
  for (int ii = 0; ii != loc_size; ++ii) {
    if (!boost::math::isfinite(a[ii])) {
      NumeredDofEntityByLocalIdx::iterator dit =
          prb_dofs->get<PetscLocalIdx_mi_tag>().find(ii);
      std::ostringstream ss;
      ss << "Not a number " << a[ii] << " on dof: " << endl
         << **dit << endl
         << endl;
      PetscSynchronizedPrintf(comm, "%s", ss.str().c_str());
    }
  }
  CHKERR VecRestoreArrayRead(v, &a);
  PetscSynchronizedFlush(comm, PETSC_STDOUT);
  MoFEMFunctionReturn(0);
}

findMinDistanceFromTheEdges()

MoFEMErrorCode MoFEM::Tools::findMinDistanceFromTheEdges	(	const double *	v_ptr,
		const int	nb,
		Range	edges,
		double *	min_dist_ptr,
		double *	o_ptr = nullptr,
		EntityHandle *	o_segments = nullptr
	)		const

Find minimal distance to edges.

Note

Finding only edges with have smaller distance than distance set on the input by min_dist_ptr

Parameters

v_ptr	point coordinates
nb	nb points
edges	range of edges
min_dist_ptr	on return minimal distance, on input starting distance
o_ptr	coordinates of the point on edge
o_segments	closest segments

Returns

MoFEMErrorCode

Definition at line 504 of file Tools.cpp.

                                                   {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  MoFEMFunctionBegin;
 
  FTensor::Index<'i', 3> i;
 
  auto get_point = [i](auto &t_w, auto &t_delta, auto t) {
    FTensor::Tensor1<double, 3> t_p;
    t = std::max(0., std::min(1., t));
    t_p(i) = t_w(i) + t * t_delta(i);
    return t_p;
  };
 
  auto get_distance = [i](auto &t_p, auto &t_n) {
    FTensor::Tensor1<double, 3> t_dist_vector;
    t_dist_vector(i) = t_p(i) - t_n(i);
    return sqrt(t_dist_vector(i) * t_dist_vector(i));
  };
 
  for (auto e : edges) {
 
    int num_nodes;
    const EntityHandle *conn_fixed;
    CHKERR moab.get_connectivity(e, conn_fixed, num_nodes, true);
    VectorDouble6 coords_fixed(6);
    CHKERR moab.get_coords(conn_fixed, num_nodes, &coords_fixed[0]);
    FTensor::Tensor1<FTensor::PackPtr<double *, 3>, 3> t_f0(
        &coords_fixed[0], &coords_fixed[1], &coords_fixed[2]);
    FTensor::Tensor1<FTensor::PackPtr<double *, 3>, 3> t_f1(
        &coords_fixed[3], &coords_fixed[4], &coords_fixed[5]);
 
    FTensor::Tensor1<double, 3> t_edge_delta;
    t_edge_delta(i) = t_f1(i) - t_f0(i);
 
    FTensor::Tensor1<FTensor::PackPtr<const double *, 3>, 3> t_n(
        v_ptr, v_ptr + 1, v_ptr + 2);
    FTensor::Tensor1<FTensor::PackPtr<double *, 3>, 3> t_min_coords(
        o_ptr, o_ptr + 1, o_ptr + 2);
    FTensor::Tensor0<FTensor::PackPtr<double *, 1>> t_min_dist(min_dist_ptr);
 
    EntityHandle *colsest_segment_it = nullptr;
    if (o_segments)
      colsest_segment_it = o_segments;
 
    for (int n = 0; n != nb; ++n) {
 
      double t;
      if (Tools::minDistancePointFromOnSegment(&t_f0(0), &t_f1(0), &t_n(0),
                                               &t) == Tools::SOLUTION_EXIST) {
        auto t_p = get_point(t_f0, t_edge_delta, t);
        auto dist_n = get_distance(t_p, t_n);
        if (dist_n < t_min_dist || t_min_dist < 0) {
          t_min_dist = dist_n;
          if (o_ptr)
            t_min_coords(i) = t_p(i);
          if (o_segments)
            *colsest_segment_it = e;
        }
      }
 
      ++t_n;
      ++t_min_dist;
      if (o_ptr)
        ++t_min_coords;
      if (o_segments)
        ++colsest_segment_it;
    }
  }
 
  MoFEMFunctionReturn(0);
}

getEdgeLength() [1/2]

double MoFEM::Tools::getEdgeLength ( const double *  edge_coords )

static

Get edge length.

Parameters

edge_coords

Returns

double

Definition at line 384 of file Tools.cpp.

                                                     {
  FTensor::Tensor1<double, 3> t_coords_n0(edge_coords[0], edge_coords[1],
                                          edge_coords[2]);
  FTensor::Tensor1<double, 3> t_coords_n1(edge_coords[3], edge_coords[4],
                                          edge_coords[5]);
  FTensor::Index<'i', 3> i;
  t_coords_n0(i) -= t_coords_n1(i);
  return sqrt(t_coords_n0(i) * t_coords_n0(i));
}

getEdgeLength() [2/2]

double MoFEM::Tools::getEdgeLength

(

const EntityHandle

edge

)

Get edge length.

Parameters

edge

Returns

double

Definition at line 394 of file Tools.cpp.

                                                   {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  auto get_edge_coords = [edge, &moab](double *const coords) {
    MoFEMFunctionBegin;
    if (type_from_handle(edge) != MBEDGE) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "Works only for edge");
    }
    const EntityHandle *conn;
    int num_nodes;
    CHKERR moab.get_connectivity(edge, conn, num_nodes, true);
    CHKERR moab.get_coords(conn, 2, coords);
    MoFEMFunctionReturn(0);
  };
  double coords[6];
  ierr = get_edge_coords(coords);
  CHKERRABORT(PETSC_COMM_SELF, ierr);
  return getEdgeLength(coords);
}

getLocalCoordinatesOnReferenceEdgeNodeEdge()

MoFEMErrorCode MoFEM::Tools::getLocalCoordinatesOnReferenceEdgeNodeEdge ( const double *  elem_coords, const double *  glob_coords, const int  nb_nodes, double *  local_coords  )

static

Get the Local Coordinates On Reference Four Node Tet object.

MatrixDouble elem_coords(4, 3);
// Set nodal coordinates
MatrixDouble global_coords(5, 3);
// Set global coordinates
MatrixDouble local_coords(global_coords.size1(), 3);
CHKERR Tools::getLocalCoordinatesOnReferenceFourNodeTet(
    &elem_coords(0, 0), &global_coords(0, 0), global_coords.size1(),
    &local_coords(0, 0))

Parameters

elem_coords	Global element node coordinates
glob_coords	Globale coordinates
nb_nodes	Number of points
local_coords	Result

Returns

MoFEMErrorCode

Definition at line 200 of file Tools.cpp.

                          {
 
  FTensor::Index<'i', 3> i3;
  MoFEMFunctionBeginHot;
 
  FTensor::Tensor1<FTensor::PackPtr<const double *, 1>, 3> t_elem_coords = {
      &elem_coords[0], &elem_coords[3], &elem_coords[6]};
 
  FTensor::Tensor1<const double, 2> t_n = {shapeFunMBEDGEAt00[0],
                                           shapeFunMBEDGEAt00[1]};
  FTensor::Tensor1<double, 3> t_coords_at_0;
  // Build matrix and get coordinates of zero point
  // ii - global coordinates
  FTensor::Tensor1<double, 3> t_a;
  for (auto ii : {0, 1, 2}) {
    t_a(ii) = diffShapeFunMBEDGE[0] * t_elem_coords(0) +
              diffShapeFunMBEDGE[1] * t_elem_coords(1);
    t_coords_at_0(ii) = shapeFunMBEDGEAt00[0] * t_elem_coords(0) +
                        shapeFunMBEDGEAt00[1] * t_elem_coords(1);
    ++t_elem_coords;
  }
 
  FTensor::Tensor1<FTensor::PackPtr<const double *, 3>, 3> t_global_coords = {
      &global_coords[0], &global_coords[1], &global_coords[2]};
  FTensor::Tensor0<FTensor::PackPtr<double *, 1>> t_local_coords = {
      &local_coords[0]};
 
  const double b = t_a(i3) * t_a(i3);
  const double inv_b = 1 / b;
 
  // Calculate right hand side
  for (int ii = 0; ii != nb_nodes; ++ii) {
    t_local_coords =
        inv_b * (t_a(i3) * (t_global_coords(i3) - t_coords_at_0(i3)));
    ++t_local_coords;
    ++t_global_coords;
  }
 
  MoFEMFunctionReturnHot(0);
}

getLocalCoordinatesOnReferenceFourNodeTet()

MoFEMErrorCode MoFEM::Tools::getLocalCoordinatesOnReferenceFourNodeTet ( const double *  elem_coords, const double *  glob_coords, const int  nb_nodes, double *  local_coords  )

static

Get the Local Coordinates On Reference Four Node Tet object.

MatrixDouble elem_coords(4, 3);
// Set nodal coordinates
MatrixDouble global_coords(5, 3);
// Set global coordinates
MatrixDouble local_coords(global_coords.size1(), 3);
CHKERR Tools::getLocalCoordinatesOnReferenceFourNodeTet(
    &elem_coords(0, 0), &global_coords(0, 0), global_coords.size1(),
    &local_coords(0, 0))

Parameters

elem_coords	Global element node coordinates
glob_coords	Globale coordinates
nb_nodes	Number of points
local_coords	Result

Returns

MoFEMErrorCode

Definition at line 90 of file Tools.cpp.

                          {
  FTensor::Index<'i', 4> i;
  MoFEMFunctionBeginHot;
 
  FTensor::Tensor1<FTensor::PackPtr<const double *, 1>, 4> t_elem_coords = {
      &elem_coords[0], &elem_coords[3], &elem_coords[6], &elem_coords[9]};
 
  FTensor::Tensor1<const double, 4> t_n = {
      shapeFunMBTETAt000[0], shapeFunMBTETAt000[1], shapeFunMBTETAt000[2],
      shapeFunMBTETAt000[3]};
  FTensor::Tensor1<double, 3> t_coords_at_0;
 
  // Build matrix and get coordinates of zero point
  // ii - global coordinates
  // jj - local derivatives
  MatrixDouble3by3 a(3, 3);
  for (auto ii : {0, 1, 2}) {
    FTensor::Tensor1<FTensor::PackPtr<const double *, 1>, 4> t_diff(
        &diffShapeFunMBTET[0], &diffShapeFunMBTET[3], &diffShapeFunMBTET[6],
        &diffShapeFunMBTET[9]);
    for (auto jj : {0, 1, 2}) {
      a(jj, ii) = t_diff(i) * t_elem_coords(i);
      ++t_diff;
    }
    t_coords_at_0(ii) = t_n(i) * t_elem_coords(i);
    ++t_elem_coords;
  }
 
  FTensor::Tensor1<FTensor::PackPtr<const double *, 3>, 3> t_global_coords = {
      &global_coords[0], &global_coords[1], &global_coords[2]};
  FTensor::Tensor1<FTensor::PackPtr<double *, 3>, 3> t_local_coords = {
      &local_coords[0], &local_coords[1], &local_coords[2]};
 
  // Calculate right hand side
  FTensor::Index<'j', 3> j;
  for (int ii = 0; ii != nb_nodes; ++ii) {
    t_local_coords(j) = t_global_coords(j) - t_coords_at_0(j);
    ++t_local_coords;
    ++t_global_coords;
  }
 
  // Solve problem
  int IPIV[3];
  int info = lapack_dgesv(3, nb_nodes, &a(0, 0), 3, IPIV, local_coords, 3);
  if (info != 0)
    SETERRQ1(PETSC_COMM_SELF, 1, "info == %d", info);
 
  MoFEMFunctionReturnHot(0);
}

getLocalCoordinatesOnReferenceTriNodeTri()

MoFEMErrorCode MoFEM::Tools::getLocalCoordinatesOnReferenceTriNodeTri ( const double *  elem_coords, const double *  glob_coords, const int  nb_nodes, double *  local_coords  )

static

Get the Local Coordinates On Reference Four Node Tet object.

MatrixDouble elem_coords(4, 3);
// Set nodal coordinates
MatrixDouble global_coords(5, 3);
// Set global coordinates
MatrixDouble local_coords(global_coords.size1(), 3);
CHKERR Tools::getLocalCoordinatesOnReferenceFourNodeTet(
    &elem_coords(0, 0), &global_coords(0, 0), global_coords.size1(),
    &local_coords(0, 0))

Parameters

elem_coords	Global element node coordinates
glob_coords	Globale coordinates
nb_nodes	Number of points
local_coords	Result

Returns

MoFEMErrorCode

Definition at line 142 of file Tools.cpp.

                          {
 
  FTensor::Index<'i', 3> i3;
  FTensor::Index<'j', 3> j3;
  FTensor::Index<'K', 2> K2;
  FTensor::Index<'L', 2> L2;
  MoFEMFunctionBeginHot;
 
  FTensor::Tensor1<FTensor::PackPtr<const double *, 1>, 3> t_elem_coords = {
      &elem_coords[0], &elem_coords[3], &elem_coords[6]};
 
  FTensor::Tensor1<const double, 3> t_n = {
      shapeFunMBTRIAt00[0], shapeFunMBTRIAt00[1], shapeFunMBTRIAt00[2]};
  FTensor::Tensor1<double, 3> t_coords_at_0;
 
  // Build matrix and get coordinates of zero point
  // ii - global coordinates
  // jj - local derivatives
  FTensor::Tensor2<double, 2, 3> t_a;
  for (auto ii : {0, 1, 2}) {
    FTensor::Tensor1<FTensor::PackPtr<const double *, 1>, 3> t_diff(
        &diffShapeFunMBTRI[0], &diffShapeFunMBTRI[2], &diffShapeFunMBTRI[4]);
    for (auto jj : {0, 1}) {
      t_a(jj, ii) = t_diff(i3) * t_elem_coords(i3);
      ++t_diff;
    }
    t_coords_at_0(ii) = t_n(i3) * t_elem_coords(i3);
    ++t_elem_coords;
  }
 
  FTensor::Tensor1<FTensor::PackPtr<const double *, 3>, 3> t_global_coords = {
      &global_coords[0], &global_coords[1], &global_coords[2]};
  FTensor::Tensor1<FTensor::PackPtr<double *, 2>, 2> t_local_coords = {
      &local_coords[0], &local_coords[1]};
 
  FTensor::Tensor2_symmetric<double, 2> t_b, t_inv_b;
  t_b(K2, L2) = t_a(K2, j3) ^ t_a(L2, j3);
 
  // Solve problem
  const auto inv_det = 1. / (t_b(0, 0) * t_b(1, 1) - t_b(0, 1) * t_b(1, 0));
  t_inv_b(0, 0) = t_b(1, 1) * inv_det;
  t_inv_b(0, 1) = -t_b(0, 1) * inv_det;
  t_inv_b(1, 1) = t_b(0, 0) * inv_det;
 
  // Calculate right hand side
  for (int ii = 0; ii != nb_nodes; ++ii) {
    t_local_coords(L2) =
        t_inv_b(L2, K2) *
        (t_a(K2, j3) * (t_global_coords(j3) - t_coords_at_0(j3)));
    ++t_local_coords;
    ++t_global_coords;
  }
 
  MoFEMFunctionReturnHot(0);
}

getTetsWithQuality()

MoFEMErrorCode MoFEM::Tools::getTetsWithQuality	(	Range &	out_tets,
		const Range &	tets,
		Tag	th = nullptr,
		boost::function< bool(double)>	f = [](double q) -> bool { if (q <= 0) return true; else return false; }
	)

Get the Tets With Quality.

Parameters

out_tets
tets
th
f

Returns

MoFEMErrorCode

Definition at line 243 of file Tools.cpp.

                                                                        {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  MoFEMFunctionBegin;
  Range to_write;
  const EntityHandle *conn;
  int num_nodes;
  double coords[12];
  for (auto tet : tets) {
    CHKERR m_field.get_moab().get_connectivity(tet, conn, num_nodes, true);
    if (th) {
      CHKERR moab.tag_get_data(th, conn, num_nodes, coords);
    } else {
      CHKERR moab.get_coords(conn, num_nodes, coords);
    }
    double q = Tools::volumeLengthQuality(coords);
    if (f(q)) {
      out_tets.insert(tet);
    }
  }
  MoFEMFunctionReturn(0);
}

getTriArea()

double MoFEM::Tools::getTriArea

(

const EntityHandle

tri

)

const

Get triangle area.

Parameters

tri

Returns

double

Definition at line 377 of file Tools.cpp.

                                                     {
  FTensor::Index<'i', 3> i;
  FTensor::Tensor1<double, 3> t_normal;
  CHK_THROW_MESSAGE(getTriNormal(tri, &t_normal(0)), "calculate area");
  return sqrt(t_normal(i) * t_normal(i)) * 0.5;
}

getTriNormal() [1/2]

MoFEMErrorCode MoFEM::Tools::getTriNormal ( const double *  coords, double *  normal  )

static

Get the Tri Normal objectGet triangle normal.

Parameters

coords
normal

Returns

MoFEMErrorCode

Definition at line 352 of file Tools.cpp.

                                                                       {
  MoFEMFunctionBegin;
  double diffN[6];
  CHKERR ShapeDiffMBTRI(diffN);
  CHKERR ShapeFaceNormalMBTRI(diffN, coords, normal);
  MoFEMFunctionReturn(0);
}

getTriNormal() [2/2]

MoFEMErrorCode MoFEM::Tools::getTriNormal	(	const EntityHandle	tri,
		double *	normal
	)		const

Get triangle normal.

Parameters

tri
normal

Returns

MoFEMErrorCode

Definition at line 360 of file Tools.cpp.

                                                         {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  MoFEMFunctionBegin;
  if (type_from_handle(tri) != MBTRI) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "Works only for triangle");
  }
  const EntityHandle *conn;
  int num_nodes;
  double coords[9];
  CHKERR moab.get_connectivity(tri, conn, num_nodes, true);
  CHKERR moab.get_coords(conn, num_nodes, coords);
  CHKERR getTriNormal(coords, normal);
  MoFEMFunctionReturn(0);
}

minDistanceFromSegments()

Tools::SEGMENT_MIN_DISTANCE MoFEM::Tools::minDistanceFromSegments ( const double *  w_ptr, const double *  v_ptr, const double *  k_ptr, const double *  l_ptr, double *const  tvw_ptr = nullptr, double *const  tlk_ptr = nullptr  )

static

Find points on two segments in closest distance.

Parameters

w_ptr
v_ptr
k_ptr
l_ptr
tvw_ptr
tlk_ptr

Returns

SEGMENT_MIN_DISTANCE

Note

If tvwk or tlk are outside bound [0,-1], it means that points are on the lines beyond segments, respectively for segment vw and lk.

Definition at line 438 of file Tools.cpp.

                                                                             {
 
  FTensor::Index<'i', 3> i;
  FTensor::Tensor1<const double *, 3> t_w(&w_ptr[0], &w_ptr[1], &w_ptr[2]);
  FTensor::Tensor1<const double *, 3> t_v(&v_ptr[0], &v_ptr[1], &v_ptr[2]);
  FTensor::Tensor1<const double *, 3> t_k(&k_ptr[0], &k_ptr[1], &k_ptr[2]);
  FTensor::Tensor1<const double *, 3> t_l(&l_ptr[0], &l_ptr[1], &l_ptr[2]);
 
  // First segnent is a point
  FTensor::Tensor1<double, 3> t_vw;
  t_vw(i) = t_v(i) - t_w(i);
  double dot_vw = t_vw(i) * t_vw(i);
  if (std::abs(dot_vw) < std::numeric_limits<double>::epsilon()) {
    if (tvw_ptr)
      *tvw_ptr = 0;
    if (minDistancePointFromOnSegment(k_ptr, l_ptr, w_ptr, tlk_ptr) ==
        SEGMENT_ONE_IS_POINT)
      return SEGMENT_TWO_AND_TWO_ARE_POINT;
    else
      return SEGMENT_ONE_IS_POINT;
  }
 
  // Second segment is a point
  FTensor::Tensor1<double, 3> t_lk;
  t_lk(i) = t_l(i) - t_k(i);
  double dot_lk = t_lk(i) * t_lk(i);
  if (std::abs(dot_lk) < std::numeric_limits<double>::epsilon()) {
    if (tlk_ptr)
      *tlk_ptr = 0;
    if (minDistancePointFromOnSegment(w_ptr, v_ptr, k_ptr, tvw_ptr) ==
        SEGMENT_ONE_IS_POINT)
      return SEGMENT_TWO_AND_TWO_ARE_POINT;
    else
      return SEGMENT_TWO_IS_POINT;
  }
 
  const double a = t_vw(i) * t_vw(i);
  const double b = -t_vw(i) * t_lk(i);
  const double c = t_lk(i) * t_lk(i);
 
  const double det = a * c - b * b;
  if (std::abs(det) < std::numeric_limits<double>::epsilon()) {
 
    return NO_SOLUTION;
 
  } else {
 
    FTensor::Tensor1<double, 3> t_wk;
    t_wk(i) = t_w(i) - t_k(i);
 
    const double ft0 = t_vw(i) * t_wk(i);
    const double ft1 = -t_lk(i) * t_wk(i);
    const double t0 = (ft1 * b - ft0 * c) / det;
    const double t1 = (ft0 * b - ft1 * a) / det;
 
    if (tvw_ptr)
      *tvw_ptr = t0;
    if (tlk_ptr)
      *tlk_ptr = t1;
 
    return SOLUTION_EXIST;
  }
}

minDistancePointFromOnSegment()

Tools::SEGMENT_MIN_DISTANCE MoFEM::Tools::minDistancePointFromOnSegment ( const double *  w_ptr, const double *  v_ptr, const double *  p_ptr, double *const  t_ptr = nullptr  )

static

Find closet point on the segment from the point.

Parameters

w_ptr	segment first vertex coordinate
v_ptr	segment second vertex coordinate
p_ptr	coordinate of point
t_ptr	distance on the segment

Note

If t is outside bounds [ 0,-1 ] point is on the line point beyond segment.

double w[] = {-1, 0, 0};
double v[] = {1, 0, 0};
double p[] = {0, 1, 0};
double t;
CHKERR Toolas::minDistancePointFromOnSegment(w, v, p, &t);
double point_on_segment[3];
for (int i = 0; i != 3; ++i)
  point_on_segment[i] = w[i] + t * (v[i] - w[i]);

Returns

SEGMENT_MIN_DISTANCE

Definition at line 415 of file Tools.cpp.

                                                                               {
  FTensor::Index<'i', 3> i;
  FTensor::Tensor1<const double *, 3> t_w(&w_ptr[0], &w_ptr[1], &w_ptr[2]);
  FTensor::Tensor1<const double *, 3> t_v(&v_ptr[0], &v_ptr[1], &v_ptr[2]);
  FTensor::Tensor1<const double *, 3> t_p(&p_ptr[0], &p_ptr[1], &p_ptr[2]);
  FTensor::Tensor1<double, 3> t_vw;
  t_vw(i) = t_v(i) - t_w(i);
  const double dot_vw = t_vw(i) * t_vw(i);
  if (std::abs(dot_vw) < std::numeric_limits<double>::epsilon()) {
    if (t_ptr)
      *t_ptr = 0;
    return SEGMENT_ONE_IS_POINT;
  }
  FTensor::Tensor1<double, 3> t_pw;
  t_pw(i) = t_p(i) - t_w(i);
  const double t = t_pw(i) * t_vw(i) / dot_vw;
  if (t_ptr)
    *t_ptr = t;
  return SOLUTION_EXIST;
}

minTetsQuality()

MoFEMErrorCode MoFEM::Tools::minTetsQuality	(	const Range &	tets,
		double &	min_quality,
		Tag	th = nullptr,
		boost::function< double(double, double)>	f = [](double a, double b) -> double { return std::min(a, b); }
	)

calculate minimal quality of tetrahedra in range

Parameters

tets	range
min_quality	mimimal quality

Returns

error code

Definition at line 51 of file Tools.cpp.

                                                               {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  MoFEMFunctionBegin;
  const EntityHandle *conn;
  int num_nodes;
  double coords[12];
  for (auto tet : tets) {
    CHKERR m_field.get_moab().get_connectivity(tet, conn, num_nodes, true);
    if (th) {
      CHKERR moab.tag_get_data(th, conn, num_nodes, coords);
    } else {
      CHKERR moab.get_coords(conn, num_nodes, coords);
    }
    double q = Tools::volumeLengthQuality(coords);
    if (!std::isnormal(q))
      q = -2;
    min_quality = f(q, min_quality);
  }
  MoFEMFunctionReturn(0);
}

outerProductOfEdgeIntegrationPtsForHex()

MoFEMErrorCode MoFEM::Tools::outerProductOfEdgeIntegrationPtsForHex ( MatrixDouble &  pts, const int  edge0, const int  edge1, const int  edge2  )

static

Definition at line 628 of file Tools.cpp.

                         {
  MoFEMFunctionBegin;
 
  auto check_rule_edge = [](int rule) {
    MoFEMFunctionBeginHot;
    if (rule < 0) {
      SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "Wrong integration rule: %d", rule);
    }
    if (rule > QUAD_1D_TABLE_SIZE) {
      SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "rule > quadrature order %d < %d", rule, QUAD_1D_TABLE_SIZE);
    }
    if (QUAD_1D_TABLE[rule]->dim != 1) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "wrong dimension");
    }
    if (QUAD_1D_TABLE[rule]->order < rule) {
      SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "wrong order %d != %d", QUAD_1D_TABLE[rule]->order, rule);
    }
    MoFEMFunctionReturnHot(0);
  };
 
  CHKERR check_rule_edge(rule_ksi);
  CHKERR check_rule_edge(rule_eta);
  CHKERR check_rule_edge(rule_zeta);
 
  const int nb_gauss_pts_ksi = QUAD_1D_TABLE[rule_ksi]->npoints;
  const int nb_gauss_pts_eta = QUAD_1D_TABLE[rule_eta]->npoints;
  const int nb_gauss_pts_zeta = QUAD_1D_TABLE[rule_zeta]->npoints;
  gauss_pts.resize(4, nb_gauss_pts_ksi * nb_gauss_pts_eta * nb_gauss_pts_zeta,
                   false);
 
  int gg = 0;
  for (size_t i = 0; i != nb_gauss_pts_ksi; ++i) {
    const double wi = QUAD_1D_TABLE[rule_ksi]->weights[i];
    const double ksi = QUAD_1D_TABLE[rule_ksi]->points[2 * i + 1];
    for (size_t j = 0; j != nb_gauss_pts_eta; ++j) {
      const double wj = wi * QUAD_1D_TABLE[rule_eta]->weights[j];
      const double eta = QUAD_1D_TABLE[rule_eta]->points[2 * j + 1];
      for (size_t k = 0; k != nb_gauss_pts_zeta; ++k, ++gg) {
        const double wk = wj * QUAD_1D_TABLE[rule_zeta]->weights[k];
        const double zeta = QUAD_1D_TABLE[rule_zeta]->points[2 * k + 1];
        gauss_pts(0, gg) = ksi;
        gauss_pts(1, gg) = eta;
        gauss_pts(2, gg) = zeta;
        gauss_pts(3, gg) = wk;
      }
    }
  }
 
  if (gg != gauss_pts.size2())
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Wrong size of matrix");
 
  MoFEMFunctionReturn(0);
}

outerProductOfEdgeIntegrationPtsForQuad()

MoFEMErrorCode MoFEM::Tools::outerProductOfEdgeIntegrationPtsForQuad ( MatrixDouble &  pts, const int  edge0, const int  edge1  )

static

Definition at line 579 of file Tools.cpp.

                                                                     {
  MoFEMFunctionBegin;
 
  auto check_rule_edge = [](int rule) {
    MoFEMFunctionBeginHot;
    if (rule < 0) {
      SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "Wrong integration rule: %d", rule);
    }
    if (rule > QUAD_1D_TABLE_SIZE) {
      SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "rule > quadrature order %d < %d", rule, QUAD_1D_TABLE_SIZE);
    }
    if (QUAD_1D_TABLE[rule]->dim != 1) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "wrong dimension");
    }
    if (QUAD_1D_TABLE[rule]->order < rule) {
      SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "wrong order %d != %d", QUAD_1D_TABLE[rule]->order, rule);
    }
    MoFEMFunctionReturnHot(0);
  };
 
  CHKERR check_rule_edge(rule_ksi);
  CHKERR check_rule_edge(rule_eta);
 
  const int nb_gauss_pts_ksi = QUAD_1D_TABLE[rule_ksi]->npoints;
  const int nb_gauss_pts_eta = QUAD_1D_TABLE[rule_eta]->npoints;
  gauss_pts.resize(3, nb_gauss_pts_ksi * nb_gauss_pts_eta, false);
 
  int gg = 0;
  for (size_t i = 0; i != nb_gauss_pts_ksi; ++i) {
    const double wi = QUAD_1D_TABLE[rule_ksi]->weights[i];
    const double ksi = (QUAD_1D_TABLE[rule_ksi]->points[2 * i + 1]);
    for (size_t j = 0; j != nb_gauss_pts_eta; ++j, ++gg) {
      const double wk = wi * QUAD_1D_TABLE[rule_eta]->weights[j];
      const double eta = QUAD_1D_TABLE[rule_eta]->points[2 * j + 1];
      gauss_pts(0, gg) = ksi;
      gauss_pts(1, gg) = eta;
      gauss_pts(2, gg) = wk;
    }
  }
  if (gg != gauss_pts.size2())
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Wrong size of matrix");
 
  MoFEMFunctionReturn(0);
}

query_interface()

MoFEMErrorCode MoFEM::Tools::query_interface ( boost::typeindex::type_index  type_index, UnknownInterface **  iface  ) const

virtual

Implements MoFEM::UnknownInterface.

Definition at line 11 of file Tools.cpp.

                                                                      {
  *iface = const_cast<Tools *>(this);
  return 0;
}

shapeFunMBEDGE()

template<int LDB>

MoFEMErrorCode MoFEM::Tools::shapeFunMBEDGE ( double *  shape, const double *  ksi, const int  nb  )

static

Calculate shape functions on edge.

Note

Template parameter is leading dimension of point coordinate arrays, such that \(ksi_{n+1} = ksi[n + LDB]\)

Template Parameters

1

Parameters

shape	shape functions
ksi	pointer to first local coordinates
nb	number of points

Returns

MoFEMErrorCode

Definition at line 617 of file Tools.hpp.

                                                   {
  MoFEMFunctionBeginHot;
  for (int n = 0; n != nb; ++n) {
    shape[0] = shapeFunMBEDGE0(*ksi);
    shape[1] = shapeFunMBEDGE1(*ksi);
    shape += 2;
    ksi += LDB;
  }
  MoFEMFunctionReturnHot(0);
}

shapeFunMBEDGE0()

double MoFEM::Tools::shapeFunMBEDGE0 ( const double  x )

inlinestatic

Definition at line 608 of file Tools.hpp.

                                            {
  return N_MBEDGE0(x);
}

shapeFunMBEDGE1()

double MoFEM::Tools::shapeFunMBEDGE1 ( const double  x )

inlinestatic

Definition at line 612 of file Tools.hpp.

                                            {
  return N_MBEDGE1(x);
}

shapeFunMBTET()

template<int LDB>

MoFEMErrorCode MoFEM::Tools::shapeFunMBTET ( double *  shape, const double *  ksi, const double *  eta, const double *  zeta, const double  nb  )

static

Calculate shape functions on tetrahedron.

Note

Template parameter is leading dimension of point coordinate arrays, such that \(ksi_{n+1} = ksi[n + LDB]\)

Template Parameters

1

Parameters

shape	shape functions
ksi	pointer to first local coordinates
eta	pointer to second local coordinates
zeta	pointer to first third coordinates
nb	number of points

Returns

MoFEMErrorCode

Definition at line 673 of file Tools.hpp.

                                                     {
  MoFEMFunctionBeginHot;
  for (int n = 0; n != nb; ++n) {
    shape[0] = shapeFunMBTET0(*ksi, *eta, *zeta);
    shape[1] = shapeFunMBTET1(*ksi, *eta, *zeta);
    shape[2] = shapeFunMBTET2(*ksi, *eta, *zeta);
    shape[3] = shapeFunMBTET3(*ksi, *eta, *zeta);
    shape += 4;
    ksi += LDB;
    eta += LDB;
    zeta += LDB;
  }
  MoFEMFunctionReturnHot(0);
}

shapeFunMBTET0()

double MoFEM::Tools::shapeFunMBTET0 ( const double  x, const double  y, const double  z  )

inlinestatic

Definition at line 656 of file Tools.hpp.

                                                                           {
  return N_MBTET0(x, y, z);
}

shapeFunMBTET1()

double MoFEM::Tools::shapeFunMBTET1 ( const double  x, const double  y, const double  z  )

inlinestatic

Definition at line 660 of file Tools.hpp.

                                                                           {
  return N_MBTET1(x, y, z);
}

shapeFunMBTET2()

double MoFEM::Tools::shapeFunMBTET2 ( const double  x, const double  y, const double  z  )

inlinestatic

Definition at line 664 of file Tools.hpp.

                                                                           {
  return N_MBTET2(x, y, z);
}

shapeFunMBTET3()

double MoFEM::Tools::shapeFunMBTET3 ( const double  x, const double  y, const double  z  )

inlinestatic

Definition at line 668 of file Tools.hpp.

                                                                           {
  return N_MBTET3(x, y, z);
};

shapeFunMBTRI()

template<int LDB>

MoFEMErrorCode MoFEM::Tools::shapeFunMBTRI ( double *  shape, const double *  ksi, const double *  eta, const int  nb  )

static

Calculate shape functions on triangle.

Note

Template parameter is leading dimension of point coordinate arrays, such that \(ksi_{n+1} = ksi[n + LDB]\)

Template Parameters

1

Parameters

shape	shape functions
ksi	pointer to first local coordinates
eta	pointer to second local coordinates
nb	number of points

Returns

MoFEMErrorCode

Definition at line 642 of file Tools.hpp.

                                                                     {
  MoFEMFunctionBeginHot;
  for (int n = 0; n != nb; ++n) {
    shape[0] = shapeFunMBTRI0(*ksi, *eta);
    shape[1] = shapeFunMBTRI1(*ksi, *eta);
    shape[2] = shapeFunMBTRI2(*ksi, *eta);
    shape += 3;
    ksi += LDB;
    eta += LDB;
  }
  MoFEMFunctionReturnHot(0);
}

shapeFunMBTRI0()

double MoFEM::Tools::shapeFunMBTRI0 ( const double  x, const double  y  )

inlinestatic

Definition at line 629 of file Tools.hpp.

                                                           {
  return N_MBTRI0(x, y);
}

shapeFunMBTRI1()

double MoFEM::Tools::shapeFunMBTRI1 ( const double  x, const double  y  )

inlinestatic

Definition at line 633 of file Tools.hpp.

                                                           {
  return N_MBTRI1(x, y);
}

shapeFunMBTRI2()

double MoFEM::Tools::shapeFunMBTRI2 ( const double  x, const double  y  )

inlinestatic

Definition at line 637 of file Tools.hpp.

                                                           {
  return N_MBTRI2(x, y);
}

tetVolume()

double MoFEM::Tools::tetVolume ( const double *  coords )

static

Calculate volume of tetrahedron.

Parameters

coords

Returns

double volume

Definition at line 32 of file Tools.cpp.

                                            {
  double diff_n[12];
  ShapeDiffMBTET(diff_n);
  FTensor::Tensor1<double *, 3> t_diff_n(&diff_n[0], &diff_n[1], &diff_n[2], 3);
  FTensor::Tensor1<const double *, 3> t_coords(&coords[0], &coords[1],
                                               &coords[2], 3);
  FTensor::Tensor2<double, 3, 3> jac;
  FTensor::Index<'i', 3> i;
  FTensor::Index<'j', 3> j;
  jac(i, j) = 0;
  for (int nn = 0; nn != 4; nn++) {
    jac(i, j) += t_coords(i) * t_diff_n(j);
    ++t_coords;
    ++t_diff_n;
  }
  return determinantTensor3by3(jac) / 6.;
}

volumeLengthQuality()

double MoFEM::Tools::volumeLengthQuality ( const double *  coords )

static

Calculate tetrahedron volume length quality.

Parameters

coords

tet coordinates

Returns

Volume-length quality

Definition at line 17 of file Tools.cpp.

                                                      {
  double lrms = 0;
  for (int dd = 0; dd != 3; dd++) {
    lrms += pow(coords[0 * 3 + dd] - coords[1 * 3 + dd], 2) +
            pow(coords[0 * 3 + dd] - coords[2 * 3 + dd], 2) +
            pow(coords[0 * 3 + dd] - coords[3 * 3 + dd], 2) +
            pow(coords[1 * 3 + dd] - coords[2 * 3 + dd], 2) +
            pow(coords[1 * 3 + dd] - coords[3 * 3 + dd], 2) +
            pow(coords[2 * 3 + dd] - coords[3 * 3 + dd], 2);
  }
  lrms = sqrt((1. / 6.) * lrms);
  double volume = tetVolume(coords);
  return 6. * sqrt(2.) * volume / pow(lrms, 3);
}

writeTetsWithQuality()

MoFEMErrorCode MoFEM::Tools::writeTetsWithQuality	(	const char *	file_name,
		const char *	file_type,
		const char *	options,
		const Range &	tets,
		Tag	th = nullptr,
		boost::function< bool(double)>	f = [](double q) -> bool { if (q <= 0) return true; else return false; }
	)

Write file with tetrahedral of given quality.

Parameters

file_name
file_type
options
tets
th
f

Returns

MoFEMErrorCode

Definition at line 268 of file Tools.cpp.

                                                                          {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  MoFEMFunctionBegin;
  Range out_tets;
  CHKERR getTetsWithQuality(out_tets, tets, th, f);
  EntityHandle meshset;
  CHKERR moab.create_meshset(MESHSET_SET, meshset);
  CHKERR moab.add_entities(meshset, out_tets);
  CHKERR moab.write_file(file_name, file_type, options, &meshset, 1);
  CHKERR moab.delete_entities(&meshset, 1);
  MoFEMFunctionReturn(0);
}

Member Data Documentation

cOre

MoFEM::Core& MoFEM::Tools::cOre

Definition at line 24 of file Tools.hpp.

diffN_MBEDGE0x

constexpr double MoFEM::Tools::diffN_MBEDGE0x = diffN_MBEDGE0

staticconstexpr

Definition at line 65 of file Tools.hpp.

diffN_MBEDGE1x

constexpr double MoFEM::Tools::diffN_MBEDGE1x = diffN_MBEDGE1

staticconstexpr

Definition at line 66 of file Tools.hpp.

diffShapeFunMBEDGE

constexpr std::array< double, 2 > MoFEM::Tools::diffShapeFunMBEDGE

staticconstexpr

Initial value:

= {diffN_MBEDGE0x,
                                                               diffN_MBEDGE1x}

Definition at line 68 of file Tools.hpp.

diffShapeFunMBHEXAtCenter

constexpr std::array< double, 24 > MoFEM::Tools::diffShapeFunMBHEXAtCenter

staticconstexpr

Initial value:

= {
 
      diffShapeFunMBHEXAtCenter0x, diffShapeFunMBHEXAtCenter0y,
      diffShapeFunMBHEXAtCenter0z,
 
      diffShapeFunMBHEXAtCenter1x, diffShapeFunMBHEXAtCenter1y,
      diffShapeFunMBHEXAtCenter1z,
 
      diffShapeFunMBHEXAtCenter2x, diffShapeFunMBHEXAtCenter2y,
      diffShapeFunMBHEXAtCenter2z,
 
      diffShapeFunMBHEXAtCenter3x, diffShapeFunMBHEXAtCenter3y,
      diffShapeFunMBHEXAtCenter3z,
 
      diffShapeFunMBHEXAtCenter4x, diffShapeFunMBHEXAtCenter4y,
      diffShapeFunMBHEXAtCenter4z,
 
      diffShapeFunMBHEXAtCenter5x, diffShapeFunMBHEXAtCenter5y,
      diffShapeFunMBHEXAtCenter5z,
 
      diffShapeFunMBHEXAtCenter6x, diffShapeFunMBHEXAtCenter6y,
      diffShapeFunMBHEXAtCenter6z,
 
      diffShapeFunMBHEXAtCenter7x, diffShapeFunMBHEXAtCenter7y,
      diffShapeFunMBHEXAtCenter7z
 
  }

Definition at line 218 of file Tools.hpp.

diffShapeFunMBHEXAtCenter0x

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter0x

staticconstexpr

Initial value:

=
      diffN_MBHEX0x(0.5, 0.5)

derivative of HEX shape function

Definition at line 163 of file Tools.hpp.

diffShapeFunMBHEXAtCenter0y

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter0y

staticconstexpr

Initial value:

=
      diffN_MBHEX0y(0.5, 0.5)

derivative of HEX shape function

Definition at line 165 of file Tools.hpp.

diffShapeFunMBHEXAtCenter0z

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter0z

staticconstexpr

Initial value:

=
      diffN_MBHEX0z(0.5, 0.5)

derivative of HEX shape function

Definition at line 167 of file Tools.hpp.

diffShapeFunMBHEXAtCenter1x

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter1x

staticconstexpr

Initial value:

=
      diffN_MBHEX1x(0.5, 0.5)

derivative of HEX shape function

Definition at line 169 of file Tools.hpp.

diffShapeFunMBHEXAtCenter1y

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter1y

staticconstexpr

Initial value:

=
      diffN_MBHEX1y(0.5, 0.5)

derivative of HEX shape function

Definition at line 171 of file Tools.hpp.

diffShapeFunMBHEXAtCenter1z

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter1z

staticconstexpr

Initial value:

=
      diffN_MBHEX1z(0.5, 0.5)

derivative of HEX shape function

Definition at line 173 of file Tools.hpp.

diffShapeFunMBHEXAtCenter2x

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter2x

staticconstexpr

Initial value:

=
      diffN_MBHEX2x(0.5, 0.5)

derivative of HEX shape function

Definition at line 175 of file Tools.hpp.

diffShapeFunMBHEXAtCenter2y

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter2y

staticconstexpr

Initial value:

=
      diffN_MBHEX2y(0.5, 0.5)

derivative of HEX shape function

Definition at line 177 of file Tools.hpp.

diffShapeFunMBHEXAtCenter2z

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter2z

staticconstexpr

Initial value:

=
      diffN_MBHEX2z(0.5, 0.5)

derivative of HEX shape function

Definition at line 179 of file Tools.hpp.

diffShapeFunMBHEXAtCenter3x

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter3x

staticconstexpr

Initial value:

=
      diffN_MBHEX3x(0.5, 0.5)

derivative of HEX shape function

Definition at line 181 of file Tools.hpp.

diffShapeFunMBHEXAtCenter3y

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter3y

staticconstexpr

Initial value:

=
      diffN_MBHEX3y(0.5, 0.5)

derivative of quad shape function

Definition at line 183 of file Tools.hpp.

diffShapeFunMBHEXAtCenter3z

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter3z

staticconstexpr

Initial value:

=
      diffN_MBHEX3z(0.5, 0.5)

derivative of quad shape function

Definition at line 185 of file Tools.hpp.

diffShapeFunMBHEXAtCenter4x

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter4x

staticconstexpr

Initial value:

=
      diffN_MBHEX4x(0.5, 0.5)

derivative of HEX shape function

Definition at line 187 of file Tools.hpp.

diffShapeFunMBHEXAtCenter4y

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter4y

staticconstexpr

Initial value:

=
      diffN_MBHEX4y(0.5, 0.5)

derivative of quad shape function

Definition at line 189 of file Tools.hpp.

diffShapeFunMBHEXAtCenter4z

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter4z

staticconstexpr

Initial value:

=
      diffN_MBHEX4z(0.5, 0.5)

derivative of quad shape function

Definition at line 191 of file Tools.hpp.

diffShapeFunMBHEXAtCenter5x

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter5x

staticconstexpr

Initial value:

=
      diffN_MBHEX5x(0.5, 0.5)

derivative of HEX shape function

Definition at line 193 of file Tools.hpp.

diffShapeFunMBHEXAtCenter5y

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter5y

staticconstexpr

Initial value:

=
      diffN_MBHEX5y(0.5, 0.5)

derivative of quad shape function

Definition at line 195 of file Tools.hpp.

diffShapeFunMBHEXAtCenter5z

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter5z

staticconstexpr

Initial value:

=
      diffN_MBHEX5z(0.5, 0.5)

derivative of quad shape function

Definition at line 197 of file Tools.hpp.

diffShapeFunMBHEXAtCenter6x

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter6x

staticconstexpr

Initial value:

=
      diffN_MBHEX6x(0.5, 0.5)

derivative of HEX shape function

Definition at line 199 of file Tools.hpp.

diffShapeFunMBHEXAtCenter6y

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter6y

staticconstexpr

Initial value:

=
      diffN_MBHEX6y(0.5, 0.5)

derivative of quad shape function

Definition at line 201 of file Tools.hpp.

diffShapeFunMBHEXAtCenter6z

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter6z

staticconstexpr

Initial value:

=
      diffN_MBHEX6z(0.5, 0.5)

derivative of quad shape function

Definition at line 203 of file Tools.hpp.

diffShapeFunMBHEXAtCenter7x

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter7x

staticconstexpr

Initial value:

=
      diffN_MBHEX7x(0.5, 0.5)

derivative of HEX shape function

Definition at line 205 of file Tools.hpp.

diffShapeFunMBHEXAtCenter7y

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter7y

staticconstexpr

Initial value:

=
      diffN_MBHEX7y(0.5, 0.5)

derivative of quad shape function

Definition at line 207 of file Tools.hpp.

diffShapeFunMBHEXAtCenter7z

constexpr double MoFEM::Tools::diffShapeFunMBHEXAtCenter7z

staticconstexpr

Initial value:

=
      diffN_MBHEX7z(0.5, 0.5)

derivative of quad shape function

Definition at line 209 of file Tools.hpp.

diffShapeFunMBQUADAtCenter

constexpr std::array< double, 8 > MoFEM::Tools::diffShapeFunMBQUADAtCenter

staticconstexpr

Initial value:

= {
      diffShapeFunMBQUADAtCenter0x, diffShapeFunMBQUADAtCenter0y,
      diffShapeFunMBQUADAtCenter1x, diffShapeFunMBQUADAtCenter1y,
      diffShapeFunMBQUADAtCenter2x, diffShapeFunMBQUADAtCenter2y,
      diffShapeFunMBQUADAtCenter3x, diffShapeFunMBQUADAtCenter3y}

Definition at line 212 of file Tools.hpp.

diffShapeFunMBQUADAtCenter0x

constexpr double MoFEM::Tools::diffShapeFunMBQUADAtCenter0x

staticconstexpr

Initial value:

=
      diffN_MBQUAD0x(0.5)

derivative of quad shape function

Definition at line 146 of file Tools.hpp.

diffShapeFunMBQUADAtCenter0y

constexpr double MoFEM::Tools::diffShapeFunMBQUADAtCenter0y

staticconstexpr

Initial value:

=
      diffN_MBQUAD0y(0.5)

derivative of quad shape function

Definition at line 148 of file Tools.hpp.

diffShapeFunMBQUADAtCenter1x

constexpr double MoFEM::Tools::diffShapeFunMBQUADAtCenter1x

staticconstexpr

Initial value:

=
      diffN_MBQUAD1x(0.5)

derivative of quad shape function

Definition at line 150 of file Tools.hpp.

diffShapeFunMBQUADAtCenter1y

constexpr double MoFEM::Tools::diffShapeFunMBQUADAtCenter1y

staticconstexpr

Initial value:

=
      diffN_MBQUAD1y(0.5)

derivative of quad shape function

Definition at line 152 of file Tools.hpp.

diffShapeFunMBQUADAtCenter2x

constexpr double MoFEM::Tools::diffShapeFunMBQUADAtCenter2x

staticconstexpr

Initial value:

=
      diffN_MBQUAD2x(0.5)

derivative of quad shape function

Definition at line 154 of file Tools.hpp.

diffShapeFunMBQUADAtCenter2y

constexpr double MoFEM::Tools::diffShapeFunMBQUADAtCenter2y

staticconstexpr

Initial value:

=
      diffN_MBQUAD2y(0.5)

derivative of quad shape function

Definition at line 156 of file Tools.hpp.

diffShapeFunMBQUADAtCenter3x

constexpr double MoFEM::Tools::diffShapeFunMBQUADAtCenter3x

staticconstexpr

Initial value:

=
      diffN_MBQUAD3x(0.5)

derivative of quad shape function

Definition at line 158 of file Tools.hpp.

diffShapeFunMBQUADAtCenter3y

constexpr double MoFEM::Tools::diffShapeFunMBQUADAtCenter3y

staticconstexpr

Initial value:

=
      diffN_MBQUAD3y(0.5)

derivative of quad shape function

Definition at line 160 of file Tools.hpp.

diffShapeFunMBTET

constexpr std::array< double, 12 > MoFEM::Tools::diffShapeFunMBTET

staticconstexpr

Initial value:

= {
 
      diffShapeFunMBTET0x, diffShapeFunMBTET0y, diffShapeFunMBTET0z,
 
      diffShapeFunMBTET1x, diffShapeFunMBTET1y, diffShapeFunMBTET1z,
 
      diffShapeFunMBTET2x, diffShapeFunMBTET2y, diffShapeFunMBTET2z,
 
      diffShapeFunMBTET3x, diffShapeFunMBTET3y, diffShapeFunMBTET3z}

Definition at line 271 of file Tools.hpp.

diffShapeFunMBTET0x

constexpr double MoFEM::Tools::diffShapeFunMBTET0x

staticconstexpr

Initial value:

=
      diffN_MBTET0x

derivative of tetrahedral shape function

Definition at line 246 of file Tools.hpp.

diffShapeFunMBTET0y

constexpr double MoFEM::Tools::diffShapeFunMBTET0y

staticconstexpr

Initial value:

=
      diffN_MBTET0y

derivative of tetrahedral shape function

Definition at line 248 of file Tools.hpp.

diffShapeFunMBTET0z

constexpr double MoFEM::Tools::diffShapeFunMBTET0z

staticconstexpr

Initial value:

=
      diffN_MBTET0z

derivative of tetrahedral shape function

Definition at line 250 of file Tools.hpp.

diffShapeFunMBTET1x

constexpr double MoFEM::Tools::diffShapeFunMBTET1x

staticconstexpr

Initial value:

=
      diffN_MBTET1x

derivative of tetrahedral shape function

Definition at line 252 of file Tools.hpp.

diffShapeFunMBTET1y

constexpr double MoFEM::Tools::diffShapeFunMBTET1y

staticconstexpr

Initial value:

=
      diffN_MBTET1y

derivative of tetrahedral shape function

Definition at line 254 of file Tools.hpp.

diffShapeFunMBTET1z

constexpr double MoFEM::Tools::diffShapeFunMBTET1z

staticconstexpr

Initial value:

=
      diffN_MBTET1z

derivative of tetrahedral shape function

Definition at line 256 of file Tools.hpp.

diffShapeFunMBTET2x

constexpr double MoFEM::Tools::diffShapeFunMBTET2x

staticconstexpr

Initial value:

=
      diffN_MBTET2x

derivative of tetrahedral shape function

Definition at line 258 of file Tools.hpp.

diffShapeFunMBTET2y

constexpr double MoFEM::Tools::diffShapeFunMBTET2y

staticconstexpr

Initial value:

=
      diffN_MBTET2y

derivative of tetrahedral shape function

Definition at line 260 of file Tools.hpp.

diffShapeFunMBTET2z

constexpr double MoFEM::Tools::diffShapeFunMBTET2z

staticconstexpr

Initial value:

=
      diffN_MBTET2z

derivative of tetrahedral shape function

Definition at line 262 of file Tools.hpp.

diffShapeFunMBTET3x

constexpr double MoFEM::Tools::diffShapeFunMBTET3x

staticconstexpr

Initial value:

=
      diffN_MBTET3x

derivative of tetrahedral shape function

Definition at line 264 of file Tools.hpp.

diffShapeFunMBTET3y

constexpr double MoFEM::Tools::diffShapeFunMBTET3y

staticconstexpr

Initial value:

=
      diffN_MBTET3y

derivative of tetrahedral shape function

Definition at line 266 of file Tools.hpp.

diffShapeFunMBTET3z

constexpr double MoFEM::Tools::diffShapeFunMBTET3z

staticconstexpr

Initial value:

=
      diffN_MBTET3z

derivative of tetrahedral shape function

Definition at line 268 of file Tools.hpp.

diffShapeFunMBTRI

constexpr std::array< double, 6 > MoFEM::Tools::diffShapeFunMBTRI

staticconstexpr

Initial value:

= {
 
      diffShapeFunMBTRI0x, diffShapeFunMBTRI0y,
 
      diffShapeFunMBTRI1x, diffShapeFunMBTRI1y,
 
      diffShapeFunMBTRI2x, diffShapeFunMBTRI2y}

Definition at line 104 of file Tools.hpp.

diffShapeFunMBTRI0x

constexpr double MoFEM::Tools::diffShapeFunMBTRI0x

staticconstexpr

Initial value:

=
      diffN_MBTRI0x

derivative of triangle shape function

Definition at line 91 of file Tools.hpp.

diffShapeFunMBTRI0y

constexpr double MoFEM::Tools::diffShapeFunMBTRI0y

staticconstexpr

Initial value:

=
      diffN_MBTRI0y

derivative of triangle shape function

Definition at line 93 of file Tools.hpp.

diffShapeFunMBTRI1x

constexpr double MoFEM::Tools::diffShapeFunMBTRI1x

staticconstexpr

Initial value:

=
      diffN_MBTRI1x

derivative of triangle shape function

Definition at line 95 of file Tools.hpp.

diffShapeFunMBTRI1y

constexpr double MoFEM::Tools::diffShapeFunMBTRI1y

staticconstexpr

Initial value:

=
      diffN_MBTRI1y

derivative of triangle shape function

Definition at line 97 of file Tools.hpp.

diffShapeFunMBTRI2x

constexpr double MoFEM::Tools::diffShapeFunMBTRI2x

staticconstexpr

Initial value:

=
      diffN_MBTRI2x

derivative of triangle shape function

Definition at line 99 of file Tools.hpp.

diffShapeFunMBTRI2y

constexpr double MoFEM::Tools::diffShapeFunMBTRI2y

staticconstexpr

Initial value:

=
      diffN_MBTRI2y

derivative of triangle shape function

Definition at line 101 of file Tools.hpp.

shapeFunMBEDGE0At00

constexpr double MoFEM::Tools::shapeFunMBEDGE0At00 = N_MBEDGE0(0)

staticconstexpr

Definition at line 55 of file Tools.hpp.

shapeFunMBEDGE1At00

constexpr double MoFEM::Tools::shapeFunMBEDGE1At00 = N_MBEDGE1(0)

staticconstexpr

Definition at line 56 of file Tools.hpp.

shapeFunMBEDGEAt00

constexpr std::array< double, 2 > MoFEM::Tools::shapeFunMBEDGEAt00

staticconstexpr

Initial value:

= {
      shapeFunMBEDGE0At00, shapeFunMBEDGE1At00}

Array of shape function at zero local point on reference element.

Definition at line 62 of file Tools.hpp.

shapeFunMBTET0At000

constexpr double MoFEM::Tools::shapeFunMBTET0At000 = N_MBTET0(0, 0, 0)

staticconstexpr

Definition at line 293 of file Tools.hpp.

shapeFunMBTET0AtOneThird

constexpr double MoFEM::Tools::shapeFunMBTET0AtOneThird

staticconstexpr

Initial value:

=
      N_MBTET0(1. / 3., 1. / 3., 1. / 3.)

Definition at line 298 of file Tools.hpp.

shapeFunMBTET1At000

constexpr double MoFEM::Tools::shapeFunMBTET1At000 = N_MBTET1(0, 0, 0)

staticconstexpr

Definition at line 294 of file Tools.hpp.

shapeFunMBTET1AtOneThird

constexpr double MoFEM::Tools::shapeFunMBTET1AtOneThird

staticconstexpr

Initial value:

=
      N_MBTET1(1. / 3., 1. / 3., 1. / 3.)

Definition at line 300 of file Tools.hpp.

shapeFunMBTET2At000

constexpr double MoFEM::Tools::shapeFunMBTET2At000 = N_MBTET2(0, 0, 0)

staticconstexpr

Definition at line 295 of file Tools.hpp.

shapeFunMBTET2AtOneThird

constexpr double MoFEM::Tools::shapeFunMBTET2AtOneThird

staticconstexpr

Initial value:

=
      N_MBTET2(1. / 3., 1. / 3., 1. / 3.)

Definition at line 302 of file Tools.hpp.

shapeFunMBTET3At000

constexpr double MoFEM::Tools::shapeFunMBTET3At000 = N_MBTET3(0, 0, 0)

staticconstexpr

Definition at line 296 of file Tools.hpp.

shapeFunMBTET3AtOneThird

constexpr double MoFEM::Tools::shapeFunMBTET3AtOneThird

staticconstexpr

Initial value:

=
      N_MBTET3(1. / 3., 1. / 3., 1. / 3.)

Definition at line 304 of file Tools.hpp.

shapeFunMBTETAt000

constexpr std::array< double, 4 > MoFEM::Tools::shapeFunMBTETAt000

staticconstexpr

Initial value:

= {
      shapeFunMBTET0At000, shapeFunMBTET1At000, shapeFunMBTET2At000,
      shapeFunMBTET3At000}

Array of shape function at zero local point on reference element.

Definition at line 330 of file Tools.hpp.

shapeFunMBTETAtOneThird

constexpr std::array<double, 4> MoFEM::Tools::shapeFunMBTETAtOneThird

staticconstexpr

Initial value:

= {
      shapeFunMBTET0AtOneThird, shapeFunMBTET1AtOneThird,
      shapeFunMBTET2AtOneThird, shapeFunMBTET3AtOneThird}

Array of shape function at center on reference element.

Definition at line 338 of file Tools.hpp.

shapeFunMBTRI0At00

constexpr double MoFEM::Tools::shapeFunMBTRI0At00 = N_MBTRI0(0, 0)

staticconstexpr

Definition at line 112 of file Tools.hpp.

shapeFunMBTRI1At00

constexpr double MoFEM::Tools::shapeFunMBTRI1At00 = N_MBTRI1(0, 0)

staticconstexpr

Definition at line 113 of file Tools.hpp.

shapeFunMBTRI2At00

constexpr double MoFEM::Tools::shapeFunMBTRI2At00 = N_MBTRI2(0, 0)

staticconstexpr

Definition at line 114 of file Tools.hpp.

shapeFunMBTRIAt00

constexpr std::array< double, 3 > MoFEM::Tools::shapeFunMBTRIAt00

staticconstexpr

Initial value:

= {
      shapeFunMBTRI0At00, shapeFunMBTRI1At00, shapeFunMBTRI2At00}

Array of shape function at zero local point on reference element.

Definition at line 120 of file Tools.hpp.

---

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

• src/interfaces/Tools.hpp
• src/interfaces/impl/Tools.cpp