Bridge++  Ver. 1.1.x
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
field_G.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 //====================================================================
26 void Field_G::mult_Field_Gnn(int ex, const Field_G& u1, int ex1,
27  const Field_G& u2, int ex2)
28 {
29  assert(ex < m_Nex);
30  assert(ex1 < u1.nex());
31  assert(ex2 < u2.nex());
32  assert(u1.nvol() == m_Nvol);
33  assert(u2.nvol() == m_Nvol);
34 
35  Mat_SU_N ut(m_Nc);
36  int Ncp = m_Nc * m_Nc;
37 
38  for (int site = 0; site < m_Nvol; ++site) {
39  ut = u1.mat(site, ex1) * u2.mat(site, ex2);
40  for (int cc = 0; cc < Ncp; ++cc) {
41  field[myindex(2 * cc, site, ex)] = ut.r(cc);
42  field[myindex(2 * cc + 1, site, ex)] = ut.i(cc);
43  }
44  }
45 }
46 
47 
48 //====================================================================
49 void Field_G::mult_Field_Gdn(int ex, const Field_G& u1, int ex1,
50  const Field_G& u2, int ex2)
51 {
52  assert(ex < m_Nex);
53  assert(ex1 < u1.nex());
54  assert(ex2 < u2.nex());
55  assert(u1.nvol() == m_Nvol);
56  assert(u2.nvol() == m_Nvol);
57 
58  Mat_SU_N ut(m_Nc);
59  int Ncp = m_Nc * m_Nc;
60 
61  for (int site = 0; site < m_Nvol; ++site) {
62  ut = u1.mat_dag(site, ex1) * u2.mat(site, ex2);
63  for (int cc = 0; cc < Ncp; ++cc) {
64  field[myindex(2 * cc, site, ex)] = ut.r(cc);
65  field[myindex(2 * cc + 1, site, ex)] = ut.i(cc);
66  }
67  }
68 }
69 
70 
71 //====================================================================
72 void Field_G::mult_Field_Gnd(int ex, const Field_G& u1, int ex1,
73  const Field_G& u2, int ex2)
74 {
75  assert(ex < m_Nex);
76  assert(ex1 < u1.nex());
77  assert(ex2 < u2.nex());
78  assert(u1.nvol() == m_Nvol);
79  assert(u2.nvol() == m_Nvol);
80 
81  Mat_SU_N ut(m_Nc);
82  int Ncp = m_Nc * m_Nc;
83 
84  for (int site = 0; site < m_Nvol; ++site) {
85  ut = u1.mat(site, ex1) * u2.mat_dag(site, ex2);
86  for (int cc = 0; cc < Ncp; ++cc) {
87  field[myindex(2 * cc, site, ex)] = ut.r(cc);
88  field[myindex(2 * cc + 1, site, ex)] = ut.i(cc);
89  }
90  }
91 }
92 
93 
94 //====================================================================
95 void Field_G::mult_Field_Gdd(int ex, const Field_G& u1, int ex1,
96  const Field_G& u2, int ex2)
97 {
98  assert(ex < m_Nex);
99  assert(ex1 < u1.nex());
100  assert(ex2 < u2.nex());
101  assert(u1.nvol() == m_Nvol);
102  assert(u2.nvol() == m_Nvol);
103 
104  Mat_SU_N ut(m_Nc);
105  int Ncp = m_Nc * m_Nc;
106 
107  for (int site = 0; site < m_Nvol; ++site) {
108  ut = u1.mat_dag(site, ex1) * u2.mat_dag(site, ex2);
109  for (int cc = 0; cc < Ncp; ++cc) {
110  field[myindex(2 * cc, site, ex)] = ut.r(cc);
111  field[myindex(2 * cc + 1, site, ex)] = ut.i(cc);
112  }
113  }
114 }
115 
116 
117 //====================================================================
118 void Field_G::multadd_Field_Gnn(int ex, const Field_G& u1, int ex1,
119  const Field_G& u2, int ex2, double ff)
120 {
121  assert(ex < m_Nex);
122  assert(ex1 < u1.nex());
123  assert(ex2 < u2.nex());
124  assert(u1.nvol() == m_Nvol);
125  assert(u2.nvol() == m_Nvol);
126 
127  Mat_SU_N ut(m_Nc);
128  int Ncp = m_Nc * m_Nc;
129 
130  for (int site = 0; site < m_Nvol; ++site) {
131  ut = u1.mat(site, ex1) * u2.mat(site, ex2);
132  for (int cc = 0; cc < Ncp; ++cc) {
133  field[myindex(2 * cc, site, ex)] += ff * ut.r(cc);
134  field[myindex(2 * cc + 1, site, ex)] += ff * ut.i(cc);
135  }
136  }
137 }
138 
139 
140 //====================================================================
141 void Field_G::multadd_Field_Gdn(int ex, const Field_G& u1, int ex1,
142  const Field_G& u2, int ex2, double ff)
143 {
144  assert(ex < m_Nex);
145  assert(ex1 < u1.nex());
146  assert(ex2 < u2.nex());
147  assert(u1.nvol() == m_Nvol);
148  assert(u2.nvol() == m_Nvol);
149 
150  Mat_SU_N ut(m_Nc);
151  int Ncp = m_Nc * m_Nc;
152 
153  for (int site = 0; site < m_Nvol; ++site) {
154  ut = u1.mat_dag(site, ex1) * u2.mat(site, ex2);
155  for (int cc = 0; cc < Ncp; ++cc) {
156  field[myindex(2 * cc, site, ex)] += ff * ut.r(cc);
157  field[myindex(2 * cc + 1, site, ex)] += ff * ut.i(cc);
158  }
159  }
160 }
161 
162 
163 //====================================================================
164 void Field_G::multadd_Field_Gnd(int ex, const Field_G& u1, int ex1,
165  const Field_G& u2, int ex2, double ff)
166 {
167  assert(ex < m_Nex);
168  assert(ex1 < u1.nex());
169  assert(ex2 < u2.nex());
170  assert(u1.nvol() == m_Nvol);
171  assert(u2.nvol() == m_Nvol);
172 
173  Mat_SU_N ut(m_Nc);
174  int Ncp = m_Nc * m_Nc;
175 
176  for (int site = 0; site < m_Nvol; ++site) {
177  ut = u1.mat(site, ex1) * u2.mat_dag(site, ex2);
178  for (int cc = 0; cc < Ncp; ++cc) {
179  field[myindex(2 * cc, site, ex)] += ff * ut.r(cc);
180  field[myindex(2 * cc + 1, site, ex)] += ff * ut.i(cc);
181  }
182  }
183 }
184 
185 
186 //====================================================================
187 void Field_G::multadd_Field_Gdd(int ex, const Field_G& u1, int ex1,
188  const Field_G& u2, int ex2, double ff)
189 {
190  assert(ex < m_Nex);
191  assert(ex1 < u1.nex());
192  assert(ex2 < u2.nex());
193  assert(u1.nvol() == m_Nvol);
194  assert(u2.nvol() == m_Nvol);
195 
196  Mat_SU_N ut(m_Nc);
197  int Ncp = m_Nc * m_Nc;
198 
199  for (int site = 0; site < m_Nvol; ++site) {
200  ut = u1.mat_dag(site, ex1) * u2.mat_dag(site, ex2);
201  for (int cc = 0; cc < Ncp; ++cc) {
202  field[myindex(2 * cc, site, ex)] += ff * ut.r(cc);
203  field[myindex(2 * cc + 1, site, ex)] += ff * ut.i(cc);
204  }
205  }
206 }
207 
208 
209 //====================================================================
210 void Field_G::at_Field_G(int ex)
211 {
212  assert(ex < m_Nex);
213 
214  // int Ndf = 2 * m_Nc * m_Nc;
215 
216  for (int site = 0; site < m_Nvol; ++site) {
217  // int ig = Ndf * (site + m_Nvol*ex);
218 
219  for (int a = 0; a < m_Nc; ++a) {
220  for (int b = a + 1; b < m_Nc; ++b) {
221  double re = field[myindex(2 * (m_Nc * a + b), site, ex)]
222  - field[myindex(2 * (m_Nc * b + a), site, ex)];
223  double im = field[myindex(2 * (m_Nc * a + b) + 1, site, ex)]
224  + field[myindex(2 * (m_Nc * b + a) + 1, site, ex)];
225 
226  field[myindex(2 * (m_Nc * a + b), site, ex)] = 0.5 * re;
227  field[myindex(2 * (m_Nc * a + b) + 1, site, ex)] = 0.5 * im;
228 
229  field[myindex(2 * (m_Nc * b + a), site, ex)] = -0.5 * re;
230  field[myindex(2 * (m_Nc * b + a) + 1, site, ex)] = 0.5 * im;
231  }
232  }
233  double tr = 0.0;
234  for (int cc = 0; cc < m_Nc; ++cc) {
235  tr += field[myindex(2 * (m_Nc * cc + cc) + 1, site, ex)];
236  }
237  tr = tr / m_Nc;
238  for (int cc = 0; cc < m_Nc; ++cc) {
239  field[myindex(2 * (m_Nc * cc + cc), site, ex)] = 0.0;
240  field[myindex(2 * (m_Nc * cc + cc) + 1, site, ex)] -= tr;
241  }
242  }
243 }
244 
245 
246 //====================================================================
247 void Field_G::ah_Field_G(int ex)
248 {
249  assert(ex < m_Nex);
250 
251  // int Ndf = 2 * m_Nc * m_Nc;
252 
253  for (int site = 0; site < m_Nvol; ++site) {
254  // int ig = Ndf * (site + m_Nvol*ex);
255 
256  for (int a = 0; a < m_Nc; ++a) {
257  for (int b = a; b < m_Nc; ++b) {
258  double re = field[myindex(2 * (m_Nc * a + b), site, ex)]
259  - field[myindex(2 * (m_Nc * b + a), site, ex)];
260  double im = field[myindex(2 * (m_Nc * a + b) + 1, site, ex)]
261  + field[myindex(2 * (m_Nc * b + a) + 1, site, ex)];
262 
263  field[myindex(2 * (m_Nc * a + b), site, ex)] = 0.5 * re;
264  field[myindex(2 * (m_Nc * a + b) + 1, site, ex)] = 0.5 * im;
265 
266  field[myindex(2 * (m_Nc * b + a), site, ex)] = -0.5 * re;
267  field[myindex(2 * (m_Nc * b + a) + 1, site, ex)] = 0.5 * im;
268  }
269  }
270  }
271 }
272 
273 
274 //====================================================================
275 //============================================================END=====