Bridge++  Version 1.5.4
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
shiftField_lex.cpp
Go to the documentation of this file.
1 
14 #include "Field/shiftField_lex.h"
15 
16 const std::string ShiftField_lex::class_name = "ShiftField_lex";
17 
18 //====================================================================
19 void ShiftField_lex::backward(Field& v, const Field& w,
20  const int mu)
21 {
22  const int boundary_condition = 1;
23 
24  if (mu == 0) { // x-direction
25  up_x(&v, &w, boundary_condition);
26  } else if (mu == 1) {
27  up_y(&v, &w, boundary_condition);
28  } else if (mu == 2) {
29  up_z(&v, &w, boundary_condition);
30  } else if (mu == 3) {
31  up_t(&v, &w, boundary_condition);
32  } else {
33  vout.crucial(m_vl, "Error at %s: wrong mu = %d\n", class_name.c_str(), mu);
34  exit(EXIT_FAILURE);
35  }
36 }
37 
38 
39 //====================================================================
40 void ShiftField_lex::forward(Field& v, const Field& w,
41  const int mu)
42 {
43  const int boundary_condition = 1;
44 
45  if (mu == 0) {
46  dn_x(&v, &w, boundary_condition);
47  } else if (mu == 1) {
48  dn_y(&v, &w, boundary_condition);
49  } else if (mu == 2) {
50  dn_z(&v, &w, boundary_condition);
51  } else if (mu == 3) {
52  dn_t(&v, &w, boundary_condition);
53  } else {
54  vout.crucial(m_vl, "Error at %s: wrong mu = %d\n", class_name.c_str(), mu);
55  exit(EXIT_FAILURE);
56  }
57 }
58 
59 
60 //====================================================================
61 void ShiftField_lex::backward(Field& v, const Field& w,
62  const int boundary_condition, const int mu)
63 {
64  if (mu == 0) { // x-direction
65  up_x(&v, &w, boundary_condition);
66  } else if (mu == 1) {
67  up_y(&v, &w, boundary_condition);
68  } else if (mu == 2) {
69  up_z(&v, &w, boundary_condition);
70  } else if (mu == 3) {
71  up_t(&v, &w, boundary_condition);
72  } else {
73  vout.crucial(m_vl, "Error at %s: wrong mu = %d\n", class_name.c_str(), mu);
74  exit(EXIT_FAILURE);
75  }
76 }
77 
78 
79 //====================================================================
80 void ShiftField_lex::forward(Field& v, const Field& w,
81  const int boundary_condition, const int mu)
82 {
83  if (mu == 0) {
84  dn_x(&v, &w, boundary_condition);
85  } else if (mu == 1) {
86  dn_y(&v, &w, boundary_condition);
87  } else if (mu == 2) {
88  dn_z(&v, &w, boundary_condition);
89  } else if (mu == 3) {
90  dn_t(&v, &w, boundary_condition);
91  } else {
92  vout.crucial(m_vl, "Error at %s: wrong mu = %d\n", class_name.c_str(), mu);
93  exit(EXIT_FAILURE);
94  }
95 }
96 
97 
98 //====================================================================
99 void ShiftField_lex::up_x(Field *v, const Field *w, const int boundary_condition)
100 {
101  double bc2;
102 
103  if (Communicator::ipe(0) == 0) {
104  bc2 = boundary_condition;
105  } else {
106  bc2 = 1.0;
107  }
108 
109  const int Nin = w->nin();
110  const int Nex = w->nex();
111  const int Nvol = w->nvol();
112 
113  unique_ptr<Field> wt(new Field(Nin, Nvol / m_Nx, Nex));
114  unique_ptr<Field> vt(new Field(Nin, Nvol / m_Nx, Nex));
115 
116  for (int t = 0; t < m_Nt; t++) {
117  for (int z = 0; z < m_Nz; z++) {
118  for (int y = 0; y < m_Ny; y++) {
119  int s2 = y + m_Ny * (z + m_Nz * t);
120  // bulk
121  for (int x = 0; x < m_Nx - 1; x++) {
122  int ix = m_index_lex.site(x, y, z, t);
123  int px = m_index_lex.site(x + 1, y, z, t);
124  for (int ex = 0; ex < Nex; ex++) {
125  for (int in = 0; in < Nin; in++) {
126  v->set(in, ix, ex, w->cmp(in, px, ex));
127  }
128  }
129  }
130  // boundary (x=m_Nx-1)
131  int ix = m_index_lex.site(m_Nx - 1, y, z, t);
132  int px = m_index_lex.site(0, y, z, t);
133  for (int in = 0; in < Nin; in++) {
134  for (int ex = 0; ex < Nex; ex++) {
135  wt->set(in, s2, ex, bc2 * w->cmp(in, px, ex));
136  }
137  }
138  }
139  }
140  }
141 
142  const int size = Nin * (Nvol / m_Nx) * Nex;
143  Communicator::exchange(size, vt->ptr(0), wt->ptr(0), 0, 1, 0);
144 
145  for (int t = 0; t < m_Nt; t++) {
146  for (int z = 0; z < m_Nz; z++) {
147  for (int y = 0; y < m_Ny; y++) {
148  int s2 = y + m_Ny * (z + m_Nz * t);
149  // boundary (x=m_Nx-1)
150  int ix = m_index_lex.site(m_Nx - 1, y, z, t);
151  int px = m_index_lex.site(0, y, z, t);
152  for (int in = 0; in < Nin; in++) {
153  for (int ex = 0; ex < Nex; ex++) {
154  v->set(in, ix, ex, vt->cmp(in, s2, ex));
155  }
156  }
157  }
158  }
159  }
160 }
161 
162 
163 //====================================================================
164 void ShiftField_lex::up_y(Field *v, const Field *w, const int boundary_condition)
165 {
166  double bc2;
167 
168  if (Communicator::ipe(1) == 0) {
169  bc2 = boundary_condition;
170  } else {
171  bc2 = 1.0;
172  }
173 
174  const int Nin = w->nin();
175  const int Nex = w->nex();
176  const int Nvol = w->nvol();
177 
178  unique_ptr<Field> wt(new Field(Nin, Nvol / m_Ny, Nex));
179  unique_ptr<Field> vt(new Field(Nin, Nvol / m_Ny, Nex));
180 
181  for (int t = 0; t < m_Nt; t++) {
182  for (int z = 0; z < m_Nz; z++) {
183  for (int x = 0; x < m_Nx; x++) {
184  int s2 = x + m_Nx * (z + m_Nz * t);
185 
186  // bulk
187  for (int y = 0; y < m_Ny - 1; y++) {
188  int ix = m_index_lex.site(x, y, z, t);
189  int px = m_index_lex.site(x, y + 1, z, t);
190  for (int ex = 0; ex < Nex; ex++) {
191  for (int in = 0; in < Nin; in++) {
192  v->set(in, ix, ex, w->cmp(in, px, ex));
193  }
194  }
195  }
196 
197  // boundary (y=m_Ny-1)
198  int ix = m_index_lex.site(x, m_Ny - 1, z, t);
199  int px = m_index_lex.site(x, 0, z, t);
200  for (int in = 0; in < Nin; in++) {
201  for (int ex = 0; ex < Nex; ex++) {
202  wt->set(in, s2, ex, bc2 * w->cmp(in, px, ex));
203  }
204  }
205  }
206  }
207  }
208 
209  const int size = Nin * (Nvol / m_Ny) * Nex;
210  Communicator::exchange(size, vt->ptr(0), wt->ptr(0), 1, 1, 1);
211 
212  for (int t = 0; t < m_Nt; t++) {
213  for (int z = 0; z < m_Nz; z++) {
214  for (int x = 0; x < m_Nx; x++) {
215  int s2 = x + m_Nx * (z + m_Nz * t);
216 
217  // boundary (y=m_Ny-1)
218  int ix = m_index_lex.site(x, m_Ny - 1, z, t);
219  int px = m_index_lex.site(x, 0, z, t);
220  for (int in = 0; in < Nin; in++) {
221  for (int ex = 0; ex < Nex; ex++) {
222  v->set(in, ix, ex, vt->cmp(in, s2, ex));
223  }
224  }
225  }
226  }
227  }
228 }
229 
230 
231 //====================================================================
232 void ShiftField_lex::up_z(Field *v, const Field *w, const int boundary_condition)
233 {
234  double bc2;
235 
236  if (Communicator::ipe(2) == 0) {
237  bc2 = boundary_condition;
238  } else {
239  bc2 = 1.0;
240  }
241 
242  const int Nin = w->nin();
243  const int Nex = w->nex();
244  const int Nvol = w->nvol();
245 
246  unique_ptr<Field> wt(new Field(Nin, Nvol / m_Nz, Nex));
247  unique_ptr<Field> vt(new Field(Nin, Nvol / m_Nz, Nex));
248 
249  for (int t = 0; t < m_Nt; t++) {
250  for (int y = 0; y < m_Ny; y++) {
251  for (int x = 0; x < m_Nx; x++) {
252  int s2 = x + m_Nx * (y + m_Ny * t);
253 
254  // bulk
255  for (int z = 0; z < m_Nz - 1; z++) {
256  int ix = m_index_lex.site(x, y, z, t);
257  int px = m_index_lex.site(x, y, z + 1, t);
258  for (int ex = 0; ex < Nex; ex++) {
259  for (int in = 0; in < Nin; in++) {
260  v->set(in, ix, ex, w->cmp(in, px, ex));
261  }
262  }
263  }
264 
265  // boundary (z=m_Nz-1)
266  int ix = m_index_lex.site(x, y, m_Nz - 1, t);
267  int px = m_index_lex.site(x, y, 0, t);
268  for (int in = 0; in < Nin; in++) {
269  for (int ex = 0; ex < Nex; ex++) {
270  wt->set(in, s2, ex, bc2 * w->cmp(in, px, ex));
271  }
272  }
273  }
274  }
275  }
276 
277  const int size = Nin * (Nvol / m_Nz) * Nex;
278  Communicator::exchange(size, vt->ptr(0), wt->ptr(0), 2, 1, 2);
279 
280  for (int t = 0; t < m_Nt; t++) {
281  for (int y = 0; y < m_Ny; y++) {
282  for (int x = 0; x < m_Nx; x++) {
283  int s2 = x + m_Nx * (y + m_Ny * t);
284 
285  // boundary (z=m_Nz-1)
286  int ix = m_index_lex.site(x, y, m_Nz - 1, t);
287  int px = m_index_lex.site(x, y, 0, t);
288  for (int in = 0; in < Nin; in++) {
289  for (int ex = 0; ex < Nex; ex++) {
290  v->set(in, ix, ex, vt->cmp(in, s2, ex));
291  }
292  }
293  }
294  }
295  }
296 }
297 
298 
299 //====================================================================
300 void ShiftField_lex::up_t(Field *v, const Field *w, const int boundary_condition)
301 {
302  double bc2;
303 
304  if (Communicator::ipe(3) == 0) {
305  bc2 = boundary_condition;
306  } else {
307  bc2 = 1.0;
308  }
309 
310  const int Nin = w->nin();
311  const int Nex = w->nex();
312  const int Nvol = w->nvol();
313 
314  unique_ptr<Field> wt(new Field(Nin, Nvol / m_Nt, Nex));
315  unique_ptr<Field> vt(new Field(Nin, Nvol / m_Nt, Nex));
316 
317  for (int z = 0; z < m_Nz; z++) {
318  for (int y = 0; y < m_Ny; y++) {
319  for (int x = 0; x < m_Nx; x++) {
320  int s2 = x + m_Nx * (y + m_Ny * z);
321 
322  // bulk
323  for (int t = 0; t < m_Nt - 1; t++) {
324  int ix = m_index_lex.site(x, y, z, t);
325  int px = m_index_lex.site(x, y, z, t + 1);
326  for (int ex = 0; ex < Nex; ex++) {
327  for (int in = 0; in < Nin; in++) {
328  v->set(in, ix, ex, w->cmp(in, px, ex));
329  }
330  }
331  }
332 
333  // boundary (t=m_Nt-1)
334  int ix = m_index_lex.site(x, y, z, m_Nt - 1);
335  int px = m_index_lex.site(x, y, z, 0);
336  for (int ex = 0; ex < Nex; ex++) {
337  for (int in = 0; in < Nin; in++) {
338  wt->set(in, s2, ex, bc2 * w->cmp(in, px, ex));
339  }
340  }
341  }
342  }
343  }
344 
345  const int size = Nin * (Nvol / m_Nt) * Nex;
346  Communicator::exchange(size, vt->ptr(0), wt->ptr(0), 3, 1, 3);
347 
348  for (int z = 0; z < m_Nz; z++) {
349  for (int y = 0; y < m_Ny; y++) {
350  for (int x = 0; x < m_Nx; x++) {
351  int s2 = x + m_Nx * (y + m_Ny * z);
352 
353  // boundary (t=m_Nt-1)
354  int ix = m_index_lex.site(x, y, z, m_Nt - 1);
355  int px = m_index_lex.site(x, y, z, 0);
356  for (int ex = 0; ex < Nex; ex++) {
357  for (int in = 0; in < Nin; in++) {
358  v->set(in, ix, ex, vt->cmp(in, s2, ex));
359  }
360  }
361  }
362  }
363  }
364 }
365 
366 
367 //====================================================================
368 void ShiftField_lex::dn_x(Field *v, const Field *w, const int boundary_condition)
369 {
370  double bc2;
371 
372  if (Communicator::ipe(0) == 0) {
373  bc2 = boundary_condition;
374  } else {
375  bc2 = 1.0;
376  }
377 
378  const int Nin = w->nin();
379  const int Nex = w->nex();
380  const int Nvol = w->nvol();
381 
382  unique_ptr<Field> wt(new Field(Nin, Nvol / m_Nx, Nex));
383  unique_ptr<Field> vt(new Field(Nin, Nvol / m_Nx, Nex));
384 
385  for (int t = 0; t < m_Nt; t++) {
386  for (int z = 0; z < m_Nz; z++) {
387  for (int y = 0; y < m_Ny; y++) {
388  int s2 = y + m_Ny * (z + m_Nz * t);
389 
390  // bulk
391  for (int x = 1; x < m_Nx; x++) {
392  int ix = m_index_lex.site(x, y, z, t);
393  int px = m_index_lex.site(x - 1, y, z, t);
394  for (int ex = 0; ex < Nex; ex++) {
395  for (int in = 0; in < Nin; in++) {
396  v->set(in, ix, ex, w->cmp(in, px, ex));
397  }
398  }
399  }
400  // boundary (x=0)
401  //int ix = m_index_lex.site(0 ,y,z,t);
402  int px = m_index_lex.site(m_Nx - 1, y, z, t);
403  for (int in = 0; in < Nin; in++) {
404  for (int ex = 0; ex < Nex; ex++) {
405  wt->set(in, s2, ex, w->cmp(in, px, ex));
406  }
407  }
408  }
409  }
410  }
411 
412  const int size = Nin * (Nvol / m_Nx) * Nex;
413  Communicator::exchange(size, vt->ptr(0), wt->ptr(0), 0, -1, 4);
414 
415  for (int t = 0; t < m_Nt; t++) {
416  for (int z = 0; z < m_Nz; z++) {
417  for (int y = 0; y < m_Ny; y++) {
418  int s2 = y + m_Ny * (z + m_Nz * t);
419  // boundary (x=0)
420  int ix = m_index_lex.site(0, y, z, t);
421  //int px = m_index_lex.site(m_Nx-1,y,z,t);
422  for (int in = 0; in < Nin; in++) {
423  for (int ex = 0; ex < Nex; ex++) {
424  v->set(in, ix, ex, bc2 * vt->cmp(in, s2, ex));
425  }
426  }
427  }
428  }
429  }
430 }
431 
432 
433 //====================================================================
434 void ShiftField_lex::dn_y(Field *v, const Field *w, const int boundary_condition)
435 {
436  double bc2;
437 
438  if (Communicator::ipe(1) == 0) {
439  bc2 = boundary_condition;
440  } else {
441  bc2 = 1.0;
442  }
443 
444  const int Nin = w->nin();
445  const int Nex = w->nex();
446  const int Nvol = w->nvol();
447 
448  unique_ptr<Field> wt(new Field(Nin, Nvol / m_Ny, Nex));
449  unique_ptr<Field> vt(new Field(Nin, Nvol / m_Ny, Nex));
450 
451  for (int t = 0; t < m_Nt; t++) {
452  for (int z = 0; z < m_Nz; z++) {
453  for (int x = 0; x < m_Nx; x++) {
454  int s2 = x + m_Nx * (z + m_Nz * t);
455 
456  // bulk
457  for (int y = 1; y < m_Ny; y++) {
458  int ix = m_index_lex.site(x, y, z, t);
459  int px = m_index_lex.site(x, y - 1, z, t);
460  for (int ex = 0; ex < Nex; ex++) {
461  for (int in = 0; in < Nin; in++) {
462  v->set(in, ix, ex, w->cmp(in, px, ex));
463  }
464  }
465  }
466  // boundary (y=0)
467  int ix = m_index_lex.site(x, 0, z, t);
468  int px = m_index_lex.site(x, m_Ny - 1, z, t);
469  for (int in = 0; in < Nin; in++) {
470  for (int ex = 0; ex < Nex; ex++) {
471  wt->set(in, s2, ex, w->cmp(in, px, ex));
472  }
473  }
474  }
475  }
476  }
477 
478  const int size = Nin * (Nvol / m_Ny) * Nex;
479  Communicator::exchange(size, vt->ptr(0), wt->ptr(0), 1, -1, 5);
480 
481  for (int t = 0; t < m_Nt; t++) {
482  for (int z = 0; z < m_Nz; z++) {
483  for (int x = 0; x < m_Nx; x++) {
484  int s2 = x + m_Nx * (z + m_Nz * t);
485 
486  // boundary (y=0)
487  int ix = m_index_lex.site(x, 0, z, t);
488  int px = m_index_lex.site(x, m_Ny - 1, z, t);
489  for (int in = 0; in < Nin; in++) {
490  for (int ex = 0; ex < Nex; ex++) {
491  v->set(in, ix, ex, bc2 * vt->cmp(in, s2, ex));
492  }
493  }
494  }
495  }
496  }
497 }
498 
499 
500 //====================================================================
501 void ShiftField_lex::dn_z(Field *v, const Field *w, const int boundary_condition)
502 {
503  double bc2;
504 
505  if (Communicator::ipe(2) == 0) {
506  bc2 = boundary_condition;
507  } else {
508  bc2 = 1.0;
509  }
510 
511  const int Nin = w->nin();
512  const int Nex = w->nex();
513  const int Nvol = w->nvol();
514 
515  unique_ptr<Field> wt(new Field(Nin, Nvol / m_Nz, Nex));
516  unique_ptr<Field> vt(new Field(Nin, Nvol / m_Nz, Nex));
517 
518  for (int t = 0; t < m_Nt; t++) {
519  for (int y = 0; y < m_Ny; y++) {
520  for (int x = 0; x < m_Nx; x++) {
521  int s2 = x + m_Nx * (y + m_Ny * t);
522 
523  // bulk
524  for (int z = 1; z < m_Nz; z++) {
525  int ix = m_index_lex.site(x, y, z, t);
526  int px = m_index_lex.site(x, y, z - 1, t);
527  for (int ex = 0; ex < Nex; ex++) {
528  for (int in = 0; in < Nin; in++) {
529  v->set(in, ix, ex, w->cmp(in, px, ex));
530  }
531  }
532  }
533  // boundary (z=0)
534  int ix = m_index_lex.site(x, y, 0, t);
535  int px = m_index_lex.site(x, y, m_Nz - 1, t);
536  for (int in = 0; in < Nin; in++) {
537  for (int ex = 0; ex < Nex; ex++) {
538  wt->set(in, s2, ex, w->cmp(in, px, ex));
539  }
540  }
541  }
542  }
543  }
544 
545  const int size = Nin * (Nvol / m_Nz) * Nex;
546  Communicator::exchange(size, vt->ptr(0), wt->ptr(0), 2, -1, 6);
547 
548  for (int t = 0; t < m_Nt; t++) {
549  for (int y = 0; y < m_Ny; y++) {
550  for (int x = 0; x < m_Nx; x++) {
551  int s2 = x + m_Nx * (y + m_Ny * t);
552 
553  // boundary (z=0)
554  int ix = m_index_lex.site(x, y, 0, t);
555  int px = m_index_lex.site(x, y, m_Nz - 1, t);
556  for (int in = 0; in < Nin; in++) {
557  for (int ex = 0; ex < Nex; ex++) {
558  v->set(in, ix, ex, bc2 * vt->cmp(in, s2, ex));
559  }
560  }
561  }
562  }
563  }
564 }
565 
566 
567 //====================================================================
568 void ShiftField_lex::dn_t(Field *v, const Field *w, const int boundary_condition)
569 {
570  double bc2;
571 
572  if (Communicator::ipe(3) == 0) {
573  bc2 = boundary_condition;
574  } else {
575  bc2 = 1.0;
576  }
577 
578  const int Nin = w->nin();
579  const int Nex = w->nex();
580  const int Nvol = w->nvol();
581 
582  unique_ptr<Field> wt(new Field(Nin, Nvol / m_Nt, Nex));
583  unique_ptr<Field> vt(new Field(Nin, Nvol / m_Nt, Nex));
584 
585  for (int z = 0; z < m_Nz; z++) {
586  for (int y = 0; y < m_Ny; y++) {
587  for (int x = 0; x < m_Nx; x++) {
588  int s2 = x + m_Nx * (y + m_Ny * z);
589 
590  // bulk
591  for (int t = 1; t < m_Nt; t++) {
592  int ix = m_index_lex.site(x, y, z, t);
593  int px = m_index_lex.site(x, y, z, t - 1);
594  for (int ex = 0; ex < Nex; ex++) {
595  for (int in = 0; in < Nin; in++) {
596  v->set(in, ix, ex, w->cmp(in, px, ex));
597  }
598  }
599  }
600  // boundary (t=0)
601  int ix = m_index_lex.site(x, y, z, 0);
602  int px = m_index_lex.site(x, y, z, m_Nt - 1);
603  for (int ex = 0; ex < Nex; ex++) {
604  for (int in = 0; in < Nin; in++) {
605  wt->set(in, s2, ex, w->cmp(in, px, ex));
606  }
607  }
608  }
609  }
610  }
611 
612  const int size = Nin * (Nvol / m_Nt) * Nex;
613  Communicator::exchange(size, vt->ptr(0), wt->ptr(0), 3, -1, 7);
614 
615  for (int z = 0; z < m_Nz; z++) {
616  for (int y = 0; y < m_Ny; y++) {
617  for (int x = 0; x < m_Nx; x++) {
618  int s2 = x + m_Nx * (y + m_Ny * z);
619 
620  // boundary (t=0)
621  int ix = m_index_lex.site(x, y, z, 0);
622  int px = m_index_lex.site(x, y, z, m_Nt - 1);
623  for (int ex = 0; ex < Nex; ex++) {
624  for (int in = 0; in < Nin; in++) {
625  v->set(in, ix, ex, bc2 * vt->cmp(in, s2, ex));
626  }
627  }
628  }
629  }
630  }
631 }
632 
633 
634 //====================================================================
635 //============================================================END=====
ShiftField_lex::m_vl
Bridge::VerboseLevel m_vl
Definition: shiftField_lex.h:43
Bridge::vout
BridgeIO vout
Definition: bridgeIO.cpp:503
Field::set
void set(const int jin, const int site, const int jex, double v)
Definition: field.h:175
Index_lex::site
int site(const int &x, const int &y, const int &z, const int &t) const
Definition: index_lex.h:53
ShiftField_lex::class_name
static const std::string class_name
Definition: shiftField_lex.h:37
ShiftField_lex::up_x
void up_x(Field *, const Field *, const int boundary_condition)
Definition: shiftField_lex_imp.cpp:100
ShiftField_lex::up_z
void up_z(Field *, const Field *, const int boundary_condition)
Definition: shiftField_lex_imp.cpp:358
Field
Container of Field-type object.
Definition: field.h:45
Field::nvol
int nvol() const
Definition: field.h:127
Field::cmp
double cmp(const int jin, const int site, const int jex) const
Definition: field.h:143
ShiftField_lex::m_Nz
int m_Nz
Definition: shiftField_lex.h:40
ShiftField_lex::dn_t
void dn_t(Field *, const Field *, const int boundary_condition)
Definition: shiftField_lex_imp.cpp:554
Communicator::ipe
static int ipe(const int dir)
logical coordinate of current proc.
Definition: communicator.cpp:105
ShiftField_lex::m_Nx
int m_Nx
Definition: shiftField_lex.h:40
ShiftField_lex::m_index_lex
Index_lex m_index_lex
Definition: shiftField_lex.h:41
Field::nin
int nin() const
Definition: field.h:126
Communicator::exchange
static int exchange(int count, double *recv_buf, double *send_buf, int idir, int ipm, int tag)
receive array of double from upstream specified by idir and ipm, and send array to downstream...
Definition: communicator.cpp:200
ShiftField_lex::backward
void backward(Field &, const Field &, const int mu)
Definition: shiftField_lex_imp.cpp:20
Field::nex
int nex() const
Definition: field.h:128
ShiftField_lex::m_Nt
int m_Nt
Definition: shiftField_lex.h:40
Bridge::BridgeIO::crucial
void crucial(const char *format,...)
Definition: bridgeIO.cpp:178
ShiftField_lex::up_y
void up_y(Field *, const Field *, const int boundary_condition)
Definition: shiftField_lex_imp.cpp:220
ShiftField_lex::dn_z
void dn_z(Field *, const Field *, const int boundary_condition)
Definition: shiftField_lex_imp.cpp:427
ShiftField_lex::up_t
void up_t(Field *, const Field *, const int boundary_condition)
Definition: shiftField_lex_imp.cpp:495
ShiftField_lex::dn_x
void dn_x(Field *, const Field *, const int boundary_condition)
Definition: shiftField_lex_imp.cpp:161
Bridge::unique_ptr
Definition: unique_pointer.h:24
shiftField_lex.h
ShiftField_lex::dn_y
void dn_y(Field *, const Field *, const int boundary_condition)
Definition: shiftField_lex_imp.cpp:289
ShiftField_lex::m_Ny
int m_Ny
Definition: shiftField_lex.h:40
ShiftField_lex::forward
void forward(Field &, const Field &, const int mu)
Definition: shiftField_lex_imp.cpp:41