sparse_vanka.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 1999 - 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_sparse_vanka_h
#define dealii_sparse_vanka_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/multithread_info.h>
#include <deal.II/base/observer_pointer.h>
 
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declarations
#ifndef DOXYGEN
template <typename number>
class FullMatrix;
template <typename number>
class SparseMatrix;
template <typename number>
class Vector;
 
template <typename number>
class SparseVanka;
template <typename number>
class SparseBlockVanka;
#endif
 
template <typename number>
class SparseVanka
{
public:
  using size_type = types::global_dof_index;
 
  SparseVanka();
 
  SparseVanka(const SparseMatrix<number> &M, const std::vector<bool> &selected);
 
  ~SparseVanka();
 
  class AdditionalData
  {
  public:
    explicit AdditionalData(const std::vector<bool> &selected);
 
    const std::vector<bool> &selected;
  };
 
 
  void
  initialize(const SparseMatrix<number> &M,
             const AdditionalData       &additional_data);
 
  template <typename number2>
  void
  vmult(Vector<number2> &dst, const Vector<number2> &src) const;
 
  template <typename number2>
  void
  Tvmult(Vector<number2> &dst, const Vector<number2> &src) const;
 
  void
  clear();
 
  size_type
  m() const;
 
  size_type
  n() const;
 
protected:
  template <typename number2>
  void
  apply_preconditioner(Vector<number2>               &dst,
                       const Vector<number2>         &src,
                       const bool                     transpose = false,
                       const std::vector<bool> *const dof_mask = nullptr) const;
 
  std::size_t
  memory_consumption() const;
 
private:
  ObserverPointer<const SparseMatrix<number>, SparseVanka<number>> matrix;
 
  const std::vector<bool> *selected;
 
  mutable std::vector<ObserverPointer<FullMatrix<float>, SparseVanka<number>>>
    inverses;
 
  size_type _m;
 
  size_type _n;
 
  void
  compute_inverses();
 
  void
  compute_inverses(const size_type begin, const size_type end);
 
  void
  compute_inverse(const size_type row, std::vector<size_type> &local_indices);
 
  // Make the derived class a friend. This seems silly, but is actually
  // necessary, since derived classes can only access non-public members
  // through their @p this pointer, but not access these members as member
  // functions of other objects of the type of this base class (i.e. like
  // <tt>x.f()</tt>, where @p x is an object of the base class, and @p f one
  // of it's non-public member functions).
  //
  // Now, in the case of the @p SparseBlockVanka class, we would like to take
  // the address of a function of the base class in order to call it through
  // the multithreading framework, so the derived class has to be a friend.
  template <typename T>
  friend class SparseBlockVanka;
};
 
 
 
template <typename number>
class SparseBlockVanka : public SparseVanka<number>
{
public:
  using size_type = types::global_dof_index;
 
  enum BlockingStrategy
  {
    index_intervals,
    adaptive
  };
 
  SparseBlockVanka(const SparseMatrix<number> &M,
                   const std::vector<bool>    &selected,
                   const unsigned int          n_blocks,
                   const BlockingStrategy      blocking_strategy);
 
  template <typename number2>
  void
  vmult(Vector<number2> &dst, const Vector<number2> &src) const;
 
 
  template <typename number2>
  void
  Tvmult(Vector<number2> &dst, const Vector<number2> &src) const;
 
  std::size_t
  memory_consumption() const;
 
private:
  const unsigned int n_blocks;
 
  std::vector<std::vector<bool>> dof_masks;
 
  void
  compute_dof_masks(const SparseMatrix<number> &M,
                    const std::vector<bool>    &selected,
                    const BlockingStrategy      blocking_strategy);
};
 
/* ---------------------------------- Inline functions ------------------- */
 
#ifndef DOXYGEN
 
template <typename number>
inline typename SparseVanka<number>::size_type
SparseVanka<number>::m() const
{
  Assert(_m != 0, ExcNotInitialized());
  return _m;
}
 
template <typename number>
inline typename SparseVanka<number>::size_type
SparseVanka<number>::n() const
{
  Assert(_n != 0, ExcNotInitialized());
  return _n;
}
 
#endif // DOXYGEN
 
DEAL_II_NAMESPACE_CLOSE
 
#endif