ImpactX
RFCavity.H
Go to the documentation of this file.
1 /* Copyright 2022-2023 The Regents of the University of California, through Lawrence
2  * Berkeley National Laboratory (subject to receipt of any required
3  * approvals from the U.S. Dept. of Energy). All rights reserved.
4  *
5  * This file is part of ImpactX.
6  *
7  * Authors: Chad Mitchell, Axel Huebl
8  * License: BSD-3-Clause-LBNL
9  */
10 #ifndef IMPACTX_RFCAVITY_H
11 #define IMPACTX_RFCAVITY_H
12 
15 #include "mixin/alignment.H"
16 #include "mixin/beamoptic.H"
17 #include "mixin/thick.H"
18 
19 #include <ablastr/constant.H>
20 
21 #include <AMReX.H>
22 #include <AMReX_Array.H>
23 #include <AMReX_Extension.H>
24 #include <AMReX_REAL.H>
25 
26 #include <array>
27 #include <cmath>
28 #include <stdexcept>
29 #include <tuple>
30 #include <vector>
31 
32 
33 namespace impactx
34 {
45  {
47  0.1644024074311037,
48  -0.1324009958969339,
49  4.3443060026047219e-002,
50  8.5602654094946495e-002,
51  -0.2433578169042885,
52  0.5297150596779437,
53  0.7164884680963959,
54  -5.2579522442877296e-003,
55  -5.5025369142193678e-002,
56  4.6845673335028933e-002,
57  -2.3279346335638568e-002,
58  4.0800777539657775e-003,
59  4.1378326533752169e-003,
60  -2.5040533340490805e-003,
61  -4.0654981400000964e-003,
62  9.6630592067498289e-003,
63  -8.5275895985990214e-003,
64  -5.8078747006425020e-002,
65  -2.4044337836660403e-002,
66  1.0968240064697212e-002,
67  -3.4461179858301418e-003,
68  -8.1201564869443749e-004,
69  2.1438992904959380e-003,
70  -1.4997753525697276e-003,
71  1.8685171825676386e-004
72  };
73 
75  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
76  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
77  0, 0, 0
78  };
79  };
80 
87 namespace RFCavityData
88 {
90  static inline int next_id = 0;
91 
93  static inline std::map<int, std::vector<amrex::ParticleReal>> h_cos_coef = {};
95  static inline std::map<int, std::vector<amrex::ParticleReal>> h_sin_coef = {};
96 
98  static inline std::map<int, amrex::Gpu::DeviceVector<amrex::ParticleReal>> d_cos_coef = {};
100  static inline std::map<int, amrex::Gpu::DeviceVector<amrex::ParticleReal>> d_sin_coef = {};
101 
102 } // namespace RFCavityData
103 
104  struct RFCavity
105  : public elements::BeamOptic<RFCavity>,
106  public elements::Thick,
107  public elements::Alignment
108  {
109  static constexpr auto name = "RFCavity";
111 
128  amrex::ParticleReal ds,
129  amrex::ParticleReal escale,
130  amrex::ParticleReal freq,
131  amrex::ParticleReal phase,
132  std::vector<amrex::ParticleReal> cos_coef,
133  std::vector<amrex::ParticleReal> sin_coef,
134  amrex::ParticleReal dx = 0,
135  amrex::ParticleReal dy = 0,
136  amrex::ParticleReal rotation_degree = 0,
137  int mapsteps = 1,
138  int nslice = 1
139  )
140  : Thick(ds, nslice),
141  Alignment(dx, dy, rotation_degree),
142  m_escale(escale), m_freq(freq), m_phase(phase), m_mapsteps(mapsteps)
143  {
144  // next created RF cavity has another id for its data
146 
147  // validate sin and cos coefficients are the same length
148  m_ncoef = int(cos_coef.size());
149  if (m_ncoef != int(sin_coef.size()))
150  throw std::runtime_error("RFCavity: cos and sin coefficients must have same length!");
151 
152  // host data
153  RFCavityData::h_cos_coef[m_id] = cos_coef;
154  RFCavityData::h_sin_coef[m_id] = sin_coef;
157 
158  // device data
162  cos_coef.begin(), cos_coef.end(),
163  RFCavityData::d_cos_coef[m_id].begin());
165  sin_coef.begin(), sin_coef.end(),
166  RFCavityData::d_sin_coef[m_id].begin());
168 
169  // low-level objects we can use on device
172  }
173 
175  using BeamOptic::operator();
176 
188  PType& AMREX_RESTRICT p,
189  amrex::ParticleReal & AMREX_RESTRICT px,
190  amrex::ParticleReal & AMREX_RESTRICT py,
191  amrex::ParticleReal & AMREX_RESTRICT pt,
192  [[maybe_unused]] RefPart const & refpart
193  ) const
194  {
195  using namespace amrex::literals; // for _rt and _prt
196 
197  // shift due to alignment errors of the element
198  shift_in(p.pos(RealAoS::x), p.pos(RealAoS::y), px, py);
199 
200  // access AoS data such as positions and cpu/id
201  amrex::ParticleReal const x = p.pos(RealAoS::x);
202  amrex::ParticleReal const y = p.pos(RealAoS::y);
203  amrex::ParticleReal const t = p.pos(RealAoS::t);
204 
205  // initialize output values of momenta
206  amrex::ParticleReal pxout = px;
207  amrex::ParticleReal pyout = py;
208  amrex::ParticleReal ptout = pt;
209 
210  // get the linear map
212 
213  // symplectic linear map for the RF cavity is computed using the
214  // Hamiltonian formalism as described in:
215  // https://uspas.fnal.gov/materials/09UNM/ComputationalMethods.pdf.
216  // R denotes the transfer matrix in the basis (x,px,y,py,t,pt),
217  // so that, e.g., R(3,4) = dyf/dpyi.
218 
219  // push particles using the linear map
220  p.pos(RealAoS::x) = R(1,1)*x + R(1,2)*px + R(1,3)*y
221  + R(1,4)*py + R(1,5)*t + R(1,6)*pt;
222  pxout = R(2,1)*x + R(2,2)*px + R(2,3)*y
223  + R(2,4)*py + R(2,5)*t + R(2,6)*pt;
224  p.pos(RealAoS::y) = R(3,1)*x + R(3,2)*px + R(3,3)*y
225  + R(3,4)*py + R(3,5)*t + R(3,6)*pt;
226  pyout = R(4,1)*x + R(4,2)*px + R(4,3)*y
227  + R(4,4)*py + R(4,5)*t + R(4,6)*pt;
228  p.pos(RealAoS::t) = R(5,1)*x + R(5,2)*px + R(5,3)*y
229  + R(5,4)*py + R(5,5)*t + R(5,6)*pt;
230  ptout = R(6,1)*x + R(6,2)*px + R(6,3)*y
231  + R(6,4)*py + R(6,5)*t + R(6,6)*pt;
232 
233  // assign updated momenta
234  px = pxout;
235  py = pyout;
236  pt = ptout;
237 
238  // undo shift due to alignment errors of the element
239  shift_out(p.pos(RealAoS::x), p.pos(RealAoS::y), px, py);
240  }
241 
247  void operator() (RefPart & AMREX_RESTRICT refpart) const
248  {
249  using namespace amrex::literals; // for _rt and _prt
250 
251  // assign input reference particle values
252  amrex::ParticleReal const x = refpart.x;
253  amrex::ParticleReal const px = refpart.px;
254  amrex::ParticleReal const y = refpart.y;
255  amrex::ParticleReal const py = refpart.py;
256  amrex::ParticleReal const z = refpart.z;
257  amrex::ParticleReal const pz = refpart.pz;
258  amrex::ParticleReal const pt = refpart.pt;
259  amrex::ParticleReal const s = refpart.s;
260  amrex::ParticleReal const sedge = refpart.sedge;
261 
262  // initialize linear map (deviation) values
263  for (int i=1; i<7; i++) {
264  for (int j=1; j<7; j++) {
265  if (i == j)
266  refpart.map(i, j) = 1.0_prt;
267  else
268  refpart.map(i, j) = 0.0_prt;
269  }
270  }
271 
272  // length of the current slice
273  amrex::ParticleReal const slice_ds = m_ds / nslice();
274 
275  // compute intial value of beta*gamma
276  amrex::ParticleReal const bgi = sqrt(pow(pt, 2) - 1.0_prt);
277 
278  // call integrator to advance (t,pt)
279  amrex::ParticleReal const zin = s - sedge;
280  amrex::ParticleReal const zout = zin + slice_ds;
281  int const nsteps = m_mapsteps;
282 
283  integrators::symp2_integrate_split3(refpart,zin,zout,nsteps,*this);
284  amrex::ParticleReal const ptf = refpart.pt;
285 
286  // advance position (x,y,z)
287  refpart.x = x + slice_ds*px/bgi;
288  refpart.y = y + slice_ds*py/bgi;
289  refpart.z = z + slice_ds*pz/bgi;
290 
291  // compute final value of beta*gamma
292  amrex::ParticleReal const bgf = sqrt(pow(ptf, 2) - 1.0_prt);
293 
294  // advance momentum (px,py,pz)
295  refpart.px = px*bgf/bgi;
296  refpart.py = py*bgf/bgi;
297  refpart.pz = pz*bgf/bgi;
298 
299  // convert linear map from dynamic to static units
300  amrex::ParticleReal scale_in = 1.0_prt;
301  amrex::ParticleReal scale_fin = 1.0_prt;
302 
303  for (int i=1; i<7; i++) {
304  for (int j=1; j<7; j++) {
305  if( i % 2 == 0)
306  scale_fin = bgf;
307  else
308  scale_fin = 1.0_prt;
309  if( j % 2 == 0)
310  scale_in = bgi;
311  else
312  scale_in = 1.0_prt;
313  refpart.map(i, j) = refpart.map(i, j) * scale_in / scale_fin;
314  }
315  }
316 
317  // advance integrated path length
318  refpart.s = s + slice_ds;
319  }
320 
327  std::tuple<amrex::ParticleReal, amrex::ParticleReal, amrex::ParticleReal>
329  RF_Efield (amrex::ParticleReal const zeval) const
330  {
331  using namespace amrex::literals; // for _rt and _prt
332 
333  // pick the right data depending if we are on the host side
334  // (reference particle push) or device side (particles):
335 #if AMREX_DEVICE_COMPILE
336  amrex::ParticleReal* cos_data = m_cos_d_data;
337  amrex::ParticleReal* sin_data = m_sin_d_data;
338 #else
339  amrex::ParticleReal* cos_data = m_cos_h_data;
340  amrex::ParticleReal* sin_data = m_sin_h_data;
341 #endif
342 
343  // specify constants
345  amrex::ParticleReal const zlen = m_ds;
346  amrex::ParticleReal const zmid = zlen / 2.0_prt;
347 
348  // compute on-axis electric field (z is relative to cavity midpoint)
349  amrex::ParticleReal efield = 0.0;
350  amrex::ParticleReal efieldp = 0.0;
351  amrex::ParticleReal efieldpp = 0.0;
352  amrex::ParticleReal efieldint = 0.0;
353  amrex::ParticleReal const z = zeval - zmid;
354 
355  if (std::abs(z) <= zmid)
356  {
357  efield = 0.5_prt*cos_data[0];
358  efieldint = z*efield;
359  for (int j=1; j < m_ncoef; ++j)
360  {
361  efield = efield + cos_data[j]*cos(j*2*pi*z/zlen) +
362  sin_data[j]*sin(j*2*pi*z/zlen);
363  efieldp = efieldp-j*2*pi*cos_data[j]*sin(j*2*pi*z/zlen)/zlen +
364  j*2*pi*sin_data[j]*cos(j*2*pi*z/zlen)/zlen;
365  efieldpp = efieldpp- pow(j*2*pi*cos_data[j]/zlen,2) *cos(j*2*pi*z/zlen) -
366  pow(j*2*pi*sin_data[j]/zlen,2) *sin(j*2*pi*z/zlen);
367  efieldint = efieldint + zlen*cos_data[j]*sin(j*2*pi*z/zlen)/(j*2*pi) -
368  zlen*sin_data[j]*cos(j*2*pi*z/zlen)/(j*2*pi);
369  }
370  }
371  return std::make_tuple(efield, efieldp, efieldint);
372  }
373 
383  void map3 (amrex::ParticleReal const tau,
384  RefPart & refpart,
385  [[maybe_unused]] amrex::ParticleReal & zeval) const
386  {
387  using namespace amrex::literals; // for _rt and _prt
388 
389  // push the reference particle
390  amrex::ParticleReal const t = refpart.t;
391  amrex::ParticleReal const pt = refpart.pt;
392 
393  if (pt < -1.0_prt) {
394  refpart.t = t + tau/sqrt(1.0_prt - pow(pt, -2));
395  refpart.pt = pt;
396  }
397  else {
398  refpart.t = t;
399  refpart.pt = pt;
400  }
401 
402  // push the linear map equations
404  amrex::ParticleReal const betgam = refpart.beta_gamma();
405 
406  refpart.map(5,5) = R(5,5) + tau*R(6,5)/pow(betgam,3);
407  refpart.map(5,6) = R(5,6) + tau*R(6,6)/pow(betgam,3);
408  }
409 
419  void map2 (amrex::ParticleReal const tau,
420  RefPart & refpart,
421  amrex::ParticleReal & zeval) const
422  {
423  using namespace amrex::literals; // for _rt and _prt
424 
425  amrex::ParticleReal const t = refpart.t;
426  amrex::ParticleReal const pt = refpart.pt;
427 
428  // Define parameters and intermediate constants
431  amrex::ParticleReal const k = (2.0_prt*pi/c)*m_freq;
432  amrex::ParticleReal const phi = m_phase*(pi/180.0_prt);
433  amrex::ParticleReal const E0 = m_escale;
434 
435  // push the reference particle
436  auto [ez, ezp, ezint] = RF_Efield(zeval);
437  amrex::ignore_unused(ez, ezint);
438 
439  refpart.t = t;
440  refpart.pt = pt;
441 
442  // push the linear map equations
444  amrex::ParticleReal const s = tau/refpart.beta_gamma();
445  amrex::ParticleReal const L = E0*ezp*sin(k*t+phi)/(2.0_prt*k);
446 
447  refpart.map(1,1) = (1.0_prt-s*L)*R(1,1) + s*R(2,1);
448  refpart.map(1,2) = (1.0_prt-s*L)*R(1,2) + s*R(2,2);
449  refpart.map(2,1) = -s*pow(L,2)*R(1,1) + (1.0_prt+s*L)*R(2,1);
450  refpart.map(2,2) = -s*pow(L,2)*R(1,2) + (1.0_prt+s*L)*R(2,2);
451 
452  refpart.map(3,3) = (1.0_prt-s*L)*R(3,3) + s*R(4,3);
453  refpart.map(3,4) = (1.0_prt-s*L)*R(3,4) + s*R(4,4);
454  refpart.map(4,3) = -s*pow(L,2)*R(3,3) + (1.0_prt+s*L)*R(4,3);
455  refpart.map(4,4) = -s*pow(L,2)*R(3,4) + (1.0_prt+s*L)*R(4,4);
456  }
457 
467  void map1 (amrex::ParticleReal const tau,
468  RefPart & refpart,
469  amrex::ParticleReal & zeval) const
470  {
471  using namespace amrex::literals; // for _rt and _prt
472 
473  amrex::ParticleReal const t = refpart.t;
474  amrex::ParticleReal const pt = refpart.pt;
475  amrex::ParticleReal const z = zeval;
476 
477  // Define parameters and intermediate constants
480  amrex::ParticleReal const k = (2.0_prt*pi/c)*m_freq;
481  amrex::ParticleReal const phi = m_phase*(pi/180.0_prt);
482  amrex::ParticleReal const E0 = m_escale;
483 
484  // push the reference particle
485  auto [ez, ezp, ezint] = RF_Efield(z);
487  zeval = z + tau;
488  auto [ezf, ezpf, ezintf] = RF_Efield(zeval);
490 
491  refpart.t = t;
492  refpart.pt = pt - E0*(ezintf-ezint)*cos(k*t+phi);
493 
494  // push the linear map equations
496  amrex::ParticleReal const M = E0*(ezintf-ezint)*k*sin(k*t+phi);
497  amrex::ParticleReal const L = E0*(ezpf-ezp)*sin(k*t+phi)/(2.0_prt*k)+M/2.0_prt;
498 
499  refpart.map(2,1) = L*R(1,1) + R(2,1);
500  refpart.map(2,2) = L*R(1,2) + R(2,2);
501 
502  refpart.map(4,3) = L*R(3,3) + R(4,3);
503  refpart.map(4,4) = L*R(3,4) + R(4,4);
504 
505  refpart.map(6,5) = M*R(5,5) + R(6,5);
506  refpart.map(6,6) = M*R(5,6) + R(6,6);
507  }
508 
511  void
513  {
514  // remove from unique data map
519 
524  }
525 
526  private:
527  amrex::ParticleReal m_escale;
528  amrex::ParticleReal m_freq;
529  amrex::ParticleReal m_phase;
531  int m_id;
532 
533  int m_ncoef = 0;
534  amrex::ParticleReal* m_cos_h_data = nullptr;
535  amrex::ParticleReal* m_sin_h_data = nullptr;
536  amrex::ParticleReal* m_cos_d_data = nullptr;
537  amrex::ParticleReal* m_sin_d_data = nullptr;
538  };
539 
540 } // namespace impactx
541 
542 #endif // IMPACTX_RFCAVITY_H
#define AMREX_FORCE_INLINE
#define AMREX_GPU_HOST_DEVICE
#define AMREX_GPU_HOST
static constexpr auto c
static constexpr amrex::Real pi
void copyAsync(HostToDevice, InIter begin, InIter end, OutIter result) noexcept
static constexpr HostToDevice hostToDevice
void streamSynchronize() noexcept
constexpr std::enable_if_t< std::is_floating_point< T >::value, T > pi()
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void ignore_unused(const Ts &...)
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE GpuComplex< T > pow(const GpuComplex< T > &a_z, const T &a_y) noexcept
const int[]
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE GpuComplex< T > sqrt(const GpuComplex< T > &a_z) noexcept
i
static std::map< int, std::vector< amrex::ParticleReal > > h_cos_coef
host: cosine coefficients in Fourier expansion of on-axis electric field Ez
Definition: RFCavity.H:93
static std::map< int, std::vector< amrex::ParticleReal > > h_sin_coef
host: sine coefficients in Fourier expansion of on-axis electric field Ez
Definition: RFCavity.H:95
static std::map< int, amrex::Gpu::DeviceVector< amrex::ParticleReal > > d_sin_coef
device: sine coefficients in Fourier expansion of on-axis electric field Ez
Definition: RFCavity.H:100
static std::map< int, amrex::Gpu::DeviceVector< amrex::ParticleReal > > d_cos_coef
device: cosine coefficients in Fourier expansion of on-axis electric field Ez
Definition: RFCavity.H:98
static int next_id
last used id for a created RF cavity
Definition: RFCavity.H:90
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void symp2_integrate_split3(RefPart &refpart, amrex::ParticleReal const zin, amrex::ParticleReal const zout, int const nsteps, T_Element const &element)
Definition: Integrators.H:53
Definition: ImpactX.cpp:35
@ t
fixed t as the independent variable
s
c
int nsteps
int count
Definition: RFCavity.H:45
amrex::Vector< amrex::ParticleReal > default_sin_coef
Definition: RFCavity.H:74
amrex::Vector< amrex::ParticleReal > default_cos_coef
Definition: RFCavity.H:46
Definition: RFCavity.H:108
amrex::ParticleReal m_escale
Definition: RFCavity.H:527
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void operator()(PType &AMREX_RESTRICT p, amrex::ParticleReal &AMREX_RESTRICT px, amrex::ParticleReal &AMREX_RESTRICT py, amrex::ParticleReal &AMREX_RESTRICT pt, [[maybe_unused]] RefPart const &refpart) const
Definition: RFCavity.H:187
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void map2(amrex::ParticleReal const tau, RefPart &refpart, amrex::ParticleReal &zeval) const
Definition: RFCavity.H:419
amrex::ParticleReal * m_cos_h_data
number of Fourier coefficients
Definition: RFCavity.H:534
amrex::ParticleReal m_phase
RF frequency in Hz.
Definition: RFCavity.H:529
void finalize()
Definition: RFCavity.H:512
amrex::ParticleReal * m_cos_d_data
non-owning pointer to host sine coefficients
Definition: RFCavity.H:536
int m_mapsteps
RF driven phase in deg.
Definition: RFCavity.H:530
RFCavity(amrex::ParticleReal ds, amrex::ParticleReal escale, amrex::ParticleReal freq, amrex::ParticleReal phase, std::vector< amrex::ParticleReal > cos_coef, std::vector< amrex::ParticleReal > sin_coef, amrex::ParticleReal dx=0, amrex::ParticleReal dy=0, amrex::ParticleReal rotation_degree=0, int mapsteps=1, int nslice=1)
Definition: RFCavity.H:127
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void map1(amrex::ParticleReal const tau, RefPart &refpart, amrex::ParticleReal &zeval) const
Definition: RFCavity.H:467
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void map3(amrex::ParticleReal const tau, RefPart &refpart, [[maybe_unused]] amrex::ParticleReal &zeval) const
Definition: RFCavity.H:383
std::tuple< amrex::ParticleReal, amrex::ParticleReal, amrex::ParticleReal > AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE RF_Efield(amrex::ParticleReal const zeval) const
Definition: RFCavity.H:329
static constexpr auto name
Definition: RFCavity.H:109
amrex::ParticleReal * m_sin_d_data
non-owning pointer to device cosine coefficients
Definition: RFCavity.H:537
ImpactXParticleContainer::ParticleType PType
Definition: RFCavity.H:110
int m_id
number of map integration steps per slice
Definition: RFCavity.H:531
amrex::ParticleReal * m_sin_h_data
non-owning pointer to host cosine coefficients
Definition: RFCavity.H:535
amrex::ParticleReal m_freq
scaling factor for RF electric field
Definition: RFCavity.H:528
int m_ncoef
unique RF cavity id used for data lookup map
Definition: RFCavity.H:533
@ x
position in x [m] (at fixed s OR fixed t)
Definition: ImpactXParticleContainer.H:49
@ y
position in y [m] (at fixed s OR fixed t)
Definition: ImpactXParticleContainer.H:50
@ t
c * time-of-flight [m] (at fixed s)
Definition: ImpactXParticleContainer.H:51
Definition: ReferenceParticle.H:30
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::ParticleReal beta_gamma() const
Definition: ReferenceParticle.H:79
amrex::ParticleReal pt
energy, normalized by rest energy
Definition: ReferenceParticle.H:39
amrex::Array2D< amrex::ParticleReal, 1, 6, 1, 6 > map
linearized map
Definition: ReferenceParticle.H:44
amrex::ParticleReal t
clock time * c in meters
Definition: ReferenceParticle.H:35
Definition: alignment.H:27
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void shift_out(amrex::ParticleReal &AMREX_RESTRICT x, amrex::ParticleReal &AMREX_RESTRICT y, amrex::ParticleReal &AMREX_RESTRICT px, amrex::ParticleReal &AMREX_RESTRICT py) const
Definition: alignment.H:91
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::ParticleReal dx() const
Definition: alignment.H:120
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void shift_in(amrex::ParticleReal &AMREX_RESTRICT x, amrex::ParticleReal &AMREX_RESTRICT y, amrex::ParticleReal &AMREX_RESTRICT px, amrex::ParticleReal &AMREX_RESTRICT py) const
Definition: alignment.H:61
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::ParticleReal dy() const
Definition: alignment.H:130
Definition: beamoptic.H:135
Definition: thick.H:24
Thick(amrex::ParticleReal ds, int nslice)
Definition: thick.H:30
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::ParticleReal ds() const
Definition: thick.H:53
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE int nslice() const
Definition: thick.H:43
amrex::ParticleReal m_ds
Definition: thick.H:58