mg_tools.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2005 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.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

template <int dim, int spacedim>
class DoFHandler;
class MGConstrainedDoFs;

/* !@addtogroup mg */
/* @{ */

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 <typename DoFHandlerType, typename SparsityPatternType>
  void
  make_sparsity_pattern(const DoFHandlerType &dof_handler,
                        SparsityPatternType & sparsity,
                        const unsigned int    level);

  template <int dim, typename SparsityPatternType, int spacedim>
  void
  make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_handler,
                             SparsityPatternType &            sparsity,
                             const unsigned int               level);

  template <int dim, typename SparsityPatternType, int spacedim>
  void
  make_flux_sparsity_pattern_edge(const DoFHandler<dim, spacedim> &dof_handler,
                                  SparsityPatternType &            sparsity,
                                  const unsigned int               level);
  template <int dim, typename SparsityPatternType, int spacedim>
  void
  make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &   dof,
                             SparsityPatternType &               sparsity,
                             const unsigned int                  level,
                             const Table<2, DoFTools::Coupling> &int_mask,
                             const Table<2, DoFTools::Coupling> &flux_mask);

  template <int dim, typename SparsityPatternType, int spacedim>
  void
  make_flux_sparsity_pattern_edge(
    const DoFHandler<dim, spacedim> &   dof_handler,
    SparsityPatternType &               sparsity,
    const unsigned int                  level,
    const Table<2, DoFTools::Coupling> &flux_mask);


  template <typename DoFHandlerType, typename SparsityPatternType>
  void
  make_interface_sparsity_pattern(const DoFHandlerType &   dof_handler,
                                  const MGConstrainedDoFs &mg_constrained_dofs,
                                  SparsityPatternType &    sparsity,
                                  const unsigned int       level);


  template <typename DoFHandlerType>
  void
  count_dofs_per_block(
    const DoFHandlerType &                             dof_handler,
    std::vector<std::vector<types::global_dof_index>> &dofs_per_block,
    std::vector<unsigned int> target_block = std::vector<unsigned int>());

  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 = std::vector<unsigned int>());

  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 = ComponentMask());

  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 = ComponentMask());

  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 = ComponentMask());

  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>
  void
  extract_non_interface_dofs(
    const DoFHandler<dim, spacedim> &               mg_dof_handler,
    std::vector<std::set<types::global_dof_index>> &non_interface_dofs);

  template <int dim, int spacedim>
  unsigned int
  max_level_for_coarse_mesh(const Triangulation<dim, spacedim> &tria);
} // namespace MGTools

/* @} */

DEAL_II_NAMESPACE_CLOSE

#endif