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.
RefEntityTmp< 0 >	getRefEntity (const EntityHandle ent)
virtual boost::shared_ptr< RefEntityTmp< 0 > >	make_shared_ref_entity (const EntityHandle ent)
	Get RefEntity.
	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
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
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
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.
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.
Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode	registerInterface (bool error_if_registration_failed=true)
	Register interface.
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface reference to pointer of interface.
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE **const iface) const
	Get interface pointer to pointer of interface.
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get interface pointer to pointer of interface.
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get reference to interface.
template<class IFACE >
IFACE *	getInterface () const
	Function returning pointer to interface.
virtual	~UnknownInterface ()=default

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
MoFEMErrorCode	getTags (int verb=DEFAULT_VERBOSITY)
	Get tag handles.
MoFEMErrorCode	clearMap ()
	Cleaning database.
MoFEMErrorCode	registerSubInterfaces ()
	Register insterfaces.
BitProblemId	getProblemShift ()
	Return unique problem Id.
MoFEMErrorCode	initialiseDatabaseFromMesh (int verb=DEFAULT_VERBOSITY)
	Initialize database getting information on mesh.
MoFEMErrorCode	getOptions (int verb=DEFAULT_VERBOSITY)
	Get core options from command line.
template<class IFACE >
MoFEMErrorCode	regSubInterface ()
	Register sub-interfaces in core interface.
template<class IFACE >
MoFEMErrorCode	regEvents ()
	Register petsc events.

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

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

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.
MoFEMErrorCode	addPrismToDatabase (const EntityHandle prism, int verb=DEFAULT_VERBOSITY)
	add prim element

Tags to data on mesh and entities
Tag	th_Part
	Tag for partition number.
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.
Tag	th_MoFEMBuild
boost::shared_ptr< BasicEntityData >	basicEntityDataPtr
boost::shared_ptr< BasicEntityData > &	get_basic_entity_data_ptr ()
	Get pointer to basic entity data.

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

Get moab database
std::reference_wrapper< moab::Interface >	moab
	moab database
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.
MoFEMErrorCode	setMoabInterface (moab::Interface &new_moab, int verb=VERBOSE)

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

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

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

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

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.
static MoFEMErrorCode	Finalize ()
	Checks for options to be called at the conclusion of the program.

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)

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

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

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

Remove and delete entities
MoFEMErrorCode	remove_parents_by_ents (const Range &ents, int verb=DEFAULT_VERBOSITY)
	Remove parents from entities.
MoFEMErrorCode	remove_parents_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	Remove parent from entities on bit level.
MoFEMErrorCode	remove_parents_by_parents (const Range &ents, int verb=DEFAULT_VERBOSITY)
	Remove paremts from entities having parents in passed range.
