mg_transfer_global_coarsening.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2020 - 2021 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_transfer_global_coarsening_h
#define dealii_mg_transfer_global_coarsening_h
 
#include <deal.II/base/mg_level_object.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/multigrid/mg_base.h>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declarations
#ifndef DOXYGEN
namespace internal
{
  class MGTwoLevelTransferImplementation;
}
#endif
 
 
 
namespace MGTransferGlobalCoarseningTools
{
  enum class PolynomialCoarseningSequenceType
  {
    bisect,
    decrease_by_one,
    go_to_one
  };
 
  unsigned int
  create_next_polynomial_coarsening_degree(
    const unsigned int                      degree,
    const PolynomialCoarseningSequenceType &p_sequence);
 
  std::vector<unsigned int>
  create_polynomial_coarsening_sequence(
    const unsigned int                      max_degree,
    const PolynomialCoarseningSequenceType &p_sequence);
 
  template <int dim, int spacedim>
  std::vector<std::shared_ptr<const Triangulation<dim, spacedim>>>
  create_geometric_coarsening_sequence(
    const Triangulation<dim, spacedim> &tria);
 
} // namespace MGTransferGlobalCoarseningTools
 
 
 
template <int dim, typename VectorType>
class MGTwoLevelTransfer
{
public:
  void
  prolongate(VectorType &dst, const VectorType &src) const;
 
  void
  restrict_and_add(VectorType &dst, const VectorType &src) const;
 
  void
  interpolate(VectorType &dst, const VectorType &src) const;
};
 
 
 
template <int dim, typename Number>
class MGTwoLevelTransfer<dim, LinearAlgebra::distributed::Vector<Number>>
{
public:
  void
  reinit_geometric_transfer(const DoFHandler<dim> &          dof_handler_fine,
                            const DoFHandler<dim> &          dof_handler_coarse,
                            const AffineConstraints<Number> &constraint_fine,
                            const AffineConstraints<Number> &constraint_coarse);
 
  void
  reinit_polynomial_transfer(
    const DoFHandler<dim> &          dof_handler_fine,
    const DoFHandler<dim> &          dof_handler_coarse,
    const AffineConstraints<Number> &constraint_fine,
    const AffineConstraints<Number> &constraint_coarse);
 
  static bool
  fast_polynomial_transfer_supported(const unsigned int fe_degree_fine,
                                     const unsigned int fe_degree_coarse);
 
  void
  prolongate(LinearAlgebra::distributed::Vector<Number> &      dst,
             const LinearAlgebra::distributed::Vector<Number> &src) const;
 
  void
  restrict_and_add(LinearAlgebra::distributed::Vector<Number> &      dst,
                   const LinearAlgebra::distributed::Vector<Number> &src) const;
 
  void
  interpolate(LinearAlgebra::distributed::Vector<Number> &      dst,
              const LinearAlgebra::distributed::Vector<Number> &src) const;
 
private:
  struct MGTransferScheme
  {
    unsigned int n_coarse_cells;
 
    unsigned int dofs_per_cell_coarse;
 
    unsigned int dofs_per_cell_fine;
 
    unsigned int degree_coarse;
 
    unsigned int degree_fine;
 
    std::vector<Number> weights;
 
    AlignedVector<VectorizedArray<Number>> prolongation_matrix;
 
    AlignedVector<VectorizedArray<Number>> prolongation_matrix_1d;
 
    AlignedVector<VectorizedArray<Number>> restriction_matrix;
 
    AlignedVector<VectorizedArray<Number>> restriction_matrix_1d;
 
    std::vector<unsigned int> level_dof_indices_coarse;
 
    std::vector<unsigned int> level_dof_indices_fine;
  };
 
  std::vector<MGTransferScheme> schemes;
 
  bool fine_element_is_continuous;
 
  std::shared_ptr<const Utilities::MPI::Partitioner> partitioner_fine;
 
  std::shared_ptr<const Utilities::MPI::Partitioner> partitioner_coarse;
 
  mutable LinearAlgebra::distributed::Vector<Number> vec_fine;
 
  mutable LinearAlgebra::distributed::Vector<Number> vec_coarse;
 
  mutable LinearAlgebra::distributed::Vector<Number> vec_coarse_constraints;
 
  std::vector<unsigned int> constraint_coarse_distribute_indices;
 
  std::vector<Number> constraint_coarse_distribute_values;
 
  std::vector<unsigned int> constraint_coarse_distribute_ptr;
 
  std::vector<unsigned int> distribute_local_to_global_indices;
 
  std::vector<Number> distribute_local_to_global_values;
 
  std::vector<unsigned int> distribute_local_to_global_ptr;
 
  unsigned int n_components;
 
  friend class internal::MGTwoLevelTransferImplementation;
};
 
 
 
template <int dim, typename VectorType>
class MGTransferGlobalCoarsening : public ::MGTransferBase<VectorType>
{
public:
  using Number = typename VectorType::value_type;
 
  MGTransferGlobalCoarsening(
    const MGLevelObject<MGTwoLevelTransfer<dim, VectorType>> &transfer,
    const std::function<void(const unsigned int, VectorType &)>
      &initialize_dof_vector = {});
 
  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;
 
  template <class InVector, int spacedim>
  void
  copy_to_mg(const DoFHandler<dim, spacedim> &dof_handler,
             MGLevelObject<VectorType> &      dst,
             const InVector &                 src) const;
 
  template <class OutVector, int spacedim>
  void
  copy_from_mg(const DoFHandler<dim, spacedim> &dof_handler,
               OutVector &                      dst,
               const MGLevelObject<VectorType> &src) const;
 
  template <class InVector, int spacedim>
  void
  interpolate_to_mg(const DoFHandler<dim, spacedim> &dof_handler,
                    MGLevelObject<VectorType> &      dst,
                    const InVector &                 src) const;
 
private:
  const MGLevelObject<MGTwoLevelTransfer<dim, VectorType>> &transfer;
 
  const std::function<void(const unsigned int, VectorType &)>
    initialize_dof_vector;
};
 
 
 
#ifndef DOXYGEN
 
/* ----------------------- Inline functions --------------------------------- */
 
 
 
template <int dim, typename VectorType>
MGTransferGlobalCoarsening<dim, VectorType>::MGTransferGlobalCoarsening(
  const MGLevelObject<MGTwoLevelTransfer<dim, VectorType>> &transfer,
  const std::function<void(const unsigned int, VectorType &)>
    &initialize_dof_vector)
  : transfer(transfer)
  , initialize_dof_vector(initialize_dof_vector)
{}
 
 
 
template <int dim, typename VectorType>
void
MGTransferGlobalCoarsening<dim, VectorType>::prolongate(
  const unsigned int to_level,
  VectorType &       dst,
  const VectorType & src) const
{
  this->transfer[to_level].prolongate(dst, src);
}
 
 
 
template <int dim, typename VectorType>
void
MGTransferGlobalCoarsening<dim, VectorType>::restrict_and_add(
  const unsigned int from_level,
  VectorType &       dst,
  const VectorType & src) const
{
  this->transfer[from_level].restrict_and_add(dst, src);
}
 
 
 
template <int dim, typename VectorType>
template <class InVector, int spacedim>
void
MGTransferGlobalCoarsening<dim, VectorType>::copy_to_mg(
  const DoFHandler<dim, spacedim> &dof_handler,
  MGLevelObject<VectorType> &      dst,
  const InVector &                 src) const
{
  (void)dof_handler;
 
  Assert(
    initialize_dof_vector,
    ExcMessage(
      "To be able to use this function, a function to initialize an internal "
      "DoF vector has to be provided in the constructor of "
      "MGTransferGlobalCoarsening."));
 
  for (unsigned int level = dst.min_level(); level <= dst.max_level(); ++level)
    initialize_dof_vector(level, dst[level]);
 
  dst[dst.max_level()].copy_locally_owned_data_from(src);
}
 
 
 
template <int dim, typename VectorType>
template <class OutVector, int spacedim>
void
MGTransferGlobalCoarsening<dim, VectorType>::copy_from_mg(
  const DoFHandler<dim, spacedim> &dof_handler,
  OutVector &                      dst,
  const MGLevelObject<VectorType> &src) const
{
  (void)dof_handler;
 
  dst.copy_locally_owned_data_from(src[src.max_level()]);
}
 
 
 
template <int dim, typename VectorType>
template <class InVector, int spacedim>
void
MGTransferGlobalCoarsening<dim, VectorType>::interpolate_to_mg(
  const DoFHandler<dim, spacedim> &dof_handler,
  MGLevelObject<VectorType> &      dst,
  const InVector &                 src) const
{
  (void)dof_handler;
 
  Assert(
    initialize_dof_vector,
    ExcMessage(
      "To be able to use this function, a function to initialize an internal "
      "DoF vector has to be provided in the constructor of "
      "MGTransferGlobalCoarsening."));
 
  const unsigned int min_level = transfer.min_level();
  const unsigned int max_level = transfer.max_level();
 
  AssertDimension(min_level, dst.min_level());
  AssertDimension(max_level, dst.max_level());
 
  for (unsigned int level = min_level; level <= max_level; ++level)
    initialize_dof_vector(level, dst[level]);
 
  dst[transfer.max_level()].copy_locally_owned_data_from(src);
 
  for (unsigned int l = max_level; l > min_level; --l)
    this->transfer[l].interpolate(dst[l - 1], dst[l]);
}
 
#endif
 
DEAL_II_NAMESPACE_CLOSE
 
#endif