OPAL (Object Oriented Parallel Accelerator Library)  2021.1.99
OPAL
IntSUDS.h
Go to the documentation of this file.
1 // -*- C++ -*-
2 /***************************************************************************
3  *
4  * The IPPL Framework
5  *
6  *
7  * Visit http://people.web.psi.ch/adelmann/ for more details
8  *
9  ***************************************************************************/
10 
11 #ifndef INT_SUDS_H
12 #define INT_SUDS_H
13 
14 /* IntSUDS.h -- Definition of simple class to perform subtracted dipole
15  interpolation of data for a single particle to or from a IPPL Field. */
16 
17 // include files
18 #include "Particle/Interpolator.h"
19 #include "Field/Field.h"
20 
21 
22 // forward declaration
23 class IntSUDS;
24 
25 // specialization of InterpolatorTraits
26 template <class T, unsigned Dim>
27 struct InterpolatorTraits<T,Dim,IntSUDS> {
28  typedef CacheData1<T,Dim> Cache_t;
29 };
30 
31 
32 // IntSUDSImpl class definition
33 template <unsigned Dim>
34 class IntSUDSImpl : public Interpolator {
35 
36 public:
37  // constructor/destructor
38  IntSUDSImpl() {}
39  ~IntSUDSImpl() {}
40 
41  // gather/scatter functions
42 
43  // scatter particle data into Field using particle position and mesh
44  template <class FT, class M, class C, class PT>
45  static
46  void scatter(const FT& /*pdata*/, Field<FT,Dim,M,C>& f,
47  const Vektor<PT,Dim>& ppos, const M& mesh) {
48  CenteringTag<C> ctag;
49  Vektor<PT,Dim> gpos, dpos, delta;
50  // unsigned int d;
51  // find nearest grid point for particle position, store in NDIndex obj
52  NDIndex<Dim> ngp = FindNGP(mesh, ppos, ctag);
53  // get position of ngp
54  FindPos(gpos, mesh, ngp, ctag);
55  // get distance from ppos to gpos
56  dpos = ppos - gpos;
57  // get mesh spacings
58  FindDelta(delta, mesh, ngp, ctag);
59  // normalize dpos by mesh spacing
60  dpos /= delta;
61  // Try to find ngp in local fields and get iterator
62  CompressedBrickIterator<FT,Dim> fiter = getFieldIter(f,ngp);
63  // accumulate into local elements
64  ERRORMSG("IntSUDS::scatter: not implemented for Dim>3!!"<<endl);
65  return;
66  }
67 
68  // scatter particle data into Field using particle position and mesh
69  // and cache mesh information for reuse
70  template <class FT, class M, class C, class PT>
71  static
72  void scatter(const FT& /*pdata*/, Field<FT,Dim,M,C>& f,
73  const Vektor<PT,Dim>& ppos, const M& mesh,
74  NDIndex<Dim>& ngp, Vektor<PT,Dim>& dpos) {
75  CenteringTag<C> ctag;
76  Vektor<PT,Dim> gpos, delta;
77  // unsigned int d;
78  // find nearest grid point for particle position, store in NDIndex obj
79  ngp = FindNGP(mesh, ppos, ctag);
80  // get position of ngp
81  FindPos(gpos, mesh, ngp, ctag);
82  // get distance from ppos to gpos
83  dpos = ppos - gpos;
84  // get mesh spacings
85  FindDelta(delta, mesh, ngp, ctag);
86  // normalize dpos by mesh spacing
87  dpos /= delta;
88  // Try to find ngp in local fields and get iterator
89  CompressedBrickIterator<FT,Dim> fiter = getFieldIter(f,ngp);
90  // accumulate into local elements
91  ERRORMSG("IntSUDS::scatter: not implemented for Dim>3!!"<<endl);
92  return;
93  }
94 
95  // scatter particle data into Field using cached mesh information
96  template <class FT, class M, class C, class PT>
97  static
98  void scatter(const FT& /*pdata*/, Field<FT,Dim,M,C>& f,
99  const NDIndex<Dim>& ngp, const Vektor<PT,Dim>&) {
100  // Try to find ngp in local fields and get iterator
101  CompressedBrickIterator<FT,Dim> fiter = getFieldIter(f,ngp);
102  // accumulate into local elements
103  ERRORMSG("IntSUDS::scatter: not implemented for Dim>3!!"<<endl);
104  return;
105  }
106 
107  // gather particle data from Field using particle position and mesh
108  template <class FT, class M, class C, class PT>
109  static
110  void gather(FT& /*pdata*/, const Field<FT,Dim,M,C>& f,
111  const Vektor<PT,Dim>& ppos, const M& mesh) {
112  CenteringTag<C> ctag;
113  Vektor<PT,Dim> gpos, dpos, delta;
114  // unsigned int d;
115  // find nearest grid point for particle position, store in NDIndex obj
116  NDIndex<Dim> ngp = FindNGP(mesh, ppos, ctag);
117  // get position of ngp
118  FindPos(gpos, mesh, ngp, ctag);
119  // get distance from ppos to gpos
120  dpos = ppos - gpos;
121  // get mesh spacings
122  FindDelta(delta, mesh, ngp, ctag);
123  // normalize dpos by mesh spacing
124  dpos /= delta;
125  // Try to find ngp in local fields and get iterator
126  CompressedBrickIterator<FT,Dim> fiter = getFieldIter(f,ngp);
127  // accumulate into particle attrib
128  ERRORMSG("IntSUDS::gather: not implemented for Dim>3!!"<<endl);
129  return;
130  }
131 
132  // gather particle data from Field using particle position and mesh
133  // and cache mesh information for reuse
134  template <class FT, class M, class C, class PT>
135  static
136  void gather(FT& /*pdata*/, const Field<FT,Dim,M,C>& f,
137  const Vektor<PT,Dim>& ppos, const M& mesh,
138  NDIndex<Dim>& ngp, Vektor<PT,Dim>& dpos) {
139  CenteringTag<C> ctag;
140  Vektor<PT,Dim> gpos, delta;
141  // unsigned int d;
142  // find nearest grid point for particle position, store in NDIndex obj
143  ngp = FindNGP(mesh, ppos, ctag);
144  // get position of ngp
145  FindPos(gpos, mesh, ngp, ctag);
146  // get distance from ppos to gpos
147  dpos = ppos - gpos;
148  // get mesh spacings
149  FindDelta(delta, mesh, ngp, ctag);
150  // normalize dpos by mesh spacing
151  dpos /= delta;
152  // Try to find ngp in local fields and get iterator
153  CompressedBrickIterator<FT,Dim> fiter = getFieldIter(f,ngp);
154  // accumulate into particle attrib
155  ERRORMSG("IntSUDS::gather: not implemented for Dim>3!!"<<endl);
156  return;
157  }
158 
159  // gather particle data from Field using cached mesh information
160  template <class FT, class M, class C, class PT>
161  static
162  void gather(FT& /*pdata*/, const Field<FT,Dim,M,C>& f,
163  const NDIndex<Dim>& ngp, const Vektor<PT,Dim>&) {
164  // Try to find ngp in local fields and get iterator
165  CompressedBrickIterator<FT,Dim> fiter = getFieldIter(f,ngp);
166  // accumulate into particle attrib
167  ERRORMSG("IntSUDS::gather: not implemented for Dim>3!!"<<endl);
168  return;
169  }
170 
171 };
172 
173 
174 template <>
175 class IntSUDSImpl<1U> : public Interpolator {
176 
177 public:
178  // constructor/destructor
179  IntSUDSImpl() {}
180  ~IntSUDSImpl() {}
181 
182  // gather/scatter functions
183 
184  // scatter particle data into Field using particle position and mesh
185  template <class FT, class M, class C, class PT>
186  static
187  void scatter(const FT& pdata, Field<FT,1U,M,C>& f,
188  const Vektor<PT,1U>& ppos, const M& mesh) {
189  CenteringTag<C> ctag;
190  Vektor<PT,1U> gpos, dpos, delta;
191  // find nearest grid point for particle position, store in NDIndex obj
192  NDIndex<1U> ngp = FindNGP(mesh, ppos, ctag);
193  // get position of ngp
194  FindPos(gpos, mesh, ngp, ctag);
195  // get distance from ppos to gpos
196  dpos = ppos - gpos;
197  // get mesh spacings
198  FindDelta(delta, mesh, ngp, ctag);
199  // normalize dpos by mesh spacing
200  dpos /= delta;
201  // Try to find ngp in local fields and get iterator
202  CompressedBrickIterator<FT,1U> fiter = getFieldIter(f,ngp);
203  // accumulate into local elements
204  *fiter += pdata;
205  fiter.offset( 1) += 0.5 * dpos(0) * pdata;
206  fiter.offset(-1) -= 0.5 * dpos(0) * pdata;
207  return;
208  }
209 
210  // scatter particle data into Field using particle position and mesh
211  // and cache mesh information for reuse
212  template <class FT, class M, class C, class PT>
213  static
214  void scatter(const FT& pdata, Field<FT,1U,M,C>& f,
215  const Vektor<PT,1U>& ppos, const M& mesh,
216  NDIndex<1U>& ngp, Vektor<PT,1U>& dpos) {
217  CenteringTag<C> ctag;
218  Vektor<PT,1U> gpos, delta;
219  // find nearest grid point for particle position, store in NDIndex obj
220  ngp = FindNGP(mesh, ppos, ctag);
221  // get position of ngp
222  FindPos(gpos, mesh, ngp, ctag);
223  // get distance from ppos to gpos
224  dpos = ppos - gpos;
225  // get mesh spacings
226  FindDelta(delta, mesh, ngp, ctag);
227  // normalize dpos by mesh spacing
228  dpos /= delta;
229  // Try to find ngp in local fields and get iterator
230  CompressedBrickIterator<FT,1U> fiter = getFieldIter(f,ngp);
231  // accumulate into local elements
232  *fiter += pdata;
233  fiter.offset( 1) += 0.5 * dpos(0) * pdata;
234  fiter.offset(-1) -= 0.5 * dpos(0) * pdata;
235  return;
236  }
237 
238  // scatter particle data into Field using cached mesh information
239  template <class FT, class M, class C, class PT>
240  static
241  void scatter(const FT& pdata, Field<FT,1U,M,C>& f,
242  const NDIndex<1U>& ngp, const Vektor<PT,1U>& dpos) {
243  // Try to find ngp in local fields and get iterator
244  CompressedBrickIterator<FT,1U> fiter = getFieldIter(f,ngp);
245  // accumulate into local elements
246  *fiter += pdata;
247  fiter.offset( 1) += 0.5 * dpos(0) * pdata;
248  fiter.offset(-1) -= 0.5 * dpos(0) * pdata;
249  return;
250  }
251 
252  // gather particle data from Field using particle position and mesh
253  template <class FT, class M, class C, class PT>
254  static
255  void gather(FT& pdata, const Field<FT,1U,M,C>& f,
256  const Vektor<PT,1U>& ppos, const M& mesh) {
257  CenteringTag<C> ctag;
258  Vektor<PT,1U> gpos, dpos, delta;
259  // find nearest grid point for particle position, store in NDIndex obj
260  NDIndex<1U> ngp = FindNGP(mesh, ppos, ctag);
261  // get position of ngp
262  FindPos(gpos, mesh, ngp, ctag);
263  // get distance from ppos to gpos
264  dpos = ppos - gpos;
265  // get mesh spacings
266  FindDelta(delta, mesh, ngp, ctag);
267  // normalize dpos by mesh spacing
268  dpos /= delta;
269  // Try to find ngp in local fields and get iterator
270  CompressedBrickIterator<FT,1U> fiter = getFieldIter(f,ngp);
271  // accumulate into particle attrib
272  pdata = (*fiter) +
273  0.5 * dpos(0) * (fiter.offset(1) - fiter.offset(-1));
274  return;
275  }
276 
277  // gather particle data from Field using particle position and mesh
278  // and cache mesh information for reuse
279  template <class FT, class M, class C, class PT>
280  static
281  void gather(FT& pdata, const Field<FT,1U,M,C>& f,
282  const Vektor<PT,1U>& ppos, const M& mesh,
283  NDIndex<1U>& ngp, Vektor<PT,1U>& dpos) {
284  CenteringTag<C> ctag;
285  Vektor<PT,1U> gpos, delta;
286  // find nearest grid point for particle position, store in NDIndex obj
287  ngp = FindNGP(mesh, ppos, ctag);
288  // get position of ngp
289  FindPos(gpos, mesh, ngp, ctag);
290  // get distance from ppos to gpos
291  dpos = ppos - gpos;
292  // get mesh spacings
293  FindDelta(delta, mesh, ngp, ctag);
294  // normalize dpos by mesh spacing
295  dpos /= delta;
296  // Try to find ngp in local fields and get iterator
297  CompressedBrickIterator<FT,1U> fiter = getFieldIter(f,ngp);
298  // accumulate into particle attrib
299  pdata = (*fiter) +
300  0.5 * dpos(0) * (fiter.offset(1) - fiter.offset(-1));
301  return;
302  }
303 
304  // gather particle data from Field using cached mesh information
305  template <class FT, class M, class C, class PT>
306  static
307  void gather(FT& pdata, const Field<FT,1U,M,C>& f,
308  const NDIndex<1U>& ngp, const Vektor<PT,1U>& dpos) {
309  // Try to find ngp in local fields and get iterator
310  CompressedBrickIterator<FT,1U> fiter = getFieldIter(f,ngp);
311  // accumulate into particle attrib
312  pdata = (*fiter) +
313  0.5 * dpos(0) * (fiter.offset(1) - fiter.offset(-1));
314  return;
315  }
316 
317 };
318 
319 
320 template <>
321 class IntSUDSImpl<2U> : public Interpolator {
322 
323 public:
324  // constructor/destructor
325  IntSUDSImpl() {}
326  ~IntSUDSImpl() {}
327 
328  // gather/scatter functions
329 
330  // scatter particle data into Field using particle position and mesh
331  template <class FT, class M, class C, class PT>
332  static
333  void scatter(const FT& pdata, Field<FT,2U,M,C>& f,
334  const Vektor<PT,2U>& ppos, const M& mesh) {
335  CenteringTag<C> ctag;
336  Vektor<PT,2U> gpos, dpos, delta;
337  // find nearest grid point for particle position, store in NDIndex obj
338  NDIndex<2U> ngp = FindNGP(mesh, ppos, ctag);
339  // get position of ngp
340  FindPos(gpos, mesh, ngp, ctag);
341  // get distance from ppos to gpos
342  dpos = ppos - gpos;
343  // get mesh spacings
344  FindDelta(delta, mesh, ngp, ctag);
345  // normalize dpos by mesh spacing
346  dpos /= delta;
347  // Try to find ngp in local fields and get iterator
348  CompressedBrickIterator<FT,2U> fiter = getFieldIter(f,ngp);
349  // accumulate into local elements
350  *fiter += pdata;
351  fiter.offset( 1,0) += 0.5 * dpos(0) * pdata;
352  fiter.offset(-1,0) -= 0.5 * dpos(0) * pdata;
353  fiter.offset(0, 1) += 0.5 * dpos(1) * pdata;
354  fiter.offset(0,-1) -= 0.5 * dpos(1) * pdata;
355  return;
356  }
357 
358  // scatter particle data into Field using particle position and mesh
359  // and cache mesh information for reuse
360  template <class FT, class M, class C, class PT>
361  static
362  void scatter(const FT& pdata, Field<FT,2U,M,C>& f,
363  const Vektor<PT,2U>& ppos, const M& mesh,
364  NDIndex<2U>& ngp, Vektor<PT,2U>& dpos) {
365  CenteringTag<C> ctag;
366  Vektor<PT,2U> gpos, delta;
367  // find nearest grid point for particle position, store in NDIndex obj
368  ngp = FindNGP(mesh, ppos, ctag);
369  // get position of ngp
370  FindPos(gpos, mesh, ngp, ctag);
371  // get distance from ppos to gpos
372  dpos = ppos - gpos;
373  // get mesh spacings
374  FindDelta(delta, mesh, ngp, ctag);
375  // normalize dpos by mesh spacing
376  dpos /= delta;
377  // Try to find ngp in local fields and get iterator
378  CompressedBrickIterator<FT,2U> fiter = getFieldIter(f,ngp);
379  // accumulate into local elements
380  *fiter += pdata;
381  fiter.offset( 1,0) += 0.5 * dpos(0) * pdata;
382  fiter.offset(-1,0) -= 0.5 * dpos(0) * pdata;
383  fiter.offset(0, 1) += 0.5 * dpos(1) * pdata;
384  fiter.offset(0,-1) -= 0.5 * dpos(1) * pdata;
385  return;
386  }
387 
388  // scatter particle data into Field using cached mesh information
389  template <class FT, class M, class C, class PT>
390  static
391  void scatter(const FT& pdata, Field<FT,2U,M,C>& f,
392  const NDIndex<2U>& ngp, const Vektor<PT,2U>& dpos) {
393  // Try to find ngp in local fields and get iterator
394  CompressedBrickIterator<FT,2U> fiter = getFieldIter(f,ngp);
395  // accumulate into local elements
396  *fiter += pdata;
397  fiter.offset( 1,0) += 0.5 * dpos(0) * pdata;
398  fiter.offset(-1,0) -= 0.5 * dpos(0) * pdata;
399  fiter.offset(0, 1) += 0.5 * dpos(1) * pdata;
400  fiter.offset(0,-1) -= 0.5 * dpos(1) * pdata;
401  return;
402  }
403 
404  // gather particle data from Field using particle position and mesh
405  template <class FT, class M, class C, class PT>
406  static
407  void gather(FT& pdata, const Field<FT,2U,M,C>& f,
408  const Vektor<PT,2U>& ppos, const M& mesh) {
409  CenteringTag<C> ctag;
410  Vektor<PT,2U> gpos, dpos, delta;
411  // find nearest grid point for particle position, store in NDIndex obj
412  NDIndex<2U> ngp = FindNGP(mesh, ppos, ctag);
413  // get position of ngp
414  FindPos(gpos, mesh, ngp, ctag);
415  // get distance from ppos to gpos
416  dpos = ppos - gpos;
417  // get mesh spacings
418  FindDelta(delta, mesh, ngp, ctag);
419  // normalize dpos by mesh spacing
420  dpos /= delta;
421  // Try to find ngp in local fields and get iterator
422  CompressedBrickIterator<FT,2U> fiter = getFieldIter(f,ngp);
423  // accumulate into particle attrib
424  pdata = (*fiter) +
425  0.5 * dpos(0) * (fiter.offset(1,0) - fiter.offset(-1,0)) +
426  0.5 * dpos(1) * (fiter.offset(0,1) - fiter.offset(0,-1));
427  return;
428  }
429 
430  // gather particle data from Field using particle position and mesh
431  // and cache mesh information for reuse
432  template <class FT, class M, class C, class PT>
433  static
434  void gather(FT& pdata, const Field<FT,2U,M,C>& f,
435  const Vektor<PT,2U>& ppos, const M& mesh,
436  NDIndex<2U>& ngp, Vektor<PT,2U>& dpos) {
437  CenteringTag<C> ctag;
438  Vektor<PT,2U> gpos, delta;
439  // find nearest grid point for particle position, store in NDIndex obj
440  ngp = FindNGP(mesh, ppos, ctag);
441  // get position of ngp
442  FindPos(gpos, mesh, ngp, ctag);
443  // get distance from ppos to gpos
444  dpos = ppos - gpos;
445  // get mesh spacings
446  FindDelta(delta, mesh, ngp, ctag);
447  // normalize dpos by mesh spacing
448  dpos /= delta;
449  // Try to find ngp in local fields and get iterator
450  CompressedBrickIterator<FT,2U> fiter = getFieldIter(f,ngp);
451  // accumulate into particle attrib
452  pdata = (*fiter) +
453  0.5 * dpos(0) * (fiter.offset(1,0) - fiter.offset(-1,0)) +
454  0.5 * dpos(1) * (fiter.offset(0,1) - fiter.offset(0,-1));
455  return;
456  }
457 
458  // gather particle data from Field using cached mesh information
459  template <class FT, class M, class C, class PT>
460  static
461  void gather(FT& pdata, const Field<FT,2U,M,C>& f,
462  const NDIndex<2U>& ngp, const Vektor<PT,2U>& dpos) {
463  // Try to find ngp in local fields and get iterator
464  CompressedBrickIterator<FT,2U> fiter = getFieldIter(f,ngp);
465  // accumulate into particle attrib
466  pdata = (*fiter) +
467  0.5 * dpos(0) * (fiter.offset(1,0) - fiter.offset(-1,0)) +
468  0.5 * dpos(1) * (fiter.offset(0,1) - fiter.offset(0,-1));
469  return;
470  }
471 
472 };
473 
474 
475 template <>
476 class IntSUDSImpl<3U> : public Interpolator {
477 
478 public:
479  // constructor/destructor
480  IntSUDSImpl() {}
481  ~IntSUDSImpl() {}
482 
483  // gather/scatter functions
484 
485  // scatter particle data into Field using particle position and mesh
486  template <class FT, class M, class C, class PT>
487  static
488  void scatter(const FT& pdata, Field<FT,3U,M,C>& f,
489  const Vektor<PT,3U>& ppos, const M& mesh) {
490  CenteringTag<C> ctag;
491  Vektor<PT,3U> gpos, dpos, delta;
492  // find nearest grid point for particle position, store in NDIndex obj
493  NDIndex<3U> ngp = FindNGP(mesh, ppos, ctag);
494  // get position of ngp
495  FindPos(gpos, mesh, ngp, ctag);
496  // get distance from ppos to gpos
497  dpos = ppos - gpos;
498  // get mesh spacings
499  FindDelta(delta, mesh, ngp, ctag);
500  // normalize dpos by mesh spacing
501  dpos /= delta;
502  // Try to find ngp in local fields and get iterator
503  CompressedBrickIterator<FT,3U> fiter = getFieldIter(f,ngp);
504  // accumulate into local elements
505  *fiter += pdata;
506  fiter.offset( 1,0,0) += 0.5 * dpos(0) * pdata;
507  fiter.offset(-1,0,0) -= 0.5 * dpos(0) * pdata;
508  fiter.offset(0, 1,0) += 0.5 * dpos(1) * pdata;
509  fiter.offset(0,-1,0) -= 0.5 * dpos(1) * pdata;
510  fiter.offset(0,0, 1) += 0.5 * dpos(2) * pdata;
511  fiter.offset(0,0,-1) -= 0.5 * dpos(2) * pdata;
512  return;
513  }
514 
515  // scatter particle data into Field using particle position and mesh
516  // and cache mesh information for reuse
517  template <class FT, class M, class C, class PT>
518  static
519  void scatter(const FT& pdata, Field<FT,3U,M,C>& f,
520  const Vektor<PT,3U>& ppos, const M& mesh,
521  NDIndex<3U>& ngp, Vektor<PT,3U>& dpos) {
522  CenteringTag<C> ctag;
523  Vektor<PT,3U> gpos, delta;
524  // find nearest grid point for particle position, store in NDIndex obj
525  ngp = FindNGP(mesh, ppos, ctag);
526  // get position of ngp
527  FindPos(gpos, mesh, ngp, ctag);
528  // get distance from ppos to gpos
529  dpos = ppos - gpos;
530  // get mesh spacings
531  FindDelta(delta, mesh, ngp, ctag);
532  // normalize dpos by mesh spacing
533  dpos /= delta;
534  // Try to find ngp in local fields and get iterator
535  CompressedBrickIterator<FT,3U> fiter = getFieldIter(f,ngp);
536  // accumulate into local elements
537  *fiter += pdata;
538  fiter.offset( 1,0,0) += 0.5 * dpos(0) * pdata;
539  fiter.offset(-1,0,0) -= 0.5 * dpos(0) * pdata;
540  fiter.offset(0, 1,0) += 0.5 * dpos(1) * pdata;
541  fiter.offset(0,-1,0) -= 0.5 * dpos(1) * pdata;
542  fiter.offset(0,0, 1) += 0.5 * dpos(2) * pdata;
543  fiter.offset(0,0,-1) -= 0.5 * dpos(2) * pdata;
544  return;
545  }
546 
547  // scatter particle data into Field using cached mesh information
548  template <class FT, class M, class C, class PT>
549  static
550  void scatter(const FT& pdata, Field<FT,3U,M,C>& f,
551  const NDIndex<3U>& ngp, const Vektor<PT,3U>& dpos) {
552  // Try to find ngp in local fields and get iterator
553  CompressedBrickIterator<FT,3U> fiter = getFieldIter(f,ngp);
554  // accumulate into local elements
555  *fiter += pdata;
556  fiter.offset( 1,0,0) += 0.5 * dpos(0) * pdata;
557  fiter.offset(-1,0,0) -= 0.5 * dpos(0) * pdata;
558  fiter.offset(0, 1,0) += 0.5 * dpos(1) * pdata;
559  fiter.offset(0,-1,0) -= 0.5 * dpos(1) * pdata;
560  fiter.offset(0,0, 1) += 0.5 * dpos(2) * pdata;
561  fiter.offset(0,0,-1) -= 0.5 * dpos(2) * pdata;
562  return;
563  }
564 
565  // gather particle data from Field using particle position and mesh
566  template <class FT, class M, class C, class PT>
567  static
568  void gather(FT& pdata, const Field<FT,3U,M,C>& f,
569  const Vektor<PT,3U>& ppos, const M& mesh) {
570  CenteringTag<C> ctag;
571  Vektor<PT,3U> gpos, dpos, delta;
572  // find nearest grid point for particle position, store in NDIndex obj
573  NDIndex<3U> ngp = FindNGP(mesh, ppos, ctag);
574  // get position of ngp
575  FindPos(gpos, mesh, ngp, ctag);
576  // get distance from ppos to gpos
577  dpos = ppos - gpos;
578  // get mesh spacings
579  FindDelta(delta, mesh, ngp, ctag);
580  // normalize dpos by mesh spacing
581  dpos /= delta;
582  // Try to find ngp in local fields and get iterator
583  CompressedBrickIterator<FT,3U> fiter = getFieldIter(f,ngp);
584  // accumulate into particle attrib
585  pdata = (*fiter) +
586  0.5 * dpos(0) * (fiter.offset(1,0,0) - fiter.offset(-1,0,0)) +
587  0.5 * dpos(1) * (fiter.offset(0,1,0) - fiter.offset(0,-1,0)) +
588  0.5 * dpos(2) * (fiter.offset(0,0,1) - fiter.offset(0,0,-1));
589  return;
590  }
591 
592  // gather particle data from Field using particle position and mesh
593  // and cache mesh information for reuse
594  template <class FT, class M, class C, class PT>
595  static
596  void gather(FT& pdata, const Field<FT,3U,M,C>& f,
597  const Vektor<PT,3U>& ppos, const M& mesh,
598  NDIndex<3U>& ngp, Vektor<PT,3U>& dpos) {
599  CenteringTag<C> ctag;
600  Vektor<PT,3U> gpos, delta;
601  // find nearest grid point for particle position, store in NDIndex obj
602  ngp = FindNGP(mesh, ppos, ctag);
603  // get position of ngp
604  FindPos(gpos, mesh, ngp, ctag);
605  // get distance from ppos to gpos
606  dpos = ppos - gpos;
607  // get mesh spacings
608  FindDelta(delta, mesh, ngp, ctag);
609  // normalize dpos by mesh spacing
610  dpos /= delta;
611  // Try to find ngp in local fields and get iterator
612  CompressedBrickIterator<FT,3U> fiter = getFieldIter(f,ngp);
613  // accumulate into particle attrib
614  pdata = (*fiter) +
615  0.5 * dpos(0) * (fiter.offset(1,0,0) - fiter.offset(-1,0,0)) +
616  0.5 * dpos(1) * (fiter.offset(0,1,0) - fiter.offset(0,-1,0)) +
617  0.5 * dpos(2) * (fiter.offset(0,0,1) - fiter.offset(0,0,-1));
618  return;
619  }
620 
621  // gather particle data from Field using cached mesh information
622  template <class FT, class M, class C, class PT>
623  static
624  void gather(FT& pdata, const Field<FT,3U,M,C>& f,
625  const NDIndex<3U>& ngp, const Vektor<PT,3U>& dpos) {
626  // Try to find ngp in local fields and get iterator
627  CompressedBrickIterator<FT,3U> fiter = getFieldIter(f,ngp);
628  // accumulate into particle attrib
629  pdata = (*fiter) +
630  0.5 * dpos(0) * (fiter.offset(1,0,0) - fiter.offset(-1,0,0)) +
631  0.5 * dpos(1) * (fiter.offset(0,1,0) - fiter.offset(0,-1,0)) +
632  0.5 * dpos(2) * (fiter.offset(0,0,1) - fiter.offset(0,0,-1));
633  return;
634  }
635 
636 };
637 
638 
639 // IntSUDS class -- what the user sees
640 class IntSUDS {
641 
642 public:
643  // constructor/destructor
644  IntSUDS() {}
645  ~IntSUDS() {}
646 
647  // gather/scatter functions
648 
649  // scatter particle data into Field using particle position and mesh
650  template <class FT, unsigned Dim, class M, class C, class PT>
651  static
652  void scatter(const FT& pdata, Field<FT,Dim,M,C>& f,
653  const Vektor<PT,Dim>& ppos, const M& mesh) {
654  IntSUDSImpl<Dim>::scatter(pdata,f,ppos,mesh);
655  }
656 
657  // scatter particle data into Field using particle position and mesh
658  // and cache mesh information for reuse
659  template <class FT, unsigned Dim, class M, class C, class PT>
660  static
661  void scatter(const FT& pdata, Field<FT,Dim,M,C>& f,
662  const Vektor<PT,Dim>& ppos, const M& mesh,
663  CacheData1<PT,Dim>& cache) {
664  IntSUDSImpl<Dim>::scatter(pdata,f,ppos,mesh,cache.Index_m,cache.Delta_m);
665  }
666 
667  // scatter particle data into Field using cached mesh information
668  template <class FT, unsigned Dim, class M, class C, class PT>
669  static
670  void scatter(const FT& pdata, Field<FT,Dim,M,C>& f,
671  const CacheData1<PT,Dim>& cache) {
672  IntSUDSImpl<Dim>::scatter(pdata,f,cache.Index_m,cache.Delta_m);
673  }
674 
675  // gather particle data from Field using particle position and mesh
676  template <class FT, unsigned Dim, class M, class C, class PT>
677  static
678  void gather(FT& pdata, const Field<FT,Dim,M,C>& f,
679  const Vektor<PT,Dim>& ppos, const M& mesh) {
680  IntSUDSImpl<Dim>::gather(pdata,f,ppos,mesh);
681  }
682 
683  // gather particle data from Field using particle position and mesh
684  // and cache mesh information for reuse
685  template <class FT, unsigned Dim, class M, class C, class PT>
686  static
687  void gather(FT& pdata, const Field<FT,Dim,M,C>& f,
688  const Vektor<PT,Dim>& ppos, const M& mesh,
689  CacheData1<PT,Dim>& cache) {
690  IntSUDSImpl<Dim>::gather(pdata,f,ppos,mesh,cache.Index_m,cache.Delta_m);
691  }
692 
693  // gather particle data from Field using cached mesh information
694  template <class FT, unsigned Dim, class M, class C, class PT>
695  static
696  void gather(FT& pdata, const Field<FT,Dim,M,C>& f,
697  const CacheData1<PT,Dim>& cache) {
698  IntSUDSImpl<Dim>::gather(pdata,f,cache.Index_m,cache.Delta_m);
699  }
700 
701 };
702 
703 #endif // INT_SUDS_H
704 
705 /***************************************************************************
706  * $RCSfile: IntSUDS.h,v $ $Author: adelmann $
707  * $Revision: 1.1.1.1 $ $Date: 2003/01/23 07:40:28 $
708  * IPPL_VERSION_ID: $Id: IntSUDS.h,v 1.1.1.1 2003/01/23 07:40:28 adelmann Exp $
709  ***************************************************************************/
710 
Dim
const unsigned Dim
Definition: P3MPoissonSolver.h:25
FindNGP
NDIndex< Dim > FindNGP(const M &mesh, const Vektor< PT, Dim > &ppos, CenteringTag< Cell >)
Definition: Interpolator.h:37
FindDelta
void FindDelta(Vektor< PT, Dim > &delta, const M &mesh, const NDIndex< Dim > &gp, CenteringTag< Cell >)
Definition: Interpolator.h:95
FindPos
void FindPos(Vektor< PT, Dim > &pos, const M &mesh, const NDIndex< Dim > &indices, CenteringTag< Cell >)
Definition: Interpolator.h:62
endl
Inform & endl(Inform &inf)
Definition: Inform.cpp:42
ERRORMSG
#define ERRORMSG(msg)
Definition: IpplInfo.h:350
Vektor
Definition: Vektor.h:32
Field
Definition: Field.h:33
BrickIterator::offset
T & offset(int i) const
Definition: BrickIterator.h:107
CacheData1::Delta_m
Vektor< T, Dim > Delta_m
Definition: Interpolator.h:134
CacheData1::Index_m
NDIndex< Dim > Index_m
Definition: Interpolator.h:133
Interpolator::getFieldIter
static CompressedBrickIterator< T, Dim > getFieldIter(const BareField< T, Dim > &f, const NDIndex< Dim > &pt)
Definition: Interpolator.h:183
InterpolatorTraits< T, Dim, IntSUDS >::Cache_t
CacheData1< T, Dim > Cache_t
Definition: IntSUDS.h:28
IntSUDSImpl::scatter
static void scatter(const FT &, Field< FT, Dim, M, C > &f, const Vektor< PT, Dim > &ppos, const M &mesh, NDIndex< Dim > &ngp, Vektor< PT, Dim > &dpos)
Definition: IntSUDS.h:72
IntSUDSImpl::gather
static void gather(FT &, const Field< FT, Dim, M, C > &f, const Vektor< PT, Dim > &ppos, const M &mesh)
Definition: IntSUDS.h:110
IntSUDSImpl::gather
static void gather(FT &, const Field< FT, Dim, M, C > &f, const Vektor< PT, Dim > &ppos, const M &mesh, NDIndex< Dim > &ngp, Vektor< PT, Dim > &dpos)
Definition: IntSUDS.h:136
IntSUDSImpl::gather
static void gather(FT &, const Field< FT, Dim, M, C > &f, const NDIndex< Dim > &ngp, const Vektor< PT, Dim > &)
Definition: IntSUDS.h:162
IntSUDSImpl::scatter
static void scatter(const FT &, Field< FT, Dim, M, C > &f, const NDIndex< Dim > &ngp, const Vektor< PT, Dim > &)
Definition: IntSUDS.h:98
IntSUDSImpl::~IntSUDSImpl
~IntSUDSImpl()
Definition: IntSUDS.h:39
IntSUDSImpl::IntSUDSImpl
IntSUDSImpl()
Definition: IntSUDS.h:38
IntSUDSImpl::scatter
static void scatter(const FT &, Field< FT, Dim, M, C > &f, const Vektor< PT, Dim > &ppos, const M &mesh)
Definition: IntSUDS.h:46
IntSUDSImpl< 1U >::scatter
static void scatter(const FT &pdata, Field< FT, 1U, M, C > &f, const NDIndex< 1U > &ngp, const Vektor< PT, 1U > &dpos)
Definition: IntSUDS.h:241
IntSUDSImpl< 1U >::gather
static void gather(FT &pdata, const Field< FT, 1U, M, C > &f, const NDIndex< 1U > &ngp, const Vektor< PT, 1U > &dpos)
Definition: IntSUDS.h:307
IntSUDSImpl< 1U >::scatter
static void scatter(const FT &pdata, Field< FT, 1U, M, C > &f, const Vektor< PT, 1U > &ppos, const M &mesh, NDIndex< 1U > &ngp, Vektor< PT, 1U > &dpos)
Definition: IntSUDS.h:214
IntSUDSImpl< 1U >::gather
static void gather(FT &pdata, const Field< FT, 1U, M, C > &f, const Vektor< PT, 1U > &ppos, const M &mesh)
Definition: IntSUDS.h:255
IntSUDSImpl< 1U >::scatter
static void scatter(const FT &pdata, Field< FT, 1U, M, C > &f, const Vektor< PT, 1U > &ppos, const M &mesh)
Definition: IntSUDS.h:187
IntSUDSImpl< 1U >::gather
static void gather(FT &pdata, const Field< FT, 1U, M, C > &f, const Vektor< PT, 1U > &ppos, const M &mesh, NDIndex< 1U > &ngp, Vektor< PT, 1U > &dpos)
Definition: IntSUDS.h:281
IntSUDSImpl< 2U >::scatter
static void scatter(const FT &pdata, Field< FT, 2U, M, C > &f, const Vektor< PT, 2U > &ppos, const M &mesh, NDIndex< 2U > &ngp, Vektor< PT, 2U > &dpos)
Definition: IntSUDS.h:362
IntSUDSImpl< 2U >::gather
static void gather(FT &pdata, const Field< FT, 2U, M, C > &f, const Vektor< PT, 2U > &ppos, const M &mesh, NDIndex< 2U > &ngp, Vektor< PT, 2U > &dpos)
Definition: IntSUDS.h:434
IntSUDSImpl< 2U >::gather
static void gather(FT &pdata, const Field< FT, 2U, M, C > &f, const NDIndex< 2U > &ngp, const Vektor< PT, 2U > &dpos)
Definition: IntSUDS.h:461
IntSUDSImpl< 2U >::scatter
static void scatter(const FT &pdata, Field< FT, 2U, M, C > &f, const NDIndex< 2U > &ngp, const Vektor< PT, 2U > &dpos)
Definition: IntSUDS.h:391
IntSUDSImpl< 2U >::gather
static void gather(FT &pdata, const Field< FT, 2U, M, C > &f, const Vektor< PT, 2U > &ppos, const M &mesh)
Definition: IntSUDS.h:407
IntSUDSImpl< 2U >::scatter
static void scatter(const FT &pdata, Field< FT, 2U, M, C > &f, const Vektor< PT, 2U > &ppos, const M &mesh)
Definition: IntSUDS.h:333
IntSUDSImpl< 3U >::scatter
static void scatter(const FT &pdata, Field< FT, 3U, M, C > &f, const Vektor< PT, 3U > &ppos, const M &mesh, NDIndex< 3U > &ngp, Vektor< PT, 3U > &dpos)
Definition: IntSUDS.h:519
IntSUDSImpl< 3U >::gather
static void gather(FT &pdata, const Field< FT, 3U, M, C > &f, const NDIndex< 3U > &ngp, const Vektor< PT, 3U > &dpos)
Definition: IntSUDS.h:624
IntSUDSImpl< 3U >::gather
static void gather(FT &pdata, const Field< FT, 3U, M, C > &f, const Vektor< PT, 3U > &ppos, const M &mesh)
Definition: IntSUDS.h:568
IntSUDSImpl< 3U >::scatter
static void scatter(const FT &pdata, Field< FT, 3U, M, C > &f, const Vektor< PT, 3U > &ppos, const M &mesh)
Definition: IntSUDS.h:488
IntSUDSImpl< 3U >::gather
static void gather(FT &pdata, const Field< FT, 3U, M, C > &f, const Vektor< PT, 3U > &ppos, const M &mesh, NDIndex< 3U > &ngp, Vektor< PT, 3U > &dpos)
Definition: IntSUDS.h:596
IntSUDSImpl< 3U >::scatter
static void scatter(const FT &pdata, Field< FT, 3U, M, C > &f, const NDIndex< 3U > &ngp, const Vektor< PT, 3U > &dpos)
Definition: IntSUDS.h:550
IntSUDS::scatter
static void scatter(const FT &pdata, Field< FT, Dim, M, C > &f, const Vektor< PT, Dim > &ppos, const M &mesh)
Definition: IntSUDS.h:652
IntSUDS::IntSUDS
IntSUDS()
Definition: IntSUDS.h:644
IntSUDS::~IntSUDS
~IntSUDS()
Definition: IntSUDS.h:645
IntSUDS::scatter
static void scatter(const FT &pdata, Field< FT, Dim, M, C > &f, const Vektor< PT, Dim > &ppos, const M &mesh, CacheData1< PT, Dim > &cache)
Definition: IntSUDS.h:661
IntSUDS::gather
static void gather(FT &pdata, const Field< FT, Dim, M, C > &f, const Vektor< PT, Dim > &ppos, const M &mesh)
Definition: IntSUDS.h:678
IntSUDS::gather
static void gather(FT &pdata, const Field< FT, Dim, M, C > &f, const Vektor< PT, Dim > &ppos, const M &mesh, CacheData1< PT, Dim > &cache)
Definition: IntSUDS.h:687
IntSUDS::gather
static void gather(FT &pdata, const Field< FT, Dim, M, C > &f, const CacheData1< PT, Dim > &cache)
Definition: IntSUDS.h:696
IntSUDS::scatter
static void scatter(const FT &pdata, Field< FT, Dim, M, C > &f, const CacheData1< PT, Dim > &cache)
Definition: IntSUDS.h:670
Generated on Wed Aug 25 2021 16:40:59 for OPAL (Object Oriented Parallel Accelerator Library) by doxygen 1.9.1