mg_transfer.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 2001 - 2026 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef dealii_mg_transfer_h
#define dealii_mg_transfer_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/mg_level_object.h>
 
#include <deal.II/distributed/tria_base.h>
 
#include <deal.II/dofs/dof_handler.h>
 
#include <deal.II/lac/affine_constraints.h>
#include <deal.II/lac/block_sparsity_pattern.h>
#include <deal.II/lac/block_vector.h>
#include <deal.II/lac/la_parallel_vector.h>
#include <deal.II/lac/petsc_sparse_matrix.h>
#include <deal.II/lac/petsc_vector.h>
#include <deal.II/lac/sparse_matrix.h>
#include <deal.II/lac/trilinos_sparse_matrix.h>
#include <deal.II/lac/trilinos_tpetra_sparse_matrix.h>
#include <deal.II/lac/vector_memory.h>
 
#include <deal.II/multigrid/mg_base.h>
#include <deal.II/multigrid/mg_constrained_dofs.h>
 
#include <memory>
 
 
DEAL_II_NAMESPACE_OPEN
 
 
namespace internal
{
  template <typename VectorType>
  struct MatrixSelector
  {
    using Sparsity = ::SparsityPattern;
    using Matrix   = ::SparseMatrix<typename VectorType::value_type>;
 
    static const bool requires_distributed_sparsity_pattern = false;
 
    template <typename SparsityPatternType, int dim, int spacedim>
    static void
    reinit(Matrix                    &matrix,
           Sparsity                  &sparsity,
           int                        level,
           const SparsityPatternType &sp,
           const DoFHandler<dim, spacedim> &)
    {
      sparsity.copy_from(sp);
      (void)level;
      matrix.reinit(sparsity);
    }
  };
 
#ifdef DEAL_II_WITH_TRILINOS
#  ifdef DEAL_II_TRILINOS_WITH_EPETRA
  template <typename Number>
  struct MatrixSelector<LinearAlgebra::distributed::Vector<Number>>
  {
    using Sparsity = ::TrilinosWrappers::SparsityPattern;
    using Matrix   = ::TrilinosWrappers::SparseMatrix;
 
    static const bool requires_distributed_sparsity_pattern = false;
 
    template <typename SparsityPatternType, int dim, int spacedim>
    static void
    reinit(Matrix &matrix,
           Sparsity &,
           int                              level,
           const SparsityPatternType       &sp,
           const DoFHandler<dim, spacedim> &dh)
    {
      const MPI_Comm communicator = dh.get_mpi_communicator();
 
      matrix.reinit(dh.locally_owned_mg_dofs(level + 1),
                    dh.locally_owned_mg_dofs(level),
                    sp,
                    communicator,
                    true);
    }
  };
 
  template <>
  struct MatrixSelector<::TrilinosWrappers::MPI::Vector>
  {
    using Sparsity = ::TrilinosWrappers::SparsityPattern;
    using Matrix   = ::TrilinosWrappers::SparseMatrix;
 
    static const bool requires_distributed_sparsity_pattern = false;
 
    template <typename SparsityPatternType, int dim, int spacedim>
    static void
    reinit(Matrix &matrix,
           Sparsity &,
           int                              level,
           const SparsityPatternType       &sp,
           const DoFHandler<dim, spacedim> &dh)
    {
      const MPI_Comm communicator = dh.get_mpi_communicator();
 
      matrix.reinit(dh.locally_owned_mg_dofs(level + 1),
                    dh.locally_owned_mg_dofs(level),
                    sp,
                    communicator,
                    true);
    }
  };
#  endif
 
#  ifdef DEAL_II_WITH_MPI
#    ifdef DEAL_II_TRILINOS_WITH_TPETRA
  template <typename Number, typename MemorySpace>
  struct MatrixSelector<
    ::LinearAlgebra::TpetraWrappers::Vector<Number, MemorySpace>>
  {
    using Sparsity =
      ::LinearAlgebra::TpetraWrappers::SparsityPattern<MemorySpace>;
    using Matrix =
      ::LinearAlgebra::TpetraWrappers::SparseMatrix<Number,
                                                            MemorySpace>;
 
    static const bool requires_distributed_sparsity_pattern = false;
 
    template <typename SparsityPatternType, int dim, int spacedim>
    static void
    reinit(Matrix &matrix,
           Sparsity &,
           int                              level,
           const SparsityPatternType       &sp,
           const DoFHandler<dim, spacedim> &dh)
    {
      const MPI_Comm communicator = dh.get_mpi_communicator();
 
      matrix.reinit(dh.locally_owned_mg_dofs(level + 1),
                    dh.locally_owned_mg_dofs(level),
                    sp,
                    communicator,
                    true);
    }
  };
#    endif
 
#    ifdef DEAL_II_TRILINOS_WITH_EPETRA
  template <>
  struct MatrixSelector<::LinearAlgebra::EpetraWrappers::Vector>
  {
    using Sparsity = ::TrilinosWrappers::SparsityPattern;
    using Matrix   = ::TrilinosWrappers::SparseMatrix;
 
    static const bool requires_distributed_sparsity_pattern = false;
 
    template <typename SparsityPatternType, int dim, int spacedim>
    static void
    reinit(Matrix &matrix,
           Sparsity &,
           int                              level,
           const SparsityPatternType       &sp,
           const DoFHandler<dim, spacedim> &dh)
    {
      const MPI_Comm communicator = dh.get_mpi_communicator();
 
      matrix.reinit(dh.locally_owned_mg_dofs(level + 1),
                    dh.locally_owned_mg_dofs(level),
                    sp,
                    communicator,
                    true);
    }
  };
#    endif
#  endif
 
#else
  // ! DEAL_II_WITH_TRILINOS
  template <typename Number>
  struct MatrixSelector<LinearAlgebra::distributed::Vector<Number>>
  {
    using Sparsity = ::SparsityPattern;
    using Matrix   = ::SparseMatrix<Number>;
 
    static const bool requires_distributed_sparsity_pattern = false;
 
    template <typename SparsityPatternType, int dim, int spacedim>
    static void
    reinit(Matrix &,
           Sparsity &,
           int,
           const SparsityPatternType &,
           const DoFHandler<dim, spacedim> &)
    {
      AssertThrow(
        false,
        ExcNotImplemented(
          "ERROR: MGTransferPrebuilt with LinearAlgebra::distributed::Vector currently "
          "needs deal.II to be configured with Trilinos."));
    }
  };
 
#endif
 
#ifdef DEAL_II_WITH_PETSC
  template <>
  struct MatrixSelector<::PETScWrappers::MPI::Vector>
  {
    using Sparsity = ::DynamicSparsityPattern;
    using Matrix   = ::PETScWrappers::MPI::SparseMatrix;
 
    static const bool requires_distributed_sparsity_pattern = true;
 
    template <typename SparsityPatternType, int dim, int spacedim>
    static void
    reinit(Matrix &matrix,
           Sparsity &,
           int                              level,
           const SparsityPatternType       &sp,
           const DoFHandler<dim, spacedim> &dh)
    {
      const MPI_Comm communicator = dh.get_mpi_communicator();
 
      // Reinit PETSc matrix
      matrix.reinit(dh.locally_owned_mg_dofs(level + 1),
                    dh.locally_owned_mg_dofs(level),
                    sp,
                    communicator);
    }
  };
#endif
} // namespace internal
 
/*
 * MGTransferBase is defined in mg_base.h
 */
 
template <typename VectorType>
class MGLevelGlobalTransfer : public MGTransferBase<VectorType>
{
public:
  void
  clear();
 
  template <int dim, class InVector, int spacedim>
  void
  copy_to_mg(const DoFHandler<dim, spacedim> &dof_handler,
             MGLevelObject<VectorType>       &dst,
             const InVector                  &src) const;
 
  template <int dim, class OutVector, int spacedim>
  void
  copy_from_mg(const DoFHandler<dim, spacedim> &dof_handler,
               OutVector                       &dst,
               const MGLevelObject<VectorType> &src) const;
 
  template <int dim, class OutVector, int spacedim>
  void
  copy_from_mg_add(const DoFHandler<dim, spacedim> &dof_handler,
                   OutVector                       &dst,
                   const MGLevelObject<VectorType> &src) const;
 
  void
  set_component_to_block_map(const std::vector<unsigned int> &map);
 
  std::size_t
  memory_consumption() const;
 
  void
  print_indices(std::ostream &os) const;
 
protected:
  template <int dim, int spacedim>
  void
  fill_and_communicate_copy_indices(
    const DoFHandler<dim, spacedim> &dof_handler);
 
  std::vector<types::global_dof_index> sizes;
 
  std::vector<
    std::vector<std::pair<types::global_dof_index, types::global_dof_index>>>
    copy_indices;
 
  std::vector<
    std::vector<std::pair<types::global_dof_index, types::global_dof_index>>>
    copy_indices_global_mine;
 
  std::vector<
    std::vector<std::pair<types::global_dof_index, types::global_dof_index>>>
    copy_indices_level_mine;
 
  bool perform_plain_copy;
 
  std::vector<unsigned int> component_to_block_map;
 
  ObserverPointer<const MGConstrainedDoFs> mg_constrained_dofs;
 
private:
  template <int dim, int spacedim>
  void
  assert_built(const DoFHandler<dim, spacedim> &dof_handler) const;
};
 
 
 
template <typename Number, typename MemorySpace>
class MGLevelGlobalTransfer<
  LinearAlgebra::distributed::Vector<Number, MemorySpace>>
  : public MGTransferBase<
      LinearAlgebra::distributed::Vector<Number, MemorySpace>>
{
public:
  void
  clear();
 
  template <int dim, typename Number2, int spacedim>
  void
  copy_to_mg(
    const DoFHandler<dim, spacedim> &dof_handler,
    MGLevelObject<LinearAlgebra::distributed::Vector<Number, MemorySpace>> &dst,
    const LinearAlgebra::distributed::Vector<Number2, MemorySpace> &src) const;
 
  template <int dim, typename Number2, int spacedim>
  void
  copy_from_mg(
    const DoFHandler<dim, spacedim>                          &dof_handler,
    LinearAlgebra::distributed::Vector<Number2, MemorySpace> &dst,
    const MGLevelObject<LinearAlgebra::distributed::Vector<Number, MemorySpace>>
      &src) const;
 
  template <int dim, typename Number2, int spacedim>
  void
  copy_from_mg_add(
    const DoFHandler<dim, spacedim>                          &dof_handler,
    LinearAlgebra::distributed::Vector<Number2, MemorySpace> &dst,
    const MGLevelObject<LinearAlgebra::distributed::Vector<Number, MemorySpace>>
      &src) const;
 
  void
  set_component_to_block_map(const std::vector<unsigned int> &map);
 
  std::size_t
  memory_consumption() const;
 
  void
  print_indices(std::ostream &os) const;
 
protected:
  template <int dim, typename Number2, int spacedim>
  void
  copy_to_mg(
    const DoFHandler<dim, spacedim> &dof_handler,
    MGLevelObject<LinearAlgebra::distributed::Vector<Number, MemorySpace>> &dst,
    const LinearAlgebra::distributed::Vector<Number2, MemorySpace>         &src,
    const bool solution_transfer) const;
 
  template <int dim, int spacedim>
  void
  fill_and_communicate_copy_indices(
    const DoFHandler<dim, spacedim> &dof_handler);
 
  std::vector<types::global_dof_index> sizes;
 
  std::vector<Table<2, unsigned int>> copy_indices;
 
  std::vector<Table<2, unsigned int>> solution_copy_indices;
 
  std::vector<Table<2, unsigned int>> copy_indices_global_mine;
 
  std::vector<Table<2, unsigned int>> copy_indices_level_mine;
 
  std::vector<Table<2, unsigned int>> solution_copy_indices_level_mine;
 
  bool perform_plain_copy;
 
  bool perform_renumbered_plain_copy;
 
  std::vector<unsigned int> component_to_block_map;
 
  ObserverPointer<const MGConstrainedDoFs> mg_constrained_dofs;
 
  mutable LinearAlgebra::distributed::Vector<Number, MemorySpace>
    ghosted_global_vector;
 
  mutable LinearAlgebra::distributed::Vector<Number, MemorySpace>
    solution_ghosted_global_vector;
 
  mutable MGLevelObject<LinearAlgebra::distributed::Vector<Number, MemorySpace>>
    ghosted_level_vector;
 
  std::function<void(const unsigned int,
                     LinearAlgebra::distributed::Vector<Number, MemorySpace> &)>
    initialize_dof_vector;
 
private:
  template <int dim, int spacedim>
  void
  assert_built(const DoFHandler<dim, spacedim> &dof_handler) const;
};
 
 
 
template <typename VectorType>
class MGTransferPrebuilt : public MGLevelGlobalTransfer<VectorType>
{
public:
  MGTransferPrebuilt() = default;
 
  MGTransferPrebuilt(const MGConstrainedDoFs &mg_constrained_dofs);
 
  virtual ~MGTransferPrebuilt() override = default;
 
  void
  initialize_constraints(const MGConstrainedDoFs &mg_constrained_dofs);
 
  void
  clear();
 
  template <int dim, int spacedim>
  void
  build(const DoFHandler<dim, spacedim> &dof_handler);
 
  virtual void
  prolongate(const unsigned int to_level,
             VectorType        &dst,
             const VectorType  &src) const override;
 
  virtual void
  restrict_and_add(const unsigned int from_level,
                   VectorType        &dst,
                   const VectorType  &src) const override;
 
  DeclException0(ExcNoProlongation);
 
  DeclException0(ExcMatricesNotBuilt);
 
  std::size_t
  memory_consumption() const;
 
  void
  print_matrices(std::ostream &os) const;
 
private:
  std::vector<
    std::shared_ptr<typename internal::MatrixSelector<VectorType>::Sparsity>>
    prolongation_sparsities;
 
  std::vector<
    std::shared_ptr<typename internal::MatrixSelector<VectorType>::Matrix>>
    prolongation_matrices;
 
  std::vector<std::vector<bool>> interface_dofs;
};
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif