MoFEM::CoreTmp< 0 > Struct Reference

Core (interface) class. More...

#include <src/interfaces/Core.hpp>

Inheritance diagram for MoFEM::CoreTmp< 0 >:

Collaboration diagram for MoFEM::CoreTmp< 0 >:

Public Member Functions
const int	getValue () const
	Get the core. More...
RefEntityTmp< 0 >	getRefEntity (const EntityHandle ent)
virtual boost::shared_ptr< RefEntityTmp< 0 > >	make_shared_ref_entity (const EntityHandle ent)
	Get RefEntity. More...
	CoreTmp (moab::Interface &moab, MPI_Comm comm=PETSC_COMM_WORLD, const int verbose=VERBOSE)
	~CoreTmp ()
Public Member Functions inherited from MoFEM::DeprecatedCoreInterface
virtual DEPRECATED MoFEMErrorCode	seed_ref_level_2D (const EntityHandle meshset, const BitRefLevel &bit, int verb=-1)
	seed 2D entities (Triangles entities only) in the meshset and their adjacencies (only TRIs adjacencies) in a particular BitRefLevel More...
DEPRECATED MoFEMErrorCode	seed_ref_level_3D (const EntityHandle meshset, const BitRefLevel &bit, int verb=-1)
	seed 2D entities in the meshset and their adjacencies (only TETs adjacencies) in a particular BitRefLevel More...
DEPRECATED MoFEMErrorCode	seed_ref_level (const Range &ents, const BitRefLevel &bit, const bool only_tets=true, int verb=-1)
	seed entities in the range and their adjacencies in a particular BitRefLevel More...
DEPRECATED MoFEMErrorCode	partition_mesh (const Range &ents, const int dim, const int adj_dim, const int n_parts, int verb=-1)
	Set partition tag to each finite element in the problem. More...
DEPRECATED MoFEMErrorCode	synchronise_entities (Range &ent, int verb=DEFAULT_VERBOSITY)
DEPRECATED MoFEMErrorCode	synchronise_field_entities (const std::string &name, int verb=DEFAULT_VERBOSITY)
Public Member Functions inherited from MoFEM::CoreInterface
virtual	~CoreInterface ()=default
virtual MoFEMErrorCode	add_broken_field (const std::string name, const FieldSpace space, const FieldApproximationBase base, const FieldCoefficientsNumber nb_of_coefficients, const std::vector< std::pair< EntityType, std::function< MoFEMErrorCode(BaseFunction::DofsSideMap &)>> > list_dof_side_map, const TagType tag_type=MB_TAG_SPARSE, const enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)=0
	Add field. More...
Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode	registerInterface (bool error_if_registration_failed=true)
	Register interface. More...
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface reference 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

Static Public Attributes
static constexpr int	value = 0

Protected Member Functions
template<int V>
	CoreTmp (moab::Interface &moab, MPI_Comm comm, const int verbose, CoreValue< V >)
MoFEMErrorCode	coreGenericConstructor (moab::Interface &moab, MPI_Comm comm, const int verbose)
MoFEMErrorCode	addProblem (const BitProblemId id, const std::string &name, int verb=DEFAULT_VERBOSITY)
	add problem More...
MoFEMErrorCode	getTags (int verb=DEFAULT_VERBOSITY)
	Get tag handles. More...
MoFEMErrorCode	clearMap ()
	Cleaning database. More...
MoFEMErrorCode	registerSubInterfaces ()
	Register insterfaces. More...
BitProblemId	getProblemShift ()
	Return unique problem Id. More...
MoFEMErrorCode	initialiseDatabaseFromMesh (int verb=DEFAULT_VERBOSITY)
	Initialize database getting information on mesh. More...
MoFEMErrorCode	getOptions (int verb=DEFAULT_VERBOSITY)
	Get core options from command line. More...
template<class IFACE >
MoFEMErrorCode	regSubInterface ()
	Register sub-interfaces in core interface. More...
template<class IFACE >
MoFEMErrorCode	regEvents ()
	Register petsc events. More...

Protected Attributes
boost::shared_ptr< WrapMPIComm >	wrapMPIMOABComm
	manage creation and destruction of MOAB communicator More...
int	verbose
	Verbosity level. More...
boost::ptr_map< boost::typeindex::type_index, UnknownInterface >	iFaces
	Hash map of pointers to interfaces. More...
int *	buildMoFEM
	keeps flags/semaphores for different stages More...
std::string	optionsPrefix
	Prefix for options on command line. More...
PetscBool	initaliseAndBuildField
PetscBool	initaliseAndBuildFiniteElements

Static Protected Attributes
static bool	isGloballyInitialised = false
	Core base globally initialized. More...
static int	mpiInitialised
	mpi was initialised by other agent More...
static PetscBool	isInitialized
	petsc was initialised by other agent More...

Global initialisation and finalisation
static MoFEMErrorCode	Initialize (int *argc, char ***args, const char file[], const char help[])
	Initializes the MoFEM database PETSc, MOAB and MPI. More...
static MoFEMErrorCode	Finalize ()
	Checks for options to be called at the conclusion of the program. More...

Static functions
static void	setRefEntBasicDataPtr (MoFEM::Interface &m_field, boost::shared_ptr< BasicEntityData > &ptr)
static boost::shared_ptr< RefEntityTmp< 0 > >	makeSharedRefEntity (MoFEM::Interface &m_field, const EntityHandle ent)

Assessing interfaces
MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
	Getting interface of core database. More...

Get tag handles to data on the mesh
Tag	get_th_RefParentHandle () const
Tag	get_th_RefBitLevel () const
Tag	get_th_RefBitEdge () const

Auxiliary data and functions
enum	SemaphoresBuildMofem {   BUILD_FIELD = 1 << 0, BUILD_FE = 1 << 1, BUILD_ADJ = 1 << 2, BUILD_PROBLEM = 1 << 3,   PARTITION_PROBLEM = 1 << 4, PARTITION_FE = 1 << 5, PARTITION_GHOST_DOFS = 1 << 6, PARTITION_MESH = 1 << 7 }
int &	getBuildMoFEM () const
	Get flags/semaphores for different stages. More...
MoFEMErrorCode	addPrismToDatabase (const EntityHandle prism, int verb=DEFAULT_VERBOSITY)
	add prim element More...

Tags to data on mesh and entities
Tag	th_Part
	Tag for partition number. More...
Tag	th_RefParentHandle
Tag	th_RefBitLevel
Tag	th_RefBitLevel_Mask
Tag	th_RefBitEdge
Tag	th_RefFEMeshset
Tag	th_FieldId
Tag	th_FieldName
Tag	th_FieldName_DataNamePrefix
Tag	th_FieldSpace
Tag	th_FieldContinuity
Tag	th_FieldBase
Tag	th_FEId
Tag	th_FEName
Tag	th_FEIdCol
Tag	th_FEIdRow
Tag	th_FEIdData
Tag	th_ProblemId
Tag	th_ProblemName
Tag	th_ProblemFEId
Tag	th_ProblemNbDofsRow
Tag	th_ProblemNbDofsCol
Tag	th_ProblemLocalNbDofRow
Tag	th_ProblemGhostNbDofRow
Tag	th_ProblemLocalNbDofCol
Tag	th_ProblemGhostNbDofCol
Tag	th_ProblemShift
Tag	th_ElemType
	Needed for VTK files. More...
Tag	th_MoFEMBuild
boost::shared_ptr< BasicEntityData >	basicEntityDataPtr
boost::shared_ptr< BasicEntityData > &	get_basic_entity_data_ptr ()
	Get pointer to basic entity data. More...

Multi-Indices accessing data on the mesh
RefEntity_multiIndex	refinedEntities
	refined entities More...
RefElement_multiIndex	refinedFiniteElements
	refined elements More...
Field_multiIndex	fIelds
	fields More...
FieldEntity_multiIndex	entsFields
	entities on fields More...
DofEntity_multiIndex	dofsField
	dofs on fields More...
FiniteElement_multiIndex	finiteElements
	finite elements More...
EntFiniteElement_multiIndex	entsFiniteElements
	finite element entities More...
FieldEntityEntFiniteElementAdjacencyMap_multiIndex	entFEAdjacencies
	adjacencies of elements to dofs More...
Problem_multiIndex	pRoblems
	problems multi-index More...

Get moab database
std::reference_wrapper< moab::Interface >	moab
	moab database More...
moab::Interface &	get_moab ()
const moab::Interface &	get_moab () const
MoFEMErrorCode	set_moab_interface (moab::Interface &new_moab, int verb=VERBOSE)
	Set the moab interface object. More...
MoFEMErrorCode	setMoabInterface (moab::Interface &new_moab, int verb=VERBOSE)

Check database consistency
MoFEMErrorCode	check_number_of_ents_in_ents_field (const std::string &name) const
	check data consistency in entitiesPtr More...
MoFEMErrorCode	check_number_of_ents_in_ents_field () const
	check data consistency in entitiesPtr More...
MoFEMErrorCode	check_number_of_ents_in_ents_finite_element (const std::string &name) const
	check data consistency in entsFiniteElements More...
MoFEMErrorCode	check_number_of_ents_in_ents_finite_element () const
	check data consistency in entsFiniteElements More...

Clear database
MoFEMErrorCode	clear_database (int verb=DEFAULT_VERBOSITY)
	Clear database. More...
MoFEMErrorCode	rebuild_database (int verb=DEFAULT_VERBOSITY)
	Clear database and initialize it once again. More...

Getting access to meshset manager
MeshsetsManager *	get_meshsets_manager_ptr ()
	get MeshsetsManager pointer More...
const MeshsetsManager *	get_meshsets_manager_ptr () const
	get MeshsetsManager pointer More...
MeshsetsManager &	get_meshsets_manager ()
	get MeshsetsManager pointer More...
const MeshsetsManager &	get_meshsets_manager () const
	get MeshsetsManager pointer More...

Remove and delete entities
MoFEMErrorCode	remove_parents_by_ents (const Range &ents, int verb=DEFAULT_VERBOSITY)
	Remove parents from entities. More...
MoFEMErrorCode	remove_parents_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	Remove parent from entities on bit level. More...
MoFEMErrorCode	remove_parents_by_parents (const Range &ents, int verb=DEFAULT_VERBOSITY)
	Remove paremts from entities having parents in passed range. More...
MoFEMErrorCode	remove_ents (const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities form mofem database More...
MoFEMErrorCode	remove_ents_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	remove entities form mofem database More...
MoFEMErrorCode	delete_ents_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, const bool remove_parent=false, int verb=DEFAULT_VERBOSITY, MoFEMTypes mf=MF_ZERO)
	delete entities form mofem and moab database More...

Fields
virtual MoFEMErrorCode	add_broken_field (const std::string name, const FieldSpace space, const FieldApproximationBase base, const FieldCoefficientsNumber nb_coefficients, std::vector< std::pair< EntityType, std::function< MoFEMErrorCode(BaseFunction::DofsSideMap &)> >> list_dof_side_map, const TagType tag_type=MB_TAG_SPARSE, const enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)
	Add field. More...
virtual MoFEMErrorCode	add_field (const std::string name, const FieldSpace space, const FieldApproximationBase base, const FieldCoefficientsNumber nb_coefficients, const TagType tag_type=MB_TAG_SPARSE, const enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)
	Add field. More...
MoFEMErrorCode	delete_field (const std::string name, int verb=DEFAULT_VERBOSITY)
	Delete field. More...
MoFEMErrorCode	addField (const std::string &name, const FieldSpace space, const FieldContinuity continuity, const FieldApproximationBase base, const FieldCoefficientsNumber nb_coefficients, const TagType tag_type, const enum MoFEMTypes bh, int verb)
	Template for add_field. More...
MoFEMErrorCode	addEntsToFieldByDim (const Range &ents, const int dim, const std::string &name, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	add_ents_to_field_by_dim (const Range &ents, const int dim, const std::string &name, int verb=DEFAULT_VERBOSITY)
	Add entities to field meshset. More...
MoFEMErrorCode	add_ents_to_field_by_type (const Range &ents, const EntityType type, const std::string &name, int verb=DEFAULT_VERBOSITY)
	Add entities to field meshset. More...
MoFEMErrorCode	add_ents_to_field_by_dim (const EntityHandle meshset, const int dim, const std::string &name, const bool recursive=true, int verb=DEFAULT_VERBOSITY)
	Add entities to field meshset. More...
MoFEMErrorCode	add_ents_to_field_by_type (const EntityHandle meshset, const EntityType type, const std::string &name, const bool recursive=true, int verb=DEFAULT_VERBOSITY)
	Add entities to field meshset. More...
MoFEMErrorCode	create_vertices_and_add_to_field (const std::string name, const double coords[], int size, int verb=DEFAULT_VERBOSITY)
	Create a vertices and add to field object. More...

Set approximation order
MoFEMErrorCode	setFieldOrder (const Range &ents, const BitFieldId id, const ApproximationOrder order, int ver)
MoFEMErrorCode	setFieldOrderImpl (boost::shared_ptr< Field > field_ptr, const Range &ents, const ApproximationOrder order, int verb)
MoFEMErrorCode	set_field_order (const Range &ents, const BitFieldId id, const ApproximationOrder order, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	set_field_order (const EntityHandle meshset, const EntityType type, const BitFieldId id, const ApproximationOrder order, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	set_field_order (const Range &ents, const std::string &name, const ApproximationOrder order, int verb=DEFAULT_VERBOSITY)
	Set order approximation of the entities in the field. More...
MoFEMErrorCode	set_field_order (const EntityHandle meshset, const EntityType type, const std::string &name, const ApproximationOrder order, int verb=DEFAULT_VERBOSITY)
	Set order approximation of the entities in the field. More...
MoFEMErrorCode	set_field_order_by_entity_type_and_bit_ref (const BitRefLevel &bit, const BitRefLevel &mask, const EntityType type, const BitFieldId id, const ApproximationOrder order, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	set_field_order_by_entity_type_and_bit_ref (const BitRefLevel &bit, const BitRefLevel &mask, const EntityType type, const std::string &name, const ApproximationOrder order, int verb=DEFAULT_VERBOSITY)
	Set order approximation of the entities in the field. More...

Build fields
MoFEMErrorCode	buildFieldForNoFieldImpl (boost::shared_ptr< Field > field_ptr, std::map< EntityType, int > &dof_counter, int verb)
MoFEMErrorCode	buildFieldForNoField (const BitFieldId id, std::map< EntityType, int > &dof_counter, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	buildFieldForL2H1HcurlHdiv (const BitFieldId id, std::map< EntityType, int > &dof_counter, std::map< EntityType, int > &inactive_dof_counter, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	buildField (const boost::shared_ptr< Field > &field, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	build_fields (int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	build_field (const std::string field_name, int verb=DEFAULT_VERBOSITY)
	build field by name More...

Clear DOFs
MoFEMErrorCode	clear_inactive_dofs (int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	clear_dofs_fields_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	clear_dofs_fields (const Range ents, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	clear_dofs_fields (const std::string name, const Range ents, int verb=DEFAULT_VERBOSITY)

Clear ENTs
MoFEMErrorCode	clear_ents_fields_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	clear_ents_fields (const Range ents, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	clear_ents_fields (const std::string name, const Range ents, int verb=DEFAULT_VERBOSITY)

Remove field entities
MoFEMErrorCode	remove_ents_from_field_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	remove entities from field More...
MoFEMErrorCode	remove_ents_from_field (const std::string name, const EntityHandle meshset, const EntityType type, int verb=DEFAULT_VERBOSITY)
	remove entities from field More...
MoFEMErrorCode	remove_ents_from_field (const std::string name, const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities from field More...
MoFEMErrorCode	remove_ents_from_field (const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities from all fields More...

Other auxiliary functions for fields
MoFEMErrorCode	list_dofs_by_field_name (const std::string &name) const
MoFEMErrorCode	list_fields () const
	list entities in the field More...
BitFieldId	get_field_id (const std::string &name) const
	Get field Id. More...
FieldBitNumber	get_field_bit_number (const std::string name) const
	get field bit number More...
std::string	get_field_name (const BitFieldId id) const
	get field name from id More...
EntityHandle	get_field_meshset (const BitFieldId id) const
EntityHandle	get_field_meshset (const std::string name) const
	get field meshset More...
MoFEMErrorCode	get_field_entities_by_dimension (const std::string name, int dim, Range &ents) const
	get entities in the field by dimension More...
MoFEMErrorCode	get_field_entities_by_type (const std::string name, EntityType type, Range &ents) const
	get entities in the field by type More...
MoFEMErrorCode	get_field_entities_by_handle (const std::string name, Range &ents) const
	get entities in the field by handle More...
bool	check_field (const std::string &name) const
	check if field is in database More...
const Field *	get_field_structure (const std::string &name, enum MoFEMTypes bh=MF_EXIST) const
	get field structure More...

Finite elements
const FiniteElement *	get_finite_element_structure (const std::string &name, enum MoFEMTypes bh=MF_EXCL) const
	get finite element struture More...
bool	check_finite_element (const std::string &name) const
	Check if finite element is in database. More...
MoFEMErrorCode	add_finite_element (const std::string &fe_name, enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)
	add finite element More...
MoFEMErrorCode	modify_finite_element_adjacency_table (const std::string &fe_name, const EntityType type, ElementAdjacencyFunct function)
	modify finite element table, only for advanced user More...
MoFEMErrorCode	modify_finite_element_add_field_data (const std::string &fe_name, const std::string name_filed)
	set finite element field data More...
MoFEMErrorCode	modify_finite_element_add_field_row (const std::string &fe_name, const std::string name_row)
	set field row which finite element use More...
MoFEMErrorCode	modify_finite_element_add_field_col (const std::string &fe_name, const std::string name_col)
	set field col which finite element use More...
MoFEMErrorCode	modify_finite_element_off_field_data (const std::string &fe_name, const std::string name_filed)
	unset finite element field data More...
MoFEMErrorCode	modify_finite_element_off_field_row (const std::string &fe_name, const std::string name_row)
	unset field row which finite element use More...
MoFEMErrorCode	modify_finite_element_off_field_col (const std::string &fe_name, const std::string name_col)
	unset field col which finite element use More...
MoFEMErrorCode	add_ents_to_finite_element_by_type (const EntityHandle meshset, const EntityType type, const std::string &name, const bool recursive=true)
	add entities to finite element More...
MoFEMErrorCode	add_ents_to_finite_element_by_dim (const EntityHandle meshset, const int dim, const std::string &name, const bool recursive=true)
	add entities to finite element More...
MoFEMErrorCode	add_ents_to_finite_element_by_type (const Range &ents, const EntityType type, const std::string &name)
	add entities to finite elements More...
MoFEMErrorCode	add_ents_to_finite_element_by_dim (const Range &ents, const int dim, const std::string &name)
	add entities to finite elements More...
MoFEMErrorCode	add_ents_to_finite_element_by_bit_ref (const BitRefLevel &bit, const BitRefLevel &mask, const std::string &name, EntityType type, int verb=DEFAULT_VERBOSITY)
	add TET entities from given refinement level to finite element database given by name More...
MoFEMErrorCode	add_ents_to_finite_element_by_MESHSET (const EntityHandle meshset, const std::string &name, const bool recursive=false)
	add MESHSET element to finite element database given by name More...
DEPRECATED MoFEMErrorCode	add_ents_to_finite_element_EntType_by_bit_ref (const BitRefLevel &bit, const std::string &name, EntityType type, int verb=DEFAULT_VERBOSITY)
DEPRECATED MoFEMErrorCode	add_ents_to_finite_element_EntType_by_bit_ref (const BitRefLevel &bit, const BitRefLevel &mask, const std::string &name, EntityType type, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	remove_ents_from_finite_element_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	remove elements from given refinement level to finite element database More...
MoFEMErrorCode	remove_ents_from_finite_element (const std::string name, const EntityHandle meshset, const EntityType type, int verb=DEFAULT_VERBOSITY)
	remove entities from given refinement level to finite element database More...
MoFEMErrorCode	remove_ents_from_finite_element (const std::string name, const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities from finite element database More...
MoFEMErrorCode	remove_ents_from_finite_element (const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities from finite elements in database More...
MoFEMErrorCode	delete_finite_element (const std::string name, int verb=DEFAULT_VERBOSITY)
	delete finite element from mofem database More...
BitFEId	getBitFEId (const std::string &fe_name) const
	Get field Id. More...
std::string	getBitFEIdName (const BitFEId id) const
	Get field name. More...
EntityHandle	get_finite_element_meshset (const BitFEId id) const
EntityHandle	get_finite_element_meshset (const std::string name) const
MoFEMErrorCode	get_finite_element_entities_by_dimension (const std::string name, int dim, Range &ents) const
	get entities in the finite element by dimension More...
MoFEMErrorCode	get_finite_element_entities_by_type (const std::string name, EntityType type, Range &ents) const
	get entities in the finite element by type More...
MoFEMErrorCode	get_finite_element_entities_by_handle (const std::string name, Range &ents) const
	get entities in the finite element by handle More...
MoFEMErrorCode	list_finite_elements () const
	list finite elements in database More...

Problems
MoFEMErrorCode	add_problem (const std::string &name, enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)
	Add problem. More...
bool	check_problem (const std::string name)
	check if problem exist More...
MoFEMErrorCode	delete_problem (const std::string name)
	Delete problem. More...
MoFEMErrorCode	modify_problem_add_finite_element (const std::string name_problem, const std::string &fe_name)
	add finite element to problem, this add entities assigned to finite element to a particular problem More...
MoFEMErrorCode	modify_problem_unset_finite_element (const std::string name_problem, const std::string &fe_name)
	unset finite element from problem, this remove entities assigned to finite element to a particular problem More...
MoFEMErrorCode	modify_problem_ref_level_add_bit (const std::string &name_problem, const BitRefLevel &bit)
	add ref level to problem More...
MoFEMErrorCode	modify_problem_ref_level_set_bit (const std::string &name_problem, const BitRefLevel &bit)
	set ref level for problem More...
MoFEMErrorCode	modify_problem_mask_ref_level_add_bit (const std::string &name_problem, const BitRefLevel &bit)
	set dof mask ref level for problem More...
MoFEMErrorCode	modify_problem_mask_ref_level_set_bit (const std::string &name_problem, const BitRefLevel &bit)
	set dof mask ref level for problem More...
BitProblemId	getBitProblemId (const std::string &name) const
MoFEMErrorCode	list_problem () const
	list problems More...
MoFEMErrorCode	clear_problem (const std::string name, int verb=DEFAULT_VERBOSITY)
	clear problem More...
MoFEMErrorCode	clear_problems (int verb=DEFAULT_VERBOSITY)
	clear problems More...
MoFEMErrorCode	build_finite_elements (int verb=DEFAULT_VERBOSITY)
	Build finite elements. More...
MoFEMErrorCode	build_finite_elements (const BitRefLevel &bit, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	build_finite_elements (const string fe_name, const Range *const ents_ptr=nullptr, int verb=DEFAULT_VERBOSITY)
	Build finite elements. More...
MoFEMErrorCode	buildFiniteElements (const boost::shared_ptr< FiniteElement > &fe, const Range *ents_ptr=NULL, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	clear_finite_elements_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	clear_finite_elements (const Range &ents, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	clear_finite_elements (const std::string &fe_name, const Range &ents, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	get_problem_finite_elements_entities (const std::string name, const std::string &fe_name, const EntityHandle meshset)
	add finite elements to the meshset More...
DEPRECATED MoFEMErrorCode	build_problem_on_distributed_mesh (int verb=DEFAULT_VERBOSITY)
DEPRECATED MoFEMErrorCode	build_problems (int verb=DEFAULT_VERBOSITY)

Adjacencies
MoFEMErrorCode	build_adjacencies (const Range &ents, int verb=DEFAULT_VERBOSITY)
	build adjacencies More...
MoFEMErrorCode	build_adjacencies (const BitRefLevel &bit, int verb=DEFAULT_VERBOSITY)
	build adjacencies More...
MoFEMErrorCode	build_adjacencies (const BitRefLevel &bit, const BitRefLevel &mask, int verb=DEFAULT_VERBOSITY)
	build adjacencies More...
MoFEMErrorCode	clear_adjacencies_entities (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	clear adjacency map for entities on given bit level More...
MoFEMErrorCode	clear_adjacencies_entities (const Range ents, int verb=DEFAULT_VERBOSITY)
	clear adjacencies for field entities by entities More...
MoFEMErrorCode	clear_adjacencies_entities (const std::string name, const Range ents, int verb=DEFAULT_VERBOSITY)
	clear adjacencies for field entities by entities and field namd More...
MoFEMErrorCode	clear_adjacencies_finite_elements (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	clear adjacency map for finite elements on given bit level More...
MoFEMErrorCode	clear_adjacencies_finite_elements (const Range ents, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode	clear_adjacencies_finite_elements (const std::string name, const Range ents, int verb=DEFAULT_VERBOSITY)

Methods for preforming operations on elements
MoFEMErrorCode	problem_basic_method_preProcess (const Problem *problem_ptr, BasicMethod &method, int verb=DEFAULT_VERBOSITY)
	Set data for BasicMethod. More...
MoFEMErrorCode	problem_basic_method_preProcess (const std::string &problem_name, BasicMethod &method, int verb=DEFAULT_VERBOSITY)
	Set data for BasicMethod. More...
MoFEMErrorCode	problem_basic_method_postProcess (const Problem *problem_ptr, BasicMethod &method, int verb=DEFAULT_VERBOSITY)
	Set data for BasicMethod. More...
MoFEMErrorCode	problem_basic_method_postProcess (const std::string &problem_name, BasicMethod &method, int verb=DEFAULT_VERBOSITY)
	Set data for BasicMethod. More...
MoFEMErrorCode	cache_problem_entities (const std::string prb_name, CacheTupleWeakPtr cache_ptr)
	Cache variables. More...
MoFEMErrorCode	loop_finite_elements (const Problem *problem_ptr, const std::string &fe_name, FEMethod &method, int lower_rank, int upper_rank, boost::shared_ptr< NumeredEntFiniteElement_multiIndex > fe_ptr=nullptr, MoFEMTypes bh=MF_EXIST, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr(), int verb=DEFAULT_VERBOSITY)
	Make a loop over finite elements on partitions from upper to lower rank. More...
MoFEMErrorCode	loop_finite_elements (const std::string problem_name, const std::string &fe_name, FEMethod &method, int lower_rank, int upper_rank, boost::shared_ptr< NumeredEntFiniteElement_multiIndex > fe_ptr=nullptr, MoFEMTypes bh=MF_EXIST, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr(), int verb=DEFAULT_VERBOSITY)
	Make a loop over finite elements on partitions from upper to lower rank. More...
MoFEMErrorCode	loop_finite_elements (const std::string problem_name, const std::string &fe_name, FEMethod &method, boost::shared_ptr< NumeredEntFiniteElement_multiIndex > fe_ptr=nullptr, MoFEMTypes bh=MF_EXIST, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr(), int verb=DEFAULT_VERBOSITY)
	Make a loop over finite elements. More...
MoFEMErrorCode	loop_dofs (const Problem *problem_ptr, const std::string &field_name, RowColData rc, DofMethod &method, int lower_rank, int upper_rank, int verb=DEFAULT_VERBOSITY)
	Make a loop over dofs. More...
MoFEMErrorCode	loop_dofs (const std::string &problem_name, const std::string &field_name, RowColData rc, DofMethod &method, int lower_rank, int upper_rank, int verb=DEFAULT_VERBOSITY)
	Make a loop over dofs. More...
MoFEMErrorCode	loop_dofs (const std::string &problem_name, const std::string &field_name, RowColData rc, DofMethod &method, int verb=DEFAULT_VERBOSITY)
	Make a loop over dofs. More...
MoFEMErrorCode	loop_dofs (const std::string &field_name, DofMethod &method, int verb=DEFAULT_VERBOSITY)
	Make a loop over dofs. More...
MoFEMErrorCode	loop_entities (const Problem *problem_ptr, const std::string field_name, RowColData rc, EntityMethod &method, int lower_rank, int upper_rank, int verb=DEFAULT_VERBOSITY)
	Loop over field entities in the problem. More...
MoFEMErrorCode	loop_entities (const std::string problem_name, const std::string field_name, RowColData rc, EntityMethod &method, int lower_rank, int upper_rank, int verb=DEFAULT_VERBOSITY)
	Loop over field entities in the problem. More...
MoFEMErrorCode	loop_entities (const std::string problem_name, const std::string field_name, RowColData rc, EntityMethod &method, int verb=DEFAULT_VERBOSITY)
	Loop over field entities in the problem. More...
MoFEMErrorCode	loop_entities (const std::string field_name, EntityMethod &method, Range const *const ents=nullptr, int verb=DEFAULT_VERBOSITY)
	Loop over field entities. More...

Accessing multi-indices
MoFEMErrorCode	get_fields (const Field_multiIndex **fields_ptr) const
	Get fields multi-index from database. More...
MoFEMErrorCode	get_ref_ents (const RefEntity_multiIndex **refined_entities_ptr) const
	Get ref entities multi-index from database. More...
MoFEMErrorCode	get_ref_finite_elements (const RefElement_multiIndex **refined_finite_elements_ptr) const
	Get ref finite elements multi-index form database. More...
MoFEMErrorCode	get_finite_elements (const FiniteElement_multiIndex **fe_ptr) const
	Get finite elements multi-index. More...
MoFEMErrorCode	get_ents_finite_elements (const EntFiniteElement_multiIndex **fe_ent_ptr) const
	Get entities finite elements multi-index. More...
MoFEMErrorCode	get_field_ents (const FieldEntity_multiIndex **field_ents) const
	Get field multi index. More...
MoFEMErrorCode	get_dofs (const DofEntity_multiIndex **dofs_ptr) const
	Get dofs multi index. More...
MoFEMErrorCode	get_problem (const std::string &problem_name, const Problem **problem_ptr) const
	Get problem database (data structure) More...
MoFEMErrorCode	get_problems (const Problem_multiIndex **problems_ptr) const
	Get pointer to problems multi-index. More...
MoFEMErrorCode	get_ents_elements_adjacency (const FieldEntityEntFiniteElementAdjacencyMap_multiIndex **dofs_elements_adjacency) const
	Get the dofs elements adjacency object. More...
const Field_multiIndex *	get_fields () const
	Get the fields object. More...
const RefEntity_multiIndex *	get_ref_ents () const
	Get the ref ents object. More...
const RefElement_multiIndex *	get_ref_finite_elements () const
	Get the ref finite elements object. More...
const FiniteElement_multiIndex *	get_finite_elements () const
	Get the finite elements object. More...
const EntFiniteElement_multiIndex *	get_ents_finite_elements () const
	Get the ents finite elements object. More...
const FieldEntity_multiIndex *	get_field_ents () const
	Get the field ents object. More...
const DofEntity_multiIndex *	get_dofs () const
	Get the dofs object. More...
const Problem *	get_problem (const std::string problem_name) const
	Get the problem object. More...
const Problem_multiIndex *	get_problems () const
	Get the problems object. More...
const FieldEntityEntFiniteElementAdjacencyMap_multiIndex *	get_ents_elements_adjacency () const
	Get the dofs elements adjacency object. More...
FieldEntityByUId::iterator	get_ent_field_by_name_begin (const std::string &field_name) const
	get begin iterator of field ents of given name (instead you can use IT_GET_ENT_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT) More...
FieldEntityByUId::iterator	get_ent_field_by_name_end (const std::string &field_name) const
	get begin iterator of field dofs of given name (instead you can use IT_GET_ENT_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT) More...
DofEntityByUId::iterator	get_dofs_by_name_begin (const std::string &field_name) const
	get begin iterator of field dofs of given name (instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT) More...
DofEntityByUId::iterator	get_dofs_by_name_end (const std::string &field_name) const
	get begin iterator of field dofs of given name (instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT) More...
DofEntityByUId::iterator	get_dofs_by_name_and_ent_begin (const std::string &field_name, const EntityHandle ent) const
	get begin iterator of field dofs of given name and ent(instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,ENT,IT) More...
DofEntityByUId::iterator	get_dofs_by_name_and_ent_end (const std::string &field_name, const EntityHandle ent) const
	get begin iterator of field dofs of given name and ent (instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,ENT,IT) More...
DofEntityByUId::iterator	get_dofs_by_name_and_type_begin (const std::string &field_name, const EntityType type) const
	get begin iterator of field dofs of given name and ent type (instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,TYPE,IT) More...
DofEntityByUId::iterator	get_dofs_by_name_and_type_end (const std::string &field_name, const EntityType ent) const
	get begin iterator of field dofs of given name end ent type(instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,TYPE,IT) More...
EntFiniteElement_multiIndex::index< Unique_mi_tag >::type::iterator	get_fe_by_name_begin (const std::string &fe_name) const
	get begin iterator of finite elements of given name (instead you can use IT_GET_FES_BY_NAME_FOR_LOOP(MFIELD,NAME,IT) More...
EntFiniteElement_multiIndex::index< Unique_mi_tag >::type::iterator	get_fe_by_name_end (const std::string &fe_name) const
	get end iterator of finite elements of given name (instead you can use IT_GET_FES_BY_NAME_FOR_LOOP(MFIELD,NAME,IT) More...

Log events
PetscLogEvent	MOFEM_EVENT_preProcess
	Event for preProcess finite element. More...
PetscLogEvent	MOFEM_EVENT_operator
	Event for evaluating operator of finite element. More...
PetscLogEvent	MOFEM_EVENT_postProcess
	Event for postProcess finite element. More...
PetscLogEvent	MOFEM_EVENT_createMat

Communicator
MPI_Comm	mofemComm
	MoFEM communicator. More...
ParallelComm *	pComm
	MOAB communicator structure. More...
int	sIze
	MoFEM communicator size. More...
int	rAnk
	MOFEM communicator rank. More...
MPI_Comm &	get_comm () const
int	get_comm_size () const
int	get_comm_rank () const

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

Detailed Description

Core (interface) class.

This is the implementation of abstract MoFEM::Interface class. Similarly to the convention used in MoAB, we use small letters to name function of purely abstract classes. This is an exception used only here. For more details about naming functions see Coding practice

This class is not used directly by the user. For internal use only. It is database with basic functions to access data. Abstraction of this is MoFEM Interface structure.

Such deign to hide complexities for users and allow low development without interfering with users modules programmer work.

Todo:

Implement static functions for Initialization and Finalization of MoFEM. Those functions should keep all static variables and initialize/finalize other libs like PETSc. Moreover initialization functions should set error handlers, etc.

Examples

add_blockset.cpp, add_cubit_meshsets.cpp, adolc_plasticity.cpp, analytical_nonlinear_poisson.cpp, analytical_poisson.cpp, analytical_poisson_field_split.cpp, approx_sphere.cpp, bernstein_bezier_generate_base.cpp, bone_adaptation.cpp, boundary_marker.cpp, build_large_problem.cpp, build_problems.cpp, cell_forces.cpp, child_and_parent.cpp, 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, cubit_bc_test.cpp, delete_ho_nodes.cpp, dg_projection.cpp, dm_build_partitioned_mesh.cpp, dm_create_subdm.cpp, dm_partitioned_no_field.cpp, dynamic_first_order_con_law.cpp, edge_and_bubble_shape_functions_on_quad.cpp, eigen_elastic.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, ep.cpp, field_evaluator.cpp, field_to_vertices.cpp, forces_and_sources_testing_edge_element.cpp, forces_and_sources_testing_flat_prism_element.cpp, forces_and_sources_testing_users_base.cpp, free_surface.cpp, gauss_points_on_outer_product.cpp, hanging_node_approx.cpp, hcurl_check_approx_in_2d.cpp, hcurl_curl_operator.cpp, hcurl_divergence_operator_2d.cpp, hdiv_divergence_operator.cpp, heat_equation.cpp, heat_method.cpp, hello_world.cpp, helmholtz.cpp, hertz_surface.cpp, higher_derivatives.cpp, level_set.cpp, log.cpp, loop_entities.cpp, lorentz_force.cpp, magnetostatic.cpp, mesh_cut.cpp, mesh_insert_interface_atom.cpp, mesh_smoothing.cpp, meshset_to_vtk.cpp, minimal_surface_area.cpp, mixed_poisson.cpp, mortar_contact.cpp, mortar_contact_thermal.cpp, navier_stokes.cpp, node_merge.cpp, nonlinear_dynamics.cpp, nonlinear_elastic.cpp, operators_tests.cpp, partition_mesh.cpp, phase.cpp, photon_diffusion.cpp, plastic.cpp, plate.cpp, plot_base.cpp, poisson_2d_dis_galerkin.cpp, poisson_2d_homogeneous.cpp, prism_elements_from_surface.cpp, prism_polynomial_approximation.cpp, quad_polynomial_approximation.cpp, reaction_diffusion.cpp, remove_entities_from_problem.cpp, remove_entities_from_problem_not_partitioned.cpp, scalar_check_approximation.cpp, schur_test_diag_mat.cpp, seepage.cpp, shallow_wave.cpp, simple_contact.cpp, simple_contact_thermal.cpp, simple_elasticity.cpp, simple_interface.cpp, simple_l2_only.cpp, split_sideset.cpp, tensor_divergence_operator.cpp, test_broken_space.cpp, test_cache_on_entities.cpp, test_jacobian_of_simple_contact_element.cpp, testing_jacobian_of_hook_element.cpp, testing_jacobian_of_hook_scaled_with_density_element.cpp, thermo_elastic.cpp, unsaturated_transport.cpp, wave_equation.cpp, and wavy_surface.cpp.

Definition at line 82 of file Core.hpp.

Member Enumeration Documentation

SemaphoresBuildMofem

enum MoFEM::CoreTmp< 0 >::SemaphoresBuildMofem

Is used to check consistency. I n future properly this will be removed and replaced by other solution. It is only for internal use.

Enumerator
BUILD_FIELD
BUILD_FE
BUILD_ADJ
BUILD_PROBLEM
PARTITION_PROBLEM
PARTITION_FE
PARTITION_GHOST_DOFS
PARTITION_MESH

Definition at line 211 of file Core.hpp.

                            {
    BUILD_FIELD = 1 << 0,
    BUILD_FE = 1 << 1,
    BUILD_ADJ = 1 << 2,
    BUILD_PROBLEM = 1 << 3,
    PARTITION_PROBLEM = 1 << 4,
    PARTITION_FE = 1 << 5,
    PARTITION_GHOST_DOFS = 1 << 6,
    PARTITION_MESH = 1 << 7
  };

Constructor & Destructor Documentation

CoreTmp() [1/2]

MoFEM::Core::CoreTmp	(	moab::Interface &	moab,
		MPI_Comm	comm = PETSC_COMM_WORLD,
		const int	verbose = VERBOSE
	)

Construct core database

Parameters

moab	MoAB interface
comm	MPI communicator
verbose	Verbosity level

Definition at line 235 of file Core.cpp.

    : CoreTmp(moab, comm, verbose, CoreValue<0>()) {
 
  // Register sub-interfaces
  ierr = this->registerSubInterfaces();
  CHKERRABORT(comm, ierr);
  ierr = this->clearMap();
  CHKERRABORT(comm, ierr);
  ierr = this->getTags();
  CHKERRABORT(comm, ierr);
  ierr = this->getOptions(verbose);
  CHKERRABORT(comm, ierr);
 
  this->basicEntityDataPtr = boost::make_shared<BasicEntityData>(moab);
  setRefEntBasicDataPtr(*this, this->basicEntityDataPtr);
 
  ierr = this->initialiseDatabaseFromMesh(verbose);
  CHKERRABORT(comm, ierr);
}

~CoreTmp()

MoFEM::Core::~CoreTmp

(

)

Definition at line 283 of file Core.cpp.

               {
  PetscBool is_finalized;
  PetscFinalized(&is_finalized);
  // Destroy interfaces
  iFaces.clear();
  // This is deprecated ONE should use MoFEM::Core::Initialize
  if (isGloballyInitialised && is_finalized) {
    isGloballyInitialised = false;
  }
}

CoreTmp() [2/2]

template<int V>

MoFEM::CoreTmp< 0 >::CoreTmp ( moab::Interface &  moab, MPI_Comm  comm, const int  verbose, CoreValue< V >    )

protected

Construct core database

Parameters

moab	MoAB interface
comm	MPI communicator

Definition at line 32 of file CoreTemplates.hpp.

    : moab(moab), mofemComm(comm), verbose(verbose),
      initaliseAndBuildField(PETSC_FALSE),
      initaliseAndBuildFiniteElements(PETSC_FALSE) {
 
  ierr = coreGenericConstructor(moab, comm, verbose);
  CHKERRABORT(comm, ierr);
 
  MOFEM_LOG_CHANNEL("WORLD");
  if (verbose > QUIET) {
    MOFEM_LOG_C("WORLD", Sev::verbose, "Core number < %d >", V);
  }
}

Member Function Documentation

add_broken_field()

MoFEMErrorCode MoFEM::Core::add_broken_field ( const std::string  name, const FieldSpace  space, const FieldApproximationBase  base, const FieldCoefficientsNumber  nb_coefficients, std::vector< std::pair< EntityType, std::function< MoFEMErrorCode(BaseFunction::DofsSideMap &)> >>  list_dof_side_map, const TagType  tag_type = MB_TAG_SPARSE, const enum MoFEMTypes  bh = MF_EXCL, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Add field.

Parameters

name	Field name
space	Space L2,H1,Hdiv,Hcurl
continuity	Field continuity (you can set broken space)
base	Approximation base AINSWORTH_LEGENDRE_BASE, AINSWORTH_BERNSTEIN_BEZIER_BASE ...
nb_coefficients	Number of field coefficients @param type_dof_side_map Map of entity type to function returning DofsSideMap
tag_type	Tag type, MB_TAG_DENSE or MB_TAG_SPARSE (default)
bh	Control behavior, if MF_EXCL throws error if exist
verb	Verbosity level

Returns

Return error code

TODO:

Todo:

MB_TAG_DENSE will not work properly in general case. It is need to separate field tags for each entity separately. That will allow for HO orders but homogenous approx. order on each entity. Need some discussion what is optimal solution. MB_TAG_SPARSE gives flexibility, but it not memory efficient. MB_TAG_DENSE uses memory more efficient and in principle allow for better efficiency if properly utilized.

FIXME:

Bug:

Need to resolve problem of dense tags at this stage of development will make only problems

Definition at line 281 of file FieldCore.cpp.

                                                                {
  MoFEMFunctionBegin;
  CHKERR this->addField(name, space, DISCONTINUOUS, base, nb_of_coefficients,
                        tag_type, bh, verb);
 
  auto fit = fIelds.get<FieldName_mi_tag>().find(name);
  if (fit == fIelds.get<FieldName_mi_tag>().end())
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "field <%s> not in database", name.c_str());
 
  for(auto &p : list_dof_side_map) {
    auto &data_side_map = (*fit)->getDofSideMap()[p.first];
    CHKERR p.second(data_side_map);
  }
 
  MoFEMFunctionReturn(0);
}

add_ents_to_field_by_dim() [1/2]

MoFEMErrorCode MoFEM::Core::add_ents_to_field_by_dim ( const EntityHandle  meshset, const int  dim, const std::string &  name, const bool  recursive = true, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Add entities to field meshset.

\not collective

The lower dimension entities are added depending on the space type

Parameters

meshset
dim	dimension
name	name of field
recursive	take entities recursively from embedded entities
verb	verbosity level

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 437 of file FieldCore.cpp.

                                                                              {
  MoFEMFunctionBeginHot;
  Range ents;
  CHKERR get_moab().get_entities_by_dimension(meshset, dim, ents, recursive);
  CHKERR addEntsToFieldByDim(ents, dim, name, verb);
  MOFEM_LOG_SYNCHRONISE(mofemComm);
  MoFEMFunctionReturnHot(0);
}

add_ents_to_field_by_dim() [2/2]

MoFEMErrorCode MoFEM::Core::add_ents_to_field_by_dim ( const Range &  ents, const int  dim, const std::string &  name, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Add entities to field meshset.

Note

not collective

The lower dimension entities are added depending on the space type

Parameters

ents	range of entities
dim	dimension of entities
name	name of field
verb	verbosity level

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 413 of file FieldCore.cpp.

                                                        {
  MoFEMFunctionBegin;
  Range ents_dim = ents.subset_by_dimension(dim);
  CHKERR addEntsToFieldByDim(ents_dim, dim, name, verb);
  MOFEM_LOG_SYNCHRONISE(mofemComm);
  MoFEMFunctionReturn(0);
}

add_ents_to_field_by_type() [1/2]

MoFEMErrorCode MoFEM::Core::add_ents_to_field_by_type ( const EntityHandle  meshset, const EntityType  type, const std::string &  name, const bool  recursive = true, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Add entities to field meshset.

Note

not collective

The lower dimension entities are added depending on the space type

Parameters

meshset
type	of entities
name	name of field
recursive	take entities recursively from embedded entities
verb	verbosity level

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 449 of file FieldCore.cpp.

                                                                               {
  MoFEMFunctionBegin;
  Range ents;
  CHKERR get_moab().get_entities_by_type(meshset, type, ents, recursive);
  if (!ents.empty()) {
    const int dim = get_moab().dimension_from_handle(ents[0]);
    CHKERR addEntsToFieldByDim(ents, dim, name, verb);
  }
  MOFEM_LOG_SYNCHRONISE(mofemComm);
  MoFEMFunctionReturn(0);
}

add_ents_to_field_by_type() [2/2]

MoFEMErrorCode MoFEM::Core::add_ents_to_field_by_type ( const Range &  ents, const EntityType  type, const std::string &  name, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Add entities to field meshset.

Note

not collective

The lower dimension entities are added depending on the space type

Parameters

ents	range of entities
type	type of entities
name	name of field
verb	verbosity level

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 423 of file FieldCore.cpp.

                                                         {
  MoFEMFunctionBegin;
  Range ents_type = ents.subset_by_type(type);
  if (!ents_type.empty()) {
    const int dim = get_moab().dimension_from_handle(ents_type[0]);
    CHKERR addEntsToFieldByDim(ents_type, dim, name, verb);
  }
  MOFEM_LOG_SYNCHRONISE(mofemComm);
  MoFEMFunctionReturn(0);
}

add_ents_to_finite_element_by_bit_ref()

MoFEMErrorCode MoFEM::Core::add_ents_to_finite_element_by_bit_ref ( const BitRefLevel &  bit, const BitRefLevel &  mask, const std::string &  name, EntityType  type, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

add TET entities from given refinement level to finite element database given by name

Note

not collective

Parameters

BitRefLevel	bit
BitRefLevel	mask
finite	element name
finite	element type
verbose	level

Implements MoFEM::CoreInterface.

Definition at line 405 of file FECore.cpp.

                               {
  FECoreFunctionBegin;
 
  if (verb == -1)
    verb = verbose;
  *buildMoFEM &= 1 << 0;
  const BitFEId id = getBitFEId(name);
  const EntityHandle idm = get_finite_element_meshset(id);
 
  auto &ref_MoFEMFiniteElement = refinedFiniteElements.get<Ent_mi_tag>();
  auto miit = ref_MoFEMFiniteElement.lower_bound(get_id_for_min_type(type));
  auto hi_miit = ref_MoFEMFiniteElement.upper_bound(get_id_for_max_type(type));
 
  int nb_add_fes = 0;
  for (; miit != hi_miit; miit++) {
    const auto &bit2 = miit->get()->getBitRefLevel();
    if ((bit2 & mask) != bit2)
      continue;
    if ((bit2 & bit).any()) {
      EntityHandle ent = miit->get()->getEnt();
      CHKERR get_moab().add_entities(idm, &ent, 1);
      nb_add_fes++;
    }
  }
 
  MOFEM_LOG("SYNC", Sev::inform)
      << "Finite element " << name << " added. Nb. of elements added "
      << nb_add_fes << " out of " << std::distance(miit, hi_miit);
 
  MOFEM_LOG_SYNCHRONISE(mofemComm)
 
  MoFEMFunctionReturn(0);
}

add_ents_to_finite_element_by_dim() [1/2]

MoFEMErrorCode MoFEM::Core::add_ents_to_finite_element_by_dim ( const EntityHandle  entities, const int  dim, const std::string &  name, const bool  recursive = true  )

protectedvirtual

add entities to finite element

Note

not collective

Parameters

entities	meshset or range form were entities taken
dim	dimension
name	name of field
recursive	take entities from meshsets in meshset

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 346 of file FECore.cpp.

                                                              {
  EntityHandle idm = no_handle;
  *buildMoFEM &= 1 << 0;
  MoFEMFunctionBegin;
  idm = get_finite_element_meshset(getBitFEId(name));
  Range ents;
  CHKERR get_moab().get_entities_by_dimension(meshset, dim, ents, recursive);
  CHKERR getInterface<BitRefManager>()->setElementsBitRefLevel(ents);
  CHKERR get_moab().add_entities(idm, ents);
  MoFEMFunctionReturn(0);
}

add_ents_to_finite_element_by_dim() [2/2]

MoFEMErrorCode MoFEM::Core::add_ents_to_finite_element_by_dim ( const Range &  ents, const int  dim, const std::string &  name  )

protectedvirtual

add entities to finite elements

Note

not collective

Parameters

ents	range of entities
dim	dimension of entities
name	name of finite element

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 373 of file FECore.cpp.

                                                               {
  EntityHandle idm = no_handle;
  *buildMoFEM &= 1 << 0;
  MoFEMFunctionBegin;
  idm = get_finite_element_meshset(getBitFEId(name));
  CHKERR getInterface<BitRefManager>()->setElementsBitRefLevel(
      ents.subset_by_dimension(dim));
  CHKERR get_moab().add_entities(idm, ents.subset_by_dimension(dim));
  MoFEMFunctionReturn(0);
}

add_ents_to_finite_element_by_MESHSET()

MoFEMErrorCode MoFEM::Core::add_ents_to_finite_element_by_MESHSET ( const EntityHandle  meshset, const std::string &  name, const bool  recursive = false  )

protectedvirtual

add MESHSET element to finite element database given by name

Note

not collective

Parameters

meshset	contains all entities that could be used for finite element
name	Finite Element name

Implements MoFEM::CoreInterface.

Definition at line 441 of file FECore.cpp.

                                                                             {
  MoFEMFunctionBegin;
  *buildMoFEM &= 1 << 0;
  const BitFEId id = getBitFEId(name);
  const EntityHandle idm = get_finite_element_meshset(id);
  if (recursive == false) {
    CHKERR get_moab().add_entities(idm, &meshset, 1);
  } else {
    Range meshsets;
    CHKERR get_moab().get_entities_by_type(meshset, MBENTITYSET, meshsets,
                                           false);
    CHKERR get_moab().add_entities(idm, meshsets);
  }
  MoFEMFunctionReturn(0);
}

add_ents_to_finite_element_by_type() [1/2]

MoFEMErrorCode MoFEM::Core::add_ents_to_finite_element_by_type ( const EntityHandle  entities, const EntityType  type, const std::string &  name, const bool  recursive = true  )

protectedvirtual

add entities to finite element

Note

not collective

Parameters

entities	meshset or range form were entities taken
type	type of entity
name	name of field
recursive	take entities from meshsets in meshset

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 329 of file FECore.cpp.

                          {
  *buildMoFEM &= 1 << 0;
  EntityHandle idm = no_handle;
  MoFEMFunctionBegin;
 
  idm = get_finite_element_meshset(getBitFEId(name));
  Range ents;
  CHKERR get_moab().get_entities_by_type(meshset, type, ents, recursive);
  CHKERR getInterface<BitRefManager>()->setElementsBitRefLevel(ents);
  CHKERR get_moab().add_entities(idm, ents);
 
  MoFEMFunctionReturn(0);
}

add_ents_to_finite_element_by_type() [2/2]

MoFEMErrorCode MoFEM::Core::add_ents_to_finite_element_by_type ( const Range &  ents, const EntityType  type, const std::string &  name  )

protectedvirtual

add entities to finite elements

Note

not collective

Parameters

ents	range of entities
type	type of entity (MBVERTEX, MBEDGE, MBTRI, ...)
name	name of finite element

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 360 of file FECore.cpp.

                                                                     {
  EntityHandle idm = no_handle;
  *buildMoFEM &= 1 << 0;
  MoFEMFunctionBegin;
  idm = get_finite_element_meshset(getBitFEId(name));
  CHKERR getInterface<BitRefManager>()->setElementsBitRefLevel(
      ents.subset_by_type(type));
  CHKERR get_moab().add_entities(idm, ents.subset_by_type(type));
  MoFEMFunctionReturn(0);
} // namespace MoFEM

add_ents_to_finite_element_EntType_by_bit_ref() [1/2]

MoFEMErrorCode MoFEM::Core::add_ents_to_finite_element_EntType_by_bit_ref ( const BitRefLevel &  bit, const BitRefLevel &  mask, const std::string &  name, EntityType  type, int  verb = DEFAULT_VERBOSITY  )

protected

Definition at line 396 of file FECore.cpp.

                               {
  MoFEMFunctionBegin;
  CHKERR add_ents_to_finite_element_by_bit_ref(bit, mask, name, type, verb);
 
  MoFEMFunctionReturn(0);
}

add_ents_to_finite_element_EntType_by_bit_ref() [2/2]

MoFEMErrorCode MoFEM::Core::add_ents_to_finite_element_EntType_by_bit_ref ( const BitRefLevel &  bit, const std::string &  name, EntityType  type, int  verb = DEFAULT_VERBOSITY  )

protected

Definition at line 386 of file FECore.cpp.

                                                                               {
  MoFEMFunctionBegin;
  CHKERR add_ents_to_finite_element_by_bit_ref(bit, BitRefLevel().set(), name,
                                               type, verb);
 
  MoFEMFunctionReturn(0);
}

add_field()

MoFEMErrorCode MoFEM::Core::add_field ( const std::string  name, const FieldSpace  space, const FieldApproximationBase  base, const FieldCoefficientsNumber  nb_coefficients, const TagType  tag_type = MB_TAG_SPARSE, const enum MoFEMTypes  bh = MF_EXCL, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Add field.

Parameters

name	Field name
space	Space L2,H1,Hdiv,Hcurl
continuity	Field continuity (you can set broken space)
base	Approximation base AINSWORTH_LEGENDRE_BASE, AINSWORTH_BERNSTEIN_BEZIER_BASE ...
nb_coefficients	Number of field coefficients
tag_type	Tag type, MB_TAG_DENSE or MB_TAG_SPARSE (default)
bh	Control behavior, if MF_EXCL throws error if exist
verb	Verbosity level

Returns

Return error code

TODO:

Todo:

MB_TAG_DENSE will not work properly in general case. It is need to separate field tags for each entity separately. That will allow for HO orders but homogenous approx. order on each entity. Need some discussion what is optimal solution. MB_TAG_SPARSE gives flexibility, but it not memory efficient. MB_TAG_DENSE uses memory more efficient and in principle allow for better efficiency if properly utilized.

FIXME:

Bug:

Need to resolve problem of dense tags at this stage of development will make only problems

Implements MoFEM::CoreInterface.

Definition at line 312 of file FieldCore.cpp.

                                         {
  return this->addField(name, space, CONTINUOUS, base, nb_of_coefficients,
                        tag_type, bh, verb);
}

add_finite_element()

MoFEMErrorCode MoFEM::Core::add_finite_element ( const std::string &  fe_name, enum MoFEMTypes  bh = MF_EXCL, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

add finite element

Parameters

name	finite element name

Note

add_file is a collective, should be executed on all processors. Otherwise could lead to deadlock.

Example

CHKERR mField.add_finite_element("ELASTIC");
CHKERR mField.add_finite_element("PLASTIC");

Implements MoFEM::CoreInterface.

Definition at line 43 of file FECore.cpp.

                                                                      {
  FECoreFunctionBegin;
  *buildMoFEM &= 1 << 0;
  if (verb == -1) {
    verb = verbose;
  }
 
  // Add finite element meshset to partion meshset. In case of no elements
  // on processor part, when mesh file is read, finite element meshset is
  // prevented from deletion by moab reader.
  auto add_meshset_to_partition = [&](auto meshset) {
    MoFEMFunctionBegin;
    const void *tag_vals[] = {&rAnk};
    ParallelComm *pcomm = ParallelComm::get_pcomm(
        &get_moab(), get_basic_entity_data_ptr()->pcommID);
    Tag part_tag = pcomm->part_tag();
    Range tagged_sets;
    CHKERR get_moab().get_entities_by_type_and_tag(0, MBENTITYSET, &part_tag,
                                                   tag_vals, 1, tagged_sets,
                                                   moab::Interface::UNION);
    for (auto s : tagged_sets)
      CHKERR get_moab().add_entities(s, &meshset, 1);
    MoFEMFunctionReturn(0);
  };
 
  auto &finite_element_name_set =
      finiteElements.get<FiniteElement_name_mi_tag>();
  auto it_fe = finite_element_name_set.find(fe_name);
 
  if (bh == MF_EXCL) {
    if (it_fe != finite_element_name_set.end()) {
      SETERRQ1(mofemComm, MOFEM_NOT_FOUND, "this < %s > is there",
               fe_name.c_str());
    }
 
  } else {
    if (it_fe != finite_element_name_set.end())
      MoFEMFunctionReturnHot(0);
  }
  EntityHandle meshset;
  CHKERR get_moab().create_meshset(MESHSET_SET, meshset);
  CHKERR add_meshset_to_partition(meshset);
 
  // id
  int fe_shift = 0;
  for (; finiteElements.get<BitFEId_mi_tag>().find(BitFEId().set(fe_shift)) !=
         finiteElements.get<BitFEId_mi_tag>().end();
       ++fe_shift) {
  }
 
  auto id = BitFEId().set(fe_shift);
  CHKERR get_moab().tag_set_data(th_FEId, &meshset, 1, &id);
 
  // id name
  void const *tag_data[] = {fe_name.c_str()};
  int tag_sizes[1];
  tag_sizes[0] = fe_name.size();
  CHKERR get_moab().tag_set_by_ptr(th_FEName, &meshset, 1, tag_data, tag_sizes);
 
  // add FiniteElement
  auto p = finiteElements.insert(
      boost::shared_ptr<FiniteElement>(new FiniteElement(moab, meshset)));
  if (!p.second)
    SETERRQ(mofemComm, MOFEM_OPERATION_UNSUCCESSFUL,
            "FiniteElement not inserted");
 
  if (verb > QUIET)
    MOFEM_LOG("WORLD", Sev::inform) << "Add finite element " << fe_name;
 
  MoFEMFunctionReturn(0);
}

add_problem()

MoFEMErrorCode MoFEM::Core::add_problem ( const std::string &  name, enum MoFEMTypes  bh = MF_EXCL, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Add problem.

Note

add_file is a collective, should be executed on all processors. Otherwise could lead to deadlock.

Implements MoFEM::CoreInterface.

Definition at line 84 of file ProblemsCore.cpp.

                                           {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  auto miit = pRoblems.get<Problem_mi_tag>().find(name);
  if (miit == pRoblems.get<Problem_mi_tag>().end()) {
 
    int p_shift = 0;
    for (; pRoblems.get<BitProblemId_mi_tag>().find(BitProblemId().set(
               p_shift)) != pRoblems.get<BitProblemId_mi_tag>().end();
         ++p_shift) {
    }
 
    auto id = BitProblemId().set(p_shift);
    CHKERR addProblem(id, name, verb);
    
  } else if (bh == MF_EXCL) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "problem is in database %s",
             name.c_str());
  }
  MoFEMFunctionReturn(0);
}

addEntsToFieldByDim()

MoFEMErrorCode MoFEM::Core::addEntsToFieldByDim ( const Range &  ents, const int  dim, const std::string &  name, int  verb = DEFAULT_VERBOSITY  )

protected

Definition at line 321 of file FieldCore.cpp.

                                                                          {
 
  *buildMoFEM = 0;
  EntityHandle idm = no_handle;
  if (verb == -1)
    verb = verbose;
 
  MOFEM_LOG_CHANNEL("SYNC");
  MOFEM_LOG_TAG("SYNC", "FieldCore");
  MOFEM_LOG_FUNCTION();
 
  MoFEMFunctionBegin;
  idm = get_field_meshset(name);
  FieldSpace space;
  CHKERR get_moab().tag_get_data(th_FieldSpace, &idm, 1, &space);
  FieldContinuity continuity;
  CHKERR get_moab().tag_get_data(th_FieldContinuity, &idm, 1, &continuity);
 
  switch (continuity) {
  case CONTINUOUS:
  case DISCONTINUOUS:
    break;
  default:
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "sorry, unknown continuity added to entity");
  }
 
  std::vector<int> nb_ents_on_dim(3, 0);
  switch (space) {
  case L2:
    CHKERR get_moab().add_entities(idm, ents);
    break;
  case H1:
    CHKERR get_moab().add_entities(idm, ents);
    if (continuity == DISCONTINUOUS)
      break;
    for (int dd = 0; dd != dim; ++dd) {
      Range adj_ents;
      CHKERR get_moab().get_adjacencies(ents, dd, false, adj_ents,
                                        moab::Interface::UNION);
      if (dd == 0) {
        Range topo_nodes;
        CHKERR get_moab().get_connectivity(ents, topo_nodes, true);
        Range mid_nodes;
        CHKERR get_moab().get_connectivity(ents, mid_nodes, false);
        mid_nodes = subtract(mid_nodes, topo_nodes);
        adj_ents = subtract(adj_ents, mid_nodes);
      }
      CHKERR get_moab().add_entities(idm, adj_ents);
      nb_ents_on_dim[dd] = adj_ents.size();
    }
    break;
  case HCURL:
    CHKERR get_moab().add_entities(idm, ents);
    if (continuity == DISCONTINUOUS)
      break;
    for (int dd = 1; dd != dim; ++dd) {
      Range adj_ents;
      CHKERR get_moab().get_adjacencies(ents, dd, false, adj_ents,
                                        moab::Interface::UNION);
      CHKERR get_moab().add_entities(idm, adj_ents);
      nb_ents_on_dim[dd] = adj_ents.size();
    }
    break;
  case HDIV:
    CHKERR get_moab().add_entities(idm, ents);
    if (continuity == DISCONTINUOUS)
      break;
    if (dim > 2) {
      Range adj_ents;
      CHKERR get_moab().get_adjacencies(ents, 2, false, adj_ents,
                                        moab::Interface::UNION);
      CHKERR get_moab().add_entities(idm, adj_ents);
      nb_ents_on_dim[2] = adj_ents.size();
    }
    break;
  default:
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "sorry, unknown space added to entity");
  }
 
  if (verb >= VERBOSE) {
    MOFEM_LOG("SYNC", Sev::noisy) << "add entities to field " << name;
    MOFEM_LOG("SYNC", Sev::noisy) << "\tnb. add ents " << ents.size();
    MOFEM_LOG("SYNC", Sev::noisy) << "\tnb. add faces " << nb_ents_on_dim[2];
    MOFEM_LOG("SYNC", Sev::noisy) << "\tnb. add edges " << nb_ents_on_dim[1];
    MOFEM_LOG("SYNC", Sev::noisy) << "\tnb. add nodes " << nb_ents_on_dim[0];
  }
  MoFEMFunctionReturn(0);
}

addField()

MoFEMErrorCode MoFEM::Core::addField ( const std::string &  name, const FieldSpace  space, const FieldContinuity  continuity, const FieldApproximationBase  base, const FieldCoefficientsNumber  nb_coefficients, const TagType  tag_type, const enum MoFEMTypes  bh, int  verb  )

protected

Template for add_field.

Template Parameters

CoreN

Parameters

name
space
continuity
base
nb_coefficients
tag_type
bh
verb

Returns

MoFEMErrorCode

Definition at line 108 of file FieldCore.cpp.

                                        {
  MOFEM_LOG_CHANNEL("WORLD");
  MOFEM_LOG_TAG("WORLD", "FieldCore");
  MOFEM_LOG_CHANNEL("SYNC");
  MOFEM_LOG_TAG("SYNC", "FieldCore");
  MOFEM_LOG_FUNCTION();
  MoFEMFunctionBegin;
 
  // Add field mesh set to partion meshset. In case of no elements
  // on processor part, when mesh file is read, finite element meshset is
  // prevented from deletion by moab reader.
  auto add_meshset_to_partition = [&](auto meshset) {
    MoFEMFunctionBegin;
    const void *tag_vals[] = {&rAnk};
    ParallelComm *pcomm = ParallelComm::get_pcomm(
        &get_moab(), get_basic_entity_data_ptr()->pcommID);
    Tag part_tag = pcomm->part_tag();
    Range tagged_sets;
    CHKERR get_moab().get_entities_by_type_and_tag(0, MBENTITYSET, &part_tag,
                                                   tag_vals, 1, tagged_sets,
                                                   moab::Interface::UNION);
    for (auto s : tagged_sets)
      CHKERR get_moab().add_entities(s, &meshset, 1);
    MoFEMFunctionReturn(0);
  };
 
  auto create_tags = [&](auto meshset, auto id) {
    MoFEMFunctionBegin;
    CHKERR get_moab().tag_set_data(th_FieldId, &meshset, 1, &id);
    // space
    CHKERR get_moab().tag_set_data(th_FieldSpace, &meshset, 1, &space);
    // continuity
    CHKERR get_moab().tag_set_data(th_FieldContinuity, &meshset, 1,
                                   &continuity);
    // base
    CHKERR get_moab().tag_set_data(th_FieldBase, &meshset, 1, &base);
 
    // name
    void const *tag_data[] = {name.c_str()};
    int tag_sizes[1];
    tag_sizes[0] = name.size();
    CHKERR get_moab().tag_set_by_ptr(th_FieldName, &meshset, 1, tag_data,
                                     tag_sizes);
    // rank
    Tag th_rank;
    int def_rank = 1;
    const std::string tag_rank_name = "_Field_Rank_" + name;
    CHKERR get_moab().tag_get_handle(tag_rank_name.c_str(), 1, MB_TYPE_INTEGER,
                                     th_rank, MB_TAG_CREAT | MB_TAG_SPARSE,
                                     &def_rank);
    CHKERR get_moab().tag_set_data(th_rank, &meshset, 1, &nb_of_coefficients);
 
    Version file_ver;
    ierr = UnknownInterface::getFileVersion(moab, file_ver);
    CHK_THROW_MESSAGE(ierr, "Not known file version");
    if (file_ver.majorVersion >= 0 && file_ver.minorVersion >= 12 &&
        file_ver.buildVersion >= 1) {
      const std::string name_data_prefix("_App_Data_");
      void const *tag_prefix_data[] = {name_data_prefix.c_str()};
      int tag_prefix_sizes[1];
      tag_prefix_sizes[0] = name_data_prefix.size();
      CHKERR get_moab().tag_set_by_ptr(th_FieldName_DataNamePrefix, &meshset, 1,
                                       tag_prefix_data, tag_prefix_sizes);
      Tag th_app_order, th_field_data, th_field_data_vert;
 
      // order
      ApproximationOrder def_approx_order = -1;
      const std::string tag_approx_order_name = "_App_Order_" + name;
      CHKERR get_moab().tag_get_handle(
          tag_approx_order_name.c_str(), 1, MB_TYPE_INTEGER, th_app_order,
          MB_TAG_CREAT | MB_TAG_SPARSE, &def_approx_order);
 
      // data
      std::string tag_data_name = name_data_prefix + name;
      const int def_len = 0;
      CHKERR get_moab().tag_get_handle(
          tag_data_name.c_str(), def_len, MB_TYPE_DOUBLE, th_field_data,
          MB_TAG_CREAT | MB_TAG_VARLEN | MB_TAG_SPARSE, NULL);
      std::string tag_data_name_verts = name_data_prefix + name + "_V";
      VectorDouble def_vert_data(nb_of_coefficients);
      def_vert_data.clear();
      CHKERR get_moab().tag_get_handle(
          tag_data_name_verts.c_str(), nb_of_coefficients, MB_TYPE_DOUBLE,
          th_field_data_vert, MB_TAG_CREAT | tag_type, &*def_vert_data.begin());
    } else {
      // Deprecated names
      const std::string name_data_prefix("_App_Data");
      void const *tag_prefix_data[] = {name_data_prefix.c_str()};
      int tag_prefix_sizes[1];
      tag_prefix_sizes[0] = name_data_prefix.size();
      CHKERR get_moab().tag_set_by_ptr(th_FieldName_DataNamePrefix, &meshset, 1,
                                       tag_prefix_data, tag_prefix_sizes);
      Tag th_app_order, th_field_data, th_field_data_vert;
 
      // order
      ApproximationOrder def_approx_order = -1;
      const std::string tag_approx_order_name = "_App_Order_" + name;
      CHKERR get_moab().tag_get_handle(
          tag_approx_order_name.c_str(), 1, MB_TYPE_INTEGER, th_app_order,
          MB_TAG_CREAT | MB_TAG_SPARSE, &def_approx_order);
 
      // data
      std::string tag_data_name = name_data_prefix + name;
      const int def_len = 0;
      CHKERR get_moab().tag_get_handle(
          tag_data_name.c_str(), def_len, MB_TYPE_DOUBLE, th_field_data,
          MB_TAG_CREAT | MB_TAG_VARLEN | MB_TAG_SPARSE, NULL);
      std::string tag_data_name_verts = name_data_prefix + name + "V";
      VectorDouble def_vert_data(nb_of_coefficients);
      def_vert_data.clear();
      CHKERR get_moab().tag_get_handle(
          tag_data_name_verts.c_str(), nb_of_coefficients, MB_TYPE_DOUBLE,
          th_field_data_vert, MB_TAG_CREAT | tag_type, &*def_vert_data.begin());
    }
 
    MoFEMFunctionReturn(0);
  };
 
  if (verb == -1)
    verb = verbose;
  *buildMoFEM = 0;
  auto fit = fIelds.get<FieldName_mi_tag>().find(name);
  if (fit != fIelds.get<FieldName_mi_tag>().end()) {
    if (bh == MF_EXCL)
      SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
               "field is <%s> in database", name.c_str());
 
  } else {
 
    EntityHandle meshset;
    CHKERR get_moab().create_meshset(MESHSET_SET, meshset);
    CHKERR add_meshset_to_partition(meshset);
 
    // id
    int field_shift = 0;
    for (;
         fIelds.get<BitFieldId_mi_tag>().find(BitFieldId().set(field_shift)) !=
         fIelds.get<BitFieldId_mi_tag>().end();
         ++field_shift) {
      if (field_shift == BITFEID_SIZE)
        SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE,
                "Maximal number of fields exceeded");
    }
 
    auto id = BitFieldId().set(field_shift);
    CHKERR create_tags(meshset, id);
 
    auto p = fIelds.insert(boost::make_shared<Field>(moab, meshset));
    if (verb > QUIET) {
      MOFEM_LOG("WORLD", Sev::inform) << "Add field " << **p.first;
      MOFEM_LOG("WORLD", Sev::noisy)
          << "Field " << (*p.first)->getName() << " core value < "
          << this->getValue() << " > field value ( "
          << static_cast<int>((*p.first)->getBitNumber()) << " )";
    }
 
    if (!p.second)
      SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_FOUND,
               "field not inserted %s (top tip, it could be already "
               "there)",
               Field(moab, meshset).getName().c_str());
  }
 
  MOFEM_LOG_CHANNEL("WORLD");
  MOFEM_LOG_CHANNEL("SYNC");
  MoFEMFunctionReturn(0);
}

addPrismToDatabase()

MoFEMErrorCode MoFEM::Core::addPrismToDatabase	(	const EntityHandle	prism,
		int	verb = DEFAULT_VERBOSITY
	)

add prim element

FIXME: This is dirt solution, need to be fixed

Parameters

prism	prim handle
verb	verbosity level

Returns

error code

Definition at line 522 of file Core.cpp.

                                                                          {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  std::pair<RefEntity_multiIndex::iterator, bool> p_ent;
  p_ent = refinedEntities.insert(
      boost::make_shared<RefEntity>(basicEntityDataPtr, prism));
  if (p_ent.second) {
    std::pair<RefElement_multiIndex::iterator, bool> p;
    p = refinedFiniteElements.insert(
        boost::shared_ptr<RefElement>(new RefElement_PRISM(*p_ent.first)));
    int num_nodes;
    const EntityHandle *conn;
    CHKERR get_moab().get_connectivity(prism, conn, num_nodes, true);
    Range face_side3, face_side4;
    CHKERR get_moab().get_adjacencies(conn, 3, 2, false, face_side3);
    CHKERR get_moab().get_adjacencies(&conn[3], 3, 2, false, face_side4);
    if (face_side3.size() != 1)
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "prism don't have side face 3");
    if (face_side4.size() != 1)
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "prims don't have side face 4");
    p.first->get()->getSideNumberPtr(*face_side3.begin());
    p.first->get()->getSideNumberPtr(*face_side4.begin());
  }
  MoFEMFunctionReturn(0);
}

addProblem()

MoFEMErrorCode MoFEM::Core::addProblem ( const BitProblemId  id, const std::string &  name, int  verb = DEFAULT_VERBOSITY  )

protected

add problem

Parameters

id	problem id
name	problem name
verb	verbosity level

Returns

MoFEMErrorCode

Definition at line 27 of file ProblemsCore.cpp.

                                          {
  ProblemCoreFunctionBegin;
 
  if (verb == -1)
    verb = verbose;
  EntityHandle meshset;
  CHKERR get_moab().create_meshset(MESHSET_SET, meshset);
  CHKERR get_moab().tag_set_data(th_ProblemId, &meshset, 1, &id);
 
  // Add problem meshset to partion meshset. In case of no elements
  // on processor part, when mesh file is read, finite element meshset is
  // prevented from deletion by moab reader.
  auto add_meshset_to_partition = [&](auto meshset) {
    MoFEMFunctionBegin;
    const void *tag_vals[] = {&rAnk};
    ParallelComm *pcomm = ParallelComm::get_pcomm(
        &get_moab(), get_basic_entity_data_ptr()->pcommID);
    Tag part_tag = pcomm->part_tag();
    Range tagged_sets;
    CHKERR get_moab().get_entities_by_type_and_tag(0, MBENTITYSET, &part_tag,
                                                   tag_vals, 1, tagged_sets,
                                                   moab::Interface::UNION);
    for (auto s : tagged_sets)
      CHKERR get_moab().add_entities(s, &meshset, 1);
    MoFEMFunctionReturn(0);
  };
  CHKERR add_meshset_to_partition(meshset);
 
  void const *tag_data[] = {name.c_str()};
  int tag_sizes[1];
  tag_sizes[0] = name.size();
  CHKERR get_moab().tag_set_by_ptr(th_ProblemName, &meshset, 1, tag_data,
                                   tag_sizes);
  // create entry
  auto p = pRoblems.insert(Problem(moab, meshset));
  if (!p.second) {
    MOFEM_LOG_FUNCTION();
    MOFEM_LOG_ATTRIBUTES("SELF", LogManager::BitScope);
    MOFEM_LOG("SELF", Sev::error) << "Following problem can not be added:";
    MOFEM_LOG("SELF", Sev::error)
        << "Problem " << name << " id(" << id.to_ulong() << ") " << id
        << " added meshset " << meshset;
    MOFEM_LOG("SELF", Sev::error) << "List of problems already in databse:";
    for (auto &p : pRoblems) {
      MOFEM_LOG("SELF", Sev::error)
          << p.getName() << " id(" << p.getId().to_ulong() << ") " << id
          << " on meshset " << p.meshset;
    }
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Problem not added");
  }
 
  MOFEM_LOG("WORLD", Sev::inform) << "Add problem " << name;
 
  MoFEMFunctionReturn(0);
}

build_adjacencies() [1/3]

MoFEMErrorCode MoFEM::Core::build_adjacencies ( const BitRefLevel &  bit, const BitRefLevel &  mask, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

build adjacencies

Parameters

bit	adjacencies for refine level
mask	mask for bit level

This function will get information of adjacent finite elements and fields of all entities. If this is not executed, partitioning the problem is not possible. Adjacency map is based on degrees of freedom adjacent to elements. This linked to geometric element connectivity.

If new degrees of freedom or new finite elements are added to the database, adjacency map has to be rebuild.

Implements MoFEM::CoreInterface.

Definition at line 814 of file FECore.cpp.

                                                                          {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  Range ents;
  CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents);
 
  CHKERR build_adjacencies(ents, verb);
 
  MoFEMFunctionReturn(0);
}

build_adjacencies() [2/3]

MoFEMErrorCode MoFEM::Core::build_adjacencies ( const BitRefLevel &  bit, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

build adjacencies

Parameters

bit	adjacencies for refine level

This function will get information of adjacent finite elements and fields of all entities. If this is not executed, partitioning the problem is not possible. Adjacency map is based on degrees of freedom adjacent to elements. This linked to geometric element connectivity.

If new degrees of freedom or new finite elements are added to the database, adjacency map has to be rebuild.

Implements MoFEM::CoreInterface.

Definition at line 826 of file FECore.cpp.

                                                                       {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  CHKERR build_adjacencies(bit, BitRefLevel().set(), verb);
 
  MoFEMFunctionReturn(0);
}

build_adjacencies() [3/3]

MoFEMErrorCode MoFEM::Core::build_adjacencies ( const Range &  ents, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

build adjacencies

Parameters

list	of entities

This function will get information of adjacent finite elements and fields of all entities. If this is not executed, partitioning the problem is not possible. Adjacency map is based on degrees of freedom adjacent to elements. This linked to geometric element connectivity.

If new degrees of freedom or new finite elements are added to the database, adjacency map has to be rebuild.

Implements MoFEM::CoreInterface.

Definition at line 742 of file FECore.cpp.

                                                                  {
  FECoreFunctionBegin;
  if (verb == DEFAULT_VERBOSITY)
    verb = verbose;
 
  if (!((*buildMoFEM) & BUILD_FIELD))
    SETERRQ(mofemComm, MOFEM_NOT_FOUND, "field not build");
  if (!((*buildMoFEM) & BUILD_FE))
    SETERRQ(mofemComm, MOFEM_NOT_FOUND, "fe not build");
  for (auto peit = ents.pair_begin(); peit != ents.pair_end(); ++peit) {
    auto fit = entsFiniteElements.get<Ent_mi_tag>().lower_bound(peit->first);
    auto hi_fit =
        entsFiniteElements.get<Ent_mi_tag>().upper_bound(peit->second);
    for (; fit != hi_fit; ++fit) {
      if ((*fit)->getBitFieldIdRow().none() &&
          (*fit)->getBitFieldIdCol().none() &&
          (*fit)->getBitFieldIdData().none())
        continue;
      int by = BYROW;
      if ((*fit)->getBitFieldIdRow() != (*fit)->getBitFieldIdCol())
        by |= BYCOL;
      if ((*fit)->getBitFieldIdRow() != (*fit)->getBitFieldIdData())
        by |= BYDATA;
      FieldEntityEntFiniteElementAdjacencyMap_change_ByWhat modify_row(by);
      auto hint = entFEAdjacencies.end();
      for (auto e : *(*fit)->getRowFieldEntsPtr()) {
        hint = entFEAdjacencies.emplace_hint(hint, e.lock(), *fit);
        bool success = entFEAdjacencies.modify(hint, modify_row);
        if (!success)
          SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                  "modification unsuccessful");
      }
      if ((*fit)->getBitFieldIdRow() != (*fit)->getBitFieldIdCol()) {
        int by = BYCOL;
        if ((*fit)->getBitFieldIdCol() != (*fit)->getBitFieldIdData())
          by |= BYDATA;
        FieldEntityEntFiniteElementAdjacencyMap_change_ByWhat modify_col(by);
        auto hint = entFEAdjacencies.end();
        for (auto e : *(*fit)->getColFieldEntsPtr()) {
          hint = entFEAdjacencies.emplace_hint(hint, e.lock(), *fit);
          bool success = entFEAdjacencies.modify(hint, modify_col);
          if (!success)
            SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                    "modification unsuccessful");
        }
      }
      if ((*fit)->getBitFieldIdRow() != (*fit)->getBitFieldIdData() ||
          (*fit)->getBitFieldIdCol() != (*fit)->getBitFieldIdData()) {
        FieldEntityEntFiniteElementAdjacencyMap_change_ByWhat modify_data(
            BYDATA);
        auto hint = entFEAdjacencies.end();
        for (auto &e : (*fit)->getDataFieldEnts()) {
          hint = entFEAdjacencies.emplace_hint(hint, e.lock(), *fit);
          bool success = entFEAdjacencies.modify(hint, modify_data);
          if (!success)
            SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                    "modification unsuccessful");
        }
      }
    }
  }
 
  if (verb >= VERBOSE) {
    MOFEM_LOG("WORLD", Sev::inform)
        << "Number of adjacencies " << entFEAdjacencies.size();
    MOFEM_LOG_SYNCHRONISE(mofemComm)
  }
 
  *buildMoFEM |= 1 << 2;
  MoFEMFunctionReturn(0);
}

build_field()

MoFEMErrorCode MoFEM::Core::build_field ( const std::string  field_name, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

build field by name

Parameters

field_name
verb	m

Returns

MoFEMErrorCode

Implements MoFEM::CoreInterface.

Definition at line 1302 of file FieldCore.cpp.

                                                                     {
  FieldCoreFunctionBegin;
  auto field_it = fIelds.get<FieldName_mi_tag>().find(field_name);
  if (field_it == fIelds.get<FieldName_mi_tag>().end())
    SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "Field < %s > not found",
             field_name.c_str());
 
  CHKERR this->buildField(*field_it, verb);
  if (verb > QUIET)
    MOFEM_LOG_SYNCHRONISE(mofemComm);
  MoFEMFunctionReturn(0);
}

build_fields()

MoFEMErrorCode MoFEM::Core::build_fields ( int  verb = DEFAULT_VERBOSITY )

protectedvirtual

build fields

Implements MoFEM::CoreInterface.

Definition at line 1315 of file FieldCore.cpp.

                                          {
  FieldCoreFunctionBegin;
  if (verb == -1)
    verb = verbose;
 
  for (auto field : fIelds.get<BitFieldId_mi_tag>())
    CHKERR this->buildField(field, verb);
 
  *buildMoFEM = 1 << 0;
  if (verb > QUIET) {
    MOFEM_LOG("SYNC", Sev::verbose) << "Number of dofs " << dofsField.size();
    MOFEM_LOG_SYNCHRONISE(mofemComm);
  }
 
  MoFEMFunctionReturn(0);
}

build_finite_elements() [1/3]

MoFEMErrorCode MoFEM::Core::build_finite_elements ( const BitRefLevel &  bit, int  verb = DEFAULT_VERBOSITY  )

protected

Definition at line 705 of file FECore.cpp.

                                                                           {
  MoFEMFunctionBeginHot;
  SETERRQ(mofemComm, MOFEM_NOT_IMPLEMENTED, "Not yet implemented");
  MoFEMFunctionReturnHot(0);
}

build_finite_elements() [2/3]

MoFEMErrorCode MoFEM::Core::build_finite_elements ( const string  fe_name, const Range *const  ents_ptr = nullptr, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Build finite elements.

Build finite element data structures. Have to be run before problem and adjacencies are constructed.

Parameters

fe_name	Name of finite element
ents_ptr	Pointer to range of finite elements
verb	Verbosity level

Returns

Error code

Implements MoFEM::CoreInterface.

Definition at line 711 of file FECore.cpp.

                                                     {
  MoFEMFunctionBeginHot;
  if (verb == -1)
    verb = verbose;
 
  auto fe_miit = finiteElements.get<FiniteElement_name_mi_tag>().find(fe_name);
  if (fe_miit == finiteElements.get<FiniteElement_name_mi_tag>().end())
    SETERRQ1(mofemComm, MOFEM_NOT_FOUND, "Finite element <%s> not found",
             fe_name.c_str());
 
  CHKERR buildFiniteElements(*fe_miit, ents_ptr, verb);
 
  if (verb >= VERBOSE) {
    auto &fe_ents = entsFiniteElements.get<Unique_mi_tag>();
    auto miit = fe_ents.lower_bound(
        EntFiniteElement::getLocalUniqueIdCalculate(0, (*fe_miit)->getFEUId()));
    auto hi_miit =
        fe_ents.upper_bound(EntFiniteElement::getLocalUniqueIdCalculate(
            get_id_for_max_type<MBENTITYSET>(), (*fe_miit)->getFEUId()));
    const auto count = std::distance(miit, hi_miit);
    MOFEM_LOG("SYNC", Sev::inform) << "Finite element " << fe_name
                                   << " added. Nb. of elements added " << count;
    MOFEM_LOG_SYNCHRONISE(mofemComm);
  }
 
  *buildMoFEM |= 1 << 1;
  MoFEMFunctionReturnHot(0);
}

build_finite_elements() [3/3]

MoFEMErrorCode MoFEM::Core::build_finite_elements ( int  verb = DEFAULT_VERBOSITY )

protectedvirtual

Build finite elements.

Build finite element data structures. Have to be run before problem and adjacencies are constructed.

Parameters

verb	Verbosity level

Returns

Error code

Implements MoFEM::CoreInterface.

Definition at line 655 of file FECore.cpp.

                                                   {
  FECoreFunctionBegin;
 
  if (verb == DEFAULT_VERBOSITY)
    verb = verbose;
 
  // loop Finite Elements
  for (auto &fe : finiteElements)
    CHKERR buildFiniteElements(fe, NULL, verb);
 
  if (verb > QUIET) {
 
    auto &fe_ents = entsFiniteElements.get<Unique_mi_tag>();
    for (auto &fe : finiteElements) {
      auto miit = fe_ents.lower_bound(
          EntFiniteElement::getLocalUniqueIdCalculate(0, fe->getFEUId()));
      auto hi_miit =
          fe_ents.upper_bound(EntFiniteElement::getLocalUniqueIdCalculate(
              get_id_for_max_type<MBENTITYSET>(), fe->getFEUId()));
      const auto count = std::distance(miit, hi_miit);
      MOFEM_LOG("SYNC", Sev::inform)
          << "Finite element " << fe->getName()
          << " added. Nb. of elements added " << count;
      MOFEM_LOG("SYNC", Sev::noisy) << *fe;
 
      auto slg = MoFEM::LogManager::getLog("SYNC");
      for (auto &field : fIelds) {
        auto rec = slg.open_record(keywords::severity = Sev::verbose);
        if (rec) {
          logging::record_ostream strm(rec);
          strm << "Field " << field->getName() << " on finite element: ";
          if ((field->getId() & fe->getBitFieldIdRow()).any())
            strm << "row ";
          if ((field->getId() & fe->getBitFieldIdCol()).any())
            strm << "columns ";
          if ((field->getId() & fe->getBitFieldIdData()).any())
            strm << "data";
          strm.flush();
          slg.push_record(boost::move(rec));
        }
      }
    }
 
    MOFEM_LOG_SYNCHRONISE(mofemComm);
  }
 
  *buildMoFEM |= 1 << 1;
  MoFEMFunctionReturn(0);
}

build_problem_on_distributed_mesh()

MoFEMErrorCode MoFEM::Core::build_problem_on_distributed_mesh ( int  verb = DEFAULT_VERBOSITY )

protected

Definition at line 257 of file ProblemsCore.cpp.

                                                               {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  Problem_multiIndex::iterator p_miit = pRoblems.begin();
  for (; p_miit != pRoblems.end(); p_miit++) {
    CHKERR getInterface<ProblemsManager>()->buildProblemOnDistributedMesh(
        const_cast<Problem *>(&*p_miit), verb);
  }
  MoFEMFunctionReturn(0);
}

build_problems()

MoFEMErrorCode MoFEM::Core::build_problems ( int  verb = DEFAULT_VERBOSITY )

protected

Definition at line 317 of file ProblemsCore.cpp.

                                            {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  if (!((*buildMoFEM) & BUILD_FIELD))
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "fields not build");
  if (!((*buildMoFEM) & BUILD_FE))
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "FEs not build");
  if (!((*buildMoFEM) & BUILD_ADJ))
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "adjacencies not build");
  // iterate problems
  Problem_multiIndex::iterator p_miit = pRoblems.begin();
  for (; p_miit != pRoblems.end(); p_miit++) {
    Problem *problem_ptr = const_cast<Problem *>(&*p_miit);
    CHKERR getInterface<ProblemsManager>()->buildProblem(problem_ptr, false,
                                                         verb);
  }
  *buildMoFEM |= BUILD_PROBLEM;
  MoFEMFunctionReturn(0);
}

buildField()

MoFEMErrorCode MoFEM::Core::buildField ( const boost::shared_ptr< Field > &  field, int  verb = DEFAULT_VERBOSITY  )

protected

Definition at line 1253 of file FieldCore.cpp.

                                          {
  FieldCoreFunctionBegin;
  if (verb == -1)
    verb = verbose;
  if (verb > QUIET)
    MOFEM_LOG("SYNC", Sev::verbose) << "Build field " << field->getName();
 
  std::map<EntityType, int> dof_counter;
  std::map<EntityType, int> inactive_dof_counter;
 
  // Need to rebuild order table since number of dofs on each order when
  // field was created.
  if (field->getApproxBase() == USER_BASE)
    CHKERR field->rebuildDofsOrderMap();
 
  switch (field->getSpace()) {
  case NOFIELD:
    CHKERR this->buildFieldForNoField(field->getId(), dof_counter, verb);
    break;
  case L2:
  case H1:
  case HCURL:
  case HDIV:
    CHKERR this->buildFieldForL2H1HcurlHdiv(field->getId(), dof_counter,
                                            inactive_dof_counter, verb);
    break;
  default:
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
  }
 
  if (verb > QUIET) {
    int nb_added_dofs = 0;
    int nb_inactive_added_dofs = 0;
    for (auto const &it : dof_counter) {
      MOFEM_LOG("SYNC", Sev::verbose)
          << "Nb. of dofs (" << moab::CN::EntityTypeName(it.first) << ") "
          << it.second << " (inactive " << inactive_dof_counter[it.first]
          << ")";
      nb_added_dofs += it.second;
      nb_inactive_added_dofs += inactive_dof_counter[it.first];
    }
    MOFEM_LOG("SYNC", Sev::verbose)
        << "Nb. added dofs " << nb_added_dofs << " (number of inactive dofs "
        << nb_inactive_added_dofs << " )";
  }
  MoFEMFunctionReturn(0);
}

buildFieldForL2H1HcurlHdiv()

MoFEMErrorCode MoFEM::Core::buildFieldForL2H1HcurlHdiv ( const BitFieldId  id, std::map< EntityType, int > &  dof_counter, std::map< EntityType, int > &  inactive_dof_counter, int  verb = DEFAULT_VERBOSITY  )

protected

Definition at line 1141 of file FieldCore.cpp.

                                                             {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
 
  // Find field
  auto &set_id = fIelds.get<BitFieldId_mi_tag>();
  auto field_it = set_id.find(id);
  if (field_it == set_id.end()) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "Field not found");
  }
  const int bit_number = field_it->get()->getBitNumber();
  const int rank = field_it->get()->getNbOfCoeffs();
 
  // Ents in the field meshset
  Range ents_of_id_meshset;
  CHKERR get_moab().get_entities_by_handle((*field_it)->meshSet,
                                           ents_of_id_meshset, false);
  if (verb > VERY_NOISY) {
    MOFEM_LOG_C("SYNC", Sev::noisy, "Ents in field %s meshset %d",
                (*field_it)->getName().c_str(), ents_of_id_meshset.size());
  }
 
  for (auto p_eit = ents_of_id_meshset.pair_begin();
       p_eit != ents_of_id_meshset.pair_end(); ++p_eit) {
 
    const EntityHandle first = p_eit->first;
    const EntityHandle second = p_eit->second;
    const auto lo_uid =
        FieldEntity::getLoLocalEntityBitNumber(bit_number, first);
    const auto hi_uid =
        FieldEntity::getHiLocalEntityBitNumber(bit_number, second);
 
    auto feit = entsFields.get<Unique_mi_tag>().lower_bound(lo_uid);
    if (feit == entsFields.get<Unique_mi_tag>().end())
      continue;
    auto hi_feit = entsFields.get<Unique_mi_tag>().upper_bound(hi_uid);
 
    // If there are DOFs in that range is more pragmatic to remove them
    // rather than to find sub-ranges or make them inactive
    auto dit = dofsField.get<Unique_mi_tag>().lower_bound(lo_uid);
    auto hi_dit = dofsField.get<Unique_mi_tag>().upper_bound(hi_uid);
    dofsField.get<Unique_mi_tag>().erase(dit, hi_dit);
 
    // Add vertices DOFs by bulk
    boost::shared_ptr<std::vector<DofEntity>> dofs_array =
        boost::make_shared<std::vector<DofEntity>>(std::vector<DofEntity>());
    // Add Sequence of DOFs to sequence container as weak_ptr
    int nb_dofs_on_ents = 0;
    for (auto tmp_feit = feit; tmp_feit != hi_feit; ++tmp_feit) {
      nb_dofs_on_ents += rank * tmp_feit->get()->getOrderNbDofs(
                                    tmp_feit->get()->getMaxOrder());
    }
 
    // Reserve memory
    dofs_array->reserve(nb_dofs_on_ents);
 
    // Create DOFs
    for (; feit != hi_feit; ++feit) {
      // Create dofs instances and shared pointers
      int DD = 0;
      // Loop orders (loop until max entity order is set)
      for (int oo = 0; oo <= feit->get()->getMaxOrder(); ++oo) {
        // Loop nb. dofs at order oo
        for (int dd = 0; dd < feit->get()->getOrderNbDofsDiff(oo); ++dd) {
          // Loop rank
          for (int rr = 0; rr < rank; ++rr, ++DD) {
            dofs_array->emplace_back(*feit, oo, rr, DD);
            ++dof_counter[feit->get()->getEntType()];
          }
        }
      }
      if (DD > feit->get()->getNbDofsOnEnt()) {
        std::ostringstream ss;
        ss << "rank " << rAnk << " ";
        ss << **feit << std::endl;
        SETERRQ3(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                 "Expected number of DOFs on entity not equal to number added "
                 "to database (DD = %d != %d = "
                 "feit->get()->getNbDofsOnEnt())\n"
                 "%s",
                 DD, feit->get()->getNbDofsOnEnt(), ss.str().c_str());
      }
    }
 
    // Insert into Multi-Index container
    int dofs_field_size0 = dofsField.size();
    auto hint = dofsField.end();
    for (auto &v : *dofs_array)
      hint = dofsField.emplace_hint(hint, dofs_array, &v);
 
    // Add Sequence of DOFs to sequence container as weak_ptr
    field_it->get()->getDofSequenceContainer().push_back(dofs_array);
 
    // Check data consistency
    if (PetscUnlikely(static_cast<int>(dofs_array.use_count()) !=
                      static_cast<int>(dofs_array->size() + 1))) {
      SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "Wrong use count %d != %d", dofs_array.use_count(),
               dofs_array->size() + 1);
    }
    if (dofs_field_size0 + dofs_array->size() != dofsField.size()) {
      SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "Wrong number of inserted DOFs %d != %d", dofs_array->size(),
               dofsField.size() - dofs_field_size0);
    }
  }
  MoFEMFunctionReturn(0);
}

buildFieldForNoField()

MoFEMErrorCode MoFEM::Core::buildFieldForNoField ( const BitFieldId  id, std::map< EntityType, int > &  dof_counter, int  verb = DEFAULT_VERBOSITY  )

protected

Definition at line 1118 of file FieldCore.cpp.

                                                                           {
  FieldCoreFunctionBegin;
 
  if (verb == -1)
    verb = verbose;
 
  // find fields
  auto field_it = fIelds.get<BitFieldId_mi_tag>().find(id);
  if (field_it == fIelds.get<BitFieldId_mi_tag>().end())
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "Field not found");
 
  if (verb > QUIET)
    MOFEM_LOG("WORLD", Sev::noisy)
        << "Field " << (*field_it)->getName() << " core value < "
        << this->getValue() << " > field value () "
        << (*field_it)->getBitNumber() << " )";
 
  CHKERR this->buildFieldForNoFieldImpl(*field_it, dof_counter, verb);
 
  MoFEMFunctionReturn(0);
}

buildFieldForNoFieldImpl()

MoFEMErrorCode MoFEM::Core::buildFieldForNoFieldImpl ( boost::shared_ptr< Field >  field_ptr, std::map< EntityType, int > &  dof_counter, int  verb  )

protected

Definition at line 1013 of file FieldCore.cpp.

                                         {
  FieldCoreFunctionBegin;
 
  const auto bit_number = field_ptr->getBitNumber();
 
  // ents in the field meshset
  Range ents;
  CHKERR get_moab().get_entities_by_handle(field_ptr->getMeshset(), ents,
                                           false);
  if (verb > VERBOSE)
    MOFEM_LOG_C("SYNC", Sev::noisy, "Ents in field %s meshset %d\n",
                field_ptr->getName().c_str(), ents.size());
 
  // ent view by field id (in set all MoabEnts has the same FieldId)
  auto eiit = entsFields.get<Unique_mi_tag>().lower_bound(
      FieldEntity::getLoBitNumberUId(field_ptr->getBitNumber()));
  FieldEntity_multiIndex_ent_view ents_id_view;
  if (eiit != entsFields.get<Unique_mi_tag>().end()) {
    auto hi_eiit = entsFields.get<Unique_mi_tag>().upper_bound(
        FieldEntity::getHiBitNumberUId(field_ptr->getBitNumber()));
    std::copy(eiit, hi_eiit, std::back_inserter(ents_id_view));
  }
 
  boost::shared_ptr<const int> zero_order(new const int(0));
 
  for (auto ent : ents) {
    // search if field meshset is in database
    auto ref_ent_it = refinedEntities.get<Ent_mi_tag>().find(ent);
    if (ref_ent_it == refinedEntities.get<Ent_mi_tag>().end())
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Entity is not in MoFEM database, entities in field meshset need "
              "to be seeded (i.e. bit ref level add to them)");
 
    auto add_dofs = [&](auto field_eit) {
      MoFEMFunctionBegin;
      // create dofs on this entity (nb. of dofs is equal to rank)
      for (FieldCoefficientsNumber rank = 0; rank < field_ptr->getNbOfCoeffs();
           rank++) {
        // insert dof
        auto p = dofsField.insert(
            boost::make_shared<DofEntity>(field_eit, 0, rank, rank));
        if (p.second) {
          dof_counter[MBENTITYSET]++; // Count entities in the meshset
        } else
          SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                  "Dof expected to be created");
      }
      MoFEMFunctionReturn(0);
    };
 
    // create database entity
    auto field_ent_it = ents_id_view.get<1>().find(ent);
    if (field_ent_it == ents_id_view.get<1>().end()) {
 
      auto p = entsFields.insert(
 
          boost::make_shared<FieldEntity>(
              field_ptr, *ref_ent_it,
              FieldEntity::makeSharedFieldDataAdaptorPtr(field_ptr,
                                                         *ref_ent_it),
              boost::shared_ptr<const int>(zero_order, zero_order.get()))
 
      );
 
      if ((*p.first)->getFieldRawPtr() != field_ptr.get())
        SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                 "Get field ent poiter and field pointer do not match for "
                 "field %s",
                 field_ptr->getName().c_str());
 
      if (!p.second)
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Entity should be created");
 
      CHKERR add_dofs(*(p.first));
 
    } else {
 
      // If there are DOFs in that range is more pragmatic to remove them
      // rather than to find sub-ranges or make them inactive
      auto dit = dofsField.get<Unique_mi_tag>().lower_bound(
          FieldEntity::getLoLocalEntityBitNumber(bit_number, ent));
      auto hi_dit = dofsField.get<Unique_mi_tag>().upper_bound(
          FieldEntity::getHiLocalEntityBitNumber(bit_number, ent));
      dofsField.get<Unique_mi_tag>().erase(dit, hi_dit);
      CHKERR add_dofs(*field_ent_it);
    }
  }
 
  if (verb > VERBOSE) {
    auto lo_dof = dofsField.get<Unique_mi_tag>().lower_bound(
        FieldEntity::getLoBitNumberUId(field_ptr->getBitNumber()));
    auto hi_dof = dofsField.get<Unique_mi_tag>().upper_bound(
        FieldEntity::getHiBitNumberUId(field_ptr->getBitNumber()));
    for (; lo_dof != hi_dof; lo_dof++)
      MOFEM_LOG("SYNC", Sev::noisy) << **lo_dof;
    MOFEM_LOG_SEVERITY_SYNC(mofemComm, Sev::noisy);
  }
 
  MoFEMFunctionReturn(0);
}

buildFiniteElements()

MoFEMErrorCode MoFEM::Core::buildFiniteElements ( const boost::shared_ptr< FiniteElement > &  fe, const Range *  ents_ptr = NULL, int  verb = DEFAULT_VERBOSITY  )

protected

Definition at line 459 of file FECore.cpp.

                                                           {
  FECoreFunctionBegin;
  if (verb == DEFAULT_VERBOSITY)
    verb = verbose;
 
  if (verb > QUIET)
    MOFEM_LOG("SYNC", Sev::verbose)
        << "Build Finite Elements " << fe->getName();
 
  auto &fields_by_id = fIelds.get<BitFieldId_mi_tag>();
 
  // Get id of mofem fields for row, col and data
  enum IntLoop { ROW = 0, COL, DATA, LAST };
  std::array<BitFieldId, LAST> fe_fields = {fe.get()->getBitFieldIdRow(),
                                            fe.get()->getBitFieldIdCol(),
                                            fe.get()->getBitFieldIdData()};
 
  // Get finite element meshset
  EntityHandle meshset = get_finite_element_meshset(fe.get()->getId());
 
  // Get entities from finite element meshset // if meshset
  Range fe_ents;
  CHKERR get_moab().get_entities_by_handle(meshset, fe_ents, false);
 
  if (ents_ptr)
    fe_ents = intersect(fe_ents, *ents_ptr);
 
  // Map entity uid to pointers
  typedef std::vector<boost::weak_ptr<EntFiniteElement>> VecOfWeakFEPtrs;
  VecOfWeakFEPtrs processed_fes;
  processed_fes.reserve(fe_ents.size());
 
  int last_data_field_ents_view_size = 0;
  int last_row_field_ents_view_size = 0;
  int last_col_field_ents_view_size = 0;
 
  // Entities adjacent to entities
  std::vector<EntityHandle> adj_ents;
 
  // Loop meshset finite element ents and add finite elements
  for (Range::const_pair_iterator peit = fe_ents.const_pair_begin();
       peit != fe_ents.const_pair_end(); peit++) {
 
    const auto first = peit->first;
    const auto second = peit->second;
 
    // Find range of ref entities that is sequence
    // note: iterator is a wrapper
    // check if is in refinedFiniteElements database
    auto ref_fe_miit =
        refinedFiniteElements.get<Ent_mi_tag>().lower_bound(first);
    if (ref_fe_miit == refinedFiniteElements.get<Ent_mi_tag>().end()) {
      std::ostringstream ss;
      ss << "refinedFiniteElements not in database ent = " << first << " type "
         << type_from_handle(first) << " " << *fe;
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, ss.str().c_str());
    }
    auto hi_ref_fe_miit =
        refinedFiniteElements.get<Ent_mi_tag>().upper_bound(second);
 
    EntFiniteElement_multiIndex::iterator hint_p = entsFiniteElements.end();
    for (; ref_fe_miit != hi_ref_fe_miit; ref_fe_miit++) {
 
      // Add finite element to database
      hint_p = entsFiniteElements.emplace_hint(
          hint_p, boost::make_shared<EntFiniteElement>(*ref_fe_miit, fe));
      processed_fes.emplace_back(*hint_p);
      auto fe_raw_ptr = hint_p->get();
 
      // Allocate space for entities view
      bool row_as_data = false, col_as_row = false;
      if (fe_fields[DATA] == fe_fields[ROW])
        row_as_data = true;
      if (fe_fields[ROW] == fe_fields[COL])
        col_as_row = true;
 
      fe_raw_ptr->getDataFieldEntsPtr()->reserve(
          last_data_field_ents_view_size);
 
      if (row_as_data) {
        fe_raw_ptr->getRowFieldEntsPtr() = fe_raw_ptr->getDataFieldEntsPtr();
      } else {
        // row and col are different
        if (fe_raw_ptr->getRowFieldEntsPtr() ==
            fe_raw_ptr->getDataFieldEntsPtr())
          fe_raw_ptr->getRowFieldEntsPtr() =
              boost::make_shared<FieldEntity_vector_view>();
        fe_raw_ptr->getRowFieldEntsPtr()->reserve(
            last_row_field_ents_view_size);
      }
 
      if (row_as_data && col_as_row) {
        fe_raw_ptr->getColFieldEntsPtr() = fe_raw_ptr->getDataFieldEntsPtr();
      } else if (col_as_row) {
        fe_raw_ptr->getColFieldEntsPtr() = fe_raw_ptr->getRowFieldEntsPtr();
      } else {
        if (
 
            fe_raw_ptr->getColFieldEntsPtr() ==
                fe_raw_ptr->getRowFieldEntsPtr() ||
            fe_raw_ptr->getColFieldEntsPtr() ==
                fe_raw_ptr->getDataFieldEntsPtr()
 
        )
          fe_raw_ptr->getColFieldEntsPtr() =
              boost::make_shared<FieldEntity_vector_view>();
        fe_raw_ptr->getColFieldEntsPtr()->reserve(
            last_col_field_ents_view_size);
      }
 
      // Iterate over all field and check which one is on the element
      for (unsigned int ii = 0; ii != BitFieldId().size(); ++ii) {
 
        // Common field id for ROW, COL and DATA
        BitFieldId id_common = 0;
        // Check if the field (ii) is added to finite element
        for (int ss = 0; ss < LAST; ss++) {
          id_common |= fe_fields[ss] & BitFieldId().set(ii);
        }
        if (id_common.none())
          continue;
 
        // Find in database data associated with the field (ii)
        const BitFieldId field_id = BitFieldId().set(ii);
        auto miit = fields_by_id.find(field_id);
        if (miit == fields_by_id.end())
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Field not found");
        auto field_bit_number = (*miit)->getBitNumber();
 
        // Loop over adjacencies of element and find field entities on those
        // adjacencies, that create hash map map_uid_fe which is used later
        const std::string field_name = miit->get()->getName();
        const bool add_to_data = (field_id & fe_fields[DATA]).any();
        const bool add_to_row = (field_id & fe_fields[ROW]).any();
        const bool add_to_col = (field_id & fe_fields[COL]).any();
 
        // Resolve entities on element, those entities are used to build tag
        // with dof uids on finite element tag
        adj_ents.clear();
        CHKERR fe_raw_ptr->getElementAdjacency(*miit, adj_ents);
 
        for (auto ent : adj_ents) {
 
          auto dof_it = entsFields.get<Unique_mi_tag>().find(
              FieldEntity::getLocalUniqueIdCalculate(field_bit_number, ent));
          if (dof_it != entsFields.get<Unique_mi_tag>().end()) {
 
            if (add_to_data) {
              fe_raw_ptr->getDataFieldEntsPtr()->emplace_back(*dof_it);
            }
            if (add_to_row && !row_as_data) {
              fe_raw_ptr->getRowFieldEntsPtr()->emplace_back(*dof_it);
            }
            if (add_to_col && !col_as_row) {
              fe_raw_ptr->getColFieldEntsPtr()->emplace_back(*dof_it);
            }
 
          }
        }
      }
 
      // Sort field ents by uid
      auto uid_comp = [](const auto &a, const auto &b) {
        return a.lock()->getLocalUniqueId() < b.lock()->getLocalUniqueId();
      };
 
      // Sort all views
 
      // Data
      sort(fe_raw_ptr->getDataFieldEntsPtr()->begin(),
           fe_raw_ptr->getDataFieldEntsPtr()->end(), uid_comp);
      last_data_field_ents_view_size =
          fe_raw_ptr->getDataFieldEntsPtr()->size();
 
      // Row
      if (!row_as_data) {
        sort(fe_raw_ptr->getRowFieldEntsPtr()->begin(),
             fe_raw_ptr->getRowFieldEntsPtr()->end(), uid_comp);
        last_row_field_ents_view_size =
            fe_raw_ptr->getRowFieldEntsPtr()->size();
      }
 
      // Column
      if (!col_as_row) {
        sort(fe_raw_ptr->getColFieldEntsPtr()->begin(),
             fe_raw_ptr->getColFieldEntsPtr()->end(), uid_comp);
        last_col_field_ents_view_size =
            fe_raw_ptr->getColFieldEntsPtr()->size();
      }
    }
  }
 
  MoFEMFunctionReturn(0);
}

cache_problem_entities()

MoFEMErrorCode MoFEM::Core::cache_problem_entities ( const std::string  prb_name, CacheTupleWeakPtr  cache_ptr  )

protectedvirtual

Cache variables.

Parameters

prb_name
cache_ptr

Returns

MoFEMErrorCode

Implements MoFEM::CoreInterface.

Definition at line 798 of file ProblemsCore.cpp.

                                                                              {
  ProblemCoreFunctionBegin;
 
  if (auto cache_ptr = cache_weak_ptr.lock()) {
    auto p_miit = pRoblems.get<Problem_mi_tag>().find(prb_name);
    if (p_miit == pRoblems.get<Problem_mi_tag>().end())
      SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "problem not in database %s",
               prb_name.c_str());
 
    const BitRefLevel &prb_bit = p_miit->getBitRefLevel();
    const BitRefLevel &prb_mask = p_miit->getBitRefLevelMask();
    const BitFEId &prb_fe_id = p_miit->getBitFEId();
 
    auto &row_dofs = p_miit->numeredRowDofsPtr;
    auto &col_dofs = p_miit->numeredColDofsPtr;
 
    auto &cache_data = std::get<0>(*cache_ptr);
    auto &cache_row = std::get<1>(*cache_ptr);
    auto &cache_col = std::get<2>(*cache_ptr);
 
    cache_row.resize(entsFields.size());
    if (row_dofs != col_dofs)
      cache_col.resize(entsFields.size());
    cache_data.resize(entsFields.size());
 
    size_t idx = 0;
    for (auto it = entsFields.begin(); it != entsFields.end(); ++it, ++idx) {
 
      const auto uid = (*it)->getLocalUniqueId();
      auto r = entFEAdjacencies.get<Unique_mi_tag>().equal_range(uid);
      for (auto lo = r.first; lo != r.second; ++lo) {
 
        if ((lo->getBitFEId() & prb_fe_id).any()) {
 
          const BitRefLevel &fe_bit = lo->entFePtr->getBitRefLevel();
 
          // if entity is not problem refinement level
          if (((fe_bit & prb_mask) != fe_bit) || ((fe_bit & prb_bit).none()))
            continue;
 
          auto cache_numered_dofs = [&](auto &numered_dofs, auto &cache_vec,
                                        auto &ent_cache) {
            auto dit = numered_dofs->lower_bound(uid);
            decltype(dit) hi_dit;
            if (dit != numered_dofs->end())
              hi_dit = numered_dofs->upper_bound(
                  uid | static_cast<UId>(MAX_DOFS_ON_ENTITY - 1));
            else
              hi_dit = dit;
 
            ent_cache = boost::shared_ptr<EntityCacheNumeredDofs>(
                cache_ptr, &(cache_vec[idx]));
            cache_vec[idx].loHi = {dit, hi_dit};
          };
 
          auto cache_dofs = [&](auto &dofs, auto &cache_vec, auto &ent_cache) {
            auto dit = dofs.lower_bound(uid);
            decltype(dit) hi_dit;
            if (dit != dofs.end())
              hi_dit = dofs.upper_bound(
                  uid | static_cast<UId>(MAX_DOFS_ON_ENTITY - 1));
            else
              hi_dit = dit;
 
            ent_cache = boost::shared_ptr<EntityCacheDofs>(cache_ptr,
                                                           &(cache_vec[idx]));
            cache_vec[idx].loHi = {dit, hi_dit};
          };
 
          cache_numered_dofs(row_dofs, cache_row, (*it)->entityCacheRowDofs);
          if (row_dofs != col_dofs) {
            if (cache_col.size() != entsFields.size())
              cache_col.resize(entsFields.size());
            cache_numered_dofs(col_dofs, cache_col, (*it)->entityCacheColDofs);
          } else {
            (*it)->entityCacheColDofs = (*it)->entityCacheRowDofs;
          }
 
          cache_dofs(dofsField, cache_data, (*it)->entityCacheDataDofs);
 
          break;
        }
      }
    }
  } else {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Cache not allocated");
  }
 
  MoFEMFunctionReturn(0);
}

check_field()

bool MoFEM::Core::check_field ( const std::string &  name ) const

protectedvirtual

check if field is in database

Parameters

name	field name

Returns

true if field exist

Implements MoFEM::CoreInterface.

Definition at line 57 of file FieldCore.cpp.

                                                  {
  auto miit = fIelds.get<FieldName_mi_tag>().find(name);
  if (miit == fIelds.get<FieldName_mi_tag>().end())
    return false;
  else
    return true;
}

check_finite_element()

bool MoFEM::Core::check_finite_element ( const std::string &  name ) const

protectedvirtual

Check if finite element is in database.

Parameters

name	Name of finite element

Returns

true if element is declared

Implements MoFEM::CoreInterface.

Definition at line 35 of file FECore.cpp.

                                                           {
  auto miit = finiteElements.get<FiniteElement_name_mi_tag>().find(name);
  if (miit == finiteElements.get<FiniteElement_name_mi_tag>().end())
    return false;
  else
    return true;
}

check_number_of_ents_in_ents_field() [1/2]

MoFEMErrorCode MoFEM::Core::check_number_of_ents_in_ents_field ( ) const

protectedvirtual

check data consistency in entitiesPtr

Implements MoFEM::CoreInterface.

Definition at line 1434 of file FieldCore.cpp.

                                                              {
  MoFEMFunctionBegin;
  for (auto &it : fIelds.get<FieldName_mi_tag>()) {
    if (it->getSpace() == NOFIELD)
      continue; // FIXME: should be treated properly, not test is just
                // skipped for this NOFIELD space
    EntityHandle meshset = it->getMeshset();
    int num_entities;
    CHKERR get_moab().get_number_entities_by_handle(meshset, num_entities);
 
    auto count_field_ents = [&]() {
      auto bit_number = it->getBitNumber();
      auto low_eit = entsFields.get<Unique_mi_tag>().lower_bound(
          FieldEntity::getLoBitNumberUId(bit_number));
      auto hi_eit = entsFields.get<Unique_mi_tag>().upper_bound(
          FieldEntity::getHiBitNumberUId(bit_number));
      return std::distance(low_eit, hi_eit);
    };
 
    if (count_field_ents() > (unsigned int)num_entities) {
      SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "not equal number of entities in meshset and field "
               "multiindex < %s >",
               it->getName().c_str());
    }
  }
  MoFEMFunctionReturn(0);
}

check_number_of_ents_in_ents_field() [2/2]

MoFEMErrorCode MoFEM::Core::check_number_of_ents_in_ents_field ( const std::string &  name ) const

protectedvirtual

check data consistency in entitiesPtr

Implements MoFEM::CoreInterface.

Definition at line 1406 of file FieldCore.cpp.

                                                                    {
  MoFEMFunctionBeginHot;
  auto it = fIelds.get<FieldName_mi_tag>().find(name);
  if (it == fIelds.get<FieldName_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "field not found < %s >", name.c_str());
  }
  EntityHandle meshset = (*it)->getMeshset();
  int num_entities;
  CHKERR get_moab().get_number_entities_by_handle(meshset, num_entities);
 
  auto count_field_ents = [&]() {
    auto bit_number = (*it)->getBitNumber();
    auto low_eit = entsFields.get<Unique_mi_tag>().lower_bound(
        FieldEntity::getLoBitNumberUId(bit_number));
    auto hi_eit = entsFields.get<Unique_mi_tag>().upper_bound(
        FieldEntity::getHiBitNumberUId(bit_number));
    return std::distance(low_eit, hi_eit);
  };
 
  if (count_field_ents() > (unsigned int)num_entities) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "not equal number of entities in meshset and field multiindex "
             "< %s >",
             name.c_str());
  }
  MoFEMFunctionReturnHot(0);
}

check_number_of_ents_in_ents_finite_element() [1/2]

MoFEMErrorCode MoFEM::Core::check_number_of_ents_in_ents_finite_element ( ) const

protectedvirtual

check data consistency in entsFiniteElements

Implements MoFEM::CoreInterface.

Definition at line 885 of file FECore.cpp.

                                                                       {
  MoFEMFunctionBegin;
  FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type::iterator it;
  it = finiteElements.get<FiniteElement_name_mi_tag>().begin();
  for (; it != finiteElements.get<FiniteElement_name_mi_tag>().end(); it++) {
    EntityHandle meshset = (*it)->getMeshset();
 
    int num_entities;
    CHKERR get_moab().get_number_entities_by_handle(meshset, num_entities);
 
    auto counts_fes = [&]() {
      return std::distance(get_fe_by_name_begin((*it)->getName()),
                           get_fe_by_name_end((*it)->getName()));
    };
 
    if (counts_fes() != static_cast<size_t>(num_entities)) {
      SETERRQ1(mofemComm, MOFEM_DATA_INCONSISTENCY,
               "not equal number of entities in meshset and finite elements "
               "multiindex < %s >",
               (*it)->getName().c_str());
    }
  }
  MoFEMFunctionReturn(0);
}

check_number_of_ents_in_ents_finite_element() [2/2]

MoFEMErrorCode MoFEM::Core::check_number_of_ents_in_ents_finite_element ( const std::string &  name ) const

protectedvirtual

check data consistency in entsFiniteElements

Implements MoFEM::CoreInterface.

Definition at line 858 of file FECore.cpp.

                                 {
  MoFEMFunctionBegin;
  FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type::iterator it;
  it = finiteElements.get<FiniteElement_name_mi_tag>().find(name);
  if (it == finiteElements.get<FiniteElement_name_mi_tag>().end()) {
    SETERRQ1(mofemComm, 1, "finite element not found < %s >", name.c_str());
  }
  EntityHandle meshset = (*it)->getMeshset();
 
  int num_entities;
  CHKERR get_moab().get_number_entities_by_handle(meshset, num_entities);
 
  auto counts_fes = [&]() {
    return std::distance(get_fe_by_name_begin((*it)->getName()),
                         get_fe_by_name_end((*it)->getName()));
  };
 
  if (counts_fes() != static_cast<size_t>(num_entities)) {
    SETERRQ1(mofemComm, MOFEM_DATA_INCONSISTENCY,
             "not equal number of entities in meshset and finite elements "
             "multiindex < %s >",
             (*it)->getName().c_str());
  }
  MoFEMFunctionReturn(0);
}

check_problem()

bool MoFEM::CoreTmp< 0 >::check_problem ( const std::string  name )

protectedvirtual

check if problem exist

Parameters

name	problem name

Returns

true if problem is in database

Implements MoFEM::CoreInterface.

clear_adjacencies_entities() [1/3]

MoFEMErrorCode MoFEM::Core::clear_adjacencies_entities ( const BitRefLevel  bit, const BitRefLevel  mask, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

clear adjacency map for entities on given bit level

Parameters

bit
mask

Implements MoFEM::CoreInterface.

Definition at line 201 of file DeleteCore.cpp.

                                                          {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  Range ents;
  CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
  CHKERR clear_adjacencies_entities(ents, verb);
  MoFEMFunctionReturn(0);
}

clear_adjacencies_entities() [2/3]

MoFEMErrorCode MoFEM::Core::clear_adjacencies_entities ( const Range  ents, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

clear adjacencies for field entities by entities

Implements MoFEM::CoreInterface.

Definition at line 213 of file DeleteCore.cpp.

                                                                          {
  MoFEMFunctionBeginHot;
  if (verb == -1)
    verb = verbose;
  for (Range::const_pair_iterator p_eit = ents.pair_begin();
       p_eit != ents.pair_end(); ++p_eit) {
    const EntityHandle first = p_eit->first;
    const EntityHandle second = p_eit->second;
    FieldEntityEntFiniteElementAdjacencyMap_multiIndex::index<
        Ent_mi_tag>::type::iterator ait,
        hi_ait;
    ait = entFEAdjacencies.get<Ent_mi_tag>().lower_bound(first);
    hi_ait = entFEAdjacencies.get<Ent_mi_tag>().upper_bound(second);
    entFEAdjacencies.get<Ent_mi_tag>().erase(ait, hi_ait);
  }
  MoFEMFunctionReturnHot(0);
}

clear_adjacencies_entities() [3/3]

MoFEMErrorCode MoFEM::Core::clear_adjacencies_entities ( const std::string  name, const Range  ents, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

clear adjacencies for field entities by entities and field namd

Implements MoFEM::CoreInterface.

Definition at line 231 of file DeleteCore.cpp.

                                                                            {
  MoFEMFunctionBeginHot;
  if (verb == -1)
    verb = verbose;
 
  const Field *field_ptr = get_field_structure(name);
  int field_bit_number = field_ptr->getBitNumber();
 
  for (Range::const_pair_iterator p_eit = ents.pair_begin();
       p_eit != ents.pair_end(); p_eit++) {
 
    // First and last handle
    const EntityHandle first = p_eit->first;
    const EntityHandle second = p_eit->second;
 
    // Get UId
    UId first_uid =
        FieldEntity::getLocalUniqueIdCalculate(field_bit_number, first);
    UId second_uid =
        FieldEntity::getLocalUniqueIdCalculate(field_bit_number, second);
 
    // Find adjacencies
    auto ait = entFEAdjacencies.get<Unique_mi_tag>().lower_bound(first_uid);
    auto hi_ait = entFEAdjacencies.get<Unique_mi_tag>().upper_bound(second_uid);
    entFEAdjacencies.get<Unique_mi_tag>().erase(ait, hi_ait);
  }
  MoFEMFunctionReturnHot(0);
}

clear_adjacencies_finite_elements() [1/3]

MoFEMErrorCode MoFEM::Core::clear_adjacencies_finite_elements ( const BitRefLevel  bit, const BitRefLevel  mask, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

clear adjacency map for finite elements on given bit level

Parameters

bit
mask

Implements MoFEM::CoreInterface.

Definition at line 312 of file DeleteCore.cpp.

                                                                 {
  MoFEMFunctionBegin;
  Range ents;
  CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
  CHKERR clear_adjacencies_finite_elements(ents, verb);
  MoFEMFunctionReturn(0);
}

clear_adjacencies_finite_elements() [2/3]

MoFEMErrorCode MoFEM::Core::clear_adjacencies_finite_elements ( const Range  ents, int  verb = DEFAULT_VERBOSITY  )

protected

Definition at line 322 of file DeleteCore.cpp.

                                                                 {
  MoFEMFunctionBeginHot;
  if (verb == -1)
    verb = verbose;
  for (Range::const_pair_iterator p_eit = ents.pair_begin();
       p_eit != ents.pair_end(); p_eit++) {
    EntityHandle first = p_eit->first;
    EntityHandle second = p_eit->second;
    FieldEntityEntFiniteElementAdjacencyMap_multiIndex::index<
        FEEnt_mi_tag>::type::iterator ait,
        hi_ait;
    ait = entFEAdjacencies.get<FEEnt_mi_tag>().lower_bound(first);
    hi_ait = entFEAdjacencies.get<FEEnt_mi_tag>().upper_bound(second);
    entFEAdjacencies.get<FEEnt_mi_tag>().erase(ait, hi_ait);
  }
  MoFEMFunctionReturnHot(0);
}

clear_adjacencies_finite_elements() [3/3]

MoFEMErrorCode MoFEM::Core::clear_adjacencies_finite_elements ( const std::string  name, const Range  ents, int  verb = DEFAULT_VERBOSITY  )

protected

Definition at line 341 of file DeleteCore.cpp.

                                                                 {
  MoFEMFunctionBeginHot;
  if (verb == -1)
    verb = verbose;
 
  FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type::iterator
      it_fe = finiteElements.get<FiniteElement_name_mi_tag>().find(name);
  if (it_fe != finiteElements.get<FiniteElement_name_mi_tag>().end()) {
 
    const auto fe_uid = (*it_fe)->getFEUId();
 
    for (Range::const_pair_iterator p_eit = ents.pair_begin();
         p_eit != ents.pair_end(); p_eit++) {
 
      // First and last handle
      const EntityHandle first = p_eit->first;
      const EntityHandle second = p_eit->second;
 
      // Get UId
      UId first_uid =
          EntFiniteElement::getLocalUniqueIdCalculate(first, fe_uid);
      UId second_uid =
          EntFiniteElement::getLocalUniqueIdCalculate(second, fe_uid);
 
      // Find and remove adjacencies
      FieldEntityEntFiniteElementAdjacencyMap_multiIndex::index<
          FE_Unique_mi_tag>::type::iterator ait,
          hi_ait;
      ait = entFEAdjacencies.get<FE_Unique_mi_tag>().lower_bound(first_uid);
      hi_ait = entFEAdjacencies.get<FE_Unique_mi_tag>().upper_bound(second_uid);
      entFEAdjacencies.get<FE_Unique_mi_tag>().erase(ait, hi_ait);
    }
  }
  MoFEMFunctionReturnHot(0);
}

clear_database()

MoFEMErrorCode MoFEM::Core::clear_database ( int  verb = DEFAULT_VERBOSITY )

protectedvirtual

Clear database.

Parameters

verb	Verbosity level

Returns

Error code

Implements MoFEM::CoreInterface.

Definition at line 728 of file Core.cpp.

                                            {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  CHKERR clearMap();
  MoFEMFunctionReturn(0);
}

clear_dofs_fields() [1/2]

MoFEMErrorCode MoFEM::Core::clear_dofs_fields ( const Range  ents, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Clear dofs by ents

Implements MoFEM::CoreInterface.

Definition at line 57 of file DeleteCore.cpp.

                                                                 {
  MoFEMFunctionBeginHot;
  if (verb == -1)
    verb = verbose;
 
  for (Range::const_pair_iterator p_eit = ents.pair_begin();
       p_eit != ents.pair_end(); p_eit++) {
    EntityHandle first = p_eit->first;
    EntityHandle second = p_eit->second;
    // get dofs range
    DofEntityByEnt::iterator dit, hi_dit;
    dit = dofsField.get<Ent_mi_tag>().lower_bound(first);
    if (dit == dofsField.get<Ent_mi_tag>().end())
      continue;
    hi_dit = dofsField.get<Ent_mi_tag>().upper_bound(second);
    // finally clear dofs
    dofsField.get<Ent_mi_tag>().erase(dit, hi_dit);
  }
  MoFEMFunctionReturnHot(0);
}

clear_dofs_fields() [2/2]

MoFEMErrorCode MoFEM::Core::clear_dofs_fields ( const std::string  name, const Range  ents, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Clear dofs by field name and ents

Implements MoFEM::CoreInterface.

Definition at line 78 of file DeleteCore.cpp.

                                                 {
  MoFEMFunctionBeginHot;
  if (verb == -1)
    verb = verbose;
 
  const auto bit_number = get_field_bit_number(name);
 
  for (Range::const_pair_iterator p_eit = ents.pair_begin();
       p_eit != ents.pair_end(); p_eit++) {
    const auto first = p_eit->first;
    const auto second = p_eit->second;
    const auto lo_uid = DofEntity::getLoFieldEntityUId(bit_number, first);
    const auto hi_uid = DofEntity::getHiFieldEntityUId(bit_number, second);
    auto dit = dofsField.get<Unique_mi_tag>().lower_bound(lo_uid);
    auto hi_dit = dofsField.get<Unique_mi_tag>().upper_bound(hi_uid);
    dofsField.get<Unique_mi_tag>().erase(dit, hi_dit);
  }
  MoFEMFunctionReturnHot(0);
}

clear_dofs_fields_by_bit_ref()

MoFEMErrorCode MoFEM::Core::clear_dofs_fields_by_bit_ref ( const BitRefLevel  bit, const BitRefLevel  mask, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Clear dofs by bit level

Implements MoFEM::CoreInterface.

Definition at line 45 of file DeleteCore.cpp.

                                                            {
  MoFEMFunctionBeginHot;
  if (verb == -1)
    verb = verbose;
  Range ents;
  CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
  CHKERR clear_dofs_fields(ents, verb);
  MoFEMFunctionReturnHot(0);
}

clear_ents_fields() [1/2]

MoFEMErrorCode MoFEM::Core::clear_ents_fields ( const Range  ents, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Clear entities by field name

Implements MoFEM::CoreInterface.

Definition at line 113 of file DeleteCore.cpp.

                                                                 {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  CHKERR clear_dofs_fields(ents, verb);
  CHKERR clear_adjacencies_entities(ents, verb);
  for (Range::const_pair_iterator p_eit = ents.pair_begin();
       p_eit != ents.pair_end(); p_eit++) {
    EntityHandle first = p_eit->first;
    EntityHandle second = p_eit->second;
    FieldEntity_multiIndex::index<Ent_mi_tag>::type::iterator dit, hi_dit;
    dit = entsFields.get<Ent_mi_tag>().lower_bound(first);
    hi_dit = entsFields.get<Ent_mi_tag>().upper_bound(second);
    entsFields.get<Ent_mi_tag>().erase(dit, hi_dit);
  }
  MoFEMFunctionReturn(0);
}

clear_ents_fields() [2/2]

MoFEMErrorCode MoFEM::Core::clear_ents_fields ( const std::string  name, const Range  ents, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Clear entities by field name

Implements MoFEM::CoreInterface.

Definition at line 131 of file DeleteCore.cpp.

                                                 {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  const auto bit_number = get_field_bit_number(name);
  CHKERR clear_dofs_fields(name, ents, verb);
  CHKERR clear_adjacencies_entities(name, ents, verb);
  for (Range::const_pair_iterator p_eit = ents.pair_begin();
       p_eit != ents.pair_end(); p_eit++) {
    const auto first = p_eit->first;
    const auto second = p_eit->second;
    auto dit = entsFields.get<Unique_mi_tag>().lower_bound(
        FieldEntity::getLocalUniqueIdCalculate(bit_number, first));
    auto hi_dit = entsFields.get<Unique_mi_tag>().upper_bound(
        FieldEntity::getLocalUniqueIdCalculate(bit_number, second));
    entsFields.get<Unique_mi_tag>().erase(dit, hi_dit);
  }
  MoFEMFunctionReturn(0);
}

clear_ents_fields_by_bit_ref()

MoFEMErrorCode MoFEM::Core::clear_ents_fields_by_bit_ref ( const BitRefLevel  bit, const BitRefLevel  mask, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Clear ents by bit level

Implements MoFEM::CoreInterface.

Definition at line 99 of file DeleteCore.cpp.

                                                            {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  Range ents;
  CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
  CHKERR clear_dofs_fields(ents, verb);
  CHKERR clear_adjacencies_entities(ents, verb);
  CHKERR clear_ents_fields(ents, verb);
  MoFEMFunctionReturn(0);
}

clear_finite_elements() [1/2]

MoFEMErrorCode MoFEM::Core::clear_finite_elements ( const Range &  ents, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

clear finite elements

Implements MoFEM::CoreInterface.

Definition at line 273 of file DeleteCore.cpp.

                                                                      {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  CHKERR clear_adjacencies_finite_elements(ents, verb);
  for (Range::const_pair_iterator p_eit = ents.pair_begin();
       p_eit != ents.pair_end(); p_eit++) {
    EntityHandle first = p_eit->first;
    EntityHandle second = p_eit->second;
    EntFiniteElement_multiIndex::index<Ent_mi_tag>::type::iterator fit, hi_fit;
    fit = entsFiniteElements.get<Ent_mi_tag>().lower_bound(first);
    hi_fit = entsFiniteElements.get<Ent_mi_tag>().upper_bound(second);
    entsFiniteElements.get<Ent_mi_tag>().erase(fit, hi_fit);
  }
  MoFEMFunctionReturn(0);
}

clear_finite_elements() [2/2]

MoFEMErrorCode MoFEM::Core::clear_finite_elements ( const std::string &  fe_name, const Range &  ents, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

clear finite elements

Implements MoFEM::CoreInterface.

Definition at line 290 of file DeleteCore.cpp.

                                                                        {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  CHKERR clear_adjacencies_finite_elements(fe_name, ents, verb);
  auto fe_miit = finiteElements.get<FiniteElement_name_mi_tag>().find(fe_name);
  if (fe_miit == finiteElements.get<FiniteElement_name_mi_tag>().end()) {
    for (Range::const_pair_iterator p_eit = ents.pair_begin();
         p_eit != ents.pair_end(); p_eit++) {
      auto fit = entsFiniteElements.get<Unique_mi_tag>().lower_bound(
          EntFiniteElement::getLocalUniqueIdCalculate(p_eit->first,
                                                      (*fe_miit)->getFEUId()));
      auto hi_fit = entsFiniteElements.get<Unique_mi_tag>().upper_bound(
          EntFiniteElement::getLocalUniqueIdCalculate(p_eit->second,
                                                      (*fe_miit)->getFEUId()));
      fit = entsFiniteElements.get<Unique_mi_tag>().erase(fit, hi_fit);
    }
  }
  MoFEMFunctionReturn(0);
}

clear_finite_elements_by_bit_ref()

MoFEMErrorCode MoFEM::Core::clear_finite_elements_by_bit_ref ( const BitRefLevel  bit, const BitRefLevel  mask, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

clear finite elements

Implements MoFEM::CoreInterface.

Definition at line 261 of file DeleteCore.cpp.

                                                                {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  Range ents;
  CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
  CHKERR clear_finite_elements(ents, verb);
  MoFEMFunctionReturn(0);
}

clear_inactive_dofs()

MoFEMErrorCode MoFEM::Core::clear_inactive_dofs ( int  verb = DEFAULT_VERBOSITY )

protectedvirtual

Clear inactive dofs

Implements MoFEM::CoreInterface.

Definition at line 29 of file DeleteCore.cpp.

                                                 {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  Range ents;
  for (DofEntity_multiIndex::iterator dit = dofsField.begin();
       dit != dofsField.end();) {
    if (!dit->get()->getActive()) {
      dit = dofsField.erase(dit);
    } else {
      ++dit;
    }
  }
  MoFEMFunctionReturn(0);
}

clear_problem()

MoFEMErrorCode MoFEM::Core::clear_problem ( const std::string  name, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

clear problem

Implements MoFEM::CoreInterface.

Definition at line 269 of file ProblemsCore.cpp.

                                                                         {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  typedef Problem_multiIndex::index<Problem_mi_tag>::type ProblemsByName;
  ProblemsByName &prob_by_name = pRoblems.get<Problem_mi_tag>();
  ProblemsByName::iterator p_miit = prob_by_name.find(problem_name);
  if (p_miit == prob_by_name.end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
             "problem < %s > not found, (top tip: check spelling)",
             problem_name.c_str());
  }
  // zero rows
  bool success = prob_by_name.modify(p_miit, ProblemZeroNbRowsChange());
  if (!success)
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  // zero cols
  success = prob_by_name.modify(p_miit, ProblemZeroNbColsChange());
  if (!success)
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  // clear finite elements
  success =
      prob_by_name.modify(p_miit, ProblemClearNumeredFiniteElementsChange());
  if (!success)
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  // clear data structures
  success = prob_by_name.modify(p_miit, ProblemClearSubProblemData());
  if (!success)
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  success = prob_by_name.modify(p_miit, ProblemClearComposedProblemData());
  if (!success)
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  if (p_miit->getRowDofsSequence())
    p_miit->getRowDofsSequence()->clear();
  if (p_miit->getColDofsSequence())
    p_miit->getColDofsSequence()->clear();
  if (p_miit->getSubData())
    p_miit->getSubData().reset();
  if (p_miit->getComposedProblemsData())
    p_miit->getComposedProblemsData().reset();
  MoFEMFunctionReturn(0);
}

clear_problems()

MoFEMErrorCode MoFEM::Core::clear_problems ( int  verb = DEFAULT_VERBOSITY )

protectedvirtual

clear problems

Implements MoFEM::CoreInterface.

Definition at line 338 of file ProblemsCore.cpp.

                                            {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  // iterate problems
  for (auto p_miit = pRoblems.begin(); p_miit != pRoblems.end(); p_miit++)
    CHKERR clear_problem(p_miit->getName(), verb);
  MoFEMFunctionReturn(0);
}

clearMap()

MoFEMErrorCode MoFEM::Core::clearMap ( )

protected

Cleaning database.

Definition at line 503 of file Core.cpp.

                              {
  MoFEMFunctionBegin;
  // Cleaning databases in interfaces
  CHKERR getInterface<SeriesRecorder>()->clearMap();
  CHKERR getInterface<MeshsetsManager>()->clearMap();
  CHKERR getInterface<CutMeshInterface>()->clearMap();
  // Cleaning databases
  refinedEntities.clear();
  refinedFiniteElements.clear();
  fIelds.clear();
  entsFields.clear();
  dofsField.clear();
  finiteElements.clear();
  entsFiniteElements.clear();
  entFEAdjacencies.clear();
  pRoblems.clear();
  MoFEMFunctionReturn(0);
}

coreGenericConstructor()

MoFEMErrorCode MoFEM::Core::coreGenericConstructor ( moab::Interface &  moab, MPI_Comm  comm, const int  verbose  )

protected

Definition at line 197 of file Core.cpp.

                                                                              {
  MoFEMFunctionBegin;
 
  // This is deprecated ONE should use MoFEM::Core::Initialize
  if (!isGloballyInitialised)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "MoFEM globally is not initialised, call MoFEM::Core::Initialize");
 
  // Create duplicate communicator
  wrapMPIMOABComm = boost::make_shared<WrapMPIComm>(comm, false);
 
  MPI_Comm_size(mofemComm, &sIze);
  MPI_Comm_rank(mofemComm, &rAnk);
 
  // CHeck if moab has set communicator if not set communicator interbally
  ParallelComm *pComm = ParallelComm::get_pcomm(&moab, MYPCOMM_INDEX);
  if (pComm == NULL)
    pComm = new ParallelComm(&moab, wrapMPIMOABComm->get_comm());
 
  // Register interfaces for this implementation
  CHKERR registerInterface<UnknownInterface>();
  CHKERR registerInterface<CoreInterface>();
  CHKERR registerInterface<DeprecatedCoreInterface>();
 
  // Register MOFEM events in PETSc
  PetscLogEventRegister("FE_preProcess", 0, &MOFEM_EVENT_preProcess);
  PetscLogEventRegister("FE_operator", 0, &MOFEM_EVENT_operator);
  PetscLogEventRegister("FE_postProcess", 0, &MOFEM_EVENT_postProcess);
  PetscLogEventRegister("MoFEMCreateMat", 0, &MOFEM_EVENT_createMat);
 
  MOFEM_LOG_CHANNEL("WORLD");
  MOFEM_LOG_CHANNEL("SELF");
  MOFEM_LOG_CHANNEL("SYNC");
 
  MoFEMFunctionReturn(0);
}

create_vertices_and_add_to_field()

MoFEMErrorCode MoFEM::Core::create_vertices_and_add_to_field ( const std::string  name, const double  coords[], int  size, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Create a vertices and add to field object.

Create vertices and add them to field. Those vertices would be carring DOFs of the field.

Note

This function is typically used when NOFIELD is created, for example load factor in arc-length control.

Parameters

name	name of the field
bit	bit ref level of the created vertices
coords	of the vertices
size	number of vertices
verb	verbosity level

Returns

MoFEMErrorCode

Implements MoFEM::CoreInterface.

Definition at line 464 of file FieldCore.cpp.

                                                                          {
  MoFEMFunctionBegin;
 
  if (verb == DEFAULT_VERBOSITY)
    verb = verbose;
 
  Range verts;
 
  auto create_vertices = [&]() {
    MoFEMFunctionBegin;
 
    vector<double *> arrays_coord;
    EntityHandle startv = 0;
    ReadUtilIface *iface;
    CHKERR get_moab().query_interface(iface);
    CHKERR iface->get_node_coords(3, size, 0, startv, arrays_coord);
    verts.insert(startv, startv + size - 1);
    for (int n = 0; n != size; ++n)
      for (auto d : {0, 1, 2})
        arrays_coord[d][n] = coords[3 * n + d];
 
    MoFEMFunctionReturn(0);
  };
 
  auto add_verts_to_field = [&]() {
    MoFEMFunctionBegin;
    EntityHandle field_meshset = get_field_meshset(name);
    CHKERR get_moab().add_entities(field_meshset, verts);
    MoFEMFunctionReturn(0);
  };
 
  CHKERR create_vertices();
  CHKERR add_verts_to_field();
 
  MoFEMFunctionReturn(0);
}

delete_ents_by_bit_ref()

MoFEMErrorCode MoFEM::Core::delete_ents_by_bit_ref ( const BitRefLevel  bit, const BitRefLevel  mask, const bool  remove_parent = false, int  verb = DEFAULT_VERBOSITY, MoFEMTypes  mf = MF_ZERO  )

protectedvirtual

delete entities form mofem and moab database

Implements MoFEM::CoreInterface.

Definition at line 535 of file DeleteCore.cpp.

                                                           {
  DeleteCoreFunctionBegin;
  if (verb == -1)
    verb = verbose;
 
  Range ents;
  CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
  Range ents_meshsets = ents.subset_by_type(MBENTITYSET);
  ents = subtract(ents, ents_meshsets);
  if(ents.empty()) {
    if (verb >= VERBOSE)
      MOFEM_LOG("WORLD", Sev::verbose) << "Nb. of deleted entities 0";
    MoFEMFunctionReturnHot(0);
  }
 
  if (verb >= VERBOSE)
    MOFEM_LOG("WORLD", Sev::noisy) << "Deleted ents:\n" << ents;
 
  CHKERR remove_ents(ents, verb);
 
  // remove parent
  if (remove_parent) {
    CHKERR remove_parents_by_parents(ents);
  }
 
  Range meshsets;
  CHKERR get_moab().get_entities_by_type(0, MBENTITYSET, meshsets, true);
  for (auto m : meshsets) {
    CHKERR get_moab().remove_entities(m, ents);
 
    }
 
  rval = get_moab().delete_entities(ents);
  if (rval != MB_SUCCESS) {
    MOFEM_LOG_ATTRIBUTES("SELF", LogManager::BitScope);
    if (verb == QUIET) {
      MOFEM_LOG("SELF", Sev::noisy) << "Problem deleting:\n" << ents;
    } else {
      MOFEM_LOG("SELF", Sev::warning) << "Problem deleting:\n" << ents;
    }
    MOFEM_LOG_CHANNEL("WORLD");
    MOFEM_LOG_TAG("WORLD", "DeleteCore");
    if (!(mf & MF_NOT_THROW)) {
      CHK_MOAB_THROW(rval, "Can not delete entities");
    } else {
      rval = MB_SUCCESS;
    }
  }
 
  MOFEM_LOG_C("SELF", Sev::noisy, "Nb. of deleted entities %d", ents.size());
 
  MoFEMFunctionReturn(0);
}

delete_field()

MoFEMErrorCode MoFEM::Core::delete_field ( const std::string  name, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

Delete field.

Parameters

name	field name
verb	verbosity level

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 609 of file DeleteCore.cpp.

                                                                {
  MoFEMFunctionBegin;
  auto &f = fIelds.get<FieldName_mi_tag>();
  auto mit = f.find(name);
  if (mit == f.end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
             "Finite element <%s> not found", name.c_str());
  }
  EntityHandle meshset = mit->get()->getMeshset();
  Range ents;
  CHKERR get_moab().get_entities_by_handle(meshset, ents, false);
  CHKERR remove_ents_from_field(name, ents, verb);
  CHKERR get_moab().tag_delete((*mit)->th_FieldDataVerts);
  CHKERR get_moab().tag_delete((*mit)->th_FieldData);
  CHKERR get_moab().tag_delete((*mit)->th_AppOrder);
  f.erase(mit);
  CHKERR get_moab().delete_entities(&meshset, 1);
  MoFEMFunctionReturn(0);
}

delete_finite_element()

MoFEMErrorCode MoFEM::Core::delete_finite_element ( const std::string  name, int  verb = DEFAULT_VERBOSITY  )

protectedvirtual

delete finite element from mofem database

Implements MoFEM::CoreInterface.

Definition at line 592 of file DeleteCore.cpp.

                                                                         {
  MoFEMFunctionBegin;
  auto &fe = finiteElements.get<FiniteElement_name_mi_tag>();
  auto mit = fe.find(name);
  if (mit == fe.end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
             "Finite element <%s> not found", name.c_str());
  }
  EntityHandle meshset = mit->get()->getMeshset();
  Range ents;
  CHKERR get_moab().get_entities_by_handle(meshset, ents, false);
  CHKERR remove_ents_from_finite_element(name, ents, verb);
  fe.erase(mit);
  CHKERR get_moab().delete_entities(&meshset, 1);
  MoFEMFunctionReturn(0);
}

delete_problem()

MoFEMErrorCode MoFEM::Core::delete_problem ( const std::string  name )

protectedvirtual

Delete problem.

Note

add_file is a collective, should be executed on all processors. Otherwise could lead to deadlock.

Implements MoFEM::CoreInterface.

Definition at line 108 of file ProblemsCore.cpp.

                                                        {
  MoFEMFunctionBegin;
  auto p_miit = pRoblems.get<Problem_mi_tag>().find(name);
  if (p_miit == pRoblems.get<Problem_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "no such problem like < %s >",
             name.c_str());
  }
  const EntityHandle meshset = p_miit->meshset;
  pRoblems.get<Problem_mi_tag>().erase(p_miit);
  CHKERR get_moab().delete_entities(&meshset, 1);
  MoFEMFunctionReturn(0);
}

Finalize()

MoFEMErrorCode MoFEM::Core::Finalize ( )

static

Checks for options to be called at the conclusion of the program.

MPI_Finalize() is called only if the user had not called MPI_Init() before calling Initialize.

Note

This function calls PetscInitialize, for more details see http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Sys/PetscFinalize.html

Returns

MoFEMErrorCode

Examples

add_blockset.cpp, add_cubit_meshsets.cpp, adolc_plasticity.cpp, analytical_nonlinear_poisson.cpp, analytical_poisson.cpp, analytical_poisson_field_split.cpp, approx_sphere.cpp, bernstein_bezier_generate_base.cpp, bone_adaptation.cpp, boundary_marker.cpp, build_large_problem.cpp, build_problems.cpp, cell_forces.cpp, child_and_parent.cpp, 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, cubit_bc_test.cpp, delete_ho_nodes.cpp, dg_projection.cpp, dm_build_partitioned_mesh.cpp, dm_create_subdm.cpp, dm_partitioned_no_field.cpp, dynamic_first_order_con_law.cpp, edge_and_bubble_shape_functions_on_quad.cpp, eigen_elastic.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, ep.cpp, field_blas.cpp, field_evaluator.cpp, field_to_vertices.cpp, forces_and_sources_testing_edge_element.cpp, forces_and_sources_testing_flat_prism_element.cpp, forces_and_sources_testing_users_base.cpp, free_surface.cpp, gauss_points_on_outer_product.cpp, hanging_node_approx.cpp, hcurl_check_approx_in_2d.cpp, hcurl_curl_operator.cpp, hcurl_divergence_operator_2d.cpp, hdiv_divergence_operator.cpp, heat_equation.cpp, heat_method.cpp, hello_world.cpp, helmholtz.cpp, hertz_surface.cpp, higher_derivatives.cpp, level_set.cpp, log.cpp, loop_entities.cpp, lorentz_force.cpp, magnetostatic.cpp, matrix_function.cpp, mesh_cut.cpp, mesh_insert_interface_atom.cpp, mesh_smoothing.cpp, meshset_to_vtk.cpp, minimal_surface_area.cpp, mixed_poisson.cpp, mortar_contact.cpp, mortar_contact_thermal.cpp, navier_stokes.cpp, node_merge.cpp, nonlinear_dynamics.cpp, nonlinear_elastic.cpp, operators_tests.cpp, partition_mesh.cpp, petsc_smart_ptr_objects.cpp, phase.cpp, photon_diffusion.cpp, plastic.cpp, plate.cpp, plot_base.cpp, poisson_2d_dis_galerkin.cpp, poisson_2d_homogeneous.cpp, prism_elements_from_surface.cpp, prism_polynomial_approximation.cpp, quad_polynomial_approximation.cpp, reaction_diffusion.cpp, remove_entities_from_problem.cpp, remove_entities_from_problem_not_partitioned.cpp, scalar_check_approximation.cpp, schur_test_diag_mat.cpp, seepage.cpp, shallow_wave.cpp, simple_contact.cpp, simple_contact_thermal.cpp, simple_elasticity.cpp, simple_interface.cpp, simple_l2_only.cpp, split_sideset.cpp, tensor_divergence_operator.cpp, test_broken_space.cpp, test_cache_on_entities.cpp, test_jacobian_of_simple_contact_element.cpp, testing_jacobian_of_hook_element.cpp, testing_jacobian_of_hook_scaled_with_density_element.cpp, thermo_elastic.cpp, unsaturated_transport.cpp, wave_equation.cpp, and wavy_surface.cpp.

Definition at line 112 of file Core.cpp.

                              {
  if (isGloballyInitialised) {
    PetscPopErrorHandler();
    isGloballyInitialised = false;
 
    if (isInitialized == PETSC_FALSE) {
      PetscBool is_finalized;
      PetscFinalized(&is_finalized);
      if (!is_finalized)
        PetscFinalize();
    }
 
    if (!mpiInitialised) {
      int mpi_finalized;
      MPI_Finalized(&mpi_finalized);
      if (!mpi_finalized)
        MPI_Finalize();
    }
  }
 
  return 0;
}

get_basic_entity_data_ptr()

boost::shared_ptr<BasicEntityData>& MoFEM::CoreTmp< 0 >::get_basic_entity_data_ptr ( )

inlineprotectedvirtual

Get pointer to basic entity data.

This structure keeps data like tags handlers and other data used to construct mofem entities, dofs and finite elements.

Implements MoFEM::CoreInterface.

Definition at line 290 of file Core.hpp.

                                                                {
    return basicEntityDataPtr;
  }

get_comm()

MPI_Comm& MoFEM::CoreTmp< 0 >::get_comm ( ) const

inlineprotectedvirtual

Returns

return communicator

Implements MoFEM::CoreInterface.

Definition at line 1021 of file Core.hpp.

{ return mofemComm; }

get_comm_rank()

int MoFEM::CoreTmp< 0 >::get_comm_rank ( ) const

inlineprotectedvirtual

Returns

return communicator rank/processor

Implements MoFEM::CoreInterface.

Definition at line 1031 of file Core.hpp.

{ return rAnk; }

get_comm_size()

int MoFEM::CoreTmp< 0 >::get_comm_size ( ) const

inlineprotectedvirtual

Returns

return communicator size

Implements MoFEM::CoreInterface.

Definition at line 1026 of file Core.hpp.

{ return sIze; }

get_dofs() [1/2]

const DofEntity_multiIndex * MoFEM::Core::get_dofs ( ) const

protectedvirtual

Get the dofs object.

Returns

const DofEntity_multiIndex*

Implements MoFEM::CoreInterface.

Definition at line 890 of file Core.cpp.

{ return &dofsField; }

get_dofs() [2/2]

MoFEMErrorCode MoFEM::Core::get_dofs ( const DofEntity_multiIndex **  dofs_ptr ) const

protectedvirtual

Get dofs multi index.

Implements MoFEM::CoreInterface.

Definition at line 829 of file Core.cpp.

                                                                         {
  MoFEMFunctionBeginHot;
  *dofs_ptr = &dofsField;
  MoFEMFunctionReturnHot(0);
}

get_dofs_by_name_and_ent_begin()

DofEntityByUId::iterator MoFEM::Core::get_dofs_by_name_and_ent_begin ( const std::string &  field_name, const EntityHandle  ent  ) const

protectedvirtual

get begin iterator of field dofs of given name and ent(instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,ENT,IT)

for(IT_GET_DOFS_FIELD_BY_NAME_AND_ENT_FOR_LOOP(MFIELD,NAME,ENT,IT)) { ... }

Parameters

field_name

Implements MoFEM::CoreInterface.

Definition at line 1378 of file FieldCore.cpp.

                                                                   {
  return dofsField.get<Unique_mi_tag>().lower_bound(
      FieldEntity::getLoLocalEntityBitNumber(get_field_bit_number(field_name),
                                             ent));
}

get_dofs_by_name_and_ent_end()

DofEntityByUId::iterator MoFEM::Core::get_dofs_by_name_and_ent_end ( const std::string &  field_name, const EntityHandle  ent  ) const

protectedvirtual

get begin iterator of field dofs of given name and ent (instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,ENT,IT)

for(IT_GET_DOFS_FIELD_BY_NAME_AND_ENT_FOR_LOOP(MFIELD,NAME,ENT,IT)) { ... }

Parameters

field_name

Implements MoFEM::CoreInterface.

Definition at line 1385 of file FieldCore.cpp.

                                                                 {
  return dofsField.get<Unique_mi_tag>().upper_bound(
      FieldEntity::getHiLocalEntityBitNumber(get_field_bit_number(field_name),
                                             ent));
}

get_dofs_by_name_and_type_begin()

DofEntityByUId::iterator MoFEM::Core::get_dofs_by_name_and_type_begin ( const std::string &  field_name, const EntityType  type  ) const

protectedvirtual

get begin iterator of field dofs of given name and ent type (instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,TYPE,IT)

for(IT_GET_DOFS_FIELD_BY_NAME_AND_TYPE_FOR_LOOP(MFIELD,NAME,TYPE,IT)) { ... }

Parameters

field_name

Implements MoFEM::CoreInterface.

Definition at line 1392 of file FieldCore.cpp.

                                                                   {
  return dofsField.get<Unique_mi_tag>().lower_bound(
      FieldEntity::getLoLocalEntityBitNumber(get_field_bit_number(field_name),
                                             get_id_for_min_type(type)));
}

get_dofs_by_name_and_type_end()

DofEntityByUId::iterator MoFEM::Core::get_dofs_by_name_and_type_end ( const std::string &  field_name, const EntityType  type  ) const

protectedvirtual

get begin iterator of field dofs of given name end ent type(instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,TYPE,IT)

for(IT_GET_DOFS_FIELD_BY_NAME_AND_TYPE_FOR_LOOP(MFIELD,NAME,TYPE,IT)) { ... }

Parameters

field_name

Implements MoFEM::CoreInterface.

Definition at line 1399 of file FieldCore.cpp.

                                                                 {
  return dofsField.get<Unique_mi_tag>().upper_bound(
      FieldEntity::getHiLocalEntityBitNumber(get_field_bit_number(field_name),
                                             get_id_for_max_type(type)));
}

get_dofs_by_name_begin()

DofEntityByUId::iterator MoFEM::Core::get_dofs_by_name_begin ( const std::string &  field_name ) const

protectedvirtual

get begin iterator of field dofs of given name (instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)

for(IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)) { ... }

Parameters

field_name

Implements MoFEM::CoreInterface.

Definition at line 1368 of file FieldCore.cpp.

                                                              {
  return dofsField.get<Unique_mi_tag>().lower_bound(
      FieldEntity::getLoBitNumberUId(get_field_bit_number(field_name)));
}

get_dofs_by_name_end()

DofEntityByUId::iterator MoFEM::Core::get_dofs_by_name_end ( const std::string &  field_name ) const

protectedvirtual

get begin iterator of field dofs of given name (instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)

for(IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)) { ... }

Parameters

field_name

Implements MoFEM::CoreInterface.

Definition at line 1373 of file FieldCore.cpp.

                                                            {
  return dofsField.get<Unique_mi_tag>().upper_bound(
      FieldEntity::getHiBitNumberUId(get_field_bit_number(field_name)));
}

get_ent_field_by_name_begin()

FieldEntityByUId::iterator MoFEM::Core::get_ent_field_by_name_begin ( const std::string &  field_name ) const

protectedvirtual

get begin iterator of field ents of given name (instead you can use IT_GET_ENT_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)

for(IT_GET_ENT_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)) { ... }

Parameters

field_name

Implements MoFEM::CoreInterface.

Definition at line 1358 of file FieldCore.cpp.

                                                                   {
  return entsFields.get<Unique_mi_tag>().lower_bound(
      FieldEntity::getLoBitNumberUId(get_field_bit_number(field_name)));
}

get_ent_field_by_name_end()

FieldEntityByUId::iterator MoFEM::Core::get_ent_field_by_name_end ( const std::string &  field_name ) const

protectedvirtual

get begin iterator of field dofs of given name (instead you can use IT_GET_ENT_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)

for(IT_GET_ENT_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)) { ... }

Parameters

field_name

Implements MoFEM::CoreInterface.

Definition at line 1363 of file FieldCore.cpp.

                                                                 {
  return entsFields.get<Unique_mi_tag>().upper_bound(
      FieldEntity::getHiBitNumberUId(get_field_bit_number(field_name)));
}

get_ents_elements_adjacency() [1/2]

const FieldEntityEntFiniteElementAdjacencyMap_multiIndex * MoFEM::Core::get_ents_elements_adjacency ( ) const

protectedvirtual

Get the dofs elements adjacency object.

Returns

const FieldEntityEntFiniteElementAdjacencyMap_multiIndex*

Implements MoFEM::CoreInterface.

Definition at line 870 of file Core.cpp.

                                        {
  return &entFEAdjacencies;
}

get_ents_elements_adjacency() [2/2]

MoFEMErrorCode MoFEM::Core::get_ents_elements_adjacency ( const FieldEntityEntFiniteElementAdjacencyMap_multiIndex **  dofs_elements_adjacency ) const

protectedvirtual

Get the dofs elements adjacency object.

Parameters

dofs_elements_adjacency

Returns

MoFEMErrorCode

Implements MoFEM::CoreInterface.

Definition at line 861 of file Core.cpp.

                                        {
  MoFEMFunctionBeginHot;
  *dofs_elements_adjacency = &entFEAdjacencies;
  MoFEMFunctionReturnHot(0);
}

get_ents_finite_elements() [1/2]

const EntFiniteElement_multiIndex * MoFEM::Core::get_ents_finite_elements ( ) const

protectedvirtual

Get the ents finite elements object.

Returns

const EntFiniteElement_multiIndex*

Implements MoFEM::CoreInterface.

Definition at line 884 of file Core.cpp.

                                                                        {
  return &entsFiniteElements;
}

get_ents_finite_elements() [2/2]

MoFEMErrorCode MoFEM::Core::get_ents_finite_elements ( const EntFiniteElement_multiIndex **  fe_ent_ptr ) const

protectedvirtual

Get entities finite elements multi-index.

Implements MoFEM::CoreInterface.

Definition at line 842 of file Core.cpp.

                                                          {
  MoFEMFunctionBeginHot;
  *fe_ent_ptr = &entsFiniteElements;
  MoFEMFunctionReturnHot(0);
}

get_fe_by_name_begin()

EntFiniteElement_multiIndex::index< Unique_mi_tag >::type::iterator MoFEM::Core::get_fe_by_name_begin ( const std::string &  fe_name ) const

protectedvirtual

get begin iterator of finite elements of given name (instead you can use IT_GET_FES_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)

for(IT_GET_FES_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)) { ... }

Parameters

fe_name

Implements MoFEM::CoreInterface.

Definition at line 836 of file FECore.cpp.

                                                         {
  auto miit = finiteElements.get<FiniteElement_name_mi_tag>().find(fe_name);
  if (miit != finiteElements.get<FiniteElement_name_mi_tag>().end()) {
    return entsFiniteElements.get<Unique_mi_tag>().lower_bound(
        EntFiniteElement::getLocalUniqueIdCalculate(0, (*miit)->getFEUId()));
  } else {
    return entsFiniteElements.get<Unique_mi_tag>().end();
  }
}

get_fe_by_name_end()

EntFiniteElement_multiIndex::index< Unique_mi_tag >::type::iterator MoFEM::Core::get_fe_by_name_end ( const std::string &  fe_name ) const

protectedvirtual

get end iterator of finite elements of given name (instead you can use IT_GET_FES_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)

for(IT_GET_FES_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)) { ... }

Parameters

fe_name

Implements MoFEM::CoreInterface.

Definition at line 847 of file FECore.cpp.

                                                       {
  auto miit = finiteElements.get<FiniteElement_name_mi_tag>().find(fe_name);
  if (miit != finiteElements.get<FiniteElement_name_mi_tag>().end()) {
    return entsFiniteElements.get<Unique_mi_tag>().upper_bound(
        EntFiniteElement::getLocalUniqueIdCalculate(
            get_id_for_max_type<MBENTITYSET>(), (*miit)->getFEUId()));
  } else {
    return entsFiniteElements.get<Unique_mi_tag>().end();
  }
}

get_field_bit_number()

FieldBitNumber MoFEM::Core::get_field_bit_number ( const std::string  name ) const

protectedvirtual

get field bit number

Parameters

name	of field Example: auto field_number = mField.get_field_bit_number("DISPLACEMENT");

Implements MoFEM::CoreInterface.

Definition at line 28 of file FieldCore.cpp.

                                                                    {
  auto &set = fIelds.get<FieldName_mi_tag>();
  auto miit = set.find(name);
  if (miit == set.end())
    THROW_MESSAGE("field < " + name +
                  " > not in database (top tip: check spelling)");
  return (*miit)->getBitNumber();
}

get_field_entities_by_dimension()

MoFEMErrorCode MoFEM::Core::get_field_entities_by_dimension ( const std::string  name, int  dim, Range &  ents  ) const

protectedvirtual

get entities in the field by dimension

Parameters

name	field name
dim	dim
ents	ents

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 81 of file FieldCore.cpp.

                                                                        {
 
  MoFEMFunctionBegin;
  EntityHandle meshset = get_field_meshset(name);
  CHKERR get_moab().get_entities_by_dimension(meshset, dim, ents, true);
  MoFEMFunctionReturn(0);
}

get_field_entities_by_handle()

MoFEMErrorCode MoFEM::Core::get_field_entities_by_handle ( const std::string  name, Range &  ents  ) const

protectedvirtual

get entities in the field by handle

Parameters

name	field name
ents	ents

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 100 of file FieldCore.cpp.

                                                                     {
  MoFEMFunctionBegin;
  EntityHandle meshset = get_field_meshset(name);
  CHKERR get_moab().get_entities_by_handle(meshset, ents, true);
  MoFEMFunctionReturn(0);
}

get_field_entities_by_type()

MoFEMErrorCode MoFEM::Core::get_field_entities_by_type ( const std::string  name, EntityType  type, Range &  ents  ) const

protectedvirtual

get entities in the field by type

Parameters

name	field name
type	entity type
ents	ents

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 91 of file FieldCore.cpp.

                                                                   {
  MoFEMFunctionBegin;
  EntityHandle meshset = get_field_meshset(name);
  CHKERR get_moab().get_entities_by_type(meshset, type, ents, true);
  MoFEMFunctionReturn(0);
}

get_field_ents() [1/2]

const FieldEntity_multiIndex * MoFEM::Core::get_field_ents ( ) const

protectedvirtual

Get the field ents object.

Returns

const FieldEntity_multiIndex*

Implements MoFEM::CoreInterface.

Definition at line 887 of file Core.cpp.

                                                         {
  return &entsFields;
}

get_field_ents() [2/2]

MoFEMErrorCode MoFEM::Core::get_field_ents ( const FieldEntity_multiIndex **  field_ents ) const

protectedvirtual

Get field multi index.

Implements MoFEM::CoreInterface.

Definition at line 824 of file Core.cpp.

                                                                    {
  MoFEMFunctionBeginHot;
  *field_ents = &entsFields;
  MoFEMFunctionReturnHot(0);
}

get_field_id()

BitFieldId MoFEM::Core::get_field_id ( const std::string &  name ) const

protectedvirtual

Get field Id.

Parameters

name

of field

Returns

BitFieldId

Implements MoFEM::CoreInterface.

Definition at line 18 of file FieldCore.cpp.

                                                         {
  auto &set = fIelds.get<FieldName_mi_tag>();
  auto miit = set.find(name);
  if (miit == set.end()) {
    THROW_MESSAGE("field < " + name +
                  " > not in database (top tip: check spelling)");
  }
  return (*miit)->getId();
}

get_field_meshset() [1/2]

EntityHandle MoFEM::Core::get_field_meshset ( const BitFieldId  id ) const

protected

Definition at line 45 of file FieldCore.cpp.

                                                              {
  auto &set = fIelds.get<BitFieldId_mi_tag>();
  auto miit = set.find(id);
  if (miit == set.end())
    THROW_MESSAGE("field not in database (top tip: check spelling)");
  return (*miit)->meshSet;
}

get_field_meshset() [2/2]

EntityHandle MoFEM::Core::get_field_meshset ( const std::string  name ) const

protectedvirtual

get field meshset

Parameters

name	of Field Example: EntityHandle disp_files_meshset = mField.get_field_meshset("DISPLACEMENT");

Implements MoFEM::CoreInterface.

Definition at line 53 of file FieldCore.cpp.

                                                               {
  return get_field_meshset(get_field_id(name));
}

get_field_name()

std::string MoFEM::Core::get_field_name ( const BitFieldId  id ) const

protectedvirtual

get field name from id

Parameters

id

Returns

std::string

Implements MoFEM::CoreInterface.

Definition at line 37 of file FieldCore.cpp.

                                                        {
  auto &set = fIelds.get<BitFieldId_mi_tag>();
  auto miit = set.find(id);
  if (miit == set.end())
    THROW_MESSAGE("field not in database (top tip: check spelling)");
  return (*miit)->getName();
}

get_field_structure()

const Field * MoFEM::Core::get_field_structure ( const std::string &  name, enum MoFEMTypes  bh = MF_EXIST  ) const

protectedvirtual

get field structure

If field is not found throw error if bh == MF_EXIST, or return nullptr if bh == MF_ZERO, i.e. otherwise

Parameters

name	field name
bh	controls behaviour

Returns

const Field*

Implements MoFEM::CoreInterface.

Definition at line 65 of file FieldCore.cpp.

                                                                 {
  auto miit = fIelds.get<FieldName_mi_tag>().find(name);
  if (miit == fIelds.get<FieldName_mi_tag>().end()) {
    if (bh == MF_EXIST)
      throw MoFEMException(
          MOFEM_NOT_FOUND,
          std::string("field < " + name +
                      " > not in database (top tip: check spelling)")
              .c_str());
    else
      return nullptr;
  }
  return miit->get();
}

get_fields() [1/2]

const Field_multiIndex * MoFEM::Core::get_fields ( ) const

protectedvirtual

Get the fields object.

Returns

const Field_multiIndex*

Implements MoFEM::CoreInterface.

Definition at line 874 of file Core.cpp.

{ return &fIelds; }

get_fields() [2/2]

MoFEMErrorCode MoFEM::Core::get_fields ( const Field_multiIndex **  fields_ptr ) const

protectedvirtual

Get fields multi-index from database.

Implements MoFEM::CoreInterface.

Definition at line 782 of file Core.cpp.

                                                                         {
  MoFEMFunctionBeginHot;
  *fields_ptr = &fIelds;
  MoFEMFunctionReturnHot(0);
}

get_finite_element_entities_by_dimension()

MoFEMErrorCode MoFEM::Core::get_finite_element_entities_by_dimension ( const std::string  name, int  dim, Range &  ents  ) const

protectedvirtual

get entities in the finite element by dimension

Parameters

name	finite element name
dim	dim
ents	ents

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 286 of file FECore.cpp.

                                                                  {
 
  MoFEMFunctionBegin;
 
  EntityHandle meshset = get_finite_element_meshset(name);
  CHKERR get_moab().get_entities_by_dimension(meshset, dim, ents, true);
  MoFEMFunctionReturn(0);
}

get_finite_element_entities_by_handle()

MoFEMErrorCode MoFEM::Core::get_finite_element_entities_by_handle ( const std::string  name, Range &  ents  ) const

protectedvirtual

get entities in the finite element by handle

Parameters

name	finite element name
ents	ents

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 309 of file FECore.cpp.

                                                               {
 
  MoFEMFunctionBegin;
 
  EntityHandle meshset = get_finite_element_meshset(name);
  CHKERR get_moab().get_entities_by_handle(meshset, ents, true);
 
  MoFEMFunctionReturn(0);
}

get_finite_element_entities_by_type()

MoFEMErrorCode MoFEM::Core::get_finite_element_entities_by_type ( const std::string  name, EntityType  type, Range &  ents  ) const

protectedvirtual

get entities in the finite element by type

Parameters

name	finite element name
type	entity type
ents	ents

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 296 of file FECore.cpp.

                                                                            {
 
  MoFEMFunctionBegin;
 
  EntityHandle meshset = get_finite_element_meshset(name);
  CHKERR get_moab().get_entities_by_type(meshset, type, ents, true);
 
  MoFEMFunctionReturn(0);
}

get_finite_element_meshset() [1/2]

EntityHandle MoFEM::Core::get_finite_element_meshset ( const BitFEId  id ) const

protected

Definition at line 273 of file FECore.cpp.

                                                                    {
  auto &fe_by_id = finiteElements.get<BitFEId_mi_tag>();
  auto miit = fe_by_id.find(id);
  if (miit == fe_by_id.end())
    THROW_MESSAGE("finite element not found");
  return (*miit)->meshset;
}

get_finite_element_meshset() [2/2]

EntityHandle MoFEM::Core::get_finite_element_meshset ( const std::string  name ) const

protectedvirtual

get finite element meshset

Implements MoFEM::CoreInterface.

Definition at line 281 of file FECore.cpp.

                                                                        {
  return get_finite_element_meshset(getBitFEId(name));
}

get_finite_element_structure()

const FiniteElement * MoFEM::Core::get_finite_element_structure ( const std::string &  name, enum MoFEMTypes  bh = MF_EXCL  ) const

protectedvirtual

get finite element struture

If finite element is not found throw error if bh == MF_EXIST, or return nullptr if bh == MF_ZERO, i.e. otherwise

Parameters

name
bh

Returns

FiniteElement*

Implements MoFEM::CoreInterface.

Definition at line 18 of file FECore.cpp.

                                                             {
  auto miit = finiteElements.get<FiniteElement_name_mi_tag>().find(name);
  if (miit == finiteElements.get<FiniteElement_name_mi_tag>().end()) {
    if (bh == MF_EXIST) {
      throw MoFEMException(
          MOFEM_NOT_FOUND,
          std::string("finite element < " + name +
                      " > not in database (top tip: check spelling)")
              .c_str());
    } else {
      return nullptr;
    }
  }
  return miit->get();
}

get_finite_elements() [1/2]

const FiniteElement_multiIndex * MoFEM::Core::get_finite_elements ( ) const

protectedvirtual

Get the finite elements object.

Returns

const FiniteElement_multiIndex*

Implements MoFEM::CoreInterface.

Definition at line 881 of file Core.cpp.

                                                                {
  return &finiteElements;
}

get_finite_elements() [2/2]

MoFEMErrorCode MoFEM::Core::get_finite_elements ( const FiniteElement_multiIndex **  fe_ptr ) const

protectedvirtual

Get finite elements multi-index.

Implements MoFEM::CoreInterface.

Definition at line 836 of file Core.cpp.

                                                                       {
  MoFEMFunctionBeginHot;
  *fe_ptr = &finiteElements;
  MoFEMFunctionReturnHot(0);
}

get_meshsets_manager() [1/2]

MeshsetsManager& MoFEM::CoreTmp< 0 >::get_meshsets_manager ( )

inlineprotectedvirtual

get MeshsetsManager pointer

Implements MoFEM::CoreInterface.

Definition at line 361 of file Core.hpp.

                                                 {
    return *get_meshsets_manager_ptr();
  }

get_meshsets_manager() [2/2]

const MeshsetsManager& MoFEM::CoreTmp< 0 >::get_meshsets_manager ( ) const

inlineprotectedvirtual

get MeshsetsManager pointer

Implements MoFEM::CoreInterface.

Definition at line 364 of file Core.hpp.

                                                             {
    return *get_meshsets_manager_ptr();
  }

get_meshsets_manager_ptr() [1/2]

const MeshsetsManager * MoFEM::Core::get_meshsets_manager_ptr ( )

protectedvirtual

get MeshsetsManager pointer

Implements MoFEM::CoreInterface.

Definition at line 849 of file Core.cpp.

                                                {
  MeshsetsManager *meshsets_manager_ptr;
  getInterface(meshsets_manager_ptr);
  return meshsets_manager_ptr;
}

get_meshsets_manager_ptr() [2/2]

const MeshsetsManager* MoFEM::CoreTmp< 0 >::get_meshsets_manager_ptr ( ) const

protectedvirtual

get MeshsetsManager pointer

Implements MoFEM::CoreInterface.

get_moab() [1/2]

moab::Interface& MoFEM::CoreTmp< 0 >::get_moab ( )

inlineprotectedvirtual

get moab instance

Implements MoFEM::CoreInterface.

Definition at line 322 of file Core.hpp.

{ return moab; }

get_moab() [2/2]

const moab::Interface& MoFEM::CoreTmp< 0 >::get_moab ( ) const

inlineprotectedvirtual

get moab instance interface

Implements MoFEM::CoreInterface.

Definition at line 323 of file Core.hpp.

{ return moab; }

get_problem() [1/2]

MoFEMErrorCode MoFEM::Core::get_problem ( const std::string &  problem_name, const Problem **  problem_ptr  ) const

protectedvirtual

Get problem database (data structure)

Implements MoFEM::CoreInterface.

Definition at line 801 of file Core.cpp.

                                                                    {
  MoFEMFunctionBeginHot;
  typedef Problem_multiIndex::index<Problem_mi_tag>::type ProblemsByName;
  const ProblemsByName &problems = pRoblems.get<Problem_mi_tag>();
  ProblemsByName::iterator p_miit = problems.find(problem_name);
  if (p_miit == problems.end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
             "problem < %s > not found, (top tip: check spelling)",
             problem_name.c_str());
  }
  *problem_ptr = &*p_miit;
  MoFEMFunctionReturnHot(0);
}

get_problem() [2/2]

const Problem * MoFEM::Core::get_problem ( const std::string  problem_name ) const

protectedvirtual

Get the problem object.

Parameters

problem_name

Returns

const Problem*

Implements MoFEM::CoreInterface.

Definition at line 891 of file Core.cpp.

                                                                   {
  const Problem *prb;
  CHK_THROW_MESSAGE(get_problem(problem_name, &prb),
                    "Problem of given name not found");
  return prb;
}

get_problem_finite_elements_entities()

MoFEMErrorCode MoFEM::Core::get_problem_finite_elements_entities ( const std::string  name, const std::string &  fe_name, const EntityHandle  meshset  )

protectedvirtual

add finite elements to the meshset

Parameters

name	is problem name
fe_name
meshset

Implements MoFEM::CoreInterface.

Definition at line 911 of file FECore.cpp.

                                                                       {
  MoFEMFunctionBegin;
  auto &prb = pRoblems.get<Problem_mi_tag>();
  auto p_miit = prb.find(problem_name);
  if (p_miit == prb.end())
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "No such problem like < %s >", problem_name.c_str());
 
  auto fe_miit = finiteElements.get<FiniteElement_name_mi_tag>().find(fe_name);
  if (fe_miit != finiteElements.get<FiniteElement_name_mi_tag>().end()) {
    auto miit =
        p_miit->numeredFiniteElementsPtr->get<Unique_mi_tag>().lower_bound(
            EntFiniteElement::getLocalUniqueIdCalculate(
                0, (*fe_miit)->getFEUId()));
    auto hi_miit =
        p_miit->numeredFiniteElementsPtr->get<Unique_mi_tag>().upper_bound(
            EntFiniteElement::getLocalUniqueIdCalculate(
                get_id_for_max_type<MBENTITYSET>(), (*fe_miit)->getFEUId()));
 
    if (miit != hi_miit) {
      std::vector<EntityHandle> ents;
      ents.reserve(std::distance(miit, hi_miit));
      for (; miit != hi_miit; ++miit)
        ents.push_back((*miit)->getEnt());
      int part = (*miit)->getPart();
      CHKERR get_moab().tag_clear_data(th_Part, &*ents.begin(), ents.size(),
                                       &part);
      CHKERR get_moab().add_entities(meshset, &*ents.begin(), ents.size());
    }
  }
 
  MoFEMFunctionReturn(0);
}

get_problems() [1/2]

const Problem_multiIndex * MoFEM::Core::get_problems ( ) const

protectedvirtual

Get the problems object.

Returns

const Problem_multiIndex*

Implements MoFEM::CoreInterface.

Definition at line 897 of file Core.cpp.

{ return &pRoblems; }

get_problems() [2/2]

MoFEMErrorCode MoFEM::Core::get_problems ( const Problem_multiIndex **  problems_ptr ) const

protectedvirtual

Get pointer to problems multi-index.

Implements MoFEM::CoreInterface.

Definition at line 817 of file Core.cpp.

                                                                {
  MoFEMFunctionBeginHot;
  *problems_ptr = &pRoblems;
  MoFEMFunctionReturnHot(0);
}

get_ref_ents() [1/2]

const RefEntity_multiIndex * MoFEM::Core::get_ref_ents ( ) const

protectedvirtual

Get the ref ents object.

Returns

const RefEntity_multiIndex*

Implements MoFEM::CoreInterface.

Definition at line 875 of file Core.cpp.

                                                     {
  return &refinedEntities;
}

get_ref_ents() [2/2]

MoFEMErrorCode MoFEM::Core::get_ref_ents ( const RefEntity_multiIndex **  refined_ents_ptr ) const

protectedvirtual

Get ref entities multi-index from database.

Implements MoFEM::CoreInterface.

Definition at line 789 of file Core.cpp.

                                                                          {
  MoFEMFunctionBeginHot;
  *refined_entities_ptr = &refinedEntities;
  MoFEMFunctionReturnHot(0);
}

get_ref_finite_elements() [1/2]

const RefElement_multiIndex * MoFEM::Core::get_ref_finite_elements ( ) const

protectedvirtual

Get the ref finite elements object.

Returns

const RefElement_multiIndex*

Implements MoFEM::CoreInterface.

Definition at line 878 of file Core.cpp.

                                                                 {
  return &refinedFiniteElements;
}

get_ref_finite_elements() [2/2]

MoFEMErrorCode MoFEM::Core::get_ref_finite_elements ( const RefElement_multiIndex **  refined_finite_elements_ptr ) const

protectedvirtual

Get ref finite elements multi-index form database.

Implements MoFEM::CoreInterface.

Definition at line 794 of file Core.cpp.

                                                                     {
  MoFEMFunctionBeginHot;
  *refined_finite_elements_ptr = &refinedFiniteElements;
  MoFEMFunctionReturnHot(0);
}

get_th_RefBitEdge()

Tag MoFEM::CoreTmp< 0 >::get_th_RefBitEdge ( ) const

inline

Definition at line 199 of file Core.hpp.

{ return th_RefBitEdge; }

get_th_RefBitLevel()

Tag MoFEM::CoreTmp< 0 >::get_th_RefBitLevel ( ) const

inline

Definition at line 198 of file Core.hpp.

{ return th_RefBitLevel; }

get_th_RefParentHandle()

Tag MoFEM::CoreTmp< 0 >::get_th_RefParentHandle ( ) const

inline

Definition at line 197 of file Core.hpp.

{ return th_RefParentHandle; }

getBitFEId()

BitFEId MoFEM::Core::getBitFEId ( const std::string &  fe_name ) const

protected

Get field Id.

Parameters

name	field name

Returns

field id

Definition at line 255 of file FECore.cpp.

                                                       {
  auto &fe_by_id = finiteElements.get<FiniteElement_name_mi_tag>();
  auto miit = fe_by_id.find(fe_name);
  if (miit == fe_by_id.end())
    THROW_MESSAGE(
        ("finite element < " + fe_name + " > not found (top tip: check spelling)")
            .c_str());
  return (*miit)->getId();
}

getBitFEIdName()

std::string MoFEM::Core::getBitFEIdName ( const BitFEId  id ) const

protected

Get field name.

Parameters

id

field id

Returns

field name

Definition at line 265 of file FECore.cpp.

                                                     {
  auto &fe_by_id = finiteElements.get<BitFEId_mi_tag>();
  auto miit = fe_by_id.find(id);
  if (miit == fe_by_id.end())
    THROW_MESSAGE("finite element not found");
  return (*miit)->getName();
}

getBitProblemId()

BitProblemId MoFEM::Core::getBitProblemId ( const std::string &  name ) const

protected

Definition at line 121 of file ProblemsCore.cpp.

                                                              {
  auto p_miit = pRoblems.get<Problem_mi_tag>().find(name);
  if (p_miit == pRoblems.get<Problem_mi_tag>().end()) {
    THROW_MESSAGE("no such problem like " + name + " >");
  }
  return p_miit->getId();
}

getBuildMoFEM()

int& MoFEM::CoreTmp< 0 >::getBuildMoFEM ( ) const

inline

Get flags/semaphores for different stages.

Definition at line 225 of file Core.hpp.

{ return *buildMoFEM; }

getOptions()

MoFEMErrorCode MoFEM::Core::getOptions ( int  verb = DEFAULT_VERBOSITY )

protected

Get core options from command line.

Returns

MoFEMErrorCode

Definition at line 755 of file Core.cpp.

                                        {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
 
  CHKERR PetscOptionsBegin(mofemComm, optionsPrefix.c_str(), "Mesh cut options",
                           "See MoFEM documentation");
 
  CHKERR PetscOptionsBool(
      "-mofem_init_fields", "Initialise fields on construction", "",
      initaliseAndBuildField, &initaliseAndBuildField, NULL);
 
  CHKERR PetscOptionsBool(
      "-mofem_init_fields", "Initialise fields on construction", "",
      initaliseAndBuildFiniteElements, &initaliseAndBuildFiniteElements, NULL);
 
  // TODO: Add read verbosity level
  // TODO: Add option to initalise problems ??? -  DO WE REALLY NEED THAT
 
  ierr = PetscOptionsEnd();
  CHKERRG(ierr);
 
  MoFEMFunctionReturn(0);
}

getProblemShift()

BitProblemId MoFEM::CoreTmp< 0 >::getProblemShift ( )

protected

Return unique problem Id.

Each time this function is called, it gives new unit problem Id for bit.

getRefEntity()

RefEntityTmp<0> MoFEM::CoreTmp< 0 >::getRefEntity ( const EntityHandle  ent )

inline

Definition at line 86 of file Core.hpp.

                                                       {
    return RefEntityTmp<0>(this->basicEntityDataPtr, ent);
  }

getTags()

MoFEMErrorCode MoFEM::Core::getTags ( int  verb = DEFAULT_VERBOSITY )

protected

Get tag handles.

Parameters

verb	verbosity level

Returns

error code

Definition at line 551 of file Core.cpp.

                                     {
  MoFEMFunctionBegin;
 
  const EntityHandle root_meshset = get_moab().get_root_set();
  if (root_meshset) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Root meshset should be 0");
  }
 
  // Set version
  {
    Version version;
    CHKERR getFileVersion(moab, version);
  }
 
  // Global Variables
  {
 
    auto check_tag_allocated = [](auto &rval) {
      MoFEMFunctionBeginHot;
      if (rval == MB_ALREADY_ALLOCATED)
        rval = MB_SUCCESS;
      else
        CHKERRG(rval);
      MoFEMFunctionReturnHot(0);
    };
 
    // Safety nets
    int def_bool = 0;
    rval = get_moab().tag_get_handle("_MoFEMBuild", 1, MB_TYPE_INTEGER,
                                     th_MoFEMBuild, MB_TAG_CREAT | MB_TAG_MESH,
                                     &def_bool);
    CHKERR check_tag_allocated(rval);
 
    CHKERR get_moab().tag_get_by_ptr(th_MoFEMBuild, &root_meshset, 1,
                                     (const void **)&buildMoFEM);
  }
 
  // Tags saved in vtk-files
  {
    const int def_part = -1;
    CHKERR get_moab().tag_get_handle("PARTITION", 1, MB_TYPE_INTEGER, th_Part,
                                     MB_TAG_CREAT | MB_TAG_SPARSE, &def_part);
  }
 
  // Tags Ref
  {
 
    // Fix size of bir ref level tags
    CHKERR BitRefManager::fixTagSize(get_moab());
 
    const int def_part = -1;
    CHKERR get_moab().tag_get_handle("_MeshsetPartition", 1, MB_TYPE_INTEGER,
                                     th_Part, MB_TAG_CREAT | MB_TAG_SPARSE,
                                     &def_part);
    EntityHandle def_handle = 0;
    CHKERR get_moab().tag_get_handle("_RefParentHandle", 1, MB_TYPE_HANDLE,
                                     th_RefParentHandle,
                                     MB_TAG_CREAT | MB_TAG_SPARSE, &def_handle);
    BitRefLevel def_bit_level = 0;
    CHKERR get_moab().tag_get_handle(
        "_RefBitLevel", sizeof(BitRefLevel), MB_TYPE_OPAQUE, th_RefBitLevel,
        MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE, &def_bit_level);
    BitRefLevel def_bit_level_mask = BitRefLevel().set();
    CHKERR get_moab().tag_get_handle(
        "_RefBitLevelMask", sizeof(BitRefLevel), MB_TYPE_OPAQUE,
        th_RefBitLevel_Mask, MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE,
        &def_bit_level_mask);
    BitRefEdges def_bit_edge = 0;
    CHKERR get_moab().tag_get_handle(
        "_RefBitEdge", sizeof(BitRefEdges), MB_TYPE_OPAQUE, th_RefBitEdge,
        MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_BYTES, &def_bit_edge);
  }
 
  // Tags Field
  {
    const unsigned long int def_id = 0;
    CHKERR get_moab().tag_get_handle(
        "_FieldId", sizeof(BitFieldId), MB_TYPE_OPAQUE, th_FieldId,
        MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE, &def_id);
    FieldSpace def_space = LASTSPACE;
    CHKERR get_moab().tag_get_handle(
        "_FieldSpace", sizeof(FieldSpace), MB_TYPE_OPAQUE, th_FieldSpace,
        MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE, &def_space);
    FieldContinuity def_continuity = LASTCONTINUITY;
    CHKERR get_moab().tag_get_handle(
        "_FieldContinuity", sizeof(FieldContinuity), MB_TYPE_OPAQUE,
        th_FieldContinuity, MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE,
        &def_continuity);
    FieldApproximationBase def_base = LASTBASE;
    CHKERR get_moab().tag_get_handle(
        "_FieldBase", sizeof(FieldApproximationBase), MB_TYPE_OPAQUE,
        th_FieldBase, MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE, &def_base);
    const int def_val_len = 0;
    CHKERR get_moab().tag_get_handle(
        "_FieldName", def_val_len, MB_TYPE_OPAQUE, th_FieldName,
        MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_VARLEN | MB_TAG_SPARSE, NULL);
    CHKERR get_moab().tag_get_handle(
        "_FieldName_DataNamePrefix", def_val_len, MB_TYPE_OPAQUE,
        th_FieldName_DataNamePrefix,
        MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_VARLEN | MB_TAG_SPARSE, NULL);
  }
 
  // Tags FE
  {
    const unsigned long int def_id = 0;
    const int def_val_len = 0;
    CHKERR get_moab().tag_get_handle(
        "_FEId", sizeof(BitFEId), MB_TYPE_OPAQUE, th_FEId,
        MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE, &def_id);
    CHKERR get_moab().tag_get_handle(
        "_FEName", def_val_len, MB_TYPE_OPAQUE, th_FEName,
        MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_VARLEN | MB_TAG_SPARSE, NULL);
    CHKERR get_moab().tag_get_handle(
        "_FEIdCol", sizeof(BitFieldId), MB_TYPE_OPAQUE, th_FEIdCol,
        MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE, &def_id);
    CHKERR get_moab().tag_get_handle(
        "_FEIdRow", sizeof(BitFieldId), MB_TYPE_OPAQUE, th_FEIdRow,
        MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE, &def_id);
    CHKERR get_moab().tag_get_handle(
        "_FEIdData", sizeof(BitFieldId), MB_TYPE_OPAQUE, th_FEIdData,
        MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE, &def_id);
  }
 
  // Tags Problem
  {
    const unsigned long int def_id = 0;
    const int def_val_len = 0;
    CHKERR get_moab().tag_get_handle(
        "_ProblemId", sizeof(BitProblemId), MB_TYPE_OPAQUE, th_ProblemId,
        MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE, &def_id);
    CHKERR get_moab().tag_get_handle(
        "_ProblemFEId", sizeof(BitFEId), MB_TYPE_OPAQUE, th_ProblemFEId,
        MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE, &def_id);
    CHKERR get_moab().tag_get_handle(
        "_ProblemName", def_val_len, MB_TYPE_OPAQUE, th_ProblemName,
        MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_VARLEN | MB_TAG_SPARSE, NULL);
    DofIdx def_nbdofs = 0;
    CHKERR get_moab().tag_get_handle(
        "_ProblemNbDofsRow", sizeof(DofIdx), MB_TYPE_OPAQUE,
        th_ProblemNbDofsRow, MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE,
        &def_nbdofs);
    CHKERR get_moab().tag_get_handle(
        "_ProblemNbDofsCol", sizeof(DofIdx), MB_TYPE_OPAQUE,
        th_ProblemNbDofsCol, MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE,
        &def_nbdofs);
    CHKERR get_moab().tag_get_handle(
        "_ProblemLocalNbDofsRow", sizeof(DofIdx), MB_TYPE_OPAQUE,
        th_ProblemLocalNbDofRow, MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE,
        &def_nbdofs);
    CHKERR get_moab().tag_get_handle(
        "_ProblemGhostNbDofsRow", sizeof(DofIdx), MB_TYPE_OPAQUE,
        th_ProblemGhostNbDofRow, MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE,
        &def_nbdofs);
    CHKERR get_moab().tag_get_handle(
        "_ProblemLocalNbDofsCol", sizeof(DofIdx), MB_TYPE_OPAQUE,
        th_ProblemLocalNbDofCol, MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE,
        &def_nbdofs);
    CHKERR get_moab().tag_get_handle(
        "_ProblemGhostNbDofsCol", sizeof(DofIdx), MB_TYPE_OPAQUE,
        th_ProblemGhostNbDofCol, MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE,
        &def_nbdofs);
  }
 
  // Meshsets with boundary conditions and material sets
  MeshsetsManager *meshsets_manager_ptr;
  CHKERR getInterface(meshsets_manager_ptr);
  CHKERR meshsets_manager_ptr->getTags(verb);
 
  // Series recorder
  SeriesRecorder *series_recorder_ptr;
  CHKERR getInterface(series_recorder_ptr);
  CHKERR series_recorder_ptr->getTags(verb);
 
  MoFEMFunctionReturn(0);
}

getValue()

const int MoFEM::CoreTmp< 0 >::getValue ( ) const

inlinevirtual

Get the core.

Returns

int

Implements MoFEM::CoreInterface.

Reimplemented in MoFEM::CoreTmp<-1 >.

Definition at line 85 of file Core.hpp.

{ return value; }

initialiseDatabaseFromMesh()

MoFEMErrorCode MoFEM::Core::initialiseDatabaseFromMesh ( int  verb = DEFAULT_VERBOSITY )

protected

Initialize database getting information on mesh.

Definition at line 294 of file Core.cpp.

                                                        {
  MOFEM_LOG_CHANNEL("WORLD");
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
 
  Range ref_elems_to_add;
 
  // Initialize database
  Range meshsets;
  CHKERR get_moab().get_entities_by_type(0, MBENTITYSET, meshsets, false);
  Range special_meshsets;
  for (auto mit : meshsets) {
    BitFieldId field_id;
    // Get bit id form field tag
    CHKERR get_moab().tag_get_data(th_FieldId, &mit, 1, &field_id);
    // Check if meshset if field meshset
    if (field_id != 0) {
 
      const void *tag_name;
      int tag_name_size;
      CHKERR get_moab().tag_get_by_ptr(
          th_FieldName, &mit, 1, (const void **)&tag_name, &tag_name_size);
 
      if (verb > QUIET)
        MOFEM_LOG("WORLD", Sev::verbose)
            << "Read field "
            << boost::string_ref((char *)tag_name, tag_name_size);
 
      auto p = fIelds.insert(boost::make_shared<Field>(moab, mit));
 
      if (!p.second) {
        // Field meshset exists, remove duplicate meshsets from other
        // processors.
        Range ents;
        CHKERR get_moab().get_entities_by_handle(mit, ents, true);
        CHKERR get_moab().add_entities((*p.first)->getMeshset(), ents);
        CHKERR get_moab().delete_entities(&mit, 1);
      } else {
        special_meshsets.insert(mit);
      }
    }
    // Check for finite elements
    BitFieldId fe_id;
    // Get bit id from fe tag
    CHKERR get_moab().tag_get_data(th_FEId, &mit, 1, &fe_id);
    // check if meshset is finite element meshset
    if (fe_id != 0) {
      std::pair<FiniteElement_multiIndex::iterator, bool> p =
          finiteElements.insert(
              boost::shared_ptr<FiniteElement>(new FiniteElement(moab, mit)));