fopr_TMWilson.h

Go to the documentation of this file.

#ifndef FOPR_TMWILSON_INCLUDED
#define FOPR_TMWILSON_INCLUDED

#include "fopr_Wilson.h"

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


//- parameters class
class Parameters_Fopr_TMWilson : virtual public Parameters
{
 public:
  Parameters_Fopr_TMWilson();
};
//- end

class Fopr_TMWilson : public Fopr
{
 private:
  int                m_Nvol, m_Ndim;
  double             m_kappa, m_tw_mass;
  std::valarray<int> m_boundary;

  Fopr_Wilson *m_fopr_w;
  std::string m_mode;
  std::string m_repr;

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

  const Field_G *m_U;

 public:
  Fopr_TMWilson()
    : Fopr()
  {
    m_Nvol = CommonParameters::Nvol();
    m_Ndim = CommonParameters::Ndim();
    m_boundary.resize(m_Ndim);
    m_U        = 0;
    m_mult     = &Fopr_TMWilson::mult_undef;
    m_mult_dag = &Fopr_TMWilson::mult_undef;
    m_repr     = "Dirac";
    m_fopr_w   = new Fopr_Wilson(m_repr);
  }

  Fopr_TMWilson(std::string repr)
    : Fopr()
  {
    m_Nvol = CommonParameters::Nvol();
    m_Ndim = CommonParameters::Ndim();
    m_boundary.resize(m_Ndim);
    m_U        = 0;
    m_mult     = &Fopr_TMWilson::mult_undef;
    m_mult_dag = &Fopr_TMWilson::mult_undef;
    m_repr     = repr;
    m_fopr_w   = new Fopr_Wilson(m_repr);
  }

  ~Fopr_TMWilson()
  {
    delete m_fopr_w;
  }

  void set_parameters(const Parameters& params);
  void set_parameters(double kappa, double tw_mass, std::valarray<int> bc);

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

  const Field mult(const Field& f)
  {
    Field v(f.nin(), f.nvol(), f.nex());

    mult(v, f);
    return v;
  }

  const Field mult_dag(const Field& f)
  {
    Field v(f.nin(), f.nvol(), f.nex());

    mult_dag(v, f);
    return v;
  }

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

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

  void set_mode(std::string mode)
  {
    m_mode = mode;

    if (m_mode == "D") {
      m_mult     = &Fopr_TMWilson::D;
      m_mult_dag = &Fopr_TMWilson::Ddag;
    } else if (m_mode == "Ddag") {
      m_mult     = &Fopr_TMWilson::Ddag;
      m_mult_dag = &Fopr_TMWilson::D;
    } else if (m_mode == "DdagD") {
      m_mult     = &Fopr_TMWilson::DdagD;
      m_mult_dag = &Fopr_TMWilson::DdagD;
    } else if (m_mode == "H") {
      m_mult     = &Fopr_TMWilson::H;
      m_mult_dag = &Fopr_TMWilson::Hdag;
    } else {
      vout.crucial(m_vl, "Fopr_TMWilson: input mode is undefined.\n");
      abort();
    }
  }

  std::string get_mode() const
  {
    return m_mode;
  }

  const Field mult_gm5(const Field& f)
  {
    Field v(f.nin(), f.nvol(), f.nex());

    mult_gm5(v, f);
    return v;
  }

  void mult_gm5(Field& v, const Field& f)
  {
    m_fopr_w->mult_gm5(v, f);
  }

  void D(Field&, const Field&);
  void DdagD(Field&, const Field&);
  void Ddag(Field&, const Field&);
  void H(Field&, const Field&);
  void Hdag(Field&, const Field&);

  void mult_undef(Field&, const Field&)
  {
    vout.crucial(m_vl, "Fopr_TMWilson: input mode is undefined.\n");
    abort();
  }

  const Field_F mult_gm5p(int mu, const Field_F& w)
  {
    return m_fopr_w->mult_gm5p(mu, w);
  }

  void fprop_normalize(Field& v)
  {
    m_fopr_w->fprop_normalize(v);
  }

  void fopr_normalize(Field& v)
  {
    m_fopr_w->fopr_normalize(v);
  }

  int field_nvol() { return m_fopr_w->field_nvol(); }
  int field_nin() { return m_fopr_w->field_nin(); }
  int field_nex() { return m_fopr_w->field_nex(); }
};
#endif