richardsonlinearsolver.h

Go to the documentation of this file.

#ifndef RICHARDSON_LINEAR_SOLVER_H_
#define RICHARDSON_LINEAR_SOLVER_H_

#include <deal.II/lac/vector.h>
#include <deal.II/lac/block_sparsity_pattern.h>
#include <deal.II/lac/block_sparse_matrix.h>
#include <deal.II/lac/compressed_simple_sparsity_pattern.h>
#include <deal.II/lac/solver_richardson.h>
#include <deal.II/lac/precondition.h>
#include <deal.II/lac/full_matrix.h>

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

#include <deal.II/numerics/vector_tools.h>

#include <vector>

namespace DOpE
{

  template <typename PRECONDITIONER, typename SPARSITYPATTERN, typename MATRIX, typename VECTOR>
    class RichardsonLinearSolverWithMatrix
  {
  public:
    RichardsonLinearSolverWithMatrix( ParameterReader &param_reader);
    ~RichardsonLinearSolverWithMatrix();

    static void declare_params(ParameterReader &param_reader);
    
    template<typename PROBLEM>
      void ReInit(PROBLEM& pde);

    template<typename PROBLEM, typename INTEGRATOR>
      void Solve(PROBLEM& pde,INTEGRATOR& integr, VECTOR &rhs, VECTOR &solution, bool force_matrix_build=false);
     
  protected:

  private:
    SPARSITYPATTERN sparsity_pattern_;
    MATRIX matrix_;

    double linear_global_tol_, linear_tol_;
    int  linear_maxiter_;
  };

/*********************************Implementation************************************************/

template <typename PRECONDITIONER,typename SPARSITYPATTERN, typename MATRIX, typename VECTOR>
 void RichardsonLinearSolverWithMatrix<PRECONDITIONER,SPARSITYPATTERN,MATRIX,VECTOR>::declare_params(ParameterReader &param_reader)
  {
    param_reader.SetSubsection("richardsonwithmatrix parameters");
    param_reader.declare_entry("linear_global_tol", "1.e-10",Patterns::Double(0),"global tolerance for the richardson iteration");
    param_reader.declare_entry("linear_maxiter", "1000",Patterns::Integer(0),"maximal number of richardson steps");
  }
/******************************************************/

  template <typename PRECONDITIONER,typename SPARSITYPATTERN, typename MATRIX, typename VECTOR>
    RichardsonLinearSolverWithMatrix<PRECONDITIONER,SPARSITYPATTERN,MATRIX,VECTOR>
    ::RichardsonLinearSolverWithMatrix(ParameterReader &param_reader) 
{
  param_reader.SetSubsection("richardsonwithmatrix parameters");
  linear_global_tol_ = param_reader.get_double ("linear_global_tol");
  linear_maxiter_    = param_reader.get_integer ("linear_maxiter"); 
}

/******************************************************/

template <typename PRECONDITIONER,typename SPARSITYPATTERN, typename MATRIX, typename VECTOR>
  RichardsonLinearSolverWithMatrix<PRECONDITIONER,SPARSITYPATTERN,MATRIX,VECTOR>::~RichardsonLinearSolverWithMatrix()
{
}

/******************************************************/

template <typename PRECONDITIONER,typename SPARSITYPATTERN, typename MATRIX, typename VECTOR>
  template<typename PROBLEM>
  void  RichardsonLinearSolverWithMatrix<PRECONDITIONER,SPARSITYPATTERN,MATRIX,VECTOR>::ReInit(PROBLEM& pde)
{
  matrix_.clear();
  pde.ComputeSparsityPattern(sparsity_pattern_);
  matrix_.reinit(sparsity_pattern_);
}

/******************************************************/

template <typename PRECONDITIONER,typename SPARSITYPATTERN, typename MATRIX, typename VECTOR>
  template<typename PROBLEM, typename INTEGRATOR>
  void RichardsonLinearSolverWithMatrix<PRECONDITIONER,SPARSITYPATTERN,MATRIX,VECTOR>::Solve(PROBLEM& pde, 
                                                                                        INTEGRATOR& integr,
                                                                                        VECTOR &rhs, 
                                                                                        VECTOR &solution, 
                                                                                        bool force_matrix_build)
{
  if(force_matrix_build)
  { 
    integr.ComputeMatrix (pde,matrix_);
  }
 
  integr.ApplyNewtonBoundaryValues(pde,matrix_,rhs,solution);

  dealii::SolverControl solver_control (linear_maxiter_, linear_global_tol_,false,false);
  
  dealii::SolverRichardson<VECTOR> richardson(solver_control);
  PRECONDITIONER precondition;
  precondition.initialize(matrix_);
  richardson.solve (matrix_, solution, rhs,
    precondition);

  pde.GetDoFConstraints().distribute(solution);
}


}
#endif