base_multigrid.hpp

Go to the documentation of this file.

#ifndef PARALUTION_BASE_MULTIGRID_HPP_
#define PARALUTION_BASE_MULTIGRID_HPP_

#include "../solver.hpp"
#include "../../base/operator.hpp"

namespace paralution {

enum _cycle {
  Vcycle = 0,
  Wcycle = 1,
  Kcycle = 2,
  Fcycle = 3
};

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

  BaseMultiGrid();
  virtual ~BaseMultiGrid();

  virtual void Print(void) const;

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

  virtual void SetSolver(Solver<OperatorType, VectorType, ValueType> &solver);

  virtual void SetSmoother(IterativeLinearSolver<OperatorType, VectorType, ValueType> **smoother);

  virtual void SetSmootherPreIter(const int iter);

  virtual void SetSmootherPostIter(const int iter);

  virtual void SetRestrictOperator(OperatorType **op) = 0;

  virtual void SetProlongOperator(OperatorType **op) = 0;

  virtual void SetOperatorHierarchy(OperatorType **op) = 0;

  virtual void SetScaling(const bool scaling);

  virtual void SetCycle(const _cycle cycle);

  virtual void SetKcycleFull(const bool kcycle_full);

  virtual void InitLevels(const int levels);

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

  virtual void Build(void);
  virtual void Clear(void);

protected:

  // Restricts from level 'level' to 'level-1'
  virtual void Restrict_(const VectorType &fine, VectorType *coarse, const int level);

  // Prolongs from level 'level' to 'level+1'
  virtual void Prolong_(const VectorType &coarse, VectorType *fine, const int level);

  void Vcycle_(const VectorType &rhs, VectorType *x);
  void Wcycle_(const VectorType &rhs, VectorType *x);
  void Fcycle_(const VectorType &rhs, VectorType *x);
  void Kcycle_(const VectorType &rhs, VectorType *x);

  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);


  int levels_ ;
  int current_level_;
  bool scaling_;
  int iter_pre_smooth_;
  int iter_post_smooth_;
  int cycle_;
  bool kcycle_full_;

  double res_norm_;

  OperatorType **op_level_;

  Operator<ValueType> **restrict_op_level_;
  Operator<ValueType> **prolong_op_level_;

  VectorType **d_level_;
  VectorType **r_level_;
  VectorType **t_level_;
  VectorType **s_level_;
  VectorType **p_level_;
  VectorType **q_level_;
  VectorType **k_level_;
  VectorType **l_level_;

  Solver<OperatorType, VectorType, ValueType>  *solver_coarse_;
  IterativeLinearSolver<OperatorType, VectorType, ValueType> **smoother_level_;

};


}

#endif // PARALUTION_BASE_MULTIGRID_HPP_