Bridge++  Ver.2.1.3
forceSmear_HYP_SF.cpp
Go to the documentation of this file.
1 
10 #include "lib/Smear/forceSmear_HYP_SF.h"
11 #include "lib/ResourceManager/threadManager.h"
12 
13 #ifdef USE_FACTORY_AUTOREGISTER
14 namespace {
15  bool init = ForceSmear_HYP_SF::register_factory();
16 }
17 #endif
18 
19 const std::string ForceSmear_HYP_SF::class_name = "ForceSmear_HYP_SF";
20 
21 //====================================================================
22 void ForceSmear_HYP_SF::init(const Parameters& params)
23 {
24  ThreadManager::assert_single_thread(class_name);
25 
26  std::string vlevel;
27  if (!params.fetch_string("verbose_level", vlevel)) {
28  m_vl = vout.set_verbose_level(vlevel);
29  } else {
30  m_vl = CommonParameters::Vlevel();
31  }
32 
33  vout.general(m_vl, "%s: construction\n", class_name.c_str());
34  vout.increase_indent();
35 
36  m_Ndim = CommonParameters::Ndim();
37  m_Nvol = CommonParameters::Nvol();
38 
39  set_parameters(params);
40 
41  m_shift = new ShiftField_lex();
42 
43  m_U.resize(m_Ndim);
44 
45  m_v1.resize(size1());
46  m_v2.resize(size2());
47 
48  m_Sigma3.resize(size2());
49  m_Sigma2.resize(size1b());
50 
51  m_iTheta3.resize(m_Ndim);
52  m_iTheta2.resize(size2());
53  m_iTheta1.resize(size1b());
54 
55  m_vt1 = new Field_G(m_Nvol, 1);
56  m_vt2 = new Field_G(m_Nvol, 1);
57  m_vt3 = new Field_G(m_Nvol, 1);
58  m_ct1 = new Field_G(m_Nvol, 1);
59  m_ct2 = new Field_G(m_Nvol, 1);
60  m_ct3 = new Field_G(m_Nvol, 1);
61 
62  vout.decrease_indent();
63  vout.general(m_vl, "%s: construction finished.\n",
64  class_name.c_str());
65 
66 }
67 
68 //====================================================================
69 void ForceSmear_HYP_SF::tidyup()
70 {
71  delete m_shift;
72 
73  delete m_vt1;
74  delete m_vt2;
75  delete m_vt3;
76  delete m_ct1;
77  delete m_ct2;
78  delete m_ct3;
79 }
80 
81 //====================================================================
82 void ForceSmear_HYP_SF::set_parameters(const Parameters& params)
83 {
84  std::string vlevel;
85  if (!params.fetch_string("verbose_level", vlevel)) {
86  m_vl = vout.set_verbose_level(vlevel);
87  }
88 
89  //- fetch and check input parameters
90  double alpha1, alpha2, alpha3;
91  std::vector<double> phi, phipr;
92 
93  int err = 0;
94  err += params.fetch_double("alpha1", alpha1);
95  err += params.fetch_double("alpha2", alpha2);
96  err += params.fetch_double("alpha3", alpha3);
97  err += params.fetch_double_vector("phi", phi);
98  err += params.fetch_double_vector("phipr", phipr);
99 
100  if (err) {
101  vout.crucial(m_vl, "Error at %s: input parameter not found.\n",
102  class_name.c_str());
103  exit(EXIT_FAILURE);
104  }
105 
106 
107  set_parameters(alpha1, alpha2, alpha3, phi, phipr);
108 }
109 
110 
111 //====================================================================
112 void ForceSmear_HYP_SF::set_parameters(const double alpha1,
113  const double alpha2,
114  const double alpha3,
115  const std::vector<double>& phi,
116  const std::vector<double>& phipr)
117 {
118 #pragma omp barrier
119 
120  int ith = ThreadManager::get_thread_id();
121  if (ith == 0) {
122 
123  m_alpha1 = alpha1;
124  m_alpha2 = alpha2;
125  m_alpha3 = alpha3;
126 
127  m_phi.resize(3);
128  m_phipr.resize(3);
129  for (int i = 0; i < 3; ++i) {
130  m_phi[i] = phi[i];
131  m_phipr[i] = phipr[i];
132  }
133 
134  const int Lx = CommonParameters::Lx();
135  double Lx_inv = 1.0 / double(Lx);
136  double c0r = cos(phi[0] * Lx_inv);
137  double c0i = sin(phi[0] * Lx_inv);
138  double c1r = cos(phi[1] * Lx_inv);
139  double c1i = sin(phi[1] * Lx_inv);
140  double c2r = cos(phi[2] * Lx_inv);
141  double c2i = sin(phi[2] * Lx_inv);
142  m_wk.zero();
143  m_wk.set(0, 0, c0r, c0i);
144  m_wk.set(1, 1, c1r, c1i);
145  m_wk.set(2, 2, c2r, c2i);
146 
147  c0r = cos(phipr[0] * Lx_inv);
148  c0i = sin(phipr[0] * Lx_inv);
149  c1r = cos(phipr[1] * Lx_inv);
150  c1i = sin(phipr[1] * Lx_inv);
151  c2r = cos(phipr[2] * Lx_inv);
152  c2i = sin(phipr[2] * Lx_inv);
153 
154  m_wkpr.zero();
155  m_wkpr.set(0, 0, c0r, c0i);
156  m_wkpr.set(1, 1, c1r, c1i);
157  m_wkpr.set(2, 2, c2r, c2i);
158  }
159 #pragma omp barrier
160 
161  vout.general(m_vl, "%s: parameters\n", class_name.c_str());
162  vout.general(m_vl, " alpha1 = %10.6F\n", m_alpha1);
163  vout.general(m_vl, " alpha2 = %10.6F\n", m_alpha2);
164  vout.general(m_vl, " alpha3 = %10.6F\n", m_alpha3);
165 
166  vout.general(m_vl, " phi1 = %12.6f\n", m_phi[0]);
167  vout.general(m_vl, " phi2 = %12.6f\n", m_phi[1]);
168  vout.general(m_vl, " phi3 = %12.6f\n", m_phi[2]);
169  vout.general(m_vl, " phipr1= %12.6f\n", m_phipr[0]);
170  vout.general(m_vl, " phipr2= %12.6f\n", m_phipr[1]);
171  vout.general(m_vl, " phipr3= %12.6f\n", m_phipr[2]);
172 
173 }
174 
175 
176 //====================================================================
177 void ForceSmear_HYP_SF::get_parameters(Parameters& params) const
178 {
179  params.set_double("alpha1", m_alpha1);
180  params.set_double("alpha2", m_alpha2);
181  params.set_double("alpha3", m_alpha3);
182  params.set_double_vector("phi", m_phi);
183  params.set_double_vector("phipr", m_phipr);
184 
185  params.set_string("verbose_level", vout.get_verbose_level(m_vl));
186 }
187 
188 
189 //====================================================================
190 void ForceSmear_HYP_SF::force_udiv(Field_G& Sigma,
191  const Field_G& Sigmap,
192  const Field_G& U)
193 {
194 #pragma omp barrier
195 
196  assert(U.nvol() == m_Nvol);
197  assert(U.nex() == m_Ndim);
198  assert(Sigmap.nvol() == m_Nvol);
199  assert(Sigmap.nex() == m_Ndim);
200 
201  for (int mu = 0; mu < m_Ndim; ++mu) {
202  copy(m_U[mu], 0, U, mu);
203 #pragma omp barrier
204  if (mu != 3){
205  Field_SF::set_boundary_wk(m_U[mu], m_wk);
206 #pragma omp barrier
207  }
208  }
209 
210  // vout.general(m_vl," smearing step-1\n");
211  smear_step1();
212  // vout.general(m_vl," smearing step-2\n");
213  smear_step2();
214 
215  Sigma.set(0.0);
216 #pragma omp barrier
217 
218  // vout.general(m_vl," smeared force step-3\n");
219  force_step3(Sigma, Sigmap);
220 
221  // vout.general(m_vl," smeared force step-2\n");
222  force_step2(Sigma);
223 
224  // vout.general(m_vl," smeared force step-1\n");
225  force_step1(Sigma);
226 
227  // vout.general(m_vl," smeared force finished\n");
228 }
229 
230 
231 //====================================================================
244 void ForceSmear_HYP_SF::force_step3(Field_G& Sigma, const Field_G& Sigmap)
245 {
246  for (int mu = 0; mu < m_Ndim; ++mu) {
247 
248  m_ct1->set(0.0);
249 #pragma omp barrier
250 
251  for (int nu = 0; nu < m_Ndim; ++nu) {
252  if (nu == mu) continue;
253 
254  staple(*m_ct2, m_v2[idx2(mu, nu)], m_v2[idx2(nu, mu)], mu, nu);
255  axpy(*m_ct1, 0, 1.0, *m_ct2, 0);
256 #pragma omp barrier
257  }
258 
259  scal(*m_ct1, m_alpha1 / 6.0);
260  copy(*m_ct2, 0, Sigmap, mu);
261 #pragma omp barrier
262 
263  m_proj->force_recursive(*m_ct3, m_iTheta3[mu],
264  m_alpha1, *m_ct2, *m_ct1, m_U[mu]);
265  axpy(Sigma, mu, 1.0, *m_ct3, 0);
266 #pragma omp barrier
267  }
268 
269  for (int mu = 0; mu < m_Ndim; ++mu) {
270  for (int nu = 0; nu < m_Ndim; ++nu) {
271  if (nu == mu) continue;
272 
273  force_each(m_Sigma3[idx2(mu, nu)],
274  m_v2[idx2(mu, nu)], m_v2[idx2(nu, mu)],
275  m_iTheta3[mu], m_iTheta3[nu], mu, nu);
276 
277  scal(m_Sigma3[idx2(mu, nu)], m_alpha1/6.0);
278 #pragma omp barrier
279 
280  if (mu != 3){
281  Field_SF::set_boundary_zero(m_Sigma3[idx2(mu, nu)]);
282 #pragma omp barrier
283  }
284  }
285  }
286 
287 }
288 
289 
290 //====================================================================
302 void ForceSmear_HYP_SF::force_step2(Field_G& Sigma)
303 {
304  for (int mu = 0; mu < m_Ndim; ++mu) {
305  for (int nu = 0; nu < m_Ndim; ++nu) {
306  if (nu == mu) continue;
307 
308  m_ct1->set(0.0);
309 #pragma omp barrier
310 
311  for (int rho = 0; rho < m_Ndim; ++rho) {
312  if ((rho == mu) || (rho == nu)) continue;
313 
314  staple(*m_ct2, m_v1[idx1(mu, nu, rho)],
315  m_v1[idx1(rho, nu, mu)], mu, rho);
316  axpy(*m_ct1, 0, 1.0, *m_ct2, 0);
317 #pragma omp barrier
318  }
319 
320  scal(*m_ct1, m_alpha2/4.0);
321 #pragma omp barrier
322 
323  m_proj->force_recursive(*m_ct3, m_iTheta2[idx2(mu, nu)],
324  m_alpha2, m_Sigma3[idx2(mu, nu)],
325  *m_ct1, m_U[mu]);
326  axpy(Sigma, mu, 1.0, *m_ct3, 0);
327 #pragma omp barrier
328  }
329  }
330 
331  for (int mu = 0; mu < m_Ndim; ++mu) {
332  for (int nu = 0; nu < m_Ndim; ++nu) {
333  if (nu == mu) continue;
334 
335  for (int rho = 0; rho < m_Ndim; ++rho) {
336  if ((rho == mu) || (rho == nu)) continue;
337 
338  force_each(m_Sigma2[idx1b(mu, nu, rho)],
339  m_v1[idx1(mu, nu, rho)], m_v1[idx1(rho, nu, mu)],
340  m_iTheta2[idx2(mu, nu)], m_iTheta2[idx2(rho, nu)],
341  mu, rho);
342 
343  scal(m_Sigma2[idx1b(mu, nu, rho)], m_alpha2/4.0);
344 #pragma omp barrier
345 
346  if (mu != 3){
347  Field_SF::set_boundary_zero(m_Sigma2[idx1b(mu, nu, rho)]);
348 #pragma omp barrier
349  }
350  }
351  }
352  }
353 }
354 
355 
356 //====================================================================
367 void ForceSmear_HYP_SF::force_step1(Field_G& Sigma)
368 {
369  for (int mu = 0; mu < m_Ndim; ++mu) {
370  for (int nu = 0; nu < m_Ndim; ++nu) {
371  if (nu == mu) continue;
372  for (int rho = 0; rho < m_Ndim; ++rho) {
373  if ((rho == mu) || (rho == nu)) continue;
374 
375  int sig = 6 - mu - nu - rho;
376 
377  staple(*m_ct1, m_U[mu], m_U[sig], mu, sig);
378 
379  scal(*m_ct1, m_alpha3/2.0);
380 #pragma omp barrier
381 
382  m_proj->force_recursive(*m_ct2, m_iTheta1[idx1b(mu, nu, rho)],
383  m_alpha3, m_Sigma2[idx1b(mu, nu, rho)],
384  *m_ct1, m_U[mu]);
385  axpy(Sigma, mu, 1.0, *m_ct2, 0);
386 #pragma omp barrier
387  }
388  }
389  }
390 
391  for (int mu = 0; mu < m_Ndim; ++mu) {
392  for (int nu = 0; nu < m_Ndim; ++nu) {
393  if (nu == mu) continue;
394 
395  for (int rho = 0; rho < m_Ndim; ++rho) {
396  if ((rho == mu) || (rho == nu)) continue;
397 
398  int sig = 6 - mu - nu - rho;
399 
400  force_each(*m_ct2, m_U[mu], m_U[sig],
401  m_iTheta1[idx1b(mu, nu, rho)],
402  m_iTheta1[idx1b(sig, nu, rho)],
403  mu, sig);
404 
405  scal(*m_ct2, m_alpha3/2.0);
406  axpy(Sigma, mu, 1.0, *m_ct2, 0);
407 #pragma omp barrier
408  }
409  }
410  }
411 
412  Field_SF::set_boundary_spatial_link_zero(Sigma);
413 #pragma omp barrier
414 
415 }
416 
417 
418 //====================================================================
431 void ForceSmear_HYP_SF::force_each(Field_G& Sigma_mu,
432  const Field_G& V_mu, const Field_G& V_nu,
433  const Field_G& iTheta_mu,
434  const Field_G& iTheta_nu,
435  const int mu, const int nu)
436 {
437 #pragma omp barrier
438 
439  Sigma_mu.set(0.0);
440 #pragma omp barrier
441 
442  //- The 1st block
443  m_shift->backward(*m_vt1, V_nu, mu);
444  if (mu == 3){
445  Field_SF::set_boundary_wkpr(*m_vt1, m_wkpr);
446  }
447  m_shift->backward(*m_vt2, V_mu, nu);
448  if (nu == 3){
449  Field_SF::set_boundary_wkpr(*m_vt2, m_wkpr);
450  }
451 #pragma omp barrier
452 
453  mult_Field_Gnd(*m_vt3, 0, *m_vt1, 0, *m_vt2, 0);
454  multadd_Field_Gnd(Sigma_mu, 0, *m_vt3, 0, iTheta_nu, 0, 1.0);
455 #pragma omp barrier
456 
457  //- The 2nd block
458  mult_Field_Gdn(*m_vt3, 0, iTheta_mu, 0, V_nu, 0);
459  mult_Field_Gdn(*m_vt2, 0, *m_vt1, 0, *m_vt3, 0);
460  m_shift->forward(*m_vt3, *m_vt2, nu);
461  axpy(Sigma_mu, 1.0, *m_vt3);
462 #pragma omp barrier
463 
464  //- The 3rd block
465  mult_Field_Gdn(*m_vt3, 0, V_mu, 0, iTheta_nu, 0);
466  mult_Field_Gdn(*m_vt2, 0, *m_vt1, 0, *m_vt3, 0);
467  m_shift->forward(*m_vt3, *m_vt2, nu);
468  axpy(Sigma_mu, 1.0, *m_vt3);
469 #pragma omp barrier
470 
471  //- The 4th block
472  m_shift->backward(*m_vt1, iTheta_nu, mu);
473  m_shift->backward(*m_vt2, V_mu, nu);
474  if (nu == 3){
475  Field_SF::set_boundary_wkpr(*m_vt2, m_wkpr);
476 #pragma omp barrier
477  }
478  mult_Field_Gnd(*m_vt3, 0, *m_vt1, 0, *m_vt2, 0);
479  multadd_Field_Gnd(Sigma_mu, 0, *m_vt3, 0, V_nu, 0, 1.0);
480 #pragma omp barrier
481 
482  //- The 5th block
483  mult_Field_Gdd(*m_vt2, 0, *m_vt1, 0, V_mu, 0);
484  mult_Field_Gnn(*m_vt3, 0, *m_vt2, 0, V_nu, 0);
485  m_shift->forward(*m_vt2, *m_vt3, nu);
486  axpy(Sigma_mu, 1.0, *m_vt2);
487 #pragma omp barrier
488 
489  //- The 6th block
490  m_shift->backward(*m_vt1, V_nu, mu);
491  if (mu == 3){
492  Field_SF::set_boundary_wkpr(*m_vt1, m_wkpr);
493 #pragma omp barrier
494  }
495  m_shift->backward(*m_vt2, iTheta_mu, nu);
496  mult_Field_Gnd(*m_vt3, 0, *m_vt1, 0, *m_vt2, 0);
497  multadd_Field_Gnd(Sigma_mu, 0, *m_vt3, 0, V_nu, 0, 1.0);
498 #pragma omp barrier
499 
500 }
501 
502 
503 //====================================================================
504 void ForceSmear_HYP_SF::smear_step1()
505 {
506  for (int mu = 0; mu < m_Ndim; ++mu) {
507  for (int nu = 0; nu < m_Ndim; ++nu) {
508  if (nu == mu) continue;
509 
510  for (int rho = nu + 1; rho < m_Ndim; ++rho) {
511  if (rho == mu) continue;
512 
513  int sig = 6 - mu - nu - rho;
514 
515  staple(*m_ct1, m_U[mu], m_U[sig], mu, sig);
516  scal(*m_ct1, m_alpha3/2.0);
517 #pragma omp barrier
518  m_proj->project(m_v1[idx1(mu, nu, rho)],
519  m_alpha3, *m_ct1, m_U[mu]);
520  if (mu != 3){
521  Field_SF::set_boundary_wk(m_v1[idx1(mu, nu, rho)], m_wk);
522 #pragma omp barrier
523  }
524  }
525  }
526  }
527 }
528 
529 
530 //====================================================================
531 void ForceSmear_HYP_SF::smear_step2()
532 {
533  for (int mu = 0; mu < m_Ndim; ++mu) {
534  for (int nu = 0; nu < m_Ndim; ++nu) {
535  if (nu == mu) continue;
536 
537  m_ct2->set(0.0);
538 #pragma omp barrier
539 
540  for (int rho = 0; rho < m_Ndim; ++rho) {
541  if ((rho != mu) && (rho != nu)) {
542  staple(*m_ct1, m_v1[idx1(mu, nu, rho)],
543  m_v1[idx1(rho, nu, mu)], mu, rho);
544  axpy(*m_ct2, 0, 1.0, *m_ct1, 0);
545 #pragma omp barrier
546  }
547  }
548  scal(*m_ct2, m_alpha2 / 4.0);
549 #pragma omp barrier
550  m_proj->project(m_v2[idx2(mu, nu)], m_alpha2, *m_ct2, m_U[mu]);
551  if (mu != 3){
552  Field_SF::set_boundary_wk(m_v2[idx2(mu, nu)], m_wk);
553 #pragma omp barrier
554  }
555  }
556  }
557 }
558 
559 
560 //====================================================================
561 void ForceSmear_HYP_SF::staple(Field_G& c,
562  const Field_G& u_mu, const Field_G& u_nu,
563  const int mu, const int nu)
564 {
565  // upper direction
566  m_shift->backward(*m_vt1, u_mu, nu);
567  if (nu == 3){
568  Field_SF::set_boundary_wkpr(*m_vt1, m_wkpr);
569 #pragma omp barrier
570  }
571 
572  mult_Field_Gnn(*m_vt2, 0, u_nu, 0, *m_vt1, 0);
573 #pragma omp barrier
574 
575  m_shift->backward(*m_vt1, u_nu, mu);
576  if (mu == 3){
577  Field_SF::set_boundary_wkpr(*m_vt1, m_wkpr);
578 #pragma omp barrier
579  }
580 
581  mult_Field_Gnd(c, 0, *m_vt2, 0, *m_vt1, 0);
582 #pragma omp barrier
583 
584  // lower direction
585  m_shift->backward(*m_vt2, u_nu, mu);
586  if (mu == 3){
587  Field_SF::set_boundary_wkpr(*m_vt2, m_wkpr);
588 #pragma omp barrier
589  }
590  mult_Field_Gnn(*m_vt1, 0, u_mu, 0, *m_vt2, 0);
591  mult_Field_Gdn(*m_vt2, 0, u_nu, 0, *m_vt1, 0);
592  m_shift->forward(*m_vt1, *m_vt2, nu);
593  axpy(c, 0, 1.0, *m_vt1, 0);
594 #pragma omp barrier
595 
596 }
597 
598 
599 //============================================================END=====
ForceSmear_HYP_SF::m_wk
Mat_SU_N m_wk
SF boundary condition at t=0.
Definition: forceSmear_HYP_SF.h:55
Field_SF::set_boundary_wkpr
void set_boundary_wkpr(Field_G &u, const Mat_SU_N &wkpr)
Definition: field_SF.cpp:63
mult_Field_Gdn
void mult_Field_Gdn(Field_G &W, const int ex, const Field_G &U1, const int ex1, const Field_G &U2, const int ex2)
Definition: field_G_imp.cpp:134
Parameters::set_string
void set_string(const string &key, const string &value)
Definition: parameters.cpp:39
ForceSmear_HYP_SF::force_step1
void force_step1(Field_G &)
Definition: forceSmear_HYP_SF.cpp:367
forceSmear_HYP_SF.h
ForceSmear_HYP_SF::m_alpha3
double m_alpha3
HYP smearing parameter (level-3)
Definition: forceSmear_HYP_SF.h:40
ForceSmear_HYP_SF::m_ct1
Field_G * m_ct1
Definition: forceSmear_HYP_SF.h:61
ShiftField_lex::forward
void forward(Field &, const Field &, const int mu)
Definition: shiftField_lex.cpp:79
ForceSmear_HYP_SF::m_vt1
Field_G * m_vt1
Definition: forceSmear_HYP_SF.h:58
CommonParameters::Ndim
static int Ndim()
Definition: commonParameters.h:117
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
ForceSmear_HYP_SF::m_shift
ShiftField_lex * m_shift
Definition: forceSmear_HYP_SF.h:45
ForceSmear_HYP_SF::m_iTheta2
std::vector< Field_G > m_iTheta2
Definition: forceSmear_HYP_SF.h:50
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
ForceSmear_HYP_SF::set_parameters
void set_parameters(const Parameters &params)
Definition: forceSmear_HYP_SF.cpp:82
ForceSmear_HYP_SF::m_proj
Projection * m_proj
Definition: forceSmear_HYP_SF.h:43
ForceSmear_HYP_SF::m_phi
std::vector< double > m_phi
SF boundary condition at t=0.
Definition: forceSmear_HYP_SF.h:52
Bridge::BridgeIO::increase_indent
void increase_indent()
Definition: bridgeIO.cpp:508
Field::nex
int nex() const
Definition: field.h:128
CommonParameters::Nvol
static int Nvol()
Definition: commonParameters.h:109
ForceSmear_HYP_SF::m_ct2
Field_G * m_ct2
Definition: forceSmear_HYP_SF.h:62
ForceSmear_HYP_SF::m_alpha2
double m_alpha2
HYP smearing parameter (level-2)
Definition: forceSmear_HYP_SF.h:39
ForceSmear_HYP_SF::idx1b
int idx1b(const int mu, int nu, int rho)
Definition: forceSmear_HYP_SF.h:110
Field_SF::set_boundary_wk
void set_boundary_wk(Field_G &u, const Mat_SU_N &wk)
Definition: field_SF.cpp:32
axpy
void axpy(Field &y, const double a, const Field &x)
axpy(y, a, x): y := a * x + y
Definition: field.cpp:381
Parameters::set_double_vector
void set_double_vector(const string &key, const vector< double > &value)
Definition: parameters.cpp:42
ForceSmear_HYP_SF::m_ct3
Field_G * m_ct3
Definition: forceSmear_HYP_SF.h:63
AProjection::force_recursive
virtual void force_recursive(Field_G &Xi, Field_G &iTheta, const double alpha, const Field_G &Sigmap, const Field_G &C, const Field_G &U)=0
determination of fields for force calculation
ForceSmear_HYP_SF::m_wkpr
Mat_SU_N m_wkpr
SF boundary condition at t=Nt.
Definition: forceSmear_HYP_SF.h:56
ForceSmear_HYP_SF::idx1
int idx1(const int mu, const int nu, const int rho)
Definition: forceSmear_HYP_SF.h:103
ForceSmear_HYP_SF::class_name
static const std::string class_name
Definition: forceSmear_HYP_SF.h:33
copy
void copy(Field &y, const Field &x)
copy(y, x): y = x
Definition: field.cpp:213
SU_N::Mat_SU_N::set
void set(int c, const double &re, const double &im)
Definition: mat_SU_N.h:137
Field_SF::set_boundary_zero
void set_boundary_zero(Field_G &u)
Definition: field_SF.cpp:96
ForceSmear_HYP_SF::size1
int size1()
Definition: forceSmear_HYP_SF.h:124
CommonParameters::Lx
static int Lx()
Definition: commonParameters.h:91
SU_N::Mat_SU_N::zero
Mat_SU_N & zero()
Definition: mat_SU_N.h:429
ForceSmear_HYP_SF::m_v2
std::vector< Field_G > m_v2
Definition: forceSmear_HYP_SF.h:48
ForceSmear_HYP_SF::size1b
int size1b()
Definition: forceSmear_HYP_SF.h:126
ForceSmear_HYP_SF::size2
int size2()
Definition: forceSmear_HYP_SF.h:128
ForceSmear_HYP_SF::m_Sigma3
std::vector< Field_G > m_Sigma3
Definition: forceSmear_HYP_SF.h:49
ForceSmear_HYP_SF::init
void init(const Parameters &params)
Definition: forceSmear_HYP_SF.cpp:22
threadManager.h
ForceSmear_HYP_SF::m_phipr
std::vector< double > m_phipr
SF boundary condition at t=Nt.
Definition: forceSmear_HYP_SF.h:53
Field::nvol
int nvol() const
Definition: field.h:127
ForceSmear_HYP_SF::force_step3
void force_step3(Field_G &, const Field_G &)
Definition: forceSmear_HYP_SF.cpp:244
ShiftField_lex
Methods to shift a field in the lexical site index.
Definition: shiftField_lex.h:39
multadd_Field_Gnd
void multadd_Field_Gnd(Field_G &W, const int ex, const Field_G &U1, const int ex1, const Field_G &U2, const int ex2, const double ff)
Definition: field_G_imp.cpp:335
ForceSmear_HYP_SF::m_Nvol
int m_Nvol
spacetime volume
Definition: forceSmear_HYP_SF.h:37
Field_SF::set_boundary_spatial_link_zero
void set_boundary_spatial_link_zero(Field_G &u)
Definition: field_SF.cpp:151
ForceSmear_HYP_SF::force_each
void force_each(Field_G &, const Field_G &, const Field_G &, const Field_G &, const Field_G &, const int mu, const int nu)
Definition: forceSmear_HYP_SF.cpp:431
ForceSmear_HYP_SF::m_vt3
Field_G * m_vt3
Definition: forceSmear_HYP_SF.h:60
ForceSmear_HYP_SF::m_Ndim
int m_Ndim
spacetime dimension
Definition: forceSmear_HYP_SF.h:36
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
mult_Field_Gnn
void mult_Field_Gnn(Field_G &W, const int ex, const Field_G &U1, const int ex1, const Field_G &U2, const int ex2)
Definition: field_G_imp.cpp:95
ShiftField_lex::backward
void backward(Field &, const Field &, const int mu)
Definition: shiftField_lex.cpp:59
ForceSmear_HYP_SF::m_iTheta3
std::vector< Field_G > m_iTheta3
Definition: forceSmear_HYP_SF.h:50
ForceSmear_HYP_SF::m_v1
std::vector< Field_G > m_v1
Definition: forceSmear_HYP_SF.h:48
ForceSmear_HYP_SF::smear_step1
void smear_step1()
Definition: forceSmear_HYP_SF.cpp:504
mult_Field_Gdd
void mult_Field_Gdd(Field_G &W, const int ex, const Field_G &U1, const int ex1, const Field_G &U2, const int ex2)
Definition: field_G_imp.cpp:212
ForceSmear_HYP_SF::m_vt2
Field_G * m_vt2
Definition: forceSmear_HYP_SF.h:59
ForceSmear_HYP_SF::m_Sigma2
std::vector< Field_G > m_Sigma2
Definition: forceSmear_HYP_SF.h:49
scal
void scal(Field &x, const double a)
scal(x, a): x = a * x
Definition: field.cpp:262
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
ForceSmear_HYP_SF::m_iTheta1
std::vector< Field_G > m_iTheta1
Definition: forceSmear_HYP_SF.h:50
Bridge::BridgeIO::crucial
void crucial(const char *format,...)
Definition: bridgeIO.cpp:242
ForceSmear_HYP_SF::idx2
int idx2(const int mu, int nu)
Definition: forceSmear_HYP_SF.h:118
ForceSmear_HYP_SF::get_parameters
void get_parameters(Parameters &params) const
Definition: forceSmear_HYP_SF.cpp:177
ForceSmear_HYP_SF::m_alpha1
double m_alpha1
HYP smearing parameter (level-1)
Definition: forceSmear_HYP_SF.h:38
ThreadManager::get_thread_id
static int get_thread_id()
returns thread id.
Definition: threadManager.cpp:253
Field_G
SU(N) gauge field.
Definition: field_G.h:38
ForceSmear_HYP_SF::m_vl
Bridge::VerboseLevel m_vl
Definition: forceSmear_HYP_SF.h:41
Parameters::fetch_double_vector
int fetch_double_vector(const string &key, vector< double > &value) const
Definition: parameters.cpp:410
ForceSmear_HYP_SF::force_udiv
void force_udiv(Field_G &Sigma, const Field_G &Sigma_p, const Field_G &U)
Definition: forceSmear_HYP_SF.cpp:190
ForceSmear_HYP_SF::smear_step2
void smear_step2()
Definition: forceSmear_HYP_SF.cpp:531
Bridge::BridgeIO::general
void general(const char *format,...)
Definition: bridgeIO.cpp:262
mult_Field_Gnd
void mult_Field_Gnd(Field_G &W, const int ex, const Field_G &U1, const int ex1, const Field_G &U2, const int ex2)
Definition: field_G_imp.cpp:173
ThreadManager::assert_single_thread
static void assert_single_thread(const std::string &class_name)
assert currently running on single thread.
Definition: threadManager.cpp:372
AProjection::project
virtual void project(Field_G &v, const double alpha, const Field_G &C, const Field_G &U)=0
projection V = P[alpha, C, U]
Bridge::vout
BridgeIO vout
Definition: bridgeIO.cpp:572
ForceSmear_HYP_SF::force_step2
void force_step2(Field_G &)
Definition: forceSmear_HYP_SF.cpp:302
Bridge::BridgeIO::get_verbose_level
static std::string get_verbose_level(const VerboseLevel vl)
Definition: bridgeIO.cpp:216
ForceSmear_HYP_SF::m_U
std::vector< Field_G > m_U
Definition: forceSmear_HYP_SF.h:47
ForceSmear_HYP_SF::staple
void staple(Field_G &, const Field_G &, const Field_G &, const int mu, const int nu)
Definition: forceSmear_HYP_SF.cpp:561
ForceSmear_HYP_SF::tidyup
void tidyup()
Definition: forceSmear_HYP_SF.cpp:69