Bridge++  Ver. 2.0.2
fopr_CloverTerm_eo_impl.cpp
Go to the documentation of this file.
1 
14 #include "fopr_CloverTerm_eo_impl.h"
15 
16 #include "Field/shiftField_eo.h"
17 #include "Measurements/Gauge/staple_eo.h"
18 #include "Solver/solver_CG.h"
19 #include "Tools/gammaMatrixSet.h"
20 
21 #include "Field/field_thread-inc.h"
22 // because of no communication in mult, threading for Field is applied.
23 
24 #if defined USE_GROUP_SU3
25 #include "fopr_Wilson_impl_SU3-inc.h"
26 #elif defined USE_GROUP_SU2
27 #include "fopr_Wilson_impl_SU2-inc.h"
28 #elif defined USE_GROUP_SU_N
29 #include "fopr_Wilson_impl_SU_N-inc.h"
30 #endif
31 
32 namespace Imp {
33  const std::string Fopr_CloverTerm_eo::class_name
34  = "Imp::Fopr_CloverTerm_eo";
35 
36 //====================================================================
37  void Fopr_CloverTerm_eo::init(const Parameters& params)
38  {
39  ThreadManager::assert_single_thread(class_name);
40 
41  m_vl = CommonParameters::Vlevel();
42 
43  vout.general(m_vl, "%s: construction\n", class_name.c_str());
44  vout.increase_indent();
45 
46  setup();
47 
48  std::string repr;
49  if (!params.fetch_string("gamma_matrix_type", repr)) {
50  m_repr = repr;
51  } else {
52  m_repr = "Dirac"; // default
53  vout.general(m_vl, "gamma_matrix_type is not given: defalt = %s\n",
54  m_repr.c_str());
55  }
56  if ((m_repr != "Dirac") && (m_repr != "Chiral")) {
57  vout.crucial("Error in %s: irrelevant mult mode = %s\n",
58  class_name.c_str(), m_repr.c_str());
59  exit(EXIT_FAILURE);
60  }
61 
62  setup_gamma_matrices();
63 
64  set_parameters(params);
65 
66  vout.decrease_indent();
67  vout.general(m_vl, "%s: construction finished.\n",
68  class_name.c_str());
69  }
70 
71 
72 //====================================================================
73  void Fopr_CloverTerm_eo::init(const std::string repr)
74  {
75  ThreadManager::assert_single_thread(class_name);
76 
77  m_vl = CommonParameters::Vlevel();
78 
79  vout.general(m_vl, "%s: construction (obsolete)\n",
80  class_name.c_str());
81 
82  vout.increase_indent();
83 
84  setup();
85 
86  m_repr = repr;
87 
88  setup_gamma_matrices();
89 
90  vout.decrease_indent();
91 
92  vout.general(m_vl, "%s: construction finished.\n",
93  class_name.c_str());
94  }
95 
96 
97 //====================================================================
98  void Fopr_CloverTerm_eo::setup()
99  {
100  m_Nc = CommonParameters::Nc();
101  m_Nd = CommonParameters::Nd();
102  m_Ndim = CommonParameters::Ndim();
103  m_NinF = 2 * m_Nc * m_Nd;
104  m_Nvol = CommonParameters::Nvol();
105  m_Nvol2 = m_Nvol / 2;
106 
107  m_boundary.resize(m_Ndim);
108 
109  m_Ueo.reset(m_Nvol, m_Ndim);
110 
111  m_Ndm2 = m_Nd * m_Nd / 2;
112  m_T.reset(m_Nvol, m_Ndm2);
113 
114  m_GM.resize(m_Ndim + 1);
115  m_SG.resize(m_Ndim * m_Ndim);
116 
117  m_Fee_inv.reset(m_Nvol2, m_Nc * m_Nd);
118  m_Foo_inv.reset(m_Nvol2, m_Nc * m_Nd);
119 
120  int Ndf = 2 * m_Nc * m_Nc;
121  m_shift_eo = new ShiftField_eo(Ndf);
122 
123  m_staple = new Staple_eo;
124 
125  m_w1.reset(m_Nvol2, 1);
126  m_w2.reset(m_Nvol2, 1);
127 
128  // setup solver
129  Parameters params_solver;
130  params_solver.set_string("solver_type", "CG");
131  params_solver.set_int("maximum_number_of_iteration", 100);
132  params_solver.set_int("maximum_number_of_restart", 40);
133  params_solver.set_double("convergence_criterion_squared", 1.0e-30);
134  params_solver.set_string("use_initial_guess", "false");
135  params_solver.set_string("verbose_level", "Crucial");
136  // NB. set VerboseLevel to CRUCIAL to suppress frequent messages.
137 
138  m_solver = new Solver_CG(this);
139  m_solver->set_parameters(params_solver);
140  }
141 
142 
143 //====================================================================
144  void Fopr_CloverTerm_eo::tidyup()
145  {
146  delete m_solver;
147  delete m_shift_eo;
148  delete m_staple;
149  }
150 
151 
152 //====================================================================
153  void Fopr_CloverTerm_eo::set_parameters(const Parameters& params)
154  {
155  int ith = ThreadManager::get_thread_id();
156 
157  std::string vlevel;
158  if (!params.fetch_string("verbose_level", vlevel)) {
159  if (ith == 0) m_vl = vout.set_verbose_level(vlevel);
160  }
161 
162  //- fetch and check input parameters
163  double kappa, cSW;
164  std::vector<int> bc;
165 
166  int err = 0;
167  err += params.fetch_double("hopping_parameter", kappa);
168  err += params.fetch_double("clover_coefficient", cSW);
169  err += params.fetch_int_vector("boundary_condition", bc);
170 
171  if (err) {
172  vout.crucial(m_vl, "Error at %s: input parameter not found.\n",
173  class_name.c_str());
174  exit(EXIT_FAILURE);
175  }
176 
177  set_parameters(kappa, cSW, bc);
178  }
179 
180 
181 //====================================================================
182  void Fopr_CloverTerm_eo::set_parameters(const double kappa,
183  const double cSW,
184  const std::vector<int> bc)
185  {
186  int ith = ThreadManager::get_thread_id();
187 
188  assert(bc.size() == m_Ndim);
189 
190  if (ith == 0) {
191  m_kappa = kappa;
192  m_cSW = cSW;
193  m_boundary = bc;
194  }
195 
196  vout.general(m_vl, "%s: input parameters\n", class_name.c_str());
197  vout.general(m_vl, " gamma matrix type = %s\n", m_repr.c_str());
198  vout.general(m_vl, " kappa = %12.8f\n", m_kappa);
199  vout.general(m_vl, " cSW = %12.8f\n", m_cSW);
200  for (int mu = 0; mu < m_Ndim; ++mu) {
201  vout.general(m_vl, " boundary[%d] = %2d\n", mu, m_boundary[mu]);
202  }
203  }
204 
205 
206 //====================================================================
207  void Fopr_CloverTerm_eo::get_parameters(Parameters& params) const
208  {
209  params.set_double("hopping_parameter", m_kappa);
210  params.set_double("clover_coefficient", m_cSW);
211  params.set_int_vector("boundary_condition", m_boundary);
212  params.set_string("gamma_matrix_type", m_repr);
213 
214  params.set_string("verbose_level", vout.get_verbose_level(m_vl));
215  }
216 
217 
218 //====================================================================
219  void Fopr_CloverTerm_eo::setup_gamma_matrices()
220  {
221  GammaMatrixSet *gmset = GammaMatrixSet::New(m_repr);
222 
223  m_GM[0] = gmset->get_GM(gmset->GAMMA1);
224  m_GM[1] = gmset->get_GM(gmset->GAMMA2);
225  m_GM[2] = gmset->get_GM(gmset->GAMMA3);
226  m_GM[3] = gmset->get_GM(gmset->GAMMA4);
227  m_GM[4] = gmset->get_GM(gmset->GAMMA5);
228 
229  m_SG[sg_index(0, 1)] = gmset->get_GM(gmset->SIGMA12);
230  m_SG[sg_index(1, 2)] = gmset->get_GM(gmset->SIGMA23);
231  m_SG[sg_index(2, 0)] = gmset->get_GM(gmset->SIGMA31);
232  m_SG[sg_index(3, 0)] = gmset->get_GM(gmset->SIGMA41);
233  m_SG[sg_index(3, 1)] = gmset->get_GM(gmset->SIGMA42);
234  m_SG[sg_index(3, 2)] = gmset->get_GM(gmset->SIGMA43);
235 
236  m_SG[sg_index(1, 0)] = m_SG[sg_index(0, 1)].mult(-1);
237  m_SG[sg_index(2, 1)] = m_SG[sg_index(1, 2)].mult(-1);
238  m_SG[sg_index(0, 2)] = m_SG[sg_index(2, 0)].mult(-1);
239  m_SG[sg_index(0, 3)] = m_SG[sg_index(3, 0)].mult(-1);
240  m_SG[sg_index(1, 3)] = m_SG[sg_index(3, 1)].mult(-1);
241  m_SG[sg_index(2, 3)] = m_SG[sg_index(3, 2)].mult(-1);
242 
243  m_SG[sg_index(0, 0)] = gmset->get_GM(gmset->UNITY);
244  m_SG[sg_index(1, 1)] = gmset->get_GM(gmset->UNITY);
245  m_SG[sg_index(2, 2)] = gmset->get_GM(gmset->UNITY);
246  m_SG[sg_index(3, 3)] = gmset->get_GM(gmset->UNITY);
247  // these 4 gamma matrices are actually not used.
248 
249  delete gmset;
250  }
251 
252 
253 //====================================================================
254  void Fopr_CloverTerm_eo::set_config(Field *U)
255  {
256  int nth = ThreadManager::get_num_threads();
257  vout.detailed(m_vl, "%s: set_config is called: num_threads = %d\n",
258  class_name.c_str(), nth);
259 
260  if (nth > 1) {
261  set_config_impl(U);
262  } else {
263  set_config_omp(U);
264  }
265 
266  vout.detailed(m_vl, "%s: set_config finished\n", class_name.c_str());
267  }
268 
269 
270 //====================================================================
271  void Fopr_CloverTerm_eo::set_config_omp(Field *U)
272  {
273  vout.detailed(m_vl, " set_config_omp is called.\n");
274 
275 #pragma omp parallel
276  {
277  set_config_impl(U);
278  }
279  }
280 
281 
282 //====================================================================
283  void Fopr_CloverTerm_eo::set_config_impl(Field *U)
284  {
285  m_idx.convertField(m_Ueo, *U);
286 
287  set_csw();
288  solve_csw_inv();
289  }
290 
291 
292 //====================================================================
293  void Fopr_CloverTerm_eo::set_mode(const std::string mode)
294  {
295 #pragma omp barrier
296 
297  int ith = ThreadManager::get_thread_id();
298  if (ith == 0) m_mode = mode;
299 
300 #pragma omp barrier
301  }
302 
303 
304 //====================================================================
305  void Fopr_CloverTerm_eo::mult(Field& v, const Field& w)
306  {
307  // multiplies 1-csw kappa sigma_{mu nu} F_{mu nu}
308  if (m_mode == "even") {
309  D(v, w, 0);
310  } else if (m_mode == "odd") {
311  D(v, w, 1);
312  } else {
313  vout.crucial("Error at %s: undefined mode = %s\n",
314  class_name.c_str(), m_mode.c_str());
315  exit(EXIT_FAILURE);
316  }
317  }
318 
319 
320 //====================================================================
321  void Fopr_CloverTerm_eo::mult_dag(Field& v, const Field& w)
322  {
323  // multiplies 1-csw kappa sigma_{mu nu} F_{mu nu}
324  mult(v, w);
325  }
326 
327 
328 //====================================================================
329  void Fopr_CloverTerm_eo::solve_csw_inv()
330  {
331  const double eps2 = CommonParameters::epsilon_criterion2();
332 
333  for (int ispin = 0; ispin < m_Nd; ++ispin) {
334  for (int icolor = 0; icolor < m_Nc; ++icolor) {
335  int spin_color = icolor + m_Nc * ispin;
336 
337  m_w1.set(0.0);
338 #pragma omp barrier
339 
340  for (int isite = 0; isite < m_Nvol2; ++isite) {
341  m_w1.set_ri(icolor, ispin, isite, 0, 1, 0);
342  }
343 #pragma omp barrier
344 
345  if (m_cSW * m_cSW < eps2) {
346  copy(m_Fee_inv, spin_color, m_w1, 0);
347  copy(m_Foo_inv, spin_color, m_w1, 0);
348  } else {
349  int Nconv;
350  double diff;
351  set_mode("even");
352 #pragma omp barrier
353  m_solver->solve(m_w2, m_w1, Nconv, diff);
354  copy(m_Fee_inv, spin_color, m_w2, 0);
355 #pragma omp barrier
356  vout.detailed(m_vl, " Nconv,diff = %d %12.4e\n", Nconv, diff);
357 
358  set_mode("odd");
359 #pragma omp barrier
360  m_solver->solve(m_w2, m_w1, Nconv, diff);
361  copy(m_Foo_inv, spin_color, m_w2, 0);
362 #pragma omp barrier
363  vout.detailed(m_vl, " Nconv,diff = %d %12.4e\n", Nconv, diff);
364  }
365  }
366  }
367 
368  int ith, nth, is, ns;
369  set_threadtask(ith, nth, is, ns, m_Nvol2);
370 
371  // redefine the inverse matrix with its dagger.
372  for (int ics = 0; ics < m_Nc * m_Nd; ++ics) {
373  for (int site = is; site < ns; ++site) {
374  for (int id = 0; id < m_Nd; ++id) {
375  for (int ic = 0; ic < m_Nc; ++ic) {
376  double re, im;
377  re = m_Foo_inv.cmp_r(ic, id, site, ics);
378  im = m_Foo_inv.cmp_i(ic, id, site, ics);
379  m_Foo_inv.set_ri(ic, id, site, ics, re, -im);
380 
381  re = m_Fee_inv.cmp_r(ic, id, site, ics);
382  im = m_Fee_inv.cmp_i(ic, id, site, ics);
383  m_Fee_inv.set_ri(ic, id, site, ics, re, -im);
384  }
385  }
386  }
387  }
388 
389 #pragma omp barrier
390  }
391 
392 
393 //====================================================================
394  void Fopr_CloverTerm_eo::mult_csw_inv(Field& v,
395  const Field& w, const int ieo)
396  {
397  // multiplies [ 1 - csw kappa sigma_{mu nu} F_{mu nu} ]^{-1}
398  if (m_repr == "Dirac") {
399  mult_csw_inv_dirac(v, w, ieo);
400  } else if (m_repr == "Chiral") {
401  mult_csw_inv_chiral(v, w, ieo);
402  }
403  }
404 
405 
406 //====================================================================
407  void Fopr_CloverTerm_eo::mult_csw_inv_dirac(Field& v, const Field& w,
408  const int ieo)
409  {
410  // multiplies [ 1 - csw kappa sigma_{mu nu} F_{mu nu} ]^{-1}
411  const int Nvc = 2 * m_Nc;
412 
413  const double *v1 = w.ptr(0);
414  double *v2 = v.ptr(0);
415 
416  double *csw_inv = 0;
417  if (ieo == 0) {
418  csw_inv = m_Fee_inv.ptr(0);
419  } else if (ieo == 1) {
420  csw_inv = m_Foo_inv.ptr(0);
421  }
422 
423  int ith, nth, is, ns;
424  set_threadtask(ith, nth, is, ns, m_Nvol2);
425 
426 #pragma omp barrier
427 
428  const int Nd2 = m_Nd / 2;
429  for (int site = is; site < ns; ++site) {
430  for (int icd = 0; icd < m_Nc * Nd2; ++icd) {
431  int iv2 = 2 * icd + m_NinF * site;
432  v2[iv2] = 0.0;
433  v2[iv2 + 1] = 0.0;
434  for (int jd = 0; jd < m_Nd; ++jd) {
435  int jcd = Nvc * jd;
436  int iv = jcd + m_NinF * site;
437 
438  int ig = jcd + m_NinF * (site + m_Nvol2 * icd);
439  v2[iv2] += mult_uv_r(&csw_inv[ig], &v1[iv], m_Nc);
440  v2[iv2 + 1] += mult_uv_i(&csw_inv[ig], &v1[iv], m_Nc);
441  }
442  }
443 
444  for (int icd = 0; icd < m_Nc * Nd2; ++icd) {
445  int iv2 = 2 * (icd + m_Nc * Nd2) + m_NinF * site;
446  v2[iv2] = 0.0;
447  v2[iv2 + 1] = 0.0;
448  for (int jd = 0; jd < m_Nd; ++jd) {
449  int jd2 = (jd + Nd2) % m_Nd;
450  int iv = Nvc * jd + m_NinF * site;
451  int ig = Nvc * jd2 + m_NinF * (site + m_Nvol2 * icd);
452 
453  v2[iv2] += mult_uv_r(&csw_inv[ig], &v1[iv], m_Nc);
454  v2[iv2 + 1] += mult_uv_i(&csw_inv[ig], &v1[iv], m_Nc);
455  }
456  }
457  }
458 #pragma omp barrier
459  }
460 
461 
462 //====================================================================
463  void Fopr_CloverTerm_eo::mult_csw_inv_chiral(Field& v, const Field& w,
464  const int ieo)
465  {
466  // multiplies [ 1 - csw kappa sigma_{mu nu} F_{mu nu} ]^{-1}
467  const int Nvc = 2 * m_Nc;
468 
469  const double *v1 = w.ptr(0);
470  double *v2 = v.ptr(0);
471 
472  double *csw_inv = 0;
473  if (ieo == 0) {
474  csw_inv = m_Fee_inv.ptr(0);
475  } else if (ieo == 1) {
476  csw_inv = m_Foo_inv.ptr(0);
477  }
478 
479  int ith, nth, is, ns;
480  set_threadtask(ith, nth, is, ns, m_Nvol2);
481 
482 #pragma omp barrier
483 
484  for (int site = is; site < ns; ++site) {
485  for (int icd = 0; icd < m_Nc * m_Nd / 2; ++icd) {
486  int iv2 = 2 * icd + m_NinF * site;
487  v2[iv2] = 0.0;
488  v2[iv2 + 1] = 0.0;
489 
490  for (int jd = 0; jd < m_Nd / 2; ++jd) {
491  int jcd = Nvc * jd;
492  int iv = jcd + m_NinF * site;
493  int ig = jcd + m_NinF * (site + m_Nvol2 * icd);
494 
495  v2[iv2] += mult_uv_r(&csw_inv[ig], &v1[iv], m_Nc);
496  v2[iv2 + 1] += mult_uv_i(&csw_inv[ig], &v1[iv], m_Nc);
497  }
498  }
499 
500  for (int icd = m_Nc * m_Nd / 2; icd < m_Nc * m_Nd; ++icd) {
501  int iv2 = 2 * icd + m_NinF * site;
502  v2[iv2] = 0.0;
503  v2[iv2 + 1] = 0.0;
504 
505  for (int jd = m_Nd / 2; jd < m_Nd; ++jd) {
506  int jcd = Nvc * jd;
507  int iv = jcd + m_NinF * site;
508  int ig = jcd + m_NinF * (site + m_Nvol2 * icd);
509 
510  v2[iv2] += mult_uv_r(&csw_inv[ig], &v1[iv], m_Nc);
511  v2[iv2 + 1] += mult_uv_i(&csw_inv[ig], &v1[iv], m_Nc);
512  }
513  }
514  }
515 
516 #pragma omp barrier
517  }
518 
519 
520 //====================================================================
521  void Fopr_CloverTerm_eo::D(Field& v, const Field& w, const int ieo)
522  {
523  // multiplies [ 1 - csw kappa sigma_{mu nu} F_{mu nu} ]
524 
525  assert(w.check_size(m_NinF, m_Nvol2, 1));
526  assert(v.check_size(m_NinF, m_Nvol2, 1));
527 
528  if (m_repr == "Dirac") {
529  D_dirac(v, w, ieo);
530  } else if (m_repr == "Chiral") {
531  D_chiral(v, w, ieo);
532  }
533  }
534 
535 
536 //====================================================================
537  void Fopr_CloverTerm_eo::D_dirac(Field& v, const Field& w, const int ieo)
538  {
539  // multiplies [ 1 - csw kappa sigma_{mu nu} F_{mu nu} ]
540 
541  const double *wp = w.ptr(0);
542  double *vp = v.ptr(0);
543  double *tp = m_T.ptr(0, m_Nvol2 * ieo, 0);
544 
545  const int Nvc = 2 * m_Nc;
546  const int Nd2 = m_Nd / 2;
547  const int NinF = 2 * m_Nc * m_Nd;
548  const int NinG = 2 * m_Nc * m_Nc;
549 
550  int ith, nth, is, ns;
551  set_threadtask(ith, nth, is, ns, m_Nvol2);
552 
553 #pragma omp barrier
554 
555  for (int site = is; site < ns; ++site) {
556  for (int id = 0; id < Nd2; ++id) {
557  for (int ic = 0; ic < m_Nc; ++ic) {
558  int icd = ic + m_Nc * id;
559 
560  int iv2 = 2 * icd + NinF * site;
561  vp[iv2] = 0.0;
562  vp[iv2 + 1] = 0.0;
563  for (int jd = 0; jd < m_Nd; ++jd) {
564  int iv = Nvc * jd + NinF * site;
565  int ig = Nvc * ic + NinG * (site + m_Nvol * (id * m_Nd + jd));
566 
567  vp[iv2] += mult_uv_r(&tp[ig], &wp[iv], m_Nc);
568  vp[iv2 + 1] += mult_uv_i(&tp[ig], &wp[iv], m_Nc);
569  }
570 
571  iv2 += Nvc * Nd2;
572  vp[iv2] = 0.0;
573  vp[iv2 + 1] = 0.0;
574  for (int jd = 0; jd < m_Nd; ++jd) {
575  int jd2 = (2 + jd) % m_Nd;
576  int iv = Nvc * jd + NinF * site;
577  int ig = Nvc * ic + NinG * (site + m_Nvol * (id * m_Nd + jd2));
578 
579  vp[iv2] += mult_uv_r(&tp[ig], &wp[iv], m_Nc);
580  vp[iv2 + 1] += mult_uv_i(&tp[ig], &wp[iv], m_Nc);
581  }
582  }
583  }
584  }
585 
586 #pragma omp barrier
587  }
588 
589 
590 //====================================================================
591  void Fopr_CloverTerm_eo::D_chiral(Field& v,
592  const Field& w, const int ieo)
593  {
594  // multiplies [ 1 - csw kappa sigma_{mu nu} F_{mu nu} ]
595 
596  const double *wp = w.ptr(0);
597  double *vp = v.ptr(0);
598  double *tp = m_T.ptr(0, m_Nvol2 * ieo, 0);
599 
600  const int Nvc = 2 * m_Nc;
601  const int Nd2 = m_Nd / 2;
602  const int NinF = 2 * m_Nc * m_Nd;
603  const int NinG = 2 * m_Nc * m_Nc;
604 
605  int ith, nth, is, ns;
606  set_threadtask(ith, nth, is, ns, m_Nvol2);
607 
608 #pragma omp barrier
609 
610  for (int site = is; site < ns; ++site) {
611  for (int id = 0; id < Nd2; ++id) {
612  for (int ic = 0; ic < m_Nc; ++ic) {
613  int icd = ic + m_Nc * id;
614 
615  double *vp2 = &vp[NinF * site];
616  vp2[2 * icd] = 0.0;
617  vp2[2 * icd + 1] = 0.0;
618  for (int jd = 0; jd < Nd2; ++jd) {
619  int iv = Nvc * jd + NinF * site;
620  int ig = Nvc * ic + NinG * (site + m_Nvol * (id * Nd2 + jd));
621  vp2[2 * icd] += mult_uv_r(&tp[ig], &wp[iv], m_Nc);
622  vp2[2 * icd + 1] += mult_uv_i(&tp[ig], &wp[iv], m_Nc);
623  }
624 
625  vp2 = &vp[Nvc * Nd2 + NinF * site];
626  vp2[2 * icd] = 0.0;
627  vp2[2 * icd + 1] = 0.0;
628  for (int jd = 0; jd < Nd2; ++jd) {
629  int iv = Nvc * (Nd2 + jd) + NinF * site;
630  int ig = Nvc * ic + NinG * (site + m_Nvol * (m_Nd + id * Nd2 + jd));
631  vp2[2 * icd] += mult_uv_r(&tp[ig], &wp[iv], m_Nc);
632  vp2[2 * icd + 1] += mult_uv_i(&tp[ig], &wp[iv], m_Nc);
633  }
634  }
635  }
636  }
637 
638 
639 #pragma omp barrier
640  }
641 
642 
643 //====================================================================
644  void Fopr_CloverTerm_eo::mult_isigma(Field_F& v, const Field_F& w,
645  const int mu, const int nu)
646  {
647 #pragma omp barrier
648 
649  assert(mu != nu);
650  mult_iGM(v, m_SG[sg_index(mu, nu)], w);
651 
652 #pragma omp barrier
653  }
654 
655 
656 //====================================================================
657  void Fopr_CloverTerm_eo::set_csw()
658  {
659  if (m_repr == "Dirac") {
660  set_csw_dirac();
661  } else if (m_repr == "Chiral") {
662  set_csw_chiral();
663  } else {
664  vout.crucial(m_vl, "Error at %s: irrelevant gamma_matrix_type: %s\n",
665  class_name.c_str(), m_repr.c_str());
666  exit(EXIT_FAILURE);
667  }
668  }
669 
670 
671 //====================================================================
672  void Fopr_CloverTerm_eo::set_csw_dirac()
673  {
674  // The clover term in the Dirac representation is as spin-space
675  // matrix
676  // [ P Q ]
677  // [ Q P ],
678  // where P and Q are 2x2 block matrices as
679  // P = [ iF(1,2) F(3,1) + iF(2,3) ]
680  // [-F(3,1) + iF(2,3) - iF(1,2) ]
681  // and
682  // Q = [ - iF(4,3) -F(4,2) - iF(4,1) ]
683  // [ F(4,2) - iF(4,1) iF(4,3) ]
684  // up to the coefficient.
685  // in the following what defined is
686  // [ P Q ] = [ T(0) T(1) T(2) T(3) ]
687  // [ T(4) T(5) T(6) T(7) ].
688 
689 #pragma omp barrier
690 
691  m_T.set(0.0);
692 #pragma omp barrier
693 
694  //- sigma23
695  // Field_G F;
696  set_fieldstrength(m_Ft, 1, 2);
697  m_Ft.xI();
698 #pragma omp barrier
699  axpy(m_T, 1, 1.0, m_Ft, 0);
700  axpy(m_T, 4, 1.0, m_Ft, 0);
701 
702  //- sigma31
703  set_fieldstrength(m_Ft, 2, 0);
704  axpy(m_T, 1, 1.0, m_Ft, 0);
705  axpy(m_T, 4, -1.0, m_Ft, 0);
706 
707  //- sigma12
708  set_fieldstrength(m_Ft, 0, 1);
709  m_Ft.xI();
710 #pragma omp barrier
711  axpy(m_T, 0, 1.0, m_Ft, 0);
712  axpy(m_T, 5, -1.0, m_Ft, 0);
713 
714  //- sigma41
715  set_fieldstrength(m_Ft, 3, 0);
716  m_Ft.xI();
717 #pragma omp barrier
718  axpy(m_T, 3, -1.0, m_Ft, 0);
719  axpy(m_T, 6, -1.0, m_Ft, 0);
720 
721  //- sigma42
722  set_fieldstrength(m_Ft, 3, 1);
723  axpy(m_T, 3, -1.0, m_Ft, 0);
724  axpy(m_T, 6, 1.0, m_Ft, 0);
725 
726  //- sigma43
727  set_fieldstrength(m_Ft, 3, 2);
728  m_Ft.xI();
729 #pragma omp barrier
730  axpy(m_T, 2, -1.0, m_Ft, 0);
731  axpy(m_T, 7, 1.0, m_Ft, 0);
732 
733  scal(m_T, -m_kappa * m_cSW);
734 
735  // Field_G Unity;
736  m_Ft.set_unit();
737 #pragma omp barrier
738  axpy(m_T, 0, 1.0, m_Ft, 0);
739  axpy(m_T, 5, 1.0, m_Ft, 0);
740 
741 #pragma omp barrier
742  }
743 
744 
745 //====================================================================
746  void Fopr_CloverTerm_eo::set_csw_chiral()
747  {
748  // The clover term in the Dirac representation is
749  // as spin-space matrix
750  // [ P+Q 0 ]
751  // [ 0 P-Q ],
752  // where P and Q are 2x2 block matrices as
753  // [ iF(1,2) | F(3,1) + iF(2,3) ]
754  // P = [ -----------------+------------------ ]
755  // [-F(3,1) + iF(2,3) | - iF(1,2) ]
756  // and
757  // [ - iF(4,3) | -F(4,2) - iF(4,1) ]
758  // Q = [ -----------------+------------------ ]
759  // [ F(4,2) - iF(4,1) | iF(4,3) ]
760  // up to the coefficient.
761  // in the following what defined is
762  // [ T(0) | T(1) ] [ T(4) | T(5) ]
763  // P+Q = [ -----+----- ] P - Q = [ -----+----- ]
764  // [ T(2) | T(3) ] [ T(6) | T(7) ]
765 
766 #pragma omp barrier
767 
768  m_T.set(0.0);
769 
770 #pragma omp barrier
771 
772  //- sigma23
773  set_fieldstrength(m_Ft, 1, 2);
774  m_Ft.xI();
775 #pragma omp barrier
776  axpy(m_T, 1, 1.0, m_Ft, 0);
777  axpy(m_T, 2, 1.0, m_Ft, 0);
778  axpy(m_T, 5, 1.0, m_Ft, 0);
779  axpy(m_T, 6, 1.0, m_Ft, 0);
780 
781  //- sigma31
782  set_fieldstrength(m_Ft, 2, 0);
783  axpy(m_T, 1, 1.0, m_Ft, 0);
784  axpy(m_T, 2, -1.0, m_Ft, 0);
785  axpy(m_T, 5, 1.0, m_Ft, 0);
786  axpy(m_T, 6, -1.0, m_Ft, 0);
787 
788  //- sigma12
789  set_fieldstrength(m_Ft, 0, 1);
790  m_Ft.xI();
791 #pragma omp barrier
792  axpy(m_T, 0, 1.0, m_Ft, 0);
793  axpy(m_T, 3, -1.0, m_Ft, 0);
794  axpy(m_T, 4, 1.0, m_Ft, 0);
795  axpy(m_T, 7, -1.0, m_Ft, 0);
796 
797  //- sigma41
798  set_fieldstrength(m_Ft, 3, 0);
799  m_Ft.xI();
800 #pragma omp barrier
801  axpy(m_T, 1, -1.0, m_Ft, 0);
802  axpy(m_T, 2, -1.0, m_Ft, 0);
803  axpy(m_T, 5, 1.0, m_Ft, 0);
804  axpy(m_T, 6, 1.0, m_Ft, 0);
805 
806  //- sigma42
807  set_fieldstrength(m_Ft, 3, 1);
808  axpy(m_T, 1, -1.0, m_Ft, 0);
809  axpy(m_T, 2, 1.0, m_Ft, 0);
810  axpy(m_T, 5, 1.0, m_Ft, 0);
811  axpy(m_T, 6, -1.0, m_Ft, 0);
812 
813  //- sigma43
814  set_fieldstrength(m_Ft, 3, 2);
815  m_Ft.xI();
816 #pragma omp barrier
817  axpy(m_T, 0, -1.0, m_Ft, 0);
818  axpy(m_T, 3, 1.0, m_Ft, 0);
819  axpy(m_T, 4, 1.0, m_Ft, 0);
820  axpy(m_T, 7, -1.0, m_Ft, 0);
821 #pragma omp barrier
822 
823  scal(m_T, -m_kappa * m_cSW);
824 
825 #pragma omp barrier
826 
827  m_Ft.set_unit();
828 #pragma omp barrier
829  axpy(m_T, 0, 1.0, m_Ft, 0);
830  axpy(m_T, 3, 1.0, m_Ft, 0);
831  axpy(m_T, 4, 1.0, m_Ft, 0);
832  axpy(m_T, 7, 1.0, m_Ft, 0);
833 
834 #pragma omp barrier
835  }
836 
837 
838 //====================================================================
839  void Fopr_CloverTerm_eo::set_fieldstrength(Field_G& Fst,
840  const int mu, const int nu)
841  {
842  int ith, nth, is, ns;
843  set_threadtask(ith, nth, is, ns, m_Nvol);
844 
845  m_Cup.set(0.0);
846 #pragma omp barrier
847 
848  m_staple->upper(m_Cup, m_Ueo, mu, nu);
849 
850  m_Cdn.set(0.0);
851  m_staple->lower(m_Cdn, m_Ueo, mu, nu);
852 
853  copy(m_Umu, 0, m_Ueo, mu);
854 #pragma omp barrier
855 
856  for (int site = is; site < ns; ++site) {
857  m_ut3.set_mat(site, 0, m_Umu.mat(site) * m_Cup.mat_dag(site));
858  }
859 
860  for (int site = is; site < ns; ++site) {
861  m_ut2.set_mat(site, 0, m_Umu.mat(site) * m_Cdn.mat_dag(site));
862  }
863 #pragma omp barrier
864 
865  axpy(m_ut3, -1.0, m_ut2);
866 #pragma omp barrier
867 
868  for (int site = is; site < ns; ++site) {
869  m_ut1.set_mat(site, 0, m_Cup.mat_dag(site) * m_Umu.mat(site));
870  }
871 
872  for (int site = is; site < ns; ++site) {
873  m_ut2.set_mat(site, 0, m_Cdn.mat_dag(site) * m_Umu.mat(site));
874  }
875 #pragma omp barrier
876 
877  axpy(m_ut1, -1.0, m_ut2);
878 #pragma omp barrier
879 
880  m_shift_eo->forward(m_ut2, m_ut1, mu);
881 
882  axpy(m_ut3, 1.0, m_ut2);
883 #pragma omp barrier
884 
885  for (int site = is; site < ns; ++site) {
886  Fst.set_mat(site, 0, m_ut3.mat(site).ah());
887  }
888 #pragma omp barrier
889 
890  scal(Fst, 0.25);
891 
892 #pragma omp barrier
893  }
894 
895 
896 //====================================================================
897  double Fopr_CloverTerm_eo::flop_count()
898  {
899  // Counting of floating point operations in giga unit.
900  // The following counting explicitly depends on the implementation
901  // and to be recalculated when the code is modified.
902  // Present counting is based on rev.1107. [24 Aug 2014 H.Matsufuru]
903 
904  const int NPE = CommonParameters::NPE();
905 
906  int flop_site = 0; // superficial initialization
907 
908  if (m_repr == "Dirac") {
909  flop_site = 8 * m_Nc * m_Nc * m_Nd * m_Nd;
910  } else if (m_repr == "Chiral") {
911  flop_site = 4 * m_Nc * m_Nc * m_Nd * m_Nd;
912  }
913 
914  const double gflop = flop_site * ((m_Nvol / 2) * (NPE / 1.0e+9));
915 
916  return gflop;
917  }
918 
919 
920 //====================================================================
921 }
922 //============================================================END=====
GammaMatrixSet
Set of Gamma Matrices: basis class.
Definition: gammaMatrixSet.h:37
Imp::Fopr_CloverTerm_eo::m_Umu
Field_G m_Umu
working vectors
Definition: fopr_CloverTerm_eo_impl.h:100
Imp::Fopr_CloverTerm_eo::get_parameters
void get_parameters(Parameters &params) const
gets parameters by a Parameter object: to be implemented in a subclass.
Definition: fopr_CloverTerm_eo_impl.cpp:207
Field_G::set_unit
void set_unit()
Definition: field_G_imp.cpp:39
ShiftField_eo::forward
void forward(Field &, const Field &, const int mu)
Definition: shiftField_eo.cpp:175
Imp::Fopr_CloverTerm_eo::m_staple
Staple_eo * m_staple
Definition: fopr_CloverTerm_eo_impl.h:90
SU_N::Mat_SU_N::ah
Mat_SU_N & ah()
antihermitian
Definition: mat_SU_N.h:403
GammaMatrixSet::GAMMA5
@ GAMMA5
Definition: gammaMatrixSet.h:48
Imp::Fopr_CloverTerm_eo::m_Ndm2
int m_Ndm2
Definition: fopr_CloverTerm_eo_impl.h:83
Imp::Fopr_CloverTerm_eo::m_GM
std::vector< GammaMatrix > m_GM
Gamma Matrix and Sigma_{mu,nu} = -i [Gamma_mu, Gamma_nu] /2.
Definition: fopr_CloverTerm_eo_impl.h:87
Imp::Fopr_CloverTerm_eo::set_csw_chiral
void set_csw_chiral()
explicit implementation for Chiral representation (for Imp-version).
Definition: fopr_CloverTerm_eo_impl.cpp:746
ShiftField_eo
Methods to shift the even-odd field.
Definition: shiftField_eo.h:49
Imp::Fopr_CloverTerm_eo::m_ut3
Field_G m_ut3
working vectors
Definition: fopr_CloverTerm_eo_impl.h:101
Parameters::set_string
void set_string(const string &key, const string &value)
Definition: parameters.cpp:39
GammaMatrixSet::GAMMA1
@ GAMMA1
Definition: gammaMatrixSet.h:48
fopr_Wilson_impl_SU_N-inc.h
fopr_Wilson_impl_SU3-inc.h
Imp::Fopr_CloverTerm_eo::m_NinF
int m_NinF
Definition: fopr_CloverTerm_eo_impl.h:84
Imp::Fopr_CloverTerm_eo::m_Foo_inv
Field_F m_Foo_inv
inverse of site-diagonal part
Definition: fopr_CloverTerm_eo_impl.h:97
Imp::Fopr_CloverTerm_eo::m_idx
Index_eo m_idx
Definition: fopr_CloverTerm_eo_impl.h:89
Imp::Fopr_CloverTerm_eo::mult_csw_inv
void mult_csw_inv(Field &, const Field &, const int ieo)
multiplies [ 1-csw kappa sigma_{mu nu} F_{mu nu} ]^{-1}
Definition: fopr_CloverTerm_eo_impl.cpp:394
ThreadManager::get_num_threads
static int get_num_threads()
returns available number of threads.
Definition: threadManager.cpp:246
Field_F::cmp_i
double cmp_i(const int cc, const int s, const int site, const int e=0) const
Definition: field_F.h:100
CommonParameters::Ndim
static int Ndim()
Definition: commonParameters.h:117
Imp::Fopr_CloverTerm_eo::set_csw_dirac
void set_csw_dirac()
explicit implementation for Dirac representation (for Imp-version).
Definition: fopr_CloverTerm_eo_impl.cpp:672
Field::set
void set(const int jin, const int site, const int jex, double v)
Definition: field.h:175
Parameters
Class for parameters.
Definition: parameters.h:46
Field_G::mat_dag
Mat_SU_N mat_dag(const int site, const int mn=0) const
Definition: field_G.h:127
GammaMatrixSet::UNITY
@ UNITY
Definition: gammaMatrixSet.h:48
Imp::Fopr_CloverTerm_eo::m_mode
std::string m_mode
Definition: fopr_CloverTerm_eo_impl.h:80
Parameters::set_double
void set_double(const string &key, const double value)
Definition: parameters.cpp:33
Bridge::BridgeIO::decrease_indent
void decrease_indent()
Definition: bridgeIO.h:86
Imp::Fopr_CloverTerm_eo::set_config_impl
void set_config_impl(Field *U)
Definition: fopr_CloverTerm_eo_impl.cpp:283
Imp::Fopr_CloverTerm_eo::flop_count
double flop_count()
returns number of floating point operations.
Definition: fopr_CloverTerm_eo_impl.cpp:897
Bridge::BridgeIO::increase_indent
void increase_indent()
Definition: bridgeIO.h:85
Bridge::BridgeIO::detailed
void detailed(const char *format,...)
Definition: bridgeIO.cpp:219
Imp::Fopr_CloverTerm_eo::set_config
void set_config(Field *U)
sets the gauge configuration.
Definition: fopr_CloverTerm_eo_impl.cpp:254
Field_G::set_mat
void set_mat(const int site, const int mn, const Mat_SU_N &U)
Definition: field_G.h:160
Imp::Fopr_CloverTerm_eo::set_config_omp
void set_config_omp(Field *U)
Definition: fopr_CloverTerm_eo_impl.cpp:271
Field::check_size
bool check_size(const int nin, const int nvol, const int nex) const
checking size parameters. [23 May 2016 H.Matsufuru]
Definition: field.h:135
CommonParameters::Nvol
static int Nvol()
Definition: commonParameters.h:109
Field_F::set_ri
void set_ri(const int cc, const int s, const int site, const int e, const double re, const double im)
Definition: field_F.h:116
Imp::Fopr_CloverTerm_eo::m_cSW
double m_cSW
Definition: fopr_CloverTerm_eo_impl.h:74
Imp::Fopr_CloverTerm_eo::m_Nvol
int m_Nvol
Definition: fopr_CloverTerm_eo_impl.h:82
Imp::Fopr_CloverTerm_eo::m_kappa
double m_kappa
Definition: fopr_CloverTerm_eo_impl.h:73
Imp::Fopr_CloverTerm_eo::m_Fee_inv
Field_F m_Fee_inv
Definition: fopr_CloverTerm_eo_impl.h:97
Field::xI
void xI()
Definition: field.cpp:138
Imp::Fopr_CloverTerm_eo::D_chiral
void D_chiral(Field &v, const Field &f, const int ieo)
explicit implementation for Chiral representation (for Imp-version).
Definition: fopr_CloverTerm_eo_impl.cpp:591
axpy
void axpy(Field &y, const double a, const Field &x)
axpy(y, a, x): y := a * x + y
Definition: field.cpp:380
Imp::Fopr_CloverTerm_eo::m_Cup
Field_G m_Cup
Definition: fopr_CloverTerm_eo_impl.h:100
Imp::Fopr_CloverTerm_eo::m_Ueo
Field_G m_Ueo
even-odd gauge configuration
Definition: fopr_CloverTerm_eo_impl.h:94
Solver_CG::solve
void solve(Field &solution, const Field &source, int &Nconv, double &diff)
Definition: solver_CG.cpp:125
GammaMatrixSet::GAMMA3
@ GAMMA3
Definition: gammaMatrixSet.h:48
fopr_CloverTerm_eo_impl.h
Imp::Fopr_CloverTerm_eo::D
void D(Field &v, const Field &f, const int ieo)
multiplies 1-csw kappa sigma_{mu nu} F_{mu nu}
Definition: fopr_CloverTerm_eo_impl.cpp:521
Imp::Fopr_CloverTerm_eo::m_Nd
int m_Nd
Definition: fopr_CloverTerm_eo_impl.h:83
copy
void copy(Field &y, const Field &x)
copy(y, x): y = x
Definition: field.cpp:212
Imp::Fopr_CloverTerm_eo::m_solver
Solver_CG * m_solver
Definition: fopr_CloverTerm_eo_impl.h:92
shiftField_eo.h
GammaMatrixSet::GAMMA4
@ GAMMA4
Definition: gammaMatrixSet.h:48
Imp::Fopr_CloverTerm_eo::m_w1
Field_F m_w1
Definition: fopr_CloverTerm_eo_impl.h:98
GammaMatrixSet::SIGMA41
@ SIGMA41
Definition: gammaMatrixSet.h:52
Imp::Fopr_CloverTerm_eo::m_boundary
std::vector< int > m_boundary
Definition: fopr_CloverTerm_eo_impl.h:75
CommonParameters::epsilon_criterion2
static double epsilon_criterion2()
Definition: commonParameters.h:120
CommonParameters::Nc
static int Nc()
Definition: commonParameters.h:115
Imp::Fopr_CloverTerm_eo::init
void init(const std::string repr)
Definition: fopr_CloverTerm_eo_impl.cpp:73
Imp::Fopr_CloverTerm_eo::m_repr
std::string m_repr
Definition: fopr_CloverTerm_eo_impl.h:76
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:250
Index_eo::convertField
void convertField(Field &eo, const Field &lex)
Definition: index_eo.cpp:90
Imp::Fopr_CloverTerm_eo::set_csw
void set_csw()
Definition: fopr_CloverTerm_eo_impl.cpp:657
Field_F::cmp_r
double cmp_r(const int cc, const int s, const int site, const int e=0) const
Definition: field_F.h:94
Parameters::fetch_int_vector
int fetch_int_vector(const string &key, vector< int > &value) const
Definition: parameters.cpp:429
Imp::Fopr_CloverTerm_eo::mult
void mult(Field &v, const Field &f)
return D = D^dag = 1-f_ee or 1-f_oo
Definition: fopr_CloverTerm_eo_impl.cpp:305
Imp::Fopr_CloverTerm_eo::set_mode
void set_mode(const std::string mode)
setting the mode of multiplication if necessary. Default implementation here is just to avoid irrelev...
Definition: fopr_CloverTerm_eo_impl.cpp:293
Imp::Fopr_CloverTerm_eo::mult_csw_inv_chiral
void mult_csw_inv_chiral(Field &, const Field &, const int ieo)
Definition: fopr_CloverTerm_eo_impl.cpp:463
Imp::Fopr_CloverTerm_eo::mult_csw_inv_dirac
void mult_csw_inv_dirac(Field &, const Field &, const int ieo)
Definition: fopr_CloverTerm_eo_impl.cpp:407
Imp::Fopr_CloverTerm_eo::mult_dag
void mult_dag(Field &v, const Field &f)
hermitian conjugate of mult.
Definition: fopr_CloverTerm_eo_impl.cpp:321
Field_G::reset
void reset(const int Nvol, const int Nex)
Definition: field_G.h:79
Imp::Fopr_CloverTerm_eo::setup
void setup()
Definition: fopr_CloverTerm_eo_impl.cpp:98
Staple_eo::upper
void upper(Field_G &, const Field_G &, const int, const int)
constructs upper staple in mu-nu plane.
Definition: staple_eo.cpp:282
CommonParameters::NPE
static int NPE()
Definition: commonParameters.h:101
Imp::Fopr_CloverTerm_eo::m_SG
std::vector< GammaMatrix > m_SG
Definition: fopr_CloverTerm_eo_impl.h:87
Imp::Fopr_CloverTerm_eo::m_w2
Field_F m_w2
working vectors
Definition: fopr_CloverTerm_eo_impl.h:98
Parameters::set_int_vector
void set_int_vector(const string &key, const vector< int > &value)
Definition: parameters.cpp:45
GammaMatrixSet::SIGMA42
@ SIGMA42
Definition: gammaMatrixSet.h:52
Imp::Fopr_CloverTerm_eo::m_shift_eo
ShiftField_eo * m_shift_eo
Definition: fopr_CloverTerm_eo_impl.h:91
Imp::Fopr_CloverTerm_eo::m_ut1
Field_G m_ut1
Definition: fopr_CloverTerm_eo_impl.h:101
Imp::Fopr_CloverTerm_eo::m_vl
Bridge::VerboseLevel m_vl
Definition: fopr_CloverTerm_eo_impl.h:77
Field::ptr
const double * ptr(const int jin, const int site, const int jex) const
Definition: field.h:153
Imp::Fopr_CloverTerm_eo::m_Nc
int m_Nc
Definition: fopr_CloverTerm_eo_impl.h:83
Imp::Fopr_CloverTerm_eo::tidyup
void tidyup()
Definition: fopr_CloverTerm_eo_impl.cpp:144
Imp::Fopr_CloverTerm_eo::m_Nvol2
int m_Nvol2
Definition: fopr_CloverTerm_eo_impl.h:82
CommonParameters::Nd
static int Nd()
Definition: commonParameters.h:116
CommonParameters::Vlevel
static Bridge::VerboseLevel Vlevel()
Definition: commonParameters.h:122
fopr_Wilson_impl_SU2-inc.h
Bridge::BridgeIO::set_verbose_level
static VerboseLevel set_verbose_level(const std::string &str)
Definition: bridgeIO.cpp:133
Imp::Fopr_CloverTerm_eo::m_T
Field_G m_T
m_T = 1 - kappa c_SW sigma F / 2
Definition: fopr_CloverTerm_eo_impl.h:95
Imp::Fopr_CloverTerm_eo::class_name
static const std::string class_name
Definition: fopr_CloverTerm_eo_impl.h:69
Staple_eo
Staple construction.
Definition: staple_eo.h:33
Imp::Fopr_CloverTerm_eo::m_Cdn
Field_G m_Cdn
Definition: fopr_CloverTerm_eo_impl.h:100
Imp::Fopr_CloverTerm_eo::setup_gamma_matrices
void setup_gamma_matrices()
Definition: fopr_CloverTerm_eo_impl.cpp:219
Imp::Fopr_CloverTerm_eo::m_Ndim
int m_Ndim
Definition: fopr_CloverTerm_eo_impl.h:82
GammaMatrixSet::SIGMA23
@ SIGMA23
Definition: gammaMatrixSet.h:51
Parameters::set_int
void set_int(const string &key, const int value)
Definition: parameters.cpp:36
Imp::Fopr_CloverTerm_eo::m_ut2
Field_G m_ut2
Definition: fopr_CloverTerm_eo_impl.h:101
scal
void scal(Field &x, const double a)
scal(x, a): x = a * x
Definition: field.cpp:261
Parameters::fetch_string
int fetch_string(const string &key, string &value) const
Definition: parameters.cpp:378
Field_F
Wilson-type fermion field.
Definition: field_F.h:37
Parameters::fetch_double
int fetch_double(const string &key, double &value) const
Definition: parameters.cpp:327
GammaMatrixSet::SIGMA12
@ SIGMA12
Definition: gammaMatrixSet.h:51
Imp::Fopr_CloverTerm_eo::m_Ft
Field_G m_Ft
working vectors
Definition: fopr_CloverTerm_eo_impl.h:99
field_thread-inc.h
Solver_CG::set_parameters
void set_parameters(const Parameters &params)
Definition: solver_CG.cpp:25
GammaMatrixSet::get_GM
GammaMatrix get_GM(GMspecies spec)
Definition: gammaMatrixSet.h:76
solver_CG.h
GammaMatrixSet::GAMMA2
@ GAMMA2
Definition: gammaMatrixSet.h:48
Bridge::BridgeIO::crucial
void crucial(const char *format,...)
Definition: bridgeIO.cpp:180
Imp
Clover term operator.
Definition: fopr_CloverTerm_eo_impl.cpp:32
Solver_CG
Standard Conjugate Gradient solver algorithm.
Definition: solver_CG.h:38
staple_eo.h
Field
Container of Field-type object.
Definition: field.h:46
Staple_eo::lower
void lower(Field_G &, const Field_G &, const int, const int)
constructs lower staple in mu-nu plane.
Definition: staple_eo.cpp:307
GammaMatrixSet::SIGMA31
@ SIGMA31
Definition: gammaMatrixSet.h:51
ThreadManager::get_thread_id
static int get_thread_id()
returns thread id.
Definition: threadManager.cpp:253
Field_G::mat
Mat_SU_N mat(const int site, const int mn=0) const
Definition: field_G.h:114
GammaMatrixSet::SIGMA43
@ SIGMA43
Definition: gammaMatrixSet.h:52
Imp::Fopr_CloverTerm_eo::set_parameters
void set_parameters(const Parameters &params)
sets parameters by a Parameter object: to be implemented in a subclass.
Definition: fopr_CloverTerm_eo_impl.cpp:153
Imp::Fopr_CloverTerm_eo::mult_isigma
void mult_isigma(Field_F &, const Field_F &, const int mu, const int nu)
Definition: fopr_CloverTerm_eo_impl.cpp:644
Imp::Fopr_CloverTerm_eo::sg_index
int sg_index(const int mu, const int nu)
Definition: fopr_CloverTerm_eo_impl.h:190
Field_G
SU(N) gauge field.
Definition: field_G.h:38
Imp::Fopr_CloverTerm_eo::solve_csw_inv
void solve_csw_inv()
Definition: fopr_CloverTerm_eo_impl.cpp:329
Imp::Fopr_CloverTerm_eo::set_fieldstrength
void set_fieldstrength(Field_G &, const int, const int)
Definition: fopr_CloverTerm_eo_impl.cpp:839
Bridge::BridgeIO::general
void general(const char *format,...)
Definition: bridgeIO.cpp:200
Field_F::reset
void reset(int Nvol, int Nex)
Definition: field_F.h:80
Imp::Fopr_CloverTerm_eo::D_dirac
void D_dirac(Field &v, const Field &f, const int ieo)
explicit implementation for Dirac representation (for Imp-version).
Definition: fopr_CloverTerm_eo_impl.cpp:537
gammaMatrixSet.h
ThreadManager::assert_single_thread
static void assert_single_thread(const std::string &class_name)
assert currently running on single thread.
Definition: threadManager.cpp:372
Bridge::vout
BridgeIO vout
Definition: bridgeIO.cpp:512
Bridge::BridgeIO::get_verbose_level
static std::string get_verbose_level(const VerboseLevel vl)
Definition: bridgeIO.cpp:154