fopr_CloverTerm_eo_impl.h

Go to the documentation of this file.

 
#ifndef FOPR_CLOVERTERM_EO_IMPL_ORG_INCLUDED
#define FOPR_CLOVERTERM_EO_IMPL_ORG_INCLUDED
 
#include "Fopr/fopr.h"
 
#include "Field/index_eo.h"
#include "Field/field_F.h"
#include "Tools/gammaMatrix.h"
 
#include "IO/bridgeIO.h"
using Bridge::vout;
 
class ShiftField_eo;
class Staple_eo;
class Solver_CG;
 
 
namespace Org {
  class Fopr_CloverTerm_eo : public Fopr
  {
   public:
    static const std::string class_name;
 
    // This class returns D_ee = 1-f_ee or D_oo = 1-f_oo
   private:
    Bridge::VerboseLevel m_vl;
 
    double m_kappa;
    double m_cSW;
    std::vector<int> m_boundary;
    std::string m_repr;
    std::string m_mode;
 
    int m_Nvol, m_Nvol2;
    int m_Ndim;
    int m_Nc, m_Nd, m_Ndm2;
    int m_NinF;
 
    std::vector<GammaMatrix> m_GM, m_SG;
 
    void (Fopr_CloverTerm_eo::*m_mult)(Field&, const Field&);
 
    //Field_G *m_Ueo;
    Field_G m_Ueo;
 
    Index_eo m_index_eo;
    Staple_eo *m_staple;
    ShiftField_eo *m_shift_eo;
    Solver_CG *m_solver;
 
    Field_F m_Fee_inv;
    Field_F m_Foo_inv;
 
    Field_G m_T;
 
    std::vector<Field_G> m_T2;
 
 
    Field_F m_w1, m_w2;        
    Field_F m_v1, m_v2, m_v3;  
 
    Field_G m_Ft;
    Field_G m_Cup, m_Cdn, m_Umu, m_u1, m_u2; 
 
   public:
    DEPRECATED
    Fopr_CloverTerm_eo(std::string repr) { init(repr); }
 
    Fopr_CloverTerm_eo(const Parameters& params) { init(params); }
 
    ~Fopr_CloverTerm_eo() { tidyup(); }
 
    void set_parameters(const Parameters& params);
    void set_parameters(const double kappa, const double cSW,
                        const std::vector<int> bc);
 
    void get_parameters(Parameters& params) const;
 
    void set_config(Field *U);
 
    void set_mode(const std::string mode);
 
    std::string get_mode() const { return m_mode; }
 
    void mult(Field&, const Field&);
 
    void mult_dag(Field&, const Field&);
 
    void mult_isigma(Field_F&, const Field_F&,
                     const int mu, const int nu);
 
    void D(Field& v, const Field& f, const int ieo);
 
    void mult_csw_inv(Field&, const Field&, const int ieo);
 
    int field_nvol() { return m_Nvol2; }
    int field_nin() { return 2 * m_Nc * m_Nd; }
    int field_nex() { return 1; }
 
    double flop_count();
 
   private:
 
    void init(const std::string repr);
 
    void init(const Parameters& params);
 
    void setup();
 
    void tidyup();
 
    void set_config_omp(Field *U);
 
    void set_config_impl(Field *U);
 
    void solve_csw_inv();
 
    void set_csw();
 
    void mult_csw(Field_F&, const Field_F&, const int ieo);
 
    void set_fieldstrength(Field_G&, const int, const int);
 
    inline int sg_index(const int mu, const int nu)
    { return mu * m_Ndim + nu; }
  };
}
#endif /* FOPR_CLOVERTERM_EO_IMPL_ORG_INCLUDED */