MoFEM::ForcesAndSourcesCore Struct Reference

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

#include "src/finite_elements/ForcesAndSourcesCore.hpp"

Inheritance diagram for MoFEM::ForcesAndSourcesCore:

Collaboration diagram for MoFEM::ForcesAndSourcesCore:

Classes
struct	UserDataOperator

Public Types
typedef boost::function< int(int order_row, int order_col, int order_data)>	RuleHookFun
typedef boost::function< MoFEMErrorCode(ForcesAndSourcesCore *fe_raw_ptr, int order_row, int order_col, int order_data)>	GaussHookFun
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_DX = 1 << 4 , CTX_SET_X_T = 1 << 5 , 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 Types inherited from MoFEM::TaoMethod
enum	TAOContext { CTX_TAO_OBJECTIVE , CTX_TAO_GRADIENT , CTX_TAO_HESSIAN , CTX_TAO_NONE }

Public Member Functions
	ForcesAndSourcesCore (Interface &m_field)
boost::ptr_deque< UserDataOperator > &	getOpPtrVector ()
	Use to push back operator for row operator.
auto &	getElementPolynomialBase ()
	Get the Entity Polynomial Base object.
auto &	getUserPolynomialBase ()
	Get the User Polynomial Base object.
virtual MoFEMErrorCode	preProcess ()
	function is run at the beginning of loop
virtual MoFEMErrorCode	operator() ()
	function is run for every finite element
virtual MoFEMErrorCode	postProcess ()
	function is run at the end of loop
int	getMaxDataOrder () const
	Get max order of approximation for data fields.
int	getMaxRowOrder () const
	Get max order of approximation for field in rows.
int	getMaxColOrder () const
	Get max order of approximation for field in columns.
auto &	getEntData (const FieldSpace space, const EntityType type, const int side)
	Get the entity data.
auto &	getDataOnElementBySpaceArray ()
	Get data on entities and space.
auto &	getDerivedDataOnElementBySpaceArray ()
	Get derived data on entities and space.
Public Member Functions inherited from MoFEM::FEMethod
MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
	FEMethod ()=default
auto	getFEName () const
	get finite element name
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
auto	getNumberOfNodes () const
EntityHandle	getFEEntityHandle () const
MoFEMErrorCode	getNodeData (const std::string field_name, VectorDouble &data, const bool reset_dofs=true)
Public Member Functions inherited from MoFEM::BasicMethod
	BasicMethod ()
virtual	~BasicMethod ()=default
int	getNinTheLoop () const
	get number of evaluated element in the loop
int	getLoopSize () const
	get loop size
auto	getLoHiFERank () const
	Get lo and hi processor rank of iterated entities.
auto	getLoFERank () const
	Get upper rank in loop for iterating elements.
auto	getHiFERank () const
	Get upper rank in loop for iterating elements.
unsigned int	getFieldBitNumber (std::string field_name) const
MoFEMErrorCode	copyBasicMethod (const BasicMethod &basic)
	Copy data from other base method to this base method.
boost::weak_ptr< CacheTuple >	getCacheWeakPtr () const
	Get the cache weak ptr object.
Public Member Functions inherited from MoFEM::KspMethod
MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
	KspMethod ()
virtual	~KspMethod ()=default
MoFEMErrorCode	copyKsp (const KspMethod &ksp)
	copy data form another method
Public Member Functions inherited from MoFEM::PetscData
	PetscData ()
virtual	~PetscData ()=default
MoFEMErrorCode	copyPetscData (const PetscData &petsc_data)
Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode	registerInterface (bool error_if_registration_failed=true)
	Register interface.
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface reference to pointer of interface.
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE **const iface) const
	Get interface pointer to pointer of interface.
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get interface pointer to pointer of interface.
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get reference to interface.
template<class IFACE >
IFACE *	getInterface () const
	Function returning pointer to interface.
virtual	~UnknownInterface ()=default
Public Member Functions inherited from MoFEM::SnesMethod
MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
	SnesMethod ()
virtual	~SnesMethod ()=default
MoFEMErrorCode	copySnes (const SnesMethod &snes)
	Copy snes data.
Public Member Functions inherited from MoFEM::TSMethod
MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
	TSMethod ()
virtual	~TSMethod ()=default
MoFEMErrorCode	copyTs (const TSMethod &ts)
	Copy TS solver data.
Public Member Functions inherited from MoFEM::TaoMethod
MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
	TaoMethod ()
virtual	~TaoMethod ()=default
MoFEMErrorCode	copyTao (const TaoMethod &tao)
	Copy TAO data.

Public Attributes
Interface &	mField
RuleHookFun	getRuleHook
	Hook to get rule.
GaussHookFun	setRuleHook
	Set function to calculate integration rule.
MatrixDouble	gaussPts
	Matrix of integration points.
Public Attributes inherited from MoFEM::FEMethod
std::string	feName
	Name of finite element.
boost::shared_ptr< const NumeredEntFiniteElement >	numeredEntFiniteElementPtr
boost::function< bool(FEMethod *fe_method_ptr)>	exeTestHook
	Tet if element to skip element.
Public Attributes inherited from MoFEM::BasicMethod
int	nInTheLoop
	number currently of processed method
int	loopSize
	local number oe methods to process
std::pair< int, int >	loHiFERank
	Llo and hi processor rank of iterated entities.
int	rAnk
	processor rank
int	sIze
	number of processors in communicator
const RefEntity_multiIndex *	refinedEntitiesPtr
	container of mofem dof entities
const RefElement_multiIndex *	refinedFiniteElementsPtr
	container of mofem finite element entities
const Problem *	problemPtr
	raw pointer to problem
const Field_multiIndex *	fieldsPtr
	raw pointer to fields container
const FieldEntity_multiIndex *	entitiesPtr
	raw pointer to container of field entities
const DofEntity_multiIndex *	dofsPtr
	raw pointer container of dofs
const FiniteElement_multiIndex *	finiteElementsPtr
	raw pointer to container finite elements
const EntFiniteElement_multiIndex *	finiteElementsEntitiesPtr
const FieldEntityEntFiniteElementAdjacencyMap_multiIndex *	adjacenciesPtr
boost::function< MoFEMErrorCode()>	preProcessHook
	Hook function for pre-processing.
boost::function< MoFEMErrorCode()>	postProcessHook
	Hook function for post-processing.
boost::function< MoFEMErrorCode()>	operatorHook
	Hook function for operator.
boost::movelib::unique_ptr< bool >	vecAssembleSwitch
boost::movelib::unique_ptr< bool >	matAssembleSwitch
boost::weak_ptr< CacheTuple >	cacheWeakPtr
Public Attributes inherited from MoFEM::KspMethod
KSPContext	ksp_ctx
	Context.
KSP	ksp
	KSP solver.
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	dx
Vec	x_t
Vec	x_tt
Public Attributes inherited from MoFEM::SnesMethod
SNESContext	snes_ctx
SNES	snes
	snes solver
Vec &	snes_x
	state vector
Vec &	snes_dx
	solution update
Vec &	snes_f
	residual
Mat &	snes_A
	jacobian matrix
Mat &	snes_B
	preconditioner of jacobian matrix
Public Attributes inherited from MoFEM::TSMethod
TS	ts
	time solver
TSContext	ts_ctx
PetscInt	ts_step
	time step number
PetscReal	ts_a
	shift for U_t (see PETSc Time Solver)
PetscReal	ts_aa
	shift for U_tt shift for U_tt
PetscReal	ts_t
	time
PetscReal	ts_dt
	time step size
Vec &	ts_u
	state vector
Vec &	ts_u_t
	time derivative of state vector
Vec &	ts_u_tt
	second time derivative of state vector
Vec &	ts_F
	residual vector
Mat &	ts_A
Mat &	ts_B
	Preconditioner for ts_A.
Public Attributes inherited from MoFEM::TaoMethod
TAOContext	tao_ctx
Tao	tao
	tao solver
Vec &	tao_x
Vec &	tao_f
	state vector
Mat &	tao_A
	gradient vector
Mat &	tao_B
	hessian matrix

Protected Member Functions
MoFEMErrorCode	getEntitySense (const EntityType type, boost::ptr_vector< EntitiesFieldData::EntData > &data) const
	get sense (orientation) of entity
MoFEMErrorCode	getEntityDataOrder (const EntityType type, const FieldSpace space, boost::ptr_vector< EntitiesFieldData::EntData > &data) const
	Get the entity data order.
template<EntityType type>
MoFEMErrorCode	getEntitySense (EntitiesFieldData &data) const
	Get the entity sense (orientation)
template<EntityType type>
MoFEMErrorCode	getEntityDataOrder (EntitiesFieldData &data, const FieldSpace space) const
	Get the entity data order for given space.
MoFEMErrorCode	getFaceNodes (EntitiesFieldData &data) const
	Get nodes on faces.
MoFEMErrorCode	getSpacesAndBaseOnEntities (EntitiesFieldData &data) const
	Get field approximation space and base on entities.
virtual int	getRule (int order_row, int order_col, int order_data)
	another variant of getRule
virtual MoFEMErrorCode	setGaussPts (int order_row, int order_col, int order_data)
	set user specific integration rule
MoFEMErrorCode	calHierarchicalBaseFunctionsOnElement (const FieldApproximationBase b)
	Calculate base functions.
MoFEMErrorCode	calHierarchicalBaseFunctionsOnElement ()
	Calculate base functions.
MoFEMErrorCode	calBernsteinBezierBaseFunctionsOnElement ()
	Calculate Bernstein-Bezier base.
MoFEMErrorCode	createDataOnElement (EntityType type)
	Create a entity data on element object.
MoFEMErrorCode	loopOverOperators ()
	Iterate user data operators.
Indices
template<typename EXTRACTOR >
MoFEMErrorCode	getNodesIndices (const int bit_number, FieldEntity_vector_view &ents_field, VectorInt &nodes_indices, VectorInt &local_nodes_indices, EXTRACTOR &&extractor) const
	get node indices
MoFEMErrorCode	getRowNodesIndices (EntitiesFieldData &data, const int bit_number) const
	get row node indices from FENumeredDofEntity_multiIndex
MoFEMErrorCode	getColNodesIndices (EntitiesFieldData &data, const int bit_number) const
	get col node indices from FENumeredDofEntity_multiIndex
template<typename EXTRACTOR >
MoFEMErrorCode	getEntityIndices (EntitiesFieldData &data, const int bit_number, FieldEntity_vector_view &ents_field, const EntityType type_lo, const EntityType type_hi, EXTRACTOR &&extractor) const
MoFEMErrorCode	getEntityRowIndices (EntitiesFieldData &data, const int bit_number, const EntityType type_lo=MBVERTEX, const EntityType type_hi=MBPOLYHEDRON) const
MoFEMErrorCode	getEntityColIndices (EntitiesFieldData &data, const int bit_number, const EntityType type_lo=MBVERTEX, const EntityType type_hi=MBPOLYHEDRON) const
MoFEMErrorCode	getNoFieldRowIndices (EntitiesFieldData &data, const int bit_number) const
	get col NoField indices
MoFEMErrorCode	getNoFieldColIndices (EntitiesFieldData &data, const int bit_number) const
	get col NoField indices
Data
MoFEMErrorCode	getBitRefLevelOnData ()
MoFEMErrorCode	getNodesFieldData (EntitiesFieldData &data, const int bit_number) const
	Get data on nodes.
MoFEMErrorCode	getEntityFieldData (EntitiesFieldData &data, const int bit_number, const EntityType type_lo=MBVERTEX, const EntityType type_hi=MBPOLYHEDRON) const
template<typename EXTRACTOR >
MoFEMErrorCode	getNoFieldEntityFieldData (EntitiesFieldData &data, const int bit_number, EXTRACTOR &&extractor) const
	Get field data on entities where no field is defined.
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
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
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
Deprecated (do not use)
virtual int	getRule (int order)
virtual MoFEMErrorCode	setGaussPts (int order)

Protected Attributes
const std::array< boost::shared_ptr< EntitiesFieldData >, LASTSPACE >	dataOnElement
	Entity data on element entity rows fields.
const std::array< boost::shared_ptr< EntitiesFieldData >, LASTSPACE >	derivedDataOnElement
	Entity data on element entity columns fields.
EntitiesFieldData &	dataNoField
EntitiesFieldData &	dataH1
EntitiesFieldData &	dataHcurl
EntitiesFieldData &	dataHdiv
EntitiesFieldData &	dataL2
boost::ptr_deque< UserDataOperator >	opPtrVector
	Vector of finite element users data operators.
EntityType	lastEvaluatedElementEntityType
	Last evaluated type of element entity.
MatrixDouble	coordsAtGaussPts
	coordinated at gauss points
double	elementMeasure

Private Member Functions
MoFEMErrorCode	setSideFEPtr (const ForcesAndSourcesCore *side_fe_ptr)
	Set the pointer to face element on the side.
MoFEMErrorCode	setRefineFEPtr (const ForcesAndSourcesCore *refine_fe_ptr)
	Set the pointer to face element refined.

Private Attributes
boost::shared_ptr< BaseFunction >	elementPolynomialBasePtr
	Pointer to entity polynomial base.
boost::shared_ptr< BaseFunction >	userPolynomialBasePtr
	Pointer to user polynomial base.
ForcesAndSourcesCore *	sidePtrFE
	Element to integrate on the sides.
ForcesAndSourcesCore *	refinePtrFE
	Element to integrate parent or child.

Friends
class	UserDataOperator
class	VolumeElementForcesAndSourcesCoreOnSide
class	FaceElementForcesAndSourcesCoreOnSide
class	FaceElementForcesAndSourcesCoreOnChildParent
class	EdgeElementForcesAndSourcesCoreOnChildParent
class	VolumeElementForcesAndSourcesCoreOnContactPrismSide
template<int DIM>
struct	OpCopyGeomDataToE
template<typename E >
struct	OpBrokenLoopSide

Additional Inherited Members
Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode	getLibVersion (Version &version)
	Get library version.
static MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version)
	Get database major version.
static MoFEMErrorCode	setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
	Get database major version.
static MoFEMErrorCode	getInterfaceVersion (Version &version)
	Get database major version.
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	CtxSetDX = PetscData::Switches(CTX_SET_DX)
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 EntitiesFieldData

Examples

EshelbianPlasticity.cpp, dynamic_first_order_con_law.cpp, hanging_node_approx.cpp, hello_world.cpp, prism_elements_from_surface.cpp, prism_polynomial_approximation.cpp, quad_polynomial_approximation.cpp, and simple_interface.cpp.

Definition at line 22 of file ForcesAndSourcesCore.hpp.

Member Typedef Documentation

GaussHookFun

boost::function<MoFEMErrorCode(ForcesAndSourcesCore *fe_raw_ptr, int order_row, int order_col, int order_data)> MoFEM::ForcesAndSourcesCore::GaussHookFun

Definition at line 33 of file ForcesAndSourcesCore.hpp.

RuleHookFun

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

Definition at line 28 of file ForcesAndSourcesCore.hpp.

Constructor & Destructor Documentation

ForcesAndSourcesCore()

MoFEM::ForcesAndSourcesCore::ForcesAndSourcesCore

(

Interface &

m_field

)

Definition at line 40 of file ForcesAndSourcesCore.cpp.

    :
 
      mField(m_field), getRuleHook(0), setRuleHook(0),
      dataOnElement{
 
          boost::make_shared<EntitiesFieldData>(MBENTITYSET), // NOSPACE,
          boost::make_shared<EntitiesFieldData>(MBENTITYSET), // NOFIELD
          boost::make_shared<EntitiesFieldData>(MBENTITYSET), // H1
          boost::make_shared<EntitiesFieldData>(MBENTITYSET), // HCURL
          boost::make_shared<EntitiesFieldData>(MBENTITYSET), // HDIV
          boost::make_shared<EntitiesFieldData>(MBENTITYSET)  // L2
 
      },
      derivedDataOnElement{
 
          nullptr,
          boost::make_shared<DerivedEntitiesFieldData>(
              dataOnElement[NOFIELD]), // NOFIELD
          boost::make_shared<DerivedEntitiesFieldData>(dataOnElement[H1]), // H1
          boost::make_shared<DerivedEntitiesFieldData>(
              dataOnElement[HCURL]), // HCURL
          boost::make_shared<DerivedEntitiesFieldData>(
              dataOnElement[HDIV]), // HDIV
          boost::make_shared<DerivedEntitiesFieldData>(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),
      refinePtrFE(nullptr) {
 
  dataOnElement[NOSPACE]->dataOnEntities[MBENTITYSET].push_back(
      new EntitiesFieldData::EntData());
 
  dataOnElement[NOFIELD]->dataOnEntities[MBENTITYSET].push_back(
      new EntitiesFieldData::EntData());
  derivedDataOnElement[NOFIELD]->dataOnEntities[MBENTITYSET].push_back(
      new EntitiesFieldData::EntData());
}

Member Function Documentation

calBernsteinBezierBaseFunctionsOnElement()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::calBernsteinBezierBaseFunctionsOnElement ( )

protected

Calculate Bernstein-Bezier base.

Returns

MoFEMErrorCode

Definition at line 1131 of file ForcesAndSourcesCore.cpp.

                                                               {
  MoFEMFunctionBegin;
 
  const auto ele_type = numeredEntFiniteElementPtr->getEntType();
 
  auto get_nodal_base_data = [&](EntitiesFieldData &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();
            const int num_nodes = getNumberOfNodes();
            bb_node_order.resize(num_nodes, false);
            bb_node_order.clear();
 
            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 = [&](EntitiesFieldData &data, auto field_ptr,
                                  const EntityType type_lo,
                                  const EntityType type_hi) {
    MoFEMFunctionBegin;
    for (EntityType t = MBEDGE; t != MBPOLYHEDRON; ++t) {
      for (auto &dat : data.dataOnEntities[t]) {
        dat.getOrder() = 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]) {
              if (const auto side = e->getSideNumberPtr()->side_number;
                  side >= 0) {
                const EntityType type = e->getEntType();
                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.getOrder() =
                    dat.getOrder() > ent_order ? dat.getOrder() : 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.getOrder() = dat.getOrder();
        }
      }
    }
    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();
          }
        }
      }
    }
  }
 
  auto check_space = [&](const auto space) {
    switch (space) {
    case H1:
      for (auto t = MBVERTEX; t <= ele_type; ++t) {
        if (dataOnElement[H1]->spacesOnEntities[t].test(H1))
          return true;
      }
      return false;
    case HCURL:
      for (auto t = MBEDGE; t <= ele_type; ++t) {
        if (dataOnElement[HCURL]->spacesOnEntities[t].test(HCURL))
          return true;
      }
      return false;
    case HDIV:
      for (auto t = MBTRI; t <= ele_type; ++t) {
        if (dataOnElement[HDIV]->spacesOnEntities[t].test(HDIV))
          return true;
      }
      return false;
    case L2:
      return dataOnElement[L2]->spacesOnEntities[ele_type].test(L2);
      break;
    default:
      THROW_MESSAGE("Not implemented");
    }
  };
 
  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,
                                      ele_type);
          if (check_space(space)) {
#ifndef NDEBUG
            if (ent_data_ptr->getContinuity() != CONTINUOUS)
              SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                      "Broken space not implemented");
#endif // NDEBUG
            CHKERR getElementPolynomialBase()
                -> getValue(gaussPts,
                            boost::make_shared<EntPolynomialBaseCtx>(
                                *dataOnElement[space], field_name,
                                static_cast<FieldSpace>(space), CONTINUOUS,
                                AINSWORTH_BERNSTEIN_BEZIER_BASE, NOBASE));
            fields_list.insert(field_name);
          }
        }
      }
    }
  }
 
  MoFEMFunctionReturn(0);
};

calHierarchicalBaseFunctionsOnElement() [1/2]

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::calHierarchicalBaseFunctionsOnElement ( )

protected

Calculate base functions.

Returns

Error code

Use the some node base. Node base is usually used for construction other bases.

Definition at line 1111 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);
    dataOnElement[space]->dataOnEntities[MBVERTEX][0].getDiffNSharedPtr(
        NOBASE) =
        dataOnElement[H1]->dataOnEntities[MBVERTEX][0].getDiffNSharedPtr(
            NOBASE);
  }
  for (int b = AINSWORTH_LEGENDRE_BASE; b != LASTBASE; b++) {
    CHKERR calHierarchicalBaseFunctionsOnElement(
        static_cast<FieldApproximationBase>(b));
  }
  MoFEMFunctionReturn(0);
}

calHierarchicalBaseFunctionsOnElement() [2/2]

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

protected

Calculate base functions.

Returns

Error code

Definition at line 1048 of file ForcesAndSourcesCore.cpp.

                                    {
  MoFEMFunctionBegin;
  if (dataOnElement[H1]->bAse.test(b)) {
 
    switch (static_cast<FieldApproximationBase>(b)) {
    case NOBASE:
    case AINSWORTH_BERNSTEIN_BEZIER_BASE: {
      // BERNSTEIN_BEZIER_BASE is not hierarchical base
      MoFEMFunctionReturnHot(0);
    }
    default:
      break;
    }
 
    auto get_elem_base = [&](auto base) {
      if (b != USER_BASE) {
        if (!getElementPolynomialBase())
          CHK_THROW_MESSAGE(
              MOFEM_DATA_INCONSISTENCY,
              "Functions generating approximation base not defined");
        return getElementPolynomialBase();
      } else {
        if (!getUserPolynomialBase())
          CHK_THROW_MESSAGE(
              MOFEM_DATA_INCONSISTENCY,
              "Functions generating user approximation base not defined");
        return getUserPolynomialBase();
      }
    };
 
    auto get_ctx = [&](auto space, auto base, auto continuity) {
      return boost::make_shared<EntPolynomialBaseCtx>(
          *dataOnElement[space], static_cast<FieldSpace>(space), continuity,
          static_cast<FieldApproximationBase>(base), NOBASE);
    };
 
    auto get_value = [&](auto elem_base, auto &gaussPts, auto &&ctx) {
      return elem_base->getValue(gaussPts, ctx);
    };
 
    for (int space = H1; space != LASTSPACE; ++space) {
 
#ifndef NDEBUG
      if (dataOnElement[H1]->basesOnSpaces[space].test(b) &&
          dataOnElement[H1]->brokenBasesOnSpaces[space].test(b)) {
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Discontinuous and continuous bases on the same space");
      }
#endif // NDEBUG
 
      if (dataOnElement[H1]->basesOnSpaces[space].test(b))
        CHKERR get_value(get_elem_base(b), gaussPts,
                         get_ctx(space, b, CONTINUOUS));
      else if (dataOnElement[H1]->brokenBasesOnSpaces[space].test(b))
        CHKERR get_value(get_elem_base(b), gaussPts,
                         get_ctx(space, b, DISCONTINUOUS));
    }
 
  }
  MoFEMFunctionReturn(0);
}

createDataOnElement()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::createDataOnElement ( EntityType type )

protected

Create a entity data on element object.

Returns

MoFEMErrorCode

Definition at line 1336 of file ForcesAndSourcesCore.cpp.

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

getBitRefLevelOnData()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getBitRefLevelOnData ( )

protected

Get bit ref level in entities, and set it to data

Definition at line 549 of file ForcesAndSourcesCore.cpp.

                                                          {
  MoFEMFunctionBegin;
 
  for (auto &data : dataOnElement) {
    if (data) {
      for (auto &dat : data->dataOnEntities) {
        for (auto &ent_dat : dat) {
          ent_dat.getEntDataBitRefLevel().clear();
        }
      }
    }
  }
 
  auto &field_ents = getDataFieldEnts();
  for (auto it : field_ents) {
    if (auto e = it.lock()) {
      const FieldSpace space = e->getSpace();
      if (space > NOFIELD) {
        const EntityType type = e->getEntType();
        const signed char side = e->getSideNumberPtr()->side_number;
        if (side >= 0) {
          if (auto &data = dataOnElement[space]) {
            if (type == MBVERTEX) {
              auto &dat = data->dataOnEntities[type][0];
              dat.getEntDataBitRefLevel().resize(getNumberOfNodes(), false);
              dat.getEntDataBitRefLevel()[side] = e->getBitRefLevel();
            } else {
              auto &dat = data->dataOnEntities[type][side];
              dat.getEntDataBitRefLevel().resize(1,
                                                 false); // one entity per sie
              dat.getEntDataBitRefLevel()[0] = e->getBitRefLevel();
            }
          }
        }
      }
    }
  }
 
  MoFEMFunctionReturn(0);
};

getColNodesIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getColNodesIndices ( EntitiesFieldData & data, const int bit_number ) const

protected

get col node indices from FENumeredDofEntity_multiIndex

Definition at line 328 of file ForcesAndSourcesCore.cpp.

                                                                     {
 
  struct Extractor {
    boost::weak_ptr<EntityCacheNumeredDofs>
    operator()(boost::shared_ptr<FieldEntity> &e) {
      return e->entityCacheColDofs;
    }
  };
 
  return getNodesIndices(bit_number, getColFieldEnts(),
                         data.dataOnEntities[MBVERTEX][0].getIndices(),
                         data.dataOnEntities[MBVERTEX][0].getLocalIndices(),
                         Extractor());
}

getDataOnElementBySpaceArray()

auto & MoFEM::ForcesAndSourcesCore::getDataOnElementBySpaceArray ( )

inline

Get data on entities and space.

Entities data are stored by space, by entity type, and entity side.

Returns

std::array<boost::shared_ptr<EntitiesFieldData>, LASTSPACE>

Definition at line 156 of file ForcesAndSourcesCore.hpp.

{ return dataOnElement; }

getDerivedDataOnElementBySpaceArray()

auto & MoFEM::ForcesAndSourcesCore::getDerivedDataOnElementBySpaceArray ( )

inline

Get derived data on entities and space.

Entities data are stored by space, by entity type, and entity side. Derived data is used to store data on columns, so it shares information about shape functions wih rows.

Returns

std::array<boost::shared_ptr<EntitiesFieldData>, LASTSPACE>

Definition at line 167 of file ForcesAndSourcesCore.hpp.

{ return derivedDataOnElement; }

getElementPolynomialBase()

auto & MoFEM::ForcesAndSourcesCore::getElementPolynomialBase ( )

inline

Get the Entity Polynomial Base object.

Returns

boost::shared_ptr<BaseFunction>&&

Definition at line 90 of file ForcesAndSourcesCore.hpp.

{ return elementPolynomialBasePtr; }

getEntData()

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

inline

Get the entity data.

Parameters

space
type
side

Returns

EntitiesFieldData::EntData&

Definition at line 144 of file ForcesAndSourcesCore.hpp.

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

getEntityColIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getEntityColIndices ( EntitiesFieldData & data, const int bit_number, const EntityType type_lo = MBVERTEX, const EntityType type_hi = MBPOLYHEDRON ) const

protected

Definition at line 427 of file ForcesAndSourcesCore.cpp.

                                    {
 
  struct Extractor {
    boost::weak_ptr<EntityCacheNumeredDofs>
    operator()(boost::shared_ptr<FieldEntity> &e) {
      return e->entityCacheColDofs;
    }
  };
 
  return getEntityIndices(data, bit_number, getColFieldEnts(), type_lo, type_hi,
                          Extractor());
}

getEntityDataOrder() [1/2]

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

protected

Get the entity data order.

Parameters

type
space
data

Returns

MoFEMErrorCode

Definition at line 139 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].getOrder() = 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;
              if (const auto side_number = side->side_number;
                  side_number >= 0) {
                ApproximationOrder ent_order = e.getMaxOrder();
                auto &dat = data[side_number];
                dat.getOrder() =
                    dat.getOrder() > ent_order ? dat.getOrder() : 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].getOrder() = data[side_number].getOrder();
        }
      }
    }
    MoFEMFunctionReturnHot(0);
  };
 
  CHKERR set_order();
  CHKERR set_order_on_brother();
 
  MoFEMFunctionReturn(0);
}

getEntityDataOrder() [2/2]

template<EntityType type>

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

inlineprotected

Get the entity data order for given space.

Template Parameters

type

Parameters

data
space

Returns

MoFEMErrorCode

Definition at line 213 of file ForcesAndSourcesCore.hpp.

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

getEntityFieldData()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getEntityFieldData ( EntitiesFieldData & data, const int bit_number, const EntityType type_lo = MBVERTEX, const EntityType type_hi = MBPOLYHEDRON ) const

protected

Definition at line 719 of file ForcesAndSourcesCore.cpp.

                                    {
  MoFEMFunctionBegin;
  for (EntityType t = type_lo; t != type_hi; ++t) {
    for (auto &dat : data.dataOnEntities[t]) {
      dat.getOrder() = 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();
  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()) {
          auto side_ptr = e->getSideNumberPtr();
          if (const auto side = side_ptr->side_number; side >= 0) {
            const EntityType type = e->getEntType();
            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.getOrder() =
                dat.getOrder() > ent_order ? dat.getOrder() : 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.getOrder() = dat.getOrder();
          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 ( EntitiesFieldData & data, const int bit_number, FieldEntity_vector_view & ents_field, const EntityType type_lo, const EntityType type_hi, EXTRACTOR && extractor ) const

protected

Definition at line 345 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);
    }
  }
 
  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();
          if (const auto side = side_ptr->side_number; side >= 0) {
            const auto nb_dofs_on_ent = e->getNbDofsOnEnt();
            const auto 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 ( EntitiesFieldData & data, const int bit_number, const EntityType type_lo = MBVERTEX, const EntityType type_hi = MBPOLYHEDRON ) const

protected

Definition at line 412 of file ForcesAndSourcesCore.cpp.

                                    {
 
  struct Extractor {
    boost::weak_ptr<EntityCacheNumeredDofs>
    operator()(boost::shared_ptr<FieldEntity> &e) {
      return e->entityCacheRowDofs;
    }
  };
 
  return getEntityIndices(data, bit_number, getRowFieldEnts(), type_lo, type_hi,
                          Extractor());
}

getEntitySense() [1/2]

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

protected

get sense (orientation) of entity

Parameters

type	type of entity
data	entity data

Returns

error code

Definition at line 84 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) {
      if (const auto side_number = (*sit)->side_number; 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 ( EntitiesFieldData & data ) const

inlineprotected

Get the entity sense (orientation)

Template Parameters

type

Parameters

data

Returns

MoFEMErrorCode

Definition at line 200 of file ForcesAndSourcesCore.hpp.

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

getFaceNodes()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getFaceNodes ( EntitiesFieldData & data ) const

protected

Get nodes on faces.

Definition at line 918 of file ForcesAndSourcesCore.cpp.

                                                                {
  MoFEMFunctionBegin;
  auto &face_nodes = data.facesNodes;
  auto &face_nodes_order = data.facesNodesOrder;
  auto &side_table = const_cast<SideNumber_multiIndex &>(
      numeredEntFiniteElementPtr->getSideNumberTable());
  const auto ent = numeredEntFiniteElementPtr->getEnt();
  const auto type = numeredEntFiniteElementPtr->getEntType();
  const auto nb_faces = CN::NumSubEntities(type, 2);
  const EntityHandle *conn_ele;
  int num_nodes_ele;
  CHKERR mField.get_moab().get_connectivity(ent, conn_ele, num_nodes_ele, true);
  auto side_ptr_it = side_table.get<1>().lower_bound(
      boost::make_tuple(CN::TypeDimensionMap[2].first, 0));
  auto hi_side_ptr_it = side_table.get<1>().upper_bound(boost::make_tuple(
      CN::TypeDimensionMap[2].second, std::numeric_limits<signed char>::max()));
 
  for (; side_ptr_it != hi_side_ptr_it; ++side_ptr_it) {
    const auto side = (*side_ptr_it)->side_number;
    if (side < 0)
      continue;
    const auto sense = (*side_ptr_it)->sense;
    const auto offset = (*side_ptr_it)->offset;
 
    EntityType face_type;
    int nb_nodes_face;
    auto face_indices =
        CN::SubEntityVertexIndices(type, 2, side, face_type, nb_nodes_face);
    face_nodes.resize(nb_faces, nb_nodes_face);
    face_nodes_order.resize(nb_faces, nb_nodes_face);
 
    if (sense == 1)
      for (int n = 0; n != nb_nodes_face; ++n)
        face_nodes_order(side, n) = (n + offset) % nb_nodes_face;
    else
      for (int n = 0; n != nb_nodes_face; ++n)
        face_nodes_order(side, n) =
            (nb_nodes_face - (n - offset) % nb_nodes_face) % nb_nodes_face;
 
    for (int n = 0; n != nb_nodes_face; ++n)
      face_nodes(side, n) = face_indices[face_nodes_order(side, n)];
 
#ifndef NDEBUG
    const auto face_ent = (*side_ptr_it)->ent;
    auto check = [&]() {
      MoFEMFunctionBegin;
      const EntityHandle *conn_face;
      // int nb_nodes_face;
      CHKERR mField.get_moab().get_connectivity(face_ent, conn_face,
                                                nb_nodes_face, true);
      face_nodes.resize(nb_faces, nb_nodes_face);
      for (int nn = 0; nn != nb_nodes_face; ++nn) {
        if (face_nodes(side, nn) !=
            std::distance(
                conn_ele,
                std::find(conn_ele, &conn_ele[num_nodes_ele], conn_face[nn]))) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "Wrong face numeration");
        }
      }
      MoFEMFunctionReturn(0);
    };
    CHKERR check();
#endif
  }
 
  MoFEMFunctionReturn(0);
}

getMaxColOrder()

int MoFEM::ForcesAndSourcesCore::getMaxColOrder

(

)

const

Get max order of approximation for field in columns.

Definition at line 135 of file ForcesAndSourcesCore.cpp.

                                               {
  return getMaxOrder(getColFieldEnts());
}

getMaxDataOrder()

int MoFEM::ForcesAndSourcesCore::getMaxDataOrder

(

)

const

Get max order of approximation for data fields.

getMeasure 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 120 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 131 of file ForcesAndSourcesCore.cpp.

                                               {
  return getMaxOrder(getRowFieldEnts());
}

getNodesFieldData()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getNodesFieldData ( EntitiesFieldData & data, const int bit_number ) const

protected

Get data on nodes.

Parameters

data	Data structure
field_name	Field name

Returns

Error code

Definition at line 591 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<BitFieldId_mi_tag>().find(BitFEId().set(bit_number - 1));
    if (field_it != fieldsPtr->get<BitFieldId_mi_tag>().end()) {
 
#ifndef NDEBUG
      if ((*field_it)->getBitNumber() != bit_number)
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Wrong bit number");
#endif
      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()) {
              if (auto cache = e->entityCacheDataDofs.lock()) {
                if (cache->loHi[0] != cache->loHi[1]) {
                  nb_dofs += std::distance(cache->loHi[0], cache->loHi[1]);
                  break;
                }
              }
            }
          }
 
          if (nb_dofs) {
 
            const int num_nodes = getNumberOfNodes();
            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();
                // Some field entities on skeleton can have negative side
                // number
                if (const auto side_number = sn->side_number;
                    side_number >= 0) {
                  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 int bit_number, FieldEntity_vector_view & ents_field, VectorInt & nodes_indices, VectorInt & local_nodes_indices, EXTRACTOR && extractor ) const

protected

get node indices

Definition at line 219 of file ForcesAndSourcesCore.cpp.

                                 {
  MoFEMFunctionBegin;
 
  auto field_it = fieldsPtr->get<BitFieldId_mi_tag>().find(
      BitFieldId().set(bit_number - 1));
  if (field_it != fieldsPtr->get<BitFieldId_mi_tag>().end()) {
 
#ifndef NDEBUG
    if ((*field_it)->getBitNumber() != bit_number)
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Wrong bit number");
#endif
    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);
 
      const int num_nodes = getNumberOfNodes();
      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();
          if (const auto side_number = side_ptr->side_number;
              side_number >= 0) {
            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 ( EntitiesFieldData & data, const int bit_number ) const

protected

get col NoField indices

getNoFieldEntityFieldData()

template<typename EXTRACTOR >

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getNoFieldEntityFieldData ( EntitiesFieldData & data, const int bit_number, EXTRACTOR && extractor ) const

protected

Get field data on entities where no field is defined.

This is not standards, since op_data, dataOnElement[NOFIELD], has to be set for rows and columns for each NOFIELD, also size of sides is not determined.

Parameters

data

param bit_number

Returns

MoFEMErrorCode

Definition at line 806 of file ForcesAndSourcesCore.cpp.

                                                                             {
  MoFEMFunctionBegin;
 
  // resize data on entities
  std::array<FieldEntity_vector_view, MBMAXTYPE> field_ents_by_type;
  for (auto it : getDataFieldEnts())
    if (auto e = it.lock())
      if (e->getBitNumber() == bit_number) {
        field_ents_by_type[e->getEntType()].emplace_back(e);
      }
 
  auto set_entity_data = [&](auto &data_on_element) {
    MoFEMFunctionBeginHot;
 
    // resize data containers
    for (EntityType t = MBVERTEX; t != MBMAXTYPE; ++t) {
      auto &data = data_on_element.dataOnEntities[t];
      data.resize(field_ents_by_type[t].size());
    }
 
    // reset data
    for (EntityType t = MBVERTEX; t != MBMAXTYPE; ++t) {
      auto &data = data_on_element.dataOnEntities[t];
      for (auto &d : data) {
        d.getEntDataBitRefLevel().clear();
        d.getOrder() = 0;
        d.getBase() = NOBASE;
        d.getSpace() = NOSPACE;
        d.getFieldData().resize(0, false);
        d.getFieldDofs().resize(0, false);
        d.getFieldEntities().resize(0, false);
        d.getIndices().resize(0, false);
        d.getLocalIndices().resize(0, false);
      }
    }
 
    // set bit ref level on entities
    for (EntityType t = MBVERTEX; t != MBMAXTYPE; ++t) {
      int side = 0;
      for (auto it : field_ents_by_type[t]) {
        if (auto e = it.lock()) {
          auto &data = data_on_element.dataOnEntities[t][side];
          data.getEntDataBitRefLevel().resize(1, false);
          data.getEntDataBitRefLevel()[0] = e->getBitRefLevel();
          ++side;
        }
      }
    }
 
    // set field data on entities
    for (EntityType t = MBVERTEX; t != MBMAXTYPE; ++t) {
      int side = 0;
      for (auto it : field_ents_by_type[t]) {
        if (auto e = it.lock()) {
          auto &data = data_on_element.dataOnEntities[t][side];
          data.getBase() = e->getApproxBase();
          data.getSpace() = e->getSpace();
          data.getFieldData() = e->getEntFieldData();
          data.getFieldEntities().resize(1, false);
          data.getFieldEntities()[0] = e.get();
          auto &ent_field_dofs = data.getFieldDofs();
          ent_field_dofs.resize(data.getFieldData().size(), false);
          std::fill(ent_field_dofs.begin(), ent_field_dofs.end(), nullptr);
          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());
            }
          }
          ++side;
        }
      }
    }
 
    // set indices on entities
    for (EntityType t = MBVERTEX; t != MBMAXTYPE; ++t) {
      int side = 0;
      for (auto it : field_ents_by_type[t]) {
        if (auto e = it.lock()) {
          auto &data = data_on_element.dataOnEntities[t][side];
          auto &indices = data.getIndices();
          auto &local_indices = data.getLocalIndices();
          indices.resize(data.getFieldData().size(), false);
          local_indices.resize(data.getFieldData().size(), false);
          std::fill(indices.begin(), indices.end(), -1);
          std::fill(local_indices.begin(), local_indices.end(), -1);
 
          if (auto cache = extractor(e).lock()) {
            for (auto dit = cache->loHi[0]; dit != cache->loHi[1]; ++dit) {
              indices[(*dit)->getEntDofIdx()] = (*dit)->getPetscGlobalDofIdx();
              local_indices[(*dit)->getEntDofIdx()] =
                  (*dit)->getPetscLocalDofIdx();
            }
          }
 
          ++side;
        }
      }
    }
    MoFEMFunctionReturnHot(0);
  };
 
  CHKERR set_entity_data(data);
 
  MoFEMFunctionReturn(0);
}

getNoFieldRowIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getNoFieldRowIndices ( EntitiesFieldData & data, const int bit_number ) const

protected

get col NoField indices

getOpPtrVector()

boost::ptr_deque< UserDataOperator > & MoFEM::ForcesAndSourcesCore::getOpPtrVector ( )

inline

Use to push back operator for row operator.

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

Examples

MagneticElement.hpp, continuity_check_on_contact_prism_side_ele.cpp, continuity_check_on_skeleton_3d.cpp, continuity_check_on_skeleton_with_simple_2d_for_h1.cpp, continuity_check_on_skeleton_with_simple_2d_for_hcurl.cpp, continuity_check_on_skeleton_with_simple_2d_for_hdiv.cpp, forces_and_sources_testing_flat_prism_element.cpp, lorentz_force.cpp, and nonlinear_dynamics.cpp.

Definition at line 83 of file ForcesAndSourcesCore.hpp.

{ return opPtrVector; }

getProblemNodesColIndices()

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

protected

Definition at line 533 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 444 of file ForcesAndSourcesCore.cpp.

                                    {
  MoFEMFunctionBeginHot;
 
  const Field *field_struture = mField.get_field_structure(field_name);
  if (field_struture->getSpace() == H1) {
 
    const int num_nodes = getNumberOfNodes();
    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 >= 0) {
        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 519 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 540 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 485 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 >= 0) {
 
      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 526 of file ForcesAndSourcesCore.cpp.

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

getRowNodesIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getRowNodesIndices ( EntitiesFieldData & data, const int bit_number ) const

protected

get row node indices from FENumeredDofEntity_multiIndex

Definition at line 311 of file ForcesAndSourcesCore.cpp.

                                                                     {
 
  struct Extractor {
    boost::weak_ptr<EntityCacheNumeredDofs>
    operator()(boost::shared_ptr<FieldEntity> &e) {
      return e->entityCacheRowDofs;
    }
  };
 
  return getNodesIndices(bit_number, getRowFieldEnts(),
                         data.dataOnEntities[MBVERTEX][0].getIndices(),
                         data.dataOnEntities[MBVERTEX][0].getLocalIndices(),
                         Extractor());
}

getRule() [1/2]

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

protectedvirtual

Deprecated

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

Reimplemented in AnalyticalDirichletBC::ApproxField::MyTriFE, BodyForceConstantField::MyVolumeFE, BoneRemodeling::DensityMapFe, BoneRemodeling::Remodeling::Fe, CohesiveElement::CohesiveInterfaceElement::MyPrism, ConvectiveMassElement::MyVolumeFE, EdgeForce::MyFE, EdgeSlidingConstrains::MyEdgeFE, EdgeSlidingConstrains::MyEdgeFE, FluidPressure::MyTriangleFE, KelvinVoigtDamper::DamperFE, MagneticElement::TriFE, MagneticElement::VolumeFE, MixTransport::MixTransportElement::MyTriFE, MixTransport::MixTransportElement::MyVolumeFE, MoFEM::EdgeElementForcesAndSourcesCoreOnChildParent, MoFEM::FaceElementForcesAndSourcesCoreOnChildParent, MoFEM::FaceElementForcesAndSourcesCoreOnSide, MoFEM::PostProcBrokenMeshInMoabBase< EdgeElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< FaceElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< VolumeElementForcesAndSourcesCore >, MoFEM::VolumeElementForcesAndSourcesCoreOnContactPrismSide, MoFEM::VolumeElementForcesAndSourcesCoreOnSide, NeumannForcesSurface::MyTriangleFE, NeumannForcesSurfaceComplexForLazy::MyTriangleSpatialFE, NonlinearElasticElement::MyVolumeFE, PostProcEdgeOnRefinedMesh, PostProcFaceOnRefinedMesh, PostProcTemplateVolumeOnRefinedMesh< MoFEM::VolumeElementForcesAndSourcesCore >, SurfaceSlidingConstrains::MyTriangleFE, SurfaceSlidingConstrains::MyTriangleFE, ThermalElement::MyTriFE, ThermalElement::MyVolumeFE, and ThermalStressElement::MyVolumeFE.

Definition at line 2115 of file ForcesAndSourcesCore.cpp.

{ return 2 * order; }

getRule() [2/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, QuadFE, and TriFE.

Definition at line 2103 of file ForcesAndSourcesCore.cpp.

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

getSpacesAndBaseOnEntities()

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

protected

Get field approximation space and base on entities.

Definition at line 989 of file ForcesAndSourcesCore.cpp.

                                   {
  MoFEMFunctionBeginHot;
 
  if (nInTheLoop == 0) {
    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();
      data.brokenBasesOnSpaces[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 FieldContinuity continuity = ptr->getContinuity();
          const FieldApproximationBase approx = ptr->getApproxBase();
 
          // set data
          switch (continuity) {
          case CONTINUOUS:
            data.basesOnSpaces[space].set(approx);
            break;
          case DISCONTINUOUS:
            data.brokenBasesOnSpaces[space].set(approx);
            break;
          default:
            SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                    "Continuity not defined");
          }
 
          data.bAse.set(approx);
          data.spacesOnEntities[type].set(space);
          data.basesOnEntities[type].set(approx);
        }
      }
    }
  else
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "data fields ents not allocated on element");
 
  for (auto space = 0; space != LASTSPACE; ++space)
    if ((data.brokenBasesOnSpaces[space] & data.basesOnSpaces[space]).any())
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Discontinuous and continuous bases on the same space");
 
  MoFEMFunctionReturnHot(0);
}

getUserPolynomialBase()

auto & MoFEM::ForcesAndSourcesCore::getUserPolynomialBase ( )

inline

Get the User Polynomial Base object.

Returns

boost::shared_ptr<BaseFunction>&

Definition at line 97 of file ForcesAndSourcesCore.hpp.

{ return userPolynomialBasePtr; }

loopOverOperators()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::loopOverOperators ( )

protected

Iterate user data operators.

Returns

MoFEMErrorCode

Definition at line 1389 of file ForcesAndSourcesCore.cpp.

                                                       {
  MoFEMFunctionBegin;
 
  using UDO = UserDataOperator;
 
  std::array<std::string, 2> field_name;
  std::array<const Field *, 3> field_struture;
  std::array<int, 2>
      field_id; // note the this is field bit number (nor field bit)
  std::array<FieldSpace, 2> space;
  std::array<FieldApproximationBase, 2> base;
 
  constexpr std::array<UDO::OpType, 2> types = {UDO::OPROW, UDO::OPCOL};
  std::array<int, 2> last_eval_field_id = {0, 0};
 
  std::array<boost::shared_ptr<EntitiesFieldData>, 2> op_data;
 
  auto swap_bases = [&](auto &op) {
    MoFEMFunctionBeginHot;
    for (size_t ss = 0; ss != 2; ++ss) {
      if (op.getOpType() & types[ss] || op.getOpType() & UDO::OPROWCOL) {
        switch (base[ss]) {
        case AINSWORTH_BERNSTEIN_BEZIER_BASE:
          CHKERR op_data[ss]->baseSwap(field_name[ss],
                                       AINSWORTH_BERNSTEIN_BEZIER_BASE);
        default:
          break;
        }
      }
    }
 
    MoFEMFunctionReturnHot(0);
  };
 
  const EntityType type = numeredEntFiniteElementPtr->getEntType();
 
  // evaluate entity data only, no field specific data provided or known
  auto evaluate_op_space = [&](auto &op) {
    MoFEMFunctionBeginHot;
 
    // reseat all data which all field dependent
    dataOnElement[op.sPace]->resetFieldDependentData();
    std::fill(last_eval_field_id.begin(), last_eval_field_id.end(), 0);
 
    switch (op.sPace) {
    case NOSPACE:
      LOG_OP(op);
      try {
        CHKERR op.doWork(
            0, MBENTITYSET,
            dataOnElement[NOSPACE]->dataOnEntities[MBENTITYSET][0]);
      }
      CATCH_OP_ERRORS(op);
      break;
    case NOFIELD:
    case H1:
    case HCURL:
    case HDIV:
    case L2:
      LOG_OP(op);
      try {
 
        for (EntityType t = MBVERTEX; t != MBMAXTYPE; ++t) {
          for (auto &e : dataOnElement[op.sPace]->dataOnEntities[t]) {
            e.getSpace() = op.sPace;
          }
        }
 
        CHKERR op.opRhs(*dataOnElement[op.sPace], false);
      }
      CATCH_OP_ERRORS(op);
      break;
    default:
      SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
              "Not implemented for this space <%s>", FieldSpaceNames[op.sPace]);
    }
 
    MoFEMFunctionReturnHot(0);
  };
 
  // set entity data
  auto set_op_entities_data = [&](auto ss, auto &op) {
    MoFEMFunctionBeginHot;
 
#ifndef NDEBUG
    if ((op.getNumeredEntFiniteElementPtr()->getBitFieldIdData() &
         mField.get_field_id(field_name[ss]))
            .none()) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "no data field < %s > on finite element < %s >",
               field_name[ss].c_str(), getFEName().c_str());
    }
#endif
 
    op_data[ss] =
        !ss ? dataOnElement[space[ss]] : derivedDataOnElement[space[ss]];
 
    for (auto &data : op_data[ss]->dataOnEntities[MBENTITYSET]) {
      CHKERR data.resetFieldDependentData();
    }
 
    auto get_data_for_nodes = [&]() {
      MoFEMFunctionBegin;
      if (!ss)
        CHKERR getRowNodesIndices(*op_data[ss], field_id[ss]);
      else
        CHKERR getColNodesIndices(*op_data[ss], field_id[ss]);
      CHKERR getNodesFieldData(*op_data[ss], field_id[ss]);
      MoFEMFunctionReturn(0);
    };
 
    // get data on entities but not nodes
    auto get_data_for_entities = [&]() {
      MoFEMFunctionBegin;
      CHKERR getEntityFieldData(*op_data[ss], field_id[ss], MBEDGE);
      if (!ss)
        CHKERR getEntityRowIndices(*op_data[ss], field_id[ss], MBEDGE);
      else
        CHKERR getEntityColIndices(*op_data[ss], field_id[ss], MBEDGE);
      MoFEMFunctionReturn(0);
    };
 
    auto get_data_for_meshset = [&]() {
      MoFEMFunctionBegin;
 
      if (!ss) {
 
        struct Extractor {
          boost::weak_ptr<EntityCacheNumeredDofs>
          operator()(boost::shared_ptr<FieldEntity> &e) {
            return e->entityCacheRowDofs;
          }
        };
 
        CHKERR getNoFieldEntityFieldData(*op_data[ss], field_id[ss],
                                         Extractor());
      } else {
 
        struct Extractor {
          boost::weak_ptr<EntityCacheNumeredDofs>
          operator()(boost::shared_ptr<FieldEntity> &e) {
            return e->entityCacheColDofs;
          }
        };
 
        CHKERR getNoFieldEntityFieldData(*op_data[ss], field_id[ss],
                                         Extractor());
      }
 
      MoFEMFunctionReturn(0);
    };
 
    switch (space[ss]) {
    case H1:
      CHKERR get_data_for_nodes();
    case HCURL:
    case HDIV:
      CHKERR get_data_for_entities();
      break;
    case L2:
      switch (type) {
      case MBVERTEX:
        CHKERR get_data_for_nodes();
        break;
      default:
        CHKERR get_data_for_entities();
      }
      break;
    case NOFIELD:
      CHKERR get_data_for_meshset();
      break;
    default:
      SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
               "not implemented for this space < %s >",
               FieldSpaceNames[space[ss]]);
    }
    MoFEMFunctionReturnHot(0);
  };
 
  // evaluate operators with field data
  auto evaluate_op_for_fields = [&](auto &op) {
    MoFEMFunctionBeginHot;
 
    if (op.getOpType() & UDO::OPROW) {
      LOG_OP(op);
      try {
        CHKERR op.opRhs(*op_data[0], false);
      }
      CATCH_OP_ERRORS(op);
    }
 
    if (op.getOpType() & UDO::OPCOL) {
      LOG_OP(op);
      try {
        CHKERR op.opRhs(*op_data[1], false);
      }
      CATCH_OP_ERRORS(op);
    }
 
    if (op.getOpType() & UDO::OPROWCOL) {
      LOG_OP(op);
      try {
        CHKERR op.opLhs(*op_data[0], *op_data[1]);
      }
      CATCH_OP_ERRORS(op);
    }
    MoFEMFunctionReturnHot(0);
  };
 
  // collect bit ref level on all entities, fields and spaces
  CHKERR getBitRefLevelOnData();
 
  auto oit = opPtrVector.begin();
  auto hi_oit = opPtrVector.end();
 
  // iterate over all operators on element
  for (; oit != hi_oit; oit++) {
 
    LOG_OP(*oit);
    try {
 
      CHKERR oit->setPtrFE(this);
 
      if ((oit->opType & UDO::OPSPACE) == UDO::OPSPACE) {
 
        // run operator for space but not specific field, thus inices of fild
        // values are not resolved, howvere bases for given space are accessible
        CHKERR evaluate_op_space(*oit);
 
      } else if (
 
          (oit->opType & (UDO::OPROW | UDO::OPCOL | UDO::OPROWCOL)) ==
          oit->opType
 
      ) {
 
        field_name[0] = oit->rowFieldName;
        field_name[1] = oit->colFieldName;
 
        for (size_t ss = 0; ss != 2; ss++) {
 
#ifndef NDEBUG
          if (field_name[ss].empty()) {
            SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                    "Not set Field name in operator %ld (0-row, 1-column) in "
                    "operator %s",
                    ss,
                    (boost::typeindex::type_id_runtime(*oit).pretty_name())
                        .c_str());
          }
#endif
 
          field_struture[ss] = mField.get_field_structure(field_name[ss]);
          field_id[ss] = field_struture[ss]->getBitNumber();
          space[ss] = field_struture[ss]->getSpace();
          base[ss] = field_struture[ss]->getApproxBase();
        }
 
        // not that if field name do not change between operators, entity field
        // data are nor rebuild
        for (size_t ss = 0; ss != 2; ss++) {
 
          if (oit->getOpType() & types[ss] ||
              oit->getOpType() & UDO::OPROWCOL) {
            if (last_eval_field_id[ss] != field_id[ss]) {
              CHKERR set_op_entities_data(ss, *oit);
              last_eval_field_id[ss] = field_id[ss];
            }
          }
        }
 
        CHKERR swap_bases(*oit);
 
        // run operator for given field or row, column or both
        CHKERR evaluate_op_for_fields(*oit);
 
        CHKERR swap_bases(*oit);
 
      } else {
 
        for (int i = 0; i != 5; ++i)
          if (oit->opType & (1 << i))
            MOFEM_LOG("SELF", Sev::error) << UDO::OpTypeNames[i];
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Impossible operator type");
      }
    }
    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::ContactPrismElementForcesAndSourcesCore, MoFEM::EdgeElementForcesAndSourcesCore, MoFEM::FaceElementForcesAndSourcesCore, MoFEM::FatPrismElementForcesAndSourcesCore, MoFEM::FlatPrismElementForcesAndSourcesCore, MoFEM::PipelineManager::MeshsetFE, MoFEM::VertexElementForcesAndSourcesCore, MoFEM::VolumeElementForcesAndSourcesCore, MoFEM::VolumeElementForcesAndSourcesCoreOnSide, and NeumannForcesSurfaceComplexForLazy::MyTriangleSpatialFE.

Definition at line 2149 of file ForcesAndSourcesCore.cpp.

                                                {
  MoFEMFunctionBeginHot;
  if (operatorHook) {
    ierr = operatorHook();
    CHKERRG(ierr);
  } else {
#ifndef NDEBUG
    MOFEM_LOG("SELF", Sev::warning)
        << "No method operator() overloaded on element entity on finite "
           "element <"
        << boost::typeindex::type_id_runtime(*this).pretty_name() << ">";
#endif
  }
  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 ConvectiveMassElement::MyVolumeFE, KelvinVoigtDamper::DamperFE, MoFEM::PipelineManager::MeshsetFE, MoFEM::PostProcBrokenMeshInMoabBase< EdgeElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< FaceElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< VolumeElementForcesAndSourcesCore >, NonlinearElasticElement::MyVolumeFE, PostProcEdgeOnRefinedMesh, PostProcFaceOnRefinedMesh, PostProcFatPrismOnRefinedMesh, PostProcTemplateVolumeOnRefinedMesh< MoFEM::VolumeElementForcesAndSourcesCore >, Smoother::MyVolumeFE, and Smoother::MyVolumeFE.

Definition at line 2164 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 ConvectiveMassElement::MyVolumeFE, EdgeSlidingConstrains::MyEdgeFE, EdgeSlidingConstrains::MyEdgeFE, FluidPressure::MyTriangleFE, KelvinVoigtDamper::DamperFE, MoFEM::PipelineManager::MeshsetFE, MoFEM::PostProcBrokenMeshInMoabBase< EdgeElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< FaceElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< VolumeElementForcesAndSourcesCore >, NeumannForcesSurfaceComplexForLazy::MyTriangleSpatialFE, NonlinearElasticElement::MyVolumeFE, PostProcEdgeOnRefinedMesh, PostProcFaceOnRefinedMesh, PostProcFatPrismOnRefinedMesh, PostProcTemplateVolumeOnRefinedMesh< MoFEM::VolumeElementForcesAndSourcesCore >, Smoother::MyVolumeFE, Smoother::MyVolumeFE, SurfaceSlidingConstrains::MyTriangleFE, and SurfaceSlidingConstrains::MyTriangleFE.

Definition at line 2141 of file ForcesAndSourcesCore.cpp.

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

setGaussPts() [1/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 MoFEM::EdgeElementForcesAndSourcesCoreOnChildParent, MoFEM::FaceElementForcesAndSourcesCoreOnChildParent, MoFEM::FaceElementForcesAndSourcesCoreOnSide, MoFEM::PostProcBrokenMeshInMoabBase< EdgeElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< FaceElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< VolumeElementForcesAndSourcesCore >, MoFEM::VolumeElementForcesAndSourcesCoreOnContactPrismSide, MoFEM::VolumeElementForcesAndSourcesCoreOnSide, PostProcEdgeOnRefinedMesh, PostProcFaceOnRefinedMesh, and PostProcTemplateVolumeOnRefinedMesh< MoFEM::VolumeElementForcesAndSourcesCore >.

Definition at line 2119 of file ForcesAndSourcesCore.cpp.

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

setGaussPts() [2/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, QuadFE, and TriFE.

Definition at line 2109 of file ForcesAndSourcesCore.cpp.

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

setRefineFEPtr()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::setRefineFEPtr ( const ForcesAndSourcesCore * refine_fe_ptr )

private

Set the pointer to face element refined.

Parameters

refine_fe_ptr

Returns

MoFEMErrorCode

Definition at line 1725 of file ForcesAndSourcesCore.cpp.

                                               {
  MoFEMFunctionBeginHot;
  refinePtrFE = const_cast<ForcesAndSourcesCore *>(refine_fe_ptr);
  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 1719 of file ForcesAndSourcesCore.cpp.

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

Friends And Related Symbol Documentation

EdgeElementForcesAndSourcesCoreOnChildParent

friend class EdgeElementForcesAndSourcesCoreOnChildParent

friend

Definition at line 534 of file ForcesAndSourcesCore.hpp.

FaceElementForcesAndSourcesCoreOnChildParent

friend class FaceElementForcesAndSourcesCoreOnChildParent

friend

Definition at line 533 of file ForcesAndSourcesCore.hpp.

FaceElementForcesAndSourcesCoreOnSide

friend class FaceElementForcesAndSourcesCoreOnSide

friend

Definition at line 532 of file ForcesAndSourcesCore.hpp.

OpBrokenLoopSide

template<typename E >

friend struct OpBrokenLoopSide

friend

Definition at line 538 of file ForcesAndSourcesCore.hpp.

OpCopyGeomDataToE

template<int DIM>

friend struct OpCopyGeomDataToE

friend

Definition at line 537 of file ForcesAndSourcesCore.hpp.

UserDataOperator

friend class UserDataOperator

friend

Examples

continuity_check_on_skeleton_with_simple_2d_for_h1.cpp, continuity_check_on_skeleton_with_simple_2d_for_hcurl.cpp, continuity_check_on_skeleton_with_simple_2d_for_hdiv.cpp, hcurl_divergence_operator_2d.cpp, helmholtz.cpp, mesh_smoothing.cpp, and phase.cpp.

Definition at line 479 of file ForcesAndSourcesCore.hpp.

VolumeElementForcesAndSourcesCoreOnContactPrismSide

friend class VolumeElementForcesAndSourcesCoreOnContactPrismSide

friend

Definition at line 535 of file ForcesAndSourcesCore.hpp.

VolumeElementForcesAndSourcesCoreOnSide

friend class VolumeElementForcesAndSourcesCoreOnSide

friend

Definition at line 531 of file ForcesAndSourcesCore.hpp.

Member Data Documentation

coordsAtGaussPts

MatrixDouble MoFEM::ForcesAndSourcesCore::coordsAtGaussPts

protected

coordinated at gauss points

Definition at line 541 of file ForcesAndSourcesCore.hpp.

dataH1

EntitiesFieldData& MoFEM::ForcesAndSourcesCore::dataH1

protected

Definition at line 468 of file ForcesAndSourcesCore.hpp.

dataHcurl

EntitiesFieldData& MoFEM::ForcesAndSourcesCore::dataHcurl

protected

Definition at line 469 of file ForcesAndSourcesCore.hpp.

dataHdiv

EntitiesFieldData& MoFEM::ForcesAndSourcesCore::dataHdiv

protected

Definition at line 470 of file ForcesAndSourcesCore.hpp.

dataL2

EntitiesFieldData& MoFEM::ForcesAndSourcesCore::dataL2

protected

Definition at line 471 of file ForcesAndSourcesCore.hpp.

dataNoField

EntitiesFieldData& MoFEM::ForcesAndSourcesCore::dataNoField

protected

Definition at line 467 of file ForcesAndSourcesCore.hpp.

dataOnElement

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

protected

Entity data on element entity rows fields.

Definition at line 458 of file ForcesAndSourcesCore.hpp.

derivedDataOnElement

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

protected

Entity data on element entity columns fields.

Definition at line 465 of file ForcesAndSourcesCore.hpp.

elementMeasure

double MoFEM::ForcesAndSourcesCore::elementMeasure

protected

Depending on dimension of elements, stores length, area or volume of element.

Definition at line 542 of file ForcesAndSourcesCore.hpp.

elementPolynomialBasePtr

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

private

Pointer to entity polynomial base.

Definition at line 493 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

EshelbianPlasticity.cpp, hanging_node_approx.cpp, and prism_elements_from_surface.cpp.

Definition at line 109 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

lorentz_force.cpp.

Definition at line 42 of file ForcesAndSourcesCore.hpp.

lastEvaluatedElementEntityType

EntityType MoFEM::ForcesAndSourcesCore::lastEvaluatedElementEntityType

protected

Last evaluated type of element entity.

Definition at line 486 of file ForcesAndSourcesCore.hpp.

mField

Interface& MoFEM::ForcesAndSourcesCore::mField

Examples

EshelbianPlasticity.cpp, and prism_elements_from_surface.cpp.

Definition at line 24 of file ForcesAndSourcesCore.hpp.

opPtrVector

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

protected

Vector of finite element users data operators.

Definition at line 477 of file ForcesAndSourcesCore.hpp.

refinePtrFE

ForcesAndSourcesCore* MoFEM::ForcesAndSourcesCore::refinePtrFE

private

Element to integrate parent or child.

u

Definition at line 521 of file ForcesAndSourcesCore.hpp.

setRuleHook

GaussHookFun MoFEM::ForcesAndSourcesCore::setRuleHook

Set function to calculate integration rule.

Examples

hanging_node_approx.cpp.

Definition at line 48 of file ForcesAndSourcesCore.hpp.

sidePtrFE

ForcesAndSourcesCore* MoFEM::ForcesAndSourcesCore::sidePtrFE

private

Element to integrate on the sides.

Definition at line 504 of file ForcesAndSourcesCore.hpp.

userPolynomialBasePtr

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

private

Pointer to user polynomial base.

Definition at line 498 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