Bridge++  Ver.2.1.3
afopr_Clover-tmpl.h
Go to the documentation of this file.
1 
10 #include "lib/ResourceManager/threadManager.h"
11 
12 template<typename AFIELD>
13 const std::string AFopr_Clover<AFIELD>::class_name = "AFopr_Clover";
14 
15 //====================================================================
16 template<typename AFIELD>
17 void AFopr_Clover<AFIELD>::init(const Parameters& params)
18 {
19  ThreadManager::assert_single_thread(class_name);
20 
21  // switch of coomunication
22  //int req_comm = 1; // set 1 if communication forced any time
23  int req_comm = 0; // set 0 if communication called in necessary
24 
25  std::string vlevel;
26  if (!params.fetch_string("verbose_level", vlevel)) {
27  m_vl = vout.set_verbose_level(vlevel);
28  } else {
29  m_vl = CommonParameters::Vlevel();
30  }
31 
32  vout.general(m_vl, "%s: construction\n", class_name.c_str());
33 
34  m_repr = "Dirac"; // now only the Dirac repr is available.
35 
36  std::string repr;
37  if (!params.fetch_string("gamma_matrix_type", repr)) {
38  if (repr != "Dirac") {
39  vout.crucial(" Error at %s: unsupported gamma-matrix type: %s\n",
40  class_name.c_str(), repr.c_str());
41  exit(EXIT_FAILURE);
42  }
43  }
44 
45  m_Nc = CommonParameters::Nc();
46  if (m_Nc != 3) {
47  vout.crucial("%s: only applicable to Nc = 3\n",
48  class_name.c_str());
49  exit(EXIT_FAILURE);
50  }
51 
52  m_Nd = CommonParameters::Nd();
53  m_Nvc = 2 * m_Nc;
54  m_Ndf = 2 * m_Nc * m_Nc;
55 
56  m_Nx = CommonParameters::Nx();
57  m_Ny = CommonParameters::Ny();
58  m_Nz = CommonParameters::Nz();
59  m_Nt = CommonParameters::Nt();
60  m_Nst = CommonParameters::Nvol();
61  m_Ndim = CommonParameters::Ndim();
62 
63  m_Nxv = m_Nx / VLENX;
64  m_Nyv = m_Ny / VLENY;
65  m_Nstv = m_Nst / VLEN;
66 
67  if (VLENX * m_Nxv != m_Nx) {
68  vout.crucial(m_vl, "%s: Nx must be multiple of VLENX.\n",
69  class_name.c_str());
70  exit(EXIT_FAILURE);
71  }
72  if (VLENY * m_Nyv != m_Ny) {
73  vout.crucial(m_vl, "%s: Ny must be multiple of VLENY.\n",
74  class_name.c_str());
75  exit(EXIT_FAILURE);
76  }
77 
78  vout.general(m_vl, " VLENX = %2d Nxv = %d\n", VLENX, m_Nxv);
79  vout.general(m_vl, " VLENY = %2d Nyv = %d\n", VLENY, m_Nyv);
80  vout.general(m_vl, " VLEN = %2d Nstv = %d\n", VLEN, m_Nstv);
81 
82  m_Nsize[0] = m_Nxv;
83  m_Nsize[1] = m_Nyv;
84  m_Nsize[2] = m_Nz;
85  m_Nsize[3] = m_Nt;
86 
87  do_comm_any = 0;
88  for (int mu = 0; mu < m_Ndim; ++mu) {
89  do_comm[mu] = 1;
90  if ((req_comm == 0) && (Communicator::npe(mu) == 1)) do_comm[mu] = 0;
91  do_comm_any += do_comm[mu];
92  vout.general(" do_comm[%d] = %d\n", mu, do_comm[mu]);
93  }
94 
95  m_bdsize.resize(m_Ndim);
96  int Nd2 = m_Nd / 2;
97  m_bdsize[0] = m_Nvc * Nd2 * m_Ny * m_Nz * m_Nt;
98  m_bdsize[1] = m_Nvc * Nd2 * m_Nx * m_Nz * m_Nt;
99  m_bdsize[2] = m_Nvc * Nd2 * m_Nx * m_Ny * m_Nt;
100  m_bdsize[3] = m_Nvc * Nd2 * m_Nx * m_Ny * m_Nz;
101 
102  setup_channels();
103 
104  vout.increase_indent();
105 
106  Parameters params_ct = params;
107 
108 #ifdef CHIRAL_ROTATION
109  params_ct.set_string("gamma_matrix_type", "Chiral");
110  m_fopr_csw = new Fopr_CloverTerm(params_ct);
111 #else
112  m_fopr_csw = new Fopr_CloverTerm(params_ct);
113 #endif
114 
115  set_parameters(params);
116 
117  vout.decrease_indent();
118 
119  // gauge configuration.
120  m_U.reset(NDF, m_Nst, m_Ndim);
121 
122  // working vectors.
123  int NinF = 2 * m_Nc * m_Nd;
124  m_v2.reset(NinF, m_Nst, 1);
125 
126  int Ndm2 = m_Nd * m_Nd / 2;
127  // m_T.reset(NDF, m_Nst, Ndm2);
128  m_T.reset(NDF * Ndm2, m_Nst, 1);
129 
130  vout.general(m_vl, "%s: construction finished.\n",
131  class_name.c_str());
132 }
133 
134 
135 //====================================================================
136 template<typename AFIELD>
137 void AFopr_Clover<AFIELD>::setup_channels()
138 {
139  chsend_up.resize(m_Ndim);
140  chrecv_up.resize(m_Ndim);
141  chsend_dn.resize(m_Ndim);
142  chrecv_dn.resize(m_Ndim);
143 
144  for (int mu = 0; mu < m_Ndim; ++mu) {
145  size_t Nvsize = m_bdsize[mu] * sizeof(real_t);
146 
147  chsend_dn[mu].send_init(Nvsize, mu, -1);
148  chsend_up[mu].send_init(Nvsize, mu, 1);
149 #ifdef USE_MPI
150  chrecv_up[mu].recv_init(Nvsize, mu, 1);
151  chrecv_dn[mu].recv_init(Nvsize, mu, -1);
152 #else
153  void *buf_up = (void *)chsend_dn[mu].ptr();
154  chrecv_up[mu].recv_init(Nvsize, mu, 1, buf_up);
155  void *buf_dn = (void *)chsend_up[mu].ptr();
156  chrecv_dn[mu].recv_init(Nvsize, mu, -1, buf_dn);
157 #endif
158 
159  if (do_comm[mu] == 1) {
160  chset_send.append(chsend_up[mu]);
161  chset_send.append(chsend_dn[mu]);
162  chset_recv.append(chrecv_up[mu]);
163  chset_recv.append(chrecv_dn[mu]);
164  }
165  }
166 }
167 
168 
169 //====================================================================
170 template<typename AFIELD>
171 void AFopr_Clover<AFIELD>::tidyup()
172 {
173  ThreadManager::assert_single_thread(class_name);
174 
175  delete m_fopr_csw;
176 }
177 
178 
179 //====================================================================
180 template<typename AFIELD>
181 void AFopr_Clover<AFIELD>::set_parameters(const Parameters& params)
182 {
183  double kappa, csw;
184  std::vector<int> bc;
185 
186  int err = 0;
187  err += params.fetch_double("hopping_parameter", kappa);
188  err += params.fetch_double("clover_coefficient", csw);
189  err += params.fetch_int_vector("boundary_condition", bc);
190  if (err) {
191  vout.crucial(m_vl, "Error at %s: input parameter not found.\n",
192  class_name.c_str());
193  exit(EXIT_FAILURE);
194  }
195 
196  set_parameters(real_t(kappa), real_t(csw), bc);
197 
198  Parameters params_csw = params;
199 #ifdef CHIRAL_ROTATION
200  params_csw.set_string("gamma_matrix_type", "Chiral");
201 #endif
202  m_fopr_csw->set_parameters(params_csw);
203 }
204 
205 
206 //====================================================================
207 template<typename AFIELD>
208 void AFopr_Clover<AFIELD>::set_parameters(const real_t CKs,
209  const real_t csw,
210  const std::vector<int> bc)
211 {
212  assert(bc.size() == m_Ndim);
213 
214 #pragma omp barrier
215 
216  int ith = ThreadManager::get_thread_id();
217 
218  if (ith == 0) {
219  m_CKs = CKs;
220  m_csw = csw;
221  m_boundary.resize(m_Ndim);
222  for (int mu = 0; mu < m_Ndim; ++mu) {
223  m_boundary[mu] = bc[mu];
224  }
225  }
226 
227  vout.general(m_vl, "%s: set parameters\n", class_name.c_str());
228  vout.general(m_vl, " gamma-matrix type = %s\n", m_repr.c_str());
229  vout.general(m_vl, " kappa = %8.4f\n", m_CKs);
230  vout.general(m_vl, " cSW = %12.8f\n", m_csw);
231  for (int mu = 0; mu < m_Ndim; ++mu) {
232  vout.general(m_vl, " boundary[%d] = %2d\n", mu, m_boundary[mu]);
233  }
234 
235 #pragma omp barrier
236 }
237 
238 
239 //====================================================================
240 template<typename AFIELD>
241 void AFopr_Clover<AFIELD>::get_parameters(Parameters& params) const
242 {
243  params.set_double("hopping_parameter", double(m_CKs));
244  params.set_double("clover_coefficient", double(m_csw));
245  params.set_int_vector("boundary_condition", m_boundary);
246  params.set_string("gamma_matrix_type", m_repr);
247 
248  params.set_string("verbose_level", vout.get_verbose_level(m_vl));
249 }
250 
251 
252 //====================================================================
253 template<typename AFIELD>
254 void AFopr_Clover<AFIELD>::set_config(Field *u)
255 {
256  int nth = ThreadManager::get_num_threads();
257 
258  vout.detailed(m_vl, "%s: set_config is called: num_threads = %d\n",
259  class_name.c_str(), nth);
260 
261  if (nth > 1) {
262  set_config_impl(u);
263  } else {
264  set_config_omp(u);
265  }
266 
267  vout.detailed(m_vl, "%s: set_config finished\n", class_name.c_str());
268 }
269 
270 
271 //====================================================================
272 template<typename AFIELD>
273 void AFopr_Clover<AFIELD>::set_config_omp(Field *u)
274 {
275  vout.detailed(m_vl, " set_config_omp is called.\n");
276 
277 #pragma omp parallel
278  {
279  set_config_impl(u);
280  }
281 }
282 
283 
284 //====================================================================
285 template<typename AFIELD>
286 void AFopr_Clover<AFIELD>::set_config_impl(Field *u)
287 {
288 #pragma omp barrier
289 
290  int ith = ThreadManager::get_thread_id();
291 
292  if (ith == 0) m_conf = u;
293 
294  AIndex_lex<real_t, AFIELD::IMPL> index;
295 
296  convert_gauge(index, m_U, *u);
297 
298  QXS_Gauge::set_boundary(m_U, m_boundary);
299 
300  m_fopr_csw->set_config(u);
301 
302 #ifdef CHIRAL_ROTATION
303  set_csw_chrot();
304 #else
305  set_csw();
306 #endif
307 }
308 
309 
310 //====================================================================
311 template<typename AFIELD>
312 void AFopr_Clover<AFIELD>::set_csw()
313 {
314  // The Dirac representation is assumed.
315  // Current implementation makes use of the corelib Fopr_CloverTerm
316  // that requires change of the gamma-matrix convention from
317  // Bridge++ to QXS (BQCD) by multiplying gamma_4 before and after
318  // m_fopr_csw->mult().
319  // For numerical efficiency, proper implementation is necessaty.
320  // [08 Mar 2021 H.Matsufuru]
321 
322 #pragma omp barrier
323 
324  AIndex_lex<real_t, AFIELD::IMPL> index;
325 
326  const int Nin = NDF * ND * 2;
327 
328  m_fopr_csw->set_mode("D");
329 
330  int ith, nth, is, ns;
331  set_threadtask_mult(ith, nth, is, ns, m_Nst);
332 
333  for (int id = 0; id < m_Nd / 2; ++id) {
334  for (int ic = 0; ic < m_Nc; ++ic) {
335  m_w1.set(0.0);
336 #pragma omp barrier
337 
338  for (int site = is; site < ns; ++site) {
339  m_w1.set_r(ic, id, site, 0, 1.0);
340  }
341 #pragma omp barrier
342 
343  m_fopr_csw->mult(m_w2, m_w1);
344 #pragma omp barrier
345 
346  for (int site = is; site < ns; ++site) {
347  for (int ic2 = 0; ic2 < m_Nc; ++ic2) {
348  real_t vt_r = m_w2.cmp_r(ic2, 0, site, 0);
349  real_t vt_i = m_w2.cmp_i(ic2, 0, site, 0);
350  int in = ic2 + NC * (ic + NC * (id + 0));
351  int idx_r = index.idx(2 * in, Nin, site, 0);
352  int idx_i = index.idx(2 * in + 1, Nin, site, 0);
353  m_T.set(idx_r, vt_r);
354  m_T.set(idx_i, vt_i);
355  }
356 
357  for (int ic2 = 0; ic2 < m_Nc; ++ic2) {
358  real_t vt_r = m_w2.cmp_r(ic2, 1, site, 0);
359  real_t vt_i = m_w2.cmp_i(ic2, 1, site, 0);
360  int in = ic2 + NC * (ic + NC * (id + 4));
361  int idx_r = index.idx(2 * in, Nin, site, 0);
362  int idx_i = index.idx(2 * in + 1, Nin, site, 0);
363  m_T.set(idx_r, vt_r);
364  m_T.set(idx_i, vt_i);
365  }
366 
367  for (int ic2 = 0; ic2 < m_Nc; ++ic2) {
368  real_t vt_r = -m_w2.cmp_r(ic2, 2, site, 0);
369  real_t vt_i = -m_w2.cmp_i(ic2, 2, site, 0);
370  int in = ic2 + NC * (ic + NC * (id + 2));
371  int idx_r = index.idx(2 * in, Nin, site, 0);
372  int idx_i = index.idx(2 * in + 1, Nin, site, 0);
373  m_T.set(idx_r, vt_r);
374  m_T.set(idx_i, vt_i);
375  }
376 
377  for (int ic2 = 0; ic2 < m_Nc; ++ic2) {
378  real_t vt_r = -m_w2.cmp_r(ic2, 3, site, 0);
379  real_t vt_i = -m_w2.cmp_i(ic2, 3, site, 0);
380  int in = ic2 + NC * (ic + NC * (id + 6));
381  int idx_r = index.idx(2 * in, Nin, site, 0);
382  int idx_i = index.idx(2 * in + 1, Nin, site, 0);
383  m_T.set(idx_r, vt_r);
384  m_T.set(idx_i, vt_i);
385  }
386  } // site loop
387 #pragma omp barrier
388  }
389  }
390 #pragma omp barrier
391 
392  real_t kappaR = 1.0 / m_CKs;
393  scal(m_T, kappaR);
394 
395 #pragma omp barrier
396 }
397 
398 
399 //====================================================================
400 template<typename AFIELD>
401 void AFopr_Clover<AFIELD>::set_csw_chrot()
402 {
403  // This method set the clover term matrix assuming the chiral
404  // representation for gamma-matrix in Bridge++ convention.
405  // The conversion from the Bridge++ to QWS convention and
406  // from Dirac to chiral representations are assumed to be cared
407  // in BridgeQXS functions.
408  // [17 Jul 2021 H.Matsufuru]
409 
410  AIndex_lex<real_t, AFIELD::IMPL> index;
411 
412  const int Nin = NDF * ND * 2;
413 
414  m_fopr_csw->set_mode("D");
415 
416  int ith, nth, is, ns;
417  set_threadtask_mult(ith, nth, is, ns, m_Nst);
418 
419  //11 22 33 44 55 66 12 34 56 23 45 13 24 35 46 15 26 14 36 25 16
420  constexpr int idx[72] = {
421  0, -1, 6, 7, 16, 17, 28, 29, 24, 25, 34, 35,
422  -1, -1, 1, -1, 12, 13, 18, 19, 32, 33, 26, 27,
423  -1, -1, -1, -5, 2, -1, 8, 9, 20, 21, 30, 31,
424  -1, -1, -1, -1, -1, -1, 3, -1, 14, 15, 22, 23,
425  -1, -1, -1, -1, -1, -1, -1, -1, 4, -1, 10, 11,
426  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, -1,
427  };
428 
429  for (int id = 0; id < m_Nd / 2; ++id) {
430  for (int ic = 0; ic < m_Nc; ++ic) {
431  m_w1.set(0.0);
432 #pragma omp barrier
433 
434  for (int site = is; site < ns; ++site) {
435  m_w1.set_r(ic, id, site, 0, 1.0);
436  m_w1.set_r(ic, id + 2, site, 0, 1.0);
437  }
438 #pragma omp barrier
439 
440  m_fopr_csw->mult(m_w2, m_w1);
441 #pragma omp barrier
442 
443  for (int site = is; site < ns; ++site) {
444  for (int id2 = 0; id2 < m_Nd; ++id2) {
445  for (int ic2 = 0; ic2 < m_Nc; ++ic2) {
446  real_t vt_r = 0.5 * m_w2.cmp_r(ic2, id2, site, 0);
447  real_t vt_i = 0.5 * m_w2.cmp_i(ic2, id2, site, 0);
448  int i = ic2 + m_Nc * (id2 % 2);
449  int j = ic + m_Nc * id;
450  int ij = m_Nc * 2 * i + j;
451  int in_r = idx[2 * ij];
452  int in_i = idx[2 * ij + 1];
453  if (in_r >= 0) {
454  in_r += 36 * (id2 / 2);
455  int idx_r = index.idx(in_r, Nin, site, 0);
456  m_T.set(idx_r, vt_r);
457  }
458  if (in_i >= 0) {
459  in_i += 36 * (id2 / 2);
460  int idx_i = index.idx(in_i, Nin, site, 0);
461  m_T.set(idx_i, vt_i);
462  }
463  }
464  }
465  } // site loop
466 #pragma omp barrier
467  }
468  }
469 #pragma omp barrier
470 
471  real_t kappaR = 1.0 / m_CKs;
472  scal(m_T, kappaR);
473 
474 #pragma omp barrier
475 }
476 
477 
478 //====================================================================
479 template<typename AFIELD>
480 void AFopr_Clover<AFIELD>::convert(AFIELD& v, const Field& w)
481 {
482  AIndex_lex<real_t, AFIELD::IMPL> index_lex;
483  convert_spinor(index_lex, m_v2, w);
484 
485  mult_gm4(v, m_v2);
486 }
487 
488 
489 //====================================================================
490 template<typename AFIELD>
491 void AFopr_Clover<AFIELD>::reverse(Field& v, const AFIELD& w)
492 {
493  mult_gm4(m_v2, w);
494 
495  AIndex_lex<real_t, AFIELD::IMPL> index_lex;
496  reverse_spinor(index_lex, v, m_v2);
497 }
498 
499 
500 //====================================================================
501 template<typename AFIELD>
502 void AFopr_Clover<AFIELD>::mult_up(int mu, AFIELD& v, const AFIELD& w)
503 {
504  real_t *vp = v.ptr(0);
505  real_t *wp = const_cast<AFIELD *>(&w)->ptr(0);
506 
507  if (mu == 0) {
508  mult_xp(vp, wp);
509  } else if (mu == 1) {
510  mult_yp(vp, wp);
511  } else if (mu == 2) {
512  mult_zp(vp, wp);
513  } else if (mu == 3) {
514  mult_tp(vp, wp);
515  } else {
516  vout.crucial(m_vl, "%s: mult_up for %d direction is undefined.",
517  class_name.c_str(), mu);
518  exit(EXIT_FAILURE);
519  }
520 }
521 
522 
523 //====================================================================
524 template<typename AFIELD>
525 void AFopr_Clover<AFIELD>::mult_dn(int mu, AFIELD& v, const AFIELD& w)
526 {
527  real_t *vp = v.ptr(0);
528  real_t *wp = const_cast<AFIELD *>(&w)->ptr(0);
529 
530  if (mu == 0) {
531  mult_xm(vp, wp);
532  } else if (mu == 1) {
533  mult_ym(vp, wp);
534  } else if (mu == 2) {
535  mult_zm(vp, wp);
536  } else if (mu == 3) {
537  mult_tm(vp, wp);
538  } else {
539  vout.crucial(m_vl, "%s: mult_dn for %d direction is undefined.",
540  class_name.c_str(), mu);
541  exit(EXIT_FAILURE);
542  }
543 }
544 
545 
546 //====================================================================
547 template<typename AFIELD>
548 void AFopr_Clover<AFIELD>::set_mode(std::string mode)
549 {
550 #pragma omp barrier
551 
552  int ith = ThreadManager::get_thread_id();
553  if (ith == 0) m_mode = mode;
554 
555 #pragma omp barrier
556 }
557 
558 
559 //====================================================================
560 template<typename AFIELD>
561 std::string AFopr_Clover<AFIELD>::get_mode() const
562 {
563  return m_mode;
564 }
565 
566 
567 //====================================================================
568 template<typename AFIELD>
569 void AFopr_Clover<AFIELD>::mult(AFIELD& v, const AFIELD& w)
570 {
571  if (m_mode == "D") {
572  return D(v, w);
573  } else if (m_mode == "DdagD") {
574  return DdagD(v, w);
575  } else if (m_mode == "Ddag") {
576  return Ddag(v, w);
577  } else if (m_mode == "H") {
578  return H(v, w);
579  } else {
580  vout.crucial(m_vl, "%s: mode undefined.\n", class_name.c_str());
581  exit(EXIT_FAILURE);
582  }
583 }
584 
585 
586 //====================================================================
587 template<typename AFIELD>
588 void AFopr_Clover<AFIELD>::mult_dag(AFIELD& v, const AFIELD& w)
589 {
590  if (m_mode == "D") {
591  return Ddag(v, w);
592  } else if (m_mode == "DdagD") {
593  return DdagD(v, w);
594  } else if (m_mode == "Ddag") {
595  return D(v, w);
596  } else if (m_mode == "H") {
597  return H(v, w);
598  } else {
599  vout.crucial(m_vl, "%s: mode undefined.\n", class_name.c_str());
600  exit(EXIT_FAILURE);
601  }
602 }
603 
604 
605 //====================================================================
606 template<typename AFIELD>
607 void AFopr_Clover<AFIELD>::D(AFIELD& v, const AFIELD& w)
608 {
609  mult_D(v, w);
610  //mult_D_alt(v, w);
611 }
612 
613 
614 //====================================================================
615 template<typename AFIELD>
616 void AFopr_Clover<AFIELD>::DdagD(AFIELD& v, const AFIELD& w)
617 {
618  D(m_v2, w);
619  mult_gm5(v, m_v2);
620  D(m_v2, v);
621  mult_gm5(v, m_v2);
622 }
623 
624 
625 //====================================================================
626 template<typename AFIELD>
627 void AFopr_Clover<AFIELD>::Ddag(AFIELD& v, const AFIELD& w)
628 {
629  mult_gm5(v, w);
630  D(m_v2, v);
631  mult_gm5(v, m_v2);
632 }
633 
634 
635 //====================================================================
636 template<typename AFIELD>
637 void AFopr_Clover<AFIELD>::mult_gm5(AFIELD& v, const AFIELD& w)
638 {
639  real_t *vp = v.ptr(0);
640  real_t *wp = const_cast<AFIELD *>(&w)->ptr(0);
641 
642 #pragma omp barrier
643 
644  BridgeQXS::mult_wilson_gm5_dirac(vp, wp, m_Nsize);
645 
646 #pragma omp barrier
647 
648  // mult_gm5(vp, wp);
649 }
650 
651 
652 //====================================================================
653 template<typename AFIELD>
654 void AFopr_Clover<AFIELD>::mult_gm4(AFIELD& v, const AFIELD& w)
655 {
656  real_t *vp = v.ptr(0);
657  real_t *wp = const_cast<AFIELD *>(&w)->ptr(0);
658 
659  int ith, nth, is, ns;
660  set_threadtask_mult(ith, nth, is, ns, m_Nstv);
661 
662  Vsimd_t wt[2];
663 
664  for (int site = is; site < ns; ++site) {
665  for (int ic = 0; ic < NC; ++ic) {
666  for (int id = 0; id < ND2; ++id) {
667  int idx1 = 2 * (id + ND * ic) + NVCD * site;
668  load_vec(wt, &wp[VLEN * idx1], 2);
669  save_vec(&vp[VLEN * idx1], wt, 2);
670  }
671 
672  for (int id = ND2; id < ND; ++id) {
673  int idx1 = 2 * (id + ND * ic) + NVCD * site;
674  load_vec(wt, &wp[VLEN * idx1], 2);
675  scal_vec(wt, real_t(-1.0), 2);
676  save_vec(&vp[VLEN * idx1], wt, 2);
677  }
678  }
679  }
680 
681 #pragma omp barrier
682 }
683 
684 
685 //====================================================================
686 template<typename AFIELD>
687 void AFopr_Clover<AFIELD>::mult_csw(real_t *v2, real_t *v1)
688 { // Dirac representation is assumed.
689  real_t *u = m_T.ptr(0);
690 
691  int ith, nth, is, ns;
692  set_threadtask(ith, nth, is, ns, m_Nstv);
693 
694 #pragma omp barrier
695 
696  for (int site = is; site < ns; ++site) {
697  Vsimd_t v2v[NVCD];
698  // clear_vec(v2v, NVCD);
699  load_vec(v2v, &v2[VLEN * NVCD * site], NVCD);
700 
701  Vsimd_t v1v[NVCD];
702  load_vec(v1v, &v1[VLEN * NVCD * site], NVCD);
703 
704  Vsimd_t ut[NDF], wt1[2], wt2[2];
705 
706  for (int jd = 0; jd < ND2; ++jd) {
707  for (int id = 0; id < ND; ++id) {
708  int ig = VLEN * NDF * (site + m_Nstv * (id + ND * jd));
709  load_vec(ut, &u[ig], NDF);
710  for (int ic = 0; ic < NC; ++ic) {
711  int ic2 = 2 * ic;
712  int id2 = (id + ND2) % ND;
713  mult_ctv(wt1, &ut[ic2], &v1v[2 * id], NC);
714  mult_ctv(wt2, &ut[ic2], &v1v[2 * id2], NC);
715  int icd1 = 2 * (jd + ND * ic);
716  int icd2 = 2 * (jd + ND2 + ND * ic);
717  axpy_vec(&v2v[icd1], real_t(1.0), wt1, 2);
718  axpy_vec(&v2v[icd2], real_t(1.0), wt2, 2);
719  }
720  }
721  }
722 
723  save_vec(&v2[VLEN * NVCD * site], v2v, NVCD);
724  }
725 
726 #pragma omp barrier
727 }
728 
729 
730 //====================================================================
731 template<typename AFIELD>
732 void AFopr_Clover<AFIELD>::mult_D(AFIELD& v, const AFIELD& w)
733 {
734  real_t *v2 = v.ptr(0);
735  real_t *v1 = const_cast<AFIELD *>(&w)->ptr(0);
736  real_t *up = m_U.ptr(0);
737  real_t *ct = m_T.ptr(0);
738 
739  int ith = ThreadManager::get_thread_id();
740 
741 #pragma omp barrier
742 
743  if (do_comm_any > 0) {
744  if (ith == 0) chset_recv.start();
745 
746  real_t *buf1_xp = (real_t *)chsend_dn[0].ptr();
747  real_t *buf1_xm = (real_t *)chsend_up[0].ptr();
748  real_t *buf1_yp = (real_t *)chsend_dn[1].ptr();
749  real_t *buf1_ym = (real_t *)chsend_up[1].ptr();
750  real_t *buf1_zp = (real_t *)chsend_dn[2].ptr();
751  real_t *buf1_zm = (real_t *)chsend_up[2].ptr();
752  real_t *buf1_tp = (real_t *)chsend_dn[3].ptr();
753  real_t *buf1_tm = (real_t *)chsend_up[3].ptr();
754 
755  BridgeQXS::mult_wilson_1_dirac(buf1_xp, buf1_xm, buf1_yp, buf1_ym,
756  buf1_zp, buf1_zm, buf1_tp, buf1_tm,
757  up, v1, &m_boundary[0], m_Nsize, do_comm);
758 
759 #pragma omp barrier
760 
761  if (ith == 0) chset_send.start();
762  }
763 
764 #ifdef CHIRAL_ROTATION
765  BridgeQXS::mult_clover_bulk_dirac_chrot(v2, up, ct, v1,
766  m_CKs, &m_boundary[0], m_Nsize, do_comm);
767 #else
768  BridgeQXS::mult_clover_bulk_dirac(v2, up, ct, v1,
769  m_CKs, &m_boundary[0], m_Nsize, do_comm);
770 #endif
771 
772  if (do_comm_any > 0) {
773  if (ith == 0) chset_recv.wait();
774 
775 #pragma omp barrier
776 
777  real_t *buf2_xp = (real_t *)chrecv_up[0].ptr();
778  real_t *buf2_xm = (real_t *)chrecv_dn[0].ptr();
779  real_t *buf2_yp = (real_t *)chrecv_up[1].ptr();
780  real_t *buf2_ym = (real_t *)chrecv_dn[1].ptr();
781  real_t *buf2_zp = (real_t *)chrecv_up[2].ptr();
782  real_t *buf2_zm = (real_t *)chrecv_dn[2].ptr();
783  real_t *buf2_tp = (real_t *)chrecv_up[3].ptr();
784  real_t *buf2_tm = (real_t *)chrecv_dn[3].ptr();
785 
786  BridgeQXS::mult_wilson_2_dirac(v2, up, v1,
787  buf2_xp, buf2_xm, buf2_yp, buf2_ym,
788  buf2_zp, buf2_zm, buf2_tp, buf2_tm,
789  m_CKs, &m_boundary[0], m_Nsize, do_comm);
790 
791  if (ith == 0) chset_send.wait();
792  }
793 
794 #pragma omp barrier
795 }
796 
797 
798 //====================================================================
799 template<typename AFIELD>
800 void AFopr_Clover<AFIELD>::mult_D_alt(AFIELD& v, const AFIELD& w)
801 {
802  real_t *vp = v.ptr(0);
803  real_t *wp = const_cast<AFIELD *>(&w)->ptr(0);
804 
805  clear(vp);
806 
807  mult_xp(vp, wp);
808  mult_xm(vp, wp);
809  mult_yp(vp, wp);
810  mult_ym(vp, wp);
811  mult_zp(vp, wp);
812  mult_zm(vp, wp);
813  mult_tp(vp, wp);
814  mult_tm(vp, wp);
815 
816  mult_csw(vp, wp);
817 
818  aypx(-m_CKs, vp, wp);
819 
820 #pragma omp barrier
821 }
822 
823 
824 //====================================================================
825 template<typename AFIELD>
826 void AFopr_Clover<AFIELD>::H(AFIELD& v, const AFIELD& w)
827 {
828  D(m_v2, w);
829  mult_gm5(v, m_v2);
830 }
831 
832 
833 //====================================================================
834 template<typename AFIELD>
835 void AFopr_Clover<AFIELD>::aypx(real_t a, real_t *v, real_t *w)
836 {
837  int ith, nth, is, ns;
838  set_threadtask_mult(ith, nth, is, ns, m_Nstv);
839 
840  Vsimd_t vt[NVCD], wt[NVCD];
841 
842  for (int site = is; site < ns; ++site) {
843  load_vec(vt, &v[VLEN * NVCD * site], NVCD);
844  load_vec(wt, &w[VLEN * NVCD * site], NVCD);
845  aypx_vec(a, vt, wt, NVCD);
846  save_vec(&v[VLEN * NVCD * site], vt, NVCD);
847  }
848 }
849 
850 
851 //====================================================================
852 template<typename AFIELD>
853 void AFopr_Clover<AFIELD>::clear(real_t *v)
854 {
855  int ith, nth, is, ns;
856  set_threadtask_mult(ith, nth, is, ns, m_Nstv);
857 
858  Vsimd_t vt[NVCD];
859  clear_vec(vt, NVCD);
860 
861  for (int site = is; site < ns; ++site) {
862  save_vec(&v[VLEN * NVCD * site], vt, NVCD);
863  }
864 }
865 
866 
867 //====================================================================
868 template<typename AFIELD>
869 void AFopr_Clover<AFIELD>::mult_xp(real_t *v2, real_t *v1)
870 {
871  int idir = 0;
872 
873  int ith, nth, is, ns;
874  set_threadtask_mult(ith, nth, is, ns, m_Nstv);
875 
876  Vsimd_t v2v[NVCD];
877 
878  real_t *buf1 = (real_t *)chsend_dn[0].ptr();
879  real_t *buf2 = (real_t *)chrecv_up[0].ptr();
880 
881  real_t *u = m_U.ptr(m_Ndf * m_Nst * idir);
882 
883 #pragma omp barrier
884 
885  if (do_comm[0] > 0) {
886  for (int site = is; site < ns; ++site) {
887  int ix = site % m_Nxv;
888  int iyzt = site / m_Nxv;
889  if (ix == 0) {
890  int ibf = VLENY * NVC * ND2 * iyzt;
891  mult_wilson_xp1(&buf1[ibf], &v1[VLEN * NVCD * site]);
892  }
893  }
894 
895 #pragma omp barrier
896 
897 #pragma omp master
898  {
899  chrecv_up[0].start();
900  chsend_dn[0].start();
901  chrecv_up[0].wait();
902  chsend_dn[0].wait();
903  }
904 #pragma omp barrier
905  } // if(do_comm[0] == 1)
906 
907  for (int site = is; site < ns; ++site) {
908  int ix = site % m_Nxv;
909  int iyzt = site / m_Nxv;
910 
911  Vsimd_t v2v[NVCD];
912  clear_vec(v2v, NVCD);
913 
914  real_t zL[VLEN * NVCD];
915 
916  if ((ix < m_Nxv - 1) || (do_comm[0] == 0)) {
917  int nei = ix + 1 + m_Nxv * iyzt;
918  if (ix == m_Nxv - 1) nei = 0 + m_Nxv * iyzt;
919  shift_vec2_xbw(zL, &v1[VLEN * NVCD * site], &v1[VLEN * NVCD * nei], NVCD);
920  mult_wilson_xpb(v2v, &u[VLEN * NDF * site], zL);
921  } else {
922  int ibf = VLENY * NVC * ND2 * iyzt;
923  shift_vec0_xbw(zL, &v1[VLEN * NVCD * site], NVCD);
924  mult_wilson_xpb(v2v, &u[VLEN * NDF * site], zL);
925  mult_wilson_xp2(v2v, &u[VLEN * NDF * site], &buf2[ibf]);
926  }
927 
928  add_vec(&v2[VLEN * NVCD * site], v2v, NVCD);
929  }
930 
931 #pragma omp barrier
932 }
933 
934 
935 //====================================================================
936 template<typename AFIELD>
937 void AFopr_Clover<AFIELD>::mult_xm(real_t *v2, real_t *v1)
938 {
939  int idir = 0;
940 
941  int ith, nth, is, ns;
942  set_threadtask_mult(ith, nth, is, ns, m_Nstv);
943 
944  Vsimd_t v2v[NVCD];
945 
946  real_t *buf1 = (real_t *)chsend_up[0].ptr();
947  real_t *buf2 = (real_t *)chrecv_dn[0].ptr();
948 
949  real_t *u = m_U.ptr(m_Ndf * m_Nst * idir);
950 
951 #pragma omp barrier
952 
953  if (do_comm[0] > 0) {
954  for (int site = is; site < ns; ++site) {
955  int ix = site % m_Nxv;
956  int iyzt = site / m_Nxv;
957  if (ix == m_Nxv - 1) {
958  int ibf = VLENY * NVC * ND2 * iyzt;
959  mult_wilson_xm1(&buf1[ibf], &u[VLEN * NDF * site],
960  &v1[VLEN * NVCD * site]);
961  }
962  }
963 
964 #pragma omp barrier
965 #pragma omp master
966  {
967  chrecv_dn[0].start();
968  chsend_up[0].start();
969  chrecv_dn[0].wait();
970  chsend_up[0].wait();
971  }
972 #pragma omp barrier
973  } // end of if(do_comm[0] > 0)
974 
975  for (int site = is; site < ns; ++site) {
976  int ix = site % m_Nxv;
977  int iyzt = site / m_Nxv;
978 
979  real_t zL[VLEN * NVCD];
980  real_t uL[VLEN * NDF];
981 
982  clear_vec(v2v, NVCD);
983 
984  if ((ix > 0) || (do_comm[0] == 0)) {
985  int nei = ix - 1 + m_Nxv * iyzt;
986  if (ix == 0) nei = m_Nxv - 1 + m_Nxv * iyzt;
987  shift_vec2_xfw(zL, &v1[VLEN * NVCD * site], &v1[VLEN * NVCD * nei], NVCD);
988  shift_vec2_xfw(uL, &u[VLEN * NDF * site], &u[VLEN * NDF * nei], NDF);
989  mult_wilson_xmb(v2v, uL, zL);
990  } else {
991  int ibf = VLENY * NVC * ND2 * iyzt;
992  shift_vec0_xfw(zL, &v1[VLEN * NVCD * site], NVCD);
993  shift_vec0_xfw(uL, &u[VLEN * NDF * site], NDF);
994  mult_wilson_xmb(v2v, uL, zL);
995  mult_wilson_xm2(v2v, &buf2[ibf]);
996  }
997 
998  add_vec(&v2[VLEN * NVCD * site], v2v, NVCD);
999  }
1000 
1001 #pragma omp barrier
1002 }
1003 
1004 
1005 //====================================================================
1006 template<typename AFIELD>
1007 void AFopr_Clover<AFIELD>::mult_yp(real_t *v2, real_t *v1)
1008 {
1009  int idir = 1;
1010  int Nxy = m_Nxv * m_Nyv;
1011 
1012  int ith, nth, is, ns;
1013  set_threadtask_mult(ith, nth, is, ns, m_Nstv);
1014 
1015  real_t *buf1 = (real_t *)chsend_dn[1].ptr();
1016  real_t *buf2 = (real_t *)chrecv_up[1].ptr();
1017 
1018  real_t *u = m_U.ptr(m_Ndf * m_Nst * idir);
1019 
1020 #pragma omp barrier
1021 
1022  if (do_comm[1] > 0) {
1023  for (int site = is; site < ns; ++site) {
1024  int ix = site % m_Nxv;
1025  int iy = (site / m_Nxv) % m_Nyv;
1026  int izt = site / Nxy;
1027  if (iy == 0) {
1028  int ibf = VLENX * NVC * ND2 * (ix + m_Nxv * izt);
1029  mult_wilson_yp1(&buf1[ibf], &v1[VLEN * NVCD * site]);
1030  }
1031  }
1032 
1033 #pragma omp barrier
1034 
1035 #pragma omp master
1036  {
1037  chrecv_up[1].start();
1038  chsend_dn[1].start();
1039  chrecv_up[1].wait();
1040  chsend_dn[1].wait();
1041  }
1042 
1043 #pragma omp barrier
1044  } // end of if(do_comm[1] > 0)
1045 
1046  for (int site = is; site < ns; ++site) {
1047  int ix = site % m_Nxv;
1048  int iy = (site / m_Nxv) % m_Nyv;
1049  int izt = site / Nxy;
1050 
1051  Vsimd_t v2v[NVCD];
1052  clear_vec(v2v, NVCD);
1053 
1054  real_t zL[VLEN * NVCD];
1055 
1056  if ((iy < m_Nyv - 1) || (do_comm[1] == 0)) {
1057  int iy2 = (iy + 1) % m_Nyv;
1058  int nei = ix + m_Nxv * (iy2 + m_Nyv * izt);
1059  shift_vec2_ybw(zL, &v1[VLEN * NVCD * site], &v1[VLEN * NVCD * nei], NVCD);
1060  mult_wilson_ypb(v2v, &u[VLEN * NDF * site], zL);
1061  } else {
1062  int ibf = VLENX * NVC * ND2 * (ix + m_Nxv * izt);
1063  shift_vec0_ybw(zL, &v1[VLEN * NVCD * site], NVCD);
1064  mult_wilson_ypb(v2v, &u[VLEN * NDF * site], zL);
1065  mult_wilson_yp2(v2v, &u[VLEN * NDF * site], &buf2[ibf]);
1066  }
1067 
1068  add_vec(&v2[VLEN * NVCD * site], v2v, NVCD);
1069  }
1070 
1071 #pragma omp barrier
1072 }
1073 
1074 
1075 //====================================================================
1076 template<typename AFIELD>
1077 void AFopr_Clover<AFIELD>::mult_ym(real_t *v2, real_t *v1)
1078 {
1079  int idir = 1;
1080  int Nxy = m_Nxv * m_Nyv;
1081 
1082  int ith, nth, is, ns;
1083  set_threadtask_mult(ith, nth, is, ns, m_Nstv);
1084 
1085  real_t *buf1 = (real_t *)chsend_up[1].ptr();
1086  real_t *buf2 = (real_t *)chrecv_dn[1].ptr();
1087 
1088  real_t *u = m_U.ptr(m_Ndf * m_Nst * idir);
1089 
1090 #pragma omp barrier
1091 
1092  if (do_comm[1] > 0) {
1093  for (int site = is; site < ns; ++site) {
1094  int ix = site % m_Nxv;
1095  int iy = (site / m_Nxv) % m_Nyv;
1096  int izt = site / Nxy;
1097  if (iy == m_Nyv - 1) {
1098  int ibf = VLENX * NVC * ND2 * (ix + m_Nxv * izt);
1099  mult_wilson_ym1(&buf1[ibf], &u[VLEN * NDF * site],
1100  &v1[VLEN * NVCD * site]);
1101  }
1102  }
1103 
1104 #pragma omp barrier
1105 
1106 #pragma omp master
1107  {
1108  chrecv_dn[1].start();
1109  chsend_up[1].start();
1110  chrecv_dn[1].wait();
1111  chsend_up[1].wait();
1112  }
1113 
1114 #pragma omp barrier
1115  }
1116 
1117  for (int site = is; site < ns; ++site) {
1118  int ix = site % m_Nxv;
1119  int iy = (site / m_Nxv) % m_Nyv;
1120  int izt = site / Nxy;
1121 
1122  Vsimd_t v2v[NVCD];
1123  clear_vec(v2v, NVCD);
1124 
1125  real_t zL[VLEN * NVCD];
1126  real_t uL[VLEN * NDF];
1127 
1128  if ((iy != 0) || (do_comm[idir] == 0)) {
1129  int iy2 = (iy - 1 + m_Nyv) % m_Nyv;
1130  int nei = ix + m_Nxv * (iy2 + m_Nyv * izt);
1131  shift_vec2_yfw(zL, &v1[VLEN * NVCD * site], &v1[VLEN * NVCD * nei], NVCD);
1132  shift_vec2_yfw(uL, &u[VLEN * NDF * site], &u[VLEN * NDF * nei], NDF);
1133  mult_wilson_ymb(v2v, uL, zL);
1134  } else {
1135  int ibf = VLENX * NVC * ND2 * (ix + m_Nxv * izt);
1136  shift_vec0_yfw(zL, &v1[VLEN * NVCD * site], NVCD);
1137  shift_vec0_yfw(uL, &u[VLEN * NDF * site], NDF);
1138  mult_wilson_ymb(v2v, uL, zL);
1139  mult_wilson_ym2(v2v, &buf2[ibf]);
1140  }
1141 
1142  add_vec(&v2[VLEN * NVCD * site], v2v, NVCD);
1143  }
1144 
1145 #pragma omp barrier
1146 }
1147 
1148 
1149 //====================================================================
1150 template<typename AFIELD>
1151 void AFopr_Clover<AFIELD>::mult_zp(real_t *v2, real_t *v1)
1152 {
1153  int idir = 2;
1154  int Nxy = m_Nxv * m_Nyv;
1155 
1156  int ith, nth, is, ns;
1157  set_threadtask_mult(ith, nth, is, ns, m_Nstv);
1158 
1159  real_t *buf1 = (real_t *)chsend_dn[2].ptr();
1160  real_t *buf2 = (real_t *)chrecv_up[2].ptr();
1161 
1162  real_t *u = m_U.ptr(m_Ndf * m_Nst * idir);
1163 
1164 #pragma omp barrier
1165 
1166  if (do_comm[2] > 0) {
1167  for (int site = is; site < ns; ++site) {
1168  int ixy = site % Nxy;
1169  int iz = (site / Nxy) % m_Nz;
1170  int it = site / (Nxy * m_Nz);
1171  if (iz == 0) {
1172  int ibf = VLEN * NVC * ND2 * (ixy + Nxy * it);
1173  mult_wilson_zp1(&buf1[ibf], &v1[VLEN * NVCD * site]);
1174  }
1175  }
1176 
1177 #pragma omp barrier
1178 
1179 #pragma omp master
1180  {
1181  chrecv_up[2].start();
1182  chsend_dn[2].start();
1183  chrecv_up[2].wait();
1184  chsend_dn[2].wait();
1185  }
1186 
1187 #pragma omp barrier
1188  }
1189 
1190  for (int site = is; site < ns; ++site) {
1191  int ixy = site % Nxy;
1192  int iz = (site / Nxy) % m_Nz;
1193  int it = site / (Nxy * m_Nz);
1194 
1195  Vsimd_t v2v[NVCD];
1196  clear_vec(v2v, NVCD);
1197 
1198  if ((iz != m_Nz - 1) || (do_comm[2] == 0)) {
1199  int iz2 = (iz + 1) % m_Nz;
1200  int nei = ixy + Nxy * (iz2 + m_Nz * it);
1201  mult_wilson_zpb(v2v, &u[VLEN * NDF * site], &v1[VLEN * NVCD * nei]);
1202  } else {
1203  int ibf = VLEN * NVC * ND2 * (ixy + Nxy * it);
1204  mult_wilson_zp2(v2v, &u[VLEN * NDF * site], &buf2[ibf]);
1205  }
1206 
1207  add_vec(&v2[VLEN * NVCD * site], v2v, NVCD);
1208  }
1209 
1210 #pragma omp barrier
1211 }
1212 
1213 
1214 //====================================================================
1215 template<typename AFIELD>
1216 void AFopr_Clover<AFIELD>::mult_zm(real_t *v2, real_t *v1)
1217 {
1218  int idir = 2;
1219  int Nxy = m_Nxv * m_Nyv;
1220 
1221  int ith, nth, is, ns;
1222  set_threadtask_mult(ith, nth, is, ns, m_Nstv);
1223 
1224  real_t *buf1 = (real_t *)chsend_up[2].ptr();
1225  real_t *buf2 = (real_t *)chrecv_dn[2].ptr();
1226 
1227  real_t *u = m_U.ptr(m_Ndf * m_Nst * idir);
1228 
1229 #pragma omp barrier
1230 
1231  if (do_comm[2] > 0) {
1232  for (int site = is; site < ns; ++site) {
1233  int ixy = site % Nxy;
1234  int iz = (site / Nxy) % m_Nz;
1235  int it = site / (Nxy * m_Nz);
1236  if (iz == m_Nz - 1) {
1237  int ibf = VLEN * NVC * ND2 * (ixy + Nxy * it);
1238  mult_wilson_zm1(&buf1[ibf], &u[VLEN * NDF * site],
1239  &v1[VLEN * NVCD * site]);
1240  }
1241  }
1242 
1243 #pragma omp barrier
1244 
1245 #pragma omp master
1246  {
1247  chrecv_dn[2].start();
1248  chsend_up[2].start();
1249  chrecv_dn[2].wait();
1250  chsend_up[2].wait();
1251  }
1252 
1253 #pragma omp barrier
1254  }
1255 
1256  for (int site = is; site < ns; ++site) {
1257  int ixy = site % Nxy;
1258  int iz = (site / Nxy) % m_Nz;
1259  int it = site / (Nxy * m_Nz);
1260 
1261  Vsimd_t v2v[NVCD];
1262  clear_vec(v2v, NVCD);
1263 
1264  if ((iz > 0) || (do_comm[2] == 0)) {
1265  int iz2 = (iz - 1 + m_Nz) % m_Nz;
1266  int nei = ixy + Nxy * (iz2 + m_Nz * it);
1267  mult_wilson_zmb(v2v, &u[VLEN * NDF * nei], &v1[VLEN * NVCD * nei]);
1268  } else {
1269  int ibf = VLEN * NVC * ND2 * (ixy + Nxy * it);
1270  mult_wilson_zm2(v2v, &buf2[ibf]);
1271  }
1272 
1273  add_vec(&v2[VLEN * NVCD * site], v2v, NVCD);
1274  }
1275 
1276 #pragma omp barrier
1277 }
1278 
1279 
1280 //====================================================================
1281 template<typename AFIELD>
1282 void AFopr_Clover<AFIELD>::mult_tp(real_t *v2, real_t *v1)
1283 {
1284  int idir = 3;
1285  int Nxyz = m_Nxv * m_Nyv * m_Nz;
1286 
1287  int ith, nth, is, ns;
1288  set_threadtask_mult(ith, nth, is, ns, m_Nstv);
1289 
1290  real_t *buf1 = (real_t *)chsend_dn[3].ptr();
1291  real_t *buf2 = (real_t *)chrecv_up[3].ptr();
1292 
1293  real_t *u = m_U.ptr(m_Ndf * m_Nst * idir);
1294 
1295 #pragma omp barrier
1296 
1297  if (do_comm[3] > 0) {
1298  for (int site = is; site < ns; ++site) {
1299  int ixyz = site % Nxyz;
1300  int it = site / Nxyz;
1301  if (it == 0) {
1302  mult_wilson_tp1_dirac(&buf1[VLEN * NVC * ND2 * ixyz],
1303  &v1[VLEN * NVCD * site]);
1304  }
1305  }
1306 
1307 #pragma omp barrier
1308 
1309 #pragma omp master
1310  {
1311  chrecv_up[3].start();
1312  chsend_dn[3].start();
1313  chrecv_up[3].wait();
1314  chsend_dn[3].wait();
1315  }
1316 
1317 #pragma omp barrier
1318  }
1319 
1320  for (int site = is; site < ns; ++site) {
1321  int ixyz = site % Nxyz;
1322  int it = site / Nxyz;
1323 
1324  Vsimd_t v2v[NVCD];
1325  clear_vec(v2v, NVCD);
1326 
1327  if ((it < m_Nt - 1) || (do_comm[3] == 0)) {
1328  int it2 = (it + 1) % m_Nt;
1329  int nei = ixyz + Nxyz * it2;
1330  mult_wilson_tpb_dirac(v2v, &u[VLEN * NDF * site],
1331  &v1[VLEN * NVCD * nei]);
1332  } else {
1333  mult_wilson_tp2_dirac(v2v, &u[VLEN * NDF * site],
1334  &buf2[VLEN * NVC * ND2 * ixyz]);
1335  }
1336 
1337  add_vec(&v2[VLEN * NVCD * site], v2v, NVCD);
1338  }
1339 
1340 #pragma omp barrier
1341 }
1342 
1343 
1344 //====================================================================
1345 template<typename AFIELD>
1346 void AFopr_Clover<AFIELD>::mult_tm(real_t *v2, real_t *v1)
1347 {
1348  int idir = 3;
1349  int Nxyz = m_Nxv * m_Nyv * m_Nz;
1350 
1351  int ith, nth, is, ns;
1352  set_threadtask_mult(ith, nth, is, ns, m_Nstv);
1353 
1354  real_t *buf1 = (real_t *)chsend_up[3].ptr();
1355  real_t *buf2 = (real_t *)chrecv_dn[3].ptr();
1356 
1357  real_t *u = m_U.ptr(m_Ndf * m_Nst * idir);
1358 
1359 #pragma omp barrier
1360 
1361  if (do_comm[3] > 0) {
1362  for (int site = is; site < ns; ++site) {
1363  int ixyz = site % Nxyz;
1364  int it = site / Nxyz;
1365  if (it == m_Nt - 1) {
1366  mult_wilson_tm1_dirac(&buf1[VLEN * NVC * ND2 * ixyz],
1367  &u[VLEN * NDF * site], &v1[VLEN * NVCD * site]);
1368  }
1369  }
1370 
1371 #pragma omp barrier
1372 
1373 #pragma omp master
1374  {
1375  chrecv_dn[3].start();
1376  chsend_up[3].start();
1377  chrecv_dn[3].wait();
1378  chsend_up[3].wait();
1379  }
1380 #pragma omp barrier
1381  }
1382 
1383  for (int site = is; site < ns; ++site) {
1384  int ixyz = site % Nxyz;
1385  int it = site / Nxyz;
1386 
1387  Vsimd_t v2v[NVCD];
1388  clear_vec(v2v, NVCD);
1389 
1390  if ((it > 0) || (do_comm[3] == 0)) {
1391  int it2 = (it - 1 + m_Nt) % m_Nt;
1392  int nei = ixyz + Nxyz * it2;
1393  mult_wilson_tmb_dirac(v2v, &u[VLEN * NDF * nei],
1394  &v1[VLEN * NVCD * nei]);
1395  } else {
1396  mult_wilson_tm2_dirac(v2v, &buf2[VLEN * NVC * ND2 * ixyz]);
1397  }
1398 
1399  add_vec(&v2[VLEN * NVCD * site], v2v, NVCD);
1400  }
1401 
1402 #pragma omp barrier
1403 }
1404 
1405 
1406 //====================================================================
1407 template<typename AFIELD>
1408 double AFopr_Clover<AFIELD>::flop_count(const std::string mode)
1409 {
1410  // The following counting explicitly depends on the implementation.
1411  // It will be recalculated when the code is modified.
1412 
1413  int Lvol = CommonParameters::Lvol();
1414  double flop_wilson, flop_clover, flop_site, flop;
1415 
1416  if (m_repr == "Dirac") {
1417  flop_wilson = static_cast<double>(
1418  m_Nc * m_Nd * (4 // aypx
1419  + 6 * (4 * m_Nc + 2) // spatial hopping
1420  + 2 * (4 * m_Nc + 1))); // temporal hopping
1421 
1422  // clover term mult assumes rotation to chiral repr.
1423  flop_clover = static_cast<double>(
1424  m_Nc * m_Nd * (2 // Dirac -> chiral
1425  + 2 * (2 * (m_Nc * m_Nd - 1) + 1) // clover term mult
1426  + 2 // chiral -> Dirac
1427  + 2)); // addition to vector
1428  } else if (m_repr == "Chiral") {
1429  flop_wilson = static_cast<double>(
1430  m_Nc * m_Nd * (4 + 8 * (4 * m_Nc + 2)));
1431 
1432  flop_clover = static_cast<double>(
1433  m_Nc * m_Nd * (2 * (2 * (m_Nc * m_Nd - 1) + 1) // clover term mult
1434  + 2)); // addition to vector
1435  } else {
1436  vout.crucial(m_vl, "%s: input repr is undefined.\n");
1437  exit(EXIT_FAILURE);
1438  }
1439 
1440  flop_site = flop_wilson + flop_clover;
1441 
1442  flop = flop_site * static_cast<double>(Lvol);
1443  if ((mode == "DdagD") || (mode == "DDdag")) flop *= 2.0;
1444 
1445  return flop;
1446 }
1447 
1448 
1449 //============================================================END=====
CommonParameters::Ny
static int Ny()
Definition: commonParameters.h:106
AFopr_Clover::mult_dag
void mult_dag(AFIELD &, const AFIELD &)
hermitian conjugate of mult.
Definition: afopr_Clover-tmpl.h:474
CommonParameters::Nz
static int Nz()
Definition: commonParameters.h:107
BridgeQXS::mult_wilson_gm5_dirac
void mult_wilson_gm5_dirac(double *v2, double *v1, int *Nsize)
Definition: mult_Wilson_qxs-inc.h:411
CommonParameters::Lvol
static long_t Lvol()
Definition: commonParameters.h:95
convert_gauge
void convert_gauge(INDEX &index, AFIELD &v, const Field &w)
Definition: afield-inc.h:223
BridgeACC::mult_wilson_yp2
void mult_wilson_yp2(double *RESTRICT v2, double *RESTRICT u, double *RESTRICT buf, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:467
Parameters::set_string
void set_string(const string &key, const string &value)
Definition: parameters.cpp:39
BridgeQXS::mult_wilson_2_dirac
void mult_wilson_2_dirac(double *v2, double *up, double *v1, double *buf_xp, double *buf_xm, double *buf_yp, double *buf_ym, double *buf_zp, double *buf_zm, double *buf_tp, double *buf_tm, double kappa, int *bc, int *Nsize, int *do_comm)
Definition: mult_Wilson_qxs-inc.h:296
BridgeQXS::mult_wilson_1_dirac
void mult_wilson_1_dirac(double *buf_xp, double *buf_xm, double *buf_yp, double *buf_ym, double *buf_zp, double *buf_zm, double *buf_tp, double *buf_tm, double *up, double *v1, int *bc, int *Nsize, int *do_comm)
Definition: mult_Wilson_qxs-inc.h:153
AFopr_Clover::flop_count
double flop_count()
returns floating operation counts.
Definition: afopr_Clover-tmpl.h:1206
ThreadManager::get_num_threads
static int get_num_threads()
returns available number of threads.
Definition: threadManager.cpp:246
CommonParameters::Ndim
static int Ndim()
Definition: commonParameters.h:117
Parameters
Class for parameters.
Definition: parameters.h:46
iy
int iy
Definition: mult_Wilson_xyz_openacc-inc.h:239
AIndex_lex
Definition: aindex_lex_base.h:17
AFopr_Clover::clear
void clear(real_t *)
Definition: afopr_Clover-tmpl.h:853
ixy
int ixy
Definition: mult_Domainwall_eo_xyz_openacc-inc.h:513
wt
real_t wt[NVCD]
Definition: mult_Clover_csw_chiral_openacc-inc.h:9
BridgeACC::mult_wilson_xpb
void mult_wilson_xpb(double *RESTRICT v2, double *RESTRICT u, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:130
izt
int izt
Definition: mult_Domainwall_eo_xyz_openacc-inc.h:262
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.cpp:518
NVCD
#define NVCD
Definition: define_params_SU3.h:20
AFopr_Clover::Ddag
void Ddag(AFIELD &, const AFIELD &)
Definition: afopr_Clover-tmpl.h:620
Bridge::BridgeIO::increase_indent
void increase_indent()
Definition: bridgeIO.cpp:508
VLEN
#define VLEN
Definition: bridgeQXS_Clover_coarse_double.cpp:12
Bridge::BridgeIO::detailed
void detailed(const char *format,...)
Definition: bridgeIO.cpp:281
BridgeACC::mult_wilson_xm2
void mult_wilson_xm2(double *RESTRICT v2, double *RESTRICT buf, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:282
AFopr_Clover::mult_csw
void mult_csw(real_t *, real_t *)
set_csw now assumes Dirac repr.
Definition: afopr_Clover-tmpl.h:687
AFopr_Clover::aypx
void aypx(real_t, real_t *, real_t *)
Definition: afopr_Clover-tmpl.h:835
NDF
#define NDF
Definition: field_F_imp_SU2-inc.h:17
Fopr_CloverTerm
Org::Fopr_CloverTerm Fopr_CloverTerm
Clover term operator.
Definition: fopr_CloverTerm.h:58
CommonParameters::Nvol
static int Nvol()
Definition: commonParameters.h:109
AFopr_Clover::setup_channels
void setup_channels()
setup channels for communication.
Definition: afopr_Clover-tmpl.h:110
AFopr_Clover::D
void D(AFIELD &, const AFIELD &)
Definition: afopr_Clover-tmpl.h:668
BridgeACC::mult_wilson_yp1
void mult_wilson_yp1(double *RESTRICT buf, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:414
AFopr_Clover::mult_up
virtual void mult_up(int mu, AFIELD &, const AFIELD &)
upward nearest neighbor hopping term.
Definition: afopr_Clover-tmpl.h:560
aypx
void aypx(const double a, Field &y, const Field &x)
aypx(y, a, x): y := a * y + x
Definition: field.cpp:510
Vsimd_t
Definition: vsimd_double-inc.h:13
AFopr_Clover::mult_xm
void mult_xm(real_t *, real_t *)
Definition: afopr_Clover-tmpl.h:834
AFopr_Clover::mult_gm4
void mult_gm4(AFIELD &, const AFIELD &)
Definition: afopr_Clover-tmpl.h:654
BridgeACC::mult_wilson_zp1
void mult_wilson_zp1(double *RESTRICT buf, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:836
AFopr_Clover::set_config_omp
void set_config_omp(Field *u)
set_config implementation
Definition: afopr_Clover-tmpl.h:318
BridgeACC::mult_wilson_tp2_dirac
void mult_wilson_tp2_dirac(double *RESTRICT v2, double *RESTRICT u, double *RESTRICT buf, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:1311
BridgeACC::mult_wilson_tm2_dirac
void mult_wilson_tm2_dirac(double *RESTRICT v2, double *RESTRICT buf, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:1522
iyzt
int iyzt
Definition: mult_Domainwall_eo_xyz_openacc-inc.h:14
CommonParameters::Nx
static int Nx()
Definition: commonParameters.h:105
AFopr_Clover::real_t
AFIELD::real_t real_t
Definition: afopr_Clover.h:34
AFopr_Clover::get_mode
std::string get_mode() const
returns mult mode.
Definition: afopr_Clover-tmpl.h:447
ix
int ix
Definition: mult_Wilson_xyz_openacc-inc.h:16
BridgeACC::mult_wilson_tmb_dirac
void mult_wilson_tmb_dirac(double *RESTRICT v2, double *RESTRICT u, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:1569
BridgeACC::mult_wilson_xmb
void mult_wilson_xmb(double *RESTRICT v2, double *RESTRICT u, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:334
idir
idir
Definition: mult_Domainwall_eo_xyz_openacc-inc.h:264
AFopr_Clover::mult_zp
void mult_zp(real_t *, real_t *)
Definition: afopr_Clover-tmpl.h:983
AFopr_Clover::mult_gm5
void mult_gm5(AFIELD &, const AFIELD &)
multiplies gamma_5 matrix.
Definition: afopr_Clover-tmpl.h:536
AFopr_Clover::set_mode
void set_mode(std::string mode)
setting mult mode.
Definition: afopr_Clover-tmpl.h:435
AFopr_Clover::mult_D_alt
void mult_D_alt(AFIELD &, const AFIELD &)
D mult using mult_xp, etc.
Definition: afopr_Clover-tmpl.h:800
CommonParameters::Nc
static int Nc()
Definition: commonParameters.h:115
NC
#define NC
Definition: field_F_imp_SU2-inc.h:15
BridgeACC::mult_wilson_xm1
void mult_wilson_xm1(double *RESTRICT buf, double *RESTRICT u, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:209
AFopr_Clover::init
void init(const Parameters &params)
initial setup.
Definition: afopr_Clover-tmpl.h:25
BridgeACC::mult_wilson_ym2
void mult_wilson_ym2(double *RESTRICT v2, double *RESTRICT buf, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:696
QXS_Gauge::set_boundary
void set_boundary(AField< REALTYPE, QXS > &ulex, const std::vector< int > &boundary)
Definition: afield_Gauge-inc.h:32
BridgeACC::mult_wilson_zpb
void mult_wilson_zpb(double *RESTRICT v2, double *RESTRICT u, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:962
CommonParameters::Nt
static int Nt()
Definition: commonParameters.h:108
BridgeACC::mult_wilson_tpb_dirac
void mult_wilson_tpb_dirac(double *RESTRICT v2, double *RESTRICT u, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:1373
Parameters::fetch_int_vector
int fetch_int_vector(const string &key, vector< int > &value) const
Definition: parameters.cpp:429
AIndex_eo_accel::idx
int idx(const int in, const int Nin, const int ist, const int leo, const int Nvol2, const int ex)
Definition: aindex_eo.h:28
Communicator::npe
static int npe(const int dir)
logical grid extent
Definition: communicator.cpp:112
BridgeQXS::mult_clover_bulk_dirac
void mult_clover_bulk_dirac(double *v2, double *up, double *ct, double *v1, double kappa, int *bc, int *Nsize, int *do_comm)
Definition: mult_Clover_qxs-inc.h:16
reverse_spinor
void reverse_spinor(INDEX &index, Field &v, const AFIELD &w)
Definition: afield-inc.h:539
AFopr_Clover::mult_xp
void mult_xp(real_t *, real_t *)
Definition: afopr_Clover-tmpl.h:784
AFopr_Clover::mult_ym
void mult_ym(real_t *, real_t *)
Definition: afopr_Clover-tmpl.h:933
threadManager.h
ND
#define ND
Definition: field_F_imp_SU2-inc.h:18
AFopr_Clover::set_parameters
void set_parameters(const Parameters &params)
setting parameters by a Parameter object.
Definition: afopr_Clover-tmpl.h:192
BridgeACC::mult_wilson_tm1_dirac
void mult_wilson_tm1_dirac(double *RESTRICT buf, double *RESTRICT u, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:1450
it
int it
Definition: mult_Wilson_xyz_openacc-inc.h:461
BridgeACC::mult_wilson_zmb
void mult_wilson_zmb(double *RESTRICT v2, double *RESTRICT u, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:1177
BridgeACC::mult_wilson_tp1_dirac
void mult_wilson_tp1_dirac(double *RESTRICT buf, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:1261
AFopr_Clover::tidyup
void tidyup()
final tidy-up.
Definition: afopr_Clover-tmpl.h:161
Parameters::set_int_vector
void set_int_vector(const string &key, const vector< int > &value)
Definition: parameters.cpp:45
AFopr_Clover::mult_tp
void mult_tp(real_t *, real_t *)
Definition: afopr_Clover-tmpl.h:1082
BridgeACC::mult_wilson_xp2
void mult_wilson_xp2(double *RESTRICT v2, double *RESTRICT u, double *RESTRICT buf, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:64
real_t
double real_t
Definition: bridgeACC_AField_double.cpp:14
BridgeACC::mult_wilson_ypb
void mult_wilson_ypb(double *RESTRICT v2, double *RESTRICT u, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:537
AFopr_Clover::H
void H(AFIELD &, const AFIELD &)
Definition: afopr_Clover-tmpl.h:675
BridgeQXS::mult_clover_bulk_dirac_chrot
void mult_clover_bulk_dirac_chrot(double *v2, double *up, double *ct, double *v1, double kappa, int *bc, int *Nsize, int *do_comm)
Definition: mult_Clover_qxs-inc.h:152
AFopr_Clover::mult_D
void mult_D(AFIELD &, const AFIELD &)
standard D mult.
Definition: afopr_Clover-tmpl.h:732
AFopr_Clover::set_csw
void set_csw()
set_csw now assumes Dirac repr.
Definition: afopr_Clover-tmpl.h:312
AFopr_Clover::set_config
void set_config(Field *u)
setting gauge configuration.
Definition: afopr_Clover-tmpl.h:302
AFopr_Clover::mult_zm
void mult_zm(real_t *, real_t *)
Definition: afopr_Clover-tmpl.h:1033
VLENY
#define VLENY
Definition: bridgeQXS_Clover_coarse_double.cpp:14
Field::ptr
const double * ptr(const int jin, const int site, const int jex) const
Definition: field.h:153
BridgeACC::mult_wilson_zm2
void mult_wilson_zm2(double *RESTRICT v2, double *RESTRICT buf, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:1121
CommonParameters::Nd
static int Nd()
Definition: commonParameters.h:116
AFopr_Clover::set_csw_chrot
void set_csw_chrot()
set_csw with rotation to chiral repr.
Definition: afopr_Clover-tmpl.h:401
NVC
#define NVC
Definition: fopr_Wilson_impl_SU2-inc.h:15
CommonParameters::Vlevel
static Bridge::VerboseLevel Vlevel()
Definition: commonParameters.h:122
BridgeACC::mult_wilson_ymb
void mult_wilson_ymb(double *RESTRICT v2, double *RESTRICT u, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:752
Bridge::BridgeIO::set_verbose_level
static VerboseLevel set_verbose_level(const std::string &str)
Definition: bridgeIO.cpp:195
VLENX
#define VLENX
Definition: bridgeQXS_Clover_coarse_double.cpp:13
AFopr_Clover::get_parameters
void get_parameters(Parameters &params) const
gets parameters by a Parameter object: to be implemented in a subclass.
Definition: afopr_Clover-tmpl.h:286
AFopr_Clover::set_config_impl
void set_config_impl(Field *u)
Definition: afopr_Clover-tmpl.h:328
BridgeACC::mult_wilson_zp2
void mult_wilson_zp2(double *RESTRICT v2, double *RESTRICT u, double *RESTRICT buf, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:891
iz
int iz
Definition: mult_Wilson_xyz_openacc-inc.h:462
scal
void scal(Field &x, const double a)
scal(x, a): x = a * x
Definition: field.cpp:262
BridgeACC::mult_wilson_ym1
void mult_wilson_ym1(double *RESTRICT buf, double *RESTRICT u, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:621
Parameters::fetch_string
int fetch_string(const string &key, string &value) const
Definition: parameters.cpp:378
Parameters::fetch_double
int fetch_double(const string &key, double &value) const
Definition: parameters.cpp:327
AFopr_Clover
Definition: afopr_Clover.h:31
ixyz
int ixyz
Definition: mult_Domainwall_eo_t_dirac_openacc-inc.h:13
Bridge::BridgeIO::crucial
void crucial(const char *format,...)
Definition: bridgeIO.cpp:242
BridgeACC::mult_wilson_zm1
void mult_wilson_zm1(double *RESTRICT buf, double *RESTRICT u, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:1045
BridgeACC::mult_wilson_xp1
void mult_wilson_xp1(double *RESTRICT buf, double *RESTRICT v1, int *Nsize, int *bc, int Nc)
Definition: mult_Wilson_dir_openacc-inc.h:14
Field
Container of Field-type object.
Definition: field.h:46
AFopr_Clover::mult_tm
void mult_tm(real_t *, real_t *)
Definition: afopr_Clover-tmpl.h:1144
AFopr_Clover::convert
void convert(AFIELD &v, const Field &w)
convert of spinor field.
Definition: afopr_Clover-tmpl.h:480
ThreadManager::get_thread_id
static int get_thread_id()
returns thread id.
Definition: threadManager.cpp:253
AFopr_Clover::mult_dn
virtual void mult_dn(int mu, AFIELD &, const AFIELD &)
downward nearest neighbor hopping term.
Definition: afopr_Clover-tmpl.h:583
ND2
#define ND2
Definition: define_params_SU3.h:18
AFopr_Clover::reverse
void reverse(Field &v, const AFIELD &w)
reverse of spinor field.
Definition: afopr_Clover-tmpl.h:491
AFopr_Clover::DdagD
void DdagD(AFIELD &, const AFIELD &)
Definition: afopr_Clover-tmpl.h:606
convert_spinor
void convert_spinor(INDEX &index, AFIELD &v, const Field &w)
Definition: afield-inc.h:210
Bridge::BridgeIO::general
void general(const char *format,...)
Definition: bridgeIO.cpp:262
AFopr_Clover::mult_yp
void mult_yp(real_t *, real_t *)
Definition: afopr_Clover-tmpl.h:884
AFopr_Clover::mult
void mult(AFIELD &, const AFIELD &)
multiplies fermion operator to a given field.
Definition: afopr_Clover-tmpl.h:454
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:572
Bridge::BridgeIO::get_verbose_level
static std::string get_verbose_level(const VerboseLevel vl)
Definition: bridgeIO.cpp:216