v0.14.0
Loading...
Searching...
No Matches
Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
MoFEM::CoreTmp< 0 > Struct Reference

Core (interface) class. More...

#include <src/interfaces/Core.hpp>

Inheritance diagram for MoFEM::CoreTmp< 0 >:
[legend]
Collaboration diagram for MoFEM::CoreTmp< 0 >:
[legend]

Public Member Functions

const int getValue () const
 Get the core. More...
 
RefEntityTmp< 0 > getRefEntity (const EntityHandle ent)
 
virtual boost::shared_ptr< RefEntityTmp< 0 > > make_shared_ref_entity (const EntityHandle ent)
 Get RefEntity. More...
 
 CoreTmp (moab::Interface &moab, MPI_Comm comm=PETSC_COMM_WORLD, const int verbose=VERBOSE)
 
 ~CoreTmp ()
 
- Public Member Functions inherited from MoFEM::DeprecatedCoreInterface
virtual DEPRECATED MoFEMErrorCode seed_ref_level_2D (const EntityHandle meshset, const BitRefLevel &bit, int verb=-1)
 seed 2D entities (Triangles entities only) in the meshset and their adjacencies (only TRIs adjacencies) in a particular BitRefLevel More...
 
DEPRECATED MoFEMErrorCode seed_ref_level_3D (const EntityHandle meshset, const BitRefLevel &bit, int verb=-1)
 seed 2D entities in the meshset and their adjacencies (only TETs adjacencies) in a particular BitRefLevel More...
 
DEPRECATED MoFEMErrorCode seed_ref_level (const Range &ents, const BitRefLevel &bit, const bool only_tets=true, int verb=-1)
 seed entities in the range and their adjacencies in a particular BitRefLevel More...
 
DEPRECATED MoFEMErrorCode partition_mesh (const Range &ents, const int dim, const int adj_dim, const int n_parts, int verb=-1)
 Set partition tag to each finite element in the problem. More...
 
DEPRECATED MoFEMErrorCode synchronise_entities (Range &ent, int verb=DEFAULT_VERBOSITY)
 
DEPRECATED MoFEMErrorCode synchronise_field_entities (const std::string &name, int verb=DEFAULT_VERBOSITY)
 
- Public Member Functions inherited from MoFEM::CoreInterface
virtual ~CoreInterface ()=default
 
virtual const int getValue () const =0
 Get the core. More...
 
virtual boost::shared_ptr< RefEntityTmp< 0 > > make_shared_ref_entity (const EntityHandle ent)=0
 Get RefEntity. More...
 
- Public Member Functions inherited from MoFEM::UnknownInterface
virtual MoFEMErrorCode query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const =0
 
template<class IFACE >
MoFEMErrorCode registerInterface (bool error_if_registration_failed=true)
 Register interface. More...
 
template<class IFACE >
MoFEMErrorCode getInterface (IFACE *&iface) const
 Get interface refernce to pointer of interface. More...
 
template<class IFACE >
MoFEMErrorCode getInterface (IFACE **const iface) const
 Get interface pointer to pointer of interface. More...
 
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE getInterface () const
 Get interface pointer to pointer of interface. More...
 
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE getInterface () const
 Get reference to interface. More...
 
template<class IFACE >
IFACE * getInterface () const
 Function returning pointer to interface. More...
 
virtual ~UnknownInterface ()=default
 

Static Public Attributes

static constexpr int value = 0
 

Protected Member Functions

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

Protected Attributes

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

Static Protected Attributes

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

Auxiliary data and functions

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

Tags to data on mesh and entities

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

Multi-Indices accessing data on the mesh

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

Get moab database

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

Log events

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

Communicator

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

Assessing interfaces

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

Get tag handles to data on the mesh

Tag get_th_RefParentHandle () const
 
Tag get_th_RefBitLevel () const
 
Tag get_th_RefBitEdge () const
 

Global initialisation and finalisation <br>

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

Static functions

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

Check database consistency

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

Clear database

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

Getting access to meshset manager

MeshsetsManagerget_meshsets_manager_ptr ()
 get MeshsetsManager pointer More...
 
const MeshsetsManagerget_meshsets_manager_ptr () const
 get MeshsetsManager pointer More...
 
MeshsetsManagerget_meshsets_manager ()
 get MeshsetsManager pointer More...
 
const MeshsetsManagerget_meshsets_manager () const
 get MeshsetsManager pointer More...
 

Remove and delete entities

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

Fields

virtual MoFEMErrorCode add_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 filed. More...
 
MoFEMErrorCode delete_field (const std::string name, int verb=DEFAULT_VERBOSITY)
 Delete field. More...
 
MoFEMErrorCode addField (const std::string &name, const FieldSpace space, const FieldApproximationBase base, const FieldCoefficientsNumber nb_coefficients, const TagType tag_type, const enum MoFEMTypes bh, int verb)
 Template for add_field. More...
 
MoFEMErrorCode addEntsToFieldByDim (const Range &ents, const int dim, const std::string &name, int verb=DEFAULT_VERBOSITY)
 
MoFEMErrorCode add_ents_to_field_by_dim (const Range &ents, const int dim, const std::string &name, int verb=DEFAULT_VERBOSITY)
 Add entities to field meshset. More...
 
MoFEMErrorCode add_ents_to_field_by_type (const Range &ents, const EntityType type, const std::string &name, int verb=DEFAULT_VERBOSITY)
 Add entities to field meshset. More...
 
MoFEMErrorCode add_ents_to_field_by_dim (const EntityHandle meshset, const int dim, const std::string &name, const bool recursive=true, int verb=DEFAULT_VERBOSITY)
 Add entities to field meshset. More...
 
MoFEMErrorCode add_ents_to_field_by_type (const EntityHandle meshset, const EntityType type, const std::string &name, const bool recursive=true, int verb=DEFAULT_VERBOSITY)
 Add entities to field meshset. More...
 
MoFEMErrorCode create_vertices_and_add_to_field (const std::string name, const double coords[], int size, int verb=DEFAULT_VERBOSITY)
 Create a vertices and add to field object. More...
 

Set approximation order

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

Build fields

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

Clear DOFs

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

Clear ENTs

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

Remove field entities

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

Other auxiliary functions for fields

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

Finite elements

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

Problems

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

Adjacencies

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

Methods for preforming operations on elements

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

Accessing multi-indices

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

Additional Inherited Members

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

Detailed Description

Core (interface) class.

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

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

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

Todo:
Implement static functions for Initialization and Finalization of MoFEM. Those functions should keep all static variables and initialize/finalize other libs like PETSc. Moreover initialization functions should set error handlers, etc.
Examples
add_blockset.cpp, add_cubit_meshsets.cpp, adolc_plasticity.cpp, analytical_nonlinear_poisson.cpp, analytical_poisson.cpp, analytical_poisson_field_split.cpp, approx_sphere.cpp, bernstein_bezier_generate_base.cpp, bone_adaptation.cpp, boundary_marker.cpp, build_large_problem.cpp, build_problems.cpp, cell_forces.cpp, child_and_parent.cpp, continuity_check_on_contact_prism_side_ele.cpp, continuity_check_on_skeleton_3d.cpp, continuity_check_on_skeleton_with_simple_2d_for_h1.cpp, continuity_check_on_skeleton_with_simple_2d_for_hcurl.cpp, continuity_check_on_skeleton_with_simple_2d_for_hdiv.cpp, cubit_bc_test.cpp, delete_ho_nodes.cpp, dg_projection.cpp, dm_build_partitioned_mesh.cpp, dm_create_subdm.cpp, dm_partitioned_no_field.cpp, dynamic_first_order_con_law.cpp, edge_and_bubble_shape_functions_on_quad.cpp, eigen_elastic.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, ep.cpp, field_evaluator.cpp, field_to_vertices.cpp, forces_and_sources_testing_edge_element.cpp, forces_and_sources_testing_flat_prism_element.cpp, forces_and_sources_testing_users_base.cpp, free_surface.cpp, gauss_points_on_outer_product.cpp, hanging_node_approx.cpp, hcurl_check_approx_in_2d.cpp, hcurl_curl_operator.cpp, hcurl_divergence_operator_2d.cpp, hdiv_divergence_operator.cpp, heat_equation.cpp, heat_method.cpp, hello_world.cpp, helmholtz.cpp, hertz_surface.cpp, higher_derivatives.cpp, level_set.cpp, log.cpp, loop_entities.cpp, lorentz_force.cpp, magnetostatic.cpp, mesh_cut.cpp, mesh_insert_interface_atom.cpp, mesh_smoothing.cpp, meshset_to_vtk.cpp, minimal_surface_area.cpp, mixed_poisson.cpp, mortar_contact.cpp, mortar_contact_thermal.cpp, navier_stokes.cpp, node_merge.cpp, nonlinear_dynamics.cpp, nonlinear_elastic.cpp, operators_tests.cpp, partition_mesh.cpp, phase.cpp, photon_diffusion.cpp, plastic.cpp, plate.cpp, plot_base.cpp, poisson_2d_dis_galerkin.cpp, poisson_2d_homogeneous.cpp, prism_elements_from_surface.cpp, prism_polynomial_approximation.cpp, quad_polynomial_approximation.cpp, reaction_diffusion.cpp, remove_entities_from_problem.cpp, remove_entities_from_problem_not_partitioned.cpp, scalar_check_approximation.cpp, seepage.cpp, shallow_wave.cpp, simple_contact.cpp, simple_contact_thermal.cpp, simple_elasticity.cpp, simple_interface.cpp, simple_l2_only.cpp, split_sideset.cpp, tensor_divergence_operator.cpp, test_cache_on_entities.cpp, test_jacobian_of_simple_contact_element.cpp, testing_jacobian_of_hook_element.cpp, testing_jacobian_of_hook_scaled_with_density_element.cpp, thermo_elastic.cpp, unsaturated_transport.cpp, wave_equation.cpp, and wavy_surface.cpp.

Definition at line 82 of file Core.hpp.

Member Enumeration Documentation

◆ SemaphoresBuildMofem

enum MoFEM::CoreTmp< 0 >::SemaphoresBuildMofem

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

Enumerator
BUILD_FIELD 
BUILD_FE 
BUILD_ADJ 
BUILD_PROBLEM 
PARTITION_PROBLEM 
PARTITION_FE 
PARTITION_GHOST_DOFS 
PARTITION_MESH 

Definition at line 211 of file Core.hpp.

211 {
212 BUILD_FIELD = 1 << 0,
213 BUILD_FE = 1 << 1,
214 BUILD_ADJ = 1 << 2,
215 BUILD_PROBLEM = 1 << 3,
216 PARTITION_PROBLEM = 1 << 4,
217 PARTITION_FE = 1 << 5,
218 PARTITION_GHOST_DOFS = 1 << 6,
219 PARTITION_MESH = 1 << 7
220 };

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
moabMoAB interface
commMPI communicator
verboseVerbosity level

Definition at line 209 of file Core.cpp.

214 : CoreTmp(moab, comm, verbose, CoreValue<0>()) {
215
216 // Register sub-interfaces
217 ierr = this->registerSubInterfaces();
218 CHKERRABORT(comm, ierr);
219 ierr = this->clearMap();
220 CHKERRABORT(comm, ierr);
221 ierr = this->getTags();
222 CHKERRABORT(comm, ierr);
223 ierr = this->getOptions(verbose);
224 CHKERRABORT(comm, ierr);
225
226 this->basicEntityDataPtr = boost::make_shared<BasicEntityData>(moab);
228
230 CHKERRABORT(comm, ierr);
231}
static MoFEMErrorCodeGeneric< PetscErrorCode > ierr
Definition: Exceptions.hpp:76
MoFEMErrorCode clearMap()
Cleaning database.
Definition: Core.cpp:474
static void setRefEntBasicDataPtr(MoFEM::Interface &m_field, boost::shared_ptr< BasicEntityData > &ptr)
Definition: Core.cpp:875
MoFEMErrorCode initialiseDatabaseFromMesh(int verb=DEFAULT_VERBOSITY)
Initialize database getting information on mesh.
Definition: Core.cpp:268
MoFEMErrorCode registerSubInterfaces()
Register insterfaces.
Definition: Core.cpp:437
MoFEMErrorCode getOptions(int verb=DEFAULT_VERBOSITY)
Get core options from command line.
Definition: Core.cpp:721
int verbose
Verbosity level.
Definition: Core.hpp:993
MoFEMErrorCode getTags(int verb=DEFAULT_VERBOSITY)
Get tag handles.
Definition: Core.cpp:522
CoreTmp(moab::Interface &moab, MPI_Comm comm=PETSC_COMM_WORLD, const int verbose=VERBOSE)
Definition: Core.cpp:209
boost::shared_ptr< BasicEntityData > basicEntityDataPtr
Definition: Core.hpp:281
std::reference_wrapper< moab::Interface > moab
moab database
Definition: Core.hpp:321

◆ ~CoreTmp()

MoFEM::Core::~CoreTmp ( )

Definition at line 257 of file Core.cpp.

257 {
258 PetscBool is_finalized;
259 PetscFinalized(&is_finalized);
260 // Destroy interfaces
261 iFaces.clear();
262 // This is deprecated ONE should use MoFEM::Core::Initialize
263 if (isGloballyInitialised && is_finalized) {
264 isGloballyInitialised = false;
265 }
266}
static bool isGloballyInitialised
Core base globally initialized.
Definition: Core.hpp:1010
boost::ptr_map< boost::typeindex::type_index, UnknownInterface > iFaces
Hash map of pointers to interfaces.
Definition: Core.hpp:998

◆ 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
moabMoAB interface
commMPI communicator

Definition at line 32 of file CoreTemplates.hpp.

34 : moab(moab), mofemComm(comm), verbose(verbose),
35 initaliseAndBuildField(PETSC_FALSE),
37
39 CHKERRABORT(comm, ierr);
40
41 MOFEM_LOG_CHANNEL("WORLD");
42 if (verbose > QUIET) {
43 MOFEM_LOG_C("WORLD", Sev::verbose, "Core number < %d >", V);
44 }
45}
#define MOFEM_LOG_C(channel, severity, format,...)
Definition: LogManager.hpp:311
@ QUIET
Definition: definitions.h:208
#define MOFEM_LOG_CHANNEL(channel)
Set and reset channel.
Definition: LogManager.hpp:284
PetscBool initaliseAndBuildFiniteElements
Definition: Core.hpp:1007
MoFEMErrorCode coreGenericConstructor(moab::Interface &moab, MPI_Comm comm, const int verbose)
Definition: Core.cpp:171
PetscBool initaliseAndBuildField
Definition: Core.hpp:1004
MPI_Comm mofemComm
MoFEM communicator.
Definition: Core.hpp:966

Member Function Documentation

◆ 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
dimdimension
namename of field
recursivetake entities recursively from embedded entities
verbverbosity level
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 384 of file FieldCore.cpp.

387 {
389 Range ents;
390 CHKERR get_moab().get_entities_by_dimension(meshset, dim, ents, recursive);
391 CHKERR addEntsToFieldByDim(ents, dim, name, verb);
394}
#define MOFEM_LOG_SYNCHRONISE(comm)
Synchronise "SYNC" channel.
Definition: LogManager.hpp:345
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:447
#define CHKERR
Inline error check.
Definition: definitions.h:535
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:440
const int dim
MoFEMErrorCode addEntsToFieldByDim(const Range &ents, const int dim, const std::string &name, int verb=DEFAULT_VERBOSITY)
Definition: FieldCore.cpp:287
moab::Interface & get_moab()
Definition: Core.hpp:322

◆ 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
entsrange of entities
dimdimension of entities
namename of field
verbverbosity level
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 360 of file FieldCore.cpp.

362 {
364 Range ents_dim = ents.subset_by_dimension(dim);
365 CHKERR addEntsToFieldByDim(ents_dim, dim, name, verb);
368}
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416

◆ 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
typeof entities
namename of field
recursivetake entities recursively from embedded entities
verbverbosity level
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 396 of file FieldCore.cpp.

399 {
401 Range ents;
402 CHKERR get_moab().get_entities_by_type(meshset, type, ents, recursive);
403 if (!ents.empty()) {
404 const int dim = get_moab().dimension_from_handle(ents[0]);
405 CHKERR addEntsToFieldByDim(ents, dim, name, verb);
406 }
409}

◆ 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
entsrange of entities
typetype of entities
namename of field
verbverbosity level
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 370 of file FieldCore.cpp.

373 {
375 Range ents_type = ents.subset_by_type(type);
376 if (!ents_type.empty()) {
377 const int dim = get_moab().dimension_from_handle(ents_type[0]);
378 CHKERR addEntsToFieldByDim(ents_type, dim, name, verb);
379 }
382}

◆ 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
BitRefLevelbit
BitRefLevelmask
finiteelement name
finiteelement type
verboselevel

Implements MoFEM::CoreInterface.

Definition at line 408 of file FECore.cpp.

410 {
412
413 if (verb == -1)
414 verb = verbose;
415 *buildMoFEM &= 1 << 0;
416 const BitFEId id = getBitFEId(name);
418
419 auto &ref_MoFEMFiniteElement = refinedFiniteElements.get<Ent_mi_tag>();
420 auto miit = ref_MoFEMFiniteElement.lower_bound(get_id_for_min_type(type));
421 auto hi_miit = ref_MoFEMFiniteElement.upper_bound(get_id_for_max_type(type));
422
423 int nb_add_fes = 0;
424 for (; miit != hi_miit; miit++) {
425 const auto &bit2 = miit->get()->getBitRefLevel();
426 if ((bit2 & mask) != bit2)
427 continue;
428 if ((bit2 & bit).any()) {
429 EntityHandle ent = miit->get()->getEnt();
430 CHKERR get_moab().add_entities(idm, &ent, 1);
431 nb_add_fes++;
432 }
433 }
434
435 MOFEM_LOG("SYNC", Sev::inform)
436 << "Finite element " << name << " added. Nb. of elements added "
437 << nb_add_fes << " out of " << std::distance(miit, hi_miit);
438
440
442}
#define FECoreFunctionBegin
Definition: FECore.cpp:7
#define MOFEM_LOG(channel, severity)
Log.
Definition: LogManager.hpp:308
auto bit
set bit
std::bitset< BITFEID_SIZE > BitFEId
Finite element Id.
Definition: Types.hpp:43
EntityHandle get_id_for_max_type()
EntityHandle get_id_for_min_type()
EntityHandle get_finite_element_meshset(const BitFEId id) const
Definition: FECore.cpp:276
RefElement_multiIndex refinedFiniteElements
refined elements
Definition: Core.hpp:301
int * buildMoFEM
keeps flags/semaphores for different stages
Definition: Core.hpp:1000
BitFEId getBitFEId(const std::string &fe_name) const
Get field Id.
Definition: FECore.cpp:258

◆ 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
entitiesmeshset or range form were entities taken
dimdimension
namename of field
recursivetake entities from meshsets in meshset
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 349 of file FECore.cpp.

351 {
353 *buildMoFEM &= 1 << 0;
356 Range ents;
357 CHKERR get_moab().get_entities_by_dimension(meshset, dim, ents, recursive);
358 CHKERR getInterface<BitRefManager>()->setElementsBitRefLevel(ents);
359 CHKERR get_moab().add_entities(idm, ents);
361}
const EntityHandle no_handle
No entity handle is indicated by zero handle, i.e. root meshset.
Definition: Common.hpp:12

◆ 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
entsrange of entities
dimdimension of entities
namename of finite element
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 376 of file FECore.cpp.

377 {
379 *buildMoFEM &= 1 << 0;
382 CHKERR getInterface<BitRefManager>()->setElementsBitRefLevel(
383 ents.subset_by_dimension(dim));
384 CHKERR get_moab().add_entities(idm, ents.subset_by_dimension(dim));
386}

◆ 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
meshsetcontains all entities that could be used for finite element
nameFinite Element name

Implements MoFEM::CoreInterface.

Definition at line 444 of file FECore.cpp.

445 {
447 *buildMoFEM &= 1 << 0;
448 const BitFEId id = getBitFEId(name);
450 if (recursive == false) {
451 CHKERR get_moab().add_entities(idm, &meshset, 1);
452 } else {
453 Range meshsets;
454 CHKERR get_moab().get_entities_by_type(meshset, MBENTITYSET, meshsets,
455 false);
456 CHKERR get_moab().add_entities(idm, meshsets);
457 }
459}

◆ 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
entitiesmeshset or range form were entities taken
typetype of entity
namename of field
recursivetake entities from meshsets in meshset
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 332 of file FECore.cpp.

334 {
335 *buildMoFEM &= 1 << 0;
338
340 Range ents;
341 CHKERR get_moab().get_entities_by_type(meshset, type, ents, recursive);
342 CHKERR getInterface<BitRefManager>()->setElementsBitRefLevel(ents);
343 CHKERR get_moab().add_entities(idm, ents);
344
346}

◆ 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
entsrange of entities
typetype of entity (MBVERTEX, MBEDGE, MBTRI, ...)
namename of finite element
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 363 of file FECore.cpp.

364 {
366 *buildMoFEM &= 1 << 0;
369 CHKERR getInterface<BitRefManager>()->setElementsBitRefLevel(
370 ents.subset_by_type(type));
371 CHKERR get_moab().add_entities(idm, ents.subset_by_type(type));
373} // 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 399 of file FECore.cpp.

401 {
403 CHKERR add_ents_to_finite_element_by_bit_ref(bit, mask, name, type, verb);
404
406}
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
Definition: FECore.cpp:408

◆ 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 389 of file FECore.cpp.

391 {
394 type, verb);
395
397}
std::bitset< BITREFLEVEL_SIZE > BitRefLevel
Bit structure attached to each entity identifying to what mesh entity is attached.
Definition: Types.hpp:40

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

Parameters
nameField name
spaceSpace L2,H1,Hdiv,Hcurl
baseApproximation base AINSWORTH_LEGENDRE_BASE, AINSWORTH_BERNSTEIN_BEZIER_BASE ...
nb_coefficientsNumber of field coefficients
tag_typeTag type, MB_TAG_DENSE or MB_TAG_SPARSE (default)
bhControl behavior, if MF_EXCL throws error if exist
verbVerbosity 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 278 of file FieldCore.cpp.

282 {
283 return this->addField(name, space, base, nb_of_coefficients, tag_type, bh,
284 verb);
285}
MoFEMErrorCode addField(const std::string &name, const FieldSpace space, const FieldApproximationBase base, const FieldCoefficientsNumber nb_coefficients, const TagType tag_type, const enum MoFEMTypes bh, int verb)
Template for add_field.
Definition: FieldCore.cpp:108

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

44 {
46 *buildMoFEM &= 1 << 0;
47 if (verb == -1) {
48 verb = verbose;
49 }
50
51 // Add finite element meshset to partion meshset. In case of no elements
52 // on processor part, when mesh file is read, finite element meshset is
53 // prevented from deletion by moab reader.
54 auto add_meshset_to_partition = [&](auto meshset) {
56 const void *tag_vals[] = {&rAnk};
57 ParallelComm *pcomm = ParallelComm::get_pcomm(
58 &get_moab(), get_basic_entity_data_ptr()->pcommID);
59 Tag part_tag = pcomm->part_tag();
60 Range tagged_sets;
61 CHKERR get_moab().get_entities_by_type_and_tag(0, MBENTITYSET, &part_tag,
62 tag_vals, 1, tagged_sets,
63 moab::Interface::UNION);
64 for (auto s : tagged_sets)
65 CHKERR get_moab().add_entities(s, &meshset, 1);
67 };
68
69 auto &finite_element_name_set =
70 finiteElements.get<FiniteElement_name_mi_tag>();
71 auto it_fe = finite_element_name_set.find(fe_name);
72
73 if (bh == MF_EXCL) {
74 if (it_fe != finite_element_name_set.end()) {
75 SETERRQ1(mofemComm, MOFEM_NOT_FOUND, "this < %s > is there",
76 fe_name.c_str());
77 }
78
79 } else {
80 if (it_fe != finite_element_name_set.end())
82 }
83 EntityHandle meshset;
84 CHKERR get_moab().create_meshset(MESHSET_SET, meshset);
85 CHKERR add_meshset_to_partition(meshset);
86
87 // id
88 int fe_shift = 0;
89 for (; finiteElements.get<BitFEId_mi_tag>().find(BitFEId().set(fe_shift)) !=
90 finiteElements.get<BitFEId_mi_tag>().end();
91 ++fe_shift) {
92 }
93
94 auto id = BitFEId().set(fe_shift);
95 CHKERR get_moab().tag_set_data(th_FEId, &meshset, 1, &id);
96
97 // id name
98 void const *tag_data[] = {fe_name.c_str()};
99 int tag_sizes[1];
100 tag_sizes[0] = fe_name.size();
101 CHKERR get_moab().tag_set_by_ptr(th_FEName, &meshset, 1, tag_data, tag_sizes);
102
103 // add FiniteElement
104 auto p = finiteElements.insert(
105 boost::shared_ptr<FiniteElement>(new FiniteElement(moab, meshset)));
106 if (!p.second)
108 "FiniteElement not inserted");
109
110 if (verb > QUIET)
111 MOFEM_LOG("WORLD", Sev::inform) << "Add finite element " << fe_name;
112
114}
static Index< 'p', 3 > p
@ MF_EXCL
Definition: definitions.h:99
@ MOFEM_NOT_FOUND
Definition: definitions.h:33
@ MOFEM_OPERATION_UNSUCCESSFUL
Definition: definitions.h:34
boost::shared_ptr< BasicEntityData > & get_basic_entity_data_ptr()
Get pointer to basic entity data.
Definition: Core.hpp:290
FiniteElement_multiIndex finiteElements
finite elements
Definition: Core.hpp:307
int rAnk
MOFEM communicator rank.
Definition: Core.hpp:970

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

85 {
87 if (verb == -1)
88 verb = verbose;
89 auto miit = pRoblems.get<Problem_mi_tag>().find(name);
90 if (miit == pRoblems.get<Problem_mi_tag>().end()) {
91
92 int p_shift = 0;
93 for (; pRoblems.get<BitProblemId_mi_tag>().find(BitProblemId().set(
94 p_shift)) != pRoblems.get<BitProblemId_mi_tag>().end();
95 ++p_shift) {
96 }
97
98 auto id = BitProblemId().set(p_shift);
99 CHKERR addProblem(id, name, verb);
100
101 } else if (bh == MF_EXCL) {
102 SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "problem is in database %s",
103 name.c_str());
104 }
106}
std::bitset< BITPROBLEMID_SIZE > BitProblemId
Problem Id.
Definition: Types.hpp:44
MoFEMErrorCode addProblem(const BitProblemId id, const std::string &name, int verb=DEFAULT_VERBOSITY)
add problem
Problem_multiIndex pRoblems
problems multi-index
Definition: Core.hpp:313

◆ addEntsToFieldByDim()

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

Definition at line 287 of file FieldCore.cpp.

288 {
289
290 *buildMoFEM = 0;
292 if (verb == -1)
293 verb = verbose;
294
295 MOFEM_LOG_CHANNEL("SYNC");
296 MOFEM_LOG_TAG("SYNC", "FieldCore");
298
300 idm = get_field_meshset(name);
301 FieldSpace space;
302 CHKERR get_moab().tag_get_data(th_FieldSpace, &idm, 1, &space);
303 std::vector<int> nb_ents_on_dim(3, 0);
304 switch (space) {
305 case L2:
306 CHKERR get_moab().add_entities(idm, ents);
307 break;
308 case H1:
309 CHKERR get_moab().add_entities(idm, ents);
310 for (int dd = 0; dd != dim; ++dd) {
311 Range adj_ents;
312 CHKERR get_moab().get_adjacencies(ents, dd, false, adj_ents,
313 moab::Interface::UNION);
314 if (dd == 0) {
315 Range topo_nodes;
316 CHKERR get_moab().get_connectivity(ents, topo_nodes, true);
317 Range mid_nodes;
318 CHKERR get_moab().get_connectivity(ents, mid_nodes, false);
319 mid_nodes = subtract(mid_nodes, topo_nodes);
320 adj_ents = subtract(adj_ents, mid_nodes);
321 }
322 CHKERR get_moab().add_entities(idm, adj_ents);
323 nb_ents_on_dim[dd] = adj_ents.size();
324 }
325 break;
326 case HCURL:
327 CHKERR get_moab().add_entities(idm, ents);
328 for (int dd = 1; dd != dim; ++dd) {
329 Range adj_ents;
330 CHKERR get_moab().get_adjacencies(ents, dd, false, adj_ents,
331 moab::Interface::UNION);
332 CHKERR get_moab().add_entities(idm, adj_ents);
333 nb_ents_on_dim[dd] = adj_ents.size();
334 }
335 break;
336 case HDIV:
337 CHKERR get_moab().add_entities(idm, ents);
338 if (dim > 2) {
339 Range adj_ents;
340 CHKERR get_moab().get_adjacencies(ents, 2, false, adj_ents,
341 moab::Interface::UNION);
342 CHKERR get_moab().add_entities(idm, adj_ents);
343 nb_ents_on_dim[2] = adj_ents.size();
344 }
345 break;
346 default:
347 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
348 "sorry, unknown space added to entity");
349 }
350 if (verb >= VERBOSE) {
351 MOFEM_LOG("SYNC", Sev::noisy) << "add entities to field " << name;
352 MOFEM_LOG("SYNC", Sev::noisy) << "\tnb. add ents " << ents.size();
353 MOFEM_LOG("SYNC", Sev::noisy) << "\tnb. add faces " << nb_ents_on_dim[2];
354 MOFEM_LOG("SYNC", Sev::noisy) << "\tnb. add edges " << nb_ents_on_dim[1];
355 MOFEM_LOG("SYNC", Sev::noisy) << "\tnb. add nodes " << nb_ents_on_dim[0];
356 }
358}
@ VERBOSE
Definition: definitions.h:209
FieldSpace
approximation spaces
Definition: definitions.h:82
@ L2
field with C-1 continuity
Definition: definitions.h:88
@ H1
continuous field
Definition: definitions.h:85
@ HCURL
field with continuous tangents
Definition: definitions.h:86
@ HDIV
field with continuous normal traction
Definition: definitions.h:87
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:31
#define MOFEM_LOG_TAG(channel, tag)
Tag channel.
Definition: LogManager.hpp:339
#define MOFEM_LOG_FUNCTION()
Set scope.
Definition: LogManager.hpp:325
const Tensor2_symmetric_Expr< const ddTensor0< T, Dim, i, j >, typename promote< T, double >::V, Dim, i, j > dd(const Tensor0< T * > &a, const Index< i, Dim > index1, const Index< j, Dim > index2, const Tensor1< int, Dim > &d_ijk, const Tensor1< double, Dim > &d_xyz)
Definition: ddTensor0.hpp:33
EntityHandle get_field_meshset(const BitFieldId id) const
Definition: FieldCore.cpp:45

◆ addField()

