docs/html.1.5.x/Imp_2fopr__CloverTerm__General__impl_8cpp_source.html

 #include "fopr_CloverTerm_General_impl.h"


 #include "ResourceManager/threadManager_OpenMP.h"


 namespace Imp {

 #if defined USE_GROUP_SU3

 #include "fopr_Wilson_impl_SU3-inc.h"

 #elif defined USE_GROUP_SU2

 #include "fopr_Wilson_impl_SU2-inc.h"

 #elif defined USE_GROUP_SU_N

 #include "fopr_Wilson_impl_SU_N-inc.h"

 #endif


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


   const std::string Fopr_CloverTerm_General::class_name = "Imp::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, "Error at %s: 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(const double kappa_s, const double kappa_t,

                                                const double cSW_s, const double cSW_t,

                                                const std::vector<int> bc)

   {

     //- print input parameters

     vout.general(m_vl, "%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.

     m_boundary = bc;

   }


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

   void Fopr_CloverTerm_General::set_config(Field *U)

   {

     m_U = (Field_G *)U;

     set_csw();

   }


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

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


     const int id1 = 0;

     const int id2 = Nvc;

     const int id3 = Nvc * 2;

     const int id4 = Nvc * 3;


     // threadding applied.

     const int Nthread  = ThreadManager_OpenMP::get_num_threads();

     const int i_thread = ThreadManager_OpenMP::get_thread_id();


     const int is = m_Nvol * i_thread / Nthread;

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


     const int id1 = 0;

     const int id2 = Nvc;

     const int id3 = Nvc * 2;

     const int id4 = Nvc * 3;


     // threadding applied.

     const int Nthread  = ThreadManager_OpenMP::get_num_threads();

     const int i_thread = ThreadManager_OpenMP::get_thread_id();


     const int is = m_Nvol * i_thread / Nthread;

     const 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)

   {

     // multiplies csw kappa sigma_{mu nu} F_{mu nu}

     // NOTE: this is NOT  1 - csw kappa sigma_{mu nu} F_{mu nu}

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

   }


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

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

   {

     // multiplies csw kappa sigma_{mu nu} F_{mu nu}

     // NOTE: this is NOT  1 - csw kappa sigma_{mu nu} F_{mu nu}

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


     // threading applied.

     const int Nthread  = ThreadManager_OpenMP::get_num_threads();

     const int i_thread = ThreadManager_OpenMP::get_thread_id();


     const int is = m_Nvol * i_thread / Nthread;

     const 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 ic_r = 2 * ic;

         int ic_i = ic_r + 1;

         int ic_g = ic * Nvc + ig;


         v2[ic_r + id1 + iv] = 0.0;

         v2[ic_i + id1 + iv] = 0.0;

         v2[ic_r + id2 + iv] = 0.0;

         v2[ic_i + id2 + iv] = 0.0;


         v2[ic_r + id3 + iv] = 0.0;

         v2[ic_i + id3 + iv] = 0.0;

         v2[ic_r + id4 + iv] = 0.0;

         v2[ic_i + id4 + iv] = 0.0;


         // isigma_23 * Bx

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

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

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

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


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

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

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

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


         // isigma_31 * By

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

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

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

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


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

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

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

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


         // isigma_12 * Bz

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

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

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

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


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

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

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

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


         // isigma_41 * Ex

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

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

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

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


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

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

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

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


         // isigma_42 * Ey

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

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

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

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


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

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

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

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


         // isigma_43 * Ez

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

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

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

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


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

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

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

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

       }

     }

 #pragma omp barrier

   }


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

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

   {

     // multiplies csw kappa sigma_{mu nu} F_{mu nu}

     // NOTE: this is NOT  1 - csw kappa sigma_{mu nu} F_{mu nu}

     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.

     const int Nthread  = ThreadManager_OpenMP::get_num_threads();

     const int i_thread = ThreadManager_OpenMP::get_thread_id();


     const int is = m_Nvol * i_thread / Nthread;

     const 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 ic_r = 2 * ic;

         int ic_i = ic_r + 1;

         int ic_g = ic * Nvc + ig;


         v2[ic_r + id1 + iv] = 0.0;

         v2[ic_i + id1 + iv] = 0.0;

         v2[ic_r + id2 + iv] = 0.0;

         v2[ic_i + id2 + iv] = 0.0;


         v2[ic_r + id3 + iv] = 0.0;

         v2[ic_i + id3 + iv] = 0.0;

         v2[ic_r + id4 + iv] = 0.0;

         v2[ic_i + id4 + iv] = 0.0;


         // isigma_23 * Bx

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

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

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

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


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

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

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

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


         // isigma_31 * By

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

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

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

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


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

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

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

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


         // isigma_12 * Bz

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

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

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

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


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

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

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

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


         // isigma_41 * Ex

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

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

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

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


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

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

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

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


         // isigma_42 * Ey

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

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

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

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


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

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

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

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


         // isigma_43 * Ez

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

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

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

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


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

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

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

         v2[ic_i + id4 + iv] += kappa_cSW_t * mult_uv_r(&Ez[ic_g], &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)

   {

     const 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()

   {

     // Counting of floating point operations in giga unit.

     // 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 Nvol = CommonParameters::Nvol();

     const int NPE  = CommonParameters::NPE();


     const int flop_site = m_Nc * m_Nd * (2 + 48 * m_Nc);


     const double gflop = flop_site * (Nvol * (NPE / 1.0e+9));


     return gflop;

   }


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

 }

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

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

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

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

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

threadManager_OpenMP.h

ah_Field_G
void ah_Field_G(Field_G &W, const int ex)
Definition: field_G_imp.cpp:501

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

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

Imp::Fopr_CloverTerm_General::m_Nd
int m_Nd
Definition: fopr_CloverTerm_General_impl.h:56

Imp::Fopr_CloverTerm_General::mult_isigma
void mult_isigma(Field_F &, const Field_F &, const int mu, const int nu)
Definition: fopr_CloverTerm_General_impl.cpp:235

Imp::Fopr_CloverTerm_General::m_Ex
Field_G m_Ex
Definition: fopr_CloverTerm_General_impl.h:64

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

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

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

Imp::Fopr_CloverTerm_General::m_Bz
Field_G m_Bz
Definition: fopr_CloverTerm_General_impl.h:64

Imp::Fopr_CloverTerm_General::set_parameters
void set_parameters(const Parameters &params)
Definition: fopr_CloverTerm_General_impl.cpp:32

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:365

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

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

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

Imp::Fopr_CloverTerm_General::m_Ez
Field_G m_Ez
field strength.
Definition: fopr_CloverTerm_General_impl.h:64

Imp::Fopr_CloverTerm_General::sg_index
int sg_index(const int mu, const int nu)
Definition: fopr_CloverTerm_General_impl.h:162

Imp::Fopr_CloverTerm_General::m_kappa_t
double m_kappa_t
Definition: fopr_CloverTerm_General_impl.h:48

Imp::Fopr_CloverTerm_General::m_Nc
int m_Nc
Definition: fopr_CloverTerm_General_impl.h:56

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:149

GammaMatrixSet::UNITY
Definition: gammaMatrixSet.h:48

Imp::Fopr_CloverTerm_General::set_fieldstrength
void set_fieldstrength(Field_G &, const int, const int)
Definition: fopr_CloverTerm_General_impl.cpp:528

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

Staple_lex::lower
void lower(Field_G &, const Field_G &, const int mu, const int nu)
constructs lower staple in mu-nu plane.
Definition: staple_lex.cpp:177

Imp::Fopr_CloverTerm_General::m_kappa_s
double m_kappa_s
Definition: fopr_CloverTerm_General_impl.h:48

Imp::Fopr_CloverTerm_General::m_cSW_t
double m_cSW_t
Definition: fopr_CloverTerm_General_impl.h:49

Imp::Fopr_CloverTerm_General::m_repr
std::string m_repr
Definition: fopr_CloverTerm_General_impl.h:51

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

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

Imp::Fopr_CloverTerm_General::m_Ndim
int m_Ndim
Definition: fopr_CloverTerm_General_impl.h:56

Imp::Fopr_CloverTerm_General::m_Ey
Field_G m_Ey
Definition: fopr_CloverTerm_General_impl.h:64

Imp::Fopr_CloverTerm_General::gm5_dirac
void gm5_dirac(Field &, const Field &)
Definition: fopr_CloverTerm_General_impl.cpp:165

Imp::Fopr_CloverTerm_General::m_U
const Field_G * m_U
pointer to gauge configuration.
Definition: fopr_CloverTerm_General_impl.h:59

Imp::Fopr_CloverTerm_General::m_NinF
int m_NinF
Definition: fopr_CloverTerm_General_impl.h:56

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

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

Imp::Fopr_CloverTerm_General::m_By
Field_G m_By
Definition: fopr_CloverTerm_General_impl.h:64

Imp::Fopr_CloverTerm_General::mult_csw_dirac
void mult_csw_dirac(Field &, const Field &)
Definition: fopr_CloverTerm_General_impl.cpp:388

Imp::Fopr_CloverTerm_General::gm5_chiral
void gm5_chiral(Field &, const Field &)
Definition: fopr_CloverTerm_General_impl.cpp:200

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:269

fopr_CloverTerm_General_impl.h

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

GammaMatrixSet::SIGMA41
Definition: gammaMatrixSet.h:52

fopr_Wilson_impl_SU2-inc.h

Imp::Fopr_CloverTerm_General::m_Bx
Field_G m_Bx
Definition: fopr_CloverTerm_General_impl.h:64

Imp::Fopr_CloverTerm_General::tidyup
void tidyup()
Definition: fopr_CloverTerm_General_impl.cpp:151

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

Staple_lex::upper
void upper(Field_G &, const Field_G &, const int mu, const int nu)
constructs upper staple in mu-nu plane.
Definition: staple_lex.cpp:151

fopr_Wilson_impl_SU_N-inc.h

Imp::Fopr_CloverTerm_General::set_config
void set_config(Field *U)
setting pointer to the gauge configuration.
Definition: fopr_CloverTerm_General_impl.cpp:90

Imp::Fopr_CloverTerm_General::m_gm5
void(Fopr_CloverTerm_General::* m_gm5)(Field &, const Field &)
Definition: fopr_CloverTerm_General_impl.h:54

Imp::Fopr_CloverTerm_General::m_SG
std::vector< GammaMatrix > m_SG
Definition: fopr_CloverTerm_General_impl.h:68

Imp::Fopr_CloverTerm_General::mult_csw
void mult_csw(Field &, const Field &)
Definition: fopr_CloverTerm_General_impl.cpp:251

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

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

GammaMatrixSet::SIGMA23
Definition: gammaMatrixSet.h:51

Imp::Fopr_CloverTerm_General::m_Nvol
int m_Nvol
Definition: fopr_CloverTerm_General_impl.h:57

Imp::Fopr_CloverTerm_General::set_csw
void set_csw()
Definition: fopr_CloverTerm_General_impl.cpp:516

GammaMatrixSet::SIGMA42
Definition: gammaMatrixSet.h:52

GammaMatrixSet::SIGMA12
Definition: gammaMatrixSet.h:51

Imp::Fopr_CloverTerm_General::mult_sigmaF
void mult_sigmaF(Field &, const Field &)
Definition: fopr_CloverTerm_General_impl.cpp:244

Imp::Fopr_CloverTerm_General::m_boundary
std::vector< int > m_boundary
Definition: fopr_CloverTerm_General_impl.h:50

Imp::Fopr_CloverTerm_General::init
void init(std::string repr)
Definition: fopr_CloverTerm_General_impl.cpp:98

GammaMatrixSet::SIGMA43
Definition: gammaMatrixSet.h:52

Imp::Fopr_CloverTerm_General::m_staple
Staple_lex m_staple
Definition: fopr_CloverTerm_General_impl.h:62

Imp::Fopr_CloverTerm_General::m_GM5
GammaMatrix m_GM5
Definition: fopr_CloverTerm_General_impl.h:69

Imp::Fopr_CloverTerm_General::m_v2
Field_G m_v2
for calculation of field strength.
Definition: fopr_CloverTerm_General_impl.h:63

Imp::Fopr_CloverTerm_General::m_cSW_s
double m_cSW_s
Definition: fopr_CloverTerm_General_impl.h:49

Imp::Fopr_CloverTerm_General::m_Cup
Field_G m_Cup
Definition: fopr_CloverTerm_General_impl.h:63

Imp::Fopr_CloverTerm_General::mult_gm5
void mult_gm5(Field &v, const Field &w)
gamma_5 multiplication. [31 Mar 2017 H.Matsufuru]
Definition: fopr_CloverTerm_General_impl.cpp:158

Imp::Fopr_CloverTerm_General::mult_csw_chiral
void mult_csw_chiral(Field &, const Field &)
Definition: fopr_CloverTerm_General_impl.cpp:260

Imp::Fopr_CloverTerm_General::flop_count
double flop_count()
this returns the number of floating point operations.
Definition: fopr_CloverTerm_General_impl.cpp:560

Bridge::unique_ptr
Definition: unique_pointer.h:24

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

Parameters::fetch_int_vector
int fetch_int_vector(const string &key, vector< int > &value) const
Definition: parameters.cpp:429

fopr_Wilson_impl_SU3-inc.h

Imp::Fopr_CloverTerm_General::m_v1
Field_G m_v1
Definition: fopr_CloverTerm_General_impl.h:63

Imp::Fopr_CloverTerm_General::class_name
static const std::string class_name
Definition: fopr_CloverTerm_General_impl.h:45

Imp::Fopr_CloverTerm_General::m_Cdn
Field_G m_Cdn
Definition: fopr_CloverTerm_General_impl.h:63

Imp::Fopr_CloverTerm_General::m_shift
ShiftField_lex m_shift
Definition: fopr_CloverTerm_General_impl.h:61

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

GammaMatrixSet::SIGMA31
Definition: gammaMatrixSet.h:51

CommonParameters::NPE
static int NPE()
Definition: commonParameters.h:101

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:320

GammaMatrixSet::GAMMA5
Definition: gammaMatrixSet.h:48

Imp::Fopr_CloverTerm_General::m_csw
void(Fopr_CloverTerm_General::* m_csw)(Field &, const Field &)
Definition: fopr_CloverTerm_General_impl.h:53

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

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:191