MoFEMErrorCode	remove_ents (const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities form mofem database
MoFEMErrorCode	remove_ents_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	remove entities form mofem database
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

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.
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.
MoFEMErrorCode	delete_field (const std::string name, int verb=DEFAULT_VERBOSITY)
	Delete field.
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.
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.
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.
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.
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.
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.

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

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

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
MoFEMErrorCode	remove_ents_from_field (const std::string name, const EntityHandle meshset, const EntityType type, int verb=DEFAULT_VERBOSITY)
	remove entities from field
MoFEMErrorCode	remove_ents_from_field (const std::string name, const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities from field
MoFEMErrorCode	remove_ents_from_field (const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities from all fields

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
BitFieldId	get_field_id (const std::string &name) const
	Get field Id.
FieldBitNumber	get_field_bit_number (const std::string name) const
	get field bit number
std::string	get_field_name (const BitFieldId id) const
	get field name from id
EntityHandle	get_field_meshset (const BitFieldId id) const
EntityHandle	get_field_meshset (const std::string name) const
	get field meshset
MoFEMErrorCode	get_field_entities_by_dimension (const std::string name, int dim, Range &ents) const
	get entities in the field by dimension
MoFEMErrorCode	get_field_entities_by_type (const std::string name, EntityType type, Range &ents) const
	get entities in the field by type
MoFEMErrorCode	get_field_entities_by_handle (const std::string name, Range &ents) const
	get entities in the field by handle
bool	check_field (const std::string &name) const
	check if field is in database
const Field *	get_field_structure (const std::string &name, enum MoFEMTypes bh=MF_EXIST) const
	get field structure

Finite elements
const FiniteElement *	get_finite_element_structure (const std::string &name, enum MoFEMTypes bh=MF_EXCL) const
	get finite element struture
bool	check_finite_element (const std::string &name) const
	Check if finite element is in database.
MoFEMErrorCode	add_finite_element (const std::string &fe_name, enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)
	add finite element
MoFEMErrorCode	modify_finite_element_adjacency_table (const std::string &fe_name, const EntityType type, ElementAdjacencyFunct function)
	modify finite element table, only for advanced user
MoFEMErrorCode	modify_finite_element_add_field_data (const std::string &fe_name, const std::string name_filed)
	set finite element field data
MoFEMErrorCode	modify_finite_element_add_field_row (const std::string &fe_name, const std::string name_row)
	set field row which finite element use
MoFEMErrorCode	modify_finite_element_add_field_col (const std::string &fe_name, const std::string name_col)
	set field col which finite element use
MoFEMErrorCode	modify_finite_element_off_field_data (const std::string &fe_name, const std::string name_filed)
	unset finite element field data
MoFEMErrorCode	modify_finite_element_off_field_row (const std::string &fe_name, const std::string name_row)
	unset field row which finite element use
MoFEMErrorCode	modify_finite_element_off_field_col (const std::string &fe_name, const std::string name_col)
	unset field col which finite element use
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
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
MoFEMErrorCode	add_ents_to_finite_element_by_type (const Range ents, const EntityType type, const std::string name)
	add entities to finite elements
MoFEMErrorCode	add_ents_to_finite_element_by_dim (const Range ents, const int dim, const std::string name)
	add entities to finite elements
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
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
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
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
MoFEMErrorCode	remove_ents_from_finite_element (const std::string name, const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities from finite element database
MoFEMErrorCode	remove_ents_from_finite_element (const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities from finite elements in database
MoFEMErrorCode	delete_finite_element (const std::string name, int verb=DEFAULT_VERBOSITY)
	delete finite element from mofem database
BitFEId	getBitFEId (const std::string &fe_name) const
	Get field Id.
std::string	getBitFEIdName (const BitFEId id) const
	Get field name.
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
MoFEMErrorCode	get_finite_element_entities_by_type (const std::string name, EntityType type, Range &ents) const
	get entities in the finite element by type
MoFEMErrorCode	get_finite_element_entities_by_handle (const std::string name, Range &ents) const
	get entities in the finite element by handle
MoFEMErrorCode	list_finite_elements () const
	list finite elements in database

Problems
MoFEMErrorCode	add_problem (const std::string &name, enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)
	Add problem.
bool	check_problem (const std::string name)
	check if problem exist
MoFEMErrorCode	delete_problem (const std::string name)
	Delete problem.
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
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
MoFEMErrorCode	modify_problem_ref_level_add_bit (const std::string &name_problem, const BitRefLevel &bit)
	add ref level to problem
MoFEMErrorCode	modify_problem_ref_level_set_bit (const std::string &name_problem, const BitRefLevel &bit)
	set ref level for problem
MoFEMErrorCode	modify_problem_mask_ref_level_add_bit (const std::string &name_problem, const BitRefLevel &bit)
	set dof mask ref level for problem
MoFEMErrorCode	modify_problem_mask_ref_level_set_bit (const std::string &name_problem, const BitRefLevel &bit)
	set dof mask ref level for problem
BitProblemId	getBitProblemId (const std::string &name) const
MoFEMErrorCode	list_problem () const
	list problems
MoFEMErrorCode	clear_problem (const std::string name, int verb=DEFAULT_VERBOSITY)
	clear problem
MoFEMErrorCode	clear_problems (int verb=DEFAULT_VERBOSITY)
	clear problems
MoFEMErrorCode	build_finite_elements (int verb=DEFAULT_VERBOSITY)
	Build finite elements.
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.
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
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
MoFEMErrorCode	build_adjacencies (const BitRefLevel &bit, int verb=DEFAULT_VERBOSITY)
	build adjacencies
MoFEMErrorCode	build_adjacencies (const BitRefLevel &bit, const BitRefLevel &mask, int verb=DEFAULT_VERBOSITY)
	build adjacencies
MoFEMErrorCode	clear_adjacencies_entities (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	clear adjacency map for entities on given bit level
MoFEMErrorCode	clear_adjacencies_entities (const Range ents, int verb=DEFAULT_VERBOSITY)
	clear adjacencies for field entities by entities
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
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
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.
MoFEMErrorCode	problem_basic_method_preProcess (const std::string &problem_name, BasicMethod &method, int verb=DEFAULT_VERBOSITY)
	Set data for BasicMethod.
MoFEMErrorCode	problem_basic_method_postProcess (const Problem *problem_ptr, BasicMethod &method, int verb=DEFAULT_VERBOSITY)
	Set data for BasicMethod.
MoFEMErrorCode	problem_basic_method_postProcess (const std::string &problem_name, BasicMethod &method, int verb=DEFAULT_VERBOSITY)
	Set data for BasicMethod.
MoFEMErrorCode	cache_problem_entities (const std::string prb_name, CacheTupleWeakPtr cache_ptr)
	Cache variables.
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.
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.
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.
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.
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.
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.
MoFEMErrorCode	loop_dofs (const std::string &field_name, DofMethod &method, int verb=DEFAULT_VERBOSITY)
	Make a loop over dofs.
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.
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.
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.
MoFEMErrorCode	loop_entities (const std::string field_name, EntityMethod &method, Range const *const ents=nullptr, int verb=DEFAULT_VERBOSITY)
	Loop over field entities.

Accessing multi-indices
MoFEMErrorCode	get_fields (const Field_multiIndex **fields_ptr) const
	Get fields multi-index from database.
MoFEMErrorCode	get_ref_ents (const RefEntity_multiIndex **refined_entities_ptr) const
	Get ref entities multi-index from database.
MoFEMErrorCode	get_ref_finite_elements (const RefElement_multiIndex **refined_finite_elements_ptr) const
	Get ref finite elements multi-index form database.
MoFEMErrorCode	get_finite_elements (const FiniteElement_multiIndex **fe_ptr) const
	Get finite elements multi-index.
MoFEMErrorCode	get_ents_finite_elements (const EntFiniteElement_multiIndex **fe_ent_ptr) const
	Get entities finite elements multi-index.
MoFEMErrorCode	get_field_ents (const FieldEntity_multiIndex **field_ents) const
	Get field multi index.
MoFEMErrorCode	get_dofs (const DofEntity_multiIndex **dofs_ptr) const
	Get dofs multi index.
MoFEMErrorCode	get_problem (const std::string &problem_name, const Problem **problem_ptr) const
	Get problem database (data structure)
MoFEMErrorCode	get_problems (const Problem_multiIndex **problems_ptr) const
	Get pointer to problems multi-index.
MoFEMErrorCode	get_ents_elements_adjacency (const FieldEntityEntFiniteElementAdjacencyMap_multiIndex **dofs_elements_adjacency) const
	Get the dofs elements adjacency object.
const Field_multiIndex *	get_fields () const
	Get the fields object.
const RefEntity_multiIndex *	get_ref_ents () const
	Get the ref ents object.
const RefElement_multiIndex *	get_ref_finite_elements () const
	Get the ref finite elements object.
const FiniteElement_multiIndex *	get_finite_elements () const
	Get the finite elements object.
const EntFiniteElement_multiIndex *	get_ents_finite_elements () const
	Get the ents finite elements object.
const FieldEntity_multiIndex *	get_field_ents () const
	Get the field ents object.
const DofEntity_multiIndex *	get_dofs () const
	Get the dofs object.
const Problem *	get_problem (const std::string problem_name) const
	Get the problem object.
const Problem_multiIndex *	get_problems () const
	Get the problems object.
const FieldEntityEntFiniteElementAdjacencyMap_multiIndex *	get_ents_elements_adjacency () const
	Get the dofs elements adjacency object.
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)

Additional Inherited Members
Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode	getLibVersion (Version &version)
	Get library version.
static MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version)
	Get database major version.
static MoFEMErrorCode	setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
	Get database major version.
static MoFEMErrorCode	getInterfaceVersion (Version &version)
	Get database major version.

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, 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_check_approx_in_3d.cpp, hdiv_divergence_operator.cpp, heat_equation.cpp, heat_method.cpp, hello_world.cpp, helmholtz.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, mofem/tutorials/vec-7/adjoint.cpp, navier_stokes.cpp, node_merge.cpp, nonlinear_dynamics.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_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, testing_jacobian_of_hook_element.cpp, testing_jacobian_of_hook_scaled_with_density_element.cpp, thermo_elastic.cpp, unsaturated_transport.cpp, and wave_equation.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 241 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 289 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()

virtual MoFEMErrorCode MoFEM::CoreTmp< 0 >::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

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 440 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 416 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 452 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 426 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	finite element name
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	finite element name
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 315 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 partition 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()) {
      SETERRQ(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) {
    SETERRQ(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 324 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) {
 
      // Change tag names comparing to older versions
 
      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)
      SETERRQ(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)
      SETERRQ(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 544 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 815 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 827 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 743 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 1305 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())
    SETERRQ(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 1318 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 706 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 712 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())
    SETERRQ(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 656 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 1256 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 1144 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;
        SETERRQ(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))) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Wrong use count %ld != %ld", dofs_array.use_count(),
              dofs_array->size() + 1);
    }
    if (dofs_field_size0 + dofs_array->size() != dofsField.size()) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Wrong number of inserted DOFs %ld != %ld", 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 1121 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 1016 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())
        SETERRQ(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);
    auto hi_ref_fe_miit =
        refinedFiniteElements.get<Ent_mi_tag>().upper_bound(second);
    if (std::distance(ref_fe_miit, hi_ref_fe_miit) != (second - first + 1)) {
      MOFEM_LOG("SELF", Sev::noisy) << "Finite element " << fe->getName()
                                    << " not defined on all entities in "
                                       "the meshset, missing entities";
      MOFEM_LOG("SELF", Sev::noisy)
          << "Missing entities: " << first << " - " << 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())
      SETERRQ(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 1437 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) {
      SETERRQ(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 1409 of file FieldCore.cpp.

                                                                    {
  MoFEMFunctionBeginHot;
  auto it = fIelds.get<FieldName_mi_tag>().find(name);
  if (it == fIelds.get<FieldName_mi_tag>().end()) {
    SETERRQ(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) {
    SETERRQ(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 886 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)) {
      SETERRQ(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 859 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()) {
    SETERRQ(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)) {
    SETERRQ(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 750 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()) {
    SETERRQ(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 525 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 203 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 internally
  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 467 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()) {
    SETERRQ(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()) {
    SETERRQ(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()) {
    SETERRQ(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, 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_check_approx_in_3d.cpp, hdiv_divergence_operator.cpp, heat_equation.cpp, heat_method.cpp, hello_world.cpp, helmholtz.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, mofem/tutorials/vec-7/adjoint.cpp, navier_stokes.cpp, node_merge.cpp, nonlinear_dynamics.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_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, testing_jacobian_of_hook_element.cpp, testing_jacobian_of_hook_scaled_with_density_element.cpp, thermo_elastic.cpp, unsaturated_transport.cpp, and wave_equation.cpp.

Definition at line 118 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 911 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 850 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 1381 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 1388 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 1395 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 1402 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 1371 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 1376 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 1361 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 1366 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 891 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 882 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 905 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 863 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 837 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 848 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 908 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 845 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 895 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 803 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 902 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 857 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]

MeshsetsManager * MoFEM::Core::get_meshsets_manager_ptr ( )

protectedvirtual

get MeshsetsManager pointer

Implements MoFEM::CoreInterface.

Definition at line 870 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::Core::get_meshsets_manager_ptr ( ) const

protectedvirtual

get MeshsetsManager pointer

Implements MoFEM::CoreInterface.

Definition at line 876 of file Core.cpp.

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

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 822 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()) {
    SETERRQ(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 912 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 912 of file FECore.cpp.

                                                                       {
  MoFEMFunctionBegin;
  auto &prb = pRoblems.get<Problem_mi_tag>();
  auto p_miit = prb.find(problem_name);
  if (p_miit == prb.end())
    SETERRQ(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 918 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 838 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 896 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 810 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 899 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 815 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 777 of file Core.cpp.

                                        {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
 
  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
 
  PetscOptionsEnd();
 
  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 573 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 300 of file Core.cpp.

                                                        {
  BOOST_LOG_SCOPED_THREAD_ATTR("Timeline", attrs::timer());
  MOFEM_LOG_CHANNEL("WORLD");
 
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
 
  Range ref_elems_to_add;
 
  MOFEM_LOG("WORLD", Sev::verbose) << "Get MoFEM meshsets";
  // 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)));
      if (verb > QUIET)
        MOFEM_LOG("WORLD", Sev::verbose) << "Read finite element " << **p.first;
 
      Range ents;
      CHKERR get_moab().get_entities_by_type(mit, MBENTITYSET, ents, false);
      CHKERR get_moab().get_entities_by_handle(mit, ents, true);
      ref_elems_to_add.merge(ents);
      if (!p.second) {
        // Finite element mesh set exist, could be created on other processor.
        // Remove duplicate.
        CHKERR get_moab().add_entities((*p.first)->getMeshset(), ents);
        CHKERR get_moab().delete_entities(&mit, 1);
      } else {
        special_meshsets.insert(mit);
      }
    }
    BitProblemId problem_id;
    // get bit id form problem tag
    CHKERR get_moab().tag_get_data(th_ProblemId, &mit, 1, &problem_id);
    // check if meshset if problem meshset
    if (problem_id != 0) {
      std::pair<Problem_multiIndex::iterator, bool> p =
          pRoblems.insert(Problem(moab, mit));
      if (verb > QUIET) {
        MOFEM_LOG("WORLD", Sev::verbose) << "Read problem " << *p.first;
        MOFEM_LOG("WORLD", Sev::noisy)
            << "\tBitRef " << p.first->getBitRefLevel() << " BitMask "
            << p.first->getBitRefLevelMask();
      }
 
      if (!p.second) {
        // Problem meshset exists, could be created on other processor.
        // Remove duplicate.
        Range ents;
        CHKERR get_moab().get_entities_by_handle(mit, ents, true);
        CHKERR get_moab().get_entities_by_type(mit, MBENTITYSET, ents, true);
        CHKERR get_moab().add_entities(p.first->meshset, ents);
        CHKERR get_moab().delete_entities(&mit, 1);
      } else {
        special_meshsets.insert(mit);
      }
    }
  }
  MOFEM_LOG("WORLD", Sev::verbose) << "Get MoFEM meshsets <- done";
 
  // Add entities to database
  MOFEM_LOG("WORLD", Sev::verbose) << "Add entities to database";
  Range bit_ref_ents;
  CHKERR get_moab().get_entities_by_handle(0, bit_ref_ents, false);
  bit_ref_ents = subtract(bit_ref_ents, special_meshsets);
  CHKERR getInterface<BitRefManager>()->filterEntitiesByRefLevel(
      BitRefLevel().set(), BitRefLevel().set(), bit_ref_ents);
  CHKERR getInterface<BitRefManager>()->setEntitiesBitRefLevel(bit_ref_ents);
  CHKERR getInterface<BitRefManager>()->setElementsBitRefLevel(
      ref_elems_to_add);
  MOFEM_LOG("WORLD", Sev::verbose) << "Add entities to database <- done";
 
  // Build field entities
  MOFEM_LOG("WORLD", Sev::verbose) << "Add field to database";
  for (auto field : fIelds) {
    if (field->getSpace() != NOSPACE) {
      Range ents_of_id_meshset;
      CHKERR get_moab().get_entities_by_handle(field->getMeshset(),
                                               ents_of_id_meshset, false);
      CHKERR set_field_order(ents_of_id_meshset, field->getId(), -1, verb);
    }
  }
  MOFEM_LOG("WORLD", Sev::verbose) << "Add field to database <- done";
 
  if (initaliseAndBuildField || initaliseAndBuildFiniteElements) {
    MOFEM_LOG("WORLD", Sev::verbose) << "Build fields elements";
    CHKERR build_fields(verb);
    MOFEM_LOG("WORLD", Sev::verbose) << "Build fields elements <- done";
    if (initaliseAndBuildFiniteElements) {
      MOFEM_LOG("WORLD", Sev::verbose) << "Build finite elements";
      CHKERR build_finite_elements(verb);
      MOFEM_LOG("WORLD", Sev::verbose) << "Build finite elements <- done";
    }
  }
 
  if (verb > VERY_NOISY) {
    list_fields();
    list_finite_elements();
    list_problem();
  }
 
  // Initialize interfaces
  MOFEM_LOG("WORLD", Sev::verbose) << "Initialise interfaces from mesh";
 
  MOFEM_LOG("WORLD", Sev::verbose) << "Initialise MeshsetManager";
  CHKERR getInterface<MeshsetsManager>() -> initialiseDatabaseFromMesh(verb);
  MOFEM_LOG("WORLD", Sev::verbose) << "Initialise MeshsetManager <- done";
  MOFEM_LOG("WORLD", Sev::verbose) << "Initialise SeriesRecorder";
  CHKERR getInterface<SeriesRecorder>() -> initialiseDatabaseFromMesh(verb);
  MOFEM_LOG("WORLD", Sev::verbose) << "Initialise SeriesRecorder <- done";
 
  MOFEM_LOG("WORLD", Sev::verbose) << "Initialise interfaces from mesh <- done";
 
  MoFEMFunctionReturn(0);
}

Initialize()

MoFEMErrorCode MoFEM::Core::Initialize ( int * argc, char *** args, const char file[], const char help[] )

static

Initializes the MoFEM database PETSc, MOAB and MPI.

Note

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

Example:

int main(int argc, char *argv[]) {
 
// Initailise MoFEM and Petsc
MoFEM::Core::Initialize(&argc, &argv, (char *)0, help);
 
try {
 
  moab::Core mb_instance; // MoAB database
  moab::Interface &moab = mb_instance;
  MoFEM::Core core(moab); // MOFEM database
  MoFEM::CoreInterface &m_field = core;
 
  CHKERR foo(); // Call function
 
}
CATCH_ERRORS;
 
return MoFEM::Core::Finalize();
 
}

Parameters

argc	count of number of command line arguments
args	the command line arguments
file	[optional] PETSc database file, also checks ~username/.petscrc and .petscrc use NULL to not check for code specific file. Use * -skip_petscrc in the code specific file to skip the .petscrc files
help	[optional] Help message to print, use NULL for no message

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, 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_check_approx_in_3d.cpp, hdiv_divergence_operator.cpp, heat_equation.cpp, heat_method.cpp, hello_world.cpp, helmholtz.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, mofem/tutorials/vec-7/adjoint.cpp, navier_stokes.cpp, node_merge.cpp, nonlinear_dynamics.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_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, testing_jacobian_of_hook_element.cpp, testing_jacobian_of_hook_scaled_with_density_element.cpp, thermo_elastic.cpp, unsaturated_transport.cpp, and wave_equation.cpp.

Definition at line 72 of file Core.cpp.

                                                   {
 
  MPI_Initialized(&mpiInitialised);
  if (!mpiInitialised)
    MPI_Init(argc, args);
 
  PetscInitialized(&isInitialized);
  if (isInitialized == PETSC_FALSE) {
    for (int i = 0; i < *argc - 1; ++i) {
      if (std::strcmp((*args)[i], "-param_file") == 0) {
        file = (*args)[i + 1];
        break;
      }
    }
    PetscInitialize(argc, args, file, help);
    PetscPushErrorHandler(mofem_error_handler, PETSC_NULLPTR);
  }
 
  LogManager::createDefaultSinks(MPI_COMM_WORLD);
  PetscVFPrintf = LogManager::logPetscFPrintf;
  CHKERR LogManager::getOptions();
  isGloballyInitialised = true;
 
  MOFEM_LOG_CHANNEL("WORLD");
  char petsc_version[255];
  CHKERR PetscGetVersion(petsc_version, 255);
  MOFEM_LOG_C("WORLD", Sev::inform, "MoFEM version %d.%d.%d (%s %s)",
              MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD,
              MOAB_VERSION_STRING, petsc_version);
  MOFEM_LOG_C("WORLD", Sev::inform, "git commit id %s", GIT_SHA1_NAME);
 
  auto log_time = [&](const auto perefix, auto time) {
    MOFEM_LOG("WORLD", Sev::inform)
        << perefix << time.date().year() << "-" << time.date().month() << "-"
        << time.date().day() << " " << time.time_of_day().hours() << ":"
        << time.time_of_day().minutes() << ":" << time.time_of_day().seconds();
  };
 
  // Get current system time
  log_time("Local time: ", boost::posix_time::second_clock::local_time());
  log_time("UTC time: ", boost::posix_time::second_clock::universal_time());
 
  return MOFEM_SUCCESS;
}

list_dofs_by_field_name()

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

protectedvirtual

list dofs

Implements MoFEM::CoreInterface.

Definition at line 1336 of file FieldCore.cpp.

                                                               {
  FieldCoreFunctionBegin;
  auto dit = dofsField.get<Unique_mi_tag>().lower_bound(
      FieldEntity::getLoBitNumberUId(get_field_bit_number((field_name))));
  auto hi_dit = dofsField.get<Unique_mi_tag>().upper_bound(
      FieldEntity::getHiBitNumberUId(get_field_bit_number(field_name)));
  MOFEM_LOG("SYNC", Sev::inform) << "List DOFs:";
  for (; dit != hi_dit; dit++)
    MOFEM_LOG("SYNC", Sev::inform) << *dit;
 
  MOFEM_LOG_SYNCHRONISE(mofemComm);
  MoFEMFunctionReturn(0);
}

list_fields()

MoFEMErrorCode MoFEM::Core::list_fields ( ) const

protectedvirtual

list entities in the field

Implements MoFEM::CoreInterface.

Definition at line 1350 of file FieldCore.cpp.

                                       {
  FieldCoreFunctionBegin;
  MOFEM_LOG("SYNC", Sev::inform) << "List Fields:";
  for (auto &miit : fIelds.get<BitFieldId_mi_tag>())
    MOFEM_LOG("SYNC", Sev::inform) << *miit;
 
  MOFEM_LOG_SYNCHRONISE(mofemComm);
  MoFEMFunctionReturn(0);
}

list_finite_elements()

MoFEMErrorCode MoFEM::Core::list_finite_elements ( ) const

protectedvirtual

list finite elements in database

Implements MoFEM::CoreInterface.

Definition at line 320 of file FECore.cpp.

                                                {
  MoFEMFunctionBegin;
  for (auto &fe : finiteElements.get<FiniteElement_name_mi_tag>())
    MOFEM_LOG("SYNC", Sev::inform) << fe;
 
  MOFEM_LOG_SYNCHRONISE(mofemComm);
  MoFEMFunctionReturn(0);
}

list_problem()

MoFEMErrorCode MoFEM::Core::list_problem ( ) const

protectedvirtual

list problems

Implements MoFEM::CoreInterface.

Definition at line 129 of file ProblemsCore.cpp.

                                        {
  MoFEMFunctionBeginHot;
  typedef Problem_multiIndex::index<BitProblemId_mi_tag>::type ProblemById;
  const ProblemById &set_id = pRoblems.get<BitProblemId_mi_tag>();
  ProblemById::iterator miit = set_id.begin();
  for (; miit != set_id.end(); miit++) {
    std::ostringstream ss;
    ss << *miit << std::endl;
    PetscPrintf(mofemComm, "%s", ss.str().c_str());
  }
  MoFEMFunctionReturnHot(0);
}

loop_dofs() [1/4]

MoFEMErrorCode MoFEM::Core::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 )

protectedvirtual

Make a loop over dofs.

Implements MoFEM::CoreInterface.

Definition at line 531 of file ProblemsCore.cpp.

                                                         {
  MoFEMFunctionBegin;
  SET_BASIC_METHOD(method, &*problem_ptr);
  typedef NumeredDofEntity_multiIndex::index<Unique_mi_tag>::type
      NumeredDofsByUId;
  NumeredDofsByUId *dofs;
  switch (rc) {
  case ROW:
    dofs = &problem_ptr->numeredRowDofsPtr->get<Unique_mi_tag>();
    break;
  case COL:
    dofs = &problem_ptr->numeredColDofsPtr->get<Unique_mi_tag>();
    break;
  default:
    SETERRQ(mofemComm, MOFEM_DATA_INCONSISTENCY, "Not implemented");
  }
 
  auto field_it = fIelds.get<FieldName_mi_tag>().find(field_name);
  if (field_it != fIelds.get<FieldName_mi_tag>().end()) {
    method.fieldPtr = *field_it;
  } else {
    SETERRQ(mofemComm, MOFEM_NOT_FOUND, "Field not found %s",
            field_name.c_str());
  }
 
  auto miit = dofs->lower_bound(
      FieldEntity::getLoBitNumberUId((*field_it)->getBitNumber()));
  auto hi_miit = dofs->upper_bound(
      FieldEntity::getHiBitNumberUId((*field_it)->getBitNumber()));
 
  method.loopSize = std::distance(miit, hi_miit);
  method.loHiFERank = std::make_pair(lower_rank, upper_rank);      
 
  CHKERR method.preProcess();
 
  int nn = 0;
  for (; miit != hi_miit; miit++, nn++) {
    if ((*miit)->getPart() >= lower_rank && (*miit)->getPart() <= upper_rank) {
      method.nInTheLoop = nn; // Index of element in the loop
      method.dofPtr = miit->get()->getDofEntityPtr();
      method.dofNumeredPtr = *miit;
      CHKERR method();
    }
  }
 
  CHKERR method.postProcess();
  MoFEMFunctionReturn(0);
}

loop_dofs() [2/4]

MoFEMErrorCode MoFEM::Core::loop_dofs ( const std::string & field_name, DofMethod & method, int verb = DEFAULT_VERBOSITY )

protectedvirtual

Make a loop over dofs.

Implements MoFEM::CoreInterface.

Definition at line 617 of file ProblemsCore.cpp.

                                         {
  MoFEMFunctionBegin;
  if (verb == DEFAULT_VERBOSITY)
    verb = verbose;
  SET_BASIC_METHOD(method, nullptr);
 
  auto field_it = fIelds.get<FieldName_mi_tag>().find(field_name);
  if (field_it != fIelds.get<FieldName_mi_tag>().end()) {
    method.fieldPtr = *field_it;
  } else {
    SETERRQ(mofemComm, MOFEM_NOT_FOUND, "Field not found %s",
            field_name.c_str());
  }
 
  auto miit = dofsField.get<Unique_mi_tag>().lower_bound(
      FieldEntity::getLoBitNumberUId((*field_it)->getBitNumber()));
  auto hi_miit = dofsField.get<Unique_mi_tag>().upper_bound(
      FieldEntity::getHiBitNumberUId((*field_it)->getBitNumber()));
 
  method.loopSize = std::distance(miit, hi_miit);
  method.loHiFERank = std::make_pair(0, get_comm_size());
 
  CHKERR method.preProcess();
  for (int nn = 0; miit != hi_miit; miit++, nn++) {
    method.nInTheLoop = nn;
    method.dofPtr = *miit;
    CHKERR method();
  }
  CHKERR method.postProcess();
  MoFEMFunctionReturn(0);
}

loop_dofs() [3/4]

MoFEMErrorCode MoFEM::Core::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 )

protectedvirtual

Make a loop over dofs.

Implements MoFEM::CoreInterface.

Definition at line 583 of file ProblemsCore.cpp.

  {
  MoFEMFunctionBegin;
  if (verb == DEFAULT_VERBOSITY)
    verb = verbose;
  typedef Problem_multiIndex::index<Problem_mi_tag>::type ProblemsByName;
  // find p_miit
  ProblemsByName &pRoblems_set = pRoblems.get<Problem_mi_tag>();
  ProblemsByName::iterator p_miit = pRoblems_set.find(problem_name);
  if (p_miit == pRoblems_set.end())
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "problem not in database %s",
             problem_name.c_str());
  CHKERR loop_dofs(&*p_miit, field_name, rc, method, lower_rank, upper_rank,
                   verb);
  MoFEMFunctionReturn(0);
}

loop_dofs() [4/4]

MoFEMErrorCode MoFEM::Core::loop_dofs ( const std::string & problem_name, const std::string & field_name, RowColData rc, DofMethod & method, int verb = DEFAULT_VERBOSITY )

protectedvirtual

Make a loop over dofs.

Implements MoFEM::CoreInterface.

Definition at line 607 of file ProblemsCore.cpp.

                                                            {
  MoFEMFunctionBegin;
  if (verb == DEFAULT_VERBOSITY)
    verb = verbose;
  CHKERR loop_dofs(problem_name, field_name, rc, method, 0, sIze, verb);
  MoFEMFunctionReturn(0);
}

loop_entities() [1/4]

MoFEMErrorCode MoFEM::Core::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 )

protectedvirtual

Loop over field entities in the problem.

Parameters

problem_ptr
field_name
rc
method
lower_rank
upper_rank
verb

Returns

MoFEMErrorCode

Implements MoFEM::CoreInterface.

Definition at line 650 of file ProblemsCore.cpp.

                                                             {
  MoFEMFunctionBegin;
  if (verb == DEFAULT_VERBOSITY)
    verb = verbose;
  decltype(problem_ptr->numeredRowDofsPtr) dofs;
  switch (rc) {
  case ROW:
    dofs = problem_ptr->numeredRowDofsPtr;
    break;
  case COL:
    dofs = problem_ptr->numeredColDofsPtr;
    break;
  default:
    SETERRQ(mofemComm, MOFEM_DATA_INCONSISTENCY,
            "It works only with rows or columns");
  }
 
  auto field_it = fIelds.get<FieldName_mi_tag>().find(field_name);
  if (field_it != fIelds.get<FieldName_mi_tag>().end()) {
    method.fieldPtr = *field_it;
  } else {
    SETERRQ(mofemComm, MOFEM_NOT_FOUND, "Field not found %s",
            field_name.c_str());
  }
 
  auto miit = dofs->lower_bound(
      FieldEntity::getLoBitNumberUId((*field_it)->getBitNumber()));
  auto hi_miit = dofs->upper_bound(
      FieldEntity::getHiBitNumberUId((*field_it)->getBitNumber()));
 
  using FieldEntity_view_multiIndex = multi_index_container<
 
      boost::shared_ptr<FieldEntity>,
      indexed_by<
 
          ordered_unique<
 
              tag<Ent_mi_tag>,
              const_mem_fun<FieldEntity::interface_type_RefEntity, EntityHandle,
                            &FieldEntity::getEnt>>
 
          >>;
 
  FieldEntity_view_multiIndex ents_view;
  auto hint = ents_view.begin();
  for (; miit != hi_miit; ++miit)
    if ((*miit)->getPart() >= lower_rank && (*miit)->getPart() <= upper_rank)
      ents_view.emplace_hint(hint, (*miit)->getFieldEntityPtr());
 
  SET_BASIC_METHOD(method, problem_ptr);
 
  method.loopSize = ents_view.size();
  method.loHiFERank = std::make_pair(lower_rank, upper_rank);
 
  CHKERR method.preProcess();
  method.nInTheLoop = 0;
  for (auto &field_ent : ents_view) {
    method.entPtr = field_ent;
    CHKERR method();
    ++method.nInTheLoop;
  }
  CHKERR method.postProcess();
  MoFEMFunctionReturn(0);
}

loop_entities() [2/4]

MoFEMErrorCode MoFEM::Core::loop_entities ( const std::string field_name, EntityMethod & method, Range const *const ents = nullptr, int verb = DEFAULT_VERBOSITY )

protectedvirtual

Loop over field entities.

Parameters

field_name	field entities
method	user method
ents	if given loop only on subset of entities in the field
verb

Returns

MoFEMErrorCode

Implements MoFEM::CoreInterface.

Definition at line 742 of file ProblemsCore.cpp.

                                                                      {
  MoFEMFunctionBegin;
  if (verb == DEFAULT_VERBOSITY)
    verb = verbose;
  SET_BASIC_METHOD(method, nullptr);
 
  auto field_it = fIelds.get<FieldName_mi_tag>().find(field_name);
  if (field_it != fIelds.get<FieldName_mi_tag>().end()) {
    method.fieldPtr = *field_it;
  } else {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "Field not found %s",
             field_name.c_str());
  }
 
  auto lo_eit = entsFields.get<Unique_mi_tag>().lower_bound(
      FieldEntity::getLoBitNumberUId((*field_it)->getBitNumber()));
  auto hi_eit = entsFields.get<Unique_mi_tag>().upper_bound(
      FieldEntity::getHiBitNumberUId((*field_it)->getBitNumber()));
 
  typedef multi_index_container<
      boost::shared_ptr<FieldEntity>,
      indexed_by<ordered_unique<
          tag<Ent_mi_tag>, const_mem_fun<FieldEntity::interface_RefEntity,
                                         EntityHandle, &FieldEntity::getEnt>>>>
      FieldEntity_view_multiIndex;
 
  FieldEntity_view_multiIndex ents_view;
  ents_view.insert(lo_eit, hi_eit);
 
  method.loopSize = ents_view.size();
  method.loHiFERank = std::make_pair(0, get_comm_size());
 
  CHKERR method.preProcess();
  method.nInTheLoop = 0;
 
  if (ents)
    for (auto p = ents->const_pair_begin(); p != ents->const_pair_end(); ++p)
      for (auto feit = ents_view.lower_bound(p->first);
           feit != ents_view.upper_bound(p->second); ++feit) {
        method.entPtr = *feit;
        CHKERR method();
        ++method.nInTheLoop;
      }
  else
    for (auto &field_ent : ents_view) {
      method.entPtr = field_ent;
      CHKERR method();
      ++method.nInTheLoop;
    }
 
  CHKERR method.postProcess();
  MoFEMFunctionReturn(0);
}

loop_entities() [3/4]

MoFEMErrorCode MoFEM::Core::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 )

protectedvirtual

Loop over field entities in the problem.

Parameters

problem_name
field_name
rc
method
lower_rank
upper_rank
verb

Returns

MoFEMErrorCode

Implements MoFEM::CoreInterface.

Definition at line 718 of file ProblemsCore.cpp.

                                                             {
  MoFEMFunctionBegin;
  if (verb == DEFAULT_VERBOSITY)
    verb = verbose;
  // find p_miit
  auto &prb = pRoblems.get<Problem_mi_tag>();
  auto p_miit = prb.find(problem_name);
  if (p_miit == prb.end())
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "problem not in database %s",
             problem_name.c_str());
  CHKERR loop_entities(&*p_miit, field_name, rc, method, lower_rank, upper_rank,
                       verb);
  MoFEMFunctionReturn(0);
}

loop_entities() [4/4]

MoFEMErrorCode MoFEM::Core::loop_entities ( const std::string problem_name, const std::string field_name, RowColData rc, EntityMethod & method, int verb = DEFAULT_VERBOSITY )

protectedvirtual

Loop over field entities in the problem.

Parameters

problem_name
field_name
rc
method
verb

Returns

MoFEMErrorCode

Implements MoFEM::CoreInterface.

Definition at line 736 of file ProblemsCore.cpp.

                                                                   {
  return loop_entities(problem_name, field_name, rc, method, rAnk, rAnk, verb);
}

loop_finite_elements() [1/3]

MoFEMErrorCode MoFEM::Core::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 )

protectedvirtual

Make a loop over finite elements on partitions from upper to lower rank.

This function is like swiss knife, is can be used to post-processing or matrix and vectors assembly. It makes loop over given finite element for given problem. The particular methods executed on each element are given by class derived form Interface::FEMethod. At beginning of each loop user defined function (method) preProcess() is called, for each element operator() is executed, at the end loop finalizes with user defined function (method) postProcess().

Note

If fe_ptr is given it is expected that multi-index is supbes of problem multi-index. If this is not the case behavior of the code is undetermined.

For more details please look to examples.

Interface::FEMethod

Parameters

problem_ptr	pointer to problem consisting set of elements
fe_name	name of element in problem
method	class derived form Interface::FEMethod
lower_rank	lower rank of process owned by finite element
upper_rank	lower rank of process owned by finite element
fe_ptr	pointer to finite elements multi-index
bh	if bH = MF_EXIST, throws error if fe_name does not exist
cache_data	cache data vector
cache_row	cache row vector
cache_col	cache row vector
verb	verbosity level

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 427 of file ProblemsCore.cpp.

                                           {
  MoFEMFunctionBegin;
  if (verb == DEFAULT_VERBOSITY)
    verb = verbose;
 
  CacheTupleSharedPtr tmp_cache_ptr;
  if (!cache_ptr.use_count()) {
    tmp_cache_ptr = boost::make_shared<CacheTuple>();
    CHKERR cache_problem_entities(problem_ptr->getName(), tmp_cache_ptr);
    method.cacheWeakPtr = tmp_cache_ptr;
  } else {
    method.cacheWeakPtr = cache_ptr;
  }
 
  if (!fe_ptr)
    fe_ptr = problem_ptr->numeredFiniteElementsPtr;
 
  auto miit = fe_ptr->get<Composite_Name_And_Part_mi_tag>().lower_bound(
      boost::make_tuple(fe_name, lower_rank));
  auto hi_miit = fe_ptr->get<Composite_Name_And_Part_mi_tag>().upper_bound(
      boost::make_tuple(fe_name, upper_rank));
 
  if (miit == hi_miit && (bh & MF_EXIST)) {
    if (!check_finite_element(fe_name)) {
      SETERRQ(mofemComm, MOFEM_NOT_FOUND, "finite element < %s > not found",
               fe_name.c_str());
    }
  }
 
  method.feName = fe_name;
  method.loopSize =
      std::distance(miit, hi_miit); // Set numbers of elements in the loop
  method.loHiFERank = std::make_pair(lower_rank, upper_rank);
 
  SET_BASIC_METHOD(method, &*problem_ptr)
  
  PetscLogEventBegin(MOFEM_EVENT_preProcess, 0, 0, 0, 0);
  CHKERR method.preProcess();
  PetscLogEventEnd(MOFEM_EVENT_preProcess, 0, 0, 0, 0);
 
  PetscLogEventBegin(MOFEM_EVENT_operator, 0, 0, 0, 0);
  for (int nn = 0; miit != hi_miit; miit++, nn++) {
 
    method.nInTheLoop = nn; // Index of element in the loop
    method.numeredEntFiniteElementPtr = *miit;
 
    if (method.exeTestHook) {
      if (method.exeTestHook(&method)) {
        CHKERR method();
      }
    } else {
      CHKERR method();
    }
 
  }
  PetscLogEventEnd(MOFEM_EVENT_operator, 0, 0, 0, 0);
 
  PetscLogEventBegin(MOFEM_EVENT_postProcess, 0, 0, 0, 0);
  CHKERR method.postProcess();
  PetscLogEventEnd(MOFEM_EVENT_postProcess, 0, 0, 0, 0);
 
  MoFEMFunctionReturn(0);
}

loop_finite_elements() [2/3]

MoFEMErrorCode MoFEM::Core::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 )

protectedvirtual

Make a loop over finite elements.

This function is like swiss knife, is can be used to post-processing or matrix and vectors assembly. It makes loop over given finite element for given problem. The particular methods executed on each element are given by class derived form Interface::FEMethod. At beginning of each loop user defined function (method) preProcess() is called, for each element operator() is executed, at the end loop finalizes with user defined function (method) postProcess().

Methods are executed only for local elements at given processor.

For more details pleas look to examples.

Note

If fe_ptr is given it is expected that multi-index is supbes of problem multi-index. If this is not the case behavior of the code is undetermined.

Parameters

problem_name	problem consisting set of elements
fe_name	name of element in problem
method	class derived form Interface::FEMethod
fe_ptr	pointer to finite elements multi-index
bh	if bH = MF_EXIST, throws error if fe_name does not exist
cache_tuple_ptr	cache
verb	verbosity level

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 495 of file ProblemsCore.cpp.

                                           {
  MoFEMFunctionBegin;
  if (verb == DEFAULT_VERBOSITY)
    verb = verbose;
 
  CHKERR loop_finite_elements(problem_name, fe_name, method, rAnk, rAnk, fe_ptr,
                              bh, cache_ptr, verb);
 
  MoFEMFunctionReturn(0);
}

loop_finite_elements() [3/3]

MoFEMErrorCode MoFEM::Core::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 )

protectedvirtual

Make a loop over finite elements on partitions from upper to lower rank.

This function is like swiss knife, is can be used to post-processing or matrix and vectors assembly. It makes loop over given finite element for given problem. The particular methods executed on each element are given by class derived form Interface::FEMethod. At beginning of each loop user defined function (method) preProcess() is called, for each element operator() is executed, at the end loop finalizes with user defined function (method) postProcess().

Note

If fe_ptr is given it is expected that multi-index is supbes of problem multi-index. If this is not the case behavior of the code is undetermined.

For more details please look to examples.

Parameters

problem_name	pointer to problem consisting set of elements
fe_name	name of element in problem
method	class derived form Interface::FEMethod
lower_rank	lower rank of process owned by finite element
upper_rank	lower rank of process owned by finite element
fe_ptr	pointer to finite elements multi-index
bh	if bH = MF_EXIST, throws error if fe_name does not exist
cache_data	cache data vector
cache_row	cache row vector
cache_col	cache row vector
verb	verbosity level

Returns

error code

Implements MoFEM::CoreInterface.

Definition at line 510 of file ProblemsCore.cpp.

                                           {
  MoFEMFunctionBegin;
  if (verb == DEFAULT_VERBOSITY)
    verb = verbose;
 
  auto &prb_by_name = pRoblems.get<Problem_mi_tag>();
  auto p_miit = prb_by_name.find(problem_name);
  if (p_miit == prb_by_name.end())
    SETERRQ(mofemComm, MOFEM_INVALID_DATA, "Problem <%s> is not in database",
             problem_name.c_str());
 
  CHKERR loop_finite_elements(&*p_miit, fe_name, method, lower_rank, upper_rank,
                              fe_ptr, bh, cache_ptr, verb);
 
  MoFEMFunctionReturn(0);
}

make_shared_ref_entity()

boost::shared_ptr< RefEntityTmp< 0 > > MoFEM::Core::make_shared_ref_entity ( const EntityHandle ent )

virtual

Get RefEntity.

Parameters

ent

Returns

boost::shared_ptr<RefEntityTmp<0>>

Implements MoFEM::CoreInterface.

Reimplemented in MoFEM::CoreTmp<-1 >.

Definition at line 983 of file Core.cpp.

                                                   {
  return this->makeSharedRefEntity(*this, ent);
}

makeSharedRefEntity()

boost::shared_ptr< RefEntityTmp< 0 > > MoFEM::Core::makeSharedRefEntity ( MoFEM::Interface & m_field, const EntityHandle ent )

static

Definition at line 949 of file Core.cpp.

                                                                         {
 
  boost::shared_ptr<RefEntityTmp<0>> ref_ent_ptr;
 
  switch (m_field.getValue()) {
  case -1:
    ref_ent_ptr = boost::shared_ptr<RefEntityTmp<0>>(
 
        new RefEntityTmp<-1>(m_field.get_basic_entity_data_ptr(), ent)
 
    );
    break;
  case 0:
    ref_ent_ptr = boost::shared_ptr<RefEntityTmp<0>>(
 
        new RefEntityTmp<0>(m_field.get_basic_entity_data_ptr(), ent)
 
    );
    break;
  case 1:
    ref_ent_ptr = boost::shared_ptr<RefEntityTmp<0>>(
 
        new RefEntityTmp<1>(m_field.get_basic_entity_data_ptr(), ent)
 
    );
    break;
  default:
    THROW_MESSAGE("Core index can vary from -1 to MAX_CORE_TMP");
  }
 
  return ref_ent_ptr;
}

modify_finite_element_add_field_col()

MoFEMErrorCode MoFEM::Core::modify_finite_element_add_field_col ( const std::string & fe_name, const std::string name_row )

protectedvirtual

set field col which finite element use

Note

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

Parameters

name	finite element name
name	field name

Implements MoFEM::CoreInterface.

Definition at line 182 of file FECore.cpp.

                                                                    {
  MoFEMFunctionBegin;
  *buildMoFEM &= 1 << 0;
  auto &finite_element_name_set =
      finiteElements.get<FiniteElement_name_mi_tag>();
  auto it_fe = finite_element_name_set.find(fe_name);
  if (it_fe == finite_element_name_set.end())
    SETERRQ(mofemComm, MOFEM_OPERATION_UNSUCCESSFUL,
            "this FiniteElement is there");
  bool success = finite_element_name_set.modify(
      it_fe, FiniteElement_col_change_bit_add(get_field_id(name_col)));
  if (!success)
    SETERRQ(mofemComm, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  MoFEMFunctionReturn(0);
}

modify_finite_element_add_field_data()

MoFEMErrorCode MoFEM::Core::modify_finite_element_add_field_data ( const std::string & fe_name, const std::string name_field )

protectedvirtual

set finite element field data

Note

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

Parameters

name	finite element name
name	field name

This function will set memory in the form of a vector

Implements MoFEM::CoreInterface.

Definition at line 138 of file FECore.cpp.

                                                                      {
  MoFEMFunctionBegin;
  *buildMoFEM &= 1 << 0;
  typedef FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type
      FiniteElements_by_name;
  FiniteElements_by_name &finite_element_name_set =
      finiteElements.get<FiniteElement_name_mi_tag>();
  FiniteElements_by_name::iterator it_fe =
      finite_element_name_set.find(fe_name);
  if (it_fe == finite_element_name_set.end())
    SETERRQ(mofemComm, MOFEM_NOT_FOUND,
            "This finite element is not defined (advise: check spelling)");
  bool success = finite_element_name_set.modify(
      it_fe, FiniteElement_change_bit_add(get_field_id(name_data)));
  if (!success)
    SETERRQ(mofemComm, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  MoFEMFunctionReturn(0);
}

modify_finite_element_add_field_row()

MoFEMErrorCode MoFEM::Core::modify_finite_element_add_field_row ( const std::string & fe_name, const std::string name_row )

protectedvirtual

set field row which finite element use

Note

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

Parameters

name	finite element name
name	field name

Implements MoFEM::CoreInterface.

Definition at line 160 of file FECore.cpp.

                                                                    {
  MoFEMFunctionBegin;
  *buildMoFEM &= 1 << 0;
  typedef FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type
      FiniteElements_by_name;
  FiniteElements_by_name &finite_element_name_set =
      finiteElements.get<FiniteElement_name_mi_tag>();
  FiniteElements_by_name::iterator it_fe =
      finite_element_name_set.find(fe_name);
  if (it_fe == finite_element_name_set.end())
    SETERRQ(mofemComm, MOFEM_NOT_FOUND, "this < %s > is not there",
             fe_name.c_str());
  bool success = finite_element_name_set.modify(
      it_fe, FiniteElement_row_change_bit_add(get_field_id(name_row)));
  if (!success)
    SETERRQ(mofemComm, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  MoFEMFunctionReturn(0);
}

modify_finite_element_adjacency_table()

MoFEMErrorCode MoFEM::Core::modify_finite_element_adjacency_table ( const std::string & fe_name, const EntityType type, ElementAdjacencyFunct function )

protectedvirtual

modify finite element table, only for advanced user

Note

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

Using that functions means that you like to do something not usual.

Implements MoFEM::CoreInterface.

Definition at line 117 of file FECore.cpp.

                                                                            {
  MoFEMFunctionBeginHot;
  *buildMoFEM &= 1 << 0;
  typedef FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type
      FiniteElements_by_name;
  FiniteElements_by_name &finite_element_name_set =
      finiteElements.get<FiniteElement_name_mi_tag>();
  FiniteElements_by_name::iterator it_fe =
      finite_element_name_set.find(fe_name);
  if (it_fe == finite_element_name_set.end())
    SETERRQ(mofemComm, MOFEM_NOT_FOUND,
            "This finite element is not defined (advise: check spelling)");
  boost::shared_ptr<FiniteElement> fe;
  fe = *it_fe;
  fe->elementAdjacencyTable[type] = function;
  MoFEMFunctionReturnHot(0);
}

modify_finite_element_off_field_col()

MoFEMErrorCode MoFEM::Core::modify_finite_element_off_field_col ( const std::string & fe_name, const std::string name_row )

protectedvirtual

unset field col which finite element use

Note

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

Parameters

name	finite element name
name	field name

Implements MoFEM::CoreInterface.

Definition at line 238 of file FECore.cpp.

                                                                    {
  MoFEMFunctionBegin;
  *buildMoFEM &= 1 << 0;
  auto &finite_element_name_set =
      finiteElements.get<FiniteElement_name_mi_tag>();
  auto it_fe = finite_element_name_set.find(fe_name);
  if (it_fe == finite_element_name_set.end())
    SETERRQ(mofemComm, MOFEM_NOT_FOUND, "this FiniteElement is there");
  bool success = finite_element_name_set.modify(
      it_fe, FiniteElement_col_change_bit_off(get_field_id(name_col)));
  if (!success)
    SETERRQ(mofemComm, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  MoFEMFunctionReturn(0);
}

modify_finite_element_off_field_data()

MoFEMErrorCode MoFEM::Core::modify_finite_element_off_field_data ( const std::string & fe_name, const std::string name_field )

protectedvirtual

unset finite element field data

Note

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

Parameters

name	finite element name
name	field name

This function will set memory in the form of a vector

Implements MoFEM::CoreInterface.

Definition at line 201 of file FECore.cpp.

                                                                      {
  MoFEMFunctionBegin;
  *buildMoFEM &= 1 << 0;
  auto &finite_element_name_set =
      finiteElements.get<FiniteElement_name_mi_tag>();
  auto it_fe = finite_element_name_set.find(fe_name);
  if (it_fe == finite_element_name_set.end())
    SETERRQ(mofemComm, MOFEM_NOT_FOUND, "this FiniteElement is there");
  bool success = finite_element_name_set.modify(
      it_fe, FiniteElement_change_bit_off(get_field_id(name_data)));
  if (!success)
    SETERRQ(mofemComm, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  MoFEMFunctionReturn(0);
}

modify_finite_element_off_field_row()

MoFEMErrorCode MoFEM::Core::modify_finite_element_off_field_row ( const std::string & fe_name, const std::string name_row )

protectedvirtual

unset field row which finite element use

Note

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

Parameters

name	finite element name
name	field name

Implements MoFEM::CoreInterface.

Definition at line 219 of file FECore.cpp.

                                                                    {
  MoFEMFunctionBegin;
  *buildMoFEM &= 1 << 0;
  auto &finite_element_name_set =
      finiteElements.get<FiniteElement_name_mi_tag>();
  auto it_fe = finite_element_name_set.find(fe_name);
  if (it_fe == finite_element_name_set.end())
    SETERRQ(mofemComm, MOFEM_NOT_FOUND, "this < %s > is not there",
             fe_name.c_str());
  bool success = finite_element_name_set.modify(
      it_fe, FiniteElement_row_change_bit_off(get_field_id(name_row)));
  if (!success)
    SETERRQ(mofemComm, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  MoFEMFunctionReturn(0);
}

modify_problem_add_finite_element()

MoFEMErrorCode MoFEM::Core::modify_problem_add_finite_element ( const std::string name_problem, const std::string & fe_name )

protectedvirtual

add finite element to problem, this add entities assigned to finite element to a particular problem

Note

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

Parameters

name	Problem name
name	Finite Element name

Implements MoFEM::CoreInterface.

Definition at line 143 of file ProblemsCore.cpp.

                                                                  {
  MoFEMFunctionBegin;
  typedef Problem_multiIndex::index<Problem_mi_tag>::type ProblemsByName;
  ProblemsByName &set = pRoblems.get<Problem_mi_tag>();
  ProblemsByName::iterator miit = set.find(name_problem);
  if (miit == set.end()) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "this problem <%s> is not there",
             name_problem.c_str());
  }
  BitFEId f_id = getBitFEId(fe_name);
  bool success = set.modify(miit, ProblemFiniteElementChangeBitAdd(f_id));
  if (!success)
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  MoFEMFunctionReturn(0);
}

modify_problem_mask_ref_level_add_bit()

MoFEMErrorCode MoFEM::Core::modify_problem_mask_ref_level_add_bit ( const std::string & name_problem, const BitRefLevel & bit )

protectedvirtual

set dof mask ref level for problem

Implements MoFEM::CoreInterface.

Definition at line 218 of file ProblemsCore.cpp.

                                                                    {
  MoFEMFunctionBegin;
  typedef Problem_multiIndex::index<Problem_mi_tag>::type ProblemsByName;
  ProblemsByName &set = pRoblems.get<Problem_mi_tag>();
  ProblemsByName::iterator miit = set.find(name_problem);
  if (miit == set.end()) {
    std::ostringstream ss;
    ss << name_problem;
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "this problem <%s> is there",
             ss.str().c_str());
  }
  bool success = set.modify(miit, ProblemChangeRefLevelBitDofMaskAdd(bit));
  if (!success)
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  MoFEMFunctionReturn(0);
}

modify_problem_mask_ref_level_set_bit()

MoFEMErrorCode MoFEM::Core::modify_problem_mask_ref_level_set_bit ( const std::string & name_problem, const BitRefLevel & bit )

protectedvirtual

set dof mask ref level for problem

Note

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

Implements MoFEM::CoreInterface.

Definition at line 238 of file ProblemsCore.cpp.

                                                                    {
  MoFEMFunctionBegin typedef Problem_multiIndex::index<Problem_mi_tag>::type
      ProblemsByName;
  ProblemsByName &set = pRoblems.get<Problem_mi_tag>();
  ProblemsByName::iterator miit = set.find(name_problem);
  if (miit == set.end()) {
    std::ostringstream ss;
    ss << name_problem;
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "this problem <%s> is there",
             ss.str().c_str());
  }
  bool success = set.modify(miit, ProblemChangeRefLevelBitDofMaskSet(bit));
  if (!success)
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  MoFEMFunctionReturn(0);
}

modify_problem_ref_level_add_bit()

MoFEMErrorCode MoFEM::Core::modify_problem_ref_level_add_bit ( const std::string & name_problem, const BitRefLevel & bit )

protectedvirtual

add ref level to problem

Note

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

if same finite element is solved using different level of refinements, than the level of refinement has to be specificied to problem in query

Parameters

name

Problem name

BitRefLevel

bitLevel Example: CHKERR mField.modify_problem_add_finite_element("BEAM_BENDING_ON_MESH_REF1","ELASTIC"); CHKERR mField.modify_problem_add_finite_element("BEAM_BENDING_ON_MESH_REF2","ELASTIC"); CHKERR mField.modify_problem_ref_level_add_bit("BEAM_BENDING_ON_MESH_REF1",bit_level1); CHKERR mField.modify_problem_ref_level_add_bit("BEAM_BENDING_ON_MESH_REF2",bit_level2); Two Problems exist and solved independently, both are elastic, but solved using different mesh refinement

Implements MoFEM::CoreInterface.

Definition at line 181 of file ProblemsCore.cpp.

                                                               {
  MoFEMFunctionBegin;
  typedef Problem_multiIndex::index<Problem_mi_tag>::type ProblemsByName;
  ProblemsByName &set = pRoblems.get<Problem_mi_tag>();
  ProblemsByName::iterator miit = set.find(name_problem);
  std::ostringstream ss;
  ss << name_problem;
  if (miit == set.end())
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "this problem <%s> is there",
             ss.str().c_str());
  bool success = set.modify(miit, ProblemChangeRefLevelBitAdd(bit));
  if (!success)
    SETERRQ(PETSC_COMM_SELF, 1, "modification unsuccessful");
  MoFEMFunctionReturn(0);
}

modify_problem_ref_level_set_bit()

MoFEMErrorCode MoFEM::Core::modify_problem_ref_level_set_bit ( const std::string & name_problem, const BitRefLevel & bit )

protectedvirtual

set ref level for problem

Note

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

if same finite element is solved using different level of refinements, than the level of refinement has to be specificied to problem in query

Parameters

name

Problem name

BitRefLevel

bitLevel Example: CHKERR mField.modify_problem_add_finite_element("BEAM_BENDING_ON_MESH_REF1","ELASTIC"); CHKERR mField.modify_problem_add_finite_element("BEAM_BENDING_ON_MESH_REF2","ELASTIC"); CHKERR mField.modify_problem_ref_level_set_bit("BEAM_BENDING_ON_MESH_REF1",bit_level1); CHKERR mField.modify_problem_ref_level_set_bit("BEAM_BENDING_ON_MESH_REF2",bit_level2); Two Problems exist and solved independently, both are elastic, but solved using different mesh refinement

Implements MoFEM::CoreInterface.

Definition at line 199 of file ProblemsCore.cpp.

                                                               {
  MoFEMFunctionBegin;
  typedef Problem_multiIndex::index<Problem_mi_tag>::type ProblemsByName;
  ProblemsByName &set = pRoblems.get<Problem_mi_tag>();
  ProblemsByName::iterator miit = set.find(name_problem);
  std::ostringstream ss;
  ss << name_problem;
  if (miit == set.end())
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "this problem <%s> is there",
             ss.str().c_str());
  bool success = set.modify(miit, ProblemChangeRefLevelBitSet(bit));
  if (!success)
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  MoFEMFunctionReturn(0);
}

modify_problem_unset_finite_element()

MoFEMErrorCode MoFEM::Core::modify_problem_unset_finite_element ( const std::string name_problem, const std::string & fe_name )

protectedvirtual

unset finite element from problem, this remove entities assigned to finite element to a particular problem

Note: If problem is build, it need to be cleaned to make this effective

Note

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

Parameters

name	Problem name
name	Finite Element name

Implements MoFEM::CoreInterface.

Definition at line 162 of file ProblemsCore.cpp.

                                                                    {
  MoFEMFunctionBegin;
  typedef Problem_multiIndex::index<Problem_mi_tag>::type ProblemsByName;
  ProblemsByName &set = pRoblems.get<Problem_mi_tag>();
  ProblemsByName::iterator miit = set.find(name_problem);
  if (miit == set.end()) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "this problem <%s> is not there",
             name_problem.c_str());
  }
  BitFEId f_id = getBitFEId(fe_name);
  bool success = set.modify(miit, ProblemFiniteElementChangeBitUnSet(f_id));
  if (!success)
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  MoFEMFunctionReturn(0);
}

problem_basic_method_postProcess() [1/2]

MoFEMErrorCode MoFEM::Core::problem_basic_method_postProcess ( const Problem * problem_ptr, BasicMethod & method, int verb = DEFAULT_VERBOSITY )

protectedvirtual

Set data for BasicMethod.

This function set data about problem, adjacencies and other multi-indices in database. This function can be used a special case when user need to do some pre- and post-processing before matrix or vector is initiated, or to assemble matrix for group of FEMethods. Is used by classes SnesCtx and TsCtx. Look for more details there.

FIXME: Here we need example

Parameters

pointer	to problem data structure
method	user method derived from BasicMethod

Implements MoFEM::CoreInterface.

Definition at line 395 of file ProblemsCore.cpp.

                                                                      {
  MoFEMFunctionBegin;
  SET_BASIC_METHOD(method, problem_ptr)
 
  PetscLogEventBegin(MOFEM_EVENT_postProcess, 0, 0, 0, 0);
  CHKERR method.postProcess();
  PetscLogEventEnd(MOFEM_EVENT_postProcess, 0, 0, 0, 0);
 
  MoFEMFunctionReturn(0);
}

problem_basic_method_postProcess() [2/2]

MoFEMErrorCode MoFEM::Core::problem_basic_method_postProcess ( const std::string & problem_name, BasicMethod & method, int verb = DEFAULT_VERBOSITY )

protectedvirtual

Set data for BasicMethod.

This function set data about problem, adjacencies and other multi-indices in database. This function can be used a special case when user need to do some pre- and post-processing before matrix or vector is initiated, or to assemble matrix for group of FEMethods. Is used by classes SnesCtx and TsCtx. Look for more details there.

FIXME: Here we need example

Parameters

problem_name	name of the problem
method	user method derived from BasicMethod

Implements MoFEM::CoreInterface.

Definition at line 408 of file ProblemsCore.cpp.

                                                                      {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  typedef Problem_multiIndex::index<Problem_mi_tag>::type ProblemsByName;
 
  // find p_miit
  ProblemsByName &pRoblems_set = pRoblems.get<Problem_mi_tag>();
  ProblemsByName::iterator p_miit = pRoblems_set.find(problem_name);
  if (p_miit == pRoblems_set.end())
    SETERRQ(mofemComm, 1, "problem is not in database %s",
             problem_name.c_str());
 
  CHKERR problem_basic_method_postProcess(&*p_miit, method, verb);
 
  MoFEMFunctionReturn(0);
}

problem_basic_method_preProcess() [1/2]

MoFEMErrorCode MoFEM::Core::problem_basic_method_preProcess ( const Problem * problem_ptr, BasicMethod & method, int verb = DEFAULT_VERBOSITY )

protectedvirtual

Set data for BasicMethod.

This function set data about problem, adjacencies and other multi-indices in database. This function can be used a special case when user need to do some pre- and post-processing before matrix or vector is initiated, or to assemble matrix for group of FEMethods. Is used by classes SnesCtx and TsCtx. Look for more details there.

FIXME: Here we need example

Parameters

pointer	to problem data structure
method	user method derived from BasicMethod

Implements MoFEM::CoreInterface.

Definition at line 363 of file ProblemsCore.cpp.

                                                               {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  // finite element
  SET_BASIC_METHOD(method, problem_ptr)
  PetscLogEventBegin(MOFEM_EVENT_preProcess, 0, 0, 0, 0);
  CHKERR method.preProcess();
  PetscLogEventEnd(MOFEM_EVENT_preProcess, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

problem_basic_method_preProcess() [2/2]

MoFEMErrorCode MoFEM::Core::problem_basic_method_preProcess ( const std::string & problem_name, BasicMethod & method, int verb = DEFAULT_VERBOSITY )

protectedvirtual

Set data for BasicMethod.

This function set data about problem, adjacencies and other multi-indices in database. This function can be used a special case when user need to do some pre- and post-processing before matrix or vector is initiated, or to assemble matrix for group of FEMethods. Is used by classes SnesCtx and TsCtx. Look for more details there.

FIXME: Here we need example

Parameters

problem_name	name of the problem
method	user method derived from BasicMethod

Implements MoFEM::CoreInterface.

Definition at line 378 of file ProblemsCore.cpp.

                                                                     {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  typedef Problem_multiIndex::index<Problem_mi_tag>::type ProblemsByName;
  // find p_miit
  ProblemsByName &pRoblems_set = pRoblems.get<Problem_mi_tag>();
  ProblemsByName::iterator p_miit = pRoblems_set.find(problem_name);
  if (p_miit == pRoblems_set.end())
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "problem is not in database %s",
             problem_name.c_str());
  CHKERR problem_basic_method_preProcess(&*p_miit, method, verb);
  MoFEMFunctionReturn(0);
}

query_interface()

MoFEMErrorCode MoFEM::Core::query_interface ( boost::typeindex::type_index type_index, UnknownInterface ** iface ) const

virtual

Getting interface of core database.

Parameters

uuid	unique ID of interface
iface	returned pointer to interface

Returns

error code

Implements MoFEM::UnknownInterface.

Definition at line 43 of file Core.cpp.

                                                                     {
  MoFEMFunctionBeginHot;
  *iface = NULL;
  if (type_index == boost::typeindex::type_id<CoreInterface>()) {
    *iface = static_cast<CoreInterface *>(const_cast<Core *>(this));
    MoFEMFunctionReturnHot(0);
  } else if (type_index ==
             boost::typeindex::type_id<DeprecatedCoreInterface>()) {
    *iface = static_cast<DeprecatedCoreInterface *>(const_cast<Core *>(this));
    MoFEMFunctionReturnHot(0);
  }
 
  // Get sub-interface
  auto it = iFaces.find(type_index);
  if (it != iFaces.end()) {
    *iface = it->second;
    MoFEMFunctionReturnHot(0);
  }
 
  *iface = NULL;
  SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "unknown interface");
  MoFEMFunctionReturnHot(0);
}

rebuild_database()

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

protectedvirtual

Clear database and initialize it once again.

Parameters

verb	Verbosity level

Returns

Error code

Implements MoFEM::CoreInterface.

Definition at line 758 of file Core.cpp.

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

regEvents()

template<class IFACE >

MoFEMErrorCode MoFEM::Core::regEvents ( )

protected

Register petsc events.

Template Parameters

IFACE

Returns

MoFEMErrorCode

Definition at line 190 of file Core.cpp.

                                                      {
  MoFEMFunctionBegin;
  auto ptr = boost::make_shared<IFACE>();
  // See SFINAE:
  // https://stackoverflow.com/questions/257288/is-it-possible-to-write-a-template-to-check-for-a-functions-existence
  // https://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error
  auto get_event_options = [](auto *const ptr) {
    return get_event_options_imp(ptr, 0);
  };
  CHKERR get_event_options(ptr.get());
  MoFEMFunctionReturn(0);
}

registerSubInterfaces()

MoFEMErrorCode MoFEM::Core::registerSubInterfaces ( )

protected

Register insterfaces.

Returns

MoFEMErrorCode

Definition at line 485 of file Core.cpp.

                                           {
  MoFEMFunctionBegin;
 
  iFaces.clear();
 
  // Register sub interfaces
  CHKERR regSubInterface<LogManager>();
  CHKERR regSubInterface<Simple>();
  CHKERR regSubInterface<OperatorsTester>();
  CHKERR regSubInterface<PipelineManager>();
  CHKERR regSubInterface<ProblemsManager>();
  CHKERR regSubInterface<MatrixManager>();
  CHKERR regSubInterface<ISManager>();
  CHKERR regSubInterface<VecManager>();
  CHKERR regSubInterface<FieldBlas>();
  CHKERR regSubInterface<BitRefManager>();
  CHKERR regSubInterface<Tools>();
  CHKERR regSubInterface<CommInterface>();
  CHKERR regSubInterface<MeshsetsManager>();
  CHKERR regSubInterface<NodeMergerInterface>();
  CHKERR regSubInterface<PrismsFromSurfaceInterface>();
  CHKERR regSubInterface<MeshRefinement>();
  CHKERR regSubInterface<PrismInterface>();
  CHKERR regSubInterface<CutMeshInterface>();
  CHKERR regSubInterface<SeriesRecorder>();
#ifdef WITH_TETGEN
  CHKERR regSubInterface<TetGenInterface>();
#endif
#ifdef WITH_MED
  CHKERR regSubInterface<MedInterface>();
#endif
  CHKERR regSubInterface<FieldEvaluatorInterface>();
  CHKERR regSubInterface<BcManager>();
 
  // Register events
  CHKERR regEvents<SchurEvents>();
 
  MoFEMFunctionReturn(0);
};

regSubInterface()

template<class IFACE >

MoFEMErrorCode MoFEM::Core::regSubInterface ( )

protected

Register sub-interfaces in core interface.

Template Parameters

IFACE

Returns

MoFEMErrorCode

Definition at line 172 of file Core.cpp.

                                                            {
  MoFEMFunctionBegin;
  CHKERR registerInterface<IFACE>(true);
  IFACE *ptr = new IFACE(*this);
 
  // If sub interface has function getSubInterfaceOptions run
  // it after construction. getSubInterfaceOptions is used to
  // get parameters from command line.
  auto get_sub_iface_options = [](auto *const ptr) {
    return get_sub_iface_options_imp(ptr, 0);
  };
  CHKERR get_sub_iface_options(ptr);
 
  auto type_idx = boost::typeindex::type_id<IFACE>();
  iFaces.insert(type_idx, ptr);
  MoFEMFunctionReturn(0);
}

remove_ents()

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

protectedvirtual

remove entities form mofem database

Implements MoFEM::CoreInterface.

Definition at line 429 of file DeleteCore.cpp.

                                                           {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  CHKERR remove_ents_from_finite_element(ents, verb);
  CHKERR remove_ents_from_field(ents, verb);
 
  for (Range::const_pair_iterator p_eit = ents.pair_begin();
       p_eit != ents.pair_end(); ++p_eit) {
 
    RefElement_multiIndex::index<Ent_mi_tag>::type::iterator frit, hi_frit;
    frit = refinedFiniteElements.get<Ent_mi_tag>().lower_bound(p_eit->first);
    hi_frit =
        refinedFiniteElements.get<Ent_mi_tag>().upper_bound(p_eit->second);
    refinedFiniteElements.get<Ent_mi_tag>().erase(frit, hi_frit);
 
    RefEntity_multiIndex::index<Ent_mi_tag>::type::iterator rit, hi_rit;
    rit = refinedEntities.get<Ent_mi_tag>().lower_bound(p_eit->first);
    hi_rit = refinedEntities.get<Ent_mi_tag>().upper_bound(p_eit->second);
    refinedEntities.get<Ent_mi_tag>().erase(rit, hi_rit);
  }
 
  MoFEMFunctionReturn(0);
}

remove_ents_by_bit_ref()

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

protectedvirtual

remove entities form mofem database

Implements MoFEM::CoreInterface.

Definition at line 454 of file DeleteCore.cpp.

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

remove_ents_from_field() [1/3]

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

protectedvirtual

remove entities from all fields

Note

not collective

Implements MoFEM::CoreInterface.

Definition at line 176 of file DeleteCore.cpp.

                                                                      {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  CHKERR clear_ents_fields(ents, verb);
  for (Field_multiIndex::iterator fit = fIelds.begin(); fit != fIelds.end();
       fit++) {
    EntityHandle meshset = fit->get()->getMeshset();
    CHKERR get_moab().remove_entities(meshset, ents);
  }
  MoFEMFunctionReturn(0);
}

remove_ents_from_field() [2/3]

MoFEMErrorCode MoFEM::Core::remove_ents_from_field ( const std::string name, const EntityHandle meshset, const EntityType type, int verb = DEFAULT_VERBOSITY )

protectedvirtual

remove entities from field

Note

not collective

Implements MoFEM::CoreInterface.

Definition at line 152 of file DeleteCore.cpp.

                                                                             {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  Range ents;
  CHKERR get_moab().get_entities_by_type(meshset, type, ents);
  CHKERR remove_ents_from_field(name, ents, verb);
  MoFEMFunctionReturn(0);
}

remove_ents_from_field() [3/3]

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

protectedvirtual

remove entities from field

Note

not collective

Implements MoFEM::CoreInterface.

Definition at line 164 of file DeleteCore.cpp.

                                                                        {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  EntityHandle meshset;
  meshset = get_field_meshset(name);
  CHKERR clear_ents_fields(name, ents, verb);
  CHKERR get_moab().remove_entities(meshset, ents);
  MoFEMFunctionReturn(0);
}

remove_ents_from_field_by_bit_ref()

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

protectedvirtual

remove entities from field

Note

not collective

Implements MoFEM::CoreInterface.

Definition at line 189 of file DeleteCore.cpp.

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

remove_ents_from_finite_element() [1/3]

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

protectedvirtual

remove entities from finite elements in database

Implements MoFEM::CoreInterface.

Definition at line 404 of file DeleteCore.cpp.

                                                               {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  CHKERR clear_finite_elements(ents, verb);
  for (FiniteElement_multiIndex::iterator fe_it = finiteElements.begin();
       fe_it != finiteElements.end(); fe_it++) {
    EntityHandle meshset = fe_it->get()->getMeshset();
    CHKERR get_moab().remove_entities(meshset, ents);
  }
  MoFEMFunctionReturn(0);
}

remove_ents_from_finite_element() [2/3]

MoFEMErrorCode MoFEM::Core::remove_ents_from_finite_element ( const std::string name, const EntityHandle meshset, const EntityType type, int verb = DEFAULT_VERBOSITY )

protectedvirtual

remove entities from given refinement level to finite element database

Implements MoFEM::CoreInterface.

Definition at line 379 of file DeleteCore.cpp.

                                                               {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  Range ents;
  CHKERR get_moab().get_entities_by_type(meshset, type, ents, false);
  CHKERR remove_ents_from_finite_element(name, ents, verb);
  MoFEMFunctionReturn(0);
}

remove_ents_from_finite_element() [3/3]

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

protectedvirtual

remove entities from finite element database

Implements MoFEM::CoreInterface.

Definition at line 392 of file DeleteCore.cpp.

                                                               {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  CHKERR clear_finite_elements(name, ents, verb);
  const EntityHandle idm = get_finite_element_meshset(name);
  CHKERR get_moab().remove_entities(idm, ents);
  MoFEMFunctionReturn(0);
}

remove_ents_from_finite_element_by_bit_ref()

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

protectedvirtual

remove elements from given refinement level to finite element database

Parameters

BitRefLevel	bit
BitRefLevel	mask
verbose	level

Implements MoFEM::CoreInterface.

Definition at line 418 of file DeleteCore.cpp.

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

remove_parents_by_bit_ref()

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

protectedvirtual

Remove parent from entities on bit level.

Evert entity created by refinement, split or any other change on the mesh can have parent. This function remove parent from entity,

Note

Functions makeing topological changes on entities should repsect parents child relation. This erase that relation. If you going to split faces and create interface is recommended to call this function before split opeartion.

Parameters

bit	level
mask	of bit level
verb	verbosity level

Returns

MoFEMErrorCode

Implements MoFEM::CoreInterface.

Definition at line 465 of file DeleteCore.cpp.

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

remove_parents_by_ents()

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

protectedvirtual

Remove parents from entities.

Implements MoFEM::CoreInterface.

Definition at line 477 of file DeleteCore.cpp.

                                                                       {
  MoFEMFunctionBegin;
 
  std::vector<EntityHandle> leftovers_ents;
  leftovers_ents.reserve(ents.size());
 
  for (auto pit = ents.pair_begin(); pit != ents.pair_end(); ++pit) {
 
    EntityHandle f = pit->first;
    const EntityHandle s = pit->second;
    auto lo = refinedEntities.lower_bound(f);
    for (; f <= s; ++f) {
 
      auto check = [this](auto lo, auto f) {
        if (lo == refinedEntities.end())
          return false;
        if ((*lo)->getEnt() == f)
          return true;
        return false;
      };
 
      if (check(lo, f)) {
        bool success = refinedEntities.modify(lo, RefEntity_change_parent(0));
        if (!success)
          SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                  "Operation of removing parent unsuccessful");
        ++lo;
      } else
        leftovers_ents.emplace_back(f);
    }
  }
 
  if (!leftovers_ents.empty()) {
    std::vector<EntityHandle> zero_parents(leftovers_ents.size());
    CHKERR get_moab().tag_set_data(th_RefParentHandle, &leftovers_ents[0],
                                   leftovers_ents.size(),
                                   &*zero_parents.begin());
  }
  MoFEMFunctionReturn(0);
}

remove_parents_by_parents()

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

protectedvirtual

Remove paremts from entities having parents in passed range.

Implements MoFEM::CoreInterface.

Definition at line 518 of file DeleteCore.cpp.

                                                                          {
  MoFEMFunctionBegin;
  for (Range::iterator eit = ents.begin(); eit != ents.end(); ++eit) {
    RefEntity_multiIndex::index<Ent_Ent_mi_tag>::type::iterator it;
    while ((it = refinedEntities.get<Ent_Ent_mi_tag>().find(*eit)) !=
           refinedEntities.get<Ent_Ent_mi_tag>().end()) {
      bool success = refinedEntities.get<Ent_Ent_mi_tag>().modify(
          it, RefEntity_change_parent(0));
      if (!success) {
        SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                "Operation of removing parent unsuccessful");
      }
    }
  }
  MoFEMFunctionReturn(0);
}

