mg_constrained_dofs.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2010 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_mg_constrained_dofs_h
#define dealii_mg_constrained_dofs_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/mg_level_object.h>
#include <deal.II/base/subscriptor.h>
 
#include <deal.II/lac/affine_constraints.h>
 
#include <set>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declaration
#ifndef DOXYGEN
template <int dim, int spacedim>
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
class DoFHandler;
#endif
 
 
class MGConstrainedDoFs : public Subscriptor
{
public:
  using size_dof = std::vector<std::set<types::global_dof_index>>::size_type;
  template <int dim, int spacedim>
  void
  initialize(const DoFHandler<dim, spacedim> &dof,
             const MGLevelObject<IndexSet>   &level_relevant_dofs =
               MGLevelObject<IndexSet>());
 
  template <int dim, int spacedim>
  void
  make_zero_boundary_constraints(
    const DoFHandler<dim, spacedim>    &dof,
    const std::set<types::boundary_id> &boundary_ids,
    const ComponentMask                &component_mask = {});
 
  template <int dim, int spacedim>
  void
  add_boundary_indices(const DoFHandler<dim, spacedim> &dof,
                       const unsigned int               level,
                       const IndexSet                  &boundary_indices);
 
  void
  add_user_constraints(const unsigned int               level,
                       const AffineConstraints<double> &constraints_on_level);
 
  template <int dim, int spacedim>
  void
  make_no_normal_flux_constraints(const DoFHandler<dim, spacedim> &dof,
                                  const types::boundary_id         bid,
                                  const unsigned int first_vector_component);
 
  void
  clear_user_constraints();
 
  void
  clear();
 
  bool
  is_boundary_index(const unsigned int            level,
                    const types::global_dof_index index) const;
 
  bool
  at_refinement_edge(const unsigned int            level,
                     const types::global_dof_index index) const;
 
 
  bool
  is_interface_matrix_entry(const unsigned int            level,
                            const types::global_dof_index i,
                            const types::global_dof_index j) const;
 
  const IndexSet &
  get_boundary_indices(const unsigned int level) const;
 
 
  const IndexSet &
  get_refinement_edge_indices(unsigned int level) const;
 
 
  bool
  have_boundary_indices() const;
 
  const AffineConstraints<double> &
  get_level_constraints(const unsigned int level) const;
 
  const AffineConstraints<double> &
  get_user_constraint_matrix(const unsigned int level) const;
 
  template <typename Number>
  void
  merge_constraints(AffineConstraints<Number> &constraints,
                    const unsigned int         level,
                    const bool                 add_boundary_indices,
                    const bool                 add_refinement_edge_indices,
                    const bool                 add_level_constraints,
                    const bool                 add_user_constraints) const;
 
private:
  std::vector<IndexSet> boundary_indices;
 
  std::vector<IndexSet> refinement_edge_indices;
 
  std::vector<AffineConstraints<double>> level_constraints;
 
  std::vector<AffineConstraints<double>> user_constraints;
};
 
 
 
inline bool
MGConstrainedDoFs::is_boundary_index(const unsigned int            level,
                                     const types::global_dof_index index) const
{
  if (boundary_indices.empty())
    return false;
 
  AssertIndexRange(level, boundary_indices.size());
  return boundary_indices[level].is_element(index);
}
 
 
 
inline bool
MGConstrainedDoFs::at_refinement_edge(const unsigned int            level,
                                      const types::global_dof_index index) const
{
  AssertIndexRange(level, refinement_edge_indices.size());
 
  return refinement_edge_indices[level].is_element(index);
}
 
 
 
inline bool
MGConstrainedDoFs::is_interface_matrix_entry(
  const unsigned int            level,
  const types::global_dof_index i,
  const types::global_dof_index j) const
{
  const IndexSet &interface_dofs_on_level =
    this->get_refinement_edge_indices(level);
 
  return interface_dofs_on_level.is_element(i)     // at_refinement_edge(i)
         && !interface_dofs_on_level.is_element(j) // !at_refinement_edge(j)
         && !this->is_boundary_index(level, i)     // !on_boundary(i)
         && !this->is_boundary_index(level, j);    // !on_boundary(j)
}
 
 
 
inline const IndexSet &
MGConstrainedDoFs::get_boundary_indices(const unsigned int level) const
{
  AssertIndexRange(level, boundary_indices.size());
  return boundary_indices[level];
}
 
 
 
inline const IndexSet &
MGConstrainedDoFs::get_refinement_edge_indices(unsigned int level) const
{
  AssertIndexRange(level, refinement_edge_indices.size());
  return refinement_edge_indices[level];
}
 
 
 
inline bool
MGConstrainedDoFs::have_boundary_indices() const
{
  return boundary_indices.size() != 0;
}
 
 
 
inline const AffineConstraints<double> &
MGConstrainedDoFs::get_level_constraints(const unsigned int level) const
{
  AssertIndexRange(level, level_constraints.size());
  return level_constraints[level];
}
 
 
 
inline const AffineConstraints<double> &
MGConstrainedDoFs::get_user_constraint_matrix(const unsigned int level) const
{
  AssertIndexRange(level, user_constraints.size());
  return user_constraints[level];
}
 
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif