fopr_Wilson_General_impl.h

Go to the documentation of this file.

#ifndef FOPR_WILSON_GENERAL_IMPL_INCLUDED
#define FOPR_WILSON_GENERAL_IMPL_INCLUDED

#include "fopr_Wilson_General.h"

#include "gammaMatrixSet.h"
#include "shiftField_lex.h"

#include "mat_SU_N.h"

#include "bridgeIO.h"
using Bridge::vout;


class Fopr_Wilson_General::Fopr_Wilson_General_impl
{
 public:
  static const std::string class_name;

 private:
  // lattice parameters
  int m_Nvol;
  int m_Ndim;
  int m_Nc;
  int m_Nd;

  double           m_kappa_s, m_kappa_t;
  double           m_nu_s, m_r_s;
  std::vector<int> m_boundary;

  std::string m_mode;
  std::string m_repr;

  void (Fopr_Wilson_General::Fopr_Wilson_General_impl::*m_mult)(Field&, const Field&);
  void (Fopr_Wilson_General::Fopr_Wilson_General_impl::*m_mult_dag)(Field&, const Field&);

  const Field_G *m_U;

  std::vector<GammaMatrix> m_GM;

  ShiftField_lex m_shift;
  Field_F        m_trf, m_trf2;

  Bridge::VerboseLevel m_vl;


 public:
  Fopr_Wilson_General_impl() {}

  void init(std::string repr);

  void set_parameters(const double kappa_s, const double kappa_t,
                      const double nu_s, const double r_s);
  void set_parameters(const double kappa_s, const double kappa_t,
                      const double nu_s, const double r_s,
                      const std::vector<int> bc);

  void set_config(Field *U)
  { m_U = (Field_G *)U; }

  void set_mode(std::string mode);

  std::string get_mode() const;

  inline void mult(Field& v, const Field& f)
  { (this->*m_mult)(v, f); }

  inline void mult_dag(Field& v, const Field& f)
  { (this->*m_mult_dag)(v, f); }

  void mult_gm5(Field& v, const Field& f);

  void proj_chiral(Field& w, const int ex1, const Field& v, const int ex2, const int ipm);

  void D(Field& v, const Field& f);

  void D_ex(Field& v, const int ex1, const Field& f, const int ex2);

  inline void Ddag(Field& w, const Field& f)
  {
    Field w2(f.nin(), f.nvol(), f.nex());

    mult_gm5(w, f);
    D(w2, w);
    mult_gm5(w, w2);
  }

  inline void DdagD(Field& w, const Field& f)
  {
    Field w2(f.nin(), f.nvol(), f.nex());

    D(w2, f);
    mult_gm5(w, w2);
    D(w2, w);
    mult_gm5(w, w2);
  }

  inline void DDdag(Field& w, const Field& f)
  {
    Field w2(f.nin(), f.nvol(), f.nex());

    mult_gm5(w2, f);
    D(w, w2);
    mult_gm5(w2, w);
    D(w, w2);
  }

  inline void H(Field& w, const Field& f)
  {
    Field w2(f.nin(), f.nvol(), f.nex());

    D(w2, f);
    mult_gm5(w, w2);
  }

  inline void mult_undef(Field&, const Field& f)
  {
    vout.crucial(m_vl, "%s: mode undefined.\n", class_name.c_str());
    exit(EXIT_FAILURE);
  }

  const Field_F mult_gm5p(int mu, const Field_F& w);

  void mult_gm5p(int mu, Field_F& v, const Field_F& w);

//  void gm5p(Field_F& v, const int mu, const Field_F& w);

  double flop_count();

  void mult_up(int mu, Field& w, const Field& f);
  void mult_dn(int mu, Field& w, const Field& f);

  // inline void fprop_normalize(Field& v)
  // { v *= (2.0 * m_kappa); }
  //
  // inline void fopr_normalize(Field& v)
  // { v *= 1.0 / (2.0 * m_kappa); }


 private:
  //- prohibit copy
  Fopr_Wilson_General_impl(const Fopr_Wilson_General::Fopr_Wilson_General_impl&) {}
  Fopr_Wilson_General_impl& operator=(const Fopr_Wilson_General::Fopr_Wilson_General_impl&);

//   void mult_p (int mu, Field_F&, const Field_F&);
//   void mult_m (int mu, Field_F&, const Field_F&);
};
#endif