Bridge++  Ver. 1.1.x
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
field_F.cpp
Go to the documentation of this file.
1 
14 #include "field_F.h"
15 #include "index_lex.h"
16 
17 #include "bridgeIO.h"
18 using Bridge::vout;
19 
20 using std::valarray;
21 
22 // This file includes implementation only applies to Nc = 3,
23 // namely the contraction of color index for construction of baryon.
24 #define NC 3
25 #define C1 0
26 #define C2 1
27 #define C3 2
28 
29 //====================================================================
30 void Field_F::check()
31 {
32  // do nothing.
33 }
34 
35 
36 //====================================================================
37 void Field_F::mult_GM(const GammaMatrix& gm, const Field_F& w)
38 {
39  assert(w.nex() == m_Nex);
40  assert(w.nvol() == m_Nvol);
41 
42  valarray<int> id(m_Nd);
43  valarray<int> idc_r(m_Nd);
44  valarray<int> idc_i(m_Nd);
45  valarray<double> gv_r(m_Nd);
46  valarray<double> gv_i(m_Nd);
47 
48  for (int s = 0; s < m_Nd; ++s) {
49  id[s] = gm.index(s);
50  gv_r[s] = gm.value_r(s);
51  gv_i[s] = gm.value_i(s);
52  idc_r[s] = gm.index_c(s);
53  idc_i[s] = 1 - idc_r[s];
54  }
55 
56  for (int ex = 0; ex < m_Nex; ++ex) {
57  for (int site = 0; site < m_Nvol; ++site) {
58  for (int s = 0; s < m_Nd; ++s) {
59  for (int c = 0; c < m_Nc; ++c) {
60  field[myindex(2 * c, s, site, ex)]
61  = gv_r[s] * w.field[myindex(2 * c + idc_r[s], id[s], site, ex)];
62  field[myindex(2 * c + 1, s, site, ex)]
63  = gv_i[s] * w.field[myindex(2 * c + idc_i[s], id[s], site, ex)];
64  }
65  }
66  }
67  }
68 }
69 
70 
71 //====================================================================
72 void Field_F::mult_iGM(const GammaMatrix& gm, const Field_F& w)
73 {
74  assert(w.nex() == m_Nex);
75  assert(w.nvol() == m_Nvol);
76 
77  valarray<int> id(m_Nd);
78  valarray<int> idc_r(m_Nd);
79  valarray<int> idc_i(m_Nd);
80  valarray<double> gv_r(m_Nd);
81  valarray<double> gv_i(m_Nd);
82 
83  for (int s = 0; s < m_Nd; ++s) {
84  id[s] = gm.index(s);
85  gv_r[s] = -gm.value_i(s);
86  gv_i[s] = gm.value_r(s);
87  idc_r[s] = 1 - gm.index_c(s);
88  idc_i[s] = 1 - idc_r[s];
89  }
90 
91  for (int ex = 0; ex < m_Nex; ++ex) {
92  for (int site = 0; site < m_Nvol; ++site) {
93  for (int s = 0; s < m_Nd; ++s) {
94  for (int c = 0; c < m_Nc; ++c) {
95  field[myindex(2 * c, s, site, ex)]
96  = gv_r[s] * w.field[myindex(2 * c + idc_r[s], id[s], site, ex)];
97  field[myindex(2 * c + 1, s, site, ex)]
98  = gv_i[s] * w.field[myindex(2 * c + idc_i[s], id[s], site, ex)];
99  }
100  }
101  }
102  }
103 }
104 
105 
106 //====================================================================
107 void Field_F::mult_GMproj(const int pm, const GammaMatrix& gm,
108  const Field_F& w)
109 {
110  assert(w.nvol() == m_Nvol);
111  assert(w.nex() == m_Nex);
112 
113  Field_F v(w.nvol(), w.nex());
114  v.mult_GM(gm, w);
115 
116  int size = m_Nin * m_Nvol * m_Nex;
117  if (pm == 1) {
118  for (int i = 0; i < size; ++i) {
119  field[i] = 0.5 * (w.field[i] + v.field[i]);
120  }
121  } else if (pm == -1) {
122  for (int i = 0; i < size; ++i) {
123  field[i] = 0.5 * (w.field[i] - v.field[i]);
124  }
125  } else {
126  vout.general(m_vl, "Field_F: wrong pm = %d\n", pm);
127  abort();
128  }
129 }
130 
131 
132 //====================================================================
133 void Field_F::mult_GMproj2(const int pm, const GammaMatrix& gm,
134  const Field_F& w)
135 {
136  assert(w.nvol() == m_Nvol);
137  assert(w.nex() == m_Nex);
138 
139  Field_F v(w.nvol(), w.nex());
140  v.mult_GM(gm, w);
141 
142  int size = m_Nin * m_Nvol * m_Nex;
143  if (pm == 1) {
144  for (int i = 0; i < size; ++i) {
145  field[i] = w.field[i] + v.field[i];
146  }
147  } else if (pm == -1) {
148  for (int i = 0; i < size; ++i) {
149  field[i] = w.field[i] - v.field[i];
150  }
151  } else {
152  vout.general(m_vl, "Field_F: wrong pm = %d\n", pm);
153  abort();
154  }
155 }
156 
157 
158 //====================================================================
159 void Field_F::mult_Field_Gn(int ex, const Field_G& U, int ex1,
160  const Field_F& x, int ex2)
161 {
162  assert(ex < m_Nex);
163  assert(ex1 < U.nex());
164  assert(ex2 < x.nex());
165  assert(U.nvol() == m_Nvol);
166  assert(x.nvol() == m_Nvol);
167 
168  Vec_SU_N vec(m_Nc);
169 
170  for (int site = 0; site < m_Nvol; ++site) {
171  for (int s = 0; s < m_Nd; ++s) {
172  vec = U.mat(site, ex1) * x.vec(s, site, ex2);
173  for (int cc = 0; cc < m_Nc; ++cc) {
174  field[myindex(2 * cc, s, site, ex)] = vec.r(cc);
175  field[myindex(2 * cc + 1, s, site, ex)] = vec.i(cc);
176  }
177  }
178  }
179 }
180 
181 
182 //====================================================================
183 void Field_F::mult_Field_Gd(int ex, const Field_G& U, int ex1,
184  const Field_F& x, int ex2)
185 {
186  assert(ex < m_Nex);
187  assert(ex1 < U.nex());
188  assert(ex2 < x.nex());
189  assert(U.nvol() == m_Nvol);
190  assert(x.nvol() == m_Nvol);
191 
192  Vec_SU_N vec(m_Nc);
193 
194  for (int site = 0; site < m_Nvol; ++site) {
195  for (int s = 0; s < m_Nd; ++s) {
196  vec = U.mat_dag(site, ex1) * x.vec(s, site, ex2);
197  for (int cc = 0; cc < m_Nc; ++cc) {
198  field[myindex(2 * cc, s, site, ex)] = vec.r(cc);
199  field[myindex(2 * cc + 1, s, site, ex)] = vec.i(cc);
200  }
201  }
202  }
203 }
204 
205 
206 //====================================================================
207 void Field_F::multadd_Field_Gn(int ex, const Field_G& U, int ex1,
208  const Field_F& x, int ex2, double a)
209 {
210  assert(ex < m_Nex);
211  assert(ex1 < U.nex());
212  assert(ex2 < x.nex());
213  assert(U.nvol() == m_Nvol);
214  assert(x.nvol() == m_Nvol);
215 
216  Vec_SU_N vec(m_Nc);
217 
218  for (int site = 0; site < m_Nvol; ++site) {
219  for (int s = 0; s < m_Nd; ++s) {
220  vec = U.mat(site, ex1) * x.vec(s, site, ex2);
221  for (int cc = 0; cc < m_Nc; ++cc) {
222  field[myindex(2 * cc, s, site, ex)] += a * vec.r(cc);
223  field[myindex(2 * cc + 1, s, site, ex)] += a * vec.i(cc);
224  }
225  }
226  }
227 }
228 
229 
230 //====================================================================
231 void Field_F::multadd_Field_Gd(int ex, const Field_G& U, int ex1,
232  const Field_F& x, int ex2, double a)
233 {
234  assert(ex < m_Nex);
235  assert(ex1 < U.nex());
236  assert(ex2 < x.nex());
237  assert(U.nvol() == m_Nvol);
238  assert(x.nvol() == m_Nvol);
239 
240  Vec_SU_N vec(m_Nc);
241 
242  for (int site = 0; site < m_Nvol; ++site) {
243  for (int s = 0; s < m_Nd; ++s) {
244  vec = U.mat_dag(site, ex1) * x.vec(s, site, ex2);
245  for (int cc = 0; cc < m_Nc; ++cc) {
246  field[myindex(2 * cc, s, site, ex)] += a * vec.r(cc);
247  field[myindex(2 * cc + 1, s, site, ex)] += a * vec.i(cc);
248  }
249  }
250  }
251 }
252 
253 
254 //====================================================================
255 //============================================================END=====