HiRep 0.1
Loading...
Searching...
No Matches
propagator.h
1/*******************************************************************************
2*
3* File propagator.h
4*
5* Type definitions and macros for propagator
6*
7* 2013 Rudy Arthur, Ari Hietanen
8*
9*******************************************************************************/
10
11#ifndef PROPAGATOR_H
12#define PROPAGATOR_H
13#include "suN_types.h"
14#include "suN.h"
15#include "gamma_spinor.h"
16#include "spin_matrix.h"
17
18#ifdef __cplusplus
19extern "C" {
20#endif
21
22typedef struct {
23 suNf_spin_matrix c[NF];
24} suNf_propagator;
25
26//r propagator, s spinor, i color index, j spin index
27#define _propagator_assign(p, s, i, j) \
28 do { \
29 int ITMP; \
30 for (ITMP = 0; ITMP < NF; ++ITMP) { \
31 (p).c[ITMP].c[0].c[j].c[i] = (s).c[0].c[ITMP]; \
32 (p).c[ITMP].c[1].c[j].c[i] = (s).c[1].c[ITMP]; \
33 (p).c[ITMP].c[2].c[j].c[i] = (s).c[2].c[ITMP]; \
34 (p).c[ITMP].c[3].c[j].c[i] = (s).c[3].c[ITMP]; \
35 } \
36 } while (0)
37
38//(r).c[i].c[j] = (s)
39//_spinmatrix_assign_col(r.c[i], s, j)
40
41//r propagator, s spinmatrix, i color index
42#define _propagator_assign_spin_matrix(r, s, i) (r).c[i] = (s)
43
44//r propagator
45#define _PROP_AT(r, a, alpha, beta, b) ((r).c[(a)].c[(alpha)].c[(beta)].c[(b)])
46
47#define _PROP_IDX(r, i, j) ((r).c[((i) / 4)].c[((i) % 4)].c[((j) % 4)].c[((j) / 4)])
48
49// r=0 (r propagator)
50#define _propagator_zero(r) \
51 do { \
52 int ITMP; \
53 for (ITMP = 0; ITMP < NF; ++ITMP) { \
54 _spinmatrix_zero((r).c[ITMP]); \
55 } \
56 } while (0)
57
58//r propagator k result; Tr [ r ]
59#define _propagator_one(r) \
60 _propagator_zero(r); \
61 do { \
62 int ITMP; \
63 for (ITMP = 0; ITMP < NF; ITMP++) { \
64 _complex_1(r.c[ITMP].c[0].c[0].c[ITMP]); \
65 _complex_1(r.c[ITMP].c[1].c[1].c[ITMP]); \
66 _complex_1(r.c[ITMP].c[2].c[2].c[ITMP]); \
67 _complex_1(r.c[ITMP].c[3].c[3].c[ITMP]); \
68 } \
69 } while (0)
70
71//r propagator k result; Tr [ r ]
72#define _propagator_trace(k, r) \
73 do { \
74 _complex_0(k); \
75 int ITMP; \
76 for (ITMP = 0; ITMP < NF; ITMP++) { \
77 (k) += (r).c[ITMP].c[0].c[0].c[ITMP]; \
78 (k) += (r).c[ITMP].c[1].c[1].c[ITMP]; \
79 (k) += (r).c[ITMP].c[2].c[2].c[ITMP]; \
80 (k) += (r).c[ITMP].c[3].c[3].c[ITMP]; \
81 } \
82 } while (0)
83
84#define _propagator_add(p, q, r) \
85 do { \
86 int _a, _beta; \
87 for (_a = 0; _a < NF; ++_a) \
88 for (_beta = 0; _beta < 4; ++_beta) { \
89 _spinor_add_f(p.c[_a].c[_beta], q.c[_a].c[_beta], r.c[_a].c[_beta]); \
90 } \
91 } while (0)
92
93#define _propagator_sub(p, q, r) \
94 do { \
95 int _a, _beta; \
96 for (_a = 0; _a < NF; ++_a) \
97 for (_beta = 0; _beta < 4; ++_beta) { \
98 _spinor_sub_f(p.c[_a].c[_beta], q.c[_a].c[_beta], r.c[_a].c[_beta]); \
99 } \
100 } while (0)
101
102//S propagator k factor;
103#define _propagator_mul_assign(S, k) \
104 do { \
105 int _a, _beta; \
106 for (_a = 0; _a < NF; ++_a) \
107 for (_beta = 0; _beta < 4; ++_beta) { \
108 _spinor_mul_f((S).c[_a].c[_beta], k, (S).c[_a].c[_beta]); \
109 } \
110 } while (0)
111
112#define _propagator_mulc_assign(S, k) \
113 do { \
114 int ITMP, JTMP; \
115 for (ITMP = 0; ITMP < 4 * NF; ITMP++) { \
116 for (JTMP = 0; JTMP < 4 * NF; JTMP++) { \
117 hr_complex tmp; \
118 tmp = _PROP_IDX(S, ITMP, JTMP); \
119 _complex_mul(_PROP_IDX(S, ITMP, JTMP), k, tmp); \
120 } \
121 } \
122 } while (0)
123
124//r propagator = s^T
125#define _propagator_transpose(r, s) \
126 do { \
127 int ITMP, JTMP; \
128 for (ITMP = 0; ITMP < 4 * NF; ITMP++) { \
129 for (JTMP = 0; JTMP < 4 * NF; JTMP++) { \
130 _PROP_IDX((r), ITMP, JTMP) = _PROP_IDX((s), JTMP, ITMP); \
131 } \
132 } \
133 } while (0)
134
135//r propagator = s^dagger
136#define _propagator_dagger(r, s) \
137 do { \
138 int ITMP, JTMP; \
139 for (ITMP = 0; ITMP < 4 * NF; ITMP++) { \
140 for (JTMP = 0; JTMP < 4 * NF; JTMP++) { \
141 _PROP_IDX((r), ITMP, JTMP) = conj(_PROP_IDX((s), JTMP, ITMP)); \
142 } \
143 } \
144 } while (0)
145
146//s spinor = r propagator t spinor
147#define _propagator_mul_spinor(s, r, t) \
148 do { \
149 _spinor_zero_f(s); \
150 int _a, _b, _alpha, _beta; \
151 for (_alpha = 0; _alpha < NF; ++_alpha) { \
152 for (_a = 0; _a < NF; ++_a) { \
153 for (_beta = 0; _beta < NF; ++_beta) { \
154 for (_b = 0; _b < NF; ++_b) { \
155 _complex_mul_assign((s).c[(_alpha)].c[(_a)], (r).c[(_a)].c[(_alpha)].c[(_beta)].c[(_b)], \
156 (t).c[(_beta)].c[(_b)]); \
157 } \
158 } \
159 } \
160 } \
161 } while (0)
162
163//s spinor = t^dagger spinor r propagator
164#define _propagator_leftmul_spinor(s, t, r) \
165 do { \
166 _spinor_zero_f(s); \
167 int _a, _b, _alpha, _beta; \
168 for (_beta = 0; _beta < NF; ++_beta) { \
169 for (_b = 0; _b < NF; ++_b) { \
170 for (_alpha = 0; _alpha < NF; ++_alpha) { \
171 for (_a = 0; _a < NF; ++_a) { \
172 _complex_mul_star_assign((s).c[(_beta)].c[(_b)], (t).c[(_alpha)].c[(_a)], \
173 (r).c[(_a)].c[(_alpha)].c[(_beta)].c[(_b)]); \
174 } \
175 } \
176 } \
177 } \
178 } while (0)
179
180//Q propagator S propagator R propagator factor; Q = SR
181#define _propagator_mul(Q, S, R) \
182 do { \
183 int _a, _b, _c, _alpha, _beta, _gamma; \
184 for (_a = 0; _a < NF; ++_a) { \
185 for (_b = 0; _b < NF; ++_b) { \
186 for (_alpha = 0; _alpha < 4; ++_alpha) { \
187 for (_beta = 0; _beta < 4; ++_beta) { \
188 _complex_0(Q.c[_a].c[_alpha].c[_beta].c[_b]); \
189 for (_c = 0; _c < NF; _c++) { \
190 for (_gamma = 0; _gamma < 4; _gamma++) { \
191 _complex_mul_assign(Q.c[_a].c[_alpha].c[_beta].c[_b], S.c[_a].c[_alpha].c[_gamma].c[_c], \
192 R.c[_c].c[_gamma].c[_beta].c[_b]); \
193 } \
194 } \
195 } \
196 } \
197 } \
198 } \
199 } while (0)
200
201//tr complex S propagator R propagator factor; tr = Trace[ S R ]
202#define _propagator_mul_trace(tr, S, R) \
203 do { \
204 int _a, _b, _alpha, _beta; \
205 _complex_0(tr); \
206 for (_a = 0; _a < NF; ++_a) { \
207 for (_alpha = 0; _alpha < 4; ++_alpha) { \
208 for (_b = 0; _b < NF; ++_b) { \
209 for (_beta = 0; _beta < 4; ++_beta) { \
210 _complex_mul_assign(tr, S.c[_a].c[_alpha].c[_beta].c[_b], R.c[_b].c[_beta].c[_alpha].c[_a]); \
211 } \
212 } \
213 } \
214 } \
215 } while (0)
216
217//tr complex S propagator R propagator factor; tr = Trace[ S^dagger R ]
218#define _propagator_muldag_trace(tr, S, R) \
219 do { \
220 int _a, _b, _alpha, _beta; \
221 _complex_0(tr); \
222 for (_a = 0; _a < NF; ++_a) { \
223 for (_alpha = 0; _alpha < 4; ++_alpha) { \
224 for (_b = 0; _b < NF; ++_b) { \
225 for (_beta = 0; _beta < 4; ++_beta) { \
226 _complex_prod_assign(tr, S.c[_b].c[_beta].c[_alpha].c[_a], R.c[_b].c[_beta].c[_alpha].c[_a]); \
227 } \
228 } \
229 } \
230 } \
231 } while (0)
232
233//Color matrix U x propagator
234#define _suNf_prop_multiply(us, u, s) \
235 do { \
236 suNf_vector v1, v2; \
237 int _a, _b, _alpha, _beta; \
238 for (_beta = 0; _beta < 4; ++_beta) \
239 for (_alpha = 0; _alpha < 4; ++_alpha) { \
240 for (_b = 0; _b < NF; ++_b) { \
241 for (_a = 0; _a < NF; ++_a) { \
242 v1.c[_a] = (s).c[_a].c[_alpha].c[_beta].c[_b]; \
243 } \
244 _suNf_multiply(v2, (u), v1); \
245 for (_a = 0; _a < NF; ++_a) { \
246 (us).c[_a].c[_alpha].c[_beta].c[_b] = v2.c[_a]; \
247 } \
248 } \
249 } \
250 } while (0)
251
252//Color matrix U^dag x propagator
253#define _suNf_inverse_prop_multiply(us, u, s) \
254 do { \
255 suNf_vector v1, v2; \
256 int _a, _b, _alpha, _beta; \
257 for (_beta = 0; _beta < 4; ++_beta) \
258 for (_alpha = 0; _alpha < 4; ++_alpha) { \
259 for (_b = 0; _b < NF; ++_b) { \
260 for (_a = 0; _a < NF; ++_a) { \
261 v1.c[_a] = (s).c[_a].c[_alpha].c[_beta].c[_b]; \
262 } \
263 _suNf_inverse_multiply(v2, (u), v1); \
264 for (_a = 0; _a < NF; ++_a) { \
265 (us).c[_a].c[_alpha].c[_beta].c[_b] = v2.c[_a]; \
266 } \
267 } \
268 } \
269 } while (0)
270
271#define _id_propagator(p, q) \
272 do { \
273 int ITMP, JTMP; \
274 for (ITMP = 0; ITMP < 4 * NF; ITMP++) { \
275 for (JTMP = 0; JTMP < 4 * NF; JTMP++) { \
276 _PROP_IDX((p), ITMP, JTMP) = _PROP_IDX((q), ITMP, JTMP); \
277 } \
278 } \
279 } while (0)
280
281//P = Gamma Q
282#define _g0_propagator(p, q) \
283 do { \
284 int _a; \
285 for (_a = 0; _a < NF; ++_a) { \
286 _g0_spinmatrix((p).c[_a], (q).c[_a]); \
287 } \
288 } while (0)
289
290#define _g1_propagator(p, q) \
291 do { \
292 int _a; \
293 for (_a = 0; _a < NF; ++_a) { \
294 _g1_spinmatrix((p).c[_a], (q).c[_a]); \
295 } \
296 } while (0)
297
298#define _g2_propagator(p, q) \
299 do { \
300 int _a; \
301 for (_a = 0; _a < NF; ++_a) { \
302 _g2_spinmatrix((p).c[_a], (q).c[_a]); \
303 } \
304 } while (0)
305
306#define _g3_propagator(p, q) \
307 do { \
308 int _a; \
309 for (_a = 0; _a < NF; ++_a) { \
310 _g3_spinmatrix((p).c[_a], (q).c[_a]); \
311 } \
312 } while (0)
313
314#define _g5_propagator(p, q) \
315 do { \
316 int _a; \
317 for (_a = 0; _a < NF; ++_a) { \
318 _g5_spinmatrix((p).c[_a], (q).c[_a]); \
319 } \
320 } while (0)
321
322#define _g5g0_propagator(p, q) \
323 do { \
324 int _a; \
325 for (_a = 0; _a < NF; ++_a) { \
326 _g5g0_spinmatrix((p).c[_a], (q).c[_a]); \
327 } \
328 } while (0)
329
330#define _g5g3_propagator(p, q) \
331 do { \
332 int _a; \
333 for (_a = 0; _a < NF; ++_a) { \
334 _g5g3_spinmatrix((p).c[_a], (q).c[_a]); \
335 } \
336 } while (0)
337
338#define _g5g1_propagator(p, q) \
339 do { \
340 int _a; \
341 for (_a = 0; _a < NF; ++_a) { \
342 _g5g1_spinmatrix((p).c[_a], (q).c[_a]); \
343 } \
344 } while (0)
345
346#define _g5g2_propagator(p, q) \
347 do { \
348 int _a; \
349 for (_a = 0; _a < NF; ++_a) { \
350 _g5g2_spinmatrix(p.c[_a], q.c[_a]); \
351 } \
352 } while (0)
353
354//P = Q Gamma
355#define _propagator_g0(p, q) \
356 do { \
357 int _a; \
358 for (_a = 0; _a < NF; ++_a) { \
359 _spinmatrix_g0((p).c[_a], (q).c[_a]); \
360 } \
361 } while (0)
362
363#define _propagator_g2(p, q) \
364 do { \
365 int _a; \
366 for (_a = 0; _a < NF; ++_a) { \
367 _spinmatrix_g2((p).c[_a], (q).c[_a]); \
368 } \
369 } while (0)
370
371#define _propagator_g5(p, q) \
372 do { \
373 int _a; \
374 for (_a = 0; _a < NF; ++_a) { \
375 _spinmatrix_g5((p).c[_a], (q).c[_a]); \
376 } \
377 } while (0)
378
379#define _propagator_g5g0(p, q) \
380 do { \
381 int _a; \
382 for (_a = 0; _a < NF; ++_a) { \
383 _spinmatrix_g5g0((p).c[_a], (q).c[_a]); \
384 } \
385 } while (0)
386
387#define _g5g0g1_propagator(p, q) \
388 do { \
389 int _a; \
390 for (_a = 0; _a < NF; ++_a) { \
391 _g5g0g1_spinmatrix(p.c[_a], q.c[_a]); \
392 } \
393 } while (0)
394
395#define _g5g0g2_propagator(p, q) \
396 do { \
397 int _a; \
398 for (_a = 0; _a < NF; ++_a) { \
399 _g5g0g2_spinmatrix((p).c[_a], (q).c[_a]); \
400 } \
401 } while (0)
402
403#define _propagator_g5g0g2(p, q) \
404 do { \
405 int _a; \
406 for (_a = 0; _a < NF; ++_a) { \
407 _spinmatrix_g5g0g2((p).c[_a], (q).c[_a]); \
408 } \
409 } while (0)
410
411#define _g5g0g3_propagator(p, q) \
412 do { \
413 int _a; \
414 for (_a = 0; _a < NF; ++_a) { \
415 _g5g0g3_spinmatrix(p.c[_a], q.c[_a]); \
416 } \
417 } while (0)
418
419#define _propagator_g5g3(p, q) \
420 do { \
421 int _a; \
422 for (_a = 0; _a < NF; ++_a) { \
423 _spinmatrix_g5g3((p).c[_a], (q).c[_a]); \
424 } \
425 } while (0)
426
427#define _propagator_g5g1(p, q) \
428 do { \
429 int _a; \
430 for (_a = 0; _a < NF; ++_a) { \
431 _spinmatrix_g5g1((p).c[_a], (q).c[_a]); \
432 } \
433 } while (0)
434
435#define _g0g1_propagator(p, q) \
436 do { \
437 int _a; \
438 for (_a = 0; _a < NF; ++_a) { \
439 _g0g1_spinmatrix(p.c[_a], q.c[_a]); \
440 } \
441 } while (0)
442
443#define _g0g2_propagator(p, q) \
444 do { \
445 int _a; \
446 for (_a = 0; _a < NF; ++_a) { \
447 _g0g2_spinmatrix((p).c[_a], (q).c[_a]); \
448 } \
449 } while (0)
450
451#define _propagator_g0g2(p, q) \
452 do { \
453 int _a; \
454 for (_a = 0; _a < NF; ++_a) { \
455 _spinmatrix_g0g2((p).c[_a], (q).c[_a]); \
456 } \
457 } while (0)
458
459#define _g0g3_propagator(p, q) \
460 do { \
461 int _a; \
462 for (_a = 0; _a < NF; ++_a) { \
463 _g0g3_spinmatrix(p.c[_a], q.c[_a]); \
464 } \
465 } while (0)
466
467#ifdef __cplusplus
468}
469#endif
470#endif
gamma_spinor.h
Macros for gamma x spinor.
spin_matrix.h
Type definitions and macros for spin_matrix.
suNf_propagator
Definition propagator.h:22
suNf_spin_matrix
Definition spin_matrix.h:32