sparse_vanka.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 1999 - 2019 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_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/smartpointer.h>
 
#include <map>
#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,
              const bool                  conserve_memory = false,
              const unsigned int n_threads = MultithreadInfo::n_threads());
 
  ~SparseVanka();
 
  class AdditionalData
  {
  public:
    AdditionalData(const std::vector<bool> &selected,
                   const bool               conserve_memory = false,
                   const unsigned int n_threads = MultithreadInfo::n_threads());
 
    const std::vector<bool> &selected;
 
    const bool conserve_mem;
 
    const unsigned int n_threads;
  };
 
 
  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;
 
  size_type
  m() const;
 
  size_type
  n() const;
 
protected:
  template <typename number2>
  void
  apply_preconditioner(Vector<number2> &              dst,
                       const Vector<number2> &        src,
                       const std::vector<bool> *const dof_mask = nullptr) const;
 
  std::size_t
  memory_consumption() const;
 
private:
  SmartPointer<const SparseMatrix<number>, SparseVanka<number>> matrix;
 
  bool conserve_mem;
 
  const std::vector<bool> *selected;
 
  unsigned int n_threads;
 
  mutable std::vector<SmartPointer<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,
                   const bool                  conserve_memory = false,
                   const unsigned int n_threads = MultithreadInfo::n_threads());
 
  template <typename number2>
  void
  vmult(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;
}
 
template <typename number>
template <typename number2>
inline void
SparseVanka<number>::Tvmult(Vector<number2> & /*dst*/,
                            const Vector<number2> & /*src*/) const
{
  AssertThrow(false, ExcNotImplemented());
}
 
#endif // DOXYGEN
 
DEAL_II_NAMESPACE_CLOSE
 
#endif