fopr_Wilson_eo.cpp

Go to the documentation of this file.

#include "fopr_Wilson_eo.h"
#include "fopr_Wilson_eo_impl.h"

#ifdef USE_PARAMETERS_FACTORY
#include "parameters_factory.h"
#endif

#include "threadManager_OpenMP.h"

using std::valarray;

//- parameter entries
namespace {
  void append_entry(Parameters& param)
  {
    param.Register_string("gamma_matrix_type", "NULL");

    param.Register_double("hopping_parameter", 0.0);
    param.Register_int_vector("boundary_condition", std::valarray<int>());

    param.Register_string("verbose_level", "NULL");
  }


#ifdef USE_PARAMETERS_FACTORY
  bool init_param = ParametersFactory::Register("Fopr.Wilson_eo", append_entry);
#endif
}
//- end

const std::string Fopr_Wilson_eo::class_name = "Fopr_Wilson_eo";

//====================================================================
Fopr_Wilson_eo::Fopr_Wilson_eo() : Fopr_eo()
{
  m_Nc    = CommonParameters::Nc();
  m_Nd    = CommonParameters::Nd();
  m_Ndim  = CommonParameters::Ndim();
  m_Nvol  = CommonParameters::Nvol();
  m_Nvol2 = m_Nvol / 2;

  m_impl = new Fopr_Wilson_eo_impl("Dirac");
}

//====================================================================
Fopr_Wilson_eo::Fopr_Wilson_eo(std::string repr) : Fopr_eo()
{
  m_Nc    = CommonParameters::Nc();
  m_Nd    = CommonParameters::Nd();
  m_Ndim  = CommonParameters::Ndim();
  m_Nvol  = CommonParameters::Nvol();
  m_Nvol2 = m_Nvol / 2;

  m_impl = new Fopr_Wilson_eo_impl(repr);
}

//====================================================================
Fopr_Wilson_eo::~Fopr_Wilson_eo()
{ delete m_impl; }

//====================================================================
void Fopr_Wilson_eo::set_parameters(const Parameters& params)
{
  const string str_vlevel = params.get_string("verbose_level");

  m_vl = vout.set_verbose_level(str_vlevel);

  //- fetch and check input parameters
  double        kappa;
  valarray<int> bc;

  int err = 0;
  err += params.fetch_double("hopping_parameter", kappa);
  err += params.fetch_int_vector("boundary_condition", bc);

  if (err) {
    vout.crucial(m_vl, "Fopr_Wilson_eo: fetch error, input parameter not found.\n");
    abort();
  }

  set_parameters(kappa, bc);
}

//====================================================================
void Fopr_Wilson_eo::set_parameters(const double kappa, const std::valarray<int> bc)
{ m_impl->set_parameters(kappa, bc); }

//====================================================================
void Fopr_Wilson_eo::set_config(Field *U)
{ m_impl->set_config(U); }

//====================================================================
void Fopr_Wilson_eo::assert_single_thread()
{
  ThreadManager_OpenMP::assert_single_thread(class_name);
}

//====================================================================
void Fopr_Wilson_eo::mult_undef(Field&, const Field&)
{
  vout.crucial("%s: mode undefined.\n", class_name.c_str());
  abort();
}

//====================================================================
double Fopr_Wilson_eo::flop_count()
{
  int    Lvol    = CommonParameters::Lvol();
  double flop_eo = m_impl->flop_count();  // this is only for Meo.
  double flop    = 2.0 * flop_eo
                   + static_cast<double>(4 * m_Nc * m_Nd * Lvol / 2);

  if ((m_mode == "DdagD") || (m_mode == "DDdag")) flop *= 2.0;

  return flop;
}

//====================================================================
void Fopr_Wilson_eo::D(Field& v, const Field& f)
{ m_impl->D(v, f); }

//====================================================================
void Fopr_Wilson_eo::Ddag(Field& v, const Field& f)
{ m_impl->Ddag(v, f); }

//====================================================================
void Fopr_Wilson_eo::DdagD(Field& v, const Field& f)
{ m_impl->DdagD(v, f); }

//====================================================================
void Fopr_Wilson_eo::DDdag(Field& v, const Field& f)
{ m_impl->DDdag(v, f); }

//====================================================================
void Fopr_Wilson_eo::H(Field& v, const Field& f)
{ m_impl->H(v, f); }

//====================================================================
const Field Fopr_Wilson_eo::MeoMoe(const Field& f)
{
  assert_single_thread();

  Field v(f.nin(), f.nvol(), f.nex());
  m_impl->MeoMoe(v, f);

  return v;
}

//====================================================================
const Field Fopr_Wilson_eo::D(const Field& f)
{
  assert_single_thread();

  Field v(f.nin(), f.nvol(), f.nex());
  m_impl->D(v, f);

  return v;
}

//====================================================================
const Field Fopr_Wilson_eo::Ddag(const Field& f)
{
  assert_single_thread();

  Field v(f.nin(), f.nvol(), f.nex());
  m_impl->Ddag(v, f);

  return v;
}

//====================================================================
const Field Fopr_Wilson_eo::DdagD(const Field& f)
{
  assert_single_thread();

  Field v(f.nin(), f.nvol(), f.nex());
  m_impl->DdagD(v, f);

  return v;
}

//====================================================================
const Field Fopr_Wilson_eo::DDdag(const Field& f)
{
  assert_single_thread();

  Field v(f.nin(), f.nvol(), f.nex());
  m_impl->DDdag(v, f);

  return v;
}

//====================================================================
const Field Fopr_Wilson_eo::H(const Field& f)
{
  assert_single_thread();

  Field v(f.nin(), f.nvol(), f.nex());
  m_impl->H(v, f);

  return v;
}

//====================================================================
const Field Fopr_Wilson_eo::mult_gm5(const Field& f)
{
  assert_single_thread();

  Field_F w(m_Nvol2, f.nex());
  m_impl->mult_gm5(w, f);

  return w;
}

//====================================================================
const Field_F Fopr_Wilson_eo::Meo(const Field_F& f, const int ieo)
{
  assert_single_thread();

  Field_F w(m_Nvol2, f.nex());
  m_impl->Meo(w, f, ieo);

  return w;
}

//====================================================================
const Field_F Fopr_Wilson_eo::Mdageo(const Field_F& f, const int ieo)
{
  assert_single_thread();

  Field_F w(m_Nvol2, f.nex());
  m_impl->Mdageo(w, f, ieo);

  return w;
}

//====================================================================
const Field_F Fopr_Wilson_eo::Meo_gm5(const Field_F& f, const int ieo)
{
  assert_single_thread();

  Field_F w(m_Nvol2, f.nex());
  m_impl->Mdageo(w, f, ieo);

  return w;
}

//====================================================================
const Field Fopr_Wilson_eo::gm5p(const int mu, const Field& f)
{
  assert_single_thread();

  Field_F w(m_Nvol2, f.nex());
  m_impl->gm5p(mu, w, f);

  return w;
}

//====================================================================
void Fopr_Wilson_eo::prePropD(Field& Be, Field& bo, const Field& b)
{ m_impl->prePropD(Be, bo, b); }

//====================================================================
void Fopr_Wilson_eo::postPropD(Field& x, const Field& xe, const Field& bo)
{ m_impl->postPropD(x, xe, bo); }

//====================================================================
void Fopr_Wilson_eo::prePropDag(Field& Be, Field& bo, const Field& b)
{ m_impl->prePropDag(Be, bo, b); }

//====================================================================
void Fopr_Wilson_eo::postPropDag(Field& x, const Field& xe, const Field& bo)
{ m_impl->postPropDag(x, xe, bo); }

//====================================================================
void Fopr_Wilson_eo::mult_gm5(Field& v, const Field& f)
{ m_impl->mult_gm5(v, f); }

//====================================================================
void Fopr_Wilson_eo::Meo(Field& w, const Field& f, const int ieo)
{ m_impl->Meo(w, f, ieo); }

//====================================================================
void Fopr_Wilson_eo::mult_p(int mu,
                            Field_F& w, const Field_F& f,
                            const int ieo)
{ m_impl->mult_p(mu, w, f, ieo); }

//=====================================================================
void Fopr_Wilson_eo::mult_m(int mu,
                            Field_F& w, const Field_F& f,
                            const int ieo)
{ m_impl->mult_m(mu, w, f, ieo); }

//====================================================================
//============================================================END=====