Field evaluator interface. More...

#include "src/interfaces/FieldEvaluator.hpp"

Inheritance diagram for MoFEM::FieldEvaluatorInterface:

Collaboration diagram for MoFEM::FieldEvaluatorInterface:

Classes
struct	SetIntegrationPtsMethod

struct	SetIntegrationPtsMethodData

Public Types
using	SetPtsData = SetIntegrationPtsMethodData

using	VecDataPts = std::vector< std::pair< boost::shared_ptr< VectorDouble >, boost::shared_ptr< VectorDouble > > >

using	MatDataPts = std::vector< std::pair< boost::shared_ptr< MatrixDouble >, boost::shared_ptr< MatrixDouble > > >

Public Member Functions
MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const

	FieldEvaluatorInterface (const MoFEM::Core &core)

template<typename VE , typename SPD = SetIntegrationPtsMethodData, typename SP = SetIntegrationPtsMethod>
boost::shared_ptr< SPD >	getData (const double *ptr=nullptr, const int nb_eval_points=0, const double eps=1e-12, VERBOSITY_LEVELS verb=QUIET)
	Get the Data object.

template<int D>
MoFEMErrorCode	buildTree (boost::shared_ptr< SetIntegrationPtsMethodData > spd_ptr, const std::string finite_element)
	Build spatial tree.

template<int D>
MoFEMErrorCode	buildTree (boost::shared_ptr< SetIntegrationPtsMethodData > spd_ptr, const std::string finite_element, BitRefLevel bit, BitRefLevel mask)
	Build spatial tree.

template<int D>
MoFEMErrorCode	evalFEAtThePoint (const double *const point, const double distance, const std::string problem, const std::string finite_element, boost::shared_ptr< SetIntegrationPtsMethodData > data_ptr, int lower_rank, int upper_rank, boost::shared_ptr< CacheTuple > cache_ptr, MoFEMTypes bh=MF_EXIST, VERBOSITY_LEVELS verb=QUIET)
	Evaluate field at actbitray position.

template<int D>
ForcesAndSourcesCore::UserDataOperator *	getDataOperator (VecDataPts vec_data_pts, MatDataPts mat_data_pts, const std::string finite_element, boost::shared_ptr< SetIntegrationPtsMethodData > data_ptr, int lower_rank, int upper_rank, BitRefLevel bit, BitRefLevel mask, MoFEMTypes bh=MF_EXIST, VERBOSITY_LEVELS verb=QUIET)
	Evaluate field values at integration points of finite elements to which operator is pushed.

template<int D>
MoFEMErrorCode	evalFEAtThePoint (const double *const point, const double distance, const std::string problem, const std::string finite_element, boost::shared_ptr< SetIntegrationPtsMethodData > data_ptr, int lower_rank, int upper_rank, BitRefLevel bit, BitRefLevel mask, boost::shared_ptr< CacheTuple > cache_ptr, MoFEMTypes bh=MF_EXIST, VERBOSITY_LEVELS verb=QUIET)
	Evaluate field at actbitray position.

template<>
MoFEMErrorCode	buildTree (boost::shared_ptr< SetIntegrationPtsMethodData > spd_ptr, const std::string finite_element, BitRefLevel bit, BitRefLevel mask)

template<>
MoFEMErrorCode	buildTree (boost::shared_ptr< SetIntegrationPtsMethodData > spd_ptr, const std::string finite_element, BitRefLevel bit, BitRefLevel mask)

template<>
MoFEMErrorCode	evalFEAtThePoint (const double *const point, const double distance, const std::string problem, const std::string finite_element, boost::shared_ptr< SetIntegrationPtsMethodData > data_ptr, int lower_rank, int upper_rank, BitRefLevel bit, BitRefLevel mask, boost::shared_ptr< CacheTuple > cache_ptr, MoFEMTypes bh, VERBOSITY_LEVELS verb)

template<>
MoFEMErrorCode	evalFEAtThePoint (const double *const point, const double distance, const std::string problem, const std::string finite_element, boost::shared_ptr< SetIntegrationPtsMethodData > data_ptr, int lower_rank, int upper_rank, BitRefLevel bit, BitRefLevel mask, boost::shared_ptr< CacheTuple > cache_ptr, MoFEMTypes bh, VERBOSITY_LEVELS verb)

template<>
ForcesAndSourcesCore::UserDataOperator *	getDataOperator (FieldEvaluatorInterface::VecDataPts vec_data_pts, FieldEvaluatorInterface::MatDataPts mat_data_pts, const std::string finite_element, boost::shared_ptr< SetIntegrationPtsMethodData > data_ptr, int lower_rank, int upper_rank, BitRefLevel bit, BitRefLevel mask, MoFEMTypes bh, VERBOSITY_LEVELS verb)

template<>
ForcesAndSourcesCore::UserDataOperator *	getDataOperator (FieldEvaluatorInterface::VecDataPts vec_data_pts, FieldEvaluatorInterface::MatDataPts mat_data_pts, const std::string finite_element, boost::shared_ptr< SetIntegrationPtsMethodData > data_ptr, int lower_rank, int upper_rank, BitRefLevel bit, BitRefLevel mask, MoFEMTypes bh, VERBOSITY_LEVELS verb)

template<>
MoFEMErrorCode	buildTree (boost::shared_ptr< SetIntegrationPtsMethodData > spd_ptr, const std::string finite_element, BitRefLevel bit, BitRefLevel mask)

template<>
MoFEMErrorCode	buildTree (boost::shared_ptr< SetIntegrationPtsMethodData > spd_ptr, const std::string finite_element, BitRefLevel bit, BitRefLevel mask)

template<>
MoFEMErrorCode	evalFEAtThePoint (const double *const point, const double distance, const std::string problem, const std::string finite_element, boost::shared_ptr< SetIntegrationPtsMethodData > data_ptr, int lower_rank, int upper_rank, BitRefLevel bit, BitRefLevel mask, boost::shared_ptr< CacheTuple > cache_ptr, MoFEMTypes bh, VERBOSITY_LEVELS verb)

template<>
MoFEMErrorCode	evalFEAtThePoint (const double *const point, const double distance, const std::string problem, const std::string finite_element, boost::shared_ptr< SetIntegrationPtsMethodData > data_ptr, int lower_rank, int upper_rank, BitRefLevel bit, BitRefLevel mask, boost::shared_ptr< CacheTuple > cache_ptr, MoFEMTypes bh, VERBOSITY_LEVELS verb)

template<>
ForcesAndSourcesCore::UserDataOperator *	getDataOperator (FieldEvaluatorInterface::VecDataPts vec_data_pts, FieldEvaluatorInterface::MatDataPts mat_data_pts, const std::string finite_element, boost::shared_ptr< SetIntegrationPtsMethodData > data_ptr, int lower_rank, int upper_rank, BitRefLevel bit, BitRefLevel mask, MoFEMTypes bh, VERBOSITY_LEVELS verb)

template<>
ForcesAndSourcesCore::UserDataOperator *	getDataOperator (FieldEvaluatorInterface::VecDataPts vec_data_pts, FieldEvaluatorInterface::MatDataPts mat_data_pts, const std::string finite_element, boost::shared_ptr< SetIntegrationPtsMethodData > data_ptr, int lower_rank, int upper_rank, BitRefLevel bit, BitRefLevel mask, MoFEMTypes bh, VERBOSITY_LEVELS verb)

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

Private Member Functions
template<int D>
MoFEMErrorCode	buildTreeImpl (boost::shared_ptr< SetIntegrationPtsMethodData > spd_ptr, const std::string finite_element, BitRefLevel bit, BitRefLevel mask)

template<int D>
MoFEMErrorCode	evalFEAtThePointImpl (const double *const point, const double distance, const std::string problem, const std::string finite_element, boost::shared_ptr< SetIntegrationPtsMethodData > data_ptr, int lower_rank, int upper_rank, BitRefLevel bit, BitRefLevel mask, boost::shared_ptr< CacheTuple > cache_ptr, MoFEMTypes bh=MF_EXIST, VERBOSITY_LEVELS verb=QUIET)

template<int D>
ForcesAndSourcesCore::UserDataOperator *	getDataOperatorImpl (VecDataPts vec_data_pts, MatDataPts mat_data_pts, const std::string finite_element, boost::shared_ptr< SetIntegrationPtsMethodData > data_ptr, int lower_rank, int upper_rank, BitRefLevel bit, BitRefLevel mask, MoFEMTypes bh=MF_EXIST, VERBOSITY_LEVELS verb=QUIET)

Private Attributes
MoFEM::Core &	cOre

Additional Inherited Members
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.

Detailed Description

Field evaluator interface.

Examples: mofem/atom_tests/field_evaluator.cpp, mofem/tutorials/adv-0/plastic.cpp, mofem/tutorials/adv-2/thermo_elastic.cpp, mofem/tutorials/adv-4/dynamic_first_order_con_law.cpp, mofem/tutorials/adv-5/seepage.cpp, mofem/tutorials/adv-6/between_meshes_dg_projection.cpp, mofem/tutorials/max-1/lorentz_force.cpp, mofem/tutorials/vec-7/adjoint.cpp, mofem/users_modules/basic_finite_elements/elasticity/elasticity.cpp, plastic.cpp, thermo_elastic.cpp, and thermoplastic.cpp.

Definition at line 21 of file FieldEvaluator.hpp.

Member Typedef Documentation

◆ MatDataPts

using MoFEM::FieldEvaluatorInterface::MatDataPts = std::vector< std::pair<boost::shared_ptr<MatrixDouble>, boost::shared_ptr<MatrixDouble> > >

Definition at line 152 of file FieldEvaluator.hpp.

◆ SetPtsData

using MoFEM::FieldEvaluatorInterface::SetPtsData = SetIntegrationPtsMethodData

Definition at line 24 of file FieldEvaluator.hpp.

◆ VecDataPts

using MoFEM::FieldEvaluatorInterface::VecDataPts = std::vector< std::pair<boost::shared_ptr<VectorDouble>, boost::shared_ptr<VectorDouble> > >

Definition at line 145 of file FieldEvaluator.hpp.

Constructor & Destructor Documentation

◆ FieldEvaluatorInterface()

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

Definition at line 8 of file FieldEvaluator.cpp.

    : cOre(const_cast<MoFEM::Core &>(core)) {
 
  if (!LogManager::checkIfChannelExist("FieldEvaluatorWorld")) {
    auto core_log = logging::core::get();
 
    core_log->add_sink(LogManager::createSink(LogManager::getStrmWorld(),
                                              "FieldEvaluatorWorld"));
    core_log->add_sink(LogManager::createSink(LogManager::getStrmSync(),
                                              "FieldEvaluatorSync"));
    core_log->add_sink(LogManager::createSink(LogManager::getStrmSelf(),
                                              "FieldEvaluatorSelf"));
 
    LogManager::setLog("FieldEvaluatorWorld");
    LogManager::setLog("FieldEvaluatorSync");
    LogManager::setLog("FieldEvaluatorSelf");
 
    MOFEM_LOG_TAG("FieldEvaluatorWorld", "FieldEvaluator");
    MOFEM_LOG_TAG("FieldEvaluatorSync", "FieldEvaluator");
    MOFEM_LOG_TAG("FieldEvaluatorSelf", "FieldEvaluator");
  }
 
  MOFEM_LOG("FieldEvaluatorWorld", Sev::noisy) << "Field evaluator intreface";
}

