MoFEM::ForcesAndSourcesCore Struct Reference

structure to get information form mofem into DataForcesAndSourcesCore More...

#include <src/finite_elements/ForcesAndSourcesCore.hpp>

Inheritance diagram for MoFEM::ForcesAndSourcesCore:

Collaboration diagram for MoFEM::ForcesAndSourcesCore:

Classes
struct	UserDataOperator
	Data operator to do calculations at integration points.Is inherited and implemented by user to do calculations. It can be used in many different ways but typically is used to integrate matrices (f.e. stiffness matrix) and the right hand vector (f.e. force vector). More...

Public Types
typedef boost::function< int(int order_row, int order_col, int order_data)>	RuleHookFun
Public Types inherited from MoFEM::KspMethod
enum	KSPContext { CTX_SETFUNCTION, CTX_OPERATORS, CTX_KSPNONE }
	pass information about context of KSP/DM for with finite element is computed More...
Public Types inherited from MoFEM::PetscData
enum	DataContext {   CTX_SET_NONE = 0, CTX_SET_F = 1 << 0, CTX_SET_A = 1 << 1, CTX_SET_B = 1 << 2,   CTX_SET_X = 1 << 3, CTX_SET_X_T = 1 << 4, CTX_SET_X_TT = 1 << 6, CTX_SET_TIME = 1 << 7 }
using	Switches = std::bitset< 8 >
Public Types inherited from MoFEM::SnesMethod
enum	SNESContext { CTX_SNESSETFUNCTION, CTX_SNESSETJACOBIAN, CTX_SNESNONE }
Public Types inherited from MoFEM::TSMethod
enum	TSContext {   CTX_TSSETRHSFUNCTION, CTX_TSSETRHSJACOBIAN, CTX_TSSETIFUNCTION, CTX_TSSETIJACOBIAN,   CTX_TSTSMONITORSET, CTX_TSNONE }

Public Member Functions
	ForcesAndSourcesCore (Interface &m_field)
boost::ptr_vector< UserDataOperator > &	getOpPtrVector ()
	Use to push back operator for row operator. More...
auto &	getElementPolynomialBase ()
	Get the Entity Polynomial Base object. More...
auto &	getUserPolynomialBase ()
	Get the User Polynomial Base object. More...
virtual MoFEMErrorCode	preProcess ()
	function is run at the beginning of loop More...
virtual MoFEMErrorCode	operator() ()
	function is run for every finite element More...
virtual MoFEMErrorCode	postProcess ()
	function is run at the end of loop More...
int	getMaxDataOrder () const
	Get max order of approximation for data fields. More...
int	getMaxRowOrder () const
	Get max order of approximation for field in rows. More...
int	getMaxColOrder () const
	Get max order of approximation for field in columns. More...
const DataForcesAndSourcesCore::EntData &	getEntData (const FieldSpace space, const EntityType type, const int side) const
	Get the entity data. More...
DataForcesAndSourcesCore::EntData &	getEntData (const FieldSpace space, const EntityType type, const int side)
	Get the entity data. More...
Public Member Functions inherited from MoFEM::FEMethod
MoFEMErrorCode	query_interface (const MOFEMuuid &uuid, UnknownInterface **iface) const
	FEMethod ()
auto	getDataDofsPtr () const
auto	getDataVectorDofsPtr () const
const FieldEntity_vector_view &	getDataFieldEnts () const
boost::shared_ptr< FieldEntity_vector_view > &	getDataFieldEntsPtr () const
auto &	getRowFieldEnts () const
auto &	getRowFieldEntsPtr () const
auto &	getColFieldEnts () const
auto &	getColFieldEntsPtr () const
auto	getRowDofsPtr () const
auto	getColDofsPtr () const
MoFEMErrorCode	getNumberOfNodes (int &num_nodes) const
	Get number of DOFs on element. More...
EntityHandle	getFEEntityHandle () const
MoFEMErrorCode	getNodeData (const std::string field_name, VectorDouble &data, const bool reset_dofs=true)
template<class MULTIINDEX >
MULTIINDEX::iterator	get_begin (const MULTIINDEX &index, const std::string &field_name, const EntityType type) const
template<class MULTIINDEX >
MULTIINDEX::iterator	get_end (const MULTIINDEX &index, const std::string &field_name, const EntityType type) const
template<class MULTIINDEX >
MULTIINDEX::iterator	get_begin (const MULTIINDEX &index, const std::string &field_name) const
template<class MULTIINDEX >
MULTIINDEX::iterator	get_end (const MULTIINDEX &index, const std::string &field_name) const
Public Member Functions inherited from MoFEM::BasicMethod
	BasicMethod ()
virtual	~BasicMethod ()=default
int	getNinTheLoop () const
	get number of evaluated element in the loop More...
int	getLoopSize () const
	get loop size More...
unsigned int	getFieldBitNumber (std::string field_name) const
MoFEMErrorCode	copyBasicMethod (const BasicMethod &basic)
	Copy data from other base method to this base method. More...
Public Member Functions inherited from MoFEM::KspMethod
	KspMethod ()
virtual	~KspMethod ()=default
MoFEMErrorCode	copyKsp (const KspMethod &ksp)
	copy data form another method More...
Public Member Functions inherited from MoFEM::PetscData
	PetscData ()
virtual	~PetscData ()=default
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 ()=default
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 Member Functions inherited from MoFEM::SnesMethod
	SnesMethod ()
virtual	~SnesMethod ()=default
MoFEMErrorCode	copySnes (const SnesMethod &snes)
	Copy snes data. More...
DEPRECATED MoFEMErrorCode	setSnesCtx (SNESContext ctx)
Public Member Functions inherited from MoFEM::TSMethod
	TSMethod ()
virtual	~TSMethod ()=default
MoFEMErrorCode	copyTs (const TSMethod &ts)
	Copy TS solver data. More...
DEPRECATED MoFEMErrorCode	setTsCtx (TSContext ctx)

Public Attributes
Interface &	mField
RuleHookFun	getRuleHook
	Hook to get rule. More...
RuleHookFun	setRuleHook
	Set function to calculate integration rule. More...
MatrixDouble	gaussPts
	Matrix of integration points. More...
Public Attributes inherited from MoFEM::FEMethod
std::string	feName
	Name of finite element. More...
boost::shared_ptr< const NumeredEntFiniteElement >	numeredEntFiniteElementPtr
Public Attributes inherited from MoFEM::BasicMethod
int	nInTheLoop
	number currently of processed method More...
int	loopSize
	local number oe methods to process More...
int	rAnk
	processor rank More...
int	sIze
	number of processors in communicator More...
const RefEntity_multiIndex *	refinedEntitiesPtr
	container of mofem dof entities More...
const RefElement_multiIndex *	refinedFiniteElementsPtr
	container of mofem finite element entities More...
const Problem *	problemPtr
	raw pointer to problem More...
const Field_multiIndex *	fieldsPtr
	raw pointer to fields container More...
const FieldEntity_multiIndex *	entitiesPtr
	raw pointer to container of field entities More...
const DofEntity_multiIndex *	dofsPtr
	raw pointer container of dofs More...
const FiniteElement_multiIndex *	finiteElementsPtr
	raw pointer to container finite elements More...
const EntFiniteElement_multiIndex *	finiteElementsEntitiesPtr
const FieldEntityEntFiniteElementAdjacencyMap_multiIndex *	adjacenciesPtr
boost::function< MoFEMErrorCode()>	preProcessHook
	Hook function for pre-processing. More...
boost::function< MoFEMErrorCode()>	postProcessHook
	Hook function for post-processing. More...
boost::function< MoFEMErrorCode()>	operatorHook
	Hook function for operator. More...
boost::movelib::unique_ptr< bool >	vecAssembleSwitch
boost::movelib::unique_ptr< bool >	matAssembleSwitch
Public Attributes inherited from MoFEM::KspMethod
KSPContext	ksp_ctx
	Context. More...
KSP	ksp
	KSP solver. More...
Vec &	ksp_f
Mat &	ksp_A
Mat &	ksp_B
Public Attributes inherited from MoFEM::PetscData
Switches	data_ctx
Vec	f
Mat	A
Mat	B
Vec	x
Vec	x_t
Vec	x_tt
Public Attributes inherited from MoFEM::SnesMethod
SNESContext	snes_ctx
SNES	snes
	snes solver More...
Vec &	snes_x
	state vector More...
Vec &	snes_f
	residual More...
Mat &	snes_A
	jacobian matrix More...
Mat &	snes_B
	preconditioner of jacobian matrix More...
Public Attributes inherited from MoFEM::TSMethod
TS	ts
	time solver More...
TSContext	ts_ctx
PetscInt	ts_step
	time step More...
PetscReal	ts_a
	shift for U_tt (see PETSc Time Solver) More...
PetscReal	ts_v
	shift for U_t shift for U_t More...
PetscReal	ts_t
	time More...
Vec &	ts_u
	state vector More...
Vec &	ts_u_t
	time derivative of state vector More...
Vec &	ts_u_tt
	second time derivative of state vector More...
Vec &	ts_F
	residual vector More...
Mat &	ts_A
Mat &	ts_B
	Preconditioner for ts_A. More...

Protected Member Functions
MoFEMErrorCode	getEntitySense (const EntityType type, boost::ptr_vector< DataForcesAndSourcesCore::EntData > &data) const
	get sense (orientation) of entity More...
MoFEMErrorCode	getEntityDataOrder (const EntityType type, const FieldSpace space, boost::ptr_vector< DataForcesAndSourcesCore::EntData > &data) const
	Get the entity data order. More...
template<EntityType type>
MoFEMErrorCode	getEntitySense (DataForcesAndSourcesCore &data) const
	Get the entity sense (orientation) More...
template<EntityType type>
MoFEMErrorCode	getEntityDataOrder (DataForcesAndSourcesCore &data, const FieldSpace space) const
	Get the entity data order for given space. More...
MoFEMErrorCode	getFaceTriNodes (DataForcesAndSourcesCore &data) const
	Get nodes on triangles. More...
MoFEMErrorCode	getSpacesAndBaseOnEntities (DataForcesAndSourcesCore &data) const
	Get field approximation space and base on entities. More...
virtual int	getRule (int order_row, int order_col, int order_data)
	another variant of getRule More...
virtual MoFEMErrorCode	setGaussPts (int order_row, int order_col, int order_data)
	set user specific integration rule More...
MoFEMErrorCode	calHierarchicalBaseFunctionsOnElement (const FieldApproximationBase b)
	Calculate base functions. More...
MoFEMErrorCode	calHierarchicalBaseFunctionsOnElement ()
	Calculate base functions. More...
MoFEMErrorCode	calBernsteinBezierBaseFunctionsOnElement ()
	Calculate Bernstein-Bezier base. More...
MoFEMErrorCode	createDataOnElement ()
	Create a entity data on element object. More...
MoFEMErrorCode	loopOverOperators ()
	Iterate user data operators. More...
Indices
template<typename EXTRACTOR >
MoFEMErrorCode	getNodesIndices (const std::string &field_name, FieldEntity_vector_view &ents_field, VectorInt &nodes_indices, VectorInt &local_nodes_indices, EXTRACTOR &&extractor) const
	get node indices More...
MoFEMErrorCode	getRowNodesIndices (DataForcesAndSourcesCore &data, const std::string &field_name) const
	get row node indices from FENumeredDofEntity_multiIndex More...
MoFEMErrorCode	getColNodesIndices (DataForcesAndSourcesCore &data, const std::string &field_name) const
	get col node indices from FENumeredDofEntity_multiIndex More...
template<typename EXTRACTOR >
MoFEMErrorCode	getEntityIndices (DataForcesAndSourcesCore &data, const std::string &field_name, FieldEntity_vector_view &ents_field, const EntityType type_lo, const EntityType type_hi, EXTRACTOR &&extractor) const
MoFEMErrorCode	getEntityRowIndices (DataForcesAndSourcesCore &data, const std::string &field_name, const EntityType type_lo=MBVERTEX, const EntityType type_hi=MBPOLYHEDRON) const
MoFEMErrorCode	getEntityColIndices (DataForcesAndSourcesCore &data, const std::string &field_name, const EntityType type_lo=MBVERTEX, const EntityType type_hi=MBPOLYHEDRON) const
MoFEMErrorCode	getNoFieldIndices (const std::string &field_name, boost::shared_ptr< FENumeredDofEntity_multiIndex > dofs, VectorInt &nodes_indices) const
	get NoField indices More...
MoFEMErrorCode	getNoFieldRowIndices (DataForcesAndSourcesCore &data, const std::string &field_name) const
	get col NoField indices More...
MoFEMErrorCode	getNoFieldColIndices (DataForcesAndSourcesCore &data, const std::string &field_name) const
	get col NoField indices More...
Data
MoFEMErrorCode	getNoFieldFieldData (const std::string field_name, VectorDouble &ent_field_data, VectorDofs &ent_field_dofs, VectorFieldEntities &ent_field) const
	Get field data on nodes. More...
MoFEMErrorCode	getNoFieldFieldData (DataForcesAndSourcesCore &data, const std::string field_name) const
MoFEMErrorCode	getNodesFieldData (DataForcesAndSourcesCore &data, const std::string &field_name) const
	Get data on nodes. More...
MoFEMErrorCode	getEntityFieldData (DataForcesAndSourcesCore &data, const std::string &field_name, const EntityType type_lo=MBVERTEX, const EntityType type_hi=MBPOLYHEDRON) const
Data form NumeredDofEntity_multiIndex
MoFEMErrorCode	getProblemNodesIndices (const std::string &field_name, const NumeredDofEntity_multiIndex &dofs, VectorInt &nodes_indices) const
	get indices of nodal indices which are declared for problem but not this particular element More...
MoFEMErrorCode	getProblemTypeIndices (const std::string &field_name, const NumeredDofEntity_multiIndex &dofs, EntityType type, int side_number, VectorInt &indices) const
	get indices by type (generic function) which are declared for problem but not this particular element More...
MoFEMErrorCode	getProblemNodesRowIndices (const std::string &field_name, VectorInt &nodes_indices) const
MoFEMErrorCode	getProblemTypeRowIndices (const std::string &field_name, EntityType type, int side_number, VectorInt &indices) const
MoFEMErrorCode	getProblemNodesColIndices (const std::string &field_name, VectorInt &nodes_indices) const
MoFEMErrorCode	getProblemTypeColIndices (const std::string &field_name, EntityType type, int side_number, VectorInt &indices) const
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...

Deprecated (do not use)
const std::array< boost::shared_ptr< DataForcesAndSourcesCore >, LASTSPACE >	dataOnElement
	Entity data on element entity rows fields. More...
const std::array< boost::shared_ptr< DataForcesAndSourcesCore >, LASTSPACE >	derivedDataOnElement
	Entity data on element entity columns fields. More...
DataForcesAndSourcesCore &	dataNoField
DataForcesAndSourcesCore &	dataH1
DataForcesAndSourcesCore &	dataHcurl
DataForcesAndSourcesCore &	dataHdiv
DataForcesAndSourcesCore &	dataL2
boost::ptr_vector< UserDataOperator >	opPtrVector
	Vector of finite element users data operators. More...
EntityType	lastEvaluatedElementEntityType
	Last evaluated type of element entity. More...
class	UserDataOperator
class	VolumeElementForcesAndSourcesCoreOnSideBase
class	FaceElementForcesAndSourcesCoreOnSideBase
class	VolumeElementForcesAndSourcesCoreOnContactPrismSideBase
boost::shared_ptr< BaseFunction >	elementPolynomialBasePtr
	Pointer to entity polynomial base. More...
boost::shared_ptr< BaseFunction >	userPolynomialBasePtr
	Pointer to user polynomail base. More...
ForcesAndSourcesCore *	sidePtrFE
	Element to integrate on the sides. More...
virtual int	getRule (int order)
virtual MoFEMErrorCode	setGaussPts (int order)
MoFEMErrorCode	setSideFEPtr (const ForcesAndSourcesCore *side_fe_ptr)
	Set the pointer to face element on the side. More...

Additional Inherited Members
Static Public Attributes inherited from MoFEM::PetscData
static constexpr Switches	CtxSetNone = PetscData::Switches(CTX_SET_NONE)
static constexpr Switches	CtxSetF = PetscData::Switches(CTX_SET_F)
static constexpr Switches	CtxSetA = PetscData::Switches(CTX_SET_A)
static constexpr Switches	CtxSetB = PetscData::Switches(CTX_SET_B)
static constexpr Switches	CtxSetX = PetscData::Switches(CTX_SET_X)
static constexpr Switches	CtxSetX_T = PetscData::Switches(CTX_SET_X_T)
static constexpr Switches	CtxSetX_TT = PetscData::Switches(CTX_SET_X_TT)
static constexpr Switches	CtxSetTime = PetscData::Switches(CTX_SET_TIME)

Detailed Description

structure to get information form mofem into DataForcesAndSourcesCore

Examples

EshelbianPlasticity.cpp, hello_world.cpp, prism_elements_from_surface.cpp, prism_polynomial_approximation.cpp, and quad_polynomial_approximation.cpp.

Definition at line 34 of file ForcesAndSourcesCore.hpp.

Member Typedef Documentation

RuleHookFun

typedef boost::function<int(int order_row, int order_col, int order_data)> MoFEM::ForcesAndSourcesCore::RuleHookFun

Definition at line 41 of file ForcesAndSourcesCore.hpp.

Constructor & Destructor Documentation

ForcesAndSourcesCore()

MoFEM::ForcesAndSourcesCore::ForcesAndSourcesCore

(

Interface &

m_field

)

Definition at line 54 of file ForcesAndSourcesCore.cpp.

    :

      mField(m_field), getRuleHook(0), setRuleHook(0),
      dataOnElement{

          nullptr,
          boost::make_shared<DataForcesAndSourcesCore>(MBENTITYSET), // NOFIELD
          boost::make_shared<DataForcesAndSourcesCore>(MBENTITYSET), // H1
          boost::make_shared<DataForcesAndSourcesCore>(MBENTITYSET), // HCURL
          boost::make_shared<DataForcesAndSourcesCore>(MBENTITYSET), // HDIV
          boost::make_shared<DataForcesAndSourcesCore>(MBENTITYSET)  // L2

      },
      derivedDataOnElement{

          nullptr,
          boost::make_shared<DerivedDataForcesAndSourcesCore>(
              dataOnElement[NOFIELD]), // NOFIELD
          boost::make_shared<DerivedDataForcesAndSourcesCore>(
              dataOnElement[H1]), // H1
          boost::make_shared<DerivedDataForcesAndSourcesCore>(
              dataOnElement[HCURL]), // HCURL
          boost::make_shared<DerivedDataForcesAndSourcesCore>(
              dataOnElement[HDIV]), // HDIV
          boost::make_shared<DerivedDataForcesAndSourcesCore>(
              dataOnElement[L2]) // L2

      },
      dataNoField(*dataOnElement[NOFIELD].get()),
      dataH1(*dataOnElement[H1].get()), dataHcurl(*dataOnElement[HCURL].get()),
      dataHdiv(*dataOnElement[HDIV].get()), dataL2(*dataOnElement[L2].get()),
      lastEvaluatedElementEntityType(MBMAXTYPE), sidePtrFE(nullptr) {}

Member Function Documentation

calBernsteinBezierBaseFunctionsOnElement()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::calBernsteinBezierBaseFunctionsOnElement ( )

protected

Calculate Bernstein-Bezier base.

Returns

MoFEMErrorCode

Definition at line 1079 of file ForcesAndSourcesCore.cpp.

                                                               {
  MoFEMFunctionBegin;

  auto get_nodal_base_data = [&](DataForcesAndSourcesCore &data,
                                 auto field_ptr) {
    MoFEMFunctionBegin;
    auto &space = data.dataOnEntities[MBVERTEX][0].getSpace();
    auto &base = data.dataOnEntities[MBVERTEX][0].getBase();
    auto &bb_node_order = data.dataOnEntities[MBVERTEX][0].getBBNodeOrder();

    auto &field_ents = getDataFieldEnts();
    auto bit_number = field_ptr->getBitNumber();
    const auto lo_uid = FieldEntity::getLocalUniqueIdCalculate(
        bit_number, get_id_for_min_type<MBVERTEX>());
    auto lo = std::lower_bound(field_ents.begin(), field_ents.end(), lo_uid,
                               cmp_uid_lo);
    if (lo != field_ents.end()) {
      const auto hi_uid = FieldEntity::getLocalUniqueIdCalculate(
          bit_number, get_id_for_max_type<MBVERTEX>());
      auto hi = std::upper_bound(lo, field_ents.end(), hi_uid, cmp_uid_hi);
      if (lo != hi) {

        for (auto it = lo; it != hi; ++it)
          if (auto first_e = it->lock()) {
            space = first_e->getSpace();
            base = first_e->getApproxBase();
            int num_nodes;
            CHKERR getNumberOfNodes(num_nodes);
            bb_node_order.resize(num_nodes, false);
            bb_node_order.clear();
            const int nb_dof_idx = first_e->getNbOfCoeffs();

            std::vector<boost::weak_ptr<FieldEntity>> brother_ents_vec;

            for (; it != hi; ++it) {
              if (auto e = it->lock()) {
                const auto &sn = e->getSideNumberPtr();
                const int side_number = sn->side_number;
                const int brother_side_number = sn->brother_side_number;
                if (brother_side_number != -1)
                  brother_ents_vec.emplace_back(e);
                bb_node_order[side_number] = e->getMaxOrder();
              }
            }

            for (auto &it : brother_ents_vec) {
              if (const auto e = it.lock()) {
                const auto &sn = e->getSideNumberPtr();
                const int side_number = sn->side_number;
                const int brother_side_number = sn->brother_side_number;
                bb_node_order[brother_side_number] = bb_node_order[side_number];
              }
            }

            break;
          }
      }
    }

    MoFEMFunctionReturn(0);
  };

  auto get_entity_base_data = [&](DataForcesAndSourcesCore &data,
                                  auto field_ptr, const EntityType type_lo,
                                  const EntityType type_hi) {
    MoFEMFunctionBegin;
    for (EntityType t = type_lo; t != type_hi; ++t) {
      for (auto &dat : data.dataOnEntities[t]) {
        dat.getDataOrder() = 0;
        dat.getBase() = NOBASE;
        dat.getSpace() = NOSPACE;
        dat.getFieldData().resize(0, false);
        dat.getFieldDofs().resize(0, false);
      }
    }

    auto &field_ents = getDataFieldEnts();
    auto bit_number = field_ptr->getBitNumber();
    const auto lo_uid = FieldEntity::getLocalUniqueIdCalculate(
        bit_number, get_id_for_min_type(type_lo));
    auto lo = std::lower_bound(field_ents.begin(), field_ents.end(), lo_uid,
                               cmp_uid_lo);
    if (lo != field_ents.end()) {
      const auto hi_uid = FieldEntity::getLocalUniqueIdCalculate(
          bit_number, get_id_for_max_type(type_hi));
      auto hi = std::upper_bound(lo, field_ents.end(), hi_uid, cmp_uid_hi);

      std::vector<boost::weak_ptr<FieldEntity>> brother_ents_vec;
      for (; lo != hi; ++lo) {
        if (auto e = lo->lock()) {
          if (auto cache = e->entityCacheDataDofs.lock()) {
            if (cache->loHi[0] != cache->loHi[1]) {
              const EntityType type = e->getEntType();
              const int side = e->getSideNumberPtr()->side_number;
              auto &dat = data.dataOnEntities[type][side];
              const int brother_side =
                  e->getSideNumberPtr()->brother_side_number;
              if (brother_side != -1)
                brother_ents_vec.emplace_back(e);
              dat.getBase() = e->getApproxBase();
              dat.getSpace() = e->getSpace();
              const auto ent_order = e->getMaxOrder();
              dat.getDataOrder() = dat.getDataOrder() > ent_order
                                       ? dat.getDataOrder()
                                       : ent_order;
            }
          }
        }
      }

      for (auto &ent_ptr : brother_ents_vec) {
        if (auto e = ent_ptr.lock()) {
          const EntityType type = e->getEntType();
          const int side = e->getSideNumberPtr()->side_number;
          const int brother_side = e->getSideNumberPtr()->brother_side_number;
          auto &dat = data.dataOnEntities[type][side];
          auto &dat_brother = data.dataOnEntities[type][brother_side];
          dat_brother.getBase() = dat.getBase();
          dat_brother.getSpace() = dat.getSpace();
          dat_brother.getDataOrder() = dat.getDataOrder();
        }
      }
    }
    MoFEMFunctionReturn(0);
  };

  for (auto &e : getDataFieldEnts()) {
    if (auto ent_data_ptr = e.lock()) {
      if (ent_data_ptr->getApproxBase() == AINSWORTH_BERNSTEIN_BEZIER_BASE) {
        auto space = ent_data_ptr->getSpace();
        for (EntityType t = MBVERTEX; t != MBPOLYHEDRON; ++t) {
          for (auto &dat : (*dataOnElement[space]).dataOnEntities[t]) {
            for (auto &ptr : dat.getBBAlphaIndicesByOrderArray())
              ptr.reset();
            for (auto &ptr : dat.getBBNByOrderArray())
              ptr.reset();
            for (auto &ptr : dat.getBBDiffNByOrderArray())
              ptr.reset();
          }
        }
      }
    }
  }

  std::set<string> fields_list;
  for (auto &e : getDataFieldEnts()) {
    if (auto ent_data_ptr = e.lock()) {
      if (ent_data_ptr->getApproxBase() == AINSWORTH_BERNSTEIN_BEZIER_BASE) {
        auto field_name = ent_data_ptr->getName();
        if (fields_list.find(field_name) == fields_list.end()) {
          auto field_ptr = ent_data_ptr->getFieldRawPtr();
          auto space = ent_data_ptr->getSpace();
          CHKERR get_nodal_base_data(*dataOnElement[space], field_ptr);
          CHKERR get_entity_base_data(*dataOnElement[space], field_ptr, MBEDGE,
                                      MBPOLYHEDRON);
          CHKERR getElementPolynomialBase()->getValue(
              gaussPts, boost::make_shared<EntPolynomialBaseCtx>(
                            *dataOnElement[space], field_name,
                            static_cast<FieldSpace>(space),
                            AINSWORTH_BERNSTEIN_BEZIER_BASE, NOBASE));
          fields_list.insert(field_name);
        }
      }
    }
  }

  MoFEMFunctionReturn(0);
};

calHierarchicalBaseFunctionsOnElement() [1/2]

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::calHierarchicalBaseFunctionsOnElement ( const FieldApproximationBase  b )

protected

Calculate base functions.

Returns

Error code

Definition at line 1009 of file ForcesAndSourcesCore.cpp.

                                    {
  MoFEMFunctionBegin;
  if (dataOnElement[H1]->bAse.test(b)) {
    switch (static_cast<FieldApproximationBase>(b)) {
    case NOBASE:
      break;
    case AINSWORTH_BERNSTEIN_BEZIER_BASE:
      // BERNSTEIN_BEZIER_BASE is not hierarchical base
      break;
    case AINSWORTH_LEGENDRE_BASE:
    case AINSWORTH_LOBATTO_BASE:
    case DEMKOWICZ_JACOBI_BASE:
      if (!getElementPolynomialBase())
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Functions genrating approximation base not defined");

      for (int space = H1; space != LASTSPACE; ++space) {
        if (dataOnElement[H1]->sPace.test(space) &&
            dataOnElement[H1]->bAse.test(b) &&
            dataOnElement[H1]->basesOnSpaces[space].test(b)) {
          CHKERR getElementPolynomialBase()->getValue(
              gaussPts,
              boost::make_shared<EntPolynomialBaseCtx>(
                  *dataOnElement[space], static_cast<FieldSpace>(space),
                  static_cast<FieldApproximationBase>(b), NOBASE));
        }
      }
      break;
    case USER_BASE:
      if (!getUserPolynomialBase())
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Functions genrating user approximation base not defined");

      for (int space = H1; space != LASTSPACE; ++space)
        if (dataOnElement[H1]->sPace.test(space) &&
            dataOnElement[H1]->bAse.test(b) &&
            dataOnElement[H1]->basesOnSpaces[space].test(b)) {
          CHKERR getUserPolynomialBase()->getValue(
              gaussPts,
              boost::make_shared<EntPolynomialBaseCtx>(
                  *dataOnElement[space], static_cast<FieldSpace>(space),
                  static_cast<FieldApproximationBase>(b), NOBASE));
        }
      break;
    default:
      SETERRQ1(mField.get_comm(), MOFEM_DATA_INCONSISTENCY,
               "Base <%s> not yet implemented",
               ApproximationBaseNames[static_cast<FieldApproximationBase>(b)]);
    }
  }
  MoFEMFunctionReturn(0);
}

calHierarchicalBaseFunctionsOnElement() [2/2]

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::calHierarchicalBaseFunctionsOnElement ( )

protected

Calculate base functions.

Returns

Error code

Definition at line 1063 of file ForcesAndSourcesCore.cpp.

                                                                           {
  MoFEMFunctionBegin;
  /// Use the some node base. Node base is usually used for construction other
  /// bases.
  for (int space = HCURL; space != LASTSPACE; ++space) {
    dataOnElement[space]->dataOnEntities[MBVERTEX][0].getNSharedPtr(NOBASE) =
        dataOnElement[H1]->dataOnEntities[MBVERTEX][0].getNSharedPtr(NOBASE);
  }
  for (int b = AINSWORTH_LEGENDRE_BASE; b != LASTBASE; b++) {
    CHKERR calHierarchicalBaseFunctionsOnElement(
        static_cast<FieldApproximationBase>(b));
  }
  MoFEMFunctionReturn(0);
}

createDataOnElement()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::createDataOnElement ( )

protected

Create a entity data on element object.

Returns

MoFEMErrorCode

Definition at line 1248 of file ForcesAndSourcesCore.cpp.

                                                         {
  MoFEMFunctionBegin;

  const EntityType type = numeredEntFiniteElementPtr->getEntType();
  if (type == lastEvaluatedElementEntityType)
    MoFEMFunctionReturnHot(0);

  // Data on elements for proper spaces
  for (int space = H1; space != LASTSPACE; ++space) {
    dataOnElement[space]->setElementType(type);
    derivedDataOnElement[space]->setElementType(type);
  }

  lastEvaluatedElementEntityType = type;

  MoFEMFunctionReturn(0);
}

getColNodesIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getColNodesIndices ( DataForcesAndSourcesCore &  data, const std::string &  field_name  ) const

protected

get col node indices from FENumeredDofEntity_multiIndex

Definition at line 332 of file ForcesAndSourcesCore.cpp.

                                                                            {

  struct Extractor {
    boost::weak_ptr<EntityCacheNumeredDofs>
    operator()(boost::shared_ptr<FieldEntity> &e) {
      return e->entityCacheColDofs;
    }
  };

  return getNodesIndices(field_name, getColFieldEnts(),
                         data.dataOnEntities[MBVERTEX][0].getIndices(),
                         data.dataOnEntities[MBVERTEX][0].getLocalIndices(),
                         Extractor());
}

getElementPolynomialBase()

auto& MoFEM::ForcesAndSourcesCore::getElementPolynomialBase

(

)

Get the Entity Polynomial Base object.

Returns

boost::shared_ptr<BaseFunction>&&

Definition at line 430 of file ForcesAndSourcesCore.hpp.

{ return elementPolynomialBasePtr; }

getEntData() [1/2]

const DataForcesAndSourcesCore::EntData& MoFEM::ForcesAndSourcesCore::getEntData	(	const FieldSpace	space,
		const EntityType	type,
		const int	side
	)		const

Get the entity data.

Parameters

space
type
side

Returns

const DataForcesAndSourcesCore::EntData&

Definition at line 484 of file ForcesAndSourcesCore.hpp.

                                                                            {
    return dataOnElement[space]->dataOnEntities[type][side];
  }

getEntData() [2/2]

DataForcesAndSourcesCore::EntData& MoFEM::ForcesAndSourcesCore::getEntData	(	const FieldSpace	space,
		const EntityType	type,
		const int	side
	)

Get the entity data.

Parameters

space
type
side

Returns

DataForcesAndSourcesCore::EntData&

Definition at line 499 of file ForcesAndSourcesCore.hpp.

                                                                            {
    return dataOnElement[space]->dataOnEntities[type][side];
  }

getEntityColIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getEntityColIndices ( DataForcesAndSourcesCore &  data, const std::string &  field_name, const EntityType  type_lo = MBVERTEX, const EntityType  type_hi = MBPOLYHEDRON  ) const

protected

Definition at line 433 of file ForcesAndSourcesCore.cpp.

                                                              {

  struct Extractor {
    boost::weak_ptr<EntityCacheNumeredDofs>
    operator()(boost::shared_ptr<FieldEntity> &e) {
      return e->entityCacheColDofs;
    }
  };

  return getEntityIndices(data, field_name, getColFieldEnts(), type_lo, type_hi,
                          Extractor());
}

getEntityDataOrder() [1/2]

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getEntityDataOrder ( const EntityType  type, const FieldSpace  space, boost::ptr_vector< DataForcesAndSourcesCore::EntData > &  data  ) const

protected

Get the entity data order.

Parameters

type
space
data

Returns

MoFEMErrorCode

Definition at line 146 of file ForcesAndSourcesCore.cpp.

                                                                  {
  MoFEMFunctionBegin;

  auto set_order = [&]() {
    MoFEMFunctionBeginHot;
    auto &side_table = numeredEntFiniteElementPtr->getSideNumberTable();

    for (unsigned int s = 0; s != data.size(); ++s)
      data[s].getDataOrder() = 0;

    const FieldEntity_vector_view &data_field_ent = getDataFieldEnts();

    for (auto r = fieldsPtr->get<BitFieldId_space_mi_tag>().equal_range(space);
         r.first != r.second; ++r.first) {

      const auto field_bit_number = (*r.first)->getBitNumber();
      const auto lo_uid = FieldEntity::getLocalUniqueIdCalculate(
          field_bit_number, get_id_for_min_type(type));
      auto lo = std::lower_bound(data_field_ent.begin(), data_field_ent.end(),
                                 lo_uid, cmp_uid_lo);
      if (lo != data_field_ent.end()) {
        const auto hi_uid = FieldEntity::getLocalUniqueIdCalculate(
            field_bit_number, get_id_for_max_type(type));
        auto hi =
            std::upper_bound(lo, data_field_ent.end(), hi_uid, cmp_uid_hi);
        for (; lo != hi; ++lo) {

          if (auto ptr = lo->lock()) {

            auto &e = *ptr;
            auto sit = side_table.find(e.getEnt());
            if (sit != side_table.end()) {
              auto &side = *sit;
              const int side_number = side->side_number;
              if (side_number >= 0) {
                ApproximationOrder ent_order = e.getMaxOrder();
                auto &dat = data[side_number];
                dat.getDataOrder() = dat.getDataOrder() > ent_order
                                         ? dat.getDataOrder()
                                         : ent_order;
              }
            } else
              SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                      "Entity on side of the element not found");
          }
        }
      }
    }

    MoFEMFunctionReturnHot(0);
  };

  auto set_order_on_brother = [&]() {
    MoFEMFunctionBeginHot;
    auto &side_table =
        numeredEntFiniteElementPtr->getSideNumberTable().get<0>();
    auto sit = side_table.lower_bound(get_id_for_min_type(type));
    if (sit != side_table.end()) {
      auto hi_sit = side_table.upper_bound(get_id_for_max_type(type));
      for (; sit != hi_sit; ++sit) {
        const int brother_side_number = (*sit)->brother_side_number;
        if (brother_side_number != -1) {
          const int side_number = (*sit)->side_number;
          data[brother_side_number].getDataOrder() =
              data[side_number].getDataOrder();
        }
      }
    }
    MoFEMFunctionReturnHot(0);
  };

  CHKERR set_order();
  CHKERR set_order_on_brother();

  MoFEMFunctionReturn(0);
}

getEntityDataOrder() [2/2]

template<EntityType type>

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getEntityDataOrder ( DataForcesAndSourcesCore &  data, const FieldSpace  space  ) const

protected

Get the entity data order for given space.

Template Parameters

type

Parameters

data
space

Returns

MoFEMErrorCode

Definition at line 547 of file ForcesAndSourcesCore.hpp.

                                                                         {
    return getEntityDataOrder(type, space, data.dataOnEntities[type]);
  }

getEntityFieldData()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getEntityFieldData ( DataForcesAndSourcesCore &  data, const std::string &  field_name, const EntityType  type_lo = MBVERTEX, const EntityType  type_hi = MBPOLYHEDRON  ) const

protected

Definition at line 716 of file ForcesAndSourcesCore.cpp.

                                                              {
  MoFEMFunctionBegin;
  for (EntityType t = type_lo; t != type_hi; ++t) {
    for (auto &dat : data.dataOnEntities[t]) {
      dat.getDataOrder() = 0;
      dat.getBase() = NOBASE;
      dat.getSpace() = NOSPACE;
      dat.getFieldData().resize(0, false);
      dat.getFieldDofs().resize(0, false);
      dat.getFieldEntities().resize(0, false);
    }
  }

  auto &field_ents = getDataFieldEnts();
  auto bit_number = mField.get_field_bit_number(field_name);
  const auto lo_uid = FieldEntity::getLocalUniqueIdCalculate(
      bit_number, get_id_for_min_type(type_lo));
  auto lo = std::lower_bound(field_ents.begin(), field_ents.end(), lo_uid,
                             cmp_uid_lo);
  if (lo != field_ents.end()) {
    const auto hi_uid = FieldEntity::getLocalUniqueIdCalculate(
        bit_number, get_id_for_max_type(type_hi));
    auto hi = std::upper_bound(lo, field_ents.end(), hi_uid, cmp_uid_hi);
    if (lo != hi) {

      std::vector<boost::weak_ptr<FieldEntity>> brother_ents_vec;

      for (auto it = lo; it != hi; ++it)
        if (auto e = it->lock()) {

          const EntityType type = e->getEntType();
          auto side_ptr = e->getSideNumberPtr();
          const int side = side_ptr->side_number;
          if (side >= 0) {

            auto &dat = data.dataOnEntities[type][side];
            auto &ent_field = dat.getFieldEntities();
            auto &ent_field_dofs = dat.getFieldDofs();
            auto &ent_field_data = dat.getFieldData();

            const int brother_side = side_ptr->brother_side_number;
            if (brother_side != -1)
              brother_ents_vec.emplace_back(e);

            dat.getBase() = e->getApproxBase();
            dat.getSpace() = e->getSpace();
            const int ent_order = e->getMaxOrder();
            dat.getDataOrder() =
                dat.getDataOrder() > ent_order ? dat.getDataOrder() : ent_order;

            auto ent_data = e->getEntFieldData();
            ent_field_data.resize(ent_data.size(), false);
            noalias(ent_field_data) = ent_data;
            ent_field_dofs.resize(ent_data.size(), false);
            std::fill(ent_field_dofs.begin(), ent_field_dofs.end(), nullptr);
            ent_field.resize(1, false);
            ent_field[0] = e.get();
            if (auto cache = e->entityCacheDataDofs.lock()) {
              for (auto dit = cache->loHi[0]; dit != cache->loHi[1]; ++dit) {
                ent_field_dofs[(*dit)->getEntDofIdx()] =
                    reinterpret_cast<FEDofEntity *>((*dit).get());
              }
            }
          }
        }

      for (auto &it : brother_ents_vec) {
        if (const auto e = it.lock()) {
          const EntityType type = e->getEntType();
          const int side = e->getSideNumberPtr()->side_number;
          const int brother_side = e->getSideNumberPtr()->brother_side_number;
          auto &dat = data.dataOnEntities[type][side];
          auto &dat_brother = data.dataOnEntities[type][brother_side];
          dat_brother.getBase() = dat.getBase();
          dat_brother.getSpace() = dat.getSpace();
          dat_brother.getDataOrder() = dat.getDataOrder();
          dat_brother.getFieldData() = dat.getFieldData();
          dat_brother.getFieldDofs() = dat.getFieldDofs();
          dat_brother.getFieldEntities() = dat.getFieldEntities();
        }
      }
    }
  }

  MoFEMFunctionReturn(0);
}

getEntityIndices()

template<typename EXTRACTOR >

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getEntityIndices ( DataForcesAndSourcesCore &  data, const std::string &  field_name, FieldEntity_vector_view &  ents_field, const EntityType  type_lo, const EntityType  type_hi, EXTRACTOR &&  extractor  ) const

protected

Definition at line 349 of file ForcesAndSourcesCore.cpp.

                                                           {
  MoFEMFunctionBegin;

  for (EntityType t = type_lo; t != type_hi; ++t) {
    for (auto &dat : data.dataOnEntities[t]) {
      dat.getIndices().resize(0, false);
      dat.getLocalIndices().resize(0, false);
    }
  }

  auto bit_number = mField.get_field_bit_number(field_name);
  const auto lo_uid = FieldEntity::getLocalUniqueIdCalculate(
      bit_number, get_id_for_min_type(type_lo));
  auto lo = std::lower_bound(ents_field.begin(), ents_field.end(), lo_uid,
                             cmp_uid_lo);
  if (lo != ents_field.end()) {
    const auto hi_uid = FieldEntity::getLocalUniqueIdCalculate(
        bit_number, get_id_for_max_type(type_hi));
    auto hi = std::upper_bound(lo, ents_field.end(), hi_uid, cmp_uid_hi);
    if (lo != hi) {

      std::vector<boost::weak_ptr<FieldEntity>> brother_ents_vec;

      for (auto it = lo; it != hi; ++it)
        if (auto e = it->lock()) {

          const EntityType type = e->getEntType();
          auto side_ptr = e->getSideNumberPtr();
          const int side = side_ptr->side_number;
          if (side >= 0) {
            const int nb_dofs_on_ent = e->getNbDofsOnEnt();
            const int brother_side = side_ptr->brother_side_number;
            auto &dat = data.dataOnEntities[type][side];
            auto &ent_field_indices = dat.getIndices();
            auto &ent_field_local_indices = dat.getLocalIndices();

            ent_field_indices.resize(nb_dofs_on_ent, false);
            ent_field_local_indices.resize(nb_dofs_on_ent, false);
            std::fill(ent_field_indices.data().begin(),
                      ent_field_indices.data().end(), -1);
            std::fill(ent_field_local_indices.data().begin(),
                      ent_field_local_indices.data().end(), -1);

            if (auto cache = extractor(e).lock()) {
              for (auto dit = cache->loHi[0]; dit != cache->loHi[1]; ++dit) {
                const int idx = (*dit)->getEntDofIdx();
                ent_field_indices[idx] = (*dit)->getPetscGlobalDofIdx();
                ent_field_local_indices[idx] = (*dit)->getPetscLocalDofIdx();
              }
            }

            if (brother_side != -1) {
              auto &dat_brother = data.dataOnEntities[type][brother_side];
              dat_brother.getIndices().resize(nb_dofs_on_ent, false);
              dat_brother.getLocalIndices().resize(nb_dofs_on_ent, false);
              noalias(dat_brother.getIndices()) = dat.getIndices();
              noalias(dat_brother.getLocalIndices()) = dat.getLocalIndices();
            }
          }
        }
    }
  }

  MoFEMFunctionReturn(0);
}

getEntityRowIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getEntityRowIndices ( DataForcesAndSourcesCore &  data, const std::string &  field_name, const EntityType  type_lo = MBVERTEX, const EntityType  type_hi = MBPOLYHEDRON  ) const

protected

Definition at line 418 of file ForcesAndSourcesCore.cpp.

                                                              {

  struct Extractor {
    boost::weak_ptr<EntityCacheNumeredDofs>
    operator()(boost::shared_ptr<FieldEntity> &e) {
      return e->entityCacheRowDofs;
    }
  };

  return getEntityIndices(data, field_name, getRowFieldEnts(), type_lo, type_hi,
                          Extractor());
}

getEntitySense() [1/2]

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getEntitySense ( const EntityType  type, boost::ptr_vector< DataForcesAndSourcesCore::EntData > &  data  ) const

protected

get sense (orientation) of entity

Parameters

type	type of entity
data	entity data

Returns

error code

Definition at line 90 of file ForcesAndSourcesCore.cpp.

                                                                  {
  MoFEMFunctionBegin;

  auto &side_table = numeredEntFiniteElementPtr->getSideNumberTable().get<0>();
  auto sit = side_table.lower_bound(get_id_for_min_type(type));
  if (sit != side_table.end()) {
    auto hi_sit = side_table.upper_bound(get_id_for_max_type(type));
    for (; sit != hi_sit; ++sit) {
      const int side_number = (*sit)->side_number;
      if (side_number >= 0) {
        const int brother_side_number = (*sit)->brother_side_number;
        const int sense = (*sit)->sense;

        data[side_number].getSense() = sense;
        if (brother_side_number != -1)
          data[brother_side_number].getSense() = sense;
      }
    }
  }
  MoFEMFunctionReturn(0);
}

getEntitySense() [2/2]

template<EntityType type>

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getEntitySense ( DataForcesAndSourcesCore &  data ) const

protected

Get the entity sense (orientation)

Template Parameters

type

Parameters

data

Returns

MoFEMErrorCode

Definition at line 534 of file ForcesAndSourcesCore.hpp.

                                                                             {
    return getEntitySense(type, data.dataOnEntities[type]);
  }

getFaceTriNodes()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getFaceTriNodes ( DataForcesAndSourcesCore &  data ) const

protected

Get nodes on triangles.

Definition at line 873 of file ForcesAndSourcesCore.cpp.

                                                                          {
  MoFEMFunctionBegin;
  // PetscAttachDebugger();
  data.facesNodes.resize(4, 3, false);
  auto &side_table = const_cast<SideNumber_multiIndex &>(
      numeredEntFiniteElementPtr->getSideNumberTable());
  auto siit = side_table.get<1>().lower_bound(boost::make_tuple(MBTRI, 0));
  auto hi_siit = side_table.get<1>().upper_bound(boost::make_tuple(MBTRI, 4));
  if (std::distance(siit, hi_siit) != 4) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Should be 4 triangles on tet, side_table not initialized");
  }
  const int canonical_face_sense_p1[4][3] = {
      {0, 1, 3},
      {1, 2, 3},
      {0, 3, 2} /**/,
      {0, 2, 1} /**/}; // second index is offset (positive sense)
  const int canonical_face_sense_m1[4][3] = {
      {0, 3, 1},
      {1, 3, 2},
      {0, 2, 3},
      {0, 1, 2}}; // second index is offset (negative sense
  for (; siit != hi_siit; siit++) {
    const boost::shared_ptr<SideNumber> side = *siit;
    int face_conn[3] = {-1, -1, -1};
    if (side->offset == 0) {
      face_conn[0] = side->sense == 1
                         ? canonical_face_sense_p1[(int)side->side_number][0]
                         : canonical_face_sense_m1[(int)side->side_number][0];
      face_conn[1] = side->sense == 1
                         ? canonical_face_sense_p1[(int)side->side_number][1]
                         : canonical_face_sense_m1[(int)side->side_number][1];
      face_conn[2] = side->sense == 1
                         ? canonical_face_sense_p1[(int)side->side_number][2]
                         : canonical_face_sense_m1[(int)side->side_number][2];
    }
    if (side->offset == 1) {
      face_conn[0] =
          side->sense == 1
              ? canonical_face_sense_p1[(int)side->side_number][1]
              : canonical_face_sense_m1[(int)side->side_number][2] /**/;
      face_conn[1] = side->sense == 1
                         ? canonical_face_sense_p1[(int)side->side_number][2]
                         : canonical_face_sense_m1[(int)side->side_number][0];
      face_conn[2] = side->sense == 1
                         ? canonical_face_sense_p1[(int)side->side_number][0]
                         : canonical_face_sense_m1[(int)side->side_number][1];
    }
    if (side->offset == 2) {
      face_conn[0] =
          side->sense == 1
              ? canonical_face_sense_p1[(int)side->side_number][2]
              : canonical_face_sense_m1[(int)side->side_number][1] /**/;
      face_conn[1] = side->sense == 1
                         ? canonical_face_sense_p1[(int)side->side_number][0]
                         : canonical_face_sense_m1[(int)side->side_number][2];
      face_conn[2] = side->sense == 1
                         ? canonical_face_sense_p1[(int)side->side_number][1]
                         : canonical_face_sense_m1[(int)side->side_number][0];
    }
    for (int nn = 0; nn < 3; nn++)
      data.facesNodes(side->side_number, nn) = face_conn[nn];
    {
      const EntityHandle *conn_tet;
      int num_nodes_tet;
      EntityHandle ent = numeredEntFiniteElementPtr->getEnt();
      CHKERR mField.get_moab().get_connectivity(ent, conn_tet, num_nodes_tet,
                                                true);
      if (num_nodes_tet != 4)
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "data inconsistency");
      int num_nodes_face;
      const EntityHandle *conn_face;
      CHKERR mField.get_moab().get_connectivity(side->ent, conn_face,
                                                num_nodes_face, true);
      if (num_nodes_face != 3)
        SETERRQ(PETSC_COMM_SELF, 1, "data inconsistency");
      if (conn_face[0] != conn_tet[data.facesNodes(side->side_number, 0)])
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "data inconsistency");
      if (conn_face[1] != conn_tet[data.facesNodes(side->side_number, 1)])
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "data inconsistency");
      if (conn_face[2] != conn_tet[data.facesNodes(side->side_number, 2)])
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "data inconsistency");
    }
  }
  MoFEMFunctionReturn(0);
}

getMaxColOrder()

int MoFEM::ForcesAndSourcesCore::getMaxColOrder

(

)

const

Get max order of approximation for field in columns.

Definition at line 142 of file ForcesAndSourcesCore.cpp.

                                               {
  return getMaxOrder(getColFieldEnts());
}

getMaxDataOrder()

int MoFEM::ForcesAndSourcesCore::getMaxDataOrder

(

)

const

Get max order of approximation for data fields.

Method getMaxDataOrder () return maximal order on entities, for all data on the element. So for example if finite element is triangle, and triangle base function have order 4 and on edges base function have order 2, this function return 4.

If finite element has for example 2 or more approximated fields, for example Pressure (order 3) and displacement field (order 5), this function returns 5.

Definition at line 127 of file ForcesAndSourcesCore.cpp.

                                                {
  int max_order = 0;
  for (auto e : getDataFieldEnts()) {
    if (auto ptr = e.lock()) {
      const int order = ptr->getMaxOrder();
      max_order = (max_order < order) ? order : max_order;
    }
  }
  return max_order;
}

getMaxRowOrder()

int MoFEM::ForcesAndSourcesCore::getMaxRowOrder

(

)

const

Get max order of approximation for field in rows.

Definition at line 138 of file ForcesAndSourcesCore.cpp.

                                               {
  return getMaxOrder(getRowFieldEnts());
}

getNodesFieldData()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getNodesFieldData ( DataForcesAndSourcesCore &  data, const std::string &  field_name  ) const

protected

Get data on nodes.

Parameters

data	Data structure
field_name	Field name

Returns

Error code

Definition at line 600 of file ForcesAndSourcesCore.cpp.

                                                                           {

  auto get_nodes_field_data = [&](VectorDouble &nodes_data,
                                  VectorFieldEntities &field_entities,
                                  VectorDofs &nodes_dofs, FieldSpace &space,
                                  FieldApproximationBase &base,
                                  VectorInt &bb_node_order) {
    MoFEMFunctionBegin;

    nodes_data.resize(0, false);
    nodes_dofs.resize(0, false);
    field_entities.resize(0, false);

    auto field_it = fieldsPtr->get<FieldName_mi_tag>().find(field_name);
    if (field_it != fieldsPtr->get<FieldName_mi_tag>().end()) {

      auto bit_number = (*field_it)->getBitNumber();
      const int nb_dofs_on_vert = (*field_it)->getNbOfCoeffs();
      space = (*field_it)->getSpace();
      base = (*field_it)->getApproxBase();

      auto &field_ents = getDataFieldEnts();
      const auto lo_uid = FieldEntity::getLocalUniqueIdCalculate(
          bit_number, get_id_for_min_type<MBVERTEX>());
      auto lo = std::lower_bound(field_ents.begin(), field_ents.end(), lo_uid,
                                 cmp_uid_lo);
      if (lo != field_ents.end()) {
        const auto hi_uid = FieldEntity::getLocalUniqueIdCalculate(
            bit_number, get_id_for_max_type<MBVERTEX>());
        auto hi = std::upper_bound(lo, field_ents.end(), hi_uid, cmp_uid_hi);
        if (lo != hi) {

          int nb_dofs = 0;
          for (auto it = lo; it != hi; ++it) {
            if (auto e = it->lock()) {
              nb_dofs += e->getNbDofsOnEnt();
            }
          }

          if (nb_dofs) {

            int num_nodes;
            CHKERR getNumberOfNodes(num_nodes);
            bb_node_order.resize(num_nodes, false);
            bb_node_order.clear();
            const int max_nb_dofs = nb_dofs_on_vert * num_nodes;
            nodes_data.resize(max_nb_dofs, false);
            nodes_dofs.resize(max_nb_dofs, false);
            field_entities.resize(num_nodes, false);
            std::fill(nodes_data.begin(), nodes_data.end(), 0);
            std::fill(nodes_dofs.begin(), nodes_dofs.end(), nullptr);
            std::fill(field_entities.begin(), field_entities.end(), nullptr);

            std::vector<boost::weak_ptr<FieldEntity>> brother_ents_vec;

            for (auto it = lo; it != hi; ++it) {
              if (auto e = it->lock()) {
                const auto &sn = e->getSideNumberPtr();
                const int side_number = sn->side_number;
                const int brother_side_number = sn->brother_side_number;

                field_entities[side_number] = e.get();
                if (brother_side_number != -1) {
                  brother_ents_vec.emplace_back(e);
                  field_entities[side_number] = field_entities[side_number];
                }

                bb_node_order[side_number] = e->getMaxOrder();
                int pos = side_number * nb_dofs_on_vert;
                auto ent_filed_data_vec = e->getEntFieldData();
                if (auto cache = e->entityCacheDataDofs.lock()) {
                  for (auto dit = cache->loHi[0]; dit != cache->loHi[1];
                       ++dit) {
                    const auto dof_idx = (*dit)->getEntDofIdx();
                    nodes_data[pos + dof_idx] = ent_filed_data_vec[dof_idx];
                    nodes_dofs[pos + dof_idx] =
                        reinterpret_cast<FEDofEntity *>((*dit).get());
                  }
                }
              }
            }

            for (auto &it : brother_ents_vec) {
              if (const auto e = it.lock()) {
                const auto &sn = e->getSideNumberPtr();
                const int side_number = sn->side_number;
                const int brother_side_number = sn->brother_side_number;
                bb_node_order[brother_side_number] = bb_node_order[side_number];
                int pos = side_number * nb_dofs_on_vert;
                int brother_pos = brother_side_number * nb_dofs_on_vert;
                for (int ii = 0; ii != nb_dofs_on_vert; ++ii) {
                  nodes_data[brother_pos] = nodes_data[pos];
                  nodes_dofs[brother_pos] = nodes_dofs[pos];
                  ++pos;
                  ++brother_pos;
                }
              }
            }
          }
        }
      }
    }

    MoFEMFunctionReturn(0);
  };

  return get_nodes_field_data(
      data.dataOnEntities[MBVERTEX][0].getFieldData(),
      data.dataOnEntities[MBVERTEX][0].getFieldEntities(),
      data.dataOnEntities[MBVERTEX][0].getFieldDofs(),
      data.dataOnEntities[MBVERTEX][0].getSpace(),
      data.dataOnEntities[MBVERTEX][0].getBase(),
      data.dataOnEntities[MBVERTEX][0].getBBNodeOrder());
}

getNodesIndices()

template<typename EXTRACTOR >

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getNodesIndices ( const std::string &  field_name, FieldEntity_vector_view &  ents_field, VectorInt &  nodes_indices, VectorInt &  local_nodes_indices, EXTRACTOR &&  extractor  ) const

protected

get node indices

Definition at line 228 of file ForcesAndSourcesCore.cpp.

                                 {
  MoFEMFunctionBegin;

  auto field_it = fieldsPtr->get<FieldName_mi_tag>().find(field_name);
  if (field_it != fieldsPtr->get<FieldName_mi_tag>().end()) {

    auto bit_number = (*field_it)->getBitNumber();
    const auto lo_uid = FieldEntity::getLocalUniqueIdCalculate(
        bit_number, get_id_for_min_type<MBVERTEX>());
    auto lo = std::lower_bound(ents_field.begin(), ents_field.end(), lo_uid,
                               cmp_uid_lo);
    if (lo != ents_field.end()) {
      const auto hi_uid = FieldEntity::getLocalUniqueIdCalculate(
          bit_number, get_id_for_max_type<MBVERTEX>());
      auto hi = std::upper_bound(lo, ents_field.end(), hi_uid, cmp_uid_hi);

      int num_nodes;
      CHKERR getNumberOfNodes(num_nodes);
      const int nb_dofs_on_vert = (*field_it)->getNbOfCoeffs();
      const int max_nb_dofs = nb_dofs_on_vert * num_nodes;

      int nb_dofs = 0;
      for (auto it = lo; it != hi; ++it) {
        if (auto e = it->lock()) {
          if (auto cache = extractor(e).lock()) {
            if (cache->loHi[0] != cache->loHi[1]) {
              nb_dofs += std::distance(cache->loHi[0], cache->loHi[1]);
              break;
            }
          }
        }
      }

      if (nb_dofs) {
        nodes_indices.resize(max_nb_dofs, false);
        local_nodes_indices.resize(max_nb_dofs, false);
      } else {
        nodes_indices.resize(0, false);
        local_nodes_indices.resize(0, false);
      }

      if (nb_dofs != max_nb_dofs) {
        std::fill(nodes_indices.begin(), nodes_indices.end(), -1);
        std::fill(local_nodes_indices.begin(), local_nodes_indices.end(), -1);
      }

      for (auto it = lo; it != hi; ++it) {
        if (auto e = it->lock()) {
          auto side_ptr = e->getSideNumberPtr();
          const auto side_number = side_ptr->side_number;
          const auto brother_side_number = side_ptr->brother_side_number;
          if (auto cache = extractor(e).lock()) {
            for (auto dit = cache->loHi[0]; dit != cache->loHi[1]; ++dit) {
              auto &dof = **dit;
              const int idx = dof.getPetscGlobalDofIdx();
              const int local_idx = dof.getPetscLocalDofIdx();
              const int pos =
                  side_number * nb_dofs_on_vert + dof.getDofCoeffIdx();
              nodes_indices[pos] = idx;
              local_nodes_indices[pos] = local_idx;
              if (brother_side_number != -1) {
                const int elem_idx = brother_side_number * nb_dofs_on_vert +
                                     (*dit)->getDofCoeffIdx();
                nodes_indices[elem_idx] = idx;
                local_nodes_indices[elem_idx] = local_idx;
              }
            }
          }
        }
      }
    } else {
      nodes_indices.resize(0, false);
      local_nodes_indices.resize(0, false);
    }

  } else {
    nodes_indices.resize(0, false);
    local_nodes_indices.resize(0, false);
  }

  MoFEMFunctionReturn(0);
}

getNoFieldColIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getNoFieldColIndices ( DataForcesAndSourcesCore &  data, const std::string &  field_name  ) const

protected

get col NoField indices

Definition at line 477 of file ForcesAndSourcesCore.cpp.

                                                                       {
  MoFEMFunctionBegin;
  if (data.dataOnEntities[MBENTITYSET].size() == 0) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
  }
  CHKERR getNoFieldIndices(field_name, getColDofsPtr(),
                           data.dataOnEntities[MBENTITYSET][0].getIndices());
  MoFEMFunctionReturn(0);
}

getNoFieldFieldData() [1/2]

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getNoFieldFieldData ( const std::string  field_name, VectorDouble &  ent_field_data, VectorDofs &  ent_field_dofs, VectorFieldEntities &  ent_field  ) const

protected

Get field data on nodes.

Definition at line 805 of file ForcesAndSourcesCore.cpp.

                                                                      {

  MoFEMFunctionBeginHot;

  ent_field_data.resize(0, false);
  ent_field_dofs.resize(0, false);
  ent_field.resize(0, false);

  auto &field_ents = getDataFieldEnts();
  auto bit_number = mField.get_field_bit_number(field_name);
  const auto lo_uid = FieldEntity::getLocalUniqueIdCalculate(
      bit_number, get_id_for_min_type<MBVERTEX>());
  auto lo = std::lower_bound(field_ents.begin(), field_ents.end(), lo_uid,
                             cmp_uid_lo);
  if (lo != field_ents.end()) {

    ent_field.resize(field_ents.size(), false);
    std::fill(ent_field.begin(), ent_field.end(), nullptr);

    const auto hi_uid = FieldEntity::getLocalUniqueIdCalculate(
        bit_number, get_id_for_max_type<MBVERTEX>());
    auto hi = std::upper_bound(lo, field_ents.end(), hi_uid, cmp_uid_hi);
    if (lo != hi) {

      int side = 0;
      for (auto it = lo; it != hi; ++it, ++side)
        if (auto e = it->lock()) {

          const auto size = e->getNbDofsOnEnt();
          ent_field_data.resize(size, false);
          ent_field_dofs.resize(size, false);
          ent_field[side] = e.get();
          noalias(ent_field_data) = e->getEntFieldData();


          if (auto cache = e->entityCacheDataDofs.lock()) {
            for (auto dit = cache->loHi[0]; dit != cache->loHi[1]; ++dit) {
              ent_field_dofs[(*dit)->getEntDofIdx()] =
                  reinterpret_cast<FEDofEntity *>((*dit).get());
            }
          }
        }
    }
  }

  MoFEMFunctionReturnHot(0);
}

getNoFieldFieldData() [2/2]

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getNoFieldFieldData ( DataForcesAndSourcesCore &  data, const std::string  field_name  ) const

protected

Definition at line 856 of file ForcesAndSourcesCore.cpp.

                                                                            {
  MoFEMFunctionBegin;
  if (data.dataOnEntities[MBENTITYSET].size() == 0)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "No space to insert data");

  CHKERR getNoFieldFieldData(
      field_name, data.dataOnEntities[MBENTITYSET][0].getFieldData(),
      data.dataOnEntities[MBENTITYSET][0].getFieldDofs(),
      data.dataOnEntities[MBENTITYSET][0].getFieldEntities());
  MoFEMFunctionReturn(0);
}

getNoFieldIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getNoFieldIndices ( const std::string &  field_name, boost::shared_ptr< FENumeredDofEntity_multiIndex >  dofs, VectorInt &  nodes_indices  ) const

protected

get NoField indices

Definition at line 448 of file ForcesAndSourcesCore.cpp.

                              {
  MoFEMFunctionBeginHot;
  auto field_it = fieldsPtr->get<FieldName_mi_tag>().find(field_name);
  auto dit = dofs->get<Unique_mi_tag>().lower_bound(
      FieldEntity::getLoBitNumberUId((*field_it)->getBitNumber()));
  auto hi_dit = dofs->get<Unique_mi_tag>().upper_bound(
      FieldEntity::getHiBitNumberUId((*field_it)->getBitNumber()));
  indices.resize(std::distance(dit, hi_dit));
  for (; dit != hi_dit; dit++) {
    int idx = (*dit)->getPetscGlobalDofIdx();
    indices[(*dit)->getDofCoeffIdx()] = idx;
  }
  MoFEMFunctionReturnHot(0);
}

getNoFieldRowIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getNoFieldRowIndices ( DataForcesAndSourcesCore &  data, const std::string &  field_name  ) const

protected

get col NoField indices

Definition at line 466 of file ForcesAndSourcesCore.cpp.

                                                                       {
  MoFEMFunctionBegin;
  if (data.dataOnEntities[MBENTITYSET].size() == 0) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
  }
  CHKERR getNoFieldIndices(field_name, getRowDofsPtr(),
                           data.dataOnEntities[MBENTITYSET][0].getIndices());
  MoFEMFunctionReturn(0);
}

getOpPtrVector()

boost::ptr_vector<UserDataOperator>& MoFEM::ForcesAndSourcesCore::getOpPtrVector

(

)

Use to push back operator for row operator.

It can be used to calculate nodal forces or other quantities on the mesh.

Examples

continuity_check_on_contact_prism_side_ele.cpp, continuity_check_on_skeleton_3d.cpp, continuity_check_on_skeleton_with_simple_2d.cpp, forces_and_sources_testing_edge_element.cpp, forces_and_sources_testing_flat_prism_element.cpp, and lorentz_force.cpp.

Definition at line 423 of file ForcesAndSourcesCore.hpp.

{ return opPtrVector; }

getProblemNodesColIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getProblemNodesColIndices ( const std::string &  field_name, VectorInt &  nodes_indices  ) const

protected

Definition at line 583 of file ForcesAndSourcesCore.cpp.

                                                                 {
  return getProblemNodesIndices(field_name, *(problemPtr->numeredColDofsPtr),
                                nodes_indices);
}

getProblemNodesIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getProblemNodesIndices ( const std::string &  field_name, const NumeredDofEntity_multiIndex &  dofs, VectorInt &  nodes_indices  ) const

protected

get indices of nodal indices which are declared for problem but not this particular element

Definition at line 490 of file ForcesAndSourcesCore.cpp.

                                    {
  MoFEMFunctionBeginHot;

  const Field *field_struture = mField.get_field_structure(field_name);
  if (field_struture->getSpace() == H1) {

    int num_nodes;
    CHKERR getNumberOfNodes(num_nodes);
    nodes_indices.resize(field_struture->getNbOfCoeffs() * num_nodes, false);
    std::fill(nodes_indices.begin(), nodes_indices.end(), -1);

    auto &side_table = const_cast<SideNumber_multiIndex &>(
        numeredEntFiniteElementPtr->getSideNumberTable());
    auto siit = side_table.get<1>().lower_bound(boost::make_tuple(MBVERTEX, 0));
    auto hi_siit =
        side_table.get<1>().lower_bound(boost::make_tuple(MBVERTEX, 10000));

    int nn = 0;
    for (; siit != hi_siit; siit++, nn++) {

      if (siit->get()->side_number == -1)
        continue;

      auto bit_number = mField.get_field_bit_number(field_name);
      const EntityHandle ent = siit->get()->ent;
      auto dit = dofs.get<Unique_mi_tag>().lower_bound(
          FieldEntity::getLoLocalEntityBitNumber(bit_number, ent));
      auto hi_dit = dofs.get<Unique_mi_tag>().upper_bound(
          FieldEntity::getHiLocalEntityBitNumber(bit_number, ent));
      for (; dit != hi_dit; dit++) {
        nodes_indices[siit->get()->side_number * (*dit)->getNbOfCoeffs() +
                      (*dit)->getDofCoeffIdx()] =
            (*dit)->getPetscGlobalDofIdx();
      }
    }
  } else {
    nodes_indices.resize(0, false);
  }

  MoFEMFunctionReturnHot(0);
}

getProblemNodesRowIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getProblemNodesRowIndices ( const std::string &  field_name, VectorInt &  nodes_indices  ) const

protected

Definition at line 569 of file ForcesAndSourcesCore.cpp.

                                                                 {
  return getProblemNodesIndices(field_name, *(problemPtr->numeredRowDofsPtr),
                                nodes_indices);
}

getProblemTypeColIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getProblemTypeColIndices ( const std::string &  field_name, EntityType  type, int  side_number, VectorInt &  indices  ) const

protected

Definition at line 590 of file ForcesAndSourcesCore.cpp.

                                                                         {
  return getProblemTypeIndices(field_name, *(problemPtr->numeredColDofsPtr), type,
                               side_number, indices);
}

getProblemTypeIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getProblemTypeIndices ( const std::string &  field_name, const NumeredDofEntity_multiIndex &  dofs, EntityType  type, int  side_number, VectorInt &  indices  ) const

protected

get indices by type (generic function) which are declared for problem but not this particular element

Definition at line 534 of file ForcesAndSourcesCore.cpp.

                                                                {
  MoFEMFunctionBeginHot;

  indices.resize(0);

  auto &side_table = const_cast<SideNumber_multiIndex &>(
      numeredEntFiniteElementPtr->getSideNumberTable());
  auto siit =
      side_table.get<1>().lower_bound(boost::make_tuple(type, side_number));
  auto hi_siit =
      side_table.get<1>().upper_bound(boost::make_tuple(type, side_number));

  for (; siit != hi_siit; siit++) {

    if (siit->get()->side_number == -1)
      continue;

    const EntityHandle ent = siit->get()->ent;
    auto bit_number = mField.get_field_bit_number(field_name);
    auto dit = dofs.get<Unique_mi_tag>().lower_bound(
        FieldEntity::getLoLocalEntityBitNumber(bit_number, ent));
    auto hi_dit = dofs.get<Unique_mi_tag>().upper_bound(
        FieldEntity::getHiLocalEntityBitNumber(bit_number, ent));
    indices.resize(std::distance(dit, hi_dit));
    for (; dit != hi_dit; dit++) {

      indices[(*dit)->getEntDofIdx()] = (*dit)->getPetscGlobalDofIdx();
    }
  }

  MoFEMFunctionReturnHot(0);
}

getProblemTypeRowIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getProblemTypeRowIndices ( const std::string &  field_name, EntityType  type, int  side_number, VectorInt &  indices  ) const

protected

Definition at line 576 of file ForcesAndSourcesCore.cpp.

                                                                         {
  return getProblemTypeIndices(field_name, *(problemPtr->numeredRowDofsPtr), type,
                               side_number, indices);
}

getRowNodesIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getRowNodesIndices ( DataForcesAndSourcesCore &  data, const std::string &  field_name  ) const

protected

get row node indices from FENumeredDofEntity_multiIndex

Definition at line 315 of file ForcesAndSourcesCore.cpp.

                                                                            {

  struct Extractor {
    boost::weak_ptr<EntityCacheNumeredDofs>
    operator()(boost::shared_ptr<FieldEntity> &e) {
      return e->entityCacheRowDofs;
    }
  };

  return getNodesIndices(field_name, getRowFieldEnts(),
                         data.dataOnEntities[MBVERTEX][0].getIndices(),
                         data.dataOnEntities[MBVERTEX][0].getLocalIndices(),
                         Extractor());
}

getRule() [1/2]

int MoFEM::ForcesAndSourcesCore::getRule ( int  order_row, int  order_col, int  order_data  )

protectedvirtual

another variant of getRule

Parameters

order_row	order of base function on row
order_col	order of base function on columns
order_data	order of base function approximating data

Returns

integration rule

This function is overloaded by the user. The integration rule is set such that specific operator implemented by the user is integrated accurately. For example if user implement bilinear operator

\[ b(u,v) = \int_\mathcal{T} \frac{\partial u_i}{\partial x_j}\frac{\partial v_i}{\partial x_j} \textrm{d}\mathcal{T} \]

then if \(u\) and \(v\) are polynomial of given order, then exact integral would be

 int getRule(int order) { return
2*(order-1); }; 

The integration points and weights are set appropriately for given entity type and integration rule from quad.c

Method ForcesAndSourcesCore::getRule takes at argument takes maximal polynomial order set on the element on all fields defined on the element. If a user likes to have more control, another variant of this function can be called which distinguishing between field orders on rows, columns and data, the i.e. first argument of a bilinear form, the second argument of bilinear form and field coefficients on the element.

Note

If user set rule to -1 or any other negative integer, then method ForcesAndSourcesCore::setGaussPts is called. In that method user can implement own (specific) integration method.

Bug:

this function should be const

Reimplemented in EdgeFE.

Definition at line 1580 of file ForcesAndSourcesCore.cpp.

                                                  {
  return getRuleHook ? getRuleHook(order_row, order_col, order_data)
                     : getRule(order_data);
}

getRule() [2/2]

int MoFEM::ForcesAndSourcesCore::getRule ( int  order )

protectedvirtual

Deprecated:

Use getRule(int row_order, int col_order, int data order)

Reimplemented in EdgeSlidingConstrains::MyEdgeFE, PostProcEdgeOnRefinedMesh, BoneRemodeling::DensityMapFe, GelModule::Gel::GelFE, SurfaceSlidingConstrains::MyTriangleFE, SmallStrainPlasticity::MyVolumeFE, PostProcTemplateVolumeOnRefinedMesh< MoFEM::VolumeElementForcesAndSourcesCore >, NitscheMethod::MyVolumeFE, KelvinVoigtDamper::DamperFE, MoFEM::VolumeElementForcesAndSourcesCoreOnSideBase, MoFEM::VolumeElementForcesAndSourcesCoreOnContactPrismSideBase, NonlinearElasticElement::MyVolumeFE, ThermalElement::MyVolumeFE, MixTransport::MixTransportElement::MyVolumeFE, CellEngineering::FaceElement, MagneticElement::VolumeFE, BoneRemodeling::Remodeling::Fe, OptimalMassTransport::VolumeFE, MoFEM::FaceElementForcesAndSourcesCoreOnSideBase, CohesiveElement::CohesiveInterfaceElement::MyPrism, EdgeForce::MyFE, ThermalStressElement::MyVolumeFE, and BodyForceConstantField::MyVolumeFE.

Definition at line 1592 of file ForcesAndSourcesCore.cpp.

{ return 2 * order; }

getSpacesAndBaseOnEntities()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getSpacesAndBaseOnEntities ( DataForcesAndSourcesCore &  data ) const

protected

Get field approximation space and base on entities.

Definition at line 967 of file ForcesAndSourcesCore.cpp.

                                          {
  MoFEMFunctionBeginHot;

  if (nInTheLoop == 0) {
    data.sPace.reset();
    data.bAse.reset();
    for (EntityType t = MBVERTEX; t != MBMAXTYPE; ++t) {
      data.spacesOnEntities[t].reset();
      data.basesOnEntities[t].reset();
    }
    for (int s = 0; s != LASTSPACE; ++s) {
      data.basesOnSpaces[s].reset();
    }
  }

  auto fe_type = numeredEntFiniteElementPtr->getEntType();

  if (getDataFieldEntsPtr())
    for (auto e : getDataFieldEnts()) {
      if (auto ptr = e.lock()) {
        // get data from entity
        const EntityType type = ptr->getEntType();
        if (DefaultElementAdjacency::getDefTypeMap(fe_type, type)) {
          const FieldSpace space = ptr->getSpace();
          const FieldApproximationBase approx = ptr->getApproxBase();
          // set data
          data.sPace.set(space);
          data.bAse.set(approx);
          data.spacesOnEntities[type].set(space);
          data.basesOnEntities[type].set(approx);
          data.basesOnSpaces[space].set(approx);
        }
      }
    }
  else
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "data fields ents not allocated on element");

  MoFEMFunctionReturnHot(0);
}

getUserPolynomialBase()

auto& MoFEM::ForcesAndSourcesCore::getUserPolynomialBase

(

)

Get the User Polynomial Base object.

Returns

boost::shared_ptr<BaseFunction>&

Definition at line 437 of file ForcesAndSourcesCore.hpp.

{ return userPolynomialBasePtr; }

loopOverOperators()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::loopOverOperators ( )

protected

Iterate user data operators.

Returns

MoFEMErrorCode

Definition at line 1296 of file ForcesAndSourcesCore.cpp.

                                                       {
  MoFEMFunctionBegin;

  const EntityType type = numeredEntFiniteElementPtr->getEntType();
  const UserDataOperator::OpType types[2] = {UserDataOperator::OPROW,
                                             UserDataOperator::OPCOL};
  std::vector<std::string> last_eval_field_name(2);

  boost::ptr_vector<UserDataOperator>::iterator oit, hi_oit;
  oit = opPtrVector.begin();
  hi_oit = opPtrVector.end();

  for (; oit != hi_oit; oit++) {

    try {

      CHKERR oit->setPtrFE(this);

      if (oit->opType == UserDataOperator::OPLAST) {

        // Set field
        switch (oit->sPace) {
        case NOSPACE:
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Unknown space");
        case NOFIELD:
        case H1:
        case HCURL:
        case HDIV:
        case L2:
          break;
        default:
          SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
                   "Not implemented for this space", oit->sPace);
        }

        // Reseat all data which all field dependent
        dataOnElement[oit->sPace]->resetFieldDependentData();
        last_eval_field_name[0] = "";

        // Run operator
        try {
          CHKERR oit->opRhs(*dataOnElement[oit->sPace], false);
        }
        CATCH_OP_ERRORS(*oit);

      } else {

        boost::shared_ptr<DataForcesAndSourcesCore> op_data[2];
        std::array<bool, 2> base_swap;
        std::array<std::pair<std::string, FieldApproximationBase>, 2>
            base_swap_data;
        auto swap_bases = [&]() {
          MoFEMFunctionBeginHot;
          for (size_t ss = 0; ss != 2; ++ss)
            if (base_swap[ss])
              CHKERR op_data[ss]->baseSwap(base_swap_data[ss].first,
                                           base_swap_data[ss].second);
          MoFEMFunctionReturnHot(0);
        };

        for (size_t ss = 0; ss != 2; ss++) {

          const std::string field_name =
              !ss ? oit->rowFieldName : oit->colFieldName;
          if (field_name.empty()) {
            SETERRQ2(
                PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "No field name in operator %d (0-row, 1-column) in operator %s",
                ss,
                (boost::typeindex::type_id_runtime(*oit).pretty_name())
                    .c_str());
          }
          const Field *field_struture = mField.get_field_structure(field_name);
          const BitFieldId data_id = field_struture->getId();
          const FieldSpace space = field_struture->getSpace();
          const FieldApproximationBase base = field_struture->getApproxBase();
          op_data[ss] =
              !ss ? dataOnElement[space] : derivedDataOnElement[space];

          switch (base) {
          case AINSWORTH_BERNSTEIN_BEZIER_BASE:
            base_swap_data[ss] = std::pair<std::string, FieldApproximationBase>(
                field_name, AINSWORTH_BERNSTEIN_BEZIER_BASE);
            base_swap[ss] = true;
            break;
          default:
            base_swap[ss] = false;
          };

          if ((oit->getNumeredEntFiniteElementPtr()->getBitFieldIdData() &
               data_id)
                  .none()) {
            SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                     "no data field < %s > on finite element < %s >",
                     field_name.c_str(), feName.c_str());
          }

          if (oit->getOpType() & types[ss] ||
              oit->getOpType() & UserDataOperator::OPROWCOL) {

            switch (space) {
            case NOSPACE:
              SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                      "unknown space");
              break;
            case NOFIELD:
            case H1:
            case HCURL:
            case HDIV:
            case L2:
              break;
            default:
              SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
                       "Not implemented for this space", space);
            }

            if (last_eval_field_name[ss] != field_name) {

              CHKERR getEntityFieldData(*op_data[ss], field_name, MBEDGE);
              if (!ss)
                CHKERR getEntityRowIndices(*op_data[ss], field_name, MBEDGE);
              else
                CHKERR getEntityColIndices(*op_data[ss], field_name, MBEDGE);

              switch (space) {
              case NOSPACE:
                SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                        "unknown space");
                break;
              case H1:
                if (!ss)
                  CHKERR getRowNodesIndices(*op_data[ss], field_name);
                else
                  CHKERR getColNodesIndices(*op_data[ss], field_name);
                CHKERR getNodesFieldData(*op_data[ss], field_name);
                break;
              case HCURL:
              case HDIV:
                break;
              case L2:
                switch (type) {
                case MBVERTEX:
                  CHKERR getNodesFieldData(*op_data[ss], field_name);
                  break;
                default:
                  break;
                }
                break;
              case NOFIELD:
                if (!getNinTheLoop()) {
                  // NOFIELD data are the same for each element, can be
                  // retrieved only once
                  if (!ss) {
                    CHKERR getNoFieldRowIndices(*op_data[ss], field_name);
                  } else {
                    CHKERR getNoFieldColIndices(*op_data[ss], field_name);
                  }
                  CHKERR getNoFieldFieldData(*op_data[ss], field_name);
                }
                break;
              default:
                SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
                         "Not implemented for this space", space);
              }
              last_eval_field_name[ss] = field_name;
            }
          }
        }

        CHKERR swap_bases();

        if (oit->getOpType() & UserDataOperator::OPROW) {
          try {
            CHKERR oit->opRhs(*op_data[0], false);
          }
          CATCH_OP_ERRORS(*oit);
        }

        if (oit->getOpType() & UserDataOperator::OPCOL) {
          try {
            CHKERR oit->opRhs(*op_data[1], false);
          }
          CATCH_OP_ERRORS(*oit);
        }

        if (oit->getOpType() & UserDataOperator::OPROWCOL) {
          try {
            CHKERR oit->opLhs(*op_data[0], *op_data[1]);
          }
          CATCH_OP_ERRORS(*oit);
        }

        CHKERR swap_bases();
      }
    }
    CATCH_OP_ERRORS(*oit);
  }
  MoFEMFunctionReturn(0);
}

operator()()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::operator() ( )

virtual

function is run for every finite element

It is used to calculate element local matrices and assembly. It can be used for post-processing.

Reimplemented from MoFEM::BasicMethod.

Reimplemented in MoFEM::VolumeElementForcesAndSourcesCoreSwitch< SWITCH >, MoFEM::FaceElementForcesAndSourcesCoreSwitch< SWITCH >, MoFEM::ContactPrismElementForcesAndSourcesCore, MoFEM::VolumeElementForcesAndSourcesCoreOnSideSwitch< SWITCH >, MoFEM::FatPrismElementForcesAndSourcesCore, MoFEM::EdgeElementForcesAndSourcesCoreSwitch< SWITCH >, MoFEM::FaceElementForcesAndSourcesCoreOnSideSwitch< SWITCH >, MoFEM::FaceElementForcesAndSourcesCoreOnSideSwitch< FaceElementForcesAndSourcesCore::NO_HO_GEOMETRY >, MoFEM::FaceElementForcesAndSourcesCoreOnSideSwitch< FaceElementForcesAndSourcesCore::NO_CONTRAVARIANT_TRANSFORM_HDIV|FaceElementForcesAndSourcesCore::NO_COVARIANT_TRANSFORM_HCURL >, MoFEM::FlatPrismElementForcesAndSourcesCore, MoFEM::VolumeElementForcesAndSourcesCoreOnContactPrismSideSwitch< SWITCH >, and MoFEM::VertexElementForcesAndSourcesCore.

Definition at line 1626 of file ForcesAndSourcesCore.cpp.

                                                {
  MoFEMFunctionBeginHot;
  if (operatorHook) {
    ierr = operatorHook();
    CHKERRG(ierr);
  }
  MoFEMFunctionReturnHot(0);
}

postProcess()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::postProcess ( )

virtual

function is run at the end of loop

It is used to assembly matrices and vectors, calculating global variables, f.e. total internal energy, ect.

Iterating over dofs: Example1 iterating over dofs in row by name of the field for(IT_GET_FEROW_BY_NAME_DOFS_FOR_LOOP(this,"DISPLACEMENT",it)) { ... }

Reimplemented from MoFEM::BasicMethod.

Reimplemented in PostProcEdgeOnRefinedMesh, PostProcFatPrismOnRefinedMesh, SolidShellModule::SolidShellPrismElement::PostProcFatPrismOnTriangleOnRefinedMesh, PostProcTemplateVolumeOnRefinedMesh< MoFEM::VolumeElementForcesAndSourcesCore >, GelModule::Gel::GelFE, KelvinVoigtDamper::DamperFE, SolidShellModule::SolidShellPrismElement::SolidShellError, SolidShellModule::SolidShellPrismElement::SolidShell, Smoother::MyVolumeFE, and NonlinearElasticElement::MyVolumeFE.

Definition at line 1634 of file ForcesAndSourcesCore.cpp.

                                                 {
  MoFEMFunctionBeginHot;
  if (postProcessHook) {
    ierr = postProcessHook();
    CHKERRG(ierr);
  }
  MoFEMFunctionReturnHot(0);
}

preProcess()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::preProcess ( )

virtual

function is run at the beginning of loop

It is used to zeroing matrices and vectors, calculation of shape functions on reference element, preprocessing boundary conditions, etc.

Reimplemented from MoFEM::BasicMethod.

Reimplemented in EdgeSlidingConstrains::MyEdgeFE, PostProcEdgeOnRefinedMesh, PostProcFatPrismOnRefinedMesh, PostProcTemplateVolumeOnRefinedMesh< MoFEM::VolumeElementForcesAndSourcesCore >, GelModule::Gel::GelFE, SurfaceSlidingConstrains::MyTriangleFE, KelvinVoigtDamper::DamperFE, SolidShellModule::SolidShellPrismElement::SolidShellError, SolidShellModule::SolidShellPrismElement::SolidShell, Smoother::MyVolumeFE, and NonlinearElasticElement::MyVolumeFE.

Definition at line 1618 of file ForcesAndSourcesCore.cpp.

                                                {
  MoFEMFunctionBeginHot;
  if (preProcessHook) {
    ierr = preProcessHook();
    CHKERRG(ierr);
  }
  MoFEMFunctionReturnHot(0);
}

setGaussPts() [1/2]

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::setGaussPts ( int  order_row, int  order_col, int  order_data  )

protectedvirtual

set user specific integration rule

This function allows for user defined integration rule. The key is to called matrix gaussPts, which is used by other MoFEM procedures. Matrix has number of rows equal to problem dimension plus one, where last index is used to store weight values. Number of columns is equal to number of integration points.

Note

This function is called if method ForcesAndSourcesCore::getRule is returning integer -1 or any other negative integer.

User sets

MatrixDouble gaussPts;

where

gaussPts.resize(dim+1,nb_gauss_pts);

number rows represents local coordinates of integration points in reference element, where last index in row is for integration weight.

Reimplemented in EdgeFE.

Definition at line 1586 of file ForcesAndSourcesCore.cpp.

                                                                 {
  return setRuleHook ? setRuleHook(order_row, order_col, order_data)
                     : setGaussPts(order_data);
}

setGaussPts() [2/2]

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::setGaussPts ( int  order )

protectedvirtual

Deprecated:

setGaussPts(int row_order, int col_order, int data order);

Deprecated:

setGaussPts(int row_order, int col_order, int data order);

Reimplemented in PostProcEdgeOnRefinedMesh, PostProcTemplateVolumeOnRefinedMesh< MoFEM::VolumeElementForcesAndSourcesCore >, NitscheMethod::MyVolumeFE, MoFEM::VolumeElementForcesAndSourcesCoreOnSideBase, MoFEM::FaceElementForcesAndSourcesCoreOnSideBase, and MoFEM::VolumeElementForcesAndSourcesCoreOnContactPrismSideBase.

Definition at line 1596 of file ForcesAndSourcesCore.cpp.

                                                          {
  MoFEMFunctionBeginHot;
  SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "Sorry, not implemented");
  MoFEMFunctionReturnHot(0);
}

setSideFEPtr()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::setSideFEPtr ( const ForcesAndSourcesCore *  side_fe_ptr )

private

Set the pointer to face element on the side.

Note

Function is is used by face element, while it iterates over elements on the side

Parameters

side_fe_ptr

Returns

MoFEMErrorCode

Definition at line 1531 of file ForcesAndSourcesCore.cpp.

                                                                          {
  MoFEMFunctionBeginHot;
  sidePtrFE = const_cast<ForcesAndSourcesCore *>(side_fe_ptr);
  MoFEMFunctionReturnHot(0);
}

Friends And Related Function Documentation

FaceElementForcesAndSourcesCoreOnSideBase

friend class FaceElementForcesAndSourcesCoreOnSideBase

friend

Definition at line 855 of file ForcesAndSourcesCore.hpp.

UserDataOperator

friend class UserDataOperator

friend

Examples

continuity_check_on_contact_prism_side_ele.cpp, continuity_check_on_skeleton_with_simple_2d.cpp, forces_and_sources_testing_edge_element.cpp, hcurl_divergence_operator_2d.cpp, heat_equation.hpp, hello_world.cpp, helmholtz.cpp, lesson3_poisson.cpp, lesson6_radiation.cpp, lesson7_plastic.cpp, lesson8_contact.cpp, mesh_smoothing.cpp, and wave_equation.hpp.

Definition at line 816 of file ForcesAndSourcesCore.hpp.

VolumeElementForcesAndSourcesCoreOnContactPrismSideBase

friend class VolumeElementForcesAndSourcesCoreOnContactPrismSideBase

friend

Definition at line 856 of file ForcesAndSourcesCore.hpp.

VolumeElementForcesAndSourcesCoreOnSideBase

friend class VolumeElementForcesAndSourcesCoreOnSideBase

friend

Definition at line 854 of file ForcesAndSourcesCore.hpp.

Member Data Documentation

dataH1

DataForcesAndSourcesCore& MoFEM::ForcesAndSourcesCore::dataH1

protected

Definition at line 805 of file ForcesAndSourcesCore.hpp.

dataHcurl

DataForcesAndSourcesCore& MoFEM::ForcesAndSourcesCore::dataHcurl

protected

Definition at line 806 of file ForcesAndSourcesCore.hpp.

dataHdiv

DataForcesAndSourcesCore& MoFEM::ForcesAndSourcesCore::dataHdiv

protected

Definition at line 807 of file ForcesAndSourcesCore.hpp.

dataL2

DataForcesAndSourcesCore& MoFEM::ForcesAndSourcesCore::dataL2

protected

Definition at line 808 of file ForcesAndSourcesCore.hpp.

dataNoField

DataForcesAndSourcesCore& MoFEM::ForcesAndSourcesCore::dataNoField

protected

Definition at line 804 of file ForcesAndSourcesCore.hpp.

dataOnElement

const std::array<boost::shared_ptr<DataForcesAndSourcesCore>, LASTSPACE> MoFEM::ForcesAndSourcesCore::dataOnElement

protected

Entity data on element entity rows fields.

@/}

Definition at line 795 of file ForcesAndSourcesCore.hpp.

derivedDataOnElement

const std::array<boost::shared_ptr<DataForcesAndSourcesCore>, LASTSPACE> MoFEM::ForcesAndSourcesCore::derivedDataOnElement

protected

Entity data on element entity columns fields.

Definition at line 802 of file ForcesAndSourcesCore.hpp.

elementPolynomialBasePtr

boost::shared_ptr<BaseFunction> MoFEM::ForcesAndSourcesCore::elementPolynomialBasePtr

private

Pointer to entity polynomial base.

Definition at line 830 of file ForcesAndSourcesCore.hpp.

gaussPts

MatrixDouble MoFEM::ForcesAndSourcesCore::gaussPts

Matrix of integration points.

Columns is equal to number of integration points, numver of rows depends on dimension of finite element entity, for example for tetrahedron rows are x,y,z,weight. Last row is integration weight.

FIXME: that should be moved to private class data and acessed only by member function

Examples

prism_elements_from_surface.cpp.

Definition at line 449 of file ForcesAndSourcesCore.hpp.

getRuleHook

RuleHookFun MoFEM::ForcesAndSourcesCore::getRuleHook

Hook to get rule.

Todo:

check preferred format how works with gcc and clang, see http://www.boost.org/doc/libs/1_64_0/doc/html/function/tutorial.html#idp247873024

Examples

field_evaluator.cpp, and lorentz_force.cpp.

Definition at line 50 of file ForcesAndSourcesCore.hpp.

lastEvaluatedElementEntityType

EntityType MoFEM::ForcesAndSourcesCore::lastEvaluatedElementEntityType

protected

Last evaluated type of element entity.

Definition at line 823 of file ForcesAndSourcesCore.hpp.

mField

Interface& MoFEM::ForcesAndSourcesCore::mField

Examples

prism_elements_from_surface.cpp.

Definition at line 36 of file ForcesAndSourcesCore.hpp.

opPtrVector

boost::ptr_vector<UserDataOperator> MoFEM::ForcesAndSourcesCore::opPtrVector

protected

Vector of finite element users data operators.

Definition at line 814 of file ForcesAndSourcesCore.hpp.

setRuleHook

RuleHookFun MoFEM::ForcesAndSourcesCore::setRuleHook

Set function to calculate integration rule.

Definition at line 56 of file ForcesAndSourcesCore.hpp.

sidePtrFE

ForcesAndSourcesCore* MoFEM::ForcesAndSourcesCore::sidePtrFE

private

Element to integrate on the sides.

Definition at line 841 of file ForcesAndSourcesCore.hpp.

userPolynomialBasePtr

boost::shared_ptr<BaseFunction> MoFEM::ForcesAndSourcesCore::userPolynomialBasePtr

private

Pointer to user polynomail base.

Definition at line 835 of file ForcesAndSourcesCore.hpp.

---

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

• src/finite_elements/ForcesAndSourcesCore.hpp
• src/finite_elements/impl/ForcesAndSourcesCore.cpp