libMesh::DofMap类 参考

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

#include <dof_map.h>

类 libMesh::DofMap 继承关系图:

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

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

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

Public 属性
CouplingMatrix *	_dof_coupling
	Degree of freedom coupling. 更多...

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

Protected 成员函数
void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter. 更多...
void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter. 更多...

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

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

Private 成员函数
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
	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. 更多...
void	_node_dof_indices (const Elem &elem, unsigned int n, const DofObject &obj, std::vector< dof_id_type > &di, const unsigned int vn) const
	Helper function that implements the element-nodal versions of dof_indices and old_dof_indices. 更多...
void	invalidate_dofs (MeshBase &mesh) const
	Invalidates all active DofObject dofs for this system. 更多...
DofObject *	node_ptr (MeshBase &mesh, dof_id_type i) const
DofObject *	elem_ptr (MeshBase &mesh, dof_id_type i) const
template<typename iterator_type >
void	set_nonlocal_dof_objects (iterator_type objects_begin, iterator_type objects_end, MeshBase &mesh, dofobject_accessor objects)
	Helper function for distributing dofs in parallel. 更多...
void	distribute_local_dofs_var_major (dof_id_type &next_free_dof, MeshBase &mesh)
	Distributes the global degrees of freedom, for dofs on this processor. 更多...
void	distribute_local_dofs_node_major (dof_id_type &next_free_dof, MeshBase &mesh)
	Distributes the global degrees of freedom for dofs on this processor. 更多...
void	distribute_scalar_dofs (dof_id_type &next_free_dof)
void	assert_no_nodes_missed (MeshBase &mesh)
void	add_neighbors_to_send_list (MeshBase &mesh)
	Adds entries to the _send_list vector corresponding to DoFs on elements neighboring the current processor. 更多...
void	build_constraint_matrix (DenseMatrix< Number > &C, std::vector< dof_id_type > &elem_dofs, const bool called_recursively=false) const
	Build the constraint matrix C associated with the element degree of freedom indices elem_dofs. 更多...
void	build_constraint_matrix_and_vector (DenseMatrix< Number > &C, DenseVector< Number > &H, std::vector< dof_id_type > &elem_dofs, int qoi_index=-1, const bool called_recursively=false) const
	Build the constraint matrix C and the forcing vector H associated with the element degree of freedom indices elem_dofs. 更多...
void	find_connected_dofs (std::vector< dof_id_type > &elem_dofs) const
	Finds all the DOFS associated with the element DOFs elem_dofs. 更多...
void	find_connected_dof_objects (std::vector< const DofObject * > &objs) const
	Finds all the DofObjects associated with the set in objs. 更多...
void	add_constraints_to_send_list ()
	Adds entries to the _send_list vector corresponding to DoFs which are dependencies for constraint equations on the current processor. 更多...
void	process_mesh_constraint_rows (const MeshBase &mesh)
	Adds any spline constraints from the Mesh to our DoF constraints. 更多...

静态 Private 成员函数
static void	merge_ghost_functor_outputs (GhostingFunctor::map_type &elements_to_ghost, CouplingMatricesSet &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 属性
bool	_error_on_constraint_loop
	This flag indicates whether or not we do an opt-mode check for the presence of constraint loops, i.e. 更多...
bool	_constrained_sparsity_construction
	This flag indicates whether or not we explicitly take constraint equations into account when computing a sparsity pattern. 更多...
std::vector< Variable >	_variables
	The finite element type for each variable. 更多...
std::vector< VariableGroup >	_variable_groups
	The finite element type for each variable group. 更多...
std::vector< unsigned int >	_variable_group_numbers
	The variable group number for each variable. 更多...
std::unordered_map< unsigned int, unsigned int >	_var_to_vg
	A map from variable number to variable group number. 更多...
const unsigned int	_sys_number
	The number of the system we manage DOFs for. 更多...
MeshBase &	_mesh
	The mesh that system uses. 更多...
std::vector< SparseMatrix < Number > * >	_matrices
	Additional matrices handled by this object. 更多...
std::vector< dof_id_type >	_first_df
	First DOF index on processor p. 更多...
std::vector< dof_id_type >	_end_df
	Last DOF index (plus 1) on processor p. 更多...
std::vector< dof_id_type >	_first_scalar_df
	First DOF index for SCALAR variable v, or garbage for non-SCALAR variable v. 更多...
std::vector< dof_id_type >	_send_list
	A list containing all the global DOF indices that affect the solution on my processor. 更多...
SparsityPattern::AugmentSparsityPattern *	_augment_sparsity_pattern
	Function object to call to add extra entries to the sparsity pattern. 更多...
void(*	_extra_sparsity_function )(SparsityPattern::Graph &, std::vector< dof_id_type > &n_nz, std::vector< dof_id_type > &n_oz, void *)
	A function pointer to a function to call to add extra entries to the sparsity pattern. 更多...
void *	_extra_sparsity_context
	A pointer associated with the extra sparsity that can optionally be passed in. 更多...
AugmentSendList *	_augment_send_list
	Function object to call to add extra entries to the send list. 更多...
void(*	_extra_send_list_function )(std::vector< dof_id_type > &, void *)
	A function pointer to a function to call to add extra entries to the send list. 更多...
void *	_extra_send_list_context
	A pointer associated with the extra send list that can optionally be passed in. 更多...
std::unique_ptr< DefaultCoupling >	_default_coupling
	The default coupling GhostingFunctor, used to implement standard libMesh sparsity pattern construction. 更多...
std::unique_ptr< DefaultCoupling >	_default_evaluating
	The default algebraic GhostingFunctor, used to implement standard libMesh send_list construction. 更多...
std::set< GhostingFunctor * >	_algebraic_ghosting_functors
	The list of all GhostingFunctor objects to be used when distributing ghosted vectors. 更多...
std::set< GhostingFunctor * >	_coupling_functors
	The list of all GhostingFunctor objects to be used when coupling degrees of freedom in matrix sparsity patterns. 更多...
std::map< GhostingFunctor *, std::shared_ptr < GhostingFunctor > >	_shared_functors
	Hang on to references to any GhostingFunctor objects we were passed in shared_ptr form. 更多...
bool	need_full_sparsity_pattern
	Default false; set to true if any attached matrix requires a full sparsity pattern. 更多...
std::unique_ptr < SparsityPattern::Build >	_sp
	The sparsity pattern of the global matrix. 更多...
dof_id_type	_n_dfs
	Total number of degrees of freedom. 更多...
dof_id_type	_n_SCALAR_dofs
	The total number of SCALAR dofs associated to all SCALAR variables. 更多...
dof_id_type	_n_old_dfs
	Total number of degrees of freedom on old dof objects. 更多...
std::vector< dof_id_type >	_first_old_df
	First old DOF index on processor p. 更多...
std::vector< dof_id_type >	_end_old_df
	Last old DOF index (plus 1) on processor p. 更多...
std::vector< dof_id_type >	_first_old_scalar_df
	First old DOF index for SCALAR variable v, or garbage for non-SCALAR variable v. 更多...
std::unordered_set< unsigned int >	_dont_p_refine
	A container of variable groups that we should not p-refine. 更多...
DofConstraints	_dof_constraints
	Data structure containing DOF constraints. 更多...
DofConstraints	_stashed_dof_constraints
DofConstraintValueMap	_primal_constraint_values
AdjointDofConstraintValues	_adjoint_constraint_values
NodeConstraints	_node_constraints
	Data structure containing DofObject constraints. 更多...
std::unique_ptr < PeriodicBoundaries >	_periodic_boundaries
	Data structure containing periodic boundaries. 更多...
std::unique_ptr < DirichletBoundaries >	_dirichlet_boundaries
	Data structure containing Dirichlet functions. 更多...
std::vector< std::unique_ptr < DirichletBoundaries > >	_adjoint_dirichlet_boundaries
	Data structure containing Dirichlet functions. 更多...
bool	_implicit_neighbor_dofs_initialized
	Bools to indicate if we override the –implicit_neighbor_dofs commandline options. 更多...
bool	_implicit_neighbor_dofs
bool	_verify_dirichlet_bc_consistency
	Flag which determines whether we should do some additional checking of the consistency of the DirichletBoundary objects added by the user. 更多...

友元
class	SparsityPattern::Build

详细描述

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.

作者

Benjamin S. Kirk

日期

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

在文件 dof_map.h 第 169 行定义.

成员类型定义说明

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.

在文件 reference_counter.h 第 119 行定义.

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

private

在文件 dof_map.h 第 1742 行定义.

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

在文件 dof_map.h 第 1690 行定义.

构造及析构函数说明

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.

在文件 dof_map.C 第 135 行定义.

参考 _default_coupling, _default_evaluating, _matrices, _mesh, _periodic_boundaries, add_algebraic_ghosting_functor() , 以及 add_coupling_functor().

                                :
  ParallelObject (mesh.comm()),
  _dof_coupling(nullptr),
  _error_on_constraint_loop(false),
  _constrained_sparsity_construction(false),
  _variables(),
  _variable_groups(),
  _variable_group_numbers(),
  _sys_number(number),
  _mesh(mesh),
  _matrices(),
  _first_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(std::make_unique<DefaultCoupling>()),
  _default_evaluating(std::make_unique<DefaultCoupling>()),
  need_full_sparsity_pattern(false),
  _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(std::make_unique<PeriodicBoundaries>())
#endif
#ifdef LIBMESH_ENABLE_DIRICHLET
  , _dirichlet_boundaries(std::make_unique<DirichletBoundaries>())
  , _adjoint_dirichlet_boundaries()
#endif
  , _implicit_neighbor_dofs_initialized(false),
  _implicit_neighbor_dofs(false),
  _verify_dirichlet_bc_consistency(true)
{
  _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);
}

libMesh::DofMap::~DofMap

(

)

Destructor.

在文件 dof_map.C 第 206 行定义.

参考 _default_coupling, _default_evaluating, _mesh , 以及 clear().

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

成员函数说明

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.

在文件 dof_map.C 第 2381 行定义.

参考 _dont_p_refine, libMesh::Variable::active_on_subdomain(), libMesh::DofObject::invalid_id, n_dofs(), sys_number(), libMesh::Variable::type() , 以及 variable_group().

参考自 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();
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
      const bool is_inf          = elem.infinite();
#endif

      const bool extra_hanging_dofs =
        FEInterface::extra_hanging_dofs(var.type());

      FEType fe_type = var.type();

      const bool add_p_level =
#ifdef LIBMESH_ENABLE_AMR
          !_dont_p_refine.count(vg);
#else
          false;
#endif

#ifdef DEBUG
      // The number of dofs per element is non-static for subdivision FE
      if (var.type().family == SUBDIVISION)
        tot_size += n_nodes;
      else
        // FIXME: Is the passed-in p_level just elem.p_level()? If so,
        // this seems redundant.
        tot_size += FEInterface::n_dofs(fe_type, add_p_level*p_level, &elem);
#endif

      // The total Order is not required when getting the function
      // pointer, it is only needed when the function is called (see
      // below).
      const FEInterface::n_dofs_at_node_ptr ndan =
        FEInterface::n_dofs_at_node_function(fe_type, &elem);

      // Get the node-based DOF numbers
      for (unsigned int n=0; n != n_nodes; n++)
        {
          const Node & node = *nodes[n];

          // Cache the intermediate lookups that are common to every
          // component
#ifdef DEBUG
          const std::pair<unsigned int, unsigned int>
            vg_and_offset = node.var_to_vg_and_offset(sys_num,v);
          libmesh_assert_equal_to (vg, vg_and_offset.first);
          libmesh_assert_equal_to (vig, vg_and_offset.second);
#endif
          const unsigned int n_comp = node.n_comp_group(sys_num,vg);

          // There is a potential problem with h refinement.  Imagine a
          // quad9 that has a linear FE on it.  Then, on the hanging side,
          // it can falsely identify a DOF at the mid-edge node. This is why
          // we go through FEInterface instead of node.n_comp() directly.
          const unsigned int nc =
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
            is_inf ?
            FEInterface::n_dofs_at_node(fe_type, add_p_level*p_level, &elem, n) :
#endif
            ndan (type, static_cast<Order>(fe_type.order + add_p_level*p_level), n);

          // If this is a non-vertex on a hanging node with extra
          // degrees of freedom, we use the non-vertex dofs (which
          // come in reverse order starting from the end, to
          // simplify p refinement)
          if (extra_hanging_dofs && !elem.is_vertex(n))
            {
              const int dof_offset = n_comp - nc;

              // We should never have fewer dofs than necessary on a
              // node unless we're getting indices on a parent element,
              // and we should never need the indices on such a node
              if (dof_offset < 0)
                {
                  libmesh_assert(!elem.active());
                  di.resize(di.size() + nc, DofObject::invalid_id);
                }
              else
                for (int i=int(n_comp)-1; i>=dof_offset; i--)
                  {
                    const dof_id_type d =
                      node.dof_number(sys_num, vg, vig, i, n_comp);
                    libmesh_assert_not_equal_to (d, DofObject::invalid_id);
                    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
            {
              // We have a good component index only if it's being
              // used on this FE type (nc) *and* it's available on
              // this DofObject (n_comp).
              const unsigned int good_nc = std::min(n_comp, nc);
              for (unsigned int i=0; i!=good_nc; ++i)
                {
                  const dof_id_type d =
                    node.dof_number(sys_num, vg, vig, i, n_comp);
                  libmesh_assert_not_equal_to (d, DofObject::invalid_id);
                  libmesh_assert_less (d, this->n_dofs());
                  di.push_back(d);
                }

              // With fewer good component indices than we need, e.g.
              // due to subdomain expansion, the remaining expected
              // indices are marked invalid.
              if (n_comp < nc)
                for (unsigned int i=n_comp; i!=nc; ++i)
                  di.push_back(DofObject::invalid_id);
            }
        }

      // If there are any element-based DOF numbers, get them
      const unsigned int nc = FEInterface::n_dofs_per_elem(fe_type, add_p_level*p_level, &elem);

      // We should never have fewer dofs than necessary on an
      // element unless we're getting indices on a parent element
      // (and we should never need those indices) or off-domain for a
      // subdomain-restricted variable (where invalid_id is the
      // correct thing to return)
      if (nc != 0)
        {
          const unsigned int n_comp = elem.n_comp_group(sys_num,vg);
          if (elem.n_systems() > sys_num && nc <= n_comp)
            {
              for (unsigned int i=0; i<nc; i++)
                {
                  const dof_id_type d =
                    elem.dof_number(sys_num, vg, vig, i, n_comp);
                  libmesh_assert_not_equal_to (d, DofObject::invalid_id);

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

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

private

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

在文件 dof_map.C 第 2296 行定义.

参考 _dont_p_refine, libMesh::DofObject::dof_number(), libMesh::DofObject::invalid_id, libMesh::DofObject::n_comp_group(), sys_number(), libMesh::Variable::type(), libMesh::DofObject::var_to_vg_and_offset() , 以及 variable_group().

参考自 dof_indices() , 以及 old_dof_indices().

{
  // Half of this is a cut and paste of _dof_indices code below, but
  // duplication actually seems cleaner than creating a helper
  // function with a million arguments and hoping the compiler inlines
  // it properly into one of our most highly trafficked functions.

  LOG_SCOPE("_node_dof_indices()", "DofMap");

  const unsigned int sys_num = this->sys_number();
  const auto [vg, vig] =
    obj.var_to_vg_and_offset(sys_num,vn);
  const unsigned int n_comp = obj.n_comp_group(sys_num,vg);

  const VariableGroup & var = this->variable_group(vg);
  FEType fe_type = var.type();
  const bool extra_hanging_dofs =
    FEInterface::extra_hanging_dofs(fe_type);

  const bool add_p_level =
#ifdef LIBMESH_ENABLE_AMR
      !_dont_p_refine.count(vg);
#else
      false;
#endif

  // There is a potential problem with h refinement.  Imagine a
  // quad9 that has a linear FE on it.  Then, on the hanging side,
  // it can falsely identify a DOF at the mid-edge node. This is why
  // we go through FEInterface instead of obj->n_comp() directly.
  const unsigned int nc =
    FEInterface::n_dofs_at_node(fe_type, &elem, n, add_p_level);

  // If this is a non-vertex on a hanging node with extra
  // degrees of freedom, we use the non-vertex dofs (which
  // come in reverse order starting from the end, to
  // simplify p refinement)
  if (extra_hanging_dofs && nc && !elem.is_vertex(n))
    {
      const int dof_offset = n_comp - nc;

      // We should never have fewer dofs than necessary on a
      // node unless we're getting indices on a parent element,
      // and we should never need the indices on such a node
      if (dof_offset < 0)
        {
          libmesh_assert(!elem.active());
          di.resize(di.size() + nc, DofObject::invalid_id);
        }
      else
        for (unsigned int i = dof_offset; i != n_comp; ++i)
          {
            const dof_id_type d =
              obj.dof_number(sys_num, vg, vig, i, n_comp);
            libmesh_assert_not_equal_to (d, DofObject::invalid_id);
            di.push_back(d);
          }
    }
  // If this is a vertex or an element without extra hanging
  // dofs, our dofs come in forward order coming from the
  // beginning.  But we still might not have all those dofs, in cases
  // where a subdomain-restricted variable just had its subdomain
  // expanded.
  else
    {
      const unsigned int good_nc =
        std::min(static_cast<unsigned int>(n_comp), nc);
      for (unsigned int i=0; i != good_nc; ++i)
        {
          const dof_id_type d =
            obj.dof_number(sys_num, vg, vig, i, n_comp);
          libmesh_assert_not_equal_to (d, DofObject::invalid_id);
          di.push_back(d);
        }
      for (unsigned int i=good_nc; i != nc; ++i)
        di.push_back(DofObject::invalid_id);
    }
}

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.

在文件 dof_map_constraints.C 第 2218 行定义.

参考 _adjoint_constraint_values , 以及 is_constrained_dof().

{
  // Optionally allow the user to overwrite constraints.  Defaults to false.
  if (forbid_constraint_overwrite)
    {
      libmesh_error_msg_if(!this->is_constrained_dof(dof_number),
                           "ERROR: DOF " << dof_number << " has no corresponding primal constraint!");
#ifndef NDEBUG
      // No way to do this without a non-normalized tolerance?

      // // If the user passed in more than just the rhs, let's check the
      // // coefficients for consistency
      // if (!constraint_row.empty())
      //   {
      //     DofConstraintRow row = _dof_constraints[dof_number];
      //     for (const auto & [dof, val] : row)
      //       libmesh_assert(constraint_row.find(dof)->second == val);
      //   }
      //
      // if (_adjoint_constraint_values[qoi_index].find(dof_number) !=
      //     _adjoint_constraint_values[qoi_index].end())
      //   libmesh_assert_equal_to(_adjoint_constraint_values[qoi_index][dof_number],
      //                           constraint_rhs);

#endif
    }

  // Creates the map of rhs values if it doesn't already exist; then
  // adds the current value to that map

  // 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].emplace(dof_number, constraint_rhs);
  if (!rhs_it.second)
    rhs_it.first->second = constraint_rhs;
}

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.

在文件 dof_map_constraints.C 第 5456 行定义.

参考 _adjoint_dirichlet_boundaries.

{
  unsigned int old_size = cast_int<unsigned int>
    (_adjoint_dirichlet_boundaries.size());
  for (unsigned int i = old_size; i <= qoi_index; ++i)
    _adjoint_dirichlet_boundaries.push_back(std::make_unique<DirichletBoundaries>());

  // Make copy of DirichletBoundary, owned by _adjoint_dirichlet_boundaries
  _adjoint_dirichlet_boundaries[qoi_index]->push_back
    (std::make_unique<DirichletBoundary>(dirichlet_boundary));
}

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.

在文件 dof_map.C 第 1886 行定义.

参考 _algebraic_ghosting_functors , 以及 _mesh.

参考自 add_algebraic_ghosting_functor(), add_default_ghosting(), clear() , 以及 DofMap().

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

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

inline

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

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

在文件 dof_map.h 第 391 行定义.

参考 _shared_functors , 以及 add_algebraic_ghosting_functor().

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

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.

在文件 dof_map_constraints.C 第 2183 行定义.

参考 _dof_constraints, _primal_constraint_values, is_constrained_dof() , 以及 n_dofs().

参考自 add_constraint_row() , 以及 process_mesh_constraint_rows().

{
  // Optionally allow the user to overwrite constraints.  Defaults to false.
  libmesh_error_msg_if(forbid_constraint_overwrite && this->is_constrained_dof(dof_number),
                       "ERROR: DOF " << dof_number << " was already constrained!");

  libmesh_assert_less(dof_number, this->n_dofs());

  // There is an implied "1" on the diagonal of the constraint row, and the user
  // should not try to manually set _any_ value on the diagonal.
  libmesh_assert_msg(!constraint_row.count(dof_number),
                     "Error: constraint_row for dof " << dof_number <<
                     " should not contain an entry for dof " << dof_number);

#ifndef NDEBUG
  for (const auto & pr : constraint_row)
    libmesh_assert_less(pr.first, this->n_dofs());
#endif

  // We don't get insert_or_assign until C++17 so we make do.
  std::pair<DofConstraints::iterator, bool> it =
    _dof_constraints.emplace(dof_number, constraint_row);
  if (!it.second)
    it.first->second = constraint_row;

  std::pair<DofConstraintValueMap::iterator, bool> rhs_it =
    _primal_constraint_values.emplace(dof_number, constraint_rhs);
  if (!rhs_it.second)
    rhs_it.first->second = constraint_rhs;
}

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.

在文件 dof_map.h 第 1002 行定义.

参考 add_constraint_row().

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

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.

在文件 dof_map_constraints.C 第 5349 行定义.

参考 _dof_constraints, _send_list , 以及 local_index().

参考自 process_constraints().

{
  // 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 & [constrained_dof, constraint_row] : _dof_constraints)
    {
      // We only need the dependencies of our own constrained dofs
      if (!this->local_index(constrained_dof))
        continue;

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

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.

在文件 dof_map.C 第 1861 行定义.

参考 _coupling_functors , 以及 _mesh.

参考自 add_coupling_functor(), add_default_ghosting(), clear() , 以及 DofMap().

{
  _coupling_functors.insert(&coupling_functor);
  coupling_functor.set_mesh(&_mesh);
  if (to_mesh)
    _mesh.add_ghosting_functor(coupling_functor);
}

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

inline

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

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

在文件 dof_map.h 第 329 行定义.

参考 _shared_functors , 以及 add_coupling_functor().

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

void libMesh::DofMap::add_default_ghosting

(

)

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

User-added ghosting functors will be unaffected.

在文件 dof_map.C 第 1852 行定义.

参考 add_algebraic_ghosting_functor(), add_coupling_functor(), default_algebraic_ghosting() , 以及 default_coupling().

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

void libMesh::DofMap::add_dirichlet_boundary

(

const DirichletBoundary &

dirichlet_boundary

)

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

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

在文件 dof_map_constraints.C 第 5450 行定义.

参考 _dirichlet_boundaries.

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

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.

在文件 dof_map.C 第 1544 行定义.

参考 _send_list, algebraic_ghosting_functors_begin(), algebraic_ghosting_functors_end(), coupling_functors_begin(), coupling_functors_end(), dof_indices(), libMesh::DofObject::invalid_id, local_index(), merge_ghost_functor_outputs(), n_dofs() , 以及 n_variables().

参考自 distribute_dofs() , 以及 reinit_send_list().

{
  LOG_SCOPE("add_neighbors_to_send_list()", "DofMap");

  // Return immediately if there's no ghost data
  if (this->n_processors() == 1)
    return;

  const unsigned int n_var  = this->n_variables();

  MeshBase::const_element_iterator       local_elem_it
    = mesh.active_local_elements_begin();
  const MeshBase::const_element_iterator local_elem_end
    = mesh.active_local_elements_end();

  GhostingFunctor::map_type elements_to_send;
  DofMap::CouplingMatricesSet temporary_coupling_matrices;

  // We need to add dofs to the send list if they've been directly
  // requested by an algebraic ghosting functor or they've been
  // indirectly requested by a coupling functor.
  this->merge_ghost_functor_outputs(elements_to_send,
                                    temporary_coupling_matrices,
                                    this->algebraic_ghosting_functors_begin(),
                                    this->algebraic_ghosting_functors_end(),
                                    local_elem_it, local_elem_end, mesh.processor_id());

  this->merge_ghost_functor_outputs(elements_to_send,
                                    temporary_coupling_matrices,
                                    this->coupling_functors_begin(),
                                    this->coupling_functors_end(),
                                    local_elem_it, local_elem_end, mesh.processor_id());

  // Making a list of non-zero coupling matrix columns is an
  // O(N_var^2) operation.  We cache it so we only have to do it once
  // per CouplingMatrix and not once per element.
  std::map<const CouplingMatrix *, std::vector<unsigned int>>
    column_variable_lists;

  for (const auto & [partner, ghost_coupling] : elements_to_send)
    {
      // We asked ghosting functors not to give us local elements
      libmesh_assert_not_equal_to
        (partner->processor_id(), this->processor_id());

      // Loop over any present coupling matrix column variables if we
      // have a coupling matrix, or just add all variables to
      // send_list if not.
      if (ghost_coupling)
        {
          libmesh_assert_equal_to (ghost_coupling->size(), n_var);

          // Try to find a cached list of column variables.
          std::map<const CouplingMatrix *, std::vector<unsigned int>>::const_iterator
            column_variable_list = column_variable_lists.find(ghost_coupling);

          // If we didn't find it, then we need to create it.
          if (column_variable_list == column_variable_lists.end())
            {
              auto inserted_variable_list_pair =
                column_variable_lists.emplace(ghost_coupling, std::vector<unsigned int>());
              column_variable_list = inserted_variable_list_pair.first;

              std::vector<unsigned int> & new_variable_list =
                inserted_variable_list_pair.first->second;

              std::vector<unsigned char> has_variable(n_var, false);

              for (unsigned int vi = 0; vi != n_var; ++vi)
                {
                  ConstCouplingRow ccr(vi, *ghost_coupling);

                  for (const auto & vj : ccr)
                    has_variable[vj] = true;
                }
              for (unsigned int vj = 0; vj != n_var; ++vj)
                {
                  if (has_variable[vj])
                    new_variable_list.push_back(vj);
                }
            }

          const std::vector<unsigned int> & variable_list =
            column_variable_list->second;

          for (const auto & vj : variable_list)
            {
              std::vector<dof_id_type> di;
              this->dof_indices (partner, di, vj);

              // Insert the remote DOF indices into the send list
              for (auto d : di)
                if (d != DofObject::invalid_id &&
                    !this->local_index(d))
                  {
                    libmesh_assert_less(d, this->n_dofs());
                    _send_list.push_back(d);
                  }
            }
        }
      else
        {
          std::vector<dof_id_type> di;
          this->dof_indices (partner, di);

          // Insert the remote DOF indices into the send list
          for (const auto & dof : di)
            if (dof != DofObject::invalid_id &&
                !this->local_index(dof))
              {
                libmesh_assert_less(dof, this->n_dofs());
                _send_list.push_back(dof);
              }
        }

    }

  // We're now done with any merged coupling matrices we had to create.
  temporary_coupling_matrices.clear();

  //-------------------------------------------------------------------------
  // Our coupling functors added dofs from neighboring elements to the
  // send list, but we may still need to add non-local dofs from local
  // elements.
  //-------------------------------------------------------------------------

  // Loop over the active local elements, adding all active elements
  // that neighbor an active local element to the send list.
  for ( ; local_elem_it != local_elem_end; ++local_elem_it)
    {
      const Elem * elem = *local_elem_it;

      std::vector<dof_id_type> di;
      this->dof_indices (elem, di);

      // Insert the remote DOF indices into the send list
      for (const auto & dof : di)
        if (dof != DofObject::invalid_id &&
            !this->local_index(dof))
          {
            libmesh_assert_less(dof, this->n_dofs());
            _send_list.push_back(dof);
          }
    }
}

void libMesh::DofMap::add_periodic_boundary

(

const PeriodicBoundaryBase &

periodic_boundary

)

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

在文件 dof_map_constraints.C 第 5570 行定义.

参考 _periodic_boundaries, libMesh::PeriodicBoundaryBase::clone(), libMesh::PeriodicBoundaryBase::INVERSE, libMesh::PeriodicBoundaryBase::merge(), libMesh::PeriodicBoundaryBase::myboundary , 以及 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)
    {
      // ...if not, clone the input (and its inverse) and add them to the PeriodicBoundaries object
      // Pass the pairedboundary of the original as the boundary id of the inverse clone.
      _periodic_boundaries->emplace(periodic_boundary.myboundary, periodic_boundary.clone());
      _periodic_boundaries->emplace(periodic_boundary.pairedboundary, periodic_boundary.clone(PeriodicBoundaryBase::INVERSE));
    }
  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);
    }
}

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

Add a periodic boundary pair.

参数

boundary	- primary boundary
inverse_boundary	- inverse boundary

在文件 dof_map_constraints.C 第 5597 行定义.

参考 _periodic_boundaries, libMesh::PeriodicBoundaryBase::clone(), libMesh::PeriodicBoundaryBase::myboundary , 以及 libMesh::PeriodicBoundaryBase::pairedboundary.

{
  libmesh_assert_equal_to (boundary.myboundary, inverse_boundary.pairedboundary);
  libmesh_assert_equal_to (boundary.pairedboundary, inverse_boundary.myboundary);

  // Store clones of the passed-in objects. These will be cleaned up
  // automatically in the _periodic_boundaries destructor.
  _periodic_boundaries->emplace(boundary.myboundary, boundary.clone());
  _periodic_boundaries->emplace(inverse_boundary.myboundary, inverse_boundary.clone());
}

void libMesh::DofMap::add_variable_group

(

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.

在文件 dof_map.C 第 252 行定义.

参考 _var_to_vg, _variable_group_numbers, _variable_groups, _variables , 以及 libMesh::VariableGroup::n_variables().

{
  // Ensure that we are not duplicating an existing entry in _variable_groups
  if (std::find(_variable_groups.begin(), _variable_groups.end(), var_group) == _variable_groups.end())
  {
   const unsigned int vg = cast_int<unsigned int>(_variable_groups.size());

   _variable_groups.push_back(std::move(var_group));

    VariableGroup & new_var_group = _variable_groups.back();

    for (auto var : make_range(new_var_group.n_variables()))
    {
      auto var_instance = new_var_group(var);
      const auto vn = var_instance.number();
      _variables.push_back (std::move(var_instance));
      _variable_group_numbers.push_back (vg);
      _var_to_vg.emplace(vn, vg);
    }
  }
  // End if check for var_group in _variable_groups

}

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

inline

Beginning of range of algebraic ghosting functors.

在文件 dof_map.h 第 406 行定义.

参考 _algebraic_ghosting_functors.

参考自 add_neighbors_to_send_list().

  { return _algebraic_ghosting_functors.begin(); }

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

inline

End of range of algebraic ghosting functors.

在文件 dof_map.h 第 412 行定义.

参考 _algebraic_ghosting_functors.

参考自 add_neighbors_to_send_list().

  { return _algebraic_ghosting_functors.end(); }

bool libMesh::DofMap::all_semilocal_indices

(

const std::vector< dof_id_type > &

dof_indices

)

const

返回

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

注解

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

在文件 dof_map.C 第 2596 行定义.

参考 semilocal_index().

参考自 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;
}

void libMesh::DofMap::allgather_recursive_constraints

(

MeshBase &

mesh

)

Gathers constraint equation dependencies from other processors.

在文件 dof_map_constraints.C 第 3708 行定义.

参考 _adjoint_constraint_values, _dof_constraints, _node_constraints, _primal_constraint_values, gather_constraints(), libMesh::DofObject::invalid_id, is_constrained_dof(), is_constrained_node(), libMesh::libmesh_isnan(), libMesh::Real , 以及 sys_number().

参考自 process_constraints().

{
  // This function must be run on all processors at once
  parallel_object_only();

  // Return immediately if there's nothing to gather
  if (this->n_processors() == 1)
    return;

  // We might get to return immediately if none of the processors
  // found any constraints
  unsigned int has_constraints = !_dof_constraints.empty()
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
    || !_node_constraints.empty()
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
    ;
  this->comm().max(has_constraints);
  if (!has_constraints)
    return;

  // If we have heterogeneous adjoint constraints we need to
  // communicate those too.
  const unsigned int max_qoi_num =
    _adjoint_constraint_values.empty() ?
    0 : _adjoint_constraint_values.rbegin()->first+1;

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  // We may need to send nodes ahead of data about them
  std::vector<Parallel::Request> packed_range_sends;

  // We may be receiving packed_range sends out of order with
  // parallel_sync tags, so make sure they're received correctly.
  Parallel::MessageTag range_tag = this->comm().get_unique_tag();

  // We only need to do these sends on a distributed mesh
  const bool dist_mesh = !mesh.is_serial();
#endif

  // We might have calculated constraints for constrained dofs
  // which have support on other processors.
  // Push these out first.
  {
    std::map<processor_id_type, std::set<dof_id_type>> pushed_ids;

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
    std::map<processor_id_type, std::set<dof_id_type>> pushed_node_ids;
#endif

    const unsigned int sys_num = this->sys_number();

    // Collect the constraints to push to each processor
    for (auto & elem : as_range(mesh.active_not_local_elements_begin(),
                                mesh.active_not_local_elements_end()))
      {
        const unsigned short n_nodes = elem->n_nodes();

        // Just checking dof_indices on the foreign element isn't
        // enough.  Consider a central hanging node between a coarse
        // Q2/Q1 element and its finer neighbors on a higher-ranked
        // processor.  The coarse element's processor will own the node,
        // and will thereby own the pressure dof on that node, despite
        // the fact that that pressure dof doesn't directly exist on the
        // coarse element!
        //
        // So, we loop through dofs manually.

        {
          const unsigned int n_vars = elem->n_vars(sys_num);
          for (unsigned int v=0; v != n_vars; ++v)
            {
              const unsigned int n_comp = elem->n_comp(sys_num,v);
              for (unsigned int c=0; c != n_comp; ++c)
                {
                  const unsigned int id =
                    elem->dof_number(sys_num,v,c);
                  if (this->is_constrained_dof(id))
                    pushed_ids[elem->processor_id()].insert(id);
                }
            }
        }

        for (unsigned short n = 0; n != n_nodes; ++n)
          {
            const Node & node = elem->node_ref(n);
            const unsigned int n_vars = node.n_vars(sys_num);
            for (unsigned int v=0; v != n_vars; ++v)
              {
                const unsigned int n_comp = node.n_comp(sys_num,v);
                for (unsigned int c=0; c != n_comp; ++c)
                  {
                    const unsigned int id =
                      node.dof_number(sys_num,v,c);
                    if (this->is_constrained_dof(id))
                      pushed_ids[elem->processor_id()].insert(id);
                  }
              }
          }

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
        for (unsigned short n = 0; n != n_nodes; ++n)
          if (this->is_constrained_node(elem->node_ptr(n)))
            pushed_node_ids[elem->processor_id()].insert(elem->node_id(n));
#endif
      }

    // Rewrite those id sets as vectors for sending and receiving,
    // then find the corresponding data for each id, then push it all.
    std::map<processor_id_type, std::vector<dof_id_type>>
      pushed_id_vecs, received_id_vecs;
    for (auto & p : pushed_ids)
      pushed_id_vecs[p.first].assign(p.second.begin(), p.second.end());

    std::map<processor_id_type, std::vector<std::vector<std::pair<dof_id_type,Real>>>>
      pushed_keys_vals, received_keys_vals;
    std::map<processor_id_type, std::vector<std::vector<Number>>> pushed_rhss, received_rhss;
    for (auto & p : pushed_id_vecs)
      {
        auto & keys_vals = pushed_keys_vals[p.first];
        keys_vals.reserve(p.second.size());

        auto & rhss = pushed_rhss[p.first];
        rhss.reserve(p.second.size());
        for (auto & pushed_id : p.second)
          {
            const DofConstraintRow & row = _dof_constraints[pushed_id];
            keys_vals.emplace_back(row.begin(), row.end());

            rhss.push_back(std::vector<Number>(max_qoi_num+1));
            std::vector<Number> & rhs = rhss.back();
            DofConstraintValueMap::const_iterator rhsit =
              _primal_constraint_values.find(pushed_id);
            rhs[max_qoi_num] =
              (rhsit == _primal_constraint_values.end()) ?
              0 : rhsit->second;
            for (unsigned int q = 0; q != max_qoi_num; ++q)
              {
                AdjointDofConstraintValues::const_iterator adjoint_map_it =
                  _adjoint_constraint_values.find(q);

                if (adjoint_map_it == _adjoint_constraint_values.end())
                  continue;

                const DofConstraintValueMap & constraint_map =
                  adjoint_map_it->second;

                DofConstraintValueMap::const_iterator adj_rhsit =
                  constraint_map.find(pushed_id);

                rhs[q] =
                  (adj_rhsit == constraint_map.end()) ?
                  0 : adj_rhsit->second;
              }
          }
      }

    auto ids_action_functor =
      [& received_id_vecs]
      (processor_id_type pid,
       const std::vector<dof_id_type> & data)
      {
        received_id_vecs[pid] = data;
      };

    Parallel::push_parallel_vector_data
      (this->comm(), pushed_id_vecs, ids_action_functor);

    auto keys_vals_action_functor =
      [& received_keys_vals]
      (processor_id_type pid,
       const std::vector<std::vector<std::pair<dof_id_type,Real>>> & data)
      {
        received_keys_vals[pid] = data;
      };

    Parallel::push_parallel_vector_data
      (this->comm(), pushed_keys_vals, keys_vals_action_functor);

    auto rhss_action_functor =
      [& received_rhss]
      (processor_id_type pid,
       const std::vector<std::vector<Number>> & data)
      {
        received_rhss[pid] = data;
      };

    Parallel::push_parallel_vector_data
      (this->comm(), pushed_rhss, rhss_action_functor);

    // Now we have all the DofConstraint rows and rhs values received
    // from others, so add the DoF constraints that we've been sent

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
    std::map<processor_id_type, std::vector<dof_id_type>>
      pushed_node_id_vecs, received_node_id_vecs;
    for (auto & p : pushed_node_ids)
      pushed_node_id_vecs[p.first].assign(p.second.begin(), p.second.end());

    std::map<processor_id_type, std::vector<std::vector<std::pair<dof_id_type,Real>>>>
      pushed_node_keys_vals, received_node_keys_vals;
    std::map<processor_id_type, std::vector<Point>> pushed_offsets, received_offsets;

    for (auto & p : pushed_node_id_vecs)
      {
        const processor_id_type pid = p.first;

        // FIXME - this could be an unordered set, given a
        // hash<pointers> specialization
        std::set<const Node *> nodes_requested;

        auto & node_keys_vals = pushed_node_keys_vals[pid];
        node_keys_vals.reserve(p.second.size());

        auto & offsets = pushed_offsets[pid];
        offsets.reserve(p.second.size());

        for (auto & pushed_node_id : p.second)
          {
            const Node * node = mesh.node_ptr(pushed_node_id);
            NodeConstraintRow & row = _node_constraints[node].first;
            const std::size_t row_size = row.size();
            node_keys_vals.push_back
              (std::vector<std::pair<dof_id_type,Real>>());
            std::vector<std::pair<dof_id_type,Real>> & this_node_kv =
              node_keys_vals.back();
            this_node_kv.reserve(row_size);
            for (const auto & j : row)
              {
                this_node_kv.emplace_back(j.first->id(), j.second);

                // If we're not sure whether our send
                // destination already has this node, let's give
                // it a copy.
                if (j.first->processor_id() != pid && dist_mesh)
                  nodes_requested.insert(j.first);
              }

            offsets.push_back(_node_constraints[node].second);

          }

        // Constraining nodes might not even exist on our
        // correspondant's subset of a distributed mesh, so let's
        // make them exist.
        if (dist_mesh)
          {
            packed_range_sends.push_back(Parallel::Request());
            this->comm().send_packed_range
              (pid, &mesh, nodes_requested.begin(), nodes_requested.end(),
               packed_range_sends.back(), range_tag);
          }
      }

    auto node_ids_action_functor =
      [& received_node_id_vecs]
      (processor_id_type pid,
       const std::vector<dof_id_type> & data)
      {
        received_node_id_vecs[pid] = data;
      };

    Parallel::push_parallel_vector_data
      (this->comm(), pushed_node_id_vecs, node_ids_action_functor);

    auto node_keys_vals_action_functor =
      [& received_node_keys_vals]
      (processor_id_type pid,
       const std::vector<std::vector<std::pair<dof_id_type,Real>>> & data)
      {
        received_node_keys_vals[pid] = data;
      };

    Parallel::push_parallel_vector_data
      (this->comm(), pushed_node_keys_vals,
       node_keys_vals_action_functor);

    auto node_offsets_action_functor =
      [& received_offsets]
      (processor_id_type pid,
       const std::vector<Point> & data)
      {
        received_offsets[pid] = data;
      };

    Parallel::push_parallel_vector_data
      (this->comm(), pushed_offsets, node_offsets_action_functor);

#endif

    // Add all the dof constraints that I've been sent
    for (auto & [pid, pushed_ids_to_me] : received_id_vecs)
      {
        libmesh_assert(received_keys_vals.count(pid));
        libmesh_assert(received_rhss.count(pid));
        const auto & pushed_keys_vals_to_me = received_keys_vals.at(pid);
        const auto & pushed_rhss_to_me = received_rhss.at(pid);

        libmesh_assert_equal_to (pushed_ids_to_me.size(),
                                 pushed_keys_vals_to_me.size());
        libmesh_assert_equal_to (pushed_ids_to_me.size(),
                                 pushed_rhss_to_me.size());

        for (auto i : index_range(pushed_ids_to_me))
          {
            dof_id_type constrained = pushed_ids_to_me[i];

            // If we don't already have a constraint for this dof,
            // add the one we were sent
            if (!this->is_constrained_dof(constrained))
              {
                DofConstraintRow & row = _dof_constraints[constrained];
                for (auto & kv : pushed_keys_vals_to_me[i])
                  {
                    libmesh_assert_less(kv.first, this->n_dofs());
                    row[kv.first] = kv.second;
                  }

                const Number primal_rhs = pushed_rhss_to_me[i][max_qoi_num];

                if (libmesh_isnan(primal_rhs))
                  libmesh_assert(pushed_keys_vals_to_me[i].empty());

                if (primal_rhs != Number(0))
                  _primal_constraint_values[constrained] = primal_rhs;
                else
                  _primal_constraint_values.erase(constrained);

                for (unsigned int q = 0; q != max_qoi_num; ++q)
                  {
                    AdjointDofConstraintValues::iterator adjoint_map_it =
                      _adjoint_constraint_values.find(q);

                    const Number adj_rhs = pushed_rhss_to_me[i][q];

                    if ((adjoint_map_it == _adjoint_constraint_values.end()) &&
                        adj_rhs == Number(0))
                      continue;

                    if (adjoint_map_it == _adjoint_constraint_values.end())
                      adjoint_map_it = _adjoint_constraint_values.emplace
                        (q, DofConstraintValueMap()).first;

                    DofConstraintValueMap & constraint_map =
                      adjoint_map_it->second;

                    if (adj_rhs != Number(0))
                      constraint_map[constrained] = adj_rhs;
                    else
                      constraint_map.erase(constrained);
                  }
              }
          }
      }

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
    // Add all the node constraints that I've been sent
    for (auto & [pid, pushed_node_ids_to_me] : received_node_id_vecs)
      {
        // Before we act on any new constraint rows, we may need to
        // make sure we have all the nodes involved!
        if (dist_mesh)
          this->comm().receive_packed_range
            (pid, &mesh, null_output_iterator<Node>(),
             (Node**)nullptr, range_tag);

        libmesh_assert(received_node_keys_vals.count(pid));
        libmesh_assert(received_offsets.count(pid));
        const auto & pushed_node_keys_vals_to_me = received_node_keys_vals.at(pid);
        const auto & pushed_offsets_to_me = received_offsets.at(pid);

        libmesh_assert_equal_to (pushed_node_ids_to_me.size(),
                                 pushed_node_keys_vals_to_me.size());
        libmesh_assert_equal_to (pushed_node_ids_to_me.size(),
                                 pushed_offsets_to_me.size());

        for (auto i : index_range(pushed_node_ids_to_me))
          {
            dof_id_type constrained_id = pushed_node_ids_to_me[i];

            // If we don't already have a constraint for this node,
            // add the one we were sent
            const Node * constrained = mesh.node_ptr(constrained_id);
            if (!this->is_constrained_node(constrained))
              {
                NodeConstraintRow & row = _node_constraints[constrained].first;
                for (auto & kv : pushed_node_keys_vals_to_me[i])
                  {
                    const Node * key_node = mesh.node_ptr(kv.first);
                    libmesh_assert(key_node);
                    row[key_node] = kv.second;
                  }
                _node_constraints[constrained].second = pushed_offsets_to_me[i];
              }
          }
      }
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
  }

  // Now start checking for any other constraints we need
  // to know about, requesting them recursively.

  // Create sets containing the DOFs and nodes we already depend on
  typedef std::set<dof_id_type> DoF_RCSet;
  DoF_RCSet unexpanded_dofs;

  for (const auto & i : _dof_constraints)
    unexpanded_dofs.insert(i.first);

  // Gather all the dof constraints we need
  this->gather_constraints(mesh, unexpanded_dofs, false);

  // Gather all the node constraints we need
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  typedef std::set<const Node *> Node_RCSet;
  Node_RCSet unexpanded_nodes;

  for (const auto & i : _node_constraints)
    unexpanded_nodes.insert(i.first);

  // We have to keep recursing while the unexpanded set is
  // nonempty on *any* processor
  bool unexpanded_set_nonempty = !unexpanded_nodes.empty();
  this->comm().max(unexpanded_set_nonempty);

  while (unexpanded_set_nonempty)
    {
      // Let's make sure we don't lose sync in this loop.
      parallel_object_only();

      // Request sets
      Node_RCSet node_request_set;

      // Request sets to send to each processor
      std::map<processor_id_type, std::vector<dof_id_type>>
        requested_node_ids;

      // And the sizes of each
      std::map<processor_id_type, dof_id_type> node_ids_on_proc;

      // Fill (and thereby sort and uniq!) the main request sets
      for (const auto & i : unexpanded_nodes)
        {
          NodeConstraintRow & row = _node_constraints[i].first;
          for (const auto & j : row)
            {
              const Node * const node = j.first;
              libmesh_assert(node);

              // If it's non-local and we haven't already got a
              // constraint for it, we might need to ask for one
              if ((node->processor_id() != this->processor_id()) &&
                  !_node_constraints.count(node))
                node_request_set.insert(node);
            }
        }

      // Clear the unexpanded constraint sets; we're about to expand
      // them
      unexpanded_nodes.clear();

      // Count requests by processor
      for (const auto & node : node_request_set)
        {
          libmesh_assert(node);
          libmesh_assert_less (node->processor_id(), this->n_processors());
          node_ids_on_proc[node->processor_id()]++;
        }

      for (auto pair : node_ids_on_proc)
        requested_node_ids[pair.first].reserve(pair.second);

      // Prepare each processor's request set
      for (const auto & node : node_request_set)
        requested_node_ids[node->processor_id()].push_back(node->id());

      typedef std::vector<std::pair<dof_id_type, Real>> row_datum;

      auto node_row_gather_functor =
        [this,
         & mesh,
         dist_mesh,
         & packed_range_sends,
         & range_tag]
        (processor_id_type pid,
         const std::vector<dof_id_type> & ids,
         std::vector<row_datum> & data)
        {
          // FIXME - this could be an unordered set, given a
          // hash<pointers> specialization
          std::set<const Node *> nodes_requested;

          // Fill those requests
          const std::size_t query_size = ids.size();

          data.resize(query_size);
          for (std::size_t i=0; i != query_size; ++i)
            {
              dof_id_type constrained_id = ids[i];
              const Node * constrained_node = mesh.node_ptr(constrained_id);
              if (_node_constraints.count(constrained_node))
                {
                  const NodeConstraintRow & row = _node_constraints[constrained_node].first;
                  std::size_t row_size = row.size();
                  data[i].reserve(row_size);
                  for (const auto & j : row)
                    {
                      const Node * node = j.first;
                      data[i].emplace_back(node->id(), j.second);

                      // If we're not sure whether our send
                      // destination already has this node, let's give
                      // it a copy.
                      if (node->processor_id() != pid && dist_mesh)
                        nodes_requested.insert(node);

                      // We can have 0 nodal constraint
                      // coefficients, where no Lagrange constraint
                      // exists but non-Lagrange basis constraints
                      // might.
                      // libmesh_assert(j.second);
                    }
                }
              else
                {
                  // We have to distinguish "constraint with no
                  // constraining nodes" (e.g. due to user node
                  // constraint equations) from "no constraint".
                  // We'll use invalid_id for the latter.
                  data[i].emplace_back(DofObject::invalid_id, Real(0));
                }
            }

          // Constraining nodes might not even exist on our
          // correspondant's subset of a distributed mesh, so let's
          // make them exist.
          if (dist_mesh)
            {
              packed_range_sends.push_back(Parallel::Request());
              this->comm().send_packed_range
                (pid, &mesh, nodes_requested.begin(), nodes_requested.end(),
                 packed_range_sends.back(), range_tag);
            }
        };

      typedef Point node_rhs_datum;

      auto node_rhs_gather_functor =
        [this,
         & mesh]
        (processor_id_type,
         const std::vector<dof_id_type> & ids,
         std::vector<node_rhs_datum> & data)
        {
          // Fill those requests
          const std::size_t query_size = ids.size();

          data.resize(query_size);
          for (std::size_t i=0; i != query_size; ++i)
            {
              dof_id_type constrained_id = ids[i];
              const Node * constrained_node = mesh.node_ptr(constrained_id);
              if (_node_constraints.count(constrained_node))
                data[i] = _node_constraints[constrained_node].second;
              else
                data[i](0) = std::numeric_limits<Real>::quiet_NaN();
            }
        };

      auto node_row_action_functor =
        [this,
         & mesh,
         dist_mesh,
         & range_tag,
         & unexpanded_nodes]
        (processor_id_type pid,
         const std::vector<dof_id_type> & ids,
         const std::vector<row_datum> & data)
        {
          // Before we act on any new constraint rows, we may need to
          // make sure we have all the nodes involved!
          if (dist_mesh)
            this->comm().receive_packed_range
              (pid, &mesh, null_output_iterator<Node>(),
               (Node**)nullptr, range_tag);

          // Add any new constraint rows we've found
          const std::size_t query_size = ids.size();

          for (std::size_t i=0; i != query_size; ++i)
            {
              const dof_id_type constrained_id = ids[i];

              // An empty row is an constraint with an empty row; for
              // no constraint we use a "no row" placeholder
              if (data[i].empty())
                {
                  const Node * constrained_node = mesh.node_ptr(constrained_id);
                  NodeConstraintRow & row = _node_constraints[constrained_node].first;
                  row.clear();
                }
              else if (data[i][0].first != DofObject::invalid_id)
                {
                  const Node * constrained_node = mesh.node_ptr(constrained_id);
                  NodeConstraintRow & row = _node_constraints[constrained_node].first;
                  row.clear();
                  for (auto & pair : data[i])
                    {
                      const Node * key_node =
                        mesh.node_ptr(pair.first);
                      libmesh_assert(key_node);
                      row[key_node] = pair.second;
                    }

                  // And prepare to check for more recursive constraints
                  unexpanded_nodes.insert(constrained_node);
                }
            }
        };

      auto node_rhs_action_functor =
        [this,
         & mesh]
        (processor_id_type,
         const std::vector<dof_id_type> & ids,
         const std::vector<node_rhs_datum> & data)
        {
          // Add rhs data for any new node constraint rows we've found
          const std::size_t query_size = ids.size();

          for (std::size_t i=0; i != query_size; ++i)
            {
              dof_id_type constrained_id = ids[i];
              const Node * constrained_node = mesh.node_ptr(constrained_id);

              if (!libmesh_isnan(data[i](0)))
                _node_constraints[constrained_node].second = data[i];
              else
                _node_constraints.erase(constrained_node);
            }
        };

      // Now request node constraint rows from other processors
      row_datum * node_row_ex = nullptr;
      Parallel::pull_parallel_vector_data
        (this->comm(), requested_node_ids, node_row_gather_functor,
         node_row_action_functor, node_row_ex);

      // And request node constraint right hand sides from other procesors
      node_rhs_datum * node_rhs_ex = nullptr;
      Parallel::pull_parallel_vector_data
        (this->comm(), requested_node_ids, node_rhs_gather_functor,
         node_rhs_action_functor, node_rhs_ex);


      // We have to keep recursing while the unexpanded set is
      // nonempty on *any* processor
      unexpanded_set_nonempty = !unexpanded_nodes.empty();
      this->comm().max(unexpanded_set_nonempty);
    }
  Parallel::wait(packed_range_sends);
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
}

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

private

在文件 dof_map.C 第 1418 行定义.

参考 libMesh::DofObject::invalid_id , 以及 sys_number().

参考自 distribute_local_dofs_node_major() , 以及 distribute_local_dofs_var_major().

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

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.

在文件 dof_map.h 第 468 行定义.

参考 _extra_send_list_context , 以及 _extra_send_list_function.

  { _extra_send_list_function = func; _extra_send_list_context = context; }

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!

在文件 dof_map.h 第 459 行定义.

参考 _augment_send_list.

  {
    _augment_send_list = &asl;
  }

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!

在文件 dof_map.h 第 445 行定义.

参考 _extra_sparsity_context , 以及 _extra_sparsity_function.

  { _extra_sparsity_function = func; _extra_sparsity_context = context; }

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

inline

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

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

Further, you must modify n_nz and n_oz properly!

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

在文件 dof_map.h 第 430 行定义.

参考 _augment_sparsity_pattern.

  {
    _augment_sparsity_pattern = &asp;
  }

void libMesh::DofMap::attach_matrix

(

SparseMatrix< Number > &

matrix

)

Additional matrices may be attached to this DofMap.

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

在文件 dof_map.C 第 278 行定义.

参考 _matrices, libMesh::SparseMatrix< T >::need_full_sparsity_pattern(), need_full_sparsity_pattern , 以及 update_sparsity_pattern().

{
  parallel_object_only();

  // We shouldn't be trying to re-attach the same matrices repeatedly
  libmesh_assert (std::find(_matrices.begin(), _matrices.end(),
                            &matrix) == _matrices.end());

  _matrices.push_back(&matrix);

  this->update_sparsity_pattern(matrix);

  if (matrix.need_full_sparsity_pattern())
    need_full_sparsity_pattern = true;
}

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

inline

返回

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

在文件 dof_map.h 第 651 行定义.

参考 has_blocked_representation() , 以及 n_variables().

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

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.

在文件 dof_map_constraints.C 第 3459 行定义.

参考 _dof_constraints, is_constrained_dof(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseMatrix< T >::resize() , 以及 libMesh::DenseMatrix< T >::right_multiply().

参考自 constrain_element_dyad_matrix(), constrain_element_matrix(), constrain_element_matrix_and_vector(), constrain_element_vector(), constrain_nothing() , 以及 max_constraint_error().

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

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

private

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

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

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

在文件 dof_map_constraints.C 第 3569 行定义.

参考 _adjoint_constraint_values, _dof_constraints, _primal_constraint_values, is_constrained_dof(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseVector< T >::resize(), libMesh::DenseMatrix< T >::resize(), libMesh::DenseMatrix< T >::right_multiply() , 以及 libMesh::DenseMatrix< T >::vector_mult_add().

参考自 extract_local_vector(), heterogeneously_constrain_element_matrix_and_vector() , 以及 heterogeneously_constrain_element_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());
    }
}

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

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

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

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

在文件 dof_map.C 第 64 行定义.

参考 _augment_sparsity_pattern, _coupling_functors, _dof_coupling, _extra_sparsity_context, _extra_sparsity_function, n_dofs_on_processor(), need_full_sparsity_pattern, libMesh::out , 以及 use_coupled_neighbor_dofs().

参考自 compute_sparsity() , 以及 process_mesh_constraint_rows().

{
  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.
  auto sp = std::make_unique<SparsityPattern::Build>
    (*this,
     this->_dof_coupling,
     this->_coupling_functors,
     implicit_neighbor_dofs,
     need_full_sparsity_pattern,
     calculate_constrained);

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

      sp->apply_extra_sparsity_function(_extra_sparsity_function,
                                        _extra_sparsity_context);
    }

  if (_augment_sparsity_pattern)
    sp->apply_extra_sparsity_object(*_augment_sparsity_pattern);

  return sp;
}

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

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

If not, this will throw an error.

在文件 dof_map_constraints.C 第 5532 行定义.

参考 libMesh::DirichletBoundary::b.

参考自 create_dof_constraints().

{
  const std::set<boundary_id_type>& mesh_side_bcids =
    mesh.get_boundary_info().get_boundary_ids();
  const std::set<boundary_id_type>& mesh_edge_bcids =
    mesh.get_boundary_info().get_edge_boundary_ids();
  const std::set<boundary_id_type>& mesh_node_bcids =
    mesh.get_boundary_info().get_node_boundary_ids();
  const std::set<boundary_id_type>& dbc_bcids = boundary.b;

  // DirichletBoundary id sets should be consistent across all ranks
  libmesh_assert(mesh.comm().verify(dbc_bcids.size()));

  for (const auto & bc_id : dbc_bcids)
    {
      // DirichletBoundary id sets should be consistent across all ranks
      libmesh_assert(mesh.comm().verify(bc_id));

      bool found_bcid = (mesh_side_bcids.find(bc_id) != mesh_side_bcids.end() ||
                         mesh_edge_bcids.find(bc_id) != mesh_edge_bcids.end() ||
                         mesh_node_bcids.find(bc_id) != mesh_node_bcids.end());

      // On a distributed mesh, boundary id sets may *not* be
      // consistent across all ranks, since not all ranks see all
      // boundaries
      mesh.comm().max(found_bcid);

      libmesh_error_msg_if(!found_bcid,
                           "Could not find Dirichlet boundary id " << bc_id << " in mesh!");
    }
}

void libMesh::DofMap::check_for_constraint_loops

(

)

在文件 dof_map_constraints.C 第 4545 行定义.

参考 _dof_constraints , 以及 libMesh::Real.

参考自 check_for_cyclic_constraints() , 以及 process_constraints().

{
  // Create a set containing the DOFs we already depend on
  typedef std::set<dof_id_type> RCSet;
  RCSet unexpanded_set;

  // Use dof_constraints_copy in this method so that we don't
  // mess with _dof_constraints.
  DofConstraints dof_constraints_copy = _dof_constraints;

  for (const auto & i : dof_constraints_copy)
    unexpanded_set.insert(i.first);

  while (!unexpanded_set.empty())
    for (RCSet::iterator i = unexpanded_set.begin();
         i != unexpanded_set.end(); /* nothing */)
      {
        // If the DOF is constrained
        DofConstraints::iterator
          pos = dof_constraints_copy.find(*i);

        libmesh_assert (pos != dof_constraints_copy.end());

        DofConstraintRow & constraint_row = pos->second;

        // Comment out "rhs" parts of this method copied from process_constraints
        // DofConstraintValueMap::iterator rhsit =
        //   _primal_constraint_values.find(*i);
        // Number constraint_rhs = (rhsit == _primal_constraint_values.end()) ?
        //   0 : rhsit->second;

        std::vector<dof_id_type> constraints_to_expand;

        for (const auto & item : constraint_row)
          if (item.first != *i && this->is_constrained_dof(item.first))
            {
              unexpanded_set.insert(item.first);
              constraints_to_expand.push_back(item.first);
            }

        for (const auto & expandable : constraints_to_expand)
          {
            const Real this_coef = constraint_row[expandable];

            DofConstraints::const_iterator
              subpos = dof_constraints_copy.find(expandable);

            libmesh_assert (subpos != dof_constraints_copy.end());

            const DofConstraintRow & subconstraint_row = subpos->second;

            for (const auto & item : subconstraint_row)
              {
                libmesh_error_msg_if(item.first == expandable, "Constraint loop detected");

                constraint_row[item.first] += item.second * this_coef;
              }

            // Comment out "rhs" parts of this method copied from process_constraints
            // DofConstraintValueMap::const_iterator subrhsit =
            //   _primal_constraint_values.find(expandable);
            // if (subrhsit != _primal_constraint_values.end())
            //   constraint_rhs += subrhsit->second * this_coef;

            constraint_row.erase(expandable);
          }

        // Comment out "rhs" parts of this method copied from process_constraints
        // if (rhsit == _primal_constraint_values.end())
        //   {
        //     if (constraint_rhs != Number(0))
        //       _primal_constraint_values[*i] = constraint_rhs;
        //     else
        //       _primal_constraint_values.erase(*i);
        //   }
        // else
        //   {
        //     if (constraint_rhs != Number(0))
        //       rhsit->second = constraint_rhs;
        //     else
        //       _primal_constraint_values.erase(rhsit);
        //   }

        if (constraints_to_expand.empty())
          i = unexpanded_set.erase(i);
        else
          ++i;
      }
}

void libMesh::DofMap::check_for_cyclic_constraints

(

)

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

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

注解

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

在文件 dof_map_constraints.C 第 4539 行定义.

参考 check_for_constraint_loops().

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

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.

在文件 dof_map.C 第 850 行定义.

参考 _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, _shared_functors, _stashed_dof_constraints, _var_to_vg, _variable_group_numbers, _variable_groups, _variables, add_algebraic_ghosting_functor(), add_coupling_functor(), clear_send_list(), clear_sparsity(), need_full_sparsity_pattern , 以及 use_coupled_neighbor_dofs().

参考自 ~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);
  }

  this->_shared_functors.clear();

  _variables.clear();
  _variable_groups.clear();
  _var_to_vg.clear();
  _variable_group_numbers.clear();
  _first_df.clear();
  _end_df.clear();
  _first_scalar_df.clear();
  this->clear_send_list();
  this->clear_sparsity();
  need_full_sparsity_pattern = false;

#ifdef LIBMESH_ENABLE_AMR

  _dof_constraints.clear();
  _stashed_dof_constraints.clear();
  _primal_constraint_values.clear();
  _adjoint_constraint_values.clear();
  _n_old_dfs = 0;
  _first_old_df.clear();
  _end_old_df.clear();
  _first_old_scalar_df.clear();

#endif

  _matrices.clear();

  _n_dfs = 0;
}

void libMesh::DofMap::clear_send_list ( )

inline

Clears the _send_list vector.

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

在文件 dof_map.h 第 485 行定义.

参考 _send_list.

参考自 clear(), distribute_dofs() , 以及 reinit_send_list().

  {
    _send_list.clear();
  }

void libMesh::DofMap::clear_sparsity

(

)

Clears the sparsity pattern.

在文件 dof_map.C 第 1837 行定义.

参考 _sp.

参考自 clear().

{
  _sp.reset();
}

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.

在文件 dof_map.C 第 1816 行定义.

参考 _constrained_sparsity_construction, _matrices, _sp, build_sparsity() , 以及 need_full_sparsity_pattern.

{
  _sp = this->build_sparsity(mesh, this->_constrained_sparsity_construction);

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

bool libMesh::DofMap::computed_sparsity_already

(

)

const

Returns true iff a sparsity pattern has already been computed.

在文件 dof_map.C 第 296 行定义.

参考 _sp.

参考自 update_sparsity_pattern().

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

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.

在文件 dof_map_constraints.C 第 3048 行定义.

参考 _dof_constraints, build_constraint_matrix(), is_constrained_dof(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseVector< T >::size() , 以及 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.
}

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.

在文件 dof_map_constraints.C 第 2380 行定义.

参考 _dof_constraints, build_constraint_matrix(), is_constrained_dof(), libMesh::DenseMatrix< T >::left_multiply_transpose(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n() , 以及 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 (auto j : make_range(matrix.n()))
              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
                // heterogeneous 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...
}

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.

在文件 dof_map_constraints.C 第 2914 行定义.

参考 _dof_constraints, build_constraint_matrix(), is_constrained_dof(), libMesh::DenseMatrix< T >::left_multiply_transpose(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n() , 以及 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 (auto j : make_range(matrix.n()))
              {
                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...
}

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.

在文件 dof_map_constraints.C 第 2450 行定义.

参考 _dof_constraints, build_constraint_matrix(), is_constrained_dof(), libMesh::DenseMatrix< T >::left_multiply_transpose(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseMatrix< T >::right_multiply(), libMesh::DenseVector< T >::size() , 以及 libMesh::DenseMatrix< T >::vector_mult_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 (auto j : make_range(matrix.n()))
              matrix(i,j) = 0.;

            // If the DOF is constrained
            matrix(i,i) = 1.;

            // This will put a nonsymmetric entry in the constraint
            // row to ensure that the linear system produces the
            // correct value for the constrained DOF.
            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...
}

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

Constrains the element residual.

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

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

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

在文件 dof_map_constraints.C 第 2782 行定义.

参考 libMesh::DenseMatrixBase< T >::n(), libMesh::DenseVector< T >::size(), libMesh::NumericVector< T >::type() , 以及 libMesh::DenseMatrix< T >::vector_mult_transpose().

{
  libmesh_assert_equal_to (elem_dofs.size(), rhs.size());

  libmesh_assert (solution_local.type() == SERIAL ||
                  solution_local.type() == GHOSTED);

  // check for easy return
  if (this->_dof_constraints.empty())
    return;

  // The constrained RHS is built up as C^T F
  DenseMatrix<Number> C;

  this->build_constraint_matrix (C, elem_dofs);

  LOG_SCOPE("cnstrn_elem_residual()", "DofMap");

  // It is possible that the matrix is not constrained at all.
  if (C.n() != elem_dofs.size())
    return;

  // Compute the matrix-vector product C^T F
  DenseVector<Number> old_rhs(rhs);
  C.vector_mult_transpose(rhs, old_rhs);

  for (unsigned int i=0,
       n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
       i != n_elem_dofs; i++)
    {
      const dof_id_type dof_id = elem_dofs[i];

      const DofConstraints::const_iterator
        pos = _dof_constraints.find(dof_id);

      if (pos != _dof_constraints.end())
        {
          // This will put a nonsymmetric entry in the constraint
          // row to ensure that the linear system produces the
          // correct value for the constrained DOF.
          const DofConstraintRow & constraint_row = pos->second;

          Number & rhs_val = rhs(i);
          rhs_val = 0;
          for (const auto & [constraining_dof, coef] : constraint_row)
            rhs_val -= coef * solution_local(constraining_dof);
          rhs_val += solution_local(dof_id);
        }
    }
}

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.

在文件 dof_map_constraints.C 第 3006 行定义.

参考 _dof_constraints, build_constraint_matrix(), is_constrained_dof(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseVector< T >::size() , 以及 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.
}

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

inline

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

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

在文件 dof_map_constraints.C 第 3099 行定义.

参考 _dof_constraints , 以及 build_constraint_matrix().

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

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.

在文件 dof_map_constraints.C 第 5391 行定义.

参考 _dof_constraints, _primal_constraint_values, sys_number() , 以及 variable_type().

{
  // We're constraining dofs on elem which correspond to p refinement
  // levels above p - this only makes sense if elem's p refinement
  // level is above p.
  libmesh_assert_greater (elem->p_level(), p);
  libmesh_assert_less (s, elem->n_sides());

  const unsigned int sys_num = this->sys_number();
  FEType fe_type = this->variable_type(var);

  const unsigned int n_nodes = elem->n_nodes();
  for (unsigned int n = 0; n != n_nodes; ++n)
    if (elem->is_node_on_side(n, s))
      {
        const Node & node = elem->node_ref(n);
        const unsigned int low_nc =
          FEInterface::n_dofs_at_node (fe_type, p, elem, n);
        const unsigned int high_nc =
          FEInterface::n_dofs_at_node (fe_type, elem, n);

        // since we may be running this method concurrently
        // on multiple threads we need to acquire a lock
        // before modifying the _dof_constraints object.
        Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);

        if (elem->is_vertex(n))
          {
            // Add "this is zero" constraint rows for high p vertex
            // dofs
            for (unsigned int i = low_nc; i != high_nc; ++i)
              {
                _dof_constraints[node.dof_number(sys_num,var,i)].clear();
                _primal_constraint_values.erase(node.dof_number(sys_num,var,i));
              }
          }
        else
          {
            const unsigned int total_dofs = node.n_comp(sys_num, var);
            libmesh_assert_greater_equal (total_dofs, high_nc);
            // Add "this is zero" constraint rows for high p
            // non-vertex dofs, which are numbered in reverse
            for (unsigned int j = low_nc; j != high_nc; ++j)
              {
                const unsigned int i = total_dofs - j - 1;
                _dof_constraints[node.dof_number(sys_num,var,i)].clear();
                _primal_constraint_values.erase(node.dof_number(sys_num,var,i));
              }
          }
      }
}

bool libMesh::DofMap::constrained_sparsity_construction ( )

inline

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

在文件 dof_map.h 第 2309 行定义.

参考 _constrained_sparsity_construction.

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

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

inline

返回

An iterator pointing to the first DoF constraint row.

在文件 dof_map.h 第 1010 行定义.

参考 _dof_constraints.

  { return _dof_constraints.begin(); }

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

inline

返回

An iterator pointing just past the last DoF constraint row.

在文件 dof_map.h 第 1016 行定义.

参考 _dof_constraints.

  { return _dof_constraints.end(); }

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

inline

Beginning of range of coupling functors.

在文件 dof_map.h 第 344 行定义.

参考 _coupling_functors.

参考自 add_neighbors_to_send_list(), libMesh::SparsityPattern::Build::operator()() , 以及 scatter_constraints().

  { return _coupling_functors.begin(); }

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

inline

End of range of coupling functors.

在文件 dof_map.h 第 350 行定义.

参考 _coupling_functors.

参考自 add_neighbors_to_send_list(), libMesh::SparsityPattern::Build::operator()() , 以及 scatter_constraints().

  { return _coupling_functors.end(); }

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.

在文件 dof_map_constraints.C 第 1736 行定义.

参考 _adjoint_constraint_values, _adjoint_dirichlet_boundaries, _dirichlet_boundaries, _dof_constraints, _node_constraints, _periodic_boundaries, _primal_constraint_values, _verify_dirichlet_bc_consistency, check_dirichlet_bcid_consistency(), n_variables() , 以及 process_mesh_constraint_rows().

{
  parallel_object_only();

  LOG_SCOPE("create_dof_constraints()", "DofMap");

  libmesh_assert (mesh.is_prepared());

  // The user might have set boundary conditions after the mesh was
  // prepared; we should double-check that those boundary conditions
  // are still consistent.
#ifdef DEBUG
  MeshTools::libmesh_assert_valid_boundary_ids(mesh);
#endif

  // In a distributed mesh we might have constraint rows on some
  // processors but not all; if we have constraint rows on *any*
  // processor then we need to process them.
  bool constraint_rows_empty = mesh.get_constraint_rows().empty();
  this->comm().min(constraint_rows_empty);

  // We might get constraint equations from AMR hanging nodes in
  // 2D/3D, or from spline constraint rows or boundary conditions in
  // any dimension
  const bool possible_local_constraints = false
    || !mesh.n_elem()
    || !constraint_rows_empty
#ifdef LIBMESH_ENABLE_AMR
    || mesh.mesh_dimension() > 1
#endif
#ifdef LIBMESH_ENABLE_PERIODIC
    || !_periodic_boundaries->empty()
#endif
#ifdef LIBMESH_ENABLE_DIRICHLET
    || !_dirichlet_boundaries->empty()
#endif
    ;

  // Even if we don't have constraints, another processor might.
  bool possible_global_constraints = possible_local_constraints;
#if defined(LIBMESH_ENABLE_PERIODIC) || defined(LIBMESH_ENABLE_DIRICHLET) || defined(LIBMESH_ENABLE_AMR)
  libmesh_assert(this->comm().verify(mesh.is_serial()));

  this->comm().max(possible_global_constraints);
#endif

  // Recalculate dof constraints from scratch.  (Or just clear them,
  // if the user has just deleted their last dirichlet/periodic/user
  // constraint)
  // Note: any _stashed_dof_constraints are not cleared as it
  // may be the user's intention to restore them later.
#ifdef LIBMESH_ENABLE_CONSTRAINTS
  _dof_constraints.clear();
  _primal_constraint_values.clear();
  _adjoint_constraint_values.clear();
#endif
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  _node_constraints.clear();
#endif

  if (!possible_global_constraints)
    return;

  // Here we build the hanging node constraints.  This is done
  // by enforcing the condition u_a = u_b along hanging sides.
  // u_a = u_b is collocated at the nodes of side a, which gives
  // one row of the constraint matrix.

  // Processors only compute their local constraints
  ConstElemRange range (mesh.local_elements_begin(),
                        mesh.local_elements_end());

  // Global computation fails if we're using a FEMFunctionBase BC on a
  // ReplicatedMesh in parallel
  // ConstElemRange range (mesh.elements_begin(),
  //                       mesh.elements_end());

  // compute_periodic_constraints requires a point_locator() from our
  // Mesh, but point_locator() construction is parallel and threaded.
  // Rather than nest threads within threads we'll make sure it's
  // preconstructed.
#ifdef LIBMESH_ENABLE_PERIODIC
  bool need_point_locator = !_periodic_boundaries->empty() && !range.empty();

  this->comm().max(need_point_locator);

  if (need_point_locator)
    mesh.sub_point_locator();
#endif

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  Threads::parallel_for (range,
                         ComputeNodeConstraints (_node_constraints,
#ifdef LIBMESH_ENABLE_PERIODIC
                                                 *_periodic_boundaries,
#endif
                                                 mesh));
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS


  // Look at all the variables in the system.  Reset the element
  // range at each iteration -- there is no need to reconstruct it.
  const auto n_vars = this->n_variables();
  for (unsigned int variable_number=0; variable_number<n_vars;
       ++variable_number, range.reset())
    Threads::parallel_for (range,
                           ComputeConstraints (_dof_constraints,
                                               *this,
#ifdef LIBMESH_ENABLE_PERIODIC
                                               *_periodic_boundaries,
#endif
                                               mesh,
                                               variable_number));

#ifdef LIBMESH_ENABLE_DIRICHLET

  if (!_dirichlet_boundaries->empty())
    {
      // Sanity check that the boundary ids associated with the
      // DirichletBoundary objects are actually present in the
      // mesh. We do this check by default, but in cases where you
      // intentionally add "inconsistent but valid" DirichletBoundary
      // objects in parallel, this check can deadlock since it does a
      // collective communication internally. In that case it is
      // possible to disable this check by setting the flag to false.
      if (_verify_dirichlet_bc_consistency)
        for (const auto & dirichlet : *_dirichlet_boundaries)
          this->check_dirichlet_bcid_consistency(mesh, *dirichlet);

      // Threaded loop over local over elems applying all Dirichlet BCs
      Threads::parallel_for
        (range,
         ConstrainDirichlet(*this, mesh, time, *_dirichlet_boundaries,
                            AddPrimalConstraint(*this)));

      // Threaded loop over local over elems per QOI applying all adjoint
      // Dirichlet BCs.  Note that the ConstElemRange is reset before each
      // execution of Threads::parallel_for().

      for (auto qoi_index : index_range(_adjoint_dirichlet_boundaries))
        {
          const DirichletBoundaries & adb_q =
            *(_adjoint_dirichlet_boundaries[qoi_index]);

          if (!adb_q.empty())
            Threads::parallel_for
              (range.reset(),
               ConstrainDirichlet(*this, mesh, time, adb_q,
                                  AddAdjointConstraint(*this, qoi_index)));
        }
    }

#endif // LIBMESH_ENABLE_DIRICHLET

  // Handle spline node constraints last, so we can try to move
  // existing constraints onto the spline basis if necessary.
  if (!constraint_rows_empty)
    this->process_mesh_constraint_rows(mesh);
}

DefaultCoupling& libMesh::DofMap::default_algebraic_ghosting ( )

inline

Default algebraic ghosting functor.

在文件 dof_map.h 第 418 行定义.

参考 _default_evaluating.

参考自 add_default_ghosting() , 以及 remove_default_ghosting().

{ return *_default_evaluating; }

DefaultCoupling& libMesh::DofMap::default_coupling ( )

inline

Default coupling functor.

在文件 dof_map.h 第 356 行定义.

参考 _default_coupling.

参考自 add_default_ghosting() , 以及 remove_default_ghosting().

{ return *_default_coupling; }

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

在文件 reference_counter.C 第 100 行定义.

参考 libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = false;
  return;
}

std::size_t libMesh::DofMap::distribute_dofs

(

MeshBase &

mesh

)

Distribute dofs on the current mesh.

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

返回

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

在文件 dof_map.C 第 927 行定义.

参考 _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, add_neighbors_to_send_list(), clear_send_list(), distribute_local_dofs_node_major(), distribute_local_dofs_var_major(), libMesh::DofObject::dof_number(), elem_ptr(), end_dof(), first_dof(), libMesh::DofObject::invalid_id, invalidate_dofs(), libMesh::DofObject::n_comp(), n_dofs(), n_SCALAR_dofs(), n_variables(), libMesh::DofObject::n_vars(), node_ptr(), libMesh::on_command_line(), libMesh::DofObject::processor_id(), reinit(), set_nonlocal_dof_objects(), sys_number(), libMesh::Variable::type() , 以及 variable().

{
  // 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
  this->clear_send_list();

  // Set temporary DOF indices on this processor
  if (node_major_dofs)
    this->distribute_local_dofs_node_major (next_free_dof, mesh);
  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 (auto v : make_range(dofobj->n_vars(sys_num)))
          for (auto c : make_range(dofobj->n_comp(sys_num,v)))
            {
              const dof_id_type dofid = dofobj->dof_number(sys_num,v,c);
              libmesh_assert_greater_equal (dofid, this->first_dof(obj_proc_id));
              libmesh_assert_less (dofid, this->end_dof(obj_proc_id));
            }
      }

    for (auto & elem : mesh.element_ptr_range())
      {
        DofObject const * const dofobj = elem;
        const processor_id_type obj_proc_id = dofobj->processor_id();

        for (auto v : make_range(dofobj->n_vars(sys_num)))
          for (auto c : make_range(dofobj->n_comp(sys_num,v)))
            {
              const dof_id_type dofid = dofobj->dof_number(sys_num,v,c);
              libmesh_assert_greater_equal (dofid, this->first_dof(obj_proc_id));
              libmesh_assert_less (dofid, this->end_dof(obj_proc_id));
            }
      }
  }
#endif

  // 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 (auto v : make_range(this->n_variables()))
    if (this->variable(v).type().family == SCALAR)
      {
        _first_scalar_df[v] = current_SCALAR_dof_index;
        current_SCALAR_dof_index += this->variable(v).type().order.get_order();
      }

  // Allow our GhostingFunctor objects to reinit if necessary
  for (const auto & gf : _algebraic_ghosting_functors)
    {
      libmesh_assert(gf);
      gf->dofmap_reinit();
    }

  for (const auto & gf : _coupling_functors)
    {
      libmesh_assert(gf);
      gf->dofmap_reinit();
    }

  // Note that in the add_neighbors_to_send_list nodes on processor
  // boundaries that are shared by multiple elements are added for
  // each element.
  this->add_neighbors_to_send_list(mesh);

  // Here we used to clean up that data structure; now System and
  // EquationSystems call that for us, after we've added constraint
  // dependencies to the send_list too.
  // this->sort_send_list ();

  // Return total number of DOFs across all procs. We compute and
  // return this as a std::size_t so that we can detect situations in
  // which the total number of DOFs across all procs would exceed the
  // capability of the underlying NumericVector representation to
  // index into it correctly (std::size_t is the largest unsigned
  // type, so no NumericVector representation can exceed it).
  return std::accumulate(dofs_on_proc.begin(), dofs_on_proc.end(), static_cast<std::size_t>(0));
}

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.

注解

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

在文件 dof_map.C 第 1196 行定义.

参考 libMesh::Variable::active_on_subdomain(), assert_no_nodes_missed(), distribute_scalar_dofs(), libMesh::DofObject::invalid_id, n_variable_groups(), libMesh::VariableGroup::n_variables(), sys_number(), libMesh::Variable::type() , 以及 variable_group().

参考自 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));
            }
      }

  this->distribute_scalar_dofs(next_free_dof);

#ifdef DEBUG
  this->assert_no_nodes_missed(mesh);
#endif // DEBUG
}

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.

在文件 dof_map.C 第 1299 行定义.

参考 libMesh::Variable::active_on_subdomain(), assert_no_nodes_missed(), distribute_scalar_dofs(), libMesh::DofObject::invalid_id, n_variable_groups(), libMesh::VariableGroup::n_variables(), sys_number(), libMesh::Variable::type() , 以及 variable_group().

参考自 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

  this->distribute_scalar_dofs(next_free_dof);

#ifdef DEBUG
  this->assert_no_nodes_missed(mesh);
#endif
}

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

private

在文件 dof_map.C 第 1394 行定义.

参考 _n_SCALAR_dofs, n_variable_groups(), libMesh::VariableGroup::n_variables(), libMesh::Variable::type() , 以及 variable_group().

参考自 distribute_local_dofs_node_major() , 以及 distribute_local_dofs_var_major().

{
  this->_n_SCALAR_dofs = 0;
  for (auto vg : make_range(this->n_variable_groups()))
    {
      const VariableGroup & vg_description(this->variable_group(vg));

      if (vg_description.type().family == SCALAR)
        {
          this->_n_SCALAR_dofs += (vg_description.n_variables()*
                                   vg_description.type().order.get_order());
          continue;
        }
    }

  // Only increment next_free_dof if we're on the processor
  // that holds this SCALAR variable
  if (this->processor_id() == (this->n_processors()-1))
    next_free_dof += _n_SCALAR_dofs;
}

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.

在文件 dof_map.C 第 1992 行定义.

参考 _dof_indices(), libMesh::Variable::active_on_subdomain(), n_variable_groups(), libMesh::VariableGroup::n_variables(), libMesh::VariableGroup::number(), SCALAR_dof_indices(), libMesh::Variable::type() , 以及 variable_group().

参考自 add_neighbors_to_send_list(), dof_indices(), is_evaluable(), max_constraint_error(), process_mesh_constraint_rows(), scatter_constraints() , 以及 libMesh::SparsityPattern::Build::sorted_connected_dofs().

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

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

在文件 dof_map.C 第 2102 行定义.

参考 _dof_indices(), _variable_group_numbers, libMesh::Variable::active_on_subdomain(), libMesh::VariableGroup::number(), SCALAR_dof_indices(), libMesh::Variable::type() , 以及 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
}

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.

在文件 dof_map.C 第 2177 行定义.

参考 libMesh::DofObject::invalid_id, n_variable_groups(), libMesh::VariableGroup::n_variables(), libMesh::VariableGroup::number(), SCALAR_dof_indices(), sys_number(), libMesh::Variable::type() , 以及 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);
                }
            }
        }
    }
}

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.

在文件 dof_map.C 第 2225 行定义.

参考 _variable_group_numbers, dof_indices(), libMesh::DofObject::invalid_id, libMesh::invalid_uint, libMesh::VariableGroup::number(), SCALAR_dof_indices(), sys_number(), libMesh::Variable::type() , 以及 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);
        }
    }
}

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

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

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

在文件 dof_map.C 第 2271 行定义.

参考 _node_dof_indices().

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

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

inline

返回

The processor id that owns the dof index dof

在文件 dof_map.h 第 717 行定义.

参考 _end_df.

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

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

private

返回

The Elem pointer with index i from the mesh.

在文件 dof_map.C 第 348 行定义.

参考自 distribute_dofs().

{
  return mesh.elem_ptr(i);
}

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

在文件 reference_counter.C 第 94 行定义.

参考 libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = true;
  return;
}

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

inline

返回

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

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

在文件 dof_map.h 第 708 行定义.

参考 _end_df.

参考自 libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::SparsityPattern::Build::join(), libMesh::SparsityPattern::Build::operator()() , 以及 libMesh::SparsityPattern::Build::parallel_sync().

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

dof_id_type libMesh::DofMap::end_dof ( ) const

inline

在文件 dof_map.h 第 711 行定义.

参考自 distribute_dofs(), local_index(), n_local_constrained_dofs() , 以及 process_mesh_constraint_rows().

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

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

inline

返回

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

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

在文件 dof_map.h 第 731 行定义.

参考 _end_old_df.

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

dof_id_type libMesh::DofMap::end_old_dof ( ) const

inline

在文件 dof_map.h 第 734 行定义.

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

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

inline

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

For homogeneous constraints, use enforce_constraints_exactly instead

在文件 dof_map_constraints.C 第 3285 行定义.

参考 _adjoint_constraint_values, _dof_constraints, libMesh::NumericVector< T >::build(), libMesh::NumericVector< T >::close(), libMesh::NumericVector< T >::closed(), libMesh::NumericVector< T >::get(), get_send_list(), local_index(), libMesh::NumericVector< T >::local_size(), libMesh::NumericVector< T >::localize(), n_constrained_dofs(), n_dofs(), n_local_dofs(), libMesh::NumericVector< T >::set(), libMesh::NumericVector< T >::size() , 以及 libMesh::NumericVector< T >::type().

{
  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.local_size(),
                     this->get_send_list(), true, GHOSTED);
      v.localize(*v_built, this->get_send_list());
      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 & [constrained_dof, constraint_row] : _dof_constraints)
    {
      if (!this->local_index(constrained_dof))
        continue;

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

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.

在文件 dof_map_constraints.C 第 3113 行定义.

参考 _dof_constraints, _primal_constraint_values, libMesh::NumericVector< T >::build(), libMesh::NumericVector< T >::close(), libMesh::NumericVector< T >::closed(), libMesh::NumericVector< T >::get(), get_send_list(), local_index(), libMesh::NumericVector< T >::local_size(), libMesh::NumericVector< T >::localize(), n_constrained_dofs(), n_dofs(), n_local_dofs(), libMesh::NumericVector< T >::set(), libMesh::NumericVector< T >::size() , 以及 libMesh::NumericVector< T >::type().

{
  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->local_size(),
                     this->get_send_list(), true,
                     GHOSTED);
      v->localize(*v_built, this->get_send_list());
      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: Unsupported NumericVector type == " << Utility::enum_to_string(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 & [constrained_dof, constraint_row] : _dof_constraints)
    {
      if (!this->local_index(constrained_dof))
        continue;

      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 & [dof, val] : constraint_row)
        exact_value += val * (*v_local)(dof);

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

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

inline

在文件 dof_map_constraints.C 第 3260 行定义.

参考 _dof_constraints, local_index(), n_constrained_dofs() , 以及 libMesh::SparseMatrix< T >::set().

{
  parallel_object_only();

  if (!this->n_constrained_dofs())
    return;

  if (!jac)
    jac = system.matrix;

  libmesh_assert_equal_to (this, &(system.get_dof_map()));

  for (const auto & [constrained_dof, constraint_row] : _dof_constraints)
    {
      if (!this->local_index(constrained_dof))
        continue;

      for (const auto & j : constraint_row)
        jac->set(constrained_dof, j.first, -j.second);
      jac->set(constrained_dof, constrained_dof, 1);
    }
}

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

inline

在文件 dof_map_constraints.C 第 3203 行定义.

参考 _dof_constraints, _primal_constraint_values, libMesh::NumericVector< T >::build(), libMesh::NumericVector< T >::get(), get_send_list(), local_index(), libMesh::NumericVector< T >::local_size(), libMesh::NumericVector< T >::localize(), n_constrained_dofs(), libMesh::NumericVector< T >::set(), libMesh::NumericVector< T >::size() , 以及 libMesh::NumericVector< T >::type().

{
  parallel_object_only();

  if (!this->n_constrained_dofs())
    return;

  if (!rhs)
    rhs = system.rhs;
  if (!solution)
    solution = system.solution.get();

  NumericVector<Number> const * solution_local  = nullptr; // will be initialized below
  std::unique_ptr<NumericVector<Number>> solution_built;
  if (solution->type() == SERIAL || solution->type() == GHOSTED)
      solution_local = solution;
  else if (solution->type() == PARALLEL)
    {
      solution_built = NumericVector<Number>::build(this->comm());
      solution_built->init (solution->size(), solution->local_size(),
                            this->get_send_list(), true, GHOSTED);
      solution->localize(*solution_built, this->get_send_list());
      solution_built->close();
      solution_local = solution_built.get();
    }
  else // unknown solution->type()
    libmesh_error_msg("ERROR: Unsupported NumericVector type == " << Utility::enum_to_string(solution->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 solution_local
  libmesh_assert(solution_local);
  libmesh_assert_equal_to (this, &(system.get_dof_map()));

  for (const auto & [constrained_dof, constraint_row] : _dof_constraints)
    {
      if (!this->local_index(constrained_dof))
        continue;

      Number exact_value = 0;
      for (const auto & [dof, val] : constraint_row)
        exact_value -= val * (*solution_local)(dof);
      exact_value += (*solution_local)(constrained_dof);
      if (!homogeneous)
        {
          DofConstraintValueMap::const_iterator rhsit =
            _primal_constraint_values.find(constrained_dof);
          if (rhsit != _primal_constraint_values.end())
            exact_value += rhsit->second;
        }

      rhs->set(constrained_dof, exact_value);
    }
}

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

注解

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.

在文件 dof_map.C 第 1910 行定义.

参考 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() , 以及 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
}

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.

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.

在文件 dof_map.C 第 2852 行定义.

参考 _dof_constraints , 以及 is_constrained_dof().

参考自 libMesh::SparsityPattern::Build::sorted_connected_dofs().

{
  typedef std::set<dof_id_type> RCSet;

  // First insert the DOFS we already depend on into the set.
  RCSet dof_set (elem_dofs.begin(), elem_dofs.end());

  bool done = true;

  // Next insert any dofs those might be constrained in terms
  // of.  Note that in this case we may not be done:  Those may
  // in turn depend on others.  So, we need to repeat this process
  // in that case until the system depends only on unconstrained
  // degrees of freedom.
  for (const auto & dof : elem_dofs)
    if (this->is_constrained_dof(dof))
      {
        // If the DOF is constrained
        DofConstraints::const_iterator
          pos = _dof_constraints.find(dof);

        libmesh_assert (pos != _dof_constraints.end());

        const DofConstraintRow & constraint_row = pos->second;

        // adaptive p refinement currently gives us lots of empty constraint
        // rows - we should optimize those DoFs away in the future.  [RHS]
        //libmesh_assert (!constraint_row.empty());

        // Add the DOFs this dof is constrained in terms of.
        // note that these dofs might also be constrained, so
        // we will need to call this function recursively.
        for (const auto & pr : constraint_row)
          if (!dof_set.count (pr.first))
            {
              dof_set.insert (pr.first);
              done = false;
            }
      }


  // If not done then we need to do more work
  // (obviously :-) )!
  if (!done)
    {
      // Fill the vector with the contents of the set
      elem_dofs.clear();
      elem_dofs.insert (elem_dofs.end(),
                        dof_set.begin(), dof_set.end());


      // May need to do this recursively.  It is possible
      // that we just replaced a constrained DOF with another
      // constrained DOF.
      this->find_connected_dofs (elem_dofs);

    } // end if (!done)
}

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

inline

返回

The first dof index that is local to partition proc.

在文件 dof_map.h 第 684 行定义.

参考 _first_df.

参考自 libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::SparsityPattern::Build::join(), libMesh::SparsityPattern::Build::operator()() , 以及 libMesh::SparsityPattern::Build::parallel_sync().

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

dof_id_type libMesh::DofMap::first_dof ( ) const

inline

在文件 dof_map.h 第 687 行定义.

参考自 distribute_dofs(), local_index(), n_local_constrained_dofs() , 以及 process_mesh_constraint_rows().

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

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

inline

返回

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

在文件 dof_map.h 第 694 行定义.

参考 _first_old_df.

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

dof_id_type libMesh::DofMap::first_old_dof ( ) const

inline

在文件 dof_map.h 第 697 行定义.

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

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

Helper function for querying about constraint equations on other processors.

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

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

在文件 dof_map_constraints.C 第 5055 行定义.

参考 _adjoint_constraint_values, _dof_constraints, _end_df, _primal_constraint_values, libMesh::DofObject::invalid_id, local_index() , 以及 libMesh::Real.

参考自 allgather_recursive_constraints() , 以及 scatter_constraints().

{
  typedef std::set<dof_id_type> DoF_RCSet;

  // If we have heterogeneous adjoint constraints we need to
  // communicate those too.
  const unsigned int max_qoi_num =
    _adjoint_constraint_values.empty() ?
    0 : _adjoint_constraint_values.rbegin()->first+1;

  // We have to keep recursing while the unexpanded set is
  // nonempty on *any* processor
  bool unexpanded_set_nonempty = !unexpanded_dofs.empty();
  this->comm().max(unexpanded_set_nonempty);

  while (unexpanded_set_nonempty)
    {
      // Let's make sure we don't lose sync in this loop.
      parallel_object_only();

      // Request sets
      DoF_RCSet   dof_request_set;

      // Request sets to send to each processor
      std::map<processor_id_type, std::vector<dof_id_type>>
        requested_dof_ids;

      // And the sizes of each
      std::map<processor_id_type, dof_id_type>
        dof_ids_on_proc;

      // Fill (and thereby sort and uniq!) the main request sets
      for (const auto & unexpanded_dof : unexpanded_dofs)
        {
          DofConstraints::const_iterator
            pos = _dof_constraints.find(unexpanded_dof);

          // If we were asked for a DoF and we don't already have a
          // constraint for it, then we need to check for one.
          if (pos == _dof_constraints.end())
            {
              if (!this->local_index(unexpanded_dof) &&
                  !_dof_constraints.count(unexpanded_dof) )
                dof_request_set.insert(unexpanded_dof);
            }
          // If we were asked for a DoF and we already have a
          // constraint for it, then we need to check if the
          // constraint is recursive.
          else
            {
              const DofConstraintRow & row = pos->second;
              for (const auto & j : row)
                {
                  const dof_id_type constraining_dof = j.first;

                  // If it's non-local and we haven't already got a
                  // constraint for it, we might need to ask for one
                  if (!this->local_index(constraining_dof) &&
                      !_dof_constraints.count(constraining_dof))
                    dof_request_set.insert(constraining_dof);
                }
            }
        }

      // Clear the unexpanded constraint set; we're about to expand it
      unexpanded_dofs.clear();

      // Count requests by processor
      processor_id_type proc_id = 0;
      for (const auto & i : dof_request_set)
        {
          while (i >= _end_df[proc_id])
            proc_id++;
          dof_ids_on_proc[proc_id]++;
        }

      for (auto & pair : dof_ids_on_proc)
        {
          requested_dof_ids[pair.first].reserve(pair.second);
        }

      // Prepare each processor's request set
      proc_id = 0;
      for (const auto & i : dof_request_set)
        {
          while (i >= _end_df[proc_id])
            proc_id++;
          requested_dof_ids[proc_id].push_back(i);
        }

      typedef std::vector<std::pair<dof_id_type, Real>> row_datum;

      typedef std::vector<Number> rhss_datum;

      auto row_gather_functor =
        [this]
        (processor_id_type,
         const std::vector<dof_id_type> & ids,
         std::vector<row_datum> & data)
        {
          // Fill those requests
          const std::size_t query_size = ids.size();

          data.resize(query_size);
          for (std::size_t i=0; i != query_size; ++i)
            {
              dof_id_type constrained = ids[i];
              if (_dof_constraints.count(constrained))
                {
                  DofConstraintRow & row = _dof_constraints[constrained];
                  std::size_t row_size = row.size();
                  data[i].reserve(row_size);
                  for (const auto & j : row)
                    {
                      data[i].push_back(j);

                      // We should never have an invalid constraining
                      // dof id
                      libmesh_assert(j.first != DofObject::invalid_id);

                      // We should never have a 0 constraint
                      // coefficient; that's implicit via sparse
                      // constraint storage
                      //
                      // But we can't easily control how users add
                      // constraints, so we can't safely assert that
                      // we're being efficient here.
                      //
                      // libmesh_assert(j.second);
                    }
                }
              else
                {
                  // We have to distinguish "constraint with no
                  // constraining dofs" (e.g. due to Dirichlet
                  // constraint equations) from "no constraint".
                  // We'll use invalid_id for the latter.
                  data[i].emplace_back(DofObject::invalid_id, Real(0));
                }
            }
        };

      auto rhss_gather_functor =
        [this,
         max_qoi_num]
        (processor_id_type,
         const std::vector<dof_id_type> & ids,
         std::vector<rhss_datum> & data)
        {
          // Fill those requests
          const std::size_t query_size = ids.size();

          data.resize(query_size);
          for (std::size_t i=0; i != query_size; ++i)
            {
              dof_id_type constrained = ids[i];
              data[i].clear();
              if (_dof_constraints.count(constrained))
                {
                  DofConstraintValueMap::const_iterator rhsit =
                    _primal_constraint_values.find(constrained);
                  data[i].push_back
                    ((rhsit == _primal_constraint_values.end()) ?
                     0 : rhsit->second);

                  for (unsigned int q = 0; q != max_qoi_num; ++q)
                    {
                      AdjointDofConstraintValues::const_iterator adjoint_map_it =
                        _adjoint_constraint_values.find(q);

                      if (adjoint_map_it == _adjoint_constraint_values.end())
                        {
                          data[i].push_back(0);
                          continue;
                        }

                      const DofConstraintValueMap & constraint_map =
                        adjoint_map_it->second;

                      DofConstraintValueMap::const_iterator adj_rhsit =
                        constraint_map.find(constrained);
                      data[i].push_back
                        ((adj_rhsit == constraint_map.end()) ?
                         0 : adj_rhsit->second);
                    }
                }
            }
        };

      auto row_action_functor =
        [this,
         & unexpanded_dofs]
        (processor_id_type,
         const std::vector<dof_id_type> & ids,
         const std::vector<row_datum> & data)
        {
          // Add any new constraint rows we've found
          const std::size_t query_size = ids.size();

          for (std::size_t i=0; i != query_size; ++i)
            {
              const dof_id_type constrained = ids[i];

              // An empty row is an constraint with an empty row; for
              // no constraint we use a "no row" placeholder
              if (data[i].empty())
                {
                  DofConstraintRow & row = _dof_constraints[constrained];
                  row.clear();
                }
              else if (data[i][0].first != DofObject::invalid_id)
                {
                  DofConstraintRow & row = _dof_constraints[constrained];
                  row.clear();
                  for (auto & pair : data[i])
                    {
                      libmesh_assert_less(pair.first, this->n_dofs());
                      row[pair.first] = pair.second;
                    }

                  // And prepare to check for more recursive constraints
                  unexpanded_dofs.insert(constrained);
                }
            }
        };

      auto rhss_action_functor =
        [this,
         max_qoi_num]
        (processor_id_type,
         const std::vector<dof_id_type> & ids,
         const std::vector<rhss_datum> & data)
        {
          // Add rhs data for any new constraint rows we've found
          const std::size_t query_size = ids.size();

          for (std::size_t i=0; i != query_size; ++i)
            {
              if (!data[i].empty())
                {
                  dof_id_type constrained = ids[i];
                  if (data[i][0] != Number(0))
                    _primal_constraint_values[constrained] = data[i][0];
                  else
                    _primal_constraint_values.erase(constrained);

                  for (unsigned int q = 0; q != max_qoi_num; ++q)
                    {
                      AdjointDofConstraintValues::iterator adjoint_map_it =
                        _adjoint_constraint_values.find(q);

                      if ((adjoint_map_it == _adjoint_constraint_values.end()) &&
                          data[i][q+1] == Number(0))
                        continue;

                      if (adjoint_map_it == _adjoint_constraint_values.end())
                        adjoint_map_it = _adjoint_constraint_values.emplace
                          (q, DofConstraintValueMap()).first;

                      DofConstraintValueMap & constraint_map =
                        adjoint_map_it->second;

                      if (data[i][q+1] != Number(0))
                        constraint_map[constrained] =
                          data[i][q+1];
                      else
                        constraint_map.erase(constrained);
                    }
                }
            }

        };

      // Now request constraint rows from other processors
      row_datum * row_ex = nullptr;
      Parallel::pull_parallel_vector_data
        (this->comm(), requested_dof_ids, row_gather_functor,
         row_action_functor, row_ex);

      // And request constraint right hand sides from other procesors
      rhss_datum * rhs_ex = nullptr;
      Parallel::pull_parallel_vector_data
        (this->comm(), requested_dof_ids, rhss_gather_functor,
         rhss_action_functor, rhs_ex);

      // We have to keep recursing while the unexpanded set is
      // nonempty on *any* processor
      unexpanded_set_nonempty = !unexpanded_dofs.empty();
      this->comm().max(unexpanded_set_nonempty);
    }
}

const DirichletBoundaries * libMesh::DofMap::get_adjoint_dirichlet_boundaries

(

unsigned int

q

)

const

在文件 dof_map_constraints.C 第 5480 行定义.

参考 _adjoint_dirichlet_boundaries.

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

DirichletBoundaries * libMesh::DofMap::get_adjoint_dirichlet_boundaries

(

unsigned int

q

)

在文件 dof_map_constraints.C 第 5488 行定义.

参考 _adjoint_dirichlet_boundaries.

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

  return _adjoint_dirichlet_boundaries[q].get();
}

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

inline

在文件 dof_map.h 第 1482 行定义.

参考 _dirichlet_boundaries.

  {
    return _dirichlet_boundaries.get();
  }

DirichletBoundaries* libMesh::DofMap::get_dirichlet_boundaries ( )

inline

在文件 dof_map.h 第 1487 行定义.

参考 _dirichlet_boundaries.

  {
    return _dirichlet_boundaries.get();
  }

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

inline

Provide a const accessor to the DofConstraints map.

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

在文件 dof_map.h 第 1023 行定义.

参考 _dof_constraints.

{ return _dof_constraints; }

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

staticinherited

Gets a string containing the reference information.

在文件 reference_counter.C 第 47 行定义.

参考 libMesh::ReferenceCounter::_counts.

参考自 libMesh::ReferenceCounter::print_info().

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)

  std::ostringstream oss;

  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";

  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';

  oss << " ---------------------------------------------------------------------------- \n";

  return oss.str();

#else

  return "";

#endif
}

std::string libMesh::DofMap::get_info

(

)

const

Gets summary info about the sparsity bandwidth and constraints.

在文件 dof_map.C 第 2922 行定义.

参考 _dof_constraints, _matrices, _node_constraints, _primal_constraint_values, _sp , 以及 local_index().

参考自 print_info().

{
  std::ostringstream os;

  // If we didn't calculate the exact sparsity pattern, the threaded
  // sparsity pattern assembly may have just given us an upper bound
  // on sparsity.
  const char * may_equal = " <= ";

  // If we calculated the exact sparsity pattern, then we can report
  // exact bandwidth figures:
  for (const auto & mat : _matrices)
    if (mat->need_full_sparsity_pattern())
      may_equal = " = ";

  dof_id_type max_n_nz = 0, max_n_oz = 0;
  long double avg_n_nz = 0, avg_n_oz = 0;

  if (_sp)
    {
      for (const auto & val : _sp->get_n_nz())
        {
          max_n_nz = std::max(max_n_nz, val);
          avg_n_nz += val;
        }

      std::size_t n_nz_size = _sp->get_n_nz().size();

      this->comm().max(max_n_nz);
      this->comm().sum(avg_n_nz);
      this->comm().sum(n_nz_size);

      avg_n_nz /= std::max(n_nz_size,std::size_t(1));

      for (const auto & val : _sp->get_n_oz())
        {
          max_n_oz = std::max(max_n_oz, val);
          avg_n_oz += val;
        }

      std::size_t n_oz_size = _sp->get_n_oz().size();

      this->comm().max(max_n_oz);
      this->comm().sum(avg_n_oz);
      this->comm().sum(n_oz_size);

      avg_n_oz /= std::max(n_oz_size,std::size_t(1));
    }

  os << "    DofMap Sparsity\n      Average  On-Processor Bandwidth"
     << may_equal << avg_n_nz << '\n';

  os << "      Average Off-Processor Bandwidth"
     << may_equal << avg_n_oz << '\n';

  os << "      Maximum  On-Processor Bandwidth"
     << may_equal << max_n_nz << '\n';

  os << "      Maximum Off-Processor Bandwidth"
     << may_equal << max_n_oz << std::endl;

#ifdef LIBMESH_ENABLE_CONSTRAINTS

  std::size_t n_constraints = 0, max_constraint_length = 0,
    n_rhss = 0;
  long double avg_constraint_length = 0.;

  for (const auto & [constrained_dof, row] : _dof_constraints)
    {
      // Only count local constraints, then sum later
      if (!this->local_index(constrained_dof))
        continue;

      std::size_t rowsize = row.size();

      max_constraint_length = std::max(max_constraint_length,
                                       rowsize);
      avg_constraint_length += rowsize;
      n_constraints++;

      if (_primal_constraint_values.count(constrained_dof))
        n_rhss++;
    }

  this->comm().sum(n_constraints);
  this->comm().sum(n_rhss);
  this->comm().sum(avg_constraint_length);
  this->comm().max(max_constraint_length);

  os << "    DofMap Constraints\n      Number of DoF Constraints = "
     << n_constraints;
  if (n_rhss)
    os << '\n'
       << "      Number of Heterogenous Constraints= " << n_rhss;
  if (n_constraints)
    {
      avg_constraint_length /= n_constraints;

      os << '\n'
         << "      Average DoF Constraint Length= " << avg_constraint_length;
    }

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  std::size_t n_node_constraints = 0, max_node_constraint_length = 0,
    n_node_rhss = 0;
  long double avg_node_constraint_length = 0.;

  for (const auto & [node, pr] : _node_constraints)
    {
      // Only count local constraints, then sum later
      if (node->processor_id() != this->processor_id())
        continue;

      const NodeConstraintRow & row = pr.first;
      std::size_t rowsize = row.size();

      max_node_constraint_length = std::max(max_node_constraint_length,
                                            rowsize);
      avg_node_constraint_length += rowsize;
      n_node_constraints++;

      if (pr.second != Point(0))
        n_node_rhss++;
    }

  this->comm().sum(n_node_constraints);
  this->comm().sum(n_node_rhss);
  this->comm().sum(avg_node_constraint_length);
  this->comm().max(max_node_constraint_length);

  os << "\n      Number of Node Constraints = " << n_node_constraints;
  if (n_node_rhss)
    os << '\n'
       << "      Number of Heterogenous Node Constraints= " << n_node_rhss;
  if (n_node_constraints)
    {
      avg_node_constraint_length /= n_node_constraints;
      os << "\n      Maximum Node Constraint Length= " << max_node_constraint_length
         << '\n'
         << "      Average Node Constraint Length= " << avg_node_constraint_length;
    }
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS

  os << std::endl;

#endif // LIBMESH_ENABLE_CONSTRAINTS

  return os.str();
}

std::string libMesh::DofMap::get_local_constraints

(

bool

print_nonlocal = false

)

const

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

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

在文件 dof_map_constraints.C 第 2288 行定义.

参考 _adjoint_constraint_values, _adjoint_dirichlet_boundaries, _dof_constraints, _node_constraints, _primal_constraint_values , 以及 local_index().

参考自 print_dof_constraints().

{
  std::ostringstream os;
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  if (print_nonlocal)
    os << "All ";
  else
    os << "Local ";

  os << "Node Constraints:"
     << std::endl;

  for (const auto & [node, pr] : _node_constraints)
    {
      // Skip non-local nodes if requested
      if (!print_nonlocal &&
          node->processor_id() != this->processor_id())
        continue;

      const NodeConstraintRow & row = pr.first;
      const Point & offset = pr.second;

      os << "Constraints for Node id " << node->id()
         << ": \t";

      for (const auto & [cnode, val] : row)
        os << " (" << cnode->id() << "," << val << ")\t";

      os << "rhs: " << offset;

      os << std::endl;
    }
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS

  if (print_nonlocal)
    os << "All ";
  else
    os << "Local ";

  os << "DoF Constraints:"
     << std::endl;

  for (const auto & [i, row] : _dof_constraints)
    {
      // Skip non-local dofs if requested
      if (!print_nonlocal && !this->local_index(i))
        continue;

      DofConstraintValueMap::const_iterator rhsit =
        _primal_constraint_values.find(i);
      const Number rhs = (rhsit == _primal_constraint_values.end()) ?
        0 : rhsit->second;

      os << "Constraints for DoF " << i
         << ": \t";

      for (const auto & item : row)
        os << " (" << item.first << "," << item.second << ")\t";

      os << "rhs: " << rhs;
      os << std::endl;
    }

  for (unsigned int qoi_index = 0,
       n_qois = cast_int<unsigned int>(_adjoint_dirichlet_boundaries.size());
       qoi_index != n_qois; ++qoi_index)
    {
      os << "Adjoint " << qoi_index << " DoF rhs values:"
         << std::endl;

      AdjointDofConstraintValues::const_iterator adjoint_map_it =
        _adjoint_constraint_values.find(qoi_index);

      if (adjoint_map_it != _adjoint_constraint_values.end())
        for (const auto [i, rhs] : adjoint_map_it->second)
          {
            // Skip non-local dofs if requested
            if (!print_nonlocal && !this->local_index(i))
              continue;

            os << "RHS for DoF " << i
               << ": " << rhs;

            os << std::endl;
          }
    }

  return os.str();
}

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

inline

返回

A constant reference to the _n_nz list for this processor.

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

在文件 dof_map.h 第 520 行定义.

参考 _sp.

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

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

inline

返回

A constant reference to the _n_oz list for this processor.

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

在文件 dof_map.h 第 533 行定义.

参考 _sp.

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

PeriodicBoundaries* libMesh::DofMap::get_periodic_boundaries ( )

inline

在文件 dof_map.h 第 1429 行定义.

参考 _periodic_boundaries.

  {
    return _periodic_boundaries.get();
  }

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

inline

在文件 dof_map.h 第 1434 行定义.

参考 _periodic_boundaries.

  {
    return _periodic_boundaries.get();
  }

DofConstraintValueMap & libMesh::DofMap::get_primal_constraint_values ( )

inline

返回

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

在文件 dof_map.h 第 2224 行定义.

参考 _primal_constraint_values.

{
  return _primal_constraint_values;
}

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

inline

返回

A constant reference to the _send_list for this processor.

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

在文件 dof_map.h 第 511 行定义.

参考 _send_list.

参考自 enforce_adjoint_constraints_exactly(), enforce_constraints_exactly() , 以及 enforce_constraints_on_residual().

{ return _send_list; }

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

inline

返回

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

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

在文件 dof_map.h 第 548 行定义.

参考 _sp.

参考自 libMesh::SparseMatrix< T >::attach_dof_map().

  {
    return _sp.get();
  }

bool libMesh::DofMap::has_adjoint_dirichlet_boundaries

(

unsigned int

q

)

const

在文件 dof_map_constraints.C 第 5470 行定义.

参考 _adjoint_dirichlet_boundaries.

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

  return false;
}

bool libMesh::DofMap::has_blocked_representation ( ) const

inline

返回

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

在文件 dof_map.h 第 634 行定义.

参考 n_variable_groups() , 以及 n_variables().

参考自 block_size().

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

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

inline

返回

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

在文件 dof_map.h 第 2203 行定义.

参考 _adjoint_constraint_values.

参考自 has_heterogenous_adjoint_constraint().

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

  return 0;
}

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

inline

返回

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

在文件 dof_map.h 第 2189 行定义.

参考 _adjoint_constraint_values.

参考自 has_heterogenous_adjoint_constraints().

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

  return true;
}

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

inline

Backwards compatibility with misspelling.

在文件 dof_map.h 第 1099 行定义.

参考 has_heterogeneous_adjoint_constraint().

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

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

inline

Backwards compatibility with misspelling.

在文件 dof_map.h 第 1083 行定义.

参考 has_heterogeneous_adjoint_constraints().

  {
    return this->has_heterogeneous_adjoint_constraints (qoi_num);
  }

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