set_field_order() [1/4]

MoFEMErrorCode MoFEM::Core::set_field_order ( const EntityHandle meshset, const EntityType type, const BitFieldId id, const ApproximationOrder order, int verb = DEFAULT_VERBOSITY )

protected

Definition at line 955 of file FieldCore.cpp.

                                                                               {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  *buildMoFEM = 0;
  Range ents;
  CHKERR get_moab().get_entities_by_type(meshset, type, ents);
  CHKERR this->set_field_order(ents, id, order, verb);
  MoFEMFunctionReturn(0);
}

set_field_order() [2/4]

MoFEMErrorCode MoFEM::Core::set_field_order ( const EntityHandle meshset, const EntityType type, const std::string & name, const ApproximationOrder order, int verb = DEFAULT_VERBOSITY )

protectedvirtual

Set order approximation of the entities in the field.

Note

not collective

Parameters

meshset	containing set of the entities (use 0 for all the entities in the meshset)
type	selected type of the entities f.e. MBTET, MBTRI, MBEDGE, MBVERTEX, see moab documentation
order	approximation order

Implements MoFEM::CoreInterface.

Definition at line 967 of file FieldCore.cpp.

                                                                               {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  *buildMoFEM = 0;
  CHKERR this->set_field_order(meshset, type, get_field_id(name), order, verb);
  MoFEMFunctionReturn(0);
}

set_field_order() [3/4]

MoFEMErrorCode MoFEM::Core::set_field_order ( const Range & ents, const BitFieldId id, const ApproximationOrder order, int verb = DEFAULT_VERBOSITY )

protected

Definition at line 930 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;
 
  // check field & meshset
  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, "no field found");
 
  MOFEM_LOG("WORLD", Sev::noisy)
      << "Field " << (*field_it)->getName() << " core value < "
      << this->getValue() << " > field value ( "
      << static_cast<int>((*field_it)->getBitNumber()) << " )"
      << " nb. of ents " << ents.size();
 
  CHKERR this->setFieldOrderImpl(*field_it, ents, order, verb);
 
  MoFEMFunctionReturn(0);
}

set_field_order() [4/4]

MoFEMErrorCode MoFEM::Core::set_field_order ( const Range & ents, const std::string & name, const ApproximationOrder order, int verb = DEFAULT_VERBOSITY )

protectedvirtual

Set order approximation of the entities in the field.

Note

not collective

Parameters

entities
type	selected type of the entities f.e. MBTET, MBTRI, MBEDGE, MBVERTEX, see moab documentation
order	approximation order

Implements MoFEM::CoreInterface.

Definition at line 978 of file FieldCore.cpp.

                                                                               {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  *buildMoFEM = 0;
  CHKERR this->set_field_order(ents, get_field_id(name), order, verb);
  MoFEMFunctionReturn(0);
}

set_field_order_by_entity_type_and_bit_ref() [1/2]

MoFEMErrorCode MoFEM::Core::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 )

protected

Definition at line 987 of file FieldCore.cpp.

                                                                   {
  MoFEMFunctionBeginHot;
  if (verb == -1)
    verb = verbose;
  *buildMoFEM = 0;
  Range ents;
  CHKERR BitRefManager(*this).getEntitiesByTypeAndRefLevel(bit, mask, type,
                                                           ents, verb);
  CHKERR this->set_field_order(ents, id, order, verb);
  MoFEMFunctionReturnHot(0);
}

set_field_order_by_entity_type_and_bit_ref() [2/2]

MoFEMErrorCode MoFEM::Core::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 )

protectedvirtual

Set order approximation of the entities in the field.

Note

not collective

Parameters

bit	refinement level
mask	bit mask
type	selected type of the entities f.e. MBTET, MBTRI, MBEDGE, MBVERTEX, see moab documentation
order	approximation order

Implements MoFEM::CoreInterface.

Definition at line 1001 of file FieldCore.cpp.

                                                                     {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
  *buildMoFEM = 0;
  Range ents;
  CHKERR BitRefManager(*this).getEntitiesByTypeAndRefLevel(bit, mask, type,
                                                           ents, verb);
  CHKERR this->set_field_order(ents, get_field_id(name), order, verb);
  MoFEMFunctionReturn(0);
}

set_moab_interface()

MoFEMErrorCode MoFEM::Core::set_moab_interface ( moab::Interface & new_moab, int verb = VERBOSE )

protectedvirtual

Set the moab interface object.

Parameters

new_moab
verb

Returns

MoFEMErrorCode

Implements MoFEM::CoreInterface.

Reimplemented in MoFEM::CoreTmp<-1 >.

Definition at line 768 of file Core.cpp.

                                                                         {
  return this->setMoabInterface(new_moab, verb);
};

setFieldOrder()

MoFEMErrorCode MoFEM::CoreTmp< 0 >::setFieldOrder ( const Range & ents, const BitFieldId id, const ApproximationOrder order, int ver )

protected

setFieldOrderImpl()

MoFEMErrorCode MoFEM::Core::setFieldOrderImpl ( boost::shared_ptr< Field > field_ptr, const Range & ents, const ApproximationOrder order, int verb )

protected

Definition at line 506 of file FieldCore.cpp.

                                                 {
  FieldCoreFunctionBegin;
 
  if (verb == DEFAULT_VERBOSITY)
    verb = verbose;
  *buildMoFEM = 0;
 
  const auto field_meshset = field_ptr->getMeshset();
  const auto bit_number = field_ptr->getBitNumber();
 
  // intersection with field meshset
  Range ents_of_id_meshset;
  CHKERR get_moab().get_entities_by_handle(field_meshset, ents_of_id_meshset,
                                           false);
  Range field_ents = intersect(ents, ents_of_id_meshset);
  if (verb > QUIET) {
    MOFEM_LOG_C("SYNC", Sev::noisy,
                "change nb. of ents for order in the field <%s> %d",
                field_ptr->getName().c_str(), field_ents.size(), 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));
  }
 
  if (verb > QUIET)
    MOFEM_LOG_C("SYNC", Sev::noisy,
                "current nb. of ents in the multi index field <%s> %d",
                field_ptr->getName().c_str(), ents_id_view.size());
 
  // loop over ents
  int nb_ents_set_order_up = 0;
  int nb_ents_set_order_down = 0;
  int nb_ents_set_order_new = 0;
 
  FieldEntity_change_order modify_order_no_size_change(order, false);
  FieldEntity_change_order modify_order_size_change(order, true);
 
  for (auto pit = field_ents.const_pair_begin();
       pit != field_ents.const_pair_end(); pit++) {
    EntityHandle first = pit->first;
    EntityHandle second = pit->second;
 
    const auto type = static_cast<EntityType>(first >> MB_ID_WIDTH);
 
    // Sanity check
    switch (field_ptr->getSpace()) {
    case H1:
      break;
    case HCURL:
      if (type == MBVERTEX)
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Hcurl space on vertices makes no sense");
 
      break;
    case HDIV:
      if (type == MBVERTEX)
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Hdiv space on vertices makes no sense");
 
      if (type == MBEDGE)
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Hdiv space on edges makes no sense");
 
      break;
    default:
      break;
    }
 
    // Entity is in database, change order only if needed
    Range ents_in_database;
    auto vit = ents_id_view.get<1>().lower_bound(first);
    auto hi_vit = ents_id_view.get<1>().upper_bound(second);
    if (order >= 0) {
      for (; vit != hi_vit; ++vit) {
        ents_in_database.insert(vit->get()->getEnt());
        // entity is in database and order is changed or reset
        const ApproximationOrder old_approximation_order =
            (*vit)->getMaxOrder();
 
        if (old_approximation_order != order) {
 
          FieldEntity_multiIndex::iterator miit =
              entsFields.get<Unique_mi_tag>().find((*vit)->getLocalUniqueId());
 
          if ((*miit)->getMaxOrder() < order)
            nb_ents_set_order_up++;
          if ((*miit)->getMaxOrder() > order)
            nb_ents_set_order_down++;
 
          // set dofs inactive if order is reduced, and set new order to entity
          // if order is increased (note that dofs are not build if order is
          // increased)
 
          bool can_change_size = true;
          auto dit = dofsField.get<Unique_mi_tag>().lower_bound(
              FieldEntity::getLoLocalEntityBitNumber(bit_number,
                                                     (*miit)->getEnt()));
          if (dit != dofsField.get<Unique_mi_tag>().end()) {
            auto hi_dit = dofsField.get<Unique_mi_tag>().upper_bound(
                FieldEntity::getHiLocalEntityBitNumber(bit_number,
                                                       (*miit)->getEnt()));
 
            if (dit != hi_dit)
              can_change_size = false;
            for (; dit != hi_dit; dit++) {
              if ((*dit)->getDofOrder() > order) {
                bool success = dofsField.modify(dofsField.project<0>(dit),
                                                DofEntity_active_change(false));
                if (!success)
                  SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                          "modification unsuccessful");
              }
            }
          }
 
          bool success =
              entsFields.modify(entsFields.project<0>(miit),
                                can_change_size ? modify_order_size_change
                                                : modify_order_no_size_change);
          if (!success)
            SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                    "modification unsuccessful");
        }
      }
    }
 
    Range new_ents = subtract(Range(first, second), ents_in_database);
    for (Range::const_pair_iterator pit = new_ents.const_pair_begin();
         pit != new_ents.const_pair_end(); ++pit) {
      const auto first = pit->first;
      const auto second = pit->second;
      const auto ent_type = get_moab().type_from_handle(first);
      
      if (!field_ptr->getFieldOrderTable()[ent_type])
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                 "Number of degrees of freedom for entity %s for %s space on "
                 "base %s can "
                 "not be deduced",
                 moab::CN::EntityTypeName(ent_type),
                 field_ptr->getSpaceName().c_str(),
                 field_ptr->getApproxBaseName().c_str());
 
      auto get_nb_dofs_on_order = [&](const int order) {
        return order >= 0 ? (field_ptr->getFieldOrderTable()[ent_type])(order)
                          : 0;
      };
      const int nb_dofs_on_order = get_nb_dofs_on_order(order);
      if (nb_dofs_on_order || order == -1) {
 
        const int field_rank = field_ptr->getNbOfCoeffs();
        const int nb_dofs = nb_dofs_on_order * field_rank;
 
        // Entity is not in database and order is changed or reset
        auto miit_ref_ent =
            refinedEntities.get<Ent_mi_tag>().lower_bound(first);
 
        auto create_tags_for_max_order = [&](const Range &ents) {
          MoFEMFunctionBegin;
          if (order >= 0) {
            std::vector<ApproximationOrder> o_vec(ents.size(), order);
            CHKERR get_moab().tag_set_data(field_ptr->th_AppOrder, ents,
                                           &*o_vec.begin());
          }
          MoFEMFunctionReturn(0);
        };
 
        auto create_tags_for_data = [&](const Range &ents) {
          MoFEMFunctionBegin;
          if (order >= 0) {
 
            if (nb_dofs > 0) {
              if (ent_type == MBVERTEX) {
                std::vector<FieldData> d_vec(nb_dofs * ents.size(), 0);
                CHKERR get_moab().tag_set_data(field_ptr->th_FieldDataVerts,
                                               ents, &*d_vec.begin());
              } else {
                std::vector<int> tag_size(ents.size(), nb_dofs);
                std::vector<FieldData> d_vec(nb_dofs, 0);
                std::vector<void const *> d_vec_ptr(ents.size(),
                                                    &*d_vec.begin());
                CHKERR get_moab().tag_set_by_ptr(field_ptr->th_FieldData, ents,
                                                 &*d_vec_ptr.begin(),
                                                 &*tag_size.begin());
              }
            }
          }
 
          MoFEMFunctionReturn(0);
        };
 
        auto get_ents_in_ref_ent = [&](auto miit_ref_ent) {
          auto hi = refinedEntities.get<Ent_mi_tag>().upper_bound(second);
          Range in;
          for (; miit_ref_ent != hi; ++miit_ref_ent)
            in.insert(miit_ref_ent->get()->getEnt());
          return in;
        };
 
        auto get_ents_max_order = [&](const Range &ents) {
          boost::shared_ptr<std::vector<const void *>> vec(
              new std::vector<const void *>());
          vec->resize(ents.size());
          CHKERR get_moab().tag_get_by_ptr(field_ptr->th_AppOrder, ents,
                                           &*vec->begin());
          return vec;
        };
 
        auto get_ents_field_data_vector_adaptor =
            [&](const Range &ents,
                boost::shared_ptr<std::vector<const void *>> &ents_max_orders) {
              // create shared pointer and reserve memory
              boost::shared_ptr<std::vector<double *>> vec(
                  new std::vector<double *>());
              vec->reserve(ents.size());
 
              if (order >= 0 && nb_dofs == 0) {
                // set empty vector adaptor
                for (int i = 0; i != ents.size(); ++i)
                  vec->emplace_back(nullptr);
              } else {
                moab::ErrorCode rval;
                std::vector<int> tag_size(ents.size());
                std::vector<const void *> d_vec_ptr(ents.size());
 
                // get tags data
                if (ent_type == MBVERTEX)
                  rval = get_moab().tag_get_by_ptr(field_ptr->th_FieldDataVerts,
                                                   ents, &*d_vec_ptr.begin(),
                                                   &*tag_size.begin());
                else
                  rval = get_moab().tag_get_by_ptr(field_ptr->th_FieldData,
                                                   ents, &*d_vec_ptr.begin(),
                                                   &*tag_size.begin());
 
                auto cast = [](auto p) {
                  return const_cast<FieldData *const>(
                      static_cast<const FieldData *>(p));
                };
 
                // some of entities has tag not set or zero dofs on entity
                if (rval == MB_SUCCESS) {
                  // all is ok, all entities has tag set
                  auto tit = d_vec_ptr.begin();
                  auto oit = ents_max_orders->begin();
                  for (auto sit = tag_size.begin(); sit != tag_size.end();
                       ++sit, ++tit, ++oit)
                    vec->emplace_back(cast(*tit));
 
                } else {
                  // set empty vector adaptor
                  for (int i = 0; i != ents.size(); ++i)
                    vec->emplace_back(nullptr);
 
                  // check order on all entities, and if for that order non zero
                  // dofs are expected get pointer to tag data and reset vector
                  // adaptor
                  auto oit = ents_max_orders->begin();
                  auto dit = vec->begin();
                  for (auto eit = ents.begin(); eit != ents.end();
                       ++eit, ++oit, ++dit) {
 
                    const int ent_order =
                        *static_cast<const ApproximationOrder *>(*oit);
                    const int ent_nb_dofs = get_nb_dofs_on_order(ent_order);
 
                    if (ent_nb_dofs) {
                      int tag_size;
                      const void *ret_val;
                      if (ent_type == MBVERTEX) {
                        rval = get_moab().tag_get_by_ptr(
                            field_ptr->th_FieldDataVerts, &*eit, 1, &ret_val,
                            &tag_size);
                      } else {
                        rval = get_moab().tag_get_by_ptr(
                            field_ptr->th_FieldData, &*eit, 1, &ret_val,
                            &tag_size);
                        if (rval != MB_SUCCESS) {
 
                          const int set_tag_size[] = {ent_nb_dofs * field_rank};
                          std::array<FieldData, MAX_DOFS_ON_ENTITY> set_d_vec;
                          std::fill(set_d_vec.begin(),
                                    &set_d_vec[set_tag_size[0]], 0);
                          const void *set_d_vec_ptr[] = {set_d_vec.data()};
                          CHKERR get_moab().tag_set_by_ptr(
                              field_ptr->th_FieldData, &*eit, 1, set_d_vec_ptr,
                              set_tag_size);
                          rval = get_moab().tag_get_by_ptr(
                              field_ptr->th_FieldData, &*eit, 1, &ret_val,
                              &tag_size);
 
                          if (rval != MB_SUCCESS) {
                            MOFEM_LOG_ATTRIBUTES("SELF",
                                                 LogManager::BitLineID |
                                                     LogManager::BitScope);
                            MOFEM_LOG("SELF", Sev::error)
                                << "Error is triggered in MOAB, field tag data "
                                   "for same reason can not be for accessed.";
                            MOFEM_LOG("SELF", Sev::error)
                                << "Set order: " << order;
                            MOFEM_LOG("SELF", Sev::error)
                                << "Nb. dofs on entity for given order: "
                                << set_tag_size[0];
                            MOFEM_LOG("SELF", Sev::error)
                                << "Entity type: "
                                << moab::CN::EntityTypeName(ent_type);
                            MOFEM_LOG("SELF", Sev::error)
                                << "Field: " << *field_ptr;
                            CHKERR rval;
                          }
                        }
                      }
                      const_cast<FieldData *&>(*dit) = cast(ret_val);
                    }
                  }
                }
              }
              return vec;
            };
 
        auto ents_in_ref_ent = get_ents_in_ref_ent(miit_ref_ent);
 
        CHKERR create_tags_for_max_order(ents_in_ref_ent);
        CHKERR create_tags_for_data(ents_in_ref_ent);
        auto ents_max_order = get_ents_max_order(ents_in_ref_ent);
        auto ent_field_data =
            get_ents_field_data_vector_adaptor(ents_in_ref_ent, ents_max_order);
 
        // reserve memory for field  dofs
        auto ents_array = boost::make_shared<std::vector<FieldEntity>>();
        // Add sequence to field data structure. Note that entities are
        // allocated once into vector. This vector is passed into sequence as a
        // weak_ptr. Vector is destroyed at the point last entity inside that
        // vector is destroyed.
        ents_array->reserve(second - first + 1);
        auto vit_max_order = ents_max_order->begin();
        auto vit_field_data = ent_field_data->begin();
        for (int i = 0; i != ents_in_ref_ent.size(); ++i) {
 
          ents_array->emplace_back(
              field_ptr, *miit_ref_ent,
              boost::shared_ptr<double *const>(ent_field_data,
                                               &*vit_field_data),
              boost::shared_ptr<const int>(
                  ents_max_order, static_cast<const int *>(*vit_max_order)));
          ++vit_max_order;
          ++vit_field_data;
          ++miit_ref_ent;
        }
        if (!ents_array->empty())
          if ((*ents_array)[0].getFieldRawPtr() != field_ptr.get())
            SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                     "Get field ent poiter and field pointer do not match for "
                     "field %s",
                     field_ptr->getName().c_str());
        nb_ents_set_order_new += ents_array->size();
 
        // Check if any of entities in the range has bit level but is not added
        // to database. That generate data inconsistency and error.
        if (ents_in_ref_ent.size() < (second - first + 1)) {
          Range ents_not_in_database =
              subtract(Range(first, second), ents_in_ref_ent);
          std::vector<const void *> vec_bits(ents_not_in_database.size());
          CHKERR get_moab().tag_get_by_ptr(
              get_basic_entity_data_ptr()->th_RefBitLevel, ents_not_in_database,
              &*vec_bits.begin());
          auto cast = [](auto p) {
            return static_cast<const BitRefLevel *>(p);
          };
          for (auto v : vec_bits)
            if (cast(v)->any())
              SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                      "Try to add entities which are not seeded or added to "
                      "database");
        }
 
        // Add entities to database
        auto hint = entsFields.end();
        for (auto &v : *ents_array)
          hint = entsFields.emplace_hint(hint, ents_array, &v);
      }
    }
  }
 
  if (verb > QUIET) {
    MOFEM_LOG_C("SYNC", Sev::noisy,
                "nb. of entities in field <%s> for which order was "
                "increased %d (order %d)",
                field_ptr->getName().c_str(), nb_ents_set_order_up, order);
    MOFEM_LOG_C("SYNC", Sev::noisy,
                "nb. of entities in field <%s> for which order was "
                "reduced %d (order %d)",
                field_ptr->getName().c_str(), nb_ents_set_order_down, order);
    MOFEM_LOG_C(
        "SYNC", Sev::noisy,
        "nb. of entities in field <%s> for which order set %d (order %d)",
        field_ptr->getName().c_str(), nb_ents_set_order_new, order);
  }
 
  if (verb > QUIET) {
    auto eiit = entsFields.get<Unique_mi_tag>().lower_bound(
        FieldEntity::getLoBitNumberUId(field_ptr->getBitNumber()));
    auto hi_eiit = entsFields.get<Unique_mi_tag>().upper_bound(
        FieldEntity::getHiBitNumberUId(field_ptr->getBitNumber()));
    MOFEM_LOG_C("SYNC", Sev::noisy,
                "nb. of ents in the multi index field <%s> %d",
                field_ptr->getName().c_str(), std::distance(eiit, hi_eiit));
  }
 
  if (verb > QUIET)
    MOFEM_LOG_SEVERITY_SYNC(mofemComm, Sev::noisy);
 
  MoFEMFunctionReturn(0);
}

setMoabInterface()

MoFEMErrorCode MoFEM::Core::setMoabInterface ( moab::Interface & new_moab, int verb = VERBOSE )

protected

Definition at line 455 of file Core.cpp.

                                                                       {
  MoFEMFunctionBegin;
  if (verb == -1)
    verb = verbose;
 
  // clear moab database
  CHKERR clearMap();
 
  // set new reference
  moab = std::ref(new_moab);
 
  // check if moab has set communicator if not set communicator internally
  ParallelComm *pComm = ParallelComm::get_pcomm(&new_moab, MYPCOMM_INDEX);
  if (pComm == NULL) {
    pComm = new ParallelComm(&new_moab, wrapMPIMOABComm->get_comm());
  }
 
  // create MoFEM tags
  CHKERR getTags();
 
  // Create basic entity data struture
  basicEntityDataPtr = boost::make_shared<BasicEntityData>(moab);
  setRefEntBasicDataPtr(*this, this->basicEntityDataPtr);
 
  // Initalise database
  CHKERR this->initialiseDatabaseFromMesh(verb);
 
  MoFEMFunctionReturn(0);
};

setRefEntBasicDataPtr()

void MoFEM::Core::setRefEntBasicDataPtr ( MoFEM::Interface & m_field, boost::shared_ptr< BasicEntityData > & ptr )

static

Definition at line 930 of file Core.cpp.

                                                                        {
 
  switch (m_field.getValue()) {
  case -1:
    set_ref_ent_basic_data_ptr_impl<-1>(ptr);
    break;
  case 0:
    set_ref_ent_basic_data_ptr_impl<0>(ptr);
    break;
  case 1:
    set_ref_ent_basic_data_ptr_impl<1>(ptr);
    break;
  default:
    THROW_MESSAGE("Core index can vary from -1 to MAX_CORE_TMP");
  }
};

Member Data Documentation

basicEntityDataPtr

boost::shared_ptr<BasicEntityData> MoFEM::CoreTmp< 0 >::basicEntityDataPtr

protected

Returns

pointer to BasicEntityData structure

BasicEntityData is structure which every BasicEntity have. It keeps data about tags to handles on the mesh, in particular tag to BitRefLevel and tag with handle to parent.

Definition at line 281 of file Core.hpp.

buildMoFEM

int* MoFEM::CoreTmp< 0 >::buildMoFEM

mutableprotected

keeps flags/semaphores for different stages

Definition at line 1046 of file Core.hpp.

dofsField

DofEntity_multiIndex MoFEM::CoreTmp< 0 >::dofsField

protected

dofs on fields

Definition at line 305 of file Core.hpp.

entFEAdjacencies

FieldEntityEntFiniteElementAdjacencyMap_multiIndex MoFEM::CoreTmp< 0 >::entFEAdjacencies

protected

adjacencies of elements to dofs

Definition at line 311 of file Core.hpp.

entsFields

FieldEntity_multiIndex MoFEM::CoreTmp< 0 >::entsFields

protected

entities on fields

Definition at line 304 of file Core.hpp.

entsFiniteElements

EntFiniteElement_multiIndex MoFEM::CoreTmp< 0 >::entsFiniteElements

protected

finite element entities

Definition at line 308 of file Core.hpp.

fIelds

Field_multiIndex MoFEM::CoreTmp< 0 >::fIelds

protected

fields

Definition at line 303 of file Core.hpp.

finiteElements

FiniteElement_multiIndex MoFEM::CoreTmp< 0 >::finiteElements

protected

finite elements

Definition at line 307 of file Core.hpp.

iFaces

boost::ptr_map<boost::typeindex::type_index, UnknownInterface> MoFEM::CoreTmp< 0 >::iFaces

mutableprotected

Hash map of pointers to interfaces.

Definition at line 1044 of file Core.hpp.

initaliseAndBuildField

PetscBool MoFEM::CoreTmp< 0 >::initaliseAndBuildField

protected

If true build field on database initialisation

Definition at line 1050 of file Core.hpp.

initaliseAndBuildFiniteElements

PetscBool MoFEM::CoreTmp< 0 >::initaliseAndBuildFiniteElements

protected

Definition at line 1053 of file Core.hpp.

isGloballyInitialised

bool MoFEM::Core::isGloballyInitialised = false

staticprotected

Core base globally initialized.

Definition at line 1056 of file Core.hpp.

isInitialized

PetscBool MoFEM::Core::isInitialized

staticprotected

petsc was initialised by other agent

Definition at line 1058 of file Core.hpp.

moab

std::reference_wrapper<moab::Interface> MoFEM::CoreTmp< 0 >::moab

protected

moab database

Definition at line 321 of file Core.hpp.

MOFEM_EVENT_createMat

PetscLogEvent MoFEM::CoreTmp< 0 >::MOFEM_EVENT_createMat

protected

Definition at line 1004 of file Core.hpp.

MOFEM_EVENT_operator

PetscLogEvent MoFEM::CoreTmp< 0 >::MOFEM_EVENT_operator

protected

Event for evaluating operator of finite element.

Definition at line 1001 of file Core.hpp.

MOFEM_EVENT_postProcess

PetscLogEvent MoFEM::CoreTmp< 0 >::MOFEM_EVENT_postProcess

protected

Event for postProcess finite element.

Definition at line 1003 of file Core.hpp.

MOFEM_EVENT_preProcess

PetscLogEvent MoFEM::CoreTmp< 0 >::MOFEM_EVENT_preProcess

protected

Event for preProcess finite element.

Definition at line 999 of file Core.hpp.

mofemComm

MPI_Comm MoFEM::CoreTmp< 0 >::mofemComm

mutableprotected

MoFEM communicator.

Definition at line 1012 of file Core.hpp.

mpiInitialised

int MoFEM::Core::mpiInitialised

staticprotected

mpi was initialised by other agent

Definition at line 1057 of file Core.hpp.

optionsPrefix

std::string MoFEM::CoreTmp< 0 >::optionsPrefix

protected

Prefix for options on command line.

Definition at line 1048 of file Core.hpp.

pComm

ParallelComm* MoFEM::CoreTmp< 0 >::pComm

mutableprotected

MOAB communicator structure.

Definition at line 1013 of file Core.hpp.

pRoblems

Problem_multiIndex MoFEM::CoreTmp< 0 >::pRoblems

protected

problems multi-index

Definition at line 313 of file Core.hpp.

rAnk

int MoFEM::CoreTmp< 0 >::rAnk

protected

MOFEM communicator rank.

Definition at line 1016 of file Core.hpp.

refinedEntities

RefEntity_multiIndex MoFEM::CoreTmp< 0 >::refinedEntities

protected

refined entities

Definition at line 300 of file Core.hpp.

refinedFiniteElements

RefElement_multiIndex MoFEM::CoreTmp< 0 >::refinedFiniteElements

protected

refined elements

Definition at line 301 of file Core.hpp.

sIze

int MoFEM::CoreTmp< 0 >::sIze

protected

MoFEM communicator size.

Definition at line 1015 of file Core.hpp.

th_ElemType

Tag MoFEM::CoreTmp< 0 >::th_ElemType

protected

Needed for VTK files.

Definition at line 269 of file Core.hpp.

th_FEId

Tag MoFEM::CoreTmp< 0 >::th_FEId

protected

Definition at line 262 of file Core.hpp.

th_FEIdCol

Tag MoFEM::CoreTmp< 0 >::th_FEIdCol

protected

Definition at line 263 of file Core.hpp.

th_FEIdData

Tag MoFEM::CoreTmp< 0 >::th_FEIdData

protected

Definition at line 263 of file Core.hpp.

th_FEIdRow

Tag MoFEM::CoreTmp< 0 >::th_FEIdRow

protected

Definition at line 263 of file Core.hpp.

th_FEName

Tag MoFEM::CoreTmp< 0 >::th_FEName

protected

Definition at line 262 of file Core.hpp.

th_FieldBase

Tag MoFEM::CoreTmp< 0 >::th_FieldBase

protected

Definition at line 261 of file Core.hpp.

th_FieldContinuity

Tag MoFEM::CoreTmp< 0 >::th_FieldContinuity

protected

Definition at line 261 of file Core.hpp.

th_FieldId

Tag MoFEM::CoreTmp< 0 >::th_FieldId

protected

Definition at line 260 of file Core.hpp.

th_FieldName

Tag MoFEM::CoreTmp< 0 >::th_FieldName

protected

Definition at line 260 of file Core.hpp.

th_FieldName_DataNamePrefix

Tag MoFEM::CoreTmp< 0 >::th_FieldName_DataNamePrefix

protected

Definition at line 260 of file Core.hpp.

th_FieldSpace

Tag MoFEM::CoreTmp< 0 >::th_FieldSpace

protected

Definition at line 260 of file Core.hpp.

th_MoFEMBuild

Tag MoFEM::CoreTmp< 0 >::th_MoFEMBuild

protected

Internal use storing state, used to detect error and inconsistencies

Definition at line 270 of file Core.hpp.

th_Part

Tag MoFEM::CoreTmp< 0 >::th_Part

protected

Tag for partition number.

Definition at line 257 of file Core.hpp.

th_ProblemFEId

Tag MoFEM::CoreTmp< 0 >::th_ProblemFEId

protected

Definition at line 264 of file Core.hpp.

th_ProblemGhostNbDofCol

Tag MoFEM::CoreTmp< 0 >::th_ProblemGhostNbDofCol

protected

Definition at line 267 of file Core.hpp.

th_ProblemGhostNbDofRow

Tag MoFEM::CoreTmp< 0 >::th_ProblemGhostNbDofRow

protected

Definition at line 266 of file Core.hpp.

th_ProblemId

Tag MoFEM::CoreTmp< 0 >::th_ProblemId

protected

Definition at line 264 of file Core.hpp.

th_ProblemLocalNbDofCol

Tag MoFEM::CoreTmp< 0 >::th_ProblemLocalNbDofCol

protected

Definition at line 267 of file Core.hpp.

th_ProblemLocalNbDofRow

Tag MoFEM::CoreTmp< 0 >::th_ProblemLocalNbDofRow

protected

Definition at line 266 of file Core.hpp.

th_ProblemName

Tag MoFEM::CoreTmp< 0 >::th_ProblemName

protected

Definition at line 264 of file Core.hpp.

th_ProblemNbDofsCol

Tag MoFEM::CoreTmp< 0 >::th_ProblemNbDofsCol

protected

Definition at line 265 of file Core.hpp.

th_ProblemNbDofsRow

Tag MoFEM::CoreTmp< 0 >::th_ProblemNbDofsRow

protected

Definition at line 265 of file Core.hpp.

th_ProblemShift

Tag MoFEM::CoreTmp< 0 >::th_ProblemShift

protected

Definition at line 268 of file Core.hpp.

th_RefBitEdge

Tag MoFEM::CoreTmp< 0 >::th_RefBitEdge

protected

Definition at line 258 of file Core.hpp.

th_RefBitLevel

Tag MoFEM::CoreTmp< 0 >::th_RefBitLevel

protected

Definition at line 258 of file Core.hpp.

th_RefBitLevel_Mask

Tag MoFEM::CoreTmp< 0 >::th_RefBitLevel_Mask

protected

Definition at line 258 of file Core.hpp.

th_RefFEMeshset

Tag MoFEM::CoreTmp< 0 >::th_RefFEMeshset

protected

Definition at line 259 of file Core.hpp.

th_RefParentHandle

Tag MoFEM::CoreTmp< 0 >::th_RefParentHandle

protected

Definition at line 258 of file Core.hpp.

value

const int MoFEM::CoreTmp< 0 >::value = 0

staticconstexpr

Definition at line 84 of file Core.hpp.

verbose

int MoFEM::CoreTmp< 0 >::verbose

protected

Verbosity level.

Definition at line 1039 of file Core.hpp.

wrapMPIMOABComm

boost::shared_ptr<WrapMPIComm> MoFEM::CoreTmp< 0 >::wrapMPIMOABComm

protected

manage creation and destruction of MOAB communicator

Definition at line 1037 of file Core.hpp.

---

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

• src/interfaces/Core.hpp
• src/interfaces/CoreTemplates.hpp
• src/interfaces/impl/Core.cpp
• src/interfaces/impl/DeleteCore.cpp
• src/interfaces/impl/FECore.cpp
• src/interfaces/impl/FieldCore.cpp
• src/interfaces/impl/ProblemsCore.cpp