Create compressed matrix. More...

Inheritance diagram for MoFEM::CreateRowCompressedADJMatrix:

Collaboration diagram for MoFEM::CreateRowCompressedADJMatrix:

Public Types
using	ProblemsByName = Problem_multiIndex::index<Problem_mi_tag>::type

Public Types inherited from MoFEM::CoreTmp< 0 >
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 }

Public Member Functions
	CreateRowCompressedADJMatrix (moab::Interface &moab, MPI_Comm comm=PETSC_COMM_WORLD, int verbose=1)

template<typename TAG >
MoFEMErrorCode	createMatArrays (ProblemsByName::iterator p_miit, const MatType type, std::vector< PetscInt > &i, std::vector< PetscInt > &j, const bool no_diagonals=true, int verb=QUIET) const
	Create matrix adjacencies.

Public Member Functions inherited from MoFEM::CoreTmp< 0 >
const int	getValue () const
	Get the core.

RefEntityTmp< 0 >	getRefEntity (const EntityHandle ent)

virtual boost::shared_ptr< RefEntityTmp< 0 > >	make_shared_ref_entity (const EntityHandle ent)
	Get RefEntity.

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

	~CoreTmp ()

int &	getBuildMoFEM () const
	Get flags/semaphores for different stages.

MoFEMErrorCode	addPrismToDatabase (const EntityHandle prism, int verb=DEFAULT_VERBOSITY)
	add prim element

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

Tag	get_th_RefParentHandle () const

Tag	get_th_RefBitLevel () const

Tag	get_th_RefBitEdge () const

Public Member Functions inherited from MoFEM::DeprecatedCoreInterface
virtual DEPRECATED MoFEMErrorCode	seed_ref_level_2D (const EntityHandle meshset, const BitRefLevel &bit, int verb=-1)
	seed 2D entities (Triangles entities only) in the meshset and their adjacencies (only TRIs adjacencies) in a particular BitRefLevel

DEPRECATED MoFEMErrorCode	seed_ref_level_3D (const EntityHandle meshset, const BitRefLevel &bit, int verb=-1)
	seed 2D entities in the meshset and their adjacencies (only TETs adjacencies) in a particular BitRefLevel

DEPRECATED MoFEMErrorCode	seed_ref_level (const Range &ents, const BitRefLevel &bit, const bool only_tets=true, int verb=-1)
	seed entities in the range and their adjacencies in a particular BitRefLevel

DEPRECATED MoFEMErrorCode	partition_mesh (const Range &ents, const int dim, const int adj_dim, const int n_parts, int verb=-1)
	Set partition tag to each finite element in the problem.

DEPRECATED MoFEMErrorCode	synchronise_entities (Range &ent, int verb=DEFAULT_VERBOSITY)

DEPRECATED MoFEMErrorCode	synchronise_field_entities (const std::string &name, int verb=DEFAULT_VERBOSITY)

Public Member Functions inherited from MoFEM::CoreInterface
virtual	~CoreInterface ()=default

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

Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode	registerInterface (bool error_if_registration_failed=true)
	Register interface.

template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface reference to pointer of interface.

template<class IFACE >
MoFEMErrorCode	getInterface (IFACE **const iface) const
	Get interface pointer to pointer of interface.

template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get interface pointer to pointer of interface.

template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get reference to interface.

template<class IFACE >
IFACE *	getInterface () const
	Function returning pointer to interface.

virtual	~UnknownInterface ()=default

Private Types
using	AdjByEnt

using	DofByGlobalPetscIndex

Private Member Functions
template<typename TAG >
MoFEMErrorCode	getEntityAdjacencies (ProblemsByName::iterator p_miit, typename boost::multi_index::index< NumeredDofEntity_multiIndex, TAG >::type::iterator mit_row, boost::shared_ptr< FieldEntity > mofem_ent_ptr, std::vector< int > &dofs_col_view, int verb) const
	Get element adjacencies.

Additional Inherited Members
Static Public Member Functions inherited from MoFEM::CoreTmp< 0 >
static MoFEMErrorCode	Initialize (int argc, char **args, const char file[], const char help[])
	Initializes the MoFEM database PETSc, MOAB and MPI.

static MoFEMErrorCode	Finalize ()
	Checks for options to be called at the conclusion of the program.

static 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)

Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode	getLibVersion (Version &version)
	Get library version.

static MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version)
	Get database major version.

static MoFEMErrorCode	setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
	Get database major version.

static MoFEMErrorCode	getInterfaceVersion (Version &version)
	Get database major version.

Static Public Attributes inherited from MoFEM::CoreTmp< 0 >
static constexpr int	value = 0

Protected Member Functions inherited from MoFEM::CoreTmp< 0 >
template<int V>
	CoreTmp (moab::Interface &moab, MPI_Comm comm, const int verbose, CoreValue< V >)

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

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

MoFEMErrorCode	getTags (int verb=DEFAULT_VERBOSITY)
	Get tag handles.

MoFEMErrorCode	clearMap ()
	Cleaning database.

MoFEMErrorCode	registerSubInterfaces ()
	Register insterfaces.

BitProblemId	getProblemShift ()
	Return unique problem Id.

MoFEMErrorCode	initialiseDatabaseFromMesh (int verb=DEFAULT_VERBOSITY)
	Initialize database getting information on mesh.

MoFEMErrorCode	getOptions (int verb=DEFAULT_VERBOSITY)
	Get core options from command line.

template<class IFACE >
MoFEMErrorCode	regSubInterface ()
	Register sub-interfaces in core interface.

template<class IFACE >
MoFEMErrorCode	regEvents ()
	Register petsc events.

boost::shared_ptr< BasicEntityData > &	get_basic_entity_data_ptr ()
	Get pointer to basic entity data.

moab::Interface &	get_moab ()

const moab::Interface &	get_moab () const

MoFEMErrorCode	set_moab_interface (moab::Interface &new_moab, int verb=VERBOSE)
	Set the moab interface object.

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

MPI_Comm &	get_comm () const

int	get_comm_size () const

int	get_comm_rank () const

MoFEMErrorCode	check_number_of_ents_in_ents_field (const std::string &name) const
	check data consistency in entitiesPtr

MoFEMErrorCode	check_number_of_ents_in_ents_field () const
	check data consistency in entitiesPtr

MoFEMErrorCode	check_number_of_ents_in_ents_finite_element (const std::string &name) const
	check data consistency in entsFiniteElements

MoFEMErrorCode	check_number_of_ents_in_ents_finite_element () const
	check data consistency in entsFiniteElements

MoFEMErrorCode	clear_database (int verb=DEFAULT_VERBOSITY)
	Clear database.

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

MeshsetsManager *	get_meshsets_manager_ptr ()
	get MeshsetsManager pointer

const MeshsetsManager *	get_meshsets_manager_ptr () const
	get MeshsetsManager pointer

