libMesh::DofMap Class Reference

This class handles the numbering of degrees of freedom on a mesh. More...

#include <dof_map.h>

Inheritance diagram for libMesh::DofMap:

Classes
class	AugmentSendList
	Abstract base class to be used to add user-defined parallel degree of freedom couplings. More...
class	AugmentSparsityPattern
	Backwards compatibility for prior AugmentSparsityPattern users. More...

Public Types
typedef std::vector< GhostingFunctor * >::const_iterator	GhostingFunctorIterator
	Iterator type for coupling and algebraic ghosting functor ranges.

Public Member Functions
	DofMap (const unsigned int sys_number, MeshBase &mesh)
	Constructor.
	~DofMap ()
	Destructor.
void	attach_matrix (SparseMatrix< Number > &matrix)
	Additional matrices may be attached to this DofMap.
void	update_sparsity_pattern (SparseMatrix< Number > &matrix) const
	Additional matrices may be be temporarily initialized by this DofMap.
bool	is_attached (SparseMatrix< Number > &matrix)
	Matrices should not be attached more than once.
std::size_t	distribute_dofs (MeshBase &)
	Distribute dofs on the current mesh.
void	compute_sparsity (const MeshBase &)
	Computes the sparsity pattern for the matrices corresponding to proc_id and sends that data to Linear Algebra packages for preallocation of sparse matrices.
bool	computed_sparsity_already () const
	Returns true iff a sparsity pattern has already been computed.
void	set_constrained_sparsity_construction (bool use_constraints)
	Sets the current policy for constructing sparsity patterns: if use_constraints is true (for robustness), we explicitly account for sparsity entries created by constraint matrix pre- and post- application.
void	full_sparsity_pattern_needed ()
	Sets need_full_sparsity_pattern to true regardless of the requirements by matrices.
bool	constrained_sparsity_construction ()
	Returns true iff the current policy when constructing sparsity patterns is to explicitly account for sparsity entries created by constraint matrix pre- and post- application.
void	clear_sparsity ()
	Clears the sparsity pattern.
void	remove_default_ghosting ()
	Remove any default ghosting functor(s).
void	add_default_ghosting ()
	Add the default functor(s) for coupling and algebraic ghosting.
void	add_coupling_functor (GhostingFunctor &coupling_functor, bool to_mesh=true)
	Adds a functor which can specify coupling requirements for creation of sparse matrices.
void	add_coupling_functor (std::shared_ptr< GhostingFunctor > coupling_functor, bool to_mesh=true)
	Adds a functor which can specify coupling requirements for creation of sparse matrices.
void	remove_coupling_functor (GhostingFunctor &coupling_functor)
	Removes a functor which was previously added to the set of coupling functors, from both this DofMap and from the underlying mesh.
GhostingFunctorIterator	coupling_functors_begin () const
	Beginning of range of coupling functors.
GhostingFunctorIterator	coupling_functors_end () const
	End of range of coupling functors.
DefaultCoupling &	default_coupling ()
	Default coupling functor.
void	add_algebraic_ghosting_functor (GhostingFunctor &evaluable_functor, bool to_mesh=true)
	Adds a functor which can specify algebraic ghosting requirements for use with distributed vectors.
void	add_algebraic_ghosting_functor (std::shared_ptr< GhostingFunctor > evaluable_functor, bool to_mesh=true)
	Adds a functor which can specify algebraic ghosting requirements for use with distributed vectors.
void	remove_algebraic_ghosting_functor (GhostingFunctor &evaluable_functor)
	Removes a functor which was previously added to the set of algebraic ghosting functors, from both this DofMap and from the underlying mesh.
GhostingFunctorIterator	algebraic_ghosting_functors_begin () const
	Beginning of range of algebraic ghosting functors.
GhostingFunctorIterator	algebraic_ghosting_functors_end () const
	End of range of algebraic ghosting functors.
DefaultCoupling &	default_algebraic_ghosting ()
	Default algebraic ghosting functor.
void	attach_extra_sparsity_object (SparsityPattern::AugmentSparsityPattern &asp)
	Attach an object to use to populate the sparsity pattern with extra entries.
void	attach_extra_sparsity_function (void(*func)(SparsityPattern::Graph &sparsity, std::vector< dof_id_type > &n_nz, std::vector< dof_id_type > &n_oz, void *), void *context=nullptr)
	Attach a function pointer to use as a callback to populate the sparsity pattern with extra entries.
void	attach_extra_send_list_object (DofMap::AugmentSendList &asl)
	Attach an object to populate the send_list with extra entries.
void	attach_extra_send_list_function (void(*func)(std::vector< dof_id_type > &, void *), void *context=nullptr)
	Attach a function pointer to use as a callback to populate the send_list with extra entries.
void	prepare_send_list ()
	Takes the _send_list vector (which may have duplicate entries) and sorts it.
void	clear_send_list ()
	Clears the _send_list vector.
void	reinit_send_list (MeshBase &mesh)
	Clears the _send_list vector and then rebuilds it.
const std::vector< dof_id_type > &	get_send_list () const
const std::vector< dof_id_type > &	get_n_nz () const
const std::vector< dof_id_type > &	get_n_oz () const
const SparsityPattern::Build *	get_sparsity_pattern () const
unsigned int	n_vars () const
const std::string &	variable_name (const unsigned int i) const
unsigned int	n_components (const MeshBase &mesh) const
bool	identify_variable_groups () const
void	identify_variable_groups (const bool)
	Toggle automatic VariableGroup identification.
unsigned int	variable_scalar_number (unsigned int var_num, unsigned int component) const
const FEType &	variable_type (const unsigned int i) const
const FEType &	variable_type (std::string_view var) const
unsigned int	variable_number (std::string_view var) const
bool	has_variable (std::string_view var) const
void	get_all_variable_numbers (std::vector< unsigned int > &all_variable_numbers) const
	Fills all_variable_numbers with all the variable numbers for the variables that have been added to this system.
unsigned int	add_variable (System &sys, std::string_view var, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=nullptr)
	Adds the variable var to the list of variables for this system.
unsigned int	add_variables (System &sys, const std::vector< std::string > &vars, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=nullptr)
	Adds the variables vars to the list of variables for this system.
unsigned int	add_variable_array (System &sys, const std::vector< std::string > &vars, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=nullptr)
	Adds variables vars to the list of variables for this system.
void	set_error_on_cyclic_constraint (bool error_on_cyclic_constraint)
	Specify whether or not we perform an extra (opt-mode enabled) check for constraint loops.
void	set_error_on_constraint_loop (bool error_on_constraint_loop)
const VariableGroup &	variable_group (const unsigned int c) const
const Variable &	variable (const unsigned int c) const override
Order	variable_order (const unsigned int c) const
Order	variable_group_order (const unsigned int vg) const
const FEType &	variable_group_type (const unsigned int vg) const
unsigned int	n_variable_groups () const
unsigned int	n_variables () const override
unsigned int	var_group_from_var_number (unsigned int var_num) const
bool	has_blocked_representation () const
unsigned int	block_size () const
dof_id_type	n_dofs (const unsigned int vn) const
dof_id_type	n_SCALAR_dofs () const
dof_id_type	n_local_dofs (const unsigned int vn) const
std::vector< dof_id_type >	n_dofs_per_processor (const unsigned int vn) const
processor_id_type	dof_owner (const dof_id_type dof) const
void	dof_indices (const Elem *const elem, std::vector< dof_id_type > &di) const
void	dof_indices (const Elem *const elem, std::vector< dof_id_type > &di, const unsigned int vn, int p_level=-12345) const override
	Fills the vector di with the global degree of freedom indices for the element.
void	array_dof_indices (const Elem *const elem, std::vector< dof_id_type > &di, const unsigned int vn, int p_level=-12345) const
	Fills the vector di with the global degree of freedom indices for the element.
void	array_dof_indices (const Node *const node, std::vector< dof_id_type > &di, const unsigned int vn) const
template<typename DofIndicesFunctor >
void	array_dof_indices (const DofIndicesFunctor &functor, std::vector< dof_id_type > &di, const unsigned int vn) const
template<typename ScalarDofsFunctor , typename FieldDofsFunctor >
void	dof_indices (const Elem *const elem, std::vector< dof_id_type > &di, const unsigned int vn, ScalarDofsFunctor scalar_dofs_functor, FieldDofsFunctor field_dofs_functor, int p_level=-12345) const
	Retrieves degree of freedom indices for a given elem and then performs actions for these indices defined by the user-provided functors scalar_dofs_functor and field_dofs_functor.
void	dof_indices (const Node *const node, std::vector< dof_id_type > &di) const
	Fills the vector di with the global degree of freedom indices for the node.
void	dof_indices (const Node *const node, std::vector< dof_id_type > &di, const unsigned int vn) const override
	Fills the vector di with the global degree of freedom indices for the node, for one variable vn.
void	dof_indices (const Elem &elem, unsigned int n, std::vector< dof_id_type > &di, const unsigned int vn) const
	Appends to the vector di the global degree of freedom indices for elem.node_ref(n), for one variable vn.
void	old_dof_indices (const Elem &elem, unsigned int n, std::vector< dof_id_type > &di, const unsigned int vn) const
	Appends to the vector di the old global degree of freedom indices for elem.node_ref(n), for one variable vn.
void	SCALAR_dof_indices (std::vector< dof_id_type > &di, const unsigned int vn, const bool old_dofs=false) const
	Fills the vector di with the global degree of freedom indices corresponding to the SCALAR variable vn.
bool	semilocal_index (dof_id_type dof_index) const
bool	all_semilocal_indices (const std::vector< dof_id_type > &dof_indices) const
bool	local_index (dof_id_type dof_index) const
template<typename DofObjectSubclass >
bool	is_evaluable (const DofObjectSubclass &obj, unsigned int var_num=libMesh::invalid_uint) const
void	set_implicit_neighbor_dofs (bool implicit_neighbor_dofs)
	Allow the implicit_neighbor_dofs flag to be set programmatically.
void	set_verify_dirichlet_bc_consistency (bool val)
	Set the _verify_dirichlet_bc_consistency flag.
bool	use_coupled_neighbor_dofs (const MeshBase &mesh) const
	Tells other library functions whether or not this problem includes coupling between dofs in neighboring cells, as can currently be specified on the command line or inferred from the use of all discontinuous variables.
void	extract_local_vector (const NumericVector< Number > &Ug, const std::vector< dof_id_type > &dof_indices, DenseVectorBase< Number > &Ue) const
	Builds the local element vector Ue from the global vector Ug, accounting for any constrained degrees of freedom.
template<typename T , std::enable_if_t< std::is_same_v< T, dof_id_type >||std::is_same_v< T, std::vector< dof_id_type > >, int > = 0>
void	local_variable_indices (T &idx, const MeshBase &mesh, unsigned int var_num) const
	If T == dof_id_type, counts, if T == std::vector<dof_id_type>, fills an array of, those dof indices which belong to the given variable number and live on the current processor.
template<typename T , std::enable_if_t< std::is_same_v< T, dof_id_type >||std::is_same_v< T, std::vector< dof_id_type > >, int > = 0>
void	local_variable_indices (T &idx, unsigned int var_num) const
	If T == dof_id_type, counts, if T == std::vector<dof_id_type>, fills an array of, those dof indices which belong to the given variable number and live on the current processor.
dof_id_type	n_constrained_dofs () const
dof_id_type	n_local_constrained_dofs () const
dof_id_type	n_constrained_nodes () const
void	create_dof_constraints (const MeshBase &, Real time=0)
	Rebuilds the raw degree of freedom and DofObject constraints, based on attached DirichletBoundary objects and on non-conforming interface in adapted meshes.
void	allgather_recursive_constraints (MeshBase &)
	Gathers constraint equation dependencies from other processors.
void	scatter_constraints (MeshBase &)
	Sends constraint equations to constraining processors.
void	gather_constraints (MeshBase &mesh, std::set< dof_id_type > &unexpanded_dofs, bool look_for_constrainees)
	Helper function for querying about constraint equations on other processors.
void	process_constraints (MeshBase &)
	Postprocesses any constrained degrees of freedom to be constrained only in terms of unconstrained dofs, then adds unconstrained dofs to the send_list and prepares that for use.
void	check_for_cyclic_constraints ()
	Throw an error if we detect any constraint loops, i.e.
void	check_for_constraint_loops ()
void	add_constraint_row (const dof_id_type dof_number, const DofConstraintRow &constraint_row, const Number constraint_rhs, const bool forbid_constraint_overwrite)
	Adds a copy of the user-defined row to the constraint matrix, using an inhomogeneous right-hand-side for the constraint equation.
void	add_adjoint_constraint_row (const unsigned int qoi_index, const dof_id_type dof_number, const DofConstraintRow &constraint_row, const Number constraint_rhs, const bool forbid_constraint_overwrite)
	Adds a copy of the user-defined row to the constraint matrix, using an inhomogeneous right-hand-side for the adjoint constraint equation.
void	add_constraint_row (const dof_id_type dof_number, const DofConstraintRow &constraint_row, const bool forbid_constraint_overwrite=true)
	Adds a copy of the user-defined row to the constraint matrix, using a homogeneous right-hand-side for the constraint equation.
DofConstraints::const_iterator	constraint_rows_begin () const
DofConstraints::const_iterator	constraint_rows_end () const
const DofConstraints &	get_dof_constraints () const
	Provide a const accessor to the DofConstraints map.
void	stash_dof_constraints ()
void	unstash_dof_constraints ()
void	swap_dof_constraints ()
	Similar to the stash/unstash_dof_constraints() API, but swaps _dof_constraints and _stashed_dof_constraints without asserting that the source or destination is empty first.
NodeConstraints::const_iterator	node_constraint_rows_begin () const
NodeConstraints::const_iterator	node_constraint_rows_end () const
bool	is_constrained_dof (const dof_id_type dof) const
bool	has_heterogeneous_adjoint_constraints (const unsigned int qoi_num) const
bool	has_heterogenous_adjoint_constraints (const unsigned int qoi_num) const
	Backwards compatibility with misspelling.
Number	has_heterogeneous_adjoint_constraint (const unsigned int qoi_num, const dof_id_type dof) const
Number	has_heterogenous_adjoint_constraint (const unsigned int qoi_num, const dof_id_type dof) const
	Backwards compatibility with misspelling.
DofConstraintValueMap &	get_primal_constraint_values ()
bool	is_constrained_node (const Node *node) const
void	print_dof_constraints (std::ostream &os=libMesh::out, bool print_nonlocal=false) const
	Prints (from processor 0) all DoF and Node constraints.
std::string	get_local_constraints (bool print_nonlocal=false) const
	Gets a string reporting all DoF and Node constraints local to this processor.
std::pair< Real, Real >	max_constraint_error (const System &system, NumericVector< Number > *v=nullptr) const
	Tests the constrained degrees of freedom on the numeric vector v, which represents a solution defined on the mesh, returning a pair whose first entry is the maximum absolute error on a constrained DoF and whose second entry is the maximum relative error.
void	constrain_element_matrix (DenseMatrix< Number > &matrix, std::vector< dof_id_type > &elem_dofs, bool asymmetric_constraint_rows=true) const
	Constrains the element matrix.
void	constrain_element_matrix (DenseMatrix< Number > &matrix, std::vector< dof_id_type > &row_dofs, std::vector< dof_id_type > &col_dofs, bool asymmetric_constraint_rows=true) const
	Constrains the element matrix.
void	constrain_element_vector (DenseVector< Number > &rhs, std::vector< dof_id_type > &dofs, bool asymmetric_constraint_rows=true) const
	Constrains the element vector.
void	constrain_element_matrix_and_vector (DenseMatrix< Number > &matrix, DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, bool asymmetric_constraint_rows=true) const
	Constrains the element matrix and vector.
void	heterogeneously_constrain_element_matrix_and_vector (DenseMatrix< Number > &matrix, DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, bool asymmetric_constraint_rows=true, int qoi_index=-1) const
	Constrains the element matrix and vector.
void	heterogenously_constrain_element_matrix_and_vector (DenseMatrix< Number > &matrix, DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, bool asymmetric_constraint_rows=true, int qoi_index=-1) const
void	heterogeneously_constrain_element_vector (const DenseMatrix< Number > &matrix, DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, bool asymmetric_constraint_rows=true, int qoi_index=-1) const
	Constrains the element vector.
void	heterogenously_constrain_element_vector (const DenseMatrix< Number > &matrix, DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, bool asymmetric_constraint_rows=true, int qoi_index=-1) const
void	heterogeneously_constrain_element_jacobian_and_residual (DenseMatrix< Number > &matrix, DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, NumericVector< Number > &solution_local) const
	Constrains the element Jacobian and residual.
void	heterogeneously_constrain_element_residual (DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, NumericVector< Number > &solution_local) const
	Constrains the element residual.
void	constrain_element_residual (DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, NumericVector< Number > &solution_local) const
	Constrains the element residual.
void	constrain_element_dyad_matrix (DenseVector< Number > &v, DenseVector< Number > &w, std::vector< dof_id_type > &row_dofs, bool asymmetric_constraint_rows=true) const
	Constrains a dyadic element matrix B = v w'.
void	constrain_nothing (std::vector< dof_id_type > &dofs) const
	Does not actually constrain anything, but modifies dofs in the same way as any of the constrain functions would do, i.e.
void	enforce_constraints_exactly (const System &system, NumericVector< Number > *v=nullptr, bool homogeneous=false) const
	Constrains the numeric vector v, which represents a solution defined on the mesh.
void	enforce_adjoint_constraints_exactly (NumericVector< Number > &v, unsigned int q) const
	Heterogeneously constrains the numeric vector v, which represents an adjoint solution defined on the mesh for quantity fo interest q.
void	enforce_constraints_on_residual (const NonlinearImplicitSystem &system, NumericVector< Number > *rhs, NumericVector< Number > const *solution, bool homogeneous=true) const
void	enforce_constraints_on_jacobian (const NonlinearImplicitSystem &system, SparseMatrix< Number > *jac) const
void	add_periodic_boundary (const PeriodicBoundaryBase &periodic_boundary)
	Adds a copy of the specified periodic boundary to the system.
void	add_periodic_boundary (const PeriodicBoundaryBase &boundary, const PeriodicBoundaryBase &inverse_boundary)
	Add a periodic boundary pair.
bool	is_periodic_boundary (const boundary_id_type boundaryid) const
PeriodicBoundaries *	get_periodic_boundaries ()
const PeriodicBoundaries *	get_periodic_boundaries () const
void	add_dirichlet_boundary (const DirichletBoundary &dirichlet_boundary)
	Adds a copy of the specified Dirichlet boundary to the system.
void	add_adjoint_dirichlet_boundary (const DirichletBoundary &dirichlet_boundary, unsigned int q)
	Adds a copy of the specified Dirichlet boundary to the system, corresponding to the adjoint problem defined by Quantity of Interest q.
void	remove_dirichlet_boundary (const DirichletBoundary &dirichlet_boundary)
	Removes the specified Dirichlet boundary from the system.
void	remove_adjoint_dirichlet_boundary (const DirichletBoundary &dirichlet_boundary, unsigned int q)
	Removes from the system the specified Dirichlet boundary for the adjoint equation defined by Quantity of interest index q.
const DirichletBoundaries *	get_dirichlet_boundaries () const
DirichletBoundaries *	get_dirichlet_boundaries ()
bool	has_adjoint_dirichlet_boundaries (unsigned int q) const
const DirichletBoundaries *	get_adjoint_dirichlet_boundaries (unsigned int q) const
DirichletBoundaries *	get_adjoint_dirichlet_boundaries (unsigned int q)
void	check_dirichlet_bcid_consistency (const MeshBase &mesh, const DirichletBoundary &boundary) const
	Check that all the ids in dirichlet_bcids are actually present in the mesh.
void	old_dof_indices (const Elem *const elem, std::vector< dof_id_type > &di, const unsigned int vn=libMesh::invalid_uint) const
	After a mesh is refined and repartitioned it is possible that the _send_list will need to be augmented.
void	constrain_p_dofs (unsigned int var, const Elem *elem, unsigned int s, unsigned int p)
	Constrains degrees of freedom on side s of element elem which correspond to variable number var and to p refinement levels above p.
void	reinit (MeshBase &mesh, const std::map< const Node *, std::set< subdomain_id_type > > &constraining_subdomains)
	Reinitialize the underlying data structures conformal to the current mesh.
virtual void	clear () override
	Free all new memory associated with the object, but restore its original state, with the mesh pointer and any default ghosting.
void	print_info (std::ostream &os=libMesh::out) const
	Prints summary info about the sparsity bandwidth and constraints.
std::string	get_info () const
	Gets summary info about the sparsity bandwidth and constraints.
unsigned int	sys_number () const
std::unique_ptr< SparsityPattern::Build >	build_sparsity (const MeshBase &mesh, bool calculate_constrained=false, bool use_condensed_system=false) const
	Builds a sparsity pattern for matrices using the current degree-of-freedom numbering and coupling.
void	should_p_refine (unsigned int g, bool p_refine)
	Set whether the given variable group should be p-refined on a p-refined Elem.
bool	should_p_refine (unsigned int g) const
	Whether the given variable group should be p-refined.
bool	should_p_refine_var (unsigned int var) const
	Whether the given variable should be p-refined.
void	should_p_refine (FEFamily, bool)=delete
void	should_p_refine (Order, bool)=delete
bool	should_p_refine (FEFamily) const =delete
bool	should_p_refine (Order) const =delete
void	create_static_condensation (MeshBase &mesh, System &system)
	Add a static condensation class.
bool	has_static_condensation () const
	Checks whether we have static condensation.
StaticCondensationDofMap &	get_static_condensation ()
const StaticCondensationDofMap &	get_static_condensation () const
void	reinit_static_condensation ()
	Calls reinit on the static condensation map if it exists.
dof_id_type	n_dofs () const
dof_id_type	n_local_dofs () const
dof_id_type	first_dof (const processor_id_type proc) const
dof_id_type	first_dof () const
dof_id_type	end_dof (const processor_id_type proc) const
dof_id_type	end_dof () const
dof_id_type	n_dofs_on_processor (const processor_id_type proc) const
dof_id_type	n_old_dofs () const
dof_id_type	first_old_dof (const processor_id_type proc) const
dof_id_type	first_old_dof () const
dof_id_type	end_old_dof (const processor_id_type proc) const
dof_id_type	end_old_dof () const
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Static Public Member Functions
static std::string	get_info ()
	Gets a string containing the reference information.
static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to libMesh::out.
static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects.
static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info().
static void	disable_print_counter_info ()

Public Attributes
CouplingMatrix *	_dof_coupling
	Degree of freedom coupling.

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
	Data structure to log the information.

Protected Member Functions
std::size_t	compute_dof_info (dof_id_type n_local_dofs)
	compute the key degree of freedom information given the local number of degrees of freedom on this process
void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter.
void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter.

Protected Attributes
std::vector< dof_id_type >	_first_df
	First DOF index on processor p.
std::vector< dof_id_type >	_end_df
	Last DOF index (plus 1) on processor p.
dof_id_type	_n_dfs
	Total number of degrees of freedom.
dof_id_type	_n_old_dfs
	Total number of degrees of freedom on old dof objects.
std::vector< dof_id_type >	_first_old_df
	First old DOF index on processor p.
std::vector< dof_id_type >	_end_old_df
	Last old DOF index (plus 1) on processor p.
const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts
	Actually holds the data.
static Threads::atomic< unsigned int >	_n_objects
	The number of objects.
static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting.
static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called.

Private Types
typedef DofObject *(DofMap::*	dofobject_accessor) (MeshBase &mesh, dof_id_type i) const
	A member function type like node_ptr() or elem_ptr().
typedef std::set< std::unique_ptr< CouplingMatrix >, Utility::CompareUnderlying >	CouplingMatricesSet

Private Member Functions
const std::pair< unsigned int, unsigned int > &	get_variable_array (unsigned int vi) const
	Retrieve the array variable bounds for a given variable vi.
void	_dof_indices (const Elem &elem, int p_level, std::vector< dof_id_type > &di, const unsigned int vg, const unsigned int vig, const Node *const *nodes, unsigned int n_nodes, const unsigned int v #ifdef DEBUG, std::size_t &tot_size #endif) const
	Helper function that gets the dof indices on the current element for a non-SCALAR type variable, where the variable is identified by its variable group number vg and its offset vig from the first variable in that group.
template<typename FieldDofsFunctor >
void	_dof_indices (const Elem &elem, int p_level, std::vector< dof_id_type > &di, const unsigned int vg, const unsigned int vig, const Node *const *nodes, unsigned int n_nodes, const unsigned int v, #ifdef DEBUG std::size_t &tot_size, #endif FieldDofsFunctor field_dofs_functor) const
	As above except a field_dofs_functor must be provided.
void	_node_dof_indices (const Elem &elem, unsigned int n, const DofObject &obj, std::vector< dof_id_type > &di, const unsigned int vn) const
	Helper function that implements the element-nodal versions of dof_indices and old_dof_indices.
void	invalidate_dofs (MeshBase &mesh) const
	Invalidates all active DofObject dofs for this system.
DofObject *	node_ptr (MeshBase &mesh, dof_id_type i) const
DofObject *	elem_ptr (MeshBase &mesh, dof_id_type i) const
template<typename iterator_type >
void	set_nonlocal_dof_objects (iterator_type objects_begin, iterator_type objects_end, MeshBase &mesh, dofobject_accessor objects)
	Helper function for distributing dofs in parallel.
std::map< const Node *, std::set< subdomain_id_type > >	calculate_constraining_subdomains ()
	We may have mesh constraint rows with dependent nodes in one subdomain but dependency nodes in another subdomain, and we may have variables whose subdomain restriction includes the dependent subdomain but not the dependency.
void	distribute_local_dofs_var_major (dof_id_type &next_free_dof, MeshBase &mesh, const std::map< const Node *, std::set< subdomain_id_type > > &constraining_subdomains)
	Distributes the global degrees of freedom, for dofs on this processor.
void	distribute_local_dofs_node_major (dof_id_type &next_free_dof, MeshBase &mesh, const std::map< const Node *, std::set< subdomain_id_type > > &constraining_subdomains)
	Distributes the global degrees of freedom for dofs on this processor.
void	distribute_scalar_dofs (dof_id_type &next_free_dof)
void	assert_no_nodes_missed (MeshBase &mesh)
void	add_neighbors_to_send_list (MeshBase &mesh)
	Adds entries to the _send_list vector corresponding to DoFs on elements neighboring the current processor.
void	build_constraint_matrix (DenseMatrix< Number > &C, std::vector< dof_id_type > &elem_dofs, const bool called_recursively=false) const
	Build the constraint matrix C associated with the element degree of freedom indices elem_dofs.
void	build_constraint_matrix_and_vector (DenseMatrix< Number > &C, DenseVector< Number > &H, std::vector< dof_id_type > &elem_dofs, int qoi_index=-1, const bool called_recursively=false) const
	Build the constraint matrix C and the forcing vector H associated with the element degree of freedom indices elem_dofs.
void	find_connected_dofs (std::vector< dof_id_type > &elem_dofs) const
	Finds all the DOFS associated with the element DOFs elem_dofs.
void	find_connected_dof_objects (std::vector< const DofObject * > &objs) const
	Finds all the DofObjects associated with the set in objs.
void	add_constraints_to_send_list ()
	Adds entries to the _send_list vector corresponding to DoFs which are dependencies for constraint equations on the current processor.
void	process_mesh_constraint_rows (const MeshBase &mesh)
	Adds any spline constraints from the Mesh to our DoF constraints.

Static Private Member Functions
static void	merge_ghost_functor_outputs (GhostingFunctor::map_type &elements_to_ghost, CouplingMatricesSet &temporary_coupling_matrices, const GhostingFunctorIterator &gf_begin, const GhostingFunctorIterator &gf_end, const MeshBase::const_element_iterator &elems_begin, const MeshBase::const_element_iterator &elems_end, processor_id_type p)

Private Attributes
bool	_error_on_constraint_loop
	This flag indicates whether or not we do an opt-mode check for the presence of constraint loops, i.e.
bool	_constrained_sparsity_construction
	This flag indicates whether or not we explicitly take constraint equations into account when computing a sparsity pattern.
std::vector< Variable >	_variables
	The variables in this system/degree of freedom map.
std::vector< VariableGroup >	_variable_groups
	The variable groups in this system/degree of freedom map.
std::vector< unsigned int >	_variable_group_numbers
	The variable group number for each variable.
std::unordered_map< unsigned int, unsigned int >	_var_to_vg
	A map from variable number to variable group number.
std::map< std::string, unsigned int, std::less<> >	_variable_numbers
	The variable numbers corresponding to user-specified names, useful for name-based lookups.
std::vector< std::pair< unsigned int, unsigned int > >	_array_variables
	Array variable information storage.
bool	_identify_variable_groups = true
	true when VariableGroup structures should be automatically identified, false otherwise.
const unsigned int	_sys_number
	The number of the system we manage DOFs for.
MeshBase &	_mesh
	The mesh that system uses.
std::vector< SparseMatrix< Number > * >	_matrices
	Additional matrices handled by this object.
std::vector< dof_id_type >	_first_scalar_df
	First DOF index for SCALAR variable v, or garbage for non-SCALAR variable v.
std::vector< dof_id_type >	_send_list
	A list containing all the global DOF indices that affect the solution on my processor.
SparsityPattern::AugmentSparsityPattern *	_augment_sparsity_pattern
	Function object to call to add extra entries to the sparsity pattern.
void(*	_extra_sparsity_function )(SparsityPattern::Graph &, std::vector< dof_id_type > &n_nz, std::vector< dof_id_type > &n_oz, void *)
	A function pointer to a function to call to add extra entries to the sparsity pattern.
void *	_extra_sparsity_context
	A pointer associated with the extra sparsity that can optionally be passed in.
AugmentSendList *	_augment_send_list
	Function object to call to add extra entries to the send list.
void(*	_extra_send_list_function )(std::vector< dof_id_type > &, void *)
	A function pointer to a function to call to add extra entries to the send list.
void *	_extra_send_list_context
	A pointer associated with the extra send list that can optionally be passed in.
std::unique_ptr< DefaultCoupling >	_default_coupling
	The default coupling GhostingFunctor, used to implement standard libMesh sparsity pattern construction.
std::unique_ptr< DefaultCoupling >	_default_evaluating
	The default algebraic GhostingFunctor, used to implement standard libMesh send_list construction.
std::vector< GhostingFunctor * >	_algebraic_ghosting_functors
	The list of all GhostingFunctor objects to be used when distributing ghosted vectors.
std::vector< GhostingFunctor * >	_coupling_functors
	The list of all GhostingFunctor objects to be used when coupling degrees of freedom in matrix sparsity patterns.
std::map< GhostingFunctor *, std::shared_ptr< GhostingFunctor > >	_shared_functors
	Hang on to references to any GhostingFunctor objects we were passed in shared_ptr form.
bool	need_full_sparsity_pattern
	Default false; set to true if any attached matrix requires a full sparsity pattern.
std::unique_ptr< SparsityPattern::Build >	_sp
	The sparsity pattern of the global matrix.
dof_id_type	_n_SCALAR_dofs
	The total number of SCALAR dofs associated to all SCALAR variables.
std::vector< dof_id_type >	_first_old_scalar_df
	First old DOF index for SCALAR variable v, or garbage for non-SCALAR variable v.
DofConstraints	_dof_constraints
	Data structure containing DOF constraints.
DofConstraints	_stashed_dof_constraints
DofConstraintValueMap	_primal_constraint_values
AdjointDofConstraintValues	_adjoint_constraint_values
NodeConstraints	_node_constraints
	Data structure containing DofObject constraints.
std::unique_ptr< PeriodicBoundaries >	_periodic_boundaries
	Data structure containing periodic boundaries.
std::unique_ptr< DirichletBoundaries >	_dirichlet_boundaries
	Data structure containing Dirichlet functions.
std::vector< std::unique_ptr< DirichletBoundaries > >	_adjoint_dirichlet_boundaries
	Data structure containing Dirichlet functions.
bool	_implicit_neighbor_dofs_initialized
	Bools to indicate if we override the –implicit_neighbor_dofs commandline options.
bool	_implicit_neighbor_dofs
bool	_verify_dirichlet_bc_consistency
	Flag which determines whether we should do some additional checking of the consistency of the DirichletBoundary objects added by the user.
std::unique_ptr< StaticCondensationDofMap >	_sc
	Static condensation class.

Friends
class	SparsityPattern::Build

Detailed Description

This class handles the numbering of degrees of freedom on a mesh.

For systems of equations the class supports a fixed number of variables. The degrees of freedom are numbered such that sequential, contiguous blocks belong to distinct processors. This is so that the resulting data structures will work well with parallel linear algebra packages.

Author

Benjamin S. Kirk

Date

2002-2007

Manages the degrees of freedom (DOFs) in a simulation.

Definition at line 179 of file dof_map.h.

Member Typedef Documentation

Counts

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts

protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

CouplingMatricesSet

typedef std::set<std::unique_ptr<CouplingMatrix>, Utility::CompareUnderlying> libMesh::DofMap::CouplingMatricesSet

private

Definition at line 1999 of file dof_map.h.

dofobject_accessor

typedef DofObject *(DofMap::* libMesh::DofMap::dofobject_accessor) (MeshBase &mesh, dof_id_type i) const

private

A member function type like node_ptr() or elem_ptr().

Definition at line 1915 of file dof_map.h.

GhostingFunctorIterator

typedef std::vector<GhostingFunctor*>::const_iterator libMesh::DofMap::GhostingFunctorIterator

Iterator type for coupling and algebraic ghosting functor ranges.

This has changed in the past and may change again; code should use auto or the type here.

Definition at line 315 of file dof_map.h.

Constructor & Destructor Documentation

DofMap()

libMesh::DofMap::DofMap ( const unsigned int  sys_number, MeshBase &  mesh  )

explicit

Constructor.

Requires the number of the system for which we will be numbering degrees of freedom & the parent object we are contained in, which defines our communication space.

Definition at line 138 of file dof_map.C.

                                :
  DofMapBase (mesh.comm()),
  _dof_coupling(nullptr),
  _error_on_constraint_loop(false),
  _constrained_sparsity_construction(false),
  _variables(),
  _variable_groups(),
  _variable_group_numbers(),
  _sys_number(number),
  _mesh(mesh),
  _matrices(),
  _first_scalar_df(),
  _send_list(),
  _augment_sparsity_pattern(nullptr),
  _extra_sparsity_function(nullptr),
  _extra_sparsity_context(nullptr),
  _augment_send_list(nullptr),
  _extra_send_list_function(nullptr),
  _extra_send_list_context(nullptr),
  _default_coupling(std::make_unique<DefaultCoupling>()),
  _default_evaluating(std::make_unique<DefaultCoupling>()),
  need_full_sparsity_pattern(false),
  _n_SCALAR_dofs(0)
#ifdef LIBMESH_ENABLE_AMR
  , _first_old_scalar_df()
#endif
#ifdef LIBMESH_ENABLE_CONSTRAINTS
  , _dof_constraints()
  , _stashed_dof_constraints()
  , _primal_constraint_values()
  , _adjoint_constraint_values()
#endif
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  , _node_constraints()
#endif
#ifdef LIBMESH_ENABLE_PERIODIC
  , _periodic_boundaries(std::make_unique<PeriodicBoundaries>())
#endif
#ifdef LIBMESH_ENABLE_DIRICHLET
  , _dirichlet_boundaries(std::make_unique<DirichletBoundaries>())
  , _adjoint_dirichlet_boundaries()
#endif
  , _implicit_neighbor_dofs_initialized(false),
  _implicit_neighbor_dofs(false),
  _verify_dirichlet_bc_consistency(true),
  _sc(nullptr)
{
  _matrices.clear();
 
  _default_coupling->set_mesh(&_mesh);
  _default_evaluating->set_mesh(&_mesh);
  _default_evaluating->set_n_levels(1);
 
#ifdef LIBMESH_ENABLE_PERIODIC
  _default_coupling->set_periodic_boundaries(_periodic_boundaries.get());
  _default_evaluating->set_periodic_boundaries(_periodic_boundaries.get());
#endif
 
  this->add_coupling_functor(*_default_coupling);
  this->add_algebraic_ghosting_functor(*_default_evaluating);
}

References _default_coupling, _default_evaluating, _matrices, _mesh, _periodic_boundaries, add_algebraic_ghosting_functor(), add_coupling_functor(), and libMesh::DofMapBase::clear().

~DofMap()

libMesh::DofMap::~DofMap

(

)

Destructor.

Definition at line 204 of file dof_map.C.

{
  this->clear();
 
  // clear() resets all but the default DofMap-based functors.  We
  // need to remove those from the mesh too before we die.
  _mesh.remove_ghosting_functor(*_default_coupling);
  _mesh.remove_ghosting_functor(*_default_evaluating);
}

References _default_coupling, _default_evaluating, _mesh, clear(), and libMesh::MeshBase::remove_ghosting_functor().

Member Function Documentation

_dof_indices() [1/2]

void libMesh::DofMap::_dof_indices ( const Elem &  elem, int  p_level, std::vector< dof_id_type > &  di, const unsigned int  vg, const unsigned int  vig, const Node *const *  nodes, unsigned int  n_nodes, const unsigned int v #ifdef  DEBUG, std::size_t &tot_size #  endif  ) const

private

Helper function that gets the dof indices on the current element for a non-SCALAR type variable, where the variable is identified by its variable group number vg and its offset vig from the first variable in that group.

In DEBUG mode, the tot_size parameter will add up the total number of dof indices that should have been added to di, and v will be the variable number corresponding to vg and vig.

Definition at line 2573 of file dof_map.C.

{
  _dof_indices(elem,
               p_level,
               di,
               vg,
               vig,
               nodes,
               n_nodes,
               v,
#ifdef DEBUG
               tot_size,
#endif
               [](const Elem &,
                  unsigned int,
                  unsigned int,
                  std::vector<dof_id_type> & functor_di,
                  const dof_id_type dof) { functor_di.push_back(dof); });
}

References n_nodes.

Referenced by dof_indices().

_dof_indices() [2/2]

template<typename FieldDofsFunctor >

void libMesh::DofMap::_dof_indices ( const Elem &  elem, int  p_level, std::vector< dof_id_type > &  di, const unsigned int  vg, const unsigned int  vig, const Node *const *  nodes, unsigned int  n_nodes, const unsigned int  v, #ifdef DEBUG std::size_t &  tot_size, #endif FieldDofsFunctor  field_dofs_functor  ) const

private

As above except a field_dofs_functor must be provided.

This method is useful when the caller wants to do more than simply fill a degree of freedom container

Parameters

field_dofs_functor

This functor has the interface: void field_dofs_functor(const Elem & elem, const unsigned int node_num, const unsigned int var_num, std::vector<dof_id_type> & di, const dof_id_type field_dof) where field_dof represents a field degree of freedom to act on and is associated with node_num and var_num. If the degree of freedom is elemental than node_num will be invalid_uint. di is the degree of freedom container provided to the _dof_indices method

Definition at line 2619 of file dof_map.h.

{
  const VariableGroup & var = this->variable_group(vg);
 
  if (var.active_on_subdomain(elem.subdomain_id()))
    {
      const ElemType type        = elem.type();
      const unsigned int sys_num = this->sys_number();
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
      const bool is_inf          = elem.infinite();
#endif
 
      const bool extra_hanging_dofs =
        FEInterface::extra_hanging_dofs(var.type());
 
      FEType fe_type = var.type();
 
      const bool add_p_level = fe_type.p_refinement;
 
#ifdef DEBUG
      // The number of dofs per element is non-static for subdivision FE
      if (var.type().family == SUBDIVISION)
        tot_size += n_nodes;
      else
        // FIXME: Is the passed-in p_level just elem.p_level()? If so,
        // this seems redundant.
        tot_size += FEInterface::n_dofs(fe_type, add_p_level*p_level, &elem);
#endif
 
      // The total Order is not required when getting the function
      // pointer, it is only needed when the function is called (see
      // below).
      const FEInterface::n_dofs_at_node_ptr ndan =
        FEInterface::n_dofs_at_node_function(fe_type, &elem);
 
      // Get the node-based DOF numbers
      for (unsigned int n=0; n != n_nodes; n++)
        {
          const Node & node = *nodes[n];
 
          // Cache the intermediate lookups that are common to every
          // component
#ifdef DEBUG
          const std::pair<unsigned int, unsigned int>
            vg_and_offset = node.var_to_vg_and_offset(sys_num,v);
          libmesh_assert_equal_to (vg, vg_and_offset.first);
          libmesh_assert_equal_to (vig, vg_and_offset.second);
#endif
          const unsigned int n_comp = node.n_comp_group(sys_num,vg);
 
          // There is a potential problem with h refinement.  Imagine a
          // quad9 that has a linear FE on it.  Then, on the hanging side,
          // it can falsely identify a DOF at the mid-edge node. This is why
          // we go through FEInterface instead of node.n_comp() directly.
          const unsigned int nc =
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
            is_inf ?
            FEInterface::n_dofs_at_node(fe_type, add_p_level*p_level, &elem, n) :
#endif
            ndan (type, fe_type.order + add_p_level*p_level, n);
 
          // If this is a non-vertex on a hanging node with extra
          // degrees of freedom, we use the non-vertex dofs (which
          // come in reverse order starting from the end, to
          // simplify p refinement)
          if (extra_hanging_dofs && !elem.is_vertex(n))
            {
              const int dof_offset = n_comp - nc;
 
              // We should never have fewer dofs than necessary on a
              // node unless we're getting indices on a parent element,
              // and we should never need the indices on such a node
              if (dof_offset < 0)
                {
                  libmesh_assert(!elem.active());
                  di.resize(di.size() + nc, DofObject::invalid_id);
                }
              else
                for (int i=int(n_comp)-1; i>=dof_offset; i--)
                  {
                    const dof_id_type d =
                      node.dof_number(sys_num, vg, vig, i, n_comp);
                    libmesh_assert_not_equal_to (d, DofObject::invalid_id);
                    field_dofs_functor(elem, n, v, di, d);
                  }
            }
          // If this is a vertex or an element without extra hanging
          // dofs, our dofs come in forward order coming from the
          // beginning
          else
            {
              // We have a good component index only if it's being
              // used on this FE type (nc) *and* it's available on
              // this DofObject (n_comp).
              const unsigned int good_nc = std::min(n_comp, nc);
              for (unsigned int i=0; i!=good_nc; ++i)
                {
                  const dof_id_type d =
                    node.dof_number(sys_num, vg, vig, i, n_comp);
                  libmesh_assert_not_equal_to (d, DofObject::invalid_id);
                  libmesh_assert_less (d, this->n_dofs());
                  field_dofs_functor(elem, n, v, di, d);
                }
 
              // With fewer good component indices than we need, e.g.
              // due to subdomain expansion, the remaining expected
              // indices are marked invalid.
              if (n_comp < nc)
                for (unsigned int i=n_comp; i!=nc; ++i)
                  di.push_back(DofObject::invalid_id);
            }
        }
 
      // If there are any element-based DOF numbers, get them
      const unsigned int nc = FEInterface::n_dofs_per_elem(fe_type, add_p_level*p_level, &elem);
 
      // We should never have fewer dofs than necessary on an
      // element unless we're getting indices on a parent element
      // (and we should never need those indices) or off-domain for a
      // subdomain-restricted variable (where invalid_id is the
      // correct thing to return)
      if (nc != 0)
        {
          const unsigned int n_comp = elem.n_comp_group(sys_num,vg);
          if (elem.n_systems() > sys_num && nc <= n_comp)
            {
              for (unsigned int i=0; i<nc; i++)
                {
                  const dof_id_type d =
                    elem.dof_number(sys_num, vg, vig, i, n_comp);
                  libmesh_assert_not_equal_to (d, DofObject::invalid_id);
 
                  field_dofs_functor(elem, invalid_uint, v, di, d);
                }
            }
          else
            {
              libmesh_assert(!elem.active() || fe_type.family == LAGRANGE || fe_type.family == SUBDIVISION);
              di.resize(di.size() + nc, DofObject::invalid_id);
            }
        }
    }
}

References libMesh::Elem::active(), libMesh::Variable::active_on_subdomain(), libMesh::DofObject::dof_number(), libMesh::FEInterface::extra_hanging_dofs(), libMesh::FEType::family, libMesh::Elem::infinite(), libMesh::DofObject::invalid_id, libMesh::invalid_uint, libMesh::Elem::is_vertex(), libMesh::LAGRANGE, libMesh::libmesh_assert(), libMesh::DofObject::n_comp_group(), n_dofs(), libMesh::FEInterface::n_dofs(), libMesh::FEInterface::n_dofs_at_node(), libMesh::FEInterface::n_dofs_at_node_function(), libMesh::FEInterface::n_dofs_per_elem(), n_nodes, libMesh::DofObject::n_systems(), libMesh::FEType::order, libMesh::FEType::p_refinement, libMesh::SUBDIVISION, libMesh::Elem::subdomain_id(), sys_number(), libMesh::Variable::type(), libMesh::Elem::type(), libMesh::DofObject::var_to_vg_and_offset(), and variable_group().

_node_dof_indices()

void libMesh::DofMap::_node_dof_indices ( const Elem &  elem, unsigned int  n, const DofObject &  obj, std::vector< dof_id_type > &  di, const unsigned int  vn  ) const

private

Helper function that implements the element-nodal versions of dof_indices and old_dof_indices.

Definition at line 2491 of file dof_map.C.

{
  // Half of this is a cut and paste of _dof_indices code below, but
  // duplication actually seems cleaner than creating a helper
  // function with a million arguments and hoping the compiler inlines
  // it properly into one of our most highly trafficked functions.
 
  // dof_indices() is a relatively light-weight function; the cost of
  // the logging code itself is roughly on par with the time required
  // to call dof_indices().
  // LOG_SCOPE("_node_dof_indices()", "DofMap");
 
  const unsigned int sys_num = this->sys_number();
  const auto [vg, vig] =
    obj.var_to_vg_and_offset(sys_num,vn);
  const unsigned int n_comp = obj.n_comp_group(sys_num,vg);
 
  const VariableGroup & var = this->variable_group(vg);
  FEType fe_type = var.type();
  const bool extra_hanging_dofs =
    FEInterface::extra_hanging_dofs(fe_type);
 
  const bool add_p_level = fe_type.p_refinement;
 
  // There is a potential problem with h refinement.  Imagine a
  // quad9 that has a linear FE on it.  Then, on the hanging side,
  // it can falsely identify a DOF at the mid-edge node. This is why
  // we go through FEInterface instead of obj->n_comp() directly.
  const unsigned int nc =
    FEInterface::n_dofs_at_node(fe_type, &elem, n, add_p_level);
 
  // If this is a non-vertex on a hanging node with extra
  // degrees of freedom, we use the non-vertex dofs (which
  // come in reverse order starting from the end, to
  // simplify p refinement)
  if (extra_hanging_dofs && nc && !elem.is_vertex(n))
    {
      const int dof_offset = n_comp - nc;
 
      // We should never have fewer dofs than necessary on a
      // node unless we're getting indices on a parent element,
      // and we should never need the indices on such a node
      if (dof_offset < 0)
        {
          libmesh_assert(!elem.active());
          di.resize(di.size() + nc, DofObject::invalid_id);
        }
      else
        for (unsigned int i = dof_offset; i != n_comp; ++i)
          {
            const dof_id_type d =
              obj.dof_number(sys_num, vg, vig, i, n_comp);
            libmesh_assert_not_equal_to (d, DofObject::invalid_id);
            di.push_back(d);
          }
    }
  // If this is a vertex or an element without extra hanging
  // dofs, our dofs come in forward order coming from the
  // beginning.  But we still might not have all those dofs, in cases
  // where a subdomain-restricted variable just had its subdomain
  // expanded.
  else
    {
      const unsigned int good_nc =
        std::min(static_cast<unsigned int>(n_comp), nc);
      for (unsigned int i=0; i != good_nc; ++i)
        {
          const dof_id_type d =
            obj.dof_number(sys_num, vg, vig, i, n_comp);
          libmesh_assert_not_equal_to (d, DofObject::invalid_id);
          di.push_back(d);
        }
      for (unsigned int i=good_nc; i != nc; ++i)
        di.push_back(DofObject::invalid_id);
    }
}

References libMesh::Elem::active(), libMesh::DofObject::dof_number(), libMesh::Elem::is_vertex(), libMesh::libmesh_assert(), libMesh::DofObject::n_comp_group(), libMesh::FEType::p_refinement, libMesh::Variable::type(), and libMesh::DofObject::var_to_vg_and_offset().

add_adjoint_constraint_row()

void libMesh::DofMap::add_adjoint_constraint_row	(	const unsigned int	qoi_index,
		const dof_id_type	dof_number,
		const DofConstraintRow &	constraint_row,
		const Number	constraint_rhs,
		const bool	forbid_constraint_overwrite
	)

Adds a copy of the user-defined row to the constraint matrix, using an inhomogeneous right-hand-side for the adjoint constraint equation.

forbid_constraint_overwrite here only tests for overwriting the rhs. This method should only be used when an equivalent constraint (with a potentially different rhs) already exists for the primal problem.

Definition at line 2212 of file dof_map_constraints.C.

{
  // Optionally allow the user to overwrite constraints.  Defaults to false.
  if (forbid_constraint_overwrite)
    {
      libmesh_error_msg_if(!this->is_constrained_dof(dof_number),
                           "ERROR: DOF " << dof_number << " has no corresponding primal constraint!");
#ifndef NDEBUG
      // No way to do this without a non-normalized tolerance?
 
      // // If the user passed in more than just the rhs, let's check the
      // // coefficients for consistency
      // if (!constraint_row.empty())
      //   {
      //     DofConstraintRow row = _dof_constraints[dof_number];
      //     for (const auto & [dof, val] : row)
      //       libmesh_assert(constraint_row.find(dof)->second == val);
      //   }
      //
      // if (_adjoint_constraint_values[qoi_index].find(dof_number) !=
      //     _adjoint_constraint_values[qoi_index].end())
      //   libmesh_assert_equal_to(_adjoint_constraint_values[qoi_index][dof_number],
      //                           constraint_rhs);
 
#endif
    }
 
  // Creates the map of rhs values if it doesn't already exist; then
  // adds the current value to that map
 
  // Store the rhs value in the map
  _adjoint_constraint_values[qoi_index].insert_or_assign(dof_number, constraint_rhs);
}

References _adjoint_constraint_values, and is_constrained_dof().

add_adjoint_dirichlet_boundary()

void libMesh::DofMap::add_adjoint_dirichlet_boundary	(	const DirichletBoundary &	dirichlet_boundary,
		unsigned int	q
	)

Adds a copy of the specified Dirichlet boundary to the system, corresponding to the adjoint problem defined by Quantity of Interest q.

Definition at line 5442 of file dof_map_constraints.C.

{
  unsigned int old_size = cast_int<unsigned int>
    (_adjoint_dirichlet_boundaries.size());
  for (unsigned int i = old_size; i <= qoi_index; ++i)
    _adjoint_dirichlet_boundaries.push_back(std::make_unique<DirichletBoundaries>());
 
  // Make copy of DirichletBoundary, owned by _adjoint_dirichlet_boundaries
  _adjoint_dirichlet_boundaries[qoi_index]->push_back
    (std::make_unique<DirichletBoundary>(dirichlet_boundary));
}

References _adjoint_dirichlet_boundaries.

Referenced by PoissonSystem::init_data(), and SigmaPhysics::init_data().

add_algebraic_ghosting_functor() [1/2]

void libMesh::DofMap::add_algebraic_ghosting_functor	(	GhostingFunctor &	evaluable_functor,
		bool	to_mesh = true
	)

Adds a functor which can specify algebraic ghosting requirements for use with distributed vectors.

Degrees of freedom on other processors which match the elements and variables returned by these functors will be added to the send_list, and the elements on other processors will be ghosted on a distributed mesh, so that the elements can always be found and the solutions on them will always be evaluable.

GhostingFunctor memory must be managed by the code which calls this function; the GhostingFunctor lifetime is expected to extend until either the functor is removed or the DofMap is destructed.

When to_mesh is true, the coupling_functor is also added to our associated mesh, to ensure that evaluable elements do not get lost during mesh distribution. (if evaluable elements were already lost there's no getting them back after the fact, sorry)

If to_mesh is false, no change to mesh ghosting is made; the Mesh must already have ghosting functor(s) specifying a superset of evaluable_functor or this is a horrible bug.

Definition at line 2062 of file dof_map.C.

{
  // We used to implicitly support duplicate inserts to std::set
#ifdef LIBMESH_ENABLE_DEPRECATED
  _algebraic_ghosting_functors.erase
    (std::remove(_algebraic_ghosting_functors.begin(),
                 _algebraic_ghosting_functors.end(),
                 &evaluable_functor),
     _algebraic_ghosting_functors.end());
#endif
 
  // We shouldn't have two copies of the same functor
  libmesh_assert(std::find(_algebraic_ghosting_functors.begin(),
                           _algebraic_ghosting_functors.end(),
                           &evaluable_functor) ==
                 _algebraic_ghosting_functors.end());
 
  _algebraic_ghosting_functors.push_back(&evaluable_functor);
  evaluable_functor.set_mesh(&_mesh);
  if (to_mesh)
    _mesh.add_ghosting_functor(evaluable_functor);
}

References libMesh::libmesh_assert(), and libMesh::GhostingFunctor::set_mesh().

Referenced by add_algebraic_ghosting_functor(), DofMap(), main(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), SlitMeshRefinedSystemTest::setUp(), PointNeighborCouplingTest::testCoupling(), and EquationSystemsTest::testDisableDefaultGhosting().

add_algebraic_ghosting_functor() [2/2]

void libMesh::DofMap::add_algebraic_ghosting_functor ( std::shared_ptr< GhostingFunctor >  evaluable_functor, bool  to_mesh = true  )

inline

Adds a functor which can specify algebraic ghosting requirements for use with distributed vectors.

GhostingFunctor memory when using this method is managed by the shared_ptr mechanism.

Definition at line 413 of file dof_map.h.

  { _shared_functors[evaluable_functor.get()] = evaluable_functor;
    this->add_algebraic_ghosting_functor(*evaluable_functor, to_mesh); }

References _shared_functors, and add_algebraic_ghosting_functor().

add_constraint_row() [1/2]

void libMesh::DofMap::add_constraint_row ( const dof_id_type  dof_number, const DofConstraintRow &  constraint_row, const bool  forbid_constraint_overwrite = true  )

inline

Adds a copy of the user-defined row to the constraint matrix, using a homogeneous right-hand-side for the constraint equation.

By default, produces an error if the DOF was already constrained.

Definition at line 1156 of file dof_map.h.

  { add_constraint_row(dof_number, constraint_row, 0., forbid_constraint_overwrite); }

References add_constraint_row().

add_constraint_row() [2/2]

void libMesh::DofMap::add_constraint_row	(	const dof_id_type	dof_number,
		const DofConstraintRow &	constraint_row,
		const Number	constraint_rhs,
		const bool	forbid_constraint_overwrite
	)

Adds a copy of the user-defined row to the constraint matrix, using an inhomogeneous right-hand-side for the constraint equation.

Definition at line 2180 of file dof_map_constraints.C.

{
  // Optionally allow the user to overwrite constraints.  Defaults to false.
  libmesh_error_msg_if(forbid_constraint_overwrite && this->is_constrained_dof(dof_number),
                       "ERROR: DOF " << dof_number << " was already constrained!");
 
  libmesh_assert_less(dof_number, this->n_dofs());
 
  // There is an implied "1" on the diagonal of the constraint row, and the user
  // should not try to manually set _any_ value on the diagonal.
  libmesh_assert_msg(!constraint_row.count(dof_number),
                     "Error: constraint_row for dof " << dof_number <<
                     " should not contain an entry for dof " << dof_number);
 
#ifndef NDEBUG
  for (const auto & pr : constraint_row)
    libmesh_assert_less(pr.first, this->n_dofs());
#endif
 
  // Store the constraint_row in the map
  _dof_constraints.insert_or_assign(dof_number, constraint_row);
 
  std::pair<DofConstraintValueMap::iterator, bool> rhs_it =
    _primal_constraint_values.emplace(dof_number, constraint_rhs);
  if (!rhs_it.second)
    rhs_it.first->second = constraint_rhs;
}

References _dof_constraints, _primal_constraint_values, is_constrained_dof(), and n_dofs().

Referenced by add_constraint_row(), MyConstraint::constrain(), libMesh::VariationalSmootherConstraint::constrain_node_to_line(), libMesh::VariationalSmootherConstraint::constrain_node_to_plane(), libMesh::VariationalSmootherConstraint::fix_node(), and process_mesh_constraint_rows().

add_constraints_to_send_list()

void libMesh::DofMap::add_constraints_to_send_list ( )

private

Adds entries to the _send_list vector corresponding to DoFs which are dependencies for constraint equations on the current processor.

Definition at line 5311 of file dof_map_constraints.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  // Return immediately if there's nothing to gather
  if (this->n_processors() == 1)
    return;
 
  // We might get to return immediately if none of the processors
  // found any constraints
  unsigned int has_constraints = !_dof_constraints.empty();
  this->comm().max(has_constraints);
  if (!has_constraints)
    return;
 
  auto add_row = [this](const DofConstraintRow & constraint_row) {
    for (const auto & j : constraint_row)
      {
        dof_id_type constraint_dependency = j.first;
 
        // No point in adding one of our own dofs to the send_list
        if (this->local_index(constraint_dependency))
          continue;
 
        _send_list.push_back(constraint_dependency);
      }
  };
 
  // We usually only need dependencies of our own constrained dofs
  for (const auto & [constrained_dof, constraint_row] : _dof_constraints)
    if (this->local_index(constrained_dof))
      add_row(constraint_row);
 
  // If we only need constraint DoFs constraining DoFs which are
  // algebraically local, we're done.
  if (!this->has_static_condensation())
    return;
 
  // If we use StaticCondensation, though, we may need constraint DoFs
  // constraining DoFs which are not local (they're on someone else's
  // node) but which are supported on local elements.  Let's get those
  // too if we have to.
  //
  // We'll potentially be hitting the same constrained DoFs from
  // multiple directions.
  std::unordered_set<dof_id_type> extra_dependencies;
  for (auto & elem : this->get_static_condensation().mesh().active_local_element_ptr_range())
    {
      std::vector<dof_id_type> di;
      this->dof_indices (elem, di);
      for (const auto & dof_id : di)
        if (!this->local_index(dof_id))
          if (auto pos = _dof_constraints.find(dof_id);
              pos != _dof_constraints.end())
            add_row(pos->second);
    }
}

References _dof_constraints, _send_list, libMesh::ParallelObject::comm(), dof_indices(), get_static_condensation(), has_static_condensation(), local_index(), libMesh::Parallel::Communicator::max(), libMesh::StaticCondensationDofMap::mesh(), and libMesh::ParallelObject::n_processors().

Referenced by process_constraints().

add_coupling_functor() [1/2]

void libMesh::DofMap::add_coupling_functor	(	GhostingFunctor &	coupling_functor,
		bool	to_mesh = true
	)

Adds a functor which can specify coupling requirements for creation of sparse matrices.

Degree of freedom pairs which match the elements and variables returned by these functors will be added to the sparsity pattern, and the degrees of freedom which live on other processors will be added to the send_list for use on ghosted vectors, and the elements which live on other processors will be ghosted on a distributed mesh.

GhostingFunctor memory must be managed by the code which calls this function; the GhostingFunctor lifetime is expected to extend until either the functor is removed or the DofMap is destructed.

When to_mesh is true, the coupling_functor is also added to our associated mesh, to ensure that coupled elements do not get lost during mesh distribution. (if coupled elements were already lost there's no getting them back after the fact, sorry)

If to_mesh is false, no change to mesh ghosting is made; the Mesh must already have ghosting functor(s) specifying a superset of coupling_functor or this is a horrible bug.

Definition at line 2005 of file dof_map.C.

{
  // We used to implicitly support duplicate inserts to std::set
#ifdef LIBMESH_ENABLE_DEPRECATED
  _coupling_functors.erase
    (std::remove(_coupling_functors.begin(),
                 _coupling_functors.end(),
                 &coupling_functor),
     _coupling_functors.end());
#endif
 
  // We shouldn't have two copies of the same functor
  libmesh_assert(std::find(_coupling_functors.begin(),
                           _coupling_functors.end(),
                           &coupling_functor) ==
                 _coupling_functors.end());
 
  _coupling_functors.push_back(&coupling_functor);
  coupling_functor.set_mesh(&_mesh);
  if (to_mesh)
    _mesh.add_ghosting_functor(coupling_functor);
}

References libMesh::libmesh_assert(), and libMesh::GhostingFunctor::set_mesh().

Referenced by add_coupling_functor(), DofMap(), NonManifoldCouplingTestBase::init_es(), main(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), EquationSystemsTest::testDisableDefaultGhosting(), and SystemsTest::testDofCouplingWithVarGroups().

add_coupling_functor() [2/2]

void libMesh::DofMap::add_coupling_functor ( std::shared_ptr< GhostingFunctor >  coupling_functor, bool  to_mesh = true  )

inline

Adds a functor which can specify coupling requirements for creation of sparse matrices.

GhostingFunctor memory when using this method is managed by the shared_ptr mechanism.

Definition at line 351 of file dof_map.h.

  { _shared_functors[coupling_functor.get()] = coupling_functor;
    this->add_coupling_functor(*coupling_functor, to_mesh); }

References _shared_functors, and add_coupling_functor().

add_default_ghosting()

void libMesh::DofMap::add_default_ghosting

(

)

Add the default functor(s) for coupling and algebraic ghosting.

User-added ghosting functors will be unaffected.

Definition at line 1996 of file dof_map.C.

{
  this->add_coupling_functor(this->default_coupling());
  this->add_algebraic_ghosting_functor(this->default_algebraic_ghosting());
}

Referenced by libMesh::EquationSystems::enable_default_ghosting().

add_dirichlet_boundary()

void libMesh::DofMap::add_dirichlet_boundary

(

const DirichletBoundary &

dirichlet_boundary

)

Adds a copy of the specified Dirichlet boundary to the system.

The constraints implied by DirichletBoundary objects are imposed in the same order in which DirichletBoundary objects are added to the DofMap. When multiple DirichletBoundary objects would impose competing constraints on a given DOF, the first DirichletBoundary to constrain the DOF "wins". This distinction is important when e.g. two surfaces (sidesets) intersect. The nodes on the intersection will be constrained according to whichever sideset's DirichletBoundary object was added to the DofMap first.

Definition at line 5436 of file dof_map_constraints.C.

{
  _dirichlet_boundaries->push_back(std::make_unique<DirichletBoundary>(dirichlet_boundary));
}

References _dirichlet_boundaries.

Referenced by libMesh::DifferentiableSystem::add_dot_var_dirichlet_bcs(), assemble_and_solve(), CoupledSystem::init_data(), HeatSystem::init_data(), PoissonSystem::init_data(), NavierSystem::init_data(), ElasticitySystem::init_data(), SimpleRBConstruction::init_data(), ElasticityRBConstruction::init_data(), SigmaPhysics::init_data(), LaplaceSystem::init_dirichlet_bcs(), main(), set_lid_driven_bcs(), set_poiseuille_bcs(), set_stagnation_bcs(), set_system_parameters(), MeshAssignTest::testMeshMoveAssign(), PeriodicBCTest::testPeriodicBC(), BoundaryInfoTest::testShellFaceConstraints(), DisjointNeighborTest::testTempJump(), and DisjointNeighborTest::testTempJumpRefine().

add_neighbors_to_send_list()

void libMesh::DofMap::add_neighbors_to_send_list ( MeshBase &  mesh )

private

Adds entries to the _send_list vector corresponding to DoFs on elements neighboring the current processor.

Definition at line 1687 of file dof_map.C.

{
  LOG_SCOPE("add_neighbors_to_send_list()", "DofMap");
 
  // Return immediately if there's no ghost data
  if (this->n_processors() == 1)
    return;
 
  const unsigned int n_var  = this->n_variables();
 
  MeshBase::const_element_iterator       local_elem_it
    = mesh.active_local_elements_begin();
  const MeshBase::const_element_iterator local_elem_end
    = mesh.active_local_elements_end();
 
  GhostingFunctor::map_type elements_to_send;
  DofMap::CouplingMatricesSet temporary_coupling_matrices;
 
  // We need to add dofs to the send list if they've been directly
  // requested by an algebraic ghosting functor or they've been
  // indirectly requested by a coupling functor.
  this->merge_ghost_functor_outputs(elements_to_send,
                                    temporary_coupling_matrices,
                                    this->algebraic_ghosting_functors_begin(),
                                    this->algebraic_ghosting_functors_end(),
                                    local_elem_it, local_elem_end, mesh.processor_id());
 
  this->merge_ghost_functor_outputs(elements_to_send,
                                    temporary_coupling_matrices,
                                    this->coupling_functors_begin(),
                                    this->coupling_functors_end(),
                                    local_elem_it, local_elem_end, mesh.processor_id());
 
  // Making a list of non-zero coupling matrix columns is an
  // O(N_var^2) operation.  We cache it so we only have to do it once
  // per CouplingMatrix and not once per element.
  std::map<const CouplingMatrix *, std::vector<unsigned int>>
    column_variable_lists;
 
  for (const auto & [partner, ghost_coupling] : elements_to_send)
    {
      // We asked ghosting functors not to give us local elements
      libmesh_assert_not_equal_to
        (partner->processor_id(), this->processor_id());
 
      // Loop over any present coupling matrix column variables if we
      // have a coupling matrix, or just add all variables to
      // send_list if not.
      if (ghost_coupling)
        {
          libmesh_assert_equal_to (ghost_coupling->size(), n_var);
 
          // Try to find a cached list of column variables.
          std::map<const CouplingMatrix *, std::vector<unsigned int>>::const_iterator
            column_variable_list = column_variable_lists.find(ghost_coupling);
 
          // If we didn't find it, then we need to create it.
          if (column_variable_list == column_variable_lists.end())
            {
              auto inserted_variable_list_pair =
                column_variable_lists.emplace(ghost_coupling, std::vector<unsigned int>());
              column_variable_list = inserted_variable_list_pair.first;
 
              std::vector<unsigned int> & new_variable_list =
                inserted_variable_list_pair.first->second;
 
              std::vector<unsigned char> has_variable(n_var, false);
 
              for (unsigned int vi = 0; vi != n_var; ++vi)
                {
                  ConstCouplingRow ccr(vi, *ghost_coupling);
 
                  for (const auto & vj : ccr)
                    has_variable[vj] = true;
                }
              for (unsigned int vj = 0; vj != n_var; ++vj)
                {
                  if (has_variable[vj])
                    new_variable_list.push_back(vj);
                }
            }
 
          const std::vector<unsigned int> & variable_list =
            column_variable_list->second;
 
          for (const auto & vj : variable_list)
            {
              std::vector<dof_id_type> di;
              this->dof_indices (partner, di, vj);
 
              // Insert the remote DOF indices into the send list
              for (auto d : di)
                if (d != DofObject::invalid_id &&
                    !this->local_index(d))
                  {
                    libmesh_assert_less(d, this->n_dofs());
                    _send_list.push_back(d);
                  }
            }
        }
      else
        {
          std::vector<dof_id_type> di;
          this->dof_indices (partner, di);
 
          // Insert the remote DOF indices into the send list
          for (const auto & dof : di)
            if (dof != DofObject::invalid_id &&
                !this->local_index(dof))
              {
                libmesh_assert_less(dof, this->n_dofs());
                _send_list.push_back(dof);
              }
        }
 
    }
 
  // We're now done with any merged coupling matrices we had to create.
  temporary_coupling_matrices.clear();
 
  //-------------------------------------------------------------------------
  // Our coupling functors added dofs from neighboring elements to the
  // send list, but we may still need to add non-local dofs from local
  // elements.
  //-------------------------------------------------------------------------
 
  // Loop over the active local elements, adding all active elements
  // that neighbor an active local element to the send list.
  for ( ; local_elem_it != local_elem_end; ++local_elem_it)
    {
      const Elem * elem = *local_elem_it;
 
      std::vector<dof_id_type> di;
      this->dof_indices (elem, di);
 
      // Insert the remote DOF indices into the send list
      for (const auto & dof : di)
        if (dof != DofObject::invalid_id &&
            !this->local_index(dof))
          {
            libmesh_assert_less(dof, this->n_dofs());
            _send_list.push_back(dof);
          }
    }
}

References mesh.

add_periodic_boundary() [1/2]

void libMesh::DofMap::add_periodic_boundary	(	const PeriodicBoundaryBase &	boundary,
		const PeriodicBoundaryBase &	inverse_boundary
	)

Add a periodic boundary pair.

Parameters

boundary	- primary boundary
inverse_boundary	- inverse boundary

Definition at line 5564 of file dof_map_constraints.C.

{
  libmesh_assert_equal_to (boundary.myboundary, inverse_boundary.pairedboundary);
  libmesh_assert_equal_to (boundary.pairedboundary, inverse_boundary.myboundary);
  libmesh_assert(boundary.get_variables() == inverse_boundary.get_variables());
 
  // See if we already have a periodic boundary associated myboundary...
  PeriodicBoundaryBase * existing_boundary =
    _periodic_boundaries->boundary(boundary.myboundary);
 
  if (!existing_boundary)
    {
      // ...if not, clone the inputs and add them to the
      // PeriodicBoundaries object.
      // These will be cleaned up automatically in the
      // _periodic_boundaries destructor.
      _periodic_boundaries->emplace(boundary.myboundary, boundary.clone());
      _periodic_boundaries->emplace(inverse_boundary.myboundary, inverse_boundary.clone());
    }
  else
    {
      // ...otherwise, merge this object's variable IDs with the
      // existing boundary object's.
      existing_boundary->merge(boundary);
 
      // Do the same merging process for the inverse boundary.  The
      // inverse had better already exist!
      PeriodicBoundaryBase * existing_inverse_boundary =
        _periodic_boundaries->boundary(boundary.pairedboundary);
      libmesh_assert(existing_inverse_boundary);
      existing_inverse_boundary->merge(inverse_boundary);
 
      // If we had to merge different *types* of boundaries then
      // something likely has gone wrong.
#ifdef LIBMESH_HAVE_RTTI
      // typeid needs to be given references, not just pointers, to
      // return a derived class name.
      libmesh_assert(typeid(boundary) == typeid(*existing_boundary));
      libmesh_assert(typeid(inverse_boundary) == typeid(*existing_inverse_boundary));
#endif
    }
}

References _periodic_boundaries, libMesh::PeriodicBoundaryBase::clone(), libMesh::PeriodicBoundaryBase::get_variables(), libMesh::libmesh_assert(), libMesh::PeriodicBoundaryBase::merge(), libMesh::PeriodicBoundaryBase::myboundary, and libMesh::PeriodicBoundaryBase::pairedboundary.

add_periodic_boundary() [2/2]

void libMesh::DofMap::add_periodic_boundary

(

const PeriodicBoundaryBase &

periodic_boundary

)

Adds a copy of the specified periodic boundary to the system.

Definition at line 5556 of file dof_map_constraints.C.

{
  auto inverse_boundary = periodic_boundary.clone(PeriodicBoundaryBase::INVERSE);
  this->add_periodic_boundary(periodic_boundary, *inverse_boundary);
}

References add_periodic_boundary(), libMesh::PeriodicBoundaryBase::clone(), and libMesh::PeriodicBoundaryBase::INVERSE.

Referenced by add_periodic_boundary(), Biharmonic::JR::JR(), main(), and PeriodicBCTest::testPeriodicBC().

add_variable()

unsigned int libMesh::DofMap::add_variable	(	System &	sys,
		std::string_view	var,
		const FEType &	type,
		const std::set< subdomain_id_type > *const	active_subdomains = nullptr
	)

Adds the variable var to the list of variables for this system.

If active_subdomains is either nullptr (the default) or points to an empty set, then it will be assumed that var has no subdomain restrictions

Returns

The index number for the new variable.

Definition at line 3146 of file dof_map.C.

{
  parallel_object_only(); // Not strictly needed, but the only safe way to keep in sync
 
  libmesh_assert(this->comm().verify(std::string(var)));
  libmesh_assert(this->comm().verify(type));
  libmesh_assert(this->comm().verify((active_subdomains == nullptr)));
 
  if (active_subdomains)
    libmesh_assert(this->comm().verify(active_subdomains->size()));
 
  // Make sure the variable isn't there already
  // or if it is, that it's the type we want
  for (auto v : make_range(this->n_vars()))
    if (this->variable_name(v) == var)
      {
        if (this->variable_type(v) == type)
          {
            // Check whether the existing variable's active subdomains also matches
            // the incoming variable's active subdomains. If they don't match, then
            // either it is an error by the user or the user is trying to change the
            // subdomain restriction after the variable has already been added, which
            // is not supported.
            const Variable & existing_var = this->variable(v);
 
            // Check whether active_subdomains is not provided/empty and the existing_var is
            // implicitly_active()
            bool check1 = (!active_subdomains || active_subdomains->empty()) &&
                          existing_var.implicitly_active();
 
            // Check if the provided active_subdomains is equal to the existing_var's
            // active_subdomains
            bool check2 =
                (active_subdomains && (*active_subdomains == existing_var.active_subdomains()));
 
            // If either of these checks passed, then we already have this variable
            if (check1 || check2)
              return _variables[v].number();
          }
 
        libmesh_error_msg("ERROR: incompatible variable "
                          << var << " has already been added for this system!");
      }
 
  libmesh_assert(!sys.is_initialized());
 
  if (this->n_variable_groups())
    {
      // Optimize for VariableGroups here - if the user is adding multiple
      // variables of the same FEType and subdomain restriction, catch
      // that here and add them as members of the same VariableGroup.
      //
      // start by setting this flag to whatever the user has requested
      // and then consider the conditions which should negate it.
      bool should_be_in_vg = this->identify_variable_groups();
 
      VariableGroup & vg = _variable_groups.back();
 
      // get a pointer to their subdomain restriction, if any.
      const std::set<subdomain_id_type> * const their_active_subdomains(
          vg.implicitly_active() ? nullptr : &vg.active_subdomains());
 
      // Different types?
      if (vg.type() != type)
        should_be_in_vg = false;
 
      // they are restricted, we aren't?
      if (their_active_subdomains &&
          (!active_subdomains || (active_subdomains && active_subdomains->empty())))
        should_be_in_vg = false;
 
      // they aren't restricted, we are?
      if (!their_active_subdomains && (active_subdomains && !active_subdomains->empty()))
        should_be_in_vg = false;
 
      if (their_active_subdomains && active_subdomains)
        // restricted to different sets?
        if (*their_active_subdomains != *active_subdomains)
          should_be_in_vg = false;
 
      // OK, after all that, append the variable to the vg if none of the conditions
      // were violated
      if (should_be_in_vg)
        {
          const unsigned int vn = this->n_vars();
 
          std::string varstr(var);
 
          _variable_numbers[varstr] = vn;
          vg.append(std::move(varstr));
          _variables.push_back(vg(vg.n_variables() - 1));
          const unsigned int vgn = _variable_groups.size() - 1;
          _variable_group_numbers.push_back(vgn);
          _var_to_vg.emplace(vn, vgn);
 
          return vn;
        }
    }
 
  // otherwise, fall back to adding a single variable group
  return this->add_variables(
      sys, std::vector<std::string>(1, std::string(var)), type, active_subdomains);
}

References libMesh::Variable::active_subdomains(), libMesh::VariableGroup::append(), libMesh::Variable::implicitly_active(), libMesh::System::is_initialized(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::VariableGroup::n_variables(), n_vars, and libMesh::Variable::type().

Referenced by libMesh::System::add_variable().

add_variable_array()

unsigned int libMesh::DofMap::add_variable_array	(	System &	sys,
		const std::vector< std::string > &	vars,
		const FEType &	type,
		const std::set< subdomain_id_type > *const	active_subdomains = nullptr
	)

Adds variables vars to the list of variables for this system.

If active_subdomains is either nullptr (the default) or points to an empty set, then it will be assumed that the vars have no subdomain restrictions. This API will end up calling this->add_variables(). However, we will additionally store data that can be leveraged by the DofMap to build degrees of freedom containers corresponding to all the variables in this variable array

An 'array variable' is simply a sequence of contiguous variable numbers defined by pair where the first member of the pair is the first number in the variable sequence and the second member of the pair is the number of the last variable in the sequence plus one. Array variables may be used in tandem with variable grouping by downstream code to build optimized physics kernels since each variable in the array will have the same shape functions.

Returns

The index number for the last of the new variables.

Definition at line 3377 of file dof_map.C.

{
  const unsigned int count = cast_int<unsigned int>(vars.size());
  const unsigned int last_var = this->add_variables(sys, vars, type, active_subdomains);
  const unsigned int first_var = last_var + 1 - count;
  _array_variables.push_back({first_var, first_var + count});
  return last_var;
}

Referenced by libMesh::System::add_variable_array().

add_variables()

unsigned int libMesh::DofMap::add_variables	(	System &	sys,
		const std::vector< std::string > &	vars,
		const FEType &	type,
		const std::set< subdomain_id_type > *const	active_subdomains = nullptr
	)

Adds the variables vars to the list of variables for this system.

If active_subdomains is either nullptr (the default) or points to an empty set, then it will be assumed that the vars have no subdomain restrictions

Returns

The index number for the last of the new variables.

Definition at line 3253 of file dof_map.C.

{
  parallel_object_only(); // Not strictly needed, but the only safe way to keep in sync
 
  libmesh_assert(!sys.is_initialized());
 
  libmesh_assert(this->comm().verify(vars.size()));
  libmesh_assert(this->comm().verify(type));
  libmesh_assert(this->comm().verify((active_subdomains == nullptr)));
 
  if (active_subdomains)
    libmesh_assert(this->comm().verify(active_subdomains->size()));
 
  // Make sure the variable isn't there already
  // or if it is, that it's the type we want
  for (auto ovar : vars)
    {
      libmesh_assert(this->comm().verify(ovar));
 
      for (auto v : make_range(this->n_vars()))
        if (this->variable_name(v) == ovar)
          {
            if (this->variable_type(v) == type)
              return _variables[v].number();
 
            libmesh_error_msg("ERROR: incompatible variable "
                              << ovar << " has already been added for this system!");
          }
    }
 
  if (this->n_variable_groups())
    {
      // Optimize for VariableGroups here - if the user is adding multiple
      // variables of the same FEType and subdomain restriction, catch
      // that here and add them as members of the same VariableGroup.
      //
      // start by setting this flag to whatever the user has requested
      // and then consider the conditions which should negate it.
      bool should_be_in_vg = this->identify_variable_groups();
 
      VariableGroup & vg = _variable_groups.back();
 
      // get a pointer to their subdomain restriction, if any.
      const std::set<subdomain_id_type> * const their_active_subdomains(
          vg.implicitly_active() ? nullptr : &vg.active_subdomains());
 
      // Different types?
      if (vg.type() != type)
        should_be_in_vg = false;
 
      // they are restricted, we aren't?
      if (their_active_subdomains &&
          (!active_subdomains || (active_subdomains && active_subdomains->empty())))
        should_be_in_vg = false;
 
      // they aren't restricted, we are?
      if (!their_active_subdomains && (active_subdomains && !active_subdomains->empty()))
        should_be_in_vg = false;
 
      if (their_active_subdomains && active_subdomains)
        // restricted to different sets?
        if (*their_active_subdomains != *active_subdomains)
          should_be_in_vg = false;
 
      // If after all that none of the conditions were violated,
      // append the variables to the vg and we're done
      if (should_be_in_vg)
        {
          unsigned int vn = this->n_vars();
          const unsigned int vgn = _variable_groups.size() - 1;
 
          for (auto ovar : vars)
            {
              vn = this->n_vars();
 
              vg.append(ovar);
 
              _variables.push_back(vg(vg.n_variables() - 1));
              _variable_numbers[ovar] = vn;
              _variable_group_numbers.push_back(vgn);
              _var_to_vg.emplace(vn, vgn);
            }
          return vn;
        }
    }
 
  const unsigned int curr_n_vars = this->n_vars();
 
  const unsigned int next_first_component = this->n_components(sys.get_mesh());
 
  // We weren't able to add to an existing variable group, so
  // add a new variable group to the list
  _variable_groups.push_back(
      (active_subdomains == nullptr)
          ? VariableGroup(&sys, vars, curr_n_vars, next_first_component, type)
          : VariableGroup(&sys, vars, curr_n_vars, next_first_component, type, *active_subdomains));
 
  const VariableGroup & vg(_variable_groups.back());
  const unsigned int vgn = _variable_groups.size() - 1;
 
  // Add each component of the group individually
  for (auto v : make_range(vars.size()))
    {
      const unsigned int vn = curr_n_vars + v;
      _variables.push_back(vg(v));
      _variable_numbers[vars[v]] = vn;
      _variable_group_numbers.push_back(vgn);
      _var_to_vg.emplace(vn, vgn);
    }
 
  libmesh_assert_equal_to((curr_n_vars + vars.size()), this->n_vars());
 
  // BSK - Defer this now to System::init_data() so we can detect
  // VariableGroups 12/28/2012
  // // Add the variable group to the _dof_map
  // _dof_map->add_variable_group (vg);
 
  // Return the number of the new variable
  return cast_int<unsigned int>(curr_n_vars + vars.size() - 1);
}

References libMesh::Variable::active_subdomains(), libMesh::VariableGroup::append(), libMesh::System::get_mesh(), libMesh::Variable::implicitly_active(), libMesh::System::is_initialized(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::VariableGroup::n_variables(), n_vars, and libMesh::Variable::type().

Referenced by libMesh::System::add_variables().

algebraic_ghosting_functors_begin()

GhostingFunctorIterator libMesh::DofMap::algebraic_ghosting_functors_begin ( ) const

inline

Beginning of range of algebraic ghosting functors.

Definition at line 428 of file dof_map.h.

  { return _algebraic_ghosting_functors.begin(); }

References _algebraic_ghosting_functors.

algebraic_ghosting_functors_end()

GhostingFunctorIterator libMesh::DofMap::algebraic_ghosting_functors_end ( ) const

inline

End of range of algebraic ghosting functors.

Definition at line 434 of file dof_map.h.

  { return _algebraic_ghosting_functors.end(); }

References _algebraic_ghosting_functors.

all_semilocal_indices()

bool libMesh::DofMap::all_semilocal_indices

(

const std::vector< dof_id_type > &

dof_indices

)

const

Returns

true if all degree of freedom indices in dof_indices are either local indices or in the send_list.

Note

This is an O(logN) operation for a send_list of size N; we don't cache enough information for O(1) right now.

Definition at line 2660 of file dof_map.C.

{
  // We're all semilocal unless we find a counterexample
  for (const auto & di : dof_indices_in)
    if (!this->semilocal_index(di))
      return false;
 
  return true;
}

allgather_recursive_constraints()

void libMesh::DofMap::allgather_recursive_constraints

(

MeshBase &

mesh

)

Gathers constraint equation dependencies from other processors.

Definition at line 3677 of file dof_map_constraints.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  // Return immediately if there's nothing to gather
  if (this->n_processors() == 1)
    return;
 
  // We might get to return immediately if none of the processors
  // found any constraints
  unsigned int has_constraints = !_dof_constraints.empty()
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
    || !_node_constraints.empty()
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
    ;
  this->comm().max(has_constraints);
  if (!has_constraints)
    return;
 
  // If we have heterogeneous adjoint constraints we need to
  // communicate those too.
  const unsigned int max_qoi_num =
    _adjoint_constraint_values.empty() ?
    0 : _adjoint_constraint_values.rbegin()->first+1;
 
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  // We may need to send nodes ahead of data about them
  std::vector<Parallel::Request> packed_range_sends;
 
  // We may be receiving packed_range sends out of order with
  // parallel_sync tags, so make sure they're received correctly.
  Parallel::MessageTag range_tag = this->comm().get_unique_tag();
 
  // We only need to do these sends on a distributed mesh
  const bool dist_mesh = !mesh.is_serial();
#endif
 
  // We might have calculated constraints for constrained dofs
  // which have support on other processors.
  // Push these out first.
  {
    std::map<processor_id_type, std::set<dof_id_type>> pushed_ids;
 
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
    std::map<processor_id_type, std::set<dof_id_type>> pushed_node_ids;
#endif
 
    const unsigned int sys_num = this->sys_number();
 
    // Collect the constraints to push to each processor
    for (auto & elem : as_range(mesh.active_not_local_elements_begin(),
                                mesh.active_not_local_elements_end()))
      {
        const unsigned short n_nodes = elem->n_nodes();
 
        // Just checking dof_indices on the foreign element isn't
        // enough.  Consider a central hanging node between a coarse
        // Q2/Q1 element and its finer neighbors on a higher-ranked
        // processor.  The coarse element's processor will own the node,
        // and will thereby own the pressure dof on that node, despite
        // the fact that that pressure dof doesn't directly exist on the
        // coarse element!
        //
        // So, we loop through dofs manually.
 
        {
          const unsigned int n_vars = elem->n_vars(sys_num);
          for (unsigned int v=0; v != n_vars; ++v)
            {
              const unsigned int n_comp = elem->n_comp(sys_num,v);
              for (unsigned int c=0; c != n_comp; ++c)
                {
                  const unsigned int id =
                    elem->dof_number(sys_num,v,c);
                  if (this->is_constrained_dof(id))
                    pushed_ids[elem->processor_id()].insert(id);
                }
            }
        }
 
        for (unsigned short n = 0; n != n_nodes; ++n)
          {
            const Node & node = elem->node_ref(n);
            const unsigned int n_vars = node.n_vars(sys_num);
            for (unsigned int v=0; v != n_vars; ++v)
              {
                const unsigned int n_comp = node.n_comp(sys_num,v);
                for (unsigned int c=0; c != n_comp; ++c)
                  {
                    const unsigned int id =
                      node.dof_number(sys_num,v,c);
                    if (this->is_constrained_dof(id))
                      pushed_ids[elem->processor_id()].insert(id);
                  }
              }
          }
 
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
        for (unsigned short n = 0; n != n_nodes; ++n)
          if (this->is_constrained_node(elem->node_ptr(n)))
            pushed_node_ids[elem->processor_id()].insert(elem->node_id(n));
#endif
      }
 
    // Rewrite those id sets as vectors for sending and receiving,
    // then find the corresponding data for each id, then push it all.
    std::map<processor_id_type, std::vector<dof_id_type>>
      pushed_id_vecs, received_id_vecs;
    for (auto & p : pushed_ids)
      pushed_id_vecs[p.first].assign(p.second.begin(), p.second.end());
 
    std::map<processor_id_type, std::vector<std::vector<std::pair<dof_id_type,Real>>>>
      pushed_keys_vals, received_keys_vals;
    std::map<processor_id_type, std::vector<std::vector<Number>>> pushed_rhss, received_rhss;
    for (auto & p : pushed_id_vecs)
      {
        auto & keys_vals = pushed_keys_vals[p.first];
        keys_vals.reserve(p.second.size());
 
        auto & rhss = pushed_rhss[p.first];
        rhss.reserve(p.second.size());
        for (auto & pushed_id : p.second)
          {
            const DofConstraintRow & row = _dof_constraints[pushed_id];
            keys_vals.emplace_back(row.begin(), row.end());
 
            rhss.push_back(std::vector<Number>(max_qoi_num+1));
            std::vector<Number> & rhs = rhss.back();
            DofConstraintValueMap::const_iterator rhsit =
              _primal_constraint_values.find(pushed_id);
            rhs[max_qoi_num] =
              (rhsit == _primal_constraint_values.end()) ?
              0 : rhsit->second;
            for (unsigned int q = 0; q != max_qoi_num; ++q)
              {
                AdjointDofConstraintValues::const_iterator adjoint_map_it =
                  _adjoint_constraint_values.find(q);
 
                if (adjoint_map_it == _adjoint_constraint_values.end())
                  continue;
 
                const DofConstraintValueMap & constraint_map =
                  adjoint_map_it->second;
 
                DofConstraintValueMap::const_iterator adj_rhsit =
                  constraint_map.find(pushed_id);
 
                rhs[q] =
                  (adj_rhsit == constraint_map.end()) ?
                  0 : adj_rhsit->second;
              }
          }
      }
 
    auto ids_action_functor =
      [& received_id_vecs]
      (processor_id_type pid,
       const std::vector<dof_id_type> & data)
      {
        received_id_vecs[pid] = data;
      };
 
    Parallel::push_parallel_vector_data
      (this->comm(), pushed_id_vecs, ids_action_functor);
 
    auto keys_vals_action_functor =
      [& received_keys_vals]
      (processor_id_type pid,
       const std::vector<std::vector<std::pair<dof_id_type,Real>>> & data)
      {
        received_keys_vals[pid] = data;
      };
 
    Parallel::push_parallel_vector_data
      (this->comm(), pushed_keys_vals, keys_vals_action_functor);
 
    auto rhss_action_functor =
      [& received_rhss]
      (processor_id_type pid,
       const std::vector<std::vector<Number>> & data)
      {
        received_rhss[pid] = data;
      };
 
    Parallel::push_parallel_vector_data
      (this->comm(), pushed_rhss, rhss_action_functor);
 
    // Now we have all the DofConstraint rows and rhs values received
    // from others, so add the DoF constraints that we've been sent
 
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
    std::map<processor_id_type, std::vector<dof_id_type>>
      pushed_node_id_vecs, received_node_id_vecs;
    for (auto & p : pushed_node_ids)
      pushed_node_id_vecs[p.first].assign(p.second.begin(), p.second.end());
 
    std::map<processor_id_type, std::vector<std::vector<std::pair<dof_id_type,Real>>>>
      pushed_node_keys_vals, received_node_keys_vals;
    std::map<processor_id_type, std::vector<Point>> pushed_offsets, received_offsets;
 
    for (auto & p : pushed_node_id_vecs)
      {
        const processor_id_type pid = p.first;
 
        // FIXME - this could be an unordered set, given a
        // hash<pointers> specialization
        std::set<const Node *> nodes_requested;
 
        auto & node_keys_vals = pushed_node_keys_vals[pid];
        node_keys_vals.reserve(p.second.size());
 
        auto & offsets = pushed_offsets[pid];
        offsets.reserve(p.second.size());
 
        for (auto & pushed_node_id : p.second)
          {
            const Node * node = mesh.node_ptr(pushed_node_id);
            NodeConstraintRow & row = _node_constraints[node].first;
            const std::size_t row_size = row.size();
            node_keys_vals.push_back
              (std::vector<std::pair<dof_id_type,Real>>());
            std::vector<std::pair<dof_id_type,Real>> & this_node_kv =
              node_keys_vals.back();
            this_node_kv.reserve(row_size);
            for (const auto & j : row)
              {
                this_node_kv.emplace_back(j.first->id(), j.second);
 
                // If we're not sure whether our send
                // destination already has this node, let's give
                // it a copy.
                if (j.first->processor_id() != pid && dist_mesh)
                  nodes_requested.insert(j.first);
              }
 
            offsets.push_back(_node_constraints[node].second);
 
          }
 
        // Constraining nodes might not even exist on our
        // correspondant's subset of a distributed mesh, so let's
        // make them exist.
        if (dist_mesh)
          {
            packed_range_sends.push_back(Parallel::Request());
            this->comm().send_packed_range
              (pid, &mesh, nodes_requested.begin(), nodes_requested.end(),
               packed_range_sends.back(), range_tag);
          }
      }
 
    auto node_ids_action_functor =
      [& received_node_id_vecs]
      (processor_id_type pid,
       const std::vector<dof_id_type> & data)
      {
        received_node_id_vecs[pid] = data;
      };
 
    Parallel::push_parallel_vector_data
      (this->comm(), pushed_node_id_vecs, node_ids_action_functor);
 
    auto node_keys_vals_action_functor =
      [& received_node_keys_vals]
      (processor_id_type pid,
       const std::vector<std::vector<std::pair<dof_id_type,Real>>> & data)
      {
        received_node_keys_vals[pid] = data;
      };
 
    Parallel::push_parallel_vector_data
      (this->comm(), pushed_node_keys_vals,
       node_keys_vals_action_functor);
 
    auto node_offsets_action_functor =
      [& received_offsets]
      (processor_id_type pid,
       const std::vector<Point> & data)
      {
        received_offsets[pid] = data;
      };
 
    Parallel::push_parallel_vector_data
      (this->comm(), pushed_offsets, node_offsets_action_functor);
 
#endif
 
    // Add all the dof constraints that I've been sent
    for (auto & [pid, pushed_ids_to_me] : received_id_vecs)
      {
        libmesh_assert(received_keys_vals.count(pid));
        libmesh_assert(received_rhss.count(pid));
        const auto & pushed_keys_vals_to_me = received_keys_vals.at(pid);
        const auto & pushed_rhss_to_me = received_rhss.at(pid);
 
        libmesh_assert_equal_to (pushed_ids_to_me.size(),
                                 pushed_keys_vals_to_me.size());
        libmesh_assert_equal_to (pushed_ids_to_me.size(),
                                 pushed_rhss_to_me.size());
 
        for (auto i : index_range(pushed_ids_to_me))
          {
            dof_id_type constrained = pushed_ids_to_me[i];
 
            // If we don't already have a constraint for this dof,
            // add the one we were sent
            if (!this->is_constrained_dof(constrained))
              {
                DofConstraintRow & row = _dof_constraints[constrained];
                for (auto & kv : pushed_keys_vals_to_me[i])
                  {
                    libmesh_assert_less(kv.first, this->n_dofs());
                    row[kv.first] = kv.second;
                  }
 
                const Number primal_rhs = pushed_rhss_to_me[i][max_qoi_num];
 
                if (libmesh_isnan(primal_rhs))
                  libmesh_assert(pushed_keys_vals_to_me[i].empty());
 
                if (primal_rhs != Number(0))
                  _primal_constraint_values[constrained] = primal_rhs;
                else
                  _primal_constraint_values.erase(constrained);
 
                for (unsigned int q = 0; q != max_qoi_num; ++q)
                  {
                    AdjointDofConstraintValues::iterator adjoint_map_it =
                      _adjoint_constraint_values.find(q);
 
                    const Number adj_rhs = pushed_rhss_to_me[i][q];
 
                    if ((adjoint_map_it == _adjoint_constraint_values.end()) &&
                        adj_rhs == Number(0))
                      continue;
 
                    if (adjoint_map_it == _adjoint_constraint_values.end())
                      adjoint_map_it = _adjoint_constraint_values.emplace
                        (q, DofConstraintValueMap()).first;
 
                    DofConstraintValueMap & constraint_map =
                      adjoint_map_it->second;
 
                    if (adj_rhs != Number(0))
                      constraint_map[constrained] = adj_rhs;
                    else
                      constraint_map.erase(constrained);
                  }
              }
          }
      }
 
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
    // Add all the node constraints that I've been sent
    for (auto & [pid, pushed_node_ids_to_me] : received_node_id_vecs)
      {
        // Before we act on any new constraint rows, we may need to
        // make sure we have all the nodes involved!
        if (dist_mesh)
          this->comm().receive_packed_range
            (pid, &mesh, null_output_iterator<Node>(),
             (Node**)nullptr, range_tag);
 
        libmesh_assert(received_node_keys_vals.count(pid));
        libmesh_assert(received_offsets.count(pid));
        const auto & pushed_node_keys_vals_to_me = received_node_keys_vals.at(pid);
        const auto & pushed_offsets_to_me = received_offsets.at(pid);
 
        libmesh_assert_equal_to (pushed_node_ids_to_me.size(),
                                 pushed_node_keys_vals_to_me.size());
        libmesh_assert_equal_to (pushed_node_ids_to_me.size(),
                                 pushed_offsets_to_me.size());
 
        for (auto i : index_range(pushed_node_ids_to_me))
          {
            dof_id_type constrained_id = pushed_node_ids_to_me[i];
 
            // If we don't already have a constraint for this node,
            // add the one we were sent
            const Node * constrained = mesh.node_ptr(constrained_id);
            if (!this->is_constrained_node(constrained))
              {
                NodeConstraintRow & row = _node_constraints[constrained].first;
                for (auto & kv : pushed_node_keys_vals_to_me[i])
                  {
                    const Node * key_node = mesh.node_ptr(kv.first);
                    libmesh_assert(key_node);
                    row[key_node] = kv.second;
                  }
                _node_constraints[constrained].second = pushed_offsets_to_me[i];
              }
          }
      }
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
  }
 
  // Now start checking for any other constraints we need
  // to know about, requesting them recursively.
 
  // Create sets containing the DOFs and nodes we already depend on
  typedef std::set<dof_id_type> DoF_RCSet;
  DoF_RCSet unexpanded_dofs;
 
  for (const auto & i : _dof_constraints)
    unexpanded_dofs.insert(i.first);
 
  // Gather all the dof constraints we need
  this->gather_constraints(mesh, unexpanded_dofs, false);
 
  // Gather all the node constraints we need
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  typedef std::set<const Node *> Node_RCSet;
  Node_RCSet unexpanded_nodes;
 
  for (const auto & i : _node_constraints)
    unexpanded_nodes.insert(i.first);
 
  // We have to keep recursing while the unexpanded set is
  // nonempty on *any* processor
  bool unexpanded_set_nonempty = !unexpanded_nodes.empty();
  this->comm().max(unexpanded_set_nonempty);
 
  while (unexpanded_set_nonempty)
    {
      // Let's make sure we don't lose sync in this loop.
      parallel_object_only();
 
      // Request sets
      Node_RCSet node_request_set;
 
      // Request sets to send to each processor
      std::map<processor_id_type, std::vector<dof_id_type>>
        requested_node_ids;
 
      // And the sizes of each
      std::map<processor_id_type, dof_id_type> node_ids_on_proc;
 
      // Fill (and thereby sort and uniq!) the main request sets
      for (const auto & i : unexpanded_nodes)
        {
          NodeConstraintRow & row = _node_constraints[i].first;
          for (const auto & j : row)
            {
              const Node * const node = j.first;
              libmesh_assert(node);
 
              // If it's non-local and we haven't already got a
              // constraint for it, we might need to ask for one
              if ((node->processor_id() != this->processor_id()) &&
                  !_node_constraints.count(node))
                node_request_set.insert(node);
            }
        }
 
      // Clear the unexpanded constraint sets; we're about to expand
      // them
      unexpanded_nodes.clear();
 
      // Count requests by processor
      for (const auto & node : node_request_set)
        {
          libmesh_assert(node);
          libmesh_assert_less (node->processor_id(), this->n_processors());
          node_ids_on_proc[node->processor_id()]++;
        }
 
      for (auto pair : node_ids_on_proc)
        requested_node_ids[pair.first].reserve(pair.second);
 
      // Prepare each processor's request set
      for (const auto & node : node_request_set)
        requested_node_ids[node->processor_id()].push_back(node->id());
 
      typedef std::vector<std::pair<dof_id_type, Real>> row_datum;
 
      auto node_row_gather_functor =
        [this,
         & mesh,
         dist_mesh,
         & packed_range_sends,
         & range_tag]
        (processor_id_type pid,
         const std::vector<dof_id_type> & ids,
         std::vector<row_datum> & data)
        {
          // FIXME - this could be an unordered set, given a
          // hash<pointers> specialization
          std::set<const Node *> nodes_requested;
 
          // Fill those requests
          const std::size_t query_size = ids.size();
 
          data.resize(query_size);
          for (std::size_t i=0; i != query_size; ++i)
            {
              dof_id_type constrained_id = ids[i];
              const Node * constrained_node = mesh.node_ptr(constrained_id);
              if (_node_constraints.count(constrained_node))
                {
                  const NodeConstraintRow & row = _node_constraints[constrained_node].first;
                  std::size_t row_size = row.size();
                  data[i].reserve(row_size);
                  for (const auto & j : row)
                    {
                      const Node * node = j.first;
                      data[i].emplace_back(node->id(), j.second);
 
                      // If we're not sure whether our send
                      // destination already has this node, let's give
                      // it a copy.
                      if (node->processor_id() != pid && dist_mesh)
                        nodes_requested.insert(node);
 
                      // We can have 0 nodal constraint
                      // coefficients, where no Lagrange constraint
                      // exists but non-Lagrange basis constraints
                      // might.
                      // libmesh_assert(j.second);
                    }
                }
              else
                {
                  // We have to distinguish "constraint with no
                  // constraining nodes" (e.g. due to user node
                  // constraint equations) from "no constraint".
                  // We'll use invalid_id for the latter.
                  data[i].emplace_back(DofObject::invalid_id, Real(0));
                }
            }
 
          // Constraining nodes might not even exist on our
          // correspondant's subset of a distributed mesh, so let's
          // make them exist.
          if (dist_mesh)
            {
              packed_range_sends.push_back(Parallel::Request());
              this->comm().send_packed_range
                (pid, &mesh, nodes_requested.begin(), nodes_requested.end(),
                 packed_range_sends.back(), range_tag);
            }
        };
 
      typedef Point node_rhs_datum;
 
      auto node_rhs_gather_functor =
        [this,
         & mesh]
        (processor_id_type,
         const std::vector<dof_id_type> & ids,
         std::vector<node_rhs_datum> & data)
        {
          // Fill those requests
          const std::size_t query_size = ids.size();
 
          data.resize(query_size);
          for (std::size_t i=0; i != query_size; ++i)
            {
              dof_id_type constrained_id = ids[i];
              const Node * constrained_node = mesh.node_ptr(constrained_id);
              if (_node_constraints.count(constrained_node))
                data[i] = _node_constraints[constrained_node].second;
              else
                data[i](0) = std::numeric_limits<Real>::quiet_NaN();
            }
        };
 
      auto node_row_action_functor =
        [this,
         & mesh,
         dist_mesh,
         & range_tag,
         & unexpanded_nodes]
        (processor_id_type pid,
         const std::vector<dof_id_type> & ids,
         const std::vector<row_datum> & data)
        {
          // Before we act on any new constraint rows, we may need to
          // make sure we have all the nodes involved!
          if (dist_mesh)
            this->comm().receive_packed_range
              (pid, &mesh, null_output_iterator<Node>(),
               (Node**)nullptr, range_tag);
 
          // Add any new constraint rows we've found
          const std::size_t query_size = ids.size();
 
          for (std::size_t i=0; i != query_size; ++i)
            {
              const dof_id_type constrained_id = ids[i];
 
              // An empty row is an constraint with an empty row; for
              // no constraint we use a "no row" placeholder
              if (data[i].empty())
                {
                  const Node * constrained_node = mesh.node_ptr(constrained_id);
                  NodeConstraintRow & row = _node_constraints[constrained_node].first;
                  row.clear();
                }
              else if (data[i][0].first != DofObject::invalid_id)
                {
                  const Node * constrained_node = mesh.node_ptr(constrained_id);
                  NodeConstraintRow & row = _node_constraints[constrained_node].first;
                  row.clear();
                  for (auto & pair : data[i])
                    {
                      const Node * key_node =
                        mesh.node_ptr(pair.first);
                      libmesh_assert(key_node);
                      row[key_node] = pair.second;
                    }
 
                  // And prepare to check for more recursive constraints
                  unexpanded_nodes.insert(constrained_node);
                }
            }
        };
 
      auto node_rhs_action_functor =
        [this,
         & mesh]
        (processor_id_type,
         const std::vector<dof_id_type> & ids,
         const std::vector<node_rhs_datum> & data)
        {
          // Add rhs data for any new node constraint rows we've found
          const std::size_t query_size = ids.size();
 
          for (std::size_t i=0; i != query_size; ++i)
            {
              dof_id_type constrained_id = ids[i];
              const Node * constrained_node = mesh.node_ptr(constrained_id);
 
              if (!libmesh_isnan(data[i](0)))
                _node_constraints[constrained_node].second = data[i];
              else
                _node_constraints.erase(constrained_node);
            }
        };
 
      // Now request node constraint rows from other processors
      row_datum * node_row_ex = nullptr;
      Parallel::pull_parallel_vector_data
        (this->comm(), requested_node_ids, node_row_gather_functor,
         node_row_action_functor, node_row_ex);
 
      // And request node constraint right hand sides from other procesors
      node_rhs_datum * node_rhs_ex = nullptr;
      Parallel::pull_parallel_vector_data
        (this->comm(), requested_node_ids, node_rhs_gather_functor,
         node_rhs_action_functor, node_rhs_ex);
 
 
      // We have to keep recursing while the unexpanded set is
      // nonempty on *any* processor
      unexpanded_set_nonempty = !unexpanded_nodes.empty();
      this->comm().max(unexpanded_set_nonempty);
    }
  Parallel::wait(packed_range_sends);
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
}

References _adjoint_constraint_values, _dof_constraints, _node_constraints, _primal_constraint_values, libMesh::as_range(), libMesh::ParallelObject::comm(), libMesh::DofObject::dof_number(), gather_constraints(), libMesh::Parallel::Communicator::get_unique_tag(), libMesh::DofObject::id(), libMesh::index_range(), libMesh::DofObject::invalid_id, is_constrained_dof(), is_constrained_node(), libMesh::MeshBase::is_serial(), libMesh::libmesh_assert(), libMesh::libmesh_isnan(), libMesh::Parallel::Communicator::max(), mesh, libMesh::DofObject::n_comp(), libMesh::Elem::n_nodes(), n_nodes, libMesh::ParallelObject::n_processors(), n_vars(), libMesh::DofObject::n_vars(), libMesh::Elem::node_id(), libMesh::MeshBase::node_ptr(), libMesh::Elem::node_ptr(), libMesh::Elem::node_ref(), libMesh::DofObject::processor_id(), TIMPI::pull_parallel_vector_data(), TIMPI::push_parallel_vector_data(), libMesh::Real, libMesh::Parallel::Communicator::receive_packed_range(), libMesh::Parallel::Communicator::send_packed_range(), sys_number(), and TIMPI::wait().

Referenced by process_constraints().

array_dof_indices() [1/3]

template<typename DofIndicesFunctor >

void libMesh::DofMap::array_dof_indices	(	const DofIndicesFunctor &	functor,
		std::vector< dof_id_type > &	di,
		const unsigned int	vn
	)		const

Definition at line 2890 of file dof_map.h.

{
  const auto [begin, end] = this->get_variable_array(vn);
  functor(di, begin);
 
  const unsigned int count = end - begin;
  // We make count, which could be >> ntest, the inner index in hopes of vectorization
  if (count > 1)
    {
      const dof_id_type component_size = di.size();
      di.resize(count * component_size);
 
      const auto pack_container = [&di,
                                   component_size](const unsigned int j,
                                                   const std::vector<dof_id_type> & j_dof_indices,
                                                   const unsigned int stride) {
        if (&j_dof_indices != &di)
          libmesh_assert(j_dof_indices.size() == component_size);
        for (const auto i : make_range(component_size))
          di[j * component_size + i] = j_dof_indices[i] + stride * j;
      };
      pack_container(0, di, 0);
 
      const auto & fe_type = _variable_groups[libmesh_map_find(_var_to_vg, vn)].type();
      if (const bool lagrange = fe_type.family == LAGRANGE;
          lagrange || (FEInterface::get_continuity(fe_type) == DISCONTINUOUS))
        {
          const auto stride = lagrange ? 1 : component_size;
          for (const auto j : make_range((unsigned int)1, count))
            pack_container(j, di, stride);
        }
      else
        {
          static thread_local std::vector<dof_id_type> work_dof_indices;
          unsigned int j = 1;
          for (const auto i : make_range(begin + 1, end))
            {
              functor(work_dof_indices, i);
              pack_container(j++, work_dof_indices, 0);
            }
        }
    }
}

References _var_to_vg, _variable_groups, libMesh::DISCONTINUOUS, libMesh::FEInterface::get_continuity(), get_variable_array(), libMesh::LAGRANGE, libMesh::libmesh_assert(), and libMesh::make_range().

array_dof_indices() [2/3]

void libMesh::DofMap::array_dof_indices	(	const Elem *const	elem,
		std::vector< dof_id_type > &	di,
		const unsigned int	vn,
		int	p_level = -12345
	)		const

Fills the vector di with the global degree of freedom indices for the element.

This will aggregate all the degrees of the freedom from the variable array that vn is a member of, and potentially for a non-default element p refinement level

Definition at line 2339 of file dof_map.C.

{
  auto dof_indices_functor = [elem, p_level, this](std::vector<dof_id_type> & functor_di,
                                                   const unsigned int functor_vn) {
    this->dof_indices(elem, functor_di, functor_vn, p_level);
  };
  this->array_dof_indices(dof_indices_functor, di, vn);
}

array_dof_indices() [3/3]

void libMesh::DofMap::array_dof_indices	(	const Node *const	node,
		std::vector< dof_id_type > &	di,
		const unsigned int	vn
	)		const

Definition at line 2351 of file dof_map.C.

{
  auto dof_indices_functor = [node, this](std::vector<dof_id_type> & functor_di,
                                          const unsigned int functor_vn) {
    this->dof_indices(node, functor_di, functor_vn);
  };
  this->array_dof_indices(dof_indices_functor, di, vn);
}

assert_no_nodes_missed()

void libMesh::DofMap::assert_no_nodes_missed ( MeshBase &  mesh )

private

Definition at line 1563 of file dof_map.C.

{
  MeshTools::libmesh_assert_valid_procids<Node>(mesh);
 
  for (auto & node : mesh.local_node_ptr_range())
    {
      unsigned int n_var_g = node->n_var_groups(this->sys_number());
      for (unsigned int vg=0; vg != n_var_g; ++vg)
        {
          unsigned int n_comp_g =
            node->n_comp_group(this->sys_number(), vg);
          dof_id_type my_first_dof = n_comp_g ?
            node->vg_dof_base(this->sys_number(), vg) : 0;
          libmesh_assert_not_equal_to (my_first_dof, DofObject::invalid_id);
        }
    }
}

References mesh.

attach_extra_send_list_function()

void libMesh::DofMap::attach_extra_send_list_function ( void(*)(std::vector< dof_id_type > &, void *)  func, void *  context = nullptr  )

inline

Attach a function pointer to use as a callback to populate the send_list with extra entries.

Definition at line 490 of file dof_map.h.

  { _extra_send_list_function = func; _extra_send_list_context = context; }

References _extra_send_list_context, and _extra_send_list_function.

attach_extra_send_list_object()

void libMesh::DofMap::attach_extra_send_list_object ( DofMap::AugmentSendList &  asl )

inline

Attach an object to populate the send_list with extra entries.

This should only add to the send list, but no checking is done to enforce this behavior.

This is an advanced function... use at your own peril!

Definition at line 481 of file dof_map.h.

  {
    _augment_send_list = &asl;
  }

References _augment_send_list.

attach_extra_sparsity_function()

void libMesh::DofMap::attach_extra_sparsity_function ( void(*)(SparsityPattern::Graph &sparsity, std::vector< dof_id_type > &n_nz, std::vector< dof_id_type > &n_oz, void *)  func, void *  context = nullptr  )

inline

Attach a function pointer to use as a callback to populate the sparsity pattern with extra entries.

Care must be taken that when adding entries they are sorted into the Rows

Further, you must modify n_nz and n_oz properly!

This is an advanced function... use at your own peril!

Definition at line 467 of file dof_map.h.

  { _extra_sparsity_function = func; _extra_sparsity_context = context; }

References _extra_sparsity_context, and _extra_sparsity_function.

attach_extra_sparsity_object()

void libMesh::DofMap::attach_extra_sparsity_object ( SparsityPattern::AugmentSparsityPattern &  asp )

inline

Attach an object to use to populate the sparsity pattern with extra entries.

Care must be taken that when adding entries they are sorted into the Rows

Further, you must modify n_nz and n_oz properly!

This is an advanced function... use at your own peril!

Definition at line 452 of file dof_map.h.

  {
    _augment_sparsity_pattern = &asp;
  }

References _augment_sparsity_pattern.

attach_matrix()

void libMesh::DofMap::attach_matrix

(

SparseMatrix< Number > &

matrix

)

Additional matrices may be attached to this DofMap.

They are initialized to the same sparsity structure as the major matrix.

Definition at line 240 of file dof_map.C.

{
  parallel_object_only();
 
  // We shouldn't be trying to re-attach the same matrices repeatedly
  libmesh_assert (std::find(_matrices.begin(), _matrices.end(),
                            &matrix) == _matrices.end());
 
  _matrices.push_back(&matrix);
 
  this->update_sparsity_pattern(matrix);
 
  if (matrix.need_full_sparsity_pattern())
    need_full_sparsity_pattern = true;
}

References _matrices, libMesh::libmesh_assert(), need_full_sparsity_pattern, libMesh::SparseMatrix< T >::need_full_sparsity_pattern(), and update_sparsity_pattern().

Referenced by libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::ClawSystem::init_data(), libMesh::System::init_matrices(), and libMesh::System::late_matrix_init().

block_size()

unsigned int libMesh::DofMap::block_size ( ) const

inline

Returns

The block size, if the variables are amenable to block storage. Otherwise 1. This routine was originally designed to enable a blocked storage, but it turns out this information is still super useful for solvers even when we do not use the blocked storage (e.g., MATMPIBAIJ in PETSc). For example (in PCHMG), for a system of PDEs, to construct an efficient multilevel preconditioner, we coarsen the matrix of one single PDE instead of the entire huge matrix. In order to accomplish this, we need to know many PDEs we have. Another use case, the fieldsplit preconditioner can be constructed in place with this info without involving any user efforts.

Definition at line 766 of file dof_map.h.

  {
    return (this->has_blocked_representation() ? this->n_variables() : 1);
  }

References has_blocked_representation(), and n_variables().

build_constraint_matrix()

void libMesh::DofMap::build_constraint_matrix ( DenseMatrix< Number > &  C, std::vector< dof_id_type > &  elem_dofs, const bool  called_recursively = false  ) const

private

Build the constraint matrix C associated with the element degree of freedom indices elem_dofs.

The optional parameter called_recursively should be left at the default value false. This is used to handle the special case of an element's degrees of freedom being constrained in terms of other, local degrees of freedom. The usual case is for an elements DOFs to be constrained by some other, external DOFs.

Definition at line 3433 of file dof_map_constraints.C.

{
  LOG_SCOPE_IF("build_constraint_matrix()", "DofMap", !called_recursively);
 
  // Create a set containing the DOFs we already depend on
  typedef std::set<dof_id_type> RCSet;
  RCSet dof_set;
 
  bool we_have_constraints = false;
 
  // Next insert any other dofs the current dofs might be constrained
  // in terms of.  Note that in this case we may not be done: Those
  // may in turn depend on others.  So, we need to repeat this process
  // in that case until the system depends only on unconstrained
  // degrees of freedom.
  for (const auto & dof : elem_dofs)
    if (this->is_constrained_dof(dof))
      {
        we_have_constraints = true;
 
        // If the DOF is constrained
        DofConstraints::const_iterator
          pos = _dof_constraints.find(dof);
 
        libmesh_assert (pos != _dof_constraints.end());
 
        const DofConstraintRow & constraint_row = pos->second;
 
        // Constraint rows in p refinement may be empty
        //libmesh_assert (!constraint_row.empty());
 
        for (const auto & item : constraint_row)
          dof_set.insert (item.first);
      }
 
  // May be safe to return at this point
  // (but remember to stop the perflog)
  if (!we_have_constraints)
    return;
 
  for (const auto & dof : elem_dofs)
    dof_set.erase (dof);
 
  // If we added any DOFS then we need to do this recursively.
  // It is possible that we just added a DOF that is also
  // constrained!
  //
  // Also, we need to handle the special case of an element having DOFs
  // constrained in terms of other, local DOFs
  if (!dof_set.empty() ||  // case 1: constrained in terms of other DOFs
      !called_recursively) // case 2: constrained in terms of our own DOFs
    {
      const unsigned int old_size =
        cast_int<unsigned int>(elem_dofs.size());
 
      // Add new dependency dofs to the end of the current dof set
      elem_dofs.insert(elem_dofs.end(),
                       dof_set.begin(), dof_set.end());
 
      // Now we can build the constraint matrix.
      // Note that resize also zeros for a DenseMatrix<Number>.
      C.resize (old_size,
                cast_int<unsigned int>(elem_dofs.size()));
 
      // Create the C constraint matrix.
      for (unsigned int i=0; i != old_size; i++)
        if (this->is_constrained_dof(elem_dofs[i]))
          {
            // If the DOF is constrained
            DofConstraints::const_iterator
              pos = _dof_constraints.find(elem_dofs[i]);
 
            libmesh_assert (pos != _dof_constraints.end());
 
            const DofConstraintRow & constraint_row = pos->second;
 
            // p refinement creates empty constraint rows
            //    libmesh_assert (!constraint_row.empty());
 
            for (const auto & item : constraint_row)
              for (unsigned int j=0,
                   n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
                   j != n_elem_dofs; j++)
                if (elem_dofs[j] == item.first)
                  C(i,j) = item.second;
          }
        else
          {
            C(i,i) = 1.;
          }
 
      // May need to do this recursively.  It is possible
      // that we just replaced a constrained DOF with another
      // constrained DOF.
      DenseMatrix<Number> Cnew;
 
      this->build_constraint_matrix (Cnew, elem_dofs, true);
 
      if ((C.n() == Cnew.m()) &&
          (Cnew.n() == elem_dofs.size())) // If the constraint matrix
        C.right_multiply(Cnew);           // is constrained...
 
      libmesh_assert_equal_to (C.n(), elem_dofs.size());
    }
}

References _dof_constraints, build_constraint_matrix(), is_constrained_dof(), libMesh::libmesh_assert(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseMatrix< T >::resize(), and libMesh::DenseMatrix< T >::right_multiply().

Referenced by build_constraint_matrix(), constrain_element_residual(), and max_constraint_error().

build_constraint_matrix_and_vector()

void libMesh::DofMap::build_constraint_matrix_and_vector ( DenseMatrix< Number > &  C, DenseVector< Number > &  H, std::vector< dof_id_type > &  elem_dofs, int  qoi_index = -1, const bool  called_recursively = false  ) const

private

Build the constraint matrix C and the forcing vector H associated with the element degree of freedom indices elem_dofs.

The optional parameter called_recursively should be left at the default value false. This is used to handle the special case of an element's degrees of freedom being constrained in terms of other, local degrees of freedom. The usual case is for an elements DOFs to be constrained by some other, external DOFs and/or Dirichlet conditions.

The forcing vector will depend on which solution's heterogeneous constraints are being applied. For the default qoi_index this will be the primal solution; for qoi_index >= 0 the corresponding adjoint solution's constraints will be used.

Definition at line 3543 of file dof_map_constraints.C.

{
  LOG_SCOPE_IF("build_constraint_matrix_and_vector()", "DofMap", !called_recursively);
 
  // Create a set containing the DOFs we already depend on
  typedef std::set<dof_id_type> RCSet;
  RCSet dof_set;
 
  bool we_have_constraints = false;
 
  // Next insert any other dofs the current dofs might be constrained
  // in terms of.  Note that in this case we may not be done: Those
  // may in turn depend on others.  So, we need to repeat this process
  // in that case until the system depends only on unconstrained
  // degrees of freedom.
  for (const auto & dof : elem_dofs)
    if (this->is_constrained_dof(dof))
      {
        we_have_constraints = true;
 
        // If the DOF is constrained
        DofConstraints::const_iterator
          pos = _dof_constraints.find(dof);
 
        libmesh_assert (pos != _dof_constraints.end());
 
        const DofConstraintRow & constraint_row = pos->second;
 
        // Constraint rows in p refinement may be empty
        //libmesh_assert (!constraint_row.empty());
 
        for (const auto & item : constraint_row)
          dof_set.insert (item.first);
      }
 
  // May be safe to return at this point
  // (but remember to stop the perflog)
  if (!we_have_constraints)
    return;
 
  for (const auto & dof : elem_dofs)
    dof_set.erase (dof);
 
  // If we added any DOFS then we need to do this recursively.
  // It is possible that we just added a DOF that is also
  // constrained!
  //
  // Also, we need to handle the special case of an element having DOFs
  // constrained in terms of other, local DOFs
  if (!dof_set.empty() ||  // case 1: constrained in terms of other DOFs
      !called_recursively) // case 2: constrained in terms of our own DOFs
    {
      const DofConstraintValueMap * rhs_values = nullptr;
      if (qoi_index < 0)
        rhs_values = &_primal_constraint_values;
      else if (auto it = _adjoint_constraint_values.find(qoi_index);
               it != _adjoint_constraint_values.end())
        rhs_values = &it->second;
 
      const unsigned int old_size =
        cast_int<unsigned int>(elem_dofs.size());
 
      // Add new dependency dofs to the end of the current dof set
      elem_dofs.insert(elem_dofs.end(),
                       dof_set.begin(), dof_set.end());
 
      // Now we can build the constraint matrix and vector.
      // Note that resize also zeros for a DenseMatrix and DenseVector
      C.resize (old_size,
                cast_int<unsigned int>(elem_dofs.size()));
      H.resize (old_size);
 
      // Create the C constraint matrix.
      for (unsigned int i=0; i != old_size; i++)
        if (this->is_constrained_dof(elem_dofs[i]))
          {
            // If the DOF is constrained
            DofConstraints::const_iterator
              pos = _dof_constraints.find(elem_dofs[i]);
 
            libmesh_assert (pos != _dof_constraints.end());
 
            const DofConstraintRow & constraint_row = pos->second;
 
            // p refinement creates empty constraint rows
            //    libmesh_assert (!constraint_row.empty());
 
            for (const auto & item : constraint_row)
              for (unsigned int j=0,
                   n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
                   j != n_elem_dofs; j++)
                if (elem_dofs[j] == item.first)
                  C(i,j) = item.second;
 
            if (rhs_values)
              {
                if (const auto rhsit = rhs_values->find(elem_dofs[i]);
                    rhsit != rhs_values->end())
                  H(i) = rhsit->second;
              }
          }
        else
          {
            C(i,i) = 1.;
          }
 
      // May need to do this recursively.  It is possible
      // that we just replaced a constrained DOF with another
      // constrained DOF.
      DenseMatrix<Number> Cnew;
      DenseVector<Number> Hnew;
 
      this->build_constraint_matrix_and_vector (Cnew, Hnew, elem_dofs,
                                                qoi_index, true);
 
      if ((C.n() == Cnew.m()) &&          // If the constraint matrix
          (Cnew.n() == elem_dofs.size())) // is constrained...
        {
          // If x = Cy + h and y = Dz + g
          // Then x = (CD)z + (Cg + h)
          C.vector_mult_add(H, 1, Hnew);
 
          C.right_multiply(Cnew);
        }
 
      libmesh_assert_equal_to (C.n(), elem_dofs.size());
    }
}

References _adjoint_constraint_values, _dof_constraints, _primal_constraint_values, build_constraint_matrix_and_vector(), is_constrained_dof(), libMesh::libmesh_assert(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseVector< T >::resize(), libMesh::DenseMatrix< T >::resize(), libMesh::DenseMatrix< T >::right_multiply(), and libMesh::DenseMatrix< T >::vector_mult_add().

Referenced by build_constraint_matrix_and_vector(), heterogeneously_constrain_element_jacobian_and_residual(), and heterogeneously_constrain_element_residual().

build_sparsity()

std::unique_ptr< SparsityPattern::Build > libMesh::DofMap::build_sparsity	(	const MeshBase &	mesh,
		bool	calculate_constrained = false,
		bool	use_condensed_system = false
	)		const

Builds a sparsity pattern for matrices using the current degree-of-freedom numbering and coupling.

By default, ignores constraint equations, for build speed; this is valid for the combination of !need_full_sparsity_pattern and constraints which only come from periodic boundary conditions and adaptive mesh refinement, where matrix constraint adds some matrix entries but removes equally many (or more) other entries.

Can be told to calculate sparsity for the constrained matrix, which may be necessary in the case of spline control node constraints or sufficiently many user constraints.

Definition at line 63 of file dof_map.C.

{
  libmesh_assert (mesh.is_prepared());
 
  LOG_SCOPE("build_sparsity()", "DofMap");
 
  // Compute the sparsity structure of the global matrix.  This can be
  // fed into a PetscMatrixBase to allocate exactly the number of nonzeros
  // necessary to store the matrix.  This algorithm should be linear
  // in the (# of elements)*(# nodes per element)
 
  // We can be more efficient in the threaded sparsity pattern assembly
  // if we don't need the exact pattern.  For some sparse matrix formats
  // a good upper bound will suffice.
 
  // See if we need to include sparsity pattern entries for coupling
  // between neighbor dofs
  bool implicit_neighbor_dofs = this->use_coupled_neighbor_dofs(mesh);
 
  const StaticCondensationDofMap * sc = nullptr;
  if (use_condensed_system)
    {
      libmesh_assert(this->has_static_condensation());
      sc = _sc.get();
    }
 
  // We can compute the sparsity pattern in parallel on multiple
  // threads.  The goal is for each thread to compute the full sparsity
  // pattern for a subset of elements.  These sparsity patterns can
  // be efficiently merged in the SparsityPattern::Build::join()
  // method, especially if there is not too much overlap between them.
  // Even better, if the full sparsity pattern is not needed then
  // the number of nonzeros per row can be estimated from the
  // sparsity patterns created on each thread.
  auto sp = std::make_unique<SparsityPattern::Build>
    (*this,
     this->_dof_coupling,
     this->_coupling_functors,
     implicit_neighbor_dofs,
     need_full_sparsity_pattern,
     calculate_constrained,
     sc);
 
  Threads::parallel_reduce (ConstElemRange (mesh.active_local_elements_begin(),
                                            mesh.active_local_elements_end()), *sp);
 
  sp->parallel_sync();
 
  libmesh_assert_equal_to (sp->get_sparsity_pattern().size(), this->n_local_dofs());
 
  // Check to see if we have any extra stuff to add to the sparsity_pattern
  if (_extra_sparsity_function)
    {
      if (_augment_sparsity_pattern)
        {
          libmesh_here();
          libMesh::out << "WARNING:  You have specified both an extra sparsity function and object.\n"
                       << "          Are you sure this is what you meant to do??"
                       << std::endl;
        }
 
      sp->apply_extra_sparsity_function(_extra_sparsity_function,
                                        _extra_sparsity_context);
    }
 
  if (_augment_sparsity_pattern)
    sp->apply_extra_sparsity_object(*_augment_sparsity_pattern);
 
  return sp;
}

References _augment_sparsity_pattern, _coupling_functors, _dof_coupling, _extra_sparsity_context, _extra_sparsity_function, _sc, has_static_condensation(), libMesh::libmesh_assert(), mesh, need_full_sparsity_pattern, libMesh::out, libMesh::Threads::parallel_reduce(), and use_coupled_neighbor_dofs().

Referenced by process_mesh_constraint_rows(), libMesh::StaticCondensationDofMap::reinit(), and libMesh::System::solve_for_unconstrained_dofs().

calculate_constraining_subdomains()

std::map< const Node *, std::set< subdomain_id_type > > libMesh::DofMap::calculate_constraining_subdomains ( )

private

We may have mesh constraint rows with dependent nodes in one subdomain but dependency nodes in another subdomain, and we may have variables whose subdomain restriction includes the dependent subdomain but not the dependency.

In those cases we need to place degrees of freedom on dependency nodes anyway.

The set value for node n will include all subdomain ids of elements with nodes in subdomains constrained by n.

We use a map<set> rather than a multimap here because we expect to be inserting the same subdomain multiple times and we don't need duplicate values.

Definition at line 1256 of file dof_map.C.

{
  std::map<const Node *, std::set<subdomain_id_type>> constraining_subdomains;
  const auto & constraint_rows = _mesh.get_constraint_rows();
 
  // We can't just loop over constraint rows here because we need
  // element subdomain ids for the constrained nodes, but we don't
  // want an extra loop if there are no constraint rows.
  if (!constraint_rows.empty())
    for (auto & elem : _mesh.active_element_ptr_range())
      {
        const subdomain_id_type sbdid = elem->subdomain_id();
 
        for (const Node & node : elem->node_ref_range())
          {
            if (auto it = constraint_rows.find(&node);
                it != constraint_rows.end())
              {
                for (const auto & [pr, val] : it->second)
                  {
                    const Node * spline_node =
                      pr.first->node_ptr(pr.second);
 
                    constraining_subdomains[spline_node].insert(sbdid);
                  }
              }
          }
      }
 
  return constraining_subdomains;
}

check_dirichlet_bcid_consistency()

void libMesh::DofMap::check_dirichlet_bcid_consistency	(	const MeshBase &	mesh,
		const DirichletBoundary &	boundary
	)		const

Check that all the ids in dirichlet_bcids are actually present in the mesh.

If not, this will throw an error.

Definition at line 5518 of file dof_map_constraints.C.

{
  const std::set<boundary_id_type>& mesh_side_bcids =
    mesh.get_boundary_info().get_boundary_ids();
  const std::set<boundary_id_type>& mesh_edge_bcids =
    mesh.get_boundary_info().get_edge_boundary_ids();
  const std::set<boundary_id_type>& mesh_node_bcids =
    mesh.get_boundary_info().get_node_boundary_ids();
  const std::set<boundary_id_type>& dbc_bcids = boundary.b;
 
  // DirichletBoundary id sets should be consistent across all ranks
  libmesh_assert(mesh.comm().verify(dbc_bcids.size()));
 
  for (const auto & bc_id : dbc_bcids)
    {
      // DirichletBoundary id sets should be consistent across all ranks
      libmesh_assert(mesh.comm().verify(bc_id));
 
      bool found_bcid = (mesh_side_bcids.find(bc_id) != mesh_side_bcids.end() ||
                         mesh_edge_bcids.find(bc_id) != mesh_edge_bcids.end() ||
                         mesh_node_bcids.find(bc_id) != mesh_node_bcids.end());
 
      // On a distributed mesh, boundary id sets may *not* be
      // consistent across all ranks, since not all ranks see all
      // boundaries
      mesh.comm().max(found_bcid);
 
      libmesh_error_msg_if(!found_bcid,
                           "Could not find Dirichlet boundary id " << bc_id << " in mesh!");
    }
}

References libMesh::DirichletBoundary::b, libMesh::ParallelObject::comm(), libMesh::BoundaryInfo::get_boundary_ids(), libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::get_edge_boundary_ids(), libMesh::BoundaryInfo::get_node_boundary_ids(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), mesh, and libMesh::Parallel::Communicator::verify().

Referenced by create_dof_constraints().

check_for_constraint_loops()

void libMesh::DofMap::check_for_constraint_loops

(

)

Definition at line 4509 of file dof_map_constraints.C.

{
  // Create a set containing the DOFs we already depend on
  typedef std::set<dof_id_type> RCSet;
  RCSet unexpanded_set;
 
  // Use dof_constraints_copy in this method so that we don't
  // mess with _dof_constraints.
  DofConstraints dof_constraints_copy = _dof_constraints;
 
  for (const auto & i : dof_constraints_copy)
    unexpanded_set.insert(i.first);
 
  while (!unexpanded_set.empty())
    for (RCSet::iterator i = unexpanded_set.begin();
         i != unexpanded_set.end(); /* nothing */)
      {
        // If the DOF is constrained
        DofConstraints::iterator
          pos = dof_constraints_copy.find(*i);
 
        libmesh_assert (pos != dof_constraints_copy.end());
 
        DofConstraintRow & constraint_row = pos->second;
 
        // Comment out "rhs" parts of this method copied from process_constraints
        // DofConstraintValueMap::iterator rhsit =
        //   _primal_constraint_values.find(*i);
        // Number constraint_rhs = (rhsit == _primal_constraint_values.end()) ?
        //   0 : rhsit->second;
 
        std::vector<dof_id_type> constraints_to_expand;
 
        for (const auto & item : constraint_row)
          if (item.first != *i && this->is_constrained_dof(item.first))
            {
              unexpanded_set.insert(item.first);
              constraints_to_expand.push_back(item.first);
            }
 
        for (const auto & expandable : constraints_to_expand)
          {
            const Real this_coef = constraint_row[expandable];
 
            DofConstraints::const_iterator
              subpos = dof_constraints_copy.find(expandable);
 
            libmesh_assert (subpos != dof_constraints_copy.end());
 
            const DofConstraintRow & subconstraint_row = subpos->second;
 
            for (const auto & item : subconstraint_row)
              {
                libmesh_error_msg_if(item.first == expandable, "Constraint loop detected");
 
                constraint_row[item.first] += item.second * this_coef;
              }
 
            // Comment out "rhs" parts of this method copied from process_constraints
            // DofConstraintValueMap::const_iterator subrhsit =
            //   _primal_constraint_values.find(expandable);
            // if (subrhsit != _primal_constraint_values.end())
            //   constraint_rhs += subrhsit->second * this_coef;
 
            constraint_row.erase(expandable);
          }
 
        // Comment out "rhs" parts of this method copied from process_constraints
        // if (rhsit == _primal_constraint_values.end())
        //   {
        //     if (constraint_rhs != Number(0))
        //       _primal_constraint_values[*i] = constraint_rhs;
        //     else
        //       _primal_constraint_values.erase(*i);
        //   }
        // else
        //   {
        //     if (constraint_rhs != Number(0))
        //       rhsit->second = constraint_rhs;
        //     else
        //       _primal_constraint_values.erase(rhsit);
        //   }
 
        if (constraints_to_expand.empty())
          i = unexpanded_set.erase(i);
        else
          ++i;
      }
}

References _dof_constraints, libMesh::libmesh_assert(), and libMesh::Real.

Referenced by check_for_cyclic_constraints(), and process_constraints().

check_for_cyclic_constraints()

void libMesh::DofMap::check_for_cyclic_constraints

(

)

Throw an error if we detect any constraint loops, i.e.

A -> B -> C -> A that is, "dof A is constrained in terms of dof B which is constrained in terms of dof C which is constrained in terms of dof A", since these are not supported by libMesh and give erroneous results if they are present.

Note

The original "cyclic constraint" terminology was unfortunate since the word cyclic is used by some software to indicate an actual type of rotational/angular constraint and not (as here) a cyclic graph. The former nomenclature will eventually be deprecated in favor of "constraint loop".

Definition at line 4503 of file dof_map_constraints.C.

{
  // Eventually make this officially libmesh_deprecated();
  check_for_constraint_loops();
}

References check_for_constraint_loops().

clear()

void libMesh::DofMap::clear ( )

overridevirtual

Free all new memory associated with the object, but restore its original state, with the mesh pointer and any default ghosting.

Reimplemented from libMesh::DofMapBase.

Definition at line 871 of file dof_map.C.

{
  DofMapBase::clear();
 
  // we don't want to clear
  // the coupling matrix!
  // It should not change...
  //_dof_coupling->clear();
  //
  // But it would be inconsistent to leave our coupling settings
  // through a clear()...
  _dof_coupling = nullptr;
 
  // Reset ghosting functor statuses
  {
    for (const auto & gf : _coupling_functors)
      {
        libmesh_assert(gf);
        _mesh.remove_ghosting_functor(*gf);
      }
    this->_coupling_functors.clear();
 
    // Go back to default coupling
 
    _default_coupling->set_dof_coupling(this->_dof_coupling);
    _default_coupling->set_n_levels(this->use_coupled_neighbor_dofs(this->_mesh));
 
    this->add_coupling_functor(*_default_coupling);
  }
 
 
  {
    for (const auto & gf : _algebraic_ghosting_functors)
      {
        libmesh_assert(gf);
        _mesh.remove_ghosting_functor(*gf);
      }
    this->_algebraic_ghosting_functors.clear();
 
    // Go back to default send_list generation
 
    // _default_evaluating->set_dof_coupling(this->_dof_coupling);
    _default_evaluating->set_n_levels(1);
    this->add_algebraic_ghosting_functor(*_default_evaluating);
  }
 
  this->_shared_functors.clear();
 
  _variables.clear();
  _variable_groups.clear();
  _var_to_vg.clear();
  _variable_group_numbers.clear();
  _array_variables.clear();
  _first_scalar_df.clear();
  this->clear_send_list();
  this->clear_sparsity();
  need_full_sparsity_pattern = false;
 
#ifdef LIBMESH_ENABLE_AMR
 
  _dof_constraints.clear();
  _stashed_dof_constraints.clear();
  _primal_constraint_values.clear();
  _adjoint_constraint_values.clear();
  _n_old_dfs = 0;
  _first_old_df.clear();
  _end_old_df.clear();
  _first_old_scalar_df.clear();
 
#endif
 
  _matrices.clear();
  if (_sc)
    _sc->clear();
}

References libMesh::libmesh_assert().

Referenced by libMesh::DistributedMesh::clear(), libMesh::ReplicatedMesh::clear(), and ~DofMap().

clear_send_list()

void libMesh::DofMap::clear_send_list ( )

inline

Clears the _send_list vector.

This should be done in order to completely rebuild the send_list from scratch rather than merely adding to the existing send_list.

Definition at line 507 of file dof_map.h.

  {
    _send_list.clear();
  }

References _send_list.

clear_sparsity()

void libMesh::DofMap::clear_sparsity

(

)

Clears the sparsity pattern.

Definition at line 1981 of file dof_map.C.

{
  _sp.reset();
}

Referenced by libMesh::System::reinit(), and OverlappingCouplingGhostingTest::run_sparsity_pattern_test().

comm()

const Parallel::Communicator & libMesh::ParallelObject::comm ( ) const

inlineinherited

Returns

A reference to the Parallel::Communicator object used by this mesh.

Definition at line 97 of file parallel_object.h.

  { return _communicator; }

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBEIMEvaluation::add_interpolation_data(), libMesh::CondensedEigenSystem::add_matrices(), libMesh::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::System::add_matrix(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), allgather_recursive_constraints(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::AdvectionSystem::assemble_claw_rhs(), libMesh::FEMSystem::assemble_qoi(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Partitioner::assign_partitioning(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_data(), check_dirichlet_bcid_consistency(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::MeshBase::complete_preparation(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), computed_sparsity_already(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), PetscSolverConfiguration::configure_solver(), libMesh::ContinuationSystem::ContinuationSystem(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::CondensedEigenSystem::copy_super_to_sub(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), create_dof_constraints(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::PetscMatrix< T >::create_submatrix_nosort(), create_wrapped_function(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::MeshBase::detect_interior_parents(), libMesh::RBEIMEvaluation::distribute_bfs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::SmoothnessEstimator::estimate_smoothness(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::RBEIMEvaluation::gather_bfs(), gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::RBEIMEvaluation::get_eim_basis_function_node_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_side_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_value(), libMesh::MeshBase::get_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::RBEIMConstruction::get_max_abs_value(), libMesh::RBEIMConstruction::get_node_max_abs_value(), libMesh::RBEIMEvaluation::get_parametrized_function_node_value(), libMesh::RBEIMEvaluation::get_parametrized_function_side_value(), libMesh::RBEIMEvaluation::get_parametrized_function_value(), libMesh::RBEIMConstruction::get_random_point(), libMesh::RBEIMConstruction::get_random_point(), libMesh::RBEIMConstruction::get_random_point(), libMesh::MeshTetInterface::improve_hull_integrity(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::StaticCondensation::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::LocationMap< T >::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), ElasticitySystem::init_data(), libMesh::AdvectionSystem::init_data(), libMesh::ClawSystem::init_data(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::inner_product(), integrate_function(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_equal_points(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_linesearch_shellfunc(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::LinearImplicitSystem::LinearImplicitSystem(), main(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_bcids_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), n_constrained_dofs(), libMesh::MeshBase::n_constraint_rows(), n_dofs(), n_dofs_per_processor(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), MixedOrderTest::n_neighbor_links(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SparsityPattern::Build::n_nonzeros(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_distribute_bfs(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::RBEIMConstruction::node_inner_product(), libMesh::PetscVector< T >::operator=(), libMesh::MeshBase::operator==(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), LaplaceSystem::postprocess(), PoissonSystem::postprocess(), libMesh::MeshBase::print_constraint_rows(), print_dof_constraints(), process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), libMesh::XdrIO::read(), libMesh::Nemesis_IO::read(), FEMParameters::read(), libMesh::EquationSystems::read(), libMesh::CheckpointIO::read_header(), libMesh::ExodusII_IO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::read_header(), libMesh::RBEIMEvaluation::read_in_interior_basis_functions(), libMesh::RBEIMEvaluation::read_in_node_basis_functions(), libMesh::RBEIMEvaluation::read_in_side_basis_functions(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), MeshFunctionTest::read_variable_info_from_output_data(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::BoundaryInfo::remove_edge_id(), libMesh::BoundaryInfo::remove_node_id(), libMesh::BoundaryInfo::remove_shellface_id(), libMesh::BoundaryInfo::remove_side_id(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), scale_mesh_and_plot(), scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::RBEIMEvaluation::side_distribute_bfs(), libMesh::RBEIMEvaluation::side_gather_bfs(), libMesh::RBEIMConstruction::side_inner_product(), libMesh::Partitioner::single_partition(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::VariationalMeshSmoother::smooth(), libMesh::NoxNonlinearSolver< Number >::solve(), libMesh::ClawSystem::solve_conservation_law(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::MeshBase::sync_subdomain_name_map(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolygonTest::test_write_and_read_pentagon(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), CheckpointIOTest::testC0PolygonCheckpoint(), VolumeTest::testC0PolygonMethods(), CheckpointIOTest::testC0PolyhedronCheckpoint(), VolumeTest::testC0PolyhedronMethods(), ConstraintOperatorTest::testCoreform(), ConnectedComponentsTest::testEdge(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriEdge3ToTri7CenterFixup(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), SystemsTest::testProjectScalarCoarsening(), BoundaryInfoTest::testRenumber(), BoundaryInfoTest::testSelectiveRenumber(), BoundaryMeshSubdomainTest::testSingleSubdomain(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_assembly(), update_current_local_solution(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::XdrIO::write(), libMesh::NameBasedIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), libMesh::RBEvaluation::write_out_vectors(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

compute_dof_info()

std::size_t libMesh::DofMapBase::compute_dof_info ( dof_id_type  n_local_dofs )

protectedinherited

compute the key degree of freedom information given the local number of degrees of freedom on this process

Returns

The total number of DOFs for the System, summed across all procs.

Referenced by libMesh::StaticCondensationDofMap::reinit().

compute_sparsity()

void libMesh::DofMap::compute_sparsity

(

const MeshBase &

mesh

)

Computes the sparsity pattern for the matrices corresponding to proc_id and sends that data to Linear Algebra packages for preallocation of sparse matrices.

Definition at line 1960 of file dof_map.C.

{
  _sp = this->build_sparsity(mesh, this->_constrained_sparsity_construction);
 
  // It is possible that some \p SparseMatrix implementations want to
  // see the sparsity pattern before we throw it away.  If so, we
  // share a view of its arrays, and we pass it in to the matrices.
  for (const auto & mat : _matrices)
    {
      mat->attach_sparsity_pattern (*_sp);
      if (need_full_sparsity_pattern)
        mat->update_sparsity_pattern (_sp->get_sparsity_pattern());
    }
  // If we don't need the full sparsity pattern anymore, free the
  // parts of it we don't need.
  if (!need_full_sparsity_pattern)
    _sp->clear_full_sparsity();
}

References mesh.

Referenced by libMesh::System::init_matrices(), libMesh::System::reinit(), and OverlappingCouplingGhostingTest::run_sparsity_pattern_test().

computed_sparsity_already()

bool libMesh::DofMap::computed_sparsity_already

(

)

const

Returns true iff a sparsity pattern has already been computed.

Definition at line 258 of file dof_map.C.

{
  bool computed_sparsity_already = _sp &&
    (!_sp->get_n_nz().empty() ||
     !_sp->get_n_oz().empty());
  this->comm().max(computed_sparsity_already);
  return computed_sparsity_already;
}

References _sp, libMesh::ParallelObject::comm(), computed_sparsity_already(), and libMesh::Parallel::Communicator::max().

Referenced by computed_sparsity_already(), libMesh::System::solve_for_unconstrained_dofs(), and update_sparsity_pattern().

constrain_element_dyad_matrix()

void libMesh::DofMap::constrain_element_dyad_matrix ( DenseVector< Number > &  v, DenseVector< Number > &  w, std::vector< dof_id_type > &  row_dofs, bool  asymmetric_constraint_rows = true  ) const

inline

Constrains a dyadic element matrix B = v w'.

This method requires the element matrix to be square, in which case the elem_dofs correspond to the global DOF indices of both the rows and columns of the element matrix. For this case the rows and columns of the matrix necessarily correspond to variables of the same approximation order.

Definition at line 2511 of file dof_map.h.

                                                               {}

Referenced by assemble().

constrain_element_matrix() [1/2]

void libMesh::DofMap::constrain_element_matrix ( DenseMatrix< Number > &  matrix, std::vector< dof_id_type > &  elem_dofs, bool  asymmetric_constraint_rows = true  ) const

inline

Constrains the element matrix.

This method requires the element matrix to be square, in which case the elem_dofs correspond to the global DOF indices of both the rows and columns of the element matrix. For this case the rows and columns of the matrix necessarily correspond to variables of the same approximation order.

If asymmetric_constraint_rows is set to true (as it is by default), constraint row equations will be reinforced in a way which breaks matrix symmetry but makes inexact linear solver solutions more likely to satisfy hanging node constraints.

Definition at line 2485 of file dof_map.h.

                                                          {}

Referenced by libMesh::ClawSystem::assemble_advection_matrices(), assemble_mass(), libMesh::ClawSystem::assemble_mass_matrix(), assemble_matrices(), assemble_SchroedingerEquation(), LargeDeformationElasticity::jacobian(), and Biharmonic::JR::residual_and_jacobian().

constrain_element_matrix() [2/2]

void libMesh::DofMap::constrain_element_matrix ( DenseMatrix< Number > &  matrix, std::vector< dof_id_type > &  row_dofs, std::vector< dof_id_type > &  col_dofs, bool  asymmetric_constraint_rows = true  ) const

inline

Constrains the element matrix.

This method allows the element matrix to be non-square, in which case the row_dofs and col_dofs may be of different size and correspond to variables approximated in different spaces.

Definition at line 2489 of file dof_map.h.

                                                          {}

constrain_element_matrix_and_vector()

void libMesh::DofMap::constrain_element_matrix_and_vector ( DenseMatrix< Number > &  matrix, DenseVector< Number > &  rhs, std::vector< dof_id_type > &  elem_dofs, bool  asymmetric_constraint_rows = true  ) const

inline

Constrains the element matrix and vector.

This method requires the element matrix to be square, in which case the elem_dofs correspond to the global DOF indices of both the rows and columns of the element matrix. For this case the rows and columns of the matrix necessarily correspond to variables of the same approximation order.

Definition at line 2498 of file dof_map.h.

                                                                     {}

Referenced by libMesh::RBConstruction::add_scaled_matrix_and_vector(), LinearElasticity::assemble(), assemble(), assemble(), AssembleOptimization::assemble_A_and_F(), assemble_cd(), assemble_cd(), assemble_elasticity(), assemble_poisson(), assemble_shell(), assemble_stokes(), and LinearElasticityWithContact::residual_and_jacobian().

constrain_element_residual()

void libMesh::DofMap::constrain_element_residual	(	DenseVector< Number > &	rhs,
		std::vector< dof_id_type > &	elem_dofs,
		NumericVector< Number > &	solution_local
	)		const

Constrains the element residual.

The element Jacobian is square, and the elem_dofs should correspond to the global DOF indices of both the rows and columns of the element matrix, and the dof constraint should not include any heterogeneous terms.

The residual-constraining version of this method creates linear systems in which heterogeneously constrained degrees of freedom create non-zero residual terms when not at their correct offset values, as would be appropriate for finding a solution to a nonlinear problem in a quasi-Newton solve.

The solution vector passed in should be a serialized or ghosted primal solution

Definition at line 2762 of file dof_map_constraints.C.

{
  libmesh_assert_equal_to (elem_dofs.size(), rhs.size());
 
  libmesh_assert (solution_local.type() == SERIAL ||
                  solution_local.type() == GHOSTED);
 
  // check for easy return
  if (this->_dof_constraints.empty())
    return;
 
  // The constrained RHS is built up as C^T F
  DenseMatrix<Number> C;
 
  this->build_constraint_matrix (C, elem_dofs);
 
  LOG_SCOPE("cnstrn_elem_residual()", "DofMap");
 
  // It is possible that the matrix is not constrained at all.
  if (C.n() != elem_dofs.size())
    return;
 
  // Compute the matrix-vector product C^T F
  DenseVector<Number> old_rhs(rhs);
  C.vector_mult_transpose(rhs, old_rhs);
 
  for (unsigned int i=0,
       n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
       i != n_elem_dofs; i++)
    {
      const dof_id_type dof_id = elem_dofs[i];
 
      if (auto pos = _dof_constraints.find(dof_id);
          pos != _dof_constraints.end())
        {
          // This will put a nonsymmetric entry in the constraint
          // row to ensure that the linear system produces the
          // correct value for the constrained DOF.
          const DofConstraintRow & constraint_row = pos->second;
 
          Number & rhs_val = rhs(i);
          rhs_val = 0;
          for (const auto & [constraining_dof, coef] : constraint_row)
            rhs_val -= coef * solution_local(constraining_dof);
          rhs_val += solution_local(dof_id);
        }
    }
}

References _dof_constraints, build_constraint_matrix(), libMesh::GHOSTED, libMesh::libmesh_assert(), libMesh::DenseMatrixBase< T >::n(), libMesh::SERIAL, libMesh::DenseVector< T >::size(), libMesh::NumericVector< T >::type(), and libMesh::DenseMatrix< T >::vector_mult_transpose().

constrain_element_vector()

void libMesh::DofMap::constrain_element_vector ( DenseVector< Number > &  rhs, std::vector< dof_id_type > &  dofs, bool  asymmetric_constraint_rows = true  ) const

inline

Constrains the element vector.

Definition at line 2494 of file dof_map.h.

                                                          {}

Referenced by LargeDeformationElasticity::residual(), Biharmonic::JR::residual_and_jacobian(), and InfFERadialTest::testRefinement().

constrain_nothing()

void libMesh::DofMap::constrain_nothing ( std::vector< dof_id_type > &  dofs ) const

inline

Does not actually constrain anything, but modifies dofs in the same way as any of the constrain functions would do, i.e.

adds those dofs in terms of which any of the existing dofs is constrained.

Definition at line 2516 of file dof_map.h.

{}

constrain_p_dofs()

void libMesh::DofMap::constrain_p_dofs	(	unsigned int	var,
		const Elem *	elem,
		unsigned int	s,
		unsigned int	p
	)

Constrains degrees of freedom on side s of element elem which correspond to variable number var and to p refinement levels above p.

Definition at line 5377 of file dof_map_constraints.C.

{
  // We're constraining dofs on elem which correspond to p refinement
  // levels above p - this only makes sense if elem's p refinement
  // level is above p.
  libmesh_assert_greater (elem->p_level(), p);
  libmesh_assert_less (s, elem->n_sides());
 
  const unsigned int sys_num = this->sys_number();
  FEType fe_type = this->variable_type(var);
 
  const unsigned int n_nodes = elem->n_nodes();
  for (unsigned int n = 0; n != n_nodes; ++n)
    if (elem->is_node_on_side(n, s))
      {
        const Node & node = elem->node_ref(n);
        const unsigned int low_nc =
          FEInterface::n_dofs_at_node (fe_type, p, elem, n);
        const unsigned int high_nc =
          FEInterface::n_dofs_at_node (fe_type, elem, n);
 
        // since we may be running this method concurrently
        // on multiple threads we need to acquire a lock
        // before modifying the _dof_constraints object.
        Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
 
        if (elem->is_vertex(n))
          {
            // Add "this is zero" constraint rows for high p vertex
            // dofs
            for (unsigned int i = low_nc; i != high_nc; ++i)
              {
                _dof_constraints[node.dof_number(sys_num,var,i)].clear();
                _primal_constraint_values.erase(node.dof_number(sys_num,var,i));
              }
          }
        else
          {
            const unsigned int total_dofs = node.n_comp(sys_num, var);
            libmesh_assert_greater_equal (total_dofs, high_nc);
            // Add "this is zero" constraint rows for high p
            // non-vertex dofs, which are numbered in reverse
            for (unsigned int j = low_nc; j != high_nc; ++j)
              {
                const unsigned int i = total_dofs - j - 1;
                _dof_constraints[node.dof_number(sys_num,var,i)].clear();
                _primal_constraint_values.erase(node.dof_number(sys_num,var,i));
              }
          }
      }
}

References _dof_constraints, _primal_constraint_values, libMesh::DofObject::dof_number(), libMesh::Elem::is_node_on_side(), libMesh::Elem::is_vertex(), libMesh::DofObject::n_comp(), libMesh::FEInterface::n_dofs_at_node(), libMesh::Elem::n_nodes(), n_nodes, libMesh::Elem::n_sides(), libMesh::Elem::node_ref(), libMesh::Elem::p_level(), libMesh::Threads::spin_mtx, sys_number(), and variable_type().

Referenced by libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), and libMesh::FEGenericBase< OutputType >::compute_proj_constraints().

constrained_sparsity_construction()

bool libMesh::DofMap::constrained_sparsity_construction ( )

inline

Returns true iff the current policy when constructing sparsity patterns is to explicitly account for sparsity entries created by constraint matrix pre- and post- application.

Definition at line 2560 of file dof_map.h.

{
#ifdef LIBMESH_ENABLE_CONSTRAINTS
  return _constrained_sparsity_construction;
#else
  return true;
#endif
}

References _constrained_sparsity_construction.

constraint_rows_begin()

DofConstraints::const_iterator libMesh::DofMap::constraint_rows_begin ( ) const

inline

Returns

An iterator pointing to the first DoF constraint row.

Definition at line 1164 of file dof_map.h.

  { return _dof_constraints.begin(); }

References _dof_constraints.

constraint_rows_end()

DofConstraints::const_iterator libMesh::DofMap::constraint_rows_end ( ) const

inline

Returns

An iterator pointing just past the last DoF constraint row.

Definition at line 1170 of file dof_map.h.

  { return _dof_constraints.end(); }

References _dof_constraints.

coupling_functors_begin()

GhostingFunctorIterator libMesh::DofMap::coupling_functors_begin ( ) const

inline

Beginning of range of coupling functors.

Definition at line 366 of file dof_map.h.

  { return _coupling_functors.begin(); }

References _coupling_functors.

Referenced by libMesh::SparsityPattern::Build::operator()(), and scatter_constraints().

coupling_functors_end()

GhostingFunctorIterator libMesh::DofMap::coupling_functors_end ( ) const

inline

End of range of coupling functors.

Definition at line 372 of file dof_map.h.

  { return _coupling_functors.end(); }

References _coupling_functors.

Referenced by libMesh::SparsityPattern::Build::operator()(), and scatter_constraints().

create_dof_constraints()

void libMesh::DofMap::create_dof_constraints	(	const MeshBase &	mesh,
		Real	time = 0
	)

Rebuilds the raw degree of freedom and DofObject constraints, based on attached DirichletBoundary objects and on non-conforming interface in adapted meshes.

A time is specified for use in building time-dependent Dirichlet constraints.

Definition at line 1736 of file dof_map_constraints.C.

{
  parallel_object_only();
 
  LOG_SCOPE("create_dof_constraints()", "DofMap");
 
  libmesh_assert (mesh.is_prepared());
 
  // The user might have set boundary conditions after the mesh was
  // prepared; we should double-check that those boundary conditions
  // are still consistent.
#ifdef DEBUG
  MeshTools::libmesh_assert_valid_boundary_ids(mesh);
#endif
 
  // In a distributed mesh we might have constraint rows on some
  // processors but not all; if we have constraint rows on *any*
  // processor then we need to process them.
  bool constraint_rows_empty = mesh.get_constraint_rows().empty();
  this->comm().min(constraint_rows_empty);
 
  // We might get constraint equations from AMR hanging nodes in
  // 2D/3D, or from spline constraint rows or boundary conditions in
  // any dimension
  const bool possible_local_constraints = false
    || !mesh.n_elem()
    || !constraint_rows_empty
#ifdef LIBMESH_ENABLE_AMR
    || mesh.mesh_dimension() > 1
#endif
#ifdef LIBMESH_ENABLE_PERIODIC
    || !_periodic_boundaries->empty()
#endif
#ifdef LIBMESH_ENABLE_DIRICHLET
    || !_dirichlet_boundaries->empty()
#endif
    ;
 
  // Even if we don't have constraints, another processor might.
  bool possible_global_constraints = possible_local_constraints;
#if defined(LIBMESH_ENABLE_PERIODIC) || defined(LIBMESH_ENABLE_DIRICHLET) || defined(LIBMESH_ENABLE_AMR)
  libmesh_assert(this->comm().verify(mesh.is_serial()));
 
  this->comm().max(possible_global_constraints);
#endif
 
  // Recalculate dof constraints from scratch.  (Or just clear them,
  // if the user has just deleted their last dirichlet/periodic/user
  // constraint)
  // Note: any _stashed_dof_constraints are not cleared as it
  // may be the user's intention to restore them later.
#ifdef LIBMESH_ENABLE_CONSTRAINTS
  _dof_constraints.clear();
  _primal_constraint_values.clear();
  _adjoint_constraint_values.clear();
#endif
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  _node_constraints.clear();
#endif
 
  if (!possible_global_constraints)
    return;
 
  // Here we build the hanging node constraints.  This is done
  // by enforcing the condition u_a = u_b along hanging sides.
  // u_a = u_b is collocated at the nodes of side a, which gives
  // one row of the constraint matrix.
 
  // Processors only compute their local constraints
  ConstElemRange range (mesh.local_elements_begin(),
                        mesh.local_elements_end());
 
  // Global computation fails if we're using a FEMFunctionBase BC on a
  // ReplicatedMesh in parallel
  // ConstElemRange range (mesh.elements_begin(),
  //                       mesh.elements_end());
 
  // compute_periodic_constraints requires a point_locator() from our
  // Mesh, but point_locator() construction is parallel and threaded.
  // Rather than nest threads within threads we'll make sure it's
  // preconstructed.
#ifdef LIBMESH_ENABLE_PERIODIC
  bool need_point_locator = !_periodic_boundaries->empty() && !range.empty();
 
  this->comm().max(need_point_locator);
 
  if (need_point_locator)
    mesh.sub_point_locator();
#endif
 
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  Threads::parallel_for (range,
                         ComputeNodeConstraints (_node_constraints,
#ifdef LIBMESH_ENABLE_PERIODIC
                                                 *_periodic_boundaries,
#endif
                                                 mesh));
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
 
 
  // Look at all the variables in the system.  Reset the element
  // range at each iteration -- there is no need to reconstruct it.
  const auto n_vars = this->n_variables();
  for (unsigned int variable_number=0; variable_number<n_vars;
       ++variable_number, range.reset())
    Threads::parallel_for (range,
                           ComputeConstraints (_dof_constraints,
                                               *this,
#ifdef LIBMESH_ENABLE_PERIODIC
                                               *_periodic_boundaries,
#endif
                                               mesh,
                                               variable_number));
 
#ifdef LIBMESH_ENABLE_DIRICHLET
 
  if (!_dirichlet_boundaries->empty())
    {
      // Sanity check that the boundary ids associated with the
      // DirichletBoundary objects are actually present in the
      // mesh. We do this check by default, but in cases where you
      // intentionally add "inconsistent but valid" DirichletBoundary
      // objects in parallel, this check can deadlock since it does a
      // collective communication internally. In that case it is
      // possible to disable this check by setting the flag to false.
      if (_verify_dirichlet_bc_consistency)
        for (const auto & dirichlet : *_dirichlet_boundaries)
          this->check_dirichlet_bcid_consistency(mesh, *dirichlet);
 
      // Threaded loop over local over elems applying all Dirichlet BCs
      Threads::parallel_for
        (range,
         ConstrainDirichlet(*this, mesh, time, *_dirichlet_boundaries,
                            AddPrimalConstraint(*this)));
 
      // Threaded loop over local over elems per QOI applying all adjoint
      // Dirichlet BCs.  Note that the ConstElemRange is reset before each
      // execution of Threads::parallel_for().
 
      for (auto qoi_index : index_range(_adjoint_dirichlet_boundaries))
        {
          const DirichletBoundaries & adb_q =
            *(_adjoint_dirichlet_boundaries[qoi_index]);
 
          if (!adb_q.empty())
            Threads::parallel_for
              (range.reset(),
               ConstrainDirichlet(*this, mesh, time, adb_q,
                                  AddAdjointConstraint(*this, qoi_index)));
        }
    }
 
#endif // LIBMESH_ENABLE_DIRICHLET
 
  // Handle spline node constraints last, so we can try to move
  // existing constraints onto the spline basis if necessary.
  if (!constraint_rows_empty)
    this->process_mesh_constraint_rows(mesh);
}

References _adjoint_constraint_values, _adjoint_dirichlet_boundaries, _dirichlet_boundaries, _dof_constraints, _node_constraints, _periodic_boundaries, _primal_constraint_values, _verify_dirichlet_bc_consistency, check_dirichlet_bcid_consistency(), libMesh::ParallelObject::comm(), libMesh::StoredRange< iterator_type, object_type >::empty(), libMesh::MeshBase::get_constraint_rows(), libMesh::index_range(), libMesh::MeshBase::is_prepared(), libMesh::MeshBase::is_serial(), libMesh::libmesh_assert(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::Parallel::Communicator::max(), mesh, libMesh::MeshBase::mesh_dimension(), libMesh::Parallel::Communicator::min(), libMesh::MeshBase::n_elem(), n_variables(), n_vars(), libMesh::Threads::parallel_for(), process_mesh_constraint_rows(), libMesh::StoredRange< iterator_type, object_type >::reset(), libMesh::MeshBase::sub_point_locator(), and variable_number().

Referenced by libMesh::System::reinit_constraints().

create_static_condensation()

void libMesh::DofMap::create_static_condensation	(	MeshBase &	mesh,
		System &	system
	)

Add a static condensation class.

Definition at line 3135 of file dof_map.C.

{
  _sc = std::make_unique<StaticCondensationDofMap>(mesh, sys, *this);
}

References mesh.

default_algebraic_ghosting()

DefaultCoupling & libMesh::DofMap::default_algebraic_ghosting ( )

inline

Default algebraic ghosting functor.

Definition at line 440 of file dof_map.h.

{ return *_default_evaluating; }

References _default_evaluating.

Referenced by DefaultCouplingTest::testCoupling(), and PointNeighborCouplingTest::testCoupling().

default_coupling()

DefaultCoupling & libMesh::DofMap::default_coupling ( )

inline

Default coupling functor.

Definition at line 378 of file dof_map.h.

{ return *_default_coupling; }

References _default_coupling.

Referenced by PointNeighborCouplingTest::testCoupling().

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

distribute_dofs()

std::size_t libMesh::DofMap::distribute_dofs

(

MeshBase &

mesh

)

Distribute dofs on the current mesh.

Also builds the send list for processor proc_id, which defaults to 0 for ease of use in serial applications.

Returns

The total number of DOFs for the System, summed across all procs.

Definition at line 949 of file dof_map.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  // Log how long it takes to distribute the degrees of freedom
  LOG_SCOPE("distribute_dofs()", "DofMap");
 
  libmesh_assert (mesh.is_prepared());
 
  const processor_id_type proc_id = this->processor_id();
#ifndef NDEBUG
  const processor_id_type n_proc  = this->n_processors();
#endif
 
  //  libmesh_assert_greater (this->n_variables(), 0);
  libmesh_assert_less (proc_id, n_proc);
 
  // Data structure to ensure we can correctly combine
  // subdomain-restricted variables with constraining nodes from
  // different subdomains
  const std::map<const Node *, std::set<subdomain_id_type>>
    constraining_subdomains =
    this->calculate_constraining_subdomains();
 
  // re-init in case the mesh has changed
  this->reinit(mesh,
               constraining_subdomains);
 
  // By default distribute variables in a
  // var-major fashion, but allow run-time
  // specification
  bool node_major_dofs = libMesh::on_command_line ("--node-major-dofs");
 
  // The DOF counter, will be incremented as we encounter
  // new degrees of freedom
  dof_id_type next_free_dof = 0;
 
  // Clear the send list before we rebuild it
  this->clear_send_list();
 
  // Set temporary DOF indices on this processor
  if (node_major_dofs)
    this->distribute_local_dofs_node_major
      (next_free_dof, mesh, constraining_subdomains);
  else
    this->distribute_local_dofs_var_major
      (next_free_dof, mesh, constraining_subdomains);
 
  // Get DOF counts on all processors
  const auto n_dofs = this->compute_dof_info(next_free_dof);
 
  // Clear all the current DOF indices
  // (distribute_dofs expects them cleared!)
  this->invalidate_dofs(mesh);
 
  next_free_dof = _first_df[proc_id];
 
  // Set permanent DOF indices on this processor
  if (node_major_dofs)
    this->distribute_local_dofs_node_major
      (next_free_dof, mesh, constraining_subdomains);
  else
    this->distribute_local_dofs_var_major
      (next_free_dof, mesh, constraining_subdomains);
 
  libmesh_assert_equal_to (next_free_dof, _end_df[proc_id]);
 
  //------------------------------------------------------------
  // At this point, all n_comp and dof_number values on local
  // DofObjects should be correct, but a DistributedMesh might have
  // incorrect values on non-local DofObjects.  Let's request the
  // correct values from each other processor.
 
  if (this->n_processors() > 1)
    {
      this->set_nonlocal_dof_objects(mesh.nodes_begin(),
                                     mesh.nodes_end(),
                                     mesh, &DofMap::node_ptr);
 
      this->set_nonlocal_dof_objects(mesh.elements_begin(),
                                     mesh.elements_end(),
                                     mesh, &DofMap::elem_ptr);
    }
 
#ifdef DEBUG
  {
    const unsigned int
      sys_num = this->sys_number();
 
    // Processors should all agree on DoF ids for the newly numbered
    // system.
    MeshTools::libmesh_assert_valid_dof_ids(mesh, sys_num);
 
    // DoF processor ids should match DofObject processor ids
    for (auto & node : mesh.node_ptr_range())
      {
        DofObject const * const dofobj = node;
        const processor_id_type obj_proc_id = dofobj->processor_id();
 
        for (auto v : make_range(dofobj->n_vars(sys_num)))
          for (auto c : make_range(dofobj->n_comp(sys_num,v)))
            {
              const dof_id_type dofid = dofobj->dof_number(sys_num,v,c);
              libmesh_assert_greater_equal (dofid, this->first_dof(obj_proc_id));
              libmesh_assert_less (dofid, this->end_dof(obj_proc_id));
            }
      }
 
    for (auto & elem : mesh.element_ptr_range())
      {
        DofObject const * const dofobj = elem;
        const processor_id_type obj_proc_id = dofobj->processor_id();
 
        for (auto v : make_range(dofobj->n_vars(sys_num)))
          for (auto c : make_range(dofobj->n_comp(sys_num,v)))
            {
              const dof_id_type dofid = dofobj->dof_number(sys_num,v,c);
              libmesh_assert_greater_equal (dofid, this->first_dof(obj_proc_id));
              libmesh_assert_less (dofid, this->end_dof(obj_proc_id));
            }
      }
  }
#endif
 
  // start finding SCALAR degrees of freedom
#ifdef LIBMESH_ENABLE_AMR
  _first_old_scalar_df = _first_scalar_df;
#endif
  _first_scalar_df.clear();
  _first_scalar_df.resize(this->n_variables(), DofObject::invalid_id);
  dof_id_type current_SCALAR_dof_index = n_dofs - n_SCALAR_dofs();
 
  // Calculate and cache the initial DoF indices for SCALAR variables.
  // This is an O(N_vars) calculation so we want to do it once per
  // renumbering rather than once per SCALAR_dof_indices() call
 
  for (auto v : make_range(this->n_variables()))
    if (this->variable(v).type().family == SCALAR)
      {
        _first_scalar_df[v] = current_SCALAR_dof_index;
        current_SCALAR_dof_index += this->variable(v).type().order.get_order();
      }
 
  // Allow our GhostingFunctor objects to reinit if necessary
  for (const auto & gf : _algebraic_ghosting_functors)
    {
      libmesh_assert(gf);
      gf->dofmap_reinit();
    }
 
  for (const auto & gf : _coupling_functors)
    {
      libmesh_assert(gf);
      gf->dofmap_reinit();
    }
 
  // Note that in the add_neighbors_to_send_list nodes on processor
  // boundaries that are shared by multiple elements are added for
  // each element.
  this->add_neighbors_to_send_list(mesh);
 
  // Here we used to clean up that data structure; now System and
  // EquationSystems call that for us, after we've added constraint
  // dependencies to the send_list too.
  // this->sort_send_list ();
 
  return n_dofs;
}

References libMesh::DofObject::dof_number(), libMesh::libmesh_assert(), libMesh::make_range(), mesh, libMesh::DofObject::n_comp(), libMesh::DofObject::n_vars(), libMesh::on_command_line(), libMesh::DofObject::processor_id(), and libMesh::SCALAR.

Referenced by libMesh::EquationSystems::allgather(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::EquationSystems::reinit_solutions(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), and SystemsTest::testProjectMatrix3D().

distribute_local_dofs_node_major()

void libMesh::DofMap::distribute_local_dofs_node_major ( dof_id_type &  next_free_dof, MeshBase &  mesh, const std::map< const Node *, std::set< subdomain_id_type > > &  constraining_subdomains  )

private

Distributes the global degrees of freedom for dofs on this processor.

In this format all the degrees of freedom at a node/element are in contiguous blocks. Starts at index next_free_dof, and increments it to the post-final index. If build_send_list is true, builds the send list. If false, clears and reserves the send list.

Uses the provided constraining_subdomains map from calculate_constraining_subdomains() to ensure allocation of all DoFs on constraining nodes.

Note

The degrees of freedom for a given variable are not in contiguous blocks, as in the case of distribute_local_dofs_var_major.

Definition at line 1289 of file dof_map.C.

{
  const unsigned int sys_num       = this->sys_number();
  const unsigned int n_var_groups  = this->n_variable_groups();
 
  // This is the common case and we want to optimize for it
  const bool constraining_subdomains_empty =
    constraining_subdomains.empty();
 
  // Our numbering here must be kept consistent with the numbering
  // scheme assumed by DofMap::local_variable_indices!
 
  //-------------------------------------------------------------------------
  // First count and assign temporary numbers to local dofs
  for (auto & elem : mesh.active_local_element_ptr_range())
    {
      // Only number dofs connected to active
      // elements on this processor.
      const unsigned int n_nodes = elem->n_nodes();
 
      const subdomain_id_type sbdid = elem->subdomain_id();
 
      // First number the nodal DOFS
      for (unsigned int n=0; n<n_nodes; n++)
        {
          Node & node = elem->node_ref(n);
 
          for (unsigned vg=0; vg<n_var_groups; vg++)
            {
              const VariableGroup & vg_description(this->variable_group(vg));
 
              if (vg_description.type().family == SCALAR)
                continue;
 
              bool active_on_node =
                vg_description.active_on_subdomain(sbdid);
 
              // Are we at least active indirectly here?
              if (!active_on_node && !constraining_subdomains_empty)
                if (auto it = constraining_subdomains.find(&node);
                    it != constraining_subdomains.end())
                  for (auto s : it->second)
                    if (vg_description.active_on_subdomain(s))
                      {
                        active_on_node = true;
                        break;
                      }
 
              if (active_on_node)
                {
                  // assign dof numbers (all at once) if this is
                  // our node and if they aren't already there
                  if ((node.n_comp_group(sys_num,vg) > 0) &&
                      (node.processor_id() == this->processor_id()) &&
                      (node.vg_dof_base(sys_num,vg) ==
                       DofObject::invalid_id))
                    {
                      node.set_vg_dof_base(sys_num, vg,
                                           next_free_dof);
                      next_free_dof += (vg_description.n_variables()*
                                        node.n_comp_group(sys_num,vg));
                      //node.debug_buffer();
                    }
                }
            }
        }
 
      // Now number the element DOFS
      for (unsigned vg=0; vg<n_var_groups; vg++)
        {
          const VariableGroup & vg_description(this->variable_group(vg));
 
          if ((vg_description.type().family != SCALAR) &&
              (vg_description.active_on_subdomain(elem->subdomain_id())))
            if (elem->n_comp_group(sys_num,vg) > 0)
              {
                libmesh_assert_equal_to (elem->vg_dof_base(sys_num,vg),
                                         DofObject::invalid_id);
 
                elem->set_vg_dof_base(sys_num,
                                      vg,
                                      next_free_dof);
 
                next_free_dof += (vg_description.n_variables()*
                                  elem->n_comp_group(sys_num,vg));
              }
        }
    } // done looping over elements
 
 
  // we may have missed assigning DOFs to nodes that we own
  // but to which we have no connected elements matching our
  // variable restriction criterion.  this will happen, for example,
  // if variable V is restricted to subdomain S.  We may not own
  // any elements which live in S, but we may own nodes which are
  // *connected* to elements which do.  in this scenario these nodes
  // will presently have unnumbered DOFs. we need to take care of
  // them here since we own them and no other processor will touch them.
  for (auto & node : mesh.local_node_ptr_range())
    for (unsigned vg=0; vg<n_var_groups; vg++)
      {
        const VariableGroup & vg_description(this->variable_group(vg));
 
        if (node->n_comp_group(sys_num,vg))
          if (node->vg_dof_base(sys_num,vg) == DofObject::invalid_id)
            {
              node->set_vg_dof_base (sys_num,
                                     vg,
                                     next_free_dof);
 
              next_free_dof += (vg_description.n_variables()*
                                node->n_comp(sys_num,vg));
            }
      }
 
  this->distribute_scalar_dofs(next_free_dof);
 
#ifdef DEBUG
  this->assert_no_nodes_missed(mesh);
#endif // DEBUG
}

References libMesh::Variable::active_on_subdomain(), libMesh::FEType::family, mesh, libMesh::DofObject::n_comp_group(), n_nodes, libMesh::VariableGroup::n_variables(), libMesh::DofObject::processor_id(), libMesh::SCALAR, libMesh::DofObject::set_vg_dof_base(), libMesh::Variable::type(), and libMesh::DofObject::vg_dof_base().

distribute_local_dofs_var_major()

void libMesh::DofMap::distribute_local_dofs_var_major ( dof_id_type &  next_free_dof, MeshBase &  mesh, const std::map< const Node *, std::set< subdomain_id_type > > &  constraining_subdomains  )

private

Distributes the global degrees of freedom, for dofs on this processor.

In this format the local degrees of freedom are in a contiguous block for each variable in the system. Starts at index next_free_dof, and increments it to the post-final index.

Uses the provided constraining_subdomains map from calculate_constraining_subdomains() to ensure allocation of all DoFs on constraining nodes.

Definition at line 1417 of file dof_map.C.

{
  const unsigned int sys_num      = this->sys_number();
  const unsigned int n_var_groups = this->n_variable_groups();
 
  // This is the common case and we want to optimize for it
  const bool constraining_subdomains_empty =
    constraining_subdomains.empty();
 
  // Our numbering here must be kept consistent with the numbering
  // scheme assumed by DofMap::local_variable_indices!
 
  //-------------------------------------------------------------------------
  // First count and assign temporary numbers to local dofs
  for (unsigned vg=0; vg<n_var_groups; vg++)
    {
      const VariableGroup & vg_description(this->variable_group(vg));
 
      const unsigned int n_vars_in_group = vg_description.n_variables();
 
      // Skip the SCALAR dofs
      if (vg_description.type().family == SCALAR)
        continue;
 
      for (auto & elem : mesh.active_local_element_ptr_range())
        {
          // Only number dofs connected to active elements on this
          // processor and only for variables which are active on on
          // this element's subdomain or which are active on the
          // subdomain of a node constrained by this node.
          const bool active_on_elem =
            vg_description.active_on_subdomain(elem->subdomain_id());
 
          // If there's no way we're active on this element then we're
          // done
          if (!active_on_elem && constraining_subdomains_empty)
            continue;
 
          const unsigned int n_nodes = elem->n_nodes();
 
          // First number the nodal DOFS
          for (unsigned int n=0; n<n_nodes; n++)
            {
              Node & node = elem->node_ref(n);
 
              bool active_on_node = active_on_elem;
              if (!active_on_node)
                if (auto it = constraining_subdomains.find(&node);
                    it != constraining_subdomains.end())
                  for (auto s : it->second)
                    if (vg_description.active_on_subdomain(s))
                      {
                        active_on_node = true;
                        break;
                      }
 
              if (!active_on_node)
                continue;
 
              // assign dof numbers (all at once) if this is
              // our node and if they aren't already there
              if ((node.n_comp_group(sys_num,vg) > 0) &&
                  (node.processor_id() == this->processor_id()) &&
                  (node.vg_dof_base(sys_num,vg) ==
                   DofObject::invalid_id))
                {
                  node.set_vg_dof_base(sys_num, vg, next_free_dof);
 
                  next_free_dof += (n_vars_in_group*
                                    node.n_comp_group(sys_num,vg));
                }
            }
 
          // Now number the element DOFS
          if (elem->n_comp_group(sys_num,vg) > 0)
            {
              libmesh_assert_equal_to (elem->vg_dof_base(sys_num,vg),
                                       DofObject::invalid_id);
 
              elem->set_vg_dof_base(sys_num,
                                    vg,
                                    next_free_dof);
 
              next_free_dof += (n_vars_in_group*
                                elem->n_comp_group(sys_num,vg));
            }
        } // end loop on elements
 
      // we may have missed assigning DOFs to nodes that we own
      // but to which we have no connected elements matching our
      // variable restriction criterion.  this will happen, for example,
      // if variable V is restricted to subdomain S.  We may not own
      // any elements which live in S, but we may own nodes which are
      // *connected* to elements which do.  in this scenario these nodes
      // will presently have unnumbered DOFs. we need to take care of
      // them here since we own them and no other processor will touch them.
      for (auto & node : mesh.local_node_ptr_range())
        if (node->n_comp_group(sys_num,vg))
          if (node->vg_dof_base(sys_num,vg) == DofObject::invalid_id)
            {
              node->set_vg_dof_base (sys_num,
                                     vg,
                                     next_free_dof);
 
              next_free_dof += (n_vars_in_group*
                                node->n_comp_group(sys_num,vg));
            }
    } // end loop on variable groups
 
  this->distribute_scalar_dofs(next_free_dof);
 
#ifdef DEBUG
  this->assert_no_nodes_missed(mesh);
#endif
}

References libMesh::Variable::active_on_subdomain(), libMesh::FEType::family, mesh, libMesh::DofObject::n_comp_group(), n_nodes, libMesh::VariableGroup::n_variables(), libMesh::DofObject::processor_id(), libMesh::SCALAR, libMesh::DofObject::set_vg_dof_base(), libMesh::Variable::type(), and libMesh::DofObject::vg_dof_base().

distribute_scalar_dofs()

void libMesh::DofMap::distribute_scalar_dofs ( dof_id_type &  next_free_dof )

private

Definition at line 1539 of file dof_map.C.

{
  this->_n_SCALAR_dofs = 0;
  for (auto vg : make_range(this->n_variable_groups()))
    {
      const VariableGroup & vg_description(this->variable_group(vg));
 
      if (vg_description.type().family == SCALAR)
        {
          this->_n_SCALAR_dofs += (vg_description.n_variables()*
                                   vg_description.type().order.get_order());
          continue;
        }
    }
 
  // Only increment next_free_dof if we're on the processor
  // that holds this SCALAR variable
  if (this->processor_id() == (this->n_processors()-1))
    next_free_dof += _n_SCALAR_dofs;
}

References libMesh::FEType::family, libMesh::OrderWrapper::get_order(), libMesh::make_range(), libMesh::VariableGroup::n_variables(), libMesh::FEType::order, libMesh::SCALAR, and libMesh::Variable::type().

dof_indices() [1/6]

void libMesh::DofMap::dof_indices	(	const Elem &	elem,
		unsigned int	n,
		std::vector< dof_id_type > &	di,
		const unsigned int	vn
	)		const

Appends to the vector di the global degree of freedom indices for elem.node_ref(n), for one variable vn.

On hanging nodes with both vertex and non-vertex DoFs, only those indices which are directly supported on elem are included.

Definition at line 2466 of file dof_map.C.

{
  this->_node_dof_indices(elem, n, elem.node_ref(n), di, vn);
}

References libMesh::Elem::node_ref().

dof_indices() [2/6]

void libMesh::DofMap::dof_indices	(	const Elem *const	elem,
		std::vector< dof_id_type > &	di
	)		const

Definition at line 2201 of file dof_map.C.

{
  // We now allow elem==nullptr to request just SCALAR dofs
  // libmesh_assert(elem);
 
  // If we are asking for current indices on an element, it ought to
  // be an active element (or a temporary side, which also thinks it's
  // active)
  libmesh_assert(!elem || elem->active());
 
  // dof_indices() is a relatively light-weight function that is
  // called millions of times in normal codes. Therefore, it is not a
  // good candidate for logging, since the cost of the logging code
  // itself is roughly on par with the time required to call
  // dof_indices().
  // LOG_SCOPE("dof_indices()", "DofMap");
 
  // Clear the DOF indices vector
  di.clear();
 
  const unsigned int n_var_groups  = this->n_variable_groups();
 
#ifdef DEBUG
  // Check that sizes match in DEBUG mode
  std::size_t tot_size = 0;
#endif
 
  if (elem && elem->type() == TRI3SUBDIVISION)
    {
      // Subdivision surface FE require the 1-ring around elem
      const Tri3Subdivision * sd_elem = static_cast<const Tri3Subdivision *>(elem);
 
      // Ghost subdivision elements have no real dofs
      if (!sd_elem->is_ghost())
        {
          // Determine the nodes contributing to element elem
          std::vector<const Node *> elem_nodes;
          MeshTools::Subdivision::find_one_ring(sd_elem, elem_nodes);
 
          // Get the dof numbers
          for (unsigned int vg=0; vg<n_var_groups; vg++)
            {
              const VariableGroup & var = this->variable_group(vg);
              const unsigned int vars_in_group = var.n_variables();
 
              if (var.type().family == SCALAR &&
                  var.active_on_subdomain(elem->subdomain_id()))
                {
                  for (unsigned int vig=0; vig != vars_in_group; ++vig)
                    {
#ifdef DEBUG
                      tot_size += var.type().order;
#endif
                      std::vector<dof_id_type> di_new;
                      this->SCALAR_dof_indices(di_new,var.number(vig));
                      di.insert( di.end(), di_new.begin(), di_new.end());
                    }
                }
              else
                for (unsigned int vig=0; vig != vars_in_group; ++vig)
                  {
                    _dof_indices(*elem, elem->p_level(), di, vg, vig,
                                 elem_nodes.data(),
                                 cast_int<unsigned int>(elem_nodes.size()),
                                 var.number(vig)
#ifdef DEBUG
                                 , tot_size
#endif
                                 );
                  }
            }
        }
 
      return;
    }
 
  // Get the dof numbers for each variable
  const unsigned int n_nodes = elem ? elem->n_nodes() : 0;
  for (unsigned int vg=0; vg<n_var_groups; vg++)
    {
      const VariableGroup & var = this->variable_group(vg);
      const unsigned int vars_in_group = var.n_variables();
 
      if (var.type().family == SCALAR &&
          (!elem ||
           var.active_on_subdomain(elem->subdomain_id())))
        {
          for (unsigned int vig=0; vig != vars_in_group; ++vig)
            {
#ifdef DEBUG
              tot_size += var.type().order;
#endif
              std::vector<dof_id_type> di_new;
              this->SCALAR_dof_indices(di_new,var.number(vig));
              di.insert( di.end(), di_new.begin(), di_new.end());
            }
        }
      else if (elem)
        for (unsigned int vig=0; vig != vars_in_group; ++vig)
          {
            _dof_indices(*elem, elem->p_level(), di, vg, vig,
                         elem->get_nodes(), n_nodes, var.number(vig)
#ifdef DEBUG
                         , tot_size
#endif
                     );
          }
    }
 
#ifdef DEBUG
  libmesh_assert_equal_to (tot_size, di.size());
#endif
}

References libMesh::Elem::active(), libMesh::Variable::active_on_subdomain(), libMesh::FEType::family, libMesh::Elem::get_nodes(), libMesh::Tri3Subdivision::is_ghost(), libMesh::libmesh_assert(), libMesh::Elem::n_nodes(), n_nodes, libMesh::VariableGroup::n_variables(), libMesh::VariableGroup::number(), libMesh::FEType::order, libMesh::Elem::p_level(), libMesh::SCALAR, libMesh::Elem::subdomain_id(), libMesh::TRI3SUBDIVISION, libMesh::Variable::type(), and libMesh::Elem::type().

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::MeshFunction::_gradient_on_elem(), add_constraints_to_send_list(), libMesh::HPCoarsenTest::add_projection(), LinearElasticity::assemble(), assemble(), assemble(), AssembleOptimization::assemble_A_and_F(), libMesh::ClawSystem::assemble_advection_matrices(), libMesh::ClawSystem::assemble_avg_coupling_matrices(), libMesh::ClawSystem::assemble_boundary_condition_matrices(), assemble_cd(), assemble_cd(), assemble_elasticity(), libMesh::ClawSystem::assemble_jump_coupling_matrix(), assemble_mass(), libMesh::ClawSystem::assemble_mass_matrix(), assemble_matrices(), assemble_poisson(), assemble_SchroedingerEquation(), assemble_shell(), assemble_shell(), assemble_stokes(), assemble_wave(), Biharmonic::JR::bounds(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), compute_enriched_soln(), compute_jacobian(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), compute_residual(), LinearElasticity::compute_stresses(), LargeDeformationElasticity::compute_stresses(), LinearElasticityWithContact::compute_stresses(), compute_stresses(), libMesh::MeshFunction::discontinuous_value(), DMCreateDomainDecomposition_libMesh(), DMCreateFieldDecomposition_libMesh(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::DTKEvaluator::evaluate(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::MeshFunction::hessian(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), libMesh::SystemSubsetBySubdomain::init(), LargeDeformationElasticity::jacobian(), libMesh::HDGProblem::jacobian(), libMesh::System::local_dof_indices(), max_constraint_error(), LinearElasticityWithContact::move_mesh(), libMesh::DGFEMContext::neighbor_side_fe_reinit(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SmoothnessEstimator::EstimateSmoothness::operator()(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::BoundaryProjectSolution::operator()(), libMesh::MeshFunction::operator()(), libMesh::ErrorVector::plot_error(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::FEMContext::pre_fe_reinit(), process_mesh_constraint_rows(), libMesh::StaticCondensationDofMap::reinit(), LargeDeformationElasticity::residual(), libMesh::HDGProblem::residual(), LinearElasticityWithContact::residual_and_jacobian(), Biharmonic::JR::residual_and_jacobian(), scatter_constraints(), libMesh::HPCoarsenTest::select_refinement(), libMesh::PetscDMWrapper::set_point_range_in_section(), FETestBase< order, family, elem_type, build_nx, CaseName >::setUp(), SolidSystem::side_time_derivative(), libMesh::SparsityPattern::Build::sorted_connected_dofs(), ProjectSolutionTest::test_partial_project_solution(), MixedDimensionMeshTest::testDofOrdering(), MixedDimensionRefinedMeshTest::testDofOrdering(), MixedDimensionNonUniformRefinement::testDofOrdering(), MixedDimensionNonUniformRefinementTriangle::testDofOrdering(), MixedDimensionNonUniformRefinement3D::testDofOrdering(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), InfFERadialTest::testRefinement(), BoundaryInfoTest::testShellFaceConstraints(), libMesh::BoundaryVolumeSolutionTransfer::transfer_boundary_volume(), NonManifoldGhostingFunctorTest::verify_send_list_entries_helper(), libMesh::Nemesis_IO_Helper::write_nodal_solution(), libMesh::EnsightIO::write_scalar_ascii(), and libMesh::EnsightIO::write_vector_ascii().

dof_indices() [3/6]

void libMesh::DofMap::dof_indices ( const Elem *const  elem, std::vector< dof_id_type > &  di, const unsigned int  vn, int  p_level = -12345  ) const

overridevirtual

Fills the vector di with the global degree of freedom indices for the element.

For one variable, and potentially for a non-default element p refinement level

Implements libMesh::DofMapBase.

Definition at line 2317 of file dof_map.C.

{
  dof_indices(
      elem,
      di,
      vn,
      [](const Elem &,
         std::vector<dof_id_type> & dof_indices,
         const std::vector<dof_id_type> & scalar_dof_indices) {
        dof_indices.insert(dof_indices.end(), scalar_dof_indices.begin(), scalar_dof_indices.end());
      },
      [](const Elem &,
         unsigned int,
         unsigned int,
         std::vector<dof_id_type> & dof_indices,
         const dof_id_type dof) { dof_indices.push_back(dof); },
      p_level);
}

References int.

dof_indices() [4/6]

template<typename ScalarDofsFunctor , typename FieldDofsFunctor >

void libMesh::DofMap::dof_indices	(	const Elem *const	elem,
		std::vector< dof_id_type > &	di,
		const unsigned int	vn,
		ScalarDofsFunctor	scalar_dofs_functor,
		FieldDofsFunctor	field_dofs_functor,
		int	p_level = -12345
	)		const

Retrieves degree of freedom indices for a given elem and then performs actions for these indices defined by the user-provided functors scalar_dofs_functor and field_dofs_functor.

This API is useful when a user wants to do more than simply fill a degree of freedom container

Parameters

elem	The element to get degrees of freedom for
di	A container for degrees of freedom. It is up to the provided functors how this gets filled
vn	The variable number to retrieve degrees of freedom for
scalar_dofs_functor	The functor that acts on scalar degrees of freedom. This functor has the interface: void scalar_dofs_functor(const Elem & elem, std::vector<dof_id_type> & di, const std::vector<dof_id_type> & scalar_dof_indices) where di is the degree of freedom container described above and scalar_dof_indices are the scalar dof indices available to elem
field_dofs_functor	The functor that acts on "field" (e.g. non-scalar, non-global) degrees of freedom. This functor has the interface: void field_dofs_functor(const Elem & elem, const unsigned int node_num, const unsigned int var_num, std::vector<dof_id_type> & di, const dof_id_type field_dof) where field_dof represents a field degree of freedom to act on and is associated with node_num and var_num. If the degree of freedom is elemental than node_num will be invalid_uint. di is again the degree of freedom container provided above

Definition at line 2777 of file dof_map.h.

{
  // We now allow elem==nullptr to request just SCALAR dofs
  // libmesh_assert(elem);
 
  // dof_indices() is a relatively light-weight function that is
  // called millions of times in normal codes. Therefore, it is not a
  // good candidate for logging, since the cost of the logging code
  // itself is roughly on par with the time required to call
  // dof_indices().
  // LOG_SCOPE("dof_indices()", "DofMap");
 
  // Clear the DOF indices vector
  di.clear();
 
  // Use the default p refinement level?
  if (p_level == -12345)
    p_level = elem ? elem->p_level() : 0;
 
  const unsigned int vg = this->_variable_group_numbers[vn];
  const VariableGroup & var = this->variable_group(vg);
  const unsigned int vig = vn - var.number();
 
#ifdef DEBUG
  // Check that sizes match in DEBUG mode
  std::size_t tot_size = 0;
#endif
 
  if (elem && elem->type() == TRI3SUBDIVISION)
    {
      // Subdivision surface FE require the 1-ring around elem
      const Tri3Subdivision * sd_elem = static_cast<const Tri3Subdivision *>(elem);
 
      // Ghost subdivision elements have no real dofs
      if (!sd_elem->is_ghost())
        {
          // Determine the nodes contributing to element elem
          std::vector<const Node *> elem_nodes;
          MeshTools::Subdivision::find_one_ring(sd_elem, elem_nodes);
 
          _dof_indices(*elem, p_level, di, vg, vig, elem_nodes.data(),
                       cast_int<unsigned int>(elem_nodes.size()), vn,
#ifdef DEBUG
                       tot_size,
#endif
                       field_dofs_functor);
        }
 
      return;
    }
 
  // Get the dof numbers
  if (var.type().family == SCALAR &&
      (!elem ||
       var.active_on_subdomain(elem->subdomain_id())))
    {
#ifdef DEBUG
      tot_size += var.type().order;
#endif
      std::vector<dof_id_type> di_new;
      this->SCALAR_dof_indices(di_new,vn);
      scalar_dofs_functor(*elem, di, di_new);
    }
  else if (elem)
    _dof_indices(*elem, p_level, di, vg, vig, elem->get_nodes(),
                 elem->n_nodes(), vn,
#ifdef DEBUG
                 tot_size,
#endif
                 field_dofs_functor);
 
#ifdef DEBUG
  libmesh_assert_equal_to (tot_size, di.size());
#endif
}

References _dof_indices(), _variable_group_numbers, libMesh::Variable::active_on_subdomain(), libMesh::FEType::family, libMesh::MeshTools::Subdivision::find_one_ring(), libMesh::Elem::get_nodes(), libMesh::Tri3Subdivision::is_ghost(), libMesh::Elem::n_nodes(), libMesh::VariableGroup::number(), libMesh::FEType::order, libMesh::Elem::p_level(), libMesh::SCALAR, SCALAR_dof_indices(), libMesh::Elem::subdomain_id(), libMesh::TRI3SUBDIVISION, libMesh::Variable::type(), libMesh::Elem::type(), and variable_group().

dof_indices() [5/6]

void libMesh::DofMap::dof_indices	(	const Node *const	node,
		std::vector< dof_id_type > &	di
	)		const

Fills the vector di with the global degree of freedom indices for the node.

Definition at line 2362 of file dof_map.C.

{
  // We allow node==nullptr to request just SCALAR dofs
  // libmesh_assert(elem);
 
  // dof_indices() is a relatively light-weight function that is
  // called millions of times in normal codes. Therefore, it is not a
  // good candidate for logging, since the cost of the logging code
  // itself is roughly on par with the time required to call
  // dof_indices().
  // LOG_SCOPE("dof_indices(Node)", "DofMap");
 
  // Clear the DOF indices vector
  di.clear();
 
  const unsigned int n_var_groups  = this->n_variable_groups();
  const unsigned int sys_num = this->sys_number();
 
  // Get the dof numbers
  for (unsigned int vg=0; vg<n_var_groups; vg++)
    {
      const VariableGroup & var = this->variable_group(vg);
      const unsigned int vars_in_group = var.n_variables();
 
      if (var.type().family == SCALAR)
        {
          for (unsigned int vig=0; vig != vars_in_group; ++vig)
            {
              std::vector<dof_id_type> di_new;
              this->SCALAR_dof_indices(di_new,var.number(vig));
              di.insert( di.end(), di_new.begin(), di_new.end());
            }
        }
      else
        {
          const int n_comp = node->n_comp_group(sys_num,vg);
          for (unsigned int vig=0; vig != vars_in_group; ++vig)
            {
              for (int i=0; i != n_comp; ++i)
                {
                  const dof_id_type d =
                    node->dof_number(sys_num, vg, vig, i, n_comp);
                  libmesh_assert_not_equal_to
                    (d, DofObject::invalid_id);
                  di.push_back(d);
                }
            }
        }
    }
}

References libMesh::DofObject::dof_number(), libMesh::FEType::family, libMesh::DofObject::n_comp_group(), libMesh::VariableGroup::n_variables(), libMesh::VariableGroup::number(), libMesh::SCALAR, and libMesh::Variable::type().

dof_indices() [6/6]

void libMesh::DofMap::dof_indices ( const Node *const  node, std::vector< dof_id_type > &  di, const unsigned int  vn  ) const

overridevirtual

Fills the vector di with the global degree of freedom indices for the node, for one variable vn.

Implements libMesh::DofMapBase.

Definition at line 2415 of file dof_map.C.

{
  if (vn == libMesh::invalid_uint)
    {
      this->dof_indices(node, di);
      return;
    }
 
  // We allow node==nullptr to request just SCALAR dofs
  // libmesh_assert(elem);
 
  // dof_indices() is a relatively light-weight function that is
  // called millions of times in normal codes. Therefore, it is not a
  // good candidate for logging, since the cost of the logging code
  // itself is roughly on par with the time required to call
  // dof_indices().
  // LOG_SCOPE("dof_indices(Node)", "DofMap");
 
  // Clear the DOF indices vector
  di.clear();
 
  const unsigned int sys_num = this->sys_number();
 
  // Get the dof numbers
  const unsigned int vg = this->_variable_group_numbers[vn];
  const VariableGroup & var = this->variable_group(vg);
 
  if (var.type().family == SCALAR)
    {
      std::vector<dof_id_type> di_new;
      this->SCALAR_dof_indices(di_new,vn);
      di.insert( di.end(), di_new.begin(), di_new.end());
    }
  else
    {
      const unsigned int vig = vn - var.number();
      const int n_comp = node->n_comp_group(sys_num,vg);
      for (int i=0; i != n_comp; ++i)
        {
          const dof_id_type d =
            node->dof_number(sys_num, vg, vig, i, n_comp);
          libmesh_assert_not_equal_to
            (d, DofObject::invalid_id);
          di.push_back(d);
        }
    }
}

References libMesh::DofObject::dof_number(), libMesh::FEType::family, libMesh::invalid_uint, libMesh::DofObject::n_comp_group(), libMesh::VariableGroup::number(), libMesh::SCALAR, and libMesh::Variable::type().

dof_owner()

processor_id_type libMesh::DofMap::dof_owner ( const dof_id_type  dof ) const

inline

Returns

The processor id that owns the dof index dof

Definition at line 815 of file dof_map.h.

  { std::vector<dof_id_type>::const_iterator ub =
      std::upper_bound(_end_df.begin(), _end_df.end(), dof);
    libmesh_assert (ub != _end_df.end());
    return cast_int<processor_id_type>(ub - _end_df.begin());
  }

References libMesh::DofMapBase::_end_df, and libMesh::libmesh_assert().

Referenced by libMesh::StaticCondensationDofMap::add_uncondensed_dof(), libMesh::PetscDMWrapper::build_sf(), and DofMapTest::testDofOwner().

elem_ptr()

DofObject * libMesh::DofMap::elem_ptr ( MeshBase &  mesh, dof_id_type  i  ) const

private

Returns

The Elem pointer with index i from the mesh.

Definition at line 310 of file dof_map.C.

{
  return mesh.elem_ptr(i);
}

References mesh.

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

Methods to enable/disable the reference counter output from print_info().

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

end_dof() [1/2]

dof_id_type libMesh::DofMapBase::end_dof ( ) const

inlineinherited

Definition at line 83 of file dof_map_base.h.

{ return this->end_dof(this->processor_id()); }

References libMesh::DofMapBase::end_dof(), and libMesh::ParallelObject::processor_id().

Referenced by libMesh::DofMapBase::end_dof(), local_index(), n_local_constrained_dofs(), and process_mesh_constraint_rows().

end_dof() [2/2]

dof_id_type libMesh::DofMapBase::end_dof ( const processor_id_type  proc ) const

inlineinherited

Returns

The first dof index that is after all indices local to processor proc.

Analogous to the end() member function of STL containers.

Definition at line 191 of file dof_map_base.h.

{
  libmesh_assert_less(proc, _end_df.size());
  return _end_df[proc];
}

References libMesh::DofMapBase::_end_df.

Referenced by DMCreateDomainDecomposition_libMesh(), DMCreateFieldDecomposition_libMesh(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::SystemSubsetBySubdomain::init(), libMesh::CondensedEigenSystem::initialize_condensed_dofs(), libMesh::SparsityPattern::Build::join(), libMesh::System::local_dof_indices(), AssembleOptimization::lower_and_upper_bounds(), main(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::StaticCondensation::row_stop(), libMesh::System::solve_for_unconstrained_dofs(), DofMapTest::testDofOwner(), NonManifoldGhostingFunctorTest::verify_send_list_entries_helper(), and libMesh::RBConstruction::zero_constrained_dofs_on_vector().

end_old_dof() [1/2]

dof_id_type libMesh::DofMapBase::end_old_dof ( ) const

inlineinherited

Definition at line 140 of file dof_map_base.h.

{ return this->end_old_dof(this->processor_id()); }

References libMesh::DofMapBase::end_old_dof(), and libMesh::ParallelObject::processor_id().

Referenced by libMesh::DofMapBase::end_old_dof().

end_old_dof() [2/2]

dof_id_type libMesh::DofMapBase::end_old_dof ( const processor_id_type  proc ) const

inlineinherited

Returns

The first old dof index that is after all indices local to processor proc.

Analogous to the end() member function of STL containers.

Definition at line 210 of file dof_map_base.h.

{
  libmesh_assert_less(proc, _end_old_df.size());
  return _end_old_df[proc];
}

References libMesh::DofMapBase::_end_old_df.

Referenced by libMesh::PetscDMWrapper::init_petscdm(), libMesh::BuildProjectionList::operator()(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), and SystemsTest::testProjectMatrix3D().

enforce_adjoint_constraints_exactly()

void libMesh::DofMap::enforce_adjoint_constraints_exactly ( NumericVector< Number > &  v, unsigned int  q  ) const

inline

Heterogeneously constrains the numeric vector v, which represents an adjoint solution defined on the mesh for quantity fo interest q.

For homogeneous constraints, use enforce_constraints_exactly instead

Definition at line 2522 of file dof_map.h.

                                                                             {}

Referenced by libMesh::ImplicitSystem::adjoint_solve(), and libMesh::AdjointRefinementEstimator::estimate_error().

enforce_constraints_exactly()

void libMesh::DofMap::enforce_constraints_exactly ( const System &  system, NumericVector< Number > *  v = nullptr, bool  homogeneous = false  ) const

inline

Constrains the numeric vector v, which represents a solution defined on the mesh.

This may need to be used after a linear solve, if your linear solver's solutions do not satisfy your DoF constraints to a tight enough tolerance.

If v == nullptr, the system solution vector is constrained

If homogeneous == true, heterogeneous constraints are enforced as if they were homogeneous. This might be appropriate for e.g. a vector representing a difference between two heterogeneously-constrained solutions.

Definition at line 2518 of file dof_map.h.

                                                             {}

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), DMlibMeshFunction(), DMlibMeshJacobian(), libMesh::CondensedEigenSystem::get_eigenpair(), main(), libMesh::ImplicitSystem::sensitivity_solve(), libMesh::NewtonSolver::solve(), libMesh::PetscDiffSolver::solve(), libMesh::RBConstruction::solve_for_matrix_and_rhs(), libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve(), and libMesh::ImplicitSystem::weighted_sensitivity_solve().

enforce_constraints_on_jacobian()

void libMesh::DofMap::enforce_constraints_on_jacobian ( const NonlinearImplicitSystem &  system, SparseMatrix< Number > *  jac  ) const

inline

Definition at line 2532 of file dof_map.h.

                                 {}

enforce_constraints_on_residual()

void libMesh::DofMap::enforce_constraints_on_residual ( const NonlinearImplicitSystem &  system, NumericVector< Number > *  rhs, NumericVector< Number > const *  solution, bool  homogeneous = true  ) const

inline

Definition at line 2526 of file dof_map.h.

               {}

Referenced by libMesh::PetscNonlinearSolver< Number >::force_new_preconditioner().

extract_local_vector()

void libMesh::DofMap::extract_local_vector	(	const NumericVector< Number > &	Ug,
		const std::vector< dof_id_type > &	dof_indices,
		DenseVectorBase< Number > &	Ue
	)		const

Builds the local element vector Ue from the global vector Ug, accounting for any constrained degrees of freedom.

For an element without constrained degrees of freedom this is the trivial mapping \( Ue[i] = Ug[dof_indices[i]] \)

Note

The user must ensure that the element vector Ue is properly sized when calling this method. This is because there is no resize() method in the DenseVectorBase<> class.

Definition at line 2119 of file dof_map.C.

{
  const unsigned int n_original_dofs = dof_indices_in.size();
 
#ifdef LIBMESH_ENABLE_AMR
 
  // Trivial mapping
  libmesh_assert_equal_to (dof_indices_in.size(), Ue.size());
  bool has_constrained_dofs = false;
 
  for (unsigned int il=0; il != n_original_dofs; ++il)
    {
      const dof_id_type ig = dof_indices_in[il];
 
      if (this->is_constrained_dof (ig)) has_constrained_dofs = true;
 
      libmesh_assert_less (ig, Ug.size());
 
      Ue.el(il) = Ug(ig);
    }
 
  // If the element has any constrained DOFs then we need
  // to account for them in the mapping.  This will handle
  // the case that the input vector is not constrained.
  if (has_constrained_dofs)
    {
      // Copy the input DOF indices.
      std::vector<dof_id_type> constrained_dof_indices(dof_indices_in);
 
      DenseMatrix<Number> C;
      DenseVector<Number> H;
 
      this->build_constraint_matrix_and_vector (C, H, constrained_dof_indices);
 
      libmesh_assert_equal_to (dof_indices_in.size(), C.m());
      libmesh_assert_equal_to (constrained_dof_indices.size(), C.n());
 
      // zero-out Ue
      Ue.zero();
 
      // compute Ue = C Ug, with proper mapping.
      for (unsigned int i=0; i != n_original_dofs; i++)
        {
          Ue.el(i) = H(i);
 
          const unsigned int n_constrained =
            cast_int<unsigned int>(constrained_dof_indices.size());
          for (unsigned int j=0; j<n_constrained; j++)
            {
              const dof_id_type jg = constrained_dof_indices[j];
 
              //          If Ug is a serial or ghosted vector, then this assert is
              //          overzealous.  If Ug is a parallel vector, then this assert
              //          is redundant.
              //    libmesh_assert ((jg >= Ug.first_local_index()) &&
              //    (jg <  Ug.last_local_index()));
 
              Ue.el(i) += C(i,j)*Ug(jg);
            }
        }
    }
 
#else
 
  // Trivial mapping
 
  libmesh_assert_equal_to (n_original_dofs, Ue.size());
 
  for (unsigned int il=0; il<n_original_dofs; il++)
    {
      const dof_id_type ig = dof_indices_in[il];
 
      libmesh_assert ((ig >= Ug.first_local_index()) && (ig <  Ug.last_local_index()));
 
      Ue.el(il) = Ug(ig);
    }
 
#endif
}

References libMesh::DenseVectorBase< T >::el(), libMesh::NumericVector< T >::first_local_index(), libMesh::NumericVector< T >::last_local_index(), libMesh::libmesh_assert(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseVectorBase< T >::size(), libMesh::NumericVector< T >::size(), and libMesh::DenseVectorBase< T >::zero().

find_connected_dof_objects()

void libMesh::DofMap::find_connected_dof_objects ( std::vector< const DofObject * > &  objs ) const

private

Finds all the DofObjects associated with the set in objs.

This will account for off-element couplings via hanging nodes.

find_connected_dofs()

void libMesh::DofMap::find_connected_dofs ( std::vector< dof_id_type > &  elem_dofs ) const

private

Finds all the DOFS associated with the element DOFs elem_dofs.

This will account for off-element couplings via hanging nodes.

Definition at line 2915 of file dof_map.C.

{
  typedef std::set<dof_id_type> RCSet;
 
  // First insert the DOFS we already depend on into the set.
  RCSet dof_set (elem_dofs.begin(), elem_dofs.end());
 
  bool done = true;
 
  // Next insert any dofs those might be constrained in terms
  // of.  Note that in this case we may not be done:  Those may
  // in turn depend on others.  So, we need to repeat this process
  // in that case until the system depends only on unconstrained
  // degrees of freedom.
  for (const auto & dof : elem_dofs)
    if (this->is_constrained_dof(dof))
      {
        // If the DOF is constrained
        DofConstraints::const_iterator
          pos = _dof_constraints.find(dof);
 
        libmesh_assert (pos != _dof_constraints.end());
 
        const DofConstraintRow & constraint_row = pos->second;
 
        // adaptive p refinement currently gives us lots of empty constraint
        // rows - we should optimize those DoFs away in the future.  [RHS]
        //libmesh_assert (!constraint_row.empty());
 
        // Add the DOFs this dof is constrained in terms of.
        // note that these dofs might also be constrained, so
        // we will need to call this function recursively.
        for (const auto & pr : constraint_row)
          if (!dof_set.count (pr.first))
            {
              dof_set.insert (pr.first);
              done = false;
            }
      }
 
 
  // If not done then we need to do more work
  // (obviously :-) )!
  if (!done)
    {
      // Fill the vector with the contents of the set
      elem_dofs.clear();
      elem_dofs.insert (elem_dofs.end(),
                        dof_set.begin(), dof_set.end());
 
 
      // May need to do this recursively.  It is possible
      // that we just replaced a constrained DOF with another
      // constrained DOF.
      this->find_connected_dofs (elem_dofs);
 
    } // end if (!done)
}

References libMesh::libmesh_assert().

Referenced by libMesh::SparsityPattern::Build::sorted_connected_dofs().

first_dof() [1/2]

dof_id_type libMesh::DofMapBase::first_dof ( ) const

inlineinherited

Definition at line 73 of file dof_map_base.h.

{ return this->first_dof(this->processor_id()); }

References libMesh::DofMapBase::first_dof(), and libMesh::ParallelObject::processor_id().

Referenced by libMesh::DofMapBase::first_dof(), local_index(), n_local_constrained_dofs(), and process_mesh_constraint_rows().

first_dof() [2/2]

dof_id_type libMesh::DofMapBase::first_dof ( const processor_id_type  proc ) const

inlineinherited

Returns

The first dof index that is local to partition proc.

Definition at line 185 of file dof_map_base.h.

{
  libmesh_assert_less(proc, _first_df.size());
  return _first_df[proc];
}

References libMesh::DofMapBase::_first_df.

Referenced by libMesh::PetscDMWrapper::build_sf(), DMCreateDomainDecomposition_libMesh(), DMCreateFieldDecomposition_libMesh(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::SystemSubsetBySubdomain::init(), libMesh::CondensedEigenSystem::initialize_condensed_dofs(), libMesh::System::local_dof_indices(), AssembleOptimization::lower_and_upper_bounds(), main(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::StaticCondensationDofMap::reinit(), libMesh::StaticCondensation::row_start(), libMesh::PetscPreconditioner< T >::set_hypre_ads_data(), libMesh::PetscPreconditioner< T >::set_hypre_ams_data(), libMesh::System::solve_for_unconstrained_dofs(), DofMapTest::testDofOwner(), NonManifoldGhostingFunctorTest::verify_send_list_entries_helper(), and libMesh::RBConstruction::zero_constrained_dofs_on_vector().

first_old_dof() [1/2]

dof_id_type libMesh::DofMapBase::first_old_dof ( ) const

inlineinherited

Definition at line 130 of file dof_map_base.h.

{ return this->first_old_dof(this->processor_id()); }

References libMesh::DofMapBase::first_old_dof(), and libMesh::ParallelObject::processor_id().

Referenced by libMesh::DofMapBase::first_old_dof().

first_old_dof() [2/2]

dof_id_type libMesh::DofMapBase::first_old_dof ( const processor_id_type  proc ) const

inlineinherited

Returns

The first old dof index that is local to partition proc.

Definition at line 204 of file dof_map_base.h.

{
  libmesh_assert_less(proc, _first_old_df.size());
  return _first_old_df[proc];
}

References libMesh::DofMapBase::_first_old_df.

Referenced by libMesh::PetscDMWrapper::init_petscdm(), libMesh::BuildProjectionList::operator()(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), and SystemsTest::testProjectMatrix3D().

full_sparsity_pattern_needed()

void libMesh::DofMap::full_sparsity_pattern_needed ( )

inline

Sets need_full_sparsity_pattern to true regardless of the requirements by matrices.

Definition at line 2554 of file dof_map.h.

{
  need_full_sparsity_pattern = true;
}

References need_full_sparsity_pattern.

gather_constraints()

void libMesh::DofMap::gather_constraints	(	MeshBase &	mesh,
		std::set< dof_id_type > &	unexpanded_dofs,
		bool	look_for_constrainees
	)

Helper function for querying about constraint equations on other processors.

If any id in requested_dof_ids is constrained on another processor, its constraint will be added on this processor as well. If look_for_constrainees is true, then constraints will also be returned if the id appears as a constraining value not just if it appears as a constrained value.

This function operates recursively: if the constraint for a constrained dof is newly added locally, then any other dofs which constrain it are queried to see if they are in turn constrained, and so on.

Definition at line 5019 of file dof_map_constraints.C.

{
  typedef std::set<dof_id_type> DoF_RCSet;
 
  // If we have heterogeneous adjoint constraints we need to
  // communicate those too.
  const unsigned int max_qoi_num =
    _adjoint_constraint_values.empty() ?
    0 : _adjoint_constraint_values.rbegin()->first+1;
 
  // We have to keep recursing while the unexpanded set is
  // nonempty on *any* processor
  bool unexpanded_set_nonempty = !unexpanded_dofs.empty();
  this->comm().max(unexpanded_set_nonempty);
 
  while (unexpanded_set_nonempty)
    {
      // Let's make sure we don't lose sync in this loop.
      parallel_object_only();
 
      // Request sets
      DoF_RCSet   dof_request_set;
 
      // Request sets to send to each processor
      std::map<processor_id_type, std::vector<dof_id_type>>
        requested_dof_ids;
 
      // And the sizes of each
      std::map<processor_id_type, dof_id_type>
        dof_ids_on_proc;
 
      // Fill (and thereby sort and uniq!) the main request sets
      for (const auto & unexpanded_dof : unexpanded_dofs)
        {
          // If we were asked for a DoF and we don't already have a
          // constraint for it, then we need to check for one.
          if (auto pos = _dof_constraints.find(unexpanded_dof);
              pos == _dof_constraints.end())
            {
              if (!this->local_index(unexpanded_dof) &&
                  !_dof_constraints.count(unexpanded_dof) )
                dof_request_set.insert(unexpanded_dof);
            }
          // If we were asked for a DoF and we already have a
          // constraint for it, then we need to check if the
          // constraint is recursive.
          else
            {
              const DofConstraintRow & row = pos->second;
              for (const auto & j : row)
                {
                  const dof_id_type constraining_dof = j.first;
 
                  // If it's non-local and we haven't already got a
                  // constraint for it, we might need to ask for one
                  if (!this->local_index(constraining_dof) &&
                      !_dof_constraints.count(constraining_dof))
                    dof_request_set.insert(constraining_dof);
                }
            }
        }
 
      // Clear the unexpanded constraint set; we're about to expand it
      unexpanded_dofs.clear();
 
      // Count requests by processor
      processor_id_type proc_id = 0;
      for (const auto & i : dof_request_set)
        {
          while (i >= _end_df[proc_id])
            proc_id++;
          dof_ids_on_proc[proc_id]++;
        }
 
      for (auto & pair : dof_ids_on_proc)
        {
          requested_dof_ids[pair.first].reserve(pair.second);
        }
 
      // Prepare each processor's request set
      proc_id = 0;
      for (const auto & i : dof_request_set)
        {
          while (i >= _end_df[proc_id])
            proc_id++;
          requested_dof_ids[proc_id].push_back(i);
        }
 
      typedef std::vector<std::pair<dof_id_type, Real>> row_datum;
 
      typedef std::vector<Number> rhss_datum;
 
      auto row_gather_functor =
        [this]
        (processor_id_type,
         const std::vector<dof_id_type> & ids,
         std::vector<row_datum> & data)
        {
          // Fill those requests
          const std::size_t query_size = ids.size();
 
          data.resize(query_size);
          for (std::size_t i=0; i != query_size; ++i)
            {
              dof_id_type constrained = ids[i];
              if (_dof_constraints.count(constrained))
                {
                  DofConstraintRow & row = _dof_constraints[constrained];
                  std::size_t row_size = row.size();
                  data[i].reserve(row_size);
                  for (const auto & j : row)
                    {
                      data[i].push_back(j);
 
                      // We should never have an invalid constraining
                      // dof id
                      libmesh_assert(j.first != DofObject::invalid_id);
 
                      // We should never have a 0 constraint
                      // coefficient; that's implicit via sparse
                      // constraint storage
                      //
                      // But we can't easily control how users add
                      // constraints, so we can't safely assert that
                      // we're being efficient here.
                      //
                      // libmesh_assert(j.second);
                    }
                }
              else
                {
                  // We have to distinguish "constraint with no
                  // constraining dofs" (e.g. due to Dirichlet
                  // constraint equations) from "no constraint".
                  // We'll use invalid_id for the latter.
                  data[i].emplace_back(DofObject::invalid_id, Real(0));
                }
            }
        };
 
      auto rhss_gather_functor =
        [this,
         max_qoi_num]
        (processor_id_type,
         const std::vector<dof_id_type> & ids,
         std::vector<rhss_datum> & data)
        {
          // Fill those requests
          const std::size_t query_size = ids.size();
 
          data.resize(query_size);
          for (std::size_t i=0; i != query_size; ++i)
            {
              dof_id_type constrained = ids[i];
              data[i].clear();
              if (_dof_constraints.count(constrained))
                {
                  DofConstraintValueMap::const_iterator rhsit =
                    _primal_constraint_values.find(constrained);
                  data[i].push_back
                    ((rhsit == _primal_constraint_values.end()) ?
                     0 : rhsit->second);
 
                  for (unsigned int q = 0; q != max_qoi_num; ++q)
                    {
                      AdjointDofConstraintValues::const_iterator adjoint_map_it =
                        _adjoint_constraint_values.find(q);
 
                      if (adjoint_map_it == _adjoint_constraint_values.end())
                        {
                          data[i].push_back(0);
                          continue;
                        }
 
                      const DofConstraintValueMap & constraint_map =
                        adjoint_map_it->second;
 
                      DofConstraintValueMap::const_iterator adj_rhsit =
                        constraint_map.find(constrained);
                      data[i].push_back
                        ((adj_rhsit == constraint_map.end()) ?
                         0 : adj_rhsit->second);
                    }
                }
            }
        };
 
      auto row_action_functor =
        [this,
         & unexpanded_dofs]
        (processor_id_type,
         const std::vector<dof_id_type> & ids,
         const std::vector<row_datum> & data)
        {
          // Add any new constraint rows we've found
          const std::size_t query_size = ids.size();
 
          for (std::size_t i=0; i != query_size; ++i)
            {
              const dof_id_type constrained = ids[i];
 
              // An empty row is an constraint with an empty row; for
              // no constraint we use a "no row" placeholder
              if (data[i].empty())
                {
                  DofConstraintRow & row = _dof_constraints[constrained];
                  row.clear();
                }
              else if (data[i][0].first != DofObject::invalid_id)
                {
                  DofConstraintRow & row = _dof_constraints[constrained];
                  row.clear();
                  for (auto & pair : data[i])
                    {
                      libmesh_assert_less(pair.first, this->n_dofs());
                      row[pair.first] = pair.second;
                    }
 
                  // And prepare to check for more recursive constraints
                  unexpanded_dofs.insert(constrained);
                }
            }
        };
 
      auto rhss_action_functor =
        [this,
         max_qoi_num]
        (processor_id_type,
         const std::vector<dof_id_type> & ids,
         const std::vector<rhss_datum> & data)
        {
          // Add rhs data for any new constraint rows we've found
          const std::size_t query_size = ids.size();
 
          for (std::size_t i=0; i != query_size; ++i)
            {
              if (!data[i].empty())
                {
                  dof_id_type constrained = ids[i];
                  if (data[i][0] != Number(0))
                    _primal_constraint_values[constrained] = data[i][0];
                  else
                    _primal_constraint_values.erase(constrained);
 
                  for (unsigned int q = 0; q != max_qoi_num; ++q)
                    {
                      AdjointDofConstraintValues::iterator adjoint_map_it =
                        _adjoint_constraint_values.find(q);
 
                      if ((adjoint_map_it == _adjoint_constraint_values.end()) &&
                          data[i][q+1] == Number(0))
                        continue;
 
                      if (adjoint_map_it == _adjoint_constraint_values.end())
                        adjoint_map_it = _adjoint_constraint_values.emplace
                          (q, DofConstraintValueMap()).first;
 
                      DofConstraintValueMap & constraint_map =
                        adjoint_map_it->second;
 
                      if (data[i][q+1] != Number(0))
                        constraint_map[constrained] =
                          data[i][q+1];
                      else
                        constraint_map.erase(constrained);
                    }
                }
            }
 
        };
 
      // Now request constraint rows from other processors
      row_datum * row_ex = nullptr;
      Parallel::pull_parallel_vector_data
        (this->comm(), requested_dof_ids, row_gather_functor,
         row_action_functor, row_ex);
 
      // And request constraint right hand sides from other procesors
      rhss_datum * rhs_ex = nullptr;
      Parallel::pull_parallel_vector_data
        (this->comm(), requested_dof_ids, rhss_gather_functor,
         rhss_action_functor, rhs_ex);
 
      // We have to keep recursing while the unexpanded set is
      // nonempty on *any* processor
      unexpanded_set_nonempty = !unexpanded_dofs.empty();
      this->comm().max(unexpanded_set_nonempty);
    }
}

References _adjoint_constraint_values, _dof_constraints, libMesh::DofMapBase::_end_df, _primal_constraint_values, libMesh::ParallelObject::comm(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), local_index(), libMesh::Parallel::Communicator::max(), TIMPI::pull_parallel_vector_data(), and libMesh::Real.

Referenced by allgather_recursive_constraints(), and scatter_constraints().

get_adjoint_dirichlet_boundaries() [1/2]

DirichletBoundaries * libMesh::DofMap::get_adjoint_dirichlet_boundaries

(

unsigned int

q

)

Definition at line 5474 of file dof_map_constraints.C.

{
  unsigned int old_size = cast_int<unsigned int>
    (_adjoint_dirichlet_boundaries.size());
  for (unsigned int i = old_size; i <= q; ++i)
    _adjoint_dirichlet_boundaries.push_back(std::make_unique<DirichletBoundaries>());
 
  return _adjoint_dirichlet_boundaries[q].get();
}

References _adjoint_dirichlet_boundaries.

get_adjoint_dirichlet_boundaries() [2/2]

const DirichletBoundaries * libMesh::DofMap::get_adjoint_dirichlet_boundaries

(

unsigned int

q

)

const

Definition at line 5466 of file dof_map_constraints.C.

{
  libmesh_assert_greater(_adjoint_dirichlet_boundaries.size(),q);
  return _adjoint_dirichlet_boundaries[q].get();
}

References _adjoint_dirichlet_boundaries.

get_all_variable_numbers()

void libMesh::DofMap::get_all_variable_numbers

(

std::vector< unsigned int > &

all_variable_numbers

)

const

Fills all_variable_numbers with all the variable numbers for the variables that have been added to this system.

Definition at line 3389 of file dof_map.C.

{
  all_variable_numbers.resize(n_vars());
 
  unsigned int count = 0;
  for (auto vn : _variable_numbers)
    all_variable_numbers[count++] = vn.second;
}

References n_vars.

Referenced by libMesh::System::get_all_variable_numbers().

get_dirichlet_boundaries() [1/2]

DirichletBoundaries * libMesh::DofMap::get_dirichlet_boundaries ( )

inline

Definition at line 1641 of file dof_map.h.

  {
    return _dirichlet_boundaries.get();
  }

References _dirichlet_boundaries.

get_dirichlet_boundaries() [2/2]

const DirichletBoundaries * libMesh::DofMap::get_dirichlet_boundaries ( ) const

inline

Definition at line 1636 of file dof_map.h.

  {
    return _dirichlet_boundaries.get();
  }

References _dirichlet_boundaries.

Referenced by libMesh::DifferentiableSystem::add_dot_var_dirichlet_bcs().

get_dof_constraints()

const DofConstraints & libMesh::DofMap::get_dof_constraints ( ) const

inline

Provide a const accessor to the DofConstraints map.

This allows the user to quickly search the data structure rather than just iterating over it.

Definition at line 1177 of file dof_map.h.

{ return _dof_constraints; }

References _dof_constraints.

Referenced by libMesh::StaticCondensationDofMap::add_uncondensed_dof_plus_constraint_dofs().

get_info() [1/2]

std::string libMesh::ReferenceCounter::get_info ( )

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
  std::ostringstream oss;
 
  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
 
  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts.

Referenced by libMesh::ReferenceCounter::print_info().

get_info() [2/2]

std::string libMesh::DofMap::get_info

(

)

const

Gets summary info about the sparsity bandwidth and constraints.

Definition at line 2985 of file dof_map.C.

{
  std::ostringstream os;
 
  // If we didn't calculate the exact sparsity pattern, the threaded
  // sparsity pattern assembly may have just given us an upper bound
  // on sparsity.
  const char * may_equal = " <= ";
 
  // If we calculated the exact sparsity pattern, then we can report
  // exact bandwidth figures:
  for (const auto & mat : _matrices)
    if (mat->need_full_sparsity_pattern())
      may_equal = " = ";
 
  dof_id_type max_n_nz = 0, max_n_oz = 0;
  long double avg_n_nz = 0, avg_n_oz = 0;
 
  if (_sp)
    {
      for (const auto & val : _sp->get_n_nz())
        {
          max_n_nz = std::max(max_n_nz, val);
          avg_n_nz += val;
        }
 
      std::size_t n_nz_size = _sp->get_n_nz().size();
 
      this->comm().max(max_n_nz);
      this->comm().sum(avg_n_nz);
      this->comm().sum(n_nz_size);
 
      avg_n_nz /= std::max(n_nz_size,std::size_t(1));
 
      for (const auto & val : _sp->get_n_oz())
        {
          max_n_oz = std::max(max_n_oz, val);
          avg_n_oz += val;
        }
 
      std::size_t n_oz_size = _sp->get_n_oz().size();
 
      this->comm().max(max_n_oz);
      this->comm().sum(avg_n_oz);
      this->comm().sum(n_oz_size);
 
      avg_n_oz /= std::max(n_oz_size,std::size_t(1));
    }
 
  os << "    DofMap Sparsity\n      Average  On-Processor Bandwidth"
     << may_equal << avg_n_nz << '\n';
 
  os << "      Average Off-Processor Bandwidth"
     << may_equal << avg_n_oz << '\n';
 
  os << "      Maximum  On-Processor Bandwidth"
     << may_equal << max_n_nz << '\n';
 
  os << "      Maximum Off-Processor Bandwidth"
     << may_equal << max_n_oz << std::endl;
 
#ifdef LIBMESH_ENABLE_CONSTRAINTS
 
  std::size_t n_constraints = 0, max_constraint_length = 0,
    n_rhss = 0;
  long double avg_constraint_length = 0.;
 
  for (const auto & [constrained_dof, row] : _dof_constraints)
    {
      // Only count local constraints, then sum later
      if (!this->local_index(constrained_dof))
        continue;
 
      std::size_t rowsize = row.size();
 
      max_constraint_length = std::max(max_constraint_length,
                                       rowsize);
      avg_constraint_length += rowsize;
      n_constraints++;
 
      if (_primal_constraint_values.count(constrained_dof))
        n_rhss++;
    }
 
  this->comm().sum(n_constraints);
  this->comm().sum(n_rhss);
  this->comm().sum(avg_constraint_length);
  this->comm().max(max_constraint_length);
 
  os << "    DofMap Constraints\n      Number of DoF Constraints = "
     << n_constraints;
  if (n_rhss)
    os << '\n'
       << "      Number of Heterogenous Constraints= " << n_rhss;
  if (n_constraints)
    {
      avg_constraint_length /= n_constraints;
 
      os << '\n'
         << "      Average DoF Constraint Length= " << avg_constraint_length;
    }
 
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  std::size_t n_node_constraints = 0, max_node_constraint_length = 0,
    n_node_rhss = 0;
  long double avg_node_constraint_length = 0.;
 
  for (const auto & [node, pr] : _node_constraints)
    {
      // Only count local constraints, then sum later
      if (node->processor_id() != this->processor_id())
        continue;
 
      const NodeConstraintRow & row = pr.first;
      std::size_t rowsize = row.size();
 
      max_node_constraint_length = std::max(max_node_constraint_length,
                                            rowsize);
      avg_node_constraint_length += rowsize;
      n_node_constraints++;
 
      if (pr.second != Point(0))
        n_node_rhss++;
    }
 
  this->comm().sum(n_node_constraints);
  this->comm().sum(n_node_rhss);
  this->comm().sum(avg_node_constraint_length);
  this->comm().max(max_node_constraint_length);
 
  os << "\n      Number of Node Constraints = " << n_node_constraints;
  if (n_node_rhss)
    os << '\n'
       << "      Number of Heterogenous Node Constraints= " << n_node_rhss;
  if (n_node_constraints)
    {
      avg_node_constraint_length /= n_node_constraints;
      os << "\n      Maximum Node Constraint Length= " << max_node_constraint_length
         << '\n'
         << "      Average Node Constraint Length= " << avg_node_constraint_length;
    }
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
 
  os << std::endl;
 
#endif // LIBMESH_ENABLE_CONSTRAINTS
 
  return os.str();
}

get_local_constraints()

std::string libMesh::DofMap::get_local_constraints

(

bool

print_nonlocal = false

)

const

Gets a string reporting all DoF and Node constraints local to this processor.

If print_nonlocal is true, then nonlocal constraints which are locally known are included.

Definition at line 2279 of file dof_map_constraints.C.

{
  std::ostringstream os;
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  if (print_nonlocal)
    os << "All ";
  else
    os << "Local ";
 
  os << "Node Constraints:"
     << std::endl;
 
  for (const auto & [node, pr] : _node_constraints)
    {
      // Skip non-local nodes if requested
      if (!print_nonlocal &&
          node->processor_id() != this->processor_id())
        continue;
 
      const NodeConstraintRow & row = pr.first;
      const Point & offset = pr.second;
 
      os << "Constraints for Node id " << node->id()
         << ": \t";
 
      for (const auto & [cnode, val] : row)
        os << " (" << cnode->id() << "," << val << ")\t";
 
      os << "rhs: " << offset;
 
      os << std::endl;
    }
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
 
  if (print_nonlocal)
    os << "All ";
  else
    os << "Local ";
 
  os << "DoF Constraints:"
     << std::endl;
 
  for (const auto & [i, row] : _dof_constraints)
    {
      // Skip non-local dofs if requested
      if (!print_nonlocal && !this->local_index(i))
        continue;
 
      DofConstraintValueMap::const_iterator rhsit =
        _primal_constraint_values.find(i);
      const Number rhs = (rhsit == _primal_constraint_values.end()) ?
        0 : rhsit->second;
 
      os << "Constraints for DoF " << i
         << ": \t";
 
      for (const auto & item : row)
        os << " (" << item.first << "," << item.second << ")\t";
 
      os << "rhs: " << rhs;
      os << std::endl;
    }
 
  for (unsigned int qoi_index = 0,
       n_qois = cast_int<unsigned int>(_adjoint_dirichlet_boundaries.size());
       qoi_index != n_qois; ++qoi_index)
    {
      os << "Adjoint " << qoi_index << " DoF rhs values:"
         << std::endl;
 
      if (auto adjoint_map_it = _adjoint_constraint_values.find(qoi_index);
          adjoint_map_it != _adjoint_constraint_values.end())
        for (const auto & [i, rhs] : adjoint_map_it->second)
          {
            // Skip non-local dofs if requested
            if (!print_nonlocal && !this->local_index(i))
              continue;
 
            os << "RHS for DoF " << i
               << ": " << rhs;
 
            os << std::endl;
          }
    }
 
  return os.str();
}

References _adjoint_constraint_values, _adjoint_dirichlet_boundaries, _dof_constraints, _node_constraints, _primal_constraint_values, local_index(), and libMesh::ParallelObject::processor_id().

Referenced by print_dof_constraints().

get_n_nz()

const std::vector< dof_id_type > & libMesh::DofMap::get_n_nz ( ) const

inline

Returns

A constant reference to the _n_nz list for this processor.

The vector contains the bandwidth of the on-processor coupling for each row of the global matrix that the current processor owns. This information can be used to preallocate space for a parallel sparse matrix.

Definition at line 542 of file dof_map.h.

  {
    libmesh_assert(_sp);
    return _sp->get_n_nz();
  }

References _sp, and libMesh::libmesh_assert().

get_n_oz()

const std::vector< dof_id_type > & libMesh::DofMap::get_n_oz ( ) const

inline

Returns

A constant reference to the _n_oz list for this processor.

The vector contains the bandwidth of the off-processor coupling for each row of the global matrix that the current processor owns. This information can be used to preallocate space for a parallel sparse matrix.

Definition at line 555 of file dof_map.h.

  {
    libmesh_assert(_sp);
    return _sp->get_n_oz();
  }

References _sp, and libMesh::libmesh_assert().

get_periodic_boundaries() [1/2]

PeriodicBoundaries * libMesh::DofMap::get_periodic_boundaries ( )

inline

Definition at line 1583 of file dof_map.h.

  {
    return _periodic_boundaries.get();
  }

References _periodic_boundaries.

Referenced by main().

get_periodic_boundaries() [2/2]

const PeriodicBoundaries * libMesh::DofMap::get_periodic_boundaries ( ) const

inline

Definition at line 1588 of file dof_map.h.

  {
    return _periodic_boundaries.get();
  }

References _periodic_boundaries.

get_primal_constraint_values()

DofConstraintValueMap & libMesh::DofMap::get_primal_constraint_values ( )

inline

Returns

A reference to the set of right-hand-side values in primal constraint equations

Definition at line 2471 of file dof_map.h.

{
  return _primal_constraint_values;
}

References _primal_constraint_values.

get_send_list()

const std::vector< dof_id_type > & libMesh::DofMap::get_send_list ( ) const

inline

Returns

A constant reference to the _send_list for this processor.

The _send_list contains the global indices of all the variables in the global solution vector that influence the current processor. This information can be used for gathers at each solution step to retrieve solution values needed for computation.

Definition at line 533 of file dof_map.h.

{ return _send_list; }

References _send_list.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::AdaptiveTimeSolver::adjoint_advance_timestep(), libMesh::UnsteadySolver::adjoint_advance_timestep(), libMesh::AdaptiveTimeSolver::advance_timestep(), libMesh::NewmarkSolver::advance_timestep(), libMesh::UnsteadySolver::advance_timestep(), libMesh::PetscDMWrapper::build_sf(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::SecondOrderUnsteadySolver::init_data(), libMesh::UnsteadySolver::init_data(), libMesh::System::re_update(), libMesh::SecondOrderUnsteadySolver::reinit(), libMesh::UnsteadySolver::reinit(), libMesh::UnsteadySolver::retrieve_timestep(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), MeshFunctionTest::test_p_level(), libMesh::UnsteadySolver::update(), and NonManifoldGhostingFunctorTest::verify_send_list_entries_helper().

get_sparsity_pattern()

const SparsityPattern::Build * libMesh::DofMap::get_sparsity_pattern ( ) const

inline

Returns

A constant pointer to the sparsity pattern stored here, once that has been computed. Returns null if no sparsity pattern has yet been computed.

If need_full_sparsity_pattern is false, the "sparsity pattern" may only own n_nz and n_oz lists.

Definition at line 570 of file dof_map.h.

  {
    return _sp.get();
  }

References _sp.

Referenced by libMesh::SparseMatrix< T >::attach_dof_map().

get_static_condensation() [1/2]

StaticCondensationDofMap & libMesh::DofMap::get_static_condensation ( )

inline

Returns

the static condensation class. This should have been already added with a call to add_static_condensation()

Definition at line 2859 of file dof_map.h.

{
  libmesh_assert(_sc);
  return *_sc;
}

References _sc, and libMesh::libmesh_assert().

Referenced by add_constraints_to_send_list().

get_static_condensation() [2/2]

const StaticCondensationDofMap & libMesh::DofMap::get_static_condensation ( ) const

inline

Returns

the static condensation class. This should have been already added with a call to add_static_condensation()

Definition at line 2866 of file dof_map.h.

{
  libmesh_assert(_sc);
  return *_sc;
}

References _sc, and libMesh::libmesh_assert().

get_variable_array()

const std::pair< unsigned int, unsigned int > & libMesh::DofMap::get_variable_array ( unsigned int  vi ) const

inlineprivate

Retrieve the array variable bounds for a given variable vi.

This variable may lie anywhere within an array variable range. An 'array variable' is simply a sequence of contiguous variable numbers defined by pair where the first member of the pair is the first number in the variable sequence and the second member of the pair is the number of the last variable in the sequence plus one. Array variables may be used in tandem with variable grouping by downstream code to build optimized physics kernels since each variable in the array will have the same shape functions.

We note that we store array variables as a container of the above described pairs. Within this API we will do a binary search such that the complexity is O(log(N)) where N is the number of array variables present in this

Definition at line 2873 of file dof_map.h.

{
  auto it = std::upper_bound(
      _array_variables.begin(),
      _array_variables.end(),
      vi,
      [](unsigned int value, const std::pair<unsigned int, unsigned int> & b) { return value < b.first; });
 
  libmesh_assert_msg(it != _array_variables.begin(),
                     "Passed in " << std::to_string(vi) << " is not in any of our array variables");
  --it;
  libmesh_assert_msg(vi < it->second,
                     "Passed in " << std::to_string(vi) << " is not in any of our array variables");
  return *it;
}

References _array_variables, b, and value.

Referenced by array_dof_indices().

has_adjoint_dirichlet_boundaries()

bool libMesh::DofMap::has_adjoint_dirichlet_boundaries

(

unsigned int

q

)

const

Definition at line 5456 of file dof_map_constraints.C.

{
  if (_adjoint_dirichlet_boundaries.size() > q)
    return true;
 
  return false;
}

References _adjoint_dirichlet_boundaries.

Referenced by libMesh::AdjointRefinementEstimator::estimate_error(), and libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve().

has_blocked_representation()

bool libMesh::DofMap::has_blocked_representation ( ) const

inline

Returns

true if the variables are capable of being stored in a blocked form. Presently, this means that there can only be one variable group, and that the group has more than one variable.

Definition at line 749 of file dof_map.h.

  {
    return ((this->n_variable_groups() == 1) && (this->n_variables() > 1));
  }

References n_variable_groups(), and n_variables().

Referenced by block_size().

has_heterogeneous_adjoint_constraint()

Number libMesh::DofMap::has_heterogeneous_adjoint_constraint ( const unsigned int  qoi_num, const dof_id_type  dof  ) const

inline

Returns

The heterogeneous constraint value if the degree of freedom dof has a heterogeneous constraint for adjoint solution qoi_num, zero otherwise.

Definition at line 2450 of file dof_map.h.

{
  AdjointDofConstraintValues::const_iterator it =
    _adjoint_constraint_values.find(qoi_num);
  if (it != _adjoint_constraint_values.end())
    {
      DofConstraintValueMap::const_iterator rhsit =
        it->second.find(dof);
      if (rhsit == it->second.end())
        return 0;
      else
        return rhsit->second;
    }
 
  return 0;
}

References _adjoint_constraint_values.

Referenced by has_heterogenous_adjoint_constraint().

has_heterogeneous_adjoint_constraints()

bool libMesh::DofMap::has_heterogeneous_adjoint_constraints ( const unsigned int  qoi_num ) const

inline

Returns

true if the system has any heterogeneous constraints for adjoint solution qoi_num, false otherwise.

Definition at line 2436 of file dof_map.h.

{
  AdjointDofConstraintValues::const_iterator it =
    _adjoint_constraint_values.find(qoi_num);
  if (it == _adjoint_constraint_values.end())
    return false;
  if (it->second.empty())
    return false;
 
  return true;
}

References _adjoint_constraint_values.

Referenced by has_heterogenous_adjoint_constraints().

has_heterogenous_adjoint_constraint()

Number libMesh::DofMap::has_heterogenous_adjoint_constraint ( const unsigned int  qoi_num, const dof_id_type  dof  ) const

inline

Backwards compatibility with misspelling.

Definition at line 1253 of file dof_map.h.

  {
    return this->has_heterogeneous_adjoint_constraint (qoi_num, dof);
  }

References has_heterogeneous_adjoint_constraint().

has_heterogenous_adjoint_constraints()

bool libMesh::DofMap::has_heterogenous_adjoint_constraints ( const unsigned int  qoi_num ) const

inline

Backwards compatibility with misspelling.

Definition at line 1237 of file dof_map.h.

  {
    return this->has_heterogeneous_adjoint_constraints (qoi_num);
  }

References has_heterogeneous_adjoint_constraints().

has_static_condensation()

bool libMesh::DofMap::has_static_condensation ( ) const

inline

Checks whether we have static condensation.

Definition at line 1797 of file dof_map.h.

{ return _sc.get(); }

References _sc.

Referenced by add_constraints_to_send_list(), and build_sparsity().

has_variable()

bool libMesh::DofMap::has_variable ( std::string_view  var ) const

inline

Returns

true if a variable named var exists in this System

Definition at line 2986 of file dof_map.h.

{
  return _variable_numbers.count(var);
}

References _variable_numbers.

Referenced by libMesh::System::has_variable().

heterogeneously_constrain_element_jacobian_and_residual()

void libMesh::DofMap::heterogeneously_constrain_element_jacobian_and_residual	(	DenseMatrix< Number > &	matrix,
		DenseVector< Number > &	rhs,
		std::vector< dof_id_type > &	elem_dofs,
		NumericVector< Number > &	solution_local
	)		const

Constrains the element Jacobian and residual.

The element Jacobian is square, and the elem_dofs should correspond to the global DOF indices of both the rows and columns of the element matrix.

The residual-constraining version of this method creates linear systems in which heterogeneously constrained degrees of freedom create non-zero residual terms when not at their correct offset values, as would be appropriate for finding a solution to a nonlinear problem in a quasi-Newton solve.

Note the sign difference from the linear heterogeneous constraint method: Solving u:=u_in-J\r has the opposite sign convention from u:=K\f, and we apply heterogeneous constraints accordingly.

The solution vector passed in should be a serialized or ghosted primal solution

Definition at line 2619 of file dof_map_constraints.C.

{
  libmesh_assert_equal_to (elem_dofs.size(), matrix.m());
  libmesh_assert_equal_to (elem_dofs.size(), matrix.n());
  libmesh_assert_equal_to (elem_dofs.size(), rhs.size());
 
  libmesh_assert (solution_local.type() == SERIAL ||
                  solution_local.type() == GHOSTED);
 
  // check for easy return
  if (this->_dof_constraints.empty())
    return;
 
  // The constrained matrix is built up as C^T K C.
  // The constrained RHS is built up as C^T F
  // Asymmetric residual terms are added if we do not have x = Cx+h
  DenseMatrix<Number> C;
  DenseVector<Number> H;
 
  this->build_constraint_matrix_and_vector (C, H, elem_dofs);
 
  LOG_SCOPE("hetero_cnstrn_elem_jac_res()", "DofMap");
 
  // It is possible that the matrix is not constrained at all.
  if ((C.m() != matrix.m()) ||
      (C.n() != elem_dofs.size()))
    return;
 
  // Compute the matrix-vector product C^T F
  DenseVector<Number> old_rhs(rhs);
  C.vector_mult_transpose(rhs, old_rhs);
 
  // Compute the matrix-matrix-matrix product C^T K C
  matrix.left_multiply_transpose  (C);
  matrix.right_multiply (C);
 
  libmesh_assert_equal_to (matrix.m(), matrix.n());
  libmesh_assert_equal_to (matrix.m(), elem_dofs.size());
  libmesh_assert_equal_to (matrix.n(), elem_dofs.size());
 
  for (unsigned int i=0,
       n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
       i != n_elem_dofs; i++)
    {
      const dof_id_type dof_id = elem_dofs[i];
 
      if (auto pos = _dof_constraints.find(dof_id);
          pos != _dof_constraints.end())
        {
          for (auto j : make_range(matrix.n()))
            matrix(i,j) = 0.;
 
          // If the DOF is constrained
          matrix(i,i) = 1.;
 
          // This will put a nonsymmetric entry in the constraint
          // row to ensure that the linear system produces the
          // correct value for the constrained DOF.
          const DofConstraintRow & constraint_row = pos->second;
 
          for (const auto & item : constraint_row)
            for (unsigned int j=0; j != n_elem_dofs; j++)
              if (elem_dofs[j] == item.first)
                matrix(i,j) = -item.second;
 
          const DofConstraintValueMap::const_iterator valpos =
            _primal_constraint_values.find(dof_id);
 
          Number & rhs_val = rhs(i);
          rhs_val = (valpos == _primal_constraint_values.end()) ?
            0 : -valpos->second;
          for (const auto & [constraining_dof, coef] : constraint_row)
            rhs_val -= coef * solution_local(constraining_dof);
          rhs_val += solution_local(dof_id);
        }
    }
}

References _dof_constraints, _primal_constraint_values, build_constraint_matrix_and_vector(), libMesh::GHOSTED, libMesh::DenseMatrix< T >::left_multiply_transpose(), libMesh::libmesh_assert(), libMesh::DenseMatrixBase< T >::m(), libMesh::make_range(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseMatrix< T >::right_multiply(), libMesh::SERIAL, libMesh::DenseVector< T >::size(), libMesh::NumericVector< T >::type(), and libMesh::DenseMatrix< T >::vector_mult_transpose().

heterogeneously_constrain_element_matrix_and_vector()

void libMesh::DofMap::heterogeneously_constrain_element_matrix_and_vector ( DenseMatrix< Number > &  matrix, DenseVector< Number > &  rhs, std::vector< dof_id_type > &  elem_dofs, bool  asymmetric_constraint_rows = true, int  qoi_index = -1  ) const

inline

Constrains the element matrix and vector.

This method requires the element matrix to be square, in which case the elem_dofs correspond to the global DOF indices of both the rows and columns of the element matrix. For this case the rows and columns of the matrix necessarily correspond to variables of the same approximation order.

The heterogeneous version of this method creates linear systems in which heterogeneously constrained degrees of freedom will solve to their correct offset values, as would be appropriate for finding a solution to a linear problem in a single algebraic solve. The non-heterogeneous version of this method creates linear systems in which even heterogeneously constrained degrees of freedom are solved without offset values taken into account, as would be appropriate for finding linearized updates to a solution in which heterogeneous constraints are already satisfied.

By default, the constraints for the primal solution of this system are used. If a non-negative qoi_index is passed in, then the constraints for the corresponding adjoint solution are used instead.

Definition at line 2503 of file dof_map.h.

                                              {}

Referenced by heterogenously_constrain_element_matrix_and_vector(), and process_mesh_constraint_rows().

heterogeneously_constrain_element_residual()

void libMesh::DofMap::heterogeneously_constrain_element_residual	(	DenseVector< Number > &	rhs,
		std::vector< dof_id_type > &	elem_dofs,
		NumericVector< Number > &	solution_local
	)		const

Constrains the element residual.

The element Jacobian is square, and the elem_dofs should correspond to the global DOF indices of both the rows and columns of the element matrix.

The residual-constraining version of this method creates linear systems in which heterogeneously constrained degrees of freedom create non-zero residual terms when not at their correct offset values, as would be appropriate for finding a solution to a nonlinear problem in a quasi-Newton solve.

The solution vector passed in should be a serialized or ghosted primal solution

Definition at line 2702 of file dof_map_constraints.C.

{
  libmesh_assert_equal_to (elem_dofs.size(), rhs.size());
 
  libmesh_assert (solution_local.type() == SERIAL ||
                  solution_local.type() == GHOSTED);
 
  // check for easy return
  if (this->_dof_constraints.empty())
    return;
 
  // The constrained RHS is built up as C^T F
  // Asymmetric residual terms are added if we do not have x = Cx+h
  DenseMatrix<Number> C;
  DenseVector<Number> H;
 
  this->build_constraint_matrix_and_vector (C, H, elem_dofs);
 
  LOG_SCOPE("hetero_cnstrn_elem_res()", "DofMap");
 
  // It is possible that the element is not constrained at all.
  if ((C.m() != rhs.size()) ||
      (C.n() != elem_dofs.size()))
    return;
 
  // Compute the matrix-vector product C^T F
  DenseVector<Number> old_rhs(rhs);
  C.vector_mult_transpose(rhs, old_rhs);
 
  for (unsigned int i=0,
       n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
       i != n_elem_dofs; i++)
    {
      const dof_id_type dof_id = elem_dofs[i];
 
      if (auto pos = _dof_constraints.find(dof_id);
          pos != _dof_constraints.end())
        {
          // This will put a nonsymmetric entry in the constraint
          // row to ensure that the linear system produces the
          // correct value for the constrained DOF.
          const DofConstraintRow & constraint_row = pos->second;
 
          const DofConstraintValueMap::const_iterator valpos =
            _primal_constraint_values.find(dof_id);
 
          Number & rhs_val = rhs(i);
          rhs_val = (valpos == _primal_constraint_values.end()) ?
            0 : -valpos->second;
          for (const auto & [constraining_dof, coef] : constraint_row)
            rhs_val -= coef * solution_local(constraining_dof);
          rhs_val += solution_local(dof_id);
        }
    }
}

References _dof_constraints, _primal_constraint_values, build_constraint_matrix_and_vector(), libMesh::GHOSTED, libMesh::libmesh_assert(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::SERIAL, libMesh::DenseVector< T >::size(), libMesh::NumericVector< T >::type(), and libMesh::DenseMatrix< T >::vector_mult_transpose().

heterogeneously_constrain_element_vector()

void libMesh::DofMap::heterogeneously_constrain_element_vector ( const DenseMatrix< Number > &  matrix, DenseVector< Number > &  rhs, std::vector< dof_id_type > &  elem_dofs, bool  asymmetric_constraint_rows = true, int  qoi_index = -1  ) const

inline

Constrains the element vector.

This method requires the element matrix to be square and not-yet-constrained, in which case the elem_dofs correspond to the global DOF indices of both the rows and columns of the element matrix.

The heterogeneous version of this method creates linear systems in which heterogeneously constrained degrees of freedom will solve to their correct offset values, as would be appropriate for finding a solution to a linear problem in a single algebraic solve. The non-heterogeneous version of this method creates linear systems in which even heterogeneously constrained degrees of freedom are solved without offset values taken into account, as would be appropriate for finding linearized updates to a solution in which heterogeneous constraints are already satisfied.

Note the sign difference from the nonlinear heterogeneous constraint method: Solving u:=K\f has the opposite sign convention from u:=u_in-J\r, and we apply heterogeneous constraints accordingly.

By default, the constraints for the primal solution of this system are used. If a non-negative qoi_index is passed in, then the constraints for the corresponding adjoint solution are used instead.

Definition at line 2507 of file dof_map.h.

                                              {}

Referenced by heterogenously_constrain_element_vector().

heterogenously_constrain_element_matrix_and_vector()

void libMesh::DofMap::heterogenously_constrain_element_matrix_and_vector ( DenseMatrix< Number > &  matrix, DenseVector< Number > &  rhs, std::vector< dof_id_type > &  elem_dofs, bool  asymmetric_constraint_rows = true, int  qoi_index = -1  ) const

inline

Definition at line 1388 of file dof_map.h.

  {
    return this->heterogeneously_constrain_element_matrix_and_vector
      (matrix, rhs, elem_dofs, asymmetric_constraint_rows, qoi_index);
  }

References heterogeneously_constrain_element_matrix_and_vector().

Referenced by assemble_stokes(), and libMesh::System::solve_for_unconstrained_dofs().

heterogenously_constrain_element_vector()

void libMesh::DofMap::heterogenously_constrain_element_vector ( const DenseMatrix< Number > &  matrix, DenseVector< Number > &  rhs, std::vector< dof_id_type > &  elem_dofs, bool  asymmetric_constraint_rows = true, int  qoi_index = -1  ) const

inline

Definition at line 1432 of file dof_map.h.

  {
    return this->heterogeneously_constrain_element_vector
      (matrix, rhs, elem_dofs, asymmetric_constraint_rows, qoi_index);
  }

References heterogeneously_constrain_element_vector().

identify_variable_groups() [1/2]

bool libMesh::DofMap::identify_variable_groups ( ) const

inline

Returns

true when VariableGroup structures should be automatically identified, false otherwise.

Definition at line 2951 of file dof_map.h.

{
  return _identify_variable_groups;
}

References _identify_variable_groups.

identify_variable_groups() [2/2]

void libMesh::DofMap::identify_variable_groups ( const bool  ivg )

inline

Toggle automatic VariableGroup identification.

Definition at line 2957 of file dof_map.h.

{
  _identify_variable_groups = ivg;
}

References _identify_variable_groups.

increment_constructor_count()

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name )

inlineprotectednoexceptinherited

Increments the construction counter.

Should be called in the constructor of any derived class that will be reference counted.

Definition at line 183 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.first++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_constructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), and libMesh::ReferenceCountedObject< T >::ReferenceCountedObject().

increment_destructor_count()

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name )

inlineprotectednoexceptinherited

Increments the destruction counter.

Should be called in the destructor of any derived class that will be reference counted.

Definition at line 207 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.second++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_destructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< T >::~ReferenceCountedObject().

invalidate_dofs()

void libMesh::DofMap::invalidate_dofs ( MeshBase &  mesh ) const

private

Invalidates all active DofObject dofs for this system.

Definition at line 856 of file dof_map.C.

{
  const unsigned int sys_num = this->sys_number();
 
  // All the nodes
  for (auto & node : mesh.node_ptr_range())
    node->invalidate_dofs(sys_num);
 
  // All the active elements.
  for (auto & elem : mesh.active_element_ptr_range())
    elem->invalidate_dofs(sys_num);
}

References mesh.

is_attached()

bool libMesh::DofMap::is_attached

(

SparseMatrix< Number > &

matrix

)

Matrices should not be attached more than once.

We can test for an already-attached matrix if necessary using is_attached

Definition at line 295 of file dof_map.C.

{
  return (std::find(_matrices.begin(), _matrices.end(),
                    &matrix) != _matrices.end());
}

References _matrices.

Referenced by OverlappingCouplingGhostingTest::run_sparsity_pattern_test().

is_constrained_dof()

bool libMesh::DofMap::is_constrained_dof ( const dof_id_type  dof ) const

inline

Returns

true if the degree of freedom dof is constrained, false otherwise.

Definition at line 2426 of file dof_map.h.

{
  if (_dof_constraints.count(dof))
    return true;
 
  return false;
}

References _dof_constraints.

Referenced by add_adjoint_constraint_row(), add_constraint_row(), allgather_recursive_constraints(), AssembleOptimization::assemble_A_and_F(), build_constraint_matrix(), build_constraint_matrix_and_vector(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), libMesh::CondensedEigenSystem::initialize_condensed_dofs(), max_constraint_error(), libMesh::RBSCMConstruction::perform_SCM_greedy(), process_mesh_constraint_rows(), scatter_constraints(), libMesh::System::solve_for_unconstrained_dofs(), BoundaryInfoTest::testShellFaceConstraints(), and libMesh::RBConstruction::zero_constrained_dofs_on_vector().

is_constrained_node()

bool libMesh::DofMap::is_constrained_node ( const Node *  node ) const

inline

Returns

true if the Node is constrained, false otherwise.

Definition at line 2410 of file dof_map.h.

{
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  if (_node_constraints.count(node))
    return true;
#endif
 
  return false;
}

References _node_constraints.

Referenced by allgather_recursive_constraints(), and scatter_constraints().

is_evaluable()

template<typename DofObjectSubclass >

template LIBMESH_EXPORT bool libMesh::DofMap::is_evaluable< Node >	(	const DofObjectSubclass &	obj,
		unsigned int	var_num = libMesh::invalid_uint
	)		const

Returns

true iff our solutions can be locally evaluated on obj (which should be an Elem or a Node) for variable number var_num (for all variables, if var_num is invalid_uint)

Definition at line 2673 of file dof_map.C.

{
  // Everything is evaluable on a local object
  if (obj.processor_id() == this->processor_id())
    return true;
 
  std::vector<dof_id_type> di;
 
  if (var_num == libMesh::invalid_uint)
    this->dof_indices(&obj, di);
  else
    this->dof_indices(&obj, di, var_num);
 
  return this->all_semilocal_indices(di);
}

References libMesh::invalid_uint.

Referenced by libMesh::MeshFunction::check_found_elem(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), DefaultCouplingTest::testCoupling(), and PointNeighborCouplingTest::testCoupling().

is_periodic_boundary()

bool libMesh::DofMap::is_periodic_boundary

(

const boundary_id_type

boundaryid

)

const

Returns

true if the boundary given by boundaryid is periodic, false otherwise

Definition at line 217 of file dof_map.C.

{
  if (_periodic_boundaries->count(boundaryid) != 0)
    return true;
 
  return false;
}

References _periodic_boundaries.

local_index()

bool libMesh::DofMap::local_index ( dof_id_type  dof_index ) const

inline

Returns

true if degree of freedom index dof_index is a local index.

Definition at line 967 of file dof_map.h.

  { return (dof_index >= this->first_dof()) && (dof_index < this->end_dof()); }

References libMesh::DofMapBase::end_dof(), and libMesh::DofMapBase::first_dof().

Referenced by add_constraints_to_send_list(), libMesh::StaticCondensationDofMap::add_uncondensed_dof(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::Nemesis_IO::copy_elemental_solution(), libMesh::Nemesis_IO::copy_nodal_solution(), gather_constraints(), get_local_constraints(), libMesh::SparsityPattern::Build::parallel_sync(), process_mesh_constraint_rows(), and libMesh::PetscDMWrapper::set_point_range_in_section().

local_variable_indices() [1/2]

template<typename T , std::enable_if_t< std::is_same_v< T, dof_id_type >||std::is_same_v< T, std::vector< dof_id_type > >, int > >

void libMesh::DofMap::local_variable_indices	(	T &	idx,
		const MeshBase &	mesh,
		unsigned int	var_num
	)		const

If T == dof_id_type, counts, if T == std::vector<dof_id_type>, fills an array of, those dof indices which belong to the given variable number and live on the current processor.

Definition at line 1122 of file dof_map.C.

{
  // Only used if T == dof_id_type to keep track of the greatest dof we've seen
  dof_id_type greatest = 0;
 
  if constexpr (std::is_same_v<T, dof_id_type>)
    idx = 0;
  else if constexpr (std::is_same_v<T, std::vector<dof_id_type>>)
    idx.clear();
 
  // Count dofs in the *exact* order that distribute_dofs numbered
  // them, so that we can assume ascending indices and use push_back
  // instead of find+insert.
 
  const unsigned int sys_num = this->sys_number();
 
  // If this isn't a SCALAR variable, we need to find all its field
  // dofs on the mesh
  if (this->variable_type(var_num).family != SCALAR)
    {
      const Variable & var(this->variable(var_num));
 
      for (auto & elem : mesh.active_local_element_ptr_range())
        {
          if (!var.active_on_subdomain(elem->subdomain_id()))
            continue;
 
          // Only count dofs connected to active
          // elements on this processor.
          const unsigned int n_nodes = elem->n_nodes();
 
          // First get any new nodal DOFS
          for (unsigned int n=0; n<n_nodes; n++)
            {
              const Node & node = elem->node_ref(n);
 
              if (node.processor_id() != this->processor_id())
                continue;
 
              const unsigned int n_comp = node.n_comp(sys_num, var_num);
              for(unsigned int i=0; i<n_comp; i++)
                {
                  const dof_id_type index = node.dof_number(sys_num,var_num,i);
                  libmesh_assert (this->local_index(index));
 
                  if constexpr (std::is_same_v<T, dof_id_type>)
                    {
                      if (idx == 0 || index > greatest)
                        { idx++; greatest = index; }
                    }
                  else if constexpr (std::is_same_v<T, std::vector<dof_id_type>>)
                    {
                      if (idx.empty() || index > idx.back())
                        idx.push_back(index);
                    }
                }
            }
 
          // Next get any new element DOFS
          const unsigned int n_comp = elem->n_comp(sys_num, var_num);
          for (unsigned int i=0; i<n_comp; i++)
            {
              const dof_id_type index = elem->dof_number(sys_num,var_num,i);
 
              if constexpr (std::is_same_v<T, dof_id_type>)
                {
                  if (idx == 0 || index > greatest)
                    { idx++; greatest = index; }
                }
              else if constexpr (std::is_same_v<T, std::vector<dof_id_type>>)
                {
                  if (idx.empty() || index > idx.back())
                    idx.push_back(index);
                }
            }
        } // done looping over elements
 
 
      // we may have missed assigning DOFs to nodes that we own
      // but to which we have no connected elements matching our
      // variable restriction criterion.  this will happen, for example,
      // if variable V is restricted to subdomain S.  We may not own
      // any elements which live in S, but we may own nodes which are
      // *connected* to elements which do.  in this scenario these nodes
      // will presently have unnumbered DOFs. we need to take care of
      // them here since we own them and no other processor will touch them.
      for (const auto & node : mesh.local_node_ptr_range())
        {
          libmesh_assert(node);
 
          const unsigned int n_comp = node->n_comp(sys_num, var_num);
          for (unsigned int i=0; i<n_comp; i++)
            {
              const dof_id_type index = node->dof_number(sys_num,var_num,i);
 
              if constexpr (std::is_same_v<T, dof_id_type>)
                {
                  if (idx == 0 || index > greatest)
                    { idx++; greatest = index; }
                }
              else if constexpr (std::is_same_v<T, std::vector<dof_id_type>>)
                {
                  if (idx.empty() || index > idx.back())
                    idx.push_back(index);
                }
            }
        }
    }
  // Otherwise, count up the SCALAR dofs, if we're on the processor
  // that holds this SCALAR variable
  else if (this->processor_id() == (this->n_processors()-1))
    {
      std::vector<dof_id_type> di_scalar;
      this->SCALAR_dof_indices(di_scalar,var_num);
 
      if constexpr (std::is_same_v<T, dof_id_type>)
        idx += std::distance(di_scalar.begin(), di_scalar.end());
      else if constexpr (std::is_same_v<T, std::vector<dof_id_type>>)
        idx.insert(idx.end(), di_scalar.begin(), di_scalar.end());
    }
}

References libMesh::Variable::active_on_subdomain(), libMesh::DofObject::dof_number(), libMesh::libmesh_assert(), mesh, libMesh::DofObject::n_comp(), n_nodes, libMesh::DofObject::processor_id(), and libMesh::SCALAR.

Referenced by libMesh::PetscDMWrapper::init_petscdm(), local_variable_indices(), n_local_dofs(), libMesh::petsc_auto_fieldsplit(), libMesh::PetscPreconditioner< T >::set_hypre_ads_data(), libMesh::PetscPreconditioner< T >::set_hypre_ams_data(), and SystemsTest::testBlockRestrictedVarNDofs().

local_variable_indices() [2/2]

template<typename T , std::enable_if_t< std::is_same_v< T, dof_id_type >||std::is_same_v< T, std::vector< dof_id_type > >, int > = 0>

void libMesh::DofMap::local_variable_indices ( T &  idx, unsigned int  var_num  ) const

inline

If T == dof_id_type, counts, if T == std::vector<dof_id_type>, fills an array of, those dof indices which belong to the given variable number and live on the current processor.

Definition at line 1035 of file dof_map.h.

  { this->local_variable_indices(idx, this->_mesh, var_num); }

References _mesh, and local_variable_indices().

max_constraint_error()

std::pair< Real, Real > libMesh::DofMap::max_constraint_error	(	const System &	system,
		NumericVector< Number > *	v = nullptr
	)		const

Tests the constrained degrees of freedom on the numeric vector v, which represents a solution defined on the mesh, returning a pair whose first entry is the maximum absolute error on a constrained DoF and whose second entry is the maximum relative error.

Useful for debugging purposes.

If v == nullptr, the system solution vector is tested.

Definition at line 3355 of file dof_map_constraints.C.

{
  if (!v)
    v = system.solution.get();
  NumericVector<Number> & vec = *v;
 
  // We'll assume the vector is closed
  libmesh_assert (vec.closed());
 
  Real max_absolute_error = 0., max_relative_error = 0.;
 
  const MeshBase & mesh = system.get_mesh();
 
  libmesh_assert_equal_to (this, &(system.get_dof_map()));
 
  // indices on each element
  std::vector<dof_id_type> local_dof_indices;
 
  for (const auto & elem : mesh.active_local_element_ptr_range())
    {
      this->dof_indices(elem, local_dof_indices);
      std::vector<dof_id_type> raw_dof_indices = local_dof_indices;
 
      // Constraint matrix for each element
      DenseMatrix<Number> C;
 
      this->build_constraint_matrix (C, local_dof_indices);
 
      // Continue if the element is unconstrained
      if (!C.m())
        continue;
 
      libmesh_assert_equal_to (C.m(), raw_dof_indices.size());
      libmesh_assert_equal_to (C.n(), local_dof_indices.size());
 
      for (auto i : make_range(C.m()))
        {
          // Recalculate any constrained dof owned by this processor
          dof_id_type global_dof = raw_dof_indices[i];
          if (this->is_constrained_dof(global_dof) &&
              global_dof >= vec.first_local_index() &&
              global_dof < vec.last_local_index())
            {
#ifndef NDEBUG
              DofConstraints::const_iterator
                pos = _dof_constraints.find(global_dof);
 
              libmesh_assert (pos != _dof_constraints.end());
#endif
 
              Number exact_value = 0;
              DofConstraintValueMap::const_iterator rhsit =
                _primal_constraint_values.find(global_dof);
              if (rhsit != _primal_constraint_values.end())
                exact_value = rhsit->second;
 
              for (auto j : make_range(C.n()))
                {
                  if (local_dof_indices[j] != global_dof)
                    exact_value += C(i,j) *
                      vec(local_dof_indices[j]);
                }
 
              max_absolute_error = std::max(max_absolute_error,
                                            std::abs(vec(global_dof) - exact_value));
              max_relative_error = std::max(max_relative_error,
                                            std::abs(vec(global_dof) - exact_value)
                                            / std::abs(exact_value));
            }
        }
    }
 
  return std::pair<Real, Real>(max_absolute_error, max_relative_error);
}

References _dof_constraints, _primal_constraint_values, build_constraint_matrix(), libMesh::NumericVector< T >::closed(), dof_indices(), exact_value(), libMesh::NumericVector< T >::first_local_index(), libMesh::System::get_dof_map(), libMesh::System::get_mesh(), is_constrained_dof(), libMesh::NumericVector< T >::last_local_index(), libMesh::libmesh_assert(), libMesh::DenseMatrixBase< T >::m(), libMesh::make_range(), mesh, libMesh::DenseMatrixBase< T >::n(), libMesh::Real, and libMesh::System::solution.

merge_ghost_functor_outputs()

void libMesh::DofMap::merge_ghost_functor_outputs ( GhostingFunctor::map_type &  elements_to_ghost, CouplingMatricesSet &  temporary_coupling_matrices, const GhostingFunctorIterator &  gf_begin, const GhostingFunctorIterator &  gf_end, const MeshBase::const_element_iterator &  elems_begin, const MeshBase::const_element_iterator &  elems_end, processor_id_type  p  )

staticprivate

Definition at line 1584 of file dof_map.C.

{
  for (const auto & gf : as_range(gf_begin, gf_end))
    {
      GhostingFunctor::map_type more_elements_to_ghost;
 
      libmesh_assert(gf);
      (*gf)(elems_begin, elems_end, p, more_elements_to_ghost);
 
      // A GhostingFunctor should only return active elements, but
      // I forgot to *document* that, so let's go as easy as we
      // can on functors that return inactive elements.
#if defined(LIBMESH_ENABLE_DEPRECATED) && defined(LIBMESH_ENABLE_AMR)
      std::vector<std::pair<const Elem*, const CouplingMatrix*>> children_to_couple;
      for (auto it = more_elements_to_ghost.begin();
           it != more_elements_to_ghost.end();)
        {
          const Elem * elem = it->first;
          if (!elem->active())
            {
              libmesh_deprecated();
              std::vector<const Elem*> children_to_ghost;
              elem->active_family_tree(children_to_ghost,
                                       /*reset=*/ false);
              for (const Elem * child : children_to_ghost)
                if (child->processor_id() != p)
                  children_to_couple.emplace_back(child, it->second);
 
              it = more_elements_to_ghost.erase(it);
            }
          else
            ++it;
        }
      more_elements_to_ghost.insert(children_to_couple.begin(),
                                    children_to_couple.end());
#endif
 
      for (const auto & [elem, elem_cm] : more_elements_to_ghost)
        {
          // At this point we should only have active elements, even
          // if we had to fix up gf output to get here.
          libmesh_assert(elem->active());
 
          if (const auto existing_it = elements_to_ghost.find(elem);
              existing_it == elements_to_ghost.end())
            elements_to_ghost.emplace(elem, elem_cm);
          else
            {
              if (existing_it->second)
                {
                  if (elem_cm)
                    {
                      // If this isn't already a temporary
                      // then we need to make one so we'll
                      // have a non-const matrix to merge
                      if (temporary_coupling_matrices.empty() ||
                          !temporary_coupling_matrices.count(existing_it->second))
                        {
                          // Make copy. This just calls the
                          // compiler-generated copy constructor
                          // because the CouplingMatrix class does not
                          // define a custom copy constructor.
                          auto result_pr = temporary_coupling_matrices.insert(std::make_unique<CouplingMatrix>(*existing_it->second));
                          existing_it->second = result_pr.first->get();
                        }
 
                      // Merge elem_cm into existing CouplingMatrix
                      const_cast<CouplingMatrix &>(*existing_it->second) &= *elem_cm;
                    }
                  else // elem_cm == nullptr
                    {
                      // Any existing_it matrix merged with a full
                      // matrix (symbolized as nullptr) gives another
                      // full matrix (symbolizable as nullptr).
 
                      // So if existing_it->second is a temporary then
                      // we don't need it anymore; we might as well
                      // remove it to keep the set of temporaries
                      // small.
                      if (const auto temp_it = temporary_coupling_matrices.find(existing_it->second);
                          temp_it != temporary_coupling_matrices.end())
                        temporary_coupling_matrices.erase(temp_it);
 
                      existing_it->second = nullptr;
                    }
                }
              // else we have a nullptr already, then we have a full
              // coupling matrix, already, and merging with anything
              // else won't change that, so we're done.
            }
        }
    }
}

References libMesh::Elem::active(), libMesh::Elem::active_family_tree(), libMesh::as_range(), and libMesh::libmesh_assert().

Referenced by libMesh::SparsityPattern::Build::operator()(), and scatter_constraints().

n_components()

unsigned int libMesh::DofMap::n_components ( const MeshBase &  mesh ) const

inline

Returns

The total number of scalar components in the system's variables. This will equal n_vars() in the case of all scalar-valued variables. If vector variables are involved, we will need to leverage the mesh

Definition at line 2963 of file dof_map.h.

{
  if (_variables.empty())
    return 0;
 
  const Variable & last = _variables.back();
  return last.first_scalar_number() + last.n_components(mesh);
}

References _variables, libMesh::Variable::first_scalar_number(), mesh, and libMesh::Variable::n_components().

n_constrained_dofs()

dof_id_type libMesh::DofMap::n_constrained_dofs

(

)

const

Returns

The total number of constrained degrees of freedom in the problem.

Definition at line 1714 of file dof_map_constraints.C.

{
  parallel_object_only();
 
  dof_id_type nc_dofs = this->n_local_constrained_dofs();
  this->comm().sum(nc_dofs);
  return nc_dofs;
}

References libMesh::ParallelObject::comm(), n_local_constrained_dofs(), and libMesh::Parallel::Communicator::sum().

Referenced by libMesh::CondensedEigenSystem::initialize_condensed_dofs(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), and MeshInputTest::testDynaReadPatch().

n_constrained_nodes()

dof_id_type libMesh::DofMap::n_constrained_nodes ( ) const

inline

Returns

The total number of constrained Nodes in the mesh.

Definition at line 1059 of file dof_map.h.

  { return cast_int<dof_id_type>(_node_constraints.size()); }

References _node_constraints.

n_dofs() [1/2]

dof_id_type libMesh::DofMapBase::n_dofs ( ) const

inline

Returns

The total number of degrees of freedom in the problem.

Definition at line 105 of file dof_map_base.h.

{ return _n_dfs; }

Referenced by _dof_indices(), add_constraint_row(), and process_mesh_constraint_rows().

n_dofs() [2/2]

dof_id_type libMesh::DofMap::n_dofs ( const unsigned int  vn ) const

inline

Returns

The total number of degrees of freedom for a particular variable vn.

Definition at line 776 of file dof_map.h.

  {
    dof_id_type n = this->n_local_dofs(vn);
    this->comm().sum(n);
    return n;
  }

References libMesh::ParallelObject::comm(), n_local_dofs(), and libMesh::Parallel::Communicator::sum().

Referenced by libMesh::PetscDMWrapper::init_petscdm(), libMesh::StaticCondensation::m(), libMesh::UnsteadySolver::old_nonlinear_solution(), libMesh::SecondOrderUnsteadySolver::old_solution_accel(), libMesh::SecondOrderUnsteadySolver::old_solution_rate(), libMesh::System::solve_for_unconstrained_dofs(), SystemsTest::test100KVariables(), and DofMapTest::testDofOwner().

n_dofs_on_processor()

dof_id_type libMesh::DofMapBase::n_dofs_on_processor ( const processor_id_type  proc ) const

inlineinherited

Returns

The number of degrees of freedom on partition proc.

Definition at line 197 of file dof_map_base.h.

{
  libmesh_assert_less(proc, _first_df.size());
  return cast_int<dof_id_type>(_end_df[proc] - _first_df[proc]);
}

References libMesh::DofMapBase::_end_df, and libMesh::DofMapBase::_first_df.

Referenced by libMesh::DofMapBase::n_local_dofs(), and SystemsTest::testProjectMatrix3D().

n_dofs_per_processor()

std::vector< dof_id_type > libMesh::DofMap::n_dofs_per_processor ( const unsigned int  vn ) const

inline

Returns

The number of degrees of freedom on each partition for a particular variable vn.

Definition at line 805 of file dof_map.h.

  {
    std::vector<dof_id_type> n_local_dofs(this->n_processors(), 0);
    this->comm().allgather(this->n_local_dofs(vn), n_local_dofs);
    return n_local_dofs;
  }

References libMesh::Parallel::Communicator::allgather(), libMesh::ParallelObject::comm(), n_local_dofs(), and libMesh::ParallelObject::n_processors().

Referenced by libMesh::PetscPreconditioner< T >::set_hypre_ads_data(), libMesh::PetscPreconditioner< T >::set_hypre_ams_data(), and SystemsTest::test100KVariables().

n_local_constrained_dofs()

dof_id_type libMesh::DofMap::n_local_constrained_dofs

(

)

const

Returns

The number of constrained degrees of freedom on this processor.

Definition at line 1724 of file dof_map_constraints.C.

{
  const DofConstraints::const_iterator lower =
    _dof_constraints.lower_bound(this->first_dof()),
    upper =
    _dof_constraints.lower_bound(this->end_dof());
 
  return cast_int<dof_id_type>(std::distance(lower, upper));
}

References _dof_constraints, libMesh::DofMapBase::end_dof(), and libMesh::DofMapBase::first_dof().

Referenced by n_constrained_dofs().

n_local_dofs() [1/2]

dof_id_type libMesh::DofMapBase::n_local_dofs ( ) const

inline

Returns

The number of degrees of freedom on this processor.

Definition at line 115 of file dof_map_base.h.

{ return this->n_dofs_on_processor(this->processor_id()); }

Referenced by n_dofs(), n_dofs_per_processor(), and process_mesh_constraint_rows().

n_local_dofs() [2/2]

dof_id_type libMesh::DofMap::n_local_dofs ( const unsigned int  vn ) const

inline

Returns

The number of degrees of freedom on this processor for a particular variable vn. This is an O(N) operation on serialized or O(N/Nproc) operation on distributed meshes.

Definition at line 794 of file dof_map.h.

  {
    dof_id_type n;
    this->local_variable_indices(n, _mesh, vn);
    return n;
  }

References _mesh, and local_variable_indices().

Referenced by libMesh::PetscDMWrapper::build_sf(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::SparsityPattern::Build::join(), libMesh::SparsityPattern::Build::operator()(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::PetscPreconditioner< T >::set_hypre_ads_data(), libMesh::PetscPreconditioner< T >::set_hypre_ams_data(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::System::solve_for_unconstrained_dofs(), SystemsTest::testProjectMatrix1D(), and SystemsTest::testProjectMatrix2D().

n_objects()

static unsigned int libMesh::ReferenceCounter::n_objects ( )

inlinestaticinherited

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 85 of file reference_counter.h.

  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

n_old_dofs()

dof_id_type libMesh::DofMapBase::n_old_dofs ( ) const

inlineinherited

Returns

The total number of degrees of freedom on old_dof_objects

Definition at line 123 of file dof_map_base.h.

{ return _n_old_dfs; }

References libMesh::DofMapBase::_n_old_dfs.

Referenced by libMesh::BuildProjectionList::operator()().

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 103 of file parallel_object.h.

  {
    processor_id_type returnval =
      cast_int<processor_id_type>(_communicator.size());
    libmesh_assert(returnval); // We never have an empty comm
    return returnval;
  }

References libMesh::ParallelObject::_communicator, libMesh::libmesh_assert(), and libMesh::Parallel::Communicator::size().

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::Partitioner::build_graph(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::NumericVector< T >::is_effectively_ghosted(), libMesh::NumericVector< T >::is_effectively_serial(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshBase::n_active_elem_on_proc(), n_dofs_per_processor(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::MeshBase::print_constraint_rows(), print_dof_constraints(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::NameBasedIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), OverlappingFunctorTest::run_partitioner_test(), scatter_constraints(), libMesh::DistributedMesh::set_next_unique_id(), set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), WriteVecAndScalar::setupTests(), libMesh::RBEIMEvaluation::side_gather_bfs(), DistributedMeshTest::testRemoteElemError(), CheckpointIOTest::testSplitter(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

n_SCALAR_dofs()

dof_id_type libMesh::DofMap::n_SCALAR_dofs ( ) const

inline

Returns

The number of SCALAR dofs.

Definition at line 786 of file dof_map.h.

{ return _n_SCALAR_dofs; }

References _n_SCALAR_dofs.

Referenced by libMesh::PetscDMWrapper::set_point_range_in_section().

n_variable_groups()

unsigned int libMesh::DofMap::n_variable_groups ( ) const

inline

Returns

The number of variables in the global solution vector. Defaults to 1, should be 1 for a scalar equation, 3 for 2D incompressible Navier Stokes (u,v,p), etc...

Definition at line 733 of file dof_map.h.

  { return cast_int<unsigned int>(_variable_groups.size()); }

References _variable_groups.

Referenced by has_blocked_representation(), libMesh::StaticCondensationDofMap::reinit(), reinit(), and set_nonlocal_dof_objects().

n_variables()

unsigned int libMesh::DofMap::n_variables ( ) const

inlineoverridevirtual

Returns

The number of variables in the global solution vector. Defaults to 1, should be 1 for a scalar equation, 3 for 2D incompressible Navier Stokes (u,v,p), etc...

Implements libMesh::DofMapBase.

Definition at line 736 of file dof_map.h.

  { return cast_int<unsigned int>(_variables.size()); }

References _variables.

Referenced by block_size(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), create_dof_constraints(), DMlibMeshSetSystem_libMesh(), has_blocked_representation(), libMesh::SparsityPattern::Build::operator()(), process_mesh_constraint_rows(), and var_group_from_var_number().

n_vars()

unsigned int libMesh::DofMap::n_vars ( ) const

inline

Returns

The number of variables in the system

Definition at line 2937 of file dof_map.h.

{
  return cast_int<unsigned int>(_variables.size());
}

References _variables.

Referenced by allgather_recursive_constraints(), and create_dof_constraints().

node_constraint_rows_begin()

NodeConstraints::const_iterator libMesh::DofMap::node_constraint_rows_begin ( ) const

inline

Returns

An iterator pointing to the first Node constraint row.

Definition at line 1212 of file dof_map.h.

  { return _node_constraints.begin(); }

References _node_constraints.

node_constraint_rows_end()

NodeConstraints::const_iterator libMesh::DofMap::node_constraint_rows_end ( ) const

inline

Returns

An iterator pointing just past the last Node constraint row.

Definition at line 1218 of file dof_map.h.

  { return _node_constraints.end(); }

References _node_constraints.

node_ptr()

DofObject * libMesh::DofMap::node_ptr ( MeshBase &  mesh, dof_id_type  i  ) const

private

Returns

The Node pointer with index i from the mesh.

Definition at line 303 of file dof_map.C.

{
  return mesh.node_ptr(i);
}

References mesh.

old_dof_indices() [1/2]

void libMesh::DofMap::old_dof_indices	(	const Elem &	elem,
		unsigned int	n,
		std::vector< dof_id_type > &	di,
		const unsigned int	vn
	)		const

Appends to the vector di the old global degree of freedom indices for elem.node_ref(n), for one variable vn.

On hanging nodes with both vertex and non-vertex DoFs, only those indices which are directly supported on elem are included.

Definition at line 2478 of file dof_map.C.

{
  const DofObject & old_obj = elem.node_ref(n).get_old_dof_object_ref();
  this->_node_dof_indices(elem, n, old_obj, di, vn);
}

References libMesh::DofObject::get_old_dof_object_ref(), and libMesh::Elem::node_ref().

Referenced by libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::BuildProjectionList::operator()(), and libMesh::FEMContext::pre_fe_reinit().

old_dof_indices() [2/2]

void libMesh::DofMap::old_dof_indices	(	const Elem *const	elem,
		std::vector< dof_id_type > &	di,
		const unsigned int	vn = libMesh::invalid_uint
	)		const

After a mesh is refined and repartitioned it is possible that the _send_list will need to be augmented.

This is the case when an element is refined and its children end up on different processors than the parent. These children will need values from the parent when projecting the solution onto the refined mesh, hence the parent's DOF indices need to be included in the _send_list. Fills the vector di with the global degree of freedom indices for the element using the DofMap::old_dof_object. If no variable number is specified then all variables are returned.

Definition at line 2694 of file dof_map.C.

{
  // dof_indices() is a relatively light-weight function; the cost of
  // the logging code itself is roughly on par with the time required
  // to call dof_indices().
  // LOG_SCOPE("old_dof_indices()", "DofMap");
 
  libmesh_assert(elem);
 
  const ElemType type              = elem->type();
  const unsigned int sys_num       = this->sys_number();
  const unsigned int n_var_groups  = this->n_variable_groups();
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
  const bool is_inf                = elem->infinite();
#endif
 
  // If we have dof indices stored on the elem, and there's no chance
  // that we only have those indices because we were just p refined,
  // then we should have old dof indices too.
  libmesh_assert(!elem->has_dofs(sys_num) ||
                 elem->p_refinement_flag() == Elem::JUST_REFINED ||
                 elem->get_old_dof_object());
 
  // Clear the DOF indices vector.
  di.clear();
 
  // Determine the nodes contributing to element elem
  std::vector<const Node *> elem_nodes;
  const Node * const * nodes_ptr;
  unsigned int n_nodes;
  if (elem->type() == TRI3SUBDIVISION)
    {
      // Subdivision surface FE require the 1-ring around elem
      const Tri3Subdivision * sd_elem = static_cast<const Tri3Subdivision *>(elem);
      MeshTools::Subdivision::find_one_ring(sd_elem, elem_nodes);
      nodes_ptr = elem_nodes.data();
      n_nodes = cast_int<unsigned int>(elem_nodes.size());
    }
  else
    {
      // All other FE use only the nodes of elem itself
      nodes_ptr = elem->get_nodes();
      n_nodes = elem->n_nodes();
    }
 
  // Get the dof numbers
  for (unsigned int vg=0; vg<n_var_groups; vg++)
    {
      const VariableGroup & var = this->variable_group(vg);
      const unsigned int vars_in_group = var.n_variables();
 
      for (unsigned int vig=0; vig<vars_in_group; vig++)
        {
          const unsigned int v = var.number(vig);
          if ((vn == v) || (vn == libMesh::invalid_uint))
            {
              if (var.type().family == SCALAR &&
                  (!elem ||
                   var.active_on_subdomain(elem->subdomain_id())))
                {
                  // We asked for this variable, so add it to the vector.
                  std::vector<dof_id_type> di_new;
                  this->SCALAR_dof_indices(di_new,v,true);
                  di.insert( di.end(), di_new.begin(), di_new.end());
                }
              else
                if (var.active_on_subdomain(elem->subdomain_id()))
                  { // Do this for all the variables if one was not specified
                    // or just for the specified variable
 
                    FEType fe_type = var.type();
                    const bool add_p_level = fe_type.p_refinement;
 
                    // Increase the polynomial order on p refined elements,
                    // but make sure you get the right polynomial order for
                    // the OLD degrees of freedom
                    int p_adjustment = 0;
                    if (elem->p_refinement_flag() == Elem::JUST_REFINED)
                      {
                        libmesh_assert_greater (elem->p_level(), 0);
                        p_adjustment = -1;
                      }
                    else if (elem->p_refinement_flag() == Elem::JUST_COARSENED)
                      {
                        p_adjustment = 1;
                      }
                    p_adjustment *= add_p_level;
 
                    // Compute the net amount of "extra" order, including Elem::p_level()
                    int extra_order = int(add_p_level*elem->p_level()) + p_adjustment;
 
                    const bool extra_hanging_dofs =
                      FEInterface::extra_hanging_dofs(fe_type);
 
                    const FEInterface::n_dofs_at_node_ptr ndan =
                      FEInterface::n_dofs_at_node_function(fe_type, elem);
 
                    // Get the node-based DOF numbers
                    for (unsigned int n=0; n<n_nodes; n++)
                      {
                        const Node * node = nodes_ptr[n];
                        const DofObject & old_dof_obj = node->get_old_dof_object_ref();
 
                        // There is a potential problem with h refinement.  Imagine a
                        // quad9 that has a linear FE on it.  Then, on the hanging side,
                        // it can falsely identify a DOF at the mid-edge node. This is why
                        // we call FEInterface instead of node->n_comp() directly.
                        const unsigned int nc =
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
                          is_inf ?
                          FEInterface::n_dofs_at_node(var.type(), extra_order, elem, n) :
#endif
                          ndan (type, var.type().order + extra_order, n);
 
                        const int n_comp = old_dof_obj.n_comp_group(sys_num,vg);
 
                        // If this is a non-vertex on a hanging node with extra
                        // degrees of freedom, we use the non-vertex dofs (which
                        // come in reverse order starting from the end, to
                        // simplify p refinement)
                        if (extra_hanging_dofs && !elem->is_vertex(n))
                          {
                            const int dof_offset = n_comp - nc;
 
                            // We should never have fewer dofs than necessary on a
                            // node unless we're getting indices on a parent element
                            // or a just-coarsened element
                            if (dof_offset < 0)
                              {
                                libmesh_assert(!elem->active() || elem->refinement_flag() ==
                                               Elem::JUST_COARSENED);
                                di.resize(di.size() + nc, DofObject::invalid_id);
                              }
                            else
                              for (int i=n_comp-1; i>=dof_offset; i--)
                                {
                                  const dof_id_type d =
                                    old_dof_obj.dof_number(sys_num, vg, vig, i, n_comp);
 
                                  // On a newly-expanded subdomain, we
                                  // may have some DoFs that didn't
                                  // exist in the old system, in which
                                  // case we can't assert this:
                                  // libmesh_assert_not_equal_to (d, DofObject::invalid_id);
 
                                  di.push_back(d);
                                }
                          }
                        // If this is a vertex or an element without extra hanging
                        // dofs, our dofs come in forward order coming from the
                        // beginning.  But we still might not have all
                        // those dofs on the old_dof_obj, in cases
                        // where a subdomain-restricted variable just
                        // had its subdomain expanded.
                        else
                          {
                            const unsigned int old_nc =
                              std::min(static_cast<unsigned int>(n_comp), nc);
                            for (unsigned int i=0; i != old_nc; ++i)
                              {
                                const dof_id_type d =
                                  old_dof_obj.dof_number(sys_num, vg, vig, i, n_comp);
 
                                libmesh_assert_not_equal_to (d, DofObject::invalid_id);
 
                                di.push_back(d);
                              }
                            for (unsigned int i=old_nc; i != nc; ++i)
                              di.push_back(DofObject::invalid_id);
                          }
                      }
 
                    // If there are any element-based DOF numbers, get them
                    const unsigned int nc =
                      FEInterface::n_dofs_per_elem(fe_type, extra_order, elem);
 
                    if (nc != 0)
                      {
                        const DofObject & old_dof_obj = elem->get_old_dof_object_ref();
 
                        const unsigned int n_comp =
                          old_dof_obj.n_comp_group(sys_num,vg);
 
                        if (old_dof_obj.n_systems() > sys_num &&
                            nc <= n_comp)
                          {
 
                            for (unsigned int i=0; i<nc; i++)
                              {
                                const dof_id_type d =
                                  old_dof_obj.dof_number(sys_num, vg, vig, i, n_comp);
 
                                di.push_back(d);
                              }
                          }
                        else
                          {
                            // We should never have fewer dofs than
                            // necessary on an element unless we're
                            // getting indices on a parent element, a
                            // just-coarsened element ... or a
                            // subdomain-restricted variable with a
                            // just-expanded subdomain
                            // libmesh_assert(!elem->active() || fe_type.family == LAGRANGE ||
                            //                 elem->refinement_flag() == Elem::JUST_COARSENED);
                            di.resize(di.size() + nc, DofObject::invalid_id);
                          }
                      }
                  }
            }
        } // end loop over variables within group
    } // end loop over variable groups
}

References libMesh::Elem::active(), libMesh::Variable::active_on_subdomain(), libMesh::DofObject::dof_number(), libMesh::FEType::family, libMesh::Elem::get_nodes(), libMesh::DofObject::get_old_dof_object(), libMesh::DofObject::get_old_dof_object_ref(), libMesh::DofObject::has_dofs(), libMesh::Elem::infinite(), int, libMesh::invalid_uint, libMesh::Elem::is_vertex(), libMesh::libmesh_assert(), libMesh::DofObject::n_comp_group(), libMesh::Elem::n_nodes(), n_nodes, libMesh::DofObject::n_systems(), libMesh::VariableGroup::n_variables(), libMesh::VariableGroup::number(), libMesh::FEType::order, libMesh::Elem::p_level(), libMesh::FEType::p_refinement, libMesh::Elem::p_refinement_flag(), libMesh::Elem::refinement_flag(), libMesh::SCALAR, libMesh::Elem::subdomain_id(), libMesh::TRI3SUBDIVISION, libMesh::Variable::type(), and libMesh::Elem::type().

prepare_send_list()

void libMesh::DofMap::prepare_send_list

(

)

Takes the _send_list vector (which may have duplicate entries) and sorts it.

The duplicate entries are then removed, resulting in a sorted _send_list with unique entries. Also calls any user-provided methods for adding to the send list.

Definition at line 1835 of file dof_map.C.

{
  LOG_SCOPE("prepare_send_list()", "DofMap");
 
  // Return immediately if there's no ghost data
  if (this->n_processors() == 1)
    return;
 
  // Check to see if we have any extra stuff to add to the send_list
  if (_extra_send_list_function)
    {
      if (_augment_send_list)
        {
          libmesh_here();
          libMesh::out << "WARNING:  You have specified both an extra send list function and object.\n"
                       << "          Are you sure this is what you meant to do??"
                       << std::endl;
        }
 
      _extra_send_list_function(_send_list, _extra_send_list_context);
    }
 
  if (_augment_send_list)
    _augment_send_list->augment_send_list (_send_list);
 
  // First sort the send list.  After this
  // duplicated elements will be adjacent in the
  // vector
  std::sort(_send_list.begin(), _send_list.end());
 
  // Now use std::unique to remove duplicate entries
  std::vector<dof_id_type>::iterator new_end =
    std::unique (_send_list.begin(), _send_list.end());
 
  // Remove the end of the send_list.  Use the "swap trick"
  // from Effective STL
  std::vector<dof_id_type> (_send_list.begin(), new_end).swap (_send_list);
 
  // Make sure the send list has nothing invalid in it.
  libmesh_assert(_send_list.empty() || _send_list.back() < this->n_dofs());
}

References libMesh::libmesh_assert(), and libMesh::out.

Referenced by libMesh::PetscDMWrapper::init_petscdm(), and libMesh::System::reinit_constraints().

print_dof_constraints()

void libMesh::DofMap::print_dof_constraints	(	std::ostream &	os = libMesh::out,
		bool	print_nonlocal = false
	)		const

Prints (from processor 0) all DoF and Node constraints.

If print_nonlocal is true, then each constraint is printed once for each processor that knows about it, which may be useful for DistributedMesh debugging.

Definition at line 2253 of file dof_map_constraints.C.

{
  parallel_object_only();
 
  std::string local_constraints =
    this->get_local_constraints(print_nonlocal);
 
  if (this->processor_id())
    {
      this->comm().send(0, local_constraints);
    }
  else
    {
      os << "Processor 0:\n";
      os << local_constraints;
 
      for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
        {
          this->comm().receive(p, local_constraints);
          os << "Processor " << p << ":\n";
          os << local_constraints;
        }
    }
}

References libMesh::ParallelObject::comm(), get_local_constraints(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::Parallel::Communicator::receive(), and libMesh::Parallel::Communicator::send().

Referenced by main(), and libMesh::System::reinit_constraints().

print_info() [1/2]

void libMesh::DofMap::print_info

(

std::ostream &

os = libMesh::out

)

const

Prints summary info about the sparsity bandwidth and constraints.

Definition at line 2978 of file dof_map.C.

{
  os << this->get_info();
}

print_info() [2/2]

void libMesh::ReferenceCounter::print_info ( std::ostream &  out_stream = libMesh::out )

staticinherited

Prints the reference information, by default to libMesh::out.

Definition at line 81 of file reference_counter.C.

{
  if (_enable_print_counter)
    out_stream << ReferenceCounter::get_info();
}

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

Referenced by libMesh::LibMeshInit::~LibMeshInit().

process_constraints()

void libMesh::DofMap::process_constraints

(

MeshBase &

mesh

)

Postprocesses any constrained degrees of freedom to be constrained only in terms of unconstrained dofs, then adds unconstrained dofs to the send_list and prepares that for use.

This should be run after both system (create_dof_constraints) and user constraints have all been added.

Definition at line 4341 of file dof_map_constraints.C.

{
  // We've computed our local constraints, but they may depend on
  // non-local constraints that we'll need to take into account.
  this->allgather_recursive_constraints(mesh);
 
  if (_error_on_constraint_loop)
  {
    // Optionally check for constraint loops and throw an error
    // if they're detected. We always do this check below in dbg/devel
    // mode but here we optionally do it in opt mode as well.
    check_for_constraint_loops();
  }
 
  // Adjoints will be constrained where the primal is
  // Therefore, we will expand the adjoint_constraint_values
  // map whenever the primal_constraint_values map is expanded
 
  // First, figure out the total number of QoIs
  const unsigned int max_qoi_num =
    _adjoint_constraint_values.empty() ?
    0 : _adjoint_constraint_values.rbegin()->first+1;
 
  // Create a set containing the DOFs we already depend on
  typedef std::set<dof_id_type> RCSet;
  RCSet unexpanded_set;
 
  for (const auto & i : _dof_constraints)
    unexpanded_set.insert(i.first);
 
  while (!unexpanded_set.empty())
    for (RCSet::iterator i = unexpanded_set.begin();
         i != unexpanded_set.end(); /* nothing */)
      {
        // If the DOF is constrained
        DofConstraints::iterator
          pos = _dof_constraints.find(*i);
 
        libmesh_assert (pos != _dof_constraints.end());
 
        DofConstraintRow & constraint_row = pos->second;
 
        DofConstraintValueMap::iterator rhsit =
          _primal_constraint_values.find(*i);
        Number constraint_rhs = (rhsit == _primal_constraint_values.end()) ?
          0 : rhsit->second;
 
        // A vector of DofConstraintValueMaps for each adjoint variable
        std::vector<DofConstraintValueMap::iterator> adjoint_rhs_iterators;
        adjoint_rhs_iterators.resize(max_qoi_num);
 
        // Another to hold the adjoint constraint rhs
        std::vector<Number> adjoint_constraint_rhs(max_qoi_num, 0.0);
 
        // Find and gather recursive constraints for each adjoint variable
        for (auto & adjoint_map : _adjoint_constraint_values)
          {
            const std::size_t q = adjoint_map.first;
            adjoint_rhs_iterators[q] = adjoint_map.second.find(*i);
 
            adjoint_constraint_rhs[q] =
              (adjoint_rhs_iterators[q] == adjoint_map.second.end()) ?
              0 : adjoint_rhs_iterators[q]->second;
          }
 
        std::vector<dof_id_type> constraints_to_expand;
 
        for (const auto & item : constraint_row)
          if (item.first != *i && this->is_constrained_dof(item.first))
            {
              unexpanded_set.insert(item.first);
              constraints_to_expand.push_back(item.first);
            }
 
        for (const auto & expandable : constraints_to_expand)
          {
            const Real this_coef = constraint_row[expandable];
 
            DofConstraints::const_iterator
              subpos = _dof_constraints.find(expandable);
 
            libmesh_assert (subpos != _dof_constraints.end());
 
            const DofConstraintRow & subconstraint_row = subpos->second;
 
            for (const auto & item : subconstraint_row)
              {
                // Assert that the constraint does not form a cycle.
                libmesh_assert(item.first != expandable);
                constraint_row[item.first] += item.second * this_coef;
              }
 
            if (auto subrhsit = _primal_constraint_values.find(expandable);
                subrhsit != _primal_constraint_values.end())
              constraint_rhs += subrhsit->second * this_coef;
 
            // Find and gather recursive constraints for each adjoint variable
            for (const auto & adjoint_map : _adjoint_constraint_values)
              {
                if (auto adjoint_subrhsit = adjoint_map.second.find(expandable);
                    adjoint_subrhsit != adjoint_map.second.end())
                  adjoint_constraint_rhs[adjoint_map.first] += adjoint_subrhsit->second * this_coef;
              }
 
            constraint_row.erase(expandable);
          }
 
        if (rhsit == _primal_constraint_values.end())
          {
            if (constraint_rhs != Number(0))
              _primal_constraint_values[*i] = constraint_rhs;
            else
              _primal_constraint_values.erase(*i);
          }
        else
          {
            if (constraint_rhs != Number(0))
              rhsit->second = constraint_rhs;
            else
              _primal_constraint_values.erase(rhsit);
          }
 
        // Finally fill in the adjoint constraints for each adjoint variable if possible
        for (auto & adjoint_map : _adjoint_constraint_values)
          {
            const std::size_t q = adjoint_map.first;
 
            if(adjoint_rhs_iterators[q] == adjoint_map.second.end())
              {
                if (adjoint_constraint_rhs[q] != Number(0))
                   (adjoint_map.second)[*i] = adjoint_constraint_rhs[q];
                else
                  adjoint_map.second.erase(*i);
              }
            else
              {
                if (adjoint_constraint_rhs[q] != Number(0))
                  adjoint_rhs_iterators[q]->second = adjoint_constraint_rhs[q];
                else
                  adjoint_map.second.erase(adjoint_rhs_iterators[q]);
              }
          }
 
        if (constraints_to_expand.empty())
          i = unexpanded_set.erase(i);
        else
          ++i;
      }
 
  // In parallel we can't guarantee that nodes/dofs which constrain
  // others are on processors which are aware of that constraint, yet
  // we need such awareness for sparsity pattern generation.  So send
  // other processors any constraints they might need to know about.
  this->scatter_constraints(mesh);
 
  // Now that we have our root constraint dependencies sorted out, add
  // them to the send_list
  this->add_constraints_to_send_list();
}

References _adjoint_constraint_values, _dof_constraints, _error_on_constraint_loop, _primal_constraint_values, add_constraints_to_send_list(), allgather_recursive_constraints(), check_for_constraint_loops(), libMesh::libmesh_assert(), libMesh::Real, and scatter_constraints().

Referenced by libMesh::System::reinit_constraints().

process_mesh_constraint_rows()

void libMesh::DofMap::process_mesh_constraint_rows ( const MeshBase &  mesh )

private

Adds any spline constraints from the Mesh to our DoF constraints.

If any Dirichlet constraints exist on spline-constrained nodes, l2-projects those constraints onto the spline basis.

Definition at line 1898 of file dof_map_constraints.C.

{
  // If we already have simple Dirichlet constraints (with right hand
  // sides but with no coupling between DoFs) on spline-constrained FE
  // nodes, then we'll need a solve to compute the corresponding
  // constraints on the relevant spline nodes.  (If we already have
  // constraints with coupling between DoFs on spline-constrained FE
  // nodes, then we'll need to go sit down and cry until we figure out
  // how to handle that.)
 
  const auto & constraint_rows = mesh.get_constraint_rows();
 
  // This routine is too expensive to use unless we really might
  // need it
#ifdef DEBUG
  bool constraint_rows_empty = constraint_rows.empty();
  this->comm().min(constraint_rows_empty);
  libmesh_assert(!constraint_rows_empty);
#endif
 
  // We can't handle periodic boundary conditions on spline meshes
  // yet.
#ifdef LIBMESH_ENABLE_PERIODIC
  libmesh_error_msg_if (!_periodic_boundaries->empty(),
                        "Periodic boundary conditions are not yet implemented for spline meshes");
#endif
 
  // We can handle existing Dirichlet constraints, but we'll need
  // to do solves to project them down onto the spline basis.
  std::unique_ptr<SparsityPattern::Build> sp;
  std::unique_ptr<SparseMatrix<Number>> mat;
 
  const unsigned int n_adjoint_rhs =
    _adjoint_constraint_values.size();
 
  // [0] for primal rhs, [q+1] for adjoint qoi q
  std::vector<std::unique_ptr<NumericVector<Number>>>
    solve_rhs(n_adjoint_rhs+1);
 
  // Keep track of which spline DoFs will be Dirichlet.
  // We use a set here to make it easier to find what processors
  // to send the DoFs to later.
  std::set<dof_id_type> my_dirichlet_spline_dofs;
 
  // And keep track of which non-spline Dofs were Dirichlet
  std::unordered_set<dof_id_type> was_previously_constrained;
 
  const unsigned int sys_num = this->sys_number();
  for (auto & node_row : constraint_rows)
    {
      const Node * node = node_row.first;
      libmesh_assert(node == mesh.node_ptr(node->id()));
 
      // Each processor only computes its own (and in distributed
      // cases, is only guaranteed to have the dependency data to
      // compute its own) constraints here.
      if (node->processor_id() != mesh.processor_id())
        continue;
 
      for (auto var_num : IntRange<unsigned int>(0, this->n_variables()))
        {
          const FEFamily & fe_family = this->variable_type(var_num).family;
 
          // constraint_rows only applies to nodal variables
          if (fe_family != LAGRANGE &&
              fe_family != RATIONAL_BERNSTEIN)
            continue;
 
          DofConstraintRow dc_row;
 
          const dof_id_type constrained_id =
            node->dof_number(sys_num, var_num, 0);
          for (const auto & [pr, val] : node_row.second)
            {
              const Elem * spline_elem = pr.first;
              libmesh_assert(spline_elem == mesh.elem_ptr(spline_elem->id()));
 
              const Node & spline_node =
                spline_elem->node_ref(pr.second);
 
              const dof_id_type spline_dof_id =
                spline_node.dof_number(sys_num, var_num, 0);
              dc_row[spline_dof_id] = val;
            }
 
          // See if we already have a constraint here.
          if (this->is_constrained_dof(constrained_id))
            {
              was_previously_constrained.insert(constrained_id);
 
              // Keep track of which spline DoFs will be
              // inheriting this non-spline DoF's constraints
              for (auto & row_entry : dc_row)
                my_dirichlet_spline_dofs.insert(row_entry.first);
 
              // If it wasn't a simple Dirichlet-type constraint
              // then I don't know what to do with it.  We'll make
              // this an assertion only because this should only
              // crop up with periodic boundary conditions, which
              // we've already made sure we don't have.
              libmesh_assert(_dof_constraints[constrained_id].empty());
            }
 
          // Add the constraint, replacing any previous, so we can
          // use the new constraint in setting up the solve below
          this->add_constraint_row(constrained_id, dc_row, false);
        }
    }
 
  // my_dirichlet_spline_dofs may now include DoFs whose owners
  // don't know they need to become spline DoFs!  We need to push
  // this data to them.
  if (this->comm().size() > 1)
    {
      std::unordered_map
        <processor_id_type, std::vector<dof_id_type>>
        their_dirichlet_spline_dofs;
 
      // If we ever change the underlying container here then we'd
      // better do some kind of sort before using it; we'll rely
      // on sorting to make the processor id lookup efficient.
      libmesh_assert(std::is_sorted(my_dirichlet_spline_dofs.begin(),
                                    my_dirichlet_spline_dofs.end()));
      processor_id_type destination_pid = 0;
      for (auto d : my_dirichlet_spline_dofs)
        {
          libmesh_assert_less(d, this->end_dof(this->comm().size()-1));
          while (d >= this->end_dof(destination_pid))
            destination_pid++;
 
          if (destination_pid != this->processor_id())
            their_dirichlet_spline_dofs[destination_pid].push_back(d);
        }
 
      auto receive_dof_functor =
        [& my_dirichlet_spline_dofs]
        (processor_id_type,
         const std::vector<dof_id_type> & dofs)
        {
          my_dirichlet_spline_dofs.insert(dofs.begin(), dofs.end());
        };
 
      Parallel::push_parallel_vector_data
        (this->comm(), their_dirichlet_spline_dofs, receive_dof_functor);
    }
 
 
  // If anyone had any prior constraints in effect, then we need
  // to convert them to constraints on the spline nodes.
  //
  // NOT simply testing prior_constraints here; maybe it turned
  // out that all our constraints were on non-spline-constrained
  // parts of a hybrid mesh?
  bool important_prior_constraints =
    !was_previously_constrained.empty();
  this->comm().max(important_prior_constraints);
 
  if (important_prior_constraints)
    {
      // Now that we have the spline constraints added, we can
      // finally construct a sparsity pattern that correctly
      // accounts for those constraints!
      mat = SparseMatrix<Number>::build(this->comm());
      for (auto q : IntRange<unsigned int>(0, n_adjoint_rhs+1))
        {
          solve_rhs[q] = NumericVector<Number>::build(this->comm());
          solve_rhs[q]->init(this->n_dofs(), this->n_local_dofs(),
                             false, PARALLEL);
        }
 
      // We need to compute our own sparsity pattern, to take into
      // account the particularly non-sparse rows that can be
      // created by the spline constraints we just added.
      mat->attach_dof_map(*this);
      sp = this->build_sparsity(mesh);
      mat->attach_sparsity_pattern(*sp);
      mat->init();
 
      for (auto & node_row : constraint_rows)
        {
          const Node * node = node_row.first;
          libmesh_assert(node == mesh.node_ptr(node->id()));
 
          for (auto var_num : IntRange<unsigned int>(0, this->n_variables()))
            {
              const FEFamily & fe_family = this->variable_type(var_num).family;
 
              // constraint_rows only applies to nodal variables
              if (fe_family != LAGRANGE &&
                  fe_family != RATIONAL_BERNSTEIN)
                continue;
 
              const dof_id_type constrained_id =
                node->dof_number(sys_num, var_num, 0);
 
              if (was_previously_constrained.count(constrained_id))
                {
                  for (auto q : IntRange<int>(0, n_adjoint_rhs+1))
                    {
                      DenseMatrix<Number> K(1,1);
                      DenseVector<Number> F(1);
                      std::vector<dof_id_type> dof_indices(1, constrained_id);
 
                      K(0,0) = 1;
 
                      DofConstraintValueMap & vals = q ?
                        _adjoint_constraint_values[q-1] :
                        _primal_constraint_values;
 
                      DofConstraintValueMap::const_iterator rhsit =
                        vals.find(constrained_id);
                      F(0) = (rhsit == vals.end()) ?  0 : rhsit->second;
 
                      // We no longer need any rhs values here directly.
                      if (rhsit != vals.end())
                        vals.erase(rhsit);
 
                      this->heterogeneously_constrain_element_matrix_and_vector
                        (K, F, dof_indices, false, q ? (q-1) : -1);
                      if (!q)
                        mat->add_matrix(K, dof_indices);
                      solve_rhs[q]->add_vector(F, dof_indices);
                    }
                }
            }
        }
 
      // Any DoFs that aren't part of any constraint, directly or
      // indirectly, need a diagonal term to make the matrix
      // here invertible.
      for (dof_id_type d : IntRange<dof_id_type>(this->first_dof(),
                                                 this->end_dof()))
        if (!was_previously_constrained.count(d) &&
            !my_dirichlet_spline_dofs.count(d))
          mat->add(d,d,1);
 
      // At this point, we're finally ready to solve for Dirichlet
      // constraint values on spline nodes.
      std::unique_ptr<LinearSolver<Number>> linear_solver =
        LinearSolver<Number>::build(this->comm());
 
      std::unique_ptr<NumericVector<Number>> projected_vals =
        NumericVector<Number>::build(this->comm());
 
      projected_vals->init(this->n_dofs(), this->n_local_dofs(),
                           false, PARALLEL);
 
      DofConstraintRow empty_row;
      for (auto sd : my_dirichlet_spline_dofs)
        if (this->local_index(sd))
          this->add_constraint_row(sd, empty_row);
 
      for (auto q : IntRange<unsigned int>(0, n_adjoint_rhs+1))
        {
          // FIXME: we don't have an EquationSystems here, but I'd
          // rather not hardcode these...
          const double tol = double(TOLERANCE * TOLERANCE);
          const unsigned int max_its = 5000;
 
          linear_solver->solve(*mat, *projected_vals,
                               *(solve_rhs[q]), tol, max_its);
 
          DofConstraintValueMap & vals = q ?
            _adjoint_constraint_values[q-1] :
            _primal_constraint_values;
 
          for (auto sd : my_dirichlet_spline_dofs)
            if (this->local_index(sd))
              {
                Number constraint_rhs = (*projected_vals)(sd);
 
                std::pair<DofConstraintValueMap::iterator, bool> rhs_it =
                  vals.emplace(sd, constraint_rhs);
                if (!rhs_it.second)
                  rhs_it.first->second = constraint_rhs;
              }
        }
    }
}

References _adjoint_constraint_values, _dof_constraints, _periodic_boundaries, _primal_constraint_values, add_constraint_row(), libMesh::LinearSolver< T >::build(), libMesh::SparseMatrix< T >::build(), libMesh::NumericVector< T >::build(), build_sparsity(), libMesh::ParallelObject::comm(), dof_indices(), libMesh::DofObject::dof_number(), libMesh::MeshBase::elem_ptr(), libMesh::DofMapBase::end_dof(), libMesh::FEType::family, libMesh::DofMapBase::first_dof(), libMesh::MeshBase::get_constraint_rows(), heterogeneously_constrain_element_matrix_and_vector(), libMesh::DofObject::id(), is_constrained_dof(), libMesh::LAGRANGE, libMesh::libmesh_assert(), local_index(), libMesh::Parallel::Communicator::max(), mesh, libMesh::Parallel::Communicator::min(), n_dofs(), n_local_dofs(), n_variables(), libMesh::MeshBase::node_ptr(), libMesh::Elem::node_ref(), libMesh::PARALLEL, libMesh::DofObject::processor_id(), libMesh::ParallelObject::processor_id(), TIMPI::push_parallel_vector_data(), libMesh::RATIONAL_BERNSTEIN, sys_number(), libMesh::TOLERANCE, and variable_type().

Referenced by create_dof_constraints().

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

  { return cast_int<processor_id_type>(_communicator.rank()); }

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::rank().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshFunction::check_found_elem(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMapBase::end_dof(), libMesh::DofMapBase::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMapBase::first_dof(), libMesh::DofMapBase::first_old_dof(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), get_local_constraints(), libMesh::MeshBase::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), HeatSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::SparsityPattern::Build::join(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), main(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::MeshBase::n_constraint_rows(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMapBase::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshBase::print_constraint_rows(), print_dof_constraints(), process_mesh_constraint_rows(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::XdrIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::NameBasedIO::read(), libMesh::EquationSystems::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::ExodusII_IO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::read_header(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DistributedMesh::set_next_unique_id(), set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::RBEIMEvaluation::side_gather_bfs(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolygonTest::test_write_and_read_pentagon(), MeshInputTest::testAbaqusRead(), MeshInputTest::testBadGmsh(), BoundaryInfoTest::testBoundaryIDs(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testGmshBCIDOverlap(), MeshInputTest::testGoodGmsh(), MeshInputTest::testGoodSTL(), MeshInputTest::testGoodSTLBinary(), BoundaryInfoTest::testInternalBoundary(), MeshInputTest::testLowOrderEdgeBlocks(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), BoundaryMeshSubdomainTest::testSingleSubdomain(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::NetGenMeshInterface::triangulate(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::XdrIO::write(), libMesh::NameBasedIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

reinit()

void libMesh::DofMap::reinit	(	MeshBase &	mesh,
		const std::map< const Node *, std::set< subdomain_id_type > > &	constraining_subdomains
	)

Reinitialize the underlying data structures conformal to the current mesh.

Definition at line 468 of file dof_map.C.

{
  libmesh_assert (mesh.is_prepared());
 
  LOG_SCOPE("reinit()", "DofMap");
 
  // This is the common case and we want to optimize for it
  const bool constraining_subdomains_empty =
    constraining_subdomains.empty();
 
  // We ought to reconfigure our default coupling functor.
  //
  // The user might have removed it from our coupling functors set,
  // but if so, who cares, this reconfiguration is cheap.
 
  // Avoid calling set_dof_coupling() with an empty/non-nullptr
  // _dof_coupling matrix which may happen when there are actually no
  // variables on the system.
  if (this->_dof_coupling && this->_dof_coupling->empty() && !this->n_variables())
    this->_dof_coupling = nullptr;
  _default_coupling->set_dof_coupling(this->_dof_coupling);
 
  // By default we may want 0 or 1 levels of coupling
  unsigned int standard_n_levels =
    this->use_coupled_neighbor_dofs(mesh);
  _default_coupling->set_n_levels
    (std::max(_default_coupling->n_levels(), standard_n_levels));
 
  // But we *don't* want to restrict to a CouplingMatrix unless the
  // user does so manually; the original libMesh behavior was to put
  // ghost indices on the send_list regardless of variable.
  //_default_evaluating->set_dof_coupling(this->_dof_coupling);
 
  const unsigned int
    sys_num      = this->sys_number(),
    n_var_groups = this->n_variable_groups();
 
  // The DofObjects need to know how many variable groups we have, and
  // how many variables there are in each group.
  std::vector<unsigned int> n_vars_per_group;  n_vars_per_group.reserve (n_var_groups);
 
  for (unsigned int vg=0; vg<n_var_groups; vg++)
    n_vars_per_group.push_back (this->variable_group(vg).n_variables());
 
#ifdef LIBMESH_ENABLE_AMR
 
  //------------------------------------------------------------
  // Clear the old_dof_objects for all the nodes
  // and elements so that we can overwrite them
  for (auto & node : mesh.node_ptr_range())
    {
      node->clear_old_dof_object();
      libmesh_assert (!node->get_old_dof_object());
    }
 
  Threads::parallel_for
    (mesh.element_stored_range(),
     [](const ElemRange & range)
     {
       for (Elem * elem : range)
         {
           elem->clear_old_dof_object();
           libmesh_assert (!elem->get_old_dof_object());
         }
     });
 
  //------------------------------------------------------------
  // Set the old_dof_objects for the elements that
  // weren't just created, if these old dof objects
  // had variables
  for (auto & elem : mesh.element_ptr_range())
    {
      // Skip the elements that were just refined
      if (elem->refinement_flag() == Elem::JUST_REFINED)
        continue;
 
      for (Node & node : elem->node_ref_range())
        if (node.get_old_dof_object() == nullptr)
          if (node.has_dofs(sys_num))
            node.set_old_dof_object();
 
      libmesh_assert (!elem->get_old_dof_object());
 
      if (elem->has_dofs(sys_num))
        elem->set_old_dof_object();
    }
 
#endif // #ifdef LIBMESH_ENABLE_AMR
 
 
  //------------------------------------------------------------
  // Then set the number of variables for each \p DofObject
  // equal to n_variables() for this system.  This will
  // handle new \p DofObjects that may have just been created
 
  // All the nodes
  for (auto & node : mesh.node_ptr_range())
    node->set_n_vars_per_group(sys_num, n_vars_per_group);
 
  // All the elements
  Threads::parallel_for
    (mesh.element_stored_range(),
     [sys_num, n_vars_per_group](const ElemRange & range)
     {
       for (Elem * elem : range)
         elem->set_n_vars_per_group(sys_num, n_vars_per_group);
     });
 
  // Zero _n_SCALAR_dofs, it will be updated below.
  this->_n_SCALAR_dofs = 0;
 
  //------------------------------------------------------------
  // Next allocate space for the DOF indices
  for (unsigned int vg=0; vg<n_var_groups; vg++)
    {
      const VariableGroup & vg_description = this->variable_group(vg);
 
      const unsigned int n_var_in_group = vg_description.n_variables();
      const FEType & base_fe_type        = vg_description.type();
 
      const bool add_p_level = base_fe_type.p_refinement;
 
      // Don't need to loop over elements for a SCALAR variable
      // Just increment _n_SCALAR_dofs
      if (base_fe_type.family == SCALAR)
        {
          this->_n_SCALAR_dofs += base_fe_type.order.get_order()*n_var_in_group;
          continue;
        }
 
      // This should be constant even on p-refined elements
      const bool extra_hanging_dofs =
        FEInterface::extra_hanging_dofs(base_fe_type);
 
      // For all the active elements, count vertex degrees of freedom.
      for (auto & elem : mesh.active_element_ptr_range())
        {
          libmesh_assert(elem);
 
          // Only number dofs connected to active elements on this
          // processor and only for variables which are active on on
          // this element's subdomain or which are active on the
          // subdomain of a node constrained by this node.
          const bool active_on_elem =
            vg_description.active_on_subdomain(elem->subdomain_id());
 
          // If there's no way we're active on this element then we're
          // done
          if (!active_on_elem && constraining_subdomains_empty)
            continue;
 
          FEType fe_type = base_fe_type;
 
          const ElemType type = elem->type();
 
          libmesh_error_msg_if(base_fe_type.order.get_order() >
                               int(FEInterface::max_order(base_fe_type,type)),
                               "ERROR: Finite element "
                               << Utility::enum_to_string(base_fe_type.family)
                               << " on geometric element "
                               << Utility::enum_to_string(type)
                               << "\nonly supports FEInterface::max_order = "
                               << FEInterface::max_order(base_fe_type,type)
                               << ", not fe_type.order = "
                               << base_fe_type.order);
 
#ifdef LIBMESH_ENABLE_AMR
          // Make sure we haven't done more p refinement than we can
          // handle
          if (base_fe_type.order + add_p_level*elem->p_level() >
              FEInterface::max_order(base_fe_type, type))
            {
#  ifdef DEBUG
              libMesh::err << "WARNING: Finite element "
                           << Utility::enum_to_string(base_fe_type.family)
                           << " on geometric element "
                           << Utility::enum_to_string(type) << std::endl
                           << "could not be p refined past FEInterface::max_order = "
                           << FEInterface::max_order(base_fe_type,type)
                           << std::endl;
#  endif
              elem->set_p_level(int(FEInterface::max_order(base_fe_type,type))
                                - int(base_fe_type.order));
            }
#endif
 
          // Allocate the vertex DOFs
          for (auto n : elem->node_index_range())
            {
              Node & node = elem->node_ref(n);
 
              // If we're active on the element then we're active on
              // its nodes.  If we're not then we might *still* be
              // active on particular constraining nodes.
              bool active_on_node = active_on_elem;
              if (!active_on_node)
                if (auto it = constraining_subdomains.find(&node);
                    it != constraining_subdomains.end())
                  for (auto s : it->second)
                    if (vg_description.active_on_subdomain(s))
                      {
                        active_on_node = true;
                        break;
                      }
 
              if (!active_on_node)
                continue;
 
              if (elem->is_vertex(n))
                {
                  const unsigned int old_node_dofs =
                    node.n_comp_group(sys_num, vg);
 
                  const unsigned int vertex_dofs =
                    std::max(FEInterface::n_dofs_at_node(fe_type, elem, n, add_p_level),
                             old_node_dofs);
 
                  // Some discontinuous FEs have no vertex dofs
                  if (vertex_dofs > old_node_dofs)
                    {
                      node.set_n_comp_group(sys_num, vg,
                                            vertex_dofs);
 
                      // Abusing dof_number to set a "this is a
                      // vertex" flag
                      node.set_vg_dof_base(sys_num, vg,
                                           vertex_dofs);
 
                      // libMesh::out << "sys_num,vg,old_node_dofs,vertex_dofs="
                      //       << sys_num << ","
                      //       << vg << ","
                      //       << old_node_dofs << ","
                      //       << vertex_dofs << '\n',
                      // node.debug_buffer();
 
                      // libmesh_assert_equal_to (vertex_dofs, node.n_comp(sys_num, vg));
                      // libmesh_assert_equal_to (vertex_dofs, node.vg_dof_base(sys_num, vg));
                    }
                }
            }
        } // done counting vertex dofs
 
      // count edge & face dofs next
      for (auto & elem : mesh.active_element_ptr_range())
        {
          libmesh_assert(elem);
 
          // Only number dofs connected to active elements on this
          // processor and only for variables which are active on on
          // this element's subdomain or which are active on the
          // subdomain of a node constrained by this node.
          const bool active_on_elem =
            vg_description.active_on_subdomain(elem->subdomain_id());
 
          // If there's no way we're active on this element then we're
          // done
          if (!active_on_elem && constraining_subdomains_empty)
            continue;
 
          // Allocate the edge and face DOFs
          for (auto n : elem->node_index_range())
            {
              Node & node = elem->node_ref(n);
 
              // If we're active on the element then we're active on
              // its nodes.  If we're not then we might *still* be
              // active on particular constraining nodes.
              bool active_on_node = active_on_elem;
              if (!active_on_node)
                if (auto it = constraining_subdomains.find(&node);
                    it != constraining_subdomains.end())
                  for (auto s : it->second)
                    if (vg_description.active_on_subdomain(s))
                      {
                        active_on_node = true;
                        break;
                      }
 
              if (!active_on_node)
                continue;
 
              const unsigned int old_node_dofs =
                node.n_comp_group(sys_num, vg);
 
              const unsigned int vertex_dofs = old_node_dofs?
                cast_int<unsigned int>(node.vg_dof_base (sys_num,vg)):0;
 
              const unsigned int new_node_dofs =
                FEInterface::n_dofs_at_node(base_fe_type, elem, n, add_p_level);
 
              // We've already allocated vertex DOFs
              if (elem->is_vertex(n))
                {
                  libmesh_assert_greater_equal (old_node_dofs, vertex_dofs);
                  // //if (vertex_dofs < new_node_dofs)
                  //   libMesh::out << "sys_num,vg,old_node_dofs,vertex_dofs,new_node_dofs="
                  //                << sys_num << ","
                  //                << vg << ","
                  //                << old_node_dofs << ","
                  //                << vertex_dofs << ","
                  //                << new_node_dofs << '\n',
                  //     node.debug_buffer();
 
                  libmesh_assert_greater_equal (vertex_dofs,   new_node_dofs);
                }
              // We need to allocate the rest
              else
                {
                  // If this has no dofs yet, it needs no vertex
                  // dofs, so we just give it edge or face dofs
                  if (!old_node_dofs)
                    {
                      node.set_n_comp_group(sys_num, vg,
                                            new_node_dofs);
                      // Abusing dof_number to set a "this has no
                      // vertex dofs" flag
                      if (new_node_dofs)
                        node.set_vg_dof_base(sys_num, vg, 0);
                    }
 
                  // If this has dofs, but has no vertex dofs,
                  // it may still need more edge or face dofs if
                  // we're p-refined.
                  else if (vertex_dofs == 0)
                    {
                      if (new_node_dofs > old_node_dofs)
                        {
                          node.set_n_comp_group(sys_num, vg,
                                                new_node_dofs);
 
                          node.set_vg_dof_base(sys_num, vg,
                                               vertex_dofs);
                        }
                    }
                  // If this is another element's vertex,
                  // add more (non-overlapping) edge/face dofs if
                  // necessary
                  else if (extra_hanging_dofs)
                    {
                      if (new_node_dofs > old_node_dofs - vertex_dofs)
                        {
                          node.set_n_comp_group(sys_num, vg,
                                                vertex_dofs + new_node_dofs);
 
                          node.set_vg_dof_base(sys_num, vg,
                                               vertex_dofs);
                        }
                    }
                  // If this is another element's vertex, add any
                  // (overlapping) edge/face dofs if necessary
                  else
                    {
                      libmesh_assert_greater_equal (old_node_dofs, vertex_dofs);
                      if (new_node_dofs > old_node_dofs)
                        {
                          node.set_n_comp_group(sys_num, vg,
                                                new_node_dofs);
 
                          node.set_vg_dof_base (sys_num, vg,
                                                vertex_dofs);
                        }
                    }
                }
            }
          // Allocate the element DOFs
          const unsigned int dofs_per_elem =
            FEInterface::n_dofs_per_elem(base_fe_type, elem, add_p_level);
 
          elem->set_n_comp_group(sys_num, vg, dofs_per_elem);
 
        }
    } // end loop over variable groups
 
  // Calling DofMap::reinit() by itself makes little sense,
  // so we won't bother with nonlocal DofObjects.
  // Those will be fixed by distribute_dofs
 
  //------------------------------------------------------------
  // Finally, clear all the current DOF indices
  // (distribute_dofs expects them cleared!)
  this->invalidate_dofs(mesh);
}

References _default_coupling, _dof_coupling, libMesh::CouplingMatrix::empty(), libMesh::libmesh_assert(), mesh, n_variable_groups(), libMesh::Threads::parallel_for(), sys_number(), and use_coupled_neighbor_dofs().

Referenced by libMesh::HPCoarsenTest::add_projection().

reinit_send_list()

void libMesh::DofMap::reinit_send_list

(

MeshBase &

mesh

)

Clears the _send_list vector and then rebuilds it.

This may be needed in special situations, for example when an algebraic coupling functor cannot be added to the DofMap until after it is completely setup. Then this method can be used to rebuild the send_list once the algebraic coupling functor is added. Note that while this will recommunicate constraints with the updated send_list, this does assume no new constraints have been added since the previous reinit_constraints call.

Definition at line 1877 of file dof_map.C.

{
  this->clear_send_list();
  this->add_neighbors_to_send_list(mesh);
 
#ifdef LIBMESH_ENABLE_CONSTRAINTS
  // This is assuming that we only need to recommunicate
  // the constraints and no new ones have been added since
  // a previous call to reinit_constraints.
  this->process_constraints(mesh);
#endif
  this->prepare_send_list();
}

References mesh.

Referenced by OverlappingAlgebraicGhostingTest::run_ghosting_test(), and OverlappingCouplingGhostingTest::run_sparsity_pattern_test().

reinit_static_condensation()

void libMesh::DofMap::reinit_static_condensation

(

)

Calls reinit on the static condensation map if it exists.

Definition at line 3140 of file dof_map.C.

{
  if (_sc)
    _sc->reinit();
}

Referenced by libMesh::System::reinit().

remove_adjoint_dirichlet_boundary()

void libMesh::DofMap::remove_adjoint_dirichlet_boundary	(	const DirichletBoundary &	dirichlet_boundary,
		unsigned int	q
	)

Removes from the system the specified Dirichlet boundary for the adjoint equation defined by Quantity of interest index q.

Definition at line 5499 of file dof_map_constraints.C.

{
  libmesh_assert_greater(_adjoint_dirichlet_boundaries.size(),
                         qoi_index);
 
  auto lam = [&boundary_to_remove](const auto & bdy)
    {return bdy->b == boundary_to_remove.b && bdy->variables == boundary_to_remove.variables;};
 
  auto it = std::find_if(_adjoint_dirichlet_boundaries[qoi_index]->begin(),
                         _adjoint_dirichlet_boundaries[qoi_index]->end(),
                         lam);
 
  // Assert it was actually found and remove it from the vector
  libmesh_assert (it != _adjoint_dirichlet_boundaries[qoi_index]->end());
  _adjoint_dirichlet_boundaries[qoi_index]->erase(it);
}

References _adjoint_dirichlet_boundaries, libMesh::DirichletBoundary::b, libMesh::libmesh_assert(), and libMesh::DirichletBoundary::variables.

remove_algebraic_ghosting_functor()

void libMesh::DofMap::remove_algebraic_ghosting_functor

(

GhostingFunctor &

evaluable_functor

)

Removes a functor which was previously added to the set of algebraic ghosting functors, from both this DofMap and from the underlying mesh.

Definition at line 2089 of file dof_map.C.

{
  auto raw_it = std::find(_algebraic_ghosting_functors.begin(),
                          _algebraic_ghosting_functors.end(),
                          &evaluable_functor);
 
#ifndef LIBMESH_ENABLE_DEPRECATED
  // We shouldn't be trying to remove a functor that isn't there
  libmesh_assert(raw_it != _algebraic_ghosting_functors.end());
#else
  // Our old API supported trying to remove a functor that isn't there
  if (raw_it != _algebraic_ghosting_functors.end())
#endif
    _algebraic_ghosting_functors.erase(raw_it);
 
  // We shouldn't have had two copies of the same functor
  libmesh_assert(std::find(_algebraic_ghosting_functors.begin(),
                           _algebraic_ghosting_functors.end(),
                           &evaluable_functor) ==
                 _algebraic_ghosting_functors.end());
 
  _mesh.remove_ghosting_functor(evaluable_functor);
 
  if (const auto it = _shared_functors.find(&evaluable_functor);
      it != _shared_functors.end())
    _shared_functors.erase(it);
}

References libMesh::libmesh_assert().

Referenced by PointNeighborCouplingTest::testCoupling().

remove_coupling_functor()

void libMesh::DofMap::remove_coupling_functor

(

GhostingFunctor &

coupling_functor

)

Removes a functor which was previously added to the set of coupling functors, from both this DofMap and from the underlying mesh.

Definition at line 2032 of file dof_map.C.

{
  auto raw_it = std::find(_coupling_functors.begin(),
                          _coupling_functors.end(), &coupling_functor);
 
#ifndef LIBMESH_ENABLE_DEPRECATED
  // We shouldn't be trying to remove a functor that isn't there
  libmesh_assert(raw_it != _coupling_functors.end());
#else
  // Our old API supported trying to remove a functor that isn't there
  if (raw_it != _coupling_functors.end())
#endif
    _coupling_functors.erase(raw_it);
 
  // We shouldn't have had two copies of the same functor
  libmesh_assert(std::find(_coupling_functors.begin(),
                           _coupling_functors.end(),
                           &coupling_functor) ==
                 _coupling_functors.end());
 
  _mesh.remove_ghosting_functor(coupling_functor);
 
  if (const auto it = _shared_functors.find(&coupling_functor);
      it != _shared_functors.end())
    _shared_functors.erase(it);
}

References libMesh::libmesh_assert().

Referenced by PointNeighborCouplingTest::testCoupling().

remove_default_ghosting()

void libMesh::DofMap::remove_default_ghosting

(

)

Remove any default ghosting functor(s).

User-added ghosting functors will be unaffected.

Unless user-added equivalent ghosting functors exist, removing the default coupling functor is only safe for explicit solves, and removing the default algebraic ghosting functor is only safe for codes where no evaluations on neighbor cells (e.g. no jump error estimators) are done.

Defaults can be restored manually via add_default_ghosting(), or automatically if clear() returns the DofMap to a default state.

Definition at line 1988 of file dof_map.C.

{
  this->remove_coupling_functor(this->default_coupling());
  this->remove_algebraic_ghosting_functor(this->default_algebraic_ghosting());
}

Referenced by libMesh::EquationSystems::enable_default_ghosting().

remove_dirichlet_boundary()

void libMesh::DofMap::remove_dirichlet_boundary

(

const DirichletBoundary &

dirichlet_boundary

)

Removes the specified Dirichlet boundary from the system.

Definition at line 5485 of file dof_map_constraints.C.

{
  // Find a boundary condition matching the one to be removed
  auto lam = [&boundary_to_remove](const auto & bdy)
    {return bdy->b == boundary_to_remove.b && bdy->variables == boundary_to_remove.variables;};
 
  auto it = std::find_if(_dirichlet_boundaries->begin(), _dirichlet_boundaries->end(), lam);
 
  // Assert it was actually found and remove it from the vector
  libmesh_assert (it != _dirichlet_boundaries->end());
  _dirichlet_boundaries->erase(it);
}

References _dirichlet_boundaries, libMesh::DirichletBoundary::b, libMesh::libmesh_assert(), and libMesh::DirichletBoundary::variables.

SCALAR_dof_indices()

void libMesh::DofMap::SCALAR_dof_indices	(	std::vector< dof_id_type > &	di,
		const unsigned int	vn,
		const bool	old_dofs = false
	)		const

Fills the vector di with the global degree of freedom indices corresponding to the SCALAR variable vn.

If old_dofs=true, the old SCALAR dof indices are returned.

Note

We do not need to pass in an element since SCALARs are global variables.

Definition at line 2605 of file dof_map.C.

{
  // dof_indices() is a relatively light-weight function; the cost of
  // the logging code itself is roughly on par with the time required
  // to call dof_indices().
  // LOG_SCOPE("SCALAR_dof_indices()", "DofMap");
 
  libmesh_assert(this->variable(vn).type().family == SCALAR);
 
#ifdef LIBMESH_ENABLE_AMR
  // If we're asking for old dofs then we'd better have some
  if (old_dofs)
    libmesh_assert_greater_equal(n_old_dofs(), n_SCALAR_dofs());
 
  dof_id_type my_idx = old_dofs ?
    this->_first_old_scalar_df[vn] : this->_first_scalar_df[vn];
#else
  dof_id_type my_idx = this->_first_scalar_df[vn];
#endif
 
  libmesh_assert_not_equal_to(my_idx, DofObject::invalid_id);
 
  // The number of SCALAR dofs comes from the variable order
  const int n_dofs_vn = this->variable(vn).type().order.get_order();
 
  di.resize(n_dofs_vn);
  for (int i = 0; i != n_dofs_vn; ++i)
    di[i] = my_idx++;
}

References libMesh::libmesh_assert(), and libMesh::SCALAR.

Referenced by libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), dof_indices(), libMesh::System::project_vector(), libMesh::System::project_vector(), libMesh::System::projection_matrix(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::StaticCondensationDofMap::reinit(), SystemsTest::testProjectScalarCoarsening(), libMesh::Nemesis_IO_Helper::write_nodal_solution(), libMesh::System::write_parallel_data(), and libMesh::System::write_SCALAR_dofs().

scatter_constraints()

void libMesh::DofMap::scatter_constraints

(

MeshBase &

mesh

)

Sends constraint equations to constraining processors.

Definition at line 4607 of file dof_map_constraints.C.

{
  // At this point each processor with a constrained node knows
  // the corresponding constraint row, but we also need each processor
  // with a constrainer node to know the corresponding row(s).
 
  // This function must be run on all processors at once
  parallel_object_only();
 
  // Return immediately if there's nothing to gather
  if (this->n_processors() == 1)
    return;
 
  // We might get to return immediately if none of the processors
  // found any constraints
  unsigned int has_constraints = !_dof_constraints.empty()
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
    || !_node_constraints.empty()
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
    ;
  this->comm().max(has_constraints);
  if (!has_constraints)
    return;
 
  // We may be receiving packed_range sends out of order with
  // parallel_sync tags, so make sure they're received correctly.
  Parallel::MessageTag range_tag = this->comm().get_unique_tag();
 
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  std::map<processor_id_type, std::set<dof_id_type>> pushed_node_ids;
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
 
  std::map<processor_id_type, std::set<dof_id_type>> pushed_ids;
 
  // Collect the dof constraints I need to push to each processor
  dof_id_type constrained_proc_id = 0;
  for (const auto & [constrained, row] : _dof_constraints)
    {
      while (constrained >= _end_df[constrained_proc_id])
        constrained_proc_id++;
 
      if (constrained_proc_id != this->processor_id())
        continue;
 
      for (auto & j : row)
        {
          const dof_id_type constraining = j.first;
 
          processor_id_type constraining_proc_id = 0;
          while (constraining >= _end_df[constraining_proc_id])
            constraining_proc_id++;
 
          if (constraining_proc_id != this->processor_id() &&
              constraining_proc_id != constrained_proc_id)
            pushed_ids[constraining_proc_id].insert(constrained);
        }
    }
 
  // Pack the dof constraint rows and rhs's to push
 
  std::map<processor_id_type,
          std::vector<std::vector<std::pair<dof_id_type, Real>>>>
    pushed_keys_vals, pushed_keys_vals_to_me;
 
  std::map<processor_id_type, std::vector<std::pair<dof_id_type, Number>>>
    pushed_ids_rhss, pushed_ids_rhss_to_me;
 
  auto gather_ids =
    [this,
     & pushed_ids,
     & pushed_keys_vals,
     & pushed_ids_rhss]
    ()
    {
      for (const auto & [pid, pid_ids] : pushed_ids)
        {
          const std::size_t ids_size = pid_ids.size();
          std::vector<std::vector<std::pair<dof_id_type, Real>>> &
            keys_vals = pushed_keys_vals[pid];
          std::vector<std::pair<dof_id_type,Number>> &
            ids_rhss = pushed_ids_rhss[pid];
          keys_vals.resize(ids_size);
          ids_rhss.resize(ids_size);
 
          std::size_t push_i;
          std::set<dof_id_type>::const_iterator it;
          for (push_i = 0, it = pid_ids.begin();
               it != pid_ids.end(); ++push_i, ++it)
            {
              const dof_id_type constrained = *it;
              DofConstraintRow & row = _dof_constraints[constrained];
              keys_vals[push_i].assign(row.begin(), row.end());
 
              DofConstraintValueMap::const_iterator rhsit =
                _primal_constraint_values.find(constrained);
              ids_rhss[push_i].first = constrained;
              ids_rhss[push_i].second =
                (rhsit == _primal_constraint_values.end()) ?
                0 : rhsit->second;
            }
        }
    };
 
  gather_ids();
 
  auto ids_rhss_action_functor =
    [& pushed_ids_rhss_to_me]
    (processor_id_type pid,
     const std::vector<std::pair<dof_id_type, Number>> & data)
    {
      pushed_ids_rhss_to_me[pid] = data;
    };
 
  auto keys_vals_action_functor =
    [& pushed_keys_vals_to_me]
    (processor_id_type pid,
     const std::vector<std::vector<std::pair<dof_id_type, Real>>> & data)
    {
      pushed_keys_vals_to_me[pid] = data;
    };
 
  Parallel::push_parallel_vector_data
    (this->comm(), pushed_ids_rhss, ids_rhss_action_functor);
  Parallel::push_parallel_vector_data
    (this->comm(), pushed_keys_vals, keys_vals_action_functor);
 
  // Now work on traded dof constraint rows
  auto receive_dof_constraints =
    [this,
     & pushed_ids_rhss_to_me,
     & pushed_keys_vals_to_me]
    ()
    {
      for (const auto & [pid, ids_rhss] : pushed_ids_rhss_to_me)
        {
          const auto & keys_vals = pushed_keys_vals_to_me[pid];
 
          libmesh_assert_equal_to
            (ids_rhss.size(), keys_vals.size());
 
          // Add the dof constraints that I've been sent
          for (auto i : index_range(ids_rhss))
            {
              dof_id_type constrained = ids_rhss[i].first;
 
              // If we don't already have a constraint for this dof,
              // add the one we were sent
              if (!this->is_constrained_dof(constrained))
                {
                  DofConstraintRow & row = _dof_constraints[constrained];
                  for (auto & key_val : keys_vals[i])
                    {
                      libmesh_assert_less(key_val.first, this->n_dofs());
                      row[key_val.first] = key_val.second;
                    }
                  if (ids_rhss[i].second != Number(0))
                    _primal_constraint_values[constrained] =
                      ids_rhss[i].second;
                  else
                    _primal_constraint_values.erase(constrained);
                }
            }
        }
    };
 
  receive_dof_constraints();
 
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  // Collect the node constraints to push to each processor
  for (auto & i : _node_constraints)
    {
      const Node * constrained = i.first;
 
      if (constrained->processor_id() != this->processor_id())
        continue;
 
      NodeConstraintRow & row = i.second.first;
      for (auto & j : row)
        {
          const Node * constraining = j.first;
 
          if (constraining->processor_id() != this->processor_id() &&
              constraining->processor_id() != constrained->processor_id())
            pushed_node_ids[constraining->processor_id()].insert(constrained->id());
        }
    }
 
  // Pack the node constraint rows and rhss to push
  std::map<processor_id_type,
          std::vector<std::vector<std::pair<dof_id_type,Real>>>>
    pushed_node_keys_vals, pushed_node_keys_vals_to_me;
  std::map<processor_id_type, std::vector<std::pair<dof_id_type, Point>>>
    pushed_node_ids_offsets, pushed_node_ids_offsets_to_me;
  std::map<processor_id_type, std::vector<const Node *>> pushed_node_vecs;
 
  for (const auto & [pid, pid_ids]: pushed_node_ids)
    {
      const std::size_t ids_size = pid_ids.size();
      std::vector<std::vector<std::pair<dof_id_type,Real>>> &
        keys_vals = pushed_node_keys_vals[pid];
      std::vector<std::pair<dof_id_type, Point>> &
        ids_offsets = pushed_node_ids_offsets[pid];
      keys_vals.resize(ids_size);
      ids_offsets.resize(ids_size);
      std::set<Node *> nodes;
 
      std::size_t push_i;
      std::set<dof_id_type>::const_iterator it;
      for (push_i = 0, it = pid_ids.begin();
           it != pid_ids.end(); ++push_i, ++it)
        {
          Node * constrained = mesh.node_ptr(*it);
 
          if (constrained->processor_id() != pid)
            nodes.insert(constrained);
 
          NodeConstraintRow & row = _node_constraints[constrained].first;
          std::size_t row_size = row.size();
          keys_vals[push_i].reserve(row_size);
          for (const auto & j : row)
            {
              Node * constraining = const_cast<Node *>(j.first);
 
              keys_vals[push_i].emplace_back(constraining->id(), j.second);
 
              if (constraining->processor_id() != pid)
                nodes.insert(constraining);
            }
 
          ids_offsets[push_i].first = *it;
          ids_offsets[push_i].second = _node_constraints[constrained].second;
        }
 
      if (!mesh.is_serial())
        {
          auto & pid_nodes = pushed_node_vecs[pid];
          pid_nodes.assign(nodes.begin(), nodes.end());
        }
    }
 
  auto node_ids_offsets_action_functor =
    [& pushed_node_ids_offsets_to_me]
    (processor_id_type pid,
     const std::vector<std::pair<dof_id_type, Point>> & data)
    {
      pushed_node_ids_offsets_to_me[pid] = data;
    };
 
  auto node_keys_vals_action_functor =
    [& pushed_node_keys_vals_to_me]
    (processor_id_type pid,
     const std::vector<std::vector<std::pair<dof_id_type, Real>>> & data)
    {
      pushed_node_keys_vals_to_me[pid] = data;
    };
 
  // Trade pushed node constraint rows
  Parallel::push_parallel_vector_data
    (this->comm(), pushed_node_ids_offsets, node_ids_offsets_action_functor);
  Parallel::push_parallel_vector_data
    (this->comm(), pushed_node_keys_vals, node_keys_vals_action_functor);
 
  // Constraining nodes might not even exist on our subset of a
  // distributed mesh, so let's make them exist.
 
  // Node unpack() now automatically adds them to the context mesh
  auto null_node_functor = [](processor_id_type, const std::vector<const Node *> &){};
 
  if (!mesh.is_serial())
    Parallel::push_parallel_packed_range
      (this->comm(), pushed_node_vecs, &mesh, null_node_functor);
 
  for (const auto & [pid, ids_offsets] : pushed_node_ids_offsets_to_me)
    {
      const auto & keys_vals = pushed_node_keys_vals_to_me[pid];
 
      libmesh_assert_equal_to
        (ids_offsets.size(), keys_vals.size());
 
      // Add the node constraints that I've been sent
      for (auto i : index_range(ids_offsets))
        {
          dof_id_type constrained_id = ids_offsets[i].first;
 
          // If we don't already have a constraint for this node,
          // add the one we were sent
          const Node * constrained = mesh.node_ptr(constrained_id);
          if (!this->is_constrained_node(constrained))
            {
              NodeConstraintRow & row = _node_constraints[constrained].first;
              for (auto & key_val : keys_vals[i])
                {
                  const Node * key_node = mesh.node_ptr(key_val.first);
                  row[key_node] = key_val.second;
                }
              _node_constraints[constrained].second =
                ids_offsets[i].second;
            }
        }
    }
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
 
  // Next we need to push constraints to processors which don't own
  // the constrained dof, don't own the constraining dof, but own an
  // element supporting the constraining dof.
  //
  // We need to be able to quickly look up constrained dof ids by what
  // constrains them, so that we can handle the case where we see a
  // foreign element containing one of our constraining DoF ids and we
  // need to push that constraint.
  //
  // Getting distributed adaptive sparsity patterns right is hard.
 
  typedef std::map<dof_id_type, std::set<dof_id_type>> DofConstrainsMap;
  DofConstrainsMap dof_id_constrains;
 
  for (const auto & [constrained, row] : _dof_constraints)
    {
      for (const auto & j : row)
        {
          const dof_id_type constraining = j.first;
 
          dof_id_type constraining_proc_id = 0;
          while (constraining >= _end_df[constraining_proc_id])
            constraining_proc_id++;
 
          if (constraining_proc_id == this->processor_id())
            dof_id_constrains[constraining].insert(constrained);
        }
    }
 
  // Loop over all foreign elements, find any supporting our
  // constrained dof indices.
  pushed_ids.clear();
 
  for (const auto & elem : as_range(mesh.active_not_local_elements_begin(),
                                    mesh.active_not_local_elements_end()))
    {
      std::vector<dof_id_type> my_dof_indices;
      this->dof_indices (elem, my_dof_indices);
 
      for (const auto & dof : my_dof_indices)
        {
          if (auto dcmi = dof_id_constrains.find(dof);
              dcmi != dof_id_constrains.end())
            {
              for (const auto & constrained : dcmi->second)
                {
                  dof_id_type the_constrained_proc_id = 0;
                  while (constrained >= _end_df[the_constrained_proc_id])
                    the_constrained_proc_id++;
 
                  const processor_id_type elemproc = elem->processor_id();
                  if (elemproc != the_constrained_proc_id)
                    pushed_ids[elemproc].insert(constrained);
                }
            }
        }
    }
 
  pushed_ids_rhss.clear();
  pushed_ids_rhss_to_me.clear();
  pushed_keys_vals.clear();
  pushed_keys_vals_to_me.clear();
 
  gather_ids();
 
  // Trade pushed dof constraint rows
  Parallel::push_parallel_vector_data
    (this->comm(), pushed_ids_rhss, ids_rhss_action_functor);
  Parallel::push_parallel_vector_data
    (this->comm(), pushed_keys_vals, keys_vals_action_functor);
 
  receive_dof_constraints();
 
  // Finally, we need to handle the case of remote dof coupling.  If a
  // processor's element is coupled to a ghost element, then the
  // processor needs to know about all constraints which affect the
  // dofs on that ghost element, so we'll have to query the ghost
  // element's owner.
 
  GhostingFunctor::map_type elements_to_couple;
  DofMap::CouplingMatricesSet temporary_coupling_matrices;
 
  this->merge_ghost_functor_outputs
    (elements_to_couple,
     temporary_coupling_matrices,
     this->coupling_functors_begin(),
     this->coupling_functors_end(),
     mesh.active_local_elements_begin(),
     mesh.active_local_elements_end(),
     this->processor_id());
 
  // Each ghost-coupled element's owner should get a request for its dofs
  std::set<dof_id_type> requested_dofs;
 
  for (const auto & pr : elements_to_couple)
    {
      const Elem * elem = pr.first;
 
      // FIXME - optimize for the non-fully-coupled case?
      std::vector<dof_id_type> element_dofs;
      this->dof_indices(elem, element_dofs);
 
      for (auto dof : element_dofs)
        requested_dofs.insert(dof);
    }
 
  this->gather_constraints(mesh, requested_dofs, false);
}

References _dof_constraints, libMesh::DofMapBase::_end_df, _node_constraints, _primal_constraint_values, libMesh::as_range(), libMesh::ParallelObject::comm(), coupling_functors_begin(), coupling_functors_end(), dof_indices(), gather_constraints(), libMesh::Parallel::Communicator::get_unique_tag(), libMesh::DofObject::id(), libMesh::index_range(), is_constrained_dof(), is_constrained_node(), libMesh::MeshBase::is_serial(), libMesh::Parallel::Communicator::max(), merge_ghost_functor_outputs(), mesh, libMesh::ParallelObject::n_processors(), libMesh::MeshBase::node_ptr(), libMesh::DofObject::processor_id(), libMesh::ParallelObject::processor_id(), TIMPI::push_parallel_packed_range(), and TIMPI::push_parallel_vector_data().

Referenced by process_constraints().

semilocal_index()

bool libMesh::DofMap::semilocal_index

(

dof_id_type

dof_index

)

const

Returns

true if degree of freedom index dof_index is either a local index or in the send_list.

Note

This is an O(logN) operation for a send_list of size N; we don't cache enough information for O(1) right now.

Definition at line 2644 of file dof_map.C.

{
  // If it's not in the local indices
  if (!this->local_index(dof_index))
    {
      // and if it's not in the ghost indices, then we're not
      // semilocal
      if (!std::binary_search(_send_list.begin(), _send_list.end(), dof_index))
        return false;
    }
 
  return true;
}

set_constrained_sparsity_construction()

void libMesh::DofMap::set_constrained_sparsity_construction ( bool  use_constraints )

inline

Sets the current policy for constructing sparsity patterns: if use_constraints is true (for robustness), we explicitly account for sparsity entries created by constraint matrix pre- and post- application.

If use_constraints is false (for speed), we calculate only the sparsity pattern of an unconstrained matrix. This is false by default, because in nearly all applications our constraints do not increase the number of non-zeros required in a sparse matrix.

Definition at line 2541 of file dof_map.h.

{
  // This got only partly finished...
  if (use_constraints)
    libmesh_not_implemented();
 
#ifdef LIBMESH_ENABLE_CONSTRAINTS
  _constrained_sparsity_construction = use_constraints;
#endif
  libmesh_ignore(use_constraints);
}

References _constrained_sparsity_construction, and libMesh::libmesh_ignore().

set_error_on_constraint_loop()

void libMesh::DofMap::set_error_on_constraint_loop

(

bool

error_on_constraint_loop

)

Definition at line 234 of file dof_map.C.

{
  _error_on_constraint_loop = error_on_constraint_loop;
}

References _error_on_constraint_loop.

Referenced by set_error_on_cyclic_constraint(), and DofMapTest::testConstraintLoopDetection().

set_error_on_cyclic_constraint()

void libMesh::DofMap::set_error_on_cyclic_constraint

(

bool

error_on_cyclic_constraint

)

Specify whether or not we perform an extra (opt-mode enabled) check for constraint loops.

If a constraint loop is present then the system constraints are not valid, so if error_on_constraint_loop is true we will throw an error in this case.

Note

We previously referred to these types of constraints as "cyclic" but that has now been deprecated, and these will now instead be referred to as "constraint loops" in libMesh.

Definition at line 227 of file dof_map.C.

{
  // This function will eventually be officially libmesh_deprecated();
  // Call DofMap::set_error_on_constraint_loop() instead.
  set_error_on_constraint_loop(error_on_cyclic_constraint);
}

References set_error_on_constraint_loop().

set_implicit_neighbor_dofs()

void libMesh::DofMap::set_implicit_neighbor_dofs

(

bool

implicit_neighbor_dofs

)

Allow the implicit_neighbor_dofs flag to be set programmatically.

This overrides the –implicit_neighbor_dofs commandline option. We can use this to set the implicit neighbor dofs option differently for different systems, whereas the commandline option is the same for all systems.

Definition at line 1891 of file dof_map.C.

{
  _implicit_neighbor_dofs_initialized = true;
  _implicit_neighbor_dofs = implicit_neighbor_dofs;
}

Referenced by DisjointNeighborTest::testTempJump(), and DisjointNeighborTest::testTempJumpRefine().

set_nonlocal_dof_objects()

template<typename iterator_type >

void libMesh::DofMap::set_nonlocal_dof_objects ( iterator_type  objects_begin, iterator_type  objects_end, MeshBase &  mesh, dofobject_accessor  objects  )

private

Helper function for distributing dofs in parallel.

Definition at line 318 of file dof_map.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  // First, iterate over local objects to find out how many
  // are on each processor
  std::unordered_map<processor_id_type, dof_id_type> ghost_objects_from_proc;
 
  iterator_type it  = objects_begin;
 
  for (; it != objects_end; ++it)
    {
      DofObject * obj = *it;
 
      if (obj)
        {
          processor_id_type obj_procid = obj->processor_id();
          // We'd better be completely partitioned by now
          libmesh_assert_not_equal_to (obj_procid, DofObject::invalid_processor_id);
          ghost_objects_from_proc[obj_procid]++;
        }
    }
 
  // Request sets to send to each processor
  std::map<processor_id_type, std::vector<dof_id_type>>
    requested_ids;
 
  // We know how many of our objects live on each processor, so
  // reserve() space for requests from each.
  for (auto [p, size] : ghost_objects_from_proc)
    {
      if (p != this->processor_id())
        requested_ids[p].reserve(size);
    }
 
  for (it = objects_begin; it != objects_end; ++it)
    {
      DofObject * obj = *it;
      if (obj->processor_id() != DofObject::invalid_processor_id)
        requested_ids[obj->processor_id()].push_back(obj->id());
    }
#ifdef DEBUG
  for (auto p : make_range(this->n_processors()))
    {
      if (ghost_objects_from_proc.count(p))
        libmesh_assert_equal_to (requested_ids[p].size(), ghost_objects_from_proc[p]);
      else
        libmesh_assert(!requested_ids.count(p));
    }
#endif
 
  typedef std::vector<dof_id_type> datum;
 
  auto gather_functor =
    [this, &mesh, &objects]
    (processor_id_type,
     const std::vector<dof_id_type> & ids,
     std::vector<datum> & data)
    {
      // Fill those requests
      const unsigned int
        sys_num      = this->sys_number(),
        n_var_groups = this->n_variable_groups();
 
      const std::size_t query_size = ids.size();
 
      data.resize(query_size);
      for (auto & d : data)
        d.resize(2 * n_var_groups);
 
      for (std::size_t i=0; i != query_size; ++i)
        {
          DofObject * requested = (this->*objects)(mesh, ids[i]);
          libmesh_assert(requested);
          libmesh_assert_equal_to (requested->processor_id(), this->processor_id());
          libmesh_assert_equal_to (requested->n_var_groups(sys_num), n_var_groups);
          for (unsigned int vg=0; vg != n_var_groups; ++vg)
            {
              unsigned int n_comp_g =
                requested->n_comp_group(sys_num, vg);
              data[i][vg] = n_comp_g;
              dof_id_type my_first_dof = n_comp_g ?
                requested->vg_dof_base(sys_num, vg) : 0;
              libmesh_assert_not_equal_to (my_first_dof, DofObject::invalid_id);
              data[i][n_var_groups+vg] = my_first_dof;
            }
        }
    };
 
  auto action_functor =
    [this, &mesh, &objects]
    (processor_id_type libmesh_dbg_var(pid),
     const std::vector<dof_id_type> & ids,
     const std::vector<datum> & data)
    {
      const unsigned int
        sys_num      = this->sys_number(),
        n_var_groups = this->n_variable_groups();
 
      // Copy the id changes we've now been informed of
      for (auto i : index_range(ids))
        {
          DofObject * requested = (this->*objects)(mesh, ids[i]);
          libmesh_assert(requested);
          libmesh_assert_equal_to (requested->processor_id(), pid);
          for (unsigned int vg=0; vg != n_var_groups; ++vg)
            {
              unsigned int n_comp_g =
                cast_int<unsigned int>(data[i][vg]);
              requested->set_n_comp_group(sys_num, vg, n_comp_g);
              if (n_comp_g)
                {
                  dof_id_type my_first_dof = data[i][n_var_groups+vg];
                  libmesh_assert_not_equal_to (my_first_dof, DofObject::invalid_id);
                  requested->set_vg_dof_base
                    (sys_num, vg, my_first_dof);
                }
            }
        }
    };
 
  datum * ex = nullptr;
  Parallel::pull_parallel_vector_data
    (this->comm(), requested_ids, gather_functor, action_functor, ex);
 
#ifdef DEBUG
  // Double check for invalid dofs
  for (it = objects_begin; it != objects_end; ++it)
    {
      DofObject * obj = *it;
      libmesh_assert (obj);
      unsigned int num_variables = obj->n_vars(this->sys_number());
      for (unsigned int v=0; v != num_variables; ++v)
        {
          unsigned int n_comp =
            obj->n_comp(this->sys_number(), v);
          dof_id_type my_first_dof = n_comp ?
            obj->dof_number(this->sys_number(), v, 0) : 0;
          libmesh_assert_not_equal_to (my_first_dof, DofObject::invalid_id);
        }
    }
#endif
}

References libMesh::ParallelObject::comm(), libMesh::DofObject::dof_number(), libMesh::DofObject::id(), libMesh::index_range(), libMesh::DofObject::invalid_id, libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), libMesh::make_range(), mesh, libMesh::DofObject::n_comp(), libMesh::DofObject::n_comp_group(), libMesh::ParallelObject::n_processors(), libMesh::DofObject::n_var_groups(), n_variable_groups(), libMesh::DofObject::n_vars(), libMesh::DofObject::processor_id(), libMesh::ParallelObject::processor_id(), TIMPI::pull_parallel_vector_data(), libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_vg_dof_base(), sys_number(), and libMesh::DofObject::vg_dof_base().

set_verify_dirichlet_bc_consistency()

void libMesh::DofMap::set_verify_dirichlet_bc_consistency

(

bool

val

)

Set the _verify_dirichlet_bc_consistency flag.

Definition at line 1897 of file dof_map.C.

{
  _verify_dirichlet_bc_consistency = val;
}

should_p_refine() [1/6]

bool libMesh::DofMap::should_p_refine ( FEFamily  ) const

delete

should_p_refine() [2/6]

void libMesh::DofMap::should_p_refine ( FEFamily  , bool    )

delete

should_p_refine() [3/6]

bool libMesh::DofMap::should_p_refine ( Order  ) const

delete

should_p_refine() [4/6]

void libMesh::DofMap::should_p_refine ( Order  , bool    )

delete

should_p_refine() [5/6]

bool libMesh::DofMap::should_p_refine ( unsigned int  g ) const

inline

Whether the given variable group should be p-refined.

Definition at line 2588 of file dof_map.h.

{
#ifdef LIBMESH_ENABLE_AMR
  const VariableGroup & var = this->variable_group(g);
  return var.type().p_refinement;
#else
  libmesh_ignore(g);
  return false;
#endif
}

References libMesh::libmesh_ignore(), libMesh::FEType::p_refinement, libMesh::Variable::type(), and variable_group().

should_p_refine() [6/6]

void libMesh::DofMap::should_p_refine ( unsigned int  g, bool  p_refine  )

inline

Set whether the given variable group should be p-refined on a p-refined Elem.

This changes the FEType of the variable group to enable or disable p-refinement.

Definition at line 2570 of file dof_map.h.

{
#ifdef LIBMESH_ENABLE_AMR
  VariableGroup & var = _variable_groups[g];
  var.type().p_refinement = p_refine;
 
  for (auto v : make_range(var.first_scalar_number(0),
                           var.first_scalar_number(0) +
                           var.n_variables()))
    this->_variables[v].type().p_refinement = p_refine;
 
 
#else
  libmesh_ignore(g, p_refine);
#endif
}

References _variable_groups, _variables, libMesh::VariableGroup::first_scalar_number(), libMesh::libmesh_ignore(), libMesh::make_range(), libMesh::VariableGroup::n_variables(), libMesh::FEType::p_refinement, and libMesh::Variable::type().

Referenced by should_p_refine_var().

should_p_refine_var()

bool libMesh::DofMap::should_p_refine_var ( unsigned int  var ) const

inline

Whether the given variable should be p-refined.

Definition at line 2607 of file dof_map.h.

{
#ifdef LIBMESH_ENABLE_AMR
  const auto vg = this->var_group_from_var_number(var);
  return this->should_p_refine(vg);
#else
  libmesh_ignore(var);
  return false;
#endif
}

References libMesh::libmesh_ignore(), should_p_refine(), and var_group_from_var_number().

stash_dof_constraints()

void libMesh::DofMap::stash_dof_constraints ( )

inline

Definition at line 1179 of file dof_map.h.

  {
    libmesh_assert(_stashed_dof_constraints.empty());
    _dof_constraints.swap(_stashed_dof_constraints);
  }

References _dof_constraints, _stashed_dof_constraints, and libMesh::libmesh_assert().

swap_dof_constraints()

void libMesh::DofMap::swap_dof_constraints ( )

inline

Similar to the stash/unstash_dof_constraints() API, but swaps _dof_constraints and _stashed_dof_constraints without asserting that the source or destination is empty first.

Note

There is an implicit assumption that swapping between sets of Constraints does not change the sparsity pattern or expand the send_list, since the only thing changed is the DofConstraints themselves. This is intended to work for swapping between DofConstraints A and B, where A is used to define the send_list, and B is a subset of A.

Definition at line 1203 of file dof_map.h.

  {
    _dof_constraints.swap(_stashed_dof_constraints);
  }

References _dof_constraints, and _stashed_dof_constraints.

sys_number()

unsigned int libMesh::DofMap::sys_number ( ) const

inline

Returns

The number of the system we are responsible for.

Definition at line 2340 of file dof_map.h.

{
  return _sys_number;
}

References _sys_number.

Referenced by _dof_indices(), allgather_recursive_constraints(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), constrain_p_dofs(), process_mesh_constraint_rows(), reinit(), and set_nonlocal_dof_objects().

unstash_dof_constraints()

void libMesh::DofMap::unstash_dof_constraints ( )

inline

Definition at line 1185 of file dof_map.h.

  {
    libmesh_assert(_dof_constraints.empty());
    _dof_constraints.swap(_stashed_dof_constraints);
  }

References _dof_constraints, _stashed_dof_constraints, and libMesh::libmesh_assert().

update_sparsity_pattern()

void libMesh::DofMap::update_sparsity_pattern

(

SparseMatrix< Number > &

matrix

)

const

Additional matrices may be be temporarily initialized by this DofMap.

They are initialized to the same sparsity structure as the major matrix.

Definition at line 269 of file dof_map.C.

{
  matrix.attach_dof_map (*this);
 
  // If we've already computed sparsity, then it's too late
  // to wait for "compute_sparsity" to help with sparse matrix
  // initialization, and we need to handle this matrix individually
  if (this->computed_sparsity_already())
    {
      libmesh_assert(_sp.get());
 
      if (matrix.need_full_sparsity_pattern())
        {
          // We'd better have already computed the full sparsity
          // pattern if we need it here
          libmesh_assert(need_full_sparsity_pattern);
 
          matrix.update_sparsity_pattern (_sp->get_sparsity_pattern());
        }
 
      matrix.attach_sparsity_pattern(*_sp);
    }
}

References _sp, libMesh::SparseMatrix< T >::attach_dof_map(), libMesh::SparseMatrix< T >::attach_sparsity_pattern(), computed_sparsity_already(), libMesh::libmesh_assert(), need_full_sparsity_pattern, libMesh::SparseMatrix< T >::need_full_sparsity_pattern(), and libMesh::SparseMatrix< T >::update_sparsity_pattern().

Referenced by attach_matrix(), and libMesh::System::solve_for_unconstrained_dofs().

use_coupled_neighbor_dofs()

bool libMesh::DofMap::use_coupled_neighbor_dofs

(

const MeshBase &

mesh

)

const

Tells other library functions whether or not this problem includes coupling between dofs in neighboring cells, as can currently be specified on the command line or inferred from the use of all discontinuous variables.

Definition at line 1903 of file dof_map.C.

{
  // If we were asked on the command line, then we need to
  // include sensitivities between neighbor degrees of freedom
  bool implicit_neighbor_dofs =
    libMesh::on_command_line ("--implicit-neighbor-dofs");
 
  // If the user specifies --implicit-neighbor-dofs 0, then
  // presumably he knows what he is doing and we won't try to
  // automatically turn it on even when all the variables are
  // discontinuous.
  if (implicit_neighbor_dofs)
    {
      // No flag provided defaults to 'true'
      int flag = 1;
      flag = libMesh::command_line_next ("--implicit-neighbor-dofs", flag);
 
      if (!flag)
        {
          // The user said --implicit-neighbor-dofs 0, so he knows
          // what he is doing and really doesn't want it.
          return false;
        }
    }
 
  // Possibly override the commandline option, if set_implicit_neighbor_dofs
  // has been called.
  if (_implicit_neighbor_dofs_initialized)
    {
      implicit_neighbor_dofs = _implicit_neighbor_dofs;
 
      // Again, if the user explicitly says implicit_neighbor_dofs = false,
      // then we return here.
      if (!implicit_neighbor_dofs)
        return false;
    }
 
  // Look at all the variables in this system.  If every one is
  // discontinuous then the user must be doing DG/FVM, so be nice
  // and force implicit_neighbor_dofs=true.
  {
    bool all_discontinuous_dofs = true;
 
    // We may call this method even without ever having initialized our data
      for (auto var : index_range(this->_variables))
        if (FEInterface::get_continuity(this->variable_type(var)) !=  DISCONTINUOUS)
          all_discontinuous_dofs = false;
 
    if (all_discontinuous_dofs)
      implicit_neighbor_dofs = true;
  }
 
  return implicit_neighbor_dofs;
}

References libMesh::command_line_next(), libMesh::DISCONTINUOUS, libMesh::index_range(), and libMesh::on_command_line().

Referenced by build_sparsity(), and reinit().

var_group_from_var_number()

unsigned int libMesh::DofMap::var_group_from_var_number ( unsigned int  var_num ) const

inline

Returns

The variable group number that the provided variable number belongs to

Definition at line 2600 of file dof_map.h.

{
  libmesh_assert(var_num < n_variables());
  return libmesh_map_find(_var_to_vg, var_num);
}

References _var_to_vg, libMesh::libmesh_assert(), and n_variables().

Referenced by should_p_refine_var(), and EquationSystemsTest::testSelectivePRefine().

variable()

const Variable & libMesh::DofMap::variable ( const unsigned int  c ) const

inlineoverridevirtual

Returns

The variable description object for variable c.

Implements libMesh::DofMapBase.

Definition at line 2358 of file dof_map.h.

{
  libmesh_assert_less (c, _variables.size());
 
  return _variables[c];
}

References _variables.

Referenced by libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), DMlibMeshSetSystem_libMesh(), libMesh::BoundaryProjectSolution::operator()(), and libMesh::StaticCondensationDofMap::reinit().

variable_group()

const VariableGroup & libMesh::DofMap::variable_group ( const unsigned int  c ) const

inline

Returns

The VariableGroup description object for group g.

Definition at line 2348 of file dof_map.h.

{
  libmesh_assert_less (g, _variable_groups.size());
 
  return _variable_groups[g];
}

References _variable_groups.

Referenced by _dof_indices(), dof_indices(), libMesh::StaticCondensationDofMap::reinit(), and should_p_refine().

variable_group_order()

Order libMesh::DofMap::variable_group_order ( const unsigned int  vg ) const

inline

Returns

The approximation order for VariableGroup vg.

Definition at line 2378 of file dof_map.h.

{
  libmesh_assert_less (vg, _variable_groups.size());
 
  return _variable_groups[vg].type().order;
}

References _variable_groups.

variable_group_type()

const FEType & libMesh::DofMap::variable_group_type ( const unsigned int  vg ) const

inline

Returns

The finite element type for VariableGroup vg.

Definition at line 2398 of file dof_map.h.

{
  libmesh_assert_less (vg, _variable_groups.size());
 
  return _variable_groups[vg].type();
}

References _variable_groups.

variable_name()

const std::string & libMesh::DofMap::variable_name ( const unsigned int  i ) const

inline

Returns

The name of variable i.

Definition at line 2943 of file dof_map.h.

{
  libmesh_assert_less (i, _variables.size());
 
  return _variables[i].name();
}

References _variables.

variable_number()

unsigned int libMesh::DofMap::variable_number ( std::string_view  var ) const

inline

Returns

The variable number associated with the user-specified variable named var.

Definition at line 2991 of file dof_map.h.

{
  auto var_num = libmesh_map_find(_variable_numbers, var);
  libmesh_assert_equal_to(_variables[var_num].name(), var);
  return var_num;
}

References _variable_numbers, and _variables.

Referenced by create_dof_constraints(), libMesh::System::variable_number(), and variable_type().

variable_order()

Order libMesh::DofMap::variable_order ( const unsigned int  c ) const

inline

Returns

The approximation order for variable c.

Definition at line 2368 of file dof_map.h.

{
  libmesh_assert_less (c, _variables.size());
 
  return _variables[c].type().order;
}

References _variables.

variable_scalar_number()

unsigned int libMesh::DofMap::variable_scalar_number ( unsigned int  var_num, unsigned int  component  ) const

inline

Returns

An index, starting from 0 for the first component of the first variable, and incrementing for each component of each (potentially vector-valued) variable in the system in order. For systems with only scalar-valued variables, this will be the same as var_num

Irony: currently our only non-scalar-valued variable type is SCALAR.

Definition at line 2974 of file dof_map.h.

{
  return _variables[var_num].first_scalar_number() + component;
}

References _variables.

variable_type() [1/2]

const FEType & libMesh::DofMap::variable_type ( const unsigned int  i ) const

inline

Returns

The finite element type for variable number i.

Definition at line 2388 of file dof_map.h.

{
  libmesh_assert_less (c, _variables.size());
 
  return _variables[c].type();
}

References _variables.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::MeshFunction::_gradient_on_elem(), LinearElasticity::assemble(), AssembleOptimization::assemble_A_and_F(), assemble_elasticity(), assemble_mass(), assemble_matrices(), assemble_poisson(), assemble_SchroedingerEquation(), Biharmonic::JR::bounds(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::FEInterface::compute_constraints(), compute_enriched_soln(), compute_jacobian(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEInterface::compute_periodic_constraints(), compute_residual(), LinearElasticity::compute_stresses(), LargeDeformationElasticity::compute_stresses(), LinearElasticityWithContact::compute_stresses(), compute_stresses(), constrain_p_dofs(), libMesh::MeshFunction::discontinuous_value(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshFunction::hessian(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), LargeDeformationElasticity::jacobian(), LinearElasticityWithContact::move_mesh(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SmoothnessEstimator::EstimateSmoothness::operator()(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::MeshFunction::operator()(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), process_mesh_constraint_rows(), LargeDeformationElasticity::residual(), LinearElasticityWithContact::residual_and_jacobian(), Biharmonic::JR::residual_and_jacobian(), and libMesh::HPCoarsenTest::select_refinement().

variable_type() [2/2]

const FEType & libMesh::DofMap::variable_type ( std::string_view  var ) const

inline

Returns

The finite element type for variable var.

Definition at line 2981 of file dof_map.h.

{
  return _variables[this->variable_number(var)].type();
}

References _variables, and variable_number().

Friends And Related Symbol Documentation

SparsityPattern::Build

friend class SparsityPattern::Build

friend

Definition at line 2311 of file dof_map.h.

Member Data Documentation

_adjoint_constraint_values

AdjointDofConstraintValues libMesh::DofMap::_adjoint_constraint_values

private

Definition at line 2278 of file dof_map.h.

Referenced by add_adjoint_constraint_row(), allgather_recursive_constraints(), build_constraint_matrix_and_vector(), create_dof_constraints(), gather_constraints(), get_local_constraints(), has_heterogeneous_adjoint_constraint(), has_heterogeneous_adjoint_constraints(), process_constraints(), and process_mesh_constraint_rows().

_adjoint_dirichlet_boundaries

std::vector<std::unique_ptr<DirichletBoundaries> > libMesh::DofMap::_adjoint_dirichlet_boundaries

private

Data structure containing Dirichlet functions.

The ith entry is the constraint matrix row for boundaryid i.

Definition at line 2308 of file dof_map.h.

Referenced by add_adjoint_dirichlet_boundary(), create_dof_constraints(), get_adjoint_dirichlet_boundaries(), get_adjoint_dirichlet_boundaries(), get_local_constraints(), has_adjoint_dirichlet_boundaries(), and remove_adjoint_dirichlet_boundary().

_algebraic_ghosting_functors

std::vector<GhostingFunctor *> libMesh::DofMap::_algebraic_ghosting_functors

private

The list of all GhostingFunctor objects to be used when distributing ghosted vectors.

The library should automatically refer these functors to the MeshBase, too, so any algebraically ghosted dofs will live on geometrically ghosted elements.

Keep these in a vector so any parallel computation is done in the same order on all processors.

Definition at line 2220 of file dof_map.h.

Referenced by algebraic_ghosting_functors_begin(), and algebraic_ghosting_functors_end().

_array_variables

std::vector<std::pair<unsigned int, unsigned int> > libMesh::DofMap::_array_variables

private

Array variable information storage.

For a given array "variable", the first member of the pair denotes the first variable number present in the array variable and the second member of the pair denotes the last variable number present in the array variables plus one

Definition at line 2124 of file dof_map.h.

Referenced by get_variable_array().

_augment_send_list

AugmentSendList* libMesh::DofMap::_augment_send_list

private

Function object to call to add extra entries to the send list.

Definition at line 2181 of file dof_map.h.

Referenced by attach_extra_send_list_object().

_augment_sparsity_pattern

SparsityPattern::AugmentSparsityPattern* libMesh::DofMap::_augment_sparsity_pattern

private

Function object to call to add extra entries to the sparsity pattern.

Definition at line 2164 of file dof_map.h.

Referenced by attach_extra_sparsity_object(), and build_sparsity().

_communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator

protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::StaticCondensation::close(), libMesh::ParallelObject::comm(), libMesh::CondensedEigenSystem::initialize_condensed_matrices(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::StaticCondensationDofMap::reinit(), and libMesh::BoundaryInfo::synchronize_global_id_set().

_constrained_sparsity_construction

bool libMesh::DofMap::_constrained_sparsity_construction

private

This flag indicates whether or not we explicitly take constraint equations into account when computing a sparsity pattern.

Definition at line 2091 of file dof_map.h.

Referenced by constrained_sparsity_construction(), and set_constrained_sparsity_construction().

_counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info().

_coupling_functors

std::vector<GhostingFunctor *> libMesh::DofMap::_coupling_functors

private

The list of all GhostingFunctor objects to be used when coupling degrees of freedom in matrix sparsity patterns.

These objects will also be used as algebraic ghosting functors, but not vice-versa.

The library should automatically refer these functors to the MeshBase, too, so any dofs coupled to local dofs will live on geometrically ghosted elements.

Definition at line 2233 of file dof_map.h.

Referenced by build_sparsity(), coupling_functors_begin(), and coupling_functors_end().

_default_coupling

std::unique_ptr<DefaultCoupling> libMesh::DofMap::_default_coupling

private

The default coupling GhostingFunctor, used to implement standard libMesh sparsity pattern construction.

We use a std::unique_ptr here to reduce header dependencies.

Definition at line 2199 of file dof_map.h.

Referenced by default_coupling(), DofMap(), reinit(), and ~DofMap().

_default_evaluating

std::unique_ptr<DefaultCoupling> libMesh::DofMap::_default_evaluating

private

The default algebraic GhostingFunctor, used to implement standard libMesh send_list construction.

We use a std::unique_ptr here to reduce header dependencies.

Definition at line 2207 of file dof_map.h.

Referenced by default_algebraic_ghosting(), DofMap(), and ~DofMap().

_dirichlet_boundaries

std::unique_ptr<DirichletBoundaries> libMesh::DofMap::_dirichlet_boundaries

private

Data structure containing Dirichlet functions.

The ith entry is the constraint matrix row for boundaryid i.

Definition at line 2302 of file dof_map.h.

Referenced by add_dirichlet_boundary(), create_dof_constraints(), get_dirichlet_boundaries(), get_dirichlet_boundaries(), and remove_dirichlet_boundary().

_dof_constraints

DofConstraints libMesh::DofMap::_dof_constraints

private

Data structure containing DOF constraints.

The ith entry is the constraint matrix row for DOF i.

Definition at line 2274 of file dof_map.h.

Referenced by add_constraint_row(), add_constraints_to_send_list(), allgather_recursive_constraints(), build_constraint_matrix(), build_constraint_matrix_and_vector(), check_for_constraint_loops(), constrain_element_residual(), constrain_p_dofs(), constraint_rows_begin(), constraint_rows_end(), create_dof_constraints(), gather_constraints(), get_dof_constraints(), get_local_constraints(), heterogeneously_constrain_element_jacobian_and_residual(), heterogeneously_constrain_element_residual(), is_constrained_dof(), max_constraint_error(), n_local_constrained_dofs(), process_constraints(), process_mesh_constraint_rows(), scatter_constraints(), stash_dof_constraints(), swap_dof_constraints(), and unstash_dof_constraints().

_dof_coupling

CouplingMatrix* libMesh::DofMap::_dof_coupling

Degree of freedom coupling.

If left empty each DOF couples to all others. Can be used to reduce memory requirements for sparse matrices. DOF 0 might only couple to itself, in which case dof_coupling(0,0) should be 1 and dof_coupling(0,j) = 0 for j not equal to 0.

This variable is named as though it were class private, but it is in the public interface. Also there are no public methods for accessing it... This typically means you should only use it if you know what you are doing.

Definition at line 1741 of file dof_map.h.

Referenced by libMesh::RBConstruction::add_scaled_matrix_and_vector(), build_sparsity(), main(), and reinit().

_enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

Definition at line 143 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

_end_df

std::vector<dof_id_type> libMesh::DofMapBase::_end_df

protectedinherited

Last DOF index (plus 1) on processor p.

Definition at line 159 of file dof_map_base.h.

Referenced by libMesh::DofMapBase::clear(), dof_owner(), libMesh::DofMapBase::end_dof(), gather_constraints(), libMesh::DofMapBase::n_dofs_on_processor(), and scatter_constraints().

_end_old_df

std::vector<dof_id_type> libMesh::DofMapBase::_end_old_df

protectedinherited

Last old DOF index (plus 1) on processor p.

Definition at line 181 of file dof_map_base.h.

Referenced by libMesh::DofMapBase::end_old_dof().

_error_on_constraint_loop

bool libMesh::DofMap::_error_on_constraint_loop

private

This flag indicates whether or not we do an opt-mode check for the presence of constraint loops, i.e.

cases where the constraint graph is cyclic.

Definition at line 2085 of file dof_map.h.

Referenced by process_constraints(), and set_error_on_constraint_loop().

_extra_send_list_context

void* libMesh::DofMap::_extra_send_list_context

private

A pointer associated with the extra send list that can optionally be passed in.

Definition at line 2191 of file dof_map.h.

Referenced by attach_extra_send_list_function().

_extra_send_list_function

void(* libMesh::DofMap::_extra_send_list_function) (std::vector< dof_id_type > &, void *)

private

A function pointer to a function to call to add extra entries to the send list.

Definition at line 2186 of file dof_map.h.

Referenced by attach_extra_send_list_function().

_extra_sparsity_context

void* libMesh::DofMap::_extra_sparsity_context

private

A pointer associated with the extra sparsity that can optionally be passed in.

Definition at line 2176 of file dof_map.h.

Referenced by attach_extra_sparsity_function(), and build_sparsity().

_extra_sparsity_function

void(* libMesh::DofMap::_extra_sparsity_function) (SparsityPattern::Graph &, std::vector< dof_id_type > &n_nz, std::vector< dof_id_type > &n_oz, void *)

private

A function pointer to a function to call to add extra entries to the sparsity pattern.

Definition at line 2169 of file dof_map.h.

Referenced by attach_extra_sparsity_function(), and build_sparsity().

_first_df

std::vector<dof_id_type> libMesh::DofMapBase::_first_df

protectedinherited

First DOF index on processor p.

Definition at line 154 of file dof_map_base.h.

Referenced by libMesh::DofMapBase::clear(), libMesh::DofMapBase::first_dof(), libMesh::DofMapBase::n_dofs_on_processor(), and libMesh::StaticCondensationDofMap::reinit().

_first_old_df

std::vector<dof_id_type> libMesh::DofMapBase::_first_old_df

protectedinherited

First old DOF index on processor p.

Definition at line 176 of file dof_map_base.h.

Referenced by libMesh::DofMapBase::first_old_dof().

_first_old_scalar_df

std::vector<dof_id_type> libMesh::DofMap::_first_old_scalar_df

private

First old DOF index for SCALAR variable v, or garbage for non-SCALAR variable v.

Definition at line 2266 of file dof_map.h.

_first_scalar_df

std::vector<dof_id_type> libMesh::DofMap::_first_scalar_df

private

First DOF index for SCALAR variable v, or garbage for non-SCALAR variable v.

Definition at line 2153 of file dof_map.h.

_identify_variable_groups

bool libMesh::DofMap::_identify_variable_groups = true

private

true when VariableGroup structures should be automatically identified, false otherwise.

Defaults to true.

Definition at line 2130 of file dof_map.h.

Referenced by identify_variable_groups(), and identify_variable_groups().

_implicit_neighbor_dofs

bool libMesh::DofMap::_implicit_neighbor_dofs

private

Definition at line 2318 of file dof_map.h.

_implicit_neighbor_dofs_initialized

bool libMesh::DofMap::_implicit_neighbor_dofs_initialized

private

Bools to indicate if we override the –implicit_neighbor_dofs commandline options.

Definition at line 2317 of file dof_map.h.

_matrices

std::vector<SparseMatrix<Number> * > libMesh::DofMap::_matrices

private

Additional matrices handled by this object.

These pointers do not handle the memory, instead, System, who told DofMap about them, owns them.

Definition at line 2147 of file dof_map.h.

Referenced by attach_matrix(), DofMap(), and is_attached().

_mesh

MeshBase& libMesh::DofMap::_mesh

private

The mesh that system uses.

Definition at line 2140 of file dof_map.h.

Referenced by DofMap(), local_variable_indices(), n_local_dofs(), and ~DofMap().

_mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

_n_dfs

dof_id_type libMesh::DofMapBase::_n_dfs

protectedinherited

Total number of degrees of freedom.

Definition at line 164 of file dof_map_base.h.

Referenced by libMesh::DofMapBase::clear(), and libMesh::DofMapBase::n_dofs().

_n_objects

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects

staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

_n_old_dfs

dof_id_type libMesh::DofMapBase::_n_old_dfs

protectedinherited

Total number of degrees of freedom on old dof objects.

Definition at line 171 of file dof_map_base.h.

Referenced by libMesh::DofMapBase::n_old_dofs().

_n_SCALAR_dofs

dof_id_type libMesh::DofMap::_n_SCALAR_dofs

private

The total number of SCALAR dofs associated to all SCALAR variables.

Definition at line 2258 of file dof_map.h.

Referenced by n_SCALAR_dofs().

_node_constraints

NodeConstraints libMesh::DofMap::_node_constraints

private

Data structure containing DofObject constraints.

Definition at line 2285 of file dof_map.h.

Referenced by allgather_recursive_constraints(), create_dof_constraints(), get_local_constraints(), is_constrained_node(), n_constrained_nodes(), node_constraint_rows_begin(), node_constraint_rows_end(), and scatter_constraints().

_periodic_boundaries

std::unique_ptr<PeriodicBoundaries> libMesh::DofMap::_periodic_boundaries

private

Data structure containing periodic boundaries.

The ith entry is the constraint matrix row for boundaryid i.

Definition at line 2294 of file dof_map.h.

Referenced by add_periodic_boundary(), create_dof_constraints(), DofMap(), get_periodic_boundaries(), get_periodic_boundaries(), is_periodic_boundary(), and process_mesh_constraint_rows().

_primal_constraint_values

DofConstraintValueMap libMesh::DofMap::_primal_constraint_values

private

Definition at line 2276 of file dof_map.h.

Referenced by add_constraint_row(), allgather_recursive_constraints(), build_constraint_matrix_and_vector(), constrain_p_dofs(), create_dof_constraints(), gather_constraints(), get_local_constraints(), get_primal_constraint_values(), heterogeneously_constrain_element_jacobian_and_residual(), heterogeneously_constrain_element_residual(), max_constraint_error(), process_constraints(), process_mesh_constraint_rows(), and scatter_constraints().

_sc

std::unique_ptr<StaticCondensationDofMap> libMesh::DofMap::_sc

private

Static condensation class.

Definition at line 2333 of file dof_map.h.

Referenced by build_sparsity(), get_static_condensation(), get_static_condensation(), and has_static_condensation().

_send_list

std::vector<dof_id_type> libMesh::DofMap::_send_list

private

A list containing all the global DOF indices that affect the solution on my processor.

Definition at line 2159 of file dof_map.h.

Referenced by add_constraints_to_send_list(), clear_send_list(), and get_send_list().

_shared_functors

std::map<GhostingFunctor *, std::shared_ptr<GhostingFunctor> > libMesh::DofMap::_shared_functors

private

Hang on to references to any GhostingFunctor objects we were passed in shared_ptr form.

Definition at line 2239 of file dof_map.h.

Referenced by add_algebraic_ghosting_functor(), and add_coupling_functor().

_sp

std::unique_ptr<SparsityPattern::Build> libMesh::DofMap::_sp

private

The sparsity pattern of the global matrix.

If need_full_sparsity_pattern is true, we save the entire sparse graph here. Otherwise we save just the n_nz and n_oz vectors.

Definition at line 2252 of file dof_map.h.

Referenced by computed_sparsity_already(), get_n_nz(), get_n_oz(), get_sparsity_pattern(), and update_sparsity_pattern().

_stashed_dof_constraints

DofConstraints libMesh::DofMap::_stashed_dof_constraints

private

Definition at line 2274 of file dof_map.h.

Referenced by stash_dof_constraints(), swap_dof_constraints(), and unstash_dof_constraints().

_sys_number

const unsigned int libMesh::DofMap::_sys_number

private

The number of the system we manage DOFs for.

Definition at line 2135 of file dof_map.h.

Referenced by sys_number().

_var_to_vg

std::unordered_map<unsigned int, unsigned int> libMesh::DofMap::_var_to_vg

private

A map from variable number to variable group number.

Definition at line 2111 of file dof_map.h.

Referenced by array_dof_indices(), and var_group_from_var_number().

_variable_group_numbers

std::vector<unsigned int> libMesh::DofMap::_variable_group_numbers

private

The variable group number for each variable.

Definition at line 2106 of file dof_map.h.

Referenced by dof_indices().

_variable_groups

std::vector<VariableGroup> libMesh::DofMap::_variable_groups

private

The variable groups in this system/degree of freedom map.

Definition at line 2101 of file dof_map.h.

Referenced by array_dof_indices(), n_variable_groups(), should_p_refine(), variable_group(), variable_group_order(), and variable_group_type().

_variable_numbers

std::map<std::string, unsigned int, std::less<> > libMesh::DofMap::_variable_numbers

private

The variable numbers corresponding to user-specified names, useful for name-based lookups.

Definition at line 2117 of file dof_map.h.

Referenced by has_variable(), and variable_number().

_variables

std::vector<Variable> libMesh::DofMap::_variables

private

The variables in this system/degree of freedom map.

Definition at line 2096 of file dof_map.h.

Referenced by n_components(), n_variables(), n_vars(), should_p_refine(), variable(), variable_name(), variable_number(), variable_order(), variable_scalar_number(), variable_type(), and variable_type().

_verify_dirichlet_bc_consistency

bool libMesh::DofMap::_verify_dirichlet_bc_consistency

private

Flag which determines whether we should do some additional checking of the consistency of the DirichletBoundary objects added by the user.

Defaults to true, but can be disabled in cases where you only want to add DirichletBoundary objects "locally" and can guarantee that no repartitioning will be done, since repartitioning could cause processors to own new boundary sides for which they no longer have the proper DirichletBoundary objects stored.

Definition at line 2330 of file dof_map.h.

Referenced by create_dof_constraints().

need_full_sparsity_pattern

bool libMesh::DofMap::need_full_sparsity_pattern

private

Default false; set to true if any attached matrix requires a full sparsity pattern.

Definition at line 2245 of file dof_map.h.

Referenced by attach_matrix(), build_sparsity(), full_sparsity_pattern_needed(), and update_sparsity_pattern().

---

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

• include/base/dof_map.h
• src/base/dof_map.C
• src/base/dof_map_constraints.C