Shamrock 2025.10.0
Astrophysical Code
Loading...
Searching...
No Matches
InterpolateToFace.cpp
Go to the documentation of this file.
1// -------------------------------------------------------//
2//
3// SHAMROCK code for hydrodynamics
4// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
5// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
6// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
7//
8// -------------------------------------------------------//
9
17
18#include "shambase/assert.hpp"
19#include "shammath/AABB.hpp"
23
24namespace {
25
26 template<class Tvec, class TgridVec, class AMRBlock>
27 class GetShift {
28
29 public:
30 using Tscal = shambase::VecComponent<Tvec>;
31 using Tgridscal = shambase::VecComponent<TgridVec>;
32
33 const Tvec *acc_aabb_block_lower;
34 const Tscal *acc_aabb_cell_size;
35
36 GetShift(const Tvec *aabb_block_lower, const Tscal *aabb_cell_size)
37 : acc_aabb_block_lower{aabb_block_lower}, acc_aabb_cell_size{aabb_cell_size} {}
38
39 shammath::AABB<Tvec> get_cell_aabb(u32 id) const {
40
41 const u32 cell_global_id = (u32) id;
42
43 const u32 block_id = cell_global_id / AMRBlock::block_size;
44 const u32 cell_loc_id = cell_global_id % AMRBlock::block_size;
45
46 // fetch current block info
47 const Tvec cblock_min = acc_aabb_block_lower[block_id];
48 const Tscal delta_cell = acc_aabb_cell_size[block_id];
49
50 std::array<u32, 3> lcoord_arr = AMRBlock::get_coord(cell_loc_id);
51 Tvec offset = Tvec{lcoord_arr[0], lcoord_arr[1], lcoord_arr[2]} * delta_cell;
52
53 Tvec aabb_min = cblock_min + offset;
54 Tvec aabb_max = aabb_min + delta_cell;
55
56 return {aabb_min, aabb_max};
57 }
58
59 std::pair<Tvec, Tvec> get_shifts(u32 id_a, u32 id_b) const {
60
61 shammath::AABB<Tvec> aabb_cell_a = get_cell_aabb(id_a);
62 shammath::AABB<Tvec> aabb_cell_b = get_cell_aabb(id_b);
63
64 shammath::AABB<Tvec> face_aabb = aabb_cell_a.get_intersect(aabb_cell_b);
65
66 Tvec face_center = face_aabb.get_center();
67
68 Tvec shift_a = face_center - aabb_cell_a.get_center();
69 Tvec shift_b = face_center - aabb_cell_b.get_center();
70
71 return {shift_a, shift_b};
72 }
73 };
74
75 template<class Tvec, class TgridVec, class AMRBlock>
76 class RhoInterpolate {
77 using Tscal = shambase::VecComponent<Tvec>;
78
79 public:
80 shamrock::PatchDataFieldSpanPointer<Tvec> aabb_block_lower;
81 shamrock::PatchDataFieldSpanPointer<Tscal> aabb_cell_size;
82 shamrock::PatchDataFieldSpanPointer<Tscal> rho_cell;
83 shamrock::PatchDataFieldSpanPointer<Tvec> grad_rho_cell;
84 // For time interpolation
85 Tscal dt_interp;
86 shamrock::PatchDataFieldSpanPointer<Tscal> dt_rho_cell;
87
88 class acc {
89 public:
90 GetShift<Tvec, TgridVec, AMRBlock> shift_get;
91
92 const Tscal *acc_rho_cell;
93 const Tvec *acc_grad_rho_cell;
94
95 // For time interpolation
96 const Tscal *acc_dt_rho_cell;
97
98 Tscal dt_interp;
99
100 acc(const Tvec *aabb_block_lower,
101 const Tscal *aabb_cell_size,
102 const Tscal *rho_cell,
103 const Tvec *grad_rho_cell,
104 // For time interpolation
105 Tscal dt_interp,
106 const Tscal *dt_rho_cell)
107 : shift_get(aabb_block_lower, aabb_cell_size), acc_rho_cell{rho_cell},
108 acc_grad_rho_cell{grad_rho_cell}, acc_dt_rho_cell{dt_rho_cell},
109 dt_interp(dt_interp) {}
110
111 std::array<Tscal, 2> get_link_field_val(u32 id_a, u32 id_b) const {
112
113 auto [shift_a, shift_b] = shift_get.get_shifts(id_a, id_b);
114
115 Tscal rho_a = acc_rho_cell[id_a];
116 Tvec grad_rho_a = acc_grad_rho_cell[id_a];
117 Tscal rho_b = acc_rho_cell[id_b];
118 Tvec grad_rho_b = acc_grad_rho_cell[id_b];
119
120 // Spatial interpolate
121 Tscal rho_face_a = rho_a + sycl::dot(grad_rho_a, shift_a);
122 Tscal rho_face_b = rho_b + sycl::dot(grad_rho_b, shift_b);
123
124 // Interpolate also to half a timestep
125 rho_face_a += acc_dt_rho_cell[id_a] * dt_interp;
126 rho_face_b += acc_dt_rho_cell[id_b] * dt_interp;
127
128 return {rho_face_a, rho_face_b};
129 }
130 };
131
132 inline acc get_read_access(sham::EventList &deps) {
133 return acc(
134 aabb_block_lower.get_read_access(deps),
135 aabb_cell_size.get_read_access(deps),
136 rho_cell.get_read_access(deps),
137 grad_rho_cell.get_read_access(deps),
138 // For time interpolation
139 dt_interp,
140 dt_rho_cell.get_read_access(deps));
141 }
142
143 inline void complete_event_state(sycl::event e) {
144 aabb_block_lower.complete_event_state(e);
145 aabb_cell_size.complete_event_state(e);
146 rho_cell.complete_event_state(e);
147 grad_rho_cell.complete_event_state(e);
148 dt_rho_cell.complete_event_state(e);
149 }
150 };
151
152 template<class Tvec, class TgridVec, class AMRBlock>
153 class VelInterpolate {
154 using Tscal = shambase::VecComponent<Tvec>;
155
156 public:
157 shamrock::PatchDataFieldSpanPointer<Tvec> aabb_block_lower;
158 shamrock::PatchDataFieldSpanPointer<Tscal> aabb_cell_size;
159
160 shamrock::PatchDataFieldSpanPointer<Tvec> vel_cell;
161 shamrock::PatchDataFieldSpanPointer<Tvec> dx_v_cell;
162 shamrock::PatchDataFieldSpanPointer<Tvec> dy_v_cell;
163 shamrock::PatchDataFieldSpanPointer<Tvec> dz_v_cell;
164 // For time interpolation
165 Tscal dt_interp;
166 shamrock::PatchDataFieldSpanPointer<Tvec> dt_vel_cell;
167
168 class acc {
169 public:
170 GetShift<Tvec, TgridVec, AMRBlock> shift_get;
171
172 const Tvec *acc_vel_cell;
173 const Tvec *acc_dx_v_cell;
174 const Tvec *acc_dy_v_cell;
175 const Tvec *acc_dz_v_cell;
176
177 // For time interpolation
178 const Tvec *acc_dt_vel_cell;
179
180 Tscal dt_interp;
181
182 acc(const Tvec *aabb_block_lower,
183 const Tscal *aabb_cell_size,
184 const Tvec *vel_cell,
185 const Tvec *dx_v_cell,
186 const Tvec *dy_v_cell,
187 const Tvec *dz_v_cell,
188 // For time interpolation
189 Tscal dt_interp,
190 const Tvec *dt_vel_cell)
191 : shift_get(aabb_block_lower, aabb_cell_size), acc_vel_cell{vel_cell},
192 acc_dx_v_cell{dx_v_cell}, acc_dy_v_cell{dy_v_cell}, acc_dz_v_cell{dz_v_cell},
193 acc_dt_vel_cell{dt_vel_cell}, dt_interp(dt_interp) {}
194
195 std::array<Tvec, 2> get_link_field_val(u32 id_a, u32 id_b) const {
196
197 auto [shift_a, shift_b] = shift_get.get_shifts(id_a, id_b);
198
199 Tvec v_a = acc_vel_cell[id_a];
200 Tvec dx_vel_a = acc_dx_v_cell[id_a];
201 Tvec dy_vel_a = acc_dy_v_cell[id_a];
202 Tvec dz_vel_a = acc_dz_v_cell[id_a];
203
204 Tvec v_b = acc_vel_cell[id_b];
205 Tvec dx_vel_b = acc_dx_v_cell[id_b];
206 Tvec dy_vel_b = acc_dy_v_cell[id_b];
207 Tvec dz_vel_b = acc_dz_v_cell[id_b];
208
209 Tvec dx_v_a_dot_shift
210 = shift_a.x() * dx_vel_a + shift_a.y() * dy_vel_a + shift_a.z() * dz_vel_a;
211 Tvec dx_v_b_dot_shift
212 = shift_b.x() * dx_vel_b + shift_b.y() * dy_vel_b + shift_b.z() * dz_vel_b;
213
214 Tvec dt_v_a = acc_dt_vel_cell[id_a];
215 Tvec dt_v_b = acc_dt_vel_cell[id_b];
216
217 Tvec vel_face_a = v_a + dx_v_a_dot_shift + dt_v_a * dt_interp;
218 Tvec vel_face_b = v_b + dx_v_b_dot_shift + dt_v_b * dt_interp;
219
220 return {vel_face_a, vel_face_b};
221 }
222 };
223
224 inline acc get_read_access(sham::EventList &deps) {
225 return acc(
226 aabb_block_lower.get_read_access(deps),
227 aabb_cell_size.get_read_access(deps),
228 vel_cell.get_read_access(deps),
229 dx_v_cell.get_read_access(deps),
230 dy_v_cell.get_read_access(deps),
231 dz_v_cell.get_read_access(deps),
232 // For time interpolation
233 dt_interp,
234 dt_vel_cell.get_read_access(deps));
235 }
236
237 inline void complete_event_state(sycl::event e) {
238 aabb_block_lower.complete_event_state(e);
239 aabb_cell_size.complete_event_state(e);
240 vel_cell.complete_event_state(e);
241 dx_v_cell.complete_event_state(e);
242 dy_v_cell.complete_event_state(e);
243 dz_v_cell.complete_event_state(e);
244 dt_vel_cell.complete_event_state(e);
245 }
246 };
247
248 template<class Tvec, class TgridVec, class AMRBlock>
249 class PressInterpolate {
250 using Tscal = shambase::VecComponent<Tvec>;
251
252 public:
253 shamrock::PatchDataFieldSpanPointer<Tvec> aabb_block_lower;
254 shamrock::PatchDataFieldSpanPointer<Tscal> aabb_cell_size;
255 shamrock::PatchDataFieldSpanPointer<Tscal> P_cell;
256 shamrock::PatchDataFieldSpanPointer<Tvec> grad_P_cell;
257 // For time interpolation
258 Tscal dt_interp;
259 shamrock::PatchDataFieldSpanPointer<Tscal> dt_P_cell;
260
261 class acc {
262 public:
263 GetShift<Tvec, TgridVec, AMRBlock> shift_get;
264
265 const Tscal *acc_P_cell;
266 const Tvec *acc_grad_P_cell;
267
268 // For time interpolation
269 const Tscal *acc_dt_P_cell;
270
271 Tscal dt_interp;
272
273 acc(const Tvec *aabb_block_lower,
274 const Tscal *aabb_cell_size,
275 const Tscal *P_cell,
276 const Tvec *grad_P_cell,
277 // For time interpolation
278 Tscal dt_interp,
279 const Tscal *dt_P_cell)
280 : shift_get(aabb_block_lower, aabb_cell_size), acc_P_cell{P_cell},
281 acc_grad_P_cell{grad_P_cell}, acc_dt_P_cell{dt_P_cell}, dt_interp(dt_interp) {}
282
283 std::array<Tscal, 2> get_link_field_val(u32 id_a, u32 id_b) const {
284
285 auto [shift_a, shift_b] = shift_get.get_shifts(id_a, id_b);
286
287 Tscal P_a = acc_P_cell[id_a];
288 Tvec grad_P_a = acc_grad_P_cell[id_a];
289 Tscal P_b = acc_P_cell[id_b];
290 Tvec grad_P_b = acc_grad_P_cell[id_b];
291
292 Tscal dtP_cell_a = acc_dt_P_cell[id_a];
293 Tscal dtP_cell_b = acc_dt_P_cell[id_b];
294
295 Tscal P_face_a = P_a + sycl::dot(grad_P_a, shift_a) + dtP_cell_a * dt_interp;
296 Tscal P_face_b = P_b + sycl::dot(grad_P_b, shift_b) + dtP_cell_b * dt_interp;
297
298 SHAM_ASSERT(P_face_a >= 0.0);
299 SHAM_ASSERT(P_face_b >= 0.0);
300
301 return {P_face_a, P_face_b};
302 }
303 };
304
305 inline acc get_read_access(sham::EventList &deps) {
306 return acc(
307 aabb_block_lower.get_read_access(deps),
308 aabb_cell_size.get_read_access(deps),
309 P_cell.get_read_access(deps),
310 grad_P_cell.get_read_access(deps),
311 dt_interp,
312 dt_P_cell.get_read_access(deps));
313 }
314
315 inline void complete_event_state(sycl::event e) {
316 aabb_block_lower.complete_event_state(e);
317 aabb_cell_size.complete_event_state(e);
318 P_cell.complete_event_state(e);
319 grad_P_cell.complete_event_state(e);
320 dt_P_cell.complete_event_state(e);
321 }
322 };
323
324 template<class Tvec, class TgridVec, class AMRBlock>
325 class RhoDustInterpolate {
326 using Tscal = shambase::VecComponent<Tvec>;
327
328 public:
329 u32 nvar;
330 shamrock::PatchDataFieldSpanPointer<Tvec> aabb_block_lower;
331 shamrock::PatchDataFieldSpanPointer<Tscal> aabb_cell_size;
332 shamrock::PatchDataFieldSpanPointer<Tscal> rho_dust_cell;
333 shamrock::PatchDataFieldSpanPointer<Tvec> grad_rho_dust_cell;
334 // For time interpolation
335 Tscal dt_interp;
336 shamrock::PatchDataFieldSpanPointer<Tscal> dt_rho_dust_cell;
337
338 class acc {
339 public:
340 GetShift<Tvec, TgridVec, AMRBlock> shift_get;
341 u32 nvar;
342
343 const Tscal *acc_rho_dust_cell;
344 const Tvec *acc_grad_rho_dust_cell;
345
346 // For time interpolation
347 const Tscal *acc_dt_rho_dust_cell;
348
349 Tscal dt_interp;
350
351 acc(u32 nvar,
352 const Tvec *aabb_block_lower,
353 const Tscal *aabb_cell_size,
354 const Tscal *rho_dust_cell,
355 const Tvec *grad_rho_dust_cell,
356 // For time interpolation
357 Tscal dt_interp,
358 const Tscal *dt_rho_dust_cell)
359 : shift_get(aabb_block_lower, aabb_cell_size), nvar(nvar),
360 acc_rho_dust_cell{rho_dust_cell}, acc_grad_rho_dust_cell{grad_rho_dust_cell},
361 acc_dt_rho_dust_cell{dt_rho_dust_cell}, dt_interp(dt_interp) {}
362
363 std::array<Tscal, 2> get_link_field_val(u32 id_a, u32 id_b) const {
364 const u32 icell_a = id_a / nvar;
365 const u32 icell_b = id_b / nvar;
366
367 auto [shift_a, shift_b] = shift_get.get_shifts(icell_a, icell_b);
368
369 Tscal rho_dust_a = acc_rho_dust_cell[id_a];
370 Tvec grad_rho_dust_a = acc_grad_rho_dust_cell[id_a];
371 Tscal rho_dust_b = acc_rho_dust_cell[id_b];
372 Tvec grad_rho_dust_b = acc_grad_rho_dust_cell[id_b];
373
374 Tscal rho_dust_face_a = rho_dust_a + sycl::dot(grad_rho_dust_a, shift_a);
375 Tscal rho_dust_face_b = rho_dust_b + sycl::dot(grad_rho_dust_b, shift_b);
376
377 rho_dust_face_a += acc_dt_rho_dust_cell[id_a] * dt_interp;
378 rho_dust_face_b += acc_dt_rho_dust_cell[id_b] * dt_interp;
379
380 return {rho_dust_face_a, rho_dust_face_b};
381 }
382 };
383
384 inline acc get_read_access(sham::EventList &deps) {
385 return acc(
386 nvar,
387 aabb_block_lower.get_read_access(deps),
388 aabb_cell_size.get_read_access(deps),
389 rho_dust_cell.get_read_access(deps),
390 grad_rho_dust_cell.get_read_access(deps),
391 // For time interpolation
392 dt_interp,
393 dt_rho_dust_cell.get_read_access(deps));
394 }
395
396 inline void complete_event_state(sycl::event e) {
397 aabb_block_lower.complete_event_state(e);
398 aabb_cell_size.complete_event_state(e);
399 rho_dust_cell.complete_event_state(e);
400 grad_rho_dust_cell.complete_event_state(e);
401 dt_rho_dust_cell.complete_event_state(e);
402 }
403 };
404
405 template<class Tvec, class TgridVec, class AMRBlock>
406 class VelDustInterpolate {
407 using Tscal = shambase::VecComponent<Tvec>;
408
409 public:
410 u32 nvar;
411 shamrock::PatchDataFieldSpanPointer<Tvec> aabb_block_lower;
412 shamrock::PatchDataFieldSpanPointer<Tscal> aabb_cell_size;
413 shamrock::PatchDataFieldSpanPointer<Tvec> vel_dust_cell;
414 shamrock::PatchDataFieldSpanPointer<Tvec> dx_v_dust_cell;
415 shamrock::PatchDataFieldSpanPointer<Tvec> dy_v_dust_cell;
416 shamrock::PatchDataFieldSpanPointer<Tvec> dz_v_dust_cell;
417 // For time interpolation
418 Tscal dt_interp;
419 shamrock::PatchDataFieldSpanPointer<Tvec> dt_vel_dust_cell;
420
421 class acc {
422 public:
423 GetShift<Tvec, TgridVec, AMRBlock> shift_get;
424 u32 nvar;
425
426 const Tvec *acc_vel_dust_cell;
427 const Tvec *acc_dx_v_dust_cell;
428 const Tvec *acc_dy_v_dust_cell;
429 const Tvec *acc_dz_v_dust_cell;
430
431 // For time interpolation
432 const Tvec *acc_dt_vel_dust_cell;
433
434 Tscal dt_interp;
435
436 acc(u32 nvar,
437 const Tvec *aabb_block_lower,
438 const Tscal *aabb_cell_size,
439 const Tvec *vel_dust_cell,
440 const Tvec *dx_v_dust_cell,
441 const Tvec *dy_v_dust_cell,
442 const Tvec *dz_v_dust_cell,
443 // For time interpolation
444 Tscal dt_interp,
445 const Tvec *dt_vel_dust_cell)
446 : shift_get(aabb_block_lower, aabb_cell_size), nvar(nvar),
447 acc_vel_dust_cell{vel_dust_cell}, acc_dx_v_dust_cell{dx_v_dust_cell},
448 acc_dy_v_dust_cell{dy_v_dust_cell}, acc_dz_v_dust_cell{dz_v_dust_cell},
449 acc_dt_vel_dust_cell{dt_vel_dust_cell}, dt_interp(dt_interp) {}
450
451 std::array<Tvec, 2> get_link_field_val(u32 id_a, u32 id_b) const {
452 const u32 icell_a = id_a / nvar;
453 const u32 icell_b = id_b / nvar;
454
455 auto [shift_a, shift_b] = shift_get.get_shifts(icell_a, icell_b);
456
457 Tvec v_dust_a = acc_vel_dust_cell[id_a];
458 Tvec dx_vel_dust_a = acc_dx_v_dust_cell[id_a];
459 Tvec dy_vel_dust_a = acc_dy_v_dust_cell[id_a];
460 Tvec dz_vel_dust_a = acc_dz_v_dust_cell[id_a];
461
462 Tvec v_dust_b = acc_vel_dust_cell[id_b];
463 Tvec dx_vel_dust_b = acc_dx_v_dust_cell[id_b];
464 Tvec dy_vel_dust_b = acc_dy_v_dust_cell[id_b];
465 Tvec dz_vel_dust_b = acc_dz_v_dust_cell[id_b];
466
467 Tvec dx_v_dust_a_dot_shift = shift_a.x() * dx_vel_dust_a
468 + shift_a.y() * dy_vel_dust_a
469 + shift_a.z() * dz_vel_dust_a;
470 Tvec dx_v_dust_b_dot_shift = shift_b.x() * dx_vel_dust_b
471 + shift_b.y() * dy_vel_dust_b
472 + shift_b.z() * dz_vel_dust_b;
473
474 Tvec dt_v_dust_a = acc_dt_vel_dust_cell[id_a];
475 Tvec dt_v_dust_b = acc_dt_vel_dust_cell[id_b];
476
477 Tvec vel_dust_face_a = v_dust_a + dx_v_dust_a_dot_shift + dt_v_dust_a * dt_interp;
478 Tvec vel_dust_face_b = v_dust_b + dx_v_dust_b_dot_shift + dt_v_dust_b * dt_interp;
479
480 return {vel_dust_face_a, vel_dust_face_b};
481 }
482 };
483
484 inline acc get_read_access(sham::EventList &deps) {
485 return acc(
486 nvar,
487 aabb_block_lower.get_read_access(deps),
488 aabb_cell_size.get_read_access(deps),
489 vel_dust_cell.get_read_access(deps),
490 dx_v_dust_cell.get_read_access(deps),
491 dy_v_dust_cell.get_read_access(deps),
492 dz_v_dust_cell.get_read_access(deps),
493 // For time interpolation
494 dt_interp,
495 dt_vel_dust_cell.get_read_access(deps));
496 }
497
498 inline void complete_event_state(sycl::event e) {
499 aabb_block_lower.complete_event_state(e);
500 aabb_cell_size.complete_event_state(e);
501 vel_dust_cell.complete_event_state(e);
502 dx_v_dust_cell.complete_event_state(e);
503 dy_v_dust_cell.complete_event_state(e);
504 dz_v_dust_cell.complete_event_state(e);
505 dt_vel_dust_cell.complete_event_state(e);
506 }
507 };
508
509} // namespace
510
511template<class Tvec, class TgridVec>
514 StackEntry stack_loc{};
515
517
518 static constexpr u32 NsideBlockPow = 1;
520
521 SHAM_ASSERT(AMRBlock::block_size == block_size);
522
523 auto edges = get_edges();
524
525 auto dt_interp = edges.dt_interp.value;
526
527 solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>> &rho_face_xp = edges.rho_face_xp;
528 solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>> &rho_face_xm = edges.rho_face_xm;
529 solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>> &rho_face_yp = edges.rho_face_yp;
530 solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>> &rho_face_ym = edges.rho_face_ym;
531 solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>> &rho_face_zp = edges.rho_face_zp;
532 solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>> &rho_face_zm = edges.rho_face_zm;
533
534 rho_face_xp.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::xp));
535 rho_face_xm.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::xm));
536 rho_face_yp.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::yp));
537 rho_face_ym.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::ym));
538 rho_face_zp.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::zp));
539 rho_face_zm.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::zm));
540
541 auto spans_block_cell_sizes = edges.spans_block_cell_sizes.get_spans();
542 auto spans_cell0block_aabb_lower = edges.spans_cell0block_aabb_lower.get_spans();
543 auto spans_rhos = edges.spans_rhos.get_spans();
544 auto spans_grad_rho = edges.spans_grad_rho.get_spans();
545 auto spans_dt_rho = edges.spans_dt_rho.get_spans();
546
547 using Interp = RhoInterpolate<Tvec, TgridVec, AMRBlock>;
548 auto interpolators
549 = spans_block_cell_sizes.template map<Interp>([&](u64 id, auto &csize) -> Interp {
550 return {
551 spans_cell0block_aabb_lower.get(id),
552 spans_block_cell_sizes.get(id),
553 spans_rhos.get(id),
554 spans_grad_rho.get(id),
555 dt_interp,
556 spans_dt_rho.get(id)};
557 });
558
559 auto graphs_xp = edges.cell_neigh_graph.get_refs_dir(Direction::xp);
560 auto graphs_xm = edges.cell_neigh_graph.get_refs_dir(Direction::xm);
561 auto graphs_yp = edges.cell_neigh_graph.get_refs_dir(Direction::yp);
562 auto graphs_ym = edges.cell_neigh_graph.get_refs_dir(Direction::ym);
563 auto graphs_zp = edges.cell_neigh_graph.get_refs_dir(Direction::zp);
564 auto graphs_zm = edges.cell_neigh_graph.get_refs_dir(Direction::zm);
565
567 = graphs_xp.template map<u32>([&](u64 id, auto &graph) {
568 return graph.get().obj_cnt;
569 });
571 = graphs_xm.template map<u32>([&](u64 id, auto &graph) {
572 return graph.get().obj_cnt;
573 });
575 = graphs_yp.template map<u32>([&](u64 id, auto &graph) {
576 return graph.get().obj_cnt;
577 });
579 = graphs_ym.template map<u32>([&](u64 id, auto &graph) {
580 return graph.get().obj_cnt;
581 });
583 = graphs_zp.template map<u32>([&](u64 id, auto &graph) {
584 return graph.get().obj_cnt;
585 });
587 = graphs_zm.template map<u32>([&](u64 id, auto &graph) {
588 return graph.get().obj_cnt;
589 });
590
592 shamsys::instance::get_compute_scheduler_ptr(),
593 sham::DDMultiRef{graphs_xp, interpolators},
594 sham::DDMultiRef{rho_face_xp.link_fields},
595 counts_xp,
596 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
597 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
598 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
599 });
600 });
602 shamsys::instance::get_compute_scheduler_ptr(),
603 sham::DDMultiRef{graphs_xm, interpolators},
604 sham::DDMultiRef{rho_face_xm.link_fields},
605 counts_xm,
606 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
607 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
608 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
609 });
610 });
612 shamsys::instance::get_compute_scheduler_ptr(),
613 sham::DDMultiRef{graphs_yp, interpolators},
614 sham::DDMultiRef{rho_face_yp.link_fields},
615 counts_yp,
616 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
617 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
618 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
619 });
620 });
622 shamsys::instance::get_compute_scheduler_ptr(),
623 sham::DDMultiRef{graphs_ym, interpolators},
624 sham::DDMultiRef{rho_face_ym.link_fields},
625 counts_ym,
626 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
627 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
628 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
629 });
630 });
632 shamsys::instance::get_compute_scheduler_ptr(),
633 sham::DDMultiRef{graphs_zp, interpolators},
634 sham::DDMultiRef{rho_face_zp.link_fields},
635 counts_zp,
636 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
637 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
638 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
639 });
640 });
642 shamsys::instance::get_compute_scheduler_ptr(),
643 sham::DDMultiRef{graphs_zm, interpolators},
644 sham::DDMultiRef{rho_face_zm.link_fields},
645 counts_zm,
646 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
647 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
648 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
649 });
650 });
651}
652
653template<class Tvec, class TgridVec>
658
660
661template<class Tvec, class TgridVec>
664 StackEntry stack_loc{};
665
667
668 static constexpr u32 NsideBlockPow = 1;
670
671 SHAM_ASSERT(AMRBlock::block_size == block_size);
672
673 auto edges = get_edges();
674
675 auto dt_interp = edges.dt_interp.value;
676
677 solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>> &vel_face_xp = edges.vel_face_xp;
678 solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>> &vel_face_xm = edges.vel_face_xm;
679 solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>> &vel_face_yp = edges.vel_face_yp;
680 solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>> &vel_face_ym = edges.vel_face_ym;
681 solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>> &vel_face_zp = edges.vel_face_zp;
682 solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>> &vel_face_zm = edges.vel_face_zm;
683
684 vel_face_xp.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::xp));
685 vel_face_xm.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::xm));
686 vel_face_yp.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::yp));
687 vel_face_ym.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::ym));
688 vel_face_zp.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::zp));
689 vel_face_zm.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::zm));
690
691 auto spans_block_cell_sizes = edges.spans_block_cell_sizes.get_spans();
692 auto spans_cell0block_aabb_lower = edges.spans_cell0block_aabb_lower.get_spans();
693 auto spans_vel = edges.spans_vel.get_spans();
694 auto spans_dx_vel = edges.spans_dx_vel.get_spans();
695 auto spans_dy_vel = edges.spans_dy_vel.get_spans();
696 auto spans_dz_vel = edges.spans_dz_vel.get_spans();
697 auto spans_dt_vel = edges.spans_dt_vel.get_spans();
698
699 using Interp = VelInterpolate<Tvec, TgridVec, AMRBlock>;
700 auto interpolators
701 = spans_block_cell_sizes.template map<Interp>([&](u64 id, auto &csize) -> Interp {
702 return {
703 spans_cell0block_aabb_lower.get(id),
704 spans_block_cell_sizes.get(id),
705 spans_vel.get(id),
706 spans_dx_vel.get(id),
707 spans_dy_vel.get(id),
708 spans_dz_vel.get(id),
709 dt_interp,
710 spans_dt_vel.get(id)};
711 });
712
713 auto graphs_xp = edges.cell_neigh_graph.get_refs_dir(Direction::xp);
714 auto graphs_xm = edges.cell_neigh_graph.get_refs_dir(Direction::xm);
715 auto graphs_yp = edges.cell_neigh_graph.get_refs_dir(Direction::yp);
716 auto graphs_ym = edges.cell_neigh_graph.get_refs_dir(Direction::ym);
717 auto graphs_zp = edges.cell_neigh_graph.get_refs_dir(Direction::zp);
718 auto graphs_zm = edges.cell_neigh_graph.get_refs_dir(Direction::zm);
719
721 = graphs_xp.template map<u32>([&](u64 id, auto &graph) {
722 return graph.get().obj_cnt;
723 });
725 = graphs_xm.template map<u32>([&](u64 id, auto &graph) {
726 return graph.get().obj_cnt;
727 });
729 = graphs_yp.template map<u32>([&](u64 id, auto &graph) {
730 return graph.get().obj_cnt;
731 });
733 = graphs_ym.template map<u32>([&](u64 id, auto &graph) {
734 return graph.get().obj_cnt;
735 });
737 = graphs_zp.template map<u32>([&](u64 id, auto &graph) {
738 return graph.get().obj_cnt;
739 });
741 = graphs_zm.template map<u32>([&](u64 id, auto &graph) {
742 return graph.get().obj_cnt;
743 });
744
746 shamsys::instance::get_compute_scheduler_ptr(),
747 sham::DDMultiRef{graphs_xp, interpolators},
748 sham::DDMultiRef{vel_face_xp.link_fields},
749 counts_xp,
750 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
751 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
752 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
753 });
754 });
756 shamsys::instance::get_compute_scheduler_ptr(),
757 sham::DDMultiRef{graphs_xm, interpolators},
758 sham::DDMultiRef{vel_face_xm.link_fields},
759 counts_xm,
760 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
761 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
762 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
763 });
764 });
766 shamsys::instance::get_compute_scheduler_ptr(),
767 sham::DDMultiRef{graphs_yp, interpolators},
768 sham::DDMultiRef{vel_face_yp.link_fields},
769 counts_yp,
770 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
771 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
772 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
773 });
774 });
776 shamsys::instance::get_compute_scheduler_ptr(),
777 sham::DDMultiRef{graphs_ym, interpolators},
778 sham::DDMultiRef{vel_face_ym.link_fields},
779 counts_ym,
780 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
781 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
782 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
783 });
784 });
786 shamsys::instance::get_compute_scheduler_ptr(),
787 sham::DDMultiRef{graphs_zp, interpolators},
788 sham::DDMultiRef{vel_face_zp.link_fields},
789 counts_zp,
790 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
791 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
792 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
793 });
794 });
796 shamsys::instance::get_compute_scheduler_ptr(),
797 sham::DDMultiRef{graphs_zm, interpolators},
798 sham::DDMultiRef{vel_face_zm.link_fields},
799 counts_zm,
800 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
801 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
802 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
803 });
804 });
805}
806
807template<class Tvec, class TgridVec>
812
814
815template<class Tvec, class TgridVec>
818 StackEntry stack_loc{};
819
821
822 static constexpr u32 NsideBlockPow = 1;
824
825 SHAM_ASSERT(AMRBlock::block_size == block_size);
826
827 auto edges = get_edges();
828
829 auto dt_interp = edges.dt_interp.value;
830
831 solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>> &press_face_xp = edges.press_face_xp;
832 solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>> &press_face_xm = edges.press_face_xm;
833 solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>> &press_face_yp = edges.press_face_yp;
834 solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>> &press_face_ym = edges.press_face_ym;
835 solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>> &press_face_zp = edges.press_face_zp;
836 solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>> &press_face_zm = edges.press_face_zm;
837
838 press_face_xp.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::xp));
839 press_face_xm.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::xm));
840 press_face_yp.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::yp));
841 press_face_ym.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::ym));
842 press_face_zp.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::zp));
843 press_face_zm.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::zm));
844
845 auto spans_block_cell_sizes = edges.spans_block_cell_sizes.get_spans();
846 auto spans_cell0block_aabb_lower = edges.spans_cell0block_aabb_lower.get_spans();
847 auto spans_press = edges.spans_press.get_spans();
848 auto spans_grad_P = edges.spans_grad_P.get_spans();
849 auto spans_dt_press = edges.spans_dt_press.get_spans();
850
851 using Interp = PressInterpolate<Tvec, TgridVec, AMRBlock>;
852 auto interpolators
853 = spans_block_cell_sizes.template map<Interp>([&](u64 id, auto &csize) -> Interp {
854 return {
855 spans_cell0block_aabb_lower.get(id),
856 spans_block_cell_sizes.get(id),
857 spans_press.get(id),
858 spans_grad_P.get(id),
859 dt_interp,
860 spans_dt_press.get(id)};
861 });
862
863 auto graphs_xp = edges.cell_neigh_graph.get_refs_dir(Direction::xp);
864 auto graphs_xm = edges.cell_neigh_graph.get_refs_dir(Direction::xm);
865 auto graphs_yp = edges.cell_neigh_graph.get_refs_dir(Direction::yp);
866 auto graphs_ym = edges.cell_neigh_graph.get_refs_dir(Direction::ym);
867 auto graphs_zp = edges.cell_neigh_graph.get_refs_dir(Direction::zp);
868 auto graphs_zm = edges.cell_neigh_graph.get_refs_dir(Direction::zm);
869
871 = graphs_xp.template map<u32>([&](u64 id, auto &graph) {
872 return graph.get().obj_cnt;
873 });
875 = graphs_xm.template map<u32>([&](u64 id, auto &graph) {
876 return graph.get().obj_cnt;
877 });
879 = graphs_yp.template map<u32>([&](u64 id, auto &graph) {
880 return graph.get().obj_cnt;
881 });
883 = graphs_ym.template map<u32>([&](u64 id, auto &graph) {
884 return graph.get().obj_cnt;
885 });
887 = graphs_zp.template map<u32>([&](u64 id, auto &graph) {
888 return graph.get().obj_cnt;
889 });
891 = graphs_zm.template map<u32>([&](u64 id, auto &graph) {
892 return graph.get().obj_cnt;
893 });
894
896 shamsys::instance::get_compute_scheduler_ptr(),
897 sham::DDMultiRef{graphs_xp, interpolators},
898 sham::DDMultiRef{press_face_xp.link_fields},
899 counts_xp,
900 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
901 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
902 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
903 });
904 });
906 shamsys::instance::get_compute_scheduler_ptr(),
907 sham::DDMultiRef{graphs_xm, interpolators},
908 sham::DDMultiRef{press_face_xm.link_fields},
909 counts_xm,
910 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
911 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
912 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
913 });
914 });
916 shamsys::instance::get_compute_scheduler_ptr(),
917 sham::DDMultiRef{graphs_yp, interpolators},
918 sham::DDMultiRef{press_face_yp.link_fields},
919 counts_yp,
920 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
921 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
922 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
923 });
924 });
926 shamsys::instance::get_compute_scheduler_ptr(),
927 sham::DDMultiRef{graphs_ym, interpolators},
928 sham::DDMultiRef{press_face_ym.link_fields},
929 counts_ym,
930 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
931 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
932 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
933 });
934 });
936 shamsys::instance::get_compute_scheduler_ptr(),
937 sham::DDMultiRef{graphs_zp, interpolators},
938 sham::DDMultiRef{press_face_zp.link_fields},
939 counts_zp,
940 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
941 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
942 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
943 });
944 });
946 shamsys::instance::get_compute_scheduler_ptr(),
947 sham::DDMultiRef{graphs_zm, interpolators},
948 sham::DDMultiRef{press_face_zm.link_fields},
949 counts_zm,
950 [](u32 id_a, auto link_iter, auto compute, auto acc_link_field) {
951 link_iter.for_each_object_link_id(id_a, [&](u32 id_b, u32 link_id) {
952 acc_link_field[link_id] = compute.get_link_field_val(id_a, id_b);
953 });
954 });
955}
956
957template<class Tvec, class TgridVec>
962
964
966 namespace {
967
974 template<class Tvec, class TgridVec>
975 void interpolate_multivar_scalar_to_face(
976 u32 nvar,
977 shambase::VecComponent<Tvec> dt_interp,
979 const shamrock::solvergraph::IFieldSpan<shambase::VecComponent<Tvec>>
980 &spans_block_cell_sizes_edge,
981 const shamrock::solvergraph::IFieldSpan<Tvec> &spans_cell0block_aabb_lower_edge,
982 const shamrock::solvergraph::IFieldSpan<shambase::VecComponent<Tvec>> &spans_field_edge,
983 const shamrock::solvergraph::IFieldSpan<Tvec> &spans_grad_field_edge,
984 const shamrock::solvergraph::IFieldSpan<shambase::VecComponent<Tvec>>
985 &spans_dt_field_edge,
986 std::array<
987 solvergraph::NeighGraphLinkFieldEdge<std::array<shambase::VecComponent<Tvec>, 2>> *,
988 6> faces) {
989
990 static constexpr u32 NsideBlockPow = 1;
992
993 const std::array<Direction, 6> dirs
994 = {Direction::xp,
995 Direction::xm,
996 Direction::yp,
997 Direction::ym,
998 Direction::zp,
999 Direction::zm};
1000
1001 for (u32 d = 0; d < 6; d++) {
1002 faces[d]->resize_according_to(cell_neigh_graph.get_refs_dir(dirs[d]));
1003 }
1004
1005 auto spans_block_cell_sizes = spans_block_cell_sizes_edge.get_spans();
1006 auto spans_cell0block_aabb_lower = spans_cell0block_aabb_lower_edge.get_spans();
1007 auto spans_field = spans_field_edge.get_spans();
1008 auto spans_grad_field = spans_grad_field_edge.get_spans();
1009 auto spans_dt_field = spans_dt_field_edge.get_spans();
1010
1011 using Interp = RhoDustInterpolate<Tvec, TgridVec, AMRBlock>;
1012 auto interpolators
1013 = spans_block_cell_sizes.template map<Interp>([&](u64 id, auto &csize) -> Interp {
1014 return {
1015 nvar,
1016 spans_cell0block_aabb_lower.get(id),
1017 spans_block_cell_sizes.get(id),
1018 spans_field.get(id),
1019 spans_grad_field.get(id),
1020 dt_interp,
1021 spans_dt_field.get(id)};
1022 });
1023
1024 for (u32 d = 0; d < 6; d++) {
1025 auto graphs = cell_neigh_graph.get_refs_dir(dirs[d]);
1026
1028 = graphs.template map<u32>([&](u64 id, auto &graph) {
1029 return graph.get().obj_cnt * nvar;
1030 });
1031
1033 shamsys::instance::get_compute_scheduler_ptr(),
1034 sham::DDMultiRef{graphs, interpolators},
1035 sham::DDMultiRef{faces[d]->link_fields},
1036 counts,
1037 [nvar](u32 idvar_a, auto link_iter, auto compute, auto acc_link_field) {
1038 const u32 id_cell_a = idvar_a / nvar;
1039 const u32 nvar_loc = idvar_a % nvar;
1040 link_iter.for_each_object_link_id(
1041 id_cell_a, [&](u32 id_cell_b, u32 link_id) {
1042 acc_link_field[link_id * nvar + nvar_loc]
1043 = compute.get_link_field_val(
1044 id_cell_a * nvar + nvar_loc, id_cell_b * nvar + nvar_loc);
1045 });
1046 });
1047 }
1048 }
1049
1050 } // namespace
1051} // namespace shammodels::basegodunov::modules
1052
1053template<class Tvec, class TgridVec>
1057
1058 SHAM_ASSERT((amr::AMRBlock<Tvec, TgridVec, 1>::block_size == block_size));
1059
1060 auto edges = get_edges();
1061
1062 interpolate_multivar_scalar_to_face<Tvec, TgridVec>(
1063 ndust,
1064 edges.dt_interp.value,
1065 edges.cell_neigh_graph,
1066 edges.spans_block_cell_sizes,
1067 edges.spans_cell0block_aabb_lower,
1068 edges.spans_rhos_dust,
1069 edges.spans_grad_rho_dust,
1070 edges.spans_dt_rho_dust,
1071 {&edges.rho_dust_face_xp,
1072 &edges.rho_dust_face_xm,
1073 &edges.rho_dust_face_yp,
1074 &edges.rho_dust_face_ym,
1075 &edges.rho_dust_face_zp,
1076 &edges.rho_dust_face_zm});
1077}
1078
1079template<class Tvec, class TgridVec>
1084
1086
1087template<class Tvec, class TgridVec>
1090 StackEntry stack_loc{};
1091
1093
1094 static constexpr u32 NsideBlockPow = 1;
1096
1097 SHAM_ASSERT(AMRBlock::block_size == block_size);
1098
1099 auto edges = get_edges();
1100
1101 auto dt_interp = edges.dt_interp.value;
1102 auto ndust = this->ndust;
1103
1105 = edges.vel_dust_face_xp;
1107 = edges.vel_dust_face_xm;
1109 = edges.vel_dust_face_yp;
1111 = edges.vel_dust_face_ym;
1113 = edges.vel_dust_face_zp;
1115 = edges.vel_dust_face_zm;
1116
1117 vel_dust_face_xp.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::xp));
1118 vel_dust_face_xm.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::xm));
1119 vel_dust_face_yp.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::yp));
1120 vel_dust_face_ym.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::ym));
1121 vel_dust_face_zp.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::zp));
1122 vel_dust_face_zm.resize_according_to(edges.cell_neigh_graph.get_refs_dir(Direction::zm));
1123
1124 auto spans_block_cell_sizes = edges.spans_block_cell_sizes.get_spans();
1125 auto spans_cell0block_aabb_lower = edges.spans_cell0block_aabb_lower.get_spans();
1126 auto spans_vel_dust = edges.spans_vel_dust.get_spans();
1127 auto spans_dx_vel_dust = edges.spans_dx_vel_dust.get_spans();
1128 auto spans_dy_vel_dust = edges.spans_dy_vel_dust.get_spans();
1129 auto spans_dz_vel_dust = edges.spans_dz_vel_dust.get_spans();
1130 auto spans_dt_vel_dust = edges.spans_dt_vel_dust.get_spans();
1131
1132 using Interp = VelDustInterpolate<Tvec, TgridVec, AMRBlock>;
1133 auto interpolators
1134 = spans_block_cell_sizes.template map<Interp>([&](u64 id, auto &csize) -> Interp {
1135 return {
1136 ndust,
1137 spans_cell0block_aabb_lower.get(id),
1138 spans_block_cell_sizes.get(id),
1139 spans_vel_dust.get(id),
1140 spans_dx_vel_dust.get(id),
1141 spans_dy_vel_dust.get(id),
1142 spans_dz_vel_dust.get(id),
1143 dt_interp,
1144 spans_dt_vel_dust.get(id)};
1145 });
1146
1147 auto graphs_xp = edges.cell_neigh_graph.get_refs_dir(Direction::xp);
1148 auto graphs_xm = edges.cell_neigh_graph.get_refs_dir(Direction::xm);
1149 auto graphs_yp = edges.cell_neigh_graph.get_refs_dir(Direction::yp);
1150 auto graphs_ym = edges.cell_neigh_graph.get_refs_dir(Direction::ym);
1151 auto graphs_zp = edges.cell_neigh_graph.get_refs_dir(Direction::zp);
1152 auto graphs_zm = edges.cell_neigh_graph.get_refs_dir(Direction::zm);
1153
1155 = graphs_xp.template map<u32>([&](u64 id, auto &graph) {
1156 return graph.get().obj_cnt * ndust;
1157 });
1159 = graphs_xm.template map<u32>([&](u64 id, auto &graph) {
1160 return graph.get().obj_cnt * ndust;
1161 });
1163 = graphs_yp.template map<u32>([&](u64 id, auto &graph) {
1164 return graph.get().obj_cnt * ndust;
1165 });
1167 = graphs_ym.template map<u32>([&](u64 id, auto &graph) {
1168 return graph.get().obj_cnt * ndust;
1169 });
1171 = graphs_zp.template map<u32>([&](u64 id, auto &graph) {
1172 return graph.get().obj_cnt * ndust;
1173 });
1175 = graphs_zm.template map<u32>([&](u64 id, auto &graph) {
1176 return graph.get().obj_cnt * ndust;
1177 });
1178
1180 shamsys::instance::get_compute_scheduler_ptr(),
1181 sham::DDMultiRef{graphs_xp, interpolators},
1182 sham::DDMultiRef{vel_dust_face_xp.link_fields},
1183 counts_xp,
1184 [ndust](u32 idvar_a, auto link_iter, auto compute, auto acc_link_field) {
1185 const u32 id_cell_a = idvar_a / ndust;
1186 const u32 nvar_loc = idvar_a % ndust;
1187 link_iter.for_each_object_link_id(id_cell_a, [&](u32 id_cell_b, u32 link_id) {
1188 acc_link_field[link_id * ndust + nvar_loc] = compute.get_link_field_val(
1189 id_cell_a * ndust + nvar_loc, id_cell_b * ndust + nvar_loc);
1190 });
1191 });
1193 shamsys::instance::get_compute_scheduler_ptr(),
1194 sham::DDMultiRef{graphs_xm, interpolators},
1195 sham::DDMultiRef{vel_dust_face_xm.link_fields},
1196 counts_xm,
1197 [ndust](u32 idvar_a, auto link_iter, auto compute, auto acc_link_field) {
1198 const u32 id_cell_a = idvar_a / ndust;
1199 const u32 nvar_loc = idvar_a % ndust;
1200 link_iter.for_each_object_link_id(id_cell_a, [&](u32 id_cell_b, u32 link_id) {
1201 acc_link_field[link_id * ndust + nvar_loc] = compute.get_link_field_val(
1202 id_cell_a * ndust + nvar_loc, id_cell_b * ndust + nvar_loc);
1203 });
1204 });
1206 shamsys::instance::get_compute_scheduler_ptr(),
1207 sham::DDMultiRef{graphs_yp, interpolators},
1208 sham::DDMultiRef{vel_dust_face_yp.link_fields},
1209 counts_yp,
1210 [ndust](u32 idvar_a, auto link_iter, auto compute, auto acc_link_field) {
1211 const u32 id_cell_a = idvar_a / ndust;
1212 const u32 nvar_loc = idvar_a % ndust;
1213 link_iter.for_each_object_link_id(id_cell_a, [&](u32 id_cell_b, u32 link_id) {
1214 acc_link_field[link_id * ndust + nvar_loc] = compute.get_link_field_val(
1215 id_cell_a * ndust + nvar_loc, id_cell_b * ndust + nvar_loc);
1216 });
1217 });
1219 shamsys::instance::get_compute_scheduler_ptr(),
1220 sham::DDMultiRef{graphs_ym, interpolators},
1221 sham::DDMultiRef{vel_dust_face_ym.link_fields},
1222 counts_ym,
1223 [ndust](u32 idvar_a, auto link_iter, auto compute, auto acc_link_field) {
1224 const u32 id_cell_a = idvar_a / ndust;
1225 const u32 nvar_loc = idvar_a % ndust;
1226 link_iter.for_each_object_link_id(id_cell_a, [&](u32 id_cell_b, u32 link_id) {
1227 acc_link_field[link_id * ndust + nvar_loc] = compute.get_link_field_val(
1228 id_cell_a * ndust + nvar_loc, id_cell_b * ndust + nvar_loc);
1229 });
1230 });
1232 shamsys::instance::get_compute_scheduler_ptr(),
1233 sham::DDMultiRef{graphs_zp, interpolators},
1234 sham::DDMultiRef{vel_dust_face_zp.link_fields},
1235 counts_zp,
1236 [ndust](u32 idvar_a, auto link_iter, auto compute, auto acc_link_field) {
1237 const u32 id_cell_a = idvar_a / ndust;
1238 const u32 nvar_loc = idvar_a % ndust;
1239 link_iter.for_each_object_link_id(id_cell_a, [&](u32 id_cell_b, u32 link_id) {
1240 acc_link_field[link_id * ndust + nvar_loc] = compute.get_link_field_val(
1241 id_cell_a * ndust + nvar_loc, id_cell_b * ndust + nvar_loc);
1242 });
1243 });
1245 shamsys::instance::get_compute_scheduler_ptr(),
1246 sham::DDMultiRef{graphs_zm, interpolators},
1247 sham::DDMultiRef{vel_dust_face_zm.link_fields},
1248 counts_zm,
1249 [ndust](u32 idvar_a, auto link_iter, auto compute, auto acc_link_field) {
1250 const u32 id_cell_a = idvar_a / ndust;
1251 const u32 nvar_loc = idvar_a % ndust;
1252 link_iter.for_each_object_link_id(id_cell_a, [&](u32 id_cell_b, u32 link_id) {
1253 acc_link_field[link_id * ndust + nvar_loc] = compute.get_link_field_val(
1254 id_cell_a * ndust + nvar_loc, id_cell_b * ndust + nvar_loc);
1255 });
1256 });
1257}
1258
1259template<class Tvec, class TgridVec>
1264
utility to manipulate AMR blocks
std::uint32_t u32
32 bit unsigned integer
std::uint64_t u64
64 bit unsigned integer
Shamrock assertion utility.
#define SHAM_ASSERT(x)
Shorthand for SHAM_ASSERT_NAMED without a message.
Definition assert.hpp:67
Represents a collection of objects distributed across patches identified by a u64 id.
virtual std::string _impl_get_tex() const
get the tex of the node
virtual std::string _impl_get_tex() const
get the tex of the node
virtual std::string _impl_get_tex() const
get the tex of the node
virtual std::string _impl_get_tex() const
get the tex of the node
virtual std::string _impl_get_tex() const
get the tex of the node
Interface for a solver graph edge representing a field as spans.
virtual DDPatchDataFieldSpanPointer< T > & get_spans()=0
Get the DistributedData of spans attached to the underlying field.
void distributed_data_kernel_call(sham::DeviceScheduler_ptr dev_sched, RefIn in, RefOut in_out, const shambase::DistributedData< index_t > &thread_counts, Functor &&func)
A variant of sham::kernel_call for distributed data.
namespace for the basegodunov model modules
#define __shamrock_stack_entry()
Macro to create a stack entry.
shambase::details::BasicStackEntry StackEntry
Alias for shambase::details::BasicStackEntry.
A variant of sham::MultiRef for distributed data.
T get_center() const noexcept
Returns the center of the AABB.
Definition AABB.hpp:174
AABB get_intersect(AABB other) const noexcept
Compute the intersection of two AABB.
Definition AABB.hpp:234
utility class to handle AMR blocks
Definition AMRBlock.hpp:35