MeshsetsManager &	get_meshsets_manager ()
	get MeshsetsManager pointer

const MeshsetsManager &	get_meshsets_manager () const
	get MeshsetsManager pointer

MoFEMErrorCode	remove_parents_by_ents (const Range &ents, int verb=DEFAULT_VERBOSITY)
	Remove parents from entities.

MoFEMErrorCode	remove_parents_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	Remove parent from entities on bit level.

MoFEMErrorCode	remove_parents_by_parents (const Range &ents, int verb=DEFAULT_VERBOSITY)
	Remove paremts from entities having parents in passed range.

MoFEMErrorCode	remove_ents (const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities form mofem database

MoFEMErrorCode	remove_ents_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	remove entities form mofem database

MoFEMErrorCode	delete_ents_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, const bool remove_parent=false, int verb=DEFAULT_VERBOSITY, MoFEMTypes mf=MF_ZERO)
	delete entities form mofem and moab database

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

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

MoFEMErrorCode	delete_field (const std::string name, int verb=DEFAULT_VERBOSITY)
	Delete field.

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

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

MoFEMErrorCode	add_ents_to_field_by_dim (const Range &ents, const int dim, const std::string &name, int verb=DEFAULT_VERBOSITY)
	Add entities to field meshset.

MoFEMErrorCode	add_ents_to_field_by_type (const Range &ents, const EntityType type, const std::string &name, int verb=DEFAULT_VERBOSITY)
	Add entities to field meshset.

MoFEMErrorCode	add_ents_to_field_by_dim (const EntityHandle meshset, const int dim, const std::string &name, const bool recursive=true, int verb=DEFAULT_VERBOSITY)
	Add entities to field meshset.

MoFEMErrorCode	add_ents_to_field_by_type (const EntityHandle meshset, const EntityType type, const std::string &name, const bool recursive=true, int verb=DEFAULT_VERBOSITY)
	Add entities to field meshset.

MoFEMErrorCode	create_vertices_and_add_to_field (const std::string name, const double coords[], int size, int verb=DEFAULT_VERBOSITY)
	Create a vertices and add to field object.

MoFEMErrorCode	setFieldOrder (const Range &ents, const BitFieldId id, const ApproximationOrder order, int ver)

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

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

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

MoFEMErrorCode	set_field_order (const Range &ents, const std::string &name, const ApproximationOrder order, int verb=DEFAULT_VERBOSITY)
	Set order approximation of the entities in the field.

MoFEMErrorCode	set_field_order (const EntityHandle meshset, const EntityType type, const std::string &name, const ApproximationOrder order, int verb=DEFAULT_VERBOSITY)
	Set order approximation of the entities in the field.

MoFEMErrorCode	set_field_order_by_entity_type_and_bit_ref (const BitRefLevel &bit, const BitRefLevel &mask, const EntityType type, const BitFieldId id, const ApproximationOrder order, int verb=DEFAULT_VERBOSITY)

MoFEMErrorCode	set_field_order_by_entity_type_and_bit_ref (const BitRefLevel &bit, const BitRefLevel &mask, const EntityType type, const std::string &name, const ApproximationOrder order, int verb=DEFAULT_VERBOSITY)
	Set order approximation of the entities in the field.

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

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)

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)

MoFEMErrorCode	remove_ents_from_field_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	remove entities from field

MoFEMErrorCode	remove_ents_from_field (const std::string name, const EntityHandle meshset, const EntityType type, int verb=DEFAULT_VERBOSITY)
	remove entities from field

