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"

#ifdef USE_FACTORY
namespace {
  Fopr *create_object()
  {
    return new Fopr_Wilson_eo();
  }


  Fopr *create_object_with_repr(const std::string& repr)
  {
    return new Fopr_Wilson_eo(repr);
  }


  bool init1 = Fopr::Factory_noarg::Register("Wilson_eo", create_object);
  bool init2 = Fopr::Factory_string::Register("Wilson_eo", create_object_with_repr);
}
#endif

//- 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::vector<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;
  std::vector<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");
    exit(EXIT_FAILURE);
  }

  set_parameters(kappa, bc);
}


//====================================================================
void Fopr_Wilson_eo::set_parameters(const double kappa, const std::vector<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::mult_undef(Field&, const Field&)
{
  vout.crucial("%s: mode undefined.\n", class_name.c_str());
  exit(EXIT_FAILURE);
}


//====================================================================
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::MeoMoe(Field& v, const Field& f)
{ m_impl->MeoMoe(v, f); }
//====================================================================

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); }

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

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

//===================================================================
void Fopr_Wilson_eo::Meo_gm5(Field& v, const Field& f, const int ieo)
{
  assert(f.nvol() == m_Nvol2);
  m_impl->Meo_gm5(v, f, ieo);
}


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

//====================================================================
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::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=====