integrator_UpdateU.cpp

Go to the documentation of this file.

#include "integrator_UpdateU.h"

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

//- parameter entry
namespace {
  void append_entry(Parameters& param)
  {
    param.Register_int("order_of_exp_iP", 0);

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


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

//- parameters class
Parameters_Integrator_UpdateU::Parameters_Integrator_UpdateU() { append_entry(*this); }
//- end

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

//====================================================================
void Integrator_UpdateU::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
  int Nprec;

  int err = 0;
  err += params.fetch_int("order_of_exp_iP", Nprec);

  if (err) {
    vout.crucial(m_vl, "%s: fetch error, input parameter not found.\n", class_name.c_str());
    exit(EXIT_FAILURE);
  }

  set_parameters(Nprec);
}


//====================================================================
void Integrator_UpdateU::set_parameters(int Nprec)
{
  //- print input parameters
  vout.general(m_vl, "Parameters of %s:\n", class_name.c_str());
  vout.general(m_vl, "  Nprec    = %d\n", Nprec);

  //- range check
  int err = 0;
  err += ParameterCheck::non_zero(Nprec);

  if (err) {
    vout.crucial(m_vl, "%s: parameter range check failed.\n", class_name.c_str());
    exit(EXIT_FAILURE);
  }

  //- store values
  m_Nprec = Nprec;
}


//====================================================================
void Integrator_UpdateU::set_parameter_nprec(const int nprec)
{
  m_Nprec = nprec;
}


//====================================================================
namespace {
  // w = exp(alpha * v) * u
  //   = (u + alpha * v * (u + alpha/2 * v * ( ... (u + alpha/n * v * u) ... )
  inline
  void mat_exp(Mat_SU_N& w, const Mat_SU_N& v, const Mat_SU_N& u, const double alpha, const int nprec)
  {
    w = u;

    for (int i = 0; i < nprec; ++i) {
      double exf = alpha / (nprec - i);

      w  = v * w;
      w *= exf;
      w += u;
    }

    w.reunit();
  }
}

//====================================================================
void Integrator_UpdateU::evolve(const double step_size, Field_G& iP, Field_G& U)
{
  int Nvol = U.nvol();
  int Nex  = U.nex();
  int Nc   = CommonParameters::Nc();

  Mat_SU_N ut(Nc);

  for (int ex = 0; ex < Nex; ++ex) {
    for (int site = 0; site < Nvol; ++site) {
      mat_exp(ut, iP.mat(site, ex), U.mat(site, ex), step_size, m_Nprec);

      U.set_mat(site, ex, ut);
    }
  }

  notify_update();
}


//====================================================================
void Integrator_UpdateU::notify_update()
{
  for (size_t i = 0, n = m_integs.size(); i < n; ++i) {
    m_integs[i]->invalidate_cache();
  }
  for (size_t i = 0, n = m_director.size(); i < n; ++i) {
    m_director[i]->notify_linkv();
  }
}


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