CHROMA
wloop.cc
Go to the documentation of this file.
1 /*! \file
2  * \brief Compute simple Wilson loops for use in
3  * alpha_s calculation. These are the Wilson loops used by
4  * the HPQCD collaboration.
5  *
6  * Accurate determinations of alpha(s) from realistic lattice QCD.
7  * By HPQCD Collaboration and UKQCD Collaboration
8  * Published in Phys.Rev.Lett.95:052002,2005.
9  * e-Print: hep-lat/0503005
10  *
11  */
12 
13 #include "chromabase.h"
14 #include "meas/glue/wloop.h"
15 #include "meas/glue/polylp.h"
16 
17 namespace Chroma
18 {
19 
20  // Primitive way for now to indicate the time direction
21  static int tDir() {return Nd-1;}
22 
23  //! Return the value of the 11, 12, 13, 14 Wilson loops
24  /*!
25  * \ingroup glue
26  *
27  * \param u gauge field (Read)
28  * \param plane_plaq plane plaquette average (Write)
29  * \param link space-time average link (Write)
30  */
31 
32  void Wloop(const multi1d<LatticeColorMatrix>& u,
33  multi2d<Double>& plane_plaq_11,
34  multi2d<Double>& plane_plaq_12,
35  multi2d<Double>& plane_plaq_13,
36  multi2d<Double>& plane_plaq_14 )
37  {
38  START_CODE();
39 
40  plane_plaq_11.resize(Nd,Nd);
41  plane_plaq_12.resize(Nd,Nd);
42  plane_plaq_13.resize(Nd,Nd);
43  plane_plaq_14.resize(Nd,Nd);
44 
45  // Compute the average Wilson loops
46  for(int mu=1; mu < Nd; ++mu)
47  {
48  for(int nu=0; nu < mu; ++nu)
49  {
50 
51  /** compute the 1x1 Wilson loop **/
52  /* staple_0 = u(x,mu) * u(x+mu,nu)*u_dag(x+nu,mu) */
53  LatticeColorMatrix tmp0 = adj(shift(u[mu],FORWARD,nu)) ;
54  LatticeColorMatrix staple_0 = u[mu]*shift(u[nu],FORWARD,mu) * tmp0 ;
55 
56  /* = sum(tr(u(x,mu)*tmp_1=u(x,mu)*u(x+mu,nu)*u_dag(x+nu,mu)*u_dag(x,nu))) */
57  plane_plaq_11[mu][nu] = sum(real(trace(staple_0 * adj(u[nu]))));
58 
59  /** compute the 1x2 Wilson loop **/
60  LatticeColorMatrix staple_1 = u[mu]*shift(staple_0 ,FORWARD,mu) * tmp0 ;
61  plane_plaq_12[mu][nu] = sum(real(trace(staple_1 * adj(u[nu]))));
62 
63  /** compute the 1x3 Wilson loop **/
64  LatticeColorMatrix staple_2 = u[mu]*shift(staple_1 ,FORWARD,mu) * tmp0 ;
65  plane_plaq_13[mu][nu] = sum(real(trace(staple_2 * adj(u[nu]))));
66 
67  /** compute the 1x4 Wilson loop **/
68  LatticeColorMatrix staple_3 = u[mu]*shift(staple_2 ,FORWARD,mu) * tmp0 ;
69  plane_plaq_14[mu][nu] = sum(real(trace(staple_3 * adj(u[nu]))));
70 
71  }
72  }
73 
74  // Normalize the planes
75  for(int mu=1; mu < Nd; ++mu)
76  for(int nu=0; nu < mu; ++nu)
77  {
78  plane_plaq_11[mu][nu] /= Double(Layout::vol()*Nc);
79  plane_plaq_11[nu][mu] = plane_plaq_11[mu][nu];
80 
81  plane_plaq_12[mu][nu] /= Double(Layout::vol()*Nc);
82  plane_plaq_12[nu][mu] = plane_plaq_12[mu][nu];
83 
84  plane_plaq_13[mu][nu] /= Double(Layout::vol()*Nc);
85  plane_plaq_13[nu][mu] = plane_plaq_13[mu][nu];
86 
87  plane_plaq_14[mu][nu] /= Double(Layout::vol()*Nc);
88  plane_plaq_14[nu][mu] = plane_plaq_14[mu][nu];
89 
90  }
91 
92  END_CODE();
93 }
94 
95 
96 
97  //! Return the value of the bent 12 Wilson loops
98  /*!
99  * \ingroup glue
100  *
101  * \param u gauge field (Read)
102  * \param mu direction for plane 0 (Read)
103  * \param nu direction for plane 0 (Read)
104  * \param eta direction for plane 1 (Read)
105  * \param sigma direction for plane 1 (Read)
106  * \param ans bent rectangle (Write)
107  */
108 
109  void Wloop_bent(const multi1d<LatticeColorMatrix>& u,
110  int mu, int nu, int eta,
111  Double & ans)
112  {
113  START_CODE();
114 
115  ans = zero ;
116 
117  LatticeColorMatrix staple_0 = u[mu]*shift(u[nu],FORWARD,mu) *
118  adj(shift(u[mu],FORWARD,nu)) ;
119 
120  LatticeColorMatrix staple_1 = u[eta]*shift(u[nu],FORWARD,eta) *
121  adj(shift(u[eta],FORWARD,nu)) ;
122 
123  ans += sum(real(trace(staple_0 * adj(staple_1) )));
124 
125 
126  LatticeColorMatrix tmp0 = shift(u[mu],BACKWARD,mu) ;
127  LatticeColorMatrix staple_2 = adj(tmp0)*shift(u[nu],BACKWARD,mu) *
128  (shift(tmp0,FORWARD,nu)) ;
129 
130  ans += sum(real(trace(staple_2 * adj(staple_1) )));
131 
132 
133  tmp0 = shift(u[eta],BACKWARD,eta) ;
134  staple_1 = adj(tmp0)*shift(u[nu],BACKWARD,eta) *
135  (shift(tmp0,FORWARD,nu)) ;
136 
137  ans += sum(real(trace(staple_2 * adj(staple_1) )));
138  ans += sum(real(trace(staple_0 * adj(staple_1) )));
139 
140  // Normalize the planes
141  ans /= Double(Layout::vol()*Nc);
142  ans /= 4.0 ;
143 
144  END_CODE();
145 }
146 
147 
148 
149 
150  //! Return the value of the really bent Wilson loops of length 6
151  /*!
152  * \ingroup glue
153  *
154  * \param u gauge field (Read)
155  * \param mu1 direction 1 (Read)
156  * \param mu2 direction 2 (Read)
157  * \param mu3 direction 3 (Read)
158  * \param ans really bent rectangle (Write)
159  */
160 
161  void Wloop_really_bent(const multi1d<LatticeColorMatrix>& u,
162  int mu1, int mu2, int mu3,
163  Double & ans)
164  {
165  START_CODE();
166 
167 
168  LatticeColorMatrix tmp0 = shift(u[mu3],FORWARD,mu1) ;
169  LatticeColorMatrix third = shift(tmp0,FORWARD,mu2) ;
170 
171  LatticeColorMatrix tmp1 = shift(u[mu1],FORWARD,mu3) ;
172  LatticeColorMatrix fourth = shift(tmp1,FORWARD,mu2) ;
173 
174  LatticeColorMatrix fifth = shift(u[mu2],FORWARD,mu3) ;
175 
176 
177  ans = sum(real(trace(u[mu1] * shift(u[mu2],FORWARD,mu1)*third*adj(fourth)*adj(fifth)*adj(u[mu3] ))));
178 
179  ans /= Double(Layout::vol()*Nc);
180 
181  END_CODE();
182 }
183 
184 
185 
186 
187  //! Return the value of the really bent Wilson loops of length 6
188  /*!
189  * \ingroup glue
190  *
191  * \param u gauge field (Read)
192  * \param ans really bent rectangle (Write)
193  */
194 
195  void Wloop_really_bent(const multi1d<LatticeColorMatrix>& u,
196  Double & ans)
197  {
198  START_CODE();
199  Double ans_local ;
200 
201  ans = zero ;
202 
203  Wloop_really_bent(u,0,1,2,ans_local ) ;
204  ans += ans_local ;
205 
206  Wloop_really_bent(u,0,1,3,ans_local ) ;
207  ans += ans_local ;
208 
209  Wloop_really_bent(u,0,2,3,ans_local ) ;
210  ans += ans_local ;
211 
212  Wloop_really_bent(u,1,2,3,ans_local ) ;
213  ans += ans_local ;
214 
215 
216  ans /= Double(4.0) ;
217 
218  END_CODE();
219 }
220 
221 
222 
223 
224  //! Return the value of the bent 12 Wilson loops
225  /*! averaged over directions.
226  * \ingroup glue
227  *
228  * \param u gauge field (Read)
229  * \param ans bent rectangle (Write)
230  */
231 
232  void Wloop_bent(const multi1d<LatticeColorMatrix>& u,
233  Double & ans)
234  {
235  START_CODE();
236 
237  ans = 0.0 ;
238  Double local_ans ;
239 
240  Wloop_bent(u,0,1,2,local_ans) ;
241  ans += local_ans ;
242 
243  Wloop_bent(u,0,2,3,local_ans) ;
244  ans += local_ans ;
245 
246  Wloop_bent(u,0,1,3,local_ans) ;
247  ans += local_ans ;
248 
249  ans /= 3 ;
250 
251  END_CODE();
252 }
253 
254 
255 
256 
257  //! Return the value of the 22, 23, Wilson loops
258  /*!
259  * \ingroup glue
260  *
261  * \param u gauge field (Read)
262  * \param plane_plaq_22 plane 2x2 Wilson loops average (Write)
263  * \param plane_plaq_23 plane 2x3 Wilson loops average (Write)
264  */
265 
266  void Wloop(const multi1d<LatticeColorMatrix>& u,
267  multi2d<Double>& plane_plaq_22,
268  multi2d<Double>& plane_plaq_23)
269  {
270  START_CODE();
271 
272  plane_plaq_22.resize(Nd,Nd);
273  plane_plaq_23.resize(Nd,Nd);
274 
275  // Compute the average Wilson loops
276  for(int mu=1; mu < Nd; ++mu)
277  {
278  for(int nu=0; nu < mu; ++nu)
279  {
280  /** compute the 2x2 Wilson loop **/
281  /* staple_0 = u(x,mu) * u(x+mu,nu)*u_dag(x+nu,mu) */
282 
283  LatticeColorMatrix tmp1 = shift(u[nu],FORWARD,mu) ;
284  LatticeColorMatrix tmp2 = shift(tmp1,FORWARD,nu) ;
285 
286  LatticeColorMatrix tmp3 = shift(u[mu],FORWARD,nu) ;
287  LatticeColorMatrix tmp4 = shift(tmp3 ,FORWARD,nu) ;
288 
289  LatticeColorMatrix staple_0 = u[mu]*tmp1*tmp2*adj(tmp4) ;
290  LatticeColorMatrix staple_1 = u[mu]*shift(staple_0,FORWARD,mu)*adj(tmp4) ;
291 
292  LatticeColorMatrix tmp5 = shift(u[nu],FORWARD,nu) ;
293 
294  plane_plaq_22[mu][nu] = sum(real(trace(staple_1 * adj(u[nu] * tmp5) )) );
295 
296 
297  /** compute the 2x3 Wilson loop **/
298  LatticeColorMatrix tmp2_ = shift(tmp2,FORWARD,nu) ;
299  LatticeColorMatrix tmp4_ = shift(tmp4,FORWARD,nu) ;
300  staple_0 = u[mu] * tmp1*tmp2* tmp2_ * adj(tmp4_) ;
301  staple_1 = u[mu] * shift(staple_0,FORWARD,mu) * adj(tmp4_) ;
302 
303  LatticeColorMatrix tmp5_ = shift(tmp5,FORWARD,nu) ;
304 
305  plane_plaq_23[mu][nu] = sum(real(trace(staple_1 * adj(u[nu] * tmp5 * tmp5_) )) );
306 
307  }
308  }
309 
310  // Normalize the planes
311  for(int mu=1; mu < Nd; ++mu)
312  for(int nu=0; nu < mu; ++nu)
313  {
314  plane_plaq_22[mu][nu] /= Double(Layout::vol()*Nc);
315  plane_plaq_22[nu][mu] = plane_plaq_22[mu][nu];
316 
317  plane_plaq_23[mu][nu] /= Double(Layout::vol()*Nc);
318  plane_plaq_23[nu][mu] = plane_plaq_23[mu][nu];
319 
320  }
321 
322  END_CODE();
323 }
324 
325 
326  //! Return the value of the average Wilson loops normalized to 1
327  /*!
328  * \ingroup glue
329  *
330  * \param u gauge field (Read)
331  * \param w_plaq plaquette average (Write)
332  * \param s_plaq space-like plaquette average (Write)
333  * \param t_plaq time-like plaquette average (Write)
334  * \param plane_plaq plane plaquette average (Write)
335  */
336 
337  void Wloop(const multi1d<LatticeColorMatrix>& u,
338  Double& w_11, Double& s_11, Double& t_11, multi2d<Double>& plane_plaq_11,
339  Double& w_12, Double& s_12, Double& t_12, multi2d<Double>& plane_plaq_12,
340  Double& w_13, Double& s_13, Double& t_13, multi2d<Double>& plane_plaq_13,
341  Double& w_14, Double& s_14, Double& t_14, multi2d<Double>& plane_plaq_14 )
342  {
343  START_CODE();
344 
345  // Compute plane plaquettes
346  Wloop(u,plane_plaq_11,plane_plaq_12,plane_plaq_13,plane_plaq_14);
347 
348  // Compute basic Wilson loops
349  w_11 = s_11 = t_11 = zero;
350  w_12 = s_12 = t_12 = zero;
351  w_13 = s_13 = t_13 = zero;
352  w_14 = s_14 = t_14 = zero;
353 
354  for(int mu=1; mu < Nd; ++mu)
355  {
356  for(int nu=0; nu < mu; ++nu)
357  {
358  Double tmp11 = plane_plaq_11[mu][nu];
359  Double tmp12 = plane_plaq_12[mu][nu];
360  Double tmp13 = plane_plaq_13[mu][nu];
361  Double tmp14 = plane_plaq_14[mu][nu];
362 
363  w_11 += tmp11;
364  w_12 += tmp12;
365  w_13 += tmp13;
366  w_14 += tmp14;
367 
368  if (mu == tDir() || nu == tDir())
369  {
370  t_11 += tmp11;
371  t_12 += tmp12;
372  t_13 += tmp13;
373  t_14 += tmp14;
374  }
375  else
376  {
377  s_11 += tmp11;
378  s_12 += tmp12;
379  s_13 += tmp13;
380  s_14 += tmp14;
381  }
382 
383  }
384  }
385 
386  // Normalize
387  w_11 *= 2.0 / Double(Nd*(Nd-1));
388  w_12 *= 2.0 / Double(Nd*(Nd-1));
389  w_13 *= 2.0 / Double(Nd*(Nd-1));
390  w_14 *= 2.0 / Double(Nd*(Nd-1));
391 
392  if (Nd > 2)
393  {
394  s_11 *= 2.0 / Double((Nd-1)*(Nd-2));
395  s_12 *= 2.0 / Double((Nd-1)*(Nd-2));
396  s_13 *= 2.0 / Double((Nd-1)*(Nd-2));
397  s_14 *= 2.0 / Double((Nd-1)*(Nd-2));
398  }
399 
400 
401  t_11 /= Double(Nd-1);
402  t_12 /= Double(Nd-1);
403  t_13 /= Double(Nd-1);
404  t_14 /= Double(Nd-1);
405 
406  END_CODE();
407  }
408 
409 
410 
411  //! Return the value of the average Wilson loops normalized to 1
412  /*!
413  * \ingroup glue
414  *
415  * \param u gauge field (Read)
416  * \param w_plaq plaquette average (Write)
417  * \param s_plaq space-like plaquette average (Write)
418  * \param t_plaq time-like plaquette average (Write)
419  * \param plane_plaq plane plaquette average (Write)
420  */
421 
422  void Wloop(const multi1d<LatticeColorMatrix>& u,
423  Double& w_11, Double& s_11, Double& t_11, multi2d<Double>& plane_plaq_11,
424  Double& w_12, Double& s_12, Double& t_12, multi2d<Double>& plane_plaq_12)
425  {
426  START_CODE();
427 
428  // Compute plane plaquettes
429  Wloop(u,plane_plaq_11,plane_plaq_12);
430 
431  // Compute basic Wilson loops
432  w_11 = s_11 = t_11 = zero;
433  w_12 = s_12 = t_12 = zero;
434 
435  for(int mu=1; mu < Nd; ++mu)
436  {
437  for(int nu=0; nu < mu; ++nu)
438  {
439  Double tmp11 = plane_plaq_11[mu][nu];
440  Double tmp12 = plane_plaq_12[mu][nu];
441 
442  w_11 += tmp11;
443  w_12 += tmp12;
444 
445  if (mu == tDir() || nu == tDir())
446  {
447  t_11 += tmp11;
448  t_12 += tmp12;
449  }
450  else
451  {
452  s_11 += tmp11;
453  s_12 += tmp12;
454  }
455 
456  }
457  }
458 
459  // Normalize
460  w_11 *= 2.0 / Double(Nd*(Nd-1));
461  w_12 *= 2.0 / Double(Nd*(Nd-1));
462 
463  if (Nd > 2)
464  {
465  s_11 *= 2.0 / Double((Nd-1)*(Nd-2));
466  s_12 *= 2.0 / Double((Nd-1)*(Nd-2));
467  }
468 
469 
470  t_11 /= Double(Nd-1);
471  t_12 /= Double(Nd-1);
472 
473  END_CODE();
474  }
475 
476 
477 
478  //! Print the value of the average Wilso loops normalized to 1
479  /*!
480  * \ingroup glue
481  *
482  * \param xml plaquette average (Write)
483  * \param xml_group xml file object ( Read )
484  * \param u gauge field (Read)
485  */
486  void Wloop(XMLWriter& xml,
487  const std::string& xml_group,
488  const multi1d<LatticeColorMatrix>& u)
489  {
490  START_CODE();
491 
492  Double w_11, s_11, t_11 ; multi2d<Double> plane_plaq_11;
493  Double w_12, s_12, t_12 ; multi2d<Double> plane_plaq_12;
494  Double w_13, s_13, t_13 ; multi2d<Double> plane_plaq_13;
495  Double w_14, s_14, t_14 ; multi2d<Double> plane_plaq_14;
496 
497  Double w_22, s_22, t_22 ; multi2d<Double> plane_plaq_22;
498  Double w_23, s_23, t_23 ; multi2d<Double> plane_plaq_23;
499 
500  StopWatch swatch_a;
501 
502  swatch_a.start();
503  Wloop(u,
504  w_11, s_11, t_11, plane_plaq_11,
505  w_12, s_12, t_12, plane_plaq_12,
506  w_13, s_13, t_13, plane_plaq_13,
507  w_14, s_14, t_14, plane_plaq_14);
508 
509  swatch_a.stop() ;
510 
511  double time_in_sec_a = swatch_a.getTimeInSeconds();
512  QDPIO::cout << "Time for 11,12,13, and 14 Wilson loops " << time_in_sec_a << " sec\n" ;
513 
514 
515 
516  StopWatch swatch_b;
517  swatch_b.start();
518  Wloop(u,
519  w_22, s_22, t_22, plane_plaq_22,
520  w_23, s_23, t_23, plane_plaq_23) ;
521 
522  swatch_b.stop() ;
523  double time_in_sec_b = swatch_b.getTimeInSeconds();
524  QDPIO::cout << "Time for 22 and 23 Wilson loops " << time_in_sec_b << " sec\n" ;
525 
526  StopWatch swatch_c;
527  swatch_c.start();
528  Double w_bent1x2 ;
529  Wloop_bent(u, w_bent1x2) ;
530  swatch_c.stop() ;
531  double time_in_sec_c = swatch_c.getTimeInSeconds();
532  QDPIO::cout << "Time for bent 1x2 Wilson loops " << time_in_sec_c << " sec\n" ;
533 
534 
535  StopWatch swatch_d;
536  swatch_d.start();
537  Double w_really_bent ;
538  Wloop_really_bent(u,w_really_bent) ;
539  swatch_d.stop() ;
540  double time_in_sec_d = swatch_d.getTimeInSeconds();
541  QDPIO::cout << "Time for really bent Wilson loops " << time_in_sec_d << " sec\n" ;
542 
543 
544 
545  push(xml, xml_group);
546 
547 
548  // --------------------------------------------------
549 
550  push(xml, "Wilson_loop_11");
551  write(xml, "all_av", w_11);
552  write(xml, "space_av", s_11);
553  write(xml, "time_av", t_11);
554 
555  write(xml, "plane_01_plaq", plane_plaq_11[0][1]);
556  write(xml, "plane_02_plaq", plane_plaq_11[0][2]);
557  write(xml, "plane_12_plaq", plane_plaq_11[1][2]);
558  write(xml, "plane_03_plaq", plane_plaq_11[0][3]);
559  write(xml, "plane_13_plaq", plane_plaq_11[1][3]);
560  write(xml, "plane_23_plaq", plane_plaq_11[2][3]);
561 
562  pop(xml); // Wilson loop 11
563 
564  // --------------------------------------------------
565 
566  push(xml, "Wilson_loop_12");
567  write(xml, "all_av", w_12);
568  write(xml, "space_av", s_12);
569  write(xml, "time_av", t_12);
570 
571  write(xml, "plane_01_plaq", plane_plaq_12[0][1]);
572  write(xml, "plane_02_plaq", plane_plaq_12[0][2]);
573  write(xml, "plane_12_plaq", plane_plaq_12[1][2]);
574  write(xml, "plane_03_plaq", plane_plaq_12[0][3]);
575  write(xml, "plane_13_plaq", plane_plaq_12[1][3]);
576  write(xml, "plane_23_plaq", plane_plaq_12[2][3]);
577 
578  pop(xml); // Wilson loop 12
579 
580  // --------------------------------------------------
581 
582  push(xml, "Wilson_loop_13");
583  write(xml, "all_av", w_13);
584  write(xml, "space_av", s_13);
585  write(xml, "time_av", t_13);
586 
587  write(xml, "plane_01_plaq", plane_plaq_13[0][1]);
588  write(xml, "plane_02_plaq", plane_plaq_13[0][2]);
589  write(xml, "plane_12_plaq", plane_plaq_13[1][2]);
590  write(xml, "plane_03_plaq", plane_plaq_13[0][3]);
591  write(xml, "plane_13_plaq", plane_plaq_13[1][3]);
592  write(xml, "plane_23_plaq", plane_plaq_13[2][3]);
593 
594  pop(xml); // Wilson loop 13
595 
596  // --------------------------------------------------
597 
598  push(xml, "Wilson_loop_14");
599  write(xml, "all_av", w_14);
600  write(xml, "space_av", s_14);
601  write(xml, "time_av", t_14);
602 
603  write(xml, "plane_01_plaq", plane_plaq_14[0][1]);
604  write(xml, "plane_02_plaq", plane_plaq_14[0][2]);
605  write(xml, "plane_12_plaq", plane_plaq_14[1][2]);
606  write(xml, "plane_03_plaq", plane_plaq_14[0][3]);
607  write(xml, "plane_13_plaq", plane_plaq_14[1][3]);
608  write(xml, "plane_23_plaq", plane_plaq_14[2][3]);
609 
610  pop(xml); // Wilson loop 14
611 
612  // --------------------------------------------------
613 
614  push(xml, "Wilson_loop_22");
615  write(xml, "all_av", w_22);
616  write(xml, "space_av", s_22);
617  write(xml, "time_av", t_22);
618 
619  write(xml, "plane_01_plaq", plane_plaq_22[0][1]);
620  write(xml, "plane_02_plaq", plane_plaq_22[0][2]);
621  write(xml, "plane_12_plaq", plane_plaq_22[1][2]);
622  write(xml, "plane_03_plaq", plane_plaq_22[0][3]);
623  write(xml, "plane_13_plaq", plane_plaq_22[1][3]);
624  write(xml, "plane_23_plaq", plane_plaq_22[2][3]);
625 
626  pop(xml); // Wilson loop 22
627 
628  // --------------------------------------------------
629 
630 
631 
632  push(xml, "Wilson_loop_23");
633  write(xml, "all_av", w_23);
634  write(xml, "space_av", s_23);
635  write(xml, "time_av", t_23);
636 
637  write(xml, "plane_01_plaq", plane_plaq_23[0][1]);
638  write(xml, "plane_02_plaq", plane_plaq_23[0][2]);
639  write(xml, "plane_12_plaq", plane_plaq_23[1][2]);
640  write(xml, "plane_03_plaq", plane_plaq_23[0][3]);
641  write(xml, "plane_13_plaq", plane_plaq_23[1][3]);
642  write(xml, "plane_23_plaq", plane_plaq_23[2][3]);
643 
644  pop(xml); // Wilson loop 23
645 
646  // --------------------------------------------------
647 
648  push(xml, "Wilson_loop_bent_rectangle");
649  write(xml, "all_av", w_bent1x2);
650  pop(xml); // Wilson loop bent rectangle
651 
652 
653  // --------------------------------------------------
654 
655  push(xml, "Wilson_loop_really_bent");
656  write(xml, "all_av", w_really_bent);
657  pop(xml); // Wilson loop bent rectangle
658 
659  // --------------------------------------------------
660 
661  pop(xml); // xml_group
662 
663  END_CODE();
664  }
665 
666 } // end namespace Chroma
chromabase.h
Primary include file for CHROMA library code.
mu
int mu
Definition: cool.cc:24
nu
int nu
Definition: cool.cc:25
Chroma::write
void write(XMLWriter &xml, const std::string &path, const AsqtadFermActParams &param)
Writer parameters.
Definition: asqtad_fermact_params_s.cc:40
Chroma::Wloop
void Wloop(const multi1d< LatticeColorMatrix > &u, multi2d< Double > &plane_plaq_11, multi2d< Double > &plane_plaq_12, multi2d< Double > &plane_plaq_13, multi2d< Double > &plane_plaq_14)
Return the value of the 11, 12, 13, 14 Wilson loops.
Definition: wloop.cc:32
Chroma::Wloop_really_bent
void Wloop_really_bent(const multi1d< LatticeColorMatrix > &u, int mu1, int mu2, int mu3, Double &ans)
Return the value of the really bent Wilson loops of length 6.
Definition: wloop.cc:161
Chroma::Wloop_bent
void Wloop_bent(const multi1d< LatticeColorMatrix > &u, int mu, int nu, int eta, Double &ans)
Return the value of the bent 12 Wilson loops.
Definition: wloop.cc:109
mu1
int mu1
Definition: meslate.cc:66
mu2
int mu2
Definition: meslate.cc:68
Nd
Nd
Definition: meslate.cc:74
tmp2
Double tmp2
Definition: mesq.cc:30
tmp3
Double tmp3
Definition: mesq.cc:31
Chroma
Asqtad Staggered-Dirac operator.
Definition: klein_gord.cc:10
Chroma::tDir
static int tDir()
Definition: coulgauge.cc:14
Chroma::u
static multi1d< LatticeColorMatrix > u
Definition: syssolver_linop_qop_mg_w.cc:39
Chroma::push
push(xml_out,"Condensates")
Chroma::pop
pop(xml_out)
Chroma::eta
LatticeFermion eta
Definition: mespbg5p_w.cc:37
Chroma::START_CODE
START_CODE()
Chroma::zero
Double zero
Definition: invbicg.cc:106
testing::internal::Double
FloatingPoint< double > Double
Definition: gtest.h:7351
testing::internal::string
::std::string string
Definition: gtest.h:1979
polylp.h
Calculate the global normalized sum of the Polyakov loop.
FORWARD
#define FORWARD
Definition: primitives.h:82
BACKWARD
#define BACKWARD
Definition: primitives.h:83
sum
Double sum
Definition: qtopcor.cc:37
Generated by doxygen 1.9.1