CHROMA
deriv_meson_seqsrc_w.cc
Go to the documentation of this file.
1 /*! \file
2  * \brief Construct meson sequential sources.
3  */
4 
5 #include "meas/hadron/deriv_meson_seqsrc_w.h"
6 #include "meas/hadron/seqsource_factory_w.h"
7 #include "meas/smear/displace.h"
8 
9 #include "util/ferm/gammasgn_w.h"
10 #include "util/ferm/gamma5_herm_w.h"
11 #include "util/ferm/symtensor.h"
12 #include "util/ferm/antisymtensor.h"
13 #include "util/ferm/etensor.h"
14 #include "util/ft/sftmom.h"
15 
16 namespace Chroma
17 {
18 
19  // Read parameters
20  void read(XMLReader& xml, const std::string& path, DerivMesonSeqSourceEnv::Params& param)
21  {
22  DerivMesonSeqSourceEnv::Params tmp(xml, path);
23  param = tmp;
24  }
25 
26  // Writer
27  void write(XMLWriter& xml, const std::string& path, const DerivMesonSeqSourceEnv::Params& param)
28  {
29  param.writeXML(xml, path);
30  }
31 
32 
33  // Read parameters
34  void read(XMLReader& xml, const std::string& path, DerivMesonSeqSourceEnv::ParamsDir& param)
35  {
36  DerivMesonSeqSourceEnv::ParamsDir tmp(xml, path);
37  param = tmp;
38  }
39 
40  // Writer
41  void write(XMLWriter& xml, const std::string& path, const DerivMesonSeqSourceEnv::ParamsDir& param)
42  {
43  param.writeXML(xml, path);
44  }
45 
46 
47 
48 
49  //---------------------------------------------------------------------------------
50  // Anonymous namespace
51  /*! \ingroup hadron */
52  namespace
53  {
54  //! Check only 1 prop passed
55  /*! \ingroup hadron */
56  void check1Args(const char* name, const multi1d<LatticePropagator>& quark_propagators)
57  {
58  if (quark_propagators.size() != 1)
59  {
60  QDPIO::cerr << __func__ << ": expect only 1 prop" << std::endl;
61  QDP_abort(1);
62  }
63  }
64 
65  //! Check only 2 props passed
66  /*! \ingroup hadron */
67  void check2Args(const char* name, const multi1d<LatticePropagator>& quark_propagators)
68  {
69  if (quark_propagators.size() != 2)
70  {
71  QDPIO::cerr << __func__ << ": expect only 2 prop" << std::endl;
72  QDP_abort(1);
73  }
74  }
75  }
76 
77 
78  //---------------------------------------------------------------------------------
79  //! Meson sequential sources
80  /*! \ingroup hadron */
81  namespace DerivMesonSeqSourceEnv
82  {
83  //! Anonymous namespace
84  namespace
85  {
86 
87  //-------------------- callback functions ---------------------------------------
88 
89  //! Construct a0-(pionxNabla_T1) sequential source
90  HadronSeqSource<LatticePropagator>* mesA0PionxNablaT1SeqSrc(XMLReader& xml_in,
91  const std::string& path)
92  {
93  return new MesA0PionxNablaT1SeqSrc(ParamsDir(xml_in, path));
94  }
95 
96  //! Construct a0-(a0xNabla_T1) sequential source
97  HadronSeqSource<LatticePropagator>* mesA0A0xNablaT1SeqSrc(XMLReader& xml_in,
98  const std::string& path)
99  {
100  return new MesA0A0xNablaT1SeqSrc(ParamsDir(xml_in, path));
101  }
102 
103  //! Construct a0-(a0_2xNabla_T1) sequential source
104  HadronSeqSource<LatticePropagator>* mesA0A02xNablaT1SeqSrc(XMLReader& xml_in,
105  const std::string& path)
106  {
107  return new MesA0A02xNablaT1SeqSrc(ParamsDir(xml_in, path));
108  }
109 
110  //! Construct a0-(pion_2xNabla_T1) sequential source
111  HadronSeqSource<LatticePropagator>* mesA0Pion2xNablaT1SeqSrc(XMLReader& xml_in,
112  const std::string& path)
113  {
114  return new MesA0Pion2xNablaT1SeqSrc(ParamsDir(xml_in, path));
115  }
116 
117  //! Construct a0-(rhoxNabla_A1) sequential source
118  HadronSeqSource<LatticePropagator>* mesA0RhoxNablaA1SeqSrc(XMLReader& xml_in,
119  const std::string& path)
120  {
121  return new MesA0RhoxNablaA1SeqSrc(Params(xml_in, path));
122  }
123 
124  //! Construct a0-(rhoxNabla_T1) sequential source
125  HadronSeqSource<LatticePropagator>* mesA0RhoxNablaT1SeqSrc(XMLReader& xml_in,
126  const std::string& path)
127  {
128  return new MesA0RhoxNablaT1SeqSrc(ParamsDir(xml_in, path));
129  }
130 
131  //! Construct a0-(rhoxNabla_T2) sequential source
132  HadronSeqSource<LatticePropagator>* mesA0RhoxNablaT2SeqSrc(XMLReader& xml_in,
133  const std::string& path)
134  {
135  return new MesA0RhoxNablaT2SeqSrc(ParamsDir(xml_in, path));
136  }
137 
138  //! Construct a0-(rhoxNabla_E) sequential source
139  HadronSeqSource<LatticePropagator>* mesA0RhoxNablaESeqSrc(XMLReader& xml_in,
140  const std::string& path)
141  {
142  return new MesA0RhoxNablaESeqSrc(ParamsDir(xml_in, path));
143  }
144 
145  //! Construct a0-(rho_2xNabla_A1) sequential source
146  HadronSeqSource<LatticePropagator>* mesA0Rho2xNablaA1SeqSrc(XMLReader& xml_in,
147  const std::string& path)
148  {
149  return new MesA0Rho2xNablaA1SeqSrc(Params(xml_in, path));
150  }
151 
152  //! Construct a0-(rho_2xNabla_T1) sequential source
153  HadronSeqSource<LatticePropagator>* mesA0Rho2xNablaT1SeqSrc(XMLReader& xml_in,
154  const std::string& path)
155  {
156  return new MesA0Rho2xNablaT1SeqSrc(ParamsDir(xml_in, path));
157  }
158 
159  //! Construct a0-(rho_2xNabla_T2) sequential source
160  HadronSeqSource<LatticePropagator>* mesA0Rho2xNablaT2SeqSrc(XMLReader& xml_in,
161  const std::string& path)
162  {
163  return new MesA0Rho2xNablaT2SeqSrc(ParamsDir(xml_in, path));
164  }
165 
166  //! Construct a0-(rho_2xNabla_E) sequential source
167  HadronSeqSource<LatticePropagator>* mesA0Rho2xNablaESeqSrc(XMLReader& xml_in,
168  const std::string& path)
169  {
170  return new MesA0Rho2xNablaESeqSrc(ParamsDir(xml_in, path));
171  }
172 
173  //! Construct a0-(a1xNabla_A1) sequential source
174  HadronSeqSource<LatticePropagator>* mesA0A1xNablaA1SeqSrc(XMLReader& xml_in,
175  const std::string& path)
176  {
177  return new MesA0A1xNablaA1SeqSrc(Params(xml_in, path));
178  }
179 
180  //! Construct a0-(a1xNabla_T1) sequential source
181  HadronSeqSource<LatticePropagator>* mesA0A1xNablaT1SeqSrc(XMLReader& xml_in,
182  const std::string& path)
183  {
184  return new MesA0A1xNablaT1SeqSrc(ParamsDir(xml_in, path));
185  }
186 
187  //! Construct a0-(a1xNabla_T2) sequential source
188  HadronSeqSource<LatticePropagator>* mesA0A1xNablaT2SeqSrc(XMLReader& xml_in,
189  const std::string& path)
190  {
191  return new MesA0A1xNablaT2SeqSrc(ParamsDir(xml_in, path));
192  }
193 
194  //! Construct a0-(a1xNabla_E) sequential source
195  HadronSeqSource<LatticePropagator>* mesA0A1xNablaESeqSrc(XMLReader& xml_in,
196  const std::string& path)
197  {
198  return new MesA0A1xNablaESeqSrc(ParamsDir(xml_in, path));
199  }
200 
201  //! Construct a0-(b1xNabla_A1) sequential source
202  HadronSeqSource<LatticePropagator>* mesA0B1xNablaA1SeqSrc(XMLReader& xml_in,
203  const std::string& path)
204  {
205  return new MesA0B1xNablaA1SeqSrc(Params(xml_in, path));
206  }
207 
208  //! Construct a0-(b1xNabla_T1) sequential source
209  HadronSeqSource<LatticePropagator>* mesA0B1xNablaT1SeqSrc(XMLReader& xml_in,
210  const std::string& path)
211  {
212  return new MesA0B1xNablaT1SeqSrc(ParamsDir(xml_in, path));
213  }
214 
215  //! Construct a0-(b1xNabla_T2) sequential source
216  HadronSeqSource<LatticePropagator>* mesA0B1xNablaT2SeqSrc(XMLReader& xml_in,
217  const std::string& path)
218  {
219  return new MesA0B1xNablaT2SeqSrc(ParamsDir(xml_in, path));
220  }
221 
222  //! Construct a0-(b1xNabla_E) sequential source
223  HadronSeqSource<LatticePropagator>* mesA0B1xNablaESeqSrc(XMLReader& xml_in,
224  const std::string& path)
225  {
226  return new MesA0B1xNablaESeqSrc(ParamsDir(xml_in, path));
227  }
228 
229  //! Construct a0-(pionxD_T2) sequential source
230  HadronSeqSource<LatticePropagator>* mesA0PionxDT2SeqSrc(XMLReader& xml_in,
231  const std::string& path)
232  {
233  return new MesA0PionxDT2SeqSrc(ParamsDir(xml_in, path));
234  }
235 
236  //! Construct a0-(a0xD_T2) sequential source
237  HadronSeqSource<LatticePropagator>* mesA0A0xDT2SeqSrc(XMLReader& xml_in,
238  const std::string& path)
239  {
240  return new MesA0A0xDT2SeqSrc(ParamsDir(xml_in, path));
241  }
242 
243  //! Construct a0-(a0_2xD_T2) sequential source
244  HadronSeqSource<LatticePropagator>* mesA0A02xDT2SeqSrc(XMLReader& xml_in,
245  const std::string& path)
246  {
247  return new MesA0A02xDT2SeqSrc(ParamsDir(xml_in, path));
248  }
249 
250  //! Construct a0-(pion_2xD_T2) sequential source
251  HadronSeqSource<LatticePropagator>* mesA0Pion2xDT2SeqSrc(XMLReader& xml_in,
252  const std::string& path)
253  {
254  return new MesA0Pion2xDT2SeqSrc(ParamsDir(xml_in, path));
255  }
256 
257  //! Construct a0-(rhoxD_A2) sequential source
258  HadronSeqSource<LatticePropagator>* mesA0RhoxDA2SeqSrc(XMLReader& xml_in,
259  const std::string& path)
260  {
261  return new MesA0RhoxDA2SeqSrc(Params(xml_in, path));
262  }
263 
264  //! Construct a0-(rhoxD_T1) sequential source
265  HadronSeqSource<LatticePropagator>* mesA0RhoxDT1SeqSrc(XMLReader& xml_in,
266  const std::string& path)
267  {
268  return new MesA0RhoxDT1SeqSrc(ParamsDir(xml_in, path));
269  }
270 
271  //! Construct a0-(rhoxD_T2) sequential source
272  HadronSeqSource<LatticePropagator>* mesA0RhoxDT2SeqSrc(XMLReader& xml_in,
273  const std::string& path)
274  {
275  return new MesA0RhoxDT2SeqSrc(ParamsDir(xml_in, path));
276  }
277 
278  //! Construct a0-(rhoxD_E) sequential source
279  HadronSeqSource<LatticePropagator>* mesA0RhoxDESeqSrc(XMLReader& xml_in,
280  const std::string& path)
281  {
282  return new MesA0RhoxDESeqSrc(ParamsDir(xml_in, path));
283  }
284 
285  //! Construct a0-(rho_2xD_A2) sequential source
286  HadronSeqSource<LatticePropagator>* mesA0Rho2xDA2SeqSrc(XMLReader& xml_in,
287  const std::string& path)
288  {
289  return new MesA0Rho2xDA2SeqSrc(Params(xml_in, path));
290  }
291 
292  //! Construct a0-(rho_2xD_T1) sequential source
293  HadronSeqSource<LatticePropagator>* mesA0Rho2xDT1SeqSrc(XMLReader& xml_in,
294  const std::string& path)
295  {
296  return new MesA0Rho2xDT1SeqSrc(ParamsDir(xml_in, path));
297  }
298 
299  //! Construct a0-(rho_2xD_T2) sequential source
300  HadronSeqSource<LatticePropagator>* mesA0Rho2xDT2SeqSrc(XMLReader& xml_in,
301  const std::string& path)
302  {
303  return new MesA0Rho2xDT2SeqSrc(ParamsDir(xml_in, path));
304  }
305 
306  //! Construct a0-(rho_2xD_E) sequential source
307  HadronSeqSource<LatticePropagator>* mesA0Rho2xDESeqSrc(XMLReader& xml_in,
308  const std::string& path)
309  {
310  return new MesA0Rho2xDESeqSrc(ParamsDir(xml_in, path));
311  }
312 
313  //! Construct a0-(a1xD_A2) sequential source
314  HadronSeqSource<LatticePropagator>* mesA0A1xDA2SeqSrc(XMLReader& xml_in,
315  const std::string& path)
316  {
317  return new MesA0A1xDA2SeqSrc(Params(xml_in, path));
318  }
319 
320  //! Construct a0-(a1xD_T1) sequential source
321  HadronSeqSource<LatticePropagator>* mesA0A1xDT1SeqSrc(XMLReader& xml_in,
322  const std::string& path)
323  {
324  return new MesA0A1xDT1SeqSrc(ParamsDir(xml_in, path));
325  }
326 
327  //! Construct a0-(a1xD_T2) sequential source
328  HadronSeqSource<LatticePropagator>* mesA0A1xDT2SeqSrc(XMLReader& xml_in,
329  const std::string& path)
330  {
331  return new MesA0A1xDT2SeqSrc(ParamsDir(xml_in, path));
332  }
333 
334  //! Construct a0-(a1xD_E) sequential source
335  HadronSeqSource<LatticePropagator>* mesA0A1xDESeqSrc(XMLReader& xml_in,
336  const std::string& path)
337  {
338  return new MesA0A1xDESeqSrc(ParamsDir(xml_in, path));
339  }
340 
341  //! Construct a0-(b1xD_A2) sequential source
342  HadronSeqSource<LatticePropagator>* mesA0B1xDA2SeqSrc(XMLReader& xml_in,
343  const std::string& path)
344  {
345  return new MesA0B1xDA2SeqSrc(Params(xml_in, path));
346  }
347 
348  //! Construct a0-(b1xD_T1) sequential source
349  HadronSeqSource<LatticePropagator>* mesA0B1xDT1SeqSrc(XMLReader& xml_in,
350  const std::string& path)
351  {
352  return new MesA0B1xDT1SeqSrc(ParamsDir(xml_in, path));
353  }
354 
355  //! Construct a0-(b1xD_T2) sequential source
356  HadronSeqSource<LatticePropagator>* mesA0B1xDT2SeqSrc(XMLReader& xml_in,
357  const std::string& path)
358  {
359  return new MesA0B1xDT2SeqSrc(ParamsDir(xml_in, path));
360  }
361 
362  //! Construct a0-(b1xD_E) sequential source
363  HadronSeqSource<LatticePropagator>* mesA0B1xDESeqSrc(XMLReader& xml_in,
364  const std::string& path)
365  {
366  return new MesA0B1xDESeqSrc(ParamsDir(xml_in, path));
367  }
368 
369  //! Construct a0-(pionxB_T1) sequential source
370  HadronSeqSource<LatticePropagator>* mesA0PionxBT1SeqSrc(XMLReader& xml_in,
371  const std::string& path)
372  {
373  return new MesA0PionxBT1SeqSrc(ParamsDir(xml_in, path));
374  }
375 
376  //! Construct a0-(a0xB_T1) sequential source
377  HadronSeqSource<LatticePropagator>* mesA0A0xBT1SeqSrc(XMLReader& xml_in,
378  const std::string& path)
379  {
380  return new MesA0A0xBT1SeqSrc(ParamsDir(xml_in, path));
381  }
382 
383  //! Construct a0-(a0_2xB_T1) sequential source
384  HadronSeqSource<LatticePropagator>* mesA0A02xBT1SeqSrc(XMLReader& xml_in,
385  const std::string& path)
386  {
387  return new MesA0A02xBT1SeqSrc(ParamsDir(xml_in, path));
388  }
389 
390  //! Construct a0-(pion_2xB_T1) sequential source
391  HadronSeqSource<LatticePropagator>* mesA0Pion2xBT1SeqSrc(XMLReader& xml_in,
392  const std::string& path)
393  {
394  return new MesA0Pion2xBT1SeqSrc(ParamsDir(xml_in, path));
395  }
396 
397  //! Construct a0-(rhoxB_A1) sequential source
398  HadronSeqSource<LatticePropagator>* mesA0RhoxBA1SeqSrc(XMLReader& xml_in,
399  const std::string& path)
400  {
401  return new MesA0RhoxBA1SeqSrc(Params(xml_in, path));
402  }
403 
404  //! Construct a0-(rhoxB_T1) sequential source
405  HadronSeqSource<LatticePropagator>* mesA0RhoxBT1SeqSrc(XMLReader& xml_in,
406  const std::string& path)
407  {
408  return new MesA0RhoxBT1SeqSrc(ParamsDir(xml_in, path));
409  }
410 
411  //! Construct a0-(rhoxB_T2) sequential source
412  HadronSeqSource<LatticePropagator>* mesA0RhoxBT2SeqSrc(XMLReader& xml_in,
413  const std::string& path)
414  {
415  return new MesA0RhoxBT2SeqSrc(ParamsDir(xml_in, path));
416  }
417 
418  //! Construct a0-(rhoxB_E) sequential source
419  HadronSeqSource<LatticePropagator>* mesA0RhoxBESeqSrc(XMLReader& xml_in,
420  const std::string& path)
421  {
422  return new MesA0RhoxBESeqSrc(ParamsDir(xml_in, path));
423  }
424 
425  //! Construct a0-(rho_2xB_A1) sequential source
426  HadronSeqSource<LatticePropagator>* mesA0Rho2xBA1SeqSrc(XMLReader& xml_in,
427  const std::string& path)
428  {
429  return new MesA0Rho2xBA1SeqSrc(Params(xml_in, path));
430  }
431 
432  //! Construct a0-(rho_2xB_T1) sequential source
433  HadronSeqSource<LatticePropagator>* mesA0Rho2xBT1SeqSrc(XMLReader& xml_in,
434  const std::string& path)
435  {
436  return new MesA0Rho2xBT1SeqSrc(ParamsDir(xml_in, path));
437  }
438 
439  //! Construct a0-(rho_2xB_T2) sequential source
440  HadronSeqSource<LatticePropagator>* mesA0Rho2xBT2SeqSrc(XMLReader& xml_in,
441  const std::string& path)
442  {
443  return new MesA0Rho2xBT2SeqSrc(ParamsDir(xml_in, path));
444  }
445 
446  //! Construct a0-(rho_2xB_E) sequential source
447  HadronSeqSource<LatticePropagator>* mesA0Rho2xBESeqSrc(XMLReader& xml_in,
448  const std::string& path)
449  {
450  return new MesA0Rho2xBESeqSrc(ParamsDir(xml_in, path));
451  }
452 
453  //! Construct a0-(a1xB_A1) sequential source
454  HadronSeqSource<LatticePropagator>* mesA0A1xBA1SeqSrc(XMLReader& xml_in,
455  const std::string& path)
456  {
457  return new MesA0A1xBA1SeqSrc(Params(xml_in, path));
458  }
459 
460  //! Construct a0-(a1xB_T1) sequential source
461  HadronSeqSource<LatticePropagator>* mesA0A1xBT1SeqSrc(XMLReader& xml_in,
462  const std::string& path)
463  {
464  return new MesA0A1xBT1SeqSrc(ParamsDir(xml_in, path));
465  }
466 
467  //! Construct a0-(a1xB_T2) sequential source
468  HadronSeqSource<LatticePropagator>* mesA0A1xBT2SeqSrc(XMLReader& xml_in,
469  const std::string& path)
470  {
471  return new MesA0A1xBT2SeqSrc(ParamsDir(xml_in, path));
472  }
473 
474  //! Construct a0-(a1xB_E) sequential source
475  HadronSeqSource<LatticePropagator>* mesA0A1xBESeqSrc(XMLReader& xml_in,
476  const std::string& path)
477  {
478  return new MesA0A1xBESeqSrc(ParamsDir(xml_in, path));
479  }
480 
481  //! Construct a0-(b1xB_A1) sequential source
482  HadronSeqSource<LatticePropagator>* mesA0B1xBA1SeqSrc(XMLReader& xml_in,
483  const std::string& path)
484  {
485  return new MesA0B1xBA1SeqSrc(Params(xml_in, path));
486  }
487 
488  //! Construct a0-(b1xB_T1) sequential source
489  HadronSeqSource<LatticePropagator>* mesA0B1xBT1SeqSrc(XMLReader& xml_in,
490  const std::string& path)
491  {
492  return new MesA0B1xBT1SeqSrc(ParamsDir(xml_in, path));
493  }
494 
495  //! Construct a0-(b1xB_T2) sequential source
496  HadronSeqSource<LatticePropagator>* mesA0B1xBT2SeqSrc(XMLReader& xml_in,
497  const std::string& path)
498  {
499  return new MesA0B1xBT2SeqSrc(ParamsDir(xml_in, path));
500  }
501 
502  //! Construct a0-(b1xB_E) sequential source
503  HadronSeqSource<LatticePropagator>* mesA0B1xBESeqSrc(XMLReader& xml_in,
504  const std::string& path)
505  {
506  return new MesA0B1xBESeqSrc(ParamsDir(xml_in, path));
507  }
508 
509  } // end anonymous namespace
510 
511 
512  //---------------------------------------------------------------------------------
513  //! Initialize
514  Params::Params()
515  {
516  deriv_length = 0;
517  j_decay = -1;
518  t_sink = -1;
519  sink_mom.resize(Nd-1);
520  sink_mom = 0;
521  }
522 
523  //! Read parameters
524  Params::Params(XMLReader& xml, const std::string& path)
525  {
526  XMLReader paramtop(xml, path);
527 
528  int version;
529  read(paramtop, "version", version);
530 
531  switch (version)
532  {
533  case 1:
534  break;
535 
536  default:
537  QDPIO::cerr << __func__ << ": parameter version " << version
538  << " unsupported." << std::endl;
539  QDP_abort(1);
540  }
541 
542  read(paramtop, "deriv_length", deriv_length);
543  read(paramtop, "j_decay", j_decay);
544  read(paramtop, "t_sink", t_sink);
545  read(paramtop, "sink_mom", sink_mom);
546  }
547 
548  // Writer
549  void Params::writeXML(XMLWriter& xml, const std::string& path) const
550  {
551  push(xml, path);
552 
553  int version = 1;
554  write(xml, "version", version);
555 
556  write(xml, "deriv_length", deriv_length);
557  write(xml, "j_decay", j_decay);
558  write(xml, "t_sink", t_sink);
559  write(xml, "sink_mom", sink_mom);
560  pop(xml);
561  }
562 
563 
564  //! Initialize
565  ParamsDir::ParamsDir()
566  {
567  deriv_dir = -1;
568  deriv_length = 0;
569  j_decay = -1;
570  t_sink = -1;
571  sink_mom.resize(Nd-1);
572  sink_mom = 0;
573  }
574 
575 
576  //! Read parameters
577  ParamsDir::ParamsDir(XMLReader& xml, const std::string& path)
578  {
579  XMLReader paramtop(xml, path);
580 
581  int version;
582  read(paramtop, "version", version);
583 
584  switch (version)
585  {
586  case 1:
587  break;
588 
589  default:
590  QDPIO::cerr << __func__ << ": parameter version " << version
591  << " unsupported." << std::endl;
592  QDP_abort(1);
593  }
594 
595  read(paramtop, "deriv_dir", deriv_dir);
596  read(paramtop, "deriv_length", deriv_length);
597  read(paramtop, "j_decay", j_decay);
598  read(paramtop, "t_sink", t_sink);
599  read(paramtop, "sink_mom", sink_mom);
600  }
601 
602 
603  // Writer
604  void ParamsDir::writeXML(XMLWriter& xml, const std::string& path) const
605  {
606  push(xml, path);
607 
608  int version = 1;
609  write(xml, "version", version);
610 
611  write(xml, "deriv_dir", deriv_dir);
612  write(xml, "deriv_length", deriv_length);
613  write(xml, "j_decay", j_decay);
614  write(xml, "t_sink", t_sink);
615  write(xml, "sink_mom", sink_mom);
616  pop(xml);
617  }
618 
619 
620  //---------------------------------------------------------------------------------
621  //! Apply right nabla
622  LatticePropagator
623  DerivMesonSeqSourceBase::nabla(const LatticePropagator& F,
624  const multi1d<LatticeColorMatrix>& u,
625  int mu) const
626  {
627  return Chroma::rightNabla(F, u, mu, getDerivLength());
628  }
629 
630 
631  //! Apply right D
632  LatticePropagator
633  DerivMesonSeqSourceBase::D(const LatticePropagator& F,
634  const multi1d<LatticeColorMatrix>& u,
635  int mu) const
636  {
637  return Chroma::rightD(F, u, mu, getDerivLength());
638  }
639 
640 
641  //! Apply right nabla
642  LatticePropagator
643  DerivMesonSeqSourceBase::B(const LatticePropagator& F,
644  const multi1d<LatticeColorMatrix>& u,
645  int mu) const
646  {
647  return Chroma::rightB(F, u, mu, getDerivLength());
648  }
649 
650 
651  //---------------------------------------------------------------------------------
652  //! Apply left and right "nabla_i" onto the source
653  /*!
654  * \f$\nabla_\mu f(x) = U_\mu(x)f(x+\mu) - U_{-\mu}(x)f(x-\mu)\f$
655  *
656  * \return $\f \nabla_\mu Fx,0) = U_\mu(x) F(x+\mu) - U_{x-\mu}^\dag(x-\mu) F(x-\mu)\f$
657  */
658  LatticePropagator
659  DerivMesonSeqSourceBase::threePtNabla(const LatticePropagator& F,
660  const multi1d<LatticeColorMatrix>& u,
661  int mu) const
662  {
663  LatticeComplex ph = conj(phases());
664  return ph*nabla(F, u, mu) + nabla(ph*F, u, mu);
665  }
666 
667  //! Apply left and right "D_i" operator onto source
668  /*!
669  * \f$D_i = s_{ijk}\nabla_j\nabla_k\f$
670  *
671  * where \f$s_{ijk} = +1 \quad\forall i\ne j, j\ne k, i \ne k\f$
672  *
673  * \return $\f p*D_\mu F(x,0) + D_\mu (p*F(x,0)) + 2 \sum_{j,k}s_{ijk} \nabla_j (p*\nabla_k F(x,0))\f$
674  */
675  LatticePropagator
676  DerivMesonSeqSourceBase::threePtD(const LatticePropagator& F,
677  const multi1d<LatticeColorMatrix>& u,
678  int mu) const
679  {
680  LatticePropagator tmp = zero;
681  LatticeComplex ph = conj(phases());
682 
683  // Slow implementation - to speed up could compute once the \nabla_j deriv
684  for(int j=0; j < 3; ++j)
685  for(int k=0; k < 3; ++k)
686  {
687  if (symTensor3d(mu,j,k) != 0)
688  {
689  tmp += ph * nabla(nabla(F,u,j), u, k);
690  tmp += nabla(nabla(ph * F,u,j), u, k);
691  tmp += Real(2)*nabla(ph * nabla(F,u,j), u, k);
692  }
693  }
694 
695  return tmp;
696  }
697 
698 
699  //! Apply left and right "B_i" operator onto source
700  /*!
701  * \f$B_i = \epsilon_{ijk}\nabla_j\nabla_k\f$
702  *
703  * \return $\f -B_\mu F(x,0)\f$
704  */
705  LatticePropagator
706  DerivMesonSeqSourceBase::threePtB(const LatticePropagator& F,
707  const multi1d<LatticeColorMatrix>& u,
708  int mu) const
709  {
710  LatticePropagator tmp = zero;
711  LatticeComplex ph = conj(phases());
712 
713  // Slow implementation - to speed up could compute once the \nabla_j deriv
714  for(int j=0; j < 3; ++j)
715  for(int k=0; k < 3; ++k)
716  {
717  if (antiSymTensor3d(mu,j,k) != 0)
718  tmp -= Real(antiSymTensor3d(mu,j,k)) * nabla(nabla(ph*F,u,j), u, k);
719  }
720 
721  return tmp;
722  }
723 
724 
725  //---------------------------------------------------------------------------------
726  //! Vector from a Nabla operator
727  multi1d<LatticePropagator>
728  DerivMesonSeqSourceBase::threePtNablaVector(const LatticePropagator& F,
729  const multi1d<LatticeColorMatrix>& u) const
730  {
731  multi1d<LatticePropagator> out(3);
732 
733  for(int k=0; k < 3; ++k)
734  out[k] = threePtNabla(F,u,k);
735 
736  return out;
737  }
738 
739 
740  //! Vector from a D operator
741  multi1d<LatticePropagator>
742  DerivMesonSeqSourceBase::threePtDVector(const LatticePropagator& F,
743  const multi1d<LatticeColorMatrix>& u) const
744  {
745  multi1d<LatticePropagator> out(3);
746 
747  for(int k=0; k < 3; ++k)
748  out[k] = threePtD(F,u,k);
749 
750  return out;
751  }
752 
753 
754  //! Vector from a B operator
755  multi1d<LatticePropagator>
756  DerivMesonSeqSourceBase::threePtBVector(const LatticePropagator& F,
757  const multi1d<LatticeColorMatrix>& u) const
758  {
759  multi1d<LatticePropagator> out(3);
760 
761  for(int k=0; k < 3; ++k)
762  out[k] = threePtB(F,u,k);
763 
764  return out;
765  }
766 
767 
768  //---------------------------------------------------------------------------------
769  // Apply left and right "nabla_i" onto the source
770  LatticeComplex
771  DerivMesonSeqSourceBase::twoPtNabla(const LatticePropagator& F,
772  const multi1d<LatticeColorMatrix>& u,
773  int mu, int g, int insertion) const
774  {
775  LatticePropagator drv = nabla(F,u,mu);
776  LatticeComplex corr_fn =
777  trace(gamma5Herm(drv) * Gamma(g) * F * Gamma(insertion))
778  - trace(gamma5Herm(F) * Gamma(g) * drv * Gamma(insertion));
779 
780  return corr_fn;
781  }
782 
783 
784  // Apply left and right "D_i" operator onto source
785  LatticeComplex
786  DerivMesonSeqSourceBase::twoPtD(const LatticePropagator& F,
787  const multi1d<LatticeColorMatrix>& u,
788  int mu, int g, int insertion) const
789  {
790  LatticePropagator ddd = D(F,u,mu);
791 
792  LatticeComplex corr_fn =
793  trace(gamma5Herm(ddd) * Gamma(g) * F * Gamma(insertion))
794  + trace(gamma5Herm(F) * Gamma(g) * ddd * Gamma(insertion));
795 
796  // Slow implementation - to speed up could compute once the \nabla_j deriv
797  for(int j=0; j < 3; ++j)
798  for(int k=0; k < 3; ++k)
799  {
800  if (symTensor3d(mu,j,k) != 0)
801  corr_fn -= Real(2)*trace(gamma5Herm(nabla(F,u,j)) * Gamma(g) *
802  nabla(F,u,k) * Gamma(insertion));
803  }
804 
805  return corr_fn;
806  }
807 
808 
809  // Apply left and right "B_i" operator onto source
810  LatticeComplex
811  DerivMesonSeqSourceBase::twoPtB(const LatticePropagator& F,
812  const multi1d<LatticeColorMatrix>& u,
813  int mu, int g, int insertion) const
814  {
815  return trace(gamma5Herm(F) * Gamma(g) * B(F,u,mu) * Gamma(insertion));
816  }
817 
818 
819  // Project onto the fixed sink-momentum and return the 2-pt at the sink
820  Complex
821  DerivMesonSeqSourceBase::momentumProject(const LatticeComplex& corr_fn) const
822  {
823  START_CODE();
824 
825  // Extract the sink at the appropriate momenta
826  SftMom sft(0, getTSrce(), getSinkMom(), false, getDecayDir());
827  multi2d<DComplex> hsum;
828  hsum = sft.sft(corr_fn);
829 
830  END_CODE();
831 
832  return hsum[0][getTSink()];
833  }
834 
835 
836  //---------------------------------------------------------------------------------
837  // All 3-pt seqsrc are variants on these basic objects
838  namespace
839  {
840  int G5 = Ns*Ns-1;
841 
842  //---------------------------------------------------------------------------------
843  //! a0xVector
844  /*! \return \f$V_i\f$ */
845  LatticePropagator a0xVector(const LatticePropagator& F)
846  {
847  return F;
848  }
849 
850 
851  //! pionxVector
852  /*! \return \f$gamma_5 V_i\f$ */
853  LatticePropagator pionxVector(const LatticePropagator& F)
854  {
855  return Gamma(G5) * F;
856  }
857 
858 
859  //! pion_2xVector
860  /*! \return \f$\gamma_4\gamma_5 V_i\f$ */
861  LatticePropagator pion_2xVector(const LatticePropagator& F)
862  {
863  return Gamma(1<<3) * (Gamma(G5) * F);
864  }
865 
866 
867  //! a0_2xVector
868  /*! \return \f$\gamma_4 V_i\f$ */
869  LatticePropagator a0_2xVector(const LatticePropagator& F)
870  {
871  return Gamma(1<<3) * F;
872  }
873 
874 
875  //---------------------------------------------------------------------------------
876  //! rhoxVector_sum
877  /*! \return \f$\gamma_i V_i\f$ */
878  LatticePropagator rhoxVector_sum(const multi1d<LatticePropagator>& F)
879  {
880  LatticePropagator fin = zero;
881 
882  for(int k=0; k < 3; ++k)
883  fin += Gamma(1 << k) * F[k];
884 
885  return fin;
886  }
887 
888 
889  //! rhoxVector_antisym
890  /*! \return \f$\epsilon_{ijk}\gamma_j V_k\f$ */
891  LatticePropagator rhoxVector_antisym(const multi1d<LatticePropagator>& F, int dir)
892  {
893  LatticePropagator fin = zero;
894 
895  for(int j=0; j < 3; ++j)
896  for(int k=0; k < 3; ++k)
897  {
898  int a = antiSymTensor3d(dir,j,k);
899  if (a != 0)
900  fin += Real(a) * (Gamma(1 << j) * F[k]);
901  }
902 
903  return fin;
904  }
905 
906 
907  //! rhoxVector_sym
908  /*! \return \f$s_{ijk}\gamma_j V_k\f$ */
909  LatticePropagator rhoxVector_sym(const multi1d<LatticePropagator>& F, int dir)
910  {
911  LatticePropagator fin = zero;
912 
913  for(int j=0; j < 3; ++j)
914  for(int k=0; k < 3; ++k)
915  {
916  int s = symTensor3d(dir,j,k);
917  if (s != 0)
918  fin += Real(s) * (Gamma(1 << j) * F[k]);
919  }
920 
921  return fin;
922  }
923 
924 
925  //! rhoxVector_E
926  /*! \return \f$Q_{\alpha jk}\gamma_j V_k\f$ */
927  LatticePropagator rhoxVector_E(const multi1d<LatticePropagator>& F, int dir)
928  {
929  LatticePropagator fin = zero;
930 
931  for(int j=0; j < 3; ++j)
932  for(int k=0; k < 3; ++k)
933  {
934  Real e = ETensor3d(dir,j,k);
935  if (toBool(e != 0.0))
936  fin += e * (Gamma(1 << j) * F[k]);
937  }
938 
939  return fin;
940  }
941 
942 
943  //---------------------------------------------------------------------------------
944  //! rho_2xVector_sum
945  /*! \return \f$\gamma_4\gamma_i V_i\f$ */
946  LatticePropagator rho_2xVector_sum(const multi1d<LatticePropagator>& F)
947  {
948  return Gamma(1<<3) * rhoxVector_sum(F);
949  }
950 
951 
952  //! rho_2xVector_antisym
953  /*! \return \f$\epsilon_{ijk}\gamma_4\gamma_j V_k\f$ */
954  LatticePropagator rho_2xVector_antisym(const multi1d<LatticePropagator>& F, int dir)
955  {
956  return Gamma(1<<3) * rhoxVector_antisym(F,dir);
957  }
958 
959 
960  //! rho_2xVector_sym
961  /*! \return \f$s_{ijk}\gamma_4\gamma_j V_k\f$ */
962  LatticePropagator rho_2xVector_sym(const multi1d<LatticePropagator>& F, int dir)
963  {
964  return Gamma(1<<3) * rhoxVector_sym(F,dir);
965  }
966 
967 
968  //! rho_2xVector_E
969  /*! \return \f$Q_{\alpha jk}\gamma_4\gamma_j V_k\f$ */
970  LatticePropagator rho_2xVector_E(const multi1d<LatticePropagator>& F, int dir)
971  {
972  return Gamma(1<<3) * rhoxVector_E(F,dir);
973  }
974 
975 
976  //---------------------------------------------------------------------------------
977  //! a1xVector_sum
978  /*! \return \f$\gamma_5\gamma_i V_i\f$ */
979  LatticePropagator a1xVector_sum(const multi1d<LatticePropagator>& F)
980  {
981  return Gamma(G5) * rhoxVector_sum(F);
982  }
983 
984 
985  //! rho_2xVector_antisym
986  /*! \return \f$\epsilon_{ijk}\gamma_5\gamma_j V_k\f$ */
987  LatticePropagator a1xVector_antisym(const multi1d<LatticePropagator>& F,
988  int dir)
989  {
990  return Gamma(G5) * rhoxVector_antisym(F,dir);
991  }
992 
993 
994  //! rho_2xVector_sym
995  /*! \return \f$s_{ijk}\gamma_5\gamma_j V_k\f$ */
996  LatticePropagator a1xVector_sym(const multi1d<LatticePropagator>& F,
997  int dir)
998  {
999  return Gamma(G5) * rhoxVector_sym(F,dir);
1000  }
1001 
1002 
1003  //! rho_2xVector_E
1004  /*! \return \f$Q_{\alpha jk}\gamma_5\gamma_j V_k\f$ */
1005  LatticePropagator a1xVector_E(const multi1d<LatticePropagator>& F,
1006  int dir)
1007  {
1008  return Gamma(G5) * rhoxVector_E(F,dir);
1009  }
1010 
1011 
1012  //---------------------------------------------------------------------------------
1013  //! b1xVector_sum
1014  /*! \return \f$\gamma_4\gamma_5\gamma_i V_i\f$ */
1015  LatticePropagator b1xVector_sum(const multi1d<LatticePropagator>& F)
1016  {
1017  return Gamma(1<<3) * (Gamma(G5) * rhoxVector_sum(F));
1018  }
1019 
1020 
1021  //! b1xVector_antisym
1022  /*! \return \f$\epsilon_{ijk}\gamma_4\gamma_5\gamma_j V_k\f$ */
1023  LatticePropagator b1xVector_antisym(const multi1d<LatticePropagator>& F,
1024  int dir)
1025  {
1026  return Gamma(1<<3) * (Gamma(G5) * rhoxVector_antisym(F,dir));
1027  }
1028 
1029 
1030  //! b1xVector_sym
1031  /*! \return \f$s_{ijk}\gamma_4\gamma_5\gamma_j V_k\f$ */
1032  LatticePropagator b1xVector_sym(const multi1d<LatticePropagator>& F,
1033  int dir)
1034  {
1035  return Gamma(1<<3) * (Gamma(G5) * rhoxVector_sym(F,dir));
1036  }
1037 
1038 
1039  //! b1xVector_E
1040  /*! \return \f$Q_{\alpha jk}\gamma_4\gamma_5\gamma_j V_k\f$ */
1041  LatticePropagator b1xVector_E(const multi1d<LatticePropagator>& F,
1042  int dir)
1043  {
1044  return Gamma(1<<3) * (Gamma(G5) * rhoxVector_E(F,dir));
1045  }
1046 
1047 
1048  } // namespace anonymous
1049 
1050 
1051  //---------------------------------------------------------------------------------
1052  // Construct a0-(a0xNabla_T1) sequential source
1053  // See corresponding .h file for doxygen comments
1054  LatticePropagator
1055  MesA0A0xNablaT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1056  const multi1d<ForwardProp_t>& forward_headers,
1057  const multi1d<LatticePropagator>& quark_propagators)
1058  {
1059  check1Args("MesA0A0xNablaT1SeqSrc", quark_propagators);
1060  setTSrce(forward_headers);
1061 
1062  // \f$\Gamma_f \equiv \nabla_i\f$
1063  return project(a0xVector(threePtNabla(quark_propagators[0],u,getDerivDir())));
1064  }
1065 
1066 
1067  // Compute the 2-pt at the sink
1068  Complex
1069  MesA0A0xNablaT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1070  const multi1d<ForwardProp_t>& forward_headers,
1071  const multi1d<LatticePropagator>& quark_propagators,
1072  int insertion)
1073  {
1074  START_CODE();
1075 
1076  check1Args("MesA0A0xNablaT1SeqSrc", quark_propagators);
1077  setTSrce(forward_headers);
1078 
1079  LatticePropagator tmp = quark_propagators[0];
1080 
1081  // \f$\Gamma_f \equiv \nabla_i\f$
1082  LatticeComplex corr_fn = twoPtNabla(tmp,u,getDerivDir(),0,insertion);
1083 
1084  END_CODE();
1085 
1086  return momentumProject(corr_fn);
1087  }
1088 
1089 
1090  // Construct a0-(pionxNabla_T1) sequential source
1091  // See corresponding .h file for doxygen comments
1092  LatticePropagator
1093  MesA0PionxNablaT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1094  const multi1d<ForwardProp_t>& forward_headers,
1095  const multi1d<LatticePropagator>& quark_propagators)
1096  {
1097  check1Args("MesA0PionxNablaT1SeqSrc", quark_propagators);
1098  setTSrce(forward_headers);
1099 
1100  // \f$\Gamma_f \equiv \gamma_5\nabla_i\f$
1101  return project(pionxVector(threePtNabla(quark_propagators[0],u,getDerivDir())));
1102  }
1103 
1104 
1105  // Compute the 2-pt at the sink
1106  Complex
1107  MesA0PionxNablaT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1108  const multi1d<ForwardProp_t>& forward_headers,
1109  const multi1d<LatticePropagator>& quark_propagators,
1110  int insertion)
1111  {
1112  START_CODE();
1113 
1114  check1Args("MesA0PionxNablaT1SeqSrc", quark_propagators);
1115  setTSrce(forward_headers);
1116 
1117  LatticePropagator fin;
1118  const int G5 = Ns*Ns-1;
1119 
1120  LatticePropagator tmp = quark_propagators[0];
1121 
1122  // \f$\Gamma_f \equiv \gamma_5\nabla_i\f$
1123  LatticeComplex corr_fn = twoPtNabla(tmp,u,getDerivDir(),G5,insertion);
1124 
1125  END_CODE();
1126 
1127  return momentumProject(corr_fn);
1128  }
1129 
1130 
1131  // Construct a0-(pion_2xNabla_T1) sequential source
1132  // See corresponding .h file for doxygen comments
1133  LatticePropagator
1134  MesA0Pion2xNablaT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1135  const multi1d<ForwardProp_t>& forward_headers,
1136  const multi1d<LatticePropagator>& quark_propagators)
1137  {
1138  check1Args("MesA0Pion2xNablaT1SeqSrc", quark_propagators);
1139  setTSrce(forward_headers);
1140 
1141  // \f$\Gamma_f \equiv \gamma_4 \gamma_5 \nabla_i\f$
1142  return project(pion_2xVector(threePtNabla(quark_propagators[0],u,getDerivDir())));
1143  }
1144 
1145 
1146  // Compute the 2-pt at the sink
1147  Complex
1148  MesA0Pion2xNablaT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1149  const multi1d<ForwardProp_t>& forward_headers,
1150  const multi1d<LatticePropagator>& quark_propagators,
1151  int insertion)
1152  {
1153  START_CODE();
1154 
1155  LatticeComplex corr_fn;
1156  const int G5 = Ns*Ns-1;
1157 
1158  check1Args("MesA0Pion2xNablaT1SeqSrc", quark_propagators);
1159  setTSrce(forward_headers);
1160 
1161  LatticePropagator tmp = quark_propagators[0];
1162 
1163  // \f$\Gamma_f \equiv \gamma_4 \gamma_5 \nabla_i\f$
1164  corr_fn = gammaSgn(1<<3,G5) * twoPtNabla(tmp,u,getDerivDir(), (1<<3)^G5, insertion);
1165 
1166  END_CODE();
1167 
1168  return momentumProject(corr_fn);
1169  }
1170 
1171 
1172  // Construct a0-(a0_2xNabla_T1) sequential source
1173  // See corresponding .h file for doxygen comments
1174  LatticePropagator
1175  MesA0A02xNablaT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1176  const multi1d<ForwardProp_t>& forward_headers,
1177  const multi1d<LatticePropagator>& quark_propagators)
1178  {
1179  check1Args("MesA0A02xNablaT1SeqSrc", quark_propagators);
1180  setTSrce(forward_headers);
1181 
1182  // \f$\Gamma_f \equiv \gamma_4 \nabla_i\f$
1183  return project(-a0_2xVector(threePtNabla(quark_propagators[0],u,getDerivDir())));
1184  }
1185 
1186 
1187  // Compute the 2-pt at the sink
1188  Complex
1189  MesA0A02xNablaT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1190  const multi1d<ForwardProp_t>& forward_headers,
1191  const multi1d<LatticePropagator>& quark_propagators,
1192  int insertion)
1193  {
1194  START_CODE();
1195 
1196  check1Args("MesA0A02xNablaT1SeqSrc", quark_propagators);
1197  setTSrce(forward_headers);
1198 
1199  LatticePropagator tmp = quark_propagators[0];
1200 
1201  // \f$\Gamma_f \equiv \gamma_4 \nabla_i\f$
1202  LatticeComplex corr_fn = twoPtNabla(tmp,u,getDerivDir(), 1<<3, insertion);
1203 
1204  END_CODE();
1205 
1206  return momentumProject(corr_fn);
1207  }
1208 
1209 
1210  //---------------------------------------------------------------------------------
1211  // Construct a0-(rhoxNabla_A1) sequential source
1212  LatticePropagator
1213  MesA0RhoxNablaA1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1214  const multi1d<ForwardProp_t>& forward_headers,
1215  const multi1d<LatticePropagator>& quark_propagators)
1216  {
1217  check1Args("MesA0RhoxNablaA1SeqSrc", quark_propagators);
1218  setTSrce(forward_headers);
1219 
1220  // \f$\Gamma_f \equiv \gamma_i\nabla_i\f$
1221  return project(-rhoxVector_sum(threePtNablaVector(quark_propagators[0],u)));
1222  }
1223 
1224 
1225  // Compute the 2-pt at the sink
1226  Complex
1227  MesA0RhoxNablaA1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1228  const multi1d<ForwardProp_t>& forward_headers,
1229  const multi1d<LatticePropagator>& quark_propagators,
1230  int insertion)
1231  {
1232  START_CODE();
1233 
1234  LatticeComplex corr_fn = zero;
1235 
1236  check1Args("MesA0RhoxNablaA1SeqSrc", quark_propagators);
1237  setTSrce(forward_headers);
1238 
1239  LatticePropagator tmp = quark_propagators[0];
1240 
1241  // \f$\Gamma_f \equiv \gamma_i\nabla_i\f$
1242  for(int k=0; k < 3; ++k)
1243  corr_fn += twoPtNabla(tmp,u,k, 1<<k, insertion);
1244 
1245  END_CODE();
1246 
1247  return momentumProject(corr_fn);
1248  }
1249 
1250 
1251  // Construct a0-(rhoxNabla_T1) sequential source
1252  LatticePropagator
1253  MesA0RhoxNablaT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1254  const multi1d<ForwardProp_t>& forward_headers,
1255  const multi1d<LatticePropagator>& quark_propagators)
1256  {
1257  check1Args("MesA0RhoxNablaT1SeqSrc", quark_propagators);
1258  setTSrce(forward_headers);
1259 
1260  // \f$\Gamma_f \equiv \epsilon_{ijk}\gamma_j \nabla_k\f$
1261  return project(-rhoxVector_antisym(threePtNablaVector(quark_propagators[0],u), getDerivDir()));
1262  }
1263 
1264 
1265  // Compute the 2-pt at the sink
1266  Complex
1267  MesA0RhoxNablaT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1268  const multi1d<ForwardProp_t>& forward_headers,
1269  const multi1d<LatticePropagator>& quark_propagators,
1270  int insertion)
1271  {
1272  START_CODE();
1273 
1274  LatticeComplex corr_fn = zero;
1275 
1276  check1Args("MesA0RhoxNablaT1SeqSrc", quark_propagators);
1277  setTSrce(forward_headers);
1278 
1279  LatticePropagator tmp = quark_propagators[0];
1280 
1281  // \f$\Gamma_f \equiv \epsilon_{ijk}\gamma_j \nabla_k\f$
1282  for(int j=0; j < 3; ++j)
1283  for(int k=0; k < 3; ++k)
1284  {
1285  int a = antiSymTensor3d(getDerivDir(),j,k);
1286  if (a != 0)
1287  corr_fn += Real(a) * twoPtNabla(tmp,u,k, 1<<j, insertion);
1288  }
1289 
1290  END_CODE();
1291 
1292  return momentumProject(corr_fn);
1293  }
1294 
1295 
1296  // Construct a0-(rhoxNabla_T2) sequential source
1297  LatticePropagator
1298  MesA0RhoxNablaT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1299  const multi1d<ForwardProp_t>& forward_headers,
1300  const multi1d<LatticePropagator>& quark_propagators)
1301  {
1302  check1Args("MesA0RhoxNablaT2SeqSrc", quark_propagators);
1303  setTSrce(forward_headers);
1304 
1305  // \f$\Gamma_f \equiv s_{ijk}\gamma_j \nabla_k\f$
1306  return project(-rhoxVector_sym(threePtNablaVector(quark_propagators[0],u), getDerivDir()));
1307  }
1308 
1309 
1310  // Compute the 2-pt at the sink
1311  Complex
1312  MesA0RhoxNablaT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1313  const multi1d<ForwardProp_t>& forward_headers,
1314  const multi1d<LatticePropagator>& quark_propagators,
1315  int insertion)
1316  {
1317  START_CODE();
1318 
1319  LatticeComplex corr_fn = zero;
1320 
1321  check1Args("MesA0RhoxNablaT2SeqSrc", quark_propagators);
1322  setTSrce(forward_headers);
1323 
1324  LatticePropagator tmp = quark_propagators[0];
1325 
1326  // \f$\Gamma_f \equiv s_{ijk}\gamma_j \nabla_k\f$
1327  for(int j=0; j < 3; ++j)
1328  for(int k=0; k < 3; ++k)
1329  {
1330  int s = symTensor3d(getDerivDir(),j,k);
1331  if (s != 0)
1332  corr_fn += Real(s) * twoPtNabla(tmp,u,k, 1<<j, insertion);
1333  }
1334 
1335  END_CODE();
1336 
1337  return momentumProject(corr_fn);
1338  }
1339 
1340 
1341  // Construct a0-(rhoxNabla_E) sequential source
1342  LatticePropagator
1343  MesA0RhoxNablaESeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1344  const multi1d<ForwardProp_t>& forward_headers,
1345  const multi1d<LatticePropagator>& quark_propagators)
1346  {
1347  check1Args("MesA0RhoxNablaESeqSrc", quark_propagators);
1348  setTSrce(forward_headers);
1349 
1350  // \f$\Gamma_f \equiv Q_{\alpha jk}\gamma_j \nabla_k\f$
1351  return project(-rhoxVector_E(threePtNablaVector(quark_propagators[0],u), getDerivDir()));
1352  }
1353 
1354 
1355  // Compute the 2-pt at the sink
1356  Complex
1357  MesA0RhoxNablaESeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1358  const multi1d<ForwardProp_t>& forward_headers,
1359  const multi1d<LatticePropagator>& quark_propagators,
1360  int insertion)
1361  {
1362  START_CODE();
1363 
1364  LatticeComplex corr_fn = zero;
1365 
1366  check1Args("MesA0RhoxNablaESeqSrc", quark_propagators);
1367  setTSrce(forward_headers);
1368 
1369  LatticePropagator tmp = quark_propagators[0];
1370 
1371  // \f$\Gamma_f \equiv Q_{\alpha jk}\gamma_j \nabla_k\f$
1372  for(int j=0; j < 3; ++j)
1373  for(int k=0; k < 3; ++k)
1374  {
1375  Real e = ETensor3d(getDerivDir(),j,k);
1376  if (toBool(e != 0.0))
1377  corr_fn += e * twoPtNabla(tmp,u,k, 1<<j, insertion);
1378  }
1379 
1380  END_CODE();
1381 
1382  return momentumProject(corr_fn);
1383  }
1384 
1385 
1386  //---------------------------------------------------------------------------------
1387  // Construct a0-(rho_2xNabla_A1) sequential source
1388  LatticePropagator
1389  MesA0Rho2xNablaA1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1390  const multi1d<ForwardProp_t>& forward_headers,
1391  const multi1d<LatticePropagator>& quark_propagators)
1392  {
1393  check1Args("MesA0Rho2xNablaA1SeqSrc", quark_propagators);
1394  setTSrce(forward_headers);
1395 
1396  // \f$\Gamma_f \equiv \gamma_4\gamma_i\nabla_i\f$
1397  return project(-rho_2xVector_sum(threePtNablaVector(quark_propagators[0],u)));
1398  }
1399 
1400 
1401  // Compute the 2-pt at the sink
1402  Complex
1403  MesA0Rho2xNablaA1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1404  const multi1d<ForwardProp_t>& forward_headers,
1405  const multi1d<LatticePropagator>& quark_propagators,
1406  int insertion)
1407  {
1408  START_CODE();
1409 
1410  LatticeComplex corr_fn = zero;
1411 
1412  check1Args("MesA0Rho2xNablaA1SeqSrc", quark_propagators);
1413  setTSrce(forward_headers);
1414 
1415  LatticePropagator tmp = quark_propagators[0];
1416 
1417  // \f$\Gamma_f \equiv \gamma_4\gamma_i\nabla_i\f$
1418  for(int k=0; k < 3; ++k)
1419  corr_fn += gammaSgn(1<<3,1<<k) * twoPtNabla(tmp,u,k, (1<<3)^(1<<k), insertion);
1420 
1421  END_CODE();
1422 
1423  return momentumProject(corr_fn);
1424  }
1425 
1426 
1427  // Construct a0-(rho_2xNabla_T1) sequential source
1428  LatticePropagator
1429  MesA0Rho2xNablaT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1430  const multi1d<ForwardProp_t>& forward_headers,
1431  const multi1d<LatticePropagator>& quark_propagators)
1432  {
1433  check1Args("MesA0Rho2xNablaT1SeqSrc", quark_propagators);
1434  setTSrce(forward_headers);
1435 
1436  // \f$\Gamma_f \equiv \epsilon_{ijk}\gamma_4\gamma_j \nabla_k\f$
1437  return project(-rho_2xVector_antisym(threePtNablaVector(quark_propagators[0],u), getDerivDir()));
1438  }
1439 
1440 
1441  // Compute the 2-pt at the sink
1442  Complex
1443  MesA0Rho2xNablaT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1444  const multi1d<ForwardProp_t>& forward_headers,
1445  const multi1d<LatticePropagator>& quark_propagators,
1446  int insertion)
1447  {
1448  START_CODE();
1449 
1450  LatticeComplex corr_fn = zero;
1451 
1452  check1Args("MesA0Rho2xNablaT1SeqSrc", quark_propagators);
1453  setTSrce(forward_headers);
1454 
1455  LatticePropagator tmp = quark_propagators[0];
1456 
1457  // \f$\Gamma_f \equiv \epsilon_{ijk}\gamma_4\gamma_j \nabla_k\f$
1458  for(int j=0; j < 3; ++j)
1459  for(int k=0; k < 3; ++k)
1460  {
1461  int a = antiSymTensor3d(getDerivDir(),j,k);
1462  if (a != 0)
1463  corr_fn += Real(a) * gammaSgn(1<<3,1<<j) * twoPtNabla(tmp,u,k, (1<<3)^(1<<j), insertion);
1464  }
1465 
1466  END_CODE();
1467 
1468  return momentumProject(corr_fn);
1469  }
1470 
1471 
1472  // Construct a0-(rho_2xNabla_T2) sequential source
1473  LatticePropagator
1474  MesA0Rho2xNablaT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1475  const multi1d<ForwardProp_t>& forward_headers,
1476  const multi1d<LatticePropagator>& quark_propagators)
1477  {
1478  check1Args("MesA0Rho2xNablaT2SeqSrc", quark_propagators);
1479  setTSrce(forward_headers);
1480 
1481  // \f$\Gamma_f \equiv s_{ijk}\gamma_4\gamma_j \nabla_k\f$
1482  return project(-rho_2xVector_sym(threePtNablaVector(quark_propagators[0],u), getDerivDir()));
1483  }
1484 
1485 
1486  // Compute the 2-pt at the sink
1487  Complex
1488  MesA0Rho2xNablaT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1489  const multi1d<ForwardProp_t>& forward_headers,
1490  const multi1d<LatticePropagator>& quark_propagators,
1491  int insertion)
1492  {
1493  START_CODE();
1494 
1495  LatticeComplex corr_fn = zero;
1496 
1497  check1Args("MesA0Rho2xNablaT2SeqSrc", quark_propagators);
1498  setTSrce(forward_headers);
1499 
1500  LatticePropagator tmp = quark_propagators[0];
1501 
1502  // \f$\Gamma_f \equiv s_{ijk}\gamma_4\gamma_j \nabla_k\f$
1503  for(int j=0; j < 3; ++j)
1504  for(int k=0; k < 3; ++k)
1505  {
1506  int s = symTensor3d(getDerivDir(),j,k);
1507  if (s != 0)
1508  corr_fn += Real(s) * gammaSgn(1<<3,1<<j) * twoPtNabla(tmp,u,k, (1<<3)^(1<<j), insertion);
1509  }
1510 
1511  END_CODE();
1512 
1513  return momentumProject(corr_fn);
1514  }
1515 
1516 
1517  // Construct a0-(rho_2xNabla_E) sequential source
1518  LatticePropagator
1519  MesA0Rho2xNablaESeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1520  const multi1d<ForwardProp_t>& forward_headers,
1521  const multi1d<LatticePropagator>& quark_propagators)
1522  {
1523  check1Args("MesA0Rho2xNablaESeqSrc", quark_propagators);
1524  setTSrce(forward_headers);
1525 
1526  // \f$\Gamma_f \equiv Q_{\alpha jk}\gamma_4\gamma_j \nabla_k\f$
1527  return project(-rho_2xVector_E(threePtNablaVector(quark_propagators[0],u), getDerivDir()));
1528  }
1529 
1530 
1531  // Compute the 2-pt at the sink
1532  Complex
1533  MesA0Rho2xNablaESeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1534  const multi1d<ForwardProp_t>& forward_headers,
1535  const multi1d<LatticePropagator>& quark_propagators,
1536  int insertion)
1537  {
1538  START_CODE();
1539 
1540  LatticeComplex corr_fn = zero;
1541 
1542  check1Args("MesA0Rho2xNablaESeqSrc", quark_propagators);
1543  setTSrce(forward_headers);
1544 
1545  LatticePropagator tmp = quark_propagators[0];
1546 
1547  // \f$\Gamma_f \equiv Q_{\alpha jk}\gamma_4\gamma_j \nabla_k\f$
1548  for(int j=0; j < 3; ++j)
1549  for(int k=0; k < 3; ++k)
1550  {
1551  Real e = ETensor3d(getDerivDir(),j,k);
1552  if (toBool(e != 0.0))
1553  corr_fn += e * gammaSgn(1<<3,1<<j) * twoPtNabla(tmp,u,k, (1<<3)^(1<<j), insertion);
1554  }
1555 
1556  END_CODE();
1557 
1558  return momentumProject(corr_fn);
1559  }
1560 
1561 
1562  //---------------------------------------------------------------------------------
1563  // Construct a0-(a1xNabla_A1) sequential source
1564  LatticePropagator
1565  MesA0A1xNablaA1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1566  const multi1d<ForwardProp_t>& forward_headers,
1567  const multi1d<LatticePropagator>& quark_propagators)
1568  {
1569  check1Args("MesA0A1xNablaA1SeqSrc", quark_propagators);
1570  setTSrce(forward_headers);
1571 
1572  // \f$\Gamma_f \equiv \gamma_5\gamma_i \nabla_i\f$
1573  return project(a1xVector_sum(threePtNablaVector(quark_propagators[0],u)));
1574  }
1575 
1576 
1577  // Compute the 2-pt at the sink
1578  Complex
1579  MesA0A1xNablaA1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1580  const multi1d<ForwardProp_t>& forward_headers,
1581  const multi1d<LatticePropagator>& quark_propagators,
1582  int insertion)
1583  {
1584  START_CODE();
1585 
1586  LatticeComplex corr_fn = zero;
1587  int G5 = Ns*Ns-1;
1588 
1589  check1Args("MesA0A1xNablaA1SeqSrc", quark_propagators);
1590  setTSrce(forward_headers);
1591 
1592  LatticePropagator tmp = quark_propagators[0];
1593 
1594  // \f$\Gamma_f \equiv \gamma_5\gamma_i \nabla_i\f$
1595  for(int k=0; k < 3; ++k)
1596  corr_fn += gammaSgn(G5,1<<k) * twoPtNabla(tmp,u,k, G5^(1<<k), insertion);
1597 
1598  END_CODE();
1599 
1600  return momentumProject(corr_fn);
1601  }
1602 
1603 
1604  // Construct a0-(a1xNabla_T1) sequential source
1605  LatticePropagator
1606  MesA0A1xNablaT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1607  const multi1d<ForwardProp_t>& forward_headers,
1608  const multi1d<LatticePropagator>& quark_propagators)
1609  {
1610  check1Args("MesA0A1xNablaT1SeqSrc", quark_propagators);
1611  setTSrce(forward_headers);
1612 
1613  // \f$\Gamma_f \equiv \gamma_5 \epsilon_{ijk}\gamma_j \nabla_k\f$
1614  return project(a1xVector_antisym(threePtNablaVector(quark_propagators[0],u), getDerivDir()));
1615  }
1616 
1617 
1618  // Compute the 2-pt at the sink
1619  Complex
1620  MesA0A1xNablaT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1621  const multi1d<ForwardProp_t>& forward_headers,
1622  const multi1d<LatticePropagator>& quark_propagators,
1623  int insertion)
1624  {
1625  START_CODE();
1626 
1627  LatticeComplex corr_fn = zero;
1628  int G5 = Ns*Ns-1;
1629 
1630  check1Args("MesA0A1xNablaT1SeqSrc", quark_propagators);
1631  setTSrce(forward_headers);
1632 
1633  LatticePropagator tmp = quark_propagators[0];
1634 
1635  // \f$\Gamma_f \equiv \gamma_5 \epsilon_{ijk}\gamma_j \nabla_k\f$
1636  for(int j=0; j < 3; ++j)
1637  for(int k=0; k < 3; ++k)
1638  {
1639  int a = antiSymTensor3d(getDerivDir(),j,k);
1640  if (a != 0)
1641  corr_fn += Real(a) * gammaSgn(G5,1<<j) * twoPtNabla(tmp,u,k,G5^(1<<j),insertion);
1642  }
1643 
1644  END_CODE();
1645 
1646  return momentumProject(corr_fn);
1647  }
1648 
1649 
1650  // Construct a0-(a1xNabla_T2) sequential source
1651  LatticePropagator
1652  MesA0A1xNablaT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1653  const multi1d<ForwardProp_t>& forward_headers,
1654  const multi1d<LatticePropagator>& quark_propagators)
1655  {
1656  check1Args("MesA0A1xNablaT2SeqSrc", quark_propagators);
1657  setTSrce(forward_headers);
1658 
1659  // \f$\Gamma_f \equiv \gamma_5 s_{ijk}\gamma_j \nabla_k\f$
1660  return project(a1xVector_sym(threePtNablaVector(quark_propagators[0],u), getDerivDir()));
1661  }
1662 
1663 
1664  // Compute the 2-pt at the sink
1665  Complex
1666  MesA0A1xNablaT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1667  const multi1d<ForwardProp_t>& forward_headers,
1668  const multi1d<LatticePropagator>& quark_propagators,
1669  int insertion)
1670  {
1671  START_CODE();
1672 
1673  LatticeComplex corr_fn = zero;
1674  int G5 = Ns*Ns-1;
1675 
1676  check1Args("MesA0A1xNablaT2SeqSrc", quark_propagators);
1677  setTSrce(forward_headers);
1678 
1679  LatticePropagator tmp = quark_propagators[0];
1680 
1681  // \f$\Gamma_f \equiv \gamma_5 s_{ijk}\gamma_j \nabla_k\f$
1682  for(int j=0; j < 3; ++j)
1683  for(int k=0; k < 3; ++k)
1684  {
1685  int s = symTensor3d(getDerivDir(),j,k);
1686  if (s != 0)
1687  corr_fn += Real(s) * gammaSgn(G5,1<<j) * twoPtNabla(tmp,u,k,G5^(1<<j),insertion);
1688  }
1689 
1690  END_CODE();
1691 
1692  return momentumProject(corr_fn);
1693  }
1694 
1695 
1696  // Construct a0-(a1xNabla_E) sequential source
1697  LatticePropagator
1698  MesA0A1xNablaESeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1699  const multi1d<ForwardProp_t>& forward_headers,
1700  const multi1d<LatticePropagator>& quark_propagators)
1701  {
1702  check1Args("MesA0A1xNablaESeqSrc", quark_propagators);
1703  setTSrce(forward_headers);
1704 
1705  // \f$\Gamma_f \equiv \gamma_5 Q_{\alpha jk}\gamma_j \nabla_k\f$
1706  return project(a1xVector_E(threePtNablaVector(quark_propagators[0],u), getDerivDir()));
1707  }
1708 
1709 
1710  // Compute the 2-pt at the sink
1711  Complex
1712  MesA0A1xNablaESeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1713  const multi1d<ForwardProp_t>& forward_headers,
1714  const multi1d<LatticePropagator>& quark_propagators,
1715  int insertion)
1716  {
1717  START_CODE();
1718 
1719  LatticeComplex corr_fn = zero;
1720  int G5 = Ns*Ns-1;
1721 
1722  check1Args("MesA0A1xNablaESeqSrc", quark_propagators);
1723  setTSrce(forward_headers);
1724 
1725  LatticePropagator tmp = quark_propagators[0];
1726 
1727  // \f$\Gamma_f \equiv \gamma_5 Q_{\alpha jk}\gamma_j \nabla_k\f$
1728  for(int j=0; j < 3; ++j)
1729  for(int k=0; k < 3; ++k)
1730  {
1731  Real e = ETensor3d(getDerivDir(),j,k);
1732  if (toBool(e != 0.0))
1733  corr_fn += e * gammaSgn(G5,1<<j) * twoPtNabla(tmp,u,k,G5^(1<<j),insertion);
1734  }
1735 
1736  END_CODE();
1737 
1738  return momentumProject(corr_fn);
1739  }
1740 
1741 
1742  //---------------------------------------------------------------------------------
1743  // Construct a0-(b1xNabla_A1) sequential source
1744  LatticePropagator
1745  MesA0B1xNablaA1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1746  const multi1d<ForwardProp_t>& forward_headers,
1747  const multi1d<LatticePropagator>& quark_propagators)
1748  {
1749  check1Args("MesA0B1xNablaA1SeqSrc", quark_propagators);
1750  setTSrce(forward_headers);
1751 
1752  // \f$\Gamma_f \equiv \gamma_4\gamma_5 \gamma_i \nabla_i\f$
1753  return project(-b1xVector_sum(threePtNablaVector(quark_propagators[0],u)));
1754  }
1755 
1756 
1757  // Compute the 2-pt at the sink
1758  Complex
1759  MesA0B1xNablaA1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1760  const multi1d<ForwardProp_t>& forward_headers,
1761  const multi1d<LatticePropagator>& quark_propagators,
1762  int insertion)
1763  {
1764  START_CODE();
1765 
1766  LatticeComplex corr_fn = zero;
1767  int G5 = Ns*Ns-1;
1768 
1769  check1Args("MesA0B1xNablaA1SeqSrc", quark_propagators);
1770  setTSrce(forward_headers);
1771 
1772  LatticePropagator tmp = quark_propagators[0];
1773 
1774  // \f$\Gamma_f \equiv \gamma_4\gamma_5 \gamma_i \nabla_i\f$
1775  for(int k=0; k < 3; ++k)
1776  corr_fn += gammaSgn(1<<3,G5) * gammaSgn((1<<3)^G5,1<<k) *
1777  twoPtNabla(tmp,u,k,(1<<3)^G5^(1<<k),insertion);
1778 
1779  END_CODE();
1780 
1781  return momentumProject(corr_fn);
1782  }
1783 
1784 
1785  // Construct a0-(b1xNabla_T1) sequential source
1786  LatticePropagator
1787  MesA0B1xNablaT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1788  const multi1d<ForwardProp_t>& forward_headers,
1789  const multi1d<LatticePropagator>& quark_propagators)
1790  {
1791  check1Args("MesA0B1xNablaT1SeqSrc", quark_propagators);
1792  setTSrce(forward_headers);
1793 
1794  // \f$\Gamma_f \equiv \gamma_4\gamma_5\epsilon_{ijk}\gamma_j \nabla_k\f$
1795  return project(-b1xVector_antisym(threePtNablaVector(quark_propagators[0],u), getDerivDir()));
1796  }
1797 
1798 
1799  // Compute the 2-pt at the sink
1800  Complex
1801  MesA0B1xNablaT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1802  const multi1d<ForwardProp_t>& forward_headers,
1803  const multi1d<LatticePropagator>& quark_propagators,
1804  int insertion)
1805  {
1806  START_CODE();
1807 
1808  LatticeComplex corr_fn = zero;
1809  int G5 = Ns*Ns-1;
1810 
1811  check1Args("MesA0B1xNablaT1SeqSrc", quark_propagators);
1812  setTSrce(forward_headers);
1813 
1814  LatticePropagator tmp = quark_propagators[0];
1815 
1816  // \f$\Gamma_f \equiv \gamma_4\gamma_5\epsilon_{ijk}\gamma_j \nabla_k\f$
1817  for(int j=0; j < 3; ++j)
1818  for(int k=0; k < 3; ++k)
1819  {
1820  int a = antiSymTensor3d(getDerivDir(),j,k);
1821  if (a != 0)
1822  corr_fn += Real(a) * gammaSgn(1<<3,G5) * gammaSgn((1<<3)^G5,1<<j) *
1823  twoPtNabla(tmp,u,k,(1<<3)^G5^(1<<j),insertion);
1824  }
1825 
1826  END_CODE();
1827 
1828  return momentumProject(corr_fn);
1829  }
1830 
1831 
1832  // Construct a0-(b1xNabla_T2) sequential source
1833  LatticePropagator
1834  MesA0B1xNablaT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1835  const multi1d<ForwardProp_t>& forward_headers,
1836  const multi1d<LatticePropagator>& quark_propagators)
1837  {
1838  check1Args("MesA0B1xNablaT2SeqSrc", quark_propagators);
1839  setTSrce(forward_headers);
1840 
1841  // \f$\Gamma_f \equiv \gamma_4\gamma_5 s_{ijk}\gamma_j \nabla_k\f$
1842  return project(-b1xVector_sym(threePtNablaVector(quark_propagators[0],u), getDerivDir()));
1843  }
1844 
1845 
1846  // Compute the 2-pt at the sink
1847  Complex
1848  MesA0B1xNablaT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1849  const multi1d<ForwardProp_t>& forward_headers,
1850  const multi1d<LatticePropagator>& quark_propagators,
1851  int insertion)
1852  {
1853  START_CODE();
1854 
1855  LatticeComplex corr_fn = zero;
1856  int G5 = Ns*Ns-1;
1857 
1858  check1Args("MesA0B1xNablaT2SeqSrc", quark_propagators);
1859  setTSrce(forward_headers);
1860 
1861  LatticePropagator tmp = quark_propagators[0];
1862 
1863  // \f$\Gamma_f \equiv \gamma_4\gamma_5 s_{ijk}\gamma_j \nabla_k\f$
1864  for(int j=0; j < 3; ++j)
1865  for(int k=0; k < 3; ++k)
1866  {
1867  int s = symTensor3d(getDerivDir(),j,k);
1868  if (s != 0)
1869  corr_fn += Real(s) * gammaSgn(1<<3,G5) * gammaSgn((1<<3)^G5,1<<j) *
1870  twoPtNabla(tmp,u,k,(1<<3)^G5^(1<<j),insertion);
1871  }
1872 
1873  END_CODE();
1874 
1875  return momentumProject(corr_fn);
1876  }
1877 
1878 
1879  // Construct a0-(b1xNabla_E) sequential source
1880  LatticePropagator
1881  MesA0B1xNablaESeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1882  const multi1d<ForwardProp_t>& forward_headers,
1883  const multi1d<LatticePropagator>& quark_propagators)
1884  {
1885  check1Args("MesA0B1xNablaESeqSrc", quark_propagators);
1886  setTSrce(forward_headers);
1887 
1888  // \f$\Gamma_f \equiv \gamma_4\gamma_5 Q_{\alpha jk}\gamma_j \nabla_k\f$
1889  return project(-b1xVector_E(threePtNablaVector(quark_propagators[0],u), getDerivDir()));
1890  }
1891 
1892 
1893  // Compute the 2-pt at the sink
1894  Complex
1895  MesA0B1xNablaESeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1896  const multi1d<ForwardProp_t>& forward_headers,
1897  const multi1d<LatticePropagator>& quark_propagators,
1898  int insertion)
1899  {
1900  START_CODE();
1901 
1902  LatticeComplex corr_fn = zero;
1903  int G5 = Ns*Ns-1;
1904 
1905  check1Args("MesA0B1xNablaESeqSrc", quark_propagators);
1906  setTSrce(forward_headers);
1907 
1908  LatticePropagator tmp = quark_propagators[0];
1909 
1910  // \f$\Gamma_f \equiv \gamma_4\gamma_5 Q_{\alpha jk}\gamma_j \nabla_k\f$
1911  for(int j=0; j < 3; ++j)
1912  for(int k=0; k < 3; ++k)
1913  {
1914  Real e = ETensor3d(getDerivDir(),j,k);
1915  if (toBool(e != 0.0))
1916  corr_fn += e * gammaSgn(1<<3,G5) * gammaSgn((1<<3)^G5,1<<j) *
1917  twoPtNabla(tmp,u,k,(1<<3)^G5^(1<<j),insertion);
1918  }
1919 
1920  END_CODE();
1921 
1922  return momentumProject(corr_fn);
1923  }
1924 
1925 
1926  //---------------------------------------------------------------------------------
1927  // Construct a0-(a0xD_T2) sequential source
1928  LatticePropagator
1929  MesA0A0xDT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1930  const multi1d<ForwardProp_t>& forward_headers,
1931  const multi1d<LatticePropagator>& quark_propagators)
1932  {
1933  check1Args("MesA0A0xDT2SeqSrc", quark_propagators);
1934  setTSrce(forward_headers);
1935 
1936  // \f$\Gamma_f \equiv D_i\f$
1937  return project(a0xVector(threePtD(quark_propagators[0],u,getDerivDir())));
1938  }
1939 
1940 
1941  // Compute the 2-pt at the sink
1942  Complex
1943  MesA0A0xDT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1944  const multi1d<ForwardProp_t>& forward_headers,
1945  const multi1d<LatticePropagator>& quark_propagators,
1946  int insertion)
1947  {
1948  START_CODE();
1949 
1950  check1Args("MesA0A0xDT2SeqSrc", quark_propagators);
1951  setTSrce(forward_headers);
1952 
1953  LatticePropagator tmp = quark_propagators[0];
1954 
1955  // \f$\Gamma_f \equiv D_i\f$
1956  LatticeComplex corr_fn = twoPtD(tmp,u,getDerivDir(),0,insertion);
1957 
1958  END_CODE();
1959 
1960  return momentumProject(corr_fn);
1961  }
1962 
1963 
1964  // Construct a0-(pionxD_T2) sequential source
1965  LatticePropagator
1966  MesA0PionxDT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
1967  const multi1d<ForwardProp_t>& forward_headers,
1968  const multi1d<LatticePropagator>& quark_propagators)
1969  {
1970  check1Args("MesA0PionxDT2SeqSrc", quark_propagators);
1971  setTSrce(forward_headers);
1972 
1973  // \f$\Gamma_f \equiv \gamma_5 D_i\f$
1974  return project(pionxVector(threePtD(quark_propagators[0],u,getDerivDir())));
1975  }
1976 
1977 
1978  // Compute the 2-pt at the sink
1979  Complex
1980  MesA0PionxDT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
1981  const multi1d<ForwardProp_t>& forward_headers,
1982  const multi1d<LatticePropagator>& quark_propagators,
1983  int insertion)
1984  {
1985  START_CODE();
1986 
1987  int G5 = Ns*Ns-1;
1988 
1989  check1Args("MesA0PionxDT2SeqSrc", quark_propagators);
1990  setTSrce(forward_headers);
1991 
1992  LatticePropagator tmp = quark_propagators[0];
1993 
1994  // \f$\Gamma_f \equiv \gamma_5 D_i\f$
1995  LatticeComplex corr_fn = twoPtD(tmp,u,getDerivDir(),G5,insertion);
1996 
1997  END_CODE();
1998 
1999  return momentumProject(corr_fn);
2000  }
2001 
2002 
2003  // Construct a0-(pion_2xD_T2) sequential source
2004  LatticePropagator
2005  MesA0Pion2xDT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2006  const multi1d<ForwardProp_t>& forward_headers,
2007  const multi1d<LatticePropagator>& quark_propagators)
2008  {
2009  check1Args("MesA0Pion2xDT2SeqSrc", quark_propagators);
2010  setTSrce(forward_headers);
2011 
2012  // \f$\Gamma_f \equiv \gamma_4\gamma_5 D_i\f$
2013  return project(pion_2xVector(threePtD(quark_propagators[0],u,getDerivDir())));
2014  }
2015 
2016 
2017  // Compute the 2-pt at the sink
2018  Complex
2019  MesA0Pion2xDT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2020  const multi1d<ForwardProp_t>& forward_headers,
2021  const multi1d<LatticePropagator>& quark_propagators,
2022  int insertion)
2023  {
2024  START_CODE();
2025 
2026  int G5 = Ns*Ns-1;
2027 
2028  check1Args("MesA0Pion2xDT2SeqSrc", quark_propagators);
2029  setTSrce(forward_headers);
2030 
2031  LatticePropagator tmp = quark_propagators[0];
2032 
2033  // \f$\Gamma_f \equiv \gamma_4\gamma_5 D_i\f$
2034  LatticeComplex corr_fn = gammaSgn(1<<3,G5) * twoPtD(tmp,u,getDerivDir(),(1<<3)^G5,insertion);
2035 
2036  END_CODE();
2037 
2038  return momentumProject(corr_fn);
2039  }
2040 
2041 
2042  // Construct a0-(a0_2xD_T2) sequential source
2043  LatticePropagator
2044  MesA0A02xDT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2045  const multi1d<ForwardProp_t>& forward_headers,
2046  const multi1d<LatticePropagator>& quark_propagators)
2047  {
2048  check1Args("MesA0A02xDT2SeqSrc", quark_propagators);
2049  setTSrce(forward_headers);
2050 
2051  // \f$\Gamma_f \equiv \gamma_4 D_i\f$
2052  return project(-a0_2xVector(threePtD(quark_propagators[0],u,getDerivDir())));
2053  }
2054 
2055 
2056  // Compute the 2-pt at the sink
2057  Complex
2058  MesA0A02xDT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2059  const multi1d<ForwardProp_t>& forward_headers,
2060  const multi1d<LatticePropagator>& quark_propagators,
2061  int insertion)
2062  {
2063  START_CODE();
2064 
2065  check1Args("MesA0A02xDT2SeqSrc", quark_propagators);
2066  setTSrce(forward_headers);
2067 
2068  LatticePropagator tmp = quark_propagators[0];
2069 
2070  // \f$\Gamma_f \equiv \gamma_4 D_i\f$
2071  LatticeComplex corr_fn = twoPtD(tmp,u,getDerivDir(),1<<3,insertion);
2072 
2073  END_CODE();
2074 
2075  return momentumProject(corr_fn);
2076  }
2077 
2078 
2079  //---------------------------------------------------------------------------------
2080  // Construct a0-(rhoxD_A2) sequential source
2081  LatticePropagator
2082  MesA0RhoxDA2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2083  const multi1d<ForwardProp_t>& forward_headers,
2084  const multi1d<LatticePropagator>& quark_propagators)
2085  {
2086  check1Args("MesA0RhoxDA2SeqSrc", quark_propagators);
2087  setTSrce(forward_headers);
2088 
2089  // \f$\Gamma_f \equiv \gamma_i D_i\f$
2090  return project(-rhoxVector_sum(threePtDVector(quark_propagators[0],u)));
2091  }
2092 
2093 
2094  // Compute the 2-pt at the sink
2095  Complex
2096  MesA0RhoxDA2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2097  const multi1d<ForwardProp_t>& forward_headers,
2098  const multi1d<LatticePropagator>& quark_propagators,
2099  int insertion)
2100  {
2101  START_CODE();
2102 
2103  LatticeComplex corr_fn = zero;
2104  int G5 = Ns*Ns-1;
2105 
2106  check1Args("MesA0RhoxDA2SeqSrc", quark_propagators);
2107  setTSrce(forward_headers);
2108 
2109  LatticePropagator tmp = quark_propagators[0];
2110 
2111  // \f$\Gamma_f \equiv \gamma_i D_i\f$
2112  for(int k=0; k < 3; ++k)
2113  corr_fn += twoPtD(tmp,u,k, 1<<k, insertion);
2114 
2115  END_CODE();
2116 
2117  return momentumProject(corr_fn);
2118  }
2119 
2120 
2121  //! Construct a0-(rhoxD_T1) sequential source
2122  LatticePropagator
2123  MesA0RhoxDT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2124  const multi1d<ForwardProp_t>& forward_headers,
2125  const multi1d<LatticePropagator>& quark_propagators)
2126  {
2127  check1Args("MesA0RhoxDT1SeqSrc", quark_propagators);
2128  setTSrce(forward_headers);
2129 
2130  // \f$\Gamma_f \equiv s_{ijk}\gamma_j D_k\f$
2131  return project(-rhoxVector_sym(threePtDVector(quark_propagators[0],u), getDerivDir()));
2132  }
2133 
2134 
2135  // Compute the 2-pt at the sink
2136  Complex
2137  MesA0RhoxDT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2138  const multi1d<ForwardProp_t>& forward_headers,
2139  const multi1d<LatticePropagator>& quark_propagators,
2140  int insertion)
2141  {
2142  START_CODE();
2143 
2144  LatticeComplex corr_fn = zero;
2145  int G5 = Ns*Ns-1;
2146 
2147  check1Args("MesA0RhoxDT1SeqSrc", quark_propagators);
2148  setTSrce(forward_headers);
2149 
2150  LatticePropagator tmp = quark_propagators[0];
2151 
2152  // \f$\Gamma_f \equiv s_{ijk}\gamma_j D_k\f$
2153  for(int j=0; j < 3; ++j)
2154  for(int k=0; k < 3; ++k)
2155  {
2156  int s = symTensor3d(getDerivDir(),j,k);
2157  if (s != 0)
2158  corr_fn += Real(s) * twoPtD(tmp,u,k, 1<<j, insertion);
2159  }
2160 
2161  END_CODE();
2162 
2163  return momentumProject(corr_fn);
2164  }
2165 
2166 
2167  //! Construct a0-(rhoxD_T2) sequential source
2168  LatticePropagator
2169  MesA0RhoxDT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2170  const multi1d<ForwardProp_t>& forward_headers,
2171  const multi1d<LatticePropagator>& quark_propagators)
2172  {
2173  check1Args("MesA0RhoxDT2SeqSrc", quark_propagators);
2174  setTSrce(forward_headers);
2175 
2176  // \f$\Gamma_f \equiv \epsilon_{ijk}\gamma_j D_k\f$
2177  return project(-rhoxVector_antisym(threePtDVector(quark_propagators[0],u), getDerivDir()));
2178  }
2179 
2180 
2181  // Compute the 2-pt at the sink
2182  Complex
2183  MesA0RhoxDT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2184  const multi1d<ForwardProp_t>& forward_headers,
2185  const multi1d<LatticePropagator>& quark_propagators,
2186  int insertion)
2187  {
2188  START_CODE();
2189 
2190  LatticeComplex corr_fn = zero;
2191  int G5 = Ns*Ns-1;
2192 
2193  check1Args("MesA0RhoxDT2SeqSrc", quark_propagators);
2194  setTSrce(forward_headers);
2195 
2196  LatticePropagator tmp = quark_propagators[0];
2197 
2198  // \f$\Gamma_f \equiv \epsilon_{ijk}\gamma_j D_k\f$
2199  for(int j=0; j < 3; ++j)
2200  for(int k=0; k < 3; ++k)
2201  {
2202  int a = antiSymTensor3d(getDerivDir(),j,k);
2203  if (a != 0)
2204  corr_fn += Real(a) * twoPtD(tmp,u,k, 1<<j, insertion);
2205  }
2206 
2207  END_CODE();
2208 
2209  return momentumProject(corr_fn);
2210  }
2211 
2212 
2213  //! Construct a0-(rhoxD_E) sequential source
2214  LatticePropagator
2215  MesA0RhoxDESeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2216  const multi1d<ForwardProp_t>& forward_headers,
2217  const multi1d<LatticePropagator>& quark_propagators)
2218  {
2219  check1Args("MesA0RhoxDESeqSrc", quark_propagators);
2220  setTSrce(forward_headers);
2221 
2222  // \f$\Gamma_f \equiv Q_{\alpha jk}\gamma_j D_k\f$
2223  return project(-rhoxVector_E(threePtDVector(quark_propagators[0],u), getDerivDir()));
2224  }
2225 
2226 
2227  // Compute the 2-pt at the sink
2228  Complex
2229  MesA0RhoxDESeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2230  const multi1d<ForwardProp_t>& forward_headers,
2231  const multi1d<LatticePropagator>& quark_propagators,
2232  int insertion)
2233  {
2234  START_CODE();
2235 
2236  LatticeComplex corr_fn = zero;
2237  int G5 = Ns*Ns-1;
2238 
2239  check1Args("MesA0RhoxDESeqSrc", quark_propagators);
2240  setTSrce(forward_headers);
2241 
2242  LatticePropagator tmp = quark_propagators[0];
2243 
2244  // \f$\Gamma_f \equiv Q_{\alpha jk}\gamma_j D_k\f$
2245  for(int j=0; j < 3; ++j)
2246  for(int k=0; k < 3; ++k)
2247  {
2248  Real e = ETensor3d(getDerivDir(),j,k);
2249  if (toBool(e != 0.0))
2250  corr_fn += e * twoPtD(tmp,u,k, 1<<j, insertion);
2251  }
2252 
2253  END_CODE();
2254 
2255  return momentumProject(corr_fn);
2256  }
2257 
2258 
2259  //---------------------------------------------------------------------------------
2260  // Construct a0-(rho_2xD_A2) sequential source
2261  LatticePropagator
2262  MesA0Rho2xDA2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2263  const multi1d<ForwardProp_t>& forward_headers,
2264  const multi1d<LatticePropagator>& quark_propagators)
2265  {
2266  check1Args("MesA0Rho2xDA2SeqSrc", quark_propagators);
2267  setTSrce(forward_headers);
2268 
2269  // \f$\Gamma_f \equiv \gamma_4\gamma_i D_i\f$
2270  return project(-rho_2xVector_sum(threePtDVector(quark_propagators[0],u)));
2271  }
2272 
2273 
2274  // Compute the 2-pt at the sink
2275  Complex
2276  MesA0Rho2xDA2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2277  const multi1d<ForwardProp_t>& forward_headers,
2278  const multi1d<LatticePropagator>& quark_propagators,
2279  int insertion)
2280  {
2281  START_CODE();
2282 
2283  LatticeComplex corr_fn = zero;
2284  int G5 = Ns*Ns-1;
2285 
2286  check1Args("MesA0Rho2xDA2SeqSrc", quark_propagators);
2287  setTSrce(forward_headers);
2288 
2289  LatticePropagator tmp = quark_propagators[0];
2290 
2291  // \f$\Gamma_f \equiv \gamma_4 \gamma_i D_i\f$
2292  for(int k=0; k < 3; ++k)
2293  corr_fn += gammaSgn(1<<3,1<<k) * twoPtD(tmp,u,k, (1<<3)^(1<<k), insertion);
2294 
2295  END_CODE();
2296 
2297  return momentumProject(corr_fn);
2298  }
2299 
2300 
2301  //! Construct a0-(rho_2xD_T1) sequential source
2302  LatticePropagator
2303  MesA0Rho2xDT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2304  const multi1d<ForwardProp_t>& forward_headers,
2305  const multi1d<LatticePropagator>& quark_propagators)
2306  {
2307  check1Args("MesA0Rho2xDT1SeqSrc", quark_propagators);
2308  setTSrce(forward_headers);
2309 
2310  // \f$\Gamma_f \equiv s_{ijk}\gamma_4\gamma_j D_k\f$
2311  return project(-rho_2xVector_sym(threePtDVector(quark_propagators[0],u), getDerivDir()));
2312  }
2313 
2314 
2315  // Compute the 2-pt at the sink
2316  Complex
2317  MesA0Rho2xDT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2318  const multi1d<ForwardProp_t>& forward_headers,
2319  const multi1d<LatticePropagator>& quark_propagators,
2320  int insertion)
2321  {
2322  START_CODE();
2323 
2324  LatticeComplex corr_fn = zero;
2325  int G5 = Ns*Ns-1;
2326 
2327  check1Args("MesA0Rho2xDT1SeqSrc", quark_propagators);
2328  setTSrce(forward_headers);
2329 
2330  LatticePropagator tmp = quark_propagators[0];
2331 
2332  // \f$\Gamma_f \equiv s_{ijk}\gamma_4\gamma_j D_k\f$
2333  for(int j=0; j < 3; ++j)
2334  for(int k=0; k < 3; ++k)
2335  {
2336  int s = symTensor3d(getDerivDir(),j,k);
2337  if (s != 0)
2338  corr_fn += Real(s) * gammaSgn(1<<3,1<<j) * twoPtD(tmp,u,k, (1<<3)^(1<<j), insertion);
2339  }
2340 
2341  END_CODE();
2342 
2343  return momentumProject(corr_fn);
2344  }
2345 
2346 
2347  //! Construct a0-(rho_2xD_T2) sequential source
2348  LatticePropagator
2349  MesA0Rho2xDT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2350  const multi1d<ForwardProp_t>& forward_headers,
2351  const multi1d<LatticePropagator>& quark_propagators)
2352  {
2353  check1Args("MesA0Rho2xDT2SeqSrc", quark_propagators);
2354  setTSrce(forward_headers);
2355 
2356  // \f$\Gamma_f \equiv \epsilon_{ijk}\gamma_4\gamma_j D_k\f$
2357  return project(-rho_2xVector_antisym(threePtDVector(quark_propagators[0],u), getDerivDir()));
2358  }
2359 
2360 
2361  // Compute the 2-pt at the sink
2362  Complex
2363  MesA0Rho2xDT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2364  const multi1d<ForwardProp_t>& forward_headers,
2365  const multi1d<LatticePropagator>& quark_propagators,
2366  int insertion)
2367  {
2368  START_CODE();
2369 
2370  LatticeComplex corr_fn = zero;
2371  int G5 = Ns*Ns-1;
2372 
2373  check1Args("MesA0Rho2xDT2SeqSrc", quark_propagators);
2374  setTSrce(forward_headers);
2375 
2376  LatticePropagator tmp = quark_propagators[0];
2377 
2378  // \f$\Gamma_f \equiv \epsilon_{ijk}\gamma_4\gamma_j D_k\f$
2379  for(int j=0; j < 3; ++j)
2380  for(int k=0; k < 3; ++k)
2381  {
2382  int a = antiSymTensor3d(getDerivDir(),j,k);
2383  if (a != 0)
2384  corr_fn += Real(a) * gammaSgn(1<<3,1<<j) * twoPtD(tmp,u,k, (1<<3)^(1<<j), insertion);
2385  }
2386 
2387  END_CODE();
2388 
2389  return momentumProject(corr_fn);
2390  }
2391 
2392 
2393  //! Construct a0-(rho_2xD_E) sequential source
2394  LatticePropagator
2395  MesA0Rho2xDESeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2396  const multi1d<ForwardProp_t>& forward_headers,
2397  const multi1d<LatticePropagator>& quark_propagators)
2398  {
2399  check1Args("MesA0Rho2xDESeqSrc", quark_propagators);
2400  setTSrce(forward_headers);
2401 
2402  // \f$\Gamma_f \equiv Q_{\alpha jk}\gamma_4\gamma_j D_k\f$
2403  return project(-rho_2xVector_E(threePtDVector(quark_propagators[0],u), getDerivDir()));
2404  }
2405 
2406 
2407  // Compute the 2-pt at the sink
2408  Complex
2409  MesA0Rho2xDESeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2410  const multi1d<ForwardProp_t>& forward_headers,
2411  const multi1d<LatticePropagator>& quark_propagators,
2412  int insertion)
2413  {
2414  START_CODE();
2415 
2416  LatticeComplex corr_fn = zero;
2417  int G5 = Ns*Ns-1;
2418 
2419  check1Args("MesA0Rho2xDESeqSrc", quark_propagators);
2420  setTSrce(forward_headers);
2421 
2422  LatticePropagator tmp = quark_propagators[0];
2423 
2424  // \f$\Gamma_f \equiv Q_{\alpha jk}\gamma_4\gamma_j D_k\f$
2425  for(int j=0; j < 3; ++j)
2426  for(int k=0; k < 3; ++k)
2427  {
2428  Real e = ETensor3d(getDerivDir(),j,k);
2429  if (toBool(e != 0.0))
2430  corr_fn += e * gammaSgn(1<<3,1<<j) * twoPtD(tmp,u,k, (1<<3)^(1<<j), insertion);
2431  }
2432 
2433  END_CODE();
2434 
2435  return momentumProject(corr_fn);
2436  }
2437 
2438 
2439  //---------------------------------------------------------------------------------
2440  // Construct a0-(a1xD_A2) sequential source
2441  LatticePropagator
2442  MesA0A1xDA2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2443  const multi1d<ForwardProp_t>& forward_headers,
2444  const multi1d<LatticePropagator>& quark_propagators)
2445  {
2446  check1Args("MesA0A1xDA2SeqSrc", quark_propagators);
2447  setTSrce(forward_headers);
2448 
2449  // \f$\Gamma_f \equiv \gamma_5\gamma_i D_i\f$
2450  return project(a1xVector_sum(threePtDVector(quark_propagators[0],u)));
2451  }
2452 
2453 
2454  // Compute the 2-pt at the sink
2455  Complex
2456  MesA0A1xDA2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2457  const multi1d<ForwardProp_t>& forward_headers,
2458  const multi1d<LatticePropagator>& quark_propagators,
2459  int insertion)
2460  {
2461  START_CODE();
2462 
2463  LatticeComplex corr_fn = zero;
2464  int G5 = Ns*Ns-1;
2465 
2466  check1Args("MesA0A1xDA2SeqSrc", quark_propagators);
2467  setTSrce(forward_headers);
2468 
2469  LatticePropagator tmp = quark_propagators[0];
2470 
2471  // \f$\Gamma_f \equiv \gamma_5\gamma_i D_i\f$
2472  for(int k=0; k < 3; ++k)
2473  corr_fn += gammaSgn(G5,1<<k) * twoPtD(tmp,u,k,G5^(1<<k),insertion);
2474 
2475  END_CODE();
2476 
2477  return momentumProject(corr_fn);
2478  }
2479 
2480 
2481  // Construct a0-(a1xD_T1) sequential source
2482  LatticePropagator
2483  MesA0A1xDT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2484  const multi1d<ForwardProp_t>& forward_headers,
2485  const multi1d<LatticePropagator>& quark_propagators)
2486  {
2487  check1Args("MesA0A1xDT1SeqSrc", quark_propagators);
2488  setTSrce(forward_headers);
2489 
2490  // \f$\Gamma_f \equiv \gamma_5 s_{ijk}\gamma_j D_k\f$
2491  return project(a1xVector_sym(threePtDVector(quark_propagators[0],u), getDerivDir()));
2492  }
2493 
2494 
2495  // Compute the 2-pt at the sink
2496  Complex
2497  MesA0A1xDT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2498  const multi1d<ForwardProp_t>& forward_headers,
2499  const multi1d<LatticePropagator>& quark_propagators,
2500  int insertion)
2501  {
2502  START_CODE();
2503 
2504  LatticeComplex corr_fn = zero;
2505  int G5 = Ns*Ns-1;
2506 
2507  check1Args("MesA0A1xDT1SeqSrc", quark_propagators);
2508  setTSrce(forward_headers);
2509 
2510  LatticePropagator tmp = quark_propagators[0];
2511 
2512  // \f$\Gamma_f \equiv \gamma_5 s_{ijk}\gamma_j D_k\f$
2513  for(int j=0; j < 3; ++j)
2514  for(int k=0; k < 3; ++k)
2515  {
2516  int s = symTensor3d(getDerivDir(),j,k);
2517  if (s != 0)
2518  corr_fn += Real(s) * gammaSgn(G5,1<<j) * twoPtD(tmp,u,k,G5^(1<<j),insertion);
2519  }
2520 
2521  END_CODE();
2522 
2523  return momentumProject(corr_fn);
2524  }
2525 
2526 
2527  // Construct a0-(a1xD_T2) sequential source
2528  LatticePropagator
2529  MesA0A1xDT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2530  const multi1d<ForwardProp_t>& forward_headers,
2531  const multi1d<LatticePropagator>& quark_propagators)
2532  {
2533  check1Args("MesA0A1xDT2SeqSrc", quark_propagators);
2534  setTSrce(forward_headers);
2535 
2536  // \f$\Gamma_f \equiv \gamma_5 \epsilon_{ijk}\gamma_j D_k\f$
2537  return project(a1xVector_antisym(threePtDVector(quark_propagators[0],u), getDerivDir()));
2538  }
2539 
2540 
2541  // Compute the 2-pt at the sink
2542  Complex
2543  MesA0A1xDT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2544  const multi1d<ForwardProp_t>& forward_headers,
2545  const multi1d<LatticePropagator>& quark_propagators,
2546  int insertion)
2547  {
2548  START_CODE();
2549 
2550  LatticeComplex corr_fn = zero;
2551  int G5 = Ns*Ns-1;
2552 
2553  check1Args("MesA0A1xDT2SeqSrc", quark_propagators);
2554  setTSrce(forward_headers);
2555 
2556  LatticePropagator tmp = quark_propagators[0];
2557 
2558  // \f$\Gamma_f \equiv \gamma_5 \epsilon_{ijk}\gamma_j D_k\f$
2559  for(int j=0; j < 3; ++j)
2560  for(int k=0; k < 3; ++k)
2561  {
2562  int a = antiSymTensor3d(getDerivDir(),j,k);
2563  if (a != 0)
2564  corr_fn += Real(a) * gammaSgn(G5,1<<j) * twoPtD(tmp,u,k,G5^(1<<j),insertion);
2565  }
2566 
2567  END_CODE();
2568 
2569  return momentumProject(corr_fn);
2570  }
2571 
2572 
2573  // Construct a0-(a1xD_E) sequential source
2574  LatticePropagator
2575  MesA0A1xDESeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2576  const multi1d<ForwardProp_t>& forward_headers,
2577  const multi1d<LatticePropagator>& quark_propagators)
2578  {
2579  check1Args("MesA0A1xDESeqSrc", quark_propagators);
2580  setTSrce(forward_headers);
2581 
2582  // \f$\Gamma_f \equiv \gamma_5 Q_{\alpha jk}\gamma_j D_k\f$
2583  return project(a1xVector_E(threePtDVector(quark_propagators[0],u), getDerivDir()));
2584  }
2585 
2586 
2587  // Compute the 2-pt at the sink
2588  Complex
2589  MesA0A1xDESeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2590  const multi1d<ForwardProp_t>& forward_headers,
2591  const multi1d<LatticePropagator>& quark_propagators,
2592  int insertion)
2593  {
2594  START_CODE();
2595 
2596  LatticeComplex corr_fn = zero;
2597  int G5 = Ns*Ns-1;
2598 
2599  check1Args("MesA0A1xDESeqSrc", quark_propagators);
2600  setTSrce(forward_headers);
2601 
2602  LatticePropagator tmp = quark_propagators[0];
2603 
2604  // \f$\Gamma_f \equiv \gamma_5 Q_{\alpha jk}\gamma_j D_k\f$
2605  for(int j=0; j < 3; ++j)
2606  for(int k=0; k < 3; ++k)
2607  {
2608  Real e = ETensor3d(getDerivDir(),j,k);
2609  if (toBool(e != 0.0))
2610  corr_fn += e * gammaSgn(G5,1<<j) * twoPtD(tmp,u,k,G5^(1<<j),insertion);
2611  }
2612 
2613  END_CODE();
2614 
2615  return momentumProject(corr_fn);
2616  }
2617 
2618 
2619  //---------------------------------------------------------------------------------
2620  // Construct a0-(b1xD_A2) sequential source
2621  LatticePropagator
2622  MesA0B1xDA2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2623  const multi1d<ForwardProp_t>& forward_headers,
2624  const multi1d<LatticePropagator>& quark_propagators)
2625  {
2626  check1Args("MesA0B1xDA2SeqSrc", quark_propagators);
2627  setTSrce(forward_headers);
2628 
2629  // \f$\Gamma_f \equiv \gamma_4\gamma_5 \gamma_i D_i\f$
2630  return project(-b1xVector_sum(threePtDVector(quark_propagators[0],u)));
2631  }
2632 
2633 
2634  // Compute the 2-pt at the sink
2635  Complex
2636  MesA0B1xDA2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2637  const multi1d<ForwardProp_t>& forward_headers,
2638  const multi1d<LatticePropagator>& quark_propagators,
2639  int insertion)
2640  {
2641  START_CODE();
2642 
2643  LatticeComplex corr_fn = zero;
2644  int G5 = Ns*Ns-1;
2645 
2646  check1Args("MesA0B1xDA2SeqSrc", quark_propagators);
2647  setTSrce(forward_headers);
2648 
2649  LatticePropagator tmp = quark_propagators[0];
2650 
2651  // \f$\Gamma_f \equiv \gamma_4\gamma_5 \gamma_i D_i\f$
2652  for(int k=0; k < 3; ++k)
2653  corr_fn += gammaSgn(1<<3,G5) * gammaSgn((1<<3)^G5,1<<k) *
2654  twoPtD(tmp,u,k,(1<<3)^G5^(1<<k),insertion);
2655 
2656  END_CODE();
2657 
2658  return momentumProject(corr_fn);
2659  }
2660 
2661 
2662  // Construct a0-(b1xD_T1) sequential source
2663  LatticePropagator
2664  MesA0B1xDT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2665  const multi1d<ForwardProp_t>& forward_headers,
2666  const multi1d<LatticePropagator>& quark_propagators)
2667  {
2668  check1Args("MesA0B1xDT1SeqSrc", quark_propagators);
2669  setTSrce(forward_headers);
2670 
2671  // \f$\Gamma_f \equiv \gamma_4\gamma_5 s_{ijk}\gamma_j D_k\f$
2672  return project(-b1xVector_sym(threePtDVector(quark_propagators[0],u), getDerivDir()));
2673  }
2674 
2675 
2676  // Compute the 2-pt at the sink
2677  Complex
2678  MesA0B1xDT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2679  const multi1d<ForwardProp_t>& forward_headers,
2680  const multi1d<LatticePropagator>& quark_propagators,
2681  int insertion)
2682  {
2683  START_CODE();
2684 
2685  LatticeComplex corr_fn = zero;
2686  int G5 = Ns*Ns-1;
2687 
2688  check1Args("MesA0B1xDT1SeqSrc", quark_propagators);
2689  setTSrce(forward_headers);
2690 
2691  LatticePropagator tmp = quark_propagators[0];
2692 
2693  // \f$\Gamma_f \equiv \gamma_4\gamma_5 s_{ijk}\gamma_j D_k\f$
2694  for(int j=0; j < 3; ++j)
2695  for(int k=0; k < 3; ++k)
2696  {
2697  int s = symTensor3d(getDerivDir(),j,k);
2698  if (s != 0)
2699  corr_fn += Real(s) * gammaSgn(1<<3,G5) * gammaSgn((1<<3)^G5,1<<j) *
2700  twoPtD(tmp,u,k,(1<<3)^G5^(1<<j),insertion);
2701  }
2702 
2703  END_CODE();
2704 
2705  return momentumProject(corr_fn);
2706  }
2707 
2708 
2709  // Construct a0-(b1xD_T2) sequential source
2710  LatticePropagator
2711  MesA0B1xDT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2712  const multi1d<ForwardProp_t>& forward_headers,
2713  const multi1d<LatticePropagator>& quark_propagators)
2714  {
2715  check1Args("MesA0B1xDT2SeqSrc", quark_propagators);
2716  setTSrce(forward_headers);
2717 
2718  // \f$\Gamma_f \equiv \gamma_4\gamma_5 s_{ijk}\gamma_j D_k\f$
2719  return project(-b1xVector_antisym(threePtDVector(quark_propagators[0],u), getDerivDir()));
2720  }
2721 
2722 
2723  // Compute the 2-pt at the sink
2724  Complex
2725  MesA0B1xDT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2726  const multi1d<ForwardProp_t>& forward_headers,
2727  const multi1d<LatticePropagator>& quark_propagators,
2728  int insertion)
2729  {
2730  START_CODE();
2731 
2732  LatticeComplex corr_fn = zero;
2733  int G5 = Ns*Ns-1;
2734 
2735  check1Args("MesA0B1xDT2SeqSrc", quark_propagators);
2736  setTSrce(forward_headers);
2737 
2738  LatticePropagator tmp = quark_propagators[0];
2739 
2740  // \f$\Gamma_f \equiv \gamma_4\gamma_5 \epsilon_{ijk}\gamma_j D_k\f$
2741  for(int j=0; j < 3; ++j)
2742  for(int k=0; k < 3; ++k)
2743  {
2744  int a = antiSymTensor3d(getDerivDir(),j,k);
2745  if (a != 0)
2746  corr_fn += Real(a) * gammaSgn(1<<3,G5) * gammaSgn((1<<3)^G5,1<<j) *
2747  twoPtD(tmp,u,k,(1<<3)^G5^(1<<j),insertion);
2748  }
2749 
2750  END_CODE();
2751 
2752  return momentumProject(corr_fn);
2753  }
2754 
2755 
2756  // Construct a0-(b1xD_E) sequential source
2757  LatticePropagator
2758  MesA0B1xDESeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2759  const multi1d<ForwardProp_t>& forward_headers,
2760  const multi1d<LatticePropagator>& quark_propagators)
2761  {
2762  check1Args("MesA0B1xDESeqSrc", quark_propagators);
2763  setTSrce(forward_headers);
2764 
2765  // \f$\Gamma_f \equiv \gamma_4\gamma_5 Q_{\alpha jk}\gamma_j D_k\f$
2766  return project(-b1xVector_E(threePtDVector(quark_propagators[0],u), getDerivDir()));
2767  }
2768 
2769 
2770  // Compute the 2-pt at the sink
2771  Complex
2772  MesA0B1xDESeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2773  const multi1d<ForwardProp_t>& forward_headers,
2774  const multi1d<LatticePropagator>& quark_propagators,
2775  int insertion)
2776  {
2777  START_CODE();
2778 
2779  LatticeComplex corr_fn = zero;
2780  int G5 = Ns*Ns-1;
2781 
2782  check1Args("MesA0B1xDESeqSrc", quark_propagators);
2783  setTSrce(forward_headers);
2784 
2785  LatticePropagator tmp = quark_propagators[0];
2786 
2787  // \f$\Gamma_f \equiv \gamma_4\gamma_5 Q_{\alpha jk}\gamma_j D_k\f$
2788  for(int j=0; j < 3; ++j)
2789  for(int k=0; k < 3; ++k)
2790  {
2791  Real e = ETensor3d(getDerivDir(),j,k);
2792  if (toBool(e != 0.0))
2793  corr_fn += e * gammaSgn(1<<3,G5) * gammaSgn((1<<3)^G5,1<<j) *
2794  twoPtD(tmp,u,k,(1<<3)^G5^(1<<j),insertion);
2795  }
2796 
2797  END_CODE();
2798 
2799  return momentumProject(corr_fn);
2800  }
2801 
2802 
2803  //---------------------------------------------------------------------------------
2804  //! Construct a0-(a0xB_T1) sequential source
2805  LatticePropagator
2806  MesA0A0xBT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2807  const multi1d<ForwardProp_t>& forward_headers,
2808  const multi1d<LatticePropagator>& quark_propagators)
2809  {
2810  check1Args("MesA0A0xBT1SeqSrc", quark_propagators);
2811  setTSrce(forward_headers);
2812 
2813  // \f$\Gamma_f \equiv B_i\f$
2814  return project(a0xVector(threePtB(quark_propagators[0],u,getDerivDir())));
2815  }
2816 
2817 
2818  // Compute the 2-pt at the sink
2819  Complex
2820  MesA0A0xBT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2821  const multi1d<ForwardProp_t>& forward_headers,
2822  const multi1d<LatticePropagator>& quark_propagators,
2823  int insertion)
2824  {
2825  START_CODE();
2826 
2827  int G5 = Ns*Ns-1;
2828 
2829  check1Args("MesA0A0xBT1SeqSrc", quark_propagators);
2830  setTSrce(forward_headers);
2831 
2832  LatticePropagator tmp = quark_propagators[0];
2833 
2834  // \f$\Gamma_f \equiv B_i\f$
2835  LatticeComplex corr_fn = twoPtB(tmp,u,getDerivDir(),0,insertion);
2836 
2837  END_CODE();
2838 
2839  return momentumProject(corr_fn);
2840  }
2841 
2842 
2843  //! Construct a0-(pionxB_T1) sequential source
2844  LatticePropagator
2845  MesA0PionxBT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2846  const multi1d<ForwardProp_t>& forward_headers,
2847  const multi1d<LatticePropagator>& quark_propagators)
2848  {
2849  check1Args("MesA0PionxBT1SeqSrc", quark_propagators);
2850  setTSrce(forward_headers);
2851 
2852  // \f$\Gamma_f \equiv \gamma_5 B_i\f$
2853  return project(pionxVector(threePtB(quark_propagators[0],u,getDerivDir())));
2854  }
2855 
2856 
2857  // Compute the 2-pt at the sink
2858  Complex
2859  MesA0PionxBT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2860  const multi1d<ForwardProp_t>& forward_headers,
2861  const multi1d<LatticePropagator>& quark_propagators,
2862  int insertion)
2863  {
2864  START_CODE();
2865 
2866  int G5 = Ns*Ns-1;
2867 
2868  check1Args("MesA0PionxBT1SeqSrc", quark_propagators);
2869  setTSrce(forward_headers);
2870 
2871  LatticePropagator tmp = quark_propagators[0];
2872 
2873  // \f$\Gamma_f \equiv \gamma_5 B_i\f$
2874  LatticeComplex corr_fn = twoPtB(tmp,u,getDerivDir(), G5, insertion);
2875 
2876  END_CODE();
2877 
2878  return momentumProject(corr_fn);
2879  }
2880 
2881 
2882  //! Construct a0-(pion_2xB_T1) sequential source
2883  LatticePropagator
2884  MesA0Pion2xBT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2885  const multi1d<ForwardProp_t>& forward_headers,
2886  const multi1d<LatticePropagator>& quark_propagators)
2887  {
2888  check1Args("MesA0Pion2xBT1SeqSrc", quark_propagators);
2889  setTSrce(forward_headers);
2890 
2891  // \f$\Gamma_f \equiv \gamma_4\gamma_5 B_i\f$
2892  return project(pion_2xVector(threePtB(quark_propagators[0],u,getDerivDir())));
2893  }
2894 
2895 
2896  // Compute the 2-pt at the sink
2897  Complex
2898  MesA0Pion2xBT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2899  const multi1d<ForwardProp_t>& forward_headers,
2900  const multi1d<LatticePropagator>& quark_propagators,
2901  int insertion)
2902  {
2903  START_CODE();
2904 
2905  int G5 = Ns*Ns-1;
2906 
2907  check1Args("MesA0Pion2xBT1SeqSrc", quark_propagators);
2908  setTSrce(forward_headers);
2909 
2910  LatticePropagator tmp = quark_propagators[0];
2911 
2912  // \f$\Gamma_f \equiv \gamma_4\gamma_5 B_i\f$
2913  LatticeComplex corr_fn = gammaSgn(1<<3,G5) * twoPtB(tmp,u,getDerivDir(), (1<<3)^G5, insertion);
2914 
2915  END_CODE();
2916 
2917  return momentumProject(corr_fn);
2918  }
2919 
2920 
2921  //! Construct a0-(a0_2xB_T1) sequential source
2922  LatticePropagator
2923  MesA0A02xBT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2924  const multi1d<ForwardProp_t>& forward_headers,
2925  const multi1d<LatticePropagator>& quark_propagators)
2926  {
2927  check1Args("MesA0A02xBT1SeqSrc", quark_propagators);
2928  setTSrce(forward_headers);
2929 
2930  // \f$\Gamma_f \equiv \gamma_4 B_i\f$
2931  return project(-a0_2xVector(threePtB(quark_propagators[0],u,getDerivDir())));
2932  }
2933 
2934 
2935  // Compute the 2-pt at the sink
2936  Complex
2937  MesA0A02xBT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2938  const multi1d<ForwardProp_t>& forward_headers,
2939  const multi1d<LatticePropagator>& quark_propagators,
2940  int insertion)
2941  {
2942  START_CODE();
2943 
2944  check1Args("MesA0A02xBT1SeqSrc", quark_propagators);
2945  setTSrce(forward_headers);
2946 
2947  LatticePropagator tmp = quark_propagators[0];
2948 
2949  // \f$\Gamma_f \equiv \gamma_4 B_i\f$
2950  LatticeComplex corr_fn = twoPtB(tmp,u,getDerivDir(), 1<<3, insertion);
2951 
2952  END_CODE();
2953 
2954  return momentumProject(corr_fn);
2955  }
2956 
2957 
2958  //---------------------------------------------------------------------------------
2959  //! Construct a0-(rhoxB_A1) sequential source
2960  LatticePropagator
2961  MesA0RhoxBA1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
2962  const multi1d<ForwardProp_t>& forward_headers,
2963  const multi1d<LatticePropagator>& quark_propagators)
2964  {
2965  check1Args("MesA0RhoxBA1SeqSrc", quark_propagators);
2966  setTSrce(forward_headers);
2967 
2968  // \f$\Gamma_f \equiv \gamma_i B_i\f$
2969  return project(-rhoxVector_sum(threePtBVector(quark_propagators[0],u)));
2970  }
2971 
2972 
2973  // Compute the 2-pt at the sink
2974  Complex
2975  MesA0RhoxBA1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
2976  const multi1d<ForwardProp_t>& forward_headers,
2977  const multi1d<LatticePropagator>& quark_propagators,
2978  int insertion)
2979  {
2980  START_CODE();
2981 
2982  LatticeComplex corr_fn = zero;
2983  int G5 = Ns*Ns-1;
2984 
2985  check1Args("MesA0RhoxBA1SeqSrc", quark_propagators);
2986  setTSrce(forward_headers);
2987 
2988  LatticePropagator tmp = quark_propagators[0];
2989 
2990  // \f$\Gamma_f \equiv \gamma_i B_i\f$
2991  for(int k=0; k < 3; ++k)
2992  corr_fn += twoPtB(tmp,u,k, 1<<k, insertion);
2993 
2994  END_CODE();
2995 
2996  return momentumProject(corr_fn);
2997  }
2998 
2999 
3000  //! Construct a0-(rhoxB_T1) sequential source
3001  LatticePropagator
3002  MesA0RhoxBT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3003  const multi1d<ForwardProp_t>& forward_headers,
3004  const multi1d<LatticePropagator>& quark_propagators)
3005  {
3006  check1Args("MesA0RhoxBT1SeqSrc", quark_propagators);
3007  setTSrce(forward_headers);
3008 
3009  // \f$\Gamma_f \equiv \epsilon_{ijk}\gamma_j B_k\f$
3010  return project(-rhoxVector_antisym(threePtBVector(quark_propagators[0],u), getDerivDir()));
3011  }
3012 
3013 
3014  // Compute the 2-pt at the sink
3015  Complex
3016  MesA0RhoxBT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3017  const multi1d<ForwardProp_t>& forward_headers,
3018  const multi1d<LatticePropagator>& quark_propagators,
3019  int insertion)
3020  {
3021  START_CODE();
3022 
3023  LatticeComplex corr_fn = zero;
3024  int G5 = Ns*Ns-1;
3025 
3026  check1Args("MesA0RhoxBT1SeqSrc", quark_propagators);
3027  setTSrce(forward_headers);
3028 
3029  LatticePropagator tmp = quark_propagators[0];
3030 
3031  // \f$\Gamma_f \equiv \epsilon_{ijk}\gamma_j B_k\f$
3032  for(int j=0; j < 3; ++j)
3033  for(int k=0; k < 3; ++k)
3034  {
3035  int a = antiSymTensor3d(getDerivDir(),j,k);
3036  if (a != 0)
3037  corr_fn += Real(a) * twoPtB(tmp,u,k, 1<<j, insertion);
3038  }
3039 
3040  END_CODE();
3041 
3042  return momentumProject(corr_fn);
3043  }
3044 
3045 
3046  //! Construct a0-(rhoxB_T2) sequential source
3047  LatticePropagator
3048  MesA0RhoxBT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3049  const multi1d<ForwardProp_t>& forward_headers,
3050  const multi1d<LatticePropagator>& quark_propagators)
3051  {
3052  check1Args("MesA0RhoxBT2SeqSrc", quark_propagators);
3053  setTSrce(forward_headers);
3054 
3055  // \f$\Gamma_f \equiv s_{ijk}\gamma_j B_k\f$
3056  return project(-rhoxVector_sym(threePtBVector(quark_propagators[0],u), getDerivDir()));
3057  }
3058 
3059 
3060  // Compute the 2-pt at the sink
3061  Complex
3062  MesA0RhoxBT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3063  const multi1d<ForwardProp_t>& forward_headers,
3064  const multi1d<LatticePropagator>& quark_propagators,
3065  int insertion)
3066  {
3067  START_CODE();
3068 
3069  LatticeComplex corr_fn = zero;
3070  int G5 = Ns*Ns-1;
3071 
3072  check1Args("MesA0RhoxBT2SeqSrc", quark_propagators);
3073  setTSrce(forward_headers);
3074 
3075  LatticePropagator tmp = quark_propagators[0];
3076 
3077  // \f$\Gamma_f \equiv s_{ijk}\gamma_j B_k\f$
3078  for(int j=0; j < 3; ++j)
3079  for(int k=0; k < 3; ++k)
3080  {
3081  int s = symTensor3d(getDerivDir(),j,k);
3082  if (s != 0)
3083  corr_fn += Real(s) * twoPtB(tmp,u,k, 1<<j, insertion);
3084  }
3085 
3086  END_CODE();
3087 
3088  return momentumProject(corr_fn);
3089  }
3090 
3091 
3092  //! Construct a0-(rhoxB_E) sequential source
3093  LatticePropagator
3094  MesA0RhoxBESeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3095  const multi1d<ForwardProp_t>& forward_headers,
3096  const multi1d<LatticePropagator>& quark_propagators)
3097  {
3098  check1Args("MesA0RhoxBESeqSrc", quark_propagators);
3099  setTSrce(forward_headers);
3100 
3101  // \f$\Gamma_f \equiv Q_{\alpha jk}\gamma_j B_k\f$
3102  return project(-rhoxVector_E(threePtBVector(quark_propagators[0],u), getDerivDir()));
3103  }
3104 
3105 
3106  // Compute the 2-pt at the sink
3107  Complex
3108  MesA0RhoxBESeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3109  const multi1d<ForwardProp_t>& forward_headers,
3110  const multi1d<LatticePropagator>& quark_propagators,
3111  int insertion)
3112  {
3113  START_CODE();
3114 
3115  LatticeComplex corr_fn = zero;
3116  int G5 = Ns*Ns-1;
3117 
3118  check1Args("MesA0RhoxBESeqSrc", quark_propagators);
3119  setTSrce(forward_headers);
3120 
3121  LatticePropagator tmp = quark_propagators[0];
3122 
3123  // \f$\Gamma_f \equiv Q_{\alpha jk}\gamma_j B_k\f$
3124  for(int j=0; j < 3; ++j)
3125  for(int k=0; k < 3; ++k)
3126  {
3127  Real e = ETensor3d(getDerivDir(),j,k);
3128  if (toBool(e != 0.0))
3129  corr_fn += e * twoPtB(tmp,u,k, 1<<j, insertion);
3130  }
3131 
3132  END_CODE();
3133 
3134  return momentumProject(corr_fn);
3135  }
3136 
3137 
3138 
3139  //---------------------------------------------------------------------------------
3140  //! Construct a0-(rho_2xB_A1) sequential source
3141  LatticePropagator
3142  MesA0Rho2xBA1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3143  const multi1d<ForwardProp_t>& forward_headers,
3144  const multi1d<LatticePropagator>& quark_propagators)
3145  {
3146  check1Args("MesA0Rho2xBA1SeqSrc", quark_propagators);
3147  setTSrce(forward_headers);
3148 
3149  // \f$\Gamma_f \equiv \gamma_4\gamma_i B_i\f$
3150  return project(-rho_2xVector_sum(threePtBVector(quark_propagators[0],u)));
3151  }
3152 
3153 
3154  // Compute the 2-pt at the sink
3155  Complex
3156  MesA0Rho2xBA1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3157  const multi1d<ForwardProp_t>& forward_headers,
3158  const multi1d<LatticePropagator>& quark_propagators,
3159  int insertion)
3160  {
3161  START_CODE();
3162 
3163  LatticeComplex corr_fn = zero;
3164  int G5 = Ns*Ns-1;
3165 
3166  check1Args("MesA0Rho2xBA1SeqSrc", quark_propagators);
3167  setTSrce(forward_headers);
3168 
3169  LatticePropagator tmp = quark_propagators[0];
3170 
3171  // \f$\Gamma_f \equiv \gamma_4\gamma_i B_i\f$
3172  for(int k=0; k < 3; ++k)
3173  corr_fn += gammaSgn(1<<3,1<<k) * twoPtB(tmp,u,k, (1<<3)^(1<<k), insertion);
3174 
3175  END_CODE();
3176 
3177  return momentumProject(corr_fn);
3178  }
3179 
3180 
3181  //! Construct a0-(rho_2xB_T1) sequential source
3182  LatticePropagator
3183  MesA0Rho2xBT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3184  const multi1d<ForwardProp_t>& forward_headers,
3185  const multi1d<LatticePropagator>& quark_propagators)
3186  {
3187  check1Args("MesA0Rho2xBT1SeqSrc", quark_propagators);
3188  setTSrce(forward_headers);
3189 
3190  // \f$\Gamma_f \equiv \epsilon_{ijk}\gamma_4\gamma_j B_k\f$
3191  return project(-rho_2xVector_antisym(threePtBVector(quark_propagators[0],u), getDerivDir()));
3192  }
3193 
3194 
3195  // Compute the 2-pt at the sink
3196  Complex
3197  MesA0Rho2xBT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3198  const multi1d<ForwardProp_t>& forward_headers,
3199  const multi1d<LatticePropagator>& quark_propagators,
3200  int insertion)
3201  {
3202  START_CODE();
3203 
3204  LatticeComplex corr_fn = zero;
3205  int G5 = Ns*Ns-1;
3206 
3207  check1Args("MesA0Rho2xBT1SeqSrc", quark_propagators);
3208  setTSrce(forward_headers);
3209 
3210  LatticePropagator tmp = quark_propagators[0];
3211 
3212  // \f$\Gamma_f \equiv \epsilon_{ijk}\gamma_4\gamma_j B_k\f$
3213  for(int j=0; j < 3; ++j)
3214  for(int k=0; k < 3; ++k)
3215  {
3216  int a = antiSymTensor3d(getDerivDir(),j,k);
3217  if (a != 0)
3218  corr_fn += Real(a) * gammaSgn(1<<3,1<<j) * twoPtB(tmp,u,k, (1<<3)^(1<<j), insertion);
3219  }
3220 
3221  END_CODE();
3222 
3223  return momentumProject(corr_fn);
3224  }
3225 
3226 
3227  //! Construct a0-(rho_2xB_T2) sequential source
3228  LatticePropagator
3229  MesA0Rho2xBT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3230  const multi1d<ForwardProp_t>& forward_headers,
3231  const multi1d<LatticePropagator>& quark_propagators)
3232  {
3233  check1Args("MesA0Rho2xBT2SeqSrc", quark_propagators);
3234  setTSrce(forward_headers);
3235 
3236  // \f$\Gamma_f \equiv s_{ijk}\gamma_4\gamma_j B_k\f$
3237  return project(-rho_2xVector_sym(threePtBVector(quark_propagators[0],u), getDerivDir()));
3238  }
3239 
3240 
3241  // Compute the 2-pt at the sink
3242  Complex
3243  MesA0Rho2xBT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3244  const multi1d<ForwardProp_t>& forward_headers,
3245  const multi1d<LatticePropagator>& quark_propagators,
3246  int insertion)
3247  {
3248  START_CODE();
3249 
3250  LatticeComplex corr_fn = zero;
3251  int G5 = Ns*Ns-1;
3252 
3253  check1Args("MesA0Rho2xBT2SeqSrc", quark_propagators);
3254  setTSrce(forward_headers);
3255 
3256  LatticePropagator tmp = quark_propagators[0];
3257 
3258  // \f$\Gamma_f \equiv s_{ijk}\gamma_4\gamma_j B_k\f$
3259  for(int j=0; j < 3; ++j)
3260  for(int k=0; k < 3; ++k)
3261  {
3262  int s = symTensor3d(getDerivDir(),j,k);
3263  if (s != 0)
3264  corr_fn += Real(s) * gammaSgn(1<<3,1<<j) * twoPtB(tmp,u,k, (1<<3)^(1<<j), insertion);
3265  }
3266 
3267  END_CODE();
3268 
3269  return momentumProject(corr_fn);
3270  }
3271 
3272 
3273  //! Construct a0-(rho_2xB_E) sequential source
3274  LatticePropagator
3275  MesA0Rho2xBESeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3276  const multi1d<ForwardProp_t>& forward_headers,
3277  const multi1d<LatticePropagator>& quark_propagators)
3278  {
3279  check1Args("MesA0Rho2xBESeqSrc", quark_propagators);
3280  setTSrce(forward_headers);
3281 
3282  // \f$\Gamma_f \equiv Q_{\alpha jk}\gamma_4\gamma_j B_k\f$
3283  return project(-rho_2xVector_E(threePtBVector(quark_propagators[0],u), getDerivDir()));
3284  }
3285 
3286 
3287  // Compute the 2-pt at the sink
3288  Complex
3289  MesA0Rho2xBESeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3290  const multi1d<ForwardProp_t>& forward_headers,
3291  const multi1d<LatticePropagator>& quark_propagators,
3292  int insertion)
3293  {
3294  START_CODE();
3295 
3296  LatticeComplex corr_fn = zero;
3297  int G5 = Ns*Ns-1;
3298 
3299  check1Args("MesA0Rho2xBESeqSrc", quark_propagators);
3300  setTSrce(forward_headers);
3301 
3302  LatticePropagator tmp = quark_propagators[0];
3303 
3304  // \f$\Gamma_f \equiv Q_{\alpha jk}\gamma_4\gamma_j B_k\f$
3305  for(int j=0; j < 3; ++j)
3306  for(int k=0; k < 3; ++k)
3307  {
3308  Real e = ETensor3d(getDerivDir(),j,k);
3309  if (toBool(e != 0.0))
3310  corr_fn += e * gammaSgn(1<<3,1<<j) * twoPtB(tmp,u,k, (1<<3)^(1<<j), insertion);
3311  }
3312 
3313  END_CODE();
3314 
3315  return momentumProject(corr_fn);
3316  }
3317 
3318 
3319  //---------------------------------------------------------------------------------
3320  //! Construct a0-(a1xB_A1) sequential source
3321  LatticePropagator
3322  MesA0A1xBA1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3323  const multi1d<ForwardProp_t>& forward_headers,
3324  const multi1d<LatticePropagator>& quark_propagators)
3325  {
3326  check1Args("MesA0A1xBA1SeqSrc", quark_propagators);
3327  setTSrce(forward_headers);
3328 
3329  // \f$\Gamma_f \equiv \gamma_5 \gamma_i B_i\f$
3330  return project(a1xVector_sum(threePtBVector(quark_propagators[0],u)));
3331  }
3332 
3333 
3334  // Compute the 2-pt at the sink
3335  Complex
3336  MesA0A1xBA1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3337  const multi1d<ForwardProp_t>& forward_headers,
3338  const multi1d<LatticePropagator>& quark_propagators,
3339  int insertion)
3340  {
3341  START_CODE();
3342 
3343  LatticeComplex corr_fn = zero;
3344  int G5 = Ns*Ns-1;
3345 
3346  check1Args("MesA0A1xBA1SeqSrc", quark_propagators);
3347  setTSrce(forward_headers);
3348 
3349  LatticePropagator tmp = quark_propagators[0];
3350 
3351  // \f$\Gamma_f \equiv \gamma_5 \gamma_i B_i\f$
3352  for(int k=0; k < 3; ++k)
3353  corr_fn += gammaSgn(G5,1<<k) * twoPtB(tmp,u,k, G5^(1<<k), insertion);
3354 
3355  END_CODE();
3356 
3357  return momentumProject(corr_fn);
3358  }
3359 
3360 
3361  //! Construct a0-(a1xB_T1) sequential source
3362  LatticePropagator
3363  MesA0A1xBT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3364  const multi1d<ForwardProp_t>& forward_headers,
3365  const multi1d<LatticePropagator>& quark_propagators)
3366  {
3367  check1Args("MesA0A1xBT1SeqSrc", quark_propagators);
3368  setTSrce(forward_headers);
3369 
3370  // \f$\Gamma_f \equiv \gamma_5 \epsilon_{ijk}\gamma_j B_k\f$
3371  return project(a1xVector_antisym(threePtBVector(quark_propagators[0],u), getDerivDir()));
3372  }
3373 
3374 
3375  // Compute the 2-pt at the sink
3376  Complex
3377  MesA0A1xBT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3378  const multi1d<ForwardProp_t>& forward_headers,
3379  const multi1d<LatticePropagator>& quark_propagators,
3380  int insertion)
3381  {
3382  START_CODE();
3383 
3384  LatticeComplex corr_fn = zero;
3385  int G5 = Ns*Ns-1;
3386 
3387  check1Args("MesA0A1xBT1SeqSrc", quark_propagators);
3388  setTSrce(forward_headers);
3389 
3390  LatticePropagator tmp = quark_propagators[0];
3391 
3392  // \f$\Gamma_f \equiv \gamma_5 \epsilon_{ijk}\gamma_j B_k\f$
3393  for(int j=0; j < 3; ++j)
3394  for(int k=0; k < 3; ++k)
3395  {
3396  int a = antiSymTensor3d(getDerivDir(),j,k);
3397  if (a != 0)
3398  corr_fn += Real(a) * gammaSgn(G5,1<<j) * twoPtB(tmp,u,k, G5^(1<<j), insertion);
3399  }
3400 
3401  END_CODE();
3402 
3403  return momentumProject(corr_fn);
3404  }
3405 
3406 
3407  //! Construct a0-(a1xB_T2) sequential source
3408  LatticePropagator
3409  MesA0A1xBT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3410  const multi1d<ForwardProp_t>& forward_headers,
3411  const multi1d<LatticePropagator>& quark_propagators)
3412  {
3413  check1Args("MesA0A1xBT2SeqSrc", quark_propagators);
3414  setTSrce(forward_headers);
3415 
3416  // \f$\Gamma_f \equiv \gamma_5 s_{ijk}\gamma_j B_k\f$
3417  return project(a1xVector_sym(threePtBVector(quark_propagators[0],u), getDerivDir()));
3418  }
3419 
3420 
3421  // Compute the 2-pt at the sink
3422  Complex
3423  MesA0A1xBT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3424  const multi1d<ForwardProp_t>& forward_headers,
3425  const multi1d<LatticePropagator>& quark_propagators,
3426  int insertion)
3427  {
3428  START_CODE();
3429 
3430  LatticeComplex corr_fn = zero;
3431  int G5 = Ns*Ns-1;
3432 
3433  check1Args("MesA0A1xBT2SeqSrc", quark_propagators);
3434  setTSrce(forward_headers);
3435 
3436  LatticePropagator tmp = quark_propagators[0];
3437 
3438  // \f$\Gamma_f \equiv \gamma_5 s_{ijk}\gamma_j B_k\f$
3439  for(int j=0; j < 3; ++j)
3440  for(int k=0; k < 3; ++k)
3441  {
3442  int s = symTensor3d(getDerivDir(),j,k);
3443  if (s != 0)
3444  corr_fn += Real(s) * gammaSgn(G5,1<<j) * twoPtB(tmp,u,k, G5^(1<<j), insertion);
3445  }
3446 
3447  END_CODE();
3448 
3449  return momentumProject(corr_fn);
3450  }
3451 
3452 
3453  //! Construct a0-(a1xB_E) sequential source
3454  LatticePropagator
3455  MesA0A1xBESeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3456  const multi1d<ForwardProp_t>& forward_headers,
3457  const multi1d<LatticePropagator>& quark_propagators)
3458  {
3459  check1Args("MesA0A1xBESeqSrc", quark_propagators);
3460  setTSrce(forward_headers);
3461 
3462  // \f$\Gamma_f \equiv \gamma_5 Q_{\alpha jk}\gamma_j B_k\f$
3463  return project(a1xVector_E(threePtBVector(quark_propagators[0],u), getDerivDir()));
3464  }
3465 
3466 
3467  // Compute the 2-pt at the sink
3468  Complex
3469  MesA0A1xBESeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3470  const multi1d<ForwardProp_t>& forward_headers,
3471  const multi1d<LatticePropagator>& quark_propagators,
3472  int insertion)
3473  {
3474  START_CODE();
3475 
3476  LatticeComplex corr_fn = zero;
3477  int G5 = Ns*Ns-1;
3478 
3479  check1Args("MesA0A1xBESeqSrc", quark_propagators);
3480  setTSrce(forward_headers);
3481 
3482  LatticePropagator tmp = quark_propagators[0];
3483 
3484  // \f$\Gamma_f \equiv \gamma_5 Q_{\alpha jk}\gamma_j B_k\f$
3485  for(int j=0; j < 3; ++j)
3486  for(int k=0; k < 3; ++k)
3487  {
3488  Real e = ETensor3d(getDerivDir(),j,k);
3489  if (toBool(e != 0.0))
3490  corr_fn += e * gammaSgn(G5,1<<j) * twoPtB(tmp,u,k, G5^(1<<j), insertion);
3491  }
3492 
3493  END_CODE();
3494 
3495  return momentumProject(corr_fn);
3496  }
3497 
3498 
3499  //---------------------------------------------------------------------------------
3500  //! Construct a0-(b1xB_A1) sequential source
3501  LatticePropagator
3502  MesA0B1xBA1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3503  const multi1d<ForwardProp_t>& forward_headers,
3504  const multi1d<LatticePropagator>& quark_propagators)
3505  {
3506  check1Args("MesA0B1xBA1SeqSrc", quark_propagators);
3507  setTSrce(forward_headers);
3508 
3509  // \f$\Gamma_f \equiv \gamma_4 \gamma_5 \gamma_i B_i\f$
3510  return project(-b1xVector_sum(threePtBVector(quark_propagators[0],u)));
3511  }
3512 
3513 
3514  // Compute the 2-pt at the sink
3515  Complex
3516  MesA0B1xBA1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3517  const multi1d<ForwardProp_t>& forward_headers,
3518  const multi1d<LatticePropagator>& quark_propagators,
3519  int insertion)
3520  {
3521  START_CODE();
3522 
3523  LatticeComplex corr_fn = zero;
3524  int G5 = Ns*Ns-1;
3525 
3526  check1Args("MesA0B1xBA1SeqSrc", quark_propagators);
3527  setTSrce(forward_headers);
3528 
3529  LatticePropagator tmp = quark_propagators[0];
3530 
3531  // \f$\Gamma_f \equiv \gamma_4 \gamma_5 \gamma_i B_i\f$
3532  for(int k=0; k < 3; ++k)
3533  corr_fn += gammaSgn(1<<3,G5) * gammaSgn((1<<3)^G5,1<<k) *
3534  twoPtB(tmp,u,k, (1<<3)^G5^(1<<k), insertion);
3535 
3536  END_CODE();
3537 
3538  return momentumProject(corr_fn);
3539  }
3540 
3541 
3542  //! Construct a0-(b1xB_T1) sequential source
3543  LatticePropagator
3544  MesA0B1xBT1SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3545  const multi1d<ForwardProp_t>& forward_headers,
3546  const multi1d<LatticePropagator>& quark_propagators)
3547  {
3548  check1Args("MesA0B1xBT1SeqSrc", quark_propagators);
3549  setTSrce(forward_headers);
3550 
3551  // \f$\Gamma_f \equiv \gamma_4\gamma_5 \epsilon_{ijk}\gamma_j B_k\f$
3552  return project(-b1xVector_antisym(threePtBVector(quark_propagators[0],u), getDerivDir()));
3553  }
3554 
3555 
3556  // Compute the 2-pt at the sink
3557  Complex
3558  MesA0B1xBT1SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3559  const multi1d<ForwardProp_t>& forward_headers,
3560  const multi1d<LatticePropagator>& quark_propagators,
3561  int insertion)
3562  {
3563  START_CODE();
3564 
3565  LatticeComplex corr_fn = zero;
3566  int G5 = Ns*Ns-1;
3567 
3568  check1Args("MesA0B1xBT1SeqSrc", quark_propagators);
3569  setTSrce(forward_headers);
3570 
3571  LatticePropagator tmp = quark_propagators[0];
3572 
3573  // \f$\Gamma_f \equiv \gamma_4 \gamma_5 \epsilon_{ijk}\gamma_j B_k\f$
3574  for(int j=0; j < 3; ++j)
3575  for(int k=0; k < 3; ++k)
3576  {
3577  int a = antiSymTensor3d(getDerivDir(),j,k);
3578  if (a != 0)
3579  corr_fn += Real(a) * gammaSgn(1<<3,G5) * gammaSgn((1<<3)^G5,1<<j) *
3580  twoPtB(tmp,u,k, (1<<3)^G5^(1<<j), insertion);
3581  }
3582 
3583  END_CODE();
3584 
3585  return momentumProject(corr_fn);
3586  }
3587 
3588 
3589  //! Construct a0-(b1xB_T2) sequential source
3590  LatticePropagator
3591  MesA0B1xBT2SeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3592  const multi1d<ForwardProp_t>& forward_headers,
3593  const multi1d<LatticePropagator>& quark_propagators)
3594  {
3595  check1Args("MesA0B1xBT2SeqSrc", quark_propagators);
3596  setTSrce(forward_headers);
3597 
3598  // \f$\Gamma_f \equiv \gamma_4 \gamma_5 s_{ijk}\gamma_j B_k\f$
3599  return project(-b1xVector_sym(threePtBVector(quark_propagators[0],u), getDerivDir()));
3600  }
3601 
3602 
3603  // Compute the 2-pt at the sink
3604  Complex
3605  MesA0B1xBT2SeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3606  const multi1d<ForwardProp_t>& forward_headers,
3607  const multi1d<LatticePropagator>& quark_propagators,
3608  int insertion)
3609  {
3610  START_CODE();
3611 
3612  LatticeComplex corr_fn = zero;
3613  int G5 = Ns*Ns-1;
3614 
3615  check1Args("MesA0B1xBT2SeqSrc", quark_propagators);
3616  setTSrce(forward_headers);
3617 
3618  LatticePropagator tmp = quark_propagators[0];
3619 
3620  // \f$\Gamma_f \equiv \gamma_4 \gamma_5 s_{ijk}\gamma_j B_k\f$
3621  for(int j=0; j < 3; ++j)
3622  for(int k=0; k < 3; ++k)
3623  {
3624  int s = symTensor3d(getDerivDir(),j,k);
3625  if (s != 0)
3626  corr_fn += Real(s) * gammaSgn(1<<3,G5) * gammaSgn((1<<3)^G5,1<<j) *
3627  twoPtB(tmp,u,k, (1<<3)^G5^(1<<j), insertion);
3628  }
3629 
3630  END_CODE();
3631 
3632  return momentumProject(corr_fn);
3633  }
3634 
3635 
3636  //! Construct a0-(b1xB_E) sequential source
3637  LatticePropagator
3638  MesA0B1xBESeqSrc::operator()(const multi1d<LatticeColorMatrix>& u,
3639  const multi1d<ForwardProp_t>& forward_headers,
3640  const multi1d<LatticePropagator>& quark_propagators)
3641  {
3642  check1Args("MesA0B1xBESeqSrc", quark_propagators);
3643  setTSrce(forward_headers);
3644 
3645  // \f$\Gamma_f \equiv \gamma_4 \gamma_5 Q_{\alpha jk}\gamma_j B_k\f$
3646  return project(-b1xVector_E(threePtBVector(quark_propagators[0],u), getDerivDir()));
3647  }
3648 
3649 
3650  // Compute the 2-pt at the sink
3651  Complex
3652  MesA0B1xBESeqSrc::twoPtSink(const multi1d<LatticeColorMatrix>& u,
3653  const multi1d<ForwardProp_t>& forward_headers,
3654  const multi1d<LatticePropagator>& quark_propagators,
3655  int insertion)
3656  {
3657  START_CODE();
3658 
3659  LatticeComplex corr_fn = zero;
3660  int G5 = Ns*Ns-1;
3661 
3662  check1Args("MesA0B1xBESeqSrc", quark_propagators);
3663  setTSrce(forward_headers);
3664 
3665  LatticePropagator tmp = quark_propagators[0];
3666 
3667  // \f$\Gamma_f \equiv \gamma_4 \gamma_5 Q_{\alpha jk}\gamma_j B_k\f$
3668  for(int j=0; j < 3; ++j)
3669  for(int k=0; k < 3; ++k)
3670  {
3671  Real e = ETensor3d(getDerivDir(),j,k);
3672  if (toBool(e != 0.0))
3673  corr_fn += e * gammaSgn(1<<3,G5) * gammaSgn((1<<3)^G5,1<<j) *
3674  twoPtB(tmp,u,k, (1<<3)^G5^(1<<j), insertion);
3675  }
3676 
3677  END_CODE();
3678 
3679  return momentumProject(corr_fn);
3680  }
3681 
3682 
3683  //---------------------------------------------------------------------------------
3684  namespace
3685  {
3686  //! Local registration flag
3687  bool registered = false;
3688  }
3689 
3690  //! Register all the factories
3691  bool registerAll()
3692  {
3693  bool success = true;
3694  if (! registered)
3695  {
3696  //! Register all the factories
3697  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a0xNABLA_T1"),
3698  mesA0A0xNablaT1SeqSrc);
3699  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-pionxNABLA_T1"),
3700  mesA0PionxNablaT1SeqSrc);
3701  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-pion_2xNABLA_T1"),
3702  mesA0Pion2xNablaT1SeqSrc);
3703  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a0_2xNABLA_T1"),
3704  mesA0A02xNablaT1SeqSrc);
3705 
3706  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rhoxNABLA_A1"),
3707  mesA0RhoxNablaA1SeqSrc);
3708  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rhoxNABLA_T1"),
3709  mesA0RhoxNablaT1SeqSrc);
3710  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rhoxNABLA_T2"),
3711  mesA0RhoxNablaT2SeqSrc);
3712  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rhoxNABLA_E"),
3713  mesA0RhoxNablaESeqSrc);
3714 
3715  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rho_2xNABLA_A1"),
3716  mesA0Rho2xNablaA1SeqSrc);
3717  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rho_2xNABLA_T1"),
3718  mesA0Rho2xNablaT1SeqSrc);
3719  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rho_2xNABLA_T2"),
3720  mesA0Rho2xNablaT2SeqSrc);
3721  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rho_2xNABLA_E"),
3722  mesA0Rho2xNablaESeqSrc);
3723 
3724  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a1xNABLA_A1"),
3725  mesA0A1xNablaA1SeqSrc);
3726  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a1xNABLA_T1"),
3727  mesA0A1xNablaT1SeqSrc);
3728  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a1xNABLA_T2"),
3729  mesA0A1xNablaT2SeqSrc);
3730  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a1xNABLA_E"),
3731  mesA0A1xNablaESeqSrc);
3732 
3733  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-b1xNABLA_A1"),
3734  mesA0B1xNablaA1SeqSrc);
3735  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-b1xNABLA_T1"),
3736  mesA0B1xNablaT1SeqSrc);
3737  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-b1xNABLA_T2"),
3738  mesA0B1xNablaT2SeqSrc);
3739  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-b1xNABLA_E"),
3740  mesA0B1xNablaESeqSrc);
3741 
3742  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a0xD_T2"),
3743  mesA0A0xDT2SeqSrc);
3744  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-pionxD_T2"),
3745  mesA0PionxDT2SeqSrc);
3746  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-pion_2xD_T2"),
3747  mesA0Pion2xDT2SeqSrc);
3748  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a0_2xD_T2"),
3749  mesA0A02xDT2SeqSrc);
3750 
3751  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rhoxD_A2"),
3752  mesA0RhoxDA2SeqSrc);
3753  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rhoxD_T1"),
3754  mesA0RhoxDT1SeqSrc);
3755  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rhoxD_T2"),
3756  mesA0RhoxDT2SeqSrc);
3757  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rhoxD_E"),
3758  mesA0RhoxDESeqSrc);
3759 
3760  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rho_2xD_A2"),
3761  mesA0Rho2xDA2SeqSrc);
3762  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rho_2xD_T1"),
3763  mesA0Rho2xDT1SeqSrc);
3764  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rho_2xD_T2"),
3765  mesA0Rho2xDT2SeqSrc);
3766  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rho_2xD_E"),
3767  mesA0Rho2xDESeqSrc);
3768 
3769  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a1xD_A2"),
3770  mesA0A1xDA2SeqSrc);
3771  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a1xD_T1"),
3772  mesA0A1xDT1SeqSrc);
3773  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a1xD_T2"),
3774  mesA0A1xDT2SeqSrc);
3775  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a1xD_E"),
3776  mesA0A1xDESeqSrc);
3777 
3778  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-b1xD_A2"),
3779  mesA0B1xDA2SeqSrc);
3780  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-b1xD_T1"),
3781  mesA0B1xDT1SeqSrc);
3782  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-b1xD_T2"),
3783  mesA0B1xDT2SeqSrc);
3784  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-b1xD_E"),
3785  mesA0B1xDESeqSrc);
3786 
3787  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a0xB_T1"),
3788  mesA0A0xBT1SeqSrc);
3789  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-pionxB_T1"),
3790  mesA0PionxBT1SeqSrc);
3791  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-pion_2xB_T1"),
3792  mesA0Pion2xBT1SeqSrc);
3793  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a0_2xB_T1"),
3794  mesA0A02xBT1SeqSrc);
3795 
3796  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rhoxB_A1"),
3797  mesA0RhoxBA1SeqSrc);
3798  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rhoxB_T1"),
3799  mesA0RhoxBT1SeqSrc);
3800  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rhoxB_T2"),
3801  mesA0RhoxBT2SeqSrc);
3802  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rhoxB_E"),
3803  mesA0RhoxBESeqSrc);
3804 
3805  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rho_2xB_A1"),
3806  mesA0Rho2xBA1SeqSrc);
3807  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rho_2xB_T1"),
3808  mesA0Rho2xBT1SeqSrc);
3809  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rho_2xB_T2"),
3810  mesA0Rho2xBT2SeqSrc);
3811  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-rho_2xB_E"),
3812  mesA0Rho2xBESeqSrc);
3813 
3814  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a1xB_A1"),
3815  mesA0A1xBA1SeqSrc);
3816  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a1xB_T1"),
3817  mesA0A1xBT1SeqSrc);
3818  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a1xB_T2"),
3819  mesA0A1xBT2SeqSrc);
3820  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-a1xB_E"),
3821  mesA0A1xBESeqSrc);
3822 
3823  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-b1xB_A1"),
3824  mesA0B1xBA1SeqSrc);
3825  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-b1xB_T1"),
3826  mesA0B1xBT1SeqSrc);
3827  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-b1xB_T2"),
3828  mesA0B1xBT2SeqSrc);
3829  success &= Chroma::TheWilsonHadronSeqSourceFactory::Instance().registerObject(std::string("a0-b1xB_E"),
3830  mesA0B1xBESeqSrc);
3831 
3832  registered = true;
3833  }
3834  return success;
3835  }
3836 
3837  } // end namespace DerivMesonSeqSourceEnv
3838 
3839 } // end namespace Chroma
antisymtensor.h
Compute anti-symmetric tensors.
Chroma::SingletonHolder::Instance
static T & Instance()
Definition: singleton.h:432
MesA0A02xBT1SeqSrc
Construct a0-(a0_2xB_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:1586
MesA0A02xBT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A02xBT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A02xDT2SeqSrc
Construct a0-(a0_2xD_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:986
MesA0A02xDT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A02xDT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A02xNablaT1SeqSrc
Construct a0-(a0_2xNabla_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:386
MesA0A02xNablaT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A02xNablaT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A0xBT1SeqSrc
Construct a0-(a0xB_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:1556
MesA0A0xBT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A0xBT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A0xDT2SeqSrc
Construct a0-(a0xD_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:956
MesA0A0xDT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A0xDT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A0xNablaT1SeqSrc
Construct a0-(a0xNabla_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:356
MesA0A0xNablaT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A0xNablaT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A1xBA1SeqSrc
Construct a0-(a1xB_A1) sequential source.
Definition: deriv_meson_seqsrc_w.h:1886
MesA0A1xBA1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A1xBA1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A1xBESeqSrc
Construct a0-(a1xB_E) sequential source.
Definition: deriv_meson_seqsrc_w.h:1976
MesA0A1xBESeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A1xBESeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A1xBT1SeqSrc
Construct a0-(rhoxB_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:1916
MesA0A1xBT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A1xBT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A1xBT2SeqSrc
Construct a0-(a1xB_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:1946
MesA0A1xBT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A1xBT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A1xDA2SeqSrc
Construct a0-(a1xD_A2) sequential source.
Definition: deriv_meson_seqsrc_w.h:1046
MesA0A1xDA2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A1xDA2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A1xDESeqSrc
Construct a0-(a1xD_E) sequential source.
Definition: deriv_meson_seqsrc_w.h:1136
MesA0A1xDESeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A1xDESeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A1xDT1SeqSrc
Construct a0-(a1xD_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:1076
MesA0A1xDT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A1xDT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A1xDT2SeqSrc
Construct a0-(a1xD_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:1106
MesA0A1xDT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A1xDT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A1xNablaA1SeqSrc
Construct a0-(a1xNabla_A1) sequential source.
Definition: deriv_meson_seqsrc_w.h:686
MesA0A1xNablaA1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A1xNablaA1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A1xNablaESeqSrc
Construct a0-(a1xNabla_E) sequential source.
Definition: deriv_meson_seqsrc_w.h:776
MesA0A1xNablaESeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A1xNablaESeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A1xNablaT1SeqSrc
Construct a0-(a1xNabla_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:716
MesA0A1xNablaT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0A1xNablaT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A1xNablaT2SeqSrc
Construct a0-(a1xNabla_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:746
MesA0A1xNablaT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0A1xNablaT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0B1xBA1SeqSrc
Construct a0-(b1xB_A1) sequential source.
Definition: deriv_meson_seqsrc_w.h:2006
MesA0B1xBA1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0B1xBA1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0B1xBESeqSrc
Construct a0-(b1xB_E) sequential source.
Definition: deriv_meson_seqsrc_w.h:2096
MesA0B1xBESeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0B1xBESeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0B1xBT1SeqSrc
Construct a0-(b1xB_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:2036
MesA0B1xBT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0B1xBT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0B1xBT2SeqSrc
Construct a0-(b1xB_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:2066
MesA0B1xBT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0B1xBT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0B1xDA2SeqSrc
Construct a0-(b1xD_A2) sequential source.
Definition: deriv_meson_seqsrc_w.h:1166
MesA0B1xDA2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0B1xDA2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0B1xDESeqSrc
Construct a0-(b1xD_E) sequential source.
Definition: deriv_meson_seqsrc_w.h:1256
MesA0B1xDESeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0B1xDESeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0B1xDT1SeqSrc
Construct a0-(b1xD_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:1196
MesA0B1xDT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0B1xDT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0B1xDT2SeqSrc
Construct a0-(b1xD_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:1226
MesA0B1xDT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0B1xDT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0B1xNablaA1SeqSrc
Construct a0-(b1xNabla_A1) sequential source.
Definition: deriv_meson_seqsrc_w.h:806
MesA0B1xNablaA1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0B1xNablaA1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0B1xNablaESeqSrc
Construct a0-(b1xNabla_E) sequential source.
Definition: deriv_meson_seqsrc_w.h:896
MesA0B1xNablaESeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0B1xNablaESeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0B1xNablaT1SeqSrc
Construct a0-(b1xNabla_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:836
MesA0B1xNablaT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0B1xNablaT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0B1xNablaT2SeqSrc
Construct a0-(b1xNabla_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:866
MesA0B1xNablaT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0B1xNablaT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Pion2xBT1SeqSrc
Construct a0-(pion_2xB_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:1616
MesA0Pion2xBT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0Pion2xBT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Pion2xDT2SeqSrc
Construct a0-(pion_2xD_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:1016
MesA0Pion2xDT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Pion2xDT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0Pion2xNablaT1SeqSrc
Construct a0-(pion_2xNabla_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:416
MesA0Pion2xNablaT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0Pion2xNablaT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0PionxBT1SeqSrc
Construct a0-(pionxB_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:1526
MesA0PionxBT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0PionxBT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0PionxDT2SeqSrc
Construct a0-(pionxD_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:926
MesA0PionxDT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0PionxDT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0PionxNablaT1SeqSrc
Construct a0-(pionxNabla_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:326
MesA0PionxNablaT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0PionxNablaT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Rho2xBA1SeqSrc
Construct a0-(rho_2xB_A1) sequential source.
Definition: deriv_meson_seqsrc_w.h:1766
MesA0Rho2xBA1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0Rho2xBA1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Rho2xBESeqSrc
Construct a0-(rho_2xB_E) sequential source.
Definition: deriv_meson_seqsrc_w.h:1856
MesA0Rho2xBESeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Rho2xBESeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0Rho2xBT1SeqSrc
Construct a0-(rho_2xB_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:1796
MesA0Rho2xBT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Rho2xBT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0Rho2xBT2SeqSrc
Construct a0-(rho_2xB_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:1826
MesA0Rho2xBT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0Rho2xBT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Rho2xDA2SeqSrc
Construct a0-(rho_2xD_A2) sequential source.
Definition: deriv_meson_seqsrc_w.h:1406
MesA0Rho2xDA2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0Rho2xDA2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Rho2xDESeqSrc
Construct a0-(rho_2xD_E) sequential source.
Definition: deriv_meson_seqsrc_w.h:1496
MesA0Rho2xDESeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0Rho2xDESeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Rho2xDT1SeqSrc
Construct a0-(rho_2xD_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:1436
MesA0Rho2xDT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0Rho2xDT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Rho2xDT2SeqSrc
Construct a0-(rho_2xD_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:1466
MesA0Rho2xDT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Rho2xDT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0Rho2xNablaA1SeqSrc
Construct a0-(rho_2xNabla_A1) sequential source.
Definition: deriv_meson_seqsrc_w.h:566
MesA0Rho2xNablaA1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Rho2xNablaA1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0Rho2xNablaESeqSrc
Construct a0-(rho_2xNabla_E) sequential source.
Definition: deriv_meson_seqsrc_w.h:656
MesA0Rho2xNablaESeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Rho2xNablaESeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0Rho2xNablaT1SeqSrc
Construct a0-(rho_2xNabla_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:596
MesA0Rho2xNablaT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Rho2xNablaT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0Rho2xNablaT2SeqSrc
Construct a0-(rho_2xNabla_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:626
MesA0Rho2xNablaT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0Rho2xNablaT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0RhoxBA1SeqSrc
Construct a0-(rhoxB_A1) sequential source.
Definition: deriv_meson_seqsrc_w.h:1646
MesA0RhoxBA1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0RhoxBA1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0RhoxBESeqSrc
Construct a0-(rhoxB_E) sequential source.
Definition: deriv_meson_seqsrc_w.h:1736
MesA0RhoxBESeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0RhoxBESeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0RhoxBT1SeqSrc
Construct a0-(rhoxB_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:1676
MesA0RhoxBT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0RhoxBT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0RhoxBT2SeqSrc
Construct a0-(rhoxB_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:1706
MesA0RhoxBT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0RhoxBT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0RhoxDA2SeqSrc
Construct a0-(rhoxD_A2) sequential source.
Definition: deriv_meson_seqsrc_w.h:1286
MesA0RhoxDA2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0RhoxDA2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0RhoxDESeqSrc
Construct a0-(rhoxD_E) sequential source.
Definition: deriv_meson_seqsrc_w.h:1376
MesA0RhoxDESeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0RhoxDESeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0RhoxDT1SeqSrc
Construct a0-(rhoxD_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:1316
MesA0RhoxDT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0RhoxDT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0RhoxDT2SeqSrc
Construct a0-(rhoxD_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:1346
MesA0RhoxDT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0RhoxDT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0RhoxNablaA1SeqSrc
Construct a0-(rhoxNabla_A1) sequential source.
Definition: deriv_meson_seqsrc_w.h:446
MesA0RhoxNablaA1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0RhoxNablaA1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0RhoxNablaESeqSrc
Construct a0-(rhoxNabla_E) sequential source.
Definition: deriv_meson_seqsrc_w.h:536
MesA0RhoxNablaESeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0RhoxNablaESeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0RhoxNablaT1SeqSrc
Construct a0-(rhoxNabla_T1) sequential source.
Definition: deriv_meson_seqsrc_w.h:476
MesA0RhoxNablaT1SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0RhoxNablaT1SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
MesA0RhoxNablaT2SeqSrc
Construct a0-(rhoxNabla_T2) sequential source.
Definition: deriv_meson_seqsrc_w.h:506
MesA0RhoxNablaT2SeqSrc::operator()
LatticePropagator operator()(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props)
Construct sequential source.
MesA0RhoxNablaT2SeqSrc::twoPtSink
Complex twoPtSink(const multi1d< LatticeColorMatrix > &u, const multi1d< ForwardProp_t > &forward_headers, const multi1d< LatticePropagator > &forward_props, int gamma_insertion)
Compute the 2-pt at the sink.
mu
int mu
Definition: cool.cc:24
deriv_meson_seqsrc_w.h
Construct derivative meson sequential sources.
momentumProject
virtual Complex momentumProject(const LatticeComplex &corr_fn) const
Project onto the fixed sink-momentum and return the 2-pt at the sink.
threePtB
virtual LatticePropagator threePtB(const LatticePropagator &forward_prop, const multi1d< LatticeColorMatrix > &u, int mu) const
Apply left and right "D_i" operator onto source.
threePtD
virtual LatticePropagator threePtD(const LatticePropagator &forward_prop, const multi1d< LatticeColorMatrix > &u, int mu) const
Apply left and right "nabla_i" onto the source.
twoPtNabla
virtual LatticeComplex twoPtNabla(const LatticePropagator &forward_prop, const multi1d< LatticeColorMatrix > &u, int mu, int g, int gamma_insertion) const
Apply left and right "B_i" operator onto source.
twoPtB
virtual LatticeComplex twoPtB(const LatticePropagator &forward_prop, const multi1d< LatticeColorMatrix > &u, int mu, int g, int insertion) const
Apply left and right "D_i" operator onto source.
threePtNabla
virtual LatticePropagator threePtNabla(const LatticePropagator &forward_prop, const multi1d< LatticeColorMatrix > &u, int mu) const
displace.h
Parallel transport a lattice field.
etensor.h
Tensor used for E representations.
gamma5_herm_w.h
Gamma5 hermiticity.
gammasgn_w.h
Compute gamma matrix multiplication table factors.
Chroma::gamma5Herm
LatticePropagator gamma5Herm(const LatticePropagator &source_prop)
Return gamma_5*adj(source)*gamma_f.
Definition: gamma5_herm_w.cc:10
Chroma::symTensor3d
int symTensor3d(int i, int j, int k)
Return 3d symmetric tensor.
Definition: symtensor.cc:54
Chroma::antiSymTensor3d
int antiSymTensor3d(int i, int j, int k)
Return 3d symmetric tensor.
Definition: antisymtensor.cc:54
Chroma::gammaSgn
int gammaSgn(int n, int m)
Return gamma matrix multiplication table factors.
Definition: gammasgn_w.cc:76
Chroma::ETensor3d
Real ETensor3d(int alpha, int j, int k)
Return E antisymmetric tensor.
Definition: etensor.cc:51
Chroma::read
void read(XMLReader &xml, const std::string &path, AsqtadFermActParams &param)
Read parameters.
Definition: asqtad_fermact_params_s.cc:33
Chroma::write
void write(XMLWriter &xml, const std::string &path, const AsqtadFermActParams &param)
Writer parameters.
Definition: asqtad_fermact_params_s.cc:40
Chroma::rightNabla
LatticeColorVector rightNabla(const multi1d< LatticeColorMatrix > &u, const LatticeColorVector &chi, int length, const multi1d< int > &path)
Apply a right nabla path to a lattice field.
Chroma::rightB
LatticePropagator rightB(const LatticePropagator &F, const multi1d< LatticeColorMatrix > &u, int mu, int length)
Apply "D_i" operator to the right onto source.
Definition: displace.cc:549
j
unsigned j
Definition: ldumul_w.cc:35
j_decay
int j_decay
Definition: meslate.cc:22
Nd
Nd
Definition: meslate.cc:74
Chroma::AsqtadFermActEnv::registerAll
bool registerAll()
Register all the factories.
Definition: asqtad_fermact_s.cc:52
Chroma::AsqtadFermActEnv::registered
static bool registered
Local registration flag.
Definition: asqtad_fermact_s.cc:49
Chroma::AsqtadFermActEnv::name
const std::string name
Name to be used.
Definition: asqtad_fermact_s.cc:46
Chroma::SimpleBaryonSeqSourceEnv::check2Args
check2Args("BarNuclTCg5", quark_propagators)
Chroma::SimpleBaryonSeqSourceEnv::forward_headers
multi1d< ForwardProp_t > & forward_headers
Definition: simple_baryon_2pt_w.cc:213
Chroma::SimpleBaryonSeqSourceEnv::quark_propagators
multi1d< LatticePropagator > & quark_propagators
Definition: simple_baryon_2pt_w.cc:217
Chroma
Asqtad Staggered-Dirac operator.
Definition: klein_gord.cc:10
Chroma::G5
int G5
Definition: pbg5p_w.cc:57
Chroma::u
static multi1d< LatticeColorMatrix > u
Definition: syssolver_linop_qop_mg_w.cc:39
Chroma::tmp
LatticeFermion tmp
Definition: mespbg5p_w.cc:36
Chroma::push
push(xml_out,"Condensates")
Chroma::a
Complex a
Definition: invbicg.cc:95
Chroma::pop
pop(xml_out)
Chroma::out
static QDP_ColorVector * out
Constructor.
Definition: asqtad_cps_wrapper_qprop.cc:331
Chroma::START_CODE
START_CODE()
Chroma::zero
Double zero
Definition: invbicg.cc:106
Chroma::k
int k
Definition: invbicg.cc:119
Chroma::s
multi1d< LatticeFermion > s(Ncb)
testing::internal::string
::std::string string
Definition: gtest.h:1979
seqsource_factory_w.h
Factory for producing quark prop sinks.
sftmom.h
Fourier transform phase factor support.
symtensor.h
Compute symmetric tensors.
F
static INTERNAL_PRECISION F
Definition: zolotarev_coeffs.cc:228
Generated by doxygen 1.9.1