Constrains the element Jacobian and residual.

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

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

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

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

在文件 dof_map_constraints.C 第 2635 行定义.

参考 libMesh::DenseMatrix< T >::left_multiply_transpose(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseMatrix< T >::right_multiply(), libMesh::DenseVector< T >::size(), libMesh::NumericVector< T >::type() , 以及 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());

  libmesh_assert (solution_local.type() == SERIAL ||
                  solution_local.type() == GHOSTED);

  // check for easy return
  if (this->_dof_constraints.empty())
    return;

  // The constrained matrix is built up as C^T K C.
  // The constrained RHS is built up as C^T F
  // Asymmetric residual terms are added if we do not have x = Cx+h
  DenseMatrix<Number> C;
  DenseVector<Number> H;

  this->build_constraint_matrix_and_vector (C, H, elem_dofs);

  LOG_SCOPE("hetero_cnstrn_elem_jac_res()", "DofMap");

  // It is possible that the matrix is not constrained at all.
  if ((C.m() != matrix.m()) ||
      (C.n() != elem_dofs.size()))
    return;

  // Compute the matrix-vector product C^T F
  DenseVector<Number> old_rhs(rhs);
  C.vector_mult_transpose(rhs, old_rhs);

  // Compute the matrix-matrix-matrix product C^T K C
  matrix.left_multiply_transpose  (C);
  matrix.right_multiply (C);

  libmesh_assert_equal_to (matrix.m(), matrix.n());
  libmesh_assert_equal_to (matrix.m(), elem_dofs.size());
  libmesh_assert_equal_to (matrix.n(), elem_dofs.size());

  for (unsigned int i=0,
       n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
       i != n_elem_dofs; i++)
    {
      const dof_id_type dof_id = elem_dofs[i];

      const DofConstraints::const_iterator
        pos = _dof_constraints.find(dof_id);

      if (pos != _dof_constraints.end())
        {
          for (auto j : make_range(matrix.n()))
            matrix(i,j) = 0.;

          // If the DOF is constrained
          matrix(i,i) = 1.;

          // This will put a nonsymmetric entry in the constraint
          // row to ensure that the linear system produces the
          // correct value for the constrained DOF.
          const DofConstraintRow & constraint_row = pos->second;

          for (const auto & item : constraint_row)
            for (unsigned int j=0; j != n_elem_dofs; j++)
              if (elem_dofs[j] == item.first)
                matrix(i,j) = -item.second;

          const DofConstraintValueMap::const_iterator valpos =
            _primal_constraint_values.find(dof_id);

          Number & rhs_val = rhs(i);
          rhs_val = (valpos == _primal_constraint_values.end()) ?
            0 : -valpos->second;
          for (const auto & [constraining_dof, coef] : constraint_row)
            rhs_val -= coef * solution_local(constraining_dof);
          rhs_val += solution_local(dof_id);
        }
    }
}

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

inline

Constrains the element matrix and vector.

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

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

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

在文件 dof_map_constraints.C 第 2529 行定义.

参考 _adjoint_constraint_values, _dof_constraints, _primal_constraint_values, build_constraint_matrix_and_vector(), is_constrained_dof(), libMesh::DenseMatrix< T >::left_multiply_transpose(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseMatrix< T >::right_multiply(), libMesh::DenseVector< T >::size(), libMesh::DenseMatrix< T >::vector_mult() , 以及 libMesh::DenseMatrix< T >::vector_mult_transpose().

参考自 heterogenously_constrain_element_matrix_and_vector() , 以及 process_mesh_constraint_rows().

{
  libmesh_assert_equal_to (elem_dofs.size(), matrix.m());
  libmesh_assert_equal_to (elem_dofs.size(), matrix.n());
  libmesh_assert_equal_to (elem_dofs.size(), rhs.size());

  // check for easy return
  if (this->_dof_constraints.empty())
    return;

  // The constrained matrix is built up as C^T K C.
  // The constrained RHS is built up as C^T (F - K H)
  DenseMatrix<Number> C;
  DenseVector<Number> H;

  this->build_constraint_matrix_and_vector (C, H, elem_dofs, qoi_index);

  LOG_SCOPE("hetero_cnstrn_elem_mat_vec()", "DofMap");

  // It is possible that the matrix is not constrained at all.
  if ((C.m() == matrix.m()) &&
      (C.n() == elem_dofs.size())) // It the matrix is constrained
    {
      // We may have rhs values to use later
      const DofConstraintValueMap * rhs_values = nullptr;
      if (qoi_index < 0)
        rhs_values = &_primal_constraint_values;
      else
        {
          const AdjointDofConstraintValues::const_iterator
            it = _adjoint_constraint_values.find(qoi_index);
          if (it != _adjoint_constraint_values.end())
            rhs_values = &it->second;
        }

      // Compute matrix/vector product K H
      DenseVector<Number> KH;
      matrix.vector_mult(KH, H);

      // Compute the matrix-vector product C^T (F - KH)
      DenseVector<Number> F_minus_KH(rhs);
      F_minus_KH -= KH;
      C.vector_mult_transpose(rhs, F_minus_KH);

      // Compute the matrix-matrix-matrix product C^T K C
      matrix.left_multiply_transpose  (C);
      matrix.right_multiply (C);

      libmesh_assert_equal_to (matrix.m(), matrix.n());
      libmesh_assert_equal_to (matrix.m(), elem_dofs.size());
      libmesh_assert_equal_to (matrix.n(), elem_dofs.size());

      for (unsigned int i=0,
           n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
           i != n_elem_dofs; i++)
        {
          const dof_id_type dof_id = elem_dofs[i];

          if (this->is_constrained_dof(dof_id))
            {
              for (auto j : make_range(matrix.n()))
                matrix(i,j) = 0.;

              // If the DOF is constrained
              matrix(i,i) = 1.;

              // This will put a nonsymmetric entry in the constraint
              // row to ensure that the linear system produces the
              // correct value for the constrained DOF.
              if (asymmetric_constraint_rows)
                {
                  DofConstraints::const_iterator
                    pos = _dof_constraints.find(dof_id);

                  libmesh_assert (pos != _dof_constraints.end());

                  const DofConstraintRow & constraint_row = pos->second;

                  for (const auto & item : constraint_row)
                    for (unsigned int j=0; j != n_elem_dofs; j++)
                      if (elem_dofs[j] == item.first)
                        matrix(i,j) = -item.second;

                  if (rhs_values)
                    {
                      const DofConstraintValueMap::const_iterator valpos =
                        rhs_values->find(dof_id);

                      rhs(i) = (valpos == rhs_values->end()) ?
                        0 : valpos->second;
                    }
                }
              else
                rhs(i) = 0.;
            }
        }

    } // end if is constrained...
}

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

Constrains the element residual.

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

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

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

在文件 dof_map_constraints.C 第 2720 行定义.

参考 libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseVector< T >::size(), libMesh::NumericVector< T >::type() , 以及 libMesh::DenseMatrix< T >::vector_mult_transpose().

{
  libmesh_assert_equal_to (elem_dofs.size(), rhs.size());

  libmesh_assert (solution_local.type() == SERIAL ||
                  solution_local.type() == GHOSTED);

  // check for easy return
  if (this->_dof_constraints.empty())
    return;

  // The constrained RHS is built up as C^T F
  // Asymmetric residual terms are added if we do not have x = Cx+h
  DenseMatrix<Number> C;
  DenseVector<Number> H;

  this->build_constraint_matrix_and_vector (C, H, elem_dofs);

  LOG_SCOPE("hetero_cnstrn_elem_res()", "DofMap");

  // It is possible that the element is not constrained at all.
  if ((C.m() != rhs.size()) ||
      (C.n() != elem_dofs.size()))
    return;

  // Compute the matrix-vector product C^T F
  DenseVector<Number> old_rhs(rhs);
  C.vector_mult_transpose(rhs, old_rhs);

  for (unsigned int i=0,
       n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
       i != n_elem_dofs; i++)
    {
      const dof_id_type dof_id = elem_dofs[i];

      const DofConstraints::const_iterator
        pos = _dof_constraints.find(dof_id);

      if (pos != _dof_constraints.end())
        {
          // This will put a nonsymmetric entry in the constraint
          // row to ensure that the linear system produces the
          // correct value for the constrained DOF.
          const DofConstraintRow & constraint_row = pos->second;

          const DofConstraintValueMap::const_iterator valpos =
            _primal_constraint_values.find(dof_id);

          Number & rhs_val = rhs(i);
          rhs_val = (valpos == _primal_constraint_values.end()) ?
            0 : -valpos->second;
          for (const auto & [constraining_dof, coef] : constraint_row)
            rhs_val -= coef * solution_local(constraining_dof);
          rhs_val += solution_local(dof_id);
        }
    }
}

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

inline

Constrains the element vector.

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

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

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

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

在文件 dof_map_constraints.C 第 2836 行定义.

参考 _adjoint_constraint_values, _dof_constraints, _primal_constraint_values, build_constraint_matrix_and_vector(), is_constrained_dof(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n(), libMesh::DenseVector< T >::size(), libMesh::DenseMatrix< T >::vector_mult() , 以及 libMesh::DenseMatrix< T >::vector_mult_transpose().

参考自 heterogenously_constrain_element_vector().

{
  libmesh_assert_equal_to (elem_dofs.size(), matrix.m());
  libmesh_assert_equal_to (elem_dofs.size(), matrix.n());
  libmesh_assert_equal_to (elem_dofs.size(), rhs.size());

  // check for easy return
  if (this->_dof_constraints.empty())
    return;

  // The constrained matrix is built up as C^T K C.
  // The constrained RHS is built up as C^T (F - K H)
  DenseMatrix<Number> C;
  DenseVector<Number> H;

  this->build_constraint_matrix_and_vector (C, H, elem_dofs, qoi_index);

  LOG_SCOPE("hetero_cnstrn_elem_vec()", "DofMap");

  // It is possible that the matrix is not constrained at all.
  if ((C.m() == matrix.m()) &&
      (C.n() == elem_dofs.size())) // It the matrix is constrained
    {
      // We may have rhs values to use later
      const DofConstraintValueMap * rhs_values = nullptr;
      if (qoi_index < 0)
        rhs_values = &_primal_constraint_values;
      else
        {
          const AdjointDofConstraintValues::const_iterator
            it = _adjoint_constraint_values.find(qoi_index);
          if (it != _adjoint_constraint_values.end())
            rhs_values = &it->second;
        }

      // Compute matrix/vector product K H
      DenseVector<Number> KH;
      matrix.vector_mult(KH, H);

      // Compute the matrix-vector product C^T (F - KH)
      DenseVector<Number> F_minus_KH(rhs);
      F_minus_KH -= KH;
      C.vector_mult_transpose(rhs, F_minus_KH);

      for (unsigned int i=0,
           n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
           i != n_elem_dofs; i++)
        {
          const dof_id_type dof_id = elem_dofs[i];

          if (this->is_constrained_dof(dof_id))
            {
              // This will put a nonsymmetric entry in the constraint
              // row to ensure that the linear system produces the
              // correct value for the constrained DOF.
              if (asymmetric_constraint_rows && rhs_values)
                {
                  const DofConstraintValueMap::const_iterator valpos =
                    rhs_values->find(dof_id);

                  rhs(i) = (valpos == rhs_values->end()) ?
                    0 : valpos->second;
                }
              else
                rhs(i) = 0.;
            }
        }

    } // end if is constrained...
}

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

inline

在文件 dof_map.h 第 1234 行定义.

参考 heterogeneously_constrain_element_matrix_and_vector().

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

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

inline

在文件 dof_map.h 第 1278 行定义.

参考 heterogeneously_constrain_element_vector().

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

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

inlineprotectednoexceptinherited

Increments the construction counter.

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

在文件 reference_counter.h 第 183 行定义.

参考 libMesh::err.

参考自 libMesh::ReferenceCountedObject< SparseMatrix< T > >::ReferenceCountedObject().

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

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

inlineprotectednoexceptinherited

Increments the destruction counter.

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

在文件 reference_counter.h 第 207 行定义.

参考 libMesh::err.

参考自 libMesh::ReferenceCountedObject< SparseMatrix< T > >::~ReferenceCountedObject().

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

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

private

Invalidates all active DofObject dofs for this system.

在文件 dof_map.C 第 835 行定义.

参考 sys_number().

参考自 distribute_dofs() , 以及 reinit().

{
  const unsigned int sys_num = this->sys_number();

  // All the nodes
  for (auto & node : mesh.node_ptr_range())
    node->invalidate_dofs(sys_num);

  // All the active elements.
  for (auto & elem : mesh.active_element_ptr_range())
    elem->invalidate_dofs(sys_num);
}

bool libMesh::DofMap::is_attached

(

SparseMatrix< Number > &

matrix

)

Matrices should not be attached more than once.

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

在文件 dof_map.C 第 333 行定义.

参考 _matrices.

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

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

inline

返回

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

在文件 dof_map.h 第 2179 行定义.

参考 _dof_constraints.

参考自 add_adjoint_constraint_row(), add_constraint_row(), allgather_recursive_constraints(), build_constraint_matrix(), build_constraint_matrix_and_vector(), constrain_element_dyad_matrix(), constrain_element_matrix(), constrain_element_matrix_and_vector(), constrain_element_vector(), extract_local_vector(), find_connected_dofs(), heterogeneously_constrain_element_matrix_and_vector(), heterogeneously_constrain_element_vector(), max_constraint_error(), process_mesh_constraint_rows() , 以及 scatter_constraints().

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

  return false;
}

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

inline

返回

true if the Node is constrained, false otherwise.

在文件 dof_map.h 第 2163 行定义.

参考 _node_constraints.

参考自 allgather_recursive_constraints() , 以及 scatter_constraints().

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

  return false;
}

template<typename DofObjectSubclass >

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

返回

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

在文件 dof_map.C 第 2609 行定义.

参考 all_semilocal_indices(), dof_indices() , 以及 libMesh::invalid_uint.

{
  // Everything is evaluable on a local object
  if (obj.processor_id() == this->processor_id())
    return true;

  std::vector<dof_id_type> di;

  if (var_num == libMesh::invalid_uint)
    this->dof_indices(&obj, di);
  else
    this->dof_indices(&obj, di, var_num);

  return this->all_semilocal_indices(di);
}

bool libMesh::DofMap::is_periodic_boundary

(

const boundary_id_type

boundaryid

)

const

返回

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

在文件 dof_map.C 第 219 行定义.

参考 _periodic_boundaries.

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

  return false;
}

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

inline

返回

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

在文件 dof_map.h 第 831 行定义.

参考 end_dof() , 以及 first_dof().

参考自 add_constraints_to_send_list(), add_neighbors_to_send_list(), enforce_adjoint_constraints_exactly(), enforce_constraints_exactly(), enforce_constraints_on_jacobian(), enforce_constraints_on_residual(), gather_constraints(), get_info(), get_local_constraints(), local_variable_indices(), libMesh::SparsityPattern::Build::parallel_sync(), process_mesh_constraint_rows() , 以及 semilocal_index().

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

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

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

在文件 dof_map.C 第 1109 行定义.

参考 libMesh::Variable::active_on_subdomain(), local_index(), SCALAR_dof_indices(), sys_number(), variable() , 以及 variable_type().

{
  // Count dofs in the *exact* order that distribute_dofs numbered
  // them, so that we can assume ascending indices and use push_back
  // instead of find+insert.

  const unsigned int sys_num       = this->sys_number();

  // If this isn't a SCALAR variable, we need to find all its field
  // dofs on the mesh
  if (this->variable_type(var_num).family != SCALAR)
    {
      const Variable & var(this->variable(var_num));

      for (auto & elem : mesh.active_local_element_ptr_range())
        {
          if (!var.active_on_subdomain(elem->subdomain_id()))
            continue;

          // Only count dofs connected to active
          // elements on this processor.
          const unsigned int n_nodes = elem->n_nodes();

          // First get any new nodal DOFS
          for (unsigned int n=0; n<n_nodes; n++)
            {
              const Node & node = elem->node_ref(n);

              if (node.processor_id() != this->processor_id())
                continue;

              const unsigned int n_comp = node.n_comp(sys_num, var_num);
              for(unsigned int i=0; i<n_comp; i++)
                {
                  const dof_id_type index = node.dof_number(sys_num,var_num,i);
                  libmesh_assert (this->local_index(index));

                  if (idx.empty() || index > idx.back())
                    idx.push_back(index);
                }
            }

          // Next get any new element DOFS
          const unsigned int n_comp = elem->n_comp(sys_num, var_num);
          for (unsigned int i=0; i<n_comp; i++)
            {
              const dof_id_type index = elem->dof_number(sys_num,var_num,i);
              if (idx.empty() || index > idx.back())
                idx.push_back(index);
            }
        } // done looping over elements


      // we may have missed assigning DOFs to nodes that we own
      // but to which we have no connected elements matching our
      // variable restriction criterion.  this will happen, for example,
      // if variable V is restricted to subdomain S.  We may not own
      // any elements which live in S, but we may own nodes which are
      // *connected* to elements which do.  in this scenario these nodes
      // will presently have unnumbered DOFs. we need to take care of
      // them here since we own them and no other processor will touch them.
      for (const auto & node : mesh.local_node_ptr_range())
        {
          libmesh_assert(node);

          const unsigned int n_comp = node->n_comp(sys_num, var_num);
          for (unsigned int i=0; i<n_comp; i++)
            {
              const dof_id_type index = node->dof_number(sys_num,var_num,i);
              if (idx.empty() || index > idx.back())
                idx.push_back(index);
            }
        }
    }
  // Otherwise, count up the SCALAR dofs, if we're on the processor
  // that holds this SCALAR variable
  else if (this->processor_id() == (this->n_processors()-1))
    {
      std::vector<dof_id_type> di_scalar;
      this->SCALAR_dof_indices(di_scalar,var_num);
      idx.insert( idx.end(), di_scalar.begin(), di_scalar.end());
    }
}

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

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

Useful for debugging purposes.

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

在文件 dof_map_constraints.C 第 3381 行定义.

参考 _dof_constraints, _primal_constraint_values, std::abs(), build_constraint_matrix(), libMesh::NumericVector< T >::closed(), dof_indices(), libMesh::NumericVector< T >::first_local_index(), libMesh::NumericVector< T >::get(), is_constrained_dof(), libMesh::NumericVector< T >::last_local_index(), libMesh::DenseMatrixBase< T >::m(), libMesh::DenseMatrixBase< T >::n() , 以及 libMesh::Real.

{
  if (!v)
    v = system.solution.get();
  NumericVector<Number> & vec = *v;

  // We'll assume the vector is closed
  libmesh_assert (vec.closed());

  Real max_absolute_error = 0., max_relative_error = 0.;

  const MeshBase & mesh = system.get_mesh();

  libmesh_assert_equal_to (this, &(system.get_dof_map()));

  // indices on each element
  std::vector<dof_id_type> local_dof_indices;

  for (const auto & elem : mesh.active_local_element_ptr_range())
    {
      this->dof_indices(elem, local_dof_indices);
      std::vector<dof_id_type> raw_dof_indices = local_dof_indices;

      // Constraint matrix for each element
      DenseMatrix<Number> C;

      this->build_constraint_matrix (C, local_dof_indices);

      // Continue if the element is unconstrained
      if (!C.m())
        continue;

      libmesh_assert_equal_to (C.m(), raw_dof_indices.size());
      libmesh_assert_equal_to (C.n(), local_dof_indices.size());

      for (auto i : make_range(C.m()))
        {
          // Recalculate any constrained dof owned by this processor
          dof_id_type global_dof = raw_dof_indices[i];
          if (this->is_constrained_dof(global_dof) &&
              global_dof >= vec.first_local_index() &&
              global_dof < vec.last_local_index())
            {
#ifndef NDEBUG
              DofConstraints::const_iterator
                pos = _dof_constraints.find(global_dof);

              libmesh_assert (pos != _dof_constraints.end());
#endif

              Number exact_value = 0;
              DofConstraintValueMap::const_iterator rhsit =
                _primal_constraint_values.find(global_dof);
              if (rhsit != _primal_constraint_values.end())
                exact_value = rhsit->second;

              for (auto j : make_range(C.n()))
                {
                  if (local_dof_indices[j] != global_dof)
                    exact_value += C(i,j) *
                      vec(local_dof_indices[j]);
                }

              max_absolute_error = std::max(max_absolute_error,
                                            std::abs(vec(global_dof) - exact_value));
              max_relative_error = std::max(max_relative_error,
                                            std::abs(vec(global_dof) - exact_value)
                                            / std::abs(exact_value));
            }
        }
    }

  return std::pair<Real, Real>(max_absolute_error, max_relative_error);
}

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

staticprivate

在文件 dof_map.C 第 1440 行定义.

参考自 add_neighbors_to_send_list(), libMesh::SparsityPattern::Build::operator()() , 以及 scatter_constraints().

{
  for (const auto & gf : as_range(gf_begin, gf_end))
    {
      GhostingFunctor::map_type more_elements_to_ghost;

      libmesh_assert(gf);
      (*gf)(elems_begin, elems_end, p, more_elements_to_ghost);

      // A GhostingFunctor should only return active elements, but
      // I forgot to *document* that, so let's go as easy as we
      // can on functors that return inactive elements.
#if defined(LIBMESH_ENABLE_DEPRECATED) && defined(LIBMESH_ENABLE_AMR)
      std::vector<std::pair<const Elem*, const CouplingMatrix*>> children_to_couple;
      for (auto it = more_elements_to_ghost.begin();
           it != more_elements_to_ghost.end();)
        {
          const Elem * elem = it->first;
          if (!elem->active())
            {
              libmesh_deprecated();
              std::vector<const Elem*> children_to_ghost;
              elem->active_family_tree(children_to_ghost,
                                       /*reset=*/ false);
              for (const Elem * child : children_to_ghost)
                if (child->processor_id() != p)
                  children_to_couple.emplace_back(child, it->second);

              it = more_elements_to_ghost.erase(it);
            }
          else
            ++it;
        }
      more_elements_to_ghost.insert(children_to_couple.begin(),
                                    children_to_couple.end());
#endif

      for (const auto & [elem, elem_cm] : more_elements_to_ghost)
        {
          // At this point we should only have active elements, even
          // if we had to fix up gf output to get here.
          libmesh_assert(elem->active());

          GhostingFunctor::map_type::iterator existing_it =
            elements_to_ghost.find (elem);

          if (existing_it == elements_to_ghost.end())
            elements_to_ghost.emplace(elem, elem_cm);
          else
            {
              if (existing_it->second)
                {
                  if (elem_cm)
                    {
                      // If this isn't already a temporary
                      // then we need to make one so we'll
                      // have a non-const matrix to merge
                      if (temporary_coupling_matrices.empty() ||
                          !temporary_coupling_matrices.count(existing_it->second))
                        {
                          // Make copy. This just calls the
                          // compiler-generated copy constructor
                          // because the CouplingMatrix class does not
                          // define a custom copy constructor.
                          auto result_pr = temporary_coupling_matrices.insert(std::make_unique<CouplingMatrix>(*existing_it->second));
                          existing_it->second = result_pr.first->get();
                        }

                      // Merge elem_cm into existing CouplingMatrix
                      const_cast<CouplingMatrix &>(*existing_it->second) &= *elem_cm;
                    }
                  else // elem_cm == nullptr
                    {
                      // Any existing_it matrix merged with a full
                      // matrix (symbolized as nullptr) gives another
                      // full matrix (symbolizable as nullptr).

                      // So if existing_it->second is a temporary then
                      // we don't need it anymore; we might as well
                      // remove it to keep the set of temporaries
                      // small.
                      auto temp_it = temporary_coupling_matrices.find(existing_it->second);
                      if (temp_it != temporary_coupling_matrices.end())
                        temporary_coupling_matrices.erase(temp_it);

                      existing_it->second = nullptr;
                    }
                }
              // else we have a nullptr already, then we have a full
              // coupling matrix, already, and merging with anything
              // else won't change that, so we're done.
            }
        }
    }
}

dof_id_type libMesh::DofMap::n_constrained_dofs

(

)

const

返回

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

在文件 dof_map_constraints.C 第 1714 行定义.

参考 n_local_constrained_dofs().

参考自 enforce_adjoint_constraints_exactly(), enforce_constraints_exactly(), enforce_constraints_on_jacobian() , 以及 enforce_constraints_on_residual().

{
  parallel_object_only();

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

dof_id_type libMesh::DofMap::n_constrained_nodes ( ) const

inline

返回

The total number of constrained Nodes in the mesh.

在文件 dof_map.h 第 908 行定义.

参考 _node_constraints.

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

dof_id_type libMesh::DofMap::n_dofs ( ) const

inline

返回

The total number of degrees of freedom in the problem.

在文件 dof_map.h 第 659 行定义.

参考 _n_dfs.

参考自 _dof_indices(), add_constraint_row(), add_neighbors_to_send_list(), distribute_dofs(), enforce_adjoint_constraints_exactly(), enforce_constraints_exactly(), libMesh::SparsityPattern::Build::join(), libMesh::SparsityPattern::Build::parallel_sync(), prepare_send_list() , 以及 process_mesh_constraint_rows().

{ return _n_dfs; }

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

inline

返回

The number of degrees of freedom on partition proc.

在文件 dof_map.h 第 675 行定义.

参考 _end_df , 以及 _first_df.

参考自 build_sparsity(), libMesh::SparsityPattern::Build::join(), n_local_dofs(), libMesh::SparsityPattern::Build::operator()() , 以及 libMesh::SparsityPattern::Build::parallel_sync().

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

dof_id_type libMesh::DofMap::n_local_constrained_dofs

(

)

const

返回

The number of constrained degrees of freedom on this processor.

在文件 dof_map_constraints.C 第 1724 行定义.

参考 _dof_constraints, end_dof() , 以及 first_dof().

参考自 n_constrained_dofs().

{
  const DofConstraints::const_iterator lower =
    _dof_constraints.lower_bound(this->first_dof()),
    upper =
    _dof_constraints.lower_bound(this->end_dof());

  return cast_int<dof_id_type>(std::distance(lower, upper));
}

dof_id_type libMesh::DofMap::n_local_dofs ( ) const

inline

返回

The number of degrees of freedom on this processor.

在文件 dof_map.h 第 669 行定义.

参考 n_dofs_on_processor().

参考自 enforce_adjoint_constraints_exactly(), enforce_constraints_exactly() , 以及 process_mesh_constraint_rows().

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

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

inlinestaticinherited

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

在文件 reference_counter.h 第 85 行定义.

参考 libMesh::ReferenceCounter::_n_objects.

参考自 libMesh::LibMeshInit::~LibMeshInit().

  { return _n_objects; }

dof_id_type libMesh::DofMap::n_old_dofs ( ) const

inline

返回

The total number of degrees of freedom on old_dof_objects

在文件 dof_map.h 第 1539 行定义.

参考 _n_old_dfs.

参考自 SCALAR_dof_indices().

{ return _n_old_dfs; }

dof_id_type libMesh::DofMap::n_SCALAR_dofs ( ) const

inline

返回

The number of SCALAR dofs.

在文件 dof_map.h 第 664 行定义.

参考 _n_SCALAR_dofs.

参考自 distribute_dofs() , 以及 SCALAR_dof_indices().

{ return _n_SCALAR_dofs; }

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

inline

返回

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

在文件 dof_map.h 第 613 行定义.

参考 _variable_groups.

参考自 distribute_local_dofs_node_major(), distribute_local_dofs_var_major(), distribute_scalar_dofs(), dof_indices(), has_blocked_representation(), old_dof_indices(), reinit() , 以及 set_nonlocal_dof_objects().

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

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

inline

返回

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

在文件 dof_map.h 第 621 行定义.

参考 _variables.

参考自 add_neighbors_to_send_list(), block_size(), create_dof_constraints(), distribute_dofs(), has_blocked_representation(), libMesh::SparsityPattern::Build::operator()(), process_mesh_constraint_rows(), reinit(), use_coupled_neighbor_dofs() , 以及 var_group_from_var_number().

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

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

inline

返回

An iterator pointing to the first Node constraint row.

在文件 dof_map.h 第 1058 行定义.

参考 _node_constraints.

  { return _node_constraints.begin(); }

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

inline

返回

An iterator pointing just past the last Node constraint row.

在文件 dof_map.h 第 1064 行定义.

参考 _node_constraints.

  { return _node_constraints.end(); }

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

private

返回

The Node pointer with index i from the mesh.

在文件 dof_map.C 第 341 行定义.

参考自 distribute_dofs().

{
  return mesh.node_ptr(i);
}

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

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

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

在文件 dof_map.C 第 2283 行定义.

参考 _node_dof_indices() , 以及 libMesh::DofObject::get_old_dof_object_ref().

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

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

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

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

在文件 dof_map.C 第 2630 行定义.

参考 _dont_p_refine, libMesh::Variable::active_on_subdomain(), libMesh::DofObject::dof_number(), libMesh::DofObject::get_old_dof_object_ref(), libMesh::DofObject::invalid_id, libMesh::invalid_uint, libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), n_variable_groups(), libMesh::VariableGroup::n_variables(), libMesh::VariableGroup::number(), SCALAR_dof_indices(), sys_number(), libMesh::Variable::type() , 以及 variable_group().

{
  LOG_SCOPE("old_dof_indices()", "DofMap");

  libmesh_assert(elem);

  const ElemType type              = elem->type();
  const unsigned int sys_num       = this->sys_number();
  const unsigned int n_var_groups  = this->n_variable_groups();
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
  const bool is_inf                = elem->infinite();
#endif

  // If we have dof indices stored on the elem, and there's no chance
  // that we only have those indices because we were just p refined,
  // then we should have old dof indices too.
  libmesh_assert(!elem->has_dofs(sys_num) ||
                 elem->p_refinement_flag() == Elem::JUST_REFINED ||
                 elem->get_old_dof_object());

  // Clear the DOF indices vector.
  di.clear();

  // Determine the nodes contributing to element elem
  std::vector<const Node *> elem_nodes;
  const Node * const * nodes_ptr;
  unsigned int n_nodes;
  if (elem->type() == TRI3SUBDIVISION)
    {
      // Subdivision surface FE require the 1-ring around elem
      const Tri3Subdivision * sd_elem = static_cast<const Tri3Subdivision *>(elem);
      MeshTools::Subdivision::find_one_ring(sd_elem, elem_nodes);
      nodes_ptr = elem_nodes.data();
      n_nodes = cast_int<unsigned int>(elem_nodes.size());
    }
  else
    {
      // All other FE use only the nodes of elem itself
      nodes_ptr = elem->get_nodes();
      n_nodes = elem->n_nodes();
    }

  // Get the dof numbers
  for (unsigned int vg=0; vg<n_var_groups; vg++)
    {
      const VariableGroup & var = this->variable_group(vg);
      const unsigned int vars_in_group = var.n_variables();

      for (unsigned int vig=0; vig<vars_in_group; vig++)
        {
          const unsigned int v = var.number(vig);
          if ((vn == v) || (vn == libMesh::invalid_uint))
            {
              if (var.type().family == SCALAR &&
                  (!elem ||
                   var.active_on_subdomain(elem->subdomain_id())))
                {
                  // We asked for this variable, so add it to the vector.
                  std::vector<dof_id_type> di_new;
                  this->SCALAR_dof_indices(di_new,v,true);
                  di.insert( di.end(), di_new.begin(), di_new.end());
                }
              else
                if (var.active_on_subdomain(elem->subdomain_id()))
                  { // Do this for all the variables if one was not specified
                    // or just for the specified variable

                    FEType fe_type = var.type();
                    const bool add_p_level =
#ifdef LIBMESH_ENABLE_AMR
                        !_dont_p_refine.count(vg);
#else
                        false;
#endif
                    // Increase the polynomial order on p refined elements,
                    // but make sure you get the right polynomial order for
                    // the OLD degrees of freedom
                    int p_adjustment = 0;
                    if (elem->p_refinement_flag() == Elem::JUST_REFINED)
                      {
                        libmesh_assert_greater (elem->p_level(), 0);
                        p_adjustment = -1;
                      }
                    else if (elem->p_refinement_flag() == Elem::JUST_COARSENED)
                      {
                        p_adjustment = 1;
                      }
                    p_adjustment *= add_p_level;

                    // Compute the net amount of "extra" order, including Elem::p_level()
                    int extra_order = int(add_p_level*elem->p_level()) + p_adjustment;

                    const bool extra_hanging_dofs =
                      FEInterface::extra_hanging_dofs(fe_type);

                    const FEInterface::n_dofs_at_node_ptr ndan =
                      FEInterface::n_dofs_at_node_function(fe_type, elem);

                    // Get the node-based DOF numbers
                    for (unsigned int n=0; n<n_nodes; n++)
                      {
                        const Node * node = nodes_ptr[n];
                        const DofObject & old_dof_obj = node->get_old_dof_object_ref();

                        // There is a potential problem with h refinement.  Imagine a
                        // quad9 that has a linear FE on it.  Then, on the hanging side,
                        // it can falsely identify a DOF at the mid-edge node. This is why
                        // we call FEInterface instead of node->n_comp() directly.
                        const unsigned int nc =
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
                          is_inf ?
                          FEInterface::n_dofs_at_node(var.type(), extra_order, elem, n) :
#endif
                          ndan (type, static_cast<Order>(var.type().order + extra_order), n);

                        const int n_comp = old_dof_obj.n_comp_group(sys_num,vg);

                        // If this is a non-vertex on a hanging node with extra
                        // degrees of freedom, we use the non-vertex dofs (which
                        // come in reverse order starting from the end, to
                        // simplify p refinement)
                        if (extra_hanging_dofs && !elem->is_vertex(n))
                          {
                            const int dof_offset = n_comp - nc;

                            // We should never have fewer dofs than necessary on a
                            // node unless we're getting indices on a parent element
                            // or a just-coarsened element
                            if (dof_offset < 0)
                              {
                                libmesh_assert(!elem->active() || elem->refinement_flag() ==
                                               Elem::JUST_COARSENED);
                                di.resize(di.size() + nc, DofObject::invalid_id);
                              }
                            else
                              for (int i=n_comp-1; i>=dof_offset; i--)
                                {
                                  const dof_id_type d =
                                    old_dof_obj.dof_number(sys_num, vg, vig, i, n_comp);

                                  // On a newly-expanded subdomain, we
                                  // may have some DoFs that didn't
                                  // exist in the old system, in which
                                  // case we can't assert this:
                                  // libmesh_assert_not_equal_to (d, DofObject::invalid_id);

                                  di.push_back(d);
                                }
                          }
                        // If this is a vertex or an element without extra hanging
                        // dofs, our dofs come in forward order coming from the
                        // beginning.  But we still might not have all
                        // those dofs on the old_dof_obj, in cases
                        // where a subdomain-restricted variable just
                        // had its subdomain expanded.
                        else
                          {
                            const unsigned int old_nc =
                              std::min(static_cast<unsigned int>(n_comp), nc);
                            for (unsigned int i=0; i != old_nc; ++i)
                              {
                                const dof_id_type d =
                                  old_dof_obj.dof_number(sys_num, vg, vig, i, n_comp);

                                libmesh_assert_not_equal_to (d, DofObject::invalid_id);

                                di.push_back(d);
                              }
                            for (unsigned int i=old_nc; i != nc; ++i)
                              di.push_back(DofObject::invalid_id);
                          }
                      }

                    // If there are any element-based DOF numbers, get them
                    const unsigned int nc =
                      FEInterface::n_dofs_per_elem(fe_type, extra_order, elem);

                    if (nc != 0)
                      {
                        const DofObject & old_dof_obj = elem->get_old_dof_object_ref();

                        const unsigned int n_comp =
                          old_dof_obj.n_comp_group(sys_num,vg);

                        if (old_dof_obj.n_systems() > sys_num &&
                            nc <= n_comp)
                          {

                            for (unsigned int i=0; i<nc; i++)
                              {
                                const dof_id_type d =
                                  old_dof_obj.dof_number(sys_num, vg, vig, i, n_comp);

                                di.push_back(d);
                              }
                          }
                        else
                          {
                            // We should never have fewer dofs than
                            // necessary on an element unless we're
                            // getting indices on a parent element, a
                            // just-coarsened element ... or a
                            // subdomain-restricted variable with a
                            // just-expanded subdomain
                            // libmesh_assert(!elem->active() || fe_type.family == LAGRANGE ||
                            //                 elem->refinement_flag() == Elem::JUST_COARSENED);
                            di.resize(di.size() + nc, DofObject::invalid_id);
                          }
                      }
                  }
            }
        } // end loop over variables within group
    } // end loop over variable groups
}

void libMesh::DofMap::prepare_send_list

(

)

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

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

在文件 dof_map.C 第 1692 行定义.

参考 _augment_send_list, _extra_send_list_context, _extra_send_list_function, _send_list, libMesh::DofMap::AugmentSendList::augment_send_list(), n_dofs() , 以及 libMesh::out.

参考自 reinit_send_list().

{
  LOG_SCOPE("prepare_send_list()", "DofMap");

  // Return immediately if there's no ghost data
  if (this->n_processors() == 1)
    return;

  // Check to see if we have any extra stuff to add to the send_list
  if (_extra_send_list_function)
    {
      if (_augment_send_list)
        {
          libmesh_here();
          libMesh::out << "WARNING:  You have specified both an extra send list function and object.\n"
                       << "          Are you sure this is what you meant to do??"
                       << std::endl;
        }

      _extra_send_list_function(_send_list, _extra_send_list_context);
    }

  if (_augment_send_list)
    _augment_send_list->augment_send_list (_send_list);

  // First sort the send list.  After this
  // duplicated elements will be adjacent in the
  // vector
  std::sort(_send_list.begin(), _send_list.end());

  // Now use std::unique to remove duplicate entries
  std::vector<dof_id_type>::iterator new_end =
    std::unique (_send_list.begin(), _send_list.end());

  // Remove the end of the send_list.  Use the "swap trick"
  // from Effective STL
  std::vector<dof_id_type> (_send_list.begin(), new_end).swap (_send_list);

  // Make sure the send list has nothing invalid in it.
  libmesh_assert(_send_list.empty() || _send_list.back() < this->n_dofs());
}

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

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

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

在文件 dof_map_constraints.C 第 2262 行定义.

参考 get_local_constraints().

{
  parallel_object_only();

  std::string local_constraints =
    this->get_local_constraints(print_nonlocal);

  if (this->processor_id())
    {
      this->comm().send(0, local_constraints);
    }
  else
    {
      os << "Processor 0:\n";
      os << local_constraints;

      for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
        {
          this->comm().receive(p, local_constraints);
          os << "Processor " << p << ":\n";
          os << local_constraints;
        }
    }
}

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

staticinherited

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

在文件 reference_counter.C 第 81 行定义.

参考 libMesh::ReferenceCounter::_enable_print_counter , 以及 libMesh::ReferenceCounter::get_info().

参考自 libMesh::LibMeshInit::~LibMeshInit().

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

void libMesh::DofMap::print_info

(

std::ostream &

os = libMesh::out

)

const

Prints summary info about the sparsity bandwidth and constraints.

在文件 dof_map.C 第 2915 行定义.

参考 get_info().

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

void libMesh::DofMap::process_constraints

(

MeshBase &

mesh

)

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

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

在文件 dof_map_constraints.C 第 4372 行定义.

参考 _adjoint_constraint_values, _dof_constraints, _error_on_constraint_loop, _primal_constraint_values, add_constraints_to_send_list(), allgather_recursive_constraints(), check_for_constraint_loops(), libMesh::Real , 以及 scatter_constraints().

参考自 reinit_send_list().

{
  // We've computed our local constraints, but they may depend on
  // non-local constraints that we'll need to take into account.
  this->allgather_recursive_constraints(mesh);

  if (_error_on_constraint_loop)
  {
    // Optionally check for constraint loops and throw an error
    // if they're detected. We always do this check below in dbg/devel
    // mode but here we optionally do it in opt mode as well.
    check_for_constraint_loops();
  }

  // Adjoints will be constrained where the primal is
  // Therefore, we will expand the adjoint_constraint_values
  // map whenever the primal_constraint_values map is expanded

  // First, figure out the total number of QoIs
  const unsigned int max_qoi_num =
    _adjoint_constraint_values.empty() ?
    0 : _adjoint_constraint_values.rbegin()->first+1;

  // Create a set containing the DOFs we already depend on
  typedef std::set<dof_id_type> RCSet;
  RCSet unexpanded_set;

  for (const auto & i : _dof_constraints)
    unexpanded_set.insert(i.first);

  while (!unexpanded_set.empty())
    for (RCSet::iterator i = unexpanded_set.begin();
         i != unexpanded_set.end(); /* nothing */)
      {
        // If the DOF is constrained
        DofConstraints::iterator
          pos = _dof_constraints.find(*i);

        libmesh_assert (pos != _dof_constraints.end());

        DofConstraintRow & constraint_row = pos->second;

        DofConstraintValueMap::iterator rhsit =
          _primal_constraint_values.find(*i);
        Number constraint_rhs = (rhsit == _primal_constraint_values.end()) ?
          0 : rhsit->second;

        // A vector of DofConstraintValueMaps for each adjoint variable
        std::vector<DofConstraintValueMap::iterator> adjoint_rhs_iterators;
        adjoint_rhs_iterators.resize(max_qoi_num);

        // Another to hold the adjoint constraint rhs
        std::vector<Number> adjoint_constraint_rhs(max_qoi_num, 0.0);

        // Find and gather recursive constraints for each adjoint variable
        for (auto & adjoint_map : _adjoint_constraint_values)
          {
            const std::size_t q = adjoint_map.first;
            adjoint_rhs_iterators[q] = adjoint_map.second.find(*i);

            adjoint_constraint_rhs[q] =
              (adjoint_rhs_iterators[q] == adjoint_map.second.end()) ?
              0 : adjoint_rhs_iterators[q]->second;
          }

        std::vector<dof_id_type> constraints_to_expand;

        for (const auto & item : constraint_row)
          if (item.first != *i && this->is_constrained_dof(item.first))
            {
              unexpanded_set.insert(item.first);
              constraints_to_expand.push_back(item.first);
            }

        for (const auto & expandable : constraints_to_expand)
          {
            const Real this_coef = constraint_row[expandable];

            DofConstraints::const_iterator
              subpos = _dof_constraints.find(expandable);

            libmesh_assert (subpos != _dof_constraints.end());

            const DofConstraintRow & subconstraint_row = subpos->second;

            for (const auto & item : subconstraint_row)
              {
                // Assert that the constraint does not form a cycle.
                libmesh_assert(item.first != expandable);
                constraint_row[item.first] += item.second * this_coef;
              }

            DofConstraintValueMap::const_iterator subrhsit =
              _primal_constraint_values.find(expandable);
            if (subrhsit != _primal_constraint_values.end())
              constraint_rhs += subrhsit->second * this_coef;

            // Find and gather recursive constraints for each adjoint variable
            for (const auto & adjoint_map : _adjoint_constraint_values)
              {
                const std::size_t q = adjoint_map.first;

                DofConstraintValueMap::const_iterator adjoint_subrhsit =
                  adjoint_map.second.find(expandable);

                if (adjoint_subrhsit != adjoint_map.second.end())
                adjoint_constraint_rhs[q] += adjoint_subrhsit->second * this_coef;
              }

            constraint_row.erase(expandable);
          }

        if (rhsit == _primal_constraint_values.end())
          {
            if (constraint_rhs != Number(0))
              _primal_constraint_values[*i] = constraint_rhs;
            else
              _primal_constraint_values.erase(*i);
          }
        else
          {
            if (constraint_rhs != Number(0))
              rhsit->second = constraint_rhs;
            else
              _primal_constraint_values.erase(rhsit);
          }

        // Finally fill in the adjoint constraints for each adjoint variable if possible
        for (auto & adjoint_map : _adjoint_constraint_values)
          {
            const std::size_t q = adjoint_map.first;

            if(adjoint_rhs_iterators[q] == adjoint_map.second.end())
              {
                if (adjoint_constraint_rhs[q] != Number(0))
                   (adjoint_map.second)[*i] = adjoint_constraint_rhs[q];
                else
                  adjoint_map.second.erase(*i);
              }
            else
              {
                if (adjoint_constraint_rhs[q] != Number(0))
                  adjoint_rhs_iterators[q]->second = adjoint_constraint_rhs[q];
                else
                  adjoint_map.second.erase(adjoint_rhs_iterators[q]);
              }
          }

        if (constraints_to_expand.empty())
          i = unexpanded_set.erase(i);
        else
          ++i;
      }

  // In parallel we can't guarantee that nodes/dofs which constrain
  // others are on processors which are aware of that constraint, yet
  // we need such awareness for sparsity pattern generation.  So send
  // other processors any constraints they might need to know about.
  this->scatter_constraints(mesh);

  // Now that we have our root constraint dependencies sorted out, add
  // them to the send_list
  this->add_constraints_to_send_list();
}

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

private

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

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

在文件 dof_map_constraints.C 第 1898 行定义.

参考 _adjoint_constraint_values, _dof_constraints, _periodic_boundaries, _primal_constraint_values, add_constraint_row(), libMesh::SparseMatrix< T >::build(), libMesh::NumericVector< T >::build(), build_sparsity(), dof_indices(), end_dof(), first_dof(), heterogeneously_constrain_element_matrix_and_vector(), is_constrained_dof(), local_index(), n_dofs(), n_local_dofs(), n_variables(), sys_number(), libMesh::TOLERANCE , 以及 variable_type().

参考自 create_dof_constraints().

{
  // If we already have simple Dirichlet constraints (with right hand
  // sides but with no coupling between DoFs) on spline-constrained FE
  // nodes, then we'll need a solve to compute the corresponding
  // constraints on the relevant spline nodes.  (If we already have
  // constraints with coupling between DoFs on spline-constrained FE
  // nodes, then we'll need to go sit down and cry until we figure out
  // how to handle that.)

  const auto & constraint_rows = mesh.get_constraint_rows();

  // This routine is too expensive to use unless we really might
  // need it
#ifdef DEBUG
  bool constraint_rows_empty = constraint_rows.empty();
  this->comm().min(constraint_rows_empty);
  libmesh_assert(!constraint_rows_empty);
#endif

  // This is fairly new code, still a bit experimental.
  libmesh_experimental();

  // We can't handle periodic boundary conditions on spline meshes
  // yet.
#ifdef LIBMESH_ENABLE_PERIODIC
  libmesh_error_msg_if (!_periodic_boundaries->empty(),
                        "Periodic boundary conditions are not yet implemented for spline meshes");
#endif

  // We can handle existing Dirichlet constraints, but we'll need
  // to do solves to project them down onto the spline basis.
  std::unique_ptr<SparsityPattern::Build> sp;
  std::unique_ptr<SparseMatrix<Number>> mat;

  const unsigned int n_adjoint_rhs =
    _adjoint_constraint_values.size();

  // [0] for primal rhs, [q+1] for adjoint qoi q
  std::vector<std::unique_ptr<NumericVector<Number>>>
    solve_rhs(n_adjoint_rhs+1);

  // Keep track of which spline DoFs will be Dirichlet.
  // We use a set here to make it easier to find what processors
  // to send the DoFs to later.
  std::set<dof_id_type> my_dirichlet_spline_dofs;

  // And keep track of which non-spline Dofs were Dirichlet
  std::unordered_set<dof_id_type> was_previously_constrained;

  const unsigned int sys_num = this->sys_number();
  for (auto & node_row : constraint_rows)
    {
      const Node * node = node_row.first;
      libmesh_assert(node == mesh.node_ptr(node->id()));

      // Each processor only computes its own (and in distributed
      // cases, is only guaranteed to have the dependency data to
      // compute its own) constraints here.
      if (node->processor_id() != mesh.processor_id())
        continue;

      for (auto var_num : IntRange<unsigned int>(0, this->n_variables()))
        {
          const FEFamily & fe_family = this->variable_type(var_num).family;

          // constraint_rows only applies to nodal variables
          if (fe_family != LAGRANGE &&
              fe_family != RATIONAL_BERNSTEIN)
            continue;

          DofConstraintRow dc_row;

          const dof_id_type constrained_id =
            node->dof_number(sys_num, var_num, 0);
          for (const auto & [pr, val] : node_row.second)
            {
              const Elem * spline_elem = pr.first;
              libmesh_assert(spline_elem == mesh.elem_ptr(spline_elem->id()));

              const Node & spline_node =
                spline_elem->node_ref(pr.second);

              const dof_id_type spline_dof_id =
                spline_node.dof_number(sys_num, var_num, 0);
              dc_row[spline_dof_id] = val;
            }

          // See if we already have a constraint here.
          if (this->is_constrained_dof(constrained_id))
            {
              was_previously_constrained.insert(constrained_id);

              // Keep track of which spline DoFs will be
              // inheriting this non-spline DoF's constraints
              for (auto & row_entry : dc_row)
                my_dirichlet_spline_dofs.insert(row_entry.first);

              // If it wasn't a simple Dirichlet-type constraint
              // then I don't know what to do with it.  We'll make
              // this an assertion only because this should only
              // crop up with periodic boundary conditions, which
              // we've already made sure we don't have.
              libmesh_assert(_dof_constraints[constrained_id].empty());
            }

          // Add the constraint, replacing any previous, so we can
          // use the new constraint in setting up the solve below
          this->add_constraint_row(constrained_id, dc_row, false);
        }
    }

  // my_dirichlet_spline_dofs may now include DoFs whose owners
  // don't know they need to become spline DoFs!  We need to push
  // this data to them.
  if (this->comm().size() > 1)
    {
      std::unordered_map
        <processor_id_type, std::vector<dof_id_type>>
        their_dirichlet_spline_dofs;

      // If we ever change the underlying container here then we'd
      // better do some kind of sort before using it; we'll rely
      // on sorting to make the processor id lookup efficient.
      libmesh_assert(std::is_sorted(my_dirichlet_spline_dofs.begin(),
                                    my_dirichlet_spline_dofs.end()));
      processor_id_type destination_pid = 0;
      for (auto d : my_dirichlet_spline_dofs)
        {
          libmesh_assert_less(d, this->end_dof(this->comm().size()-1));
          while (d >= this->end_dof(destination_pid))
            destination_pid++;

          if (destination_pid != this->processor_id())
            their_dirichlet_spline_dofs[destination_pid].push_back(d);
        }

      auto receive_dof_functor =
        [& my_dirichlet_spline_dofs]
        (processor_id_type,
         const std::vector<dof_id_type> & dofs)
        {
          my_dirichlet_spline_dofs.insert(dofs.begin(), dofs.end());
        };

      Parallel::push_parallel_vector_data
        (this->comm(), their_dirichlet_spline_dofs, receive_dof_functor);
    }


  // If anyone had any prior constraints in effect, then we need
  // to convert them to constraints on the spline nodes.
  //
  // NOT simply testing prior_constraints here; maybe it turned
  // out that all our constraints were on non-spline-constrained
  // parts of a hybrid mesh?
  bool important_prior_constraints =
    !was_previously_constrained.empty();
  this->comm().max(important_prior_constraints);

  if (important_prior_constraints)
    {
      // Now that we have the spline constraints added, we can
      // finally construct a sparsity pattern that correctly
      // accounts for those constraints!
      mat = SparseMatrix<Number>::build(this->comm());
      for (auto q : IntRange<unsigned int>(0, n_adjoint_rhs+1))
        {
          solve_rhs[q] = NumericVector<Number>::build(this->comm());
          solve_rhs[q]->init(this->n_dofs(), this->n_local_dofs(),
                             false, PARALLEL);
        }

      // We need to compute our own sparsity pattern, to take into
      // account the particularly non-sparse rows that can be
      // created by the spline constraints we just added.
      mat->attach_dof_map(*this);
      sp = this->build_sparsity(mesh);
      mat->attach_sparsity_pattern(*sp);
      mat->init();

      for (auto & node_row : constraint_rows)
        {
          const Node * node = node_row.first;
          libmesh_assert(node == mesh.node_ptr(node->id()));

          for (auto var_num : IntRange<unsigned int>(0, this->n_variables()))
            {
              const FEFamily & fe_family = this->variable_type(var_num).family;

              // constraint_rows only applies to nodal variables
              if (fe_family != LAGRANGE &&
                  fe_family != RATIONAL_BERNSTEIN)
                continue;

              const dof_id_type constrained_id =
                node->dof_number(sys_num, var_num, 0);

              if (was_previously_constrained.count(constrained_id))
                {
                  for (auto q : IntRange<int>(0, n_adjoint_rhs+1))
                    {
                      DenseMatrix<Number> K(1,1);
                      DenseVector<Number> F(1);
                      std::vector<dof_id_type> dof_indices(1, constrained_id);

                      K(0,0) = 1;

                      DofConstraintValueMap & vals = q ?
                        _adjoint_constraint_values[q-1] :
                        _primal_constraint_values;

                      DofConstraintValueMap::const_iterator rhsit =
                        vals.find(constrained_id);
                      F(0) = (rhsit == vals.end()) ?  0 : rhsit->second;

                      // We no longer need any rhs values here directly.
                      if (rhsit != vals.end())
                        vals.erase(rhsit);

                      this->heterogeneously_constrain_element_matrix_and_vector
                        (K, F, dof_indices, false, q ? (q-1) : -1);
                      if (!q)
                        mat->add_matrix(K, dof_indices);
                      solve_rhs[q]->add_vector(F, dof_indices);
                    }
                }
            }
        }

      // Any DoFs that aren't part of any constraint, directly or
      // indirectly, need a diagonal term to make the matrix
      // here invertible.
      for (dof_id_type d : IntRange<dof_id_type>(this->first_dof(),
                                                 this->end_dof()))
        if (!was_previously_constrained.count(d) &&
            !my_dirichlet_spline_dofs.count(d))
          mat->add(d,d,1);

      // At this point, we're finally ready to solve for Dirichlet
      // constraint values on spline nodes.
      std::unique_ptr<LinearSolver<Number>> linear_solver =
        LinearSolver<Number>::build(this->comm());

      std::unique_ptr<NumericVector<Number>> projected_vals =
        NumericVector<Number>::build(this->comm());

      projected_vals->init(this->n_dofs(), this->n_local_dofs(),
                           false, PARALLEL);

      DofConstraintRow empty_row;
      for (auto sd : my_dirichlet_spline_dofs)
        if (this->local_index(sd))
          this->add_constraint_row(sd, empty_row);

      for (auto q : IntRange<unsigned int>(0, n_adjoint_rhs+1))
        {
          // FIXME: we don't have an EquationSystems here, but I'd
          // rather not hardcode these...
          const double tol = double(TOLERANCE * TOLERANCE);
          const unsigned int max_its = 5000;

          linear_solver->solve(*mat, *projected_vals,
                               *(solve_rhs[q]), tol, max_its);

          DofConstraintValueMap & vals = q ?
            _adjoint_constraint_values[q-1] :
            _primal_constraint_values;

          for (auto sd : my_dirichlet_spline_dofs)
            if (this->local_index(sd))
              {
                Number constraint_rhs = (*projected_vals)(sd);

                std::pair<DofConstraintValueMap::iterator, bool> rhs_it =
                  vals.emplace(sd, constraint_rhs);
                if (!rhs_it.second)
                  rhs_it.first->second = constraint_rhs;
              }
        }
    }
}

void libMesh::DofMap::reinit

(

MeshBase &

mesh

)

Reinitialize the underlying data structures conformal to the current mesh.

在文件 dof_map.C 第 506 行定义.

参考 _default_coupling, _dof_coupling, _dont_p_refine, _n_SCALAR_dofs, libMesh::Variable::active_on_subdomain(), libMesh::err, invalidate_dofs(), n_variable_groups(), libMesh::VariableGroup::n_variables(), n_variables(), sys_number(), libMesh::Variable::type(), use_coupled_neighbor_dofs() , 以及 variable_group().

参考自 distribute_dofs().

{
  libmesh_assert (mesh.is_prepared());

  LOG_SCOPE("reinit()", "DofMap");

  // We ought to reconfigure our default coupling functor.
  //
  // The user might have removed it from our coupling functors set,
  // but if so, who cares, this reconfiguration is cheap.

  // Avoid calling set_dof_coupling() with an empty/non-nullptr
  // _dof_coupling matrix which may happen when there are actually no
  // variables on the system.
  if (this->_dof_coupling && this->_dof_coupling->empty() && !this->n_variables())
    this->_dof_coupling = nullptr;
  _default_coupling->set_dof_coupling(this->_dof_coupling);

  // By default we may want 0 or 1 levels of coupling
  unsigned int standard_n_levels =
    this->use_coupled_neighbor_dofs(mesh);
  _default_coupling->set_n_levels
    (std::max(_default_coupling->n_levels(), standard_n_levels));

  // But we *don't* want to restrict to a CouplingMatrix unless the
  // user does so manually; the original libMesh behavior was to put
  // ghost indices on the send_list regardless of variable.
  //_default_evaluating->set_dof_coupling(this->_dof_coupling);

  const unsigned int
    sys_num      = this->sys_number(),
    n_var_groups = this->n_variable_groups();

  // The DofObjects need to know how many variable groups we have, and
  // how many variables there are in each group.
  std::vector<unsigned int> n_vars_per_group;  n_vars_per_group.reserve (n_var_groups);

  for (unsigned int vg=0; vg<n_var_groups; vg++)
    n_vars_per_group.push_back (this->variable_group(vg).n_variables());

#ifdef LIBMESH_ENABLE_AMR

  //------------------------------------------------------------
  // Clear the old_dof_objects for all the nodes
  // and elements so that we can overwrite them
  for (auto & node : mesh.node_ptr_range())
    {
      node->clear_old_dof_object();
      libmesh_assert (!node->get_old_dof_object());
    }

  for (auto & elem : mesh.element_ptr_range())
    {
      elem->clear_old_dof_object();
      libmesh_assert (!elem->get_old_dof_object());
    }


  //------------------------------------------------------------
  // Set the old_dof_objects for the elements that
  // weren't just created, if these old dof objects
  // had variables
  for (auto & elem : mesh.element_ptr_range())
    {
      // Skip the elements that were just refined
      if (elem->refinement_flag() == Elem::JUST_REFINED)
        continue;

      for (Node & node : elem->node_ref_range())
        if (node.get_old_dof_object() == nullptr)
          if (node.has_dofs(sys_num))
            node.set_old_dof_object();

      libmesh_assert (!elem->get_old_dof_object());

      if (elem->has_dofs(sys_num))
        elem->set_old_dof_object();
    }

#endif // #ifdef LIBMESH_ENABLE_AMR


  //------------------------------------------------------------
  // Then set the number of variables for each \p DofObject
  // equal to n_variables() for this system.  This will
  // handle new \p DofObjects that may have just been created

  // All the nodes
  for (auto & node : mesh.node_ptr_range())
    node->set_n_vars_per_group(sys_num, n_vars_per_group);

  // All the elements
  for (auto & elem : mesh.element_ptr_range())
    elem->set_n_vars_per_group(sys_num, n_vars_per_group);

  // Zero _n_SCALAR_dofs, it will be updated below.
  this->_n_SCALAR_dofs = 0;

  //------------------------------------------------------------
  // Next allocate space for the DOF indices
  for (unsigned int vg=0; vg<n_var_groups; vg++)
    {
      const VariableGroup & vg_description = this->variable_group(vg);

      const unsigned int n_var_in_group = vg_description.n_variables();
      const FEType & base_fe_type        = vg_description.type();

      const bool add_p_level =
#ifdef LIBMESH_ENABLE_AMR
          !_dont_p_refine.count(vg);
#else
          false;
#endif

      // Don't need to loop over elements for a SCALAR variable
      // Just increment _n_SCALAR_dofs
      if (base_fe_type.family == SCALAR)
        {
          this->_n_SCALAR_dofs += base_fe_type.order.get_order()*n_var_in_group;
          continue;
        }

      // This should be constant even on p-refined elements
      const bool extra_hanging_dofs =
        FEInterface::extra_hanging_dofs(base_fe_type);

      // For all the active elements, count vertex degrees of freedom.
      for (auto & elem : mesh.active_element_ptr_range())
        {
          libmesh_assert(elem);

          // Skip the numbering if this variable is
          // not active on this element's subdomain
          if (!vg_description.active_on_subdomain(elem->subdomain_id()))
            continue;

          FEType fe_type = base_fe_type;

          const ElemType type = elem->type();

          libmesh_error_msg_if(base_fe_type.order.get_order() >
                               int(FEInterface::max_order(base_fe_type,type)),
                               "ERROR: Finite element "
                               << Utility::enum_to_string(base_fe_type.family)
                               << " on geometric element "
                               << Utility::enum_to_string(type)
                               << "\nonly supports FEInterface::max_order = "
                               << FEInterface::max_order(base_fe_type,type)
                               << ", not fe_type.order = "
                               << base_fe_type.order);

#ifdef LIBMESH_ENABLE_AMR
          // Make sure we haven't done more p refinement than we can
          // handle
          if (add_p_level*elem->p_level() + base_fe_type.order >
              FEInterface::max_order(base_fe_type, type))
            {
#  ifdef DEBUG
              libMesh::err << "WARNING: Finite element "
                           << Utility::enum_to_string(base_fe_type.family)
                           << " on geometric element "
                           << Utility::enum_to_string(type) << std::endl
                           << "could not be p refined past FEInterface::max_order = "
                           << FEInterface::max_order(base_fe_type,type)
                           << std::endl;
#  endif
              elem->set_p_level(FEInterface::max_order(base_fe_type,type)
                                - base_fe_type.order);
            }
#endif

          // Allocate the vertex DOFs
          for (auto n : elem->node_index_range())
            {
              Node & node = elem->node_ref(n);

              if (elem->is_vertex(n))
                {
                  const unsigned int old_node_dofs =
                    node.n_comp_group(sys_num, vg);

                  const unsigned int vertex_dofs =
                    std::max(FEInterface::n_dofs_at_node(fe_type, elem, n, add_p_level),
                             old_node_dofs);

                  // Some discontinuous FEs have no vertex dofs
                  if (vertex_dofs > old_node_dofs)
                    {
                      node.set_n_comp_group(sys_num, vg,
                                            vertex_dofs);

                      // Abusing dof_number to set a "this is a
                      // vertex" flag
                      node.set_vg_dof_base(sys_num, vg,
                                           vertex_dofs);

                      // libMesh::out << "sys_num,vg,old_node_dofs,vertex_dofs="
                      //       << sys_num << ","
                      //       << vg << ","
                      //       << old_node_dofs << ","
                      //       << vertex_dofs << '\n',
                      // node.debug_buffer();

                      // libmesh_assert_equal_to (vertex_dofs, node.n_comp(sys_num, vg));
                      // libmesh_assert_equal_to (vertex_dofs, node.vg_dof_base(sys_num, vg));
                    }
                }
            }
        } // done counting vertex dofs

      // count edge & face dofs next
      for (auto & elem : mesh.active_element_ptr_range())
        {
          libmesh_assert(elem);

          // Skip the numbering if this variable is
          // not active on this element's subdomain
          if (!vg_description.active_on_subdomain(elem->subdomain_id()))
            continue;

          // Allocate the edge and face DOFs
          for (auto n : elem->node_index_range())
            {
              Node & node = elem->node_ref(n);

              const unsigned int old_node_dofs =
                node.n_comp_group(sys_num, vg);

              const unsigned int vertex_dofs = old_node_dofs?
                cast_int<unsigned int>(node.vg_dof_base (sys_num,vg)):0;

              const unsigned int new_node_dofs =
                FEInterface::n_dofs_at_node(base_fe_type, elem, n, add_p_level);

              // We've already allocated vertex DOFs
              if (elem->is_vertex(n))
                {
                  libmesh_assert_greater_equal (old_node_dofs, vertex_dofs);
                  // //if (vertex_dofs < new_node_dofs)
                  //   libMesh::out << "sys_num,vg,old_node_dofs,vertex_dofs,new_node_dofs="
                  //                << sys_num << ","
                  //                << vg << ","
                  //                << old_node_dofs << ","
                  //                << vertex_dofs << ","
                  //                << new_node_dofs << '\n',
                  //     node.debug_buffer();

                  libmesh_assert_greater_equal (vertex_dofs,   new_node_dofs);
                }
              // We need to allocate the rest
              else
                {
                  // If this has no dofs yet, it needs no vertex
                  // dofs, so we just give it edge or face dofs
                  if (!old_node_dofs)
                    {
                      node.set_n_comp_group(sys_num, vg,
                                            new_node_dofs);
                      // Abusing dof_number to set a "this has no
                      // vertex dofs" flag
                      if (new_node_dofs)
                        node.set_vg_dof_base(sys_num, vg, 0);
                    }

                  // If this has dofs, but has no vertex dofs,
                  // it may still need more edge or face dofs if
                  // we're p-refined.
                  else if (vertex_dofs == 0)
                    {
                      if (new_node_dofs > old_node_dofs)
                        {
                          node.set_n_comp_group(sys_num, vg,
                                                new_node_dofs);

                          node.set_vg_dof_base(sys_num, vg,
                                               vertex_dofs);
                        }
                    }
                  // If this is another element's vertex,
                  // add more (non-overlapping) edge/face dofs if
                  // necessary
                  else if (extra_hanging_dofs)
                    {
                      if (new_node_dofs > old_node_dofs - vertex_dofs)
                        {
                          node.set_n_comp_group(sys_num, vg,
                                                vertex_dofs + new_node_dofs);

                          node.set_vg_dof_base(sys_num, vg,
                                               vertex_dofs);
                        }
                    }
                  // If this is another element's vertex, add any
                  // (overlapping) edge/face dofs if necessary
                  else
                    {
                      libmesh_assert_greater_equal (old_node_dofs, vertex_dofs);
                      if (new_node_dofs > old_node_dofs)
                        {
                          node.set_n_comp_group(sys_num, vg,
                                                new_node_dofs);

                          node.set_vg_dof_base (sys_num, vg,
                                                vertex_dofs);
                        }
                    }
                }
            }
          // Allocate the element DOFs
          const unsigned int dofs_per_elem =
            FEInterface::n_dofs_per_elem(base_fe_type, elem, add_p_level);

          elem->set_n_comp_group(sys_num, vg, dofs_per_elem);

        }
    } // end loop over variable groups

  // Calling DofMap::reinit() by itself makes little sense,
  // so we won't bother with nonlocal DofObjects.
  // Those will be fixed by distribute_dofs

  //------------------------------------------------------------
  // Finally, clear all the current DOF indices
  // (distribute_dofs expects them cleared!)
  this->invalidate_dofs(mesh);
}

void libMesh::DofMap::reinit_send_list

(

MeshBase &

mesh

)

Clears the _send_list vector and then rebuilds it.

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

在文件 dof_map.C 第 1734 行定义.

参考 add_neighbors_to_send_list(), clear_send_list(), prepare_send_list() , 以及 process_constraints().

{
  this->clear_send_list();
  this->add_neighbors_to_send_list(mesh);

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

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

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

在文件 dof_map_constraints.C 第 5513 行定义.

参考 _adjoint_dirichlet_boundaries, libMesh::DirichletBoundary::b , 以及 libMesh::DirichletBoundary::variables.

{
  libmesh_assert_greater(_adjoint_dirichlet_boundaries.size(),
                         qoi_index);

  auto lam = [&boundary_to_remove](const auto & bdy)
    {return bdy->b == boundary_to_remove.b && bdy->variables == boundary_to_remove.variables;};

  auto it = std::find_if(_adjoint_dirichlet_boundaries[qoi_index]->begin(),
                         _adjoint_dirichlet_boundaries[qoi_index]->end(),
                         lam);

  // Assert it was actually found and remove it from the vector
  libmesh_assert (it != _adjoint_dirichlet_boundaries[qoi_index]->end());
  _adjoint_dirichlet_boundaries[qoi_index]->erase(it);
}

void libMesh::DofMap::remove_algebraic_ghosting_functor

(

GhostingFunctor &

evaluable_functor

)

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

在文件 dof_map.C 第 1898 行定义.

参考 _algebraic_ghosting_functors, _mesh , 以及 _shared_functors.

参考自 remove_default_ghosting().

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

  auto it = _shared_functors.find(&evaluable_functor);
  if (it != _shared_functors.end())
    _shared_functors.erase(it);
}

void libMesh::DofMap::remove_coupling_functor

(

GhostingFunctor &

coupling_functor

)

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

在文件 dof_map.C 第 1873 行定义.

参考 _coupling_functors, _mesh , 以及 _shared_functors.

参考自 remove_default_ghosting().

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

  auto it = _shared_functors.find(&coupling_functor);
  if (it != _shared_functors.end())
    _shared_functors.erase(it);
}

void libMesh::DofMap::remove_default_ghosting

(

)

Remove any default ghosting functor(s).

User-added ghosting functors will be unaffected.

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

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

在文件 dof_map.C 第 1844 行定义.

参考 default_algebraic_ghosting(), default_coupling(), remove_algebraic_ghosting_functor() , 以及 remove_coupling_functor().

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

void libMesh::DofMap::remove_dirichlet_boundary

(

const DirichletBoundary &

dirichlet_boundary

)

Removes the specified Dirichlet boundary from the system.

在文件 dof_map_constraints.C 第 5499 行定义.

参考 _dirichlet_boundaries, libMesh::DirichletBoundary::b , 以及 libMesh::DirichletBoundary::variables.

{
  // Find a boundary condition matching the one to be removed
  auto lam = [&boundary_to_remove](const auto & bdy)
    {return bdy->b == boundary_to_remove.b && bdy->variables == boundary_to_remove.variables;};

  auto it = std::find_if(_dirichlet_boundaries->begin(), _dirichlet_boundaries->end(), lam);

  // Assert it was actually found and remove it from the vector
  libmesh_assert (it != _dirichlet_boundaries->end());
  _dirichlet_boundaries->erase(it);
}

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

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

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

注解

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

在文件 dof_map.C 第 2544 行定义.

参考 _first_old_scalar_df, _first_scalar_df, libMesh::DofObject::invalid_id, n_old_dofs(), n_SCALAR_dofs(), libMesh::Variable::type() , 以及 variable().

参考自 dof_indices(), local_variable_indices() , 以及 old_dof_indices().

{
  LOG_SCOPE("SCALAR_dof_indices()", "DofMap");

  libmesh_assert(this->variable(vn).type().family == SCALAR);

#ifdef LIBMESH_ENABLE_AMR
  // If we're asking for old dofs then we'd better have some
  if (old_dofs)
    libmesh_assert_greater_equal(n_old_dofs(), n_SCALAR_dofs());

  dof_id_type my_idx = old_dofs ?
    this->_first_old_scalar_df[vn] : this->_first_scalar_df[vn];
#else
  dof_id_type my_idx = this->_first_scalar_df[vn];
#endif

  libmesh_assert_not_equal_to(my_idx, DofObject::invalid_id);

  // The number of SCALAR dofs comes from the variable order
  const int n_dofs_vn = this->variable(vn).type().order.get_order();

  di.resize(n_dofs_vn);
  for (int i = 0; i != n_dofs_vn; ++i)
    di[i] = my_idx++;
}

void libMesh::DofMap::scatter_constraints

(

MeshBase &

mesh

)

Sends constraint equations to constraining processors.

在文件 dof_map_constraints.C 第 4643 行定义.

参考 _dof_constraints, _end_df, _node_constraints, _primal_constraint_values, coupling_functors_begin(), coupling_functors_end(), dof_indices(), gather_constraints(), is_constrained_dof(), is_constrained_node() , 以及 merge_ghost_functor_outputs().

参考自 process_constraints().

{
  // At this point each processor with a constrained node knows
  // the corresponding constraint row, but we also need each processor
  // with a constrainer node to know the corresponding row(s).

  // This function must be run on all processors at once
  parallel_object_only();

  // Return immediately if there's nothing to gather
  if (this->n_processors() == 1)
    return;

  // We might get to return immediately if none of the processors
  // found any constraints
  unsigned int has_constraints = !_dof_constraints.empty()
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
    || !_node_constraints.empty()
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS
    ;
  this->comm().max(has_constraints);
  if (!has_constraints)
    return;

  // We may be receiving packed_range sends out of order with
  // parallel_sync tags, so make sure they're received correctly.
  Parallel::MessageTag range_tag = this->comm().get_unique_tag();

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  std::map<processor_id_type, std::set<dof_id_type>> pushed_node_ids;
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS

  std::map<processor_id_type, std::set<dof_id_type>> pushed_ids;

  // Collect the dof constraints I need to push to each processor
  dof_id_type constrained_proc_id = 0;
  for (const auto & [constrained, row] : _dof_constraints)
    {
      while (constrained >= _end_df[constrained_proc_id])
        constrained_proc_id++;

      if (constrained_proc_id != this->processor_id())
        continue;

      for (auto & j : row)
        {
          const dof_id_type constraining = j.first;

          processor_id_type constraining_proc_id = 0;
          while (constraining >= _end_df[constraining_proc_id])
            constraining_proc_id++;

          if (constraining_proc_id != this->processor_id() &&
              constraining_proc_id != constrained_proc_id)
            pushed_ids[constraining_proc_id].insert(constrained);
        }
    }

  // Pack the dof constraint rows and rhs's to push

  std::map<processor_id_type,
          std::vector<std::vector<std::pair<dof_id_type, Real>>>>
    pushed_keys_vals, pushed_keys_vals_to_me;

  std::map<processor_id_type, std::vector<std::pair<dof_id_type, Number>>>
    pushed_ids_rhss, pushed_ids_rhss_to_me;

  auto gather_ids =
    [this,
     & pushed_ids,
     & pushed_keys_vals,
     & pushed_ids_rhss]
    ()
    {
      for (const auto & [pid, pid_ids] : pushed_ids)
        {
          const std::size_t ids_size = pid_ids.size();
          std::vector<std::vector<std::pair<dof_id_type, Real>>> &
            keys_vals = pushed_keys_vals[pid];
          std::vector<std::pair<dof_id_type,Number>> &
            ids_rhss = pushed_ids_rhss[pid];
          keys_vals.resize(ids_size);
          ids_rhss.resize(ids_size);

          std::size_t push_i;
          std::set<dof_id_type>::const_iterator it;
          for (push_i = 0, it = pid_ids.begin();
               it != pid_ids.end(); ++push_i, ++it)
            {
              const dof_id_type constrained = *it;
              DofConstraintRow & row = _dof_constraints[constrained];
              keys_vals[push_i].assign(row.begin(), row.end());

              DofConstraintValueMap::const_iterator rhsit =
                _primal_constraint_values.find(constrained);
              ids_rhss[push_i].first = constrained;
              ids_rhss[push_i].second =
                (rhsit == _primal_constraint_values.end()) ?
                0 : rhsit->second;
            }
        }
    };

  gather_ids();

  auto ids_rhss_action_functor =
    [& pushed_ids_rhss_to_me]
    (processor_id_type pid,
     const std::vector<std::pair<dof_id_type, Number>> & data)
    {
      pushed_ids_rhss_to_me[pid] = data;
    };

  auto keys_vals_action_functor =
    [& pushed_keys_vals_to_me]
    (processor_id_type pid,
     const std::vector<std::vector<std::pair<dof_id_type, Real>>> & data)
    {
      pushed_keys_vals_to_me[pid] = data;
    };

  Parallel::push_parallel_vector_data
    (this->comm(), pushed_ids_rhss, ids_rhss_action_functor);
  Parallel::push_parallel_vector_data
    (this->comm(), pushed_keys_vals, keys_vals_action_functor);

  // Now work on traded dof constraint rows
  auto receive_dof_constraints =
    [this,
     & pushed_ids_rhss_to_me,
     & pushed_keys_vals_to_me]
    ()
    {
      for (const auto & [pid, ids_rhss] : pushed_ids_rhss_to_me)
        {
          const auto & keys_vals = pushed_keys_vals_to_me[pid];

          libmesh_assert_equal_to
            (ids_rhss.size(), keys_vals.size());

          // Add the dof constraints that I've been sent
          for (auto i : index_range(ids_rhss))
            {
              dof_id_type constrained = ids_rhss[i].first;

              // If we don't already have a constraint for this dof,
              // add the one we were sent
              if (!this->is_constrained_dof(constrained))
                {
                  DofConstraintRow & row = _dof_constraints[constrained];
                  for (auto & key_val : keys_vals[i])
                    {
                      libmesh_assert_less(key_val.first, this->n_dofs());
                      row[key_val.first] = key_val.second;
                    }
                  if (ids_rhss[i].second != Number(0))
                    _primal_constraint_values[constrained] =
                      ids_rhss[i].second;
                  else
                    _primal_constraint_values.erase(constrained);
                }
            }
        }
    };

  receive_dof_constraints();

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  // Collect the node constraints to push to each processor
  for (auto & i : _node_constraints)
    {
      const Node * constrained = i.first;

      if (constrained->processor_id() != this->processor_id())
        continue;

      NodeConstraintRow & row = i.second.first;
      for (auto & j : row)
        {
          const Node * constraining = j.first;

          if (constraining->processor_id() != this->processor_id() &&
              constraining->processor_id() != constrained->processor_id())
            pushed_node_ids[constraining->processor_id()].insert(constrained->id());
        }
    }

  // Pack the node constraint rows and rhss to push
  std::map<processor_id_type,
          std::vector<std::vector<std::pair<dof_id_type,Real>>>>
    pushed_node_keys_vals, pushed_node_keys_vals_to_me;
  std::map<processor_id_type, std::vector<std::pair<dof_id_type, Point>>>
    pushed_node_ids_offsets, pushed_node_ids_offsets_to_me;
  std::map<processor_id_type, std::vector<const Node *>> pushed_node_vecs;

  for (const auto & [pid, pid_ids]: pushed_node_ids)
    {
      const std::size_t ids_size = pid_ids.size();
      std::vector<std::vector<std::pair<dof_id_type,Real>>> &
        keys_vals = pushed_node_keys_vals[pid];
      std::vector<std::pair<dof_id_type, Point>> &
        ids_offsets = pushed_node_ids_offsets[pid];
      keys_vals.resize(ids_size);
      ids_offsets.resize(ids_size);
      std::set<Node *> nodes;

      std::size_t push_i;
      std::set<dof_id_type>::const_iterator it;
      for (push_i = 0, it = pid_ids.begin();
           it != pid_ids.end(); ++push_i, ++it)
        {
          Node * constrained = mesh.node_ptr(*it);

          if (constrained->processor_id() != pid)
            nodes.insert(constrained);

          NodeConstraintRow & row = _node_constraints[constrained].first;
          std::size_t row_size = row.size();
          keys_vals[push_i].reserve(row_size);
          for (const auto & j : row)
            {
              Node * constraining = const_cast<Node *>(j.first);

              keys_vals[push_i].emplace_back(constraining->id(), j.second);

              if (constraining->processor_id() != pid)
                nodes.insert(constraining);
            }

          ids_offsets[push_i].first = *it;
          ids_offsets[push_i].second = _node_constraints[constrained].second;
        }

      if (!mesh.is_serial())
        {
          auto & pid_nodes = pushed_node_vecs[pid];
          pid_nodes.assign(nodes.begin(), nodes.end());
        }
    }

  auto node_ids_offsets_action_functor =
    [& pushed_node_ids_offsets_to_me]
    (processor_id_type pid,
     const std::vector<std::pair<dof_id_type, Point>> & data)
    {
      pushed_node_ids_offsets_to_me[pid] = data;
    };

  auto node_keys_vals_action_functor =
    [& pushed_node_keys_vals_to_me]
    (processor_id_type pid,
     const std::vector<std::vector<std::pair<dof_id_type, Real>>> & data)
    {
      pushed_node_keys_vals_to_me[pid] = data;
    };

  // Trade pushed node constraint rows
  Parallel::push_parallel_vector_data
    (this->comm(), pushed_node_ids_offsets, node_ids_offsets_action_functor);
  Parallel::push_parallel_vector_data
    (this->comm(), pushed_node_keys_vals, node_keys_vals_action_functor);

  // Constraining nodes might not even exist on our subset of a
  // distributed mesh, so let's make them exist.

  // Node unpack() now automatically adds them to the context mesh
  auto null_node_functor = [](processor_id_type, const std::vector<const Node *> &){};

  if (!mesh.is_serial())
    Parallel::push_parallel_packed_range
      (this->comm(), pushed_node_vecs, &mesh, null_node_functor);

  for (const auto & [pid, ids_offsets] : pushed_node_ids_offsets_to_me)
    {
      const auto & keys_vals = pushed_node_keys_vals_to_me[pid];

      libmesh_assert_equal_to
        (ids_offsets.size(), keys_vals.size());

      // Add the node constraints that I've been sent
      for (auto i : index_range(ids_offsets))
        {
          dof_id_type constrained_id = ids_offsets[i].first;

          // If we don't already have a constraint for this node,
          // add the one we were sent
          const Node * constrained = mesh.node_ptr(constrained_id);
          if (!this->is_constrained_node(constrained))
            {
              NodeConstraintRow & row = _node_constraints[constrained].first;
              for (auto & key_val : keys_vals[i])
                {
                  const Node * key_node = mesh.node_ptr(key_val.first);
                  row[key_node] = key_val.second;
                }
              _node_constraints[constrained].second =
                ids_offsets[i].second;
            }
        }
    }
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS

  // Next we need to push constraints to processors which don't own
  // the constrained dof, don't own the constraining dof, but own an
  // element supporting the constraining dof.
  //
  // We need to be able to quickly look up constrained dof ids by what
  // constrains them, so that we can handle the case where we see a
  // foreign element containing one of our constraining DoF ids and we
  // need to push that constraint.
  //
  // Getting distributed adaptive sparsity patterns right is hard.

  typedef std::map<dof_id_type, std::set<dof_id_type>> DofConstrainsMap;
  DofConstrainsMap dof_id_constrains;

  for (const auto & [constrained, row] : _dof_constraints)
    {
      for (const auto & j : row)
        {
          const dof_id_type constraining = j.first;

          dof_id_type constraining_proc_id = 0;
          while (constraining >= _end_df[constraining_proc_id])
            constraining_proc_id++;

          if (constraining_proc_id == this->processor_id())
            dof_id_constrains[constraining].insert(constrained);
        }
    }

  // Loop over all foreign elements, find any supporting our
  // constrained dof indices.
  pushed_ids.clear();

  for (const auto & elem : as_range(mesh.active_not_local_elements_begin(),
                                    mesh.active_not_local_elements_end()))
    {
      std::vector<dof_id_type> my_dof_indices;
      this->dof_indices (elem, my_dof_indices);

      for (const auto & dof : my_dof_indices)
        {
          DofConstrainsMap::const_iterator dcmi = dof_id_constrains.find(dof);
          if (dcmi != dof_id_constrains.end())
            {
              for (const auto & constrained : dcmi->second)
                {
                  dof_id_type the_constrained_proc_id = 0;
                  while (constrained >= _end_df[the_constrained_proc_id])
                    the_constrained_proc_id++;

                  const processor_id_type elemproc = elem->processor_id();
                  if (elemproc != the_constrained_proc_id)
                    pushed_ids[elemproc].insert(constrained);
                }
            }
        }
    }

  pushed_ids_rhss.clear();
  pushed_ids_rhss_to_me.clear();
  pushed_keys_vals.clear();
  pushed_keys_vals_to_me.clear();

  gather_ids();

  // Trade pushed dof constraint rows
  Parallel::push_parallel_vector_data
    (this->comm(), pushed_ids_rhss, ids_rhss_action_functor);
  Parallel::push_parallel_vector_data
    (this->comm(), pushed_keys_vals, keys_vals_action_functor);

  receive_dof_constraints();

  // Finally, we need to handle the case of remote dof coupling.  If a
  // processor's element is coupled to a ghost element, then the
  // processor needs to know about all constraints which affect the
  // dofs on that ghost element, so we'll have to query the ghost
  // element's owner.

  GhostingFunctor::map_type elements_to_couple;
  DofMap::CouplingMatricesSet temporary_coupling_matrices;

  this->merge_ghost_functor_outputs
    (elements_to_couple,
     temporary_coupling_matrices,
     this->coupling_functors_begin(),
     this->coupling_functors_end(),
     mesh.active_local_elements_begin(),
     mesh.active_local_elements_end(),
     this->processor_id());

  // Each ghost-coupled element's owner should get a request for its dofs
  std::set<dof_id_type> requested_dofs;

  for (const auto & pr : elements_to_couple)
    {
      const Elem * elem = pr.first;

      // FIXME - optimize for the non-fully-coupled case?
      std::vector<dof_id_type> element_dofs;
      this->dof_indices(elem, element_dofs);

      for (auto dof : element_dofs)
        requested_dofs.insert(dof);
    }

  this->gather_constraints(mesh, requested_dofs, false);
}

bool libMesh::DofMap::semilocal_index

(

dof_id_type

dof_index

)

const

返回

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

注解

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

在文件 dof_map.C 第 2580 行定义.

参考 _send_list , 以及 local_index().

参考自 all_semilocal_indices().

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

  return true;
}

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

inline

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

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

在文件 dof_map.h 第 2294 行定义.

参考 _constrained_sparsity_construction , 以及 libMesh::libmesh_ignore().

{
  // This got only partly finished...
  if (use_constraints)
    libmesh_not_implemented();

#ifdef LIBMESH_ENABLE_CONSTRAINTS
  _constrained_sparsity_construction = use_constraints;
#endif
  libmesh_ignore(use_constraints);
}

void libMesh::DofMap::set_error_on_constraint_loop

(

bool

error_on_constraint_loop

)

在文件 dof_map.C 第 245 行定义.

参考 _error_on_constraint_loop.

参考自 set_error_on_cyclic_constraint().

{
  _error_on_constraint_loop = error_on_constraint_loop;
}

void libMesh::DofMap::set_error_on_cyclic_constraint

(

bool

error_on_cyclic_constraint

)

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

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

注解

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

在文件 dof_map.C 第 238 行定义.

参考 set_error_on_constraint_loop().

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

void libMesh::DofMap::set_implicit_neighbor_dofs

(

bool

implicit_neighbor_dofs

)

Allow the implicit_neighbor_dofs flag to be set programmatically.

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

在文件 dof_map.C 第 1748 行定义.

参考 _implicit_neighbor_dofs , 以及 _implicit_neighbor_dofs_initialized.

{
  _implicit_neighbor_dofs_initialized = true;
  _implicit_neighbor_dofs = implicit_neighbor_dofs;
}

template<typename iterator_type >

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

private

Helper function for distributing dofs in parallel.

在文件 dof_map.C 第 356 行定义.

参考 libMesh::DofObject::dof_number(), libMesh::DofObject::id(), libMesh::DofObject::invalid_id, libMesh::DofObject::invalid_processor_id, libMesh::DofObject::n_comp(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_var_groups(), n_variable_groups(), libMesh::DofObject::n_vars(), libMesh::DofObject::processor_id(), libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_vg_dof_base(), sys_number() , 以及 libMesh::DofObject::vg_dof_base().

参考自 distribute_dofs().

{
  // This function must be run on all processors at once
  parallel_object_only();

  // First, iterate over local objects to find out how many
  // are on each processor
  std::unordered_map<processor_id_type, dof_id_type> ghost_objects_from_proc;

  iterator_type it  = objects_begin;

  for (; it != objects_end; ++it)
    {
      DofObject * obj = *it;

      if (obj)
        {
          processor_id_type obj_procid = obj->processor_id();
          // We'd better be completely partitioned by now
          libmesh_assert_not_equal_to (obj_procid, DofObject::invalid_processor_id);
          ghost_objects_from_proc[obj_procid]++;
        }
    }

  // Request sets to send to each processor
  std::map<processor_id_type, std::vector<dof_id_type>>
    requested_ids;

  // We know how many of our objects live on each processor, so
  // reserve() space for requests from each.
  for (auto [p, size] : ghost_objects_from_proc)
    {
      if (p != this->processor_id())
        requested_ids[p].reserve(size);
    }

  for (it = objects_begin; it != objects_end; ++it)
    {
      DofObject * obj = *it;
      if (obj->processor_id() != DofObject::invalid_processor_id)
        requested_ids[obj->processor_id()].push_back(obj->id());
    }
#ifdef DEBUG
  for (auto p : make_range(this->n_processors()))
    {
      if (ghost_objects_from_proc.count(p))
        libmesh_assert_equal_to (requested_ids[p].size(), ghost_objects_from_proc[p]);
      else
        libmesh_assert(!requested_ids.count(p));
    }
#endif

  typedef std::vector<dof_id_type> datum;

  auto gather_functor =
    [this, &mesh, &objects]
    (processor_id_type,
     const std::vector<dof_id_type> & ids,
     std::vector<datum> & data)
    {
      // Fill those requests
      const unsigned int
        sys_num      = this->sys_number(),
        n_var_groups = this->n_variable_groups();

      const std::size_t query_size = ids.size();

      data.resize(query_size);
      for (auto & d : data)
        d.resize(2 * n_var_groups);

      for (std::size_t i=0; i != query_size; ++i)
        {
          DofObject * requested = (this->*objects)(mesh, ids[i]);
          libmesh_assert(requested);
          libmesh_assert_equal_to (requested->processor_id(), this->processor_id());
          libmesh_assert_equal_to (requested->n_var_groups(sys_num), n_var_groups);
          for (unsigned int vg=0; vg != n_var_groups; ++vg)
            {
              unsigned int n_comp_g =
                requested->n_comp_group(sys_num, vg);
              data[i][vg] = n_comp_g;
              dof_id_type my_first_dof = n_comp_g ?
                requested->vg_dof_base(sys_num, vg) : 0;
              libmesh_assert_not_equal_to (my_first_dof, DofObject::invalid_id);
              data[i][n_var_groups+vg] = my_first_dof;
            }
        }
    };

  auto action_functor =
    [this, &mesh, &objects]
    (processor_id_type libmesh_dbg_var(pid),
     const std::vector<dof_id_type> & ids,
     const std::vector<datum> & data)
    {
      const unsigned int
        sys_num      = this->sys_number(),
        n_var_groups = this->n_variable_groups();

      // Copy the id changes we've now been informed of
      for (auto i : index_range(ids))
        {
          DofObject * requested = (this->*objects)(mesh, ids[i]);
          libmesh_assert(requested);
          libmesh_assert_equal_to (requested->processor_id(), pid);
          for (unsigned int vg=0; vg != n_var_groups; ++vg)
            {
              unsigned int n_comp_g =
                cast_int<unsigned int>(data[i][vg]);
              requested->set_n_comp_group(sys_num, vg, n_comp_g);
              if (n_comp_g)
                {
                  dof_id_type my_first_dof = data[i][n_var_groups+vg];
                  libmesh_assert_not_equal_to (my_first_dof, DofObject::invalid_id);
                  requested->set_vg_dof_base
                    (sys_num, vg, my_first_dof);
                }
            }
        }
    };

  datum * ex = nullptr;
  Parallel::pull_parallel_vector_data
    (this->comm(), requested_ids, gather_functor, action_functor, ex);

#ifdef DEBUG
  // Double check for invalid dofs
  for (it = objects_begin; it != objects_end; ++it)
    {
      DofObject * obj = *it;
      libmesh_assert (obj);
      unsigned int num_variables = obj->n_vars(this->sys_number());
      for (unsigned int v=0; v != num_variables; ++v)
        {
          unsigned int n_comp =
            obj->n_comp(this->sys_number(), v);
          dof_id_type my_first_dof = n_comp ?
            obj->dof_number(this->sys_number(), v, 0) : 0;
          libmesh_assert_not_equal_to (my_first_dof, DofObject::invalid_id);
        }
    }
#endif
}

void libMesh::DofMap::set_verify_dirichlet_bc_consistency

(

bool

val

)

Set the _verify_dirichlet_bc_consistency flag.

在文件 dof_map.C 第 1754 行定义.

参考 _verify_dirichlet_bc_consistency.

{
  _verify_dirichlet_bc_consistency = val;
}

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

inline

Describe whether the given variable group should be p-refined.

If this API is not called with false, the default is to p-refine

在文件 dof_map.h 第 2319 行定义.

参考 _dont_p_refine , 以及 libMesh::libmesh_ignore().

{
#ifdef LIBMESH_ENABLE_AMR
  if (p_refine)
  {
    auto it = _dont_p_refine.find(g);
    if (it != _dont_p_refine.end())
      _dont_p_refine.erase(it);
  }
  else
    _dont_p_refine.insert(g);
#else
  libmesh_ignore(g, p_refine);
#endif
}

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

inline

Whether the given variable group should be p-refined.

在文件 dof_map.h 第 2336 行定义.

参考 _dont_p_refine , 以及 libMesh::libmesh_ignore().

{
#ifdef LIBMESH_ENABLE_AMR
  return !_dont_p_refine.count(g);
#else
  libmesh_ignore(g);
  return false;
#endif
}

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

delete

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

delete

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

delete

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

delete

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

inline

Whether the given variable should be p-refined.

在文件 dof_map.h 第 2354 行定义.

参考 _dont_p_refine, libMesh::libmesh_ignore() , 以及 var_group_from_var_number().

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

void libMesh::DofMap::stash_dof_constraints ( )

inline

在文件 dof_map.h 第 1025 行定义.

参考 _dof_constraints , 以及 _stashed_dof_constraints.

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

void libMesh::DofMap::swap_dof_constraints ( )

inline

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

注解

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

在文件 dof_map.h 第 1049 行定义.

参考 _dof_constraints , 以及 _stashed_dof_constraints.

  {
    _dof_constraints.swap(_stashed_dof_constraints);
  }

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

inline

返回

The number of the system we are responsible for.

在文件 dof_map.h 第 2093 行定义.

参考 _sys_number.

参考自 _dof_indices(), _node_dof_indices(), allgather_recursive_constraints(), assert_no_nodes_missed(), constrain_p_dofs(), distribute_dofs(), distribute_local_dofs_node_major(), distribute_local_dofs_var_major(), dof_indices(), invalidate_dofs(), local_variable_indices(), old_dof_indices(), process_mesh_constraint_rows(), reinit() , 以及 set_nonlocal_dof_objects().

{
  return _sys_number;
}

void libMesh::DofMap::unstash_dof_constraints ( )

inline

在文件 dof_map.h 第 1031 行定义.

参考 _dof_constraints , 以及 _stashed_dof_constraints.

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

void libMesh::DofMap::update_sparsity_pattern

(

SparseMatrix< Number > &

matrix

)

const

Additional matrices may be be temporarily initialized by this DofMap.

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

在文件 dof_map.C 第 307 行定义.

参考 _sp, libMesh::SparseMatrix< T >::attach_dof_map(), libMesh::SparseMatrix< T >::attach_sparsity_pattern(), computed_sparsity_already(), libMesh::SparseMatrix< T >::need_full_sparsity_pattern(), need_full_sparsity_pattern , 以及 libMesh::SparseMatrix< T >::update_sparsity_pattern().

参考自 attach_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
  if (this->computed_sparsity_already())
    {
      libmesh_assert(_sp.get());

      if (matrix.need_full_sparsity_pattern())
        {
          // We'd better have already computed the full sparsity
          // pattern if we need it here
          libmesh_assert(need_full_sparsity_pattern);

          matrix.update_sparsity_pattern (_sp->get_sparsity_pattern());
        }

      matrix.attach_sparsity_pattern(*_sp);
    }
}

bool libMesh::DofMap::use_coupled_neighbor_dofs

(

const MeshBase &

mesh

)

const

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

在文件 dof_map.C 第 1760 行定义.

参考 _implicit_neighbor_dofs, _implicit_neighbor_dofs_initialized, libMesh::command_line_next(), n_variables(), libMesh::on_command_line() , 以及 variable_type().

参考自 build_sparsity(), clear() , 以及 reinit().

{
  // If we were asked on the command line, then we need to
  // include sensitivities between neighbor degrees of freedom
  bool implicit_neighbor_dofs =
    libMesh::on_command_line ("--implicit-neighbor-dofs");

  // If the user specifies --implicit-neighbor-dofs 0, then
  // presumably he knows what he is doing and we won't try to
  // automatically turn it on even when all the variables are
  // discontinuous.
  if (implicit_neighbor_dofs)
    {
      // No flag provided defaults to 'true'
      int flag = 1;
      flag = libMesh::command_line_next ("--implicit-neighbor-dofs", flag);

      if (!flag)
        {
          // The user said --implicit-neighbor-dofs 0, so he knows
          // what he is doing and really doesn't want it.
          return false;
        }
    }

  // Possibly override the commandline option, if set_implicit_neighbor_dofs
  // has been called.
  if (_implicit_neighbor_dofs_initialized)
    {
      implicit_neighbor_dofs = _implicit_neighbor_dofs;

      // Again, if the user explicitly says implicit_neighbor_dofs = false,
      // then we return here.
      if (!implicit_neighbor_dofs)
        return false;
    }

  // Look at all the variables in this system.  If every one is
  // discontinuous then the user must be doing DG/FVM, so be nice
  // and force implicit_neighbor_dofs=true.
  {
    bool all_discontinuous_dofs = true;

    for (auto var : make_range(this->n_variables()))
      if (FEInterface::get_continuity(this->variable_type(var)) !=  DISCONTINUOUS)
        all_discontinuous_dofs = false;

    if (all_discontinuous_dofs)
      implicit_neighbor_dofs = true;
  }

  return implicit_neighbor_dofs;
}

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

inline

返回

The variable group number that the provided variable number belongs to

在文件 dof_map.h 第 2347 行定义.

参考 _var_to_vg , 以及 n_variables().

参考自 should_p_refine_var().

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

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

inline

返回

The variable description object for variable c.

在文件 dof_map.h 第 2111 行定义.

参考 _variables.

参考自 distribute_dofs(), local_variable_indices() , 以及 SCALAR_dof_indices().

{
  libmesh_assert_less (c, _variables.size());

  return _variables[c];
}

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

inline

返回

The VariableGroup description object for group g.

在文件 dof_map.h 第 2101 行定义.

参考 _variable_groups.

参考自 _dof_indices(), _node_dof_indices(), distribute_local_dofs_node_major(), distribute_local_dofs_var_major(), distribute_scalar_dofs(), dof_indices(), old_dof_indices() , 以及 reinit().

{
  libmesh_assert_less (g, _variable_groups.size());

  return _variable_groups[g];
}

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

inline

返回

The approximation order for VariableGroup vg.

在文件 dof_map.h 第 2131 行定义.

参考 _variable_groups.

{
  libmesh_assert_less (vg, _variable_groups.size());

  return _variable_groups[vg].type().order;
}

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

inline

返回

The finite element type for VariableGroup vg.

在文件 dof_map.h 第 2151 行定义.

参考 _variable_groups.

{
  libmesh_assert_less (vg, _variable_groups.size());

  return _variable_groups[vg].type();
}

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

inline

返回

The approximation order for variable c.

在文件 dof_map.h 第 2121 行定义.

参考 _variables.

{
  libmesh_assert_less (c, _variables.size());

  return _variables[c].type().order;
}

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

inline

返回

The finite element type for variable c.

在文件 dof_map.h 第 2141 行定义.

参考 _variables.

参考自 constrain_p_dofs(), local_variable_indices(), process_mesh_constraint_rows() , 以及 use_coupled_neighbor_dofs().

{
  libmesh_assert_less (c, _variables.size());

  return _variables[c].type();
}

友元及相关函数文档

friend class SparsityPattern::Build

friend

在文件 dof_map.h 第 2067 行定义.

类成员变量说明

AdjointDofConstraintValues libMesh::DofMap::_adjoint_constraint_values

private

在文件 dof_map.h 第 2034 行定义.

参考自 add_adjoint_constraint_row(), allgather_recursive_constraints(), build_constraint_matrix_and_vector(), clear(), create_dof_constraints(), enforce_adjoint_constraints_exactly(), gather_constraints(), get_local_constraints(), has_heterogeneous_adjoint_constraint(), has_heterogeneous_adjoint_constraints(), heterogeneously_constrain_element_matrix_and_vector(), heterogeneously_constrain_element_vector(), process_constraints() , 以及 process_mesh_constraint_rows().

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

private

Data structure containing Dirichlet functions.

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

在文件 dof_map.h 第 2064 行定义.

参考自 add_adjoint_dirichlet_boundary(), create_dof_constraints(), get_adjoint_dirichlet_boundaries(), get_local_constraints(), has_adjoint_dirichlet_boundaries() , 以及 remove_adjoint_dirichlet_boundary().

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

private

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

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

在文件 dof_map.h 第 1951 行定义.

参考自 add_algebraic_ghosting_functor(), algebraic_ghosting_functors_begin(), algebraic_ghosting_functors_end(), clear(), distribute_dofs() , 以及 remove_algebraic_ghosting_functor().

AugmentSendList* libMesh::DofMap::_augment_send_list

private

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

在文件 dof_map.h 第 1915 行定义.

参考自 attach_extra_send_list_object() , 以及 prepare_send_list().

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

private

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

在文件 dof_map.h 第 1898 行定义.

参考自 attach_extra_sparsity_object() , 以及 build_sparsity().

bool libMesh::DofMap::_constrained_sparsity_construction

private

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

在文件 dof_map.h 第 1834 行定义.

参考自 compute_sparsity(), constrained_sparsity_construction() , 以及 set_constrained_sparsity_construction().

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

在文件 reference_counter.h 第 124 行定义.

参考自 libMesh::ReferenceCounter::get_info().

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

private

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

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

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

在文件 dof_map.h 第 1964 行定义.

参考自 add_coupling_functor(), build_sparsity(), clear(), coupling_functors_begin(), coupling_functors_end(), distribute_dofs() , 以及 remove_coupling_functor().

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

private

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

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

在文件 dof_map.h 第 1933 行定义.

参考自 clear(), default_coupling(), DofMap(), reinit() , 以及 ~DofMap().

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

private

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

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

在文件 dof_map.h 第 1941 行定义.

参考自 clear(), default_algebraic_ghosting(), DofMap() , 以及 ~DofMap().

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

private

Data structure containing Dirichlet functions.

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

在文件 dof_map.h 第 2058 行定义.

参考自 add_dirichlet_boundary(), create_dof_constraints(), get_dirichlet_boundaries() , 以及 remove_dirichlet_boundary().

DofConstraints libMesh::DofMap::_dof_constraints

private

Data structure containing DOF constraints.

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

在文件 dof_map.h 第 2030 行定义.

参考自 add_constraint_row(), add_constraints_to_send_list(), allgather_recursive_constraints(), build_constraint_matrix(), build_constraint_matrix_and_vector(), check_for_constraint_loops(), clear(), constrain_element_dyad_matrix(), constrain_element_matrix(), constrain_element_matrix_and_vector(), constrain_element_vector(), constrain_nothing(), constrain_p_dofs(), constraint_rows_begin(), constraint_rows_end(), create_dof_constraints(), enforce_adjoint_constraints_exactly(), enforce_constraints_exactly(), enforce_constraints_on_jacobian(), enforce_constraints_on_residual(), find_connected_dofs(), gather_constraints(), get_dof_constraints(), get_info(), get_local_constraints(), heterogeneously_constrain_element_matrix_and_vector(), heterogeneously_constrain_element_vector(), is_constrained_dof(), max_constraint_error(), n_local_constrained_dofs(), process_constraints(), process_mesh_constraint_rows(), scatter_constraints(), stash_dof_constraints(), swap_dof_constraints() , 以及 unstash_dof_constraints().

CouplingMatrix* libMesh::DofMap::_dof_coupling

Degree of freedom coupling.

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

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

在文件 dof_map.h 第 1589 行定义.

参考自 build_sparsity(), clear() , 以及 reinit().

std::unordered_set<unsigned int> libMesh::DofMap::_dont_p_refine

private

A container of variable groups that we should not p-refine.

在文件 dof_map.h 第 2022 行定义.

参考自 _dof_indices(), _node_dof_indices(), old_dof_indices(), reinit(), should_p_refine() , 以及 should_p_refine_var().

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

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

在文件 reference_counter.h 第 143 行定义.

参考自 libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info() , 以及 libMesh::ReferenceCounter::print_info().

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

private

Last DOF index (plus 1) on processor p.

在文件 dof_map.h 第 1881 行定义.

参考自 clear(), distribute_dofs(), dof_owner(), end_dof(), gather_constraints(), n_dofs_on_processor() , 以及 scatter_constraints().

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

private

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

在文件 dof_map.h 第 2011 行定义.

参考自 clear(), distribute_dofs() , 以及 end_old_dof().

bool libMesh::DofMap::_error_on_constraint_loop

private

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

cases where the constraint graph is cyclic.

在文件 dof_map.h 第 1828 行定义.

参考自 process_constraints() , 以及 set_error_on_constraint_loop().

void* libMesh::DofMap::_extra_send_list_context

private

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

在文件 dof_map.h 第 1925 行定义.

参考自 attach_extra_send_list_function() , 以及 prepare_send_list().

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

private

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

在文件 dof_map.h 第 1920 行定义.

参考自 attach_extra_send_list_function() , 以及 prepare_send_list().

void* libMesh::DofMap::_extra_sparsity_context

private

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

在文件 dof_map.h 第 1910 行定义.

参考自 attach_extra_sparsity_function() , 以及 build_sparsity().

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

private

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

在文件 dof_map.h 第 1903 行定义.

参考自 attach_extra_sparsity_function() , 以及 build_sparsity().

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

private

First DOF index on processor p.

在文件 dof_map.h 第 1876 行定义.

参考自 clear(), distribute_dofs(), first_dof() , 以及 n_dofs_on_processor().

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

private

First old DOF index on processor p.

在文件 dof_map.h 第 2006 行定义.

参考自 clear(), distribute_dofs() , 以及 first_old_dof().

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

private

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

在文件 dof_map.h 第 2017 行定义.

参考自 clear(), distribute_dofs() , 以及 SCALAR_dof_indices().

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

private

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

在文件 dof_map.h 第 1887 行定义.

参考自 clear(), distribute_dofs() , 以及 SCALAR_dof_indices().

bool libMesh::DofMap::_implicit_neighbor_dofs

private

在文件 dof_map.h 第 2074 行定义.

参考自 set_implicit_neighbor_dofs() , 以及 use_coupled_neighbor_dofs().

bool libMesh::DofMap::_implicit_neighbor_dofs_initialized

private

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

在文件 dof_map.h 第 2073 行定义.

参考自 set_implicit_neighbor_dofs() , 以及 use_coupled_neighbor_dofs().

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

private

Additional matrices handled by this object.

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

在文件 dof_map.h 第 1871 行定义.

参考自 attach_matrix(), clear(), compute_sparsity(), DofMap(), get_info() , 以及 is_attached().

MeshBase& libMesh::DofMap::_mesh

private

The mesh that system uses.

在文件 dof_map.h 第 1864 行定义.

参考自 add_algebraic_ghosting_functor(), add_coupling_functor(), clear(), DofMap(), remove_algebraic_ghosting_functor(), remove_coupling_functor() , 以及 ~DofMap().

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

在文件 reference_counter.h 第 137 行定义.

dof_id_type libMesh::DofMap::_n_dfs

private

Total number of degrees of freedom.

在文件 dof_map.h 第 1988 行定义.

参考自 clear(), distribute_dofs() , 以及 n_dofs().

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

staticprotectedinherited

The number of objects.

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

在文件 reference_counter.h 第 132 行定义.

参考自 libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter() , 以及 libMesh::ReferenceCounter::~ReferenceCounter().

dof_id_type libMesh::DofMap::_n_old_dfs

private

Total number of degrees of freedom on old dof objects.

在文件 dof_map.h 第 2001 行定义.

参考自 clear(), distribute_dofs() , 以及 n_old_dofs().

dof_id_type libMesh::DofMap::_n_SCALAR_dofs

private

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

在文件 dof_map.h 第 1994 行定义.

参考自 distribute_scalar_dofs(), n_SCALAR_dofs() , 以及 reinit().

NodeConstraints libMesh::DofMap::_node_constraints

private

Data structure containing DofObject constraints.

在文件 dof_map.h 第 2041 行定义.

参考自 allgather_recursive_constraints(), create_dof_constraints(), get_info(), get_local_constraints(), is_constrained_node(), n_constrained_nodes(), node_constraint_rows_begin(), node_constraint_rows_end() , 以及 scatter_constraints().

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

private

Data structure containing periodic boundaries.

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

在文件 dof_map.h 第 2050 行定义.

参考自 add_periodic_boundary(), create_dof_constraints(), DofMap(), get_periodic_boundaries(), is_periodic_boundary() , 以及 process_mesh_constraint_rows().

DofConstraintValueMap libMesh::DofMap::_primal_constraint_values

private

在文件 dof_map.h 第 2032 行定义.

参考自 add_constraint_row(), allgather_recursive_constraints(), build_constraint_matrix_and_vector(), clear(), constrain_p_dofs(), create_dof_constraints(), enforce_constraints_exactly(), enforce_constraints_on_residual(), gather_constraints(), get_info(), get_local_constraints(), get_primal_constraint_values(), heterogeneously_constrain_element_matrix_and_vector(), heterogeneously_constrain_element_vector(), max_constraint_error(), process_constraints(), process_mesh_constraint_rows() , 以及 scatter_constraints().

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

private

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

在文件 dof_map.h 第 1893 行定义.

参考自 add_constraints_to_send_list(), add_neighbors_to_send_list(), clear_send_list(), get_send_list(), prepare_send_list() , 以及 semilocal_index().

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

private

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

在文件 dof_map.h 第 1970 行定义.

参考自 add_algebraic_ghosting_functor(), add_coupling_functor(), clear(), remove_algebraic_ghosting_functor() , 以及 remove_coupling_functor().

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

private

The sparsity pattern of the global matrix.

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

在文件 dof_map.h 第 1983 行定义.

参考自 clear_sparsity(), compute_sparsity(), computed_sparsity_already(), get_info(), get_n_nz(), get_n_oz(), get_sparsity_pattern() , 以及 update_sparsity_pattern().

DofConstraints libMesh::DofMap::_stashed_dof_constraints

private

在文件 dof_map.h 第 2030 行定义.

参考自 clear(), stash_dof_constraints(), swap_dof_constraints() , 以及 unstash_dof_constraints().

const unsigned int libMesh::DofMap::_sys_number

private

The number of the system we manage DOFs for.

在文件 dof_map.h 第 1859 行定义.

参考自 sys_number().

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

private

A map from variable number to variable group number.

在文件 dof_map.h 第 1854 行定义.

参考自 add_variable_group(), clear() , 以及 var_group_from_var_number().

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

private

The variable group number for each variable.

在文件 dof_map.h 第 1849 行定义.

参考自 add_variable_group(), clear() , 以及 dof_indices().

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

private

The finite element type for each variable group.

在文件 dof_map.h 第 1844 行定义.

参考自 add_variable_group(), clear(), n_variable_groups(), variable_group(), variable_group_order() , 以及 variable_group_type().

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

private

The finite element type for each variable.

在文件 dof_map.h 第 1839 行定义.

参考自 add_variable_group(), clear(), n_variables(), variable(), variable_order() , 以及 variable_type().

bool libMesh::DofMap::_verify_dirichlet_bc_consistency

private

Flag which determines whether we should do some additional checking of the consistency of the DirichletBoundary objects added by the user.

Defaults to true, but can be disabled in cases where you only want to add DirichletBoundary objects "locally" and can guarantee that no repartitioning will be done, since repartitioning could cause processors to own new boundary sides for which they no longer have the proper DirichletBoundary objects stored.

在文件 dof_map.h 第 2086 行定义.

参考自 create_dof_constraints() , 以及 set_verify_dirichlet_bc_consistency().

bool libMesh::DofMap::need_full_sparsity_pattern

private

Default false; set to true if any attached matrix requires a full sparsity pattern.

在文件 dof_map.h 第 1976 行定义.

参考自 attach_matrix(), build_sparsity(), clear(), compute_sparsity() , 以及 update_sparsity_pattern().

---

该类的文档由以下文件生成:

• /home/lwz/libmesh/include/base/dof_map.h
• /home/lwz/libmesh/src/base/dof_map.C
• /home/lwz/libmesh/src/base/dof_map_constraints.C