MoFEMErrorCode MoFEM::Core::addField ( const std::string &  name,
const FieldSpace  space,
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
base
nb_coefficients
tag_type
bh
verb
Returns
MoFEMErrorCode

Definition at line 108 of file FieldCore.cpp.

112 {
113 MOFEM_LOG_CHANNEL("WORLD");
114 MOFEM_LOG_TAG("WORLD", "FieldCore");
115 MOFEM_LOG_CHANNEL("SYNC");
116 MOFEM_LOG_TAG("SYNC", "FieldCore");
119
120 // Add field mesh set to partion meshset. In case of no elements
121 // on processor part, when mesh file is read, finite element meshset is
122 // prevented from deletion by moab reader.
123 auto add_meshset_to_partition = [&](auto meshset) {
125 const void *tag_vals[] = {&rAnk};
126 ParallelComm *pcomm = ParallelComm::get_pcomm(
127 &get_moab(), get_basic_entity_data_ptr()->pcommID);
128 Tag part_tag = pcomm->part_tag();
129 Range tagged_sets;
130 CHKERR get_moab().get_entities_by_type_and_tag(0, MBENTITYSET, &part_tag,
131 tag_vals, 1, tagged_sets,
132 moab::Interface::UNION);
133 for (auto s : tagged_sets)
134 CHKERR get_moab().add_entities(s, &meshset, 1);
136 };
137
138 auto create_tags = [&](auto meshset, auto id) {
140 CHKERR
141 get_moab().tag_set_data(th_FieldId, &meshset, 1, &id);
142 // space
143 CHKERR get_moab().tag_set_data(th_FieldSpace, &meshset, 1, &space);
144 // base
145 CHKERR get_moab().tag_set_data(th_FieldBase, &meshset, 1, &base);
146
147 // name
148 void const *tag_data[] = {name.c_str()};
149 int tag_sizes[1];
150 tag_sizes[0] = name.size();
151 CHKERR get_moab().tag_set_by_ptr(th_FieldName, &meshset, 1, tag_data,
152 tag_sizes);
153 // rank
154 Tag th_rank;
155 int def_rank = 1;
156 const std::string tag_rank_name = "_Field_Rank_" + name;
157 CHKERR get_moab().tag_get_handle(tag_rank_name.c_str(), 1, MB_TYPE_INTEGER,
158 th_rank, MB_TAG_CREAT | MB_TAG_SPARSE,
159 &def_rank);
160 CHKERR get_moab().tag_set_data(th_rank, &meshset, 1, &nb_of_coefficients);
161
162 Version file_ver;
164 CHK_THROW_MESSAGE(ierr, "Not known file version");
165 if (file_ver.majorVersion >= 0 && file_ver.minorVersion >= 12 &&
166 file_ver.buildVersion >= 1) {
167 const std::string name_data_prefix("_App_Data_");
168 void const *tag_prefix_data[] = {name_data_prefix.c_str()};
169 int tag_prefix_sizes[1];
170 tag_prefix_sizes[0] = name_data_prefix.size();
171 CHKERR get_moab().tag_set_by_ptr(th_FieldName_DataNamePrefix, &meshset, 1,
172 tag_prefix_data, tag_prefix_sizes);
173 Tag th_app_order, th_field_data, th_field_data_vert;
174
175 // order
176 ApproximationOrder def_approx_order = -1;
177 const std::string tag_approx_order_name = "_App_Order_" + name;
178 CHKERR get_moab().tag_get_handle(
179 tag_approx_order_name.c_str(), 1, MB_TYPE_INTEGER, th_app_order,
180 MB_TAG_CREAT | MB_TAG_SPARSE, &def_approx_order);
181
182 // data
183 std::string tag_data_name = name_data_prefix + name;
184 const int def_len = 0;
185 CHKERR get_moab().tag_get_handle(
186 tag_data_name.c_str(), def_len, MB_TYPE_DOUBLE, th_field_data,
187 MB_TAG_CREAT | MB_TAG_VARLEN | MB_TAG_SPARSE, NULL);
188 std::string tag_data_name_verts = name_data_prefix + name + "_V";
189 VectorDouble def_vert_data(nb_of_coefficients);
190 def_vert_data.clear();
191 CHKERR get_moab().tag_get_handle(
192 tag_data_name_verts.c_str(), nb_of_coefficients, MB_TYPE_DOUBLE,
193 th_field_data_vert, MB_TAG_CREAT | tag_type, &*def_vert_data.begin());
194 } else {
195 // Deprecated names
196 const std::string name_data_prefix("_App_Data");
197 void const *tag_prefix_data[] = {name_data_prefix.c_str()};
198 int tag_prefix_sizes[1];
199 tag_prefix_sizes[0] = name_data_prefix.size();
200 CHKERR get_moab().tag_set_by_ptr(th_FieldName_DataNamePrefix, &meshset, 1,
201 tag_prefix_data, tag_prefix_sizes);
202 Tag th_app_order, th_field_data, th_field_data_vert;
203
204 // order
205 ApproximationOrder def_approx_order = -1;
206 const std::string tag_approx_order_name = "_App_Order_" + name;
207 CHKERR get_moab().tag_get_handle(
208 tag_approx_order_name.c_str(), 1, MB_TYPE_INTEGER, th_app_order,
209 MB_TAG_CREAT | MB_TAG_SPARSE, &def_approx_order);
210
211 // data
212 std::string tag_data_name = name_data_prefix + name;
213 const int def_len = 0;
214 CHKERR get_moab().tag_get_handle(
215 tag_data_name.c_str(), def_len, MB_TYPE_DOUBLE, th_field_data,
216 MB_TAG_CREAT | MB_TAG_VARLEN | MB_TAG_SPARSE, NULL);
217 std::string tag_data_name_verts = name_data_prefix + name + "V";
218 VectorDouble def_vert_data(nb_of_coefficients);
219 def_vert_data.clear();
220 CHKERR get_moab().tag_get_handle(
221 tag_data_name_verts.c_str(), nb_of_coefficients, MB_TYPE_DOUBLE,
222 th_field_data_vert, MB_TAG_CREAT | tag_type, &*def_vert_data.begin());
223 }
224
226 };
227
228 if (verb == -1)
229 verb = verbose;
230 *buildMoFEM = 0;
231 auto fit = fIelds.get<FieldName_mi_tag>().find(name);
232 if (fit != fIelds.get<FieldName_mi_tag>().end()) {
233 if (bh == MF_EXCL)
234 SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
235 "field is <%s> in database", name.c_str());
236
237 } else {
238
239 EntityHandle meshset;
240 CHKERR get_moab().create_meshset(MESHSET_SET, meshset);
241 CHKERR add_meshset_to_partition(meshset);
242
243 // id
244 int field_shift = 0;
245 for (;
246 fIelds.get<BitFieldId_mi_tag>().find(BitFieldId().set(field_shift)) !=
247 fIelds.get<BitFieldId_mi_tag>().end();
248 ++field_shift) {
249 if (field_shift == BITFEID_SIZE)
250 SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE,
251 "Maximal number of fields exceeded");
252 }
253
254 auto id = BitFieldId().set(field_shift);
255 CHKERR create_tags(meshset, id);
256
257 auto p = fIelds.insert(boost::make_shared<Field>(moab, meshset));
258 if (verb > QUIET) {
259 MOFEM_LOG("WORLD", Sev::inform) << "Add field " << **p.first;
260 MOFEM_LOG("WORLD", Sev::noisy)
261 << "Field " << (*p.first)->getName() << " core value < "
262 << this->getValue() << " > field value ) "
263 << (*p.first)->getBitNumber() << " )";
264 }
265
266 if (!p.second)
267 SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_FOUND,
268 "field not inserted %s (top tip, it could be already "
269 "there)",
270 Field(moab, meshset).getName().c_str());
271 }
272
273 MOFEM_LOG_CHANNEL("WORLD");
274 MOFEM_LOG_CHANNEL("SYNC");
276}
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
Definition: definitions.h:595
@ MOFEM_IMPOSSIBLE_CASE
Definition: definitions.h:35
#define BITFEID_SIZE
max number of finite elements
Definition: definitions.h:221
int ApproximationOrder
Approximation on the entity.
Definition: Types.hpp:26
std::bitset< BITFIELDID_SIZE > BitFieldId
Field Id.
Definition: Types.hpp:42
UBlasVector< double > VectorDouble
Definition: Types.hpp:68
Field_multiIndex fIelds
fields
Definition: Core.hpp:303
Tag th_FieldName_DataNamePrefix
Definition: Core.hpp:260
const int getValue() const
Get the core.
Definition: Core.hpp:85
static MoFEMErrorCode getFileVersion(moab::Interface &moab, Version &version)
Get database major version.

◆ 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
prismprim handle
verbverbosity level
Returns
error code

Definition at line 493 of file Core.cpp.

493 {
495 if (verb == -1)
496 verb = verbose;
497 std::pair<RefEntity_multiIndex::iterator, bool> p_ent;
498 p_ent = refinedEntities.insert(
499 boost::make_shared<RefEntity>(basicEntityDataPtr, prism));
500 if (p_ent.second) {
501 std::pair<RefElement_multiIndex::iterator, bool> p;
502 p = refinedFiniteElements.insert(
503 boost::shared_ptr<RefElement>(new RefElement_PRISM(*p_ent.first)));
504 int num_nodes;
505 const EntityHandle *conn;
506 CHKERR get_moab().get_connectivity(prism, conn, num_nodes, true);
507 Range face_side3, face_side4;
508 CHKERR get_moab().get_adjacencies(conn, 3, 2, false, face_side3);
509 CHKERR get_moab().get_adjacencies(&conn[3], 3, 2, false, face_side4);
510 if (face_side3.size() != 1)
511 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
512 "prism don't have side face 3");
513 if (face_side4.size() != 1)
514 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
515 "prims don't have side face 4");
516 p.first->get()->getSideNumberPtr(*face_side3.begin());
517 p.first->get()->getSideNumberPtr(*face_side4.begin());
518 }
520}
RefEntity_multiIndex refinedEntities
refined entities
Definition: Core.hpp:300

◆ addProblem()

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

add problem

Parameters
idproblem id
nameproblem name
verbverbosity level
Returns
MoFEMErrorCode

Definition at line 27 of file ProblemsCore.cpp.

28 {
30
31 if (verb == -1)
32 verb = verbose;
33 EntityHandle meshset;
34 CHKERR get_moab().create_meshset(MESHSET_SET, meshset);
35 CHKERR get_moab().tag_set_data(th_ProblemId, &meshset, 1, &id);
36
37 // Add problem meshset to partion meshset. In case of no elements
38 // on processor part, when mesh file is read, finite element meshset is
39 // prevented from deletion by moab reader.
40 auto add_meshset_to_partition = [&](auto meshset) {
42 const void *tag_vals[] = {&rAnk};
43 ParallelComm *pcomm = ParallelComm::get_pcomm(
44 &get_moab(), get_basic_entity_data_ptr()->pcommID);
45 Tag part_tag = pcomm->part_tag();
46 Range tagged_sets;
47 CHKERR get_moab().get_entities_by_type_and_tag(0, MBENTITYSET, &part_tag,
48 tag_vals, 1, tagged_sets,
49 moab::Interface::UNION);
50 for (auto s : tagged_sets)
51 CHKERR get_moab().add_entities(s, &meshset, 1);
53 };
54 CHKERR add_meshset_to_partition(meshset);
55
56 void const *tag_data[] = {name.c_str()};
57 int tag_sizes[1];
58 tag_sizes[0] = name.size();
59 CHKERR get_moab().tag_set_by_ptr(th_ProblemName, &meshset, 1, tag_data,
60 tag_sizes);
61 // create entry
62 auto p = pRoblems.insert(Problem(moab, meshset));
63 if (!p.second) {
66 MOFEM_LOG("SELF", Sev::error) << "Following problem can not be added:";
67 MOFEM_LOG("SELF", Sev::error)
68 << "Problem " << name << " id(" << id.to_ulong() << ") " << id
69 << " added meshset " << meshset;
70 MOFEM_LOG("SELF", Sev::error) << "List of problems already in databse:";
71 for (auto &p : pRoblems) {
72 MOFEM_LOG("SELF", Sev::error)
73 << p.getName() << " id(" << p.getId().to_ulong() << ") " << id
74 << " on meshset " << p.meshset;
75 }
76 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Problem not added");
77 }
78
79 MOFEM_LOG("WORLD", Sev::inform) << "Add problem " << name;
80
82}
#define ProblemCoreFunctionBegin
Definition: ProblemsCore.cpp:8
#define MOFEM_LOG_ATTRIBUTES(channel, bit)
Add attributes to channel.
Definition: LogManager.hpp:296

◆ build_adjacencies() [1/3]

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

build adjacencies

Parameters
bitadjacencies for refine level
maskmask 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 817 of file FECore.cpp.

818 {
820 if (verb == -1)
821 verb = verbose;
822 Range ents;
823 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents);
824
825 CHKERR build_adjacencies(ents, verb);
826
828}
MoFEMErrorCode build_adjacencies(const Range &ents, int verb=DEFAULT_VERBOSITY)
build adjacencies
Definition: FECore.cpp:745

◆ build_adjacencies() [2/3]

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

build adjacencies

Parameters
bitadjacencies 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 829 of file FECore.cpp.

829 {
831 if (verb == -1)
832 verb = verbose;
833 CHKERR build_adjacencies(bit, BitRefLevel().set(), verb);
834
836}

◆ build_adjacencies() [3/3]

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

build adjacencies

Parameters
listof 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 745 of file FECore.cpp.

745 {
747 if (verb == DEFAULT_VERBOSITY)
748 verb = verbose;
749
750 if (!((*buildMoFEM) & BUILD_FIELD))
751 SETERRQ(mofemComm, MOFEM_NOT_FOUND, "field not build");
752 if (!((*buildMoFEM) & BUILD_FE))
753 SETERRQ(mofemComm, MOFEM_NOT_FOUND, "fe not build");
754 for (auto peit = ents.pair_begin(); peit != ents.pair_end(); ++peit) {
755 auto fit = entsFiniteElements.get<Ent_mi_tag>().lower_bound(peit->first);
756 auto hi_fit =
757 entsFiniteElements.get<Ent_mi_tag>().upper_bound(peit->second);
758 for (; fit != hi_fit; ++fit) {
759 if ((*fit)->getBitFieldIdRow().none() &&
760 (*fit)->getBitFieldIdCol().none() &&
761 (*fit)->getBitFieldIdData().none())
762 continue;
763 int by = BYROW;
764 if ((*fit)->getBitFieldIdRow() != (*fit)->getBitFieldIdCol())
765 by |= BYCOL;
766 if ((*fit)->getBitFieldIdRow() != (*fit)->getBitFieldIdData())
767 by |= BYDATA;
768 FieldEntityEntFiniteElementAdjacencyMap_change_ByWhat modify_row(by);
769 auto hint = entFEAdjacencies.end();
770 for (auto e : *(*fit)->getRowFieldEntsPtr()) {
771 hint = entFEAdjacencies.emplace_hint(hint, e.lock(), *fit);
772 bool success = entFEAdjacencies.modify(hint, modify_row);
773 if (!success)
774 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
775 "modification unsuccessful");
776 }
777 if ((*fit)->getBitFieldIdRow() != (*fit)->getBitFieldIdCol()) {
778 int by = BYCOL;
779 if ((*fit)->getBitFieldIdCol() != (*fit)->getBitFieldIdData())
780 by |= BYDATA;
781 FieldEntityEntFiniteElementAdjacencyMap_change_ByWhat modify_col(by);
782 auto hint = entFEAdjacencies.end();
783 for (auto e : *(*fit)->getColFieldEntsPtr()) {
784 hint = entFEAdjacencies.emplace_hint(hint, e.lock(), *fit);
785 bool success = entFEAdjacencies.modify(hint, modify_col);
786 if (!success)
787 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
788 "modification unsuccessful");
789 }
790 }
791 if ((*fit)->getBitFieldIdRow() != (*fit)->getBitFieldIdData() ||
792 (*fit)->getBitFieldIdCol() != (*fit)->getBitFieldIdData()) {
793 FieldEntityEntFiniteElementAdjacencyMap_change_ByWhat modify_data(
794 BYDATA);
795 auto hint = entFEAdjacencies.end();
796 for (auto &e : (*fit)->getDataFieldEnts()) {
797 hint = entFEAdjacencies.emplace_hint(hint, e.lock(), *fit);
798 bool success = entFEAdjacencies.modify(hint, modify_data);
799 if (!success)
800 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
801 "modification unsuccessful");
802 }
803 }
804 }
805 }
806
807 if (verb >= VERBOSE) {
808 MOFEM_LOG("WORLD", Sev::inform)
809 << "Number of adjacencies " << entFEAdjacencies.size();
811 }
812
813 *buildMoFEM |= 1 << 2;
815}
@ DEFAULT_VERBOSITY
Definition: definitions.h:207
@ BYCOL
Definition: definitions.h:132
@ BYDATA
Definition: definitions.h:133
@ BYROW
Definition: definitions.h:131
EntFiniteElement_multiIndex entsFiniteElements
finite element entities
Definition: Core.hpp:308
FieldEntityEntFiniteElementAdjacencyMap_multiIndex entFEAdjacencies
adjacencies of elements to dofs
Definition: Core.hpp:311

◆ build_field()

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

build field by name

Parameters
field_name
verbm
Returns
MoFEMErrorCode

Implements MoFEM::CoreInterface.

Definition at line 1249 of file FieldCore.cpp.

1249 {
1251 auto field_it = fIelds.get<FieldName_mi_tag>().find(field_name);
1252 if (field_it == fIelds.get<FieldName_mi_tag>().end())
1253 SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "Field < %s > not found",
1254 field_name.c_str());
1255
1256 CHKERR this->buildField(*field_it, verb);
1257 if (verb > QUIET)
1260}
#define FieldCoreFunctionBegin
Definition: FieldCore.cpp:8
Field_multiIndex::index< FieldName_mi_tag >::type::iterator field_it
constexpr auto field_name
MoFEMErrorCode buildField(const boost::shared_ptr< Field > &field, int verb=DEFAULT_VERBOSITY)
Definition: FieldCore.cpp:1200

◆ build_fields()

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

build fields

Implements MoFEM::CoreInterface.

Definition at line 1262 of file FieldCore.cpp.

1262 {
1264 if (verb == -1)
1265 verb = verbose;
1266
1267 for (auto field : fIelds.get<BitFieldId_mi_tag>())
1268 CHKERR this->buildField(field, verb);
1269
1270 *buildMoFEM = 1 << 0;
1271 if (verb > QUIET) {
1272 MOFEM_LOG("SYNC", Sev::inform) << "Number of dofs " << dofsField.size();
1274 }
1275
1277}
DofEntity_multiIndex dofsField
dofs on fields
Definition: Core.hpp:305

◆ build_finite_elements() [1/3]

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

Definition at line 708 of file FECore.cpp.

708 {
710 SETERRQ(mofemComm, MOFEM_NOT_IMPLEMENTED, "Not yet implemented");
712}
@ MOFEM_NOT_IMPLEMENTED
Definition: definitions.h:32

◆ 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_nameName of finite element
ents_ptrPointer to range of finite elements
verbVerbosity level
Returns
Error code

Implements MoFEM::CoreInterface.

Definition at line 714 of file FECore.cpp.

716 {
718 if (verb == -1)
719 verb = verbose;
720
721 auto fe_miit = finiteElements.get<FiniteElement_name_mi_tag>().find(fe_name);
722 if (fe_miit == finiteElements.get<FiniteElement_name_mi_tag>().end())
723 SETERRQ1(mofemComm, MOFEM_NOT_FOUND, "Finite element <%s> not found",
724 fe_name.c_str());
725
726 CHKERR buildFiniteElements(*fe_miit, ents_ptr, verb);
727
728 if (verb >= VERBOSE) {
729 auto &fe_ents = entsFiniteElements.get<Unique_mi_tag>();
730 auto miit = fe_ents.lower_bound(
731 EntFiniteElement::getLocalUniqueIdCalculate(0, (*fe_miit)->getFEUId()));
732 auto hi_miit =
734 get_id_for_max_type<MBENTITYSET>(), (*fe_miit)->getFEUId()));
735 const auto count = std::distance(miit, hi_miit);
736 MOFEM_LOG("SYNC", Sev::inform) << "Finite element " << fe_name
737 << " added. Nb. of elements added " << count;
739 }
740
741 *buildMoFEM |= 1 << 1;
743}
MoFEMErrorCode buildFiniteElements(const boost::shared_ptr< FiniteElement > &fe, const Range *ents_ptr=NULL, int verb=DEFAULT_VERBOSITY)
Definition: FECore.cpp:462
UId getLocalUniqueIdCalculate() const
Generate UId for finite element entity.

◆ 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
verbVerbosity level
Returns
Error code

Implements MoFEM::CoreInterface.

Definition at line 658 of file FECore.cpp.

658 {
660
661 if (verb == DEFAULT_VERBOSITY)
662 verb = verbose;
663
664 // loop Finite Elements
665 for (auto &fe : finiteElements)
666 CHKERR buildFiniteElements(fe, NULL, verb);
667
668 if (verb > QUIET) {
669
670 auto &fe_ents = entsFiniteElements.get<Unique_mi_tag>();
671 for (auto &fe : finiteElements) {
672 auto miit = fe_ents.lower_bound(
674 auto hi_miit =
676 get_id_for_max_type<MBENTITYSET>(), fe->getFEUId()));
677 const auto count = std::distance(miit, hi_miit);
678 MOFEM_LOG("SYNC", Sev::inform)
679 << "Finite element " << fe->getName()
680 << " added. Nb. of elements added " << count;
681 MOFEM_LOG("SYNC", Sev::noisy) << *fe;
682
683 auto slg = MoFEM::LogManager::getLog("SYNC");
684 for (auto &field : fIelds) {
685 auto rec = slg.open_record(keywords::severity = Sev::verbose);
686 if (rec) {
687 logging::record_ostream strm(rec);
688 strm << "Field " << field->getName() << " on finite element: ";
689 if ((field->getId() & fe->getBitFieldIdRow()).any())
690 strm << "row ";
691 if ((field->getId() & fe->getBitFieldIdCol()).any())
692 strm << "columns ";
693 if ((field->getId() & fe->getBitFieldIdData()).any())
694 strm << "data";
695 strm.flush();
696 slg.push_record(boost::move(rec));
697 }
698 }
699 }
700
702 }
703
704 *buildMoFEM |= 1 << 1;
706}
static LoggerType & getLog(const std::string channel)
Get logger by channel.
Definition: LogManager.cpp:395

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

257 {
259 if (verb == -1)
260 verb = verbose;
261 Problem_multiIndex::iterator p_miit = pRoblems.begin();
262 for (; p_miit != pRoblems.end(); p_miit++) {
263 CHKERR getInterface<ProblemsManager>()->buildProblemOnDistributedMesh(
264 const_cast<Problem *>(&*p_miit), verb);
265 }
267}

◆ build_problems()

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

Definition at line 317 of file ProblemsCore.cpp.

317 {
319 if (verb == -1)
320 verb = verbose;
321 if (!((*buildMoFEM) & BUILD_FIELD))
322 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "fields not build");
323 if (!((*buildMoFEM) & BUILD_FE))
324 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "FEs not build");
325 if (!((*buildMoFEM) & BUILD_ADJ))
326 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "adjacencies not build");
327 // iterate problems
328 Problem_multiIndex::iterator p_miit = pRoblems.begin();
329 for (; p_miit != pRoblems.end(); p_miit++) {
330 Problem *problem_ptr = const_cast<Problem *>(&*p_miit);
331 CHKERR getInterface<ProblemsManager>()->buildProblem(problem_ptr, false,
332 verb);
333 }
336}

◆ buildField()

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

Definition at line 1200 of file FieldCore.cpp.

1201 {
1203 if (verb == -1)
1204 verb = verbose;
1205 if (verb > QUIET)
1206 MOFEM_LOG("SYNC", Sev::verbose) << "Build field " << field->getName();
1207
1208 std::map<EntityType, int> dof_counter;
1209 std::map<EntityType, int> inactive_dof_counter;
1210
1211 // Need to rebuild order table since number of dofs on each order when
1212 // field was created.
1213 if (field->getApproxBase() == USER_BASE)
1214 CHKERR field->rebuildDofsOrderMap();
1215
1216 switch (field->getSpace()) {
1217 case NOFIELD:
1218 CHKERR this->buildFieldForNoField(field->getId(), dof_counter, verb);
1219 break;
1220 case L2:
1221 case H1:
1222 case HCURL:
1223 case HDIV:
1224 CHKERR this->buildFieldForL2H1HcurlHdiv(field->getId(), dof_counter,
1225 inactive_dof_counter, verb);
1226 break;
1227 default:
1228 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
1229 }
1230
1231 if (verb > QUIET) {
1232 int nb_added_dofs = 0;
1233 int nb_inactive_added_dofs = 0;
1234 for (auto const &it : dof_counter) {
1235 MOFEM_LOG("SYNC", Sev::verbose)
1236 << "Nb. of dofs (" << moab::CN::EntityTypeName(it.first) << ") "
1237 << it.second << " (inactive " << inactive_dof_counter[it.first]
1238 << ")";
1239 nb_added_dofs += it.second;
1240 nb_inactive_added_dofs += inactive_dof_counter[it.first];
1241 }
1242 MOFEM_LOG("SYNC", Sev::verbose)
1243 << "Nb. added dofs " << nb_added_dofs << " (number of inactive dofs "
1244 << nb_inactive_added_dofs << " )";
1245 }
1247}
@ USER_BASE
user implemented approximation base
Definition: definitions.h:68
@ NOFIELD
scalar or vector of scalars describe (no true field)
Definition: definitions.h:84
MoFEMErrorCode buildFieldForNoField(const BitFieldId id, std::map< EntityType, int > &dof_counter, int verb=DEFAULT_VERBOSITY)
Definition: FieldCore.cpp:1065
MoFEMErrorCode buildFieldForL2H1HcurlHdiv(const BitFieldId id, std::map< EntityType, int > &dof_counter, std::map< EntityType, int > &inactive_dof_counter, int verb=DEFAULT_VERBOSITY)
Definition: FieldCore.cpp:1088

◆ 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 1088 of file FieldCore.cpp.

1090 {
1092 if (verb == -1)
1093 verb = verbose;
1094
1095 // Find field
1096 auto &set_id = fIelds.get<BitFieldId_mi_tag>();
1097 auto field_it = set_id.find(id);
1098 if (field_it == set_id.end()) {
1099 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "Field not found");
1100 }
1101 const int bit_number = field_it->get()->getBitNumber();
1102 const int rank = field_it->get()->getNbOfCoeffs();
1103
1104 // Ents in the field meshset
1105 Range ents_of_id_meshset;
1106 CHKERR get_moab().get_entities_by_handle((*field_it)->meshSet,
1107 ents_of_id_meshset, false);
1108 if (verb > VERY_NOISY) {
1109 MOFEM_LOG_C("SYNC", Sev::noisy, "Ents in field %s meshset %d",
1110 (*field_it)->getName().c_str(), ents_of_id_meshset.size());
1111 }
1112
1113 for (auto p_eit = ents_of_id_meshset.pair_begin();
1114 p_eit != ents_of_id_meshset.pair_end(); ++p_eit) {
1115
1116 const EntityHandle first = p_eit->first;
1117 const EntityHandle second = p_eit->second;
1118 const auto lo_uid =
1119 FieldEntity::getLoLocalEntityBitNumber(bit_number, first);
1120 const auto hi_uid =
1121 FieldEntity::getHiLocalEntityBitNumber(bit_number, second);
1122
1123 auto feit = entsFields.get<Unique_mi_tag>().lower_bound(lo_uid);
1124 if (feit == entsFields.get<Unique_mi_tag>().end())
1125 continue;
1126 auto hi_feit = entsFields.get<Unique_mi_tag>().upper_bound(hi_uid);
1127
1128 // If there are DOFs in that range is more pragmatic to remove them
1129 // rather than to find sub-ranges or make them inactive
1130 auto dit = dofsField.get<Unique_mi_tag>().lower_bound(lo_uid);
1131 auto hi_dit = dofsField.get<Unique_mi_tag>().upper_bound(hi_uid);
1132 dofsField.get<Unique_mi_tag>().erase(dit, hi_dit);
1133
1134 // Add vertices DOFs by bulk
1135 boost::shared_ptr<std::vector<DofEntity>> dofs_array =
1136 boost::make_shared<std::vector<DofEntity>>(std::vector<DofEntity>());
1137 // Add Sequence of DOFs to sequence container as weak_ptr
1138 int nb_dofs_on_ents = 0;
1139 for (auto tmp_feit = feit; tmp_feit != hi_feit; ++tmp_feit) {
1140 nb_dofs_on_ents += rank * tmp_feit->get()->getOrderNbDofs(
1141 tmp_feit->get()->getMaxOrder());
1142 }
1143
1144 // Reserve memory
1145 dofs_array->reserve(nb_dofs_on_ents);
1146
1147 // Create DOFs
1148 for (; feit != hi_feit; ++feit) {
1149 // Create dofs instances and shared pointers
1150 int DD = 0;
1151 // Loop orders (loop until max entity order is set)
1152 for (int oo = 0; oo <= feit->get()->getMaxOrder(); ++oo) {
1153 // Loop nb. dofs at order oo
1154 for (int dd = 0; dd < feit->get()->getOrderNbDofsDiff(oo); ++dd) {
1155 // Loop rank
1156 for (int rr = 0; rr < rank; ++rr, ++DD) {
1157 dofs_array->emplace_back(*feit, oo, rr, DD);
1158 ++dof_counter[feit->get()->getEntType()];
1159 }
1160 }
1161 }
1162 if (DD > feit->get()->getNbDofsOnEnt()) {
1163 std::ostringstream ss;
1164 ss << "rank " << rAnk << " ";
1165 ss << **feit << std::endl;
1166 SETERRQ3(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
1167 "Expected number of DOFs on entity not equal to number added "
1168 "to database (DD = %d != %d = "
1169 "feit->get()->getNbDofsOnEnt())\n"
1170 "%s",
1171 DD, feit->get()->getNbDofsOnEnt(), ss.str().c_str());
1172 }
1173 }
1174
1175 // Insert into Multi-Index container
1176 int dofs_field_size0 = dofsField.size();
1177 auto hint = dofsField.end();
1178 for (auto &v : *dofs_array)
1179 hint = dofsField.emplace_hint(hint, dofs_array, &v);
1180
1181 // Add Sequence of DOFs to sequence container as weak_ptr
1182 field_it->get()->getDofSequenceContainer().push_back(dofs_array);
1183
1184 // Check data consistency
1185 if (PetscUnlikely(static_cast<int>(dofs_array.use_count()) !=
1186 static_cast<int>(dofs_array->size() + 1))) {
1187 SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
1188 "Wrong use count %d != %d", dofs_array.use_count(),
1189 dofs_array->size() + 1);
1190 }
1191 if (dofs_field_size0 + dofs_array->size() != dofsField.size()) {
1192 SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
1193 "Wrong number of inserted DOFs %d != %d", dofs_array->size(),
1194 dofsField.size() - dofs_field_size0);
1195 }
1196 }
1198}
@ VERY_NOISY
Definition: definitions.h:212
const double v
phase velocity of light in medium (cm/ns)
FieldEntity_multiIndex entsFields
entities on fields
Definition: Core.hpp:304
static UId getLoLocalEntityBitNumber(const char bit_number, const EntityHandle ent)
static UId getHiLocalEntityBitNumber(const char bit_number, const EntityHandle ent)

◆ buildFieldForNoField()

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

Definition at line 1065 of file FieldCore.cpp.

1066 {
1068
1069 if (verb == -1)
1070 verb = verbose;
1071
1072 // find fields
1073 auto field_it = fIelds.get<BitFieldId_mi_tag>().find(id);
1074 if (field_it == fIelds.get<BitFieldId_mi_tag>().end())
1075 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "Field not found");
1076
1077 if (verb > QUIET)
1078 MOFEM_LOG("WORLD", Sev::noisy)
1079 << "Field " << (*field_it)->getName() << " core value < "
1080 << this->getValue() << " > field value () "
1081 << (*field_it)->getBitNumber() << " )";
1082
1083 CHKERR this->buildFieldForNoFieldImpl(*field_it, dof_counter, verb);
1084
1086}
MoFEMErrorCode buildFieldForNoFieldImpl(boost::shared_ptr< Field > field_ptr, std::map< EntityType, int > &dof_counter, int verb)
Definition: FieldCore.cpp:960

◆ buildFieldForNoFieldImpl()

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

Definition at line 960 of file FieldCore.cpp.

