Bridge++  Ver. 2.0.4
afopr_Staggered-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_Staggered<AFIELD>::class_name
14  = "AFopr_Staggered<AFIELD>";
15 //====================================================================
16 template<typename AFIELD>
17 void AFopr_Staggered<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 only when 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_Nc = CommonParameters::Nc();
35  if (m_Nc != 3) {
36  vout.crucial("%s: only applicable to Nc = 3\n",
37  class_name.c_str());
38  exit(EXIT_FAILURE);
39  }
40 
41  m_Ndim = CommonParameters::Ndim();
42  m_Nvc = m_Nc * 2;
43  m_Ndf = 2 * m_Nc * m_Nc;
44  m_Nx = CommonParameters::Nx();
45  m_Ny = CommonParameters::Ny();
46  m_Nz = CommonParameters::Nz();
47  m_Nt = CommonParameters::Nt();
48  m_Nst = CommonParameters::Nvol();
49 
50  m_Nxv = m_Nx / VLENX;
51  m_Nyv = m_Ny / VLENY;
52  m_Nstv = m_Nst / VLEN;
53 
54  if (VLENX * m_Nxv != m_Nx) {
55  vout.crucial(m_vl, "%s: Nx must be multiple of VLENX.\n",
56  class_name.c_str());
57  exit(EXIT_FAILURE);
58  }
59  if (VLENY * m_Nyv != m_Ny) {
60  vout.crucial(m_vl, "%s: Ny must be multiple of VLENY.\n",
61  class_name.c_str());
62  exit(EXIT_FAILURE);
63  }
64 
65  vout.general(m_vl, " VLENX = %2d Nxv = %d\n", VLENX, m_Nxv);
66  vout.general(m_vl, " VLENY = %2d Nyv = %d\n", VLENY, m_Nyv);
67  vout.general(m_vl, " VLEN = %2d Nstv = %d\n", VLEN, m_Nstv);
68 
69  m_Nsize[0] = m_Nxv;
70  m_Nsize[1] = m_Nyv;
71  m_Nsize[2] = m_Nz;
72  m_Nsize[3] = m_Nt;
73 
74  do_comm_any = 0;
75  for (int mu = 0; mu < m_Ndim; ++mu) {
76  do_comm[mu] = 1;
77  if ((req_comm == 0) && (Communicator::npe(mu) == 1)) do_comm[mu] = 0;
78  do_comm_any += do_comm[mu];
79  vout.general(m_vl, " do_comm[%d] = %d\n", mu, do_comm[mu]);
80  }
81 
82  m_Nbdsize.resize(m_Ndim);
83  m_Nbdsize[0] = m_Nvc * m_Ny * m_Nz * m_Nt;
84  m_Nbdsize[1] = m_Nvc * m_Nx * m_Nz * m_Nt;
85  m_Nbdsize[2] = m_Nvc * m_Nx * m_Ny * m_Nt;
86  m_Nbdsize[3] = m_Nvc * m_Nx * m_Ny * m_Nz;
87 
88  setup_channels();
89 
90  // gauge configuration.
91  m_U.reset(m_Ndf, m_Nst, m_Ndim);
92 
93  // working vectors.
94  m_w1.reset(m_Nvc, m_Nst, 1);
95  m_w2.reset(m_Nvc, m_Nst, 1);
96  m_v2.reset(m_Nvc, m_Nst, 1);
97 
98  // staggered phase and parity
99  m_stg_phase.reset(1, m_Nst, m_Ndim, Element_type::REAL);
100  m_parity.reset(1, m_Nst, 1, Element_type::REAL);
101 
102  set_staggered_phase();
103 
104  vout.increase_indent();
105 
106  set_parameters(params);
107 
108  m_shift = new ShiftAField_lex<AFIELD>(m_Nvc);
109 
110  vout.decrease_indent();
111 
112  vout.general(m_vl, "%s: construction finished.\n",
113  class_name.c_str());
114 }
115 
116 
117 //====================================================================
118 template<typename AFIELD>
119 void AFopr_Staggered<AFIELD>::tidyup()
120 {
121  ThreadManager::assert_single_thread(class_name);
122 
123  delete m_shift;
124 }
125 
126 
127 //====================================================================
128 template<typename AFIELD>
129 void AFopr_Staggered<AFIELD>::setup_channels()
130 {
131  chsend_up.resize(m_Ndim);
132  chrecv_up.resize(m_Ndim);
133  chsend_dn.resize(m_Ndim);
134  chrecv_dn.resize(m_Ndim);
135 
136  for (int mu = 0; mu < m_Ndim; ++mu) {
137  int Nvsize = m_Nbdsize[mu] * sizeof(real_t);
138 
139  chsend_dn[mu].send_init(Nvsize, mu, -1);
140  chsend_up[mu].send_init(Nvsize, mu, 1);
141 #ifdef USE_MPI
142  chrecv_up[mu].recv_init(Nvsize, mu, 1);
143  chrecv_dn[mu].recv_init(Nvsize, mu, -1);
144 #else
145  void *buf_up = (void *)chsend_dn[mu].ptr();
146  chrecv_up[mu].recv_init(Nvsize, mu, 1, buf_up);
147  void *buf_dn = (void *)chsend_up[mu].ptr();
148  chrecv_dn[mu].recv_init(Nvsize, mu, -1, buf_dn);
149 #endif
150 
151  if (do_comm[mu] == 1) {
152  chset_send.append(chsend_up[mu]);
153  chset_send.append(chsend_dn[mu]);
154  chset_recv.append(chrecv_up[mu]);
155  chset_recv.append(chrecv_dn[mu]);
156  }
157  }
158 }
159 
160 
161 //====================================================================
162 template<typename AFIELD>
163 void AFopr_Staggered<AFIELD>::set_parameters(const Parameters& params)
164 {
165  double mq;
166  std::vector<int> bc;
167 
168  int err = 0;
169  err += params.fetch_double("quark_mass", mq);
170  err += params.fetch_int_vector("boundary_condition", bc);
171 
172  if (err) {
173  vout.crucial(m_vl, "%s: fetch error, input parameter not found.\n",
174  class_name.c_str());
175  exit(EXIT_FAILURE);
176  }
177 
178  set_parameters(real_t(mq), bc);
179 }
180 
181 
182 //====================================================================
183 template<typename AFIELD>
184 void AFopr_Staggered<AFIELD>::set_parameters(const real_t mq,
185  const std::vector<int> bc)
186 {
187  assert(bc.size() == m_Ndim);
188 
189 #pragma omp barrier
190 
191  int ith = ThreadManager::get_thread_id();
192 
193  if (ith == 0) {
194  m_mq = mq;
195  m_boundary.resize(m_Ndim);
196  for (int mu = 0; mu < m_Ndim; ++mu) {
197  m_boundary[mu] = bc[mu];
198  }
199  }
200 
201  vout.general(m_vl, "%s: set parameters\n", class_name.c_str());
202  vout.general(m_vl, " mq = %8.4f\n", m_mq);
203  for (int mu = 0; mu < m_Ndim; ++mu) {
204  vout.general(m_vl, " boundary[%d] = %2d\n", mu, m_boundary[mu]);
205  }
206 
207 #pragma omp barrier
208 }
209 
210 
211 //====================================================================
212 template<typename AFIELD>
213 void AFopr_Staggered<AFIELD>::get_parameters(Parameters& params) const
214 {
215  params.set_double("quark_mass", double(m_mq));
216  params.set_int_vector("boundary_condition", m_boundary);
217 
218  params.set_string("verbose_level", vout.get_verbose_level(m_vl));
219 }
220 
221 
222 //====================================================================
223 template<typename AFIELD>
224 void AFopr_Staggered<AFIELD>::set_staggered_phase()
225 {
226  int ipex = Communicator::ipe(0);
227  int ipey = Communicator::ipe(1);
228  int ipez = Communicator::ipe(2);
229  int ipet = Communicator::ipe(3);
230 
231  real_t *stgph = m_stg_phase.ptr(0);
232  real_t *prty = m_parity.ptr(0);
233 
234  AIndex_lex<real_t, AFIELD::IMPL> index;
235 
236  for (int t = 0; t < m_Nt; ++t) {
237  int t2 = t + ipet * m_Nt;
238  for (int z = 0; z < m_Nz; ++z) {
239  int z2 = z + ipez * m_Nz;
240  for (int y = 0; y < m_Ny; ++y) {
241  int y2 = y + ipey * m_Ny;
242  for (int x = 0; x < m_Nx; ++x) {
243  int x2 = x + ipex * m_Nx;
244  int is = index.site(x, y, z, t);
245 
246  stgph[index.idx(0, 1, is, 0)] = 1.0;
247  stgph[index.idx(0, 1, is, 1)] = 1.0;
248  stgph[index.idx(0, 1, is, 2)] = 1.0;
249  stgph[index.idx(0, 1, is, 3)] = 1.0;
250 
251  prty[index.idx(0, 1, is, 0)] = 1.0;
252 
253  if ((x2 % 2) == 1) {
254  stgph[index.idx(0, 1, is, 1)] = -1.0;
255  }
256  if (((x2 + y2) % 2) == 1) {
257  stgph[index.idx(0, 1, is, 2)] = -1.0;
258  }
259  if (((x2 + y2 + z2) % 2) == 1) {
260  stgph[index.idx(0, 1, is, 3)] = -1.0;
261  }
262  if (((x2 + y2 + z2 + t2) % 2) == 1) {
263  prty[index.idx(0, 1, is, 0)] = -1.0;
264  }
265  }
266  }
267  }
268  }
269 }
270 
271 
272 //====================================================================
273 template<typename AFIELD>
274 void AFopr_Staggered<AFIELD>::set_config(Field *u)
275 {
276  int nth = ThreadManager::get_num_threads();
277 
278  vout.detailed(m_vl, "%s: set_config is called: num_threads = %d\n",
279  class_name.c_str(), nth);
280 
281  if (nth > 1) {
282  set_config_impl(u);
283  } else {
284  set_config_omp(u);
285  }
286 
287  vout.detailed(m_vl, "%s: set_config finished\n", class_name.c_str());
288 }
289 
290 
291 //====================================================================
292 template<typename AFIELD>
293 void AFopr_Staggered<AFIELD>::set_config_omp(Field *u)
294 {
295  vout.detailed(m_vl, " set_config_omp is called.\n");
296 
297 #pragma omp parallel
298  {
299  set_config_impl(u);
300  }
301 }
302 
303 
304 //====================================================================
305 template<typename AFIELD>
306 void AFopr_Staggered<AFIELD>::set_config_impl(Field *U)
307 {
308  AIndex_lex<real_t, AFIELD::IMPL> index;
309 
310  convert_gauge(index, m_U, *U);
311 
312  QXS_Gauge::set_boundary(m_U, m_boundary);
313 
314  for (int mu = 0; mu < m_Ndim; ++mu) {
315  // staggered phase is multiplied to gauge field
316  real_t *stgph = m_stg_phase.ptr(index.idx(0, 1, 0, mu));
317  real_t *up = m_U.ptr(index.idx_G(0, 0, mu));
318  BridgeQXS::mult_staggered_phase(up, stgph, m_Nsize, m_Ndf);
319  }
320 
321 #pragma omp barrier
322 }
323 
324 
325 //====================================================================
326 template<typename AFIELD>
327 void AFopr_Staggered<AFIELD>::set_mode(std::string mode)
328 {
329 #pragma omp barrier
330 
331  int ith = ThreadManager::get_thread_id();
332  if (ith == 0) m_mode = mode;
333 
334 #pragma omp barrier
335 }
336 
337 
338 //====================================================================
339 template<typename AFIELD>
340 void AFopr_Staggered<AFIELD>::mult(AFIELD& v, const AFIELD& w)
341 {
342  if (m_mode == "D") {
343  D(v, w);
344  } else if (m_mode == "Ddag") {
345  Ddag(v, w);
346  } else if (m_mode == "DdagD") {
347  DdagD(v, w);
348  } else if (m_mode == "H") {
349  H(v, w);
350  } else {
351  vout.crucial(m_vl, "%s: mode undeifined.\n", class_name.c_str());
352  abort();
353  }
354 }
355 
356 
357 //====================================================================
358 template<typename AFIELD>
359 void AFopr_Staggered<AFIELD>::mult_dag(AFIELD& v, const AFIELD& w)
360 {
361  if (m_mode == "D") {
362  Ddag(v, w);
363  } else if (m_mode == "Ddag") {
364  D(v, w);
365  } else if (m_mode == "DdagD") {
366  DdagD(v, w);
367  } else if (m_mode == "H") {
368  H(v, w);
369  } else {
370  vout.crucial(m_vl, "%s: mode undeifined.\n", class_name.c_str());
371  abort();
372  }
373 }
374 
375 
376 //====================================================================
377 template<typename AFIELD>
378 void AFopr_Staggered<AFIELD>::H(AFIELD& v, const AFIELD& w)
379 {
380  D(v, w);
381  mult_gm5(v);
382 }
383 
384 
385 //====================================================================
386 template<typename AFIELD>
387 void AFopr_Staggered<AFIELD>::DdagD(AFIELD& v, const AFIELD& w)
388 {
389  D(m_v2, w);
390  Ddag(v, m_v2);
391  // H(m_v2, w);
392  // H(v, m_v2);
393 }
394 
395 
396 //====================================================================
397 template<typename AFIELD>
398 void AFopr_Staggered<AFIELD>::D(AFIELD& v, const AFIELD& w)
399 {
400  mult_D_qxs(v, w, 1);
401  //mult_D_alt(v, w, 1);
402 }
403 
404 
405 //====================================================================
406 template<typename AFIELD>
407 void AFopr_Staggered<AFIELD>::Ddag(AFIELD& v, const AFIELD& w)
408 {
409  mult_D_qxs(v, w, -1);
410  //mult_D_alt(v, w, -1);
411 }
412 
413 
414 //====================================================================
415 template<typename AFIELD>
416 void AFopr_Staggered<AFIELD>::mult_D_qxs(AFIELD& v, const AFIELD& w,
417  int jd)
418 {
419  // jd = 1: D, jd = -1: Ddag
420 
421  real_t *vp = v.ptr(0);
422  real_t *wp = const_cast<AFIELD *>(&w)->ptr(0);
423  real_t *up = m_U.ptr(0);
424 
425  int ith = ThreadManager::get_thread_id();
426 
427 #pragma omp barrier
428 
429  if (do_comm_any > 0) {
430  if (ith == 0) chset_recv.start();
431 
432  real_t *buf1xp = (real_t *)chsend_dn[0].ptr();
433  real_t *buf1xm = (real_t *)chsend_up[0].ptr();
434 
435  real_t *buf1yp = (real_t *)chsend_dn[1].ptr();
436  real_t *buf1ym = (real_t *)chsend_up[1].ptr();
437 
438  real_t *buf1zp = (real_t *)chsend_dn[2].ptr();
439  real_t *buf1zm = (real_t *)chsend_up[2].ptr();
440 
441  real_t *buf1tp = (real_t *)chsend_dn[3].ptr();
442  real_t *buf1tm = (real_t *)chsend_up[3].ptr();
443 
444  BridgeQXS::mult_staggered_1(buf1xp, buf1xm, buf1yp, buf1ym,
445  buf1zp, buf1zm, buf1tp, buf1tm,
446  up, wp, m_Nsize, do_comm);
447 
448 #pragma omp barrier
449 
450  if (ith == 0) chset_send.start();
451  }
452 
453  BridgeQXS::mult_staggered_bulk(vp, up, wp, m_mq, jd,
454  m_Nsize, do_comm);
455 
456  if (do_comm_any > 0) {
457  if (ith == 0) chset_recv.wait();
458 
459 #pragma omp barrier
460 
461  real_t *buf2xp = (real_t *)chrecv_up[0].ptr();
462  real_t *buf2xm = (real_t *)chrecv_dn[0].ptr();
463 
464  real_t *buf2yp = (real_t *)chrecv_up[1].ptr();
465  real_t *buf2ym = (real_t *)chrecv_dn[1].ptr();
466 
467  real_t *buf2zp = (real_t *)chrecv_up[2].ptr();
468  real_t *buf2zm = (real_t *)chrecv_dn[2].ptr();
469 
470  real_t *buf2tp = (real_t *)chrecv_up[3].ptr();
471  real_t *buf2tm = (real_t *)chrecv_dn[3].ptr();
472 
473  BridgeQXS::mult_staggered_2(vp, up, wp,
474  buf2xp, buf2xm, buf2yp, buf2ym,
475  buf2zp, buf2zm, buf2tp, buf2tm,
476  m_mq, jd, m_Nsize, do_comm);
477 
478  if (ith == 0) chset_send.wait();
479  }
480 
481 #pragma omp barrier
482 }
483 
484 
485 //====================================================================
486 template<typename AFIELD>
487 void AFopr_Staggered<AFIELD>::mult_D_alt(AFIELD& v, const AFIELD& w,
488  int jd)
489 {
490  real_t *vp = v.ptr(0);
491  real_t *wp = const_cast<AFIELD *>(&w)->ptr(0);
492 
493 #pragma omp barrier
494 
495  clear(vp);
496 #pragma omp barrier
497 
498  for (int mu = 0; mu < m_Ndim; ++mu) {
499  mult_up(mu, v, w);
500  mult_dn(mu, v, w);
501  }
502 
503 #pragma omp barrier
504 
505  // note that mass normalization is adopted.
506  real_t fac = real_t(jd);
507  axpby(fac, vp, m_mq, wp);
508 
509 #pragma omp barrier
510 }
511 
512 
513 //====================================================================
514 template<typename AFIELD>
515 void AFopr_Staggered<AFIELD>::mult_gm5(AFIELD& v, const AFIELD& w)
516 {
517 #pragma omp barrier
518 
519  copy(v, w);
520 #pragma omp barrier
521 
522  real_t *ph = m_parity.ptr(0);
523  real_t *vp = v.ptr(0);
524 
525  BridgeQXS::mult_staggered_phase(vp, ph, m_Nsize, m_Nvc);
526 
527 #pragma omp barrier
528 }
529 
530 
531 //====================================================================
532 template<typename AFIELD>
533 void AFopr_Staggered<AFIELD>::mult_gm5(AFIELD& v)
534 {
535  real_t *ph = m_parity.ptr(0);
536  real_t *vp = v.ptr(0);
537 
538 #pragma omp barrier
539  BridgeQXS::mult_staggered_phase(vp, ph, m_Nsize, m_Nvc);
540 #pragma omp barrier
541 }
542 
543 
544 //====================================================================
545 template<typename AFIELD>
546 void AFopr_Staggered<AFIELD>::clear(real_t *vp)
547 {
548  BridgeQXS::mult_staggered_clear(vp, m_Nsize, m_Nvc);
549 }
550 
551 
552 //====================================================================
553 template<typename AFIELD>
554 void AFopr_Staggered<AFIELD>::axpby(real_t b, real_t *vp,
555  real_t a, real_t *wp)
556 {
557  BridgeQXS::mult_staggered_axpby(b, vp, a, wp, m_Nsize, m_Nvc);
558 }
559 
560 
561 //====================================================================
562 template<typename AFIELD>
563 void AFopr_Staggered<AFIELD>::mult_up(int idir,
564  AFIELD& v, const AFIELD& w)
565 {
566  m_shift->backward(m_w1, w, idir);
567 
568  real_t *wp = m_w1.ptr(0);
569  real_t *up = m_U.ptr(m_Ndf * m_Nst * idir);
570  real_t *vp = m_w2.ptr(0);
571 
572  BridgeQXS::mult_staggered_mult_Gn(vp, up, wp, m_Nsize);
573 #pragma omp barrier
574 
575  axpy(v, real_t(0.5), m_w2);
576 #pragma omp barrier
577 }
578 
579 
580 //====================================================================
581 template<typename AFIELD>
582 void AFopr_Staggered<AFIELD>::mult_dn(int idir,
583  AFIELD& v, const AFIELD& w)
584 {
585  real_t *wp = const_cast<AFIELD *>(&w)->ptr(0);
586  real_t *up = m_U.ptr(m_Ndf * m_Nst * idir);
587  real_t *vp = m_w1.ptr(0);
588 
589  BridgeQXS::mult_staggered_mult_Gd(vp, up, wp, m_Nsize);
590 #pragma omp barrier
591 
592  m_shift->forward(m_w2, m_w1, idir);
593 
594  axpy(v, real_t(-0.5), m_w2);
595 #pragma omp barrier
596 }
597 
598 
599 //====================================================================
600 template<typename AFIELD>
601 double AFopr_Staggered<AFIELD>::flop_count()
602 {
603  return flop_count(m_mode);
604 }
605 
606 
607 //====================================================================
608 template<typename AFIELD>
609 double AFopr_Staggered<AFIELD>::flop_count(const std::string mode)
610 {
611  // The following counting explicitly depends on the implementation.
612  // It will be recalculated when the code is modified.
613  // The following is based on rev.1976. [21 Jul 2019 H.Matsufuru]
614 
615  int Lvol = CommonParameters::Lvol();
616  double flop_site, flop;
617 
618  flop_site = static_cast<double>(m_Nvc * (2 + 8 * 2 * m_Nvc));
619  // #comp aypx dir FMA #comp
620 
621  flop = flop_site * static_cast<double>(Lvol);
622 
623  if ((mode == "DdagD") || (mode == "DDdag")) flop *= 2.0;
624 
625  return flop;
626 }
627 
628 
629 //============================================================END=====
BridgeQXS::mult_staggered_bulk
void mult_staggered_bulk(double *v2, double *up, double *v1, double qm, int jd, int *Nsize, int *do_comm)
Definition: mult_Staggered_qxs-inc.h:184
AFopr_Staggered::D
void D(AFIELD &, const AFIELD &)
Definition: afopr_Staggered-tmpl.h:398
CommonParameters::Ny
static int Ny()
Definition: commonParameters.h:106
BridgeQXS::mult_staggered_2
void mult_staggered_2(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 qm, int jd, int *Nsize, int *do_comm)
Definition: mult_Staggered_qxs-inc.h:528
CommonParameters::Nz
static int Nz()
Definition: commonParameters.h:107
AFopr_Staggered::set_mode
void set_mode(std::string mode)
setting the mode of multiplication if necessary. Default implementation here is just to avoid irrelev...
Definition: afopr_Staggered-tmpl.h:327
CommonParameters::Lvol
static long_t Lvol()
Definition: commonParameters.h:95
Parameters::set_string
void set_string(const string &key, const string &value)
Definition: parameters.cpp:39
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
AIndex_lex
Definition: aindex_lex_base.h:17
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:517
AFopr_Staggered::mult_up
void mult_up(int mu, AFIELD &, const AFIELD &)
upward nearest neighbor hopping term.
Definition: afopr_Staggered-tmpl.h:563
AFopr_Staggered::set_config_impl
void set_config_impl(Field *u)
setting gauge configuration (implementation).
Definition: afopr_Staggered-tmpl.h:306
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
BridgeQXS::mult_staggered_phase
void mult_staggered_phase(double *v, double *ph, int *Nsize, int Nin)
Definition: mult_Staggered_qxs-inc.h:16
AFopr_Staggered::tidyup
void tidyup()
Definition: afopr_Staggered-tmpl.h:119
CommonParameters::Nvol
static int Nvol()
Definition: commonParameters.h:109
convert_gauge
void convert_gauge(INDEX &index, FIELD &v, const Field &w)
Definition: afield-inc.h:224
AFopr_Staggered
Staggered fermion operator.
Definition: afopr_Staggered.h:41
ShiftAField_lex
Methods to shift a field in the lexical site index.
Definition: shiftAField_lex.h:33
AFopr_Staggered::init
void init(const Parameters &params)
Definition: afopr_Staggered-tmpl.h:17
axpy
void axpy(Field &y, const double a, const Field &x)
axpy(y, a, x): y := a * x + y
Definition: field.cpp:380
real_t
double real_t
Definition: bridgeQXS_Clover_coarse_double.cpp:16
copy
void copy(Field &y, const Field &x)
copy(y, x): y = x
Definition: field.cpp:212
AFopr_Staggered::mult_D_alt
void mult_D_alt(AFIELD &, const AFIELD &, int jd)
Definition: afopr_Staggered-tmpl.h:487
CommonParameters::Nx
static int Nx()
Definition: commonParameters.h:105
CommonParameters::Nc
static int Nc()
Definition: commonParameters.h:115
AFopr_Staggered::real_t
AFIELD::real_t real_t
Definition: afopr_Staggered.h:44
QXS_Gauge::set_boundary
void set_boundary(AField< REALTYPE, QXS > &ulex, const std::vector< int > &boundary)
Definition: afield_Gauge-inc.h:24
CommonParameters::Nt
static int Nt()
Definition: commonParameters.h:108
Parameters::fetch_int_vector
int fetch_int_vector(const string &key, vector< int > &value) const
Definition: parameters.cpp:429
Communicator::npe
static int npe(const int dir)
logical grid extent
Definition: communicator.cpp:112
BridgeQXS::mult_staggered_mult_Gd
void mult_staggered_mult_Gd(double *v, double *u, double *w, int *Nsize)
Definition: mult_Staggered_qxs-inc.h:142
BridgeQXS::mult_staggered_axpby
void mult_staggered_axpby(double b, double *y, double a, double *x, int *Nsize, int Nin)
Definition: mult_Staggered_qxs-inc.h:70
AFopr_Staggered::setup_channels
void setup_channels()
Definition: afopr_Staggered-tmpl.h:129
BridgeQXS::mult_staggered_1
void mult_staggered_1(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 *Nsize, int *do_comm)
Definition: mult_Staggered_qxs-inc.h:333
BridgeQXS::mult_staggered_clear
void mult_staggered_clear(double *v, int *Nsize, int Nin)
Definition: mult_Staggered_qxs-inc.h:45
AFopr_Staggered::mult_D_qxs
void mult_D_qxs(AFIELD &, const AFIELD &, int jd)
Definition: afopr_Staggered-tmpl.h:416
AFopr_Staggered::get_parameters
void get_parameters(Parameters &params) const
getting parameters via a Parameters object.
Definition: afopr_Staggered-tmpl.h:213
AFopr_Staggered::mult
void mult(AFIELD &, const AFIELD &)
multiplies fermion operator to a given field.
Definition: afopr_Staggered-tmpl.h:340
threadManager.h
AFopr_Staggered::Ddag
void Ddag(AFIELD &, const AFIELD &)
Definition: afopr_Staggered-tmpl.h:407
Element_type::REAL
@ REAL
Definition: bridge_defs.h:43
AFopr_Staggered::set_parameters
void set_parameters(const Parameters &params)
setting parameters by a Parameter object.
Definition: afopr_Staggered-tmpl.h:163
Parameters::set_int_vector
void set_int_vector(const string &key, const vector< int > &value)
Definition: parameters.cpp:45
AFopr_Staggered::axpby
void axpby(real_t, real_t *, real_t, real_t *)
Definition: afopr_Staggered-tmpl.h:554
AFopr_Staggered::clear
void clear(real_t *)
Definition: afopr_Staggered-tmpl.h:546
BridgeQXS::mult_staggered_mult_Gn
void mult_staggered_mult_Gn(double *v, double *u, double *w, int *Nsize)
Definition: mult_Staggered_qxs-inc.h:100
AFopr_Staggered::mult_dag
void mult_dag(AFIELD &, const AFIELD &)
hermitian conjugate of mult.
Definition: afopr_Staggered-tmpl.h:359
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
CommonParameters::Vlevel
static Bridge::VerboseLevel Vlevel()
Definition: commonParameters.h:122
Bridge::BridgeIO::set_verbose_level
static VerboseLevel set_verbose_level(const std::string &str)
Definition: bridgeIO.cpp:195
AFopr_Staggered::set_staggered_phase
void set_staggered_phase()
Definition: afopr_Staggered-tmpl.h:224
VLENX
#define VLENX
Definition: bridgeQXS_Clover_coarse_double.cpp:13
AFopr_Staggered::set_config
void set_config(Field *U)
setting gauge configuration (common interface).
Definition: afopr_Staggered-tmpl.h:274
Communicator::ipe
static int ipe(const int dir)
logical coordinate of current proc.
Definition: communicator.cpp:105
Parameters::fetch_string
int fetch_string(const string &key, string &value) const
Definition: parameters.cpp:378
AFopr_Staggered::mult_dn
void mult_dn(int mu, AFIELD &, const AFIELD &)
downward nearest neighbor hopping term.
Definition: afopr_Staggered-tmpl.h:582
Parameters::fetch_double
int fetch_double(const string &key, double &value) const
Definition: parameters.cpp:327
AFopr_Staggered::flop_count
double flop_count()
returns floating operation counts.
Definition: afopr_Staggered-tmpl.h:601
Bridge::BridgeIO::crucial
void crucial(const char *format,...)
Definition: bridgeIO.cpp:242
AFopr_Staggered::mult_gm5
void mult_gm5(AFIELD &, const AFIELD &)
multiplies gamma_5 matrix.
Definition: afopr_Staggered-tmpl.h:515
Field
Container of Field-type object.
Definition: field.h:46
ThreadManager::get_thread_id
static int get_thread_id()
returns thread id.
Definition: threadManager.cpp:253
AFopr_Staggered::H
void H(AFIELD &, const AFIELD &)
Definition: afopr_Staggered-tmpl.h:378
AFopr_Staggered::DdagD
void DdagD(AFIELD &, const AFIELD &)
Definition: afopr_Staggered-tmpl.h:387
Bridge::BridgeIO::general
void general(const char *format,...)
Definition: bridgeIO.cpp:262
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:569
Bridge::BridgeIO::get_verbose_level
static std::string get_verbose_level(const VerboseLevel vl)
Definition: bridgeIO.cpp:216
AFopr_Staggered::set_config_omp
void set_config_omp(Field *u)
setting gauge configuration (setting omp parallel).
Definition: afopr_Staggered-tmpl.h:293