mg_transfer_matrix_free.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2016 - 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_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, dim> &dof_handler,
        const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
          &external_partitioners =
            std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>());
 
  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 Number2, int spacedim>
  void
  interpolate_to_mg(
    const DoFHandler<dim, spacedim> &                          dof_handler,
    MGLevelObject<LinearAlgebra::distributed::Vector<Number>> &dst,
    const LinearAlgebra::distributed::Vector<Number2> &        src) const;
 
  DeclException0(ExcNoProlongation);
 
  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>
class MGTransferBlockMatrixFree
  : public MGTransferBase<LinearAlgebra::distributed::BlockVector<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, dim> &dof_handler);
 
  void
  build(const std::vector<const DoFHandler<dim, dim> *> &dof_handler);
 
  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 Number2, int spacedim>
  void
  copy_to_mg(
    const DoFHandler<dim, spacedim> &                               dof_handler,
    MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &dst,
    const LinearAlgebra::distributed::BlockVector<Number2> &        src) const;
 
  template <typename Number2, int spacedim>
  void
  copy_to_mg(
    const std::vector<const DoFHandler<dim, spacedim> *> &          dof_handler,
    MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &dst,
    const LinearAlgebra::distributed::BlockVector<Number2> &        src) const;
 
  template <typename Number2, int spacedim>
  void
  copy_from_mg(
    const DoFHandler<dim, spacedim> &                 dof_handler,
    LinearAlgebra::distributed::BlockVector<Number2> &dst,
    const MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &src)
    const;
 
  template <typename Number2, int spacedim>
  void
  copy_from_mg(
    const std::vector<const DoFHandler<dim, spacedim> *> &dof_handler,
    LinearAlgebra::distributed::BlockVector<Number2> &    dst,
    const MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &src)
    const;
 
  std::size_t
  memory_consumption() const;
 
  static const bool supports_dof_handler_vector = true;
 
private:
  std::vector<MGTransferMatrixFree<dim, Number>> matrix_free_transfer_vector;
 
  const bool same_for_all;
};
 
 
//------------------------ templated functions -------------------------
#ifndef DOXYGEN
 
 
template <int dim, typename Number>
template <typename Number2, int spacedim>
void
MGTransferMatrixFree<dim, Number>::interpolate_to_mg(
  const DoFHandler<dim, spacedim> &                          dof_handler,
  MGLevelObject<LinearAlgebra::distributed::Vector<Number>> &dst,
  const LinearAlgebra::distributed::Vector<Number2> &        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 FiniteElement<dim, spacedim> &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);
                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();
    }
}
 
 
 
template <int dim, typename Number>
template <typename Number2, int spacedim>
void
MGTransferBlockMatrixFree<dim, Number>::copy_to_mg(
  const DoFHandler<dim, spacedim> &                               dof_handler,
  MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &dst,
  const LinearAlgebra::distributed::BlockVector<Number2> &        src) const
{
  AssertDimension(matrix_free_transfer_vector.size(), 1);
  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, spacedim> *> mg_dofs(src.n_blocks(),
                                                               &dof_handler);
 
  copy_to_mg(mg_dofs, dst, src);
}
 
 
 
template <int dim, typename Number>
template <typename Number2, int spacedim>
void
MGTransferBlockMatrixFree<dim, Number>::copy_to_mg(
  const std::vector<const DoFHandler<dim, spacedim> *> &          dof_handler,
  MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &dst,
  const LinearAlgebra::distributed::BlockVector<Number2> &        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();
 
  // this function is normally called within the Multigrid class with
  // dst == defect level block vector. At first run this vector is not
  // initialized. Do this below:
  {
    const parallel::TriangulationBase<dim, spacedim> *tria =
      (dynamic_cast<const parallel::TriangulationBase<dim, spacedim> *>(
        &(dof_handler[0]->get_triangulation())));
    for (unsigned int i = 1; i < n_blocks; ++i)
      AssertThrow(
        (dynamic_cast<const parallel::TriangulationBase<dim, spacedim> *>(
           &(dof_handler[0]->get_triangulation())) == tria),
        ExcMessage("The DoFHandler use different Triangulations!"));
 
    MGLevelObject<bool> do_reinit;
    do_reinit.resize(min_level, max_level);
    for (unsigned int level = min_level; level <= max_level; ++level)
      {
        do_reinit[level] = false;
        if (dst[level].n_blocks() != n_blocks)
          {
            do_reinit[level] = true;
            continue; // level
          }
        for (unsigned int b = 0; b < n_blocks; ++b)
          {
            LinearAlgebra::distributed::Vector<Number> &v = dst[level].block(b);
            if (v.size() !=
                  dof_handler[b]->locally_owned_mg_dofs(level).size() ||
                v.locally_owned_size() !=
                  dof_handler[b]->locally_owned_mg_dofs(level).n_elements())
              {
                do_reinit[level] = true;
                break; // b
              }
          }
      }
 
    for (unsigned int level = min_level; level <= max_level; ++level)
      {
        if (do_reinit[level])
          {
            dst[level].reinit(n_blocks);
            for (unsigned int b = 0; b < n_blocks; ++b)
              {
                LinearAlgebra::distributed::Vector<Number> &v =
                  dst[level].block(b);
                v.reinit(dof_handler[b]->locally_owned_mg_dofs(level),
                         dof_handler[b]->get_communicator());
              }
            dst[level].collect_sizes();
          }
        else
          dst[level] = 0;
      }
  }
 
  // 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)
    {
      for (unsigned int l = min_level; l <= max_level; ++l)
        dst_non_block[l].reinit(dst[l].block(b));
      const unsigned int data_block = same_for_all ? 0 : b;
      matrix_free_transfer_vector[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];
    }
}
 
template <int dim, typename Number>
template <typename Number2, int spacedim>
void
MGTransferBlockMatrixFree<dim, Number>::copy_from_mg(
  const DoFHandler<dim, spacedim> &                 dof_handler,
  LinearAlgebra::distributed::BlockVector<Number2> &dst,
  const MGLevelObject<LinearAlgebra::distributed::BlockVector<Number>> &src)
  const
{
  AssertDimension(matrix_free_transfer_vector.size(), 1);
  const std::vector<const DoFHandler<dim, spacedim> *> mg_dofs(dst.n_blocks(),
                                                               &dof_handler);
 
  copy_from_mg(mg_dofs, dst, src);
}
 
template <int dim, typename Number>
template <typename Number2, int spacedim>
void
MGTransferBlockMatrixFree<dim, Number>::copy_from_mg(
  const std::vector<const DoFHandler<dim, spacedim> *> &dof_handler,
  LinearAlgebra::distributed::BlockVector<Number2> &    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;
      matrix_free_transfer_vector[data_block].copy_from_mg(*dof_handler[b],
                                                           dst.block(b),
                                                           src_non_block);
    }
}
 
 
 
#endif // DOXYGEN
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif