mg_transfer_matrix_free.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2016 - 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_transfer_matrix_free_h
#define dealii_mg_transfer_matrix_free_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/mg_level_object.h>
#include <deal.II/base/vectorization.h>
 
#include <deal.II/dofs/dof_handler.h>
 
#include <deal.II/lac/la_parallel_block_vector.h>
#include <deal.II/lac/la_parallel_vector.h>
 
#include <deal.II/multigrid/mg_base.h>
#include <deal.II/multigrid/mg_constrained_dofs.h>
#include <deal.II/multigrid/mg_transfer.h>
#include <deal.II/multigrid/mg_transfer_internal.h>
 
 
DEAL_II_NAMESPACE_OPEN
 
 
template <int dim, typename Number>
class MGTransferMatrixFree
  : public MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>
{
public:
  MGTransferMatrixFree();
 
  MGTransferMatrixFree(const MGConstrainedDoFs &mg_constrained_dofs);
 
  virtual ~MGTransferMatrixFree() override = default;
 
  void
  initialize_constraints(const MGConstrainedDoFs &mg_constrained_dofs);
 
  void
  clear();
 
  void
  build(const DoFHandler<dim> &dof_handler,
        const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
          &external_partitioners =
            std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>());
 
  void
  build(const DoFHandler<dim> &dof_handler,
        const std::function<void(const unsigned int,
                                 LinearAlgebra::distributed::Vector<Number> &)>
          &initialize_dof_vector);
 
  virtual void
  prolongate(
    const unsigned int                                to_level,
    LinearAlgebra::distributed::Vector<Number>       &dst,
    const LinearAlgebra::distributed::Vector<Number> &src) const override;
 
  virtual void
  prolongate_and_add(
    const unsigned int                                to_level,
    LinearAlgebra::distributed::Vector<Number>       &dst,
    const LinearAlgebra::distributed::Vector<Number> &src) const override;
 
  virtual void
  restrict_and_add(
    const unsigned int                                from_level,
    LinearAlgebra::distributed::Vector<Number>       &dst,
    const LinearAlgebra::distributed::Vector<Number> &src) const override;
 
  template <typename BlockVectorType2>
  void
  interpolate_to_mg(
    const DoFHandler<dim>                                     &dof_handler,
    MGLevelObject<LinearAlgebra::distributed::Vector<Number>> &dst,
    const BlockVectorType2                                    &src) const;
 
  std::size_t
  memory_consumption() const;
 
private:
  unsigned int fe_degree;
 
  bool element_is_continuous;
 
  unsigned int n_components;
 
  unsigned int n_child_cell_dofs;
 
  std::vector<std::vector<unsigned int>> level_dof_indices;
 
  std::vector<std::vector<std::pair<unsigned int, unsigned int>>>
    parent_child_connect;
 
  std::vector<unsigned int> n_owned_level_cells;
 
  AlignedVector<VectorizedArray<Number>> prolongation_matrix_1d;
 
  mutable AlignedVector<VectorizedArray<Number>> evaluation_data;
 
  std::vector<AlignedVector<VectorizedArray<Number>>> weights_on_refined;
 
  std::vector<std::vector<std::vector<unsigned short>>> dirichlet_indices;
 
  MGLevelObject<std::shared_ptr<const Utilities::MPI::Partitioner>>
    vector_partitioners;
 
  template <int degree>
  void
  do_prolongate_add(
    const unsigned int                                to_level,
    LinearAlgebra::distributed::Vector<Number>       &dst,
    const LinearAlgebra::distributed::Vector<Number> &src) const;
 
  template <int degree>
  void
  do_restrict_add(const unsigned int                                from_level,
                  LinearAlgebra::distributed::Vector<Number>       &dst,
                  const LinearAlgebra::distributed::Vector<Number> &src) const;
};
 
 
 
template <int dim, typename Number, typename TransferType>
class MGTransferBlockMatrixFreeBase
  : public MGTransferBase<LinearAlgebra::distributed::BlockVector<Number>>
{
public:
  MGTransferBlockMatrixFreeBase(const bool same_for_all)
    : same_for_all(same_for_all)
  {}
 
  virtual void
  prolongate(
    const unsigned int                                     to_level,
    LinearAlgebra::distributed::BlockVector<Number>       &dst,
    const LinearAlgebra::distributed::BlockVector<Number> &src) const override;
 
  virtual void
  prolongate_and_add(
    const unsigned int                                     to_level,
    LinearAlgebra::distributed::BlockVector<Number>       &dst,
    const LinearAlgebra::distributed::BlockVector<Number> &src) const override;
 
  virtual void
  restrict_and_add(
    const unsigned int                                     from_level,
    LinearAlgebra::distributed::BlockVector<Number>       &dst,
    const LinearAlgebra::distributed::BlockVector<Number> &src) const override;
 
  template <typename BlockVectorType2>
  void
  copy_to_mg(
    const DoFHandler<dim>                                          &dof_handler,
    MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &dst,
    const BlockVectorType2                                         &src) const;
 
  template <typename BlockVectorType2>
  void
  copy_to_mg(
    const std::vector<const DoFHandler<dim> *>                     &dof_handler,
    MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &dst,
    const BlockVectorType2                                         &src) const;
 
  template <typename BlockVectorType2>
  void
  copy_from_mg(
    const DoFHandler<dim> &dof_handler,
    BlockVectorType2      &dst,
    const MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &src)
    const;
 
  template <typename BlockVectorType2>
  void
  copy_from_mg(
    const std::vector<const DoFHandler<dim> *> &dof_handler,
    BlockVectorType2                           &dst,
    const MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &src)
    const;
 
  static const bool supports_dof_handler_vector = true;
 
protected:
  virtual const TransferType &
  get_matrix_free_transfer(const unsigned int b) const = 0;
 
  const bool same_for_all;
};
 
 
 
template <int dim, typename Number>
class MGTransferBlockMatrixFree
  : public MGTransferBlockMatrixFreeBase<dim,
                                         Number,
                                         MGTransferMatrixFree<dim, Number>>
{
public:
  MGTransferBlockMatrixFree() = default;
 
  MGTransferBlockMatrixFree(const MGConstrainedDoFs &mg_constrained_dofs);
 
  MGTransferBlockMatrixFree(
    const std::vector<MGConstrainedDoFs> &mg_constrained_dofs);
 
  virtual ~MGTransferBlockMatrixFree() override = default;
 
  void
  initialize_constraints(const MGConstrainedDoFs &mg_constrained_dofs);
 
  void
  initialize_constraints(
    const std::vector<MGConstrainedDoFs> &mg_constrained_dofs);
 
  void
  clear();
 
  void
  build(const DoFHandler<dim> &dof_handler);
 
  void
  build(const std::vector<const DoFHandler<dim> *> &dof_handler);
 
  std::size_t
  memory_consumption() const;
 
protected:
  const MGTransferMatrixFree<dim, Number> &
  get_matrix_free_transfer(const unsigned int b) const override;
 
private:
  std::vector<MGTransferMatrixFree<dim, Number>> matrix_free_transfer_vector;
};
 
 
//------------------------ templated functions -------------------------
#ifndef DOXYGEN
 
 
template <int dim, typename Number>
template <typename BlockVectorType2>
void
MGTransferMatrixFree<dim, Number>::interpolate_to_mg(
  const DoFHandler<dim>                                     &dof_handler,
  MGLevelObject<LinearAlgebra::distributed::Vector<Number>> &dst,
  const BlockVectorType2                                    &src) const
{
  const unsigned int min_level = dst.min_level();
  const unsigned int max_level = dst.max_level();
 
  Assert(max_level == dof_handler.get_triangulation().n_global_levels() - 1,
         ExcDimensionMismatch(
           max_level, dof_handler.get_triangulation().n_global_levels() - 1));
 
  const auto &fe = dof_handler.get_fe();
 
  for (unsigned int level = min_level; level <= max_level; ++level)
    if (dst[level].size() != dof_handler.n_dofs(level) ||
        dst[level].locally_owned_size() !=
          dof_handler.locally_owned_mg_dofs(level).n_elements())
      dst[level].reinit(this->vector_partitioners[level]);
 
  // copy fine level vector to active cells in MG hierarchy
  this->copy_to_mg(dof_handler, dst, src, true);
 
  // FIXME: maybe need to store hanging nodes constraints per level?
  // MGConstrainedDoFs does NOT keep this info right now, only periodicity
  // constraints...
 
  // do the transfer from level to level-1:
  dst[max_level].update_ghost_values();
 
  for (unsigned int level = max_level; level > min_level; --level)
    {
      // auxiliary vector which always has ghost elements
      const LinearAlgebra::distributed::Vector<Number> *input = nullptr;
      LinearAlgebra::distributed::Vector<Number>        ghosted_fine;
      if (dst[level].get_partitioner().get() ==
          this->vector_partitioners[level].get())
        input = &dst[level];
      else
        {
          ghosted_fine.reinit(this->vector_partitioners[level]);
          ghosted_fine.copy_locally_owned_data_from(dst[level]);
          ghosted_fine.update_ghost_values();
          input = &ghosted_fine;
        }
 
      std::vector<Number> dof_values_coarse(fe.n_dofs_per_cell());
      Vector<Number>      dof_values_fine(fe.n_dofs_per_cell());
      Vector<Number>      tmp(fe.n_dofs_per_cell());
      std::vector<types::global_dof_index> dof_indices(fe.n_dofs_per_cell());
      for (const auto &cell : dof_handler.cell_iterators_on_level(level - 1))
        if (cell->is_locally_owned_on_level())
          {
            // if we get to a cell without children (== active), we can
            // skip it as there values should be already set by the
            // equivalent of copy_to_mg()
            if (cell->is_active())
              continue;
 
            std::fill(dof_values_coarse.begin(), dof_values_coarse.end(), 0.);
            for (unsigned int child = 0; child < cell->n_children(); ++child)
              {
                cell->child(child)->get_mg_dof_indices(dof_indices);
 
                internal::MGTransfer::resolve_identity_constraints(
                  this->mg_constrained_dofs, level, dof_indices);
 
                for (unsigned int i = 0; i < fe.n_dofs_per_cell(); ++i)
                  dof_values_fine(i) = (*input)(dof_indices[i]);
                fe.get_restriction_matrix(child, cell->refinement_case())
                  .vmult(tmp, dof_values_fine);
                for (unsigned int i = 0; i < fe.n_dofs_per_cell(); ++i)
                  if (fe.restriction_is_additive(i))
                    dof_values_coarse[i] += tmp[i];
                  else if (tmp(i) != 0.)
                    dof_values_coarse[i] = tmp[i];
              }
            cell->get_mg_dof_indices(dof_indices);
            for (unsigned int i = 0; i < fe.n_dofs_per_cell(); ++i)
              if (dof_handler.locally_owned_mg_dofs(level - 1).is_element(
                    dof_indices[i]))
                dst[level - 1](dof_indices[i]) = dof_values_coarse[i];
          }
 
      dst[level - 1].update_ghost_values();
    }
 
  for (unsigned int level = min_level; level <= max_level; ++level)
    dst[level].zero_out_ghost_values();
}
 
 
 
template <int dim, typename Number, typename TransferType>
template <typename BlockVectorType2>
void
MGTransferBlockMatrixFreeBase<dim, Number, TransferType>::copy_to_mg(
  const DoFHandler<dim>                                          &dof_handler,
  MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &dst,
  const BlockVectorType2                                         &src) const
{
  Assert(same_for_all,
         ExcMessage(
           "This object was initialized with support for usage with one "
           "DoFHandler for each block, but this method assumes that "
           "the same DoFHandler is used for all the blocks!"));
  const std::vector<const DoFHandler<dim> *> mg_dofs(src.n_blocks(),
                                                     &dof_handler);
 
  copy_to_mg(mg_dofs, dst, src);
}
 
 
 
template <int dim, typename Number, typename TransferType>
template <typename BlockVectorType2>
void
MGTransferBlockMatrixFreeBase<dim, Number, TransferType>::copy_to_mg(
  const std::vector<const DoFHandler<dim> *>                     &dof_handler,
  MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &dst,
  const BlockVectorType2                                         &src) const
{
  const unsigned int n_blocks = src.n_blocks();
  AssertDimension(dof_handler.size(), n_blocks);
 
  if (n_blocks == 0)
    return;
 
  const unsigned int min_level = dst.min_level();
  const unsigned int max_level = dst.max_level();
 
  for (unsigned int level = min_level; level <= max_level; ++level)
    if (dst[level].n_blocks() != n_blocks)
      dst[level].reinit(n_blocks);
 
  // FIXME: this a quite ugly as we need a temporary object:
  MGLevelObject<LinearAlgebra::distributed::Vector<Number>> dst_non_block(
    min_level, max_level);
 
  for (unsigned int b = 0; b < n_blocks; ++b)
    {
      const unsigned int data_block = same_for_all ? 0 : b;
      get_matrix_free_transfer(data_block)
        .copy_to_mg(*dof_handler[b], dst_non_block, src.block(b));
 
      for (unsigned int l = min_level; l <= max_level; ++l)
        dst[l].block(b) = dst_non_block[l];
    }
 
  for (unsigned int level = min_level; level <= max_level; ++level)
    dst[level].collect_sizes();
}
 
template <int dim, typename Number, typename TransferType>
template <typename BlockVectorType2>
void
MGTransferBlockMatrixFreeBase<dim, Number, TransferType>::copy_from_mg(
  const DoFHandler<dim> &dof_handler,
  BlockVectorType2      &dst,
  const MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &src)
  const
{
  Assert(same_for_all,
         ExcMessage(
           "This object was initialized with support for usage with one "
           "DoFHandler for each block, but this method assumes that "
           "the same DoFHandler is used for all the blocks!"));
  const std::vector<const DoFHandler<dim> *> mg_dofs(dst.n_blocks(),
                                                     &dof_handler);
 
  copy_from_mg(mg_dofs, dst, src);
}
 
template <int dim, typename Number, typename TransferType>
template <typename BlockVectorType2>
void
MGTransferBlockMatrixFreeBase<dim, Number, TransferType>::copy_from_mg(
  const std::vector<const DoFHandler<dim> *> &dof_handler,
  BlockVectorType2                           &dst,
  const MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &src)
  const
{
  const unsigned int n_blocks = dst.n_blocks();
  AssertDimension(dof_handler.size(), n_blocks);
 
  if (n_blocks == 0)
    return;
 
  const unsigned int min_level = src.min_level();
  const unsigned int max_level = src.max_level();
 
  for (unsigned int l = min_level; l <= max_level; ++l)
    AssertDimension(src[l].n_blocks(), dst.n_blocks());
 
  // FIXME: this a quite ugly as we need a temporary object:
  MGLevelObject<LinearAlgebra::distributed::Vector<Number>> src_non_block(
    min_level, max_level);
 
  for (unsigned int b = 0; b < n_blocks; ++b)
    {
      for (unsigned int l = min_level; l <= max_level; ++l)
        {
          src_non_block[l].reinit(src[l].block(b));
          src_non_block[l] = src[l].block(b);
        }
      const unsigned int data_block = same_for_all ? 0 : b;
      get_matrix_free_transfer(data_block)
        .copy_from_mg(*dof_handler[b], dst.block(b), src_non_block);
    }
}
 
 
 
#endif // DOXYGEN
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif