docs/html.1.3.x/fopr__CloverTerm__General__imp_8cpp_source.html

 #include "fopr_CloverTerm_General.h"


 #include "threadManager_OpenMP.h"


 #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_spatial", 0.0);

     param.Register_double("hopping_parameter_temporal", 0.0);

     param.Register_double("clover_coefficient_spatial", 0.0);

     param.Register_double("clover_coefficient_temporal", 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_General::Parameters_Fopr_CloverTerm_General() { append_entry(*this); }

 //- end


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


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

 void Fopr_CloverTerm_General::set_parameters(const Parameters& params)

 {

   const std::string str_vlevel = params.get_string("verbose_level");


   m_vl = vout.set_verbose_level(str_vlevel);


   //- fetch and check input parameters

   double           kappa_s, kappa_t, cSW_s, cSW_t;

   std::vector<int> bc;


   int err = 0;

   err += params.fetch_double("hopping_parameter_spatial", kappa_s);

   err += params.fetch_double("hopping_parameter_temporal", kappa_t);

   err += params.fetch_double("clover_coefficient_spatial", cSW_s);

   err += params.fetch_double("clover_coefficient_temporal", cSW_t);

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


   if (err) {

     vout.crucial(m_vl, "%s: fetch error, input parameter not found.\n", class_name.c_str());

     exit(EXIT_FAILURE);

   }


   set_parameters(kappa_s, kappa_t, cSW_s, cSW_t, bc);

 }


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

 void Fopr_CloverTerm_General::set_parameters(double kappa_s, double kappa_t,

                                              double cSW_s, double cSW_t,

                                              std::vector<int> bc)

 {

   //- print input parameters

   vout.general(m_vl, "Parameters of %s:\n", class_name.c_str());

   vout.general(m_vl, "  kappa_s = %12.8f\n", kappa_s);

   vout.general(m_vl, "  kappa_t = %12.8f\n", kappa_t);

   vout.general(m_vl, "  cSW_s   = %12.8f\n", cSW_s);

   vout.general(m_vl, "  cSW_t   = %12.8f\n", cSW_t);

   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_s = kappa_s;

   m_kappa_t = kappa_t;

   m_cSW_s   = cSW_s;

   m_cSW_t   = cSW_t;


   // 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_General::set_config(Field *U)

 {

   m_U = (Field_G *)U;

   set_csw();

 }


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

 void Fopr_CloverTerm_General::init(std::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);


   unique_ptr<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_General::mult_csw_dirac;

     m_gm5 = &Fopr_CloverTerm_General::gm5_dirac;

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

     m_csw = &Fopr_CloverTerm_General::mult_csw_chiral;

     m_gm5 = &Fopr_CloverTerm_General::gm5_chiral;

   }


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

 }


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

 void Fopr_CloverTerm_General::tidyup()

 {

   //  nothing to do.

 }


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

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

 {

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

 }


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

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

 {

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

   const 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 Nthread  = ThreadManager_OpenMP::get_num_threads();

   int i_thread = ThreadManager_OpenMP::get_thread_id();


   int is = m_Nvol * i_thread / Nthread;

   int ns = m_Nvol * (i_thread + 1) / Nthread - 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_General::gm5_chiral(Field& w, const Field& f)

 {

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

   const 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 Nthread  = ThreadManager_OpenMP::get_num_threads();

   int i_thread = ThreadManager_OpenMP::get_thread_id();


   int is = m_Nvol * i_thread / Nthread;

   int ns = m_Nvol * (i_thread + 1) / Nthread - 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_General::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_General::mult_sigmaF(Field& v, const Field& f)

 {

   mult_csw(v, f);

 }


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

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

 {

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

 }


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

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

 {

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


   const int Nc   = CommonParameters::Nc();

   const int Nvc  = 2 * Nc;

   const int Ndf  = 2 * Nc * Nc;

   const int Nd   = CommonParameters::Nd();

   const int Nvol = w.nvol();


   const int id1 = 0;

   const int id2 = Nvc;

   const int id3 = Nvc * 2;

   const int id4 = Nvc * 3;


   const double kappa_cSW_s = m_kappa_s * m_cSW_s;

   const double kappa_cSW_t = m_kappa_t * m_cSW_t;


   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 Nthread  = ThreadManager_OpenMP::get_num_threads();

   int i_thread = ThreadManager_OpenMP::get_thread_id();


   int is = m_Nvol * i_thread / Nthread;

   int ns = m_Nvol * (i_thread + 1) / Nthread - 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] -= kappa_cSW_s * mult_uv_i(&Bx[icg], &w2[id2 + iv], Nc);

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

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

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


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

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

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

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


       // isigma_31 * By

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

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

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

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


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

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

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

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


       // isigma_12 * Bz

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

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

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

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


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

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

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

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


       // isigma_41 * Ex

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

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

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

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


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

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

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

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


       // isigma_42 * Ey

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

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

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

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


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

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

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

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


       // isigma_43 * Ez

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

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

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

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


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

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

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

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

     }

   }

 #pragma omp barrier

 }


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

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

 {

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


   const int Nc   = CommonParameters::Nc();

   const int Nvc  = 2 * Nc;

   const int Ndf  = 2 * Nc * Nc;

   const int Nd   = CommonParameters::Nd();

   const int Nvol = w.nvol();


   const int id1 = 0;

   const int id2 = Nvc;

   const int id3 = Nvc * 2;

   const int id4 = Nvc * 3;


   const double kappa_cSW_s = m_kappa_s * m_cSW_s;

   const double kappa_cSW_t = m_kappa_t * m_cSW_t;


   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 Nthread  = ThreadManager_OpenMP::get_num_threads();

   int i_thread = ThreadManager_OpenMP::get_thread_id();


   int is = m_Nvol * i_thread / Nthread;

   int ns = m_Nvol * (i_thread + 1) / Nthread - 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] -= kappa_cSW_s * mult_uv_i(&Bx[icg], &w2[id2 + iv], Nc);

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

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

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


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

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

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

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


       // isigma_31 * By

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

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

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

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


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

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

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

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


       // isigma_12 * Bz

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

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

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

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


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

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

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

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


       // isigma_41 * Ex

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

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

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

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


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

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

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

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


       // isigma_42 * Ey

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

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

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

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


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

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

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

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


       // isigma_43 * Ez

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

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

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

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


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

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

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

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

     }

   }

 #pragma omp barrier

 }


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

 void Fopr_CloverTerm_General::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_General::set_fieldstrength(Field_G& Fst,

                                                 const int mu, const int nu)

 {

   int Nthread = ThreadManager_OpenMP::get_num_threads();


   assert(Nthread == 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_General::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]


   const 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

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

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

Fopr_CloverTerm_General::m_cSW_s
double m_cSW_s
Definition: fopr_CloverTerm_General.h:53

Fopr_CloverTerm_General::flop_count
double flop_count()
this returns the number of floating point operations.
Definition: fopr_CloverTerm_General_imp.cpp:576

Fopr_CloverTerm_General::m_Ex
Field_G m_Ex
Definition: fopr_CloverTerm_General.h:68

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

threadManager_OpenMP.h

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

Fopr_CloverTerm_General::m_Nd
int m_Nd
Definition: fopr_CloverTerm_General.h:60

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

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

Parameters_Fopr_CloverTerm_General::Parameters_Fopr_CloverTerm_General
Parameters_Fopr_CloverTerm_General()
Definition: fopr_CloverTerm_General_imp.cpp:48

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_General::m_Ndim
int m_Ndim
Definition: fopr_CloverTerm_General.h:60

Fopr_CloverTerm_General::m_By
Field_G m_By
Definition: fopr_CloverTerm_General.h:68

Fopr_CloverTerm_General::m_Ey
Field_G m_Ey
Definition: fopr_CloverTerm_General.h:68

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

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

Fopr_CloverTerm_General::m_Nvol
int m_Nvol
Definition: fopr_CloverTerm_General.h:61

GammaMatrixSet::UNITY
Definition: gammaMatrixSet.h:48

Fopr_CloverTerm_General::m_kappa_s
double m_kappa_s
Definition: fopr_CloverTerm_General.h:52

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

Fopr_CloverTerm_General::init
void init(std::string repr)
Definition: fopr_CloverTerm_General_imp.cpp:122

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

Fopr_CloverTerm_General::set_fieldstrength
void set_fieldstrength(Field_G &, const int, const int)
Definition: fopr_CloverTerm_General_imp.cpp:544

Fopr_CloverTerm_General::gm5_dirac
void gm5_dirac(Field &, const Field &)
Definition: fopr_CloverTerm_General_imp.cpp:189

Fopr_CloverTerm_General::m_v2
Field_G m_v2
for calculation of field strength.
Definition: fopr_CloverTerm_General.h:67

Fopr_CloverTerm_General::mult_csw_chiral
void mult_csw_chiral(Field &, const Field &)
Definition: fopr_CloverTerm_General_imp.cpp:280

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

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

Fopr_CloverTerm_General::m_SG
std::vector< GammaMatrix > m_SG
Definition: fopr_CloverTerm_General.h:72

Fopr_CloverTerm_General::m_kappa_t
double m_kappa_t
Definition: fopr_CloverTerm_General.h:52

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

Fopr_CloverTerm_General::m_v1
Field_G m_v1
Definition: fopr_CloverTerm_General.h:67

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

Fopr_CloverTerm_General::mult_csw_dirac
void mult_csw_dirac(Field &, const Field &)
Definition: fopr_CloverTerm_General_imp.cpp:406

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_CloverTerm_General::mult_gm5
void mult_gm5(Field &v, const Field &w)
Definition: fopr_CloverTerm_General_imp.cpp:182

Fopr_CloverTerm_General::tidyup
void tidyup()
Definition: fopr_CloverTerm_General_imp.cpp:175

Fopr_CloverTerm_General::m_cSW_t
double m_cSW_t
Definition: fopr_CloverTerm_General.h:53

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

Fopr_CloverTerm_General::set_config
void set_config(Field *U)
setting pointer to the gauge configuration.
Definition: fopr_CloverTerm_General_imp.cpp:114

GammaMatrixSet::SIGMA41
Definition: gammaMatrixSet.h:51

Fopr_CloverTerm_General::mult_isigma
void mult_isigma(Field_F &, const Field_F &, const int mu, const int nu)
Definition: fopr_CloverTerm_General_imp.cpp:257

Fopr_CloverTerm_General::mult_csw
void mult_csw(Field &, const Field &)
Definition: fopr_CloverTerm_General_imp.cpp:273

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

Fopr_CloverTerm_General::m_csw
void(Fopr_CloverTerm_General::* m_csw)(Field &, const Field &)
Definition: fopr_CloverTerm_General.h:57

Fopr_CloverTerm_General::set_parameters
void set_parameters(const Parameters &params)
Definition: fopr_CloverTerm_General_imp.cpp:54

Fopr_CloverTerm_General::m_repr
std::string m_repr
Definition: fopr_CloverTerm_General.h:55

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

Fopr_CloverTerm_General::m_Cdn
Field_G m_Cdn
Definition: fopr_CloverTerm_General.h:67

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_General::gm5_chiral
void gm5_chiral(Field &, const Field &)
Definition: fopr_CloverTerm_General_imp.cpp:223

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

GammaMatrixSet::SIGMA23
Definition: gammaMatrixSet.h:50

Fopr_CloverTerm_General::m_U
const Field_G * m_U
pointer to gauge configuration.
Definition: fopr_CloverTerm_General.h:63

Fopr_CloverTerm_General::m_GM5
GammaMatrix m_GM5
Definition: fopr_CloverTerm_General.h:73

Fopr_CloverTerm_General::mult_sigmaF
void mult_sigmaF(Field &, const Field &)
Definition: fopr_CloverTerm_General_imp.cpp:266

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_General::m_shift
ShiftField_lex m_shift
Definition: fopr_CloverTerm_General.h:65

Fopr_CloverTerm_General::m_Ez
Field_G m_Ez
field strength.
Definition: fopr_CloverTerm_General.h:68

Fopr_CloverTerm_General::m_boundary
std::vector< int > m_boundary
Definition: fopr_CloverTerm_General.h:54

GammaMatrixSet::SIGMA12
Definition: gammaMatrixSet.h:50

GammaMatrixSet::SIGMA43
Definition: gammaMatrixSet.h:51

Fopr_CloverTerm_General::m_Cup
Field_G m_Cup
Definition: fopr_CloverTerm_General.h:67

fopr_CloverTerm_General.h

Fopr_CloverTerm_General::m_gm5
void(Fopr_CloverTerm_General::* m_gm5)(Field &, const Field &)
Definition: fopr_CloverTerm_General.h:58

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

Fopr_CloverTerm_General::class_name
static const std::string class_name
Definition: fopr_CloverTerm_General.h:49

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

Bridge::unique_ptr
Definition: unique_pointer.h:24

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

Fopr_CloverTerm_General::m_staple
Staples m_staple
Definition: fopr_CloverTerm_General.h:66

Fopr_CloverTerm_General::m_Bz
Field_G m_Bz
Definition: fopr_CloverTerm_General.h:68

Fopr_CloverTerm_General::set_csw
void set_csw()
Definition: fopr_CloverTerm_General_imp.cpp:532

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_General::m_NinF
int m_NinF
Definition: fopr_CloverTerm_General.h:60

Fopr_CloverTerm_General::m_Nc
int m_Nc
Definition: fopr_CloverTerm_General.h:60

Fopr_CloverTerm_General::m_Bx
Field_G m_Bx
Definition: fopr_CloverTerm_General.h:68

Fopr_CloverTerm_General::sg_index
int sg_index(int mu, int nu)
Definition: fopr_CloverTerm_General.h:163

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

GammaMatrixSet::SIGMA31
Definition: gammaMatrixSet.h:50

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