docs/html.1.3.x/BGQ_2fopr__CloverTerm__imp_8cpp_source.html

 #include "fopr_CloverTerm.h"


 #include "threadManager_OpenMP.h"


 #ifdef USE_PARAMETERS_FACTORY

 #include "parameters_factory.h"

 #endif


 using std::string;


 #if defined USE_GROUP_SU3

 #include "fopr_Wilson_impl_SU3.inc"

 #elif defined USE_GROUP_SU2

 #include "fopr_Wilson_impl_SU2.inc"

 #elif defined USE_GROUP_SU_N

 #include "fopr_Wilson_impl_SU_N.inc"

 #endif


 //====================================================================

 //- parameter entries

 namespace {

   void append_entry(Parameters& param)

   {

     param.Register_double("hopping_parameter", 0.0);

     param.Register_double("clover_coefficient", 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("", append_entry);

 #endif

 }

 //- end


 //- parameters class

 Parameters_Fopr_CloverTerm::Parameters_Fopr_CloverTerm() { append_entry(*this); }

 //- end


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


 //====================================================================

 void Fopr_CloverTerm::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, cSW;

   std::vector<int> bc;


   int err = 0;

   err += params.fetch_double("hopping_parameter", kappa);

   err += params.fetch_double("clover_coefficient", cSW);

   err += params.fetch_int_vector("boundary_condition", bc);


   if (err) {

     vout.crucial(m_vl, "Fopr_CloverTerm: fetch error, input parameter not found.\n");

     exit(EXIT_FAILURE);

   }


   set_parameters(kappa, cSW, bc);

 }


 //====================================================================

 void Fopr_CloverTerm::set_parameters(double kappa, double cSW,

                                      std::vector<int> bc)

 {

   //- print input parameters

   vout.general(m_vl, "Parameters of Fopr_CloverTerm:\n");

   vout.general(m_vl, "  kappa = %8.4f\n", kappa);

   vout.general(m_vl, "  cSW   = %8.4f\n", cSW);

   for (int mu = 0; mu < m_Ndim; ++mu) {

     vout.general(m_vl, "  boundary[%d] = %2d\n", mu, bc[mu]);

   }


   //- range check

   // NB. kappa,cSW == 0 is allowed.

   assert(bc.size() == m_Ndim);


   //- store values

   m_kappa = kappa;

   m_cSW   = cSW;


   // m_boundary.resize(m_Ndim);  // already resized in init.

   for (int mu = 0; mu < m_Ndim; ++mu) {

     m_boundary[mu] = bc[mu];

   }

 }


 //====================================================================

 void Fopr_CloverTerm::set_config(Field *U)

 {

   m_U = (Field_G *)U;

   set_csw();

 }


 //====================================================================

 void Fopr_CloverTerm::init(string repr)

 {

   m_Nvol = CommonParameters::Nvol();

   m_Ndim = CommonParameters::Ndim();

   m_Nc   = CommonParameters::Nc();

   m_Nd   = CommonParameters::Nd();

   m_NinF = 2 * m_Nc * m_Nd;


   m_U = 0;


   m_repr = repr;


   m_boundary.resize(m_Ndim);

   m_SG.resize(m_Ndim * m_Ndim);


   GammaMatrixSet *gmset = GammaMatrixSet::New(m_repr);


   m_GM5 = gmset->get_GM(gmset->GAMMA5);


   m_SG[sg_index(0, 1)] = gmset->get_GM(gmset->SIGMA12);

   m_SG[sg_index(1, 2)] = gmset->get_GM(gmset->SIGMA23);

   m_SG[sg_index(2, 0)] = gmset->get_GM(gmset->SIGMA31);

   m_SG[sg_index(3, 0)] = gmset->get_GM(gmset->SIGMA41);

   m_SG[sg_index(3, 1)] = gmset->get_GM(gmset->SIGMA42);

   m_SG[sg_index(3, 2)] = gmset->get_GM(gmset->SIGMA43);


   m_SG[sg_index(1, 0)] = m_SG[sg_index(0, 1)].mult(-1);

   m_SG[sg_index(2, 1)] = m_SG[sg_index(1, 2)].mult(-1);

   m_SG[sg_index(0, 2)] = m_SG[sg_index(2, 0)].mult(-1);

   m_SG[sg_index(0, 3)] = m_SG[sg_index(3, 0)].mult(-1);

   m_SG[sg_index(1, 3)] = m_SG[sg_index(3, 1)].mult(-1);

   m_SG[sg_index(2, 3)] = m_SG[sg_index(3, 2)].mult(-1);


   m_SG[sg_index(0, 0)] = gmset->get_GM(gmset->UNITY);

   m_SG[sg_index(1, 1)] = gmset->get_GM(gmset->UNITY);

   m_SG[sg_index(2, 2)] = gmset->get_GM(gmset->UNITY);

   m_SG[sg_index(3, 3)] = gmset->get_GM(gmset->UNITY);

   // these 4 gamma matrices are actually not used.


   //  m_fopr_w = new Fopr_Wilson(repr);

   if (m_repr == "Dirac") {

     m_csw = &Fopr_CloverTerm::mult_csw_dirac;

     m_gm5 = &Fopr_CloverTerm::gm5_dirac;

   } else if (m_repr == "Chiral") {

     m_csw = &Fopr_CloverTerm::mult_csw_chiral;

     m_gm5 = &Fopr_CloverTerm::gm5_chiral;

   }


   delete gmset;


   //  m_w2.reset(m_NinF,m_Nvol,1);

 }


 //====================================================================

 void Fopr_CloverTerm::tidyup()

 {

   //  nothing to do.

 }


 //====================================================================

 void Fopr_CloverTerm::mult_gm5(Field& v, const Field& f)

 {

   (this->*m_gm5)(v, f);

 }


 //====================================================================

 void Fopr_CloverTerm::gm5_dirac(Field& w, const Field& f)

 {

   int Nvc = 2 * CommonParameters::Nc();

   int Nd  = CommonParameters::Nd();


   const double *v1 = f.ptr(0);

   double       *v2 = w.ptr(0);


   int id1 = 0;

   int id2 = Nvc;

   int id3 = Nvc * 2;

   int id4 = Nvc * 3;


   // threadding applied.

   int nth = ThreadManager_OpenMP::get_num_threads();

   int ith = ThreadManager_OpenMP::get_thread_id();


   int is = m_Nvol * ith / nth;

   int ns = m_Nvol * (ith + 1) / nth - is;


   for (int site = is; site < is + ns; ++site) {

     // for (int site = 0; site < m_Nvol; ++site) {

     for (int icc = 0; icc < Nvc; icc++) {

       int in = Nvc * Nd * site;

       v2[icc + id1 + in] = v1[icc + id3 + in];

       v2[icc + id2 + in] = v1[icc + id4 + in];

       v2[icc + id3 + in] = v1[icc + id1 + in];

       v2[icc + id4 + in] = v1[icc + id2 + in];

     }

   }

 }


 //====================================================================

 void Fopr_CloverTerm::gm5_chiral(Field& w, const Field& f)

 {

   int Nvc = 2 * CommonParameters::Nc();

   int Nd  = CommonParameters::Nd();


   const double *v1 = f.ptr(0);

   double       *v2 = w.ptr(0);


   int id1 = 0;

   int id2 = Nvc;

   int id3 = Nvc * 2;

   int id4 = Nvc * 3;


   // threadding applied.

   int nth = ThreadManager_OpenMP::get_num_threads();

   int ith = ThreadManager_OpenMP::get_thread_id();


   int is = m_Nvol * ith / nth;

   int ns = m_Nvol * (ith + 1) / nth - is;


   for (int site = is; site < is + ns; ++site) {

     // for (int site = 0; site < m_Nvol; ++site) {

     for (int icc = 0; icc < Nvc; icc++) {

       int in = Nvc * Nd * site;

       v2[icc + id1 + in] = v1[icc + id1 + in];

       v2[icc + id2 + in] = v1[icc + id2 + in];

       v2[icc + id3 + in] = -v1[icc + id3 + in];

       v2[icc + id4 + in] = -v1[icc + id4 + in];

     }

   }

 }


 //====================================================================

 void Fopr_CloverTerm::mult_isigma(Field_F& v, const Field_F& w,

                                   const int mu, const int nu)

 {

   assert(mu != nu);

   mult_iGM(v, m_SG[sg_index(mu, nu)], w);

 }


 //====================================================================

 void Fopr_CloverTerm::mult_sigmaF(Field& v, const Field& f)

 {

   mult_csw(v, f);

 }


 //====================================================================

 void Fopr_CloverTerm::mult_csw(Field& v, const Field& w)

 {

   (this->*m_csw)(v, w);

 }


 //====================================================================

 void Fopr_CloverTerm::mult_csw_chiral(Field& v, const Field& w)

 {

   assert(w.nex() == 1);


   int Nc   = CommonParameters::Nc();

   int Nvc  = 2 * Nc;

   int Ndf  = 2 * Nc * Nc;

   int Nd   = CommonParameters::Nd();

   int Nvol = w.nvol();


   int id1 = 0;

   int id2 = Nvc;

   int id3 = Nvc * 2;

   int id4 = Nvc * 3;


   double kappa_cSW = m_kappa * m_cSW;


   const double *w2 = w.ptr(0);

   double       *v2 = v.ptr(0);


   double *Bx = m_Bx.ptr(0);

   double *By = m_By.ptr(0);

   double *Bz = m_Bz.ptr(0);

   double *Ex = m_Ex.ptr(0);

   double *Ey = m_Ey.ptr(0);

   double *Ez = m_Ez.ptr(0);


   // threadding applied.

   int nth = ThreadManager_OpenMP::get_num_threads();

   int ith = ThreadManager_OpenMP::get_thread_id();


   int is = m_Nvol * ith / nth;

   int ns = m_Nvol * (ith + 1) / nth - is;


   for (int site = is; site < is + ns; ++site) {

     int iv = Nvc * Nd * site;

     int ig = Ndf * site;


     for (int ic = 0; ic < Nc; ++ic) {

       int icr = 2 * ic;

       int ici = icr + 1;

       int icg = ic * Nvc + ig;


       v2[icr + id1 + iv] = 0.0;

       v2[ici + id1 + iv] = 0.0;

       v2[icr + id2 + iv] = 0.0;

       v2[ici + id2 + iv] = 0.0;


       v2[icr + id3 + iv] = 0.0;

       v2[ici + id3 + iv] = 0.0;

       v2[icr + id4 + iv] = 0.0;

       v2[ici + id4 + iv] = 0.0;


       // isigma_23 * Bx

       v2[icr + id1 + iv] -= mult_uv_i(&Bx[icg], &w2[id2 + iv], Nc);

       v2[ici + id1 + iv] += mult_uv_r(&Bx[icg], &w2[id2 + iv], Nc);

       v2[icr + id2 + iv] -= mult_uv_i(&Bx[icg], &w2[id1 + iv], Nc);

       v2[ici + id2 + iv] += mult_uv_r(&Bx[icg], &w2[id1 + iv], Nc);


       v2[icr + id3 + iv] -= mult_uv_i(&Bx[icg], &w2[id4 + iv], Nc);

       v2[ici + id3 + iv] += mult_uv_r(&Bx[icg], &w2[id4 + iv], Nc);

       v2[icr + id4 + iv] -= mult_uv_i(&Bx[icg], &w2[id3 + iv], Nc);

       v2[ici + id4 + iv] += mult_uv_r(&Bx[icg], &w2[id3 + iv], Nc);


       // isigma_31 * By

       v2[icr + id1 + iv] += mult_uv_r(&By[icg], &w2[id2 + iv], Nc);

       v2[ici + id1 + iv] += mult_uv_i(&By[icg], &w2[id2 + iv], Nc);

       v2[icr + id2 + iv] -= mult_uv_r(&By[icg], &w2[id1 + iv], Nc);

       v2[ici + id2 + iv] -= mult_uv_i(&By[icg], &w2[id1 + iv], Nc);


       v2[icr + id3 + iv] += mult_uv_r(&By[icg], &w2[id4 + iv], Nc);

       v2[ici + id3 + iv] += mult_uv_i(&By[icg], &w2[id4 + iv], Nc);

       v2[icr + id4 + iv] -= mult_uv_r(&By[icg], &w2[id3 + iv], Nc);

       v2[ici + id4 + iv] -= mult_uv_i(&By[icg], &w2[id3 + iv], Nc);


       // isigma_12 * Bz

       v2[icr + id1 + iv] -= mult_uv_i(&Bz[icg], &w2[id1 + iv], Nc);

       v2[ici + id1 + iv] += mult_uv_r(&Bz[icg], &w2[id1 + iv], Nc);

       v2[icr + id2 + iv] += mult_uv_i(&Bz[icg], &w2[id2 + iv], Nc);

       v2[ici + id2 + iv] -= mult_uv_r(&Bz[icg], &w2[id2 + iv], Nc);


       v2[icr + id3 + iv] -= mult_uv_i(&Bz[icg], &w2[id3 + iv], Nc);

       v2[ici + id3 + iv] += mult_uv_r(&Bz[icg], &w2[id3 + iv], Nc);

       v2[icr + id4 + iv] += mult_uv_i(&Bz[icg], &w2[id4 + iv], Nc);

       v2[ici + id4 + iv] -= mult_uv_r(&Bz[icg], &w2[id4 + iv], Nc);


       // isigma_41 * Ex

       v2[icr + id1 + iv] += mult_uv_i(&Ex[icg], &w2[id2 + iv], Nc);

       v2[ici + id1 + iv] -= mult_uv_r(&Ex[icg], &w2[id2 + iv], Nc);

       v2[icr + id2 + iv] += mult_uv_i(&Ex[icg], &w2[id1 + iv], Nc);

       v2[ici + id2 + iv] -= mult_uv_r(&Ex[icg], &w2[id1 + iv], Nc);


       v2[icr + id3 + iv] -= mult_uv_i(&Ex[icg], &w2[id4 + iv], Nc);

       v2[ici + id3 + iv] += mult_uv_r(&Ex[icg], &w2[id4 + iv], Nc);

       v2[icr + id4 + iv] -= mult_uv_i(&Ex[icg], &w2[id3 + iv], Nc);

       v2[ici + id4 + iv] += mult_uv_r(&Ex[icg], &w2[id3 + iv], Nc);


       // isigma_42 * Ey

       v2[icr + id1 + iv] -= mult_uv_r(&Ey[icg], &w2[id2 + iv], Nc);

       v2[ici + id1 + iv] -= mult_uv_i(&Ey[icg], &w2[id2 + iv], Nc);

       v2[icr + id2 + iv] += mult_uv_r(&Ey[icg], &w2[id1 + iv], Nc);

       v2[ici + id2 + iv] += mult_uv_i(&Ey[icg], &w2[id1 + iv], Nc);


       v2[icr + id3 + iv] += mult_uv_r(&Ey[icg], &w2[id4 + iv], Nc);

       v2[ici + id3 + iv] += mult_uv_i(&Ey[icg], &w2[id4 + iv], Nc);

       v2[icr + id4 + iv] -= mult_uv_r(&Ey[icg], &w2[id3 + iv], Nc);

       v2[ici + id4 + iv] -= mult_uv_i(&Ey[icg], &w2[id3 + iv], Nc);


       // isigma_43 * Ez

       v2[icr + id1 + iv] += mult_uv_i(&Ez[icg], &w2[id1 + iv], Nc);

       v2[ici + id1 + iv] -= mult_uv_r(&Ez[icg], &w2[id1 + iv], Nc);

       v2[icr + id2 + iv] -= mult_uv_i(&Ez[icg], &w2[id2 + iv], Nc);

       v2[ici + id2 + iv] += mult_uv_r(&Ez[icg], &w2[id2 + iv], Nc);


       v2[icr + id3 + iv] -= mult_uv_i(&Ez[icg], &w2[id3 + iv], Nc);

       v2[ici + id3 + iv] += mult_uv_r(&Ez[icg], &w2[id3 + iv], Nc);

       v2[icr + id4 + iv] += mult_uv_i(&Ez[icg], &w2[id4 + iv], Nc);

       v2[ici + id4 + iv] -= mult_uv_r(&Ez[icg], &w2[id4 + iv], Nc);


       // v *= m_kappa * m_cSW;

       v2[icr + id1 + iv] *= kappa_cSW;

       v2[ici + id1 + iv] *= kappa_cSW;

       v2[icr + id2 + iv] *= kappa_cSW;

       v2[ici + id2 + iv] *= kappa_cSW;


       v2[icr + id3 + iv] *= kappa_cSW;

       v2[ici + id3 + iv] *= kappa_cSW;

       v2[icr + id4 + iv] *= kappa_cSW;

       v2[ici + id4 + iv] *= kappa_cSW;

     }

   }

 #pragma omp barrier

 }


 //====================================================================

 void Fopr_CloverTerm::mult_csw_dirac(Field& v, const Field& w)

 {

   assert(w.nex() == 1);


   int Nc   = CommonParameters::Nc();

   int Nvc  = 2 * Nc;

   int Ndf  = 2 * Nc * Nc;

   int Nd   = CommonParameters::Nd();

   int Nvol = w.nvol();


   int id1 = 0;

   int id2 = Nvc;

   int id3 = Nvc * 2;

   int id4 = Nvc * 3;


   double kappa_cSW = m_kappa * m_cSW;


   const double *w2 = w.ptr(0);

   double       *v2 = v.ptr(0);


   double *Bx = m_Bx.ptr(0);

   double *By = m_By.ptr(0);

   double *Bz = m_Bz.ptr(0);

   double *Ex = m_Ex.ptr(0);

   double *Ey = m_Ey.ptr(0);

   double *Ez = m_Ez.ptr(0);


   // threadding applied.

   int nth = ThreadManager_OpenMP::get_num_threads();

   int ith = ThreadManager_OpenMP::get_thread_id();


   int is = m_Nvol * ith / nth;

   int ns = m_Nvol * (ith + 1) / nth - is;


   for (int site = is; site < is + ns; ++site) {

     int iv = Nvc * Nd * site;

     int ig = Ndf * site;


     for (int ic = 0; ic < Nc; ++ic) {

       int icr = 2 * ic;

       int ici = icr + 1;

       int icg = ic * Nvc + ig;


       v2[icr + id1 + iv] = 0.0;

       v2[ici + id1 + iv] = 0.0;

       v2[icr + id2 + iv] = 0.0;

       v2[ici + id2 + iv] = 0.0;


       v2[icr + id3 + iv] = 0.0;

       v2[ici + id3 + iv] = 0.0;

       v2[icr + id4 + iv] = 0.0;

       v2[ici + id4 + iv] = 0.0;


       // isigma_23 * Bx

       v2[icr + id1 + iv] -= mult_uv_i(&Bx[icg], &w2[id2 + iv], Nc);

       v2[ici + id1 + iv] += mult_uv_r(&Bx[icg], &w2[id2 + iv], Nc);

       v2[icr + id2 + iv] -= mult_uv_i(&Bx[icg], &w2[id1 + iv], Nc);

       v2[ici + id2 + iv] += mult_uv_r(&Bx[icg], &w2[id1 + iv], Nc);


       v2[icr + id3 + iv] -= mult_uv_i(&Bx[icg], &w2[id4 + iv], Nc);

       v2[ici + id3 + iv] += mult_uv_r(&Bx[icg], &w2[id4 + iv], Nc);

       v2[icr + id4 + iv] -= mult_uv_i(&Bx[icg], &w2[id3 + iv], Nc);

       v2[ici + id4 + iv] += mult_uv_r(&Bx[icg], &w2[id3 + iv], Nc);


       // isigma_31 * By

       v2[icr + id1 + iv] += mult_uv_r(&By[icg], &w2[id2 + iv], Nc);

       v2[ici + id1 + iv] += mult_uv_i(&By[icg], &w2[id2 + iv], Nc);

       v2[icr + id2 + iv] -= mult_uv_r(&By[icg], &w2[id1 + iv], Nc);

       v2[ici + id2 + iv] -= mult_uv_i(&By[icg], &w2[id1 + iv], Nc);


       v2[icr + id3 + iv] += mult_uv_r(&By[icg], &w2[id4 + iv], Nc);

       v2[ici + id3 + iv] += mult_uv_i(&By[icg], &w2[id4 + iv], Nc);

       v2[icr + id4 + iv] -= mult_uv_r(&By[icg], &w2[id3 + iv], Nc);

       v2[ici + id4 + iv] -= mult_uv_i(&By[icg], &w2[id3 + iv], Nc);


       // isigma_12 * Bz

       v2[icr + id1 + iv] -= mult_uv_i(&Bz[icg], &w2[id1 + iv], Nc);

       v2[ici + id1 + iv] += mult_uv_r(&Bz[icg], &w2[id1 + iv], Nc);

       v2[icr + id2 + iv] += mult_uv_i(&Bz[icg], &w2[id2 + iv], Nc);

       v2[ici + id2 + iv] -= mult_uv_r(&Bz[icg], &w2[id2 + iv], Nc);


       v2[icr + id3 + iv] -= mult_uv_i(&Bz[icg], &w2[id3 + iv], Nc);

       v2[ici + id3 + iv] += mult_uv_r(&Bz[icg], &w2[id3 + iv], Nc);

       v2[icr + id4 + iv] += mult_uv_i(&Bz[icg], &w2[id4 + iv], Nc);

       v2[ici + id4 + iv] -= mult_uv_r(&Bz[icg], &w2[id4 + iv], Nc);


       // isigma_41 * Ex

       v2[icr + id1 + iv] += mult_uv_i(&Ex[icg], &w2[id4 + iv], Nc);

       v2[ici + id1 + iv] -= mult_uv_r(&Ex[icg], &w2[id4 + iv], Nc);

       v2[icr + id2 + iv] += mult_uv_i(&Ex[icg], &w2[id3 + iv], Nc);

       v2[ici + id2 + iv] -= mult_uv_r(&Ex[icg], &w2[id3 + iv], Nc);


       v2[icr + id3 + iv] += mult_uv_i(&Ex[icg], &w2[id2 + iv], Nc);

       v2[ici + id3 + iv] -= mult_uv_r(&Ex[icg], &w2[id2 + iv], Nc);

       v2[icr + id4 + iv] += mult_uv_i(&Ex[icg], &w2[id1 + iv], Nc);

       v2[ici + id4 + iv] -= mult_uv_r(&Ex[icg], &w2[id1 + iv], Nc);


       // isigma_42 * Ey

       v2[icr + id1 + iv] -= mult_uv_r(&Ey[icg], &w2[id4 + iv], Nc);

       v2[ici + id1 + iv] -= mult_uv_i(&Ey[icg], &w2[id4 + iv], Nc);

       v2[icr + id2 + iv] += mult_uv_r(&Ey[icg], &w2[id3 + iv], Nc);

       v2[ici + id2 + iv] += mult_uv_i(&Ey[icg], &w2[id3 + iv], Nc);


       v2[icr + id3 + iv] -= mult_uv_r(&Ey[icg], &w2[id2 + iv], Nc);

       v2[ici + id3 + iv] -= mult_uv_i(&Ey[icg], &w2[id2 + iv], Nc);

       v2[icr + id4 + iv] += mult_uv_r(&Ey[icg], &w2[id1 + iv], Nc);

       v2[ici + id4 + iv] += mult_uv_i(&Ey[icg], &w2[id1 + iv], Nc);


       // isigma_43 * Ez

       v2[icr + id1 + iv] += mult_uv_i(&Ez[icg], &w2[id3 + iv], Nc);

       v2[ici + id1 + iv] -= mult_uv_r(&Ez[icg], &w2[id3 + iv], Nc);

       v2[icr + id2 + iv] -= mult_uv_i(&Ez[icg], &w2[id4 + iv], Nc);

       v2[ici + id2 + iv] += mult_uv_r(&Ez[icg], &w2[id4 + iv], Nc);


       v2[icr + id3 + iv] += mult_uv_i(&Ez[icg], &w2[id1 + iv], Nc);

       v2[ici + id3 + iv] -= mult_uv_r(&Ez[icg], &w2[id1 + iv], Nc);

       v2[icr + id4 + iv] -= mult_uv_i(&Ez[icg], &w2[id2 + iv], Nc);

       v2[ici + id4 + iv] += mult_uv_r(&Ez[icg], &w2[id2 + iv], Nc);


       // v *= m_kappa * m_cSW;

       v2[icr + id1 + iv] *= kappa_cSW;

       v2[ici + id1 + iv] *= kappa_cSW;

       v2[icr + id2 + iv] *= kappa_cSW;

       v2[ici + id2 + iv] *= kappa_cSW;


       v2[icr + id3 + iv] *= kappa_cSW;

       v2[ici + id3 + iv] *= kappa_cSW;

       v2[icr + id4 + iv] *= kappa_cSW;

       v2[ici + id4 + iv] *= kappa_cSW;

     }

   }

 #pragma omp barrier

 }


 //====================================================================

 void Fopr_CloverTerm::set_csw()

 {

   set_fieldstrength(m_Bx, 1, 2);

   set_fieldstrength(m_By, 2, 0);

   set_fieldstrength(m_Bz, 0, 1);

   set_fieldstrength(m_Ex, 3, 0);

   set_fieldstrength(m_Ey, 3, 1);

   set_fieldstrength(m_Ez, 3, 2);

 }


 //====================================================================

 void Fopr_CloverTerm::set_fieldstrength(Field_G& Fst,

                                         const int mu, const int nu)

 {

   int nth = ThreadManager_OpenMP::get_num_threads();


   assert(nth == 1);

   // this function must be called in single thread region.


   m_staple.upper(m_Cup, *m_U, mu, nu);  // these staple constructions

   m_staple.lower(m_Cdn, *m_U, mu, nu);  // are multi-threaded.


   //#pragma omp parallel

   {

     mult_Field_Gnd(Fst, 0, *m_U, mu, m_Cup, 0);

     multadd_Field_Gnd(Fst, 0, *m_U, mu, m_Cdn, 0, -1.0);


     mult_Field_Gdn(m_v1, 0, m_Cup, 0, *m_U, mu);

     multadd_Field_Gdn(m_v1, 0, m_Cdn, 0, *m_U, mu, -1.0);

   }


   m_shift.forward(m_v2, m_v1, mu);


   //#pragma omp parallel

   {

     axpy(Fst, 1.0, m_v2);

     ah_Field_G(Fst, 0);

     scal(Fst, 0.25);

   }

 }


 //====================================================================

 double Fopr_CloverTerm::flop_count()

 {

   // The following counting explicitly depends on the implementation

   // and to be recalculated when the code is modified.

   // Present counting is based on rev.1107. [24 Aug 2014 H.Matsufuru]


   int Lvol = CommonParameters::Lvol();


   double flop_site

     = static_cast<double>(m_Nc * m_Nd * (2 + 48 * m_Nc));

   double flop = flop_site * static_cast<double>(Lvol);


   return flop;

 }


 //====================================================================

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

Parameters::Register_int_vector
void Register_int_vector(const string &, const std::vector< int > &)
Definition: parameters.cpp:344

CommonParameters::Nd
static int Nd()
Definition: commonParameters.h:108

Fopr_CloverTerm::m_cSW
double m_cSW
Definition: fopr_CloverTerm.h:60

scal
void scal(Field &x, const double a)
scal(x, a): x = a * x
Definition: field.cpp:282

Fopr_CloverTerm::set_config
void set_config(Field *U)
setting pointer to the gauge configuration.
Definition: fopr_CloverTerm_imp.cpp:111

CommonParameters::Nc
static int Nc()
Definition: commonParameters.h:107

Bridge::vout
BridgeIO vout
Definition: bridgeIO.cpp:278

threadManager_OpenMP.h

Fopr_CloverTerm::m_v1
Field_G m_v1
Definition: fopr_CloverTerm.h:74

ThreadManager_OpenMP::get_num_threads
static int get_num_threads()
returns available number of threads.
Definition: threadManager_OpenMP.cpp:72

Parameters::Register_string
void Register_string(const string &, const string &)
Definition: parameters.cpp:351

Field::ptr
const double * ptr(const int jin, const int site, const int jex) const
Definition: field.h:133

Fopr_CloverTerm::mult_sigmaF
void mult_sigmaF(Field &, const Field &)
Definition: fopr_CloverTerm_imp.cpp:265

Fopr_CloverTerm::m_Ez
Field_G m_Ez
field strength.
Definition: fopr_CloverTerm.h:75

Fopr_CloverTerm::m_GM5
GammaMatrix m_GM5
Definition: fopr_CloverTerm.h:80

mult_Field_Gdn
void mult_Field_Gdn(Field_G &w, const int ex, const Field_G &u1, const int ex1, const Field_G &u2, const int ex2)
Definition: field_G_imp.cpp:151

CommonParameters::Ndim
static int Ndim()
Definition: commonParameters.h:109

Fopr_CloverTerm::mult_csw_chiral
void mult_csw_chiral(Field &, const Field &)
Definition: fopr_CloverTerm_imp.cpp:279

Fopr_CloverTerm::gm5_chiral
void gm5_chiral(Field &, const Field &)
Definition: fopr_CloverTerm_imp.cpp:222

Fopr_CloverTerm::m_Ex
Field_G m_Ex
Definition: fopr_CloverTerm.h:75

Bridge::BridgeIO::general
void general(const char *format,...)
Definition: bridgeIO.cpp:65

GammaMatrixSet::get_GM
GammaMatrix get_GM(GMspecies spec)
Definition: gammaMatrixSet.h:74

Fopr_CloverTerm::set_csw
void set_csw()
Definition: fopr_CloverTerm_imp.cpp:551

Field
Container of Field-type object.
Definition: field.h:39

Fopr_CloverTerm::m_Nvol
int m_Nvol
Definition: fopr_CloverTerm.h:68

Fopr_CloverTerm::set_parameters
void set_parameters(const Parameters &params)
Definition: fopr_CloverTerm_imp.cpp:58

Field::nvol
int nvol() const
Definition: field.h:116

Fopr_CloverTerm::set_fieldstrength
void set_fieldstrength(Field_G &, const int, const int)
Definition: fopr_CloverTerm_imp.cpp:563

GammaMatrixSet::UNITY
Definition: gammaMatrixSet.h:48

Parameters
Class for parameters.
Definition: parameters.h:38

Parameters_Fopr_CloverTerm::Parameters_Fopr_CloverTerm
Parameters_Fopr_CloverTerm()
Definition: fopr_CloverTerm_imp.cpp:52

Fopr_CloverTerm::m_Nd
int m_Nd
Definition: fopr_CloverTerm.h:67

CommonParameters::Lvol
static int Lvol()
Definition: commonParameters.h:91

Fopr_CloverTerm::m_staple
Staples m_staple
Definition: fopr_CloverTerm.h:73

ThreadManager_OpenMP::get_thread_id
static int get_thread_id()
returns thread id.
Definition: threadManager_OpenMP.cpp:79

Field_F
Wilson-type fermion field.
Definition: field_F.h:37

Fopr_CloverTerm::m_NinF
int m_NinF
Definition: fopr_CloverTerm.h:67

ah_Field_G
void ah_Field_G(Field_G &w, const int ex)
Definition: field_G_imp.cpp:503

Fopr_CloverTerm::m_v2
Field_G m_v2
for calculation of field strength.
Definition: fopr_CloverTerm.h:74

Field_G
SU(N) gauge field.
Definition: field_G.h:38

Fopr_CloverTerm::mult_gm5
void mult_gm5(Field &v, const Field &w)
Definition: fopr_CloverTerm_imp.cpp:181

Fopr_CloverTerm::gm5_dirac
void gm5_dirac(Field &, const Field &)
Definition: fopr_CloverTerm_imp.cpp:188

CommonParameters::Nvol
static int Nvol()
Definition: commonParameters.h:105

Fopr_CloverTerm::m_gm5
void(Fopr_CloverTerm::* m_gm5)(Field &, const Field &)
Definition: fopr_CloverTerm.h:65

Fopr_CloverTerm::m_Ey
Field_G m_Ey
Definition: fopr_CloverTerm.h:75

multadd_Field_Gdn
void multadd_Field_Gdn(Field_G &w, const int ex, const Field_G &u1, const int ex1, const Field_G &u2, const int ex2, const double ff)
Definition: field_G_imp.cpp:322

mult_Field_Gnd
void mult_Field_Gnd(Field_G &w, const int ex, const Field_G &u1, const int ex1, const Field_G &u2, const int ex2)
Definition: field_G_imp.cpp:193

mult_iGM
void mult_iGM(Field_F &y, const GammaMatrix &gm, const Field_F &x)
gamma matrix multiplication (i is multiplied)
Definition: field_F_imp.cpp:273

Fopr::m_vl
Bridge::VerboseLevel m_vl
Definition: fopr.h:113

Fopr_CloverTerm::mult_isigma
void mult_isigma(Field_F &, const Field_F &, const int mu, const int nu)
Definition: fopr_CloverTerm_imp.cpp:256

Fopr_CloverTerm::m_By
Field_G m_By
Definition: fopr_CloverTerm.h:75

Fopr_CloverTerm::m_Cdn
Field_G m_Cdn
Definition: fopr_CloverTerm.h:74

GammaMatrixSet::SIGMA41
Definition: gammaMatrixSet.h:51

GammaMatrixSet
Set of Gamma Matrices: basis class.
Definition: gammaMatrixSet.h:37

Field::nex
int nex() const
Definition: field.h:117

Fopr_CloverTerm::init
void init(std::string repr)
Definition: fopr_CloverTerm_imp.cpp:119

Fopr_CloverTerm::m_Cup
Field_G m_Cup
Definition: fopr_CloverTerm.h:74

multadd_Field_Gnd
void multadd_Field_Gnd(Field_G &w, const int ex, const Field_G &u1, const int ex1, const Field_G &u2, const int ex2, const double ff)
Definition: field_G_imp.cpp:367

axpy
void axpy(Field &y, const double a, const Field &x)
axpy(y, a, x): y := a * x + y
Definition: field.cpp:168

Fopr_CloverTerm::m_repr
std::string m_repr
Definition: fopr_CloverTerm.h:62

Bridge::BridgeIO::crucial
void crucial(const char *format,...)
Definition: bridgeIO.cpp:48

GammaMatrixSet::SIGMA23
Definition: gammaMatrixSet.h:50

Fopr_CloverTerm::flop_count
double flop_count()
this returns the number of floating point operations.
Definition: fopr_CloverTerm_imp.cpp:595

Fopr_CloverTerm::m_shift
ShiftField_lex m_shift
Definition: fopr_CloverTerm.h:72

Fopr_CloverTerm::mult_csw
void mult_csw(Field &, const Field &)
Definition: fopr_CloverTerm_imp.cpp:272

Staples::lower
void lower(Field_G &, const Field_G &, const int mu, const int nu)
constructs lower staple in mu-nu plane.
Definition: staples.cpp:152

ParametersFactory::Register
static bool Register(const std::string &realm, const creator_callback &cb)
Definition: parameters_factory.h:74

GammaMatrixSet::SIGMA42
Definition: gammaMatrixSet.h:51

Fopr_CloverTerm::m_U
const Field_G * m_U
pointer to gauge configuration.
Definition: fopr_CloverTerm.h:70

Fopr_CloverTerm::class_name
static const std::string class_name
Definition: fopr_CloverTerm.h:56

GammaMatrixSet::SIGMA12
Definition: gammaMatrixSet.h:50

Fopr_CloverTerm::m_Ndim
int m_Ndim
Definition: fopr_CloverTerm.h:67

parameters_factory.h

GammaMatrixSet::SIGMA43
Definition: gammaMatrixSet.h:51

Fopr_CloverTerm::sg_index
int sg_index(int mu, int nu)
Definition: fopr_CloverTerm.h:169

Parameters::Register_double
void Register_double(const string &, const double)
Definition: parameters.cpp:323

Fopr_CloverTerm::m_kappa
double m_kappa
Definition: fopr_CloverTerm.h:59

Fopr_CloverTerm::m_boundary
std::vector< int > m_boundary
Definition: fopr_CloverTerm.h:61

Fopr_CloverTerm::m_Nc
int m_Nc
Definition: fopr_CloverTerm.h:67

Fopr_CloverTerm::mult_csw_dirac
void mult_csw_dirac(Field &, const Field &)
Definition: fopr_CloverTerm_imp.cpp:415

Fopr_CloverTerm::tidyup
void tidyup()
Definition: fopr_CloverTerm_imp.cpp:174

Fopr_CloverTerm::m_Bx
Field_G m_Bx
Definition: fopr_CloverTerm.h:75

Parameters::fetch_double
int fetch_double(const string &key, double &val) const
Definition: parameters.cpp:124

Parameters::get_string
string get_string(const string &key) const
Definition: parameters.cpp:87

Staples::upper
void upper(Field_G &, const Field_G &, const int mu, const int nu)
constructs upper staple in mu-nu plane.
Definition: staples.cpp:128

fopr_CloverTerm.h

Fopr_CloverTerm::m_csw
void(Fopr_CloverTerm::* m_csw)(Field &, const Field &)
Definition: fopr_CloverTerm.h:64

Bridge::BridgeIO::set_verbose_level
static VerboseLevel set_verbose_level(const std::string &str)
Definition: bridgeIO.cpp:28

GammaMatrixSet::SIGMA31
Definition: gammaMatrixSet.h:50

Fopr_CloverTerm::m_Bz
Field_G m_Bz
Definition: fopr_CloverTerm.h:75

Parameters::fetch_int_vector
int fetch_int_vector(const string &key, std::vector< int > &val) const
Definition: parameters.cpp:176

GammaMatrixSet::GAMMA5
Definition: gammaMatrixSet.h:49

ShiftField_lex::forward
void forward(Field &, const Field &, const int mu)
Definition: shiftField_lex_imp.cpp:44

Fopr_CloverTerm::m_SG
std::vector< GammaMatrix > m_SG
Definition: fopr_CloverTerm.h:79