962 {
964
965 const auto bit_number = field_ptr->getBitNumber();
966
967 // ents in the field meshset
968 Range ents;
969 CHKERR get_moab().get_entities_by_handle(field_ptr->getMeshset(), ents,
970 false);
971 if (verb > VERBOSE)
972 MOFEM_LOG_C("SYNC", Sev::noisy, "Ents in field %s meshset %d\n",
973 field_ptr->getName().c_str(), ents.size());
974
975 // ent view by field id (in set all MoabEnts has the same FieldId)
976 auto eiit = entsFields.get<Unique_mi_tag>().lower_bound(
977 FieldEntity::getLoBitNumberUId(field_ptr->getBitNumber()));
979 if (eiit != entsFields.get<Unique_mi_tag>().end()) {
980 auto hi_eiit = entsFields.get<Unique_mi_tag>().upper_bound(
981 FieldEntity::getHiBitNumberUId(field_ptr->getBitNumber()));
982 std::copy(eiit, hi_eiit, std::back_inserter(ents_id_view));
983 }
984
985 boost::shared_ptr<const int> zero_order(new const int(0));
986
987 for (auto ent : ents) {
988 // search if field meshset is in database
989 auto ref_ent_it = refinedEntities.get<Ent_mi_tag>().find(ent);
990 if (ref_ent_it == refinedEntities.get<Ent_mi_tag>().end())
991 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
992 "Entity is not in MoFEM database, entities in field meshset need "
993 "to be seeded (i.e. bit ref level add to them)");
994
995 auto add_dofs = [&](auto field_eit) {
997 // create dofs on this entity (nb. of dofs is equal to rank)
998 for (FieldCoefficientsNumber rank = 0; rank < field_ptr->getNbOfCoeffs();
999 rank++) {
1000 // insert dof
1001 auto p = dofsField.insert(
1002 boost::make_shared<DofEntity>(field_eit, 0, rank, rank));
1003 if (p.second) {
1004 dof_counter[MBENTITYSET]++; // Count entities in the meshset
1005 } else
1006 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
1007 "Dof expected to be created");
1008 }
1010 };
1011
1012 // create database entity
1013 auto field_ent_it = ents_id_view.get<1>().find(ent);
1014 if (field_ent_it == ents_id_view.get<1>().end()) {
1015
1016 auto p = entsFields.insert(
1017
1018 boost::make_shared<FieldEntity>(
1019 field_ptr, *ref_ent_it,
1021 *ref_ent_it),
1022 boost::shared_ptr<const int>(zero_order, zero_order.get()))
1023
1024 );
1025
1026 if ((*p.first)->getFieldRawPtr() != field_ptr.get())
1027 SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
1028 "Get field ent poiter and field pointer do not match for "
1029 "field %s",
1030 field_ptr->getName().c_str());
1031
1032 if (!p.second)
1033 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
1034 "Entity should be created");
1035
1036 CHKERR add_dofs(*(p.first));
1037
1038 } else {
1039
1040 // If there are DOFs in that range is more pragmatic to remove them
1041 // rather than to find sub-ranges or make them inactive
1042 auto dit = dofsField.get<Unique_mi_tag>().lower_bound(
1044 auto hi_dit = dofsField.get<Unique_mi_tag>().upper_bound(
1046 dofsField.get<Unique_mi_tag>().erase(dit, hi_dit);
1047 CHKERR add_dofs(*field_ent_it);
1048 }
1049 }
1050
1051 if (verb > VERBOSE) {
1052 auto lo_dof = dofsField.get<Unique_mi_tag>().lower_bound(
1053 FieldEntity::getLoBitNumberUId(field_ptr->getBitNumber()));
1054 auto hi_dof = dofsField.get<Unique_mi_tag>().upper_bound(
1055 FieldEntity::getHiBitNumberUId(field_ptr->getBitNumber()));
1056 for (; lo_dof != hi_dof; lo_dof++)
1057 MOFEM_LOG("SYNC", Sev::noisy) << **lo_dof;
1059 }
1060
1062}
#define MOFEM_LOG_SEVERITY_SYNC(comm, severity)
Synchronise "SYNC" on curtain severity level.
Definition: LogManager.hpp:352
int FieldCoefficientsNumber
Number of field coefficients.
Definition: Types.hpp:27
multi_index_container< boost::shared_ptr< FieldEntity >, indexed_by< sequenced<>, ordered_non_unique< tag< Ent_mi_tag >, const_mem_fun< FieldEntity::interface_type_RefEntity, EntityHandle, &FieldEntity::getEnt > > > > FieldEntity_multiIndex_ent_view
static UId getHiBitNumberUId(const FieldBitNumber bit_number)
static boost::shared_ptr< FieldData *const > makeSharedFieldDataAdaptorPtr(const boost::shared_ptr< Field > &field_ptr, const boost::shared_ptr< RefEntity > &ref_ents_ptr)
Return shared pointer to entity field data vector adaptor.
static UId getLoBitNumberUId(const FieldBitNumber bit_number)

◆ buildFiniteElements()

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

Definition at line 462 of file FECore.cpp.

463 {
465 if (verb == DEFAULT_VERBOSITY)
466 verb = verbose;
467
468 if (verb > QUIET)
469 MOFEM_LOG("SYNC", Sev::verbose)
470 << "Build Finite Elements " << fe->getName();
471
472 auto &fields_by_id = fIelds.get<BitFieldId_mi_tag>();
473
474 // Get id of mofem fields for row, col and data
475 enum IntLoop { ROW = 0, COL, DATA, LAST };
476 std::array<BitFieldId, LAST> fe_fields = {fe.get()->getBitFieldIdRow(),
477 fe.get()->getBitFieldIdCol(),
478 fe.get()->getBitFieldIdData()};
479
480 // Get finite element meshset
481 EntityHandle meshset = get_finite_element_meshset(fe.get()->getId());
482
483 // Get entities from finite element meshset // if meshset
484 Range fe_ents;
485 CHKERR get_moab().get_entities_by_handle(meshset, fe_ents, false);
486
487 if (ents_ptr)
488 fe_ents = intersect(fe_ents, *ents_ptr);
489
490 // Map entity uid to pointers
491 typedef std::vector<boost::weak_ptr<EntFiniteElement>> VecOfWeakFEPtrs;
492 VecOfWeakFEPtrs processed_fes;
493 processed_fes.reserve(fe_ents.size());
494
495 int last_data_field_ents_view_size = 0;
496 int last_row_field_ents_view_size = 0;
497 int last_col_field_ents_view_size = 0;
498
499 // Entities adjacent to entities
500 std::vector<EntityHandle> adj_ents;
501
502 // Loop meshset finite element ents and add finite elements
503 for (Range::const_pair_iterator peit = fe_ents.const_pair_begin();
504 peit != fe_ents.const_pair_end(); peit++) {
505
506 const auto first = peit->first;
507 const auto second = peit->second;
508
509 // Find range of ref entities that is sequence
510 // note: iterator is a wrapper
511 // check if is in refinedFiniteElements database
512 auto ref_fe_miit =
513 refinedFiniteElements.get<Ent_mi_tag>().lower_bound(first);
514 if (ref_fe_miit == refinedFiniteElements.get<Ent_mi_tag>().end()) {
515 std::ostringstream ss;
516 ss << "refinedFiniteElements not in database ent = " << first << " type "
517 << type_from_handle(first) << " " << *fe;
518 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, ss.str().c_str());
519 }
520 auto hi_ref_fe_miit =
521 refinedFiniteElements.get<Ent_mi_tag>().upper_bound(second);
522
523 EntFiniteElement_multiIndex::iterator hint_p = entsFiniteElements.end();
524 for (; ref_fe_miit != hi_ref_fe_miit; ref_fe_miit++) {
525
526 // Add finite element to database
527 hint_p = entsFiniteElements.emplace_hint(
528 hint_p, boost::make_shared<EntFiniteElement>(*ref_fe_miit, fe));
529 processed_fes.emplace_back(*hint_p);
530 auto fe_raw_ptr = hint_p->get();
531
532 // Allocate space for entities view
533 bool row_as_data = false, col_as_row = false;
534 if (fe_fields[DATA] == fe_fields[ROW])
535 row_as_data = true;
536 if (fe_fields[ROW] == fe_fields[COL])
537 col_as_row = true;
538
539 fe_raw_ptr->getDataFieldEntsPtr()->reserve(
540 last_data_field_ents_view_size);
541
542 if (row_as_data) {
543 fe_raw_ptr->getRowFieldEntsPtr() = fe_raw_ptr->getDataFieldEntsPtr();
544 } else {
545 // row and col are different
546 if (fe_raw_ptr->getRowFieldEntsPtr() ==
547 fe_raw_ptr->getDataFieldEntsPtr())
548 fe_raw_ptr->getRowFieldEntsPtr() =
549 boost::make_shared<FieldEntity_vector_view>();
550 fe_raw_ptr->getRowFieldEntsPtr()->reserve(
551 last_row_field_ents_view_size);
552 }
553
554 if (row_as_data && col_as_row) {
555 fe_raw_ptr->getColFieldEntsPtr() = fe_raw_ptr->getDataFieldEntsPtr();
556 } else if (col_as_row) {
557 fe_raw_ptr->getColFieldEntsPtr() = fe_raw_ptr->getRowFieldEntsPtr();
558 } else {
559 if (
560
561 fe_raw_ptr->getColFieldEntsPtr() ==
562 fe_raw_ptr->getRowFieldEntsPtr() ||
563 fe_raw_ptr->getColFieldEntsPtr() ==
564 fe_raw_ptr->getDataFieldEntsPtr()
565
566 )
567 fe_raw_ptr->getColFieldEntsPtr() =
568 boost::make_shared<FieldEntity_vector_view>();
569 fe_raw_ptr->getColFieldEntsPtr()->reserve(
570 last_col_field_ents_view_size);
571 }
572
573 // Iterate over all field and check which one is on the element
574 for (unsigned int ii = 0; ii != BitFieldId().size(); ++ii) {
575
576 // Common field id for ROW, COL and DATA
577 BitFieldId id_common = 0;
578 // Check if the field (ii) is added to finite element
579 for (int ss = 0; ss < LAST; ss++) {
580 id_common |= fe_fields[ss] & BitFieldId().set(ii);
581 }
582 if (id_common.none())
583 continue;
584
585 // Find in database data associated with the field (ii)
586 const BitFieldId field_id = BitFieldId().set(ii);
587 auto miit = fields_by_id.find(field_id);
588 if (miit == fields_by_id.end())
589 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Field not found");
590 auto field_bit_number = (*miit)->getBitNumber();
591
592 // Loop over adjacencies of element and find field entities on those
593 // adjacencies, that create hash map map_uid_fe which is used later
594 const std::string field_name = miit->get()->getName();
595 const bool add_to_data = (field_id & fe_fields[DATA]).any();
596 const bool add_to_row = (field_id & fe_fields[ROW]).any();
597 const bool add_to_col = (field_id & fe_fields[COL]).any();
598
599 // Resolve entities on element, those entities are used to build tag
600 // with dof uids on finite element tag
601 adj_ents.clear();
602 CHKERR fe_raw_ptr->getElementAdjacency(*miit, adj_ents);
603
604 for (auto ent : adj_ents) {
605
606 auto dof_it = entsFields.get<Unique_mi_tag>().find(
607 FieldEntity::getLocalUniqueIdCalculate(field_bit_number, ent));
608 if (dof_it != entsFields.get<Unique_mi_tag>().end()) {
609
610 if (add_to_data) {
611 fe_raw_ptr->getDataFieldEntsPtr()->emplace_back(*dof_it);
612 }
613 if (add_to_row && !row_as_data) {
614 fe_raw_ptr->getRowFieldEntsPtr()->emplace_back(*dof_it);
615 }
616 if (add_to_col && !col_as_row) {
617 fe_raw_ptr->getColFieldEntsPtr()->emplace_back(*dof_it);
618 }
619
620 }
621 }
622 }
623
624 // Sort field ents by uid
625 auto uid_comp = [](const auto &a, const auto &b) {
626 return a.lock()->getLocalUniqueId() < b.lock()->getLocalUniqueId();
627 };
628
629 // Sort all views
630
631 // Data
632 sort(fe_raw_ptr->getDataFieldEntsPtr()->begin(),
633 fe_raw_ptr->getDataFieldEntsPtr()->end(), uid_comp);
634 last_data_field_ents_view_size =
635 fe_raw_ptr->getDataFieldEntsPtr()->size();
636
637 // Row
638 if (!row_as_data) {
639 sort(fe_raw_ptr->getRowFieldEntsPtr()->begin(),
640 fe_raw_ptr->getRowFieldEntsPtr()->end(), uid_comp);
641 last_row_field_ents_view_size =
642 fe_raw_ptr->getRowFieldEntsPtr()->size();
643 }
644
645 // Column
646 if (!col_as_row) {
647 sort(fe_raw_ptr->getColFieldEntsPtr()->begin(),
648 fe_raw_ptr->getColFieldEntsPtr()->end(), uid_comp);
649 last_col_field_ents_view_size =
650 fe_raw_ptr->getColFieldEntsPtr()->size();
651 }
652 }
653 }
654
656}
constexpr double a
@ COL
Definition: definitions.h:123
@ DATA
Definition: definitions.h:123
@ ROW
Definition: definitions.h:123
auto type_from_handle(const EntityHandle h)
get type from entity handle
Definition: Templates.hpp:1869
UId getLocalUniqueIdCalculate()
Get the Local Unique Id Calculate object.

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

799 {
801
802 if (auto cache_ptr = cache_weak_ptr.lock()) {
803 auto p_miit = pRoblems.get<Problem_mi_tag>().find(prb_name);
804 if (p_miit == pRoblems.get<Problem_mi_tag>().end())
805 SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "problem not in database %s",
806 prb_name.c_str());
807
808 const BitRefLevel &prb_bit = p_miit->getBitRefLevel();
809 const BitRefLevel &prb_mask = p_miit->getBitRefLevelMask();
810 const BitFEId &prb_fe_id = p_miit->getBitFEId();
811
812 auto &row_dofs = p_miit->numeredRowDofsPtr;
813 auto &col_dofs = p_miit->numeredColDofsPtr;
814
815 auto &cache_data = std::get<0>(*cache_ptr);
816 auto &cache_row = std::get<1>(*cache_ptr);
817 auto &cache_col = std::get<2>(*cache_ptr);
818
819 cache_row.resize(entsFields.size());
820 if (row_dofs != col_dofs)
821 cache_col.resize(entsFields.size());
822 cache_data.resize(entsFields.size());
823
824 size_t idx = 0;
825 for (auto it = entsFields.begin(); it != entsFields.end(); ++it, ++idx) {
826
827 const auto uid = (*it)->getLocalUniqueId();
828 auto r = entFEAdjacencies.get<Unique_mi_tag>().equal_range(uid);
829 for (auto lo = r.first; lo != r.second; ++lo) {
830
831 if ((lo->getBitFEId() & prb_fe_id).any()) {
832
833 const BitRefLevel &fe_bit = lo->entFePtr->getBitRefLevel();
834
835 // if entity is not problem refinement level
836 if (((fe_bit & prb_mask) != fe_bit) || ((fe_bit & prb_bit).none()))
837 continue;
838
839 auto cache_numered_dofs = [&](auto &numered_dofs, auto &cache_vec,
840 auto &ent_cache) {
841 auto dit = numered_dofs->lower_bound(uid);
842 decltype(dit) hi_dit;
843 if (dit != numered_dofs->end())
844 hi_dit = numered_dofs->upper_bound(
845 uid | static_cast<UId>(MAX_DOFS_ON_ENTITY - 1));
846 else
847 hi_dit = dit;
848
849 ent_cache = boost::shared_ptr<EntityCacheNumeredDofs>(
850 cache_ptr, &(cache_vec[idx]));
851 cache_vec[idx].loHi = {dit, hi_dit};
852 };
853
854 auto cache_dofs = [&](auto &dofs, auto &cache_vec, auto &ent_cache) {
855 auto dit = dofs.lower_bound(uid);
856 decltype(dit) hi_dit;
857 if (dit != dofs.end())
858 hi_dit = dofs.upper_bound(
859 uid | static_cast<UId>(MAX_DOFS_ON_ENTITY - 1));
860 else
861 hi_dit = dit;
862
863 ent_cache = boost::shared_ptr<EntityCacheDofs>(cache_ptr,
864 &(cache_vec[idx]));
865 cache_vec[idx].loHi = {dit, hi_dit};
866 };
867
868 cache_numered_dofs(row_dofs, cache_row, (*it)->entityCacheRowDofs);
869 if (row_dofs != col_dofs) {
870 if (cache_col.size() != entsFields.size())
871 cache_col.resize(entsFields.size());
872 cache_numered_dofs(col_dofs, cache_col, (*it)->entityCacheColDofs);
873 } else {
874 (*it)->entityCacheColDofs = (*it)->entityCacheRowDofs;
875 }
876
877 cache_dofs(dofsField, cache_data, (*it)->entityCacheDataDofs);
878
879 break;
880 }
881 }
882 }
883 } else {
884 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Cache not allocated");
885 }
886
888}
#define MAX_DOFS_ON_ENTITY
Maximal number of DOFs on entity.
Definition: definitions.h:236
uint128_t UId
Unique Id.
Definition: Types.hpp:31
int r
Definition: sdf.py:8

