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.nev, param.np => param.deflation_grid*param.nev;
        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 nev);

    void reduce(double tol, int max_nev);

    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