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
template<class IFACE >
MoFEMErrorCode	registerInterface (bool error_if_registration_failed=true)
	Register interface.
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface reference to pointer of interface.
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE **const iface) const
	Get interface pointer to pointer of interface.
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get interface pointer to pointer of interface.
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get reference to interface.
template<class IFACE >
IFACE *	getInterface () const
	Function returning pointer to interface.
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.
static MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version)
	Get database major version.
static MoFEMErrorCode	setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
	Get database major version.
static MoFEMErrorCode	getInterfaceVersion (Version &version)
	Get database major version.

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.
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
static constexpr double	diffShapeFunMBTRI0y
	derivative of triangle shape function
static constexpr double	diffShapeFunMBTRI1x
	derivative of triangle shape function
static constexpr double	diffShapeFunMBTRI1y
	derivative of triangle shape function
static constexpr double	diffShapeFunMBTRI2x
	derivative of triangle shape function
static constexpr double	diffShapeFunMBTRI2y
	derivative of triangle shape function
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.
static constexpr double	diffShapeFunMBQUADAtCenter0x
	derivative of quad shape function
static constexpr double	diffShapeFunMBQUADAtCenter0y
	derivative of quad shape function
static constexpr double	diffShapeFunMBQUADAtCenter1x
	derivative of quad shape function
static constexpr double	diffShapeFunMBQUADAtCenter1y
	derivative of quad shape function
static constexpr double	diffShapeFunMBQUADAtCenter2x
	derivative of quad shape function
static constexpr double	diffShapeFunMBQUADAtCenter2y
	derivative of quad shape function
static constexpr double	diffShapeFunMBQUADAtCenter3x
	derivative of quad shape function
static constexpr double	diffShapeFunMBQUADAtCenter3y
	derivative of quad shape function
static constexpr double	diffShapeFunMBHEXAtCenter0x
	derivative of HEX shape function
static constexpr double	diffShapeFunMBHEXAtCenter0y
	derivative of HEX shape function
static constexpr double	diffShapeFunMBHEXAtCenter0z
	derivative of HEX shape function
static constexpr double	diffShapeFunMBHEXAtCenter1x
	derivative of HEX shape function
static constexpr double	diffShapeFunMBHEXAtCenter1y
	derivative of HEX shape function
static constexpr double	diffShapeFunMBHEXAtCenter1z
	derivative of HEX shape function
static constexpr double	diffShapeFunMBHEXAtCenter2x
	derivative of HEX shape function
static constexpr double	diffShapeFunMBHEXAtCenter2y
	derivative of HEX shape function
static constexpr double	diffShapeFunMBHEXAtCenter2z
	derivative of HEX shape function
static constexpr double	diffShapeFunMBHEXAtCenter3x
	derivative of HEX shape function
static constexpr double	diffShapeFunMBHEXAtCenter3y
	derivative of quad shape function
static constexpr double	diffShapeFunMBHEXAtCenter3z
	derivative of quad shape function
static constexpr double	diffShapeFunMBHEXAtCenter4x
	derivative of HEX shape function
static constexpr double	diffShapeFunMBHEXAtCenter4y
	derivative of quad shape function
static constexpr double	diffShapeFunMBHEXAtCenter4z
	derivative of quad shape function
static constexpr double	diffShapeFunMBHEXAtCenter5x
	derivative of HEX shape function
static constexpr double	diffShapeFunMBHEXAtCenter5y
	derivative of quad shape function
static constexpr double	diffShapeFunMBHEXAtCenter5z
	derivative of quad shape function
static constexpr double	diffShapeFunMBHEXAtCenter6x
	derivative of HEX shape function
static constexpr double	diffShapeFunMBHEXAtCenter6y
	derivative of quad shape function
static constexpr double	diffShapeFunMBHEXAtCenter6z
	derivative of quad shape function
static constexpr double	diffShapeFunMBHEXAtCenter7x
	derivative of HEX shape function
static constexpr double	diffShapeFunMBHEXAtCenter7y
	derivative of quad shape function
static constexpr double	diffShapeFunMBHEXAtCenter7z
	derivative of quad shape function
static constexpr std::array< double, 8 >	diffShapeFunMBQUADAtCenter
static constexpr std::array< double, 24 >	diffShapeFunMBHEXAtCenter
static constexpr double	diffShapeFunMBTET0x
	derivative of tetrahedral shape function
static constexpr double	diffShapeFunMBTET0y
	derivative of tetrahedral shape function
static constexpr double	diffShapeFunMBTET0z
	derivative of tetrahedral shape function
static constexpr double	diffShapeFunMBTET1x
	derivative of tetrahedral shape function
static constexpr double	diffShapeFunMBTET1y
	derivative of tetrahedral shape function
static constexpr double	diffShapeFunMBTET1z
	derivative of tetrahedral shape function
static constexpr double	diffShapeFunMBTET2x
	derivative of tetrahedral shape function
static constexpr double	diffShapeFunMBTET2y
	derivative of tetrahedral shape function
static constexpr double	diffShapeFunMBTET2z
	derivative of tetrahedral shape function
static constexpr double	diffShapeFunMBTET3x
	derivative of tetrahedral shape function
static constexpr double	diffShapeFunMBTET3y
	derivative of tetrahedral shape function
static constexpr double	diffShapeFunMBTET3z
	derivative of tetrahedral shape function
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.
static constexpr std::array< double, 4 >	shapeFunMBTETAtOneThird
	Array of shape function at center on reference element.
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
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.
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.
MoFEMErrorCode	getTriNormal (const EntityHandle tri, double *normal) const
	Get triangle normal.
double	getTriArea (const EntityHandle tri) const
	Get triangle area.
double	getEdgeLength (const EntityHandle edge)
	Get edge length.
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.
static double	volumeLengthQuality (const double *coords)
	Calculate tetrahedron volume length quality.
static double	tetVolume (const double *coords)
	Calculate volume of tetrahedron.
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.
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.
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.
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.
static MoFEMErrorCode	getLocalCoordinatesOnReferenceThreeNodeTri (const double *elem_coords, const double *glob_coords, const int nb_nodes, double *local_coords)
	Get the local coordinates on reference three node tri object.
static MoFEMErrorCode	getLocalCoordinatesOnReferenceThreeNodeTri (const double *elem_coords, const std::complex< double > *glob_coords, const int nb_nodes, std::complex< double > *local_coords)
	Get the local coordinates on reference three node tri object.
static DEPRECATED MoFEMErrorCode	getLocalCoordinatesOnReferenceTriNodeTri (const double *elem_coords, const double *glob_coords, const int nb_nodes, double *local_coords)
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.
static MoFEMErrorCode	checkIfPointIsInTet (const double tet_coords[], const double global_coord[], const double tol, bool &result)
	Check of point is in tetrahedral.
static MoFEMErrorCode	getTriNormal (const double *coords, double *normal, double *d_normal=nullptr)
	Get the Tri Normal objectGet triangle normal.
static double	getEdgeLength (const double *edge_coords)
	Get edge length.
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.
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.

Mesh refinement
using	RefineTrianglesReturn
static constexpr std::array< int, 12 >	uniformTriangleRefineTriangles
static RefineTrianglesReturn	refineTriangle (int nb_levels)
	create uniform triangle mesh of refined elements
static MatrixDouble	refineTriangleIntegrationPts (MatrixDouble pts, RefineTrianglesReturn refined)
	generate integration points for refined triangle mesh for last level
static MatrixDouble	refineTriangleIntegrationPts (int rule, RefineTrianglesReturn refined)
	generate integration points for refined triangle mesh for last level

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.

Detailed Description

Auxiliary tools.

Examples

EshelbianPlasticity.cpp.

Definition at line 19 of file Tools.hpp.

Member Typedef Documentation

RefineTrianglesReturn

using MoFEM::Tools::RefineTrianglesReturn

Initial value:

 
      std::tuple<std::vector<double>, std::vector<int>, std::vector<int>>

Definition at line 647 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 534 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 287 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 307 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) {
    SETERRQ(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 538 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 418 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 428 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::getLocalCoordinatesOnReferenceEdgeNodeEdge(
    &elem_coords(0, 0), &global_coords(0, 0), global_coords.size1(),
    &local_coords(0, 0))

Parameters

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

Returns

MoFEMErrorCode

Definition at line 203 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<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	Global coordinates
nb_nodes	Number of points
local_coords	Result

Returns

MoFEMErrorCode

Definition at line 88 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)
    SETERRQ(PETSC_COMM_SELF, 1, "info == %d", info);
 
  MoFEMFunctionReturnHot(0);
}

getLocalCoordinatesOnReferenceThreeNodeTri() [1/2]

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

static

Get the local coordinates on reference three node tri 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	Global coordinates
nb_nodes	Number of points
local_coords	Result
d_elem_coords	Derivative of local coordinates
d_global_coords

Returns

MoFEMErrorCode

Definition at line 188 of file Tools.cpp.

                          {
  return getLocalCoordinatesOnReferenceThreeNodeTriImpl<double, double>(
      elem_coords, glob_coords, nb_nodes, local_coords);
}

getLocalCoordinatesOnReferenceThreeNodeTri() [2/2]

MoFEMErrorCode MoFEM::Tools::getLocalCoordinatesOnReferenceThreeNodeTri ( const double * elem_coords, const std::complex< double > * glob_coords, const int nb_nodes, std::complex< double > * local_coords )

static

Get the local coordinates on reference three node tri 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	Global coordinates
nb_nodes	Number of points
local_coords	Result
d_elem_coords	Derivative of local coordinates
d_global_coords

Returns

MoFEMErrorCode

Definition at line 195 of file Tools.cpp.

                                                          {
  return getLocalCoordinatesOnReferenceThreeNodeTriImpl<double,
                                                        std::complex<double>>(
      elem_coords, glob_coords, nb_nodes, local_coords);
}

getLocalCoordinatesOnReferenceTriNodeTri()

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

inlinestatic

Deprecated

use getLocalCoordinatesOnReferenceThreeNodeTri

Definition at line 398 of file Tools.hpp.

                            {
    return getLocalCoordinatesOnReferenceThreeNodeTri(elem_coords, glob_coords,
                                                      nb_nodes, local_coords);
  }

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 244 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 408 of file Tools.cpp.

                                                     {
  if (type_from_handle(tri) != MBTRI) {
    CHK_THROW_MESSAGE(MOFEM_INVALID_DATA, "Works only for triangle");
  }
  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, double * d_normal = nullptr )

static

Get the Tri Normal objectGet triangle normal.

Parameters

coords
normal
d_normal	derivative, if pointer is null, derivative is not calculated

In d_normal, format is 3rd rank tensor, first index is normal direction, second is node number, third is coordinate.

This is relation between tensor and pointer

auto t_d_normal = getFTensor3FromPtr<3, 3, 3>(d_normal);

Returns

MoFEMErrorCode

Examples

EshelbianPlasticity.cpp.

Definition at line 353 of file Tools.cpp.

                                                     {
  MoFEMFunctionBegin;
  FTensor::Index<'i', 3> i;
  FTensor::Index<'j', 3> j;
  FTensor::Index<'k', 3> k;
  FTensor::Index<'l', 3> l;
  FTensor::Index<'n', 3> n;
  FTensor::Index<'m', 3> m;
  FTensor::Index<'J', 2> J;
  FTensor::Number<0> N0;
  FTensor::Number<1> N1;
  auto diff_ptr = Tools::diffShapeFunMBTRI.data();
  auto t_diff_tensor = getFTensor2FromPtr<3, 2>(const_cast<double *>(diff_ptr));
  auto t_coords = getFTensor2FromPtr<3, 3>(const_cast<double *>(coords));
  FTensor::Tensor2<double, 3, 2> t_tangent;
  t_tangent(i, J) = t_coords(n, i) * t_diff_tensor(n, J);
  auto t_normal = getFTensor1FromPtr<3>(normal);
  t_normal(j) =
      (FTensor::levi_civita(i, j, k) * t_tangent(k, N0)) * t_tangent(i, N1);
  if (d_normal) {
    constexpr auto t_kd = FTensor::Kronecker_Delta<int>();
    FTensor::Tensor4<int, 3, 3, 3, 3> t_d_coords;
    t_d_coords(i, j, k, n) = t_kd(i, k) * t_kd(j, n);
    FTensor::Tensor4<double, 3, 3, 3, 2> t_d_tangent;
    t_d_tangent(i, k, l, J) = t_d_coords(n, i, k, l) * t_diff_tensor(n, J);
    auto t_d_normal = getFTensor3FromPtr<3, 3, 3>(d_normal);
    t_d_normal(j, m, n) = (FTensor::levi_civita(i, j, k) * t_tangent(i, N1)) *
                              t_d_tangent(k, m, n, N0)
 
                          +
 
                          (FTensor::levi_civita(i, j, k) * t_tangent(k, N0)) *
                              t_d_tangent(i, m, n, N1);
  }
  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 391 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 472 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 449 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	minimal quality

Returns

error code

Definition at line 49 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 662 of file Tools.cpp.

                         {
  MoFEMFunctionBegin;
 
  auto check_rule_edge = [](int rule) {
    MoFEMFunctionBeginHot;
    if (rule < 0) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "Wrong integration rule: %d", rule);
    }
    if (rule > QUAD_1D_TABLE_SIZE) {
      SETERRQ(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) {
      SETERRQ(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 613 of file Tools.cpp.

                                                                     {
  MoFEMFunctionBegin;
 
  auto check_rule_edge = [](int rule) {
    MoFEMFunctionBeginHot;
    if (rule < 0) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "Wrong integration rule: %d", rule);
    }
    if (rule > QUAD_1D_TABLE_SIZE) {
      SETERRQ(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) {
      SETERRQ(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 9 of file Tools.cpp.

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

refineTriangle()

std::tuple< std::vector< double >, std::vector< int >, std::vector< int > > MoFEM::Tools::refineTriangle ( int nb_levels )

static

create uniform triangle mesh of refined elements

Parameters

nb_levels

Returns

RefineTrianglesReturn

Definition at line 724 of file Tools.cpp.

                                   {
 
  std::vector<int> triangles{0, 1, 2, 3, 4, 5};
  std::vector<double> nodes{
 
      0.,  0.,  // 0
      1.,  0.,  // 1
      0.,  1.,  // 2
      0.5, 0.,  // 3
      0.5, 0.5, // 4
      0.,  0.5  // 5
 
  };
  std::map<std::pair<int, int>, int> edges{
      {{0, 1}, 3}, {{1, 2}, 4}, {{0, 2}, 5}};
 
  auto add_edge = [&](auto a, auto b) {
    if (a > b) {
      std::swap(a, b);
    }
    auto it = edges.find(std::make_pair(a, b));
    if (it == edges.end()) {
      int e = 3 + edges.size();
      edges[std::make_pair(a, b)] = e;
      for (auto n : {0, 1}) {
        nodes.push_back((nodes[2 * a + n] + nodes[2 * b + n]) / 2);
      }
#ifndef NDEBUG
      if (e != nodes.size() / 2 - 1)
        CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY, "wrong node/edge index");
#endif
      return e;
    }
    return it->second;
  };
 
  auto add_triangle = [&](auto t) {
    for (auto tt : {0, 1, 2, 3}) {
      auto last = triangles.size() / 6;
      for (auto n : {0, 1, 2}) {
        // add triangle nodes
        triangles.push_back(
            triangles[6 * t + uniformTriangleRefineTriangles[3 * tt + n]]);
      }
      // add triangle edges
      auto cycle = std::array<int, 4>{0, 1, 2, 0};
      for (auto e : {0, 1, 2}) {
        triangles.push_back(add_edge(triangles[6 * last + cycle[e]],
                                     triangles[6 * last + cycle[e + 1]]));
      }
    }
  };
 
  std::vector<int> level_index{0, 1};
  auto l = 0;
  for (; l != nb_levels; ++l) {
    auto first_tet = level_index[l];
    auto nb_last_level_test = level_index.back() - level_index[l];
    for (auto t = first_tet; t != (first_tet + nb_last_level_test); ++t) {
      add_triangle(t);
    }
    level_index.push_back(triangles.size() / 6);
  }
 
  return std::make_tuple(nodes, triangles, level_index);
}

refineTriangleIntegrationPts() [1/2]

MatrixDouble MoFEM::Tools::refineTriangleIntegrationPts ( int rule, RefineTrianglesReturn refined )

static

generate integration points for refined triangle mesh for last level

Parameters

rule	Gauss integration rule
refined

Returns

MatrixDouble

Definition at line 856 of file Tools.cpp.

                                                                           {
 
  MatrixDouble gauss_pts;
 
  const size_t nb_gauss_pts = QUAD_2D_TABLE[rule]->npoints;
  gauss_pts.resize(3, nb_gauss_pts, false);
  cblas_dcopy(nb_gauss_pts, &QUAD_2D_TABLE[rule]->points[1], 3,
              &gauss_pts(0, 0), 1);
  cblas_dcopy(nb_gauss_pts, &QUAD_2D_TABLE[rule]->points[2], 3,
              &gauss_pts(1, 0), 1);
  cblas_dcopy(nb_gauss_pts, QUAD_2D_TABLE[rule]->weights, 1, &gauss_pts(2, 0),
              1);
 
  return Tools::refineTriangleIntegrationPts(gauss_pts, refined);
}

refineTriangleIntegrationPts() [2/2]

MatrixDouble MoFEM::Tools::refineTriangleIntegrationPts ( MatrixDouble pts, RefineTrianglesReturn refined )

static

generate integration points for refined triangle mesh for last level

Parameters

pts
refined

Returns

MatrixDouble

Definition at line 791 of file Tools.cpp.

                 {
 
  auto [nodes, triangles, level_index] = refined;
  
  auto get_coords = [&](auto t) {
    auto [nodes, triangles, level_index] = refined;
    std::array<double, 9> ele_coords;
    for (auto n : {0, 1, 2}) {
      for (auto i : {0, 1}) {
        ele_coords[3 * n + i] = nodes[2 * triangles[6 * t + n] + i];
      }
      ele_coords[3 * n + 2] = 0;
    }
    return ele_coords;
  };
 
  auto get_normal = [](auto &ele_coords) {
    FTensor::Tensor1<double, 3> t_normal;
    Tools::getTriNormal(ele_coords.data(), &t_normal(0));
    return t_normal;
  };
 
  std::vector<double> ele_shape(3 * pts.size2());
  shapeFunMBTRI<1>(&*ele_shape.begin(), &pts(0, 0), &pts(1, 0), pts.size2());
 
  int nb_elems = level_index.back() - level_index[level_index.size() - 2];
  MatrixDouble new_pts(3, pts.size2() * nb_elems);
  FTensor::Tensor1<FTensor::PackPtr<double *, 1>, 2> t_gauss_pt{&new_pts(0, 0),
                                                                &new_pts(1, 0)};
  FTensor::Tensor0<FTensor::PackPtr<double *, 1>> t_gauss_weight{
      &new_pts(2, 0)};
 
  for (auto t = level_index[level_index.size() - 2]; t != level_index.back();
       ++t) {
 
    auto ele_coords = get_coords(t);
    auto t_normal = get_normal(ele_coords);
    auto area = t_normal.l2();
 
    FTensor::Tensor1<FTensor::PackPtr<double *, 3>, 3> t_ele_shape{
        &ele_shape[0], &ele_shape[1], &ele_shape[2]};
    FTensor::Tensor2<double, 3, 2> t_ele_coords{ele_coords[0], ele_coords[1],
                                                ele_coords[3], ele_coords[4],
                                                ele_coords[6], ele_coords[7]};
 
    FTensor::Index<'i', 3> i;
    FTensor::Index<'J', 2> J;
 
    for (auto gg = 0; gg != pts.size2(); ++gg) {
      t_gauss_pt(J) = t_ele_shape(i) * t_ele_coords(i, J);
      t_gauss_weight = area * pts(2, gg);
      ++t_gauss_pt;
      ++t_gauss_weight;
      ++t_ele_shape;
    }
 
  }
 
  return new_pts;
}

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 691 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 682 of file Tools.hpp.

                                            {
  return N_MBEDGE0(x);
}

shapeFunMBEDGE1()

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

inlinestatic

Definition at line 686 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 747 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 730 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 734 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 738 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 742 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 716 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 703 of file Tools.hpp.

                                                           {
  return N_MBTRI0(x, y);
}

shapeFunMBTRI1()

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

inlinestatic

Definition at line 707 of file Tools.hpp.

                                                           {
  return N_MBTRI1(x, y);
}

shapeFunMBTRI2()

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

inlinestatic

Definition at line 711 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 30 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 15 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 269 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

double MoFEM::Tools::diffN_MBEDGE0x = diffN_MBEDGE0

staticconstexpr

Definition at line 65 of file Tools.hpp.

diffN_MBEDGE1x

double MoFEM::Tools::diffN_MBEDGE1x = diffN_MBEDGE1

staticconstexpr

Definition at line 66 of file Tools.hpp.

diffShapeFunMBEDGE

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

staticconstexpr

Initial value:

= {diffN_MBEDGE0x,
                                                               diffN_MBEDGE1x}

Definition at line 68 of file Tools.hpp.

                                                            {diffN_MBEDGE0x,
                                                               diffN_MBEDGE1x};

diffShapeFunMBHEXAtCenter

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, diffShapeFunMBHEXAtCenter0y,
      diffShapeFunMBHEXAtCenter0z,
 
      diffShapeFunMBHEXAtCenter1x, diffShapeFunMBHEXAtCenter1y,
      diffShapeFunMBHEXAtCenter1z,
 
      diffShapeFunMBHEXAtCenter2x, diffShapeFunMBHEXAtCenter2y,
      diffShapeFunMBHEXAtCenter2z,
 
      diffShapeFunMBHEXAtCenter3x, diffShapeFunMBHEXAtCenter3y,
      diffShapeFunMBHEXAtCenter3z,
 
      diffShapeFunMBHEXAtCenter4x, diffShapeFunMBHEXAtCenter4y,
      diffShapeFunMBHEXAtCenter4z,
 
      diffShapeFunMBHEXAtCenter5x, diffShapeFunMBHEXAtCenter5y,
      diffShapeFunMBHEXAtCenter5z,
 
      diffShapeFunMBHEXAtCenter6x, diffShapeFunMBHEXAtCenter6y,
      diffShapeFunMBHEXAtCenter6z,
 
      diffShapeFunMBHEXAtCenter7x, diffShapeFunMBHEXAtCenter7y,
      diffShapeFunMBHEXAtCenter7z
 
  };

diffShapeFunMBHEXAtCenter0x

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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, diffShapeFunMBQUADAtCenter0y,
      diffShapeFunMBQUADAtCenter1x, diffShapeFunMBQUADAtCenter1y,
      diffShapeFunMBQUADAtCenter2x, diffShapeFunMBQUADAtCenter2y,
      diffShapeFunMBQUADAtCenter3x, diffShapeFunMBQUADAtCenter3y};

diffShapeFunMBQUADAtCenter0x

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

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

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

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

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

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

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

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

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, diffShapeFunMBTET0y, diffShapeFunMBTET0z,
 
      diffShapeFunMBTET1x, diffShapeFunMBTET1y, diffShapeFunMBTET1z,
 
      diffShapeFunMBTET2x, diffShapeFunMBTET2y, diffShapeFunMBTET2z,
 
      diffShapeFunMBTET3x, diffShapeFunMBTET3y, diffShapeFunMBTET3z};

diffShapeFunMBTET0x

double MoFEM::Tools::diffShapeFunMBTET0x

staticconstexpr

Initial value:

=
      diffN_MBTET0x

derivative of tetrahedral shape function

Definition at line 246 of file Tools.hpp.

diffShapeFunMBTET0y

double MoFEM::Tools::diffShapeFunMBTET0y

staticconstexpr

Initial value:

=
      diffN_MBTET0y

derivative of tetrahedral shape function

Definition at line 248 of file Tools.hpp.

diffShapeFunMBTET0z

double MoFEM::Tools::diffShapeFunMBTET0z

staticconstexpr

Initial value:

=
      diffN_MBTET0z

derivative of tetrahedral shape function

Definition at line 250 of file Tools.hpp.

diffShapeFunMBTET1x

double MoFEM::Tools::diffShapeFunMBTET1x

staticconstexpr

Initial value:

=
      diffN_MBTET1x

derivative of tetrahedral shape function

Definition at line 252 of file Tools.hpp.

diffShapeFunMBTET1y

double MoFEM::Tools::diffShapeFunMBTET1y

staticconstexpr

Initial value:

=
      diffN_MBTET1y

derivative of tetrahedral shape function

Definition at line 254 of file Tools.hpp.

diffShapeFunMBTET1z

double MoFEM::Tools::diffShapeFunMBTET1z

staticconstexpr

Initial value:

=
      diffN_MBTET1z

derivative of tetrahedral shape function

Definition at line 256 of file Tools.hpp.

diffShapeFunMBTET2x

double MoFEM::Tools::diffShapeFunMBTET2x

staticconstexpr

Initial value:

=
      diffN_MBTET2x

derivative of tetrahedral shape function

Definition at line 258 of file Tools.hpp.

diffShapeFunMBTET2y

double MoFEM::Tools::diffShapeFunMBTET2y

staticconstexpr

Initial value:

=
      diffN_MBTET2y

derivative of tetrahedral shape function

Definition at line 260 of file Tools.hpp.

diffShapeFunMBTET2z

double MoFEM::Tools::diffShapeFunMBTET2z

staticconstexpr

Initial value:

=
      diffN_MBTET2z

derivative of tetrahedral shape function

Definition at line 262 of file Tools.hpp.

diffShapeFunMBTET3x

double MoFEM::Tools::diffShapeFunMBTET3x

staticconstexpr

Initial value:

=
      diffN_MBTET3x

derivative of tetrahedral shape function

Definition at line 264 of file Tools.hpp.

diffShapeFunMBTET3y

double MoFEM::Tools::diffShapeFunMBTET3y

staticconstexpr

Initial value:

=
      diffN_MBTET3y

derivative of tetrahedral shape function

Definition at line 266 of file Tools.hpp.

diffShapeFunMBTET3z

double MoFEM::Tools::diffShapeFunMBTET3z

staticconstexpr

Initial value:

=
      diffN_MBTET3z

derivative of tetrahedral shape function

Definition at line 268 of file Tools.hpp.

diffShapeFunMBTRI

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, diffShapeFunMBTRI0y,
 
      diffShapeFunMBTRI1x, diffShapeFunMBTRI1y,
 
      diffShapeFunMBTRI2x, diffShapeFunMBTRI2y};

diffShapeFunMBTRI0x

double MoFEM::Tools::diffShapeFunMBTRI0x

staticconstexpr

Initial value:

=
      diffN_MBTRI0x

derivative of triangle shape function

Definition at line 91 of file Tools.hpp.

diffShapeFunMBTRI0y

double MoFEM::Tools::diffShapeFunMBTRI0y

staticconstexpr

Initial value:

=
      diffN_MBTRI0y

derivative of triangle shape function

Definition at line 93 of file Tools.hpp.

diffShapeFunMBTRI1x

double MoFEM::Tools::diffShapeFunMBTRI1x

staticconstexpr

Initial value:

=
      diffN_MBTRI1x

derivative of triangle shape function

Definition at line 95 of file Tools.hpp.

diffShapeFunMBTRI1y

double MoFEM::Tools::diffShapeFunMBTRI1y

staticconstexpr

Initial value:

=
      diffN_MBTRI1y

derivative of triangle shape function

Definition at line 97 of file Tools.hpp.

diffShapeFunMBTRI2x

double MoFEM::Tools::diffShapeFunMBTRI2x

staticconstexpr

Initial value:

=
      diffN_MBTRI2x

derivative of triangle shape function

Definition at line 99 of file Tools.hpp.

diffShapeFunMBTRI2y

double MoFEM::Tools::diffShapeFunMBTRI2y

staticconstexpr

Initial value:

=
      diffN_MBTRI2y

derivative of triangle shape function

Definition at line 101 of file Tools.hpp.

shapeFunMBEDGE0At00

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

staticconstexpr

Definition at line 55 of file Tools.hpp.

shapeFunMBEDGE1At00

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

staticconstexpr

Definition at line 56 of file Tools.hpp.

shapeFunMBEDGEAt00

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.

                                                            {
      shapeFunMBEDGE0At00, shapeFunMBEDGE1At00};

shapeFunMBTET0At000

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

staticconstexpr

Definition at line 293 of file Tools.hpp.

shapeFunMBTET0AtOneThird

double MoFEM::Tools::shapeFunMBTET0AtOneThird

staticconstexpr

Initial value:

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

Definition at line 298 of file Tools.hpp.

shapeFunMBTET1At000

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

staticconstexpr

Definition at line 294 of file Tools.hpp.

shapeFunMBTET1AtOneThird

double MoFEM::Tools::shapeFunMBTET1AtOneThird

staticconstexpr

Initial value:

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

Definition at line 300 of file Tools.hpp.

shapeFunMBTET2At000

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

staticconstexpr

Definition at line 295 of file Tools.hpp.

shapeFunMBTET2AtOneThird

double MoFEM::Tools::shapeFunMBTET2AtOneThird

staticconstexpr

Initial value:

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

Definition at line 302 of file Tools.hpp.

shapeFunMBTET3At000

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

staticconstexpr

Definition at line 296 of file Tools.hpp.

shapeFunMBTET3AtOneThird

double MoFEM::Tools::shapeFunMBTET3AtOneThird

staticconstexpr

Initial value:

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

Definition at line 304 of file Tools.hpp.

shapeFunMBTETAt000

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.

                                                            {
      shapeFunMBTET0At000, shapeFunMBTET1At000, shapeFunMBTET2At000,
      shapeFunMBTET3At000};

shapeFunMBTETAtOneThird

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.

                                                                 {
      shapeFunMBTET0AtOneThird, shapeFunMBTET1AtOneThird,
      shapeFunMBTET2AtOneThird, shapeFunMBTET3AtOneThird};

shapeFunMBTRI0At00

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

staticconstexpr

Definition at line 112 of file Tools.hpp.

shapeFunMBTRI1At00

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

staticconstexpr

Definition at line 113 of file Tools.hpp.

shapeFunMBTRI2At00

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

staticconstexpr

Definition at line 114 of file Tools.hpp.

shapeFunMBTRIAt00

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.

                                                           {
      shapeFunMBTRI0At00, shapeFunMBTRI1At00, shapeFunMBTRI2At00};

uniformTriangleRefineTriangles

std::array< int, 12 > MoFEM::Tools::uniformTriangleRefineTriangles

staticconstexpr

Initial value:

= {
 
      0, 3, 5, 
      3, 1, 4, 
      5, 4, 2, 
      5, 3, 4  
 
  }

Definition at line 638 of file Tools.hpp.

                                                                      {
 
      0, 3, 5, // 0
      3, 1, 4, // 1
      5, 4, 2, // 2
      5, 3, 4  // 3
 
  };

---

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

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