MoFEM::FieldEvaluatorInterface Struct Reference

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 (const MOFEMuuid &uuid, 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	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, 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 (const MOFEMuuid &uuid, bool error_if_registration_failed=true)
	Register interface. More...
template<class IFACE , bool VERIFY = false>
MoFEMErrorCode	getInterface (const MOFEMuuid &uuid, IFACE *&iface) const
	Get interface by uuid and return reference to pointer of 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 ()
virtual MoFEMErrorCode	getLibVersion (Version &version) const
	Get library version. More...
virtual const MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version) const
	Get database major version. More...
virtual MoFEMErrorCode	getInterfaceVersion (Version &version) const
	Get database major version. More...
template<>
MoFEMErrorCode	getInterface (const MOFEMuuid &uuid, UnknownInterface *&iface) const

Public Attributes
MoFEM::Core &	cOre

Additional Inherited Members
Protected Member Functions inherited from MoFEM::UnknownInterface
boost::typeindex::type_index	getClassIdx (const MOFEMuuid &uid) const
	Get type name for interface Id. More...
MOFEMuuid	getUId (const boost::typeindex::type_index &class_idx) const
	Get interface Id for class name. More...

Detailed Description

Field evaluator interface.

Examples

EshelbianPlasticity.cpp, field_evaluator.cpp, and lorentz_force.cpp.

Definition at line 34 of file FieldEvaluator.hpp.

Constructor & Destructor Documentation

FieldEvaluatorInterface()

MoFEM::FieldEvaluatorInterface::FieldEvaluatorInterface

(

const MoFEM::Core &

core

)

Definition at line 40 of file FieldEvaluator.hpp.

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

Member Function Documentation

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 37 of file FieldEvaluator.cpp.

                                                                     {
  CoreInterface &m_field = cOre;
  MoFEMFunctionBegin;
  EntityHandle fe_meshset;
  fe_meshset = m_field.get_finite_element_meshset(finite_element);
  Range entities_3d;
  CHKERR m_field.get_moab().get_entities_by_dimension(fe_meshset, 3,
                                                      entities_3d, true);
  spd_ptr->treePtr.reset(new AdaptiveKDTree(&m_field.get_moab()));
  CHKERR spd_ptr->treePtr->build_tree(entities_3d, &spd_ptr->rooTreeSet);
  MoFEMFunctionReturn(0);
}

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,
		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
  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(), MF_EXIST, QUIET);
}

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
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 113 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, 3, tree_ents,
                                                        true);

  if (verb >= VERY_NOISY)
    std::cout << "tree entities: " << tree_ents << endl;

  data_ptr->evalPointEntityHandle.resize(data_ptr->nbEvalPoints);
  std::fill(data_ptr->evalPointEntityHandle.begin(),
            data_ptr->evalPointEntityHandle.end(), 0);

  for (auto tet : tree_ents) {

    const EntityHandle *conn;
    int num_nodes;
    CHKERR m_field.get_moab().get_connectivity(tet, conn, num_nodes, true);
    std::array<double, 12> coords;
    CHKERR m_field.get_moab().get_coords(conn, num_nodes, coords.data());

    for (int n = 0; n != data_ptr->nbEvalPoints; ++n) {

      std::array<double, 3> local_coords;
      CHKERR Tools::getLocalCoordinatesOnReferenceFourNodeTet(
          coords.data(), &data_ptr->evalPoints[3 * n], 1, local_coords.data());

      std::array<double, 4> shape;
      CHKERR Tools::shapeFunMBTET<3>(shape.data(), &local_coords[0],
                                     &local_coords[1], &local_coords[2], 1);

      const double eps = data_ptr->eps;
      if (shape[0] >= 0 - eps && shape[0] <= 1 + eps &&

          shape[1] >= 0 - eps && shape[1] <= 1 + eps &&

          shape[2] >= 0 - eps && shape[2] <= 1 + eps &&

          shape[3] >= 0 - eps && shape[3] <= 1 + eps) {

        std::copy(shape.begin(), shape.end(), &data_ptr->shapeFunctions(n, 0));
        std::copy(local_coords.begin(), local_coords.end(),
                  &data_ptr->localCoords(n, 0));
        data_ptr->evalPointEntityHandle[n] = tet;
      }
    }
  }

  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(3);

  if (verb >= VERY_NOISY)
    std::cout << "in tets: " << in_tets << endl;

  for (auto peit = in_tets.pair_begin(); peit != in_tets.pair_end(); ++peit) {
    auto lo =
        prb_ptr->numeredFiniteElements->get<Composite_Name_And_Ent_mi_tag>()
            .lower_bound(boost::make_tuple(finite_element, peit->first));
    auto hi =
        prb_ptr->numeredFiniteElements->get<Composite_Name_And_Ent_mi_tag>()
            .upper_bound(boost::make_tuple(finite_element, peit->second));
    numered_fes->insert(lo, hi);

    if (verb >= VERY_NOISY)
      std::cout << "numered elements:" << std::endl;
    for (; lo != hi; ++lo)
      if (verb >= VERY_NOISY)
        std::cout << **lo << endl;
  }
  if (verb >= VERY_NOISY)
    std::cout << std::endl;

  if (auto fe_ptr = data_ptr->feMethodPtr.lock()) {
    
    if(verb >= VERBOSE) {
      CHKERR PetscSynchronizedPrintf(
          m_field.get_comm(), "Number elements %d to evaluate at proc %d\n",
          numered_fes->size(), m_field.get_comm_rank());
      PetscSynchronizedFlush(m_field.get_comm(), PETSC_STDOUT);
    }

    CHKERR m_field.loop_finite_elements(prb_ptr, finite_element, *fe_ptr,
                                        lower_rank, upper_rank, numered_fes, bh,
                                        verb);
  } else
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Pointer to element does not exists");

  MoFEMFunctionReturn(0);
}

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
	)

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

EshelbianPlasticity.cpp, field_evaluator.cpp, and lorentz_force.cpp.

Definition at line 118 of file FieldEvaluator.hpp.

                                                                   {
    struct PackData {
      boost::scoped_ptr<VE> volElePtr;
      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->volElePtr.reset(new VE(m_field));
    pack_data->setPtsDataPtr.reset(
        new SPD(boost::shared_ptr<VE>(pack_data, pack_data->volElePtr.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->volElePtr->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 ( const MOFEMuuid &  uuid, UnknownInterface **  iface  ) const

virtual

Implements MoFEM::UnknownInterface.

Definition at line 24 of file FieldEvaluator.cpp.

                                                                         {
  MoFEMFunctionBeginHot;
  *iface = NULL;
  if (uuid == IDD_MOFEMFieldEvaluator) {
    *iface = const_cast<FieldEvaluatorInterface *>(this);
    MoFEMFunctionReturnHot(0);
  }
  SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "unknown interface");
  MoFEMFunctionReturnHot(0);
}

Member Data Documentation

cOre

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

Definition at line 39 of file FieldEvaluator.hpp.

---

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

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