relaxation_block.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2010 - 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_relaxation_block_h
#define dealii_relaxation_block_h

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

#include <deal.II/base/smartpointer.h>
#include <deal.II/base/subscriptor.h>

#include <deal.II/lac/precondition_block_base.h>
#include <deal.II/lac/sparsity_pattern.h>
#include <deal.II/lac/vector.h>

#include <set>
#include <vector>

DEAL_II_NAMESPACE_OPEN

template <typename MatrixType,
          typename InverseNumberType = typename MatrixType::value_type,
          typename VectorType        = Vector<double>>
class RelaxationBlock : protected PreconditionBlockBase<InverseNumberType>
{
private:
  using number = typename MatrixType::value_type;

  using value_type = InverseNumberType;

public:
  using size_type = types::global_dof_index;

  class AdditionalData : public Subscriptor
  {
  public:
    AdditionalData(
      const double relaxation      = 1.,
      const bool   invert_diagonal = true,
      const bool   same_diagonal   = false,
      const typename PreconditionBlockBase<InverseNumberType>::Inversion
                   inversion = PreconditionBlockBase<InverseNumberType>::gauss_jordan,
      const double threshold         = 0.,
      VectorType * temp_ghost_vector = nullptr);

    SparsityPattern block_list;

    double relaxation;

    bool invert_diagonal;

    bool same_diagonal;

    typename PreconditionBlockBase<InverseNumberType>::Inversion inversion;

    double threshold = 0.;

    unsigned int kernel_size = 0;

    std::vector<std::vector<unsigned int>> order;

    mutable VectorType *temp_ghost_vector;

    std::size_t
    memory_consumption() const;
  };

  void
  initialize(const MatrixType &A, const AdditionalData &parameters);

  void
  clear();

  void
  invert_diagblocks();

protected:
  void
  do_step(VectorType &      dst,
          const VectorType &prev,
          const VectorType &src,
          const bool        backward) const;

  SmartPointer<const MatrixType,
               RelaxationBlock<MatrixType, InverseNumberType, VectorType>>
    A;

  SmartPointer<const AdditionalData,
               RelaxationBlock<MatrixType, InverseNumberType, VectorType>>
    additional_data;

private:
  void
  block_kernel(const size_type block_begin, const size_type block_end);
};


template <typename MatrixType,
          typename InverseNumberType = typename MatrixType::value_type,
          typename VectorType        = Vector<double>>
class RelaxationBlockJacobi
  : public virtual Subscriptor,
    protected RelaxationBlock<MatrixType, InverseNumberType, VectorType>
{
public:
  //    RelaxationBlockJacobi();

  using number = typename MatrixType::value_type;

  using typename RelaxationBlock<MatrixType, InverseNumberType, VectorType>::
    AdditionalData;

  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::initialize;

  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::clear;

  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::size;
  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::inverse;
  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::
    inverse_householder;
  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::inverse_svd;
  using PreconditionBlockBase<InverseNumberType>::log_statistics;
  void
  step(VectorType &dst, const VectorType &rhs) const;

  void
  Tstep(VectorType &dst, const VectorType &rhs) const;

  void
  vmult(VectorType &dst, const VectorType &rhs) const;

  void
  Tvmult(VectorType &dst, const VectorType &rhs) const;
};


template <typename MatrixType,
          typename InverseNumberType = typename MatrixType::value_type,
          typename VectorType        = Vector<double>>
class RelaxationBlockSOR
  : public virtual Subscriptor,
    protected RelaxationBlock<MatrixType, InverseNumberType, VectorType>
{
public:
  //    RelaxationBlockSOR();

  using number = typename MatrixType::value_type;

  using typename RelaxationBlock<MatrixType, InverseNumberType, VectorType>::
    AdditionalData;

  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::initialize;

  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::clear;

  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::size;
  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::inverse;
  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::
    inverse_householder;
  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::inverse_svd;
  using PreconditionBlockBase<InverseNumberType>::log_statistics;
  void
  step(VectorType &dst, const VectorType &rhs) const;

  void
  Tstep(VectorType &dst, const VectorType &rhs) const;

  void
  vmult(VectorType &dst, const VectorType &rhs) const;

  void
  Tvmult(VectorType &dst, const VectorType &rhs) const;
};


template <typename MatrixType,
          typename InverseNumberType = typename MatrixType::value_type,
          typename VectorType        = Vector<double>>
class RelaxationBlockSSOR
  : public virtual Subscriptor,
    protected RelaxationBlock<MatrixType, InverseNumberType, VectorType>
{
public:
  using number = typename MatrixType::value_type;

  using typename RelaxationBlock<MatrixType, InverseNumberType, VectorType>::
    AdditionalData;

  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::initialize;

  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::clear;

  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::size;
  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::inverse;
  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::
    inverse_householder;
  using RelaxationBlock<MatrixType, InverseNumberType, VectorType>::inverse_svd;
  using PreconditionBlockBase<InverseNumberType>::log_statistics;
  void
  step(VectorType &dst, const VectorType &rhs) const;

  void
  Tstep(VectorType &dst, const VectorType &rhs) const;

  void
  vmult(VectorType &dst, const VectorType &rhs) const;

  void
  Tvmult(VectorType &dst, const VectorType &rhs) const;
};


DEAL_II_NAMESPACE_CLOSE

#endif