CHROMA
wallrhoff_w.cc
Go to the documentation of this file.
1 /*! \file
2  * \brief Wall-sink rho-> gamma+rho form-factors
3  *
4  * Form factors constructed from a quark and a backward quark propagator
5  */
6 
7 #include "chromabase.h"
9 
10 namespace Chroma {
11 
12 
13 //! Wall-sink rho-> gamma+rho form-factors
14 /*!
15  * \ingroup hadron
16  *
17  * This routine is specific to Wilson fermions!
18  *
19  * \param form Mega-structure holding form-factors ( Write )
20  * \param u gauge fields (used for non-local currents) ( Read )
21  * \param forw_u_prop forward U quark propagator ( Read )
22  * \param back_u_prop backward D quark propagator ( Read )
23  * \param forw_d_prop forward U quark propagator ( Read )
24  * \param back_d_prop backward D quark propagator ( Read )
25  * \param u_x2 forward U quark propagator evaluated at sink ( Read )
26  * \param d_x2 forward D quark propagator evaluated at sink ( Read )
27  * \param phases fourier transform phase factors ( Read )
28  * \param t0 time slice of the source ( Read )
29  * \param wall_source true if using a wall source ( Read )
30  */
31 
33  const multi1d<LatticeColorMatrix>& u,
34  const LatticePropagator& forw_u_prop,
35  const LatticePropagator& back_u_prop,
36  const LatticePropagator& forw_d_prop,
37  const LatticePropagator& back_d_prop,
38  const Propagator& u_x2,
39  const Propagator& d_x2,
40  const SftMom& phases,
41  int t0,
42  bool wall_source)
43 {
44  START_CODE();
45 
46  if ( Ns != 4 || Nc != 3 || Nd != 4 ) // Code is specific to Ns=4, Nc=3, Nd=4
47  return;
48 
49  form.subroutine = "wallRhoFormFac";
50 
51  // Length of lattice in decay direction and 3pt correlations fcns
52  int length = phases.numSubsets();
53 
54  int G5 = Ns*Ns-1;
55 
56  // The list of meaningful insertions
57  // The gamma matrices specified correspond to
58  // V_mu and A_mu = gamma_mu gamma_5, specificially
59  // where in the Chroma code gamma_5 = g_3 g_2 g_1 g_0
60  //
61  // GAMMA CURRENT
62  // 1 V_0
63  // 2 V_1
64  // 4 V_2
65  // 8 V_3
66  // 14 -A_0
67  // 13 A_1
68  // 11 -A_2
69  // 7 A_3
70  multi1d<int> gamma_list(2*Nd);
71  gamma_list[0] = 1;
72  gamma_list[1] = 2;
73  gamma_list[2] = 4;
74  gamma_list[3] = 8;
75  gamma_list[4] = 14;
76  gamma_list[5] = 13;
77  gamma_list[6] = 11;
78  gamma_list[7] = 7;
79 
80  // Quark names
81  multi1d<std::string> quark_name(2);
82  quark_name[0] = "u";
83  quark_name[1] = "d";
84 
85  // Formfac names
86  multi1d<std::string> formfac_name(1);
87  formfac_name[0] = "rho->gamma+rho";
88 
89  // Projector names
90  multi1d<std::string> proj_name(1);
91  proj_name[0] = "none";
92 
93 
94  // Antiquarks
95  LatticePropagator anti_u_prop = adj(Gamma(G5)*back_u_prop*Gamma(G5));
96  LatticePropagator anti_d_prop = adj(Gamma(G5)*back_d_prop*Gamma(G5));
97 
98 
99  // Resize some things - this is needed upfront because I traverse the
100  // structure in a non-recursive scheme
101  form.quark.resize(quark_name.size());
102  for (int ud=0; ud < form.quark.size(); ++ud)
103  {
104  form.quark[ud].formfac.resize(formfac_name.size());
105  for(int dp = 0; dp < form.quark[ud].formfac.size(); ++dp)
106  {
107  form.quark[ud].formfac[dp].lorentz.resize(Nd*Nd);
108  for(int lorz = 0; lorz < form.quark[ud].formfac[dp].lorentz.size(); ++lorz)
109  {
110  form.quark[ud].formfac[dp].lorentz[lorz].projector.resize(proj_name.size());
111  for (int proj = 0; proj < form.quark[ud].formfac[dp].lorentz[lorz].projector.size(); ++proj)
112  {
113  form.quark[ud].formfac[dp].lorentz[lorz].projector[proj].insertion.resize(gamma_list.size());
114  }
115  }
116  }
117  }
118 
119 
120  // For calculational purpose, loop over insertions first.
121  // This is out-of-order from storage within the data structure
122  // Loop over gamma matrices of the insertion current of insertion current
123  for(int gamma_ctr = 0; gamma_ctr < gamma_list.size(); ++gamma_ctr)
124  {
125  int gamma_value = gamma_list[gamma_ctr];
126  int mu = gamma_ctr % Nd;
127  bool compute_nonlocal = (gamma_ctr < Nd) ? true : false;
128 
129  // Loop over "u"=0 or "d"=1 pieces
130  for(int ud = 0; ud < form.quark.size(); ++ud)
131  {
132  WallFormFac_quark_t& quark = form.quark[ud];
133  quark.quark_ctr = ud;
134  quark.quark_name = quark_name[ud];
135 
136  LatticePropagator local_insert_prop, nonlocal_insert_prop;
137 
138  switch (ud)
139  {
140  case 0:
141  {
142  // "\bar u O u" insertion in rho
143  // The local non-conserved current contraction
144  local_insert_prop = anti_u_prop*Gamma(gamma_value)*forw_u_prop;
145 
146  if (compute_nonlocal)
147  {
148  // Construct the non-local (possibly conserved) current contraction
149  nonlocal_insert_prop = nonlocalCurrentProp(u, mu, forw_u_prop, anti_u_prop);
150  }
151  }
152  break;
153 
154  case 1:
155  {
156  // "\bar d O d" insertion in rho
157  // The local non-conserved current contraction
158  local_insert_prop = anti_d_prop*Gamma(gamma_value)*forw_d_prop;
159 
160  if (compute_nonlocal)
161  {
162  // Construct the non-local (possibly conserved) current contraction
163  nonlocal_insert_prop =
164  nonlocalCurrentProp(u, mu, forw_d_prop, anti_d_prop);
165  }
166  }
167  break;
168 
169  default:
170  QDP_error_exit("Unknown ud type", ud);
171  }
172 
173 
174  // Loop over "rho->rho"=0 types of form-factors
175  for(int dp = 0; dp < quark.formfac.size(); ++dp)
176  {
177  WallFormFac_formfac_t& formfac = quark.formfac[dp];
178  formfac.formfac_ctr = dp;
179  formfac.formfac_name = formfac_name[dp];
180 
181  LatticeComplex local_contract, nonlocal_contract;
182 
183 
184  // Loop over Lorentz indices of source and sink hadron operators
185  for(int lorz = 0; lorz < formfac.lorentz.size(); ++lorz)
186  {
187  WallFormFac_lorentz_t& lorentz = formfac.lorentz[lorz];
188  lorentz.lorentz_ctr = lorz;
189 
190  int sigma; // Lorentz index at sink
191  int tau; // Lorentz index at source
192 
193  // Encoding of lorentz indices
194  sigma = lorz % Nd;
195  tau = int(lorz / Nd);
196 
197  int gamma_value1 = 1 << sigma;
198  int gamma_value2 = 1 << tau;
199 
200  lorentz.snk_gamma = gamma_value1;
201  lorentz.src_gamma = gamma_value2;
202 
203  // Contractions depend on "ud" (u or d quark contribution)
204  // and source/sink operators
205  switch (ud)
206  {
207  case 0:
208  {
209  // "\bar u O u" insertion in rho
210  // The local non-conserved current contraction
211  local_contract =
212  trace(Gamma(gamma_value1)*local_insert_prop*Gamma(gamma_value2)*
213  Gamma(G5)*adj(d_x2)*Gamma(G5));
214 
215  if (compute_nonlocal)
216  {
217  // Construct the non-local (possibly conserved) current contraction
218  nonlocal_contract =
219  trace(Gamma(gamma_value1)*nonlocal_insert_prop*Gamma(gamma_value2)*
220  Gamma(G5)*adj(d_x2)*Gamma(G5));
221  }
222  }
223  break;
224 
225  case 1:
226  {
227  // "\bar d O d" insertion in rho
228  // The local non-conserved current contraction
229  local_contract =
230  trace(Gamma(gamma_value1)*u_x2*Gamma(gamma_value2)*
231  Gamma(G5)*adj(local_insert_prop)*Gamma(G5));
232 
233  if (compute_nonlocal)
234  {
235  // Construct the non-local (possibly conserved) current contraction
236  nonlocal_contract =
237  trace(Gamma(gamma_value1)*u_x2*Gamma(gamma_value2)*
238  Gamma(G5)*adj(nonlocal_insert_prop)*Gamma(G5));
239  }
240  }
241  break;
242 
243  default:
244  QDP_error_exit("Unknown ud type", ud);
245  }
246 
247 
248  // Loop over the spin projectors - none here
249  for (int proj = 0; proj < lorentz.projector.size(); ++proj)
250  {
251  WallFormFac_projector_t& projector = lorentz.projector[proj];
252  projector.proj_ctr = proj;
253  projector.proj_name = proj_name[proj];
254 
255  WallFormFac_insertion_t& insertion = projector.insertion[gamma_ctr];
256 
257  insertion.gamma_ctr = gamma_ctr;
258  insertion.mu = mu;
259  insertion.gamma_value = gamma_value;
260 
261  // The local non-conserved std::vector-current matrix element
262  LatticeComplex corr_local_fn = local_contract;
263 
264  // The nonlocal (possibly conserved) current matrix element
265  LatticeComplex corr_nonlocal_fn = nonlocal_contract;
266 
267  multi1d<WallFormFac_momenta_t>& momenta = insertion.momenta;
268 
269  wallFormFacSft(momenta, corr_local_fn, corr_nonlocal_fn, phases,
270  compute_nonlocal, t0);
271 
272  } // end for(proj)
273  } // end for(lorz)
274  } // end for(dp)
275  } // end for(ud)
276  } // end for(gamma_ctr)
277 
278  END_CODE();
279 }
280 
281 } // end namespace Chroma
Primary include file for CHROMA library code.
Fourier transform phase factor support.
Definition: sftmom.h:35
int numSubsets() const
Number of subsets - length in decay direction.
Definition: sftmom.h:63
int mu
Definition: cool.cc:24
void wallFormFacSft(multi1d< WallFormFac_momenta_t > &momenta, const LatticeComplex &corr_local_fn, const LatticeComplex &corr_nonlocal_fn, const SftMom &phases, bool compute_nonlocal, int t0)
Do slow SFT over hadron correlator data.
Definition: wallff_w.cc:54
LatticePropagator nonlocalCurrentProp(const multi1d< LatticeColorMatrix > &u, int mu, const LatticePropagator &forw_prop, const LatticePropagator &anti_prop)
Compute nonlocal current propagator.
Definition: wallff_w.cc:28
void wallRhoFormFac(WallFormFac_formfacs_t &form, const multi1d< LatticeColorMatrix > &u, const LatticePropagator &forw_u_prop, const LatticePropagator &back_u_prop, const LatticePropagator &forw_d_prop, const LatticePropagator &back_d_prop, const Propagator &u_x2, const Propagator &d_x2, const SftMom &phases, int t0, bool wall_source)
Wall-sink rho-> gamma+rho form-factors.
Definition: wallrhoff_w.cc:32
Nd
Definition: meslate.cc:74
Asqtad Staggered-Dirac operator.
Definition: klein_gord.cc:10
QDP_error_exit("too many BiCG iterations", n_count, rsd_sq, cp, c, re_rvr, im_rvr, re_a, im_a, re_b, im_b)
int G5
Definition: pbg5p_w.cc:57
static multi1d< LatticeColorMatrix > u
START_CODE()
multi1d< WallFormFac_lorentz_t > lorentz
Definition: wallff_w.h:51
multi1d< WallFormFac_quark_t > quark
Definition: wallff_w.h:64
multi1d< WallFormFac_momenta_t > momenta
Definition: wallff_w.h:29
multi1d< WallFormFac_projector_t > projector
Definition: wallff_w.h:44
multi1d< WallFormFac_insertion_t > insertion
Definition: wallff_w.h:36
multi1d< WallFormFac_formfac_t > formfac
Definition: wallff_w.h:58
Wall-sink rho-> gamma+rho form-factors.