Shamrock 2025.10.0
Astrophysical Code
Loading...
Searching...
No Matches
UpdateDerivs.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
19#include "shambase/memory.hpp"
22#include "shambackends/math.hpp"
23#include "shamcomm/logs.hpp"
43#include "shamphys/mhd.hpp"
50#include <memory>
51#include <vector>
52
53template<class Tvec, template<class> class SPHKernel>
54void shammodels::sph::modules::UpdateDerivs<Tvec, SPHKernel>::update_derivs(Tscal dt_hydro) {
55
56 Cfg_AV cfg_av = solver_config.artif_viscosity;
57 Cfg_MHD cfg_mhd = solver_config.mhd_config;
58 DustConfig cfg_dust = solver_config.dust_config;
59
60 // dt += hydro _dt
61 if (Constant *v = std::get_if<Constant>(&cfg_av.config)) {
62 update_derivs_constantAV(*v);
63 } else if (VaryingMM97 *v = std::get_if<VaryingMM97>(&cfg_av.config)) {
64 update_derivs_mm97(*v);
65 } else if (VaryingCD10 *v = std::get_if<VaryingCD10>(&cfg_av.config)) {
66 update_derivs_cd10(*v);
67 } else if (ConstantDisc *v = std::get_if<ConstantDisc>(&cfg_av.config)) {
68 update_derivs_disc_visco(*v);
69 } else if (None *v = std::get_if<None>(&cfg_av.config)) {
71 } else {
73 }
74
75 // dt += MHD _dt
76 if (IdealMHD *v = std::get_if<IdealMHD>(&cfg_mhd.configMHD)) {
77 update_derivs_mhd(*v);
78 } else if (NonIdealMHD *v = std::get_if<NonIdealMHD>(&cfg_mhd.configMHD)) {
79 update_derivs_nimhd(*v);
80 } else if (NoneMHD *v = std::get_if<NoneMHD>(&cfg_mhd.configMHD)) {
81 // do nothing as god intended
82 } else {
84 }
85
86 // dt += dust _dt
87 if (cfg_dust.has_s_j_field()) {
88 // we can do it separately because the backreaction is done only through the pressure
89 update_derivs_dust_monofluid_tva_Sj(cfg_dust, dt_hydro);
90 }
91}
92
93template<class Tvec, template<class> class SPHKernel>
94void shammodels::sph::modules::UpdateDerivs<Tvec, SPHKernel>::update_derivs_noAV(None cfg) {}
95
96template<class Tvec, template<class> class SPHKernel>
97void shammodels::sph::modules::UpdateDerivs<Tvec, SPHKernel>::update_derivs_constantAV(
98 Constant cfg) {
99 StackEntry stack_loc{};
100
101 using namespace shamrock;
102 using namespace shamrock::patch;
103
104 PatchDataLayerLayout &pdl = scheduler().pdl_old();
105
106 const u32 ixyz = pdl.get_field_idx<Tvec>("xyz");
107 const u32 ivxyz = pdl.get_field_idx<Tvec>("vxyz");
108 const u32 iaxyz = pdl.get_field_idx<Tvec>("axyz");
109 const u32 iuint = pdl.get_field_idx<Tscal>("uint");
110 const u32 iduint = pdl.get_field_idx<Tscal>("duint");
111 const u32 ihpart = pdl.get_field_idx<Tscal>("hpart");
112
114 = shambase::get_check_ref(storage.ghost_layout.get());
115 u32 ihpart_interf = ghost_layout.get_field_idx<Tscal>("hpart");
116 u32 iuint_interf = ghost_layout.get_field_idx<Tscal>("uint");
117 u32 ivxyz_interf = ghost_layout.get_field_idx<Tvec>("vxyz");
118 u32 iomega_interf = ghost_layout.get_field_idx<Tscal>("omega");
119
120 // with MHD the signal velocity uses the fast magnetosonic speed instead of cs
121 bool use_mhd = solver_config.has_field_b_on_rho();
122
123 auto &merged_xyzh = storage.merged_xyzh.get();
125 shambase::DistributedData<PatchDataLayer> &mpdats = storage.merged_patchdata_ghost.get();
126
127 scheduler().for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
128 PatchDataLayer &mpdat = mpdats.get(cur_p.id_patch);
129
131 = merged_xyzh.get(cur_p.id_patch).template get_field_buf_ref<Tvec>(0);
132 sham::DeviceBuffer<Tvec> &buf_axyz = pdat.get_field_buf_ref<Tvec>(iaxyz);
133 sham::DeviceBuffer<Tscal> &buf_duint = pdat.get_field_buf_ref<Tscal>(iduint);
134 sham::DeviceBuffer<Tvec> &buf_vxyz = mpdat.get_field_buf_ref<Tvec>(ivxyz_interf);
135 sham::DeviceBuffer<Tscal> &buf_hpart = mpdat.get_field_buf_ref<Tscal>(ihpart_interf);
136 sham::DeviceBuffer<Tscal> &buf_omega = mpdat.get_field_buf_ref<Tscal>(iomega_interf);
137 sham::DeviceBuffer<Tscal> &buf_uint = mpdat.get_field_buf_ref<Tscal>(iuint_interf);
138 sham::DeviceBuffer<Tscal> &buf_pressure
139 = shambase::get_check_ref(storage.pressure).get_field(cur_p.id_patch).get_buf();
141 = shambase::get_check_ref(storage.soundspeed).get_field(cur_p.id_patch).get_buf();
142
143 sycl::range range_npart{pdat.get_obj_cnt()};
144
145 tree::ObjectCache &pcache
146 = shambase::get_check_ref(storage.neigh_cache).get_cache(cur_p.id_patch);
147
149
150 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
151 sham::EventList depends_list;
152
153 auto xyz = buf_xyz.get_read_access(depends_list);
154 auto axyz = buf_axyz.get_write_access(depends_list);
155 auto du = buf_duint.get_write_access(depends_list);
156 auto vxyz = buf_vxyz.get_read_access(depends_list);
157 auto hpart = buf_hpart.get_read_access(depends_list);
158 auto omega = buf_omega.get_read_access(depends_list);
159 auto u = buf_uint.get_read_access(depends_list); // TODO rename to uint
160 auto pressure = buf_pressure.get_read_access(depends_list);
161 auto cs = buf_cs.get_read_access(depends_list);
162 auto ploop_ptrs = pcache.get_read_access(depends_list);
163
164 sycl::event e;
165 if (!use_mhd) {
166 e = q.submit(depends_list, [&](sycl::handler &cgh) {
167 const Tscal pmass = solver_config.gpart_mass;
168 const Tscal alpha_u = cfg.alpha_u;
169 const Tscal alpha_AV = cfg.alpha_AV;
170 const Tscal beta_AV = cfg.beta_AV;
171
172 shamlog_debug_sycl_ln("deriv kernel", "alpha_u :", alpha_u);
173 shamlog_debug_sycl_ln("deriv kernel", "alpha_AV :", alpha_AV);
174 shamlog_debug_sycl_ln("deriv kernel", "beta_AV :", beta_AV);
175
176 // tree::ObjectIterator particle_looper(tree,cgh);
177
178 // tree::LeafCacheObjectIterator
179 // particle_looper(tree,*xyz_cell_id,leaf_cache,cgh);
180
181 tree::ObjectCacheIterator particle_looper(ploop_ptrs);
182
183 // sycl::accessor hmax_tree{tree_field_hmax, cgh, sycl::read_only};
184
185 // sycl::stream out {4096,1024,cgh};
186
187 constexpr Tscal Rker2 = Kernel::Rkern * Kernel::Rkern;
188
189 shambase::parallel_for(
190 cgh, pdat.get_obj_cnt(), "compute force cte AV", [=](u64 gid) {
191 u32 id_a = (u32) gid;
192
193 using namespace shamrock::sph;
194
195 Tvec sum_axyz = {0, 0, 0};
196 Tscal sum_du_a = 0;
197
198 Tscal h_a = hpart[id_a];
199 Tvec xyz_a = xyz[id_a];
200 Tvec vxyz_a = vxyz[id_a];
201 Tscal P_a = pressure[id_a];
202 Tscal omega_a = omega[id_a];
203 const Tscal u_a = u[id_a];
204
205 Tscal rho_a = rho_h(pmass, h_a, Kernel::hfactd);
206 Tscal rho_a_sq = rho_a * rho_a;
207 Tscal rho_a_inv = 1. / rho_a;
208
209 // f32 P_a = cs * cs * rho_a;
210
211 Tscal omega_a_rho_a_inv = 1 / (omega_a * rho_a);
212
213 Tscal cs_a = cs[id_a];
214
215 Tvec force_pressure{0, 0, 0};
216 Tscal tmpdU_pressure = 0;
217
218 particle_looper.for_each_object(id_a, [&](u32 id_b) {
219 // compute only omega_a
220 Tvec dr = xyz_a - xyz[id_b];
221 Tscal rab2 = sycl::dot(dr, dr);
222 Tscal h_b = hpart[id_b];
223
224 if (rab2 > h_a * h_a * Rker2 && rab2 > h_b * h_b * Rker2) {
225 return;
226 }
227
228 Tscal rab = sycl::sqrt(rab2);
229 Tvec vxyz_b = vxyz[id_b];
230 const Tscal u_b = u[id_b];
231
232 Tscal rho_b = rho_h(pmass, h_b, Kernel::hfactd);
233 Tscal P_b = pressure[id_b];
234 // f32 P_b = cs * cs * rho_b;
235 Tscal omega_b = omega[id_b];
236 Tscal cs_b = cs[id_b];
237
238 const Tscal alpha_a = alpha_AV;
239 const Tscal alpha_b = alpha_AV;
240
241 Tscal Fab_a = Kernel::dW_3d(rab, h_a);
242 Tscal Fab_b = Kernel::dW_3d(rab, h_b);
243
244 Tvec v_ab = vxyz_a - vxyz_b;
245
246 Tvec r_ab_unit = dr * sham::inv_sat_positive(rab);
247
248 // f32 P_b = cs * cs * rho_b;
249 Tscal v_ab_r_ab = sycl::dot(v_ab, r_ab_unit);
250 Tscal abs_v_ab_r_ab = sycl::fabs(v_ab_r_ab);
251
252 Tscal vsig_a = alpha_a * cs_a + beta_AV * abs_v_ab_r_ab;
253 Tscal vsig_b = alpha_b * cs_b + beta_AV * abs_v_ab_r_ab;
254
255 Tscal vsig_u = shamrock::sph::vsig_u(P_a, P_b, rho_a, rho_b);
256
257 Tscal qa_ab = shamrock::sph::q_av(rho_a, vsig_a, v_ab_r_ab);
258 Tscal qb_ab = shamrock::sph::q_av(rho_b, vsig_b, v_ab_r_ab);
259
260 add_to_derivs_sph_artif_visco_cond(
261 pmass,
262 rho_a_sq,
263 omega_a_rho_a_inv,
264 rho_a_inv,
265 rho_b,
266 omega_a,
267 omega_b,
268 Fab_a,
269 Fab_b,
270 u_a,
271 u_b,
272 P_a,
273 P_b,
274 alpha_u,
275 v_ab,
276 r_ab_unit,
277 vsig_u,
278 qa_ab,
279 qb_ab,
280 force_pressure,
281 tmpdU_pressure);
282 });
283 axyz[id_a] = force_pressure;
284 du[id_a] = tmpdU_pressure;
285 });
286 });
287 } else {
288 u32 iB_on_rho_interf = ghost_layout.get_field_idx<Tvec>("B/rho");
289 Tscal const mu_0 = solver_config.get_constant_mu_0();
290
291 sham::DeviceBuffer<Tvec> &buf_B_on_rho
292 = mpdat.get_field_buf_ref<Tvec>(iB_on_rho_interf);
293 auto B_on_rho = buf_B_on_rho.get_read_access(depends_list);
294
295 e = q.submit(depends_list, [&](sycl::handler &cgh) {
296 const Tscal pmass = solver_config.gpart_mass;
297 const Tscal alpha_u = cfg.alpha_u;
298 const Tscal alpha_AV = cfg.alpha_AV;
299 const Tscal beta_AV = cfg.beta_AV;
300
301 shamlog_debug_sycl_ln("deriv kernel", "alpha_u :", alpha_u);
302 shamlog_debug_sycl_ln("deriv kernel", "alpha_AV :", alpha_AV);
303 shamlog_debug_sycl_ln("deriv kernel", "beta_AV :", beta_AV);
304
305 // tree::ObjectIterator particle_looper(tree,cgh);
306
307 // tree::LeafCacheObjectIterator
308 // particle_looper(tree,*xyz_cell_id,leaf_cache,cgh);
309
310 tree::ObjectCacheIterator particle_looper(ploop_ptrs);
311
312 // sycl::accessor hmax_tree{tree_field_hmax, cgh, sycl::read_only};
313
314 // sycl::stream out {4096,1024,cgh};
315
316 constexpr Tscal Rker2 = Kernel::Rkern * Kernel::Rkern;
317
318 shambase::parallel_for(
319 cgh, pdat.get_obj_cnt(), "compute force cte AV", [=](u64 gid) {
320 u32 id_a = (u32) gid;
321
322 using namespace shamrock::sph;
323
324 Tvec sum_axyz = {0, 0, 0};
325 Tscal sum_du_a = 0;
326
327 Tscal h_a = hpart[id_a];
328 Tvec xyz_a = xyz[id_a];
329 Tvec vxyz_a = vxyz[id_a];
330 Tscal P_a = pressure[id_a];
331 Tscal omega_a = omega[id_a];
332 const Tscal u_a = u[id_a];
333
334 Tscal rho_a = rho_h(pmass, h_a, Kernel::hfactd);
335 Tscal rho_a_sq = rho_a * rho_a;
336 Tscal rho_a_inv = 1. / rho_a;
337
338 // f32 P_a = cs * cs * rho_a;
339
340 Tscal omega_a_rho_a_inv = 1 / (omega_a * rho_a);
341
342 Tscal cs_a = cs[id_a];
343
344 // signal speed (sound speed, or fast magnetosonic speed with MHD)
345 Tscal c_sig_a = shamphys::MHD_physics<Tvec, Tscal>::v_shock(
346 cs_a, B_on_rho[id_a] * rho_a, rho_a, mu_0);
347
348 Tvec force_pressure{0, 0, 0};
349 Tscal tmpdU_pressure = 0;
350
351 particle_looper.for_each_object(id_a, [&](u32 id_b) {
352 // compute only omega_a
353 Tvec dr = xyz_a - xyz[id_b];
354 Tscal rab2 = sycl::dot(dr, dr);
355 Tscal h_b = hpart[id_b];
356
357 if (rab2 > h_a * h_a * Rker2 && rab2 > h_b * h_b * Rker2) {
358 return;
359 }
360
361 Tscal rab = sycl::sqrt(rab2);
362 Tvec vxyz_b = vxyz[id_b];
363 const Tscal u_b = u[id_b];
364
365 Tscal rho_b = rho_h(pmass, h_b, Kernel::hfactd);
366 Tscal P_b = pressure[id_b];
367 // f32 P_b = cs * cs * rho_b;
368 Tscal omega_b = omega[id_b];
369 Tscal cs_b = cs[id_b];
370
371 Tscal c_sig_b = shamphys::MHD_physics<Tvec, Tscal>::v_shock(
372 cs_b, B_on_rho[id_b] * rho_b, rho_b, mu_0);
373
374 const Tscal alpha_a = alpha_AV;
375 const Tscal alpha_b = alpha_AV;
376
377 Tscal Fab_a = Kernel::dW_3d(rab, h_a);
378 Tscal Fab_b = Kernel::dW_3d(rab, h_b);
379
380 Tvec v_ab = vxyz_a - vxyz_b;
381
382 Tvec r_ab_unit = dr * sham::inv_sat_positive(rab);
383
384 // f32 P_b = cs * cs * rho_b;
385 Tscal v_ab_r_ab = sycl::dot(v_ab, r_ab_unit);
386 Tscal abs_v_ab_r_ab = sycl::fabs(v_ab_r_ab);
387
388 Tscal vsig_a = alpha_a * c_sig_a + beta_AV * abs_v_ab_r_ab;
389 Tscal vsig_b = alpha_b * c_sig_b + beta_AV * abs_v_ab_r_ab;
390
391 Tscal vsig_u = shamrock::sph::vsig_u(P_a, P_b, rho_a, rho_b);
392
393 Tscal qa_ab = shamrock::sph::q_av(rho_a, vsig_a, v_ab_r_ab);
394 Tscal qb_ab = shamrock::sph::q_av(rho_b, vsig_b, v_ab_r_ab);
395
396 add_to_derivs_sph_artif_visco_cond(
397 pmass,
398 rho_a_sq,
399 omega_a_rho_a_inv,
400 rho_a_inv,
401 rho_b,
402 omega_a,
403 omega_b,
404 Fab_a,
405 Fab_b,
406 u_a,
407 u_b,
408 P_a,
409 P_b,
410 alpha_u,
411 v_ab,
412 r_ab_unit,
413 vsig_u,
414 qa_ab,
415 qb_ab,
416 force_pressure,
417 tmpdU_pressure);
418 });
419 axyz[id_a] = force_pressure;
420 du[id_a] = tmpdU_pressure;
421 });
422 });
423
424 buf_B_on_rho.complete_event_state(e);
425 }
426
427 buf_xyz.complete_event_state(e);
428 buf_axyz.complete_event_state(e);
429 buf_duint.complete_event_state(e);
430 buf_vxyz.complete_event_state(e);
431 buf_hpart.complete_event_state(e);
432 buf_omega.complete_event_state(e);
433 buf_uint.complete_event_state(e);
434 buf_pressure.complete_event_state(e);
435 buf_cs.complete_event_state(e);
436
437 sham::EventList resulting_events;
438 resulting_events.add_event(e);
439 pcache.complete_event_state(resulting_events);
440 });
441}
442template<class Tvec, template<class> class SPHKernel>
443void shammodels::sph::modules::UpdateDerivs<Tvec, SPHKernel>::update_derivs_mm97(VaryingMM97 cfg) {
444 StackEntry stack_loc{};
445
446 using namespace shamrock;
447 using namespace shamrock::patch;
448
449 PatchDataLayerLayout &pdl = scheduler().pdl_old();
450
451 const u32 ixyz = pdl.get_field_idx<Tvec>("xyz");
452 const u32 ivxyz = pdl.get_field_idx<Tvec>("vxyz");
453 const u32 iaxyz = pdl.get_field_idx<Tvec>("axyz");
454 const u32 iuint = pdl.get_field_idx<Tscal>("uint");
455 const u32 iduint = pdl.get_field_idx<Tscal>("duint");
456 const u32 ihpart = pdl.get_field_idx<Tscal>("hpart");
457
459 = shambase::get_check_ref(storage.ghost_layout.get());
460 u32 ihpart_interf = ghost_layout.get_field_idx<Tscal>("hpart");
461 u32 iuint_interf = ghost_layout.get_field_idx<Tscal>("uint");
462 u32 ivxyz_interf = ghost_layout.get_field_idx<Tvec>("vxyz");
463 u32 iomega_interf = ghost_layout.get_field_idx<Tscal>("omega");
464
465 auto &merged_xyzh = storage.merged_xyzh.get();
467 shambase::DistributedData<PatchDataLayer> &mpdats = storage.merged_patchdata_ghost.get();
468
469 auto &part_counts = storage.part_counts;
470 auto &part_counts_with_ghost = storage.part_counts_with_ghost;
471 auto &xyz_refs = storage.positions_with_ghosts;
472 auto &pressure_field = storage.pressure;
473 auto &soundspeed_field = storage.soundspeed;
474
475 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tscal>> uint_refs
476 = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("uint", "u");
477 {
478 shambase::get_check_ref(uint_refs).set_refs(
479 mpdats.map<std::reference_wrapper<PatchDataField<Tscal>>>(
480 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
481 return std::ref(mpdat.get_field<Tscal>(iuint_interf));
482 }));
483 }
484
485 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tvec>> vxyz_refs
486 = std::make_shared<shamrock::solvergraph::FieldRefs<Tvec>>("vxyz", "v");
487 {
488 shambase::get_check_ref(vxyz_refs).set_refs(
489 mpdats.map<std::reference_wrapper<PatchDataField<Tvec>>>(
490 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
491 return std::ref(mpdat.get_field<Tvec>(ivxyz_interf));
492 }));
493 }
494
495 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tscal>> hpart_refs
496 = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("hpart", "h");
497 { // if was just reset before this call
498 shambase::get_check_ref(hpart_refs)
499 .set_refs(mpdats.map<std::reference_wrapper<PatchDataField<Tscal>>>(
500 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
501 return std::ref(mpdat.get_field<Tscal>(ihpart_interf));
502 }));
503 }
504
505 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tscal>> omega_refs
506 = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("omega", "omega");
507 {
508 shambase::get_check_ref(omega_refs)
509 .set_refs(mpdats.map<std::reference_wrapper<PatchDataField<Tscal>>>(
510 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
511 return std::ref(mpdat.get_field<Tscal>(iomega_interf));
512 }));
513 }
514
515 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tscal>> alpha_av_refs
516 = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("alpha_av", "alpha_av");
517 {
519 scheduler().for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
520 refs.add_obj(
521 cur_p.id_patch, std::ref(storage.alpha_av_ghost.get().get(cur_p.id_patch)));
522 });
523 shambase::get_check_ref(alpha_av_refs).set_refs(refs);
524 }
525
526 shamrock::solvergraph::SolverGraph &solver_graph = storage.solver_graph;
527
528 auto axyz_refs = solver_graph.get_edge_ptr<shamrock::solvergraph::FieldRefs<Tvec>>("axyz");
529 auto duint_refs = solver_graph.get_edge_ptr<shamrock::solvergraph::FieldRefs<Tscal>>("duint");
530 auto gpart_mass
531 = solver_graph.get_edge_ptr<shamrock::solvergraph::IDataEdge<Tscal>>("gpart_mass");
532
533 std::shared_ptr<shamrock::solvergraph::IDataEdge<Tscal>> alpha_u
534 = std::make_shared<shamrock::solvergraph::IDataEdge<Tscal>>("alpha_u", "alpha_u");
535 {
536 shambase::get_check_ref(alpha_u).data = cfg.alpha_u;
537 }
538 std::shared_ptr<shamrock::solvergraph::IDataEdge<Tscal>> beta_AV
539 = std::make_shared<shamrock::solvergraph::IDataEdge<Tscal>>("beta_AV", "beta_AV");
540 {
541 shambase::get_check_ref(beta_AV).data = cfg.beta_AV;
542 }
543
544 if (solver_config.has_field_b_on_rho()) { // common for IMHD & NIMHD
545 u32 iB_on_rho_interf = ghost_layout.get_field_idx<Tvec>("B/rho");
546
547 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tvec>> B_on_rho_refs
548 = std::make_shared<shamrock::solvergraph::FieldRefs<Tvec>>("B/rho", "B/rho");
549 {
550 shambase::get_check_ref(B_on_rho_refs)
551 .set_refs(mpdats.map<std::reference_wrapper<PatchDataField<Tvec>>>(
552 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
553 return std::ref(mpdat.get_field<Tvec>(iB_on_rho_interf));
554 }));
555 }
556
557 std::shared_ptr<shamrock::solvergraph::IDataEdge<Tscal>> mu_0
558 = std::make_shared<shamrock::solvergraph::IDataEdge<Tscal>>("mu_0", "\\mu_0");
559 {
560 shambase::get_check_ref(mu_0).data = solver_config.get_constant_mu_0();
561 }
562
563 std::shared_ptr<NodeUpdateDerivsVaryingAlphaAVMHD<Tvec, SPHKernel>> node
564 = std::make_shared<NodeUpdateDerivsVaryingAlphaAVMHD<Tvec, SPHKernel>>();
565 {
566 node->set_edges(
567 gpart_mass,
568 alpha_u,
569 beta_AV,
570 mu_0,
571 part_counts,
572 part_counts_with_ghost,
573 xyz_refs,
574 hpart_refs,
575 vxyz_refs,
576 uint_refs,
577 omega_refs,
578 pressure_field,
579 soundspeed_field,
580 alpha_av_refs,
581 B_on_rho_refs,
582 storage.neigh_cache,
583 axyz_refs,
584 duint_refs);
585 }
586 node->evaluate();
587 } else {
588 std::shared_ptr<NodeUpdateDerivsVaryingAlphaAV<Tvec, SPHKernel>> node
589 = std::make_shared<NodeUpdateDerivsVaryingAlphaAV<Tvec, SPHKernel>>();
590 {
591 node->set_edges(
592 gpart_mass,
593 alpha_u,
594 beta_AV,
595 part_counts,
596 part_counts_with_ghost,
597 xyz_refs,
598 hpart_refs,
599 vxyz_refs,
600 uint_refs,
601 omega_refs,
602 pressure_field,
603 soundspeed_field,
604 alpha_av_refs,
605 storage.neigh_cache,
606 axyz_refs,
607 duint_refs);
608 }
609 node->evaluate();
610 }
611}
612template<class Tvec, template<class> class SPHKernel>
613void shammodels::sph::modules::UpdateDerivs<Tvec, SPHKernel>::update_derivs_cd10(VaryingCD10 cfg) {
614 StackEntry stack_loc{};
615
616 using namespace shamrock;
617 using namespace shamrock::patch;
618
619 PatchDataLayerLayout &pdl = scheduler().pdl_old();
620
621 const u32 ixyz = pdl.get_field_idx<Tvec>("xyz");
622 const u32 ivxyz = pdl.get_field_idx<Tvec>("vxyz");
623 const u32 iaxyz = pdl.get_field_idx<Tvec>("axyz");
624 const u32 iuint = pdl.get_field_idx<Tscal>("uint");
625 const u32 iduint = pdl.get_field_idx<Tscal>("duint");
626 const u32 ihpart = pdl.get_field_idx<Tscal>("hpart");
627
629 = shambase::get_check_ref(storage.ghost_layout.get());
630 u32 ihpart_interf = ghost_layout.get_field_idx<Tscal>("hpart");
631 u32 iuint_interf = ghost_layout.get_field_idx<Tscal>("uint");
632 u32 ivxyz_interf = ghost_layout.get_field_idx<Tvec>("vxyz");
633 u32 iomega_interf = ghost_layout.get_field_idx<Tscal>("omega");
634
635 auto &merged_xyzh = storage.merged_xyzh.get();
637 shambase::DistributedData<PatchDataLayer> &mpdats = storage.merged_patchdata_ghost.get();
638
639 auto &part_counts = storage.part_counts;
640 auto &part_counts_with_ghost = storage.part_counts_with_ghost;
641 auto &xyz_refs = storage.positions_with_ghosts;
642 auto &pressure_field = storage.pressure;
643 auto &soundspeed_field = storage.soundspeed;
644
645 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tscal>> uint_refs
646 = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("uint", "u");
647 {
648 shambase::get_check_ref(uint_refs).set_refs(
649 mpdats.map<std::reference_wrapper<PatchDataField<Tscal>>>(
650 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
651 return std::ref(mpdat.get_field<Tscal>(iuint_interf));
652 }));
653 }
654
655 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tvec>> vxyz_refs
656 = std::make_shared<shamrock::solvergraph::FieldRefs<Tvec>>("vxyz", "v");
657 {
658 shambase::get_check_ref(vxyz_refs).set_refs(
659 mpdats.map<std::reference_wrapper<PatchDataField<Tvec>>>(
660 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
661 return std::ref(mpdat.get_field<Tvec>(ivxyz_interf));
662 }));
663 }
664
665 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tscal>> hpart_refs
666 = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("hpart", "h");
667 { // if was just reset before this call
668 shambase::get_check_ref(hpart_refs)
669 .set_refs(mpdats.map<std::reference_wrapper<PatchDataField<Tscal>>>(
670 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
671 return std::ref(mpdat.get_field<Tscal>(ihpart_interf));
672 }));
673 }
674
675 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tscal>> omega_refs
676 = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("omega", "omega");
677 {
678 shambase::get_check_ref(omega_refs)
679 .set_refs(mpdats.map<std::reference_wrapper<PatchDataField<Tscal>>>(
680 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
681 return std::ref(mpdat.get_field<Tscal>(iomega_interf));
682 }));
683 }
684
685 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tscal>> alpha_av_refs
686 = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("alpha_av", "alpha_av");
687 {
689 scheduler().for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
690 refs.add_obj(
691 cur_p.id_patch, std::ref(storage.alpha_av_ghost.get().get(cur_p.id_patch)));
692 });
693 shambase::get_check_ref(alpha_av_refs).set_refs(refs);
694 }
695
696 shamrock::solvergraph::SolverGraph &solver_graph = storage.solver_graph;
697
698 auto axyz_refs = solver_graph.get_edge_ptr<shamrock::solvergraph::FieldRefs<Tvec>>("axyz");
699 auto duint_refs = solver_graph.get_edge_ptr<shamrock::solvergraph::FieldRefs<Tscal>>("duint");
700 auto gpart_mass
701 = solver_graph.get_edge_ptr<shamrock::solvergraph::IDataEdge<Tscal>>("gpart_mass");
702
703 std::shared_ptr<shamrock::solvergraph::IDataEdge<Tscal>> alpha_u
704 = std::make_shared<shamrock::solvergraph::IDataEdge<Tscal>>("alpha_u", "alpha_u");
705 {
706 shambase::get_check_ref(alpha_u).data = cfg.alpha_u;
707 }
708 std::shared_ptr<shamrock::solvergraph::IDataEdge<Tscal>> beta_AV
709 = std::make_shared<shamrock::solvergraph::IDataEdge<Tscal>>("beta_AV", "beta_AV");
710 {
711 shambase::get_check_ref(beta_AV).data = cfg.beta_AV;
712 }
713
714 if (solver_config.dust_config.should_use_dust_av()) {
715 u32 ndust = solver_config.dust_config.get_dust_nvar();
716 u32 is_j_interf = ghost_layout.get_field_idx<Tscal>("s_j");
717
718 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tscal>> s_j_refs
719 = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("s_j", "s_j");
720 {
721 shambase::get_check_ref(s_j_refs).set_refs(
722 mpdats.map<std::reference_wrapper<PatchDataField<Tscal>>>(
723 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
724 return std::ref(mpdat.get_field<Tscal>(is_j_interf));
725 }));
726 }
727
728 std::shared_ptr<NodeUpdateDerivsVaryingAlphaAVDustTVA<Tvec, SPHKernel>> node
729 = std::make_shared<NodeUpdateDerivsVaryingAlphaAVDustTVA<Tvec, SPHKernel>>(ndust);
730 {
731 node->set_edges(
732 gpart_mass,
733 alpha_u,
734 beta_AV,
735 part_counts,
736 part_counts_with_ghost,
737 xyz_refs,
738 hpart_refs,
739 vxyz_refs,
740 uint_refs,
741 omega_refs,
742 pressure_field,
743 soundspeed_field,
744 alpha_av_refs,
745 s_j_refs,
746 storage.neigh_cache,
747 axyz_refs,
748 duint_refs);
749 }
750 node->evaluate();
751 } else if (solver_config.has_field_b_on_rho()) { // common for IMHD & NIMHD
752 u32 iB_on_rho_interf = ghost_layout.get_field_idx<Tvec>("B/rho");
753
754 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tvec>> B_on_rho_refs
755 = std::make_shared<shamrock::solvergraph::FieldRefs<Tvec>>("B/rho", "B/rho");
756 {
757 shambase::get_check_ref(B_on_rho_refs)
758 .set_refs(mpdats.map<std::reference_wrapper<PatchDataField<Tvec>>>(
759 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
760 return std::ref(mpdat.get_field<Tvec>(iB_on_rho_interf));
761 }));
762 }
763
764 std::shared_ptr<shamrock::solvergraph::IDataEdge<Tscal>> mu_0
765 = std::make_shared<shamrock::solvergraph::IDataEdge<Tscal>>("mu_0", "\\mu_0");
766 {
767 shambase::get_check_ref(mu_0).data = solver_config.get_constant_mu_0();
768 }
769
770 std::shared_ptr<NodeUpdateDerivsVaryingAlphaAVMHD<Tvec, SPHKernel>> node
771 = std::make_shared<NodeUpdateDerivsVaryingAlphaAVMHD<Tvec, SPHKernel>>();
772 {
773 node->set_edges(
774 gpart_mass,
775 alpha_u,
776 beta_AV,
777 mu_0,
778 part_counts,
779 part_counts_with_ghost,
780 xyz_refs,
781 hpart_refs,
782 vxyz_refs,
783 uint_refs,
784 omega_refs,
785 pressure_field,
786 soundspeed_field,
787 alpha_av_refs,
788 B_on_rho_refs,
789 storage.neigh_cache,
790 axyz_refs,
791 duint_refs);
792 }
793 node->evaluate();
794 } else {
795 std::shared_ptr<NodeUpdateDerivsVaryingAlphaAV<Tvec, SPHKernel>> node
796 = std::make_shared<NodeUpdateDerivsVaryingAlphaAV<Tvec, SPHKernel>>();
797 {
798 node->set_edges(
799 gpart_mass,
800 alpha_u,
801 beta_AV,
802 part_counts,
803 part_counts_with_ghost,
804 xyz_refs,
805 hpart_refs,
806 vxyz_refs,
807 uint_refs,
808 omega_refs,
809 pressure_field,
810 soundspeed_field,
811 alpha_av_refs,
812 storage.neigh_cache,
813 axyz_refs,
814 duint_refs);
815 }
816 node->evaluate();
817 }
818}
819
820template<class Tvec, template<class> class SPHKernel>
821void shammodels::sph::modules::UpdateDerivs<Tvec, SPHKernel>::update_derivs_disc_visco(
822 ConstantDisc cfg) {
823 StackEntry stack_loc{};
824
825 using namespace shamrock;
826 using namespace shamrock::patch;
827
828 PatchDataLayerLayout &pdl = scheduler().pdl_old();
829
830 const u32 ixyz = pdl.get_field_idx<Tvec>("xyz");
831 const u32 ivxyz = pdl.get_field_idx<Tvec>("vxyz");
832 const u32 iaxyz = pdl.get_field_idx<Tvec>("axyz");
833 const u32 iuint = pdl.get_field_idx<Tscal>("uint");
834 const u32 iduint = pdl.get_field_idx<Tscal>("duint");
835 const u32 ihpart = pdl.get_field_idx<Tscal>("hpart");
836
838 = shambase::get_check_ref(storage.ghost_layout.get());
839 u32 ihpart_interf = ghost_layout.get_field_idx<Tscal>("hpart");
840 u32 iuint_interf = ghost_layout.get_field_idx<Tscal>("uint");
841 u32 ivxyz_interf = ghost_layout.get_field_idx<Tvec>("vxyz");
842 u32 iomega_interf = ghost_layout.get_field_idx<Tscal>("omega");
843
844 // with MHD the signal velocity->fast magnetosonic speed instead of cs
845 // @@@ not entirely sure that's correct, maybe only if alfven point not
846 // reached within the disc ?
847 bool use_mhd = solver_config.has_field_b_on_rho();
848
849 auto &merged_xyzh = storage.merged_xyzh.get();
851 shambase::DistributedData<PatchDataLayer> &mpdats = storage.merged_patchdata_ghost.get();
852
853 scheduler().for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
854 PatchDataLayer &mpdat = mpdats.get(cur_p.id_patch);
855
857 = merged_xyzh.get(cur_p.id_patch).template get_field_buf_ref<Tvec>(0);
858 sham::DeviceBuffer<Tvec> &buf_axyz = pdat.get_field_buf_ref<Tvec>(iaxyz);
859 sham::DeviceBuffer<Tscal> &buf_duint = pdat.get_field_buf_ref<Tscal>(iduint);
860 sham::DeviceBuffer<Tvec> &buf_vxyz = mpdat.get_field_buf_ref<Tvec>(ivxyz_interf);
861 sham::DeviceBuffer<Tscal> &buf_hpart = mpdat.get_field_buf_ref<Tscal>(ihpart_interf);
862 sham::DeviceBuffer<Tscal> &buf_omega = mpdat.get_field_buf_ref<Tscal>(iomega_interf);
863 sham::DeviceBuffer<Tscal> &buf_uint = mpdat.get_field_buf_ref<Tscal>(iuint_interf);
864 sham::DeviceBuffer<Tscal> &buf_pressure
865 = shambase::get_check_ref(storage.pressure).get_field(cur_p.id_patch).get_buf();
867 = shambase::get_check_ref(storage.soundspeed).get_field(cur_p.id_patch).get_buf();
868
869 sycl::range range_npart{pdat.get_obj_cnt()};
870
871 tree::ObjectCache &pcache
872 = shambase::get_check_ref(storage.neigh_cache).get_cache(cur_p.id_patch);
873
875
876 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
877 sham::EventList depends_list;
878
879 auto xyz = buf_xyz.get_read_access(depends_list);
880 auto axyz = buf_axyz.get_write_access(depends_list);
881 auto du = buf_duint.get_write_access(depends_list);
882 auto vxyz = buf_vxyz.get_read_access(depends_list);
883 auto hpart = buf_hpart.get_read_access(depends_list);
884 auto omega = buf_omega.get_read_access(depends_list);
885 auto u = buf_uint.get_read_access(depends_list);
886 auto pressure = buf_pressure.get_read_access(depends_list);
887 auto cs = buf_cs.get_read_access(depends_list);
888 auto ploop_ptrs = pcache.get_read_access(depends_list);
889
890 sycl::event e;
891 if (!use_mhd) {
892 e = q.submit(depends_list, [&](sycl::handler &cgh) {
893 const Tscal pmass = solver_config.gpart_mass;
894 const Tscal alpha_AV = cfg.alpha_AV;
895 const Tscal alpha_u = cfg.alpha_u;
896 const Tscal beta_AV = cfg.beta_AV;
897
898 shamlog_debug_sycl_ln("deriv kernel", "alpha_AV :", alpha_AV);
899 shamlog_debug_sycl_ln("deriv kernel", "alpha_u :", alpha_u);
900 shamlog_debug_sycl_ln("deriv kernel", "beta_AV :", beta_AV);
901
902 // tree::ObjectIterator particle_looper(tree,cgh);
903
904 // tree::LeafCacheObjectIterator
905 // particle_looper(tree,*xyz_cell_id,leaf_cache,cgh);
906
907 tree::ObjectCacheIterator particle_looper(ploop_ptrs);
908
909 // sycl::accessor hmax_tree{tree_field_hmax, cgh, sycl::read_only};
910
911 // sycl::stream out {4096,1024,cgh};
912
913 constexpr Tscal Rker2 = Kernel::Rkern * Kernel::Rkern;
914
915 shambase::parallel_for(cgh, pdat.get_obj_cnt(), "compute force disc", [=](u64 gid) {
916 u32 id_a = (u32) gid;
917
918 using namespace shamrock::sph;
919
920 Tvec sum_axyz = {0, 0, 0};
921 Tscal sum_du_a = 0;
922
923 Tscal h_a = hpart[id_a];
924 Tvec xyz_a = xyz[id_a];
925 Tvec vxyz_a = vxyz[id_a];
926 Tscal P_a = pressure[id_a];
927 Tscal cs_a = cs[id_a];
928 Tscal omega_a = omega[id_a];
929 const Tscal u_a = u[id_a];
930
931 Tscal rho_a = rho_h(pmass, h_a, Kernel::hfactd);
932 Tscal rho_a_sq = rho_a * rho_a;
933 Tscal rho_a_inv = 1. / rho_a;
934
935 // f32 P_a = cs * cs * rho_a;
936
937 Tscal omega_a_rho_a_inv = 1 / (omega_a * rho_a);
938
939 Tvec force_pressure{0, 0, 0};
940 Tscal tmpdU_pressure = 0;
941
942 particle_looper.for_each_object(id_a, [&](u32 id_b) {
943 // compute only omega_a
944 Tvec dr = xyz_a - xyz[id_b];
945 Tscal rab2 = sycl::dot(dr, dr);
946 Tscal h_b = hpart[id_b];
947
948 if (rab2 > h_a * h_a * Rker2 && rab2 > h_b * h_b * Rker2) {
949 return;
950 }
951
952 Tvec vxyz_b = vxyz[id_b];
953 const Tscal u_b = u[id_b];
954 Tscal P_b = pressure[id_b];
955 Tscal omega_b = omega[id_b];
956 Tscal cs_b = cs[id_b];
957
958 Tscal rab = sycl::sqrt(rab2);
959
960 Tscal rho_b = rho_h(pmass, h_b, Kernel::hfactd);
961 const Tscal alpha_a = alpha_AV;
962 const Tscal alpha_b = alpha_AV;
963 Tscal Fab_a = Kernel::dW_3d(rab, h_a);
964 Tscal Fab_b = Kernel::dW_3d(rab, h_b);
965
966 Tvec v_ab = vxyz_a - vxyz_b;
967
968 Tvec r_ab_unit = dr * sham::inv_sat_positive(rab);
969
970 // f32 P_b = cs * cs * rho_b;
971 Tscal v_ab_r_ab = sycl::dot(v_ab, r_ab_unit);
972 Tscal abs_v_ab_r_ab = sycl::fabs(v_ab_r_ab);
973
974 Tscal vsig_a = alpha_a * cs_a + beta_AV * abs_v_ab_r_ab;
975 Tscal vsig_b = alpha_b * cs_b + beta_AV * abs_v_ab_r_ab;
976
977 Tscal vsig_u = shamrock::sph::vsig_u(P_a, P_b, rho_a, rho_b);
978
979 Tscal qa_ab = shamrock::sph::q_av_disc(
980 rho_a, h_a, rab, alpha_a, cs_a, vsig_a, v_ab_r_ab);
981 Tscal qb_ab = shamrock::sph::q_av_disc(
982 rho_b, h_b, rab, alpha_b, cs_b, vsig_b, v_ab_r_ab);
983
984 add_to_derivs_sph_artif_visco_cond(
985 pmass,
986 rho_a_sq,
987 omega_a_rho_a_inv,
988 rho_a_inv,
989 rho_b,
990 omega_a,
991 omega_b,
992 Fab_a,
993 Fab_b,
994 u_a,
995 u_b,
996 P_a,
997 P_b,
998 alpha_u,
999 v_ab,
1000 r_ab_unit,
1001 vsig_u,
1002 qa_ab,
1003 qb_ab,
1004
1005 force_pressure,
1006 tmpdU_pressure);
1007 });
1008
1009 axyz[id_a] = force_pressure;
1010 du[id_a] = tmpdU_pressure;
1011 });
1012 });
1013 } else {
1014 u32 iB_on_rho_interf = ghost_layout.get_field_idx<Tvec>("B/rho");
1015 Tscal const mu_0 = solver_config.get_constant_mu_0();
1016
1017 sham::DeviceBuffer<Tvec> &buf_B_on_rho
1018 = mpdat.get_field_buf_ref<Tvec>(iB_on_rho_interf);
1019 auto B_on_rho = buf_B_on_rho.get_read_access(depends_list);
1020
1021 e = q.submit(depends_list, [&](sycl::handler &cgh) {
1022 const Tscal pmass = solver_config.gpart_mass;
1023 const Tscal alpha_AV = cfg.alpha_AV;
1024 const Tscal alpha_u = cfg.alpha_u;
1025 const Tscal beta_AV = cfg.beta_AV;
1026
1027 shamlog_debug_sycl_ln("deriv kernel", "alpha_AV :", alpha_AV);
1028 shamlog_debug_sycl_ln("deriv kernel", "alpha_u :", alpha_u);
1029 shamlog_debug_sycl_ln("deriv kernel", "beta_AV :", beta_AV);
1030
1031 // tree::ObjectIterator particle_looper(tree,cgh);
1032
1033 // tree::LeafCacheObjectIterator
1034 // particle_looper(tree,*xyz_cell_id,leaf_cache,cgh);
1035
1036 tree::ObjectCacheIterator particle_looper(ploop_ptrs);
1037
1038 // sycl::accessor hmax_tree{tree_field_hmax, cgh, sycl::read_only};
1039
1040 // sycl::stream out {4096,1024,cgh};
1041
1042 constexpr Tscal Rker2 = Kernel::Rkern * Kernel::Rkern;
1043
1044 shambase::parallel_for(
1045 cgh, pdat.get_obj_cnt(), "compute force disc MHD", [=](u64 gid) {
1046 u32 id_a = (u32) gid;
1047
1048 using namespace shamrock::sph;
1049
1050 Tvec sum_axyz = {0, 0, 0};
1051 Tscal sum_du_a = 0;
1052
1053 Tscal h_a = hpart[id_a];
1054 Tvec xyz_a = xyz[id_a];
1055 Tvec vxyz_a = vxyz[id_a];
1056 Tscal P_a = pressure[id_a];
1057 Tscal cs_a = cs[id_a];
1058 Tscal omega_a = omega[id_a];
1059 const Tscal u_a = u[id_a];
1060
1061 Tscal rho_a = rho_h(pmass, h_a, Kernel::hfactd);
1062 Tscal rho_a_sq = rho_a * rho_a;
1063 Tscal rho_a_inv = 1. / rho_a;
1064
1065 // f32 P_a = cs * cs * rho_a;
1066
1067 Tscal omega_a_rho_a_inv = 1 / (omega_a * rho_a);
1068
1069 // fast magnetosonic speed instead of the sound speed
1070 Tscal v_shock_a = shamphys::MHD_physics<Tvec, Tscal>::v_shock(
1071 cs_a, B_on_rho[id_a] * rho_a, rho_a, mu_0);
1072
1073 Tvec force_pressure{0, 0, 0};
1074 Tscal tmpdU_pressure = 0;
1075
1076 particle_looper.for_each_object(id_a, [&](u32 id_b) {
1077 // compute only omega_a
1078 Tvec dr = xyz_a - xyz[id_b];
1079 Tscal rab2 = sycl::dot(dr, dr);
1080 Tscal h_b = hpart[id_b];
1081
1082 if (rab2 > h_a * h_a * Rker2 && rab2 > h_b * h_b * Rker2) {
1083 return;
1084 }
1085
1086 Tvec vxyz_b = vxyz[id_b];
1087 const Tscal u_b = u[id_b];
1088 Tscal P_b = pressure[id_b];
1089 Tscal omega_b = omega[id_b];
1090 Tscal cs_b = cs[id_b];
1091
1092 Tscal rab = sycl::sqrt(rab2);
1093
1094 Tscal rho_b = rho_h(pmass, h_b, Kernel::hfactd);
1095 Tscal v_shock_b = shamphys::MHD_physics<Tvec, Tscal>::v_shock(
1096 cs_b, B_on_rho[id_b] * rho_b, rho_b, mu_0);
1097
1098 const Tscal alpha_a = alpha_AV;
1099 const Tscal alpha_b = alpha_AV;
1100 Tscal Fab_a = Kernel::dW_3d(rab, h_a);
1101 Tscal Fab_b = Kernel::dW_3d(rab, h_b);
1102
1103 Tvec v_ab = vxyz_a - vxyz_b;
1104
1105 Tvec r_ab_unit = dr * sham::inv_sat_positive(rab);
1106
1107 // f32 P_b = cs * cs * rho_b;
1108 Tscal v_ab_r_ab = sycl::dot(v_ab, r_ab_unit);
1109 Tscal abs_v_ab_r_ab = sycl::fabs(v_ab_r_ab);
1110
1111 Tscal vsig_a = alpha_a * v_shock_a + beta_AV * abs_v_ab_r_ab;
1112 Tscal vsig_b = alpha_b * v_shock_b + beta_AV * abs_v_ab_r_ab;
1113
1114 Tscal vsig_u = shamrock::sph::vsig_u(P_a, P_b, rho_a, rho_b);
1115
1116 Tscal qa_ab = shamrock::sph::q_av_disc(
1117 rho_a, h_a, rab, alpha_a, v_shock_a, vsig_a, v_ab_r_ab);
1118 Tscal qb_ab = shamrock::sph::q_av_disc(
1119 rho_b, h_b, rab, alpha_b, v_shock_b, vsig_b, v_ab_r_ab);
1120
1121 add_to_derivs_sph_artif_visco_cond(
1122 pmass,
1123 rho_a_sq,
1124 omega_a_rho_a_inv,
1125 rho_a_inv,
1126 rho_b,
1127 omega_a,
1128 omega_b,
1129 Fab_a,
1130 Fab_b,
1131 u_a,
1132 u_b,
1133 P_a,
1134 P_b,
1135 alpha_u,
1136 v_ab,
1137 r_ab_unit,
1138 vsig_u,
1139 qa_ab,
1140 qb_ab,
1141
1142 force_pressure,
1143 tmpdU_pressure);
1144 });
1145
1146 axyz[id_a] = force_pressure;
1147 du[id_a] = tmpdU_pressure;
1148 });
1149 });
1150
1151 buf_B_on_rho.complete_event_state(e);
1152 }
1153
1154 buf_xyz.complete_event_state(e);
1155 buf_axyz.complete_event_state(e);
1156 buf_duint.complete_event_state(e);
1157 buf_vxyz.complete_event_state(e);
1158 buf_hpart.complete_event_state(e);
1159 buf_omega.complete_event_state(e);
1160 buf_uint.complete_event_state(e);
1161 buf_pressure.complete_event_state(e);
1162 buf_cs.complete_event_state(e);
1163
1164 sham::EventList resulting_events;
1165 resulting_events.add_event(e);
1166 pcache.complete_event_state(resulting_events);
1167 });
1168}
1169
1170template<class Tvec, template<class> class SPHKernel>
1171void shammodels::sph::modules::UpdateDerivs<Tvec, SPHKernel>::update_derivs_mhd(IdealMHD cfg) {
1172 update_derivs_mhd_impl<shamrock::sph::mhd::MHDType::Ideal>(
1173 cfg.sigma_mhd,
1174 cfg.alpha_B,
1175 /*etaO=*/Tscal(0),
1176 /*etaH=*/Tscal(0),
1177 /*etaAD=*/Tscal(0));
1178}
1179
1180template<class Tvec, template<class> class SPHKernel>
1181void shammodels::sph::modules::UpdateDerivs<Tvec, SPHKernel>::update_derivs_nimhd(NonIdealMHD cfg) {
1182 update_derivs_mhd_impl<shamrock::sph::mhd::MHDType::NonIdeal>(
1183 cfg.sigma_mhd, cfg.alpha_B, cfg.etaO, cfg.etaH, cfg.etaAD);
1184}
1185
1186template<class Tvec, template<class> class SPHKernel>
1187template<shamrock::sph::mhd::MHDType mhd_mode>
1188void shammodels::sph::modules::UpdateDerivs<Tvec, SPHKernel>::update_derivs_mhd_impl(
1189 Tscal sigma_mhd, Tscal alpha_B, Tscal etaO, Tscal etaH, Tscal etaAD) {
1190
1191 StackEntry stack_loc{};
1192
1193 using namespace shamrock;
1194 using namespace shamrock::patch;
1195
1196 PatchDataLayerLayout &pdl = scheduler().pdl_old();
1197
1198 const u32 ixyz = pdl.get_field_idx<Tvec>("xyz");
1199 const u32 ivxyz = pdl.get_field_idx<Tvec>("vxyz");
1200 const u32 iaxyz = pdl.get_field_idx<Tvec>("axyz");
1201 const u32 iuint = pdl.get_field_idx<Tscal>("uint");
1202 const u32 iduint = pdl.get_field_idx<Tscal>("duint");
1203 const u32 ihpart = pdl.get_field_idx<Tscal>("hpart");
1204 const u32 iB_on_rho = pdl.get_field_idx<Tvec>("B/rho");
1205 const u32 idB_on_rho = pdl.get_field_idx<Tvec>("dB/rho");
1206 const u32 ipsi_on_ch = pdl.get_field_idx<Tscal>("psi/ch");
1207 const u32 idpsi_on_ch = pdl.get_field_idx<Tscal>("dpsi/ch");
1208 const u32 idrho_dt = pdl.get_field_idx<Tscal>("drho/dt");
1209
1210 bool do_MHD_debug = solver_config.do_MHD_debug();
1211 const u32 imag_pressure = (do_MHD_debug) ? pdl.get_field_idx<Tvec>("mag_pressure") : -1;
1212 const u32 imag_tension = (do_MHD_debug) ? pdl.get_field_idx<Tvec>("mag_tension") : -1;
1213 const u32 igas_pressure = (do_MHD_debug) ? pdl.get_field_idx<Tvec>("gas_pressure") : -1;
1214 const u32 itensile_corr = (do_MHD_debug) ? pdl.get_field_idx<Tvec>("tensile_corr") : -1;
1215 const u32 ipsi_propag = (do_MHD_debug) ? pdl.get_field_idx<Tscal>("psi_propag") : -1;
1216 const u32 ipsi_diff = (do_MHD_debug) ? pdl.get_field_idx<Tscal>("psi_diff") : -1;
1217 const u32 ipsi_cons = (do_MHD_debug) ? pdl.get_field_idx<Tscal>("psi_cons") : -1;
1218 const u32 iu_mhd = (do_MHD_debug) ? pdl.get_field_idx<Tscal>("u_mhd") : -1;
1219
1220 Tscal const mu_0 = solver_config.get_constant_mu_0();
1221
1223 = shambase::get_check_ref(storage.ghost_layout.get());
1224 u32 ihpart_interf = ghost_layout.get_field_idx<Tscal>("hpart");
1225 u32 iuint_interf = ghost_layout.get_field_idx<Tscal>("uint");
1226 u32 ivxyz_interf = ghost_layout.get_field_idx<Tvec>("vxyz");
1227 u32 iomega_interf = ghost_layout.get_field_idx<Tscal>("omega");
1228 u32 iB_on_rho_interf = ghost_layout.get_field_idx<Tvec>("B/rho");
1229 u32 ipsi_on_ch_interf = ghost_layout.get_field_idx<Tscal>("psi/ch");
1230
1231 bool do_nimhd = solver_config.do_nimhd();
1232
1233 auto &merged_xyzh = storage.merged_xyzh.get();
1235 shambase::DistributedData<PatchDataLayer> &mpdats = storage.merged_patchdata_ghost.get();
1236
1237 scheduler().for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
1238 PatchDataLayer &mpdat = mpdats.get(cur_p.id_patch);
1239
1241 = merged_xyzh.get(cur_p.id_patch).template get_field_buf_ref<Tvec>(0);
1242 sham::DeviceBuffer<Tvec> &buf_axyz = pdat.get_field_buf_ref<Tvec>(iaxyz);
1243 sham::DeviceBuffer<Tscal> &buf_duint = pdat.get_field_buf_ref<Tscal>(iduint);
1244 sham::DeviceBuffer<Tvec> &buf_vxyz = mpdat.get_field_buf_ref<Tvec>(ivxyz_interf);
1245 sham::DeviceBuffer<Tscal> &buf_hpart = mpdat.get_field_buf_ref<Tscal>(ihpart_interf);
1246 sham::DeviceBuffer<Tscal> &buf_omega = mpdat.get_field_buf_ref<Tscal>(iomega_interf);
1248 = shambase::get_check_ref(storage.soundspeed).get_field(cur_p.id_patch).get_buf();
1249
1250 sham::DeviceBuffer<Tvec> &buf_dB_on_rho = pdat.get_field_buf_ref<Tvec>(idB_on_rho);
1251 sham::DeviceBuffer<Tscal> &buf_dpsi_on_ch = pdat.get_field_buf_ref<Tscal>(idpsi_on_ch);
1252 sham::DeviceBuffer<Tscal> &buf_drho_dt = pdat.get_field_buf_ref<Tscal>(idrho_dt);
1253
1254 sham::DeviceBuffer<Tvec> &buf_B_on_rho = mpdat.get_field_buf_ref<Tvec>(iB_on_rho_interf);
1255 sham::DeviceBuffer<Tscal> &buf_psi_on_ch
1256 = mpdat.get_field_buf_ref<Tscal>(ipsi_on_ch_interf);
1257
1258 bool do_nimhd = solver_config.do_nimhd();
1260 = (do_nimhd) ? &storage.MagCurrentJ_ghost.get().get(cur_p.id_patch).get_buf() : nullptr;
1261
1262 tree::ObjectCache &pcache
1263 = shambase::get_check_ref(storage.neigh_cache).get_cache(cur_p.id_patch);
1264
1265 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
1266 sham::EventList depends_list;
1267
1268 auto xyz = buf_xyz.get_read_access(depends_list);
1269 // axyz & du already contain the hydro terms, the MHD terms are added on top
1270 auto axyz = buf_axyz.get_write_access(depends_list);
1271 auto du = buf_duint.get_write_access(depends_list);
1272 auto vxyz = buf_vxyz.get_read_access(depends_list);
1273 auto hpart = buf_hpart.get_read_access(depends_list);
1274 auto omega = buf_omega.get_read_access(depends_list);
1275 auto cs = buf_cs.get_read_access(depends_list);
1276 auto B_on_rho = buf_B_on_rho.get_read_access(depends_list);
1277 auto psi_on_ch = buf_psi_on_ch.get_read_access(depends_list);
1278 auto dB_on_rho = buf_dB_on_rho.get_write_access(depends_list);
1279 auto dpsi_on_ch = buf_dpsi_on_ch.get_write_access(depends_list);
1280 auto drho_dt = buf_drho_dt.get_write_access(depends_list);
1281 auto J_field = (do_nimhd) ? buf_J->get_read_access(depends_list) : nullptr;
1282
1283 Tvec *mag_pressure
1284 = (do_MHD_debug)
1285 ? pdat.get_field_buf_ref<Tvec>(imag_pressure).get_write_access(depends_list)
1286 : nullptr;
1287 Tvec *mag_tension
1288 = (do_MHD_debug)
1289 ? pdat.get_field_buf_ref<Tvec>(imag_tension).get_write_access(depends_list)
1290 : nullptr;
1291 Tvec *gas_pressure
1292 = (do_MHD_debug)
1293 ? pdat.get_field_buf_ref<Tvec>(igas_pressure).get_write_access(depends_list)
1294 : nullptr;
1295 Tvec *tensile_corr
1296 = (do_MHD_debug)
1297 ? pdat.get_field_buf_ref<Tvec>(itensile_corr).get_write_access(depends_list)
1298 : nullptr;
1299 Tscal *psi_propag
1300 = (do_MHD_debug)
1301 ? pdat.get_field_buf_ref<Tscal>(ipsi_propag).get_write_access(depends_list)
1302 : nullptr;
1303 Tscal *psi_diff
1304 = (do_MHD_debug)
1305 ? pdat.get_field_buf_ref<Tscal>(ipsi_diff).get_write_access(depends_list)
1306 : nullptr;
1307 Tscal *psi_cons
1308 = (do_MHD_debug)
1309 ? pdat.get_field_buf_ref<Tscal>(ipsi_cons).get_write_access(depends_list)
1310 : nullptr;
1311 Tscal *u_mhd = (do_MHD_debug)
1312 ? pdat.get_field_buf_ref<Tscal>(iu_mhd).get_write_access(depends_list)
1313 : nullptr;
1314
1315 auto ploop_ptrs = pcache.get_read_access(depends_list);
1316
1317 auto e = q.submit(depends_list, [&](sycl::handler &cgh) {
1318 const Tscal pmass = solver_config.gpart_mass;
1319 const Tscal _sigma = sigma_mhd;
1320 const Tscal _alpha_B = alpha_B;
1321 const Tscal _etaO = etaO;
1322 const Tscal _etaH = etaH;
1323 const Tscal _etaAD = etaAD;
1324
1325 shamlog_debug_ln("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@", "");
1326 shamlog_debug_sycl_ln("deriv kernel", "sigma_mhd :", _sigma);
1327 shamlog_debug_sycl_ln("deriv kernel", "alpha_B :", _alpha_B);
1328 shamlog_debug_sycl_ln("deriv kernel", "etaO :", _etaO);
1329 shamlog_debug_sycl_ln("deriv kernel", "etaH :", _etaH);
1330 shamlog_debug_sycl_ln("deriv kernel", "etaAD :", _etaAD);
1331 shamlog_debug_ln("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@", "");
1332
1333 tree::ObjectCacheIterator particle_looper(ploop_ptrs);
1334
1335 constexpr Tscal Rker2 = Kernel::Rkern * Kernel::Rkern;
1336
1337 shambase::parallel_for(cgh, pdat.get_obj_cnt(), "compute MHD", [=](u64 gid) {
1338 u32 id_a = (u32) gid;
1339
1340 using namespace shamrock::sph;
1341
1342 Tscal h_a = hpart[id_a];
1343 Tvec xyz_a = xyz[id_a];
1344 Tvec vxyz_a = vxyz[id_a];
1345 Tscal cs_a = cs[id_a];
1346 Tscal omega_a = omega[id_a];
1347
1348 Tvec J_a = (do_nimhd) ? J_field[id_a] : Tvec{0, 0, 0};
1349
1350 Tscal rho_a = rho_h(pmass, h_a, Kernel::hfactd);
1351 Tscal rho_a_sq = rho_a * rho_a;
1352
1353 Tvec B_a = B_on_rho[id_a] * rho_a;
1354 Tscal v_alfven_a = sycl::sqrt(sycl::dot(B_a, B_a) / (mu_0 * rho_a));
1355 Tscal v_shock_a = sycl::sqrt(cs_a * cs_a + v_alfven_a * v_alfven_a);
1356 Tscal psi_a = psi_on_ch[id_a] * v_shock_a;
1357
1358 Tvec force_mhd{0, 0, 0};
1359 Tscal tmpdU_mhd = 0;
1360 Tvec magnetic_eq{0, 0, 0};
1361 Tscal psi_eq = 0;
1362 Tscal drho_eq = 0;
1363
1364 Tvec mag_pressure_term{0, 0, 0};
1365 Tvec mag_tension_term{0, 0, 0};
1366 Tvec tensile_corr_term{0, 0, 0};
1367 Tscal psi_propag_term = 0;
1368 Tscal psi_diff_term = 0;
1369 Tscal psi_cons_term = 0;
1370
1371 particle_looper.for_each_object(id_a, [&](u32 id_b) {
1372 Tvec dr = xyz_a - xyz[id_b];
1373 Tscal rab2 = sycl::dot(dr, dr);
1374 Tscal h_b = hpart[id_b];
1375
1376 if (rab2 > h_a * h_a * Rker2 && rab2 > h_b * h_b * Rker2) {
1377 return;
1378 }
1379
1380 Tvec vxyz_b = vxyz[id_b];
1381 Tscal omega_b = omega[id_b];
1382 Tscal cs_b = cs[id_b];
1383 Tscal rab = sycl::sqrt(rab2);
1384
1385 Tvec J_b = (do_nimhd) ? J_field[id_b] : Tvec{0, 0, 0};
1386
1387 Tscal rho_b = rho_h(pmass, h_b, Kernel::hfactd);
1388 Tvec B_b = B_on_rho[id_b] * rho_b;
1389 Tscal v_alfven_b = sycl::sqrt(sycl::dot(B_b, B_b) / (mu_0 * rho_b));
1390 Tscal v_shock_b = sycl::sqrt(cs_b * cs_b + v_alfven_b * v_alfven_b);
1391 Tscal psi_b = psi_on_ch[id_b] * v_shock_b;
1392
1393 Tscal Fab_a = Kernel::dW_3d(rab, h_a);
1394 Tscal Fab_b = Kernel::dW_3d(rab, h_b);
1395
1397 pmass,
1398 dr,
1399 rab,
1400 rho_a,
1401 rho_a_sq,
1402 rho_b,
1403 omega_a,
1404 omega_b,
1405 Fab_a,
1406 Fab_b,
1407 vxyz_a,
1408 vxyz_b,
1409 cs_a,
1410 cs_b,
1411 h_a,
1412 h_b,
1413 _alpha_B,
1414 B_a,
1415 B_b,
1416 J_a,
1417 J_b,
1418 psi_a,
1419 psi_b,
1420 mu_0,
1421 _sigma,
1422 _etaO,
1423 _etaH,
1424 _etaAD,
1425 force_mhd,
1426 tmpdU_mhd,
1427 magnetic_eq,
1428 psi_eq,
1429 drho_eq,
1430 mag_pressure_term,
1431 mag_tension_term,
1432 tensile_corr_term,
1433 psi_propag_term,
1434 psi_diff_term,
1435 psi_cons_term);
1436 });
1437
1438 if (do_nimhd) {
1439 // only add once per particle
1440 Tscal u_NI = shamrock::sph::mhd::u_ni_heating<Tvec, Tscal, mhd_mode>(
1441 B_a, J_a, rho_a, etaO, etaH, etaAD, mu_0);
1442 tmpdU_mhd += u_NI;
1443 }
1444
1445 if (do_MHD_debug) {
1446 // at this point axyz only contains the hydro terms (gas pressure + AV)
1447 gas_pressure[id_a] = axyz[id_a];
1448 mag_pressure[id_a] = mag_pressure_term;
1449 mag_tension[id_a] = mag_tension_term;
1450 tensile_corr[id_a] = tensile_corr_term;
1451 psi_propag[id_a] = psi_propag_term;
1452 psi_diff[id_a] = psi_diff_term;
1453 psi_cons[id_a] = -psi_a / h_a;
1454 u_mhd[id_a] = tmpdU_mhd;
1455 }
1456
1457 axyz[id_a] += force_mhd;
1458 du[id_a] += tmpdU_mhd;
1459 dB_on_rho[id_a] = magnetic_eq;
1460 dpsi_on_ch[id_a] = psi_eq - psi_a / h_a;
1461 drho_dt[id_a] = drho_eq;
1462 });
1463 });
1464
1465 buf_xyz.complete_event_state(e);
1466 buf_axyz.complete_event_state(e);
1467 buf_duint.complete_event_state(e);
1468 buf_vxyz.complete_event_state(e);
1469 buf_hpart.complete_event_state(e);
1470 buf_omega.complete_event_state(e);
1471 buf_cs.complete_event_state(e);
1472 buf_B_on_rho.complete_event_state(e);
1473 buf_psi_on_ch.complete_event_state(e);
1474 buf_dB_on_rho.complete_event_state(e);
1475 buf_dpsi_on_ch.complete_event_state(e);
1476 buf_drho_dt.complete_event_state(e);
1477
1478 if (do_nimhd) {
1479 buf_J->complete_event_state(e);
1480 }
1481
1482 if (do_MHD_debug) {
1483 pdat.get_field_buf_ref<Tvec>(imag_pressure).complete_event_state(e);
1484 pdat.get_field_buf_ref<Tvec>(imag_tension).complete_event_state(e);
1485 pdat.get_field_buf_ref<Tvec>(igas_pressure).complete_event_state(e);
1486 pdat.get_field_buf_ref<Tvec>(itensile_corr).complete_event_state(e);
1487 pdat.get_field_buf_ref<Tscal>(ipsi_propag).complete_event_state(e);
1488 pdat.get_field_buf_ref<Tscal>(ipsi_diff).complete_event_state(e);
1489 pdat.get_field_buf_ref<Tscal>(ipsi_cons).complete_event_state(e);
1490 pdat.get_field_buf_ref<Tscal>(iu_mhd).complete_event_state(e);
1491 }
1492
1493 sham::EventList resulting_events;
1494 resulting_events.add_event(e);
1495 pcache.complete_event_state(resulting_events);
1496 });
1497
1498 // storage.MagCurrentJ.reset();
1499}
1500
1501template<class Tvec, template<class> class SPHKernel>
1502void shammodels::sph::modules::UpdateDerivs<Tvec, SPHKernel>::update_derivs_dust_monofluid_tva_Sj(
1503 DustConfig cfg, Tscal dt_hydro) {
1504
1505 using MonofluidTVA = typename DustConfig::MonofluidTVA;
1506
1507 StackEntry stack_loc{};
1508
1509 using namespace shamrock;
1510 using namespace shamrock::patch;
1511
1512 PatchDataLayerLayout &pdl = scheduler().pdl_old();
1513
1514 const u32 ixyz = pdl.get_field_idx<Tvec>("xyz");
1515 const u32 ivxyz = pdl.get_field_idx<Tvec>("vxyz");
1516 const u32 iaxyz = pdl.get_field_idx<Tvec>("axyz");
1517 const u32 ihpart = pdl.get_field_idx<Tscal>("hpart");
1518 const u32 is_j = pdl.get_field_idx<Tscal>("s_j");
1519 const u32 ids_j_dt = pdl.get_field_idx<Tscal>("ds_j_dt");
1520
1522 = shambase::get_check_ref(storage.ghost_layout.get());
1523 u32 ihpart_interf = ghost_layout.get_field_idx<Tscal>("hpart");
1524 u32 ivxyz_interf = ghost_layout.get_field_idx<Tvec>("vxyz");
1525 u32 iomega_interf = ghost_layout.get_field_idx<Tscal>("omega");
1526 u32 is_j_interf = ghost_layout.get_field_idx<Tscal>("s_j");
1527
1528 u32 ndust = cfg.get_dust_nvar();
1529
1530 auto &merged_xyzh = storage.merged_xyzh.get();
1532 shambase::DistributedData<PatchDataLayer> &mpdats = storage.merged_patchdata_ghost.get();
1533
1534 auto &part_counts = storage.part_counts;
1535 auto &part_counts_with_ghost = storage.part_counts_with_ghost;
1536 auto &xyz_refs = storage.positions_with_ghosts;
1537 auto &pressure_field = storage.pressure;
1538
1539 shamrock::solvergraph::SolverGraph &solver_graph = storage.solver_graph;
1540 auto gpart_mass
1541 = solver_graph.get_edge_ptr<shamrock::solvergraph::IDataEdge<Tscal>>("gpart_mass");
1542
1543 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tvec>> vxyz_refs
1544 = std::make_shared<shamrock::solvergraph::FieldRefs<Tvec>>("vxyz", "v");
1545 {
1546 shambase::get_check_ref(vxyz_refs).set_refs(
1547 mpdats.map<std::reference_wrapper<PatchDataField<Tvec>>>(
1548 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
1549 return std::ref(mpdat.get_field<Tvec>(ivxyz_interf));
1550 }));
1551 }
1552
1553 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tscal>> hpart_refs
1554 = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("hpart", "h");
1555 { // if was just reset before this call
1556 shambase::get_check_ref(hpart_refs)
1557 .set_refs(mpdats.map<std::reference_wrapper<PatchDataField<Tscal>>>(
1558 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
1559 return std::ref(mpdat.get_field<Tscal>(ihpart_interf));
1560 }));
1561 }
1562
1563 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tscal>> omega_refs
1564 = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("omega", "omega");
1565 {
1566 shambase::get_check_ref(omega_refs)
1567 .set_refs(mpdats.map<std::reference_wrapper<PatchDataField<Tscal>>>(
1568 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
1569 return std::ref(mpdat.get_field<Tscal>(iomega_interf));
1570 }));
1571 }
1572
1573 // s_j_interf
1574 std::shared_ptr<shamrock::solvergraph::FieldRefs<Tscal>> s_j_refs
1575 = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("s_j", "s_j");
1576 {
1577 shambase::get_check_ref(s_j_refs).set_refs(
1578 mpdats.map<std::reference_wrapper<PatchDataField<Tscal>>>(
1579 [&](u64 id, shamrock::patch::PatchDataLayer &mpdat) {
1580 return std::ref(mpdat.get_field<Tscal>(is_j_interf));
1581 }));
1582 }
1583
1584 auto t_j_field
1585 = storage.solver_graph.template get_edge_ptr<shamrock::solvergraph::Field<Tscal>>("Ts_j");
1586
1587 std::shared_ptr<shamrock::solvergraph::Field<Tscal>> Ttilde_sj_field
1588 = std::make_shared<shamrock::solvergraph::Field<Tscal>>(ndust, "Ttilde_sj", "Ttilde_sj");
1589
1590 auto ds_j_dt_refs
1591 = solver_graph.get_edge_ptr<shamrock::solvergraph::FieldRefs<Tscal>>("ds_j_dt");
1592
1593 std::shared_ptr<ComputeDustTtilde<Tvec, SPHKernel>> node_tj
1594 = std::make_shared<ComputeDustTtilde<Tvec, SPHKernel>>(ndust);
1595 {
1596 node_tj->set_edges(
1597 gpart_mass, part_counts_with_ghost, hpart_refs, s_j_refs, t_j_field, Ttilde_sj_field);
1598 }
1599 node_tj->evaluate();
1600
1601 MonofluidTVA &cfg_monofluid_tva
1602 = shambase::get_check_ref((std::get_if<MonofluidTVA>(&cfg.current_mode)));
1603
1604 // the pair gate is independent of the limiter choice; when combined with the smooth limiter
1605 // it replaces its per-particle xi switch
1606 const bool use_pair_gate = cfg_monofluid_tva.pair_gate_s_positivity_limiter;
1607
1608 std::shared_ptr<NodeUpdateDerivsMonofluidTVA<Tvec, SPHKernel>> node
1609 = std::make_shared<NodeUpdateDerivsMonofluidTVA<Tvec, SPHKernel>>(ndust, use_pair_gate);
1610 {
1611 node->set_edges(
1612 gpart_mass,
1613 part_counts,
1614 part_counts_with_ghost,
1615 xyz_refs,
1616 hpart_refs,
1617 vxyz_refs,
1618 omega_refs,
1619 pressure_field,
1620 s_j_refs,
1621 Ttilde_sj_field,
1622 storage.neigh_cache,
1623 ds_j_dt_refs);
1624 }
1625 node->evaluate();
1626
1627 if (DustEvolCoalaCoag<Tscal> *cfg_evol
1628 = std::get_if<DustEvolCoalaCoag<Tscal>>(&cfg.dust_evol_config)) {
1629
1630 auto massgrid = shamrock::solvergraph::IDataEdge<std::vector<Tscal>>::make_shared("", "");
1631 massgrid->data = cfg_evol->massgrid;
1632
1633 auto tabflux_coag
1635 tabflux_coag->data = cfg_evol->tabflux_coag;
1636
1637 auto rhodust_eps = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("", "");
1638 rhodust_eps->data = cfg_evol->rhodust_eps;
1639
1640 auto tau_frac = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("", "");
1641 tau_frac->data = cfg_evol->tau_frac;
1642
1643 auto vfrag_threshold = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("", "");
1644 vfrag_threshold->data = cfg_evol->vfrag_threshold;
1645
1646 auto dt_hydro_edge = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("", "");
1647 dt_hydro_edge->data = dt_hydro;
1648
1649 std::shared_ptr<shamrock::solvergraph::Field<Tvec>> grad_P_on_rho
1650 = std::make_shared<shamrock::solvergraph::Field<Tvec>>(1, "grad P/rho", "grad P/rho");
1651
1652 std::shared_ptr<shamrock::solvergraph::Field<Tvec>> delta_v
1653 = std::make_shared<shamrock::solvergraph::Field<Tvec>>(ndust, "Delta v", "Delta v");
1654
1655 std::shared_ptr<shamrock::solvergraph::Field<Tscal>> S_coag
1656 = std::make_shared<shamrock::solvergraph::Field<Tscal>>(ndust, "S_coag", "S_coag");
1657
1658 auto press_grad_node = std::make_shared<NodeComputePressureGrad<Tvec, SPHKernel>>();
1659 auto delta_v_node = std::make_shared<MonoFluidTVADeltav<Tvec, SPHKernel>>(ndust);
1660 auto node = std::make_shared<NodeEvolveDustCOALASourceTerm<Tvec>>(ndust);
1661 auto node_add_source_term = std::make_shared<NodeMonofluidTVAAddSourceTerm<Tvec>>(ndust);
1662
1663 press_grad_node->set_edges(
1664 gpart_mass,
1665 part_counts,
1666 part_counts_with_ghost,
1667 xyz_refs,
1668 hpart_refs,
1669 omega_refs,
1670 pressure_field,
1671 storage.neigh_cache,
1672 grad_P_on_rho);
1673
1674 delta_v_node->set_edges(
1675 gpart_mass, part_counts, hpart_refs, grad_P_on_rho, s_j_refs, t_j_field, delta_v);
1676
1677 node->set_edges(
1678 rhodust_eps,
1679 vfrag_threshold,
1680 massgrid,
1681 tabflux_coag,
1682 part_counts,
1683 s_j_refs,
1684 delta_v,
1685 S_coag);
1686
1687 node_add_source_term->set_edges(
1688 part_counts, rhodust_eps, tau_frac, dt_hydro_edge, S_coag, s_j_refs, ds_j_dt_refs);
1689
1690 press_grad_node->evaluate();
1691 delta_v_node->evaluate();
1692 node->evaluate();
1693
1694 // here we could compute the sum of S_coag to see if we are fucking up the dust mass
1695 // conservation
1696
1697 node_add_source_term->evaluate();
1698 }
1699
1700 if (cfg_monofluid_tva.smooth_s_positivity_limiter) {
1701 // with the pair gate the xi switch was already applied pairwise in the TVA derivative,
1702 // only the restoring term (phi) remains
1703 std::shared_ptr<NodeMonofluidTVASmoothSPositivityLimiter<Tvec>> node_limiter
1704 = std::make_shared<NodeMonofluidTVASmoothSPositivityLimiter<Tvec>>(
1705 ndust, !use_pair_gate);
1706 {
1707 node_limiter->set_edges(part_counts, s_j_refs, Ttilde_sj_field, ds_j_dt_refs);
1708 }
1709 node_limiter->evaluate();
1710 }
1711
1712 if (cfg_monofluid_tva.pure_diffusion_mode) {
1713 // reset accelerations & du/dt to 0
1714
1715 const u32 iaxyz = pdl.get_field_idx<Tvec>("axyz");
1716 const u32 iduint = pdl.get_field_idx<Tscal>("duint");
1717
1718 scheduler().for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
1719 pdat.get_field_buf_ref<Tvec>(iaxyz).fill({0, 0, 0});
1720 pdat.get_field_buf_ref<Tscal>(iduint).fill(0);
1721 });
1722 }
1723}
1724
1725using namespace shammath;
1729
Compute the dust combined stopping times Ttilde_sj for each dust species j see Hutchison 2018 eq 15.
constexpr const char * axyz
3-acceleration field
constexpr const char * vxyz
3-velocity field
constexpr const char * part_counts_with_ghost
Particle counts including ghosts.
constexpr const char * xyz
Position field (3D coordinates).
constexpr const char * part_counts
Particle counts per patch.
constexpr const char * pressure
Pressure P (derived from EOS).
constexpr const char * hpart
Smoothing length field.
constexpr const char * omega
Grad-h correction factor \Omega.
Hydro update derivs (pressure, artificial viscosity & conductivity) with a varying alpha AV,...
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
void add_event(sycl::event e)
Add an event to the list of events.
Definition EventList.hpp:88
Represents a collection of objects distributed across patches identified by a u64 id.
iterator add_obj(u64 id, T &&obj)
Adds a new object to the collection.
DistributedData< Tmap > map(std::function< Tmap(u64, T &)> map_func)
Apply a function to all objects in the collection and return a new collection containing the results.
T & get(u64 id)
Returns a reference to an object in the collection.
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
A graph container for managing solver nodes and edges with type-safe access.
std::shared_ptr< T > get_edge_ptr(const std::string &name)
Get a typed shared pointer to an edge by name.
constexpr Unit mu_0
vacuum permeability
T inv_sat_positive(T v, T minvsat=T{1e-9}, T satval=T{0.}) noexcept
inverse saturated (positive numbers only)
Definition math.hpp:841
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
void throw_unimplemented(SourceLocation loc=SourceLocation{})
Throw a std::runtime_error saying that the function is unimplemented.
namespace for math utility
Definition AABB.hpp:26
namespace for the main framework
Definition __init__.py:1
constexpr Tscal q_av(const Tscal &rho, const Tscal &vsig, const Tscal &v_scal_rhat)
phantom_2018 eq.40
Definition q_ab.hpp:37
file containing formulas for sphmhd forces, evolution of magnetic and divergence cleaning fields.
void add_to_derivs_spmhd(Tscal pmass, Tvec dr, Tscal rab, Tscal rho_a, Tscal rho_a_sq, Tscal rho_b, Tscal omega_a, Tscal omega_b, Tscal Fab_a, Tscal Fab_b, Tvec vxyz_a, Tvec vxyz_b, Tscal cs_a, Tscal cs_b, Tscal h_a, Tscal h_b, Tscal alpha_B, Tvec B_a, Tvec B_b, Tvec J_a, Tvec J_b, Tscal psi_a, Tscal psi_b, Tscal mu_0, Tscal sigma_mhd, Tscal etaO, Tscal etaH, Tscal etaAD, Tvec &dv_dt, Tscal &du_dt, Tvec &dB_on_rho_dt, Tscal &dpsi_on_ch_dt, Tscal &drho_dt, Tvec &mag_pressure, Tvec &mag_tension, Tvec &tensile_corr, Tscal &psi_propag, Tscal &psi_diff, Tscal &psi_cons)
Add the pure MHD terms of the pair (a,b) to the derivatives of particle a.
Definition mhd.hpp:295
file containing formulas for sph forces
sph kernels
shambase::details::BasicStackEntry StackEntry
Alias for shambase::details::BasicStackEntry.
Patch object that contain generic patch information.
Definition Patch.hpp:33
u64 id_patch
unique key that identify the patch
Definition Patch.hpp:86