mg_transfer_component.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 2001 - 2025 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef dealii_mg_transfer_component_h
#define dealii_mg_transfer_component_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/fe/component_mask.h>
 
#include <deal.II/lac/affine_constraints.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 <memory>
#include <set>
 
 
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 MGTransferComponentBase
{
public:
  std::size_t
  memory_consumption() const;
 
 
protected:
  template <int dim, int spacedim>
  void
  build(const DoFHandler<dim, spacedim> &dof_handler);

  ComponentMask component_mask;

  ComponentMask mg_component_mask;

  std::vector<unsigned int> target_component;

  std::vector<unsigned int> mg_target_component;

  mutable std::vector<std::vector<types::global_dof_index>> sizes;

  std::vector<types::global_dof_index> component_start;

  std::vector<std::vector<types::global_dof_index>> mg_component_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::pair<types::global_dof_index, unsigned int>>>
    copy_to_and_from_indices;

  std::vector<std::set<types::global_dof_index>> boundary_indices;
};
 
// TODO:[GK] Update documentation for copy_* functions
 
// TODO: Use same kind of template argument as MGTransferSelect

template <typename number>
class MGTransferSelect : public MGTransferBase<Vector<number>>,
                         private MGTransferComponentBase
{
public:
  MGTransferSelect();

  MGTransferSelect(const AffineConstraints<double> &constraints);

  virtual ~MGTransferSelect() override = default;
 
  // TODO: rewrite docs; make sure defaulted args are actually allowed
  template <int dim, int spacedim>
  void
  build(const DoFHandler<dim, spacedim> &dof,
        unsigned int                     selected,
        unsigned int                     mg_selected,
        const std::vector<unsigned int> &target_component =
          std::vector<unsigned int>(),
        const std::vector<unsigned int> &mg_target_component =
          std::vector<unsigned int>(),
        const std::vector<std::set<types::global_dof_index>> &boundary_indices =
          std::vector<std::set<types::global_dof_index>>());

  void
  select(const unsigned int component,
         const unsigned int mg_component = numbers::invalid_unsigned_int);
 
  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> &mg_dof,
             MGLevelObject<Vector<number>>   &dst,
             const Vector<number2>           &src) const;

  template <int dim, typename number2, int spacedim>
  void
  copy_from_mg(const DoFHandler<dim, spacedim>     &mg_dof,
               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>     &mg_dof,
                   Vector<number2>                     &dst,
                   const MGLevelObject<Vector<number>> &src) const;

  template <int dim, typename number2, int spacedim>
  void
  copy_to_mg(const DoFHandler<dim, spacedim> &mg_dof,
             MGLevelObject<Vector<number>>   &dst,
             const BlockVector<number2>      &src) const;

  template <int dim, typename number2, int spacedim>
  void
  copy_from_mg(const DoFHandler<dim, spacedim>     &mg_dof,
               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>     &mg_dof,
                   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>     &mg_dof,
                  OutVector                           &dst,
                  const MGLevelObject<Vector<number>> &src) const;

  template <int dim, class OutVector, int spacedim>
  void
  do_copy_from_mg_add(const DoFHandler<dim, spacedim>     &mg_dof,
                      OutVector                           &dst,
                      const MGLevelObject<Vector<number>> &src) const;

  template <int dim, class InVector, int spacedim>
  void
  do_copy_to_mg(const DoFHandler<dim, spacedim> &mg_dof,
                MGLevelObject<Vector<number>>   &dst,
                const InVector                  &src) const;
  unsigned int selected_component;
  unsigned int mg_selected_component;

  std::vector<IndexSet> interface_dofs;

public:
  ObserverPointer<const AffineConstraints<double>> constraints;
};

 
//---------------------------------------------------------------------------
template <typename number>
inline void
MGTransferSelect<number>::select(const unsigned int component,
                                 const unsigned int mg_component)
{
  selected_component = component;
  mg_selected_component =
    (mg_component == numbers::invalid_unsigned_int) ? component : mg_component;
}
 
DEAL_II_NAMESPACE_CLOSE
 
#endif