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	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 arbitrary position.

template<int D>
ForcesAndSourcesCore::UserDataOperator *	getDataOperator (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, DataLayout data_layout=DataLayout::GaussByCoeffs)
	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 arbitrary 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::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, DataLayout data_layout)

template<>
ForcesAndSourcesCore::UserDataOperator *	getDataOperator (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, DataLayout data_layout)

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::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, DataLayout data_layout)

template<>
ForcesAndSourcesCore::UserDataOperator *	getDataOperator (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, DataLayout data_layout)

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 (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, DataLayout data_layout=DataLayout::GaussByCoeffs)

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_plasticity/plastic.cpp, mofem/tutorials/adv-4_dynamic_first_order_con_law/dynamic_first_order_con_law.cpp, mofem/tutorials/adv-5_poroelasticity/seepage.cpp, mofem/tutorials/adv-6_dg_projection/between_meshes_dg_projection.cpp, mofem/tutorials/max-1_lorentz_force//lorentz_force.cpp, mofem/tutorials/vec-7_shape_optimisation/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 145 of file FieldEvaluator.hpp.

◆ SetPtsData

using MoFEM::FieldEvaluatorInterface::SetPtsData = SetIntegrationPtsMethodData

Definition at line 24 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//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 65 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 72 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);
  }
  if (spd_ptr->treePtr) {
    spd_ptr->treePtr->reset_tree();
  } else {
    spd_ptr->treePtr = boost::make_shared<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 398 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 411 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 arbitrary 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 arbitrary 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//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 174 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()) {
        if (verb >= VERY_NOISY)
          MOFEM_LOG("FieldEvaluatorSelf", Sev::noisy);
        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);
          if (verb >= VERY_NOISY)
            MOFEM_LOG("FieldEvaluatorSelf", Sev::noisy) << **it << endl;
        }
      } else {
        numered_fes->insert(lo, hi);
        if (verb >= VERY_NOISY) {
          MOFEM_LOG("FieldEvaluatorSelf", Sev::noisy)
              << "numbered elements:" << std::endl;
          for (; lo != hi; ++lo)
            MOFEM_LOG("FieldEvaluatorSelf", Sev::noisy) << **lo << endl;
        }
      }
    }
 
    if (auto fe_ptr = data_ptr->feMethodPtr) {
 
      MOFEM_LOG_C("FieldEvaluatorSelf", Sev::noisy,
                  "Number elements %zu to evaluate at proc %d",
                  numered_fes->size(), m_field.get_comm_rank());
 
      if (!cache_ptr) {
        cache_ptr = boost::make_shared<CacheTuple>();
        CHKERR m_field.cache_problem_entities(prb_ptr->getName(), cache_ptr);
 
        MOFEM_LOG("FieldEvaluatorSelf", 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_dg_projection/between_meshes_dg_projection.cpp, and mofem/tutorials/max-1_lorentz_force//lorentz_force.cpp.

Definition at line 334 of file FieldEvaluator.hpp.

                                                                          {
  MoFEM::Interface &m_field = cOre;
  auto ve_method_ptr = boost::make_shared<VE>(m_field);
  auto spd_ptr =
      boost::make_shared<SPD>(ve_method_ptr, ptr, nb_eval_points, eps, verb);
  ve_method_ptr->setRuleHook = SP(spd_ptr);
  return spd_ptr;
}

◆ getDataOperator() [1/5]

template<>

ForcesAndSourcesCore::UserDataOperator * MoFEM::FieldEvaluatorInterface::getDataOperator	(	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,
		DataLayout	data_layout
	)

◆ getDataOperator() [2/5]

template<>

ForcesAndSourcesCore::UserDataOperator * MoFEM::FieldEvaluatorInterface::getDataOperator	(	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,
		DataLayout	data_layout
	)

◆ getDataOperator() [3/5]

template<>

ForcesAndSourcesCore::UserDataOperator * MoFEM::FieldEvaluatorInterface::getDataOperator	(	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,
		DataLayout	data_layout
	)

Definition at line 583 of file FieldEvaluator.cpp.

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

◆ getDataOperator() [4/5]

template<>

ForcesAndSourcesCore::UserDataOperator * MoFEM::FieldEvaluatorInterface::getDataOperator	(	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,
		DataLayout	data_layout
	)

Definition at line 596 of file FieldEvaluator.cpp.

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

◆ getDataOperator() [5/5]

template<int D>

ForcesAndSourcesCore::UserDataOperator * MoFEM::FieldEvaluatorInterface::getDataOperator	(	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`,
		DataLayout	data_layout = `DataLayout::GaussByCoeffs`
	)

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

Parameters

mat_data_pts	vector of pairs of pointers to matrices with field values at integration points
finite_element	finite element name on which field is evaluated
data_ptr	data about field evaluator
lower_rank	lower processor
upper_rank	upper processor
bit	bit reference level
mask	mask reference level
bh	control looping over entities, e.g. throwing error if element not found
verb	verbosity level
data_layout	layout of evaluated output matrices

Returns: ForcesAndSourcesCore::UserDataOperator*

◆ getDataOperatorImpl()

template<int D>

ForcesAndSourcesCore::UserDataOperator * MoFEM::FieldEvaluatorInterface::getDataOperatorImpl	(	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`,
		DataLayout	data_layout = `DataLayout::GaussByCoeffs`
	)

private

Definition at line 425 of file FieldEvaluator.cpp.

                                                                  {
 
  using BaseOP = ForcesAndSourcesCore::UserDataOperator;
 
  struct Op : public BaseOP {
    Op(
 
        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, DataLayout data_layout
 
        )
        : BaseOP(NOSPACE, BaseOP::OPSPACE), 
          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), dataLayout(data_layout) {}
 
    MoFEMErrorCode doWork(int side, EntityType type,
                          EntitiesFieldData::EntData &data) {
      MoFEMFunctionBegin;
 
      MOFEM_LOG_CHANNEL("SELF");
      MOFEM_LOG_TAG("SELF", "FieldEvaluator");
 
      MoFEM::Interface &m_field = this->getPtrFE()->mField;
      auto field_eval_ptr = m_field.getInterface<FieldEvaluatorInterface>();
 
      auto nb_integration_pts = getGaussPts().size2();
 
      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.
        // E.g. for edge flip expected is that only one element will be found.
        auto loop_size = dataPtr->feMethodPtr->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: "
                << loop_size;
          }
        }
 
        for (auto &m : matDataPts) {
 
          const auto nb_data_rows = m.first->size1();
          const auto nb_data_cols = m.first->size2();
 
#ifndef NDEBUG
          const auto nb_data_gauss_pts =
              dataLayout == DataLayout::GaussByCoeffs ? nb_data_rows
                                                      : nb_data_cols;
          if (nb_data_gauss_pts != loop_size) {
            SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                    "Inconsistent source data layout for size (%ld, %ld), "
                    "loop size %d, and requested layout %s",
                    nb_data_rows, nb_data_cols, loop_size,
                    dataLayout == DataLayout::GaussByCoeffs ? "GaussByCoeffs"
                                                            : "CoeffsByGauss");
          }
#endif
 
          const auto nb_data_coeffs =
              dataLayout == DataLayout::GaussByCoeffs ? nb_data_cols
                                                      : nb_data_rows;
 
          if (dataLayout == DataLayout::GaussByCoeffs) {
            m.second->resize(nb_integration_pts, nb_data_coeffs, false);
          } else {
            m.second->resize(nb_data_coeffs, nb_integration_pts, false);
          }
          if (gg == 0)
            m.second->clear();
          for (auto ll = 0; ll != loop_size; ++ll) {
            for (int dd = 0; dd != nb_data_coeffs; ++dd) {
              const auto value = dataLayout == DataLayout::GaussByCoeffs
                                     ? (*m.first)(ll, dd)
                                     : (*m.first)(dd, ll);
              if (dataLayout == DataLayout::GaussByCoeffs) {
                (*m.second)(gg, dd) += value / loop_size;
              } else {
                (*m.second)(dd, gg) += value / loop_size;
              }
            }
          }
        }
      }
 
      MOFEM_LOG_CHANNEL("SELF");
 
      MoFEMFunctionReturn(0);
    }
 
  private:
    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;
    DataLayout dataLayout;
  };
 
  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(mat_data_pts, finite_element, data_ptr, lower_rank,
                upper_rank, bit, mask, 1e-6 * dist, bh, verb, data_layout);
}

◆ 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 206 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

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