Shamrock 2025.10.0
Astrophysical Code
Loading...
Searching...
No Matches
SourceStep.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
16
23
24template<class Tvec, class TgridVec>
26 StackEntry stack_loc{};
27
28 using namespace shamrock::patch;
29 using namespace shamrock;
30 using namespace shammath;
31 using MergedPDat = shamrock::MergedPatchData;
32
33 using Flagger = FaceFlagger<Tvec, TgridVec>;
34
35 using Block = typename Config::AMRBlock;
36
37 ComputeField<Tscal> &rho_xm = storage.rho_n_xm.get();
38 ComputeField<Tscal> &rho_ym = storage.rho_n_ym.get();
39 ComputeField<Tscal> &rho_zm = storage.rho_n_zm.get();
40
41 ComputeField<Tscal> &pressure_field = storage.pressure.get();
42 ComputeField<Tscal> &p_xm = storage.pres_n_xm.get();
43 ComputeField<Tscal> &p_ym = storage.pres_n_ym.get();
44 ComputeField<Tscal> &p_zm = storage.pres_n_zm.get();
45
46 shamrock::SchedulerUtility utility(scheduler());
47 storage.forces.set(utility.make_compute_field<Tvec>("forces", Block::block_size, [&](u64 id) {
48 return storage.merged_patchdata_ghost.get().get(id).total_elements;
49 }));
50
52 = shambase::get_check_ref(storage.ghost_layout.get());
53 u32 irho_interf = ghost_layout.get_field_idx<Tscal>("rho");
54
55 scheduler().for_each_patchdata_nonempty([&](Patch p, PatchDataLayer &pdat) {
56 MergedPDat &mpdat = storage.merged_patchdata_ghost.get().get(p.id_patch);
57
58 sham::DeviceBuffer<TgridVec> &buf_cell_min = mpdat.pdat.get_field_buf_ref<TgridVec>(0);
59 sham::DeviceBuffer<TgridVec> &buf_cell_max = mpdat.pdat.get_field_buf_ref<TgridVec>(1);
60
61 Tscal coord_conv_fact = solver_config.grid_coord_to_pos_fact / Block::Nside;
62
63 sham::DeviceBuffer<Tscal> &buf_p = pressure_field.get_buf_check(p.id_patch);
64 sham::DeviceBuffer<Tscal> &buf_rho = mpdat.pdat.get_field_buf_ref<Tscal>(irho_interf);
65
66 sham::DeviceBuffer<Tscal> &buf_rho_xm = rho_xm.get_buf_check(p.id_patch);
67 sham::DeviceBuffer<Tscal> &buf_rho_ym = rho_ym.get_buf_check(p.id_patch);
68 sham::DeviceBuffer<Tscal> &buf_rho_zm = rho_zm.get_buf_check(p.id_patch);
69
70 sham::DeviceBuffer<Tscal> &buf_p_xm = p_xm.get_buf_check(p.id_patch);
71 sham::DeviceBuffer<Tscal> &buf_p_ym = p_ym.get_buf_check(p.id_patch);
72 sham::DeviceBuffer<Tscal> &buf_p_zm = p_zm.get_buf_check(p.id_patch);
73
74 sham::DeviceBuffer<Tvec> &forces_buf = storage.forces.get().get_buf_check(p.id_patch);
75
76 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
77
78 sham::EventList depends_list;
79
80 auto cell_min = buf_cell_min.get_read_access(depends_list);
81 auto cell_max = buf_cell_max.get_read_access(depends_list);
82 auto rho = buf_rho.get_read_access(depends_list);
83 auto rho_xm = buf_rho_xm.get_read_access(depends_list);
84 auto rho_ym = buf_rho_ym.get_read_access(depends_list);
85 auto rho_zm = buf_rho_zm.get_read_access(depends_list);
86 auto press = buf_p.get_read_access(depends_list);
87 auto p_xm = buf_p_xm.get_read_access(depends_list);
88 auto p_ym = buf_p_ym.get_read_access(depends_list);
89 auto p_zm = buf_p_zm.get_read_access(depends_list);
90
91 auto grad_p = forces_buf.get_write_access(depends_list);
92
93 auto e = q.submit(depends_list, [&](sycl::handler &cgh) {
94 shambase::parallel_for(
95 cgh, mpdat.total_elements * Block::block_size, "compute grad p", [=](u64 id_a) {
96 u32 block_id = id_a / Block::block_size;
97 Tvec d_cell
98 = (cell_max[block_id] - cell_min[block_id]).template convert<Tscal>()
99 * coord_conv_fact;
100
101 // clang-format off
102 Tscal rho_i_j_k = rho[id_a];
103 Tscal rho_im1_j_k = rho_xm[id_a];
104 Tscal rho_i_jm1_k = rho_ym[id_a];
105 Tscal rho_i_j_km1 = rho_zm[id_a];
106
107 Tscal p_i_j_k = press[id_a];
108 Tscal p_im1_j_k = p_xm[id_a];
109 Tscal p_i_jm1_k = p_ym[id_a];
110 Tscal p_i_j_km1 = p_zm[id_a];
111
112 Tvec dp = {
113 p_i_j_k - p_im1_j_k,
114 p_i_j_k - p_i_jm1_k,
115 p_i_j_k - p_i_j_km1
116 };
117
118 Tvec avg_rho =
119 Tvec{
120 rho_i_j_k + rho_im1_j_k,
121 rho_i_j_k + rho_i_jm1_k,
122 rho_i_j_k + rho_i_j_km1
123 } * Tscal{0.5};
124
125 Tvec grad_p_source_term = dp / (avg_rho * d_cell);
126
127 //sycl::ext::oneapi::experimental::printf("(%f %f %f) (%f %f %f) (%f %f %f)\n"
128 // , dp.x(),dp.y(),dp.z()
129 // , avg_rho.x(),avg_rho.y(),avg_rho.z()
130 // , grad_p_source_term.x(),grad_p_source_term.y(),grad_p_source_term.z()
131 // );
132 //grad_p[id_a] = grad_p_source_term;
133 grad_p[id_a] = -grad_p_source_term;
134 // clang-format on
135 });
136 });
137
138 buf_cell_min.complete_event_state(e);
139 buf_cell_max.complete_event_state(e);
140 buf_rho.complete_event_state(e);
141 buf_rho_xm.complete_event_state(e);
142 buf_rho_ym.complete_event_state(e);
143 buf_rho_zm.complete_event_state(e);
144 buf_p.complete_event_state(e);
145 buf_p_xm.complete_event_state(e);
146 buf_p_ym.complete_event_state(e);
147 buf_p_zm.complete_event_state(e);
148
149 forces_buf.complete_event_state(e);
150 });
151
152 scheduler().for_each_patchdata_nonempty([&](Patch p, PatchDataLayer &pdat) {
153 MergedPDat &mpdat = storage.merged_patchdata_ghost.get().get(p.id_patch);
154
155 sham::DeviceBuffer<TgridVec> &buf_cell_min = mpdat.pdat.get_field_buf_ref<TgridVec>(0);
156 sham::DeviceBuffer<TgridVec> &buf_cell_max = mpdat.pdat.get_field_buf_ref<TgridVec>(1);
157
158 sham::DeviceBuffer<Tvec> &forces_buf = storage.forces.get().get_buf_check(p.id_patch);
159
160 sham::DeviceBuffer<Tscal> &buf_rho = mpdat.pdat.get_field_buf_ref<Tscal>(irho_interf);
161
162 Tscal coord_conv_fact = solver_config.grid_coord_to_pos_fact;
163
164 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
165
166 sham::EventList depends_list;
167 auto cell_min = buf_cell_min.get_read_access(depends_list);
168 auto cell_max = buf_cell_max.get_read_access(depends_list);
169 auto forces = forces_buf.get_write_access(depends_list);
170 auto rho = buf_rho.get_read_access(depends_list);
171
172 auto e = q.submit(depends_list, [&](sycl::handler &cgh) {
173 shambase::parallel_for(cgh, pdat.get_obj_cnt(), "add ext force", [=](u64 id_a) {
174 Tvec block_min = cell_min[id_a].template convert<Tscal>();
175 Tvec block_max = cell_max[id_a].template convert<Tscal>();
176 Tvec delta_cell = (block_max - block_min) / Block::side_size;
177 Tvec delta_cell_h = delta_cell * Tscal(0.5);
178
179 Block::for_each_cell_in_block(delta_cell, [=](u32 lid, Tvec delta) {
180 auto get_ext_force = [](Tvec r) {
181 Tscal d = sycl::length(r);
182 return r / (d * d * d + 1e-5);
183 };
184
185 // forces[id_a * Block::block_size + lid] +=
186 // get_ext_force(block_min + delta + delta_cell_h);
187 });
188 });
189 });
190
191 buf_cell_min.complete_event_state(e);
192 buf_cell_max.complete_event_state(e);
193 forces_buf.complete_event_state(e);
194 buf_rho.complete_event_state(e);
195
196 if (storage.forces.get().get_field(p.id_patch).has_nan()) {
197 logger::err_ln("[Zeus]", "nan detected in forces");
199 }
200 // logger::raw_ln(storage.forces.get().get_field(p.id_patch).compute_max());
201 });
202}
203
204template<class Tvec, class TgridVec>
206 StackEntry stack_loc{};
207
208 using namespace shamrock::patch;
209 using namespace shamrock;
210 using namespace shammath;
211 using MergedPDat = shamrock::MergedPatchData;
212
213 using Flagger = FaceFlagger<Tvec, TgridVec>;
214
215 using Block = typename Config::AMRBlock;
216
218 = shambase::get_check_ref(storage.ghost_layout.get());
219 u32 ivel_interf = ghost_layout.get_field_idx<Tvec>("vel");
220
221 scheduler().for_each_patchdata_nonempty([&](Patch p, PatchDataLayer &pdat) {
222 MergedPDat &mpdat = storage.merged_patchdata_ghost.get().get(p.id_patch);
223
224 sham::DeviceBuffer<Tvec> &forces_buf = storage.forces.get().get_buf_check(p.id_patch);
225 sham::DeviceBuffer<Tvec> &vel_buf = mpdat.pdat.get_field_buf_ref<Tvec>(ivel_interf);
226
227 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
228
230 q,
231 sham::MultiRef{forces_buf},
232 sham::MultiRef{vel_buf},
233 mpdat.total_elements * Block::block_size,
234 [dt](u32 id_a, const Tvec *__restrict forces, Tvec *__restrict vel) {
235 vel[id_a] += dt * forces[id_a];
236 });
237
238 // logger::raw_ln(storage.forces.get().get_field(p.id_patch).compute_max());
239 });
240
241 storage.forces.reset();
242}
243
244template<class Tvec, class TgridVec>
246 StackEntry stack_loc{};
247
248 using namespace shamrock::patch;
249 using namespace shamrock;
250 using namespace shammath;
251 using MergedPDat = shamrock::MergedPatchData;
252
253 using Block = typename Config::AMRBlock;
254
255 ComputeField<Tvec> &vel_n = storage.vel_n.get();
256 ComputeField<Tvec> &vel_n_xp = storage.vel_n_xp.get();
257 ComputeField<Tvec> &vel_n_yp = storage.vel_n_yp.get();
258 ComputeField<Tvec> &vel_n_zp = storage.vel_n_zp.get();
259
260 shamrock::SchedulerUtility utility(scheduler());
261 storage.q_AV.set(utility.make_compute_field<Tvec>("q_AV", Block::block_size, [&](u64 id) {
262 return storage.merged_patchdata_ghost.get().get(id).total_elements;
263 }));
264
266 = shambase::get_check_ref(storage.ghost_layout.get());
267 u32 irho_interf = ghost_layout.get_field_idx<Tscal>("rho");
268 u32 ivel_interf = ghost_layout.get_field_idx<Tvec>("vel");
269
270 scheduler().for_each_patchdata_nonempty([&](Patch p, PatchDataLayer &pdat) {
271 MergedPDat &mpdat = storage.merged_patchdata_ghost.get().get(p.id_patch);
272
273 sham::DeviceBuffer<TgridVec> &buf_cell_min = mpdat.pdat.get_field_buf_ref<TgridVec>(0);
274 sham::DeviceBuffer<TgridVec> &buf_cell_max = mpdat.pdat.get_field_buf_ref<TgridVec>(1);
275
276 Tscal coord_conv_fact = solver_config.grid_coord_to_pos_fact / Block::Nside;
277
278 sham::DeviceBuffer<Tscal> &buf_rho = mpdat.pdat.get_field_buf_ref<Tscal>(irho_interf);
279
280 sham::DeviceBuffer<Tvec> &buf_vel = vel_n.get_buf_check(p.id_patch);
281 sham::DeviceBuffer<Tvec> &buf_vel_xp = vel_n_xp.get_buf_check(p.id_patch);
282 sham::DeviceBuffer<Tvec> &buf_vel_yp = vel_n_yp.get_buf_check(p.id_patch);
283 sham::DeviceBuffer<Tvec> &buf_vel_zp = vel_n_zp.get_buf_check(p.id_patch);
284
285 sham::DeviceBuffer<Tvec> &q_AV_buf = storage.q_AV.get().get_buf_check(p.id_patch);
286
287 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
288
289 sham::EventList depends_list;
290
291 auto cell_min = buf_cell_min.get_read_access(depends_list);
292 auto cell_max = buf_cell_max.get_read_access(depends_list);
293 auto rho = buf_rho.get_read_access(depends_list);
294 auto vel = buf_vel.get_read_access(depends_list);
295 auto vel_xp = buf_vel_xp.get_read_access(depends_list);
296 auto vel_yp = buf_vel_yp.get_read_access(depends_list);
297 auto vel_zp = buf_vel_zp.get_read_access(depends_list);
298 auto q_AV = q_AV_buf.get_write_access(depends_list);
299
300 auto e = q.submit(depends_list, [&](sycl::handler &cgh) {
301 shambase::parallel_for(
302 cgh, mpdat.total_elements * Block::block_size, "compute AV", [=](u64 id_a) {
303 u32 block_id = id_a / Block::block_size;
304 Tvec d_cell
305 = (cell_max[block_id] - cell_min[block_id]).template convert<Tscal>()
306 * coord_conv_fact;
307
308 // clang-format off
309 Tscal rho_i_j_k = rho[id_a];
310
311 Tvec vel_i_j_k = vel[id_a];
312 Tvec vel_ip1_j_k = vel_xp[id_a];
313 Tvec vel_i_jp1_k = vel_yp[id_a];
314 Tvec vel_i_j_kp1 = vel_zp[id_a];
315
316 Tvec dv = {
317 vel_ip1_j_k.x() - vel_i_j_k.x(),
318 vel_i_jp1_k.y() - vel_i_j_k.y(),
319 vel_i_j_kp1.z() - vel_i_j_k.z()
320 };
321
322 dv = sham::negative_part(dv);
323
324 constexpr Tscal C2 = 3;
325
326 q_AV[id_a] = C2*rho_i_j_k*(dv*dv);
327 // clang-format on
328 });
329 });
330
331 buf_cell_min.complete_event_state(e);
332 buf_cell_max.complete_event_state(e);
333 buf_rho.complete_event_state(e);
334 buf_vel.complete_event_state(e);
335 buf_vel_xp.complete_event_state(e);
336 buf_vel_yp.complete_event_state(e);
337 buf_vel_zp.complete_event_state(e);
338 q_AV_buf.complete_event_state(e);
339 });
340}
341
342template<class Tvec, class TgridVec>
343void shammodels::zeus::modules::SourceStep<Tvec, TgridVec>::apply_AV(Tscal dt) {
344 StackEntry stack_loc{};
345
346 using namespace shamrock::patch;
347 using namespace shamrock;
348 using namespace shammath;
349 using MergedPDat = shamrock::MergedPatchData;
350
351 using Block = typename Config::AMRBlock;
352
353 ComputeField<Tvec> &q_AV_n = storage.q_AV.get();
354 ComputeField<Tvec> &q_AV_n_xm = storage.q_AV_n_xm.get();
355 ComputeField<Tvec> &q_AV_n_ym = storage.q_AV_n_ym.get();
356 ComputeField<Tvec> &q_AV_n_zm = storage.q_AV_n_zm.get();
357
358 ComputeField<Tscal> &rho_xm = storage.rho_n_xm.get();
359 ComputeField<Tscal> &rho_ym = storage.rho_n_ym.get();
360 ComputeField<Tscal> &rho_zm = storage.rho_n_zm.get();
361
362 ComputeField<Tvec> &vel_n = storage.vel_n.get();
363 ComputeField<Tvec> &vel_n_xp = storage.vel_n_xp.get();
364 ComputeField<Tvec> &vel_n_yp = storage.vel_n_yp.get();
365 ComputeField<Tvec> &vel_n_zp = storage.vel_n_zp.get();
366
368 = shambase::get_check_ref(storage.ghost_layout.get());
369 u32 irho_interf = ghost_layout.get_field_idx<Tscal>("rho");
370 u32 ieint_interf = ghost_layout.get_field_idx<Tscal>("eint");
371 u32 ivel_interf = ghost_layout.get_field_idx<Tvec>("vel");
372
373 scheduler().for_each_patchdata_nonempty([&](Patch p, PatchDataLayer &pdat) {
374 MergedPDat &mpdat = storage.merged_patchdata_ghost.get().get(p.id_patch);
375
376 sham::DeviceBuffer<TgridVec> &buf_cell_min = mpdat.pdat.get_field_buf_ref<TgridVec>(0);
377 sham::DeviceBuffer<TgridVec> &buf_cell_max = mpdat.pdat.get_field_buf_ref<TgridVec>(1);
378
379 Tscal coord_conv_fact = solver_config.grid_coord_to_pos_fact / Block::Nside;
380
381 sham::DeviceBuffer<Tscal> &buf_rho = mpdat.pdat.get_field_buf_ref<Tscal>(irho_interf);
382 sham::DeviceBuffer<Tvec> &buf_vel = mpdat.pdat.get_field_buf_ref<Tvec>(ivel_interf);
383
384 sham::DeviceBuffer<Tvec> &buf_vel_xp = vel_n_xp.get_buf_check(p.id_patch);
385 sham::DeviceBuffer<Tvec> &buf_vel_yp = vel_n_yp.get_buf_check(p.id_patch);
386 sham::DeviceBuffer<Tvec> &buf_vel_zp = vel_n_zp.get_buf_check(p.id_patch);
387
388 sham::DeviceBuffer<Tscal> &buf_rho_xm = rho_xm.get_buf_check(p.id_patch);
389 sham::DeviceBuffer<Tscal> &buf_rho_ym = rho_ym.get_buf_check(p.id_patch);
390 sham::DeviceBuffer<Tscal> &buf_rho_zm = rho_zm.get_buf_check(p.id_patch);
391
392 sham::DeviceBuffer<Tvec> &q_AV_buf = storage.q_AV.get().get_buf_check(p.id_patch);
393 sham::DeviceBuffer<Tvec> &buf_q_AV_n_xm = q_AV_n_xm.get_buf_check(p.id_patch);
394 sham::DeviceBuffer<Tvec> &buf_q_AV_n_ym = q_AV_n_ym.get_buf_check(p.id_patch);
395 sham::DeviceBuffer<Tvec> &buf_q_AV_n_zm = q_AV_n_zm.get_buf_check(p.id_patch);
396
397 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
398
399 sham::EventList depends_list;
400
401 auto cell_min = buf_cell_min.get_read_access(depends_list);
402 auto cell_max = buf_cell_max.get_read_access(depends_list);
403 auto rho = buf_rho.get_read_access(depends_list);
404 auto rho_xm = buf_rho_xm.get_read_access(depends_list);
405 auto rho_ym = buf_rho_ym.get_read_access(depends_list);
406 auto rho_zm = buf_rho_zm.get_read_access(depends_list);
407 auto q_AV = q_AV_buf.get_read_access(depends_list);
408 auto q_AV_xm = buf_q_AV_n_xm.get_read_access(depends_list);
409 auto q_AV_ym = buf_q_AV_n_ym.get_read_access(depends_list);
410 auto q_AV_zm = buf_q_AV_n_zm.get_read_access(depends_list);
411 auto vel = buf_vel.get_write_access(depends_list);
412
413 auto e = q.submit(depends_list, [&](sycl::handler &cgh) {
414 shambase::parallel_for(
415 cgh, mpdat.total_elements * Block::block_size, "add vel AV", [=](u64 id_a) {
416 u32 block_id = id_a / Block::block_size;
417 Tvec d_cell
418 = (cell_max[block_id] - cell_min[block_id]).template convert<Tscal>()
419 * coord_conv_fact;
420
421 // clang-format off
422 Tscal rho_i_j_k = rho[id_a];
423 Tscal rho_im1_j_k = rho_xm[id_a];
424 Tscal rho_i_jm1_k = rho_ym[id_a];
425 Tscal rho_i_j_km1 = rho_zm[id_a];
426
427 Tvec q_i_j_k = q_AV[id_a];
428 Tvec q_im1_j_k = q_AV_xm[id_a];
429 Tvec q_i_jm1_k = q_AV_ym[id_a];
430 Tvec q_i_j_km1 = q_AV_zm[id_a];
431
432 Tvec avg_rho =
433 Tvec{
434 rho_i_j_k + rho_im1_j_k,
435 rho_i_j_k + rho_i_jm1_k,
436 rho_i_j_k + rho_i_j_km1
437 } * Tscal{0.5};
438
439 Tvec dq = {
440 q_i_j_k.x()-q_im1_j_k.x(),
441 q_i_j_k.y()-q_i_jm1_k.y(),
442 q_i_j_k.z()-q_i_j_km1.z()
443 };
444
445 vel[id_a] += - dt*(dq)/ (avg_rho * d_cell);
446 // clang-format on
447 });
448 });
449
450 buf_cell_min.complete_event_state(e);
451 buf_cell_max.complete_event_state(e);
452 buf_rho.complete_event_state(e);
453 buf_rho_xm.complete_event_state(e);
454 buf_rho_ym.complete_event_state(e);
455 buf_rho_zm.complete_event_state(e);
456 q_AV_buf.complete_event_state(e);
457 buf_q_AV_n_xm.complete_event_state(e);
458 buf_q_AV_n_ym.complete_event_state(e);
459 buf_q_AV_n_zm.complete_event_state(e);
460 buf_vel.complete_event_state(e);
461 });
462
463 scheduler().for_each_patchdata_nonempty([&](Patch p, PatchDataLayer &pdat) {
464 MergedPDat &mpdat = storage.merged_patchdata_ghost.get().get(p.id_patch);
465
466 sham::DeviceBuffer<TgridVec> &buf_cell_min = mpdat.pdat.get_field_buf_ref<TgridVec>(0);
467 sham::DeviceBuffer<TgridVec> &buf_cell_max = mpdat.pdat.get_field_buf_ref<TgridVec>(1);
468
469 Tscal coord_conv_fact = solver_config.grid_coord_to_pos_fact / Block::Nside;
470
471 sham::DeviceBuffer<Tscal> &buf_eint = mpdat.pdat.get_field_buf_ref<Tscal>(ieint_interf);
472
473 sham::DeviceBuffer<Tvec> &buf_vel = vel_n.get_buf_check(p.id_patch);
474 sham::DeviceBuffer<Tvec> &buf_vel_xp = vel_n_xp.get_buf_check(p.id_patch);
475 sham::DeviceBuffer<Tvec> &buf_vel_yp = vel_n_yp.get_buf_check(p.id_patch);
476 sham::DeviceBuffer<Tvec> &buf_vel_zp = vel_n_zp.get_buf_check(p.id_patch);
477
478 sham::DeviceBuffer<Tvec> &q_AV_buf = storage.q_AV.get().get_buf_check(p.id_patch);
479 sham::DeviceBuffer<Tvec> &buf_q_AV_n_xm = q_AV_n_xm.get_buf_check(p.id_patch);
480 sham::DeviceBuffer<Tvec> &buf_q_AV_n_ym = q_AV_n_ym.get_buf_check(p.id_patch);
481 sham::DeviceBuffer<Tvec> &buf_q_AV_n_zm = q_AV_n_zm.get_buf_check(p.id_patch);
482
483 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
484
485 sham::EventList depends_list;
486 auto cell_min = buf_cell_min.get_read_access(depends_list);
487 auto cell_max = buf_cell_max.get_read_access(depends_list);
488 auto vel = buf_vel.get_read_access(depends_list);
489 auto vel_xp = buf_vel_xp.get_read_access(depends_list);
490 auto vel_yp = buf_vel_yp.get_read_access(depends_list);
491 auto vel_zp = buf_vel_zp.get_read_access(depends_list);
492 auto q_AV = q_AV_buf.get_read_access(depends_list);
493 auto q_AV_xm = buf_q_AV_n_xm.get_read_access(depends_list);
494 auto q_AV_ym = buf_q_AV_n_ym.get_read_access(depends_list);
495 auto q_AV_zm = buf_q_AV_n_zm.get_read_access(depends_list);
496 auto eint = buf_eint.get_write_access(depends_list);
497
498 auto e = q.submit(depends_list, [&](sycl::handler &cgh) {
499 shambase::parallel_for(
500 cgh, pdat.get_obj_cnt() * Block::block_size, "add eint AV", [=](u64 id_a) {
501 u32 block_id = id_a / Block::block_size;
502 Tvec d_cell
503 = (cell_max[block_id] - cell_min[block_id]).template convert<Tscal>()
504 * coord_conv_fact;
505
506 // clang-format off
507 Tvec vel_i_j_k = vel[id_a];
508 Tvec vel_ip1_j_k = vel_xp[id_a];
509 Tvec vel_i_jp1_k = vel_yp[id_a];
510 Tvec vel_i_j_kp1 = vel_zp[id_a];
511
512 Tvec q_i_j_k = q_AV[id_a];
513
514 Tvec dv = {
515 vel_ip1_j_k.x() - vel_i_j_k.x(),
516 vel_i_jp1_k.y() - vel_i_j_k.y(),
517 vel_i_j_kp1.z() - vel_i_j_k.z()
518 };
519
520 eint[id_a] += -dt*sycl::dot(q_i_j_k,dv/ d_cell);
521 // clang-format on
522 });
523 });
524
525 buf_cell_min.complete_event_state(e);
526 buf_cell_max.complete_event_state(e);
527 buf_vel.complete_event_state(e);
528 buf_vel_xp.complete_event_state(e);
529 buf_vel_yp.complete_event_state(e);
530 buf_vel_zp.complete_event_state(e);
531 q_AV_buf.complete_event_state(e);
532 buf_q_AV_n_xm.complete_event_state(e);
533 buf_q_AV_n_ym.complete_event_state(e);
534 buf_q_AV_n_zm.complete_event_state(e);
535 buf_eint.complete_event_state(e);
536 });
537}
538
539template<class Tvec, class TgridVec>
540void shammodels::zeus::modules::SourceStep<Tvec, TgridVec>::compute_div_v() {
541 StackEntry stack_loc{};
542 using namespace shamrock::patch;
543 using namespace shamrock;
544 using namespace shammath;
545 using MergedPDat = shamrock::MergedPatchData;
546
547 using Flagger = FaceFlagger<Tvec, TgridVec>;
548
549 using Block = typename Config::AMRBlock;
550
551 shamrock::SchedulerUtility utility(scheduler());
552 storage.div_v_n.set(
553 utility.make_compute_field<Tscal>("div_v_n", Block::block_size, [&](u64 id) {
554 return storage.merged_patchdata_ghost.get().get(id).total_elements;
555 }));
556
557 ComputeField<Tvec> &vel_n = storage.vel_n.get();
558 ComputeField<Tvec> &vel_n_xp = storage.vel_n_xp.get();
559 ComputeField<Tvec> &vel_n_yp = storage.vel_n_yp.get();
560 ComputeField<Tvec> &vel_n_zp = storage.vel_n_zp.get();
561
562 ComputeField<Tscal> &div_v = storage.div_v_n.get();
563
564 scheduler().for_each_patchdata_nonempty([&](Patch p, PatchDataLayer &pdat) {
565 MergedPDat &mpdat = storage.merged_patchdata_ghost.get().get(p.id_patch);
566
567 sham::DeviceBuffer<TgridVec> &buf_cell_min = mpdat.pdat.get_field_buf_ref<TgridVec>(0);
568 sham::DeviceBuffer<TgridVec> &buf_cell_max = mpdat.pdat.get_field_buf_ref<TgridVec>(1);
569
570 Tscal coord_conv_fact = solver_config.grid_coord_to_pos_fact / Block::Nside;
571
572 sham::DeviceBuffer<Tvec> &buf_vel = vel_n.get_buf_check(p.id_patch);
573 sham::DeviceBuffer<Tvec> &buf_vel_xp = vel_n_xp.get_buf_check(p.id_patch);
574 sham::DeviceBuffer<Tvec> &buf_vel_yp = vel_n_yp.get_buf_check(p.id_patch);
575 sham::DeviceBuffer<Tvec> &buf_vel_zp = vel_n_zp.get_buf_check(p.id_patch);
576
577 sham::DeviceBuffer<Tscal> &buf_div_v = div_v.get_buf_check(p.id_patch);
578
579 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
580
581 sham::EventList depends_list;
582 auto cell_min = buf_cell_min.get_read_access(depends_list);
583 auto cell_max = buf_cell_max.get_read_access(depends_list);
584
585 auto vel = buf_vel.get_read_access(depends_list);
586 auto vel_xp = buf_vel_xp.get_read_access(depends_list);
587 auto vel_yp = buf_vel_yp.get_read_access(depends_list);
588 auto vel_zp = buf_vel_zp.get_read_access(depends_list);
589
590 auto divv = buf_div_v.get_write_access(depends_list);
591
592 auto e = q.submit(depends_list, [&](sycl::handler &cgh) {
593 shambase::parallel_for(
594 cgh, pdat.get_obj_cnt() * Block::block_size, "compute divv", [=](u64 id_a) {
595 u32 block_id = id_a / Block::block_size;
596 Tvec d_cell
597 = (cell_max[block_id] - cell_min[block_id]).template convert<Tscal>()
598 * coord_conv_fact;
599
600 // clang-format off
601 Tvec vel_i_j_k = vel[id_a];
602 Tvec vel_ip1_j_k = vel_xp[id_a];
603 Tvec vel_i_jp1_k = vel_yp[id_a];
604 Tvec vel_i_j_kp1 = vel_zp[id_a];
605
606 Tvec dv = {
607 vel_ip1_j_k.x() - vel_i_j_k.x(),
608 vel_i_jp1_k.y() - vel_i_j_k.y(),
609 vel_i_j_kp1.z() - vel_i_j_k.z()
610 };
611
612 divv[id_a] += sycl::dot(dv,Tvec{1,1,1}/ d_cell);
613 // clang-format on
614 });
615 });
616
617 buf_cell_min.complete_event_state(e);
618 buf_cell_max.complete_event_state(e);
619 buf_vel.complete_event_state(e);
620 buf_vel_xp.complete_event_state(e);
621 buf_vel_yp.complete_event_state(e);
622 buf_vel_zp.complete_event_state(e);
623 buf_div_v.complete_event_state(e);
624 });
625}
626
627template<class Tvec, class TgridVec>
628void shammodels::zeus::modules::SourceStep<Tvec, TgridVec>::update_eint_eos(Tscal dt) {
629 StackEntry stack_loc{};
630
631 using namespace shamrock::patch;
632 using namespace shamrock;
633 using namespace shammath;
634 using MergedPDat = shamrock::MergedPatchData;
635
636 using Block = typename Config::AMRBlock;
637
638 ComputeField<Tscal> &div_v = storage.div_v_n.get();
639
641 = shambase::get_check_ref(storage.ghost_layout.get());
642 u32 irho_interf = ghost_layout.get_field_idx<Tscal>("rho");
643 u32 ieint_interf = ghost_layout.get_field_idx<Tscal>("eint");
644 u32 ivel_interf = ghost_layout.get_field_idx<Tvec>("vel");
645
646 scheduler().for_each_patchdata_nonempty([&](Patch p, PatchDataLayer &pdat) {
647 MergedPDat &mpdat = storage.merged_patchdata_ghost.get().get(p.id_patch);
648
649 sham::DeviceBuffer<TgridVec> &buf_cell_min = mpdat.pdat.get_field_buf_ref<TgridVec>(0);
650 sham::DeviceBuffer<TgridVec> &buf_cell_max = mpdat.pdat.get_field_buf_ref<TgridVec>(1);
651
652 Tscal coord_conv_fact = solver_config.grid_coord_to_pos_fact / Block::Nside;
653
654 sham::DeviceBuffer<Tscal> &buf_eint = mpdat.pdat.get_field_buf_ref<Tscal>(ieint_interf);
655
656 sham::DeviceBuffer<Tscal> &buf_divv = div_v.get_buf_check(p.id_patch);
657
658 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
659
660 sham::EventList depends_list;
661 auto cell_min = buf_cell_min.get_read_access(depends_list);
662 auto cell_max = buf_cell_max.get_read_access(depends_list);
663
664 auto divv = buf_divv.get_read_access(depends_list);
665 auto eint = buf_eint.get_write_access(depends_list);
666
667 auto e = q.submit(depends_list, [&](sycl::handler &cgh) {
668 Tscal fact = (dt / 2.) * (solver_config.eos_gamma - 1);
669
670 shambase::parallel_for(
671 cgh, pdat.get_obj_cnt() * Block::block_size, "evolve eint", [=](u64 id_a) {
672 u32 block_id = id_a / Block::block_size;
673 Tvec d_cell
674 = (cell_max[block_id] - cell_min[block_id]).template convert<Tscal>()
675 * coord_conv_fact;
676
677 Tscal factdivv = divv[id_a] * fact;
678
679 eint[id_a] *= (1 - factdivv) / (1 + factdivv);
680 });
681 });
682
683 buf_cell_min.complete_event_state(e);
684 buf_cell_max.complete_event_state(e);
685 buf_divv.complete_event_state(e);
686 buf_eint.complete_event_state(e);
687 });
688}
689
std::uint32_t u32
32 bit unsigned integer
std::uint64_t u64
64 bit unsigned integer
A buffer allocated in USM (Unified Shared Memory).
void complete_event_state(sycl::event e) const
Complete the event state of the buffer.
T * get_write_access(sham::EventList &depends_list, SourceLocation src_loc=SourceLocation{})
Get a read-write pointer to the buffer's data.
const T * get_read_access(sham::EventList &depends_list, SourceLocation src_loc=SourceLocation{}) const
Get a read-only pointer to the buffer's data.
A SYCL queue associated with a device and a context.
sycl::event submit(Fct &&fct)
Submits a kernel to the SYCL queue.
Class to manage a list of SYCL events.
Definition EventList.hpp:32
flag faces with a lookup index for the orientation
void compute_forces()
compute general forces (pressure + external and store them into SolverStorage::forces)
void apply_force(Tscal dt)
apply the generalized forces
void compute_AV()
Compute the values of the artificial viscosity terms (zeus2d_main equations 33,34).
ComputeField< T > make_compute_field(std::string new_name, u32 nvar)
create a compute field and init it to zeros
u32 get_field_idx(const std::string &field_name) const
Get the field id if matching name & type.
PatchDataLayer container class, the layout is described in patchdata_layout.
u32 get_obj_cnt() const
get the number of objects (particles) stored in this layer
void kernel_call(sham::DeviceQueue &q, RefIn in, RefOut in_out, u32 n, Functor &&func, SourceLocation &&callsite=SourceLocation{})
Submit a kernel to a SYCL queue.
T & get_check_ref(const std::unique_ptr< T > &ptr, SourceLocation loc=SourceLocation())
Takes a std::unique_ptr and returns a reference to the object it holds. It throws a std::runtime_erro...
Definition memory.hpp:112
ExcptTypes make_except_with_loc(std::string message, SourceLocation loc=SourceLocation{})
Create an exception with a message and a location.
namespace for math utility
Definition AABB.hpp:26
SPHKernelGen< flt_type, details::KernelDefC2< flt_type > > C2
The C2 SPH kernel.
namespace for the main framework
Definition __init__.py:1
void err_ln(std::string module_name, Types... var2)
Prints a log message with multiple arguments followed by a newline.
Definition logs.hpp:132
shambase::details::BasicStackEntry StackEntry
Alias for shambase::details::BasicStackEntry.
A class that references multiple buffers or similar objects.
Definition MultiRef.hpp:33
Patch object that contain generic patch information.
Definition Patch.hpp:33
u64 id_patch
unique key that identify the patch
Definition Patch.hpp:86