portable_mg_transfer_global_coarsening.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2026 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_portable_mg_transfer_global_coarsening_h
#define dealii_portable_mg_transfer_global_coarsening_h
 
#include <deal.II/base/memory_space.h>
#include <deal.II/base/mpi_remote_point_evaluation.h>
 
#include <deal.II/dofs/dof_handler.h>
 
#include <deal.II/lac/affine_constraints.h>
#include <deal.II/lac/la_parallel_vector.h>
 
#include <deal.II/matrix_free/constraint_info.h>
#include <deal.II/matrix_free/portable_matrix_free.h>
#include <deal.II/matrix_free/shape_info.h>
 
#include <deal.II/multigrid/mg_base.h>
#include <deal.II/multigrid/mg_transfer_matrix_free.h>
 
DEAL_II_NAMESPACE_OPEN
 
namespace Portable
{
 
  // Forward declarations
#ifndef DOXYGEN
  namespace internal
  {
    template <typename Number>
    struct MGTransferSharedData;
 
  } // namespace internal
 
#endif
 
  template <int dim, typename VectorType>
  class MGTwoLevelTransfer
    : public ::internal::MGTwoLevelTransferCore<dim, VectorType>
  {
  public:
    static_assert(
      std::is_same_v<
        VectorType,
        LinearAlgebra::distributed::Vector<typename VectorType::value_type,
                                           MemorySpace::Default>>,
      "This class is currently only implemented for vectors of "
      "type LinearAlgebra::distributed::Vector.");
 
    using Number = typename VectorType::value_type;
 
    void
    reinit_geometric_transfer(
      const DoFHandler<dim>           &dof_handler_fine,
      const DoFHandler<dim>           &dof_handler_coarse,
      const AffineConstraints<Number> &constraint_fine =
        AffineConstraints<Number>(),
      const AffineConstraints<Number> &constraint_coarse =
        AffineConstraints<Number>(),
      const unsigned int mg_level_fine   = numbers::invalid_unsigned_int,
      const unsigned int mg_level_coarse = numbers::invalid_unsigned_int);
 
    void
    interpolate(VectorType &dst, const VectorType &src) const override;
 
    std::pair<bool, bool>
    enable_inplace_operations_if_possible(
      const std::shared_ptr<const Utilities::MPI::Partitioner>
        &partitioner_coarse,
      const std::shared_ptr<const Utilities::MPI::Partitioner>
        &partitioner_fine) override;
 
    std::size_t
    memory_consumption() const override;
 
    std::pair<const DoFHandler<dim> *, unsigned int>
    get_dof_handler_fine() const override;
 
    struct MGTransferScheme
    {
      unsigned int n_coarse_cells;
 
      unsigned int n_dofs_per_cell_coarse;
 
      unsigned int n_dofs_per_cell_fine;
 
      unsigned int degree_coarse;
 
      unsigned int degree_fine;
 
      Kokkos::View<Number *, MemorySpace::Default::kokkos_space>
        prolongation_matrix;
 
      bool use_constraint_crs = false;
 
      Kokkos::View<unsigned int *, MemorySpace::Default::kokkos_space>
        coarse_constraint_offsets;
 
      Kokkos::View<unsigned int *, MemorySpace::Default::kokkos_space>
        coarse_constraint_indices;
 
      Kokkos::View<Number *, MemorySpace::Default::kokkos_space>
        coarse_constraint_weights;
 
      Kokkos::View<unsigned int **, MemorySpace::Default::kokkos_space>
        dof_indices_fine;
 
      Kokkos::View<Number **, MemorySpace::Default::kokkos_space> weights;
 
      Kokkos::View<::internal::MatrixFreeFunctions::ConstraintKinds *,
                   MemorySpace::Default::kokkos_space>
        hanging_node_masks;
    };
 
    struct TransferCellData
    {
      using TeamHandle = Kokkos::TeamPolicy<
        MemorySpace::Default::kokkos_space::execution_space>::member_type;
 
      using SharedViewScratchPad =
        Kokkos::View<Number *,
                     MemorySpace::Default::kokkos_space::execution_space::
                       scratch_memory_space,
                     Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
 
      TeamHandle team_member;
 
      const SharedViewScratchPad &prolongation_matrix_device;
 
      SharedViewScratchPad &values_coarse;
 
      SharedViewScratchPad &values_fine;
 
      SharedViewScratchPad &scratch_pad;
    };
 
  protected:
    void
    prolongate_and_add_internal(VectorType       &dst,
                                const VectorType &src) const override;
 
    void
    restrict_and_add_internal(VectorType       &dst,
                              const VectorType &src) const override;
 
  private:
    std::vector<MGTransferScheme> schemes;
 
    unsigned int n_components;
 
    ObserverPointer<const DoFHandler<dim>> dof_handler_fine;
 
    unsigned int mg_level_fine;
 
    Kokkos::View<Number *, MemorySpace::Default::kokkos_space>
      hanging_node_constraint_weights;
 
    ::MGTwoLevelTransfer<
      dim,
      LinearAlgebra::distributed::Vector<Number, MemorySpace::Host>>
      transfer_cpu;
 
    friend class internal::MGTwoLevelTransferImplementation;
  };
 
} // namespace Portable
 
DEAL_II_NAMESPACE_CLOSE
 
#endif