Bridge++  Ver. 1.1.x
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
field_G_imp.cpp
Go to the documentation of this file.
1 
15 #include "field_G.h"
16 
17 #include "commonParameters.h"
18 #include "communicator.h"
19 #include "bridgeIO.h"
20 using Bridge::vout;
21 
22 #include "mat_SU_N.h"
23 
24 //====================================================================
25 void Field_G::mult_Field_Gnn(int ex, const Field_G& u1, int ex1,
26  const Field_G& u2, int ex2)
27 {
28  assert(ex < m_Nex);
29  assert(ex1 < u1.nex());
30  assert(ex2 < u2.nex());
31  assert(u1.nvol() == m_Nvol);
32  assert(u2.nvol() == m_Nvol);
33 
34  double *g1;
35  double *g2;
36  g1 = const_cast<Field_G *>(&u1)->ptr(0);
37  g2 = const_cast<Field_G *>(&u2)->ptr(0);
38  int Nc2 = 2 * m_Nc;
39  int Ndf = Nc2 * m_Nc;
40 
41  for (int site = 0; site < m_Nvol; ++site) {
42  int ig1 = Ndf * (site + m_Nvol * ex1);
43  int ig2 = Ndf * (site + m_Nvol * ex2);
44  int ig = Ndf * (site + m_Nvol * ex);
45  for (int ic2 = 0; ic2 < m_Nc; ++ic2) {
46  for (int ic1 = 0; ic1 < m_Nc; ++ic1) {
47  int jg2 = ic2 * 2 + ig2;
48  int jg1 = ic1 * Nc2 + ig1;
49  field[2 * ic2 + Nc2 * ic1 + ig] =
50  g1[0 + jg1] * g2[0 + jg2] - g1[1 + jg1] * g2[1 + jg2]
51  + g1[2 + jg1] * g2[6 + jg2] - g1[3 + jg1] * g2[7 + jg2]
52  + g1[4 + jg1] * g2[12 + jg2] - g1[5 + jg1] * g2[13 + jg2];
53  field[2 * ic2 + 1 + Nc2 * ic1 + ig] =
54  g1[0 + jg1] * g2[1 + jg2] + g1[1 + jg1] * g2[0 + jg2]
55  + g1[2 + jg1] * g2[7 + jg2] + g1[3 + jg1] * g2[6 + jg2]
56  + g1[4 + jg1] * g2[13 + jg2] + g1[5 + jg1] * g2[12 + jg2];
57  }
58  }
59  }
60 }
61 
62 
63 //====================================================================
64 void Field_G::mult_Field_Gdn(int ex, const Field_G& u1, int ex1,
65  const Field_G& u2, int ex2)
66 {
67  assert(ex < m_Nex);
68  assert(ex1 < u1.nex());
69  assert(ex2 < u2.nex());
70  assert(u1.nvol() == m_Nvol);
71  assert(u2.nvol() == m_Nvol);
72 
73  double *g1;
74  double *g2;
75  g1 = const_cast<Field_G *>(&u1)->ptr(0);
76  g2 = const_cast<Field_G *>(&u2)->ptr(0);
77  int Nc2 = 2 * m_Nc;
78  int Ndf = Nc2 * m_Nc;
79 
80  for (int site = 0; site < m_Nvol; ++site) {
81  int ig1 = Ndf * (site + m_Nvol * ex1);
82  int ig2 = Ndf * (site + m_Nvol * ex2);
83  int ig = Ndf * (site + m_Nvol * ex);
84  for (int ic2 = 0; ic2 < m_Nc; ++ic2) {
85  for (int ic1 = 0; ic1 < m_Nc; ++ic1) {
86  int jg2 = ic2 * 2 + ig2;
87  int jg1 = ic1 * 2 + ig1;
88  field[2 * ic2 + Nc2 * ic1 + ig] =
89  g1[0 + jg1] * g2[0 + jg2] + g1[1 + jg1] * g2[1 + jg2]
90  + g1[6 + jg1] * g2[6 + jg2] + g1[7 + jg1] * g2[7 + jg2]
91  + g1[12 + jg1] * g2[12 + jg2] + g1[13 + jg1] * g2[13 + jg2];
92  field[2 * ic2 + 1 + Nc2 * ic1 + ig] =
93  g1[0 + jg1] * g2[1 + jg2] - g1[1 + jg1] * g2[0 + jg2]
94  + g1[6 + jg1] * g2[7 + jg2] - g1[7 + jg1] * g2[6 + jg2]
95  + g1[12 + jg1] * g2[13 + jg2] - g1[13 + jg1] * g2[12 + jg2];
96  }
97  }
98  }
99 }
100 
101 
102 //====================================================================
103 void Field_G::mult_Field_Gnd(int ex, const Field_G& u1, int ex1,
104  const Field_G& u2, int ex2)
105 {
106  assert(ex < m_Nex);
107  assert(ex1 < u1.nex());
108  assert(ex2 < u2.nex());
109  assert(u1.nvol() == m_Nvol);
110  assert(u2.nvol() == m_Nvol);
111 
112  double *g1;
113  double *g2;
114  g1 = const_cast<Field_G *>(&u1)->ptr(0);
115  g2 = const_cast<Field_G *>(&u2)->ptr(0);
116  int Nc2 = 2 * m_Nc;
117  int Ndf = Nc2 * m_Nc;
118 
119  for (int site = 0; site < m_Nvol; ++site) {
120  int ig1 = Ndf * (site + m_Nvol * ex1);
121  int ig2 = Ndf * (site + m_Nvol * ex2);
122  int ig = Ndf * (site + m_Nvol * ex);
123  for (int ic2 = 0; ic2 < m_Nc; ++ic2) {
124  for (int ic1 = 0; ic1 < m_Nc; ++ic1) {
125  int jg2 = ic2 * Nc2 + ig2;
126  int jg1 = ic1 * Nc2 + ig1;
127  field[2 * ic2 + Nc2 * ic1 + ig] =
128  g1[0 + jg1] * g2[0 + jg2] + g1[1 + jg1] * g2[1 + jg2]
129  + g1[2 + jg1] * g2[2 + jg2] + g1[3 + jg1] * g2[3 + jg2]
130  + g1[4 + jg1] * g2[4 + jg2] + g1[5 + jg1] * g2[5 + jg2];
131  field[2 * ic2 + 1 + Nc2 * ic1 + ig] =
132  -g1[0 + jg1] * g2[1 + jg2] + g1[1 + jg1] * g2[0 + jg2]
133  - g1[2 + jg1] * g2[3 + jg2] + g1[3 + jg1] * g2[2 + jg2]
134  - g1[4 + jg1] * g2[5 + jg2] + g1[5 + jg1] * g2[4 + jg2];
135  }
136  }
137  }
138 }
139 
140 
141 //====================================================================
142 void Field_G::mult_Field_Gdd(int ex, const Field_G& u1, int ex1,
143  const Field_G& u2, int ex2)
144 {
145  assert(ex < m_Nex);
146  assert(ex1 < u1.nex());
147  assert(ex2 < u2.nex());
148  assert(u1.nvol() == m_Nvol);
149  assert(u2.nvol() == m_Nvol);
150 
151  double *g1;
152  double *g2;
153  g1 = const_cast<Field_G *>(&u1)->ptr(0);
154  g2 = const_cast<Field_G *>(&u2)->ptr(0);
155  int Nc2 = 2 * m_Nc;
156  int Ndf = Nc2 * m_Nc;
157 
158  for (int site = 0; site < m_Nvol; ++site) {
159  int ig1 = Ndf * (site + m_Nvol * ex1);
160  int ig2 = Ndf * (site + m_Nvol * ex2);
161  int ig = Ndf * (site + m_Nvol * ex);
162  for (int ic2 = 0; ic2 < m_Nc; ++ic2) {
163  for (int ic1 = 0; ic1 < m_Nc; ++ic1) {
164  int jg2 = ic2 * Nc2 + ig2;
165  int jg1 = ic1 * 2 + ig1;
166  field[2 * ic2 + Nc2 * ic1 + ig] =
167  g1[0 + jg1] * g2[0 + jg2] - g1[1 + jg1] * g2[1 + jg2]
168  + g1[6 + jg1] * g2[2 + jg2] - g1[7 + jg1] * g2[3 + jg2]
169  + g1[12 + jg1] * g2[4 + jg2] - g1[13 + jg1] * g2[5 + jg2];
170  field[2 * ic2 + 1 + Nc2 * ic1 + ig] =
171  -g1[0 + jg1] * g2[1 + jg2] - g1[1 + jg1] * g2[0 + jg2]
172  - g1[6 + jg1] * g2[3 + jg2] - g1[7 + jg1] * g2[2 + jg2]
173  - g1[12 + jg1] * g2[5 + jg2] - g1[13 + jg1] * g2[4 + jg2];
174  }
175  }
176  }
177 }
178 
179 
180 //====================================================================
181 void Field_G::multadd_Field_Gnn(int ex, const Field_G& u1, int ex1,
182  const Field_G& u2, int ex2, double ff)
183 {
184  assert(ex < m_Nex);
185  assert(ex1 < u1.nex());
186  assert(ex2 < u2.nex());
187  assert(u1.nvol() == m_Nvol);
188  assert(u2.nvol() == m_Nvol);
189 
190  double *g1;
191  double *g2;
192  g1 = const_cast<Field_G *>(&u1)->ptr(0);
193  g2 = const_cast<Field_G *>(&u2)->ptr(0);
194  int Nc2 = 2 * m_Nc;
195  int Ndf = Nc2 * m_Nc;
196 
197  for (int site = 0; site < m_Nvol; ++site) {
198  int ig1 = Ndf * (site + m_Nvol * ex1);
199  int ig2 = Ndf * (site + m_Nvol * ex2);
200  int ig = Ndf * (site + m_Nvol * ex);
201  for (int ic2 = 0; ic2 < m_Nc; ++ic2) {
202  for (int ic1 = 0; ic1 < m_Nc; ++ic1) {
203  int jg2 = ic2 * 2 + ig2;
204  int jg1 = ic1 * Nc2 + ig1;
205  field[2 * ic2 + Nc2 * ic1 + ig] += ff *
206  (g1[0 + jg1] * g2[0 + jg2] - g1[1 + jg1] * g2[1 + jg2]
207  + g1[2 + jg1] * g2[6 + jg2] - g1[3 + jg1] * g2[7 + jg2]
208  + g1[4 + jg1] * g2[12 + jg2] - g1[5 + jg1] * g2[13 + jg2]);
209  field[2 * ic2 + 1 + Nc2 * ic1 + ig] += ff *
210  (g1[0 + jg1] * g2[1 + jg2] + g1[1 + jg1] * g2[0 + jg2]
211  + g1[2 + jg1] * g2[7 + jg2] + g1[3 + jg1] * g2[6 + jg2]
212  + g1[4 + jg1] * g2[13 + jg2] + g1[5 + jg1] * g2[12 + jg2]);
213  }
214  }
215  }
216 }
217 
218 
219 //====================================================================
220 void Field_G::multadd_Field_Gdn(int ex, const Field_G& u1, int ex1,
221  const Field_G& u2, int ex2, double ff)
222 {
223  assert(ex < m_Nex);
224  assert(ex1 < u1.nex());
225  assert(ex2 < u2.nex());
226  assert(u1.nvol() == m_Nvol);
227  assert(u2.nvol() == m_Nvol);
228 
229  double *g1;
230  double *g2;
231  g1 = const_cast<Field_G *>(&u1)->ptr(0);
232  g2 = const_cast<Field_G *>(&u2)->ptr(0);
233  int Nc2 = 2 * m_Nc;
234  int Ndf = Nc2 * m_Nc;
235 
236  for (int site = 0; site < m_Nvol; ++site) {
237  int ig1 = Ndf * (site + m_Nvol * ex1);
238  int ig2 = Ndf * (site + m_Nvol * ex2);
239  int ig = Ndf * (site + m_Nvol * ex);
240  for (int ic2 = 0; ic2 < m_Nc; ++ic2) {
241  for (int ic1 = 0; ic1 < m_Nc; ++ic1) {
242  int jg2 = ic2 * 2 + ig2;
243  int jg1 = ic1 * 2 + ig1;
244  field[2 * ic2 + Nc2 * ic1 + ig] += ff *
245  (g1[0 + jg1] * g2[0 + jg2] + g1[1 + jg1] * g2[1 + jg2]
246  + g1[6 + jg1] * g2[6 + jg2] + g1[7 + jg1] * g2[7 + jg2]
247  + g1[12 + jg1] * g2[12 + jg2] + g1[13 + jg1] * g2[13 + jg2]);
248  field[2 * ic2 + 1 + Nc2 * ic1 + ig] += ff *
249  (g1[0 + jg1] * g2[1 + jg2] - g1[1 + jg1] * g2[0 + jg2]
250  + g1[6 + jg1] * g2[7 + jg2] - g1[7 + jg1] * g2[6 + jg2]
251  + g1[12 + jg1] * g2[13 + jg2] - g1[13 + jg1] * g2[12 + jg2]);
252  }
253  }
254  }
255 }
256 
257 
258 //====================================================================
259 void Field_G::multadd_Field_Gnd(int ex, const Field_G& u1, int ex1,
260  const Field_G& u2, int ex2, double ff)
261 {
262  assert(ex < m_Nex);
263  assert(ex1 < u1.nex());
264  assert(ex2 < u2.nex());
265  assert(u1.nvol() == m_Nvol);
266  assert(u2.nvol() == m_Nvol);
267 
268  double *g1;
269  double *g2;
270  g1 = const_cast<Field_G *>(&u1)->ptr(0);
271  g2 = const_cast<Field_G *>(&u2)->ptr(0);
272  int Nc2 = 2 * m_Nc;
273  int Ndf = Nc2 * m_Nc;
274 
275  for (int site = 0; site < m_Nvol; ++site) {
276  int ig1 = Ndf * (site + m_Nvol * ex1);
277  int ig2 = Ndf * (site + m_Nvol * ex2);
278  int ig = Ndf * (site + m_Nvol * ex);
279  for (int ic2 = 0; ic2 < m_Nc; ++ic2) {
280  for (int ic1 = 0; ic1 < m_Nc; ++ic1) {
281  int jg2 = ic2 * Nc2 + ig2;
282  int jg1 = ic1 * Nc2 + ig1;
283  field[2 * ic2 + Nc2 * ic1 + ig] += ff *
284  (g1[0 + jg1] * g2[0 + jg2] + g1[1 + jg1] * g2[1 + jg2]
285  + g1[2 + jg1] * g2[2 + jg2] + g1[3 + jg1] * g2[3 + jg2]
286  + g1[4 + jg1] * g2[4 + jg2] + g1[5 + jg1] * g2[5 + jg2]);
287  field[2 * ic2 + 1 + Nc2 * ic1 + ig] += ff *
288  (-g1[0 + jg1] * g2[1 + jg2] + g1[1 + jg1] * g2[0 + jg2]
289  - g1[2 + jg1] * g2[3 + jg2] + g1[3 + jg1] * g2[2 + jg2]
290  - g1[4 + jg1] * g2[5 + jg2] + g1[5 + jg1] * g2[4 + jg2]);
291  }
292  }
293  }
294 }
295 
296 
297 //====================================================================
298 void Field_G::multadd_Field_Gdd(int ex, const Field_G& u1, int ex1,
299  const Field_G& u2, int ex2, double ff)
300 {
301  assert(ex < m_Nex);
302  assert(ex1 < u1.nex());
303  assert(ex2 < u2.nex());
304  assert(u1.nvol() == m_Nvol);
305  assert(u2.nvol() == m_Nvol);
306 
307  double *g1;
308  double *g2;
309  g1 = const_cast<Field_G *>(&u1)->ptr(0);
310  g2 = const_cast<Field_G *>(&u2)->ptr(0);
311  int Nc2 = 2 * m_Nc;
312  int Ndf = Nc2 * m_Nc;
313 
314  for (int site = 0; site < m_Nvol; ++site) {
315  int ig1 = Ndf * (site + m_Nvol * ex1);
316  int ig2 = Ndf * (site + m_Nvol * ex2);
317  int ig = Ndf * (site + m_Nvol * ex);
318  for (int ic2 = 0; ic2 < m_Nc; ++ic2) {
319  for (int ic1 = 0; ic1 < m_Nc; ++ic1) {
320  int jg2 = ic2 * Nc2 + ig2;
321  int jg1 = ic1 * 2 + ig1;
322  field[2 * ic2 + Nc2 * ic1 + ig] += ff *
323  (g1[0 + jg1] * g2[0 + jg2] - g1[1 + jg1] * g2[1 + jg2]
324  + g1[6 + jg1] * g2[2 + jg2] - g1[7 + jg1] * g2[3 + jg2]
325  + g1[12 + jg1] * g2[4 + jg2] - g1[13 + jg1] * g2[5 + jg2]);
326  field[2 * ic2 + 1 + Nc2 * ic1 + ig] += ff *
327  (-g1[0 + jg1] * g2[1 + jg2] - g1[1 + jg1] * g2[0 + jg2]
328  - g1[6 + jg1] * g2[3 + jg2] - g1[7 + jg1] * g2[2 + jg2]
329  - g1[12 + jg1] * g2[5 + jg2] - g1[13 + jg1] * g2[4 + jg2]);
330  }
331  }
332  }
333 }
334 
335 
336 //====================================================================
337 void Field_G::at_Field_G(int ex)
338 {
339  assert(ex < m_Nex);
340 
341  int Ndf = 2 * m_Nc * m_Nc;
342 
343  for (int site = 0; site < m_Nvol; ++site) {
344  int ig = Ndf * (site + m_Nvol * ex);
345 
346  for (int a = 0; a < m_Nc; ++a) {
347  for (int b = a + 1; b < m_Nc; ++b) {
348  double re = field[2 * (m_Nc * a + b) + ig]
349  - field[2 * (m_Nc * b + a) + ig];
350  double im = field[2 * (m_Nc * a + b) + 1 + ig]
351  + field[2 * (m_Nc * b + a) + 1 + ig];
352 
353  field[2 * (m_Nc * a + b) + ig] = 0.5 * re;
354  field[2 * (m_Nc * a + b) + 1 + ig] = 0.5 * im;
355 
356  field[2 * (m_Nc * b + a) + ig] = -0.5 * re;
357  field[2 * (m_Nc * b + a) + 1 + ig] = 0.5 * im;
358  }
359  }
360  double tr = 0.0;
361  for (int cc = 0; cc < m_Nc; ++cc) {
362  tr += field[2 * (m_Nc * cc + cc) + 1 + ig];
363  }
364  tr = tr / m_Nc;
365  for (int cc = 0; cc < m_Nc; ++cc) {
366  field[2 * (m_Nc * cc + cc) + ig] = 0.0;
367  field[2 * (m_Nc * cc + cc) + 1 + ig] -= tr;
368  }
369  }
370 }
371 
372 
373 //====================================================================
374 void Field_G::ah_Field_G(int ex)
375 {
376  assert(ex < m_Nex);
377 
378  int Ndf = 2 * m_Nc * m_Nc;
379 
380  for (int site = 0; site < m_Nvol; ++site) {
381  int ig = Ndf * (site + m_Nvol * ex);
382 
383  for (int a = 0; a < m_Nc; ++a) {
384  for (int b = a; b < m_Nc; ++b) {
385  double re = field[2 * (m_Nc * a + b) + ig]
386  - field[2 * (m_Nc * b + a) + ig];
387  double im = field[2 * (m_Nc * a + b) + 1 + ig]
388  + field[2 * (m_Nc * b + a) + 1 + ig];
389 
390  field[2 * (m_Nc * a + b) + ig] = 0.5 * re;
391  field[2 * (m_Nc * a + b) + 1 + ig] = 0.5 * im;
392 
393  field[2 * (m_Nc * b + a) + ig] = -0.5 * re;
394  field[2 * (m_Nc * b + a) + 1 + ig] = 0.5 * im;
395  }
396  }
397  }
398 }
399 
400 
401 //====================================================================
402 //============================================================END=====