mg_transfer_block.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2001 - 2018 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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii_mg_transfer_block_h
#define dealii_mg_transfer_block_h

#include <deal.II/base/config.h>

#include <deal.II/lac/block_vector.h>
#include <deal.II/lac/sparsity_pattern.h>
#include <deal.II/lac/block_sparsity_pattern.h>
#include <deal.II/lac/vector_memory.h>
#include <deal.II/lac/block_matrix_array.h>

#include <deal.II/multigrid/mg_base.h>
#include <deal.II/multigrid/mg_constrained_dofs.h>
#include <deal.II/base/mg_level_object.h>



#include <deal.II/dofs/dof_handler.h>

#include <memory>


DEAL_II_NAMESPACE_OPEN


template <int dim, int spacedim> class DoFHandler;

/*
 * MGTransferBase is defined in mg_base.h
 */


class MGTransferBlockBase
{
public:
  MGTransferBlockBase ();

  MGTransferBlockBase (const MGConstrainedDoFs &mg_constrained_dofs);

  DEAL_II_DEPRECATED
  MGTransferBlockBase (const ConstraintMatrix &constraints,
                       const MGConstrainedDoFs &mg_constrained_dofs);

  std::size_t memory_consumption () const;

protected:
  template <int dim, int spacedim>
  void build_matrices (const DoFHandler<dim,spacedim> &dof,
                       const DoFHandler<dim,spacedim> &mg_dof);

//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 ();

  void initialize (const std::vector<number> &factors,
                   VectorMemory<Vector<number> > &memory);

  template <int dim, int spacedim>
  void build_matrices (const DoFHandler<dim,spacedim> &dof,
                       const DoFHandler<dim,spacedim> &mg_dof,
                       const std::vector<bool> &selected);

  virtual void prolongate (const unsigned int    to_level,
                           BlockVector<number>       &dst,
                           const BlockVector<number> &src) const;

  virtual void restrict_and_add (const unsigned int    from_level,
                                 BlockVector<number>       &dst,
                                 const BlockVector<number> &src) const;

  template <int dim, typename number2, int spacedim>
  void
  copy_to_mg (const DoFHandler<dim,spacedim> &mg_dof,
              MGLevelObject<BlockVector<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<BlockVector<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<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);

  DEAL_II_DEPRECATED
  MGTransferBlockSelect (const ConstraintMatrix &constraints,
                         const MGConstrainedDoFs &mg_constrained_dofs);

  virtual ~MGTransferBlockSelect () = default;

  template <int dim, int spacedim>
  void build_matrices (const DoFHandler<dim,spacedim> &dof,
                       const DoFHandler<dim,spacedim> &mg_dof,
                       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;

  virtual void restrict_and_add (const unsigned int    from_level,
                                 Vector<number>       &dst,
                                 const 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 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 unsigned int offset) 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 unsigned int offset) 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              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