fopr_Staggered_eo.h

Go to the documentation of this file.

#ifndef FOPR_STAGGERED_EO_INCLUDED
#define FOPR_STAGGERED_EO_INCLUDED

#include "fopr.h"
#include "field_F_1spinor.h"

#include "shiftField_eo.h"

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

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


class Fopr_Staggered_eo : public Fopr
{
 private:
  int                m_Nvol, m_Nvol2, m_Ndim;
  double             m_mq;
  Field              m_staggered_phase;
  std::valarray<int> m_boundary;
  Index_eo           m_idx;
  Field_G            *m_Ueo;
  std::string        m_mode;

  ShiftField_eo   shift;
  Field_F_1spinor *tr, *tr2;

 public:

  Fopr_Staggered_eo()
    : Fopr()
  {
    m_Nvol  = CommonParameters::Nvol();
    m_Nvol2 = m_Nvol / 2;
    m_Ndim  = CommonParameters::Ndim();
    m_boundary.resize(m_Ndim);
    m_staggered_phase.reset(1, m_Nvol, m_Ndim);
    m_Ueo = new Field_G(m_Nvol, m_Ndim);
    tr    = new Field_F_1spinor(m_Nvol2, 1);
    tr2   = new Field_F_1spinor(m_Nvol2, 1);
    set_staggered_phase();
  }

  ~Fopr_Staggered_eo()
  {
    delete tr2;
    delete tr;
    delete m_Ueo;
  }

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

  void set_config(Field *Ueo)
  {
    set_staggered_config((Field_G *)Ueo);
  }

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

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

  const Field mult(const Field& f)
  {
    if (m_mode == "Dee") {
      return MeoMoe(f);
    } else if (m_mode == "Meo") {
      return (Field)Meo(f, 0);
    } else if (m_mode == "Moe") {
      return (Field)Meo(f, 1);
    } else {
      vout.crucial(m_vl, "Fopr_Staggered_eo: mode undefined.");
      abort();
    }
  }

  void mult(Field& w, const Field& f)
  {
    if (m_mode == "Dee") {
      w = MeoMoe(f);
    } else if (m_mode == "Meo") {
      w = Meo(f, 0);
    } else if (m_mode == "Moe") {
      w = Meo(f, 1);
    } else {
      vout.crucial(m_vl, "Fopr_Staggered_eo: mode undeifined.\n");
      abort();
    }
  }

  const Field MeoMoe(const Field& f)
  {
    Field v(f);

    v -= Meo(Meo(f, 1), 0);
    return v;
  }

  //  const Field D(const Field&);
  //  const Field H(const Field&);

  const Field Meo(const Field&, const int ieo);

  // ieo=0: even <-- odd
  // ieo=1: odd  <-- even

  void mult_staggered_phase(Field&, int mu, int ieo);

  const Field Meo_gm5(const Field&, const int ieo);
  const Field mult_gm5(const Field&);

  void fprop_normalize(Field& v)
  {
    v *= 1.0 / m_mq;
  }

  void fopr_normalize(Field& v)
  {
    v *= m_mq;
  }

  int field_nvol() { return CommonParameters::Nvol() / 2; }
  int field_nin() { return 2 * CommonParameters::Nc(); }
  int field_nex() { return 1; }

 private:
  void set_staggered_phase();
  void set_staggered_config(Field_G *Ueo);
  void mult_xp(Field_F_1spinor&, const Field_F_1spinor&, const int ieo);
  void mult_xm(Field_F_1spinor&, const Field_F_1spinor&, const int ieo);
  void mult_yp(Field_F_1spinor&, const Field_F_1spinor&, const int ieo);
  void mult_ym(Field_F_1spinor&, const Field_F_1spinor&, const int ieo);
  void mult_zp(Field_F_1spinor&, const Field_F_1spinor&, const int ieo);
  void mult_zm(Field_F_1spinor&, const Field_F_1spinor&, const int ieo);
  void mult_tp(Field_F_1spinor&, const Field_F_1spinor&, const int ieo);
  void mult_tm(Field_F_1spinor&, const Field_F_1spinor&, const int ieo);
};
#endif