fopr_Wilson_impl.h

Go to the documentation of this file.

#ifndef FOPR_WILSON_IMPL_INCLUDED
#define FOPR_WILSON_IMPL_INCLUDED

#include "fopr_Wilson.h"

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

#include "mat_SU_N.h"

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


class Fopr_Wilson::Fopr_Wilson_impl
{
 public:
  static const std::string class_name;

 public:

  Fopr_Wilson_impl() {}

  void init(std::string repr);

  void set_parameters(const double kappa);
  void set_parameters(const double kappa, const std::valarray<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());
    abort();
  }

  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_impl(const Fopr_Wilson::Fopr_Wilson_impl&) {}
  Fopr_Wilson_impl& operator=(const Fopr_Wilson::Fopr_Wilson_impl&);


  Bridge::VerboseLevel m_vl;

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

  double             m_kappa;
  std::valarray<int> m_boundary;

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

  void (Fopr_Wilson::Fopr_Wilson_impl::*m_mult)(Field &, const Field &);
  void (Fopr_Wilson::Fopr_Wilson_impl::*m_mult_dag)(Field &, const Field &);

  const Field_G *m_U;

  std::valarray<GammaMatrix> m_GM;

  ShiftField_lex shift;
  Field_F        trf, trf2;

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