mg_transfer_block.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2001 - 2023 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_block_h
#define dealii_mg_transfer_block_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/mg_level_object.h>
 
#include <deal.II/dofs/dof_handler.h>
 
#include <deal.II/lac/block_sparsity_pattern.h>
#include <deal.II/lac/block_vector.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
 
 
// Forward declaration
#ifndef DOXYGEN
template <int dim, int spacedim>
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
class DoFHandler;
#endif
 
/*
 * MGTransferBase is defined in mg_base.h
 */
 
class MGTransferBlockBase
{
public:
  MGTransferBlockBase();
 
  MGTransferBlockBase(const MGConstrainedDoFs &mg_constrained_dofs);
 
  std::size_t
  memory_consumption() const;
 
protected:
  template <int dim, int spacedim>
  void
  build(const DoFHandler<dim, spacedim> &dof_handler);
 
  // TODO: rename this to block_mask, in the same way as has already been done
  // in MGTransferComponent, and give it type BlockMask
  std::vector<bool> selected;
 
  unsigned int n_mg_blocks;
 
  // TODO: rename this to mg_block_mask, in the same way as has already been
  // done in MGTransferComponent, and give it type BlockMask
  std::vector<unsigned int> mg_block;
 
  mutable std::vector<std::vector<types::global_dof_index>> sizes;
 
  std::vector<types::global_dof_index> block_start;
 
  std::vector<std::vector<types::global_dof_index>> mg_block_start;
 
  DeclException0(ExcMatricesNotBuilt);
 
private:
  std::vector<std::shared_ptr<BlockSparsityPattern>> prolongation_sparsities;
 
protected:
  std::vector<std::shared_ptr<BlockSparseMatrix<double>>> prolongation_matrices;
 
  std::vector<std::vector<std::vector<std::pair<unsigned int, unsigned int>>>>
    copy_indices;
 
  SmartPointer<const MGConstrainedDoFs, MGTransferBlockBase>
    mg_constrained_dofs;
};
 
template <typename number>
class MGTransferBlock : public MGTransferBase<BlockVector<number>>,
                        private MGTransferBlockBase
{
public:
  MGTransferBlock();
 
  virtual ~MGTransferBlock() override;
 
  void
  initialize(const std::vector<number> &   factors,
             VectorMemory<Vector<number>> &memory);
 
  template <int dim, int spacedim>
  void
  build(const DoFHandler<dim, spacedim> &dof_handler,
        const std::vector<bool> &        selected);
 
  virtual void
  prolongate(const unsigned int         to_level,
             BlockVector<number> &      dst,
             const BlockVector<number> &src) const override;
 
  virtual void
  restrict_and_add(const unsigned int         from_level,
                   BlockVector<number> &      dst,
                   const BlockVector<number> &src) const override;
 
  template <int dim, typename number2, int spacedim>
  void
  copy_to_mg(const DoFHandler<dim, spacedim> &   dof_handler,
             MGLevelObject<BlockVector<number>> &dst,
             const BlockVector<number2> &        src) const;
 
  template <int dim, typename number2, int spacedim>
  void
  copy_from_mg(const DoFHandler<dim, spacedim> &         dof_handler,
               BlockVector<number2> &                    dst,
               const MGLevelObject<BlockVector<number>> &src) const;
 
  template <int dim, typename number2, int spacedim>
  void
  copy_from_mg_add(const DoFHandler<dim, spacedim> &         dof_handler,
                   BlockVector<number2> &                    dst,
                   const MGLevelObject<BlockVector<number>> &src) const;
 
  using MGTransferBlockBase::memory_consumption;
 
private:
  std::vector<number> factors;
 
  SmartPointer<VectorMemory<Vector<number>>, MGTransferBlock<number>> memory;
};
 
 
// TODO:[GK] Update documentation for copy_* functions
 
template <typename number>
class MGTransferBlockSelect : public MGTransferBase<Vector<number>>,
                              private MGTransferBlockBase
{
public:
  MGTransferBlockSelect();
 
  MGTransferBlockSelect(const MGConstrainedDoFs &mg_constrained_dofs);
 
  virtual ~MGTransferBlockSelect() override = default;
 
  template <int dim, int spacedim>
  void
  build(const DoFHandler<dim, spacedim> &dof_handler, unsigned int selected);
 
  void
  select(const unsigned int block);
 
  virtual void
  prolongate(const unsigned int    to_level,
             Vector<number> &      dst,
             const Vector<number> &src) const override;
 
  virtual void
  restrict_and_add(const unsigned int    from_level,
                   Vector<number> &      dst,
                   const Vector<number> &src) const override;
 
  template <int dim, typename number2, int spacedim>
  void
  copy_to_mg(const DoFHandler<dim, spacedim> &dof_handler,
             MGLevelObject<Vector<number>> &  dst,
             const Vector<number2> &          src) const;
 
  template <int dim, typename number2, int spacedim>
  void
  copy_from_mg(const DoFHandler<dim, spacedim> &    dof_handler,
               Vector<number2> &                    dst,
               const MGLevelObject<Vector<number>> &src) const;
 
  template <int dim, typename number2, int spacedim>
  void
  copy_from_mg_add(const DoFHandler<dim, spacedim> &    dof_handler,
                   Vector<number2> &                    dst,
                   const MGLevelObject<Vector<number>> &src) const;
 
  template <int dim, typename number2, int spacedim>
  void
  copy_to_mg(const DoFHandler<dim, spacedim> &dof_handler,
             MGLevelObject<Vector<number>> &  dst,
             const BlockVector<number2> &     src) const;
 
  template <int dim, typename number2, int spacedim>
  void
  copy_from_mg(const DoFHandler<dim, spacedim> &    dof_handler,
               BlockVector<number2> &               dst,
               const MGLevelObject<Vector<number>> &src) const;
 
  template <int dim, typename number2, int spacedim>
  void
  copy_from_mg_add(const DoFHandler<dim, spacedim> &    dof_handler,
                   BlockVector<number2> &               dst,
                   const MGLevelObject<Vector<number>> &src) const;
 
  std::size_t
  memory_consumption() const;
 
private:
  template <int dim, class OutVector, int spacedim>
  void
  do_copy_from_mg(const DoFHandler<dim, spacedim> &    dof_handler,
                  OutVector &                          dst,
                  const MGLevelObject<Vector<number>> &src,
                  const unsigned int                   offset) const;
 
  template <int dim, class OutVector, int spacedim>
  void
  do_copy_from_mg_add(const DoFHandler<dim, spacedim> &    dof_handler,
                      OutVector &                          dst,
                      const MGLevelObject<Vector<number>> &src,
                      const unsigned int                   offset) const;
 
  template <int dim, class InVector, int spacedim>
  void
  do_copy_to_mg(const DoFHandler<dim, spacedim> &dof_handler,
                MGLevelObject<Vector<number>> &  dst,
                const InVector &                 src,
                const unsigned int               offset) const;
  unsigned int selected_block;
};
 
//------------------------- inline function definition ------------------------
template <typename number>
inline void
MGTransferBlockSelect<number>::select(const unsigned int block)
{
  selected_block = block;
}
 
DEAL_II_NAMESPACE_CLOSE
 
#endif