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_X_T = 1 << 4 , CTX_SET_X_TT = 1 << 6 , CTX_SET_TIME = 1 << 7 }
using	Switches = std::bitset< 8 >
Public Types inherited from MoFEM::SnesMethod
enum	SNESContext { CTX_SNESSETFUNCTION , CTX_SNESSETJACOBIAN , CTX_SNESNONE }
Public Types inherited from MoFEM::TSMethod
enum	TSContext {   CTX_TSSETRHSFUNCTION , CTX_TSSETRHSJACOBIAN , CTX_TSSETIFUNCTION , CTX_TSSETIJACOBIAN ,   CTX_TSTSMONITORSET , CTX_TSNONE }

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

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

Protected Member Functions
MoFEMErrorCode	getEntitySense (const EntityType type, boost::ptr_vector< EntitiesFieldData::EntData > &data) const
	get sense (orientation) of entity More...
MoFEMErrorCode	getEntityDataOrder (const EntityType type, const FieldSpace space, boost::ptr_vector< EntitiesFieldData::EntData > &data) const
	Get the entity data order. More...
template<EntityType type>
MoFEMErrorCode	getEntitySense (EntitiesFieldData &data) const
	Get the entity sense (orientation) More...
template<EntityType type>
MoFEMErrorCode	getEntityDataOrder (EntitiesFieldData &data, const FieldSpace space) const
	Get the entity data order for given space. More...
MoFEMErrorCode	getFaceNodes (EntitiesFieldData &data) const
	Get nodes on faces. More...
MoFEMErrorCode	getSpacesAndBaseOnEntities (EntitiesFieldData &data) const
	Get field approximation space and base on entities. More...
virtual int	getRule (int order_row, int order_col, int order_data)
	another variant of getRule More...
virtual MoFEMErrorCode	setGaussPts (int order_row, int order_col, int order_data)
	set user specific integration rule More...
MoFEMErrorCode	calHierarchicalBaseFunctionsOnElement (const FieldApproximationBase b)
	Calculate base functions. More...
MoFEMErrorCode	calHierarchicalBaseFunctionsOnElement ()
	Calculate base functions. More...
MoFEMErrorCode	calBernsteinBezierBaseFunctionsOnElement ()
	Calculate Bernstein-Bezier base. More...
MoFEMErrorCode	createDataOnElement (EntityType type)
	Create a entity data on element object. More...
MoFEMErrorCode	loopOverOperators ()
	Iterate user data operators. More...
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 More...
MoFEMErrorCode	getRowNodesIndices (EntitiesFieldData &data, const int bit_number) const
	get row node indices from FENumeredDofEntity_multiIndex More...
MoFEMErrorCode	getColNodesIndices (EntitiesFieldData &data, const int bit_number) const
	get col node indices from FENumeredDofEntity_multiIndex More...
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	getNoFieldIndices (const int bit_number, boost::shared_ptr< FENumeredDofEntity_multiIndex > dofs, VectorInt &nodes_indices) const
	get NoField indices More...
MoFEMErrorCode	getNoFieldRowIndices (EntitiesFieldData &data, const int bit_number) const
	get col NoField indices More...
MoFEMErrorCode	getNoFieldColIndices (EntitiesFieldData &data, const int bit_number) const
	get col NoField indices More...
Data
MoFEMErrorCode	getBitRefLevelOnData ()
MoFEMErrorCode	getNoFieldFieldData (const int bit_number, VectorDouble &ent_field_data, VectorDofs &ent_field_dofs, VectorFieldEntities &ent_field) const
	Get field data on nodes. More...
MoFEMErrorCode	getNoFieldFieldData (EntitiesFieldData &data, const int bit_number) const
MoFEMErrorCode	getNodesFieldData (EntitiesFieldData &data, const int bit_number) const
	Get data on nodes. More...
