relaxation_block.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2010 - 2016 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__relaxation_block_h
#define dealii__relaxation_block_h

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

#include <vector>
#include <set>

DEAL_II_NAMESPACE_OPEN

template <typename MatrixType, typename inverse_type=typename MatrixType::value_type>
class RelaxationBlock :
  protected PreconditionBlockBase<inverse_type>
{
private:
  typedef typename MatrixType::value_type number;

  typedef inverse_type value_type;

public:
  typedef types::global_dof_index size_type;

  class AdditionalData : public Subscriptor
  {
  public:
    AdditionalData (const double relaxation = 1.,
                    const bool invert_diagonal = true,
                    const bool same_diagonal = false);

    SparsityPattern block_list;

    double relaxation;

    bool invert_diagonal;

    bool same_diagonal;
    typename PreconditionBlockBase<inverse_type>::Inversion inversion;

    double threshold;

    std::vector<std::vector<unsigned int> > order;
    std::size_t memory_consumption() const;
  };

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

  void clear();

  bool empty () const;

  value_type el(size_type i,
                size_type j) const;

  void invert_diagblocks();

protected:
  template <typename number2>
  void do_step (
    Vector<number2>       &dst,
    const Vector<number2> &prev,
    const Vector<number2> &src,
    const bool backward) const;
  SmartPointer<const MatrixType,RelaxationBlock<MatrixType,inverse_type> > A;

  SmartPointer<const AdditionalData, RelaxationBlock<MatrixType,inverse_type> > additional_data;
};


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

  typedef typename MatrixType::value_type number;

  using typename RelaxationBlock<MatrixType,inverse_type>::AdditionalData;

  using RelaxationBlock<MatrixType, inverse_type>::initialize;

  using RelaxationBlock<MatrixType, inverse_type>::clear;

  using RelaxationBlock<MatrixType, inverse_type>::empty;
  using RelaxationBlock<MatrixType, inverse_type>::size;
  using RelaxationBlock<MatrixType, inverse_type>::inverse;
  using RelaxationBlock<MatrixType, inverse_type>::inverse_householder;
  using RelaxationBlock<MatrixType, inverse_type>::inverse_svd;
  using PreconditionBlockBase<inverse_type>::log_statistics;
  template <typename number2>
  void step (Vector<number2> &dst, const Vector<number2> &rhs) const;

  template <typename number2>
  void Tstep (Vector<number2> &dst, const Vector<number2> &rhs) const;

  std::size_t memory_consumption() const;
};


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

  typedef typename MatrixType::value_type number;

  using typename RelaxationBlock<MatrixType,inverse_type>::AdditionalData;

  using RelaxationBlock<MatrixType, inverse_type>::initialize;

  using RelaxationBlock<MatrixType, inverse_type>::clear;

  using RelaxationBlock<MatrixType, inverse_type>::empty;
  using RelaxationBlock<MatrixType, inverse_type>::size;
  using RelaxationBlock<MatrixType, inverse_type>::inverse;
  using RelaxationBlock<MatrixType, inverse_type>::inverse_householder;
  using RelaxationBlock<MatrixType, inverse_type>::inverse_svd;
  using PreconditionBlockBase<inverse_type>::log_statistics;
  template <typename number2>
  void step (Vector<number2> &dst, const Vector<number2> &rhs) const;

  template <typename number2>
  void Tstep (Vector<number2> &dst, const Vector<number2> &rhs) const;
};


template<typename MatrixType, typename inverse_type = typename MatrixType::value_type>
class RelaxationBlockSSOR : public virtual Subscriptor,
  protected RelaxationBlock<MatrixType, inverse_type>
{
public:
  typedef typename MatrixType::value_type number;

  using typename RelaxationBlock<MatrixType,inverse_type>::AdditionalData;

  using RelaxationBlock<MatrixType, inverse_type>::initialize;

  using RelaxationBlock<MatrixType, inverse_type>::clear;

  using RelaxationBlock<MatrixType, inverse_type>::empty;

  using RelaxationBlock<MatrixType, inverse_type>::size;
  using RelaxationBlock<MatrixType, inverse_type>::inverse;
  using RelaxationBlock<MatrixType, inverse_type>::inverse_householder;
  using RelaxationBlock<MatrixType, inverse_type>::inverse_svd;
  using PreconditionBlockBase<inverse_type>::log_statistics;
  template <typename number2>
  void step (Vector<number2> &dst, const Vector<number2> &rhs) const;

  template <typename number2>
  void Tstep (Vector<number2> &dst, const Vector<number2> &rhs) const;
};


DEAL_II_NAMESPACE_CLOSE

#endif