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

#include <dof_map.h>

Inheritance diagram for libMesh::DofMap:

Classes
class	AugmentSendList

class	AugmentSparsityPattern

Public Member Functions
	DofMap (const unsigned int sys_number, MeshBase &mesh)

	~DofMap ()

void	attach_matrix (SparseMatrix< Number > &matrix)

bool	is_attached (SparseMatrix< Number > &matrix)

void	distribute_dofs (MeshBase &)

void	compute_sparsity (const MeshBase &)

void	clear_sparsity ()

void	remove_default_ghosting ()

void	add_default_ghosting ()

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

void	remove_coupling_functor (GhostingFunctor &coupling_functor)

std::set< GhostingFunctor * >::const_iterator	coupling_functors_begin () const

std::set< GhostingFunctor * >::const_iterator	coupling_functors_end () const

DefaultCoupling &	default_coupling ()

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

void	remove_algebraic_ghosting_functor (GhostingFunctor &evaluable_functor)

std::set< GhostingFunctor * >::const_iterator	algebraic_ghosting_functors_begin () const

std::set< GhostingFunctor * >::const_iterator	algebraic_ghosting_functors_end () const

DefaultCoupling &	default_algebraic_ghosting ()

void	attach_extra_sparsity_object (DofMap::AugmentSparsityPattern &asp)

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)

void	attach_extra_send_list_object (DofMap::AugmentSendList &asl)

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

void	prepare_send_list ()

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

void	add_variable_group (const VariableGroup &var_group)

void	set_error_on_cyclic_constraint (bool error_on_cyclic_constraint)

const VariableGroup &	variable_group (const unsigned int c) const

const Variable &	variable (const unsigned int c) const

Order	variable_order (const unsigned int c) const

Order	variable_group_order (const unsigned int vg) const

const FEType &	variable_type (const unsigned int c) const

const FEType &	variable_group_type (const unsigned int vg) const

unsigned int	n_variable_groups () const

unsigned int	n_variables () const

bool	has_blocked_representation () const

unsigned int	block_size () const

dof_id_type	n_dofs () const

dof_id_type	n_SCALAR_dofs () const

dof_id_type	n_local_dofs () const

dof_id_type	n_dofs_on_processor (const processor_id_type proc) const

dof_id_type	first_dof (const processor_id_type proc) const

dof_id_type	first_dof () const

dof_id_type	first_old_dof (const processor_id_type proc) const

dof_id_type	first_old_dof () const

dof_id_type	last_dof (const processor_id_type proc) const

dof_id_type	last_dof () const

dof_id_type	end_dof (const processor_id_type proc) const

dof_id_type	end_dof () const

processor_id_type	dof_owner (const dof_id_type dof) const

dof_id_type	end_old_dof (const processor_id_type proc) const

dof_id_type	end_old_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

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

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

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

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)

bool	use_coupled_neighbor_dofs (const MeshBase &mesh) const

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

void	local_variable_indices (std::vector< dof_id_type > &idx, const MeshBase &mesh, unsigned int var_num) const

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)

void	allgather_recursive_constraints (MeshBase &)

void	scatter_constraints (MeshBase &)

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

void	process_constraints (MeshBase &)

void	check_for_cyclic_constraints ()

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

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)

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

DofConstraints::const_iterator	constraint_rows_begin () const

DofConstraints::const_iterator	constraint_rows_end () const

void	stash_dof_constraints ()

void	unstash_dof_constraints ()

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_heterogenous_adjoint_constraints (const unsigned int qoi_num) const

Number	has_heterogenous_adjoint_constraint (const unsigned int qoi_num, const dof_id_type dof) const

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

std::string	get_local_constraints (bool print_nonlocal=false) const

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

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

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

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

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

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	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	constrain_element_dyad_matrix (DenseVector< Number > &v, DenseVector< Number > &w, std::vector< dof_id_type > &row_dofs, bool asymmetric_constraint_rows=true) const

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

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

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

void	add_periodic_boundary (const PeriodicBoundaryBase &periodic_boundary)

void	add_periodic_boundary (const PeriodicBoundaryBase &boundary, const PeriodicBoundaryBase &inverse_boundary)

bool	is_periodic_boundary (const boundary_id_type boundaryid) const

PeriodicBoundaries *	get_periodic_boundaries ()

void	add_dirichlet_boundary (const DirichletBoundary &dirichlet_boundary)

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

void	remove_dirichlet_boundary (const DirichletBoundary &dirichlet_boundary)

void	remove_adjoint_dirichlet_boundary (const DirichletBoundary &dirichlet_boundary, unsigned int 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	old_dof_indices (const Elem *const elem, std::vector< dof_id_type > &di, const unsigned int vn=libMesh::invalid_uint) const

dof_id_type	n_old_dofs () const

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

void	reinit (MeshBase &mesh)

void	clear ()

void	print_info (std::ostream &os=libMesh::out) const

std::string	get_info () const

unsigned int	sys_number () 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 ()

static void	print_info (std::ostream &out=libMesh::out)

static unsigned int	n_objects ()

static void	enable_print_counter_info ()

static void	disable_print_counter_info ()

Public Attributes
CouplingMatrix *	_dof_coupling

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts

Protected Member Functions
void	increment_constructor_count (const std::string &name)

void	increment_destructor_count (const std::string &name)

Protected Attributes
const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts

static Threads::atomic< unsigned int >	_n_objects

static Threads::spin_mutex	_mutex

static bool	_enable_print_counter = true

Private Types
typedef DofObject (DofMap::	dofobject_accessor) (MeshBase &mesh, dof_id_type i) const

Private Member Functions
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 #ifdef DEBUG, const unsigned int v, std::size_t &tot_size #endif) const

std::unique_ptr< SparsityPattern::Build >	build_sparsity (const MeshBase &mesh) const

void	invalidate_dofs (MeshBase &mesh) const

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)

void	distribute_local_dofs_var_major (dof_id_type &next_free_dof, MeshBase &mesh)

void	distribute_local_dofs_node_major (dof_id_type &next_free_dof, MeshBase &mesh)

void	add_neighbors_to_send_list (MeshBase &mesh)

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

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

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

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

void	add_constraints_to_send_list ()

void	check_dirichlet_bcid_consistency (const MeshBase &mesh, const DirichletBoundary &boundary) const

Static Private Member Functions
static void	merge_ghost_functor_outputs (GhostingFunctor::map_type &elements_to_ghost, std::set< CouplingMatrix > &temporary_coupling_matrices, const std::set< GhostingFunctor >::iterator &gf_begin, const std::set< GhostingFunctor *>::iterator &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_cyclic_constraint

std::vector< Variable >	_variables

std::vector< VariableGroup >	_variable_groups

std::vector< unsigned int >	_variable_group_numbers

const unsigned int	_sys_number

MeshBase &	_mesh

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

std::vector< dof_id_type >	_first_df

std::vector< dof_id_type >	_end_df

std::vector< dof_id_type >	_first_scalar_df

std::vector< dof_id_type >	_send_list

AugmentSparsityPattern *	_augment_sparsity_pattern

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

void *	_extra_sparsity_context

AugmentSendList *	_augment_send_list

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

void *	_extra_send_list_context

std::unique_ptr< DefaultCoupling >	_default_coupling

std::unique_ptr< DefaultCoupling >	_default_evaluating

std::set< GhostingFunctor * >	_algebraic_ghosting_functors

std::set< GhostingFunctor * >	_coupling_functors

bool	need_full_sparsity_pattern

std::unique_ptr< SparsityPattern::Build >	_sp

std::vector< dof_id_type > *	_n_nz

std::vector< dof_id_type > *	_n_oz

dof_id_type	_n_dfs

dof_id_type	_n_SCALAR_dofs

dof_id_type	_n_old_dfs

std::vector< dof_id_type >	_first_old_df

std::vector< dof_id_type >	_end_old_df

std::vector< dof_id_type >	_first_old_scalar_df

DofConstraints	_dof_constraints

DofConstraints	_stashed_dof_constraints

DofConstraintValueMap	_primal_constraint_values

AdjointDofConstraintValues	_adjoint_constraint_values

NodeConstraints	_node_constraints

std::unique_ptr< PeriodicBoundaries >	_periodic_boundaries

std::unique_ptr< DirichletBoundaries >	_dirichlet_boundaries

std::vector< DirichletBoundaries * >	_adjoint_dirichlet_boundaries

bool	_implicit_neighbor_dofs_initialized

bool	_implicit_neighbor_dofs

Friends
class	SparsityPattern::Build

Detailed Description

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

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

Definition at line 176 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 117 of file reference_counter.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 1376 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 130 of file dof_map.C.

References _default_coupling, _default_evaluating, _matrices, _mesh, _periodic_boundaries, add_algebraic_ghosting_functor(), and add_coupling_functor().

                                 :
   ParallelObject (mesh.comm()),
   _dof_coupling(nullptr),
   _error_on_cyclic_constraint(false),
   _variables(),
   _variable_groups(),
   _variable_group_numbers(),
   _sys_number(number),
   _mesh(mesh),
   _matrices(),
   _first_df(),
   _end_df(),
   _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(new DefaultCoupling()),
   _default_evaluating(new DefaultCoupling()),
   need_full_sparsity_pattern(false),
   _n_nz(nullptr),
   _n_oz(nullptr),
   _n_dfs(0),
   _n_SCALAR_dofs(0)
 #ifdef LIBMESH_ENABLE_AMR
   , _n_old_dfs(0),
   _first_old_df(),
   _end_old_df(),
   _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(new PeriodicBoundaries)
 #endif
 #ifdef LIBMESH_ENABLE_DIRICHLET
   , _dirichlet_boundaries(new DirichletBoundaries)
   , _adjoint_dirichlet_boundaries()
 #endif
   , _implicit_neighbor_dofs_initialized(false),
   _implicit_neighbor_dofs(false)
 {
   _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);
 }

◆ ~DofMap()

libMesh::DofMap::~DofMap ( )

Destructor.

Definition at line 201 of file dof_map.C.

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

 {
   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);
 
 #ifdef LIBMESH_ENABLE_DIRICHLET
   for (auto & bnd : _adjoint_dirichlet_boundaries)
     delete bnd;
 #endif
 }

Member Function Documentation

◆ _dof_indices()

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 #ifdef	DEBUG,
		const unsigned int	v,
		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 2209 of file dof_map.C.

References libMesh::Elem::active(), libMesh::Variable::active_on_subdomain(), libMesh::Elem::dim(), libMesh::DofObject::dof_number(), libMesh::FEInterface::extra_hanging_dofs(), libMesh::FEType::family, libMesh::Elem::infinite(), libMesh::DofObject::invalid_id, libMesh::Elem::is_vertex(), libMesh::LAGRANGE, libMesh::DofObject::n_comp_group(), 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::SUBDIVISION, libMesh::Elem::subdomain_id(), sys_number(), libMesh::Variable::type(), libMesh::Elem::type(), libMesh::DofObject::var_to_vg_and_offset(), and variable_group().

Referenced by dof_indices().

 {
   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();
       const unsigned int dim     = elem.dim();
 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
       const bool is_inf          = elem.infinite();
 #endif
 
       // Increase the polynomial order on p refined elements
       FEType fe_type = var.type();
       fe_type.order = static_cast<Order>(fe_type.order + p_level);
 
       const bool extra_hanging_dofs =
         FEInterface::extra_hanging_dofs(fe_type);
 
 #ifdef DEBUG
       // The number of dofs per element is non-static for subdivision FE
       if (fe_type.family == SUBDIVISION)
         tot_size += n_nodes;
       else
         tot_size += FEInterface::n_dofs(dim,fe_type,type);
 #endif
 
       const FEInterface::n_dofs_at_node_ptr ndan =
         FEInterface::n_dofs_at_node_function(dim, fe_type);
 
       // 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(dim, fe_type, type, n) :
 #endif
             ndan (type, fe_type.order, 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=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);
                     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
           else
             for (unsigned int i=0; i<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);
                 di.push_back(d);
               }
         }
 
       // If there are any element-based DOF numbers, get them
       const unsigned int nc = FEInterface::n_dofs_per_elem(dim,
                                                            fe_type,
                                                            type);
       // 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
       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);
 
                   di.push_back(d);
                 }
             }
           else
             {
               libmesh_assert(!elem.active() || fe_type.family == LAGRANGE || fe_type.family == SUBDIVISION);
               di.resize(di.size() + nc, DofObject::invalid_id);
             }
         }
     }
 }

◆ 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 1373 of file dof_map_constraints.C.

 {
   // Optionally allow the user to overwrite constraints.  Defaults to false.
   if (forbid_constraint_overwrite)
     {
       if (!this->is_constrained_dof(dof_number))
         libmesh_error_msg("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 & pr : row)
       //       libmesh_assert(constraint_row.find(pr.first)->second == pr.second);
       //   }
       //
       // 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
 
   // We don't get insert_or_assign until C++17 so we make do.
   std::pair<DofConstraintValueMap::iterator, bool> rhs_it =
     _adjoint_constraint_values[qoi_index].insert(std::make_pair(dof_number,
                                                                 constraint_rhs));
   if (!rhs_it.second)
     rhs_it.first->second = constraint_rhs;
 }

◆ 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 4279 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(new DirichletBoundaries());
 
   _adjoint_dirichlet_boundaries[qoi_index]->push_back
     (new DirichletBoundary(dirichlet_boundary));
 }

◆ add_algebraic_ghosting_functor()

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 1829 of file dof_map.C.

References _algebraic_ghosting_functors, _mesh, and libMesh::MeshBase::add_ghosting_functor().

Referenced by add_default_ghosting(), clear(), and DofMap().

 {
   _algebraic_ghosting_functors.insert(&evaluable_functor);
   if (to_mesh)
     _mesh.add_ghosting_functor(evaluable_functor);
 }

◆ add_constraint_row() [1/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 1350 of file dof_map_constraints.C.

Referenced by add_constraint_row().

 {
   // Optionally allow the user to overwrite constraints.  Defaults to false.
   if (forbid_constraint_overwrite)
     if (this->is_constrained_dof(dof_number))
       libmesh_error_msg("ERROR: DOF " << dof_number << " was already constrained!");
 
   // We don't get insert_or_assign until C++17 so we make do.
   std::pair<DofConstraints::iterator, bool> it =
     _dof_constraints.insert(std::make_pair(dof_number, constraint_row));
   if (!it.second)
     it.first->second = constraint_row;
 
   std::pair<DofConstraintValueMap::iterator, bool> rhs_it =
     _primal_constraint_values.insert(std::make_pair(dof_number, constraint_rhs));
   if (!rhs_it.second)
     rhs_it.first->second = constraint_rhs;
 }

◆ add_constraint_row() [2/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 894 of file dof_map.h.

References add_constraint_row().

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

libMesh::DofMap::add_constraint_row

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

Definition: dof_map_constraints.C:1350

◆ 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 4163 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;
 
   for (const auto & i : _dof_constraints)
     {
       dof_id_type constrained_dof = i.first;
 
       // We only need the dependencies of our own constrained dofs
       if (!this->local_index(constrained_dof))
         continue;
 
       const DofConstraintRow & constraint_row = i.second;
       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);
         }
     }
 }

◆ add_coupling_functor()

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 1809 of file dof_map.C.

References _coupling_functors, _mesh, and libMesh::MeshBase::add_ghosting_functor().