MoFEMErrorCode	getEntityFieldData (EntitiesFieldData &data, const int bit_number, const EntityType type_lo=MBVERTEX, const EntityType type_hi=MBPOLYHEDRON) const
Data form NumeredDofEntity_multiIndex
MoFEMErrorCode	getProblemNodesIndices (const std::string &field_name, const NumeredDofEntity_multiIndex &dofs, VectorInt &nodes_indices) const
	get indices of nodal indices which are declared for problem but not this particular element More...
MoFEMErrorCode	getProblemTypeIndices (const std::string &field_name, const NumeredDofEntity_multiIndex &dofs, EntityType type, int side_number, VectorInt &indices) const
	get indices by type (generic function) which are declared for problem but not this particular element More...
MoFEMErrorCode	getProblemNodesRowIndices (const std::string &field_name, VectorInt &nodes_indices) const
MoFEMErrorCode	getProblemTypeRowIndices (const std::string &field_name, EntityType type, int side_number, VectorInt &indices) const
MoFEMErrorCode	getProblemNodesColIndices (const std::string &field_name, VectorInt &nodes_indices) const
MoFEMErrorCode	getProblemTypeColIndices (const std::string &field_name, EntityType type, int side_number, VectorInt &indices) const
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. More...
const std::array< boost::shared_ptr< EntitiesFieldData >, LASTSPACE >	derivedDataOnElement
	Entity data on element entity columns fields. More...
EntitiesFieldData &	dataNoField
EntitiesFieldData &	dataH1
EntitiesFieldData &	dataHcurl
EntitiesFieldData &	dataHdiv
EntitiesFieldData &	dataL2
boost::ptr_vector< UserDataOperator >	opPtrVector
	Vector of finite element users data operators. More...
EntityType	lastEvaluatedElementEntityType
	Last evaluated type of element entity. More...
MatrixDouble	coordsAtGaussPts
	coordinated at gauss points More...
double	elementMeasure

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

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

Friends
class	UserDataOperator
class	VolumeElementForcesAndSourcesCoreOnSide
class	FaceElementForcesAndSourcesCoreOnSide
class	FaceElementForcesAndSourcesCoreOnChildParent
class	EdgeElementForcesAndSourcesCoreOnChildParent
class	VolumeElementForcesAndSourcesCoreOnContactPrismSide

Additional Inherited Members
Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode	getLibVersion (Version &version)
	Get library version. More...
static MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version)
	Get database major version. More...
static MoFEMErrorCode	setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
	Get database major version. More...
static MoFEMErrorCode	getInterfaceVersion (Version &version)
	Get database major version. More...
Static Public Attributes inherited from MoFEM::PetscData
static constexpr Switches	CtxSetNone = PetscData::Switches(CTX_SET_NONE)
static constexpr Switches	CtxSetF = PetscData::Switches(CTX_SET_F)
static constexpr Switches	CtxSetA = PetscData::Switches(CTX_SET_A)
static constexpr Switches	CtxSetB = PetscData::Switches(CTX_SET_B)
static constexpr Switches	CtxSetX = PetscData::Switches(CTX_SET_X)
static constexpr Switches	CtxSetX_T = PetscData::Switches(CTX_SET_X_T)
static constexpr Switches	CtxSetX_TT = PetscData::Switches(CTX_SET_X_TT)
static constexpr Switches	CtxSetTime = PetscData::Switches(CTX_SET_TIME)

Detailed Description

structure to get information form mofem into EntitiesFieldData

Examples

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

Definition at line 22 of file ForcesAndSourcesCore.hpp.

Member Typedef Documentation

GaussHookFun

typedef 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