◆ check_field()

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

check if field is in database

Parameters
namefield name
Returns
true if field exist

Implements MoFEM::CoreInterface.

Definition at line 57 of file FieldCore.cpp.

57 {
58 auto miit = fIelds.get<FieldName_mi_tag>().find(name);
59 if (miit == fIelds.get<FieldName_mi_tag>().end())
60 return false;
61 else
62 return true;
63}

◆ check_finite_element()

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

Check if finite element is in database.

Parameters
nameName of finite element
Returns
true if element is declared

Implements MoFEM::CoreInterface.

Definition at line 35 of file FECore.cpp.

35 {
36 auto miit = finiteElements.get<FiniteElement_name_mi_tag>().find(name);
37 if (miit == finiteElements.get<FiniteElement_name_mi_tag>().end())
38 return false;
39 else
40 return true;
41}

◆ 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 1381 of file FieldCore.cpp.

1381 {
1383 for (auto &it : fIelds.get<FieldName_mi_tag>()) {
1384 if (it->getSpace() == NOFIELD)
1385 continue; // FIXME: should be treated properly, not test is just
1386 // skipped for this NOFIELD space
1387 EntityHandle meshset = it->getMeshset();
1388 int num_entities;
1389 CHKERR get_moab().get_number_entities_by_handle(meshset, num_entities);
1390
1391 auto count_field_ents = [&]() {
1392 auto bit_number = it->getBitNumber();
1393 auto low_eit = entsFields.get<Unique_mi_tag>().lower_bound(
1394 FieldEntity::getLoBitNumberUId(bit_number));
1395 auto hi_eit = entsFields.get<Unique_mi_tag>().upper_bound(
1396 FieldEntity::getHiBitNumberUId(bit_number));
1397 return std::distance(low_eit, hi_eit);
1398 };
1399
1400 if (count_field_ents() > (unsigned int)num_entities) {
1401 SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
1402 "not equal number of entities in meshset and field "
1403 "multiindex < %s >",
1404 it->getName().c_str());
1405 }
1406 }
1408}

◆ 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 1353 of file FieldCore.cpp.

1353 {
1355 auto it = fIelds.get<FieldName_mi_tag>().find(name);
1356 if (it == fIelds.get<FieldName_mi_tag>().end()) {
1357 SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
1358 "field not found < %s >", name.c_str());
1359 }
1360 EntityHandle meshset = (*it)->getMeshset();
1361 int num_entities;
1362 CHKERR get_moab().get_number_entities_by_handle(meshset, num_entities);
1363
1364 auto count_field_ents = [&]() {
1365 auto bit_number = (*it)->getBitNumber();
1366 auto low_eit = entsFields.get<Unique_mi_tag>().lower_bound(
1367 FieldEntity::getLoBitNumberUId(bit_number));
1368 auto hi_eit = entsFields.get<Unique_mi_tag>().upper_bound(
1369 FieldEntity::getHiBitNumberUId(bit_number));
1370 return std::distance(low_eit, hi_eit);
1371 };
1372
1373 if (count_field_ents() > (unsigned int)num_entities) {
1374 SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
1375 "not equal number of entities in meshset and field multiindex "
1376 "< %s >",
1377 name.c_str());
1378 }
1380}

◆ 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 888 of file FECore.cpp.

888 {
890 FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type::iterator it;
891 it = finiteElements.get<FiniteElement_name_mi_tag>().begin();
892 for (; it != finiteElements.get<FiniteElement_name_mi_tag>().end(); it++) {
893 EntityHandle meshset = (*it)->getMeshset();
894
895 int num_entities;
896 CHKERR get_moab().get_number_entities_by_handle(meshset, num_entities);
897
898 auto counts_fes = [&]() {
899 return std::distance(get_fe_by_name_begin((*it)->getName()),
900 get_fe_by_name_end((*it)->getName()));
901 };
902
903 if (counts_fes() != static_cast<size_t>(num_entities)) {
905 "not equal number of entities in meshset and finite elements "
906 "multiindex < %s >",
907 (*it)->getName().c_str());
908 }
909 }
911}
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(MF...
Definition: FECore.cpp:850
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(...
Definition: FECore.cpp:839

◆ 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 861 of file FECore.cpp.

862 {
864 FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type::iterator it;
865 it = finiteElements.get<FiniteElement_name_mi_tag>().find(name);
866 if (it == finiteElements.get<FiniteElement_name_mi_tag>().end()) {
867 SETERRQ1(mofemComm, 1, "finite element not found < %s >", name.c_str());
868 }
869 EntityHandle meshset = (*it)->getMeshset();
870
871 int num_entities;
872 CHKERR get_moab().get_number_entities_by_handle(meshset, num_entities);
873
874 auto counts_fes = [&]() {
875 return std::distance(get_fe_by_name_begin((*it)->getName()),
876 get_fe_by_name_end((*it)->getName()));
877 };
878
879 if (counts_fes() != static_cast<size_t>(num_entities)) {
881 "not equal number of entities in meshset and finite elements "
882 "multiindex < %s >",
883 (*it)->getName().c_str());
884 }
886}

◆ check_problem()

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

check if problem exist

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

203 {
205 if (verb == -1)
206 verb = verbose;
207 Range ents;
208 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
211}
MoFEMErrorCode clear_adjacencies_entities(const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
clear adjacency map for entities on given bit level
Definition: DeleteCore.cpp:201

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

213 {
215 if (verb == -1)
216 verb = verbose;
217 for (Range::const_pair_iterator p_eit = ents.pair_begin();
218 p_eit != ents.pair_end(); ++p_eit) {
219 const EntityHandle first = p_eit->first;
220 const EntityHandle second = p_eit->second;
221 FieldEntityEntFiniteElementAdjacencyMap_multiIndex::index<
222 Ent_mi_tag>::type::iterator ait,
223 hi_ait;
224 ait = entFEAdjacencies.get<Ent_mi_tag>().lower_bound(first);
225 hi_ait = entFEAdjacencies.get<Ent_mi_tag>().upper_bound(second);
226 entFEAdjacencies.get<Ent_mi_tag>().erase(ait, hi_ait);
227 }
229}

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

232 {
234 if (verb == -1)
235 verb = verbose;
236
237 const Field *field_ptr = get_field_structure(name);
238 int field_bit_number = field_ptr->getBitNumber();
239
240 for (Range::const_pair_iterator p_eit = ents.pair_begin();
241 p_eit != ents.pair_end(); p_eit++) {
242
243 // First and last handle
244 const EntityHandle first = p_eit->first;
245 const EntityHandle second = p_eit->second;
246
247 // Get UId
248 UId first_uid =
249 FieldEntity::getLocalUniqueIdCalculate(field_bit_number, first);
250 UId second_uid =
251 FieldEntity::getLocalUniqueIdCalculate(field_bit_number, second);
252
253 // Find adjacencies
254 auto ait = entFEAdjacencies.get<Unique_mi_tag>().lower_bound(first_uid);
255 auto hi_ait = entFEAdjacencies.get<Unique_mi_tag>().upper_bound(second_uid);
256 entFEAdjacencies.get<Unique_mi_tag>().erase(ait, hi_ait);
257 }
259}
const Field * get_field_structure(const std::string &name, enum MoFEMTypes bh=MF_EXIST) const
get field structure
Definition: FieldCore.cpp:65

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

314 {
316 Range ents;
317 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
320}
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
Definition: DeleteCore.cpp:312

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

323 {
325 if (verb == -1)
326 verb = verbose;
327 for (Range::const_pair_iterator p_eit = ents.pair_begin();
328 p_eit != ents.pair_end(); p_eit++) {
329 EntityHandle first = p_eit->first;
330 EntityHandle second = p_eit->second;
331 FieldEntityEntFiniteElementAdjacencyMap_multiIndex::index<
332 FEEnt_mi_tag>::type::iterator ait,
333 hi_ait;
334 ait = entFEAdjacencies.get<FEEnt_mi_tag>().lower_bound(first);
335 hi_ait = entFEAdjacencies.get<FEEnt_mi_tag>().upper_bound(second);
336 entFEAdjacencies.get<FEEnt_mi_tag>().erase(ait, hi_ait);
337 }
339}

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

343 {
345 if (verb == -1)
346 verb = verbose;
347
348 FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type::iterator
349 it_fe = finiteElements.get<FiniteElement_name_mi_tag>().find(name);
350 if (it_fe != finiteElements.get<FiniteElement_name_mi_tag>().end()) {
351
352 const auto fe_uid = (*it_fe)->getFEUId();
353
354 for (Range::const_pair_iterator p_eit = ents.pair_begin();
355 p_eit != ents.pair_end(); p_eit++) {
356
357 // First and last handle
358 const EntityHandle first = p_eit->first;
359 const EntityHandle second = p_eit->second;
360
361 // Get UId
362 UId first_uid =
364 UId second_uid =
366
367 // Find and remove adjacencies
368 FieldEntityEntFiniteElementAdjacencyMap_multiIndex::index<
369 FE_Unique_mi_tag>::type::iterator ait,
370 hi_ait;
371 ait = entFEAdjacencies.get<FE_Unique_mi_tag>().lower_bound(first_uid);
372 hi_ait = entFEAdjacencies.get<FE_Unique_mi_tag>().upper_bound(second_uid);
373 entFEAdjacencies.get<FE_Unique_mi_tag>().erase(ait, hi_ait);
374 }
375 }
377}

◆ clear_database()

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

Clear database.

Parameters
verbVerbosity level
Returns
Error code

Implements MoFEM::CoreInterface.

Definition at line 694 of file Core.cpp.

694 {
696 if (verb == -1)
697 verb = verbose;
700}

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

57 {
59 if (verb == -1)
60 verb = verbose;
61
62 for (Range::const_pair_iterator p_eit = ents.pair_begin();
63 p_eit != ents.pair_end(); p_eit++) {
64 EntityHandle first = p_eit->first;
65 EntityHandle second = p_eit->second;
66 // get dofs range
67 DofEntityByEnt::iterator dit, hi_dit;
68 dit = dofsField.get<Ent_mi_tag>().lower_bound(first);
69 if (dit == dofsField.get<Ent_mi_tag>().end())
70 continue;
71 hi_dit = dofsField.get<Ent_mi_tag>().upper_bound(second);
72 // finally clear dofs
73 dofsField.get<Ent_mi_tag>().erase(dit, hi_dit);
74 }
76}

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

79 {
81 if (verb == -1)
82 verb = verbose;
83
84 const auto bit_number = get_field_bit_number(name);
85
86 for (Range::const_pair_iterator p_eit = ents.pair_begin();
87 p_eit != ents.pair_end(); p_eit++) {
88 const auto first = p_eit->first;
89 const auto second = p_eit->second;
90 const auto lo_uid = DofEntity::getLoFieldEntityUId(bit_number, first);
91 const auto hi_uid = DofEntity::getHiFieldEntityUId(bit_number, second);
92 auto dit = dofsField.get<Unique_mi_tag>().lower_bound(lo_uid);
93 auto hi_dit = dofsField.get<Unique_mi_tag>().upper_bound(hi_uid);
94 dofsField.get<Unique_mi_tag>().erase(dit, hi_dit);
95 }
97}
FieldBitNumber get_field_bit_number(const std::string name) const
get field bit number
Definition: FieldCore.cpp:28
static UId getLoFieldEntityUId(const FieldBitNumber bit, const EntityHandle ent)
static UId getHiFieldEntityUId(const FieldBitNumber bit, const EntityHandle ent)

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

47 {
49 if (verb == -1)
50 verb = verbose;
51 Range ents;
52 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
53 CHKERR clear_dofs_fields(ents, verb);
55}
MoFEMErrorCode clear_dofs_fields(const Range ents, int verb=DEFAULT_VERBOSITY)
Definition: DeleteCore.cpp:57

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

113 {
115 if (verb == -1)
116 verb = verbose;
117 CHKERR clear_dofs_fields(ents, verb);
119 for (Range::const_pair_iterator p_eit = ents.pair_begin();
120 p_eit != ents.pair_end(); p_eit++) {
121 EntityHandle first = p_eit->first;
122 EntityHandle second = p_eit->second;
123 FieldEntity_multiIndex::index<Ent_mi_tag>::type::iterator dit, hi_dit;
124 dit = entsFields.get<Ent_mi_tag>().lower_bound(first);
125 hi_dit = entsFields.get<Ent_mi_tag>().upper_bound(second);
126 entsFields.get<Ent_mi_tag>().erase(dit, hi_dit);
127 }
129}

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

132 {
134 if (verb == -1)
135 verb = verbose;
136 const auto bit_number = get_field_bit_number(name);
137 CHKERR clear_dofs_fields(name, ents, verb);
138 CHKERR clear_adjacencies_entities(name, ents, verb);
139 for (Range::const_pair_iterator p_eit = ents.pair_begin();
140 p_eit != ents.pair_end(); p_eit++) {
141 const auto first = p_eit->first;
142 const auto second = p_eit->second;
143 auto dit = entsFields.get<Unique_mi_tag>().lower_bound(
144 FieldEntity::getLocalUniqueIdCalculate(bit_number, first));
145 auto hi_dit = entsFields.get<Unique_mi_tag>().upper_bound(
146 FieldEntity::getLocalUniqueIdCalculate(bit_number, second));
147 entsFields.get<Unique_mi_tag>().erase(dit, hi_dit);
148 }
150}

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

101 {
103 if (verb == -1)
104 verb = verbose;
105 Range ents;
106 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
107 CHKERR clear_dofs_fields(ents, verb);
109 CHKERR clear_ents_fields(ents, verb);
111}
MoFEMErrorCode clear_ents_fields(const Range ents, int verb=DEFAULT_VERBOSITY)
Definition: DeleteCore.cpp:113

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

273 {
275 if (verb == -1)
276 verb = verbose;
278 for (Range::const_pair_iterator p_eit = ents.pair_begin();
279 p_eit != ents.pair_end(); p_eit++) {
280 EntityHandle first = p_eit->first;
281 EntityHandle second = p_eit->second;
282 EntFiniteElement_multiIndex::index<Ent_mi_tag>::type::iterator fit, hi_fit;
283 fit = entsFiniteElements.get<Ent_mi_tag>().lower_bound(first);
284 hi_fit = entsFiniteElements.get<Ent_mi_tag>().upper_bound(second);
285 entsFiniteElements.get<Ent_mi_tag>().erase(fit, hi_fit);
286 }
288}

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

291 {
293 if (verb == -1)
294 verb = verbose;
295 CHKERR clear_adjacencies_finite_elements(fe_name, ents, verb);
296 auto fe_miit = finiteElements.get<FiniteElement_name_mi_tag>().find(fe_name);
297 if (fe_miit == finiteElements.get<FiniteElement_name_mi_tag>().end()) {
298 for (Range::const_pair_iterator p_eit = ents.pair_begin();
299 p_eit != ents.pair_end(); p_eit++) {
300 auto fit = entsFiniteElements.get<Unique_mi_tag>().lower_bound(
302 (*fe_miit)->getFEUId()));
303 auto hi_fit = entsFiniteElements.get<Unique_mi_tag>().upper_bound(
305 (*fe_miit)->getFEUId()));
306 fit = entsFiniteElements.get<Unique_mi_tag>().erase(fit, hi_fit);
307 }
308 }
310}

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

263 {
265 if (verb == -1)
266 verb = verbose;
267 Range ents;
268 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
269 CHKERR clear_finite_elements(ents, verb);
271}
MoFEMErrorCode clear_finite_elements(const Range &ents, int verb=DEFAULT_VERBOSITY)
Definition: DeleteCore.cpp:273

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

29 {
31 if (verb == -1)
32 verb = verbose;
33 Range ents;
34 for (DofEntity_multiIndex::iterator dit = dofsField.begin();
35 dit != dofsField.end();) {
36 if (!dit->get()->getActive()) {
37 dit = dofsField.erase(dit);
38 } else {
39 ++dit;
40 }
41 }
43}

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

269 {
271 if (verb == -1)
272 verb = verbose;
273 typedef Problem_multiIndex::index<Problem_mi_tag>::type ProblemsByName;
274 ProblemsByName &prob_by_name = pRoblems.get<Problem_mi_tag>();
275 ProblemsByName::iterator p_miit = prob_by_name.find(problem_name);
276 if (p_miit == prob_by_name.end()) {
277 SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
278 "problem < %s > not found, (top tip: check spelling)",
279 problem_name.c_str());
280 }
281 // zero rows
282 bool success = prob_by_name.modify(p_miit, ProblemZeroNbRowsChange());
283 if (!success)
284 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
285 "modification unsuccessful");
286 // zero cols
287 success = prob_by_name.modify(p_miit, ProblemZeroNbColsChange());
288 if (!success)
289 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
290 "modification unsuccessful");
291 // clear finite elements
292 success =
293 prob_by_name.modify(p_miit, ProblemClearNumeredFiniteElementsChange());
294 if (!success)
295 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
296 "modification unsuccessful");
297 // clear data structures
298 success = prob_by_name.modify(p_miit, ProblemClearSubProblemData());
299 if (!success)
300 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
301 "modification unsuccessful");
302 success = prob_by_name.modify(p_miit, ProblemClearComposedProblemData());
303 if (!success)
304 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
305 "modification unsuccessful");
306 if (p_miit->getRowDofsSequence())
307 p_miit->getRowDofsSequence()->clear();
308 if (p_miit->getColDofsSequence())
309 p_miit->getColDofsSequence()->clear();
310 if (p_miit->getSubData())
311 p_miit->getSubData().reset();
312 if (p_miit->getComposedProblemsData())
313 p_miit->getComposedProblemsData().reset();
315}

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

338 {
340 if (verb == -1)
341 verb = verbose;
342 // iterate problems
343 for (auto p_miit = pRoblems.begin(); p_miit != pRoblems.end(); p_miit++)
344 CHKERR clear_problem(p_miit->getName(), verb);
346}
MoFEMErrorCode clear_problem(const std::string name, int verb=DEFAULT_VERBOSITY)
clear problem

◆ clearMap()

MoFEMErrorCode MoFEM::Core::clearMap ( )
protected

Cleaning database.

Definition at line 474 of file Core.cpp.

474 {
476 // Cleaning databases in interfaces
477 CHKERR getInterface<SeriesRecorder>()->clearMap();
478 CHKERR getInterface<MeshsetsManager>()->clearMap();
479 CHKERR getInterface<CutMeshInterface>()->clearMap();
480 // Cleaning databases
481 refinedEntities.clear();
482 refinedFiniteElements.clear();
483 fIelds.clear();
484 entsFields.clear();
485 dofsField.clear();
486 finiteElements.clear();
487 entsFiniteElements.clear();
488 entFEAdjacencies.clear();
489 pRoblems.clear();
491}

◆ coreGenericConstructor()

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

Definition at line 171 of file Core.cpp.

172 {
174
175 // This is deprecated ONE should use MoFEM::Core::Initialize
177 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
178 "MoFEM globally is not initialised, call MoFEM::Core::Initialize");
179
180 // Create duplicate communicator
181 wrapMPIMOABComm = boost::make_shared<WrapMPIComm>(comm, false);
182
183 MPI_Comm_size(mofemComm, &sIze);
184 MPI_Comm_rank(mofemComm, &rAnk);
185
186 // CHeck if moab has set communicator if not set communicator interbally
187 ParallelComm *pComm = ParallelComm::get_pcomm(&moab, MYPCOMM_INDEX);
188 if (pComm == NULL)
189 pComm = new ParallelComm(&moab, wrapMPIMOABComm->get_comm());
190
191 // Register interfaces for this implementation
192 CHKERR registerInterface<UnknownInterface>();
193 CHKERR registerInterface<CoreInterface>();
194 CHKERR registerInterface<DeprecatedCoreInterface>();
195
196 // Register MOFEM events in PETSc
197 PetscLogEventRegister("FE_preProcess", 0, &MOFEM_EVENT_preProcess);
198 PetscLogEventRegister("FE_operator", 0, &MOFEM_EVENT_operator);
199 PetscLogEventRegister("FE_postProcess", 0, &MOFEM_EVENT_postProcess);
200 PetscLogEventRegister("MoFEMCreateMat", 0, &MOFEM_EVENT_createMat);
201
202 MOFEM_LOG_CHANNEL("WORLD");
203 MOFEM_LOG_CHANNEL("SELF");
204 MOFEM_LOG_CHANNEL("SYNC");
205
207}
#define MYPCOMM_INDEX
default communicator number PCOMM
Definition: definitions.h:215
PetscLogEvent MOFEM_EVENT_createMat
Definition: Core.hpp:958
PetscLogEvent MOFEM_EVENT_preProcess
Event for preProcess finite element.
Definition: Core.hpp:953
int sIze
MoFEM communicator size.
Definition: Core.hpp:969
ParallelComm * pComm
MOAB communicator structure.
Definition: Core.hpp:967
PetscLogEvent MOFEM_EVENT_operator
Event for evaluating operator of finite element.
Definition: Core.hpp:955
PetscLogEvent MOFEM_EVENT_postProcess
Event for postProcess finite element.
Definition: Core.hpp:957
boost::shared_ptr< WrapMPIComm > wrapMPIMOABComm
manage creation and destruction of MOAB communicator
Definition: Core.hpp:991

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

Note
This function is typically used when NOFIELD is created, for example load factor in arc-length control.
Parameters
namename of the field
bitbit ref level of the created vertices
coordsof the vertices
sizenumber of vertices
verbverbosity level
Returns
MoFEMErrorCode

Implements MoFEM::CoreInterface.

Definition at line 411 of file FieldCore.cpp.

413 {
415
416 if (verb == DEFAULT_VERBOSITY)
417 verb = verbose;
418
419 Range verts;
420
421 auto create_vertices = [&]() {
423
424 vector<double *> arrays_coord;
425 EntityHandle startv = 0;
426 ReadUtilIface *iface;
427 CHKERR get_moab().query_interface(iface);
428 CHKERR iface->get_node_coords(3, size, 0, startv, arrays_coord);
429 verts.insert(startv, startv + size - 1);
430 for (int n = 0; n != size; ++n)
431 for (auto d : {0, 1, 2})
432 arrays_coord[d][n] = coords[3 * n + d];
433
435 };
436
437 auto add_verts_to_field = [&]() {
439 EntityHandle field_meshset = get_field_meshset(name);
440 CHKERR get_moab().add_entities(field_meshset, verts);
442 };
443
444 CHKERR create_vertices();
445 CHKERR add_verts_to_field();
446
448}
FTensor::Index< 'n', SPACE_DIM > n

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

538 {
540 if (verb == -1)
541 verb = verbose;
542
543 Range ents;
544 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
545 Range ents_meshsets = ents.subset_by_type(MBENTITYSET);
546 ents = subtract(ents, ents_meshsets);
547 if(ents.empty()) {
548 if (verb >= VERBOSE)
549 MOFEM_LOG("WORLD", Sev::verbose) << "Nb. of deleted entities 0";
551 }
552
553 if (verb >= VERBOSE)
554 MOFEM_LOG("WORLD", Sev::noisy) << "Deleted ents:\n" << ents;
555
556 CHKERR remove_ents(ents, verb);
557
558 // remove parent
559 if (remove_parent) {
561 }
562
563 Range meshsets;
564 CHKERR get_moab().get_entities_by_type(0, MBENTITYSET, meshsets, true);
565 for (auto m : meshsets) {
566 CHKERR get_moab().remove_entities(m, ents);
567
568 }
569
570 rval = get_moab().delete_entities(ents);
571 if (rval != MB_SUCCESS) {
573 if (verb == QUIET) {
574 MOFEM_LOG("SELF", Sev::noisy) << "Problem deleting:\n" << ents;
575 } else {
576 MOFEM_LOG("SELF", Sev::warning) << "Problem deleting:\n" << ents;
577 }
578 MOFEM_LOG_CHANNEL("WORLD");
579 MOFEM_LOG_TAG("WORLD", "DeleteCore");
580 if (!(mf & MF_NOT_THROW)) {
581 CHK_MOAB_THROW(rval, "Can not delete entities");
582 } else {
583 rval = MB_SUCCESS;
584 }
585 }
586
587 MOFEM_LOG_C("SELF", Sev::noisy, "Nb. of deleted entities %d", ents.size());
588
590}
#define DeleteCoreFunctionBegin
Definition: DeleteCore.cpp:21
@ MF_NOT_THROW
Definition: definitions.h:101
#define CHK_MOAB_THROW(err, msg)
Check error code of MoAB function and throw MoFEM exception.
Definition: definitions.h:576
FTensor::Index< 'm', SPACE_DIM > m
static MoFEMErrorCodeGeneric< moab::ErrorCode > rval
Definition: Exceptions.hpp:74
MoFEMErrorCode remove_parents_by_parents(const Range &ents, int verb=DEFAULT_VERBOSITY)
Remove paremts from entities having parents in passed range.
Definition: DeleteCore.cpp:518
MoFEMErrorCode remove_ents(const Range ents, int verb=DEFAULT_VERBOSITY)
remove entities form mofem database
Definition: DeleteCore.cpp:429

◆ delete_field()

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

Delete field.

Parameters
namefield name
verbverbosity level
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 609 of file DeleteCore.cpp.

609 {
611 auto &f = fIelds.get<FieldName_mi_tag>();
612 auto mit = f.find(name);
613 if (mit == f.end()) {
614 SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
615 "Finite element <%s> not found", name.c_str());
616 }
617 EntityHandle meshset = mit->get()->getMeshset();
618 Range ents;
619 CHKERR get_moab().get_entities_by_handle(meshset, ents, false);
620 CHKERR remove_ents_from_field(name, ents, verb);
621 CHKERR get_moab().tag_delete((*mit)->th_FieldDataVerts);
622 CHKERR get_moab().tag_delete((*mit)->th_FieldData);
623 CHKERR get_moab().tag_delete((*mit)->th_AppOrder);
624 f.erase(mit);
625 CHKERR get_moab().delete_entities(&meshset, 1);
627}
MoFEMErrorCode remove_ents_from_field(const std::string name, const EntityHandle meshset, const EntityType type, int verb=DEFAULT_VERBOSITY)
remove entities from field
Definition: DeleteCore.cpp:152

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

592 {
594 auto &fe = finiteElements.get<FiniteElement_name_mi_tag>();
595 auto mit = fe.find(name);
596 if (mit == fe.end()) {
597 SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
598 "Finite element <%s> not found", name.c_str());
599 }
600 EntityHandle meshset = mit->get()->getMeshset();
601 Range ents;
602 CHKERR get_moab().get_entities_by_handle(meshset, ents, false);
603 CHKERR remove_ents_from_finite_element(name, ents, verb);
604 fe.erase(mit);
605 CHKERR get_moab().delete_entities(&meshset, 1);
607}
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
Definition: DeleteCore.cpp:379

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

108 {
110 auto p_miit = pRoblems.get<Problem_mi_tag>().find(name);
111 if (p_miit == pRoblems.get<Problem_mi_tag>().end()) {
112 SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "no such problem like < %s >",
113 name.c_str());
114 }
115 const EntityHandle meshset = p_miit->meshset;
116 pRoblems.get<Problem_mi_tag>().erase(p_miit);
117 CHKERR get_moab().delete_entities(&meshset, 1);
119}

◆ Finalize()

MoFEMErrorCode MoFEM::Core::Finalize ( )
static

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

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

Note
This function calls PetscInitialize, for more details see http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Sys/PetscFinalize.html
Returns
MoFEMErrorCode
Examples
add_blockset.cpp, add_cubit_meshsets.cpp, adolc_plasticity.cpp, analytical_nonlinear_poisson.cpp, analytical_poisson.cpp, analytical_poisson_field_split.cpp, approx_sphere.cpp, bernstein_bezier_generate_base.cpp, bone_adaptation.cpp, boundary_marker.cpp, build_large_problem.cpp, build_problems.cpp, cell_forces.cpp, child_and_parent.cpp, continuity_check_on_contact_prism_side_ele.cpp, continuity_check_on_skeleton_3d.cpp, continuity_check_on_skeleton_with_simple_2d_for_h1.cpp, continuity_check_on_skeleton_with_simple_2d_for_hcurl.cpp, continuity_check_on_skeleton_with_simple_2d_for_hdiv.cpp, cubit_bc_test.cpp, delete_ho_nodes.cpp, dg_projection.cpp, dm_build_partitioned_mesh.cpp, dm_create_subdm.cpp, dm_partitioned_no_field.cpp, dynamic_first_order_con_law.cpp, edge_and_bubble_shape_functions_on_quad.cpp, eigen_elastic.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, ep.cpp, field_blas.cpp, field_evaluator.cpp, field_to_vertices.cpp, forces_and_sources_testing_edge_element.cpp, forces_and_sources_testing_flat_prism_element.cpp, forces_and_sources_testing_users_base.cpp, free_surface.cpp, gauss_points_on_outer_product.cpp, hanging_node_approx.cpp, hcurl_check_approx_in_2d.cpp, hcurl_curl_operator.cpp, hcurl_divergence_operator_2d.cpp, hdiv_divergence_operator.cpp, heat_equation.cpp, heat_method.cpp, hello_world.cpp, helmholtz.cpp, hertz_surface.cpp, higher_derivatives.cpp, level_set.cpp, log.cpp, loop_entities.cpp, lorentz_force.cpp, magnetostatic.cpp, matrix_function.cpp, mesh_cut.cpp, mesh_insert_interface_atom.cpp, mesh_smoothing.cpp, meshset_to_vtk.cpp, minimal_surface_area.cpp, mixed_poisson.cpp, mortar_contact.cpp, mortar_contact_thermal.cpp, navier_stokes.cpp, node_merge.cpp, nonlinear_dynamics.cpp, nonlinear_elastic.cpp, operators_tests.cpp, partition_mesh.cpp, petsc_smart_ptr_objects.cpp, phase.cpp, photon_diffusion.cpp, plastic.cpp, plate.cpp, plot_base.cpp, poisson_2d_dis_galerkin.cpp, poisson_2d_homogeneous.cpp, prism_elements_from_surface.cpp, prism_polynomial_approximation.cpp, quad_polynomial_approximation.cpp, reaction_diffusion.cpp, remove_entities_from_problem.cpp, remove_entities_from_problem_not_partitioned.cpp, scalar_check_approximation.cpp, seepage.cpp, shallow_wave.cpp, simple_contact.cpp, simple_contact_thermal.cpp, simple_elasticity.cpp, simple_interface.cpp, simple_l2_only.cpp, split_sideset.cpp, tensor_divergence_operator.cpp, test_cache_on_entities.cpp, test_jacobian_of_simple_contact_element.cpp, testing_jacobian_of_hook_element.cpp, testing_jacobian_of_hook_scaled_with_density_element.cpp, thermo_elastic.cpp, unsaturated_transport.cpp, wave_equation.cpp, and wavy_surface.cpp.

Definition at line 112 of file Core.cpp.

112 {
114 PetscPopErrorHandler();
115 isGloballyInitialised = false;
116
117 if (isInitialized == PETSC_FALSE) {
118 PetscBool is_finalized;
119 PetscFinalized(&is_finalized);
120 if (!is_finalized)
121 PetscFinalize();
122 }
123
124 if (!mpiInitialised) {
125 int mpi_finalized;
126 MPI_Finalized(&mpi_finalized);
127 if (!mpi_finalized)
128 MPI_Finalize();
129 }
130 }
131
132 return 0;
133}
static PetscBool isInitialized
petsc was initialised by other agent
Definition: Core.hpp:1012
static int mpiInitialised
mpi was initialised by other agent
Definition: Core.hpp:1011

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

290 {
291 return basicEntityDataPtr;
292 }

◆ get_comm()

MPI_Comm & MoFEM::CoreTmp< 0 >::get_comm ( ) const
inlineprotectedvirtual
Returns
return communicator

Implements MoFEM::CoreInterface.

Definition at line 975 of file Core.hpp.

975{ 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 985 of file Core.hpp.

985{ return rAnk; }

◆ get_comm_size()

int MoFEM::CoreTmp< 0 >::get_comm_size ( ) const
inlineprotectedvirtual
Returns
return communicator size

Implements MoFEM::CoreInterface.

Definition at line 980 of file Core.hpp.

980{ 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 856 of file Core.cpp.

856{ 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 795 of file Core.cpp.

795 {
797 *dofs_ptr = &dofsField;
799}

◆ 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 filed 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 1325 of file FieldCore.cpp.

1326 {
1327 return dofsField.get<Unique_mi_tag>().lower_bound(
1329 ent));
1330}

◆ 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 filed 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 1332 of file FieldCore.cpp.

1333 {
1334 return dofsField.get<Unique_mi_tag>().upper_bound(
1336 ent));
1337}

◆ 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 filed 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 1339 of file FieldCore.cpp.

1340 {
1341 return dofsField.get<Unique_mi_tag>().lower_bound(
1343 get_id_for_min_type(type)));
1344}

◆ 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 filed 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 1346 of file FieldCore.cpp.

1347 {
1348 return dofsField.get<Unique_mi_tag>().upper_bound(
1350 get_id_for_max_type(type)));
1351}

◆ 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 filed 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 1315 of file FieldCore.cpp.

1315 {
1316 return dofsField.get<Unique_mi_tag>().lower_bound(
1318}

◆ 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 filed 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 1320 of file FieldCore.cpp.

1320 {
1321 return dofsField.get<Unique_mi_tag>().upper_bound(
1323}

◆ 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 filed 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 1305 of file FieldCore.cpp.

1305 {
1306 return entsFields.get<Unique_mi_tag>().lower_bound(
1308}

◆ 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 filed 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 1310 of file FieldCore.cpp.

1310 {
1311 return entsFields.get<Unique_mi_tag>().upper_bound(
1313}

◆ 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 836 of file Core.cpp.

836 {
837 return &entFEAdjacencies;
838}

◆ 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 827 of file Core.cpp.

829 {
831 *dofs_elements_adjacency = &entFEAdjacencies;
833}

◆ 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 850 of file Core.cpp.

850 {
851 return &entsFiniteElements;
852}

◆ 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 808 of file Core.cpp.

809 {
811 *fe_ent_ptr = &entsFiniteElements;
813}

◆ 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 839 of file FECore.cpp.

839 {
840 auto miit = finiteElements.get<FiniteElement_name_mi_tag>().find(fe_name);
841 if (miit != finiteElements.get<FiniteElement_name_mi_tag>().end()) {
842 return entsFiniteElements.get<Unique_mi_tag>().lower_bound(
843 EntFiniteElement::getLocalUniqueIdCalculate(0, (*miit)->getFEUId()));
844 } else {
845 return entsFiniteElements.get<Unique_mi_tag>().end();
846 }
847}

◆ 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 850 of file FECore.cpp.

850 {
851 auto miit = finiteElements.get<FiniteElement_name_mi_tag>().find(fe_name);
852 if (miit != finiteElements.get<FiniteElement_name_mi_tag>().end()) {
853 return entsFiniteElements.get<Unique_mi_tag>().upper_bound(
855 get_id_for_max_type<MBENTITYSET>(), (*miit)->getFEUId()));
856 } else {
857 return entsFiniteElements.get<Unique_mi_tag>().end();
858 }
859}

◆ get_field_bit_number()

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

get field bit number

Parameters
nameof field Example:
auto field_number = mField.get_field_bit_number("DISPLACEMENT");

Implements MoFEM::CoreInterface.

Definition at line 28 of file FieldCore.cpp.

28 {
29 auto &set = fIelds.get<FieldName_mi_tag>();
30 auto miit = set.find(name);
31 if (miit == set.end())
32 THROW_MESSAGE("field < " + name +
33 " > not in database (top tip: check spelling)");
34 return (*miit)->getBitNumber();
35}
#define THROW_MESSAGE(msg)
Throw MoFEM exception.
Definition: definitions.h:561

◆ 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
namefield name
dimdim
entsents
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 81 of file FieldCore.cpp.

83 {
84
86 EntityHandle meshset = get_field_meshset(name);
87 CHKERR get_moab().get_entities_by_dimension(meshset, dim, ents, true);
89}

◆ 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
namefield name
entsents
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 100 of file FieldCore.cpp.

101 {
103 EntityHandle meshset = get_field_meshset(name);
104 CHKERR get_moab().get_entities_by_handle(meshset, ents, true);
106}

◆ 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
namefield name
typeentity type
entsents
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 91 of file FieldCore.cpp.

93 {
95 EntityHandle meshset = get_field_meshset(name);
96 CHKERR get_moab().get_entities_by_type(meshset, type, ents, true);
98}

◆ 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 853 of file Core.cpp.

853 {
854 return &entsFields;
855}

◆ 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 790 of file Core.cpp.

790 {
792 *field_ents = &entsFields;
794}

◆ get_field_id()

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

Get field Id.

Parameters
nameof field
Returns
BitFieldId

Implements MoFEM::CoreInterface.

Definition at line 18 of file FieldCore.cpp.

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

◆ get_field_meshset() [1/2]

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

Definition at line 45 of file FieldCore.cpp.

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

◆ get_field_meshset() [2/2]

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

get field meshset

Parameters
nameof Field Example:
EntityHandle disp_files_meshset = mField.get_field_meshset("DISPLACEMENT");

Implements MoFEM::CoreInterface.

Definition at line 53 of file FieldCore.cpp.

53 {
54 return get_field_meshset(get_field_id(name));
55}
BitFieldId get_field_id(const std::string &name) const
Get field Id.
Definition: FieldCore.cpp:18

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

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

◆ 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
namefield name
bhcontrols behaviour
Returns
const Field*

Implements MoFEM::CoreInterface.

Definition at line 65 of file FieldCore.cpp.

66 {
67 auto miit = fIelds.get<FieldName_mi_tag>().find(name);
68 if (miit == fIelds.get<FieldName_mi_tag>().end()) {
69 if (bh == MF_EXIST)
70 throw MoFEMException(
72 std::string("field < " + name +
73 " > not in database (top tip: check spelling)")
74 .c_str());
75 else
76 return nullptr;
77 }
78 return miit->get();
79}
@ MF_EXIST
Definition: definitions.h:100

◆ 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 840 of file Core.cpp.

840{ 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 748 of file Core.cpp.

748 {
750 *fields_ptr = &fIelds;
752}

◆ 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
namefinite element name
dimdim
entsents
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 289 of file FECore.cpp.

290 {
291
293
295 CHKERR get_moab().get_entities_by_dimension(meshset, dim, ents, true);
297}

◆ 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
namefinite element name
entsents
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 312 of file FECore.cpp.

313 {
314
316
318 CHKERR get_moab().get_entities_by_handle(meshset, ents, true);
319
321}

◆ 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
namefinite element name
typeentity type
entsents
Returns
error code

Implements MoFEM::CoreInterface.

Definition at line 299 of file FECore.cpp.

301 {
302
304
306 CHKERR get_moab().get_entities_by_type(meshset, type, ents, true);
307
309}

◆ get_finite_element_meshset() [1/2]

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

Definition at line 276 of file FECore.cpp.

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

◆ 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 284 of file FECore.cpp.

284 {
286}

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

19 {
20 auto miit = finiteElements.get<FiniteElement_name_mi_tag>().find(name);
21 if (miit == finiteElements.get<FiniteElement_name_mi_tag>().end()) {
22 if (bh == MF_EXIST) {
23 throw MoFEMException(
25 std::string("finite element < " + name +
26 " > not in database (top tip: check spelling)")
27 .c_str());
28 } else {
29 return nullptr;
30 }
31 }
32 return miit->get();
33}

◆ 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 847 of file Core.cpp.

847 {
848 return &finiteElements;
849}

◆ 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 802 of file Core.cpp.

802 {
804 *fe_ptr = &finiteElements;
806}

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

361 {
362 return *get_meshsets_manager_ptr();
363 }
MeshsetsManager * get_meshsets_manager_ptr()
get MeshsetsManager pointer
Definition: Core.cpp:815

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

364 {
365 return *get_meshsets_manager_ptr();
366 }

◆ get_meshsets_manager_ptr() [1/2]

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

get MeshsetsManager pointer

Implements MoFEM::CoreInterface.

Definition at line 815 of file Core.cpp.

815 {
816 MeshsetsManager *meshsets_manager_ptr;
817 getInterface(meshsets_manager_ptr);
818 return meshsets_manager_ptr;
819}
IFACE getInterface() const
Get interface pointer to pointer of interface.

◆ 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 821 of file Core.cpp.

821 {
822 MeshsetsManager *meshsets_manager_ptr;
823 getInterface(meshsets_manager_ptr);
824 return meshsets_manager_ptr;
825}

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

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

323{ 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 767 of file Core.cpp.

768 {
770 typedef Problem_multiIndex::index<Problem_mi_tag>::type ProblemsByName;
771 const ProblemsByName &problems = pRoblems.get<Problem_mi_tag>();
772 ProblemsByName::iterator p_miit = problems.find(problem_name);
773 if (p_miit == problems.end()) {
774 SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
775 "problem < %s > not found, (top tip: check spelling)",
776 problem_name.c_str());
777 }
778 *problem_ptr = &*p_miit;
780}

◆ 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 857 of file Core.cpp.

857 {
858 const Problem *prb;
859 CHK_THROW_MESSAGE(get_problem(problem_name, &prb),
860 "Problem of given name not found");
861 return prb;
862}
MoFEMErrorCode get_problem(const std::string &problem_name, const Problem **problem_ptr) const
Get problem database (data structure)
Definition: Core.cpp:767

◆ 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
nameis problem name
fe_name
meshset

Implements MoFEM::CoreInterface.

Definition at line 914 of file FECore.cpp.

916 {
918 auto &prb = pRoblems.get<Problem_mi_tag>();
919 auto p_miit = prb.find(problem_name);
920 if (p_miit == prb.end())
921 SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
922 "No such problem like < %s >", problem_name.c_str());
923
924 auto fe_miit = finiteElements.get<FiniteElement_name_mi_tag>().find(fe_name);
925 if (fe_miit != finiteElements.get<FiniteElement_name_mi_tag>().end()) {
926 auto miit =
927 p_miit->numeredFiniteElementsPtr->get<Unique_mi_tag>().lower_bound(
929 0, (*fe_miit)->getFEUId()));
930 auto hi_miit =
931 p_miit->numeredFiniteElementsPtr->get<Unique_mi_tag>().upper_bound(
933 get_id_for_max_type<MBENTITYSET>(), (*fe_miit)->getFEUId()));
934
935 if (miit != hi_miit) {
936 std::vector<EntityHandle> ents;
937 ents.reserve(std::distance(miit, hi_miit));
938 for (; miit != hi_miit; ++miit)
939 ents.push_back((*miit)->getEnt());
940 int part = (*miit)->getPart();
941 CHKERR get_moab().tag_clear_data(th_Part, &*ents.begin(), ents.size(),
942 &part);
943 CHKERR get_moab().add_entities(meshset, &*ents.begin(), ents.size());
944 }
945 }
946
948}
Tag th_Part
Tag for partition number.
Definition: Core.hpp:257

◆ 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 863 of file Core.cpp.

863{ 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 783 of file Core.cpp.

783 {
785 *problems_ptr = &pRoblems;
787}

◆ 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 841 of file Core.cpp.

841 {
842 return &refinedEntities;
843}

◆ 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 755 of file Core.cpp.

755 {
757 *refined_entities_ptr = &refinedEntities;
759}

◆ 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 844 of file Core.cpp.

844 {
845 return &refinedFiniteElements;
846}

◆ 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 760 of file Core.cpp.

761 {
763 *refined_finite_elements_ptr = &refinedFiniteElements;
765}

◆ get_th_RefBitEdge()

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

Definition at line 199 of file Core.hpp.

199{ return th_RefBitEdge; }

◆ get_th_RefBitLevel()

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

Definition at line 198 of file Core.hpp.

198{ return th_RefBitLevel; }

◆ get_th_RefParentHandle()

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

Definition at line 197 of file Core.hpp.

197{ return th_RefParentHandle; }
Tag th_RefParentHandle
Definition: Core.hpp:258

◆ getBitFEId()

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

Get field Id.

Parameters
namefield name
Returns
field id

Definition at line 258 of file FECore.cpp.

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

◆ getBitFEIdName()

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

Get field name.

Parameters
idfield id
Returns
field name

Definition at line 268 of file FECore.cpp.

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

◆ getBitProblemId()

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

Definition at line 121 of file ProblemsCore.cpp.

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

◆ getBuildMoFEM()

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

Get flags/semaphores for different stages.

Definition at line 225 of file Core.hpp.

225{ return *buildMoFEM; }

◆ getOptions()

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

Get core options from command line.

Returns
MoFEMErrorCode

Definition at line 721 of file Core.cpp.

721 {
723 if (verb == -1)
724 verb = verbose;
725
726 CHKERR PetscOptionsBegin(mofemComm, optionsPrefix.c_str(), "Mesh cut options",
727 "See MoFEM documentation");
728
729 CHKERR PetscOptionsBool(
730 "-mofem_init_fields", "Initialise fields on construction", "",
732
733 CHKERR PetscOptionsBool(
734 "-mofem_init_fields", "Initialise fields on construction", "",
736
737 // TODO: Add read verbosity level
738 // TODO: Add option to initalise problems ??? - DO WE REALLY NEED THAT
739
740 ierr = PetscOptionsEnd();
741 CHKERRG(ierr);
742
744}
#define CHKERRG(n)
Check error code of MoFEM/MOAB/PETSc function.
Definition: definitions.h:483
std::string optionsPrefix
Prefix for options on command line.
Definition: Core.hpp:1002

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

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

◆ getTags()

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

Get tag handles.

Parameters
verbverbosity level
Returns
error code

Definition at line 522 of file Core.cpp.

522 {
524
525 const EntityHandle root_meshset = get_moab().get_root_set();
526 if (root_meshset) {
527 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
528 "Root meshset should be 0");
529 }
530
531 // Set version
532 {
533 Version version;
534 CHKERR getFileVersion(moab, version);
535 }
536
537 // Global Variables
538 {
539
540 auto check_tag_allocated = [](auto &rval) {
542 if (rval == MB_ALREADY_ALLOCATED)
543 rval = MB_SUCCESS;
544 else
545 CHKERRG(rval);
547 };
548
549 // Safety nets
550 int def_bool = 0;
551 rval = get_moab().tag_get_handle("_MoFEMBuild", 1, MB_TYPE_INTEGER,
552 th_MoFEMBuild, MB_TAG_CREAT | MB_TAG_MESH,
553 &def_bool);
554 CHKERR check_tag_allocated(rval);
555
556 CHKERR get_moab().tag_get_by_ptr(th_MoFEMBuild, &root_meshset, 1,
557 (const void **)&buildMoFEM);
558 }
559
560 // Tags saved in vtk-files
561 {
562 const int def_part = -1;
563 CHKERR get_moab().tag_get_handle("PARTITION", 1, MB_TYPE_INTEGER, th_Part,
564 MB_TAG_CREAT | MB_TAG_SPARSE, &def_part);
565 }
566
567 // Tags Ref
568 {
569
570 // Fix size of bir ref level tags
572
573 const int def_part = -1;
574 CHKERR get_moab().tag_get_handle("_MeshsetPartition", 1, MB_TYPE_INTEGER,
575 th_Part, MB_TAG_CREAT | MB_TAG_SPARSE,
576 &def_part);
577 EntityHandle def_handle = 0;
578 CHKERR get_moab().tag_get_handle("_RefParentHandle", 1, MB_TYPE_HANDLE,
580 MB_TAG_CREAT | MB_TAG_SPARSE, &def_handle);
581 BitRefLevel def_bit_level = 0;
582 CHKERR get_moab().tag_get_handle(
583 "_RefBitLevel", sizeof(BitRefLevel), MB_TYPE_OPAQUE, th_RefBitLevel,