deflation.h

Go to the documentation of this file.

#pragma once
 
#include <invert_quda.h>
#include <vector>
#include <complex_quda.h>
 
namespace quda {
 
  struct DeflationParam {
 
    QudaEigParam  &eig_global;
 
    ColorSpinorField *RV;  
    
    double *invRitzVals;
 
    DiracMatrix &matDeflation;
 
    Complex *matProj; 
 
    int ld;
 
    int tot_dim;
 
    int cur_dim;
 
    bool use_inv_ritz;
 
    QudaFieldLocation location;
 
    char filename[100];
 
    DeflationParam(QudaEigParam &param, ColorSpinorField *RV,  DiracMatrix &matDeflation, int cur_dim = 0) : eig_global(param), RV(RV), matDeflation(matDeflation), 
             cur_dim(cur_dim), use_inv_ritz(false), location(param.location) {
 
        if(param.nk == 0 || param.np == 0 || (param.np % param.nk != 0)) errorQuda("\nIncorrect deflation space parameters...\n");
        // redesign: param.nk => param.n_ev, param.np => param.deflation_grid*param.n_ev;
        tot_dim      = param.np;
        ld           = ((tot_dim+15) / 16) * tot_dim;
        //allocate deflation resources:
        matProj      = new Complex[ld*tot_dim];
        invRitzVals  = new double[tot_dim];
 
        //Check that RV is a composite field:
        if(RV->IsComposite() == false) errorQuda("\nRitz vectors must be contained in a composite field.\n");
 
        cudaHostRegister(matProj,ld*tot_dim*sizeof(Complex),cudaHostRegisterDefault);
     }
 
     ~DeflationParam(){
        cudaHostUnregister(matProj);
        if(matProj) delete[]  matProj;
        if(invRitzVals)       delete[]  invRitzVals;
     }
  };
 
  class Deflation {
 
  private:
    DeflationParam &param;
 
    TimeProfile profile;
 
    ColorSpinorField *r;
 
    ColorSpinorField *Av;
 
    ColorSpinorField *r_sloppy;
 
    ColorSpinorField *Av_sloppy;
 
 
  public:
    Deflation(DeflationParam &param, TimeProfile &profile);
 
    virtual ~Deflation();
 
    void verify();
 
    void increment(ColorSpinorField &V, int n_ev);
 
    void reduce(double tol, int max_n_ev);
 
    void operator()(ColorSpinorField &out, ColorSpinorField &in);
 
    void loadVectors(ColorSpinorField *RV);
 
    void saveVectors(ColorSpinorField *RV);
 
    bool is_complete() {return (param.cur_dim == param.tot_dim);}
 
    int size() {return param.cur_dim;}
 
 
    double flops() const;
 
  };
 
  struct deflated_solver {
 
    Dirac  *d;
    DiracMatrix *m;
 
    ColorSpinorField *RV;//Ritz vectors
 
    DeflationParam *deflParam;
 
    Deflation *defl;
    TimeProfile &profile;
 
    deflated_solver(QudaEigParam &eig_param, TimeProfile &profile);
 
    virtual ~deflated_solver()
    {
      profile.TPSTART(QUDA_PROFILE_FREE);
 
      if (defl) delete defl;
      if (deflParam) delete deflParam;
 
      if (RV) delete RV;
 
      if (m) delete m;
      if (d) delete d;
 
      profile.TPSTOP(QUDA_PROFILE_FREE);
    }
  };
 
} // namespace quda