Member Function Documentation

◆ buildTree() [1/6]

template<int D>

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::buildTree	(	boost::shared_ptr< SetIntegrationPtsMethodData >	spd_ptr,
		const std::string	finite_element
	)

inline

Build spatial tree.

Parameters

finite_element finite element name

Returns: MoFEMErrorCode

Examples: mofem/atom_tests/field_evaluator.cpp, and mofem/tutorials/max-1/lorentz_force.cpp.

Definition at line 70 of file FieldEvaluator.hpp.

                                            {
    return buildTree<D>(spd_ptr, finite_element, BitRefLevel(), BitRefLevel());
  }

◆ buildTree() [2/6]

template<int D>

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::buildTree	(	boost::shared_ptr< SetIntegrationPtsMethodData >	spd_ptr,
		const std::string	finite_element,
		BitRefLevel	bit,
		BitRefLevel	mask
	)

Build spatial tree.

Parameters

finite_element	finite element name
bit	bit reference level
mask	mask reference level

Returns: MoFEMErrorCode

◆ buildTree() [3/6]

template<>

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::buildTree	(	boost::shared_ptr< SetIntegrationPtsMethodData >	spd_ptr,
		const std::string	finite_element,
		BitRefLevel	bit,
		BitRefLevel	mask
	)

◆ buildTree() [4/6]

template<>

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::buildTree	(	boost::shared_ptr< SetIntegrationPtsMethodData >	spd_ptr,
		const std::string	finite_element,
		BitRefLevel	bit,
		BitRefLevel	mask
	)

◆ buildTree() [5/6]

template<>

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::buildTree	(	boost::shared_ptr< SetIntegrationPtsMethodData >	spd_ptr,
		const std::string	finite_element,
		BitRefLevel	bit,
		BitRefLevel	mask
	)

Definition at line 61 of file FieldEvaluator.cpp.

                                                                       {
  return buildTreeImpl<2>(spd_ptr, finite_element, bit, mask);
}

◆ buildTree() [6/6]

template<>

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::buildTree	(	boost::shared_ptr< SetIntegrationPtsMethodData >	spd_ptr,
		const std::string	finite_element,
		BitRefLevel	bit,
		BitRefLevel	mask
	)

Definition at line 68 of file FieldEvaluator.cpp.

                                                                       {
  return buildTreeImpl<3>(spd_ptr, finite_element, bit, mask);
}

◆ buildTreeImpl()

template<int D>

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::buildTreeImpl	(	boost::shared_ptr< SetIntegrationPtsMethodData >	spd_ptr,
		const std::string	finite_element,
		BitRefLevel	bit,
		BitRefLevel	mask
	)

private

Definition at line 41 of file FieldEvaluator.cpp.

                                                                       {
  CoreInterface &m_field = cOre;
  MoFEMFunctionBegin;
  EntityHandle fe_meshset;
  fe_meshset = m_field.get_finite_element_meshset(finite_element);
  Range entities;
  CHKERR m_field.get_moab().get_entities_by_dimension(fe_meshset, D, entities,
                                                      true);
  if (bit.any()) {
    CHKERR m_field.getInterface<BitRefManager>()->filterEntitiesByRefLevel(
        bit, mask, entities);
  }
  spd_ptr->treePtr.reset(new AdaptiveKDTree(&m_field.get_moab()));
  CHKERR spd_ptr->treePtr->build_tree(entities, &spd_ptr->rooTreeSet);
  MoFEMFunctionReturn(0);
}

◆ evalFEAtThePoint() [1/6]

template<>

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::evalFEAtThePoint	(	const double *const	point,
		const double	distance,
		const std::string	problem,
		const std::string	finite_element,
		boost::shared_ptr< SetIntegrationPtsMethodData >	data_ptr,
		int	lower_rank,
		int	upper_rank,
		BitRefLevel	bit,
		BitRefLevel	mask,
		boost::shared_ptr< CacheTuple >	cache_ptr,
		MoFEMTypes	bh,
		VERBOSITY_LEVELS	verb
	)

◆ evalFEAtThePoint() [2/6]

template<>

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::evalFEAtThePoint	(	const double *const	point,
		const double	distance,
		const std::string	problem,
		const std::string	finite_element,
		boost::shared_ptr< SetIntegrationPtsMethodData >	data_ptr,
		int	lower_rank,
		int	upper_rank,
		BitRefLevel	bit,
		BitRefLevel	mask,
		boost::shared_ptr< CacheTuple >	cache_ptr,
		MoFEMTypes	bh,
		VERBOSITY_LEVELS	verb
	)

◆ evalFEAtThePoint() [3/6]

template<>

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::evalFEAtThePoint	(	const double *const	point,
		const double	distance,
		const std::string	problem,
		const std::string	finite_element,
		boost::shared_ptr< SetIntegrationPtsMethodData >	data_ptr,
		int	lower_rank,
		int	upper_rank,
		BitRefLevel	bit,
		BitRefLevel	mask,
		boost::shared_ptr< CacheTuple >	cache_ptr,
		MoFEMTypes	bh,
		VERBOSITY_LEVELS	verb
	)

Definition at line 394 of file FieldEvaluator.cpp.

                           {
  return evalFEAtThePointImpl<2>(point, distance, problem, finite_element,
                                 data_ptr, lower_rank, upper_rank, bit, mask,
                                 cache_ptr, bh, verb);
}

◆ evalFEAtThePoint() [4/6]

template<>

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::evalFEAtThePoint	(	const double *const	point,
		const double	distance,
		const std::string	problem,
		const std::string	finite_element,
		boost::shared_ptr< SetIntegrationPtsMethodData >	data_ptr,
		int	lower_rank,
		int	upper_rank,
		BitRefLevel	bit,
		BitRefLevel	mask,
		boost::shared_ptr< CacheTuple >	cache_ptr,
		MoFEMTypes	bh,
		VERBOSITY_LEVELS	verb
	)

Definition at line 407 of file FieldEvaluator.cpp.

                           {
  return evalFEAtThePointImpl<3>(point, distance, problem, finite_element,
                                 data_ptr, lower_rank, upper_rank, bit, mask,
                                 cache_ptr, bh, verb);
}

◆ evalFEAtThePoint() [5/6]

template<int D>

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::evalFEAtThePoint	(	const double *const	point,
		const double	distance,
		const std::string	problem,
		const std::string	finite_element,
		boost::shared_ptr< SetIntegrationPtsMethodData >	data_ptr,
		int	lower_rank,
		int	upper_rank,
		BitRefLevel	bit,
		BitRefLevel	mask,
		boost::shared_ptr< CacheTuple >	cache_ptr,
		MoFEMTypes	bh = `MF_EXIST`,
		VERBOSITY_LEVELS	verb = `QUIET`
	)

Evaluate field at actbitray position.

Parameters

point	point used to find tetrahedrons
distance	distance from the point where tetrahedrons are searched
problem	problem name
finite_element	finite element name
data_ptr	pointer to data abut gauss points
lower_rank	lower processor
upper_rank	upper process
bit	bit reference level
mask	mask reference level
cache_ptr	cache or problem entities
bh	control looping over entities, e.g. throwing error if element not found
verb	verbosity level

Returns: MoFEMErrorCode

◆ evalFEAtThePoint() [6/6]

template<int D>

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::evalFEAtThePoint	(	const double *const	point,
		const double	distance,
		const std::string	problem,
		const std::string	finite_element,
		boost::shared_ptr< SetIntegrationPtsMethodData >	data_ptr,
		int	lower_rank,
		int	upper_rank,
		boost::shared_ptr< CacheTuple >	cache_ptr,
		MoFEMTypes	bh = `MF_EXIST`,
		VERBOSITY_LEVELS	verb = `QUIET`
	)

inline

Evaluate field at actbitray position.

std::array<double, 3> point = {0, 0, 0};
const double dist = 0.3;
std::array<double, 6> eval_points = {-1.,  -1., -1., 1., 1., 1. };
 
using VolEle = VolumeElementForcesAndSourcesCore;
auto data_ptr =
  m_field.getInterface<FieldEvaluatorInterface>()->
  getData<VolEle>(point.data(), point.size/3);
 
if(auto vol_ele = data_ptr->feMethod.lock()) {
  // push operators to finite element instance, e.g.
  vol_ele->getOpPtrVector().push_back(new MyOp());
  // iterate over elemnts with evaluated points
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR m_field.cache_problem_entities(prb_ptr->getName(), cache_ptr);
  // SPACE_DIM is 3 in this example
  CHKERR m_field.getInterface<FieldEvaluatorInterface>()
    ->evalFEAtThePoint<3>(point.data(), dist, prb_ptr->getName(),
                         "FINITE_ELEMENT_NAME",
                         data_ptr, m_field.get_comm_rank(),
                         m_field.get_comm_rank(), cache_ptr);
}

Parameters

point	point used to find tetrahedrons
distance	distance from the point where tetrahedrons are searched
problem	problem name
finite_element	finite element name
data_ptr	pointer to data abut gauss points
lower_rank	lower processor
upper_rank	upper process
cache_ptr	cache or problem entities
bh	control looping over entities, e.g. throwing error if element not found
verb	verbosity level

Returns: MoFEMErrorCode

Examples: mofem/atom_tests/field_evaluator.cpp, and mofem/tutorials/max-1/lorentz_force.cpp.

Definition at line 134 of file FieldEvaluator.hpp.

                                                                            {
    return evalFEAtThePoint<D>(point, distance, problem, finite_element,
                               data_ptr, lower_rank, upper_rank, BitRefLevel(),
                               BitRefLevel(), cache_ptr, bh, verb);
  }

◆ evalFEAtThePointImpl()

template<int D>

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::evalFEAtThePointImpl	(	const double *const	point,
		const double	distance,
		const std::string	problem,
		const std::string	finite_element,
		boost::shared_ptr< SetIntegrationPtsMethodData >	data_ptr,
		int	lower_rank,
		int	upper_rank,
		BitRefLevel	bit,
		BitRefLevel	mask,
		boost::shared_ptr< CacheTuple >	cache_ptr,
		MoFEMTypes	bh = `MF_EXIST`,
		VERBOSITY_LEVELS	verb = `QUIET`
	)

private

Definition at line 170 of file FieldEvaluator.cpp.

                           {
  CoreInterface &m_field = cOre;
  MoFEMFunctionBegin;
 
  std::vector<EntityHandle> leafs_out;
  CHKERR data_ptr->treePtr->distance_search(point, distance, leafs_out);
  Range tree_ents;
  for (auto lit : leafs_out) //{
    CHKERR m_field.get_moab().get_entities_by_dimension(lit, D, tree_ents,
                                                        true);
 
  if (verb >= NOISY)
    MOFEM_LOG("SELF", Sev::noisy) << "tree entities: " << tree_ents;
 
  data_ptr->evalPointEntityHandle.resize(data_ptr->nbEvalPoints);
  std::fill(data_ptr->evalPointEntityHandle.begin(),
            data_ptr->evalPointEntityHandle.end(), 0);
 
  std::vector<double> local_coords;
  std::vector<double> shape;
 
  auto nb_eval_points = data_ptr->nbEvalPoints;
 
  for (auto tet : tree_ents) {
    if ((type_from_handle(tet) != moab::MBTRI) &&
        (type_from_handle(tet) != moab::MBTET)) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
              "Wrong element type, Field Evaluator not implemented for Quads "
              "and Hexes");
    }
    const EntityHandle *conn;
    int num_nodes;
    CHKERR m_field.get_moab().get_connectivity(tet, conn, num_nodes, true);
 
    if constexpr (D == 3) {
 
      local_coords.resize(3 * nb_eval_points);
      shape.resize(4 * nb_eval_points);
 
      std::array<double, 12> coords;
      CHKERR m_field.get_moab().get_coords(conn, num_nodes, coords.data());
 
      CHKERR Tools::getLocalCoordinatesOnReferenceFourNodeTet(
          coords.data(), &data_ptr->evalPoints[0], nb_eval_points,
          &local_coords[0]);
      CHKERR Tools::shapeFunMBTET<3>(&shape[0], &local_coords[0],
                                     &local_coords[1], &local_coords[2],
                                     nb_eval_points);
 
      FTensor::Index<'i', 4> i4;
      FTensor::Tensor1<FTensor::PackPtr<double *, 4>, 4> t_shape{
          &shape[0], &shape[1], &shape[2], &shape[3]};
      FTensor::Tensor1<FTensor::PackPtr<double *, 4>, 4> t_shape_data{
          &data_ptr->shapeFunctions(0, 0), &data_ptr->shapeFunctions(0, 1),
          &data_ptr->shapeFunctions(0, 2), &data_ptr->shapeFunctions(0, 3)};
 
      FTensor::Index<'j', 3> j3;
      FTensor::Tensor1<FTensor::PackPtr<double *, 3>, 3> t_local{
          &local_coords[0], &local_coords[1], &local_coords[2]};
      FTensor::Tensor1<FTensor::PackPtr<double *, 3>, 3> t_local_data{
          &(data_ptr->localCoords(0, 0)), &(data_ptr->localCoords(0, 1)),
          &(data_ptr->localCoords(0, 2))};
 
      for (int n = 0; n != nb_eval_points; ++n) {
 
        const double eps = data_ptr->eps;
        if (t_shape(0) >= 0 - eps && t_shape(0) <= 1 + eps &&
 
            t_shape(1) >= 0 - eps && t_shape(1) <= 1 + eps &&
 
            t_shape(2) >= 0 - eps && t_shape(2) <= 1 + eps &&
 
            t_shape(3) >= 0 - eps && t_shape(3) <= 1 + eps) {
 
          data_ptr->evalPointEntityHandle[n] = tet;
          t_shape_data(i4) = t_shape(i4);
          t_local_data(j3) = t_local(j3);
        }
 
        ++t_shape;
        ++t_shape_data;
        ++t_local;
        ++t_local_data;
      }
    }
 
    if constexpr (D == 2) {
 
      local_coords.resize(2 * nb_eval_points);
      shape.resize(3 * nb_eval_points);
 
      std::array<double, 9> coords;
      CHKERR m_field.get_moab().get_coords(conn, num_nodes, coords.data());
 
      CHKERR Tools::getLocalCoordinatesOnReferenceThreeNodeTri(
          coords.data(), &data_ptr->evalPoints[0], nb_eval_points,
          &local_coords[0]);
      CHKERR Tools::shapeFunMBTRI<2>(&shape[0], &local_coords[0],
                                     &local_coords[1], nb_eval_points);
 
      FTensor::Index<'i', 3> i3;
      FTensor::Tensor1<FTensor::PackPtr<double *, 3>, 3> t_shape{
          &shape[0], &shape[1], &shape[2]};
      FTensor::Tensor1<FTensor::PackPtr<double *, 3>, 3> t_shape_data{
          &data_ptr->shapeFunctions(0, 0), &data_ptr->shapeFunctions(0, 1),
          &data_ptr->shapeFunctions(0, 2)};
 
      FTensor::Index<'j', 2> j2;
      FTensor::Tensor1<FTensor::PackPtr<double *, 2>, 2> t_local{
          &local_coords[0], &local_coords[1]};
      data_ptr->localCoords.resize(nb_eval_points, 2);
      FTensor::Tensor1<FTensor::PackPtr<double *, 2>, 2> t_local_data{
          &(data_ptr->localCoords(0, 0)), &(data_ptr->localCoords(0, 1))};
 
      for (int n = 0; n != nb_eval_points; ++n) {
 
        const double eps = data_ptr->eps;
        if (t_shape(0) >= 0 - eps && t_shape(0) <= 1 + eps &&
 
            t_shape(1) >= 0 - eps && t_shape(1) <= 1 + eps &&
 
            t_shape(2) >= 0 - eps && t_shape(2) <= 1 + eps) {
 
          data_ptr->evalPointEntityHandle[n] = tet;
          t_shape_data(i3) = t_shape(i3);
          t_local_data(j2) = t_local(j2);
        }
 
        ++t_shape;
        ++t_shape_data;
        ++t_local;
        ++t_local_data;
      }
    }
  }
 
  const Problem *prb_ptr;
  CHKERR m_field.get_problem(problem, &prb_ptr);
  boost::shared_ptr<NumeredEntFiniteElement_multiIndex> numered_fes(
      new NumeredEntFiniteElement_multiIndex());
 
  Range in_tets;
  in_tets.insert_list(data_ptr->evalPointEntityHandle.begin(),
                      data_ptr->evalPointEntityHandle.end());
  in_tets = in_tets.subset_by_dimension(D);
 
  if (verb >= NOISY)
    MOFEM_LOG("SELF", Sev::noisy) << "in tets: " << in_tets << endl;
 
  auto fe_miit =
      m_field.get_finite_elements()->get<FiniteElement_name_mi_tag>().find(
          finite_element);
  if (fe_miit !=
      m_field.get_finite_elements()->get<FiniteElement_name_mi_tag>().end()) {
 
    for (auto peit = in_tets.pair_begin(); peit != in_tets.pair_end(); ++peit) {
 
      auto lo =
          prb_ptr->numeredFiniteElementsPtr->get<Unique_mi_tag>().lower_bound(
              EntFiniteElement::getLocalUniqueIdCalculate(
                  peit->first, (*fe_miit)->getFEUId()));
      auto hi =
          prb_ptr->numeredFiniteElementsPtr->get<Unique_mi_tag>().upper_bound(
              EntFiniteElement::getLocalUniqueIdCalculate(
                  peit->second, (*fe_miit)->getFEUId()));
 
      if (bit.any()) {
        for (auto it = lo; it != hi; ++it) {
          auto fe_bit = (*it)->getBitRefLevel();
          if ((fe_bit & mask) != fe_bit)
            continue;
          if ((fe_bit & bit).none())
            continue;
          numered_fes->insert(*it);
        }
      } else {
        numered_fes->insert(lo, hi);
      }
 
      if (verb >= VERY_NOISY)
        std::cerr << "numered elements:" << std::endl;
      for (; lo != hi; ++lo)
        if (verb >= VERY_NOISY)
          std::cerr << **lo << endl;
    }
    if (verb >= VERY_NOISY)
      std::cerr << std::endl;
 
    if (auto fe_ptr = data_ptr->feMethodPtr.lock()) {
 
      MOFEM_LOG_C("FieldEvaluatorSync", Sev::verbose,
                  "Number elements %d to evaluate at proc %d",
                  numered_fes->size(), m_field.get_comm_rank());
      MOFEM_LOG_SYNCHRONISE(m_field.get_comm());
 
      if (!cache_ptr) {
        cache_ptr = boost::make_shared<CacheTuple>();
        CHKERR m_field.cache_problem_entities(prb_ptr->getName(), cache_ptr);
 
        MOFEM_LOG("FieldEvaluatorSync", Sev::noisy)
            << "If you call that function many times in the loop consider to "
               "set "
               "cache_ptr outside of the loop. Otherwise code can be slow.";
      }
 
      CHKERR m_field.loop_finite_elements(prb_ptr, finite_element, *fe_ptr,
                                          lower_rank, upper_rank, numered_fes,
                                          bh, cache_ptr, verb);
 
    } else
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Pointer to element does not exists");
  }
 
  MoFEMFunctionReturn(0);
}

◆ getData()

template<typename VE , typename SPD , typename SP >

boost::shared_ptr< SPD > MoFEM::FieldEvaluatorInterface::getData	(	const double *	ptr = `nullptr`,
		const int	nb_eval_points = `0`,
		const double	eps = `1e-12`,
		VERBOSITY_LEVELS	verb = `QUIET`
	)

Get the Data object.

Pack pointers with data structures for field evaluator and finite element. Function return shared pointer if returned shared pointer is reset; all data are destroyed. The idea is to pack all data in one structure, create shared pointer to it and return aliased shared pointer to one of the elements of the data structure. It is a bit complicated, but has great flexibility.

Template Parameters

VE
SetIntegrationPtsMethodData
SetIntegrationPtsMethod

Parameters

ptr
nb_eval_points
eps
verb

Returns: boost::shared_ptr<SPD>

Examples: mofem/atom_tests/field_evaluator.cpp, mofem/tutorials/adv-6/between_meshes_dg_projection.cpp, and mofem/tutorials/max-1/lorentz_force.cpp.

Definition at line 333 of file FieldEvaluator.hpp.

                                                                          {
 
  struct PackData {
    boost::scoped_ptr<VE> elePtr;         //< finite element pointer
    boost::scoped_ptr<SPD> setPtsDataPtr; //< integration pts data
    boost::scoped_ptr<SP> setPtsPtr;      //< integration pts method
  };
  boost::shared_ptr<PackData> pack_data(new PackData());
  MoFEM::Interface &m_field = cOre;
  pack_data->elePtr.reset(new VE(m_field));
 
  pack_data->setPtsDataPtr.reset(
      new SPD(boost::shared_ptr<VE>(pack_data, pack_data->elePtr.get()), ptr,
              nb_eval_points, eps, verb));
  pack_data->setPtsPtr.reset(new SP(
      boost::shared_ptr<SPD>(pack_data, pack_data->setPtsDataPtr.get())));
  pack_data->elePtr->setRuleHook = boost::ref(*pack_data->setPtsPtr);
  boost::shared_ptr<SPD> data(pack_data, pack_data->setPtsDataPtr.get());
  return data;
}

◆ getDataOperator() [1/5]

template<>

ForcesAndSourcesCore::UserDataOperator * MoFEM::FieldEvaluatorInterface::getDataOperator	(	FieldEvaluatorInterface::VecDataPts	vec_data_pts,
		FieldEvaluatorInterface::MatDataPts	mat_data_pts,
		const std::string	finite_element,
		boost::shared_ptr< SetIntegrationPtsMethodData >	data_ptr,
		int	lower_rank,
		int	upper_rank,
		BitRefLevel	bit,
		BitRefLevel	mask,
		MoFEMTypes	bh,
		VERBOSITY_LEVELS	verb
	)

◆ getDataOperator() [2/5]

template<>

ForcesAndSourcesCore::UserDataOperator * MoFEM::FieldEvaluatorInterface::getDataOperator	(	FieldEvaluatorInterface::VecDataPts	vec_data_pts,
		FieldEvaluatorInterface::MatDataPts	mat_data_pts,
		const std::string	finite_element,
		boost::shared_ptr< SetIntegrationPtsMethodData >	data_ptr,
		int	lower_rank,
		int	upper_rank,
		BitRefLevel	bit,
		BitRefLevel	mask,
		MoFEMTypes	bh,
		VERBOSITY_LEVELS	verb
	)

◆ getDataOperator() [3/5]

template<>

ForcesAndSourcesCore::UserDataOperator * MoFEM::FieldEvaluatorInterface::getDataOperator	(	FieldEvaluatorInterface::VecDataPts	vec_data_pts,
		FieldEvaluatorInterface::MatDataPts	mat_data_pts,
		const std::string	finite_element,
		boost::shared_ptr< SetIntegrationPtsMethodData >	data_ptr,
		int	lower_rank,
		int	upper_rank,
		BitRefLevel	bit,
		BitRefLevel	mask,
		MoFEMTypes	bh,
		VERBOSITY_LEVELS	verb
	)

Definition at line 559 of file FieldEvaluator.cpp.

                           {
  return getDataOperatorImpl<2>(vec_data_pts, mat_data_pts, finite_element,
                                data_ptr, lower_rank, upper_rank, bit, mask, bh,
                                verb);
}

◆ getDataOperator() [4/5]

template<>

ForcesAndSourcesCore::UserDataOperator * MoFEM::FieldEvaluatorInterface::getDataOperator	(	FieldEvaluatorInterface::VecDataPts	vec_data_pts,
		FieldEvaluatorInterface::MatDataPts	mat_data_pts,
		const std::string	finite_element,
		boost::shared_ptr< SetIntegrationPtsMethodData >	data_ptr,
		int	lower_rank,
		int	upper_rank,
		BitRefLevel	bit,
		BitRefLevel	mask,
		MoFEMTypes	bh,
		VERBOSITY_LEVELS	verb
	)

Definition at line 573 of file FieldEvaluator.cpp.

                           {
  return getDataOperatorImpl<3>(vec_data_pts, mat_data_pts, finite_element,
                                data_ptr, lower_rank, upper_rank, bit, mask, bh,
                                verb);
}

◆ getDataOperator() [5/5]

template<int D>

ForcesAndSourcesCore::UserDataOperator * MoFEM::FieldEvaluatorInterface::getDataOperator	(	VecDataPts	vec_data_pts,
		MatDataPts	mat_data_pts,
		const std::string	finite_element,
		boost::shared_ptr< SetIntegrationPtsMethodData >	data_ptr,
		int	lower_rank,
		int	upper_rank,
		BitRefLevel	bit,
		BitRefLevel	mask,
		MoFEMTypes	bh = `MF_EXIST`,
		VERBOSITY_LEVELS	verb = `QUIET`
	)

Evaluate field values at integration points of finite elements to which operator is pushed.

Parameters

vec_data_pts	vector of data shared between physical and post proc elements
mat_data_pts	matrix of data shared between physical and post proc elements
finite_element	finite element name on which field is evaluated
data_ptr	data about field evaluator
bh	control looping over entities, e.g. throwing error if element not found

◆ getDataOperatorImpl()

template<int D>

ForcesAndSourcesCore::UserDataOperator * MoFEM::FieldEvaluatorInterface::getDataOperatorImpl	(	FieldEvaluatorInterface::VecDataPts	vec_data_pts,
		FieldEvaluatorInterface::MatDataPts	mat_data_pts,
		const std::string	finite_element,
		boost::shared_ptr< SetIntegrationPtsMethodData >	data_ptr,
		int	lower_rank,
		int	upper_rank,
		BitRefLevel	bit,
		BitRefLevel	mask,
		MoFEMTypes	bh = `MF_EXIST`,
		VERBOSITY_LEVELS	verb = `QUIET`
	)

private

Definition at line 421 of file FieldEvaluator.cpp.

                                          {
 
  using BaseOP = ForcesAndSourcesCore::UserDataOperator;
 
  struct Op : public BaseOP {
    Op(
 
        FieldEvaluatorInterface::VecDataPts vec_data_pts,
        FieldEvaluatorInterface::MatDataPts mat_data_pts,
        const std::string finite_element,
        boost::shared_ptr<SetIntegrationPtsMethodData> data_ptr, int lower_rank,
        int upper_rank, BitRefLevel bit, BitRefLevel mask, double eps,
        MoFEMTypes bh, VERBOSITY_LEVELS verb
 
        )
        : BaseOP(NOSPACE, BaseOP::OPSPACE), vecDataPts(vec_data_pts),
          matDataPts(mat_data_pts), finiteElement(finite_element),
          dataPtr(data_ptr), lowerRank(lower_rank), upperRank(upper_rank),
          bitRefLevel(bit), maskRefLevel(mask), eps(eps), bhType(bh),
          verbosity(verb) {}
 
    MoFEMErrorCode doWork(int side, EntityType type,
                          EntitiesFieldData::EntData &data) {
      MoFEMFunctionBegin;
 
      MOFEM_LOG_CHANNEL("SELF");
      MOFEM_LOG_TAG("SELF", "FieldEvaluator");
 
      auto &m_field = this->getPtrFE()->mField;
      auto field_eval_ptr = m_field.getInterface<FieldEvaluatorInterface>();
 
      auto nb_integration_pts = getGaussPts().size2();
      auto &spatial_coords = getCoordsAtGaussPts();
 
      auto prb_name = getPtrFE()->problemPtr->getName();
      auto cache_ptr = getPtrFE()->getCacheWeakPtr();
 
      auto coords_at_pts = getCoordsAtGaussPts();
      for (int gg = 0; gg != nb_integration_pts; ++gg) {
        double *coords_ptr = &coords_at_pts(gg, 0);
 
        dataPtr->setEvalPoints(coords_ptr, 1);
        CHKERR field_eval_ptr->evalFEAtThePoint<D>(
            coords_ptr, eps, prb_name, finiteElement, dataPtr, lowerRank,
            upperRank, bitRefLevel, maskRefLevel, cache_ptr.lock(), MF_EXIST,
            QUIET);
 
        // Get number of found finite elements, that consist gauss point.
        // For edge flip expected is that only one element will be found.
        auto loop_size = dataPtr->feMethodPtr.lock()->getLoopSize();
        if (loop_size != 1) {
          if (verbosity >= QUIET) {
            MOFEM_LOG_ATTRIBUTES("SELF",
                                 LogManager::BitLineID | LogManager::BitScope);
            MOFEM_LOG("SELF", Sev::warning)
                << "Field evaluator wrong number of elements found %d",
                loop_size;
          }
        }
 
        for (auto &v : vecDataPts) {
          v.second->resize(nb_integration_pts, false);
          if (gg == 0)
            v.second->clear();
          for (auto ll = 0; ll != loop_size; ++ll)
            (*v.second)(gg) += (*v.first)(ll) / loop_size;
        }
 
        for (auto &m : matDataPts) {
          auto nb_rows = m.first->size1();
          m.second->resize(nb_rows, nb_integration_pts, false);
          if (gg == 0)
            m.second->clear();
          for (auto ll = 0; ll != loop_size; ++ll) {
            for (int dd = 0; dd != nb_rows; ++dd) {
              (*m.second)(dd, gg) += (*m.first)(dd, ll) / loop_size;
            }
          }
        }
      }
 
      MOFEM_LOG_CHANNEL("SELF");
 
      MoFEMFunctionReturn(0);
    }
 
  private:
    FieldEvaluatorInterface::VecDataPts vecDataPts;
    FieldEvaluatorInterface::MatDataPts matDataPts;
    std::string finiteElement;
    boost::shared_ptr<SetIntegrationPtsMethodData> dataPtr;
    int lowerRank;
    int upperRank;
    BitRefLevel bitRefLevel;
    BitRefLevel maskRefLevel;
    double eps;
    MoFEMTypes bhType;
    VERBOSITY_LEVELS verbosity;
  };
 
  double min[3];
  double max[3];
  unsigned int dep;
  CHKERR data_ptr->treePtr->get_info(data_ptr->rooTreeSet, min, max, dep);
  double dist = std::sqrt(pow(max[0] - min[0], 2) + pow(max[1] - min[1], 2) +
                          pow(max[2] - min[2], 2));
 
  return new Op(vec_data_pts, mat_data_pts, finite_element, data_ptr,
                lower_rank, upper_rank, bit, mask, 1e-6 * dist, bh, verb);
}

◆ query_interface()

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

virtual

Implements MoFEM::UnknownInterface.

Definition at line 33 of file FieldEvaluator.cpp.

                                                                         {
  MoFEMFunctionBeginHot;
  *iface = const_cast<FieldEvaluatorInterface *>(this);
  MoFEMFunctionReturnHot(0);
}

Member Data Documentation

◆ cOre

MoFEM::Core& MoFEM::FieldEvaluatorInterface::cOre

private

Definition at line 209 of file FieldEvaluator.hpp.

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

src/interfaces/FieldEvaluator.hpp
src/interfaces/impl/FieldEvaluator.cpp

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ MatDataPts

◆ SetPtsData

◆ VecDataPts

Constructor & Destructor Documentation

◆ FieldEvaluatorInterface()

Member Function Documentation

◆ buildTree() [1/6]

◆ buildTree() [2/6]

◆ buildTree() [3/6]

◆ buildTree() [4/6]

◆ buildTree() [5/6]

◆ buildTree() [6/6]

◆ buildTreeImpl()

◆ evalFEAtThePoint() [1/6]

◆ evalFEAtThePoint() [2/6]

◆ evalFEAtThePoint() [3/6]

◆ evalFEAtThePoint() [4/6]

◆ evalFEAtThePoint() [5/6]

◆ evalFEAtThePoint() [6/6]

◆ evalFEAtThePointImpl()

◆ getData()

◆ getDataOperator() [1/5]

◆ getDataOperator() [2/5]

◆ getDataOperator() [3/5]

◆ getDataOperator() [4/5]

◆ getDataOperator() [5/5]

◆ getDataOperatorImpl()

◆ query_interface()

Member Data Documentation

◆ cOre