fopr_Overlap.h

Go to the documentation of this file.

#ifndef FOPR_OVERLAP_INCLUDED
#define FOPR_OVERLAP_INCLUDED

#include "fopr_Wilson.h"
#include "fopr_Sign.h"

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

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


class Fopr_Overlap : public Fopr
{
 private:
  //- parameters
  double             m_mq;             // quark mass
  double             m_M0;             // domain-wall height
  int                m_Np;             // number of poles in rational approx.
  double             m_x_min, m_x_max; // valid range of approximate sign function
  int                m_Niter;          // max iteration of shiftsolver
  double             m_Stop_cond;      // stopping condition of shift solver
  std::valarray<int> m_boundary;

  //- pointers to used classes
  Fopr_Wilson *m_fopr_w;  // kernel fermion operator.
  Fopr_Sign   *m_sign;    // sign function approximation.

  //- for low-eigenmode subtraction.
  int m_Nsbt;
  std::valarray<double> *m_ev;
  std::valarray<Field>  *m_vk;

  //- mode control
  std::string m_mode;
  void        (Fopr_Overlap::*m_mult) (Field&, const Field&);
  void        (Fopr_Overlap::*m_mult_dag) (Field&, const Field&);

 public:

  Fopr_Overlap(Fopr_Wilson *fopr)
    : Fopr()
  {
    m_fopr_w   = fopr;
    m_sign     = new Fopr_Sign(m_fopr_w);
    m_mult     = &Fopr_Overlap::mult_undef;
    m_mult_dag = &Fopr_Overlap::mult_undef;
  }

  ~Fopr_Overlap()
  {
    delete m_sign;
  }

  void set_parameters(const Parameters& params);
  void set_parameters(const double mq, const double M0, const int Np,
                      const double x_min, const double x_max,
                      const int Niter, const double Stop_cond,
                      const std::valarray<int> bc);

  void set_config(Field *U)
  {
    m_sign->set_config(U);
    // m_fopr_w->set_config() is called in m_sign.
  }

  void set_lowmodes(int Nsbt, std::valarray<double> *,
                    std::valarray<Field> *);

  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_Overlap::D;
      m_mult_dag = &Fopr_Overlap::Ddag;
    } else if (m_mode == "Ddag") {
      m_mult     = &Fopr_Overlap::Ddag;
      m_mult_dag = &Fopr_Overlap::D;
    } else if (m_mode == "DdagD") {
      m_mult     = &Fopr_Overlap::DdagD;
      m_mult_dag = &Fopr_Overlap::DdagD;
    } else if (m_mode == "H") {
      m_mult     = &Fopr_Overlap::H;
      m_mult_dag = &Fopr_Overlap::H;
    } else {
      vout.crucial(m_vl, "Fopr_Overlap: mode undefined.\n");
      abort();
    }
  }

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

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

  void mult_undef(Field& v, const Field& f)
  {
    vout.crucial(m_vl, "Fopr_Overlap: mode undefined.\n");
    abort();
  }

  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