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 = 

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]