XGC1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
grid_field.hpp
Go to the documentation of this file.
1 #ifndef GRID_FIELD_HPP
2 #define GRID_FIELD_HPP
3 #include "space_settings.hpp"
4 #include "NamelistReader.hpp"
5 
6 #include "globals.hpp"
7 #include "grid.hpp"
8 #include "linear_weights.hpp"
9 #include "gyro_radius.hpp"
10 #include "field.hpp"
11 
12 /* TorType specifies whether the field is a single plane or needs a plane dimension
13  * */
14 enum class TorType{
15  OnePlane,
17 };
18 
19 // General declaration
20 // 2x2 = 4 types of GridField available: With and without gyroaverage dimension, with and without plane dimension
21 template<class Device, VarType VT, PhiInterpType PIT, TorType TT, KinType KT, ScatterType ST = ScatterType::Atomic>
22 struct GridField;
23 
24 // "ScalarGridField"
25 template<class Device, VarType VT, PhiInterpType PIT>
28  using device_type = Device;
29  static constexpr KinType KT = KinType::DriftKin;
30 
31  Kokkos::View<field_type*,Kokkos::LayoutRight,Device> f;
32 
34  GridField(std::string name, int nphi, int nrho, int nnode) : f(name,nnode) {}
35  GridField(std::string name, int nnode) : f(name,nnode) {}
36  field_type* data() const {return f.data();}
37  int size() const {return f.size();}
38  int nnode() const {return f.extent(0);}
39  int nrhop1() const {return 1;}
40  int nphi() const {return 1;}
41 
42  KOKKOS_INLINE_FUNCTION bool is_allocated() const {return f.is_allocated();}
43  KOKKOS_INLINE_FUNCTION field_type& operator ()(int inode) const {return f(inode);}
44 
45  // Scatter to a node
46  KOKKOS_INLINE_FUNCTION void scatter(int node, const SimdPhiWeights<get_phi_wt_usage(PIT)>& phi_wts, int i_simd, double particle_weight) const{
47  f(node).scatter(phi_wts, i_simd, particle_weight);
48  }
49 
50  // Scatter to a triangle
51  KOKKOS_INLINE_FUNCTION void scatter(const Grid<DeviceType>& grid, int ithread, const SimdGridWeights<Order::One, PIT_GLOBAL>& grid_wts, int i_simd, const SimdGyroWeights<DriftKin>& rho_wts, double particle_weight) const{
52  for (int j = 0; j<3; j++){
53  // Find triangle's nodes
54  int node=grid.get_node_index(grid_wts.itr[i_simd], j);
55  double wp=grid_wts.p[j][i_simd];
56 
57  // Scatter to node
58  scatter(node, grid_wts.phi_wts, i_simd, wp*particle_weight);
59  }
60  }
61 
62  // Gather from a triangle
63  KOKKOS_INLINE_FUNCTION void gather(const Grid<Device> &grid, const SimdGridWeights<Order::One, PhiInterpType::None>& grid_wts, const Simd<double>& phi, Simd<double>& fld) const{
64  // Initialize local field to 0
65  fld = 0.0;
66 
67  for (int i_simd = 0; i_simd<SIMD_SIZE; i_simd++){
68  if(grid_wts.is_invalid(i_simd)) continue;
69 
70  // Loop over the 3 vertices of the grid triangle and add up the contributions from each
71  for (int ip = 0; ip<3; ip++){
72  int node = grid.get_node_index(grid_wts.itr[i_simd], ip);
73  double wp = grid_wts.p[ip][i_simd];
74  f(node).gather(fld,i_simd,wp);
75  }
76  }
77  }
78 
79  // Gather from a triangle
80  KOKKOS_INLINE_FUNCTION void gather(const Grid<Device> &grid, const SimdGridWeights<Order::One, PhiInterpType::Planes>& grid_wts, const Simd<double>& phi, Simd<double>& fld) const{
81  // Initialize local field to 0
82  fld = 0.0;
83 
84  for (int i_simd = 0; i_simd<SIMD_SIZE; i_simd++){
85  if(grid_wts.is_invalid(i_simd)) continue;
86 
87  // Loop over the 3 vertices of the grid triangle and add up the contributions from each
88  for (int ip = 0; ip<3; ip++){
89  int node = grid.get_node_index(grid_wts.itr[i_simd], ip);
90  double wp = grid_wts.p[ip][i_simd];
91  f(node).gather(fld,i_simd,wp,grid_wts.phi_wts);
92  }
93  }
94  }
95 
96  void reset_to_zero(){
97  int ndoubles_in_grid_field = f.size()*field_type::SIZE();
98  Kokkos::View<double*,Kokkos::LayoutRight,Device,Kokkos::MemoryTraits<Kokkos::Unmanaged>> view_1d_double((double*)(data()), ndoubles_in_grid_field);
99  Kokkos::deep_copy(view_1d_double, 0.0);
100  }
101 
102  // TODO: Generalize this copy and these transposes for ndim etc
103  // Fill View with transposed data where inode is the contiguous index
104  // Ultimately, there should probably be an implementation GridField that has the transposed indices
105  void copy_to_double_view(const View<double*,CLayout,Device>& dest_view) const{
106  // Make an unmanaged view around the input field
107  View<double*,CLayout,Device,Kokkos::MemoryTraits<Kokkos::Unmanaged>> f_unmanaged((double*)data(),nnode());
108 
109  Kokkos::deep_copy(dest_view, f_unmanaged);
110  }
111 
112  View<double*,CLayout,Device,Kokkos::MemoryTraits<Kokkos::Unmanaged>> unmanaged() const{
113  return View<double*,CLayout,Device,Kokkos::MemoryTraits<Kokkos::Unmanaged>>((double*)(f.data()), f.layout());
114  }
115 
116  // Fill View with transposed data where inode is the contiguous index
117  // Ultimately, there should probably be an implementation GridField that has the transposed indices
118  void transpose_copy_to_double_view(const View<double**,CLayout,Device>& dest_view) const{
119  // Retrieve nphi from the Field of this GridField
120  constexpr int n_phi = field_type::NPHI();
121 
122  // Make an unmanaged view around the input field
123  View<double**,CLayout,Device,Kokkos::MemoryTraits<Kokkos::Unmanaged>> f_unmanaged((double*)data(),nnode(), n_phi);
124 
125  // Copy f_unmanaged into iphi = 0 and iphi = 1 of dest_view
126  Kokkos::parallel_for("var_transpose_copy", Kokkos::RangePolicy<typename Device::execution_space>( 0, nnode()), KOKKOS_LAMBDA(const int inode){
127  for(int iphi=0; iphi<n_phi; iphi++){
128  dest_view(iphi, inode) = f_unmanaged(inode, iphi);
129  }
130  });
131  Kokkos::fence();
132  }
133 
134  // Transpose and copy data from a view where inode is the contiguous index
135  void transpose_copy_from_double_view(const View<double**,CLayout,Device>& src_view) const{
136  // Retrieve nphi from the Field of this GridField
137  constexpr int n_phi = field_type::NPHI();
138 
139  // Make an unmanaged view of the data
140  View<double**,CLayout,Device,Kokkos::MemoryTraits<Kokkos::Unmanaged>> f_unmanaged((double*)data(),nnode(), n_phi);
141 
142  // Transpose from src_view into this gridfield
143  Kokkos::parallel_for("var_transpose_copy", Kokkos::RangePolicy<ExSpace>( 0, nnode()), KOKKOS_LAMBDA(const int inode){
144  for(int iphi=0; iphi<n_phi; iphi++){
145  f_unmanaged(inode, iphi) = src_view(iphi, inode);
146  }
147  });
148  Kokkos::fence();
149  }
150 
153  static KOKKOS_INLINE_FUNCTION void view_gather3(const Grid<DeviceType>& grid, const View<double*,CLayout,Device>& view1, const View<double*,CLayout,Device>& view2, const View<double*,CLayout,Device>& view3, const SimdGridWeights<Order::One, PIT_GLOBAL>& grid_wts, double& val1, double& val2, double& val3, int i_simd){
154  val1=0.0;
155  val2=0.0;
156  val3=0.0;
157  for (int ip=0; ip<3; ip++){
158  int nd = grid.get_node_index(grid_wts.itr[i_simd], ip);
159  val1 += view1(nd)*grid_wts.p[ip][i_simd];
160  val2 += view2(nd)*grid_wts.p[ip][i_simd];
161  val3 += view3(nd)*grid_wts.p[ip][i_simd];
162  }
163  }
164 
165  static KOKKOS_INLINE_FUNCTION void view_gather(const Grid<DeviceType>& grid, const View<double*,CLayout,Device>& view, const SimdGridWeights<Order::One, PIT_GLOBAL>& grid_wts, Simd<double>& val){
166  val = 0.0;
167  for (int i_simd = 0; i_simd<SIMD_SIZE; i_simd++){
168  if(grid_wts.itr[i_simd]<=0) continue;
169  for (int ip = 0; ip < 3; ip++){
170  int node = grid.get_node_index(grid_wts.itr[i_simd], ip);
171  val[i_simd] += grid_wts.p[ip][i_simd]*view(node);
172  }
173  }
174  }
175 
176  static KOKKOS_INLINE_FUNCTION void view_vec_odim_gather(const Grid<DeviceType>& grid, const View<Field<VarType::Vector,PhiInterpType::None>**,CLayout,Device>& view, int ind, const SimdGridWeights<Order::One, PhiInterpType::None>& grid_wts, SimdVector& val, int i_simd){
177  val.r[i_simd] = 0.0;
178  val.z[i_simd] = 0.0;
179  val.phi[i_simd] = 0.0;
180  for (int ip = 0; ip<3; ip++){
181  int node = grid.get_node_index(grid_wts.itr[i_simd], ip);
182  double wp = grid_wts.p[ip][i_simd];
183  view(ind,node).gather(val, i_simd, wp);
184  }
185  }
186 
187  static KOKKOS_INLINE_FUNCTION void view_gyro_scatter3(const Grid<DeviceType>& grid, const View<double**,CLayout,Device>& view1, const View<double**,CLayout,Device>& view2, const View<double**,CLayout,Device>& view3, const SimdGridWeights<Order::One, PIT_GLOBAL>& grid_wts, double val1, double val2, double val3, int i_simd, const LinearWeights& rho_wts, bool is_gyro){
188  // Scatter moments into grid array
189  for (int ip = 0; ip < 3; ip++){
190  int node = grid.get_node_index(grid_wts.itr[i_simd], ip);
191  Kokkos::atomic_add(&(view1(rho_wts.i, node)), grid_wts.p[ip][i_simd]*rho_wts.w[0]*val1);
192  Kokkos::atomic_add(&(view2(rho_wts.i, node)), grid_wts.p[ip][i_simd]*rho_wts.w[0]*val2);
193  Kokkos::atomic_add(&(view3(rho_wts.i, node)), grid_wts.p[ip][i_simd]*rho_wts.w[0]*val3);
194  if(is_gyro){
195  Kokkos::atomic_add(&(view1(rho_wts.i+1, node)), grid_wts.p[ip][i_simd]*rho_wts.w[1]*val1);
196  Kokkos::atomic_add(&(view2(rho_wts.i+1, node)), grid_wts.p[ip][i_simd]*rho_wts.w[1]*val2);
197  Kokkos::atomic_add(&(view3(rho_wts.i+1, node)), grid_wts.p[ip][i_simd]*rho_wts.w[1]*val3);
198  }
199  }
200  }
201 
202  // view with outer dimension
203  static KOKKOS_INLINE_FUNCTION void view_odim_scatter(const Grid<DeviceType>& grid, const View<double**,CLayout,Device>& view, int ind, const SimdGridWeights<Order::One, PIT_GLOBAL>& grid_wts, double val, int i_simd){
204  for (int j = 0; j<3; j++){
205  int node=grid.get_node_index(grid_wts.itr[i_simd], j);
206  double wp=grid_wts.p[j][i_simd];
207 
208  Kokkos::atomic_add(&(view(ind,node)), wp*val);
209  }
210  }
211 
212  static KOKKOS_INLINE_FUNCTION void view_scatter(const Grid<DeviceType>& grid, const View<double*,CLayout,Device>& view, const SimdGridWeights<Order::One, PhiInterpType::None>& grid_wts, double val, int i_simd){
213  for (int j = 0; j<3; j++){
214  int node=grid.get_node_index(grid_wts.itr[i_simd], j);
215  double wp=grid_wts.p[j][i_simd];
216 
217  Kokkos::atomic_add(&(view(node)), wp*val);
218  }
219  }
220 
221  static KOKKOS_INLINE_FUNCTION void view_ff_scatter(const Grid<DeviceType>& grid, const View<double**,CLayout,Device>& view, const SimdGridWeights<Order::One, PhiInterpType::Planes>& grid_wts, double wphi, double val, int i_simd){
222  for (int j = 0; j<3; j++){
223  int node=grid.get_node_index(grid_wts.itr[i_simd], j);
224  double wp=grid_wts.p[j][i_simd];
225 
226  Kokkos::atomic_add(&(view(0,node)), wp*wphi*val);
227  Kokkos::atomic_add(&(view(1,node)), wp*(1.0-wphi)*val);
228  }
229  }
230 
231  static KOKKOS_INLINE_FUNCTION void view_odim_variance(const Grid<DeviceType>& grid, const View<double**,CLayout,Device>& view, const View<double**,CLayout,Device>& variance, int ind, const SimdGridWeights<Order::One, PIT_GLOBAL>& grid_wts, double val, int i_simd){
232  for (int j = 0; j<3; j++){
233  int node=grid.get_node_index(grid_wts.itr[i_simd], j);
234  double wp=grid_wts.p[j][i_simd];
235 
236  double tmp = view(ind,node) - wp*val;
237  Kokkos::atomic_add(&(variance(ind,node)), tmp*tmp);
238  }
239  }
240 
241  static KOKKOS_INLINE_FUNCTION void view_rep_scatter3(const Grid<DeviceType>& grid, const View<double***,CLayout,Device>& view, int ind1, int ind2, int ind3, const SimdGridWeights<Order::One, PIT_GLOBAL>& grid_wts, double val1, double val2, double val3, int ithread, int i_simd){
242  // Scatter moments into grid array
243  for (int ip = 0; ip < 3; ip++){
244  int node = grid.get_node_index(grid_wts.itr[i_simd], ip);
245  double wp = grid_wts.p[ip][i_simd];
246 
247  access_add(&(view(ithread,node,ind1)),wp*val1);
248  access_add(&(view(ithread,node,ind2)),wp*val2);
249  access_add(&(view(ithread,node,ind3)),wp*val3);
250  }
251  }
252 };
253 
254 template<class Device, VarType VT, PhiInterpType PIT>
257  using device_type = Device;
258  static constexpr KinType KT = KinType::GyroKin;
259 
260  Kokkos::View<field_type**,Kokkos::LayoutRight,Device> f;
261 
263  GridField(std::string name, int nphi, int nrho, int nnode) : f(name,nnode, nrho+1) {}
264  GridField(std::string name, int nrho, int nnode) : f(name,nnode, nrho+1) {}
265  field_type* data() const {return f.data();}
266  int size() const {return f.size();}
267  int nnode() const {return f.extent(0);}
268  int nrhop1() const {return f.extent(1);}
269  int nphi() const {return 1;}
270  KOKKOS_INLINE_FUNCTION bool is_allocated() const {return f.is_allocated();}
271  KOKKOS_INLINE_FUNCTION field_type& operator ()(int inode, int irho) const {return f(inode, irho);}
272 
273  // Scatter to a node
274  KOKKOS_INLINE_FUNCTION void scatter(int node, const SimdPhiWeights<get_phi_wt_usage(PIT)>& phi_wts, const SimdGyroWeights<GyroKin>& rho_wts, int i_simd, double particle_weight) const{
275  int irho = rho_wts.irho(i_simd);
276  f(node,irho).scatter(rho_wts, phi_wts, i_simd, particle_weight, f(node,irho+1));
277  }
278 
279  // Scatter to a triangle (same as for DriftKin - consolidate)
280  KOKKOS_INLINE_FUNCTION void scatter(const Grid<DeviceType>& grid, int ithread, const SimdGridWeights<Order::One, PIT_GLOBAL>& grid_wts, int i_simd, const SimdGyroWeights<GyroKin>& rho_wts, double particle_weight) const{
281  for (int j = 0; j<3; j++){
282  // Find triangle's nodes
283  int node=grid.get_node_index(grid_wts.itr[i_simd], j);
284  double wp=grid_wts.p[j][i_simd];
285 
286  // Scatter to node
287  scatter(node, grid_wts.phi_wts, rho_wts, i_simd, wp*particle_weight);
288  }
289  }
290 
292  int ndoubles_in_grid_field = f.size()*field_type::SIZE();
293  Kokkos::View<double*,Kokkos::LayoutRight,Device,Kokkos::MemoryTraits<Kokkos::Unmanaged>> view_1d_double((double*)(f.data()), ndoubles_in_grid_field);
294  Kokkos::deep_copy(view_1d_double, 0.0);
295  }
296 };
297 
298 /******** GridField with array replication ********/
299 template<class Device, VarType VT, PhiInterpType PIT>
302  using device_type = Device;
303  static constexpr KinType KT = KinType::DriftKin;
304 
305  Kokkos::View<field_type**,Kokkos::LayoutRight,Device> f;
306 
308  GridField(std::string name, int nphi, int nrho, int nnode) : f(name,get_num_cpu_threads(), nnode) {}
309  GridField(std::string name, int nnode) : f(name,get_num_cpu_threads(), nnode) {}
310  field_type* data() const {return f.data();}
311  int size() const {return f.size();}
312  int nnode() const {return f.extent(1);}
313  int nrhop1() const {return 1;}
314  int nphi() const {return 1;}
315  KOKKOS_INLINE_FUNCTION bool is_allocated() const {return f.is_allocated();}
316  KOKKOS_INLINE_FUNCTION field_type& operator ()(int ithread, int inode) const {return f(ithread, inode);}
317 
318  // Scatter to a node
319  KOKKOS_INLINE_FUNCTION void scatter(int ithread, int node, const SimdPhiWeights<get_phi_wt_usage(PIT)>& phi_wts, int i_simd, double particle_weight) const{
320  f(ithread,node).scatter(phi_wts, i_simd, particle_weight);
321  }
322 
323  // Scatter to a triangle
324  KOKKOS_INLINE_FUNCTION void scatter(const Grid<DeviceType>& grid, int ithread, const SimdGridWeights<Order::One, PIT_GLOBAL>& grid_wts, int i_simd, const SimdGyroWeights<DriftKin>& rho_wts, double particle_weight) const{
325  for (int j = 0; j<3; j++){
326  // Find triangle's nodes
327  int node=grid.get_node_index(grid_wts.itr[i_simd], j);
328  double wp=grid_wts.p[j][i_simd];
329 
330  // Scatter to node
331  scatter(ithread, node, grid_wts.phi_wts, i_simd, wp*particle_weight);
332  }
333  }
334 
336  int ndoubles_in_grid_field = f.size()*field_type::SIZE();
337  Kokkos::View<double*,Kokkos::LayoutRight,Device,Kokkos::MemoryTraits<Kokkos::Unmanaged>> view_1d_double((double*)(f.data()), ndoubles_in_grid_field);
338  Kokkos::deep_copy(view_1d_double, 0.0);
339  }
340 };
341 
342 template<class Device, VarType VT, PhiInterpType PIT>
345  using device_type = Device;
346  static constexpr KinType KT = KinType::GyroKin;
347 
348  Kokkos::View<field_type***,Kokkos::LayoutRight,Device> f;
349 
351  GridField(std::string name, int nphi, int nrho, int nnode) : f(name,get_num_cpu_threads(),nnode, nrho+1) {}
352  GridField(std::string name, int nrho, int nnode) : f(name,get_num_cpu_threads(),nnode, nrho+1) {}
353  field_type* data() const {return f.data();}
354  int size() const {return f.size();}
355  int nnode() const {return f.extent(1);}
356  int nrhop1() const {return f.extent(2);}
357  int nphi() const {return 1;}
358  KOKKOS_INLINE_FUNCTION bool is_allocated() const {return f.is_allocated();}
359  KOKKOS_INLINE_FUNCTION field_type& operator ()(int ithread, int inode, int irho) const {return f(ithread,inode, irho);}
360 
361  // Scatter to a node
362  KOKKOS_INLINE_FUNCTION void scatter(int ithread, int node, const SimdPhiWeights<get_phi_wt_usage(PIT)>& phi_wts, const SimdGyroWeights<GyroKin>& rho_wts, int i_simd, double particle_weight) const{
363  int irho = rho_wts.irho(i_simd);
364  f(ithread,node,irho).scatter(rho_wts, phi_wts, i_simd, particle_weight, f(ithread,node,irho+1));
365  }
366 
367  // Scatter to a triangle (same as for DriftKin - consolidate)
368  KOKKOS_INLINE_FUNCTION void scatter(const Grid<DeviceType>& grid, int ithread, const SimdGridWeights<Order::One, PIT_GLOBAL>& grid_wts, int i_simd, const SimdGyroWeights<GyroKin>& rho_wts, double particle_weight) const{
369  for (int j = 0; j<3; j++){
370  // Find triangle's nodes
371  int node=grid.get_node_index(grid_wts.itr[i_simd], j);
372  double wp=grid_wts.p[j][i_simd];
373 
374  // Scatter to node
375  scatter(ithread, node, grid_wts.phi_wts, rho_wts, i_simd, wp*particle_weight);
376  }
377  }
378 
380  int ndoubles_in_grid_field = f.size()*field_type::SIZE();
381  Kokkos::View<double*,Kokkos::LayoutRight,Device,Kokkos::MemoryTraits<Kokkos::Unmanaged>> view_1d_double((double*)(f.data()), ndoubles_in_grid_field);
382  Kokkos::deep_copy(view_1d_double, 0.0);
383  }
384 };
385 /************/
386 
387 template<class Device, VarType VT, PhiInterpType PIT>
390  using device_type = Device;
391  static constexpr KinType KT = KinType::DriftKin;
392 
393  Kokkos::View<field_type**,Kokkos::LayoutRight,Device> f;
394 
396  GridField(std::string name, int nphi, int nrho, int nnode) : f(name,nphi, nnode) {}
397  GridField(std::string name, int nphi, int nnode) : f(name,nphi, nnode) {}
398  field_type* data() const {return f.data();}
399  int size() const {return f.size();}
400  int nnode() const {return f.extent(1);}
401  int nrhop1() const {return 1;}
402  int nphi() const {return f.extent(0);}
403  KOKKOS_INLINE_FUNCTION bool is_allocated() const {return f.is_allocated();}
404  KOKKOS_INLINE_FUNCTION field_type& operator ()(int iphi, int inode) const {return f(iphi, inode);}
405 
408  new_field.f = my_subview(f, subfield_idx);
409  return new_field;
410  }
411 
412  Kokkos::View<double**,Kokkos::LayoutRight,Device,Kokkos::MemoryTraits<Kokkos::Unmanaged>> unmanaged() const{
413  return Kokkos::View<double**,Kokkos::LayoutRight,Device,Kokkos::MemoryTraits<Kokkos::Unmanaged>>((double*)(f.data()), f.layout());
414  }
415 };
416 
417 template<class Device, VarType VT, PhiInterpType PIT>
420  using device_type = Device;
421  static constexpr KinType KT = KinType::GyroKin;
422 
423  Kokkos::View<field_type***,Kokkos::LayoutRight,Device> f;
424 
426  GridField(std::string name, int nphi, int nrho, int nnode) : f(name,nphi, nnode, nrho+1) {}
427  field_type* data() const {return f.data();}
428  int size() const {return f.size();}
429  int nnode() const {return f.extent(1);}
430  int nrhop1() const {return f.extent(2);}
431  int nphi() const {return f.extent(0);}
432  KOKKOS_INLINE_FUNCTION bool is_allocated() const {return f.is_allocated();}
433  KOKKOS_INLINE_FUNCTION field_type& operator ()(int iphi, int inode, int irho) const {return f(iphi, inode, irho);}
434 };
435 
436 // For convenience
448 
449 
450 // Shallow copy if types are the same
451 template<typename T>
452 inline void grid_field_copy(T& dest, const T& src){
453  dest = src;
454 }
455 
456 // Allocate dest grid_field and copy data from src
457 template<typename T1, typename T2>
458 inline void grid_field_copy(T1& dest, const T2& src){
459  // Allocate device array
460  dest = T1("grid_field",src.nphi(), src.nrhop1()-1, src.nnode());
461  // Deep copy from host to device
462  Kokkos::deep_copy(dest.f, src.f);
463 }
464 
465 #endif
static KOKKOS_INLINE_FUNCTION void view_odim_scatter(const Grid< DeviceType > &grid, const View< double **, CLayout, Device > &view, int ind, const SimdGridWeights< Order::One, PIT_GLOBAL > &grid_wts, double val, int i_simd)
Definition: grid_field.hpp:203
GridField< DeviceType, VarType::Vector2D, PhiInterpType::None, TorType::OnePlane, KinType::GyroKin > Efield2DGyroType
Definition: grid_field.hpp:445
Simd< double > r
Definition: simd.hpp:150
GridField(std::string name, int nphi, int nrho, int nnode)
Definition: grid_field.hpp:34
static KOKKOS_INLINE_FUNCTION void view_gather3(const Grid< DeviceType > &grid, const View< double *, CLayout, Device > &view1, const View< double *, CLayout, Device > &view2, const View< double *, CLayout, Device > &view3, const SimdGridWeights< Order::One, PIT_GLOBAL > &grid_wts, double &val1, double &val2, double &val3, int i_simd)
Definition: grid_field.hpp:153
Definition: simd.hpp:149
KOKKOS_INLINE_FUNCTION void scatter(const Grid< DeviceType > &grid, int ithread, const SimdGridWeights< Order::One, PIT_GLOBAL > &grid_wts, int i_simd, const SimdGyroWeights< DriftKin > &rho_wts, double particle_weight) const
Definition: grid_field.hpp:324
GridField(std::string name, int nphi, int nrho, int nnode)
Definition: grid_field.hpp:396
GridField< DeviceType, VarType::Scalar, PIT_GLOBAL, TorType::MultiplePlanes, KinType::DriftKin > PotType
Definition: grid_field.hpp:442
KOKKOS_INLINE_FUNCTION bool is_allocated() const
Definition: grid_field.hpp:42
GridField(std::string name, int nrho, int nnode)
Definition: grid_field.hpp:264
void transpose_copy_to_double_view(const View< double **, CLayout, Device > &dest_view) const
Definition: grid_field.hpp:118
KOKKOS_INLINE_FUNCTION int irho(int i_simd) const
Definition: gyro_radius.hpp:107
KOKKOS_INLINE_FUNCTION bool is_allocated() const
Definition: grid_field.hpp:270
static KOKKOS_INLINE_FUNCTION void view_gyro_scatter3(const Grid< DeviceType > &grid, const View< double **, CLayout, Device > &view1, const View< double **, CLayout, Device > &view2, const View< double **, CLayout, Device > &view3, const SimdGridWeights< Order::One, PIT_GLOBAL > &grid_wts, double val1, double val2, double val3, int i_simd, const LinearWeights &rho_wts, bool is_gyro)
Definition: grid_field.hpp:187
void scatter(const Grid< DeviceType > &grid, const MagneticField< DeviceType > &magnetic_field, const GridFieldPack< DeviceType, PIT > &gfpack, const Species< DeviceType > &species, bool exclude_private, bool do_cv_adjustment, bool cv_full_weight, const Charge< DeviceType, KT > &charge)
Definition: scatter.cpp:240
GridField(std::string name, int nrho, int nnode)
Definition: grid_field.hpp:352
void copy_to_double_view(const View< double *, CLayout, Device > &dest_view) const
Definition: grid_field.hpp:105
static KOKKOS_INLINE_FUNCTION void view_ff_scatter(const Grid< DeviceType > &grid, const View< double **, CLayout, Device > &view, const SimdGridWeights< Order::One, PhiInterpType::Planes > &grid_wts, double wphi, double val, int i_simd)
Definition: grid_field.hpp:221
Definition: linear_weights.hpp:8
Kokkos::View< field_type **, Kokkos::LayoutRight, Device > f
Definition: grid_field.hpp:260
Definition: globals.hpp:89
Definition: grid_weights.hpp:47
KOKKOS_INLINE_FUNCTION bool is_allocated() const
Definition: grid_field.hpp:403
GridField(std::string name, int nphi, int nnode)
Definition: grid_field.hpp:397
GridField(std::string name, int nnode)
Definition: grid_field.hpp:35
Kokkos::View< double **, Kokkos::LayoutRight, Device, Kokkos::MemoryTraits< Kokkos::Unmanaged > > unmanaged() const
Definition: grid_field.hpp:412
View< double *, CLayout, Device, Kokkos::MemoryTraits< Kokkos::Unmanaged > > unmanaged() const
Definition: grid_field.hpp:112
GridField< DeviceType, VarType::Vector2D, PhiInterpType::None, TorType::MultiplePlanes, KinType::DriftKin > Efield2DType
Definition: grid_field.hpp:441
GridField< DeviceType, VarType::Vector, PhiInterpType::Planes, TorType::MultiplePlanes, KinType::DriftKin > EfieldType
Definition: grid_field.hpp:440
KOKKOS_INLINE_FUNCTION bool is_allocated() const
Definition: grid_field.hpp:315
Kokkos::LayoutRight CLayout
Definition: space_settings.hpp:67
GridField< DeviceType, VarType::Vector2D, PIT_GLOBAL, TorType::OnePlane, KinType::DriftKin > E00Type
Definition: grid_field.hpp:443
KOKKOS_INLINE_FUNCTION bool is_allocated() const
Definition: grid_field.hpp:432
constexpr KOKKOS_INLINE_FUNCTION PhiWtUsage get_phi_wt_usage(PhiInterpType PIT)
Definition: grid_weights.hpp:15
GridField(std::string name, int nphi, int nrho, int nnode)
Definition: grid_field.hpp:308
Definition: grid_field.hpp:22
KOKKOS_INLINE_FUNCTION void gather(const Grid< Device > &grid, const SimdGridWeights< Order::One, PhiInterpType::Planes > &grid_wts, const Simd< double > &phi, Simd< double > &fld) const
Definition: grid_field.hpp:80
GridField< DeviceType, VarType::Scalar, PIT_GLOBAL, TorType::OnePlane, KinType::DriftKin > AxisymPotType
Definition: grid_field.hpp:439
KOKKOS_INLINE_FUNCTION void scatter(const Grid< DeviceType > &grid, int ithread, const SimdGridWeights< Order::One, PIT_GLOBAL > &grid_wts, int i_simd, const SimdGyroWeights< DriftKin > &rho_wts, double particle_weight) const
Definition: grid_field.hpp:51
Definition: grid_weights.hpp:18
TorType
Definition: grid_field.hpp:14
Definition: gyro_radius.hpp:114
KOKKOS_INLINE_FUNCTION void scatter(const Grid< DeviceType > &grid, int ithread, const SimdGridWeights< Order::One, PIT_GLOBAL > &grid_wts, int i_simd, const SimdGyroWeights< GyroKin > &rho_wts, double particle_weight) const
Definition: grid_field.hpp:280
Definition: gyro_radius.hpp:84
Kokkos::View< field_type *, Kokkos::LayoutRight, Device > f
Definition: grid_field.hpp:31
KOKKOS_INLINE_FUNCTION void scatter(int ithread, int node, const SimdPhiWeights< get_phi_wt_usage(PIT)> &phi_wts, const SimdGyroWeights< GyroKin > &rho_wts, int i_simd, double particle_weight) const
Definition: grid_field.hpp:362
KOKKOS_INLINE_FUNCTION void access_add(T *addr, T val)
Definition: access_add.hpp:40
KOKKOS_INLINE_FUNCTION void scatter(int node, const SimdPhiWeights< get_phi_wt_usage(PIT)> &phi_wts, int i_simd, double particle_weight) const
Definition: grid_field.hpp:46
static KOKKOS_INLINE_FUNCTION void view_odim_variance(const Grid< DeviceType > &grid, const View< double **, CLayout, Device > &view, const View< double **, CLayout, Device > &variance, int ind, const SimdGridWeights< Order::One, PIT_GLOBAL > &grid_wts, double val, int i_simd)
Definition: grid_field.hpp:231
void grid_field_copy(T &dest, const T &src)
Definition: grid_field.hpp:452
void transpose_copy_from_double_view(const View< double **, CLayout, Device > &src_view) const
Definition: grid_field.hpp:135
KOKKOS_INLINE_FUNCTION int get_node_index(int triangle_index, int tri_vertex_index) const
Definition: grid.tpp:158
GridField(std::string name, int nphi, int nrho, int nnode)
Definition: grid_field.hpp:263
KOKKOS_INLINE_FUNCTION void scatter(int ithread, int node, const SimdPhiWeights< get_phi_wt_usage(PIT)> &phi_wts, int i_simd, double particle_weight) const
Definition: grid_field.hpp:319
double w[2]
Definition: linear_weights.hpp:10
Definition: globals.hpp:90
GridField< DeviceType, VarType::Scalar, PhiInterpType::None, TorType::OnePlane, KinType::DriftKin > ScalarGridField
Definition: grid_field.hpp:437
GridField< Device, VT, PIT, TorType::OnePlane, KinType::DriftKin > subfield(int subfield_idx) const
Definition: grid_field.hpp:406
static KOKKOS_INLINE_FUNCTION void view_vec_odim_gather(const Grid< DeviceType > &grid, const View< Field< VarType::Vector, PhiInterpType::None > **, CLayout, Device > &view, int ind, const SimdGridWeights< Order::One, PhiInterpType::None > &grid_wts, SimdVector &val, int i_simd)
Definition: grid_field.hpp:176
static KOKKOS_INLINE_FUNCTION void view_scatter(const Grid< DeviceType > &grid, const View< double *, CLayout, Device > &view, const SimdGridWeights< Order::One, PhiInterpType::None > &grid_wts, double val, int i_simd)
Definition: grid_field.hpp:212
Simd< double > phi
Definition: simd.hpp:152
KOKKOS_INLINE_FUNCTION void gather(const Grid< Device > &grid, const SimdGridWeights< Order::One, PhiInterpType::None > &grid_wts, const Simd< double > &phi, Simd< double > &fld) const
Definition: grid_field.hpp:63
Simd< double > z
Definition: simd.hpp:151
int i
Definition: linear_weights.hpp:9
KinType
Definition: globals.hpp:88
Definition: field.hpp:45
Kokkos::View< field_type ***, Kokkos::LayoutRight, Device > f
Definition: grid_field.hpp:423
GridField< DeviceType, VarType::Vector2D, PIT_GLOBAL, TorType::OnePlane, KinType::GyroKin > E00GyroType
Definition: grid_field.hpp:447
Kokkos::View< field_type **, Kokkos::LayoutRight, Device > f
Definition: grid_field.hpp:305
Kokkos::View< T *, Kokkos::LayoutRight, Device > my_subview(const Kokkos::View< T ****, Kokkos::LayoutRight, Device > &view, int i, int j, int k)
Definition: my_subview.hpp:8
GridField< DeviceType, VarType::Scalar, PIT_GLOBAL, TorType::OnePlane, KinType::GyroKin > PotGyroType
Definition: grid_field.hpp:446
KOKKOS_INLINE_FUNCTION void scatter(int node, const SimdPhiWeights< get_phi_wt_usage(PIT)> &phi_wts, const SimdGyroWeights< GyroKin > &rho_wts, int i_simd, double particle_weight) const
Definition: grid_field.hpp:274
KOKKOS_INLINE_FUNCTION bool is_allocated() const
Definition: grid_field.hpp:358
int get_num_cpu_threads()
Definition: globals.hpp:17
Kokkos::View< field_type ***, Kokkos::LayoutRight, Device > f
Definition: grid_field.hpp:348
GridField(std::string name, int nphi, int nrho, int nnode)
Definition: grid_field.hpp:426
static KOKKOS_INLINE_FUNCTION void view_gather(const Grid< DeviceType > &grid, const View< double *, CLayout, Device > &view, const SimdGridWeights< Order::One, PIT_GLOBAL > &grid_wts, Simd< double > &val)
Definition: grid_field.hpp:165
void parallel_for(const std::string name, int n_ptl, Function func, Option option, HostAoSoA aosoa_h, DeviceAoSoA aosoa_d)
Definition: streamed_parallel_for.hpp:252
GridField< DeviceType, VarType::Scalar, PIT_GLOBAL, TorType::OnePlane, KinType::DriftKin > OnePlanePotType
Definition: grid_field.hpp:438
KOKKOS_INLINE_FUNCTION void scatter(const Grid< DeviceType > &grid, int ithread, const SimdGridWeights< Order::One, PIT_GLOBAL > &grid_wts, int i_simd, const SimdGyroWeights< GyroKin > &rho_wts, double particle_weight) const
Definition: grid_field.hpp:368
GridField< DeviceType, VarType::Vector, PhiInterpType::Planes, TorType::OnePlane, KinType::GyroKin > EfieldGyroType
Definition: grid_field.hpp:444
Kokkos::View< field_type **, Kokkos::LayoutRight, Device > f
Definition: grid_field.hpp:393
GridField(std::string name, int nphi, int nrho, int nnode)
Definition: grid_field.hpp:351
static KOKKOS_INLINE_FUNCTION void view_rep_scatter3(const Grid< DeviceType > &grid, const View< double ***, CLayout, Device > &view, int ind1, int ind2, int ind3, const SimdGridWeights< Order::One, PIT_GLOBAL > &grid_wts, double val1, double val2, double val3, int ithread, int i_simd)
Definition: grid_field.hpp:241