MoFEMErrorCode	remove_ents_from_field (const std::string name, const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities from field

MoFEMErrorCode	remove_ents_from_field (const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities from all fields

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

MoFEMErrorCode	list_fields () const
	list entities in the field

BitFieldId	get_field_id (const std::string &name) const
	Get field Id.

FieldBitNumber	get_field_bit_number (const std::string name) const
	get field bit number

std::string	get_field_name (const BitFieldId id) const
	get field name from id

EntityHandle	get_field_meshset (const BitFieldId id) const

EntityHandle	get_field_meshset (const std::string name) const
	get field meshset

MoFEMErrorCode	get_field_entities_by_dimension (const std::string name, int dim, Range &ents) const
	get entities in the field by dimension

MoFEMErrorCode	get_field_entities_by_type (const std::string name, EntityType type, Range &ents) const
	get entities in the field by type

MoFEMErrorCode	get_field_entities_by_handle (const std::string name, Range &ents) const
	get entities in the field by handle

bool	check_field (const std::string &name) const
	check if field is in database

const Field *	get_field_structure (const std::string &name, enum MoFEMTypes bh=MF_EXIST) const
	get field structure

const FiniteElement *	get_finite_element_structure (const std::string &name, enum MoFEMTypes bh=MF_EXCL) const
	get finite element struture

bool	check_finite_element (const std::string &name) const
	Check if finite element is in database.

MoFEMErrorCode	add_finite_element (const std::string &fe_name, enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)
	add finite element

MoFEMErrorCode	modify_finite_element_adjacency_table (const std::string &fe_name, const EntityType type, ElementAdjacencyFunct function)
	modify finite element table, only for advanced user

MoFEMErrorCode	modify_finite_element_add_field_data (const std::string &fe_name, const std::string name_filed)
	set finite element field data

MoFEMErrorCode	modify_finite_element_add_field_row (const std::string &fe_name, const std::string name_row)
	set field row which finite element use

MoFEMErrorCode	modify_finite_element_add_field_col (const std::string &fe_name, const std::string name_col)
	set field col which finite element use

MoFEMErrorCode	modify_finite_element_off_field_data (const std::string &fe_name, const std::string name_filed)
	unset finite element field data

MoFEMErrorCode	modify_finite_element_off_field_row (const std::string &fe_name, const std::string name_row)
	unset field row which finite element use

MoFEMErrorCode	modify_finite_element_off_field_col (const std::string &fe_name, const std::string name_col)
	unset field col which finite element use

MoFEMErrorCode	add_ents_to_finite_element_by_type (const EntityHandle meshset, const EntityType type, const std::string name, const bool recursive=true)
	add entities to finite element

MoFEMErrorCode	add_ents_to_finite_element_by_dim (const EntityHandle meshset, const int dim, const std::string name, const bool recursive=true)
	add entities to finite element

MoFEMErrorCode	add_ents_to_finite_element_by_type (const Range ents, const EntityType type, const std::string name)
	add entities to finite elements

MoFEMErrorCode	add_ents_to_finite_element_by_dim (const Range ents, const int dim, const std::string name)
	add entities to finite elements

MoFEMErrorCode	add_ents_to_finite_element_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, const std::string name, EntityType type, int verb=DEFAULT_VERBOSITY)
	add TET entities from given refinement level to finite element database given by name

MoFEMErrorCode	add_ents_to_finite_element_by_MESHSET (const EntityHandle meshset, const std::string &name, const bool recursive=false)
	add MESHSET element to finite element database given by name

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

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

MoFEMErrorCode	remove_ents_from_finite_element_by_bit_ref (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	remove elements from given refinement level to finite element database

MoFEMErrorCode	remove_ents_from_finite_element (const std::string name, const EntityHandle meshset, const EntityType type, int verb=DEFAULT_VERBOSITY)
	remove entities from given refinement level to finite element database

MoFEMErrorCode	remove_ents_from_finite_element (const std::string name, const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities from finite element database

MoFEMErrorCode	remove_ents_from_finite_element (const Range ents, int verb=DEFAULT_VERBOSITY)
	remove entities from finite elements in database

MoFEMErrorCode	delete_finite_element (const std::string name, int verb=DEFAULT_VERBOSITY)
	delete finite element from mofem database

BitFEId	getBitFEId (const std::string &fe_name) const
	Get field Id.

std::string	getBitFEIdName (const BitFEId id) const
	Get field name.

EntityHandle	get_finite_element_meshset (const BitFEId id) const

EntityHandle	get_finite_element_meshset (const std::string name) const

MoFEMErrorCode	get_finite_element_entities_by_dimension (const std::string name, int dim, Range &ents) const
	get entities in the finite element by dimension

MoFEMErrorCode	get_finite_element_entities_by_type (const std::string name, EntityType type, Range &ents) const
	get entities in the finite element by type

MoFEMErrorCode	get_finite_element_entities_by_handle (const std::string name, Range &ents) const
	get entities in the finite element by handle

MoFEMErrorCode	list_finite_elements () const
	list finite elements in database

MoFEMErrorCode	add_problem (const std::string &name, enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)
	Add problem.

bool	check_problem (const std::string name)
	check if problem exist

MoFEMErrorCode	delete_problem (const std::string name)
	Delete problem.

MoFEMErrorCode	modify_problem_add_finite_element (const std::string name_problem, const std::string &fe_name)
	add finite element to problem, this add entities assigned to finite element to a particular problem

MoFEMErrorCode	modify_problem_unset_finite_element (const std::string name_problem, const std::string &fe_name)
	unset finite element from problem, this remove entities assigned to finite element to a particular problem

MoFEMErrorCode	modify_problem_ref_level_add_bit (const std::string &name_problem, const BitRefLevel &bit)
	add ref level to problem

MoFEMErrorCode	modify_problem_ref_level_set_bit (const std::string &name_problem, const BitRefLevel &bit)
	set ref level for problem

MoFEMErrorCode	modify_problem_mask_ref_level_add_bit (const std::string &name_problem, const BitRefLevel &bit)
	set dof mask ref level for problem

MoFEMErrorCode	modify_problem_mask_ref_level_set_bit (const std::string &name_problem, const BitRefLevel &bit)
	set dof mask ref level for problem

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

MoFEMErrorCode	list_problem () const
	list problems

MoFEMErrorCode	clear_problem (const std::string name, int verb=DEFAULT_VERBOSITY)
	clear problem

MoFEMErrorCode	clear_problems (int verb=DEFAULT_VERBOSITY)
	clear problems

MoFEMErrorCode	build_finite_elements (int verb=DEFAULT_VERBOSITY)
	Build finite elements.

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

MoFEMErrorCode	build_finite_elements (const string fe_name, const Range *const ents_ptr=nullptr, int verb=DEFAULT_VERBOSITY)
	Build finite elements.

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

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

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

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

MoFEMErrorCode	get_problem_finite_elements_entities (const std::string name, const std::string &fe_name, const EntityHandle meshset)
	add finite elements to the meshset

DEPRECATED MoFEMErrorCode	build_problem_on_distributed_mesh (int verb=DEFAULT_VERBOSITY)

DEPRECATED MoFEMErrorCode	build_problems (int verb=DEFAULT_VERBOSITY)

MoFEMErrorCode	build_adjacencies (const Range &ents, int verb=DEFAULT_VERBOSITY)
	build adjacencies

MoFEMErrorCode	build_adjacencies (const BitRefLevel &bit, int verb=DEFAULT_VERBOSITY)
	build adjacencies

MoFEMErrorCode	build_adjacencies (const BitRefLevel &bit, const BitRefLevel &mask, int verb=DEFAULT_VERBOSITY)
	build adjacencies

MoFEMErrorCode	clear_adjacencies_entities (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	clear adjacency map for entities on given bit level

MoFEMErrorCode	clear_adjacencies_entities (const Range ents, int verb=DEFAULT_VERBOSITY)
	clear adjacencies for field entities by entities

MoFEMErrorCode	clear_adjacencies_entities (const std::string name, const Range ents, int verb=DEFAULT_VERBOSITY)
	clear adjacencies for field entities by entities and field namd

MoFEMErrorCode	clear_adjacencies_finite_elements (const BitRefLevel bit, const BitRefLevel mask, int verb=DEFAULT_VERBOSITY)
	clear adjacency map for finite elements on given bit level

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

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

MoFEMErrorCode	problem_basic_method_preProcess (const Problem *problem_ptr, BasicMethod &method, int verb=DEFAULT_VERBOSITY)
	Set data for BasicMethod.

MoFEMErrorCode	problem_basic_method_preProcess (const std::string &problem_name, BasicMethod &method, int verb=DEFAULT_VERBOSITY)
	Set data for BasicMethod.

MoFEMErrorCode	problem_basic_method_postProcess (const Problem *problem_ptr, BasicMethod &method, int verb=DEFAULT_VERBOSITY)
	Set data for BasicMethod.

MoFEMErrorCode	problem_basic_method_postProcess (const std::string &problem_name, BasicMethod &method, int verb=DEFAULT_VERBOSITY)
	Set data for BasicMethod.

MoFEMErrorCode	cache_problem_entities (const std::string prb_name, CacheTupleWeakPtr cache_ptr)
	Cache variables.

MoFEMErrorCode	loop_finite_elements (const Problem *problem_ptr, const std::string &fe_name, FEMethod &method, int lower_rank, int upper_rank, boost::shared_ptr< NumeredEntFiniteElement_multiIndex > fe_ptr=nullptr, MoFEMTypes bh=MF_EXIST, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr(), int verb=DEFAULT_VERBOSITY)
	Make a loop over finite elements on partitions from upper to lower rank.

MoFEMErrorCode	loop_finite_elements (const std::string problem_name, const std::string &fe_name, FEMethod &method, int lower_rank, int upper_rank, boost::shared_ptr< NumeredEntFiniteElement_multiIndex > fe_ptr=nullptr, MoFEMTypes bh=MF_EXIST, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr(), int verb=DEFAULT_VERBOSITY)
	Make a loop over finite elements on partitions from upper to lower rank.

MoFEMErrorCode	loop_finite_elements (const std::string problem_name, const std::string &fe_name, FEMethod &method, boost::shared_ptr< NumeredEntFiniteElement_multiIndex > fe_ptr=nullptr, MoFEMTypes bh=MF_EXIST, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr(), int verb=DEFAULT_VERBOSITY)
	Make a loop over finite elements.

MoFEMErrorCode	loop_dofs (const Problem *problem_ptr, const std::string &field_name, RowColData rc, DofMethod &method, int lower_rank, int upper_rank, int verb=DEFAULT_VERBOSITY)
	Make a loop over dofs.

MoFEMErrorCode	loop_dofs (const std::string &problem_name, const std::string &field_name, RowColData rc, DofMethod &method, int lower_rank, int upper_rank, int verb=DEFAULT_VERBOSITY)
	Make a loop over dofs.

MoFEMErrorCode	loop_dofs (const std::string &problem_name, const std::string &field_name, RowColData rc, DofMethod &method, int verb=DEFAULT_VERBOSITY)
	Make a loop over dofs.

MoFEMErrorCode	loop_dofs (const std::string &field_name, DofMethod &method, int verb=DEFAULT_VERBOSITY)
	Make a loop over dofs.

MoFEMErrorCode	loop_entities (const Problem *problem_ptr, const std::string field_name, RowColData rc, EntityMethod &method, int lower_rank, int upper_rank, int verb=DEFAULT_VERBOSITY)
	Loop over field entities in the problem.

MoFEMErrorCode	loop_entities (const std::string problem_name, const std::string field_name, RowColData rc, EntityMethod &method, int lower_rank, int upper_rank, int verb=DEFAULT_VERBOSITY)
	Loop over field entities in the problem.

MoFEMErrorCode	loop_entities (const std::string problem_name, const std::string field_name, RowColData rc, EntityMethod &method, int verb=DEFAULT_VERBOSITY)
	Loop over field entities in the problem.

MoFEMErrorCode	loop_entities (const std::string field_name, EntityMethod &method, Range const *const ents=nullptr, int verb=DEFAULT_VERBOSITY)
	Loop over field entities.

MoFEMErrorCode	get_fields (const Field_multiIndex **fields_ptr) const
	Get fields multi-index from database.

MoFEMErrorCode	get_ref_ents (const RefEntity_multiIndex **refined_entities_ptr) const
	Get ref entities multi-index from database.

MoFEMErrorCode	get_ref_finite_elements (const RefElement_multiIndex **refined_finite_elements_ptr) const
	Get ref finite elements multi-index form database.

MoFEMErrorCode	get_finite_elements (const FiniteElement_multiIndex **fe_ptr) const
	Get finite elements multi-index.

MoFEMErrorCode	get_ents_finite_elements (const EntFiniteElement_multiIndex **fe_ent_ptr) const
	Get entities finite elements multi-index.

MoFEMErrorCode	get_field_ents (const FieldEntity_multiIndex **field_ents) const
	Get field multi index.

MoFEMErrorCode	get_dofs (const DofEntity_multiIndex **dofs_ptr) const
	Get dofs multi index.

MoFEMErrorCode	get_problem (const std::string &problem_name, const Problem **problem_ptr) const
	Get problem database (data structure)

MoFEMErrorCode	get_problems (const Problem_multiIndex **problems_ptr) const
	Get pointer to problems multi-index.

MoFEMErrorCode	get_ents_elements_adjacency (const FieldEntityEntFiniteElementAdjacencyMap_multiIndex **dofs_elements_adjacency) const
	Get the dofs elements adjacency object.

const Field_multiIndex *	get_fields () const
	Get the fields object.

const RefEntity_multiIndex *	get_ref_ents () const
	Get the ref ents object.

const RefElement_multiIndex *	get_ref_finite_elements () const
	Get the ref finite elements object.

const FiniteElement_multiIndex *	get_finite_elements () const
	Get the finite elements object.

const EntFiniteElement_multiIndex *	get_ents_finite_elements () const
	Get the ents finite elements object.

const FieldEntity_multiIndex *	get_field_ents () const
	Get the field ents object.

const DofEntity_multiIndex *	get_dofs () const
	Get the dofs object.

const Problem *	get_problem (const std::string problem_name) const
	Get the problem object.

const Problem_multiIndex *	get_problems () const
	Get the problems object.

const FieldEntityEntFiniteElementAdjacencyMap_multiIndex *	get_ents_elements_adjacency () const
	Get the dofs elements adjacency object.

FieldEntityByUId::iterator	get_ent_field_by_name_begin (const std::string &field_name) const
	get begin iterator of field ents of given name (instead you can use IT_GET_ENT_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)

FieldEntityByUId::iterator	get_ent_field_by_name_end (const std::string &field_name) const
	get begin iterator of field dofs of given name (instead you can use IT_GET_ENT_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)

DofEntityByUId::iterator	get_dofs_by_name_begin (const std::string &field_name) const
	get begin iterator of field dofs of given name (instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)

DofEntityByUId::iterator	get_dofs_by_name_end (const std::string &field_name) const
	get begin iterator of field dofs of given name (instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)

DofEntityByUId::iterator	get_dofs_by_name_and_ent_begin (const std::string &field_name, const EntityHandle ent) const
	get begin iterator of field dofs of given name and ent(instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,ENT,IT)

DofEntityByUId::iterator	get_dofs_by_name_and_ent_end (const std::string &field_name, const EntityHandle ent) const
	get begin iterator of field dofs of given name and ent (instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,ENT,IT)

DofEntityByUId::iterator	get_dofs_by_name_and_type_begin (const std::string &field_name, const EntityType type) const
	get begin iterator of field dofs of given name and ent type (instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,TYPE,IT)

DofEntityByUId::iterator	get_dofs_by_name_and_type_end (const std::string &field_name, const EntityType ent) const
	get begin iterator of field dofs of given name end ent type(instead you can use IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP(MFIELD,NAME,TYPE,IT)

EntFiniteElement_multiIndex::index< Unique_mi_tag >::type::iterator	get_fe_by_name_begin (const std::string &fe_name) const
	get begin iterator of finite elements of given name (instead you can use IT_GET_FES_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)

EntFiniteElement_multiIndex::index< Unique_mi_tag >::type::iterator	get_fe_by_name_end (const std::string &fe_name) const
	get end iterator of finite elements of given name (instead you can use IT_GET_FES_BY_NAME_FOR_LOOP(MFIELD,NAME,IT)

Protected Attributes inherited from MoFEM::CoreTmp< 0 >
boost::shared_ptr< WrapMPIComm >	wrapMPIMOABComm
	manage creation and destruction of MOAB communicator

int	verbose
	Verbosity level.

boost::ptr_map< boost::typeindex::type_index, UnknownInterface >	iFaces
	Hash map of pointers to interfaces.

int *	buildMoFEM
	keeps flags/semaphores for different stages

std::string	optionsPrefix
	Prefix for options on command line.

PetscBool	initaliseAndBuildField

PetscBool	initaliseAndBuildFiniteElements

Tag	th_Part
	Tag for partition number.

Tag	th_RefParentHandle

Tag	th_RefBitLevel

Tag	th_RefBitLevel_Mask

Tag	th_RefBitEdge

Tag	th_RefFEMeshset

Tag	th_FieldId

Tag	th_FieldName

Tag	th_FieldName_DataNamePrefix

Tag	th_FieldSpace

Tag	th_FieldContinuity

Tag	th_FieldBase

Tag	th_FEId

Tag	th_FEName

Tag	th_FEIdCol

Tag	th_FEIdRow

Tag	th_FEIdData

Tag	th_ProblemId

Tag	th_ProblemName

Tag	th_ProblemFEId

Tag	th_ProblemNbDofsRow

Tag	th_ProblemNbDofsCol

Tag	th_ProblemLocalNbDofRow

Tag	th_ProblemGhostNbDofRow

Tag	th_ProblemLocalNbDofCol

Tag	th_ProblemGhostNbDofCol

Tag	th_ProblemShift

Tag	th_ElemType
	Needed for VTK files.

Tag	th_MoFEMBuild

boost::shared_ptr< BasicEntityData >	basicEntityDataPtr

RefEntity_multiIndex	refinedEntities
	refined entities

RefElement_multiIndex	refinedFiniteElements
	refined elements

Field_multiIndex	fIelds
	fields

FieldEntity_multiIndex	entsFields
	entities on fields

DofEntity_multiIndex	dofsField
	dofs on fields

FiniteElement_multiIndex	finiteElements
	finite elements

EntFiniteElement_multiIndex	entsFiniteElements
	finite element entities

FieldEntityEntFiniteElementAdjacencyMap_multiIndex	entFEAdjacencies
	adjacencies of elements to dofs

Problem_multiIndex	pRoblems
	problems multi-index

std::reference_wrapper< moab::Interface >	moab
	moab database

PetscLogEvent	MOFEM_EVENT_preProcess
	Event for preProcess finite element.

PetscLogEvent	MOFEM_EVENT_operator
	Event for evaluating operator of finite element.

PetscLogEvent	MOFEM_EVENT_postProcess
	Event for postProcess finite element.

PetscLogEvent	MOFEM_EVENT_createMat

MPI_Comm	mofemComm
	MoFEM communicator.

ParallelComm *	pComm
	MOAB communicator structure.

int	sIze
	MoFEM communicator size.

int	rAnk
	MOFEM communicator rank.

Static Protected Attributes inherited from MoFEM::CoreTmp< 0 >
static bool	isGloballyInitialised = false
	Core base globally initialized.

static int	mpiInitialised
	mpi was initialised by other agent

static PetscBool	isInitialized
	petsc was initialised by other agent

Detailed Description

Create compressed matrix.

Note: Only function class members are allowed in this class. NO VARIABLES.

Todo: It is obsolete implementation, code should be moved to interface MatrixManager.

Todo: While matrix is created is assumed that all entities on element are adjacent to each other, in some cases, this is created denser matrices than it should be. Some kind of filtering can be added.

Todo: Creation of the block matrices

Todo: Some efficiency improvement are possible

Definition at line 33 of file MatrixManager.cpp.

Member Typedef Documentation

◆ AdjByEnt

using MoFEM::CreateRowCompressedADJMatrix::AdjByEnt

private

Initial value:

FieldEntityEntFiniteElementAdjacencyMap_multiIndex::index<

Unique_mi_tag>::type

Definition at line 58 of file MatrixManager.cpp.

◆ DofByGlobalPetscIndex

using MoFEM::CreateRowCompressedADJMatrix::DofByGlobalPetscIndex

private

Initial value:

NumeredDofEntity_multiIndex::index<PetscGlobalIdx_mi_tag>::type

Definition at line 61 of file MatrixManager.cpp.

◆ ProblemsByName

using MoFEM::CreateRowCompressedADJMatrix::ProblemsByName = Problem_multiIndex::index<Problem_mi_tag>::type

Definition at line 40 of file MatrixManager.cpp.

Constructor & Destructor Documentation

◆ CreateRowCompressedADJMatrix()

MoFEM::CreateRowCompressedADJMatrix::CreateRowCompressedADJMatrix	(	moab::Interface &	moab,
		MPI_Comm	comm = PETSC_COMM_WORLD,
		int	verbose = 1 )

inline

Definition at line 35 of file MatrixManager.cpp.

38 : Core(moab, comm, verbose) {}

MoFEM::Core

CoreTmp< 0 > Core

Definition Core.hpp:1148

MoFEM::CoreTmp< 0 >::verbose

int verbose

Verbosity level.

Definition Core.hpp:1039

MoFEM::CoreTmp< 0 >::moab

std::reference_wrapper< moab::Interface > moab

moab database

Definition Core.hpp:321

Member Function Documentation

◆ createMatArrays()

template<typename TAG >

MoFEMErrorCode MoFEM::CreateRowCompressedADJMatrix::createMatArrays	(	ProblemsByName::iterator	p_miit,
		const MatType	type,
		std::vector< PetscInt > &	i,
		std::vector< PetscInt > &	j,
		const bool	no_diagonals = true,
		int	verb = QUIET ) const

Create matrix adjacencies.

Depending on TAG type, which some structure used to number dofs, matrix is partitioned using part number stored in multi-index, or is partitioned on parts based only on index number.

See: Idx_mi_tag PetscGlobalIdx_mi_tag and PetscLocalIdx_mi_tag

Definition at line 160 of file MatrixManager.cpp.

                    {
  MatrixManagerFunctionBegin;
 
  PetscLogEventBegin(MOFEM_EVENT_createMat, 0, 0, 0, 0);
 
  auto cache = boost::make_shared<std::vector<EntityCacheNumeredDofs>>(
      entsFields.size());
 
  size_t idx = 0;
  for (auto it = entsFields.begin(); it != entsFields.end(); ++it, ++idx) {
 
    const auto uid = (*it)->getLocalUniqueId();
    auto r = entFEAdjacencies.get<Unique_mi_tag>().equal_range(uid);
    for (auto lo = r.first; lo != r.second; ++lo) {
 
      if ((lo->getBitFEId() & p_miit->getBitFEId()).any()) {
 
        const BitRefLevel &prb_bit = p_miit->getBitRefLevel();
        const BitRefLevel &prb_mask = p_miit->getBitRefLevelMask();
        const BitRefLevel &fe_bit = lo->entFePtr->getBitRefLevel();
 
        // if entity is not problem refinement level
        if ((fe_bit & prb_mask) != fe_bit)
          continue;
        if ((fe_bit & prb_bit).none())
          continue;
 
        auto dit = p_miit->numeredColDofsPtr->lower_bound(uid);
 
        decltype(dit) hi_dit;
        if (dit != p_miit->numeredColDofsPtr->end())
          hi_dit = p_miit->numeredColDofsPtr->upper_bound(
              uid | static_cast<UId>(MAX_DOFS_ON_ENTITY - 1));
        else
          hi_dit = dit;
 
        (*it)->entityCacheColDofs =
            boost::shared_ptr<EntityCacheNumeredDofs>(cache, &((*cache)[idx]));
        (*cache)[idx].loHi = {dit, hi_dit};
 
        break;
      }
    }
  }
 
  using NumeredDofEntitysByIdx =
      typename boost::multi_index::index<NumeredDofEntity_multiIndex,
                                         TAG>::type;
 
  // Get multi-indices for rows and columns
  const NumeredDofEntitysByIdx &dofs_row_by_idx =
      p_miit->numeredRowDofsPtr->get<TAG>();
  int nb_dofs_row = p_miit->getNbDofsRow();
  if (nb_dofs_row == 0) {
    SETERRQ(mofemComm, MOFEM_DATA_INCONSISTENCY, "problem <%s> has zero rows",
             p_miit->getName().c_str());
  }
 
  // Get adjacencies form other processors
  std::map<int, std::vector<int>> adjacent_dofs_on_other_parts;
 
  // If not partitioned set petsc layout for matrix. If partitioned need to get
  // adjacencies form other parts. Note if algebra is only partitioned no need
  // to collect adjacencies form other entities. Those are already on mesh
  // which is assumed that is on each processor the same.
  typename boost::multi_index::index<NumeredDofEntity_multiIndex,
                                     TAG>::type::iterator miit_row,
      hi_miit_row;
 
  if (TAG::IamNotPartitioned) {
 
    // Get range of local indices
    PetscLayout layout;
    CHKERR PetscLayoutCreate(mofemComm, &layout);
    CHKERR PetscLayoutSetBlockSize(layout, 1);
    CHKERR PetscLayoutSetSize(layout, nb_dofs_row);
    CHKERR PetscLayoutSetUp(layout);
    PetscInt rstart, rend;
    CHKERR PetscLayoutGetRange(layout, &rstart, &rend);
    CHKERR PetscLayoutDestroy(&layout);
 
    if (verb >= VERBOSE) {
      MOFEM_LOG("SYNC", Sev::noisy)
          << "row lower " << rstart << " row upper " << rend;
      MOFEM_LOG_SYNCHRONISE(mofemComm)
    }
 
    miit_row = dofs_row_by_idx.lower_bound(rstart);
    hi_miit_row = dofs_row_by_idx.lower_bound(rend);
    if (std::distance(miit_row, hi_miit_row) != rend - rstart) {
      SETERRQ(
          mofemComm, PETSC_ERR_ARG_SIZ,
          "data inconsistency, std::distance(miit_row,hi_miit_row) != rend - "
          "rstart (%ld != %d - %d = %d) ",
          std::distance(miit_row, hi_miit_row), rend, rstart, rend - rstart);
    }
 
  } else {
 
    MPI_Comm comm;
    // // Make sure it is a PETSc mofemComm
    CHKERR PetscCommDuplicate(get_comm(), &comm, NULL);
 
    // get adjacent nodes on other partitions
    std::vector<std::vector<int>> dofs_vec(sIze);
 
    boost::shared_ptr<FieldEntity> mofem_ent_ptr;
    std::vector<int> dofs_col_view;
 
    typename boost::multi_index::index<NumeredDofEntity_multiIndex,
                                       TAG>::type::iterator mit_row,
        hi_mit_row;
 
    mit_row = dofs_row_by_idx.begin();
    hi_mit_row = dofs_row_by_idx.end();
    for (; mit_row != hi_mit_row; mit_row++) {
 
      // Shared or multi-shared row and not owned. Those data should be send to
      // other side.
 
      // Get entity adjacencies, no need to repeat that operation for dofs when
      // are on the same entity. For simplicity is assumed that those sheered
      // the same adjacencies.
      unsigned char pstatus = (*mit_row)->getPStatus();
      if ((pstatus & PSTATUS_NOT_OWNED) &&
          (pstatus & (PSTATUS_SHARED | PSTATUS_MULTISHARED))) {
 
        bool get_adj_col = true;
        if (mofem_ent_ptr) {
          if (mofem_ent_ptr->getLocalUniqueId() ==
              (*mit_row)->getFieldEntityPtr()->getLocalUniqueId()) {
            get_adj_col = false;
          }
        }
 
        if (get_adj_col) {
          // Get entity adjacencies
          mofem_ent_ptr = (*mit_row)->getFieldEntityPtr();
          CHKERR getEntityAdjacencies<TAG>(p_miit, mit_row, mofem_ent_ptr,
                                           dofs_col_view, verb);
          // Sort, unique and resize dofs_col_view
          {
            std::sort(dofs_col_view.begin(), dofs_col_view.end());
            std::vector<int>::iterator new_end =
                std::unique(dofs_col_view.begin(), dofs_col_view.end());
            int new_size = std::distance(dofs_col_view.begin(), new_end);
            dofs_col_view.resize(new_size);
          }
          // Add that row. Patterns is that first index is row index, second is
          // size of adjacencies after that follows column adjacencies.
          int owner = (*mit_row)->getOwnerProc();
          dofs_vec[owner].emplace_back(TAG::get_index(mit_row)); // row index
          dofs_vec[owner].emplace_back(
              dofs_col_view.size()); // nb. of column adjacencies
          // add adjacent cools
          dofs_vec[owner].insert(dofs_vec[owner].end(), dofs_col_view.begin(),
                                 dofs_col_view.end());
        }
      }
    }
 
    int nsends = 0;                         // number of messages to send
    std::vector<int> dofs_vec_length(sIze); // length of the message to proc
    for (int proc = 0; proc < sIze; proc++) {
 
      if (!dofs_vec[proc].empty()) {
 
        dofs_vec_length[proc] = dofs_vec[proc].size();
        nsends++;
 
      } else {
 
        dofs_vec_length[proc] = 0;
      }
    }
 
    std::vector<MPI_Status> status(sIze);
 
    // Computes the number of messages a node expects to receive
    int nrecvs; // number of messages received
    CHKERR PetscGatherNumberOfMessages(comm, NULL, &dofs_vec_length[0],
                                       &nrecvs);
 
    // Computes info about messages that a MPI-node will receive, including
    // (from-id,length) pairs for each message.
    int *onodes;   // list of node-ids from which messages are expected
    int *olengths; // corresponding message lengths
    CHKERR PetscGatherMessageLengths(comm, nsends, nrecvs, &dofs_vec_length[0],
                                     &onodes, &olengths);
 
    // Gets a unique new tag from a PETSc communicator.
    int tag;
    CHKERR PetscCommGetNewTag(comm, &tag);
 
    // Allocate a buffer sufficient to hold messages of size specified in
    // olengths. And post Irecvs on these buffers using node info from onodes
    int **rbuf;           // must bee freed by user
    MPI_Request *r_waits; // must bee freed by user
 
    // rbuf has a pointers to messages. It has size of of nrecvs (number of
    // messages) +1. In the first index a block is allocated,
    // such that rbuf[i] = rbuf[i-1]+olengths[i-1].
    CHKERR PetscPostIrecvInt(comm, tag, nrecvs, onodes, olengths, &rbuf,
                             &r_waits);
 
    MPI_Request *s_waits; // status of sens messages
    CHKERR PetscMalloc1(nsends, &s_waits);
 
    // Send messages
    for (int proc = 0, kk = 0; proc < sIze; proc++) {
      if (!dofs_vec_length[proc])
        continue;                             // no message to send to this proc
      CHKERR MPI_Isend(&(dofs_vec[proc])[0],  // buffer to send
                       dofs_vec_length[proc], // message length
                       MPIU_INT, proc,        // to proc
                       tag, comm, s_waits + kk);
      kk++;
    }
 
    // Wait for received
    if (nrecvs) {
      CHKERR MPI_Waitall(nrecvs, r_waits, &status[0]);
    }
    // Wait for send messages
    if (nsends) {
      CHKERR MPI_Waitall(nsends, s_waits, &status[0]);
    }
 
    for (int kk = 0; kk < nrecvs; kk++) {
 
      int len = olengths[kk];
      int *data_from_proc = rbuf[kk];
 
      for (int ii = 0; ii < len;) {
 
        int row_idx = data_from_proc[ii++];     // get row number
        int nb_adj_dofs = data_from_proc[ii++]; // get nb. of adjacent dofs
 
        if (debug) {
 
          DofByGlobalPetscIndex::iterator dit;
          dit = p_miit->numeredRowDofsPtr->get<PetscGlobalIdx_mi_tag>().find(
              row_idx);
          if (dit ==
              p_miit->numeredRowDofsPtr->get<PetscGlobalIdx_mi_tag>().end()) {
            SETERRQ(get_comm(), MOFEM_DATA_INCONSISTENCY,
                     "dof %d can not be found in problem", row_idx);
          }
        }
 
        for (int jj = 0; jj < nb_adj_dofs; jj++) {
          adjacent_dofs_on_other_parts[row_idx].push_back(data_from_proc[ii++]);
        }
      }
    }
 
    // Cleaning
    CHKERR PetscFree(s_waits);
    CHKERR PetscFree(rbuf[0]);
    CHKERR PetscFree(rbuf);
    CHKERR PetscFree(r_waits);
    CHKERR PetscFree(onodes);
    CHKERR PetscFree(olengths);
 
    miit_row = dofs_row_by_idx.begin();
    hi_miit_row = dofs_row_by_idx.end();
 
    CHKERR PetscCommDestroy(&comm);
  }
 
  boost::shared_ptr<FieldEntity> mofem_ent_ptr;
  int row_last_evaluated_idx = -1;
 
  std::vector<int> dofs_vec;
  std::vector<int> dofs_col_view;
 
  // loop local rows
  int nb_loc_row_from_iterators = 0;
  unsigned int rows_to_fill = p_miit->getNbLocalDofsRow();
  i.reserve(rows_to_fill + 1);
  for (; miit_row != hi_miit_row; miit_row++) {
 
    if (!TAG::IamNotPartitioned) {
      if (static_cast<int>((*miit_row)->getPart()) != rAnk)
        continue;
    }
    // This is only for cross-check if everything is ok
    nb_loc_row_from_iterators++;
 
    // add next row to compressed matrix
    i.push_back(j.size());
 
    // Get entity adjacencies, no need to repeat that operation for dofs when
    // are on the same entity. For simplicity is assumed that those share the
    // same adjacencies.
    if ((!mofem_ent_ptr)
            ? 1
            : (mofem_ent_ptr->getLocalUniqueId() !=
               (*miit_row)->getFieldEntityPtr()->getLocalUniqueId())) {
 
      // get entity adjacencies
      mofem_ent_ptr = (*miit_row)->getFieldEntityPtr();
      CHKERR getEntityAdjacencies<TAG>(p_miit, miit_row, mofem_ent_ptr,
                                       dofs_col_view, verb);
      row_last_evaluated_idx = TAG::get_index(miit_row);
 
      dofs_vec.resize(0);
      // insert dofs_col_view
      dofs_vec.insert(dofs_vec.end(), dofs_col_view.begin(),
                      dofs_col_view.end());
 
      unsigned char pstatus = (*miit_row)->getPStatus();
      if (pstatus > 0) {
        std::map<int, std::vector<int>>::iterator mit;
        mit = adjacent_dofs_on_other_parts.find(row_last_evaluated_idx);
        if (mit == adjacent_dofs_on_other_parts.end()) {
          // NOTE: Dof can adjacent to other part but no elements are there
          // which use that dof std::cerr << *miit_row << std::endl; SETERRQ(
          //   get_comm(),MOFEM_DATA_INCONSISTENCY,
          //   "data inconsistency row_last_evaluated_idx = %d",
          //   row_last_evaluated_idx
          // );
        } else {
          dofs_vec.insert(dofs_vec.end(), mit->second.begin(),
                          mit->second.end());
        }
      }
 
      // sort and make unique
      sort(dofs_vec.begin(), dofs_vec.end());
      std::vector<int>::iterator new_end =
          unique(dofs_vec.begin(), dofs_vec.end());
      int new_size = std::distance(dofs_vec.begin(), new_end);
      dofs_vec.resize(new_size);
    }
 
    // Try to be smart reserving memory
    if (j.capacity() < j.size() + dofs_vec.size()) {
 
      // TODO: [CORE-55] Improve algorithm estimating size of compressed matrix
      unsigned int nb_nonzero = j.size() + dofs_vec.size();
      unsigned int average_row_fill = nb_nonzero / i.size() + 1;
      j.reserve(rows_to_fill * average_row_fill);
    }
 
    auto hi_diit = dofs_vec.end();
    for (auto diit = dofs_vec.begin(); diit != hi_diit; diit++) {
 
      if (no_diagonals) {
        if (*diit == TAG::get_index(miit_row)) {
          continue;
        }
      }
      j.push_back(*diit);
    }
  }
 
  // build adj matrix
  i.push_back(j.size());
 
  if (strcmp(type, MATMPIADJ) == 0) {
 
    // Adjacency matrix used to partition problems, f.e. METIS
    if (i.size() - 1 != (unsigned int)nb_loc_row_from_iterators) {
      SETERRQ(
          get_comm(), PETSC_ERR_ARG_SIZ,
          "Number of rows from iterator is different than size of rows in "
          "compressed row "
          "matrix (unsigned int)nb_local_dofs_row != i.size() - 1, i.e. %d != "
          "%ld",
          (unsigned int)nb_loc_row_from_iterators, i.size() - 1);
    }
 
  } else if (strcmp(type, MATMPIAIJ) == 0) {
 
    // Compressed MPIADJ matrix
    if (i.size() - 1 != (unsigned int)nb_loc_row_from_iterators) {
      SETERRQ(
          get_comm(), PETSC_ERR_ARG_SIZ,
          "Number of rows from iterator is different than size of rows in "
          "compressed row "
          "matrix (unsigned int)nb_local_dofs_row != i.size() - 1, i.e. %d != "
          "%ld",
          (unsigned int)nb_loc_row_from_iterators, i.size() - 1);
    }
    PetscInt nb_local_dofs_row = p_miit->getNbLocalDofsRow();
    if ((unsigned int)nb_local_dofs_row != i.size() - 1) {
      SETERRQ(
          get_comm(), PETSC_ERR_ARG_SIZ,
          "Number of rows is different than size of rows in compressed row "
          "matrix (unsigned int)nb_local_dofs_row != i.size() - 1, i.e. %d != "
          "%ld",
          (unsigned int)nb_local_dofs_row, i.size() - 1);
    }
 
  } else if (strcmp(type, MATAIJ) == 0) {
 
    // Sequential compressed ADJ matrix
    if (i.size() - 1 != (unsigned int)nb_loc_row_from_iterators) {
      SETERRQ(
          get_comm(), PETSC_ERR_ARG_SIZ,
          "Number of rows form iterator is different than size of rows in "
          "compressed row "
          "matrix (unsigned int)nb_local_dofs_row != i.size() - 1, i.e. %d != "
          "%ld",
          (unsigned int)nb_loc_row_from_iterators, i.size() - 1);
    }
    PetscInt nb_local_dofs_row = p_miit->getNbLocalDofsRow();
    if ((unsigned int)nb_local_dofs_row != i.size() - 1) {
      SETERRQ(
          get_comm(), PETSC_ERR_ARG_SIZ,
          "Number of rows is different than size of rows in compressed row "
          "matrix (unsigned int)nb_local_dofs_row != i.size() - 1, i.e. %d != "
          "%ld",
          (unsigned int)nb_local_dofs_row, i.size() - 1);
    }
 
  } else if (strcmp(type, MATAIJCUSPARSE) == 0) {
 
    if (i.size() - 1 != (unsigned int)nb_loc_row_from_iterators) {
      SETERRQ(get_comm(), PETSC_ERR_ARG_SIZ, "data inconsistency");
    }
    PetscInt nb_local_dofs_row = p_miit->getNbLocalDofsRow();
    if ((unsigned int)nb_local_dofs_row != i.size() - 1) {
      SETERRQ(get_comm(), PETSC_ERR_ARG_SIZ, "data inconsistency");
    }
 
  } else {
 
    SETERRQ(get_comm(), PETSC_ERR_ARG_NULL, "not implemented");
  }
 
  PetscLogEventEnd(MOFEM_EVENT_createMat, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

◆ getEntityAdjacencies()

template<typename TAG >

MoFEMErrorCode MoFEM::CreateRowCompressedADJMatrix::getEntityAdjacencies	(	ProblemsByName::iterator	p_miit,
		typename boost::multi_index::index< NumeredDofEntity_multiIndex, TAG >::type::iterator	mit_row,
		boost::shared_ptr< FieldEntity >	mofem_ent_ptr,
		std::vector< int > &	dofs_col_view,
		int	verb ) const

private

Get element adjacencies.

Definition at line 81 of file MatrixManager.cpp.

                                                   {
  MoFEMFunctionBegin;
 
  BitRefLevel prb_bit = p_miit->getBitRefLevel();
  BitRefLevel prb_mask = p_miit->getBitRefLevelMask();
 
  const EmptyFieldBlocks &empty_field_blocks = p_miit->getEmptyFieldBlocks();
 
  dofs_col_view.clear();
  for (auto r = entFEAdjacencies.get<Unique_mi_tag>().equal_range(
           mofem_ent_ptr->getLocalUniqueId());
       r.first != r.second; ++r.first) {
 
    if (r.first->byWhat & BYROW) {
 
      if ((r.first->entFePtr->getId() & p_miit->getBitFEId()).none()) {
        // if element is not part of problem
        continue;
      }
 
      const BitRefLevel &fe_bit = r.first->entFePtr->getBitRefLevel();
      // if entity is not problem refinement level
      if ((fe_bit & prb_bit).any() && (fe_bit & prb_mask) == fe_bit) {
 
        auto check_block = [&empty_field_blocks](auto &r_if, auto &col_id) {
          for (auto &b : empty_field_blocks) {
            if ((b.first & r_if).any() && (b.second & col_id).any()) {
              return false;
            }
          }
          return true;
        };
 
        for (auto &it : r.first->entFePtr->getColFieldEnts()) {
          if (auto e = it.lock()) {
 
            if (check_block((*mit_row)->getId(), e->getId())) {
 
              if (auto cache = e->entityCacheColDofs.lock()) {
                const auto lo = cache->loHi[0];
                const auto hi = cache->loHi[1];
                for (auto vit = lo; vit != hi; ++vit) {
 
                  const int idx = TAG::get_index(vit);
                  if (PetscLikely(idx >= 0))
                    dofs_col_view.push_back(idx);
 
#ifndef NDEBUG
                  const DofIdx nb_dofs_col = p_miit->getNbDofsCol();
                  if (PetscUnlikely(idx >= nb_dofs_col)) {
                    MOFEM_LOG("SELF", Sev::error)
                        << "Problem with dof: " << std::endl
                        << "Rank " << rAnk << " : " << *(*vit);
                    SETERRQ(
                        mofemComm, PETSC_ERR_ARG_SIZ,
                        "Index of dof larger than number of DOFs in column");
                  }
#endif
                }
 
              } else {
                SETERRQ(mofemComm, MOFEM_DATA_INCONSISTENCY, "Cache not set");
              }
            }
          }
        }
      }
    }
  }
 
  MoFEMFunctionReturn(0);
}

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

src/interfaces/impl/MatrixManager.cpp

Public Types

Public Member Functions

Private Types

Private Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ AdjByEnt

◆ DofByGlobalPetscIndex

◆ ProblemsByName

Constructor & Destructor Documentation

◆ CreateRowCompressedADJMatrix()

Member Function Documentation

◆ createMatArrays()

◆ getEntityAdjacencies()