/**
================================================================================
=                       Class Preconditioner member functions                         =
================================================================================
Author : C.Chambeyron (6 Sept 2005)
Version: 1
================================================================================
==============================================================================
*/

using namespace std;
#include "Preconditioner.h++"


// Constructors:
template<class Mat>
Preconditioner<Mat>::Preconditioner() {
    w=0.;
    Type_Of_Preconditioner=noPreconditioner;
    precond_Matrix=NULL;
}


template<class Mat>
Preconditioner<Mat>::Preconditioner(preconditioner_Type Pt, Mat& A, real_t v) {
    w=v;
    Type_Of_Preconditioner=Pt;
    precond_Matrix=&A;
}

template<class Mat>
Preconditioner<Mat>::Preconditioner( Mat& A,preconditioner_Type Pt, real_t v) {
    w=v;
    Type_Of_Preconditioner=Pt;
    precond_Matrix=&A;
}


template<class Mat>
Preconditioner<Mat>::Preconditioner(preconditioner_Type Pt, real_t v) {
    w=v;
    Type_Of_Preconditioner=Pt;
    precond_Matrix=NULL;
}
// Destructor
template<class Mat>
Preconditioner<Mat>::~Preconditioner(){}

/// print :
template<class Mat>
void Preconditioner<Mat>::print(preconditioner_Type Pt,ostream& os)
{
    os<<endl;
    os <<" preconditioning with "<<Pt<<endl;;
}


template<class Mat>
void Preconditioner<Mat>::print(preconditioner_Type Pt)
{
   print(Pt, me_ofprint);
}



// Solving:
template <class Mat> template<class Vec>
Vec   Preconditioner<Mat>::solve( Vec &B){
 
  Vec X(B); 
  Vec Y(X);  
  switch ( Type_Of_Preconditioner )
  { 
    case LU: 
    break;
    case Diag: 
             X=precond_Matrix->diagonalSolver (B,w);  
    break;                                                                                               
    case Ssor: 
             Y=precond_Matrix->lowerPartSolver(B,w);
             Y=precond_Matrix->diagonalMultiplication(Y,w);
             X=precond_Matrix->upperPartSolver(Y,w);
    break; //SsorMethod
    
    case myOwnPreconditioner:
             X=precond_Matrix->solve(B);
    break;
  }
  return X;
}


template < class Mat> template<class Vec  >
Vec   Preconditioner<Mat>::transposedSolve( Vec &B){
   if (precond_Matrix->typeOfSymmetry() >0 ) return (*this).solve(B);
                                        else return B;  
}