alg_smear.h

Go to the documentation of this file.

//------------------------------------------------------------------
//------------------------------------------------------------------
#ifndef _ALG_SMEAR_CD_
#define _ALG_SMEAR_CD_
#include <config.h>
#include <alg/alg_base.h>
#include <alg/ape_smear_arg.h>
#include <alg/kinetic_smear_arg.h>
#include <alg/hyp_smear_arg.h>


CPS_START_NAMESPACE


class AlgSmear:public Alg
{
private:
  char *cname;

  int bool_su3_proj;
  Float tolerance  ;
  int orthog       ;
  Matrix* lat_back ;
    
public:
  
  AlgSmear( Lattice&   lat,
            CommonArg* ca ,
            int su3_proj );
  
  virtual ~AlgSmear();
  
  void run();
  

  void set_orthog( int i ) { orthog=i; }
  

  int  get_orthog() const  { return orthog; }

  void set_tol( Float x ) { tolerance = x; }
  
  Float get_tol() const { return tolerance; }

  // YA
  int ifSu3Proj() const {return bool_su3_proj;}

protected:
  

  virtual void smear_link( Matrix& link, 
                           int*    pos,
                           int      mu )=0;
  
  
};

void three_staple(Lattice& latt, Matrix& link, int *pos, int u, int orth);

void five_staple  (Lattice& latt, Matrix& link, int *pos, int u, int orth);

void seven_staple (Lattice& latt, Matrix& link, int *pos, int u, int orth);

void lepage_staple(Lattice& latt, Matrix& link, int *pos, int u, int orth);
  
int su3_proj( Matrix& x , Float tolerance );



class AlgApeSmear:public AlgSmear
{
private:
  
  Float c;
  char *cname;
  
public:

  AlgApeSmear(Lattice&     lat,
              CommonArg*   ca ,
              ApeSmearArg* asa,
              int        in_bool_su3_proj=1);

  ~AlgApeSmear()
  {;}
  
  void run();

  void set_coef( Float x ) { c = x ; }

protected:
  
  void smear_link( Matrix& mat,
                   int*    pos,
                   int      mu );
};



class AlgKineticSmear:public AlgSmear
{

private:
  
  char *cname;
  Float _coef[5];
    
public:
  
  AlgKineticSmear(Lattice&   lat,
                  CommonArg* ca ,
                  KineticSmearArg* ksa );
  
  ~AlgKineticSmear()
  {;}
  
  void run();

  void single_link( Float coef ) { _coef[0] = coef; }
  void three_link ( Float coef ) { _coef[1] = coef; }
  void five_link  ( Float coef ) { _coef[2] = coef; }
  void seven_link ( Float coef ) { _coef[3] = coef; }
  void lepage     ( Float coef ) { _coef[4] = coef; }

protected:
  
  void smear_link( Matrix& link,
                   int*    pos,
                   int      mu );
  
};




class AlgHypSmear:public AlgSmear
{
private:

  char *cname;  
  Float c1, c2, c3;
  
  const Matrix GetLink( Lattice& lat, const int* x, int mu );
  void get_vtilde( Matrix& , int*, int, int );
  void get_vbar  ( Matrix& , int*, int, int, int );
  
public:
  AlgHypSmear(Lattice&     lat, 
              CommonArg*    ca,
              HypSmearArg* hsa );
  
  ~AlgHypSmear()
  {;}
  
  void run();
  
  void set_c1( Float x ) { c1=x; }
  void set_c2( Float x ) { c2=x; }
  void set_c3( Float x ) { c3=x; }
  
protected:
  
  void smear_link( Matrix& link,
                   int*    pos,
                   int      mu );
  
};

class AlgOlegSmear:public AlgApeSmear {

private:
  
  char *cname;
  Matrix* lat_back2 ;

public:
  AlgOlegSmear(Lattice&     lat,
               CommonArg*   ca,
               ApeSmearArg* asa);
  ~AlgOlegSmear();

  Float coef;
  void run();
};

CPS_END_NAMESPACE
#endif /* _ALG_SMEAR_CD_ */

---