Referenced by add_default_ghosting(), clear(), and DofMap().

 {
   _coupling_functors.insert(&coupling_functor);
   if (to_mesh)
     _mesh.add_ghosting_functor(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 1800 of file dof_map.C.

References add_algebraic_ghosting_functor(), add_coupling_functor(), default_algebraic_ghosting(), and default_coupling().

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

 {
   this->add_coupling_functor(this->default_coupling());
   this->add_algebraic_ghosting_functor(this->default_algebraic_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.

Definition at line 4273 of file dof_map_constraints.C.

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

 {
   _dirichlet_boundaries->push_back(new DirichletBoundary(dirichlet_boundary));
 }

◆ 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 1499 of file dof_map.C.

References _send_list, algebraic_ghosting_functors_begin(), algebraic_ghosting_functors_end(), coupling_functors_begin(), coupling_functors_end(), dof_indices(), local_index(), merge_ghost_functor_outputs(), mesh, n_variables(), libMesh::ParallelObject::processor_id(), and libMesh::DofObject::processor_id().

Referenced by distribute_dofs().

 {
   LOG_SCOPE("add_neighbors_to_send_list()", "DofMap");
 
   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;
 
   // Man, I wish we had guaranteed unique_ptr availability...
   std::set<CouplingMatrix *> 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 (auto & pr : elements_to_send)
     {
       const Elem * const partner = pr.first;
 
       // We asked ghosting functors not to give us local elements
       libmesh_assert_not_equal_to
         (partner->processor_id(), this->processor_id());
 
       const CouplingMatrix * ghost_coupling = pr.second;
 
       // 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())
             {
               std::pair<std::map<const CouplingMatrix *, std::vector<unsigned int>>::iterator, bool>
                 inserted_variable_list_pair = column_variable_lists.insert(std::make_pair(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 (!this->local_index(d))
                   _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 (!this->local_index(dof))
               _send_list.push_back(dof);
         }
 
     }
 
   // We're now done with any merged coupling matrices we had to create.
   for (auto & mat : temporary_coupling_matrices)
     delete mat;
 
   //-------------------------------------------------------------------------
   // 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 (!this->local_index(dof))
           _send_list.push_back(dof);
     }
 }

◆ add_periodic_boundary() [1/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 4393 of file dof_map_constraints.C.

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

 {
   // See if we already have a periodic boundary associated myboundary...
   PeriodicBoundaryBase * existing_boundary = _periodic_boundaries->boundary(periodic_boundary.myboundary);
 
   if (existing_boundary == nullptr)
     {
       // ...if not, clone the input (and its inverse) and add them to the PeriodicBoundaries object
       PeriodicBoundaryBase * boundary = periodic_boundary.clone().release();
       PeriodicBoundaryBase * inverse_boundary = periodic_boundary.clone(PeriodicBoundaryBase::INVERSE).release();
 
       // _periodic_boundaries takes ownership of the pointers
       _periodic_boundaries->insert(std::make_pair(boundary->myboundary, boundary));
       _periodic_boundaries->insert(std::make_pair(inverse_boundary->myboundary, inverse_boundary));
     }
   else
     {
       // ...otherwise, merge this object's variable IDs with the existing boundary object's.
       existing_boundary->merge(periodic_boundary);
 
       // Do the same merging process for the inverse boundary.  Note: the inverse better already exist!
       PeriodicBoundaryBase * inverse_boundary = _periodic_boundaries->boundary(periodic_boundary.pairedboundary);
       libmesh_assert(inverse_boundary);
       inverse_boundary->merge(periodic_boundary);
     }
 }

◆ add_periodic_boundary() [2/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 4423 of file dof_map_constraints.C.

References libMesh::PeriodicBoundaryBase::clone(), libMesh::PeriodicBoundaryBase::myboundary, and libMesh::PeriodicBoundaryBase::pairedboundary.

 {
   libmesh_assert_equal_to (boundary.myboundary, inverse_boundary.pairedboundary);
   libmesh_assert_equal_to (boundary.pairedboundary, inverse_boundary.myboundary);
 
   // Allocate copies on the heap.  The _periodic_boundaries object will manage this memory.
   // Note: this also means that the copy constructor for the PeriodicBoundary (or user class
   // derived therefrom) must be implemented!
   // PeriodicBoundary * p_boundary = new PeriodicBoundary(boundary);
   // PeriodicBoundary * p_inverse_boundary = new PeriodicBoundary(inverse_boundary);
 
   // We can't use normal copy construction since this leads to slicing with derived classes.
   // Use clone() "virtual constructor" instead.  But, this *requires* user to override the clone()
   // method.  Note also that clone() allocates memory.  In this case, the _periodic_boundaries object
   // takes responsibility for cleanup.
   PeriodicBoundaryBase * p_boundary = boundary.clone().release();
   PeriodicBoundaryBase * p_inverse_boundary = inverse_boundary.clone().release();
 
   // Add the periodic boundary and its inverse to the PeriodicBoundaries data structure.  The
   // PeriodicBoundaries data structure takes ownership of the pointers.
   _periodic_boundaries->insert(std::make_pair(p_boundary->myboundary, p_boundary));
   _periodic_boundaries->insert(std::make_pair(p_inverse_boundary->myboundary, p_inverse_boundary));
 }

◆ add_variable_group()

void libMesh::DofMap::add_variable_group ( const VariableGroup & var_group )

Add an unknown of order order and finite element type type to the system of equations. Add a group of unknowns of order order and finite element type type to the system of equations.

Definition at line 245 of file dof_map.C.

References _variable_group_numbers, _variable_groups, _variables, and libMesh::VariableGroup::n_variables().

 {
   const unsigned int vg = cast_int<unsigned int>(_variable_groups.size());
 
   _variable_groups.push_back(var_group);
 
   VariableGroup & new_var_group = _variable_groups.back();
 
   for (unsigned int var=0; var<new_var_group.n_variables(); var++)
     {
       _variables.push_back (new_var_group(var));
       _variable_group_numbers.push_back (vg);
     }
 }

◆ algebraic_ghosting_functors_begin()

std::set<GhostingFunctor *>::const_iterator libMesh::DofMap::algebraic_ghosting_functors_begin ( ) const

inline

Beginning of range of algebraic ghosting functors

Definition at line 367 of file dof_map.h.

References _algebraic_ghosting_functors.

Referenced by add_neighbors_to_send_list().

368 { return _algebraic_ghosting_functors.begin(); }

libMesh::DofMap::_algebraic_ghosting_functors

std::set< GhostingFunctor * > _algebraic_ghosting_functors

Definition: dof_map.h:1605

◆ algebraic_ghosting_functors_end()

std::set<GhostingFunctor *>::const_iterator libMesh::DofMap::algebraic_ghosting_functors_end ( ) const

inline

End of range of algebraic ghosting functors

Definition at line 373 of file dof_map.h.

References _algebraic_ghosting_functors.

Referenced by add_neighbors_to_send_list().

374 { return _algebraic_ghosting_functors.end(); }

libMesh::DofMap::_algebraic_ghosting_functors

std::set< GhostingFunctor * > _algebraic_ghosting_functors

Definition: dof_map.h:1605

◆ 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 2400 of file dof_map.C.

References semilocal_index().

Referenced by is_evaluable().

 {
   // 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 2595 of file dof_map_constraints.C.

References libMesh::MeshBase::active_not_local_elements_begin(), libMesh::MeshBase::active_not_local_elements_end(), libMesh::as_range(), data, libMesh::DofObject::dof_number(), libMesh::DofObject::id(), libMesh::index_range(), libMesh::MeshBase::is_serial(), libMesh::libmesh_isnan(), mesh, libMesh::DofObject::n_comp(), n_nodes, n_vars, libMesh::DofObject::n_vars(), libMesh::MeshBase::node_ptr(), libMesh::DofObject::processor_id(), libMesh::Parallel::pull_parallel_vector_data(), libMesh::Parallel::push_parallel_vector_data(), libMesh::Real, libMesh::TypeVector< T >::size(), and libMesh::Parallel::wait().

 {
   // 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 heterogenous adjoint constraints we need to
   // communicate those too.
   const unsigned int max_qoi_num =
     _adjoint_constraint_values.empty() ?
     0 : _adjoint_constraint_values.rbegin()->first;
 
   // 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)
       {
         auto & node_keys_vals = pushed_node_keys_vals[p.first];
         node_keys_vals.reserve(p.second.size());
 
         auto & offsets = pushed_offsets[p.first];
         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.push_back
                 (std::make_pair(j.first->id(), j.second));
 
             offsets.push_back(_node_constraints[node].second);
           }
       }
 
     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 & p : received_id_vecs)
       {
         const processor_id_type pid = p.first;
         const auto & pushed_ids_to_me = p.second;
         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])
                   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.insert
                         (std::make_pair(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 & p : received_node_id_vecs)
       {
         const processor_id_type pid = p.first;
         const auto & pushed_node_ids_to_me = p.second;
         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);
 
   // 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(14142);
 
   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 (processor_id_type p = 0; p != this->n_processors(); ++p)
         if (node_ids_on_proc.count(p))
           requested_node_ids[p].reserve(node_ids_on_proc[p]);
 
       // 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;
 
       // We may need to send nodes ahead of data about them
       std::vector<Parallel::Request> packed_range_sends;
 
       auto node_row_gather_functor =
         [this,
          & mesh,
          & packed_range_sends,
          & range_tag]
         (processor_id_type pid,
          const std::vector<dof_id_type> & ids,
          std::vector<row_datum> & data)
         {
           // Do we need to keep track of requested nodes to send
           // later?
           const bool dist_mesh = !mesh.is_serial();
 
           // 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].push_back(std::make_pair(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].push_back
                     (std::make_pair(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,
          & 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 (!mesh.is_serial())
             this->comm().receive_packed_range
               (pid, &mesh, mesh_inserter_iterator<Node>(mesh),
                (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);
 
       Parallel::wait(packed_range_sends);
 
       // 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);
     }
 #endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
 }

◆ 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 429 of file dof_map.h.

References _extra_send_list_context, and _extra_send_list_function.

431 { _extra_send_list_function = func; _extra_send_list_context = context; }

libMesh::DofMap::_extra_send_list_context

void * _extra_send_list_context

Definition: dof_map.h:1579

libMesh::DofMap::_extra_send_list_function

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

Definition: dof_map.h:1574

◆ 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 420 of file dof_map.h.

References _augment_send_list.

   {
     _augment_send_list = &asl;
   }

◆ 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 406 of file dof_map.h.

References _extra_sparsity_context, and _extra_sparsity_function.

411 { _extra_sparsity_function = func; _extra_sparsity_context = context; }

libMesh::DofMap::_extra_sparsity_context

void * _extra_sparsity_context

Definition: dof_map.h:1564

libMesh::DofMap::_extra_sparsity_function

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

Definition: dof_map.h:1557

◆ attach_extra_sparsity_object()

void libMesh::DofMap::attach_extra_sparsity_object ( DofMap::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 391 of file dof_map.h.

References _augment_sparsity_pattern.

   {
     _augment_sparsity_pattern = &asp;
   }

◆ attach_matrix()

void libMesh::DofMap::attach_matrix ( SparseMatrix< Number > & matrix )

Additional matrices may be handled with this DofMap. They are initialized to the same sparsity structure as the major matrix.

Definition at line 262 of file dof_map.C.

References _matrices, _n_nz, _n_oz, _sp, libMesh::SparseMatrix< T >::attach_dof_map(), libMesh::ParallelObject::comm(), libMesh::Parallel::Communicator::max(), libMesh::SparseMatrix< T >::need_full_sparsity_pattern(), need_full_sparsity_pattern, and libMesh::SparseMatrix< T >::update_sparsity_pattern().

Referenced by libMesh::EigenSystem::init_matrices(), and libMesh::ImplicitSystem::init_matrices().

 {
   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);
 
   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
   bool computed_sparsity_already =
     ((_n_nz && !_n_nz->empty()) ||
      (_n_oz && !_n_oz->empty()));
   this->comm().max(computed_sparsity_already);
   if (computed_sparsity_already &&
       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);
       libmesh_assert(_sp.get());
 
       matrix.update_sparsity_pattern (_sp->sparsity_pattern);
     }
 
   if (matrix.need_full_sparsity_pattern())
     need_full_sparsity_pattern = true;
 }

◆ block_size()

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

inline

Returns: The block size, if the variables are amenable to block storage. Otherwise 1.

Definition at line 562 of file dof_map.h.

References has_blocked_representation(), and n_variables().

   {
 #ifdef LIBMESH_ENABLE_BLOCKED_STORAGE
     return (this->has_blocked_representation() ? this->n_variables() : 1);
 #else
     return 1;
 #endif
   }

◆ 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 2346 of file dof_map_constraints.C.

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

 {
   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());
     }
 }

◆ 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 heterogenous 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 2456 of file dof_map_constraints.C.

References 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 extract_local_vector().

 {
   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
         {
           const AdjointDofConstraintValues::const_iterator
             it = _adjoint_constraint_values.find(qoi_index);
           if (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)
               {
                 DofConstraintValueMap::const_iterator rhsit =
                   rhs_values->find(elem_dofs[i]);
                 if (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());
     }
 }

◆ build_sparsity()

std::unique_ptr< SparsityPattern::Build > libMesh::DofMap::build_sparsity ( const MeshBase & mesh ) const

private

Builds a sparsity pattern

Definition at line 58 of file dof_map.C.

References _augment_sparsity_pattern, _coupling_functors, _dof_coupling, _extra_sparsity_context, _extra_sparsity_function, libMesh::DofMap::AugmentSparsityPattern::augment_sparsity_pattern(), mesh, n_dofs_on_processor(), need_full_sparsity_pattern, libMesh::out, libMesh::Threads::parallel_reduce(), and use_coupled_neighbor_dofs().

Referenced by compute_sparsity().

 {
   libmesh_assert (mesh.is_prepared());
 
   LOG_SCOPE("build_sparsity()", "DofMap");
 
   // Compute the sparsity structure of the global matrix.  This can be
   // fed into a PetscMatrix 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);
 
   // 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.
   std::unique_ptr<SparsityPattern::Build> sp
     (new SparsityPattern::Build (mesh,
                                  *this,
                                  this->_dof_coupling,
                                  this->_coupling_functors,
                                  implicit_neighbor_dofs,
                                  need_full_sparsity_pattern));
 
   Threads::parallel_reduce (ConstElemRange (mesh.active_local_elements_begin(),
                                             mesh.active_local_elements_end()), *sp);
 
   sp->parallel_sync();
 
 #ifndef NDEBUG
   // Avoid declaring these variables unless asserts are enabled.
   const processor_id_type proc_id        = mesh.processor_id();
   const dof_id_type n_dofs_on_proc = this->n_dofs_on_processor(proc_id);
 #endif
   libmesh_assert_equal_to (sp->sparsity_pattern.size(), n_dofs_on_proc);
 
   // 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;
         }
 
       _extra_sparsity_function
         (sp->sparsity_pattern, sp->n_nz,
          sp->n_oz, _extra_sparsity_context);
     }
 
   if (_augment_sparsity_pattern)
     _augment_sparsity_pattern->augment_sparsity_pattern
       (sp->sparsity_pattern, sp->n_nz, sp->n_oz);
 
   return std::unique_ptr<SparsityPattern::Build>(sp.release());
 }

◆ check_dirichlet_bcid_consistency()

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

private

Check that all the ids in dirichlet_bcids are actually present in the mesh. If not, this will throw an error.

Definition at line 4362 of file dof_map_constraints.C.

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

 {
   const std::set<boundary_id_type>& mesh_bcids = mesh.get_boundary_info().get_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_bcids.find(bc_id) != mesh_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);
 
       if (!found_bcid)
         libmesh_error_msg("Could not find Dirichlet boundary id " << bc_id << " in mesh!");
     }
 }

◆ check_for_cyclic_constraints()

void libMesh::DofMap::check_for_cyclic_constraints ( )

Throw an error if we detect and cyclic constraints, since these are not supported by libMesh and give erroneous results if they are present.

Definition at line 3334 of file dof_map_constraints.C.

References libMesh::Real.

 {
   // 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)
               {
                 if (item.first == expandable)
                   libmesh_error_msg("Cyclic constraint 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;
       }
 }

◆ clear()

void libMesh::DofMap::clear ( )

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

Definition at line 828 of file dof_map.C.

References _adjoint_constraint_values, _algebraic_ghosting_functors, _coupling_functors, _default_coupling, _default_evaluating, _dof_constraints, _dof_coupling, _end_df, _end_old_df, _first_df, _first_old_df, _first_old_scalar_df, _first_scalar_df, _matrices, _mesh, _n_dfs, _n_old_dfs, _primal_constraint_values, _send_list, _stashed_dof_constraints, _variable_group_numbers, _variable_groups, _variables, add_algebraic_ghosting_functor(), add_coupling_functor(), clear_sparsity(), need_full_sparsity_pattern, libMesh::MeshBase::remove_ghosting_functor(), and use_coupled_neighbor_dofs().

Referenced by ~DofMap().

 {
   // 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);
   }
 
   _variables.clear();
   _variable_groups.clear();
   _variable_group_numbers.clear();
   _first_df.clear();
   _end_df.clear();
   _first_scalar_df.clear();
   _send_list.clear();
   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();
 
   _n_dfs = 0;
 }

◆ clear_sparsity()

void libMesh::DofMap::clear_sparsity ( )

Clears the sparsity pattern

Definition at line 1771 of file dof_map.C.

References _n_nz, _n_oz, _sp, and need_full_sparsity_pattern.

Referenced by clear(), libMesh::EigenSystem::reinit(), and libMesh::ImplicitSystem::reinit().

 {
   if (need_full_sparsity_pattern)
     {
       libmesh_assert(_sp.get());
       libmesh_assert(!_n_nz || _n_nz == &_sp->n_nz);
       libmesh_assert(!_n_oz || _n_oz == &_sp->n_oz);
       _sp.reset();
     }
   else
     {
       libmesh_assert(!_sp.get());
       delete _n_nz;
       delete _n_oz;
     }
   _n_nz = nullptr;
   _n_oz = nullptr;
 }

◆ comm()

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

inlineinherited

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

Definition at line 89 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

90 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

◆ 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 1739 of file dof_map.C.

References _matrices, _n_nz, _n_oz, _sp, build_sparsity(), and need_full_sparsity_pattern.

Referenced by libMesh::EigenSystem::init_matrices(), libMesh::ImplicitSystem::init_matrices(), libMesh::EigenSystem::reinit(), and libMesh::ImplicitSystem::reinit().

 {
   _sp = this->build_sparsity(mesh);
 
   // 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.
   if (need_full_sparsity_pattern)
     {
       _n_nz = &_sp->n_nz;
       _n_oz = &_sp->n_oz;
 
       for (const auto & mat : _matrices)
         mat->update_sparsity_pattern (_sp->sparsity_pattern);
     }
   // If we don't need the full sparsity pattern anymore, steal the
   // arrays we do need and free the rest of the memory
   else
     {
       if (!_n_nz)
         _n_nz = new std::vector<dof_id_type>();
       _n_nz->swap(_sp->n_nz);
       if (!_n_oz)
         _n_oz = new std::vector<dof_id_type>();
       _n_oz->swap(_sp->n_oz);
 
       _sp.reset();
     }
 }

◆ 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 2012 of file dof_map_constraints.C.

References libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseVector< T >::size(), and libMesh::DenseMatrix< T >::vector_mult_transpose().

 {
   libmesh_assert_equal_to (v.size(), row_dofs.size());
   libmesh_assert_equal_to (w.size(), row_dofs.size());
 
   // check for easy return
   if (this->_dof_constraints.empty())
     return;
 
   // The constrained RHS is built up as R^T F.
   DenseMatrix<Number> R;
 
   this->build_constraint_matrix (R, row_dofs);
 
   LOG_SCOPE("cnstrn_elem_dyad_mat()", "DofMap");
 
   // It is possible that the vector is not constrained at all.
   if ((R.m() == v.size()) &&
       (R.n() == row_dofs.size())) // if the RHS is constrained
     {
       // Compute the matrix-vector products
       DenseVector<Number> old_v(v);
       DenseVector<Number> old_w(w);
 
       // compute matrix/vector product
       R.vector_mult_transpose(v, old_v);
       R.vector_mult_transpose(w, old_w);
 
       libmesh_assert_equal_to (row_dofs.size(), v.size());
       libmesh_assert_equal_to (row_dofs.size(), w.size());
 
       /* Constrain only v, not w.  */
 
       for (unsigned int i=0,
            n_row_dofs = cast_int<unsigned int>(row_dofs.size());
            i != n_row_dofs; i++)
         if (this->is_constrained_dof(row_dofs[i]))
           {
             // If the DOF is constrained
             libmesh_assert (_dof_constraints.find(row_dofs[i]) != _dof_constraints.end());
 
             v(i) = 0;
           }
     } // end if the RHS is constrained.
 }

◆ 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 1545 of file dof_map_constraints.C.

References libMesh::DenseMatrix< T >::left_multiply_transpose(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), and libMesh::DenseMatrix< T >::right_multiply().

 {
   libmesh_assert_equal_to (elem_dofs.size(), matrix.m());
   libmesh_assert_equal_to (elem_dofs.size(), matrix.n());
 
   // check for easy return
   if (this->_dof_constraints.empty())
     return;
 
   // The constrained matrix is built up as C^T K C.
   DenseMatrix<Number> C;
 
 
   this->build_constraint_matrix (C, elem_dofs);
 
   LOG_SCOPE("constrain_elem_matrix()", "DofMap");
 
   // It is possible that the matrix is not constrained at all.
   if ((C.m() == matrix.m()) &&
       (C.n() == elem_dofs.size())) // It the matrix is constrained
     {
       // 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++)
         // If the DOF is constrained
         if (this->is_constrained_dof(elem_dofs[i]))
           {
             for (unsigned int j=0; j<matrix.n(); j++)
               matrix(i,j) = 0.;
 
             matrix(i,i) = 1.;
 
             if (asymmetric_constraint_rows)
               {
                 DofConstraints::const_iterator
                   pos = _dof_constraints.find(elem_dofs[i]);
 
                 libmesh_assert (pos != _dof_constraints.end());
 
                 const DofConstraintRow & constraint_row = pos->second;
 
                 // This is an overzealous assertion in the presence of
                 // heterogenous constraints: we now can constrain "u_i = c"
                 // with no other u_j terms involved.
                 //
                 // libmesh_assert (!constraint_row.empty());
 
                 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;
               }
           }
     } // end if is constrained...
 }

◆ 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 1878 of file dof_map_constraints.C.

References libMesh::DenseMatrix< T >::left_multiply_transpose(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), and libMesh::DenseMatrix< T >::right_multiply().

 {
   libmesh_assert_equal_to (row_dofs.size(), matrix.m());
   libmesh_assert_equal_to (col_dofs.size(), matrix.n());
 
   // check for easy return
   if (this->_dof_constraints.empty())
     return;
 
   // The constrained matrix is built up as R^T K C.
   DenseMatrix<Number> R;
   DenseMatrix<Number> C;
 
   // Safeguard against the user passing us the same
   // object for row_dofs and col_dofs.  If that is done
   // the calls to build_matrix would fail
   std::vector<dof_id_type> orig_row_dofs(row_dofs);
   std::vector<dof_id_type> orig_col_dofs(col_dofs);
 
   this->build_constraint_matrix (R, orig_row_dofs);
   this->build_constraint_matrix (C, orig_col_dofs);
 
   LOG_SCOPE("constrain_elem_matrix()", "DofMap");
 
   row_dofs = orig_row_dofs;
   col_dofs = orig_col_dofs;
 
   bool constraint_found = false;
 
   // K_constrained = R^T K C
 
   if ((R.m() == matrix.m()) &&
       (R.n() == row_dofs.size()))
     {
       matrix.left_multiply_transpose  (R);
       constraint_found = true;
     }
 
   if ((C.m() == matrix.n()) &&
       (C.n() == col_dofs.size()))
     {
       matrix.right_multiply (C);
       constraint_found = true;
     }
 
   // It is possible that the matrix is not constrained at all.
   if (constraint_found)
     {
       libmesh_assert_equal_to (matrix.m(), row_dofs.size());
       libmesh_assert_equal_to (matrix.n(), col_dofs.size());
 
 
       for (unsigned int i=0,
            n_row_dofs = cast_int<unsigned int>(row_dofs.size());
            i != n_row_dofs; i++)
         if (this->is_constrained_dof(row_dofs[i]))
           {
             for (unsigned int j=0; j<matrix.n(); j++)
               {
                 if (row_dofs[i] != col_dofs[j])
                   matrix(i,j) = 0.;
                 else // If the DOF is constrained
                   matrix(i,j) = 1.;
               }
 
             if (asymmetric_constraint_rows)
               {
                 DofConstraints::const_iterator
                   pos = _dof_constraints.find(row_dofs[i]);
 
                 libmesh_assert (pos != _dof_constraints.end());
 
                 const DofConstraintRow & constraint_row = pos->second;
 
                 libmesh_assert (!constraint_row.empty());
 
                 for (const auto & item : constraint_row)
                   for (unsigned int j=0,
                        n_col_dofs = cast_int<unsigned int>(col_dofs.size());
                        j != n_col_dofs; j++)
                     if (col_dofs[j] == item.first)
                       matrix(i,j) = -item.second;
               }
           }
     } // end if is constrained...
 }

◆ 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 1615 of file dof_map_constraints.C.

References libMesh::DenseMatrix< T >::left_multiply_transpose(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseMatrix< T >::right_multiply(), libMesh::DenseVector< T >::size(), and libMesh::DenseMatrix< T >::vector_mult_transpose().

 {
   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());
 
   // 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
   DenseMatrix<Number> C;
 
   this->build_constraint_matrix (C, elem_dofs);
 
   LOG_SCOPE("cnstrn_elem_mat_vec()", "DofMap");
 
   // It is possible that the matrix is not constrained at all.
   if ((C.m() == matrix.m()) &&
       (C.n() == elem_dofs.size())) // It the matrix is constrained
     {
       // 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++)
         if (this->is_constrained_dof(elem_dofs[i]))
           {
             for (unsigned int j=0; j<matrix.n(); j++)
               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.
             if (asymmetric_constraint_rows)
               {
                 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; j != n_elem_dofs; j++)
                     if (elem_dofs[j] == item.first)
                       matrix(i,j) = -item.second;
               }
           }
 
 
       // Compute the matrix-vector product C^T F
       DenseVector<Number> old_rhs(rhs);
 
       // compute matrix/vector product
       C.vector_mult_transpose(rhs, old_rhs);
     } // end if is constrained...
 }

◆ 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 1970 of file dof_map_constraints.C.

References libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseVector< T >::size(), and libMesh::DenseMatrix< T >::vector_mult_transpose().

 {
   libmesh_assert_equal_to (rhs.size(), row_dofs.size());
 
   // check for easy return
   if (this->_dof_constraints.empty())
     return;
 
   // The constrained RHS is built up as R^T F.
   DenseMatrix<Number> R;
 
   this->build_constraint_matrix (R, row_dofs);
 
   LOG_SCOPE("constrain_elem_vector()", "DofMap");
 
   // It is possible that the vector is not constrained at all.
   if ((R.m() == rhs.size()) &&
       (R.n() == row_dofs.size())) // if the RHS is constrained
     {
       // Compute the matrix-vector product
       DenseVector<Number> old_rhs(rhs);
       R.vector_mult_transpose(rhs, old_rhs);
 
       libmesh_assert_equal_to (row_dofs.size(), rhs.size());
 
       for (unsigned int i=0,
            n_row_dofs = cast_int<unsigned int>(row_dofs.size());
            i != n_row_dofs; i++)
         if (this->is_constrained_dof(row_dofs[i]))
           {
             // If the DOF is constrained
             libmesh_assert (_dof_constraints.find(row_dofs[i]) != _dof_constraints.end());
 
             rhs(i) = 0;
           }
     } // end if the RHS is constrained.
 }

◆ constrain_nothing()

void libMesh::DofMap::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. adds those dofs in terms of which any of the existing dofs is constrained.

Definition at line 2063 of file dof_map_constraints.C.

 {
   // check for easy return
   if (this->_dof_constraints.empty())
     return;
 
   // All the work is done by \p build_constraint_matrix.  We just need
   // a dummy matrix.
   DenseMatrix<Number> R;
   this->build_constraint_matrix (R, dofs);
 }

◆ 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 4208 of file dof_map_constraints.C.

References libMesh::Elem::dim(), libMesh::DofObject::dof_number(), libMesh::Elem::is_node_on_side(), libMesh::Elem::is_vertex(), libMesh::DofObject::n_comp(), n_nodes, libMesh::Elem::n_nodes(), libMesh::Elem::n_sides(), libMesh::Elem::node_ref(), libMesh::FEType::order, libMesh::Elem::p_level(), libMesh::Threads::spin_mtx, and libMesh::Elem::type().

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), and libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints().

 {
   // 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();
   const unsigned int dim = elem->dim();
   ElemType type = elem->type();
   FEType low_p_fe_type = this->variable_type(var);
   FEType high_p_fe_type = this->variable_type(var);
   low_p_fe_type.order = static_cast<Order>(low_p_fe_type.order + p);
   high_p_fe_type.order = static_cast<Order>(high_p_fe_type.order +
                                             elem->p_level());
 
   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 (dim, low_p_fe_type, type, n);
         const unsigned int high_nc =
           FEInterface::n_dofs_at_node (dim, high_p_fe_type, type, 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));
               }
           }
       }
 }

◆ 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 902 of file dof_map.h.

References _dof_constraints.

903 { return _dof_constraints.begin(); }

libMesh::DofMap::_dof_constraints

DofConstraints _dof_constraints

Definition: dof_map.h:1687

◆ 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 908 of file dof_map.h.

References _dof_constraints.

909 { return _dof_constraints.end(); }

libMesh::DofMap::_dof_constraints

DofConstraints _dof_constraints

Definition: dof_map.h:1687

◆ coupling_functors_begin()

std::set<GhostingFunctor *>::const_iterator libMesh::DofMap::coupling_functors_begin ( ) const

inline

Beginning of range of coupling functors

Definition at line 317 of file dof_map.h.

References _coupling_functors.

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

318 { return _coupling_functors.begin(); }

libMesh::DofMap::_coupling_functors

std::set< GhostingFunctor * > _coupling_functors

Definition: dof_map.h:1618

◆ coupling_functors_end()

std::set<GhostingFunctor *>::const_iterator libMesh::DofMap::coupling_functors_end ( ) const

inline

End of range of coupling functors

Definition at line 323 of file dof_map.h.

References _coupling_functors.

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

324 { return _coupling_functors.end(); }

libMesh::DofMap::_coupling_functors

std::set< GhostingFunctor * > _coupling_functors

Definition: dof_map.h:1618

◆ create_dof_constraints()

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

Rebuilds the raw degree of freedom and DofObject constraints. A time is specified for use in building time-dependent Dirichlet constraints.

Definition at line 1194 of file dof_map_constraints.C.

References libMesh::StoredRange< iterator_type, object_type >::empty(), libMesh::MeshBase::is_prepared(), libMesh::MeshBase::is_serial(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshBase::local_elements_begin(), libMesh::MeshBase::local_elements_end(), mesh, libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_elem(), libMesh::Threads::parallel_for(), libMesh::StoredRange< iterator_type, object_type >::reset(), and libMesh::MeshBase::sub_point_locator().

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

 {
   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
 
   // We might get constraint equations from AMR hanging nodes in 2D/3D
   // or from boundary conditions in any dimension
   const bool possible_local_constraints = false
     || !mesh.n_elem()
 #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
 
   if (!possible_global_constraints)
     {
       // Clear out any old constraints; maybe the user just deleted
       // their last remaining dirichlet/periodic/user constraint?
 #ifdef LIBMESH_ENABLE_CONSTRAINTS
       _dof_constraints.clear();
       _stashed_dof_constraints.clear();
       _primal_constraint_values.clear();
       _adjoint_constraint_values.clear();
 #endif
 #ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
       _node_constraints.clear();
 #endif
 
       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
   // recalculate node constraints from scratch
   _node_constraints.clear();
 
   Threads::parallel_for (range,
                          ComputeNodeConstraints (_node_constraints,
 #ifdef LIBMESH_ENABLE_PERIODIC
                                                  *_periodic_boundaries,
 #endif
                                                  mesh));
 #endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
 
 
   // recalculate dof constraints from scratch
   _dof_constraints.clear();
   _stashed_dof_constraints.clear();
   _primal_constraint_values.clear();
   _adjoint_constraint_values.clear();
 
   // Look at all the variables in the system.  Reset the element
   // range at each iteration -- there is no need to reconstruct it.
   for (unsigned int variable_number=0; variable_number<this->n_variables();
        ++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
   for (DirichletBoundaries::iterator
          i = _dirichlet_boundaries->begin();
        i != _dirichlet_boundaries->end(); ++i, range.reset())
     {
       // Sanity check that the boundary ids associated with the DirichletBoundary
       // objects are actually present in the mesh
       this->check_dirichlet_bcid_consistency(mesh,**i);
 
       Threads::parallel_for
         (range,
          ConstrainDirichlet(*this, mesh, time, **i,
                             AddPrimalConstraint(*this))
          );
     }
 
   for (unsigned int qoi_index = 0,
        n_qois = cast_int<unsigned int>(_adjoint_dirichlet_boundaries.size());
        qoi_index != n_qois; ++qoi_index)
     {
       for (DirichletBoundaries::iterator
              i = _adjoint_dirichlet_boundaries[qoi_index]->begin();
            i != _adjoint_dirichlet_boundaries[qoi_index]->end();
            ++i, range.reset())
         {
           // Sanity check that the boundary ids associated with the DirichletBoundary
           // objects are actually present in the mesh
           this->check_dirichlet_bcid_consistency(mesh,**i);
 
           Threads::parallel_for
             (range,
              ConstrainDirichlet(*this, mesh, time, **i,
                                 AddAdjointConstraint(*this, qoi_index))
              );
         }
     }
 
 #endif // LIBMESH_ENABLE_DIRICHLET
 }

◆ default_algebraic_ghosting()

DefaultCoupling& libMesh::DofMap::default_algebraic_ghosting ( )

inline

Default algebraic ghosting functor

Definition at line 379 of file dof_map.h.

References _default_evaluating.

Referenced by add_default_ghosting(), and remove_default_ghosting().

379 { return *_default_evaluating; }

libMesh::DofMap::_default_evaluating

std::unique_ptr< DefaultCoupling > _default_evaluating

Definition: dof_map.h:1595

◆ default_coupling()

DefaultCoupling& libMesh::DofMap::default_coupling ( )

inline

Default coupling functor

Definition at line 329 of file dof_map.h.

References _default_coupling.

Referenced by add_default_ghosting(), and remove_default_ghosting().

329 { return *_default_coupling; }

libMesh::DofMap::_default_coupling

std::unique_ptr< DefaultCoupling > _default_coupling

Definition: dof_map.h:1587

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

 {
   _enable_print_counter = false;
   return;
 }

◆ distribute_dofs()

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

Definition at line 902 of file dof_map.C.

References _algebraic_ghosting_functors, _coupling_functors, _end_df, _end_old_df, _first_df, _first_old_df, _first_old_scalar_df, _first_scalar_df, _n_dfs, _n_old_dfs, _send_list, add_neighbors_to_send_list(), libMesh::Parallel::Communicator::allgather(), libMesh::ParallelObject::comm(), distribute_local_dofs_node_major(), distribute_local_dofs_var_major(), libMesh::DofObject::dof_number(), elem_ptr(), libMesh::MeshBase::elements_begin(), end_dof(), libMesh::FEType::family, first_dof(), libMesh::OrderWrapper::get_order(), libMesh::DofObject::invalid_id, invalidate_dofs(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), mesh, libMesh::DofObject::n_comp(), n_dofs(), libMesh::ParallelObject::n_processors(), n_SCALAR_dofs(), n_variables(), libMesh::DofObject::n_vars(), node_ptr(), libMesh::MeshBase::nodes_begin(), libMesh::on_command_line(), libMesh::FEType::order, libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), reinit(), libMesh::SCALAR, set_nonlocal_dof_objects(), sys_number(), libMesh::Variable::type(), and variable().

Referenced by libMesh::EquationSystems::allgather(), and libMesh::EquationSystems::reinit_solutions().

 {
   // 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();
   const processor_id_type n_proc  = this->n_processors();
 
   //  libmesh_assert_greater (this->n_variables(), 0);
   libmesh_assert_less (proc_id, n_proc);
 
   // re-init in case the mesh has changed
   this->reinit(mesh);
 
   // 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
   _send_list.clear();
 
   // Set temporary DOF indices on this processor
   if (node_major_dofs)
     this->distribute_local_dofs_node_major (next_free_dof, mesh);
   else
     this->distribute_local_dofs_var_major (next_free_dof, mesh);
 
   // Get DOF counts on all processors
   std::vector<dof_id_type> dofs_on_proc(n_proc, 0);
   this->comm().allgather(next_free_dof, dofs_on_proc);
 
   // Resize and fill the _first_df and _end_df arrays
 #ifdef LIBMESH_ENABLE_AMR
   _first_old_df = _first_df;
   _end_old_df = _end_df;
 #endif
 
   _first_df.resize(n_proc);
   _end_df.resize (n_proc);
 
   // Get DOF offsets
   _first_df[0] = 0;
   for (processor_id_type i=1; i < n_proc; ++i)
     _first_df[i] = _end_df[i-1] = _first_df[i-1] + dofs_on_proc[i-1];
   _end_df[n_proc-1] = _first_df[n_proc-1] + dofs_on_proc[n_proc-1];
 
   // 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);
   else
     this->distribute_local_dofs_var_major (next_free_dof, mesh);
 
   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 (unsigned int v=0; v != dofobj->n_vars(sys_num); ++v)
           for (unsigned int c=0; c != dofobj->n_comp(sys_num,v); ++c)
             {
               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 (unsigned int v=0; v != dofobj->n_vars(sys_num); ++v)
           for (unsigned int c=0; c != dofobj->n_comp(sys_num,v); ++c)
             {
               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
 
   // Set the total number of degrees of freedom, then start finding
   // SCALAR degrees of freedom
 #ifdef LIBMESH_ENABLE_AMR
   _n_old_dfs = _n_dfs;
   _first_old_scalar_df = _first_scalar_df;
 #endif
   _n_dfs = _end_df[n_proc-1];
   _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 (unsigned int v=0; v<this->n_variables(); v++)
     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 ();
 }

◆ distribute_local_dofs_node_major()

void libMesh::DofMap::distribute_local_dofs_node_major	(	dof_id_type &	next_free_dof,
		MeshBase &	mesh
	)

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.

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 1163 of file dof_map.C.

References _n_SCALAR_dofs, libMesh::Variable::active_on_subdomain(), libMesh::FEType::family, libMesh::OrderWrapper::get_order(), libMesh::DofObject::invalid_id, mesh, libMesh::DofObject::n_comp_group(), n_nodes, libMesh::ParallelObject::n_processors(), n_variable_groups(), libMesh::VariableGroup::n_variables(), libMesh::FEType::order, libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::SCALAR, libMesh::DofObject::set_vg_dof_base(), sys_number(), libMesh::Variable::type(), variable_group(), and libMesh::DofObject::vg_dof_base().

Referenced by distribute_dofs().

 {
   const unsigned int sys_num       = this->sys_number();
   const unsigned int n_var_groups  = this->n_variable_groups();
 
   // 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();
 
       // 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) &&
                   (vg_description.active_on_subdomain(elem->subdomain_id())))
                 {
                   // 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(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));
             }
       }
 
   // Finally, count up the SCALAR dofs
   this->_n_SCALAR_dofs = 0;
   for (unsigned vg=0; vg<n_var_groups; vg++)
     {
       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;
 
 #ifdef DEBUG
   {
     // libMesh::out << "next_free_dof=" << next_free_dof << std::endl
     //       << "_n_SCALAR_dofs=" << _n_SCALAR_dofs << std::endl;
 
     // Make sure we didn't miss any nodes
     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);
           }
       }
   }
 #endif // DEBUG
 }

◆ distribute_local_dofs_var_major()

void libMesh::DofMap::distribute_local_dofs_var_major	(	dof_id_type &	next_free_dof,
		MeshBase &	mesh
	)

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.

Definition at line 1302 of file dof_map.C.

References _n_SCALAR_dofs, libMesh::Variable::active_on_subdomain(), libMesh::FEType::family, libMesh::OrderWrapper::get_order(), libMesh::DofObject::invalid_id, mesh, libMesh::DofObject::n_comp_group(), n_nodes, libMesh::ParallelObject::n_processors(), n_variable_groups(), libMesh::VariableGroup::n_variables(), libMesh::FEType::order, libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::SCALAR, libMesh::DofObject::set_vg_dof_base(), sys_number(), libMesh::Variable::type(), variable_group(), and libMesh::DofObject::vg_dof_base().

Referenced by distribute_dofs().

 {
   const unsigned int sys_num      = this->sys_number();
   const unsigned int n_var_groups = this->n_variable_groups();
 
   // 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 variables which are active on on this
           // element's subdomain.
           if (!vg_description.active_on_subdomain(elem->subdomain_id()))
             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);
 
               // 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
 
   // Finally, count up the SCALAR dofs
   this->_n_SCALAR_dofs = 0;
   for (unsigned vg=0; vg<n_var_groups; vg++)
     {
       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;
 
 #ifdef DEBUG
   {
     // Make sure we didn't miss any nodes
     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);
           }
       }
   }
 #endif // DEBUG
 }

◆ dof_indices() [1/4]

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

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

Definition at line 1930 of file dof_map.C.

References _dof_indices(), libMesh::Elem::active(), libMesh::Variable::active_on_subdomain(), libMesh::FEType::family, libMesh::MeshTools::Subdivision::find_one_ring(), libMesh::Elem::get_nodes(), libMesh::Tri3Subdivision::is_ghost(), n_nodes, libMesh::Elem::n_nodes(), n_variable_groups(), libMesh::VariableGroup::n_variables(), 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().

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), add_neighbors_to_send_list(), libMesh::HPCoarsenTest::add_projection(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::System::calculate_norm(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::MeshFunction::discontinuous_gradient(), libMesh::MeshFunction::discontinuous_value(), DMCreateDomainDecomposition_libMesh(), DMCreateFieldDecomposition_libMesh(), dof_indices(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshFunction::gradient(), libMesh::MeshFunction::hessian(), libMesh::SystemSubsetBySubdomain::init(), is_evaluable(), libMesh::System::local_dof_indices(), libMesh::DGFEMContext::neighbor_side_fe_reinit(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::MeshFunction::operator()(), libMesh::BoundaryProjectSolution::operator()(), libMesh::ErrorVector::plot_error(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::FEMContext::pre_fe_reinit(), libMesh::HPCoarsenTest::select_refinement(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::SparsityPattern::Build::sorted_connected_dofs(), libMesh::EnsightIO::write_scalar_ascii(), and libMesh::EnsightIO::write_vector_ascii().

 {
   // 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 Side proxy, which also thinks it's
   // active)
   libmesh_assert(!elem || elem->active());
 
   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())
 #ifdef DEBUG
                                  , var.number(vig), 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
 #ifdef DEBUG
                          , var.number(vig), tot_size
 #endif
                      );
           }
     }
 
 #ifdef DEBUG
   libmesh_assert_equal_to (tot_size, di.size());
 #endif
 }

◆ dof_indices() [2/4]

void libMesh::DofMap::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. For one variable, and potentially for a non-default element p refinement level

Definition at line 2040 of file dof_map.C.

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

 {
   // We now allow elem==nullptr to request just SCALAR dofs
   // libmesh_assert(elem);
 
   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())
 #ifdef DEBUG
                        , vn, tot_size
 #endif
                        );
         }
 
       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);
       di.insert( di.end(), di_new.begin(), di_new.end());
     }
   else if (elem)
     _dof_indices(*elem, p_level, di, vg, vig, elem->get_nodes(),
                  elem->n_nodes()
 #ifdef DEBUG
                  , vn, tot_size
 #endif
                  );
 
 #ifdef DEBUG
   libmesh_assert_equal_to (tot_size, di.size());
 #endif
 }

◆ dof_indices() [3/4]

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 2115 of file dof_map.C.

References libMesh::DofObject::dof_number(), libMesh::FEType::family, libMesh::DofObject::invalid_id, libMesh::DofObject::n_comp_group(), n_variable_groups(), libMesh::VariableGroup::n_variables(), libMesh::VariableGroup::number(), libMesh::SCALAR, SCALAR_dof_indices(), sys_number(), libMesh::Variable::type(), and variable_group().

 {
   // We allow node==nullptr to request just SCALAR dofs
   // libmesh_assert(elem);
 
   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);
                 }
             }
         }
     }
 }

◆ dof_indices() [4/4]

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

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

Definition at line 2163 of file dof_map.C.

References _variable_group_numbers, dof_indices(), libMesh::DofObject::dof_number(), libMesh::FEType::family, libMesh::DofObject::invalid_id, libMesh::invalid_uint, libMesh::DofObject::n_comp_group(), libMesh::VariableGroup::number(), libMesh::SCALAR, SCALAR_dof_indices(), sys_number(), libMesh::Variable::type(), and variable_group().

 {
   if (vn == libMesh::invalid_uint)
     {
       this->dof_indices(node, di);
       return;
     }
 
   // We allow node==nullptr to request just SCALAR dofs
   // libmesh_assert(elem);
 
   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);
         }
     }
 }

◆ 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 650 of file dof_map.h.

References _end_df.

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

   { 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());
   }

◆ 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 313 of file dof_map.C.

References mesh.

Referenced by distribute_dofs().

 {
   return mesh.elem_ptr(i);
 }

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

 {
   _enable_print_counter = true;
   return;
 }

◆ end_dof() [1/2]

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

inline

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 641 of file dof_map.h.

References _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(), libMesh::SparsityPattern::Build::operator()(), and libMesh::SparsityPattern::Build::parallel_sync().

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

libMesh::DofMap::_end_df

std::vector< dof_id_type > _end_df

Definition: dof_map.h:1535

◆ end_dof() [2/2]

dof_id_type libMesh::DofMap::end_dof ( ) const

inline

Definition at line 644 of file dof_map.h.

References libMesh::ParallelObject::processor_id().

Referenced by distribute_dofs(), and local_index().

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

libMesh::DofMap::end_dof

dof_id_type end_dof() const

Definition: dof_map.h:644

libMesh::ParallelObject::processor_id

processor_id_type processor_id() const

Definition: parallel_object.h:101

◆ end_old_dof() [1/2]

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

inline

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 664 of file dof_map.h.

References _end_old_df.

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

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

libMesh::DofMap::_end_old_df

std::vector< dof_id_type > _end_old_df

Definition: dof_map.h:1672

◆ end_old_dof() [2/2]

dof_id_type libMesh::DofMap::end_old_dof ( ) const

inline

Definition at line 667 of file dof_map.h.

References libMesh::ParallelObject::processor_id().

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

libMesh::DofMap::end_old_dof

dof_id_type end_old_dof() const

Definition: dof_map.h:667

libMesh::ParallelObject::processor_id

processor_id_type processor_id() const

Definition: parallel_object.h:101

◆ enforce_adjoint_constraints_exactly()

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

inline

Heterogenously 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 2170 of file dof_map_constraints.C.

References libMesh::NumericVector< T >::close(), libMesh::NumericVector< T >::closed(), libMesh::NumericVector< T >::get(), libMesh::GHOSTED, libMesh::NumericVector< T >::localize(), libMesh::PARALLEL, libMesh::SERIAL, libMesh::NumericVector< T >::set(), libMesh::NumericVector< T >::size(), and libMesh::NumericVector< T >::type().

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

 {
   parallel_object_only();
 
   if (!this->n_constrained_dofs())
     return;
 
   LOG_SCOPE("enforce_adjoint_constraints_exactly()", "DofMap");
 
   NumericVector<Number> * v_local  = nullptr; // will be initialized below
   NumericVector<Number> * v_global = nullptr; // will be initialized below
   std::unique_ptr<NumericVector<Number>> v_built;
   if (v.type() == SERIAL)
     {
       v_built = NumericVector<Number>::build(this->comm());
       v_built->init(this->n_dofs(), this->n_local_dofs(), true, PARALLEL);
       v_built->close();
 
       for (dof_id_type i=v_built->first_local_index();
            i<v_built->last_local_index(); i++)
         v_built->set(i, v(i));
       v_built->close();
       v_global = v_built.get();
 
       v_local = &v;
       libmesh_assert (v_local->closed());
     }
   else if (v.type() == PARALLEL)
     {
       v_built = NumericVector<Number>::build(this->comm());
       v_built->init (v.size(), v.size(), true, SERIAL);
       v.localize(*v_built);
       v_built->close();
       v_local = v_built.get();
 
       v_global = &v;
     }
   else if (v.type() == GHOSTED)
     {
       v_local = &v;
       v_global = &v;
     }
   else // unknown v.type()
     libmesh_error_msg("ERROR: Unknown v.type() == " << v.type());
 
   // We should never hit these asserts because we should error-out in
   // else clause above.  Just to be sure we don't try to use v_local
   // and v_global uninitialized...
   libmesh_assert(v_local);
   libmesh_assert(v_global);
 
   // Do we have any non_homogeneous constraints?
   const AdjointDofConstraintValues::const_iterator
     adjoint_constraint_map_it = _adjoint_constraint_values.find(q);
   const DofConstraintValueMap * constraint_map =
     (adjoint_constraint_map_it == _adjoint_constraint_values.end()) ?
     nullptr : &adjoint_constraint_map_it->second;
 
   for (const auto & pr : _dof_constraints)
     {
       dof_id_type constrained_dof = pr.first;
       if (!this->local_index(constrained_dof))
         continue;
 
       const DofConstraintRow constraint_row = pr.second;
 
       Number exact_value = 0;
       if (constraint_map)
         {
           const DofConstraintValueMap::const_iterator
             adjoint_constraint_it =
             constraint_map->find(constrained_dof);
           if (adjoint_constraint_it != constraint_map->end())
             exact_value = adjoint_constraint_it->second;
         }
 
       for (const auto & j : constraint_row)
         exact_value += j.second * (*v_local)(j.first);
 
       v_global->set(constrained_dof, exact_value);
     }
 
   // If the old vector was serial, we probably need to send our values
   // to other processors
   if (v.type() == SERIAL)
     {
 #ifndef NDEBUG
       v_global->close();
 #endif
       v_global->localize (v);
     }
   v.close();
 }

◆ 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 2077 of file dof_map_constraints.C.

References libMesh::NumericVector< T >::close(), libMesh::NumericVector< T >::closed(), libMesh::NumericVector< T >::get(), libMesh::System::get_dof_map(), libMesh::GHOSTED, libMesh::NumericVector< T >::localize(), libMesh::PARALLEL, libMesh::SERIAL, libMesh::NumericVector< T >::set(), libMesh::NumericVector< T >::size(), libMesh::System::solution, and libMesh::NumericVector< T >::type().

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), DMlibMeshFunction(), DMlibMeshJacobian(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_residual_helper(), libMesh::ImplicitSystem::sensitivity_solve(), libMesh::NewtonSolver::solve(), libMesh::PetscDiffSolver::solve(), libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve(), and libMesh::ImplicitSystem::weighted_sensitivity_solve().

 {
   parallel_object_only();
 
   if (!this->n_constrained_dofs())
     return;
 
   LOG_SCOPE("enforce_constraints_exactly()","DofMap");
 
   if (!v)
     v = system.solution.get();
 
   NumericVector<Number> * v_local  = nullptr; // will be initialized below
   NumericVector<Number> * v_global = nullptr; // will be initialized below
   std::unique_ptr<NumericVector<Number>> v_built;
   if (v->type() == SERIAL)
     {
       v_built = NumericVector<Number>::build(this->comm());
       v_built->init(this->n_dofs(), this->n_local_dofs(), true, PARALLEL);
       v_built->close();
 
       for (dof_id_type i=v_built->first_local_index();
            i<v_built->last_local_index(); i++)
         v_built->set(i, (*v)(i));
       v_built->close();
       v_global = v_built.get();
 
       v_local = v;
       libmesh_assert (v_local->closed());
     }
   else if (v->type() == PARALLEL)
     {
       v_built = NumericVector<Number>::build(this->comm());
       v_built->init (v->size(), v->size(), true, SERIAL);
       v->localize(*v_built);
       v_built->close();
       v_local = v_built.get();
 
       v_global = v;
     }
   else if (v->type() == GHOSTED)
     {
       v_local = v;
       v_global = v;
     }
   else // unknown v->type()
     libmesh_error_msg("ERROR: Unknown v->type() == " << v->type());
 
   // We should never hit these asserts because we should error-out in
   // else clause above.  Just to be sure we don't try to use v_local
   // and v_global uninitialized...
   libmesh_assert(v_local);
   libmesh_assert(v_global);
   libmesh_assert_equal_to (this, &(system.get_dof_map()));
 
   for (const auto & pr : _dof_constraints)
     {
       dof_id_type constrained_dof = pr.first;
       if (!this->local_index(constrained_dof))
         continue;
 
       const DofConstraintRow constraint_row = pr.second;
 
       Number exact_value = 0;
       if (!homogeneous)
         {
           DofConstraintValueMap::const_iterator rhsit =
             _primal_constraint_values.find(constrained_dof);
           if (rhsit != _primal_constraint_values.end())
             exact_value = rhsit->second;
         }
       for (const auto & j : constraint_row)
         exact_value += j.second * (*v_local)(j.first);
 
       v_global->set(constrained_dof, exact_value);
     }
 
   // If the old vector was serial, we probably need to send our values
   // to other processors
   if (v->type() == SERIAL)
     {
 #ifndef NDEBUG
       v_global->close();
 #endif
       v_global->localize (*v);
     }
   v->close();
 }

◆ 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 1848 of file dof_map.C.

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

 {
   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
 }

◆ 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 2633 of file dof_map.C.

References _dof_constraints, and is_constrained_dof().

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

 {
   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)
 }

◆ first_dof() [1/2]

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

inline

Returns: The first dof index that is local to partition proc.

Definition at line 599 of file dof_map.h.

References _first_df.

Referenced by libMesh::PetscDMWrapper::build_sf(), DMCreateDomainDecomposition_libMesh(), DMCreateFieldDecomposition_libMesh(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::SystemSubsetBySubdomain::init(), libMesh::SparsityPattern::Build::join(), libMesh::System::local_dof_indices(), libMesh::SparsityPattern::Build::operator()(), and libMesh::SparsityPattern::Build::parallel_sync().

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

libMesh::DofMap::_first_df

std::vector< dof_id_type > _first_df

Definition: dof_map.h:1530

◆ first_dof() [2/2]

dof_id_type libMesh::DofMap::first_dof ( ) const

inline

Definition at line 602 of file dof_map.h.

References libMesh::ParallelObject::processor_id().

Referenced by distribute_dofs(), and local_index().

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

libMesh::DofMap::first_dof

dof_id_type first_dof() const

Definition: dof_map.h:602

libMesh::ParallelObject::processor_id

processor_id_type processor_id() const

Definition: parallel_object.h:101

◆ first_old_dof() [1/2]

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

inline

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

Definition at line 609 of file dof_map.h.

References _first_old_df.

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

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

libMesh::DofMap::_first_old_df

std::vector< dof_id_type > _first_old_df

Definition: dof_map.h:1667

◆ first_old_dof() [2/2]

dof_id_type libMesh::DofMap::first_old_dof ( ) const

inline

Definition at line 612 of file dof_map.h.

References libMesh::ParallelObject::processor_id().

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

libMesh::DofMap::first_old_dof

dof_id_type first_old_dof() const

Definition: dof_map.h:612

libMesh::ParallelObject::processor_id

processor_id_type processor_id() const

Definition: parallel_object.h:101

◆ 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 3871 of file dof_map_constraints.C.

References data, libMesh::Parallel::pull_parallel_vector_data(), and libMesh::Real.

 {
   typedef std::set<dof_id_type> DoF_RCSet;
 
   // If we have heterogenous adjoint constraints we need to
   // communicate those too.
   const unsigned int max_qoi_num =
     _adjoint_constraint_values.empty() ?
     0 : _adjoint_constraint_values.rbegin()->first;
 
   // 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)
         {
           DofConstraints::const_iterator
             pos = _dof_constraints.find(unexpanded_dof);
 
           // 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 (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].push_back
                     (std::make_pair(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])
                     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.insert
                           (std::make_pair(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);
     }
 }

◆ get_adjoint_dirichlet_boundaries() [1/2]

const DirichletBoundaries * libMesh::DofMap::get_adjoint_dirichlet_boundaries ( unsigned int q ) const

Definition at line 4302 of file dof_map_constraints.C.

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

◆ get_adjoint_dirichlet_boundaries() [2/2]

DirichletBoundaries * libMesh::DofMap::get_adjoint_dirichlet_boundaries ( unsigned int q )

Definition at line 4310 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(new DirichletBoundaries());
 
   return _adjoint_dirichlet_boundaries[q];
 }

◆ get_dirichlet_boundaries() [1/2]

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

inline

Definition at line 1223 of file dof_map.h.

References _dirichlet_boundaries.

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

   {
     return _dirichlet_boundaries.get();
   }

◆ get_dirichlet_boundaries() [2/2]

DirichletBoundaries* libMesh::DofMap::get_dirichlet_boundaries ( )

inline

Definition at line 1228 of file dof_map.h.

References _dirichlet_boundaries.

   {
     return _dirichlet_boundaries.get();
   }

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

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

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

 {
 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
   std::ostringstream oss;
 
   oss << '\n'
       << " ---------------------------------------------------------------------------- \n"
       << "| Reference count information                                                |\n"
       << " ---------------------------------------------------------------------------- \n";
 
   for (const auto & pr : _counts)
     {
       const std::string name(pr.first);
       const unsigned int creations    = pr.second.first;
       const unsigned int destructions = pr.second.second;
 
       oss << "| " << name << " reference count information:\n"
           << "|  Creations:    " << creations    << '\n'
           << "|  Destructions: " << destructions << '\n';
     }
 
   oss << " ---------------------------------------------------------------------------- \n";
 
   return oss.str();
 
 #else
 
   return "";
 
 #endif
 }

◆ get_info() [2/2]

std::string libMesh::DofMap::get_info ( ) const

Gets summary info about the sparsity bandwidth and constraints.

Definition at line 2703 of file dof_map.C.

References _dof_constraints, _matrices, _n_nz, _n_oz, _node_constraints, _primal_constraint_values, libMesh::ParallelObject::comm(), local_index(), std::max(), libMesh::Parallel::Communicator::max(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::TypeVector< T >::size(), and libMesh::Parallel::Communicator::sum().

Referenced by libMesh::System::get_info(), and print_info().

 {
   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 (_n_nz)
     {
       for (const auto & val : *_n_nz)
         {
           max_n_nz = std::max(max_n_nz, val);
           avg_n_nz += val;
         }
 
       std::size_t n_nz_size = _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));
 
       libmesh_assert(_n_oz);
 
       for (const auto & val : *_n_oz)
         {
           max_n_oz = std::max(max_n_oz, val);
           avg_n_oz += val;
         }
 
       std::size_t n_oz_size = _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 & pr : _dof_constraints)
     {
       // Only count local constraints, then sum later
       const dof_id_type constrained_dof = pr.first;
       if (!this->local_index(constrained_dof))
         continue;
 
       const DofConstraintRow & row = pr.second;
       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 & pr : _node_constraints)
     {
       // Only count local constraints, then sum later
       const Node * node = pr.first;
       if (node->processor_id() != this->processor_id())
         continue;
 
       const NodeConstraintRow & row = pr.second.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.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 1444 of file dof_map_constraints.C.

References libMesh::DofObject::id(), and libMesh::DofObject::processor_id().

 {
   std::ostringstream os;
 #ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
   if (print_nonlocal)
     os << "All ";
   else
     os << "Local ";
 
   os << "Node Constraints:"
      << std::endl;
 
   for (const auto & pr : _node_constraints)
     {
       const Node * node = pr.first;
 
       // Skip non-local nodes if requested
       if (!print_nonlocal &&
           node->processor_id() != this->processor_id())
         continue;
 
       const NodeConstraintRow & row = pr.second.first;
       const Point & offset = pr.second.second;
 
       os << "Constraints for Node id " << node->id()
          << ": \t";
 
       for (const auto & item : row)
         os << " (" << item.first->id() << "," << item.second << ")\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 & pr : _dof_constraints)
     {
       const dof_id_type i = pr.first;
 
       // Skip non-local dofs if requested
       if (!print_nonlocal && !this->local_index(i))
         continue;
 
       const DofConstraintRow & row = pr.second;
       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;
 
       AdjointDofConstraintValues::const_iterator adjoint_map_it =
         _adjoint_constraint_values.find(qoi_index);
 
       if (adjoint_map_it != _adjoint_constraint_values.end())
         for (const auto & pr : adjoint_map_it->second)
           {
             const dof_id_type i = pr.first;
 
             // Skip non-local dofs if requested
             if (!print_nonlocal && !this->local_index(i))
               continue;
 
             const Number rhs = pr.second;
 
             os << "RHS for DoF " << i
                << ": " << rhs;
 
             os << std::endl;
           }
     }
 
   return os.str();
 }

◆ 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 459 of file dof_map.h.

References _n_nz.

   {
     libmesh_assert(_n_nz);
     return *_n_nz;
   }

◆ 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 472 of file dof_map.h.

References _n_oz.

   {
     libmesh_assert(_n_oz);
     return *_n_oz;
   }

◆ get_periodic_boundaries()

PeriodicBoundaries* libMesh::DofMap::get_periodic_boundaries ( )

inline

Definition at line 1185 of file dof_map.h.

References _periodic_boundaries.

   {
     return _periodic_boundaries.get();
   }

◆ 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 1874 of file dof_map.h.

References _primal_constraint_values.

 {
   return _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 450 of file dof_map.h.

References _send_list.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::UnsteadySolver::adjoint_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(), and libMesh::UnsteadySolver::retrieve_timestep().

450 { return _send_list; }

libMesh::DofMap::_send_list

std::vector< dof_id_type > _send_list

Definition: dof_map.h:1547

◆ has_adjoint_dirichlet_boundaries()

bool libMesh::DofMap::has_adjoint_dirichlet_boundaries ( unsigned int q ) const

Definition at line 4292 of file dof_map_constraints.C.

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

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

◆ 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 549 of file dof_map.h.

References n_variable_groups(), and n_variables().

Referenced by block_size().

   {
 #ifdef LIBMESH_ENABLE_BLOCKED_STORAGE
     return ((this->n_variable_groups() == 1) && (this->n_variables() > 1));
 #else
     return false;
 #endif
   }

◆ has_heterogenous_adjoint_constraint()

Number libMesh::DofMap::has_heterogenous_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 heterogenous constraint for adjoint solution qoi_num, zero otherwise.

Definition at line 1853 of file dof_map.h.

References _adjoint_constraint_values.

 {
   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;
 }

◆ has_heterogenous_adjoint_constraints()

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

inline

Returns: true if the system has any heterogenous constraints for adjoint solution qoi_num, false otherwise.

Definition at line 1839 of file dof_map.h.

References _adjoint_constraint_values.

 {
   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;
 }

◆ 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

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 heterogenous version of this method creates linear systems in which heterogenously 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-heterogenous version of this method creates linear systems in which even heterogenously 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 heterogenous 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 1694 of file dof_map_constraints.C.

References dof_id, libMesh::DenseMatrix< T >::left_multiply_transpose(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseMatrix< T >::right_multiply(), libMesh::DenseVector< T >::size(), libMesh::DenseMatrix< T >::vector_mult(), and libMesh::DenseMatrix< T >::vector_mult_transpose().

 {
   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());
 
   // 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 - K H)
   DenseMatrix<Number> C;
   DenseVector<Number> H;
 
   this->build_constraint_matrix_and_vector (C, H, elem_dofs, qoi_index);
 
   LOG_SCOPE("hetero_cnstrn_elem_mat_vec()", "DofMap");
 
   // It is possible that the matrix is not constrained at all.
   if ((C.m() == matrix.m()) &&
       (C.n() == elem_dofs.size())) // It the matrix is constrained
     {
       // We may have rhs values to use later
       const DofConstraintValueMap * rhs_values = nullptr;
       if (qoi_index < 0)
         rhs_values = &_primal_constraint_values;
       else
         {
           const AdjointDofConstraintValues::const_iterator
             it = _adjoint_constraint_values.find(qoi_index);
           if (it != _adjoint_constraint_values.end())
             rhs_values = &it->second;
         }
 
       // Compute matrix/vector product K H
       DenseVector<Number> KH;
       matrix.vector_mult(KH, H);
 
       // Compute the matrix-vector product C^T (F - KH)
       DenseVector<Number> F_minus_KH(rhs);
       F_minus_KH -= KH;
       C.vector_mult_transpose(rhs, F_minus_KH);
 
       // 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 (this->is_constrained_dof(dof_id))
             {
               for (unsigned int j=0; j<matrix.n(); j++)
                 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.
               if (asymmetric_constraint_rows)
                 {
                   DofConstraints::const_iterator
                     pos = _dof_constraints.find(dof_id);
 
                   libmesh_assert (pos != _dof_constraints.end());
 
                   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;
 
                   if (rhs_values)
                     {
                       const DofConstraintValueMap::const_iterator valpos =
                         rhs_values->find(dof_id);
 
                       rhs(i) = (valpos == rhs_values->end()) ?
                         0 : valpos->second;
                     }
                 }
               else
                 rhs(i) = 0.;
             }
         }
 
     } // end if is constrained...
 }

◆ 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

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 heterogenous version of this method creates linear systems in which heterogenously 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-heterogenous version of this method creates linear systems in which even heterogenously 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 heterogenous 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 1800 of file dof_map_constraints.C.

References dof_id, libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseVector< T >::size(), libMesh::DenseMatrix< T >::vector_mult(), and libMesh::DenseMatrix< T >::vector_mult_transpose().

 {
   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());
 
   // 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 - K H)
   DenseMatrix<Number> C;
   DenseVector<Number> H;
 
   this->build_constraint_matrix_and_vector (C, H, elem_dofs, qoi_index);
 
   LOG_SCOPE("hetero_cnstrn_elem_vec()", "DofMap");
 
   // It is possible that the matrix is not constrained at all.
   if ((C.m() == matrix.m()) &&
       (C.n() == elem_dofs.size())) // It the matrix is constrained
     {
       // We may have rhs values to use later
       const DofConstraintValueMap * rhs_values = nullptr;
       if (qoi_index < 0)
         rhs_values = &_primal_constraint_values;
       else
         {
           const AdjointDofConstraintValues::const_iterator
             it = _adjoint_constraint_values.find(qoi_index);
           if (it != _adjoint_constraint_values.end())
             rhs_values = &it->second;
         }
 
       // Compute matrix/vector product K H
       DenseVector<Number> KH;
       matrix.vector_mult(KH, H);
 
       // Compute the matrix-vector product C^T (F - KH)
       DenseVector<Number> F_minus_KH(rhs);
       F_minus_KH -= KH;
       C.vector_mult_transpose(rhs, F_minus_KH);
 
       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 (this->is_constrained_dof(dof_id))
             {
               // This will put a nonsymmetric entry in the constraint
               // row to ensure that the linear system produces the
               // correct value for the constrained DOF.
               if (asymmetric_constraint_rows && rhs_values)
                 {
                   const DofConstraintValueMap::const_iterator valpos =
                     rhs_values->find(dof_id);
 
                   rhs(i) = (valpos == rhs_values->end()) ?
                     0 : valpos->second;
                 }
               else
                 rhs(i) = 0.;
             }
         }
 
     } // end if is constrained...
 }

◆ increment_constructor_count()

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

inlineprotectedinherited

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

Definition at line 181 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.first++;
 }

◆ increment_destructor_count()

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

inlineprotectedinherited

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

Definition at line 194 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

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

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.second++;
 }

◆ invalidate_dofs()

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

private

Invalidates all active DofObject dofs for this system

Definition at line 813 of file dof_map.C.

References mesh, and sys_number().

Referenced by distribute_dofs(), and reinit().

 {
   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);
 }

◆ 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 298 of file dof_map.C.

References _matrices.

Referenced by libMesh::ImplicitSystem::init_matrices().

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

◆ 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 1829 of file dof_map.h.

References _dof_constraints.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), extract_local_vector(), find_connected_dofs(), and libMesh::CondensedEigenSystem::initialize_condensed_dofs().

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

◆ 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 1812 of file dof_map.h.

References _node_constraints.

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

◆ is_evaluable()

template<typename DofObjectSubclass >

template 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 2413 of file dof_map.C.

References all_semilocal_indices(), dof_indices(), libMesh::invalid_uint, and libMesh::ParallelObject::processor_id().

Referenced by libMesh::System::point_gradient(), and libMesh::System::point_hessian().

 {
   // 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);
 }

◆ 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 219 of file dof_map.C.

References _periodic_boundaries.

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

◆ last_dof() [1/2]

dof_id_type libMesh::DofMap::last_dof ( const processor_id_type proc ) const

inline

Returns: The last dof index that is local to processor proc.

Deprecated:: This function returns nonsense in the rare case where proc has no local dof indices. Use end_dof() instead.

Definition at line 624 of file dof_map.h.

References _end_df.

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

◆ last_dof() [2/2]

dof_id_type libMesh::DofMap::last_dof ( ) const

inline

Definition at line 631 of file dof_map.h.

References libMesh::ParallelObject::processor_id().

632 { return this->last_dof(this->processor_id()); }

libMesh::DofMap::last_dof

dof_id_type last_dof() const

Definition: dof_map.h:631

libMesh::ParallelObject::processor_id

processor_id_type processor_id() const

Definition: parallel_object.h:101

◆ 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 738 of file dof_map.h.

References end_dof(), and first_dof().

Referenced by add_neighbors_to_send_list(), get_info(), local_variable_indices(), semilocal_index(), and libMesh::PetscDMWrapper::set_point_range_in_section().

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

libMesh::DofMap::end_dof

dof_id_type end_dof() const

Definition: dof_map.h:644

libMesh::DofMap::first_dof

dof_id_type first_dof() const

Definition: dof_map.h:602

◆ local_variable_indices()

void libMesh::DofMap::local_variable_indices	(	std::vector< dof_id_type > &	idx,
		const MeshBase &	mesh,
		unsigned int	var_num
	)		const

Fills an array of those dof indices which belong to the given variable number and live on the current processor.

Definition at line 1076 of file dof_map.C.

References libMesh::Variable::active_on_subdomain(), libMesh::DofObject::dof_number(), libMesh::MeshTools::Generation::Private::idx(), local_index(), mesh, libMesh::DofObject::n_comp(), n_nodes, libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::SCALAR, SCALAR_dof_indices(), sys_number(), variable(), and variable_type().

Referenced by libMesh::petsc_auto_fieldsplit().

 {
   // 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++)
             {
               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 (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 (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 (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);
       idx.insert( idx.end(), di_scalar.begin(), di_scalar.end());
     }
 }

◆ 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 2268 of file dof_map_constraints.C.

References std::abs(), libMesh::MeshBase::active_local_element_ptr_range(), libMesh::NumericVector< T >::closed(), libMesh::NumericVector< T >::first_local_index(), libMesh::System::get_dof_map(), libMesh::System::get_mesh(), libMesh::NumericVector< T >::last_local_index(), libMesh::DenseMatrixBase< T >::m(), std::max(), mesh, libMesh::DenseMatrixBase< T >::n(), libMesh::Real, and libMesh::System::solution.

 {
   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 (unsigned int i=0; i!=C.m(); ++i)
         {
           // 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 (unsigned int j=0; j!=C.n(); ++j)
                 {
                   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);
 }

◆ merge_ghost_functor_outputs()

void libMesh::DofMap::merge_ghost_functor_outputs	(	GhostingFunctor::map_type &	elements_to_ghost,
		std::set< CouplingMatrix *> &	temporary_coupling_matrices,
		const std::set< GhostingFunctor *>::iterator &	gf_begin,
		const std::set< GhostingFunctor *>::iterator &	gf_end,
		const MeshBase::const_element_iterator &	elems_begin,
		const MeshBase::const_element_iterator &	elems_end,
		processor_id_type	p
	)

staticprivate

Definition at line 1432 of file dof_map.C.

References libMesh::as_range().

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

 {
   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);
 
       for (const auto & pr : more_elements_to_ghost)
         {
           GhostingFunctor::map_type::iterator existing_it =
             elements_to_ghost.find (pr.first);
           if (existing_it == elements_to_ghost.end())
             elements_to_ghost.insert(pr);
           else
             {
               if (existing_it->second)
                 {
                   if (pr.second)
                     {
                       // 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.find(const_cast<CouplingMatrix *>(existing_it->second)) == temporary_coupling_matrices.end())
                         {
                           CouplingMatrix * cm = new CouplingMatrix(*existing_it->second);
                           temporary_coupling_matrices.insert(cm);
                           existing_it->second = cm;
                         }
                       const_cast<CouplingMatrix &>(*existing_it->second) &= *pr.second;
                     }
                   else
                     {
                       // 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.
                       std::set<CouplingMatrix *>::iterator temp_it =
                         temporary_coupling_matrices.find(const_cast<CouplingMatrix *>(existing_it->second));
                       if (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.
             }
         }
     }
 }

◆ 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 1172 of file dof_map_constraints.C.

Referenced by libMesh::libmesh_petsc_snes_postcheck().

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

◆ 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 810 of file dof_map.h.

References _node_constraints.

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

libMesh::DofMap::_node_constraints

NodeConstraints _node_constraints

Definition: dof_map.h:1698

◆ n_dofs()

dof_id_type libMesh::DofMap::n_dofs ( ) const

inline

Returns: The total number of degrees of freedom in the problem.

Definition at line 574 of file dof_map.h.

References _n_dfs.

Referenced by distribute_dofs(), libMesh::SparsityPattern::Build::join(), libMesh::UnsteadySolver::old_nonlinear_solution(), libMesh::SecondOrderUnsteadySolver::old_solution_accel(), libMesh::SecondOrderUnsteadySolver::old_solution_rate(), and libMesh::SparsityPattern::Build::parallel_sync().

574 { return _n_dfs; }

libMesh::DofMap::_n_dfs

dof_id_type _n_dfs

Definition: dof_map.h:1649

◆ n_dofs_on_processor()

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

inline

Returns: The number of degrees of freedom on partition proc.

Definition at line 590 of file dof_map.h.

References _end_df, and _first_df.

Referenced by build_sparsity(), libMesh::SparsityPattern::Build::join(), n_local_dofs(), libMesh::SparsityPattern::Build::operator()(), and libMesh::SparsityPattern::Build::parallel_sync().

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

◆ 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 1182 of file dof_map_constraints.C.

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

◆ n_local_dofs()

dof_id_type libMesh::DofMap::n_local_dofs ( ) const

inline

Returns: The number of degrees of freedom on this processor.

Definition at line 584 of file dof_map.h.

References n_dofs_on_processor(), and libMesh::ParallelObject::processor_id().

Referenced by libMesh::PetscDMWrapper::build_sf(), and libMesh::PetscDMWrapper::set_point_range_in_section().

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

libMesh::DofMap::n_dofs_on_processor

dof_id_type n_dofs_on_processor(const processor_id_type proc) const

Definition: dof_map.h:590

libMesh::ParallelObject::processor_id

processor_id_type processor_id() const

Definition: parallel_object.h:101

◆ n_objects()

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

inlinestaticinherited

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

Definition at line 83 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

84 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

Definition: reference_counter.h:130

◆ n_old_dofs()

dof_id_type libMesh::DofMap::n_old_dofs ( ) const

inline

Returns: The total number of degrees of freedom on old_dof_objects

Definition at line 1271 of file dof_map.h.

References _n_old_dfs.

Referenced by SCALAR_dof_indices().

1271 { return _n_old_dfs; }

libMesh::DofMap::_n_old_dfs

dof_id_type _n_old_dfs

Definition: dof_map.h:1662

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 95 of file parallel_object.h.

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

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

libMesh::Parallel::Communicator::size

processor_id_type size() const

Definition: communicator.h:175

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

◆ n_SCALAR_dofs()

dof_id_type libMesh::DofMap::n_SCALAR_dofs ( ) const

inline

Returns: The number of SCALAR dofs.

Definition at line 579 of file dof_map.h.

References _n_SCALAR_dofs.

Referenced by distribute_dofs(), SCALAR_dof_indices(), and libMesh::PetscDMWrapper::set_point_range_in_section().

579 { return _n_SCALAR_dofs; }

libMesh::DofMap::_n_SCALAR_dofs

dof_id_type _n_SCALAR_dofs

Definition: dof_map.h:1655

◆ 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 533 of file dof_map.h.

References _variable_groups.

Referenced by distribute_local_dofs_node_major(), distribute_local_dofs_var_major(), dof_indices(), has_blocked_representation(), old_dof_indices(), reinit(), and set_nonlocal_dof_objects().

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

libMesh::DofMap::_variable_groups

std::vector< VariableGroup > _variable_groups

Definition: dof_map.h:1503

◆ n_variables()

unsigned int libMesh::DofMap::n_variables ( ) 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 541 of file dof_map.h.

References _variables.

Referenced by add_neighbors_to_send_list(), block_size(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), distribute_dofs(), DMlibMeshSetSystem_libMesh(), has_blocked_representation(), libMesh::SparsityPattern::Build::operator()(), reinit(), and use_coupled_neighbor_dofs().

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

libMesh::DofMap::_variables

std::vector< Variable > _variables

Definition: dof_map.h:1498

◆ 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 927 of file dof_map.h.

References _node_constraints.

928 { return _node_constraints.begin(); }

libMesh::DofMap::_node_constraints

NodeConstraints _node_constraints

Definition: dof_map.h:1698

◆ 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 933 of file dof_map.h.

References _node_constraints.

934 { return _node_constraints.end(); }

libMesh::DofMap::_node_constraints

NodeConstraints _node_constraints

Definition: dof_map.h:1698

◆ 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 306 of file dof_map.C.

References mesh.

Referenced by distribute_dofs().

 {
   return mesh.node_ptr(i);
 }

◆ old_dof_indices()

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 2434 of file dof_map.C.

References libMesh::Elem::active(), libMesh::Variable::active_on_subdomain(), libMesh::Elem::dim(), libMesh::DofObject::dof_number(), libMesh::FEInterface::extra_hanging_dofs(), libMesh::FEType::family, libMesh::MeshTools::Subdivision::find_one_ring(), libMesh::Elem::get_nodes(), libMesh::DofObject::has_dofs(), libMesh::Elem::infinite(), libMesh::DofObject::invalid_id, libMesh::invalid_uint, libMesh::Elem::is_vertex(), libMesh::Elem::JUST_COARSENED, libMesh::Elem::JUST_REFINED, libMesh::LAGRANGE, libMesh::DofObject::n_comp_group(), libMesh::FEInterface::n_dofs_at_node(), libMesh::FEInterface::n_dofs_at_node_function(), libMesh::FEInterface::n_dofs_per_elem(), n_nodes, libMesh::Elem::n_nodes(), libMesh::DofObject::n_systems(), n_variable_groups(), libMesh::VariableGroup::n_variables(), libMesh::VariableGroup::number(), libMesh::DofObject::old_dof_object, libMesh::FEType::order, libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::Elem::refinement_flag(), libMesh::SCALAR, SCALAR_dof_indices(), libMesh::Elem::subdomain_id(), sys_number(), libMesh::TRI3SUBDIVISION, libMesh::Variable::type(), libMesh::Elem::type(), and variable_group().

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

 {
   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();
   const unsigned int dim           = elem->dim();
 #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->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
 
                     // 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;
                       }
                     FEType fe_type = var.type();
                     fe_type.order = static_cast<Order>(fe_type.order +
                                                        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(dim, fe_type);
 
                     // 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->old_dof_object;
                         libmesh_assert(old_dof_obj);
 
                         // 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(dim, fe_type, type, n) :
 #endif
                           ndan (type, fe_type.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);
                                   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
                         else
                           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);
                               libmesh_assert_not_equal_to (d, DofObject::invalid_id);
                               di.push_back(d);
                             }
                       }
 
                     // If there are any element-based DOF numbers, get them
                     const unsigned int nc = FEInterface::n_dofs_per_elem(dim,
                                                                          fe_type,
                                                                          type);
 
                     // We should never have fewer dofs than necessary on an
                     // element unless we're getting indices on a parent element
                     // or a just-coarsened element
                     if (nc != 0)
                       {
                         const DofObject * old_dof_obj = elem->old_dof_object;
                         libmesh_assert(old_dof_obj);
 
                         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
                           {
                             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
 }

◆ 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 1639 of file dof_map.C.

References _augment_send_list, _extra_send_list_context, _extra_send_list_function, _send_list, libMesh::DofMap::AugmentSendList::augment_send_list(), libMesh::out, and swap().

Referenced by libMesh::EquationSystems::allgather(), and libMesh::System::reinit_constraints().

 {
   LOG_SCOPE("prepare_send_list()", "DofMap");
 
   // 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);
 }

◆ 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 1418 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 (processor_id_type p=1, np=this->n_processors(); p != np; ++p)
         {
           this->comm().receive(p, local_constraints);
           os << "Processor " << p << ":\n";
           os << local_constraints;
         }
     }
 }

◆ print_info() [1/2]

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

staticinherited

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

Definition at line 87 of file reference_counter.C.

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

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

◆ print_info() [2/2]

void libMesh::DofMap::print_info ( std::ostream & os = libMesh::out ) const

Prints summary info about the sparsity bandwidth and constraints.

Definition at line 2696 of file dof_map.C.

References get_info().

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

◆ 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 3227 of file dof_map_constraints.C.

References mesh, and libMesh::Real.

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

 {
   // 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_cyclic_constraint)
   {
     // Optionally check for cyclic constraints 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_cyclic_constraints();
   }
 
   // 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;
 
         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 is not cyclic.
                 libmesh_assert(item.first != expandable);
                 constraint_row[item.first] += item.second * this_coef;
               }
 
             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);
           }
 
         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;
       }
 
   // 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();
 }

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 101 of file parallel_object.h.

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

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

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

libMesh::Parallel::Communicator::rank

processor_id_type rank() const

Definition: communicator.h:173

◆ reinit()

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

Reinitialize the underlying data structures conformal to the current mesh.

Definition at line 474 of file dof_map.C.

References _default_coupling, _dof_coupling, _n_SCALAR_dofs, libMesh::Variable::active_on_subdomain(), libMesh::CouplingMatrix::empty(), libMesh::Utility::enum_to_string(), libMesh::err, libMesh::FEInterface::extra_hanging_dofs(), libMesh::FEType::family, libMesh::OrderWrapper::get_order(), libMesh::DofObject::has_dofs(), invalidate_dofs(), libMesh::Elem::JUST_REFINED, std::max(), libMesh::FEInterface::max_order(), mesh, libMesh::DofObject::n_comp_group(), libMesh::FEInterface::n_dofs_at_node(), libMesh::FEInterface::n_dofs_per_elem(), n_variable_groups(), libMesh::VariableGroup::n_variables(), n_variables(), libMesh::DofObject::old_dof_object, libMesh::FEType::order, libMesh::SCALAR, libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_old_dof_object(), libMesh::DofObject::set_vg_dof_base(), sys_number(), libMesh::Variable::type(), use_coupled_neighbor_dofs(), variable_group(), and libMesh::DofObject::vg_dof_base().

Referenced by distribute_dofs().

 {
   libmesh_assert (mesh.is_prepared());
 
   LOG_SCOPE("reinit()", "DofMap");
 
   // 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->old_dof_object);
     }
 
   for (auto & elem : mesh.element_ptr_range())
     {
       elem->clear_old_dof_object();
       libmesh_assert (!elem->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 (unsigned int n=0; n<elem->n_nodes(); n++)
         {
           Node & node = elem->node_ref(n);
 
           if (node.old_dof_object == nullptr)
             if (node.has_dofs(sys_num))
               node.set_old_dof_object();
         }
 
       libmesh_assert (!elem->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
   for (auto & elem : mesh.element_ptr_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();
 
       // 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);
 
           // Skip the numbering if this variable is
           // not active on this element's subdomain
           if (!vg_description.active_on_subdomain(elem->subdomain_id()))
             continue;
 
           const ElemType type = elem->type();
           const unsigned int dim = elem->dim();
 
           FEType fe_type = base_fe_type;
 
 #ifdef LIBMESH_ENABLE_AMR
           // Make sure we haven't done more p refinement than we can
           // handle
           if (elem->p_level() + base_fe_type.order >
               FEInterface::max_order(base_fe_type, type))
             {
               libmesh_assert_less_msg(static_cast<unsigned int>(base_fe_type.order.get_order()),
                                       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 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(FEInterface::max_order(base_fe_type,type)
                                 - base_fe_type.order);
             }
 #endif
 
           fe_type.order = static_cast<Order>(fe_type.order +
                                              elem->p_level());
 
           // Allocate the vertex DOFs
           for (unsigned int n=0; n<elem->n_nodes(); n++)
             {
               Node & node = elem->node_ref(n);
 
               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(dim, fe_type,
                                                          type, n),
                              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);
 
           // Skip the numbering if this variable is
           // not active on this element's subdomain
           if (!vg_description.active_on_subdomain(elem->subdomain_id()))
             continue;
 
           const ElemType type = elem->type();
           const unsigned int dim = elem->dim();
 
           FEType fe_type = base_fe_type;
           fe_type.order = static_cast<Order>(fe_type.order +
                                              elem->p_level());
 
           // Allocate the edge and face DOFs
           for (unsigned int n=0; n<elem->n_nodes(); n++)
             {
               Node & node = elem->node_ref(n);
 
               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(dim, fe_type, type, n);
 
               // 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(dim, fe_type,
                                          type);
 
           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);
 }

◆ 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 4336 of file dof_map_constraints.C.

References libMesh::DirichletBoundary::b, end, and libMesh::DirichletBoundary::variables.

 {
   libmesh_assert_greater(_adjoint_dirichlet_boundaries.size(),
                          qoi_index);
 
   auto lam = [&boundary_to_remove](const DirichletBoundary * 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);
 
   // Delete it and remove it
   libmesh_assert (it != _adjoint_dirichlet_boundaries[qoi_index]->end());
   delete *it;
   _adjoint_dirichlet_boundaries[qoi_index]->erase(it);
 }

◆ 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 1840 of file dof_map.C.

References _algebraic_ghosting_functors, _mesh, and libMesh::MeshBase::remove_ghosting_functor().

Referenced by remove_default_ghosting().

 {
   _algebraic_ghosting_functors.erase(&evaluable_functor);
   _mesh.remove_ghosting_functor(evaluable_functor);
 }

◆ 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 1820 of file dof_map.C.

References _coupling_functors, _mesh, and libMesh::MeshBase::remove_ghosting_functor().

Referenced by remove_default_ghosting().

 {
   _coupling_functors.erase(&coupling_functor);
   _mesh.remove_ghosting_functor(coupling_functor);
 }

◆ 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 1792 of file dof_map.C.

References default_algebraic_ghosting(), default_coupling(), remove_algebraic_ghosting_functor(), and remove_coupling_functor().

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

 {
   this->remove_coupling_functor(this->default_coupling());
   this->remove_algebraic_ghosting_functor(this->default_algebraic_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 4321 of file dof_map_constraints.C.

References libMesh::DirichletBoundary::b, and libMesh::DirichletBoundary::variables.

 {
   // Find a boundary condition matching the one to be removed
   auto lam = [&boundary_to_remove](const DirichletBoundary * 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);
 
   // Delete it and remove it
   libmesh_assert (it != _dirichlet_boundaries->end());
   delete *it;
   _dirichlet_boundaries->erase(it);
 }

◆ 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 2348 of file dof_map.C.

References _first_old_scalar_df, _first_scalar_df, libMesh::OrderWrapper::get_order(), libMesh::DofObject::invalid_id, n_old_dofs(), n_SCALAR_dofs(), libMesh::FEType::order, libMesh::SCALAR, libMesh::Variable::type(), and variable().

Referenced by dof_indices(), local_variable_indices(), old_dof_indices(), libMesh::System::project_vector(), libMesh::System::projection_matrix(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::write_parallel_data(), and libMesh::System::write_SCALAR_dofs().

 {
   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++;
 }

◆ scatter_constraints()

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

Sends constraint equations to constraining processors

Definition at line 3432 of file dof_map_constraints.C.

References libMesh::MeshBase::active_local_elements_begin(), libMesh::MeshBase::active_local_elements_end(), libMesh::MeshBase::active_not_local_elements_begin(), libMesh::MeshBase::active_not_local_elements_end(), libMesh::as_range(), data, end, libMesh::DofObject::id(), libMesh::index_range(), libMesh::MeshBase::is_serial(), mesh, libMesh::MeshBase::node_ptr(), libMesh::DofObject::processor_id(), libMesh::Parallel::push_parallel_vector_data(), libMesh::TypeVector< T >::size(), and libMesh::Parallel::wait().

 {
   // 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(1414);
 
 #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 (auto & i : _dof_constraints)
     {
       const dof_id_type constrained = i.first;
       while (constrained >= _end_df[constrained_proc_id])
         constrained_proc_id++;
 
       if (constrained_proc_id != this->processor_id())
         continue;
 
       DofConstraintRow & row = i.second;
       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 (auto & pid_id_pair : pushed_ids)
         {
           const processor_id_type pid = pid_id_pair.first;
           const std::set<dof_id_type>
             & pid_ids = pid_id_pair.second;
 
           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;
     };
 
   // 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);
 
   // Now work on traded dof constraint rows
   auto receive_dof_constraints =
     [this,
      & pushed_ids_rhss_to_me,
      & pushed_keys_vals_to_me]
     ()
     {
       for (auto & pid_id_pair : pushed_ids_rhss_to_me)
         {
           const processor_id_type pid = pid_id_pair.first;
           const auto & ids_rhss = pid_id_pair.second;
           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])
                     {
                       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::set<const Node *>> pushed_nodes;
 
   for (auto & pid_id_pair : pushed_node_ids)
     {
       const processor_id_type pid = pid_id_pair.first;
       const std::set<dof_id_type>
         & pid_ids = pid_id_pair.second;
 
       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<const Node *> & nodes = pushed_nodes[pid];
 
       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 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)
             {
               const Node * constraining = j.first;
 
               keys_vals[push_i].push_back
                 (std::make_pair(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;
         }
     }
 
   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.
   std::vector<Parallel::Request> send_requests;
   if (!mesh.is_serial())
     {
       for (auto & pid_id_pair : pushed_node_ids_offsets)
         {
           const processor_id_type pid = pid_id_pair.first;
           send_requests.push_back(Parallel::Request());
           this->comm().send_packed_range
             (pid, &mesh,
              pushed_nodes[pid].begin(), pushed_nodes[pid].end(),
              send_requests.back(), range_tag);
         }
     }
 
   for (auto & pid_id_pair : pushed_node_ids_offsets_to_me)
     {
       const processor_id_type pid = pid_id_pair.first;
       const auto & ids_offsets = pid_id_pair.second;
       const auto & keys_vals = pushed_node_keys_vals_to_me[pid];
 
       libmesh_assert_equal_to
         (ids_offsets.size(), keys_vals.size());
 
       if (!mesh.is_serial())
         this->comm().receive_packed_range
           (pid, &mesh, mesh_inserter_iterator<Node>(mesh),
            (Node**)nullptr, range_tag);
 
       // 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;
             }
         }
     }
 
   Parallel::wait(send_requests);
 
 #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 (auto & i : _dof_constraints)
     {
       const dof_id_type constrained = i.first;
       DofConstraintRow & row = i.second;
       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)
         {
           DofConstrainsMap::const_iterator dcmi = dof_id_constrains.find(dof);
           if (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;
 
   // Man, I wish we had guaranteed unique_ptr availability...
   std::set<CouplingMatrix*> 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);
 }

◆ 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 2384 of file dof_map.C.

References _send_list, and local_index().

Referenced by all_semilocal_indices().

 {
   // 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_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 cyclic constraints. If a cyclic constraint is present then the system constraints are not valid, so if error_on_cyclic_constraint is true we will throw an error in this case.

Definition at line 238 of file dof_map.C.

References _error_on_cyclic_constraint.

 {
   _error_on_cyclic_constraint = error_on_cyclic_constraint;
 }

◆ 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 1675 of file dof_map.C.

References _implicit_neighbor_dofs, and _implicit_neighbor_dofs_initialized.

 {
   _implicit_neighbor_dofs_initialized = true;
   _implicit_neighbor_dofs = implicit_neighbor_dofs;
 }

◆ 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 321 of file dof_map.C.

Referenced by distribute_dofs().

 {
   // 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.
   auto ghost_end = ghost_objects_from_proc.end();
   for (processor_id_type p=0, np = this->n_processors(); p != np; ++p)
     if (p != this->processor_id())
       {
         auto ghost_it = ghost_objects_from_proc.find(p);
         if (ghost_it != ghost_end)
           requested_ids[p].reserve(ghost_it->second);
       }
 
   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 (processor_id_type p=0, np = this->n_processors(); p != np; ++p)
     {
       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
 }

◆ stash_dof_constraints()

void libMesh::DofMap::stash_dof_constraints ( )

inline

Definition at line 911 of file dof_map.h.

References _dof_constraints, and _stashed_dof_constraints.

   {
     libmesh_assert(_stashed_dof_constraints.empty());
     _dof_constraints.swap(_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 1744 of file dof_map.h.

References _sys_number.

Referenced by _dof_indices(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), distribute_dofs(), distribute_local_dofs_node_major(), distribute_local_dofs_var_major(), dof_indices(), invalidate_dofs(), local_variable_indices(), old_dof_indices(), reinit(), and set_nonlocal_dof_objects().

 {
   return _sys_number;
 }

◆ unstash_dof_constraints()

void libMesh::DofMap::unstash_dof_constraints ( )

inline

Definition at line 917 of file dof_map.h.

References _dof_constraints, and _stashed_dof_constraints.

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

◆ 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 1682 of file dof_map.C.

References _implicit_neighbor_dofs, _implicit_neighbor_dofs_initialized, libMesh::FEAbstract::build(), libMesh::command_line_next(), libMesh::DISCONTINUOUS, mesh, n_variables(), libMesh::on_command_line(), and variable_type().

Referenced by build_sparsity(), clear(), and reinit().

 {
   // 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;
 
     for (unsigned int var=0; var<this->n_variables(); var++)
       if (FEAbstract::build (mesh.mesh_dimension(),
                              this->variable_type(var))->get_continuity() !=  DISCONTINUOUS)
         all_discontinuous_dofs = false;
 
     if (all_discontinuous_dofs)
       implicit_neighbor_dofs = true;
   }
 
   return implicit_neighbor_dofs;
 }

◆ variable()

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

inline

Returns: The variable description object for variable c.

Definition at line 1762 of file dof_map.h.

References _variables.

Referenced by distribute_dofs(), DMlibMeshSetSystem_libMesh(), local_variable_indices(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()(), libMesh::BoundaryProjectSolution::operator()(), and SCALAR_dof_indices().

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

◆ 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 1752 of file dof_map.h.

References _variable_groups.

Referenced by _dof_indices(), distribute_local_dofs_node_major(), distribute_local_dofs_var_major(), dof_indices(), libMesh::System::get_info(), old_dof_indices(), and reinit().

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

◆ 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 1782 of file dof_map.h.

References _variable_groups.

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

◆ 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 1802 of file dof_map.h.

References _variable_groups.

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

◆ variable_order()

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

inline

Returns: The approximation order for variable c.

Definition at line 1772 of file dof_map.h.

References _variables.

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

◆ variable_type()

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

inline

Returns: The finite element type for variable c.

Definition at line 1792 of file dof_map.h.

References _variables.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::HPCoarsenTest::add_projection(), libMesh::System::calculate_norm(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::FEInterface::compute_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::MeshFunction::discontinuous_gradient(), libMesh::MeshFunction::discontinuous_value(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshFunction::gradient(), libMesh::MeshFunction::hessian(), local_variable_indices(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::MeshFunction::operator()(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::HPCoarsenTest::select_refinement(), and use_coupled_neighbor_dofs().

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

Friends And Related Function Documentation

◆ SparsityPattern::Build

friend class SparsityPattern::Build

friend

Definition at line 1730 of file dof_map.h.

Member Data Documentation

◆ _adjoint_constraint_values

AdjointDofConstraintValues libMesh::DofMap::_adjoint_constraint_values

private

Definition at line 1691 of file dof_map.h.

Referenced by clear(), has_heterogenous_adjoint_constraint(), and has_heterogenous_adjoint_constraints().

◆ _adjoint_dirichlet_boundaries

std::vector<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 1727 of file dof_map.h.

Referenced by ~DofMap().

◆ _algebraic_ghosting_functors

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

private

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

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

Definition at line 1605 of file dof_map.h.

Referenced by add_algebraic_ghosting_functor(), algebraic_ghosting_functors_begin(), algebraic_ghosting_functors_end(), clear(), distribute_dofs(), and remove_algebraic_ghosting_functor().

◆ _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 1569 of file dof_map.h.

Referenced by attach_extra_send_list_object(), and prepare_send_list().

◆ _augment_sparsity_pattern

AugmentSparsityPattern* libMesh::DofMap::_augment_sparsity_pattern

private

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

Definition at line 1552 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 107 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::ParallelObject::comm(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), and libMesh::ParallelObject::processor_id().

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

◆ _coupling_functors

std::set<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 copy these functors to the MeshBase, too, so any dofs coupled to local dofs will live on geometrically ghosted elements.

Definition at line 1618 of file dof_map.h.

Referenced by add_coupling_functor(), build_sparsity(), clear(), coupling_functors_begin(), coupling_functors_end(), distribute_dofs(), and remove_coupling_functor().

◆ _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 1587 of file dof_map.h.

Referenced by clear(), 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 1595 of file dof_map.h.

Referenced by clear(), 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 1721 of file dof_map.h.

Referenced by get_dirichlet_boundaries().

◆ _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 1687 of file dof_map.h.

Referenced by clear(), constraint_rows_begin(), constraint_rows_end(), find_connected_dofs(), get_info(), is_constrained_dof(), stash_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 1319 of file dof_map.h.

Referenced by build_sparsity(), clear(), 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 141 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::DofMap::_end_df

private

Last DOF index (plus 1) on processor p.

Definition at line 1535 of file dof_map.h.

Referenced by clear(), distribute_dofs(), dof_owner(), end_dof(), last_dof(), and n_dofs_on_processor().

◆ _end_old_df

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

private

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

Definition at line 1672 of file dof_map.h.

Referenced by clear(), distribute_dofs(), and end_old_dof().

◆ _error_on_cyclic_constraint

bool libMesh::DofMap::_error_on_cyclic_constraint

private

This flag indicates whether or not we do an opt-mode check for the presence of cyclic constraints.

Definition at line 1493 of file dof_map.h.

Referenced by set_error_on_cyclic_constraint().

◆ _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 1579 of file dof_map.h.

Referenced by attach_extra_send_list_function(), and prepare_send_list().

◆ _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 1574 of file dof_map.h.

Referenced by attach_extra_send_list_function(), and prepare_send_list().

◆ _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 1564 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 1557 of file dof_map.h.

Referenced by attach_extra_sparsity_function(), and build_sparsity().

◆ _first_df

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

private

First DOF index on processor p.

Definition at line 1530 of file dof_map.h.

Referenced by clear(), distribute_dofs(), first_dof(), and n_dofs_on_processor().

◆ _first_old_df

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

private

First old DOF index on processor p.

Definition at line 1667 of file dof_map.h.

Referenced by clear(), distribute_dofs(), and 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 1678 of file dof_map.h.

Referenced by clear(), distribute_dofs(), and SCALAR_dof_indices().

◆ _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 1541 of file dof_map.h.

Referenced by clear(), distribute_dofs(), and SCALAR_dof_indices().

◆ _implicit_neighbor_dofs

bool libMesh::DofMap::_implicit_neighbor_dofs

private

Definition at line 1737 of file dof_map.h.

Referenced by set_implicit_neighbor_dofs(), and use_coupled_neighbor_dofs().

◆ _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 1736 of file dof_map.h.

Referenced by set_implicit_neighbor_dofs(), and use_coupled_neighbor_dofs().

◆ _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 1525 of file dof_map.h.

Referenced by attach_matrix(), clear(), compute_sparsity(), DofMap(), get_info(), and is_attached().

◆ _mesh

MeshBase& libMesh::DofMap::_mesh

private

The mesh that system uses.

Definition at line 1518 of file dof_map.h.

Referenced by add_algebraic_ghosting_functor(), add_coupling_functor(), clear(), DofMap(), remove_algebraic_ghosting_functor(), remove_coupling_functor(), and ~DofMap().

◆ _mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 135 of file reference_counter.h.

◆ _n_dfs

dof_id_type libMesh::DofMap::_n_dfs

private

Total number of degrees of freedom.

Definition at line 1649 of file dof_map.h.

Referenced by clear(), distribute_dofs(), and n_dofs().

◆ _n_nz

std::vector<dof_id_type>* libMesh::DofMap::_n_nz

private

The number of on-processor nonzeros in my portion of the global matrix. If need_full_sparsity_pattern is true, this will just be a pointer into the corresponding sparsity pattern vector. Otherwise we have to new/delete it ourselves.

Definition at line 1638 of file dof_map.h.

Referenced by attach_matrix(), clear_sparsity(), compute_sparsity(), get_info(), and get_n_nz().

◆ _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 130 of file reference_counter.h.

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

◆ _n_old_dfs

dof_id_type libMesh::DofMap::_n_old_dfs

private

Total number of degrees of freedom on old dof objects

Definition at line 1662 of file dof_map.h.

Referenced by clear(), distribute_dofs(), and n_old_dofs().

◆ _n_oz

std::vector<dof_id_type>* libMesh::DofMap::_n_oz

private

The number of off-processor nonzeros in my portion of the global matrix; allocated similar to _n_nz.

Definition at line 1644 of file dof_map.h.

Referenced by attach_matrix(), clear_sparsity(), compute_sparsity(), get_info(), and get_n_oz().

◆ _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 1655 of file dof_map.h.

Referenced by distribute_local_dofs_node_major(), distribute_local_dofs_var_major(), n_SCALAR_dofs(), and reinit().

◆ _node_constraints

NodeConstraints libMesh::DofMap::_node_constraints

private

Data structure containing DofObject constraints.

Definition at line 1698 of file dof_map.h.

Referenced by get_info(), is_constrained_node(), n_constrained_nodes(), node_constraint_rows_begin(), and node_constraint_rows_end().

◆ _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 1707 of file dof_map.h.

Referenced by DofMap(), get_periodic_boundaries(), and is_periodic_boundary().

◆ _primal_constraint_values

DofConstraintValueMap libMesh::DofMap::_primal_constraint_values

private

Definition at line 1689 of file dof_map.h.

Referenced by clear(), get_info(), and get_primal_constraint_values().

◆ _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 1547 of file dof_map.h.

Referenced by add_neighbors_to_send_list(), clear(), distribute_dofs(), get_send_list(), prepare_send_list(), and semilocal_index().

◆ _sp

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

private

The sparsity pattern of the global matrix, kept around if it might be needed by future additions of the same type of matrix.

Definition at line 1630 of file dof_map.h.

Referenced by attach_matrix(), clear_sparsity(), and compute_sparsity().

◆ _stashed_dof_constraints

DofConstraints libMesh::DofMap::_stashed_dof_constraints

private

Definition at line 1687 of file dof_map.h.

Referenced by clear(), stash_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 1513 of file dof_map.h.

Referenced by sys_number().

◆ _variable_group_numbers

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

private

The variable group number for each variable.

Definition at line 1508 of file dof_map.h.

Referenced by add_variable_group(), clear(), and dof_indices().

◆ _variable_groups

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

private

The finite element type for each variable group.

Definition at line 1503 of file dof_map.h.

Referenced by add_variable_group(), clear(), n_variable_groups(), variable_group(), variable_group_order(), and variable_group_type().

◆ _variables

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

private

The finite element type for each variable.

Definition at line 1498 of file dof_map.h.

Referenced by add_variable_group(), clear(), n_variables(), variable(), variable_order(), and variable_type().

◆ 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 1624 of file dof_map.h.

Referenced by attach_matrix(), build_sparsity(), clear(), clear_sparsity(), and compute_sparsity().

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

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ Counts

◆ dofobject_accessor

Constructor & Destructor Documentation

◆ DofMap()

◆ ~DofMap()

Member Function Documentation

◆ _dof_indices()

◆ add_adjoint_constraint_row()

◆ add_adjoint_dirichlet_boundary()

◆ add_algebraic_ghosting_functor()

◆ add_constraint_row() [1/2]

◆ add_constraint_row() [2/2]

◆ add_constraints_to_send_list()

◆ add_coupling_functor()

◆ add_default_ghosting()

◆ add_dirichlet_boundary()

◆ add_neighbors_to_send_list()

◆ add_periodic_boundary() [1/2]

◆ add_periodic_boundary() [2/2]

◆ add_variable_group()

◆ algebraic_ghosting_functors_begin()

◆ algebraic_ghosting_functors_end()

◆ all_semilocal_indices()

◆ allgather_recursive_constraints()

◆ attach_extra_send_list_function()

◆ attach_extra_send_list_object()

◆ attach_extra_sparsity_function()

◆ attach_extra_sparsity_object()

◆ attach_matrix()

◆ block_size()

◆ build_constraint_matrix()

◆ build_constraint_matrix_and_vector()

◆ build_sparsity()

◆ check_dirichlet_bcid_consistency()

◆ check_for_cyclic_constraints()

◆ clear()

◆ clear_sparsity()

◆ comm()

◆ compute_sparsity()

◆ constrain_element_dyad_matrix()

◆ constrain_element_matrix() [1/2]

◆ constrain_element_matrix() [2/2]

◆ constrain_element_matrix_and_vector()

◆ constrain_element_vector()

◆ constrain_nothing()

◆ constrain_p_dofs()

◆ constraint_rows_begin()

◆ constraint_rows_end()

◆ coupling_functors_begin()

◆ coupling_functors_end()

◆ create_dof_constraints()

◆ default_algebraic_ghosting()

◆ default_coupling()

◆ disable_print_counter_info()

◆ distribute_dofs()

◆ distribute_local_dofs_node_major()

◆ distribute_local_dofs_var_major()

◆ dof_indices() [1/4]

◆ dof_indices() [2/4]

◆ dof_indices() [3/4]

◆ dof_indices() [4/4]

◆ dof_owner()

◆ elem_ptr()

◆ enable_print_counter_info()

◆ end_dof() [1/2]