Field evaluator interface. More...

#include <src/interfaces/FieldEvaluator.hpp>

Inheritance diagram for MoFEM::FieldEvaluatorInterface:

Collaboration diagram for MoFEM::FieldEvaluatorInterface:

Classes
struct	SetPts
	Default evaluator for setting integration points. More...

struct	SetPtsData

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 = SetPtsData, typename SP = SetPts>
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. More...

MoFEMErrorCode	buildTree3D (boost::shared_ptr< SetPtsData > spd_ptr, const std::string finite_element)
	Build spatial tree. More...

MoFEMErrorCode	buildTree2D (boost::shared_ptr< SetPtsData > spd_ptr, const std::string finite_element)
	Build spatial tree. More...

MoFEMErrorCode	evalFEAtThePoint3D (const double *const point, const double distance, const std::string problem, const std::string finite_element, boost::shared_ptr< SetPtsData > 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 artbitray position. More...

MoFEMErrorCode	evalFEAtThePoint2D (const double *const point, const double distance, const std::string problem, const std::string finite_element, boost::shared_ptr< SetPtsData > 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 artbitray position. More...

Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode	registerInterface (bool error_if_registration_failed=true)
	Register interface. More...

template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface refernce to pointer of interface. More...

template<class IFACE >
MoFEMErrorCode	getInterface (IFACE **const iface) const
	Get interface pointer to pointer of interface. More...

template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get interface pointer to pointer of interface. More...

template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get reference to interface. More...

template<class IFACE >
IFACE *	getInterface () const
	Function returning pointer to interface. More...

virtual	~UnknownInterface ()=default

Public Attributes
MoFEM::Core &	cOre

Private Member Functions
template<int D>
MoFEMErrorCode	buildTree (boost::shared_ptr< SetPtsData > spd_ptr, const std::string finite_element)
	Build spatial tree. More...

template<int D>
MoFEMErrorCode	evalFEAtThePoint (const double *const point, const double distance, const std::string problem, const std::string finite_element, boost::shared_ptr< SetPtsData > 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 artbitray position. More...

Additional Inherited Members
Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode	getLibVersion (Version &version)
	Get library version. More...

static MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version)
	Get database major version. More...

static MoFEMErrorCode	setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
	Get database major version. More...

static MoFEMErrorCode	getInterfaceVersion (Version &version)
	Get database major version. More...

Detailed Description

Field evaluator interface.

Examples: dynamic_first_order_con_law.cpp, elasticity.cpp, field_evaluator.cpp, lorentz_force.cpp, seepage.cpp, and thermo_elastic.cpp.

Definition at line 21 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()

template<int D>

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

private

Build spatial tree.

Parameters

finite_element finite element name

Returns: MoFEMErrorCode

Definition at line 42 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);
   spd_ptr->treePtr.reset(new AdaptiveKDTree(&m_field.get_moab()));
   CHKERR spd_ptr->treePtr->build_tree(entities, &spd_ptr->rooTreeSet);
   MoFEMFunctionReturn(0);
 }

◆ buildTree2D()

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

Build spatial tree.

Parameters

finite_element finite element name

Returns: MoFEMErrorCode

Examples: field_evaluator.cpp.

Definition at line 63 of file FieldEvaluator.cpp.

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

◆ buildTree3D()

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

Build spatial tree.

Parameters

finite_element finite element name

Returns: MoFEMErrorCode

Examples: field_evaluator.cpp, and lorentz_force.cpp.

Definition at line 57 of file FieldEvaluator.cpp.

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

◆ evalFEAtThePoint()

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< SetPtsData >	data_ptr,
		int	lower_rank,
		int	upper_rank,
		boost::shared_ptr< CacheTuple >	cache_ptr,
		MoFEMTypes	bh = `MF_EXIST`,
		VERBOSITY_LEVELS	verb = `QUIET`
	)

private

Evaluate field at artbitray 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);
  CHKERR m_field.getInterface<FieldEvaluatorInterface>()
    ->evalFEAtThePoint3D(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

Definition at line 161 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) {
     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()));
       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);
 }

◆ evalFEAtThePoint2D()

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::evalFEAtThePoint2D	(	const double *const	point,
		const double	distance,
		const std::string	problem,
		const std::string	finite_element,
		boost::shared_ptr< SetPtsData >	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 artbitray 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);
  CHKERR m_field.getInterface<FieldEvaluatorInterface>()
    ->evalFEAtThePoint3D(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: field_evaluator.cpp.

Definition at line 373 of file FieldEvaluator.cpp.

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

◆ evalFEAtThePoint3D()

MoFEMErrorCode MoFEM::FieldEvaluatorInterface::evalFEAtThePoint3D	(	const double *const	point,
		const double	distance,
		const std::string	problem,
		const std::string	finite_element,
		boost::shared_ptr< SetPtsData >	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 artbitray 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);
  CHKERR m_field.getInterface<FieldEvaluatorInterface>()
    ->evalFEAtThePoint3D(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: field_evaluator.cpp, and lorentz_force.cpp.

Definition at line 364 of file FieldEvaluator.cpp.

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

◆ getData()

template<typename VE , typename SPD = SetPtsData, typename SP = SetPts>

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`
	)

inline

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
SetPtsData
SetPts

Parameters

ptr
nb_eval_points
eps
verb

Returns: boost::shared_ptr<SPD>

Examples: field_evaluator.cpp, and lorentz_force.cpp.

Definition at line 107 of file FieldEvaluator.hpp.

                                                                    {
     struct PackData {
       boost::scoped_ptr<VE> elePtr;
       boost::scoped_ptr<SPD> setPtsDataPtr;
       boost::scoped_ptr<SP> setPtsPtr;
     };
     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;
   }

◆ 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

Definition at line 26 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 Member Functions

Public Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FieldEvaluatorInterface()

Member Function Documentation

◆ buildTree()

◆ buildTree2D()

◆ buildTree3D()

◆ evalFEAtThePoint()

◆ evalFEAtThePoint2D()

◆ evalFEAtThePoint3D()

◆ getData()

◆ query_interface()

Member Data Documentation

◆ cOre