mg_tools.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2005 - 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_tools_h
#define dealii_mg_tools_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/index_set.h>
 
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_tools.h>
 
#include <set>
#include <vector>
 
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declarations
#ifndef DOXYGEN
template <int dim, int spacedim>
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
class DoFHandler;
class MGConstrainedDoFs;
#endif
 
namespace MGTools
{
  template <int dim, int spacedim>
  void
  compute_row_length_vector(
    const DoFHandler<dim, spacedim> &dofs,
    const unsigned int               level,
    std::vector<unsigned int>       &row_lengths,
    const DoFTools::Coupling         flux_couplings = DoFTools::none);
 
  template <int dim, int spacedim>
  void
  compute_row_length_vector(const DoFHandler<dim, spacedim>    &dofs,
                            const unsigned int                  level,
                            std::vector<unsigned int>          &row_lengths,
                            const Table<2, DoFTools::Coupling> &couplings,
                            const Table<2, DoFTools::Coupling> &flux_couplings);
 
  template <int dim, int spacedim, typename number = double>
  void
  make_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_handler,
                        SparsityPatternBase             &sparsity,
                        const unsigned int               level,
                        const AffineConstraints<number> &constraints = {},
                        const bool keep_constrained_dofs             = true);
 
  template <int dim, int spacedim, typename number = double>
  void
  make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_handler,
                             SparsityPatternBase             &sparsity,
                             const unsigned int               level,
                             const AffineConstraints<number> &constraints = {},
                             const bool keep_constrained_dofs = true);
 
 
  template <int dim, int spacedim>
  void
  make_flux_sparsity_pattern_edge(const DoFHandler<dim, spacedim> &dof_handler,
                                  SparsityPatternBase             &sparsity,
                                  const unsigned int               level);
  template <int dim, int spacedim>
  void
  make_flux_sparsity_pattern(const DoFHandler<dim, spacedim>    &dof,
                             SparsityPatternBase                &sparsity,
                             const unsigned int                  level,
                             const Table<2, DoFTools::Coupling> &int_mask,
                             const Table<2, DoFTools::Coupling> &flux_mask);
 
  template <int dim, int spacedim>
  void
  make_flux_sparsity_pattern_edge(
    const DoFHandler<dim, spacedim>    &dof_handler,
    SparsityPatternBase                &sparsity,
    const unsigned int                  level,
    const Table<2, DoFTools::Coupling> &flux_mask);
 
 
  template <int dim, int spacedim>
  void
  make_interface_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_handler,
                                  const MGConstrainedDoFs &mg_constrained_dofs,
                                  SparsityPatternBase     &sparsity,
                                  const unsigned int       level);
 
 
  template <int dim, int spacedim>
  void
  count_dofs_per_block(
    const DoFHandler<dim, spacedim>                   &dof_handler,
    std::vector<std::vector<types::global_dof_index>> &dofs_per_block,
    std::vector<unsigned int>                          target_block = {});
 
  template <int dim, int spacedim>
  void
  count_dofs_per_component(
    const DoFHandler<dim, spacedim>                   &mg_dof,
    std::vector<std::vector<types::global_dof_index>> &result,
    const bool                                         only_once        = false,
    std::vector<unsigned int>                          target_component = {});
 
  template <int dim, int spacedim>
  void
  make_boundary_list(
    const DoFHandler<dim, spacedim> &mg_dof,
    const std::map<types::boundary_id, const Function<spacedim> *>
                                                   &function_map,
    std::vector<std::set<types::global_dof_index>> &boundary_indices,
    const ComponentMask                            &component_mask = {});
 
  template <int dim, int spacedim>
  void
  make_boundary_list(const DoFHandler<dim, spacedim>            &mg_dof,
                     const std::map<types::boundary_id,
                                    const Function<spacedim> *> &function_map,
                     std::vector<IndexSet> &boundary_indices,
                     const ComponentMask   &component_mask = {});
 
  template <int dim, int spacedim>
  void
  make_boundary_list(const DoFHandler<dim, spacedim>    &mg_dof,
                     const std::set<types::boundary_id> &boundary_ids,
                     std::vector<IndexSet>              &boundary_indices,
                     const ComponentMask                &component_mask = {});
 
  template <int dim, int spacedim>
  void
  extract_inner_interface_dofs(const DoFHandler<dim, spacedim> &mg_dof_handler,
                               std::vector<IndexSet>           &interface_dofs);
 
  template <int dim, int spacedim>
  unsigned int
  max_level_for_coarse_mesh(const Triangulation<dim, spacedim> &tria);
 
  template <int dim, int spacedim>
  std::vector<types::global_dof_index>
  local_workload(const Triangulation<dim, spacedim> &tria);
 
  template <int dim, int spacedim>
  std::vector<types::global_dof_index>
  local_workload(
    const std::vector<std::shared_ptr<const Triangulation<dim, spacedim>>>
      &trias);
 
  template <int dim, int spacedim>
  double
  workload_imbalance(const Triangulation<dim, spacedim> &tria);
 
  template <int dim, int spacedim>
  double
  workload_imbalance(
    const std::vector<std::shared_ptr<const Triangulation<dim, spacedim>>>
      &trias);
 
  template <int dim, int spacedim>
  std::vector<std::pair<types::global_dof_index, types::global_dof_index>>
  local_vertical_communication_cost(const Triangulation<dim, spacedim> &tria);
 
  template <int dim, int spacedim>
  std::vector<std::pair<types::global_dof_index, types::global_dof_index>>
  local_vertical_communication_cost(
    const std::vector<std::shared_ptr<const Triangulation<dim, spacedim>>>
      &trias);
 
  template <int dim, int spacedim>
  double
  vertical_communication_efficiency(const Triangulation<dim, spacedim> &tria);
 
  template <int dim, int spacedim>
  double
  vertical_communication_efficiency(
    const std::vector<std::shared_ptr<const Triangulation<dim, spacedim>>>
      &trias);
 
 
} // namespace MGTools
 
DEAL_II_NAMESPACE_CLOSE
 
#endif