typedef 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 42 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 1098 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();
            const int nb_dof_idx = first_e->getNbOfCoeffs();
 
            std::vector<boost::weak_ptr<FieldEntity>> brother_ents_vec;
 
            for (; it != hi; ++it) {
              if (auto e = it->lock()) {
                const auto &sn = e->getSideNumberPtr();
                const int side_number = sn->side_number;
                const int brother_side_number = sn->brother_side_number;
                if (brother_side_number != -1)
                  brother_ents_vec.emplace_back(e);
                bb_node_order[side_number] = e->getMaxOrder();
              }
            }
 
            for (auto &it : brother_ents_vec) {
              if (const auto e = it.lock()) {
                const auto &sn = e->getSideNumberPtr();
                const int side_number = sn->side_number;
                const int brother_side_number = sn->brother_side_number;
                bb_node_order[brother_side_number] = bb_node_order[side_number];
              }
            }
 
            break;
          }
      }
    }
 
    MoFEMFunctionReturn(0);
  };
 
  auto get_entity_base_data = [&](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)) {
            CHKERR getElementPolynomialBase()->getValue(
                gaussPts, boost::make_shared<EntPolynomialBaseCtx>(
                              *dataOnElement[space], field_name,
                              static_cast<FieldSpace>(space),
                              AINSWORTH_BERNSTEIN_BEZIER_BASE, NOBASE));
            fields_list.insert(field_name);
          }
        }
      }
    }
  }
 
  MoFEMFunctionReturn(0);
};

calHierarchicalBaseFunctionsOnElement() [1/2]

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::calHierarchicalBaseFunctionsOnElement ( )

protected

Calculate base functions.

Returns

Error code

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

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

                                    {
  MoFEMFunctionBegin;
  if (dataOnElement[H1]->bAse.test(b)) {
    switch (static_cast<FieldApproximationBase>(b)) {
    case NOBASE:
      break;
    case AINSWORTH_BERNSTEIN_BEZIER_BASE:
      // BERNSTEIN_BEZIER_BASE is not hierarchical base
      break;
    case AINSWORTH_LEGENDRE_BASE:
    case AINSWORTH_LOBATTO_BASE:
    case DEMKOWICZ_JACOBI_BASE:
      if (!getElementPolynomialBase())
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Functions genrating approximation base not defined");
 
      for (int space = H1; space != LASTSPACE; ++space) {
        if (dataOnElement[H1]->sPace.test(space) &&
            dataOnElement[H1]->bAse.test(b) &&
            dataOnElement[H1]->basesOnSpaces[space].test(b)) {
          CHKERR getElementPolynomialBase()->getValue(
              gaussPts,
              boost::make_shared<EntPolynomialBaseCtx>(
                  *dataOnElement[space], static_cast<FieldSpace>(space),
                  static_cast<FieldApproximationBase>(b), NOBASE));
        }
      }
      break;
    case USER_BASE:
      if (!getUserPolynomialBase())
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Functions generating user approximation base not defined");
 
      for (int space = H1; space != LASTSPACE; ++space)
        if (dataOnElement[H1]->sPace.test(space) &&
            dataOnElement[H1]->bAse.test(b) &&
            dataOnElement[H1]->basesOnSpaces[space].test(b)) {
          CHKERR getUserPolynomialBase()->getValue(
              gaussPts,
              boost::make_shared<EntPolynomialBaseCtx>(
                  *dataOnElement[space], static_cast<FieldSpace>(space),
                  static_cast<FieldApproximationBase>(b), NOBASE));
        }
      break;
    default:
      SETERRQ1(mField.get_comm(), MOFEM_DATA_INCONSISTENCY,
               "Base <%s> not yet implemented",
               ApproximationBaseNames[static_cast<FieldApproximationBase>(b)]);
    }
  }
  MoFEMFunctionReturn(0);
}

createDataOnElement()

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

protected

Create a entity data on element object.

Returns

MoFEMErrorCode

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

                                           {
  MoFEMFunctionBegin;
 
  // for (int s = H1; s != LASTSPACE; ++s) {
  //   dataOnElement[s]->dataOnEntities[MBENTITYSET].resize(0);
  // }
 
  for (auto &data : dataOnElement) {
    if (data) {
      for (auto &dat : data->dataOnEntities) {
        for (auto &ent_dat : dat) {
          ent_dat.getEntDataBitRefLevel().reset();
        }
      }
    }
  }
 
  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 =
            type == MBVERTEX ? 0 : e->getSideNumberPtr()->side_number;
        if (side >= 0) {
          if (auto &data = dataOnElement[space]) {
            auto &dat = data->dataOnEntities[type][side];
            dat.getEntDataBitRefLevel() |= e->getBitRefLevel();
          }
        }
      } else {
        if (auto &data = dataOnElement[NOFIELD]) {
          auto &dat = data->dataOnEntities[MBENTITYSET][0];
          dat.getEntDataBitRefLevel() |= 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 infromatin 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 141 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 762 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 86 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 913 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, 100));
 
  for (; side_ptr_it != hi_side_ptr_it; ++side_ptr_it) {
    const auto side = (*side_ptr_it)->side_number;
    const auto sense = (*side_ptr_it)->sense;
    const auto offset = (*side_ptr_it)->offset;
    const auto face_ent = (*side_ptr_it)->ent;
 
    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
    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 137 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 122 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 133 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 640 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()) {
              nb_dofs += e->getNbDofsOnEnt();
            }
          }
 
          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 220 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

Definition at line 474 of file ForcesAndSourcesCore.cpp.

                                                                       {
  MoFEMFunctionBegin;
#ifndef NDEBUG
  if (data.dataOnEntities[MBENTITYSET].size() == 0) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "data.dataOnEntities[MBENTITYSET] is empty");
  }
#endif
  CHKERR getNoFieldIndices(bit_number, getColDofsPtr(),
                           data.dataOnEntities[MBENTITYSET][0].getIndices());
  MoFEMFunctionReturn(0);
}

getNoFieldFieldData() [1/2]

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getNoFieldFieldData ( const int  bit_number, VectorDouble &  ent_field_data, VectorDofs &  ent_field_dofs, VectorFieldEntities &  ent_field  ) const

protected

Get field data on nodes.

Definition at line 847 of file ForcesAndSourcesCore.cpp.

                                                                      {
 
  MoFEMFunctionBeginHot;
 
  ent_field_data.resize(0, false);
  ent_field_dofs.resize(0, false);
  ent_field.resize(0, false);
 
  auto &field_ents = getDataFieldEnts();
  const auto lo_uid = FieldEntity::getLocalUniqueIdCalculate(
      bit_number, get_id_for_min_type<MBVERTEX>());
  auto lo = std::lower_bound(field_ents.begin(), field_ents.end(), lo_uid,
                             cmp_uid_lo);
  if (lo != field_ents.end()) {
 
    ent_field.resize(field_ents.size(), false);
    std::fill(ent_field.begin(), ent_field.end(), nullptr);
 
    const auto hi_uid = FieldEntity::getLocalUniqueIdCalculate(
        bit_number, get_id_for_max_type<MBENTITYSET>());
    auto hi = std::upper_bound(lo, field_ents.end(), hi_uid, cmp_uid_hi);
    if (lo != hi) {
 
      int side = 0;
      for (auto it = lo; it != hi; ++it, ++side)
        if (auto e = it->lock()) {
 
          const auto size = e->getNbDofsOnEnt();
          ent_field_data.resize(size, false);
          ent_field_dofs.resize(size, false);
          ent_field[side] = e.get();
          noalias(ent_field_data) = e->getEntFieldData();
 
          if (auto cache = e->entityCacheDataDofs.lock()) {
            for (auto dit = cache->loHi[0]; dit != cache->loHi[1]; ++dit) {
              ent_field_dofs[(*dit)->getEntDofIdx()] =
                  reinterpret_cast<FEDofEntity *>((*dit).get());
            }
          }
        }
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

getNoFieldFieldData() [2/2]

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

protected

Definition at line 896 of file ForcesAndSourcesCore.cpp.

                                                                      {
  MoFEMFunctionBegin;
  if (data.dataOnEntities[MBENTITYSET].size() == 0)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "No space to insert data");
 
  CHKERR getNoFieldFieldData(
      bit_number, data.dataOnEntities[MBENTITYSET][0].getFieldData(),
      data.dataOnEntities[MBENTITYSET][0].getFieldDofs(),
      data.dataOnEntities[MBENTITYSET][0].getFieldEntities());
  MoFEMFunctionReturn(0);
}

getNoFieldIndices()

MoFEMErrorCode MoFEM::ForcesAndSourcesCore::getNoFieldIndices ( const int  bit_number, boost::shared_ptr< FENumeredDofEntity_multiIndex >  dofs, VectorInt &  nodes_indices  ) const

protected

get NoField indices

Definition at line 442 of file ForcesAndSourcesCore.cpp.

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

getNoFieldRowIndices()

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

protected

get col NoField indices

Definition at line 459 of file ForcesAndSourcesCore.cpp.

                                                                       {
  MoFEMFunctionBegin;
#ifndef NDEBUG
  if (data.dataOnEntities[MBENTITYSET].size() == 0) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "data.dataOnEntities[MBENTITYSET] is empty");
  }
#endif
  CHKERR getNoFieldIndices(bit_number, getRowDofsPtr(),
                           data.dataOnEntities[MBENTITYSET][0].getIndices());
  MoFEMFunctionReturn(0);
}

getOpPtrVector()

boost::ptr_vector< 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, and lorentz_force.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 579 of file ForcesAndSourcesCore.cpp.

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

getProblemNodesIndices()

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

protected

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

Definition at line 490 of file ForcesAndSourcesCore.cpp.

                                    {
  MoFEMFunctionBeginHot;
 
  const Field *field_struture = mField.get_field_structure(field_name);
  if (field_struture->getSpace() == H1) {
 
    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 565 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 586 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 531 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 572 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 MoFEM::EdgeElementForcesAndSourcesCoreOnChildParent, MoFEM::FaceElementForcesAndSourcesCoreOnChildParent, MoFEM::FaceElementForcesAndSourcesCoreOnSide, MoFEM::VolumeElementForcesAndSourcesCoreOnContactPrismSide, MoFEM::VolumeElementForcesAndSourcesCoreOnSide, MoFEM::PostProcBrokenMeshInMoabBase< EdgeElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< FaceElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< VolumeElementForcesAndSourcesCore >, CohesiveElement::CohesiveInterfaceElement::MyPrism, AnalyticalDirichletBC::ApproxField::MyTriFE, BodyForceConstantField::MyVolumeFE, EdgeForce::MyFE, FluidPressure::MyTriangleFE, KelvinVoigtDamper::DamperFE, NonlinearElasticElement::MyVolumeFE, PostProcFaceOnRefinedMesh, PostProcEdgeOnRefinedMesh, NeumannForcesSurface::MyTriangleFE, NeumannForcesSurfaceComplexForLazy::MyTriangleSpatialFE, SurfaceSlidingConstrains::MyTriangleFE, EdgeSlidingConstrains::MyEdgeFE, ThermalElement::MyVolumeFE, ThermalElement::MyTriFE, ThermalStressElement::MyVolumeFE, BoneRemodeling::DensityMapFe, BoneRemodeling::Remodeling::Fe, CellEngineering::FaceElement, CellEngineering::DispMapFe, GelModule::Gel::GelFE, NitscheMethod::MyFace, NitscheMethod::MyVolumeFE, SmallStrainPlasticity::MyVolumeFE, MixTransport::MixTransportElement::MyVolumeFE, MixTransport::MixTransportElement::MyTriFE, MagneticElement::VolumeFE, and MagneticElement::TriFE.

Definition at line 1856 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 TriFE, QuadFE, and EdgeFE.

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

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

getUserPolynomialBase()

auto & MoFEM::ForcesAndSourcesCore::getUserPolynomialBase ( )

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 1340 of file ForcesAndSourcesCore.cpp.

                                                       {
  MoFEMFunctionBegin;
 
  using UDO = UserDataOperator;
 
  std::array<std::string, 2> field_name;
  std::array<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:
      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:
      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:
      SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
               "Not implemented for this space", op.sPace);
    }
 
    MoFEMFunctionReturnHot(0);
  };
 
  // set entity data
  auto set_op_entityties_data = [&](auto ss, auto &op) {
    MoFEMFunctionBeginHot;
 
#ifndef NDEBUG
    if ((op.getNumeredEntFiniteElementPtr()->getBitFieldIdData() &
         mField.get_field_id(field_name[ss]))
            .none()) {
      SETERRQ2(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) {
        CHKERR getNoFieldRowIndices(*op_data[ss], field_id[ss]);
      } else {
        CHKERR getNoFieldColIndices(*op_data[ss], field_id[ss]);
      }
      CHKERR getNoFieldFieldData(*op_data[ss], field_id[ss]);
      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:
      // if (!getNinTheLoop()) {
      // NOFIELD data are the same for each element, can be
      // retrieved only once
      CHKERR get_data_for_meshset();
      // }
      break;
    default:
      SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
               "not implemented for this space < %s >",
               FieldSpaceNames[space[ss]]);
    }
    MoFEMFunctionReturnHot(0);
  };
 
  // evalate operators with field data
  auto evaluate_op_for_fields = [&](auto &op) {
    MoFEMFunctionBeginHot;
 
    if (op.getOpType() & UDO::OPROW) {
      try {
        CHKERR op.opRhs(*op_data[0], false);
      }
      CATCH_OP_ERRORS(op);
    }
 
    if (op.getOpType() & UDO::OPCOL) {
      try {
        CHKERR op.opRhs(*op_data[1], false);
      }
      CATCH_OP_ERRORS(op);
    }
 
    if (op.getOpType() & UDO::OPROWCOL) {
      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();
 
  // interate over all operators on element
  for (; oit != hi_oit; oit++) {
 
    try {
 
      CHKERR oit->setPtrFE(this);
 
      if ((oit->opType & UDO::OPSPACE) == UDO::OPSPACE) {
 
        // run operator for space but specific field
        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()) {
            SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                     "Not set Field name in operator %d (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_entityties_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::VertexElementForcesAndSourcesCore, MoFEM::VolumeElementForcesAndSourcesCore, and NeumannForcesSurfaceComplexForLazy::MyTriangleSpatialFE.

Definition at line 1890 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 MoFEM::PostProcBrokenMeshInMoabBase< EdgeElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< FaceElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< VolumeElementForcesAndSourcesCore >, KelvinVoigtDamper::DamperFE, NonlinearElasticElement::MyVolumeFE, PostProcFatPrismOnRefinedMesh, PostProcFaceOnRefinedMesh, PostProcEdgeOnRefinedMesh, Smoother::MyVolumeFE, GelModule::Gel::GelFE, SolidShellModule::SolidShellPrismElement::SolidShell, SolidShellModule::SolidShellPrismElement::SolidShellError, and SolidShellModule::SolidShellPrismElement::PostProcFatPrismOnTriangleOnRefinedMesh.

Definition at line 1905 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 MoFEM::PostProcBrokenMeshInMoabBase< EdgeElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< FaceElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< VolumeElementForcesAndSourcesCore >, FluidPressure::MyTriangleFE, KelvinVoigtDamper::DamperFE, NonlinearElasticElement::MyVolumeFE, PostProcFatPrismOnRefinedMesh, PostProcFaceOnRefinedMesh, PostProcEdgeOnRefinedMesh, Smoother::MyVolumeFE, NeumannForcesSurfaceComplexForLazy::MyTriangleSpatialFE, SurfaceSlidingConstrains::MyTriangleFE, EdgeSlidingConstrains::MyEdgeFE, GelModule::Gel::GelFE, SolidShellModule::SolidShellPrismElement::SolidShell, and SolidShellModule::SolidShellPrismElement::SolidShellError.

Definition at line 1882 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::VolumeElementForcesAndSourcesCoreOnContactPrismSide, MoFEM::VolumeElementForcesAndSourcesCoreOnSide, MoFEM::PostProcBrokenMeshInMoabBase< EdgeElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< FaceElementForcesAndSourcesCore >, MoFEM::PostProcBrokenMeshInMoabBase< VolumeElementForcesAndSourcesCore >, PostProcFaceOnRefinedMesh, PostProcEdgeOnRefinedMesh, and NitscheMethod::MyVolumeFE.

Definition at line 1860 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 TriFE, QuadFE, and EdgeFE.

Definition at line 1850 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 1654 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 1648 of file ForcesAndSourcesCore.cpp.

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

Friends And Related Function Documentation

EdgeElementForcesAndSourcesCoreOnChildParent

friend class EdgeElementForcesAndSourcesCoreOnChildParent

friend

Definition at line 537 of file ForcesAndSourcesCore.hpp.

FaceElementForcesAndSourcesCoreOnChildParent

friend class FaceElementForcesAndSourcesCoreOnChildParent

friend

Definition at line 536 of file ForcesAndSourcesCore.hpp.

FaceElementForcesAndSourcesCoreOnSide

friend class FaceElementForcesAndSourcesCoreOnSide

friend

Definition at line 535 of file ForcesAndSourcesCore.hpp.

UserDataOperator

friend class UserDataOperator

friend

Definition at line 482 of file ForcesAndSourcesCore.hpp.

VolumeElementForcesAndSourcesCoreOnContactPrismSide

friend class VolumeElementForcesAndSourcesCoreOnContactPrismSide

friend

Definition at line 538 of file ForcesAndSourcesCore.hpp.

VolumeElementForcesAndSourcesCoreOnSide

friend class VolumeElementForcesAndSourcesCoreOnSide

friend

Definition at line 534 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 471 of file ForcesAndSourcesCore.hpp.

dataHcurl

EntitiesFieldData& MoFEM::ForcesAndSourcesCore::dataHcurl

protected

Definition at line 472 of file ForcesAndSourcesCore.hpp.

dataHdiv

EntitiesFieldData& MoFEM::ForcesAndSourcesCore::dataHdiv

protected

Definition at line 473 of file ForcesAndSourcesCore.hpp.

dataL2

EntitiesFieldData& MoFEM::ForcesAndSourcesCore::dataL2

protected

Definition at line 474 of file ForcesAndSourcesCore.hpp.

dataNoField

EntitiesFieldData& MoFEM::ForcesAndSourcesCore::dataNoField

protected

Definition at line 470 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 461 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 468 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 496 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

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

field_evaluator.cpp, and 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 489 of file ForcesAndSourcesCore.hpp.

mField

Interface& MoFEM::ForcesAndSourcesCore::mField

Examples

prism_elements_from_surface.cpp.

Definition at line 24 of file ForcesAndSourcesCore.hpp.

opPtrVector

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

protected

Vector of finite element users data operators.

Definition at line 480 of file ForcesAndSourcesCore.hpp.

refinePtrFE

ForcesAndSourcesCore* MoFEM::ForcesAndSourcesCore::refinePtrFE

private

Element to integrate parent or child.

u

Definition at line 524 of file ForcesAndSourcesCore.hpp.

setRuleHook

GaussHookFun MoFEM::ForcesAndSourcesCore::setRuleHook

Set function to calculate integration rule.

Definition at line 48 of file ForcesAndSourcesCore.hpp.

sidePtrFE

ForcesAndSourcesCore* MoFEM::ForcesAndSourcesCore::sidePtrFE

private

Element to integrate on the sides.

Definition at line 507 of file ForcesAndSourcesCore.hpp.

userPolynomialBasePtr

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

private

Pointer to user polynomail base.

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