solver.hpp

Go to the documentation of this file.

#ifndef PARALUTION_SOLVER_HPP_
#define PARALUTION_SOLVER_HPP_

#include "iter_ctrl.hpp"
#include "../base/base_paralution.hpp"
#include "../base/local_vector.hpp"

namespace paralution {

template <class OperatorType, class VectorType, typename ValueType>
class Solver : public ParalutionObj {

public:

  Solver();
  virtual ~Solver();

  void SetOperator(const OperatorType &op);

  virtual void ResetOperator(const OperatorType &op);

  virtual void Print(void) const = 0;

  virtual void Solve(const VectorType &rhs,
                     VectorType *x) = 0;

  virtual void SolveZeroSol(const VectorType &rhs,
                            VectorType *x);

  virtual void Clear(void);

  virtual void Build(void);

  virtual void ReBuildNumeric(void);

  virtual void MoveToHost(void);
  virtual void MoveToAccelerator(void);

  virtual void Verbose(const int verb=1);

protected:

  const OperatorType *op_;

  Solver<OperatorType, VectorType, ValueType> *precond_;

  bool build_;

  LocalVector<int> permutation_;

  int verb_;

  virtual void PrintStart_(void) const = 0;
  virtual void PrintEnd_(void) const = 0;

  virtual void MoveToHostLocalData_(void) = 0;
  virtual void MoveToAcceleratorLocalData_(void) = 0;

};

template <class OperatorType, class VectorType, typename ValueType>
class IterativeLinearSolver : public Solver<OperatorType, VectorType, ValueType> {

public:

  IterativeLinearSolver();
  virtual ~IterativeLinearSolver();

  void Init(const double abs_tol,
            const double rel_tol,
            const double div_tol,
            const int max_iter);

  void Init(const double abs_tol,
            const double rel_tol,
            const double div_tol,
            const int min_iter,
            const int max_iter);

  void InitMinIter(const int min_iter);

  void InitMaxIter(const int max_iter);

  void InitTol(const double abs,
               const double rel,
               const double div);

  void SetResidualNorm(const int resnorm);

  void RecordResidualHistory(void);

  void RecordHistory(const std::string filename) const;

  virtual void Verbose(const int verb=1);

  virtual void Solve(const VectorType &rhs,
                     VectorType *x);

  virtual void SetPreconditioner(Solver<OperatorType, VectorType, ValueType> &precond);

  virtual int GetIterationCount(void);

  virtual double GetCurrentResidual(void);

  virtual int GetSolverStatus(void);

  virtual int GetAmaxResidualIndex(void);

protected:

  IterationControl iter_ctrl_;

  virtual void SolveNonPrecond_(const VectorType &rhs,
                                VectorType *x) = 0;

  virtual void SolvePrecond_(const VectorType &rhs,
                             VectorType *x) = 0;

  int res_norm_;

  int index_;

  ValueType Norm(const VectorType &vec);

};

template <class OperatorType, class VectorType, typename ValueType>
class FixedPoint : public IterativeLinearSolver<OperatorType, VectorType, ValueType> {

public:

  FixedPoint();
  virtual ~FixedPoint();

  virtual void Print(void) const;

  virtual void ReBuildNumeric(void);

  virtual void SetRelaxation(const ValueType omega);

  virtual void Build(void);

  virtual void Clear(void);

protected:

  ValueType omega_;
  VectorType x_old_;
  VectorType x_res_;


  virtual void SolveNonPrecond_(const VectorType &rhs,
                                VectorType *x);
  virtual void SolvePrecond_(const VectorType &rhs,
                                VectorType *x);

  virtual void PrintStart_(void) const;
  virtual void PrintEnd_(void) const;

  virtual void MoveToHostLocalData_(void);
  virtual void MoveToAcceleratorLocalData_(void);

};

template <class OperatorType, class VectorType, typename ValueType>
class DirectLinearSolver : public Solver<OperatorType, VectorType, ValueType> {

public:

  DirectLinearSolver();
  virtual ~DirectLinearSolver();

  virtual void Verbose(const int verb=1);

  virtual void Solve(const VectorType &rhs,
                     VectorType *x);

protected:

  virtual void Solve_(const VectorType &rhs, VectorType *x) = 0;

};


}

#endif // PARALUTION_SOLVER_HPP_