40#define NODE_EDGES(X_RO, X_RW, X_RO_OPTIONAL, X_RW_OPTIONAL) \
42 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, cs) \
43 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, hfactd) \
44 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, pmass) \
45 X_RO_OPTIONAL(shamrock::solvergraph::IFieldSpan<Tscal>, spans_rho) \
46 X_RO_OPTIONAL(shamrock::solvergraph::IFieldSpan<Tscal>, spans_h) \
47 X_RO(shamrock::solvergraph::Indexes<u32>, sizes) \
50 X_RW(shamrock::solvergraph::IFieldSpan<Tscal>, spans_pressure) \
51 X_RW(shamrock::solvergraph::IFieldSpan<Tscal>, spans_soundspeed)
53namespace shammodels::common::modules {
57 using Tscal = shambase::VecComponent<Tvec>;
60 ComputeEOSIsothermal() =
default;
62 EXPAND_NODE_EDGES_OPTIONAL(NODE_EDGES)
64 inline static void internal_eos(
65 const Tscal &cs,
const Tscal &rho, Tscal &pressure, Tscal &soundspeed)
noexcept {
67 Tscal P_a = EOS::pressure(cs, rho);
76 auto edges = get_edges();
78 bool has_rho = edges.spans_rho.has_value();
79 bool has_h = edges.spans_h.has_value();
82 if ((has_rho && has_h) || (!has_rho && !has_h)) {
84 "Must have either rho or h");
87 edges.spans_pressure.ensure_sizes(edges.sizes.indexes);
88 edges.spans_soundspeed.ensure_sizes(edges.sizes.indexes);
90 Tscal cs = edges.cs.data;
91 Tscal pmass = edges.pmass.data;
92 Tscal hfactd = edges.hfactd.data;
94 auto dev_sched = shamsys::instance::get_compute_scheduler_ptr();
97 edges.spans_pressure.get_spans(), edges.spans_soundspeed.get_spans()};
100 auto &spans_rho = edges.spans_rho.value().get();
101 spans_rho.check_sizes(edges.sizes.indexes);
108 [cs](
u32 gid,
const Tscal *rho, Tscal *pressure, Tscal *soundspeed) {
109 Tscal rho_a = rho[gid];
110 internal_eos(cs, rho_a, pressure[gid], soundspeed[gid]);
113 auto &spans_h = edges.spans_h.value().get();
114 spans_h.check_sizes(edges.sizes.indexes);
122 u32 gid,
const Tscal *h, Tscal *pressure, Tscal *soundspeed) {
123 using namespace shamrock::sph;
124 Tscal rho = rho_h(pmass, h[gid], hfactd);
125 internal_eos(cs, rho, pressure[gid], soundspeed[gid]);
130 inline virtual std::string
_impl_get_label()
const {
return "ComputeEOSIsothermal"; };
138#define NODE_EDGES(X_RO, X_RW, X_RO_OPTIONAL, X_RW_OPTIONAL) \
140 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, gamma) \
141 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, hfactd) \
142 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, pmass) \
143 X_RO_OPTIONAL(shamrock::solvergraph::IFieldSpan<Tscal>, spans_rho) \
144 X_RO_OPTIONAL(shamrock::solvergraph::IFieldSpan<Tscal>, spans_h) \
145 X_RO(shamrock::solvergraph::IFieldSpan<Tscal>, spans_uint) \
146 X_RO(shamrock::solvergraph::Indexes<u32>, sizes) \
149 X_RW(shamrock::solvergraph::IFieldSpan<Tscal>, spans_pressure) \
150 X_RW(shamrock::solvergraph::IFieldSpan<Tscal>, spans_soundspeed)
152namespace shammodels::common::modules {
156 using Tscal = shambase::VecComponent<Tvec>;
159 ComputeEOSAdiabatic() =
default;
161 EXPAND_NODE_EDGES_OPTIONAL(NODE_EDGES)
163 inline static void internal_eos(
168 Tscal &soundspeed)
noexcept {
170 Tscal P_a = EOS::pressure(gamma, rho, uint);
171 Tscal cs_a = EOS::cs_from_p(gamma, rho, P_a);
180 auto edges = get_edges();
182 bool has_rho = edges.spans_rho.has_value();
183 bool has_h = edges.spans_h.has_value();
186 if ((has_rho && has_h) || (!has_rho && !has_h)) {
188 "Must have either rho or h");
191 edges.spans_pressure.ensure_sizes(edges.sizes.indexes);
192 edges.spans_soundspeed.ensure_sizes(edges.sizes.indexes);
194 Tscal gamma = edges.gamma.data;
195 Tscal pmass = edges.pmass.data;
196 Tscal hfactd = edges.hfactd.data;
198 auto dev_sched = shamsys::instance::get_compute_scheduler_ptr();
201 edges.spans_pressure.get_spans(), edges.spans_soundspeed.get_spans()};
204 auto &spans_rho = edges.spans_rho.value().get();
205 spans_rho.check_sizes(edges.sizes.indexes);
218 Tscal rho_a = rho[gid];
219 Tscal uint_a = uint[gid];
220 internal_eos(gamma, rho_a, uint_a, pressure[gid], soundspeed[gid]);
223 auto &spans_h = edges.spans_h.value().get();
224 spans_h.check_sizes(edges.sizes.indexes);
231 [gamma, pmass, hfactd](
237 using namespace shamrock::sph;
238 Tscal rho = rho_h(pmass, h[gid], hfactd);
239 Tscal uint_a = uint[gid];
240 internal_eos(gamma, rho, uint_a, pressure[gid], soundspeed[gid]);
253#define NODE_EDGES(X_RO, X_RW, X_RO_OPTIONAL, X_RW_OPTIONAL) \
255 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, K) \
256 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, gamma) \
257 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, hfactd) \
258 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, pmass) \
259 X_RO_OPTIONAL(shamrock::solvergraph::IFieldSpan<Tscal>, spans_rho) \
260 X_RO_OPTIONAL(shamrock::solvergraph::IFieldSpan<Tscal>, spans_h) \
261 X_RO(shamrock::solvergraph::Indexes<u32>, sizes) \
264 X_RW(shamrock::solvergraph::IFieldSpan<Tscal>, spans_pressure) \
265 X_RW(shamrock::solvergraph::IFieldSpan<Tscal>, spans_soundspeed)
267namespace shammodels::common::modules {
271 using Tscal = shambase::VecComponent<Tvec>;
274 ComputeEOSPolytropic() =
default;
276 EXPAND_NODE_EDGES_OPTIONAL(NODE_EDGES)
278 inline static void internal_eos(
283 Tscal &soundspeed)
noexcept {
285 Tscal P_a = EOS::pressure(gamma, K, rho);
286 Tscal cs_a = EOS::soundspeed(gamma, K, rho);
295 auto edges = get_edges();
297 bool has_rho = edges.spans_rho.has_value();
298 bool has_h = edges.spans_h.has_value();
301 if ((has_rho && has_h) || (!has_rho && !has_h)) {
303 "Must have either rho or h");
306 edges.spans_pressure.ensure_sizes(edges.sizes.indexes);
307 edges.spans_soundspeed.ensure_sizes(edges.sizes.indexes);
309 Tscal K = edges.K.data;
310 Tscal gamma = edges.gamma.data;
311 Tscal pmass = edges.pmass.data;
312 Tscal hfactd = edges.hfactd.data;
314 auto dev_sched = shamsys::instance::get_compute_scheduler_ptr();
317 edges.spans_pressure.get_spans(), edges.spans_soundspeed.get_spans()};
320 auto &spans_rho = edges.spans_rho.value().get();
321 spans_rho.check_sizes(edges.sizes.indexes);
328 [K, gamma](
u32 gid,
const Tscal *rho, Tscal *pressure, Tscal *soundspeed) {
329 Tscal rho_a = rho[gid];
330 internal_eos(K, gamma, rho_a, pressure[gid], soundspeed[gid]);
333 auto &spans_h = edges.spans_h.value().get();
334 spans_h.check_sizes(edges.sizes.indexes);
341 [K, gamma, pmass, hfactd](
342 u32 gid,
const Tscal *h, Tscal *pressure, Tscal *soundspeed) {
343 using namespace shamrock::sph;
344 Tscal rho = rho_h(pmass, h[gid], hfactd);
345 internal_eos(K, gamma, rho, pressure[gid], soundspeed[gid]);
350 inline virtual std::string
_impl_get_label()
const {
return "ComputeEOSPolytropic"; };
358#define NODE_EDGES(X_RO, X_RW, X_RO_OPTIONAL, X_RW_OPTIONAL) \
360 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, cs0) \
361 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, rho0) \
362 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, gamma0) \
363 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, hfactd) \
364 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, pmass) \
365 X_RO_OPTIONAL(shamrock::solvergraph::IFieldSpan<Tscal>, spans_rho) \
366 X_RO_OPTIONAL(shamrock::solvergraph::IFieldSpan<Tscal>, spans_h) \
367 X_RO(shamrock::solvergraph::Indexes<u32>, sizes) \
370 X_RW(shamrock::solvergraph::IFieldSpan<Tscal>, spans_pressure) \
371 X_RW(shamrock::solvergraph::IFieldSpan<Tscal>, spans_soundspeed)
373namespace shammodels::common::modules {
378 using Tscal = shambase::VecComponent<Tvec>;
381 ComputeEOSBarotropic() =
default;
383 EXPAND_NODE_EDGES_OPTIONAL(NODE_EDGES)
385 inline static void internal_eos(
391 Tscal &soundspeed)
noexcept {
393 pressure = EOS::pressure(cs0, rho0, gamma0, rho);
394 soundspeed = EOS::soundspeed(cs0, rho0, gamma0, rho);
401 auto edges = get_edges();
403 bool has_rho = edges.spans_rho.has_value();
404 bool has_h = edges.spans_h.has_value();
407 if ((has_rho && has_h) || (!has_rho && !has_h)) {
409 "Must have either rho or h");
412 edges.spans_pressure.ensure_sizes(edges.sizes.indexes);
413 edges.spans_soundspeed.ensure_sizes(edges.sizes.indexes);
415 Tscal cs0 = edges.cs0.data;
416 Tscal rho0 = edges.rho0.data;
417 Tscal gamma0 = edges.gamma0.data;
418 Tscal pmass = edges.pmass.data;
419 Tscal hfactd = edges.hfactd.data;
421 auto dev_sched = shamsys::instance::get_compute_scheduler_ptr();
424 edges.spans_pressure.get_spans(), edges.spans_soundspeed.get_spans()};
427 auto &spans_rho = edges.spans_rho.value().get();
428 spans_rho.check_sizes(edges.sizes.indexes);
436 u32 gid,
const Tscal *rho, Tscal *pressure, Tscal *soundspeed) {
437 internal_eos(cs0, rho0, gamma0, rho[gid], pressure[gid], soundspeed[gid]);
440 auto &spans_h = edges.spans_h.value().get();
441 spans_h.check_sizes(edges.sizes.indexes);
448 [cs0, rho0, gamma0, pmass, hfactd](
449 u32 gid,
const Tscal *h, Tscal *pressure, Tscal *soundspeed) {
450 using namespace shamrock::sph;
451 Tscal rho = rho_h(pmass, h[gid], hfactd);
452 internal_eos(cs0, rho0, gamma0, rho, pressure[gid], soundspeed[gid]);
457 inline virtual std::string
_impl_get_label()
const {
return "ComputeEOSBarotropic"; };
465#define NODE_EDGES(X_RO, X_RW, X_RO_OPTIONAL, X_RW_OPTIONAL) \
467 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, hfactd) \
468 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, pmass) \
469 X_RO_OPTIONAL(shamrock::solvergraph::IFieldSpan<Tscal>, spans_rho) \
470 X_RO_OPTIONAL(shamrock::solvergraph::IFieldSpan<Tscal>, spans_h) \
471 X_RO(shamrock::solvergraph::IFieldSpan<Tscal>, spans_cs0) \
472 X_RO(shamrock::solvergraph::Indexes<u32>, sizes) \
475 X_RW(shamrock::solvergraph::IFieldSpan<Tscal>, spans_pressure) \
476 X_RW(shamrock::solvergraph::IFieldSpan<Tscal>, spans_soundspeed)
478namespace shammodels::common::modules {
482 using Tscal = shambase::VecComponent<Tvec>;
485 ComputeEOSLocallyIsothermal() =
default;
487 EXPAND_NODE_EDGES_OPTIONAL(NODE_EDGES)
489 inline static void internal_eos(
490 const Tscal &cs0,
const Tscal &rho, Tscal &pressure, Tscal &soundspeed)
noexcept {
492 pressure = EOS::pressure_from_cs(cs0 * cs0, rho);
500 auto edges = get_edges();
502 bool has_rho = edges.spans_rho.has_value();
503 bool has_h = edges.spans_h.has_value();
506 if ((has_rho && has_h) || (!has_rho && !has_h)) {
508 "Must have either rho or h");
511 edges.spans_pressure.ensure_sizes(edges.sizes.indexes);
512 edges.spans_soundspeed.ensure_sizes(edges.sizes.indexes);
514 Tscal pmass = edges.pmass.data;
515 Tscal hfactd = edges.hfactd.data;
517 auto dev_sched = shamsys::instance::get_compute_scheduler_ptr();
520 edges.spans_pressure.get_spans(), edges.spans_soundspeed.get_spans()};
523 auto &spans_rho = edges.spans_rho.value().get();
524 spans_rho.check_sizes(edges.sizes.indexes);
536 Tscal rho_a = rho[gid];
537 Tscal cs0_a = cs0[gid];
538 internal_eos(cs0_a, rho_a, pressure[gid], soundspeed[gid]);
541 auto &spans_h = edges.spans_h.value().get();
542 spans_h.check_sizes(edges.sizes.indexes);
555 using namespace shamrock::sph;
556 Tscal rho = rho_h(pmass, h[gid], hfactd);
557 Tscal cs0_a = cs0[gid];
558 internal_eos(cs0_a, rho, pressure[gid], soundspeed[gid]);
564 return "ComputeEOSLocallyIsothermal";
573#define NODE_EDGES(X_RO, X_RW, X_RO_OPTIONAL, X_RW_OPTIONAL) \
575 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, mu_e) \
576 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, density_unit) \
577 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, pressure_unit) \
578 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, velocity_unit) \
579 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, hfactd) \
580 X_RO(shamrock::solvergraph::IDataEdge<Tscal>, pmass) \
581 X_RO_OPTIONAL(shamrock::solvergraph::IFieldSpan<Tscal>, spans_rho) \
582 X_RO_OPTIONAL(shamrock::solvergraph::IFieldSpan<Tscal>, spans_h) \
583 X_RO(shamrock::solvergraph::Indexes<u32>, sizes) \
586 X_RW(shamrock::solvergraph::IFieldSpan<Tscal>, spans_pressure) \
587 X_RW(shamrock::solvergraph::IFieldSpan<Tscal>, spans_soundspeed)
589namespace shammodels::common::modules {
593 using Tscal = shambase::VecComponent<Tvec>;
596 ComputeEOSFermi() =
default;
598 EXPAND_NODE_EDGES_OPTIONAL(NODE_EDGES)
600 inline static void internal_eos(
602 const Tscal &density_unit,
603 const Tscal &pressure_unit,
604 const Tscal &velocity_unit,
607 Tscal &soundspeed)
noexcept {
609 auto const res = EOS::pressure_and_soundspeed(mu_e, rho * density_unit);
610 pressure = res.pressure / pressure_unit;
611 soundspeed = res.soundspeed / velocity_unit;
618 auto edges = get_edges();
620 bool has_rho = edges.spans_rho.has_value();
621 bool has_h = edges.spans_h.has_value();
624 if ((has_rho && has_h) || (!has_rho && !has_h)) {
626 "Must have either rho or h");
629 edges.spans_pressure.ensure_sizes(edges.sizes.indexes);
630 edges.spans_soundspeed.ensure_sizes(edges.sizes.indexes);
632 Tscal mu_e = edges.mu_e.data;
633 Tscal density_unit = edges.density_unit.data;
634 Tscal pressure_unit = edges.pressure_unit.data;
635 Tscal velocity_unit = edges.velocity_unit.data;
636 Tscal pmass = edges.pmass.data;
637 Tscal hfactd = edges.hfactd.data;
639 auto dev_sched = shamsys::instance::get_compute_scheduler_ptr();
642 edges.spans_pressure.get_spans(), edges.spans_soundspeed.get_spans()};
645 auto &spans_rho = edges.spans_rho.value().get();
646 spans_rho.check_sizes(edges.sizes.indexes);
653 [mu_e, density_unit, pressure_unit, velocity_unit](
654 u32 gid,
const Tscal *rho, Tscal *pressure, Tscal *soundspeed) {
655 Tscal rho_a = rho[gid];
666 auto &spans_h = edges.spans_h.value().get();
667 spans_h.check_sizes(edges.sizes.indexes);
674 [mu_e, density_unit, pressure_unit, velocity_unit, pmass, hfactd](
675 u32 gid,
const Tscal *h, Tscal *pressure, Tscal *soundspeed) {
676 using namespace shamrock::sph;
677 Tscal rho = rho_h(pmass, h[gid], hfactd);
698template<
class Tvec,
template<
class>
class SPHKernel>
699void shammodels::sph::modules::ComputeEos<Tvec, SPHKernel>::compute_eos_internal(
713 using namespace shamrock::patch;
715 using SolverConfigEOS =
typename Config::EOSConfig;
716 using SolverEOS_Isothermal =
typename SolverConfigEOS::Isothermal;
717 using SolverEOS_Adiabatic =
typename SolverConfigEOS::Adiabatic;
718 using SolverEOS_Polytropic =
typename SolverConfigEOS::Polytropic;
719 using SolverEOS_LocallyIsothermal =
typename SolverConfigEOS::LocallyIsothermal;
720 using SolverEOS_LocallyIsothermalLP07 =
typename SolverConfigEOS::LocallyIsothermalLP07;
721 using SolverEOS_LocallyIsothermalFA2014 =
typename SolverConfigEOS::LocallyIsothermalFA2014;
722 using SolverEOS_LocallyIsothermalFA2014Extended =
723 typename SolverConfigEOS::LocallyIsothermalFA2014Extended;
724 using SolverEOS_Fermi =
typename SolverConfigEOS::Fermi;
725 using SolverEOS_Barotropic =
typename SolverConfigEOS::Barotropic;
728 auto dev_sched = shamsys::instance::get_compute_scheduler_ptr();
735 bool has_rho = spans_rho.has_value();
736 bool has_h = spans_h.has_value();
739 if ((!has_rho || has_h) && (has_rho || !has_h)) {
744 = [](
const std::optional<std::shared_ptr<shamrock::solvergraph::IFieldSpan<Tscal>>> &opt)
746 if (!opt.has_value()) {
753 const std::optional<std::reference_wrapper<shamrock::solvergraph::IFieldSpan<Tscal>>>
755 const std::optional<std::reference_wrapper<shamrock::solvergraph::IFieldSpan<Tscal>>>
757 const std::optional<std::reference_wrapper<shamrock::solvergraph::IFieldSpan<Tscal>>>
759 } edges{map_opt_span(spans_rho), map_opt_span(spans_h), map_opt_span(spans_uint)};
765 if (SolverEOS_Isothermal *eos_config
766 = std::get_if<SolverEOS_Isothermal>(&solver_config.eos_config.config)) {
768 auto cs = shamrock::solvergraph::IDataEdge<Tscal>::make_shared(
"cs",
"c_s");
769 cs->data = eos_config->cs;
773 cs, hfactd, pmass, spans_rho, spans_h, sizes, spans_pressure, spans_soundspeed);
776 SolverEOS_Adiabatic *eos_config
777 = std::get_if<SolverEOS_Adiabatic>(&solver_config.eos_config.config)) {
779 auto gamma = shamrock::solvergraph::IDataEdge<Tscal>::make_shared(
"gamma",
"\\gamma");
780 gamma->data = eos_config->gamma;
795 SolverEOS_Polytropic *eos_config
796 = std::get_if<SolverEOS_Polytropic>(&solver_config.eos_config.config)) {
798 auto K = shamrock::solvergraph::IDataEdge<Tscal>::make_shared(
"K",
"K");
799 auto gamma = shamrock::solvergraph::IDataEdge<Tscal>::make_shared(
"gamma",
"\\gamma");
800 K->data = eos_config->K;
801 gamma->data = eos_config->gamma;
805 K, gamma, hfactd, pmass, spans_rho, spans_h, sizes, spans_pressure, spans_soundspeed);
808 [[maybe_unused]] SolverEOS_LocallyIsothermal *eos_config
809 = std::get_if<SolverEOS_LocallyIsothermal>(&solver_config.eos_config.config)) {
814 = shamrock::solvergraph::FieldRefs<Tscal>::make_shared(
"cs0",
"c_{s,0}");
815 auto refs = storage.merged_patchdata_ghost.get()
816 .template map<shamrock::solvergraph::PatchDataFieldRef<Tscal>>(
819 return mpdat.get_field<Tscal>(isoundspeed_interf);
821 soundspeed_refs->set_refs(refs);
835 SolverEOS_LocallyIsothermalLP07 *eos_config
836 = std::get_if<SolverEOS_LocallyIsothermalLP07>(&solver_config.eos_config.config)) {
838 Tscal cs0 = eos_config->cs0;
839 Tscal r0sq = eos_config->r0 * eos_config->r0;
840 Tscal mq = -eos_config->q;
847 = storage.merged_xyzh.get()
848 .template map<shamrock::solvergraph::PatchDataFieldRef<Tvec>>(
851 return mpdat.get_field<Tvec>(0);
853 xyz_refs.set_refs(refs);
857 auto eos_internal = [](Tvec R,
864 Tscal Rsq = sycl::dot(R, R);
865 Tscal cs_sq = EOS::soundspeed_sq(cs0 * cs0, Rsq / r0sq, mq);
866 Tscal cs_out = sycl::sqrt(cs_sq);
868 Tscal P_a = EOS::pressure_from_cs(cs_sq, rho_a);
875 auto &spans_rho_ = edges.spans_rho.value().get();
876 spans_rho_.check_sizes(sizes_indexes);
882 [cs0, r0sq, mq, eos_internal](
889 Tscal rho_a = rho[gid];
890 eos_internal(R_a, cs0, r0sq, mq, rho_a, pressure[gid], soundspeed[gid]);
893 auto &spans_h_ = edges.spans_h.value().get();
894 spans_h_.check_sizes(sizes_indexes);
900 [cs0, r0sq, mq, pmass_, hfactd_, eos_internal](
902 using namespace shamrock::sph;
904 Tscal rho_a = rho_h(pmass_, h[gid], hfactd_);
905 eos_internal(R_a, cs0, r0sq, mq, rho_a, pressure[gid], soundspeed[gid]);
910 SolverEOS_LocallyIsothermalFA2014 *eos_config
911 = std::get_if<SolverEOS_LocallyIsothermalFA2014>(&solver_config.eos_config.config)) {
913 Tscal G = solver_config.get_constant_G();
914 Tscal h_over_r = eos_config->h_over_r;
920 auto &sink_pos = get_sink_pos<Tvec>(scheduler().synchronized_data);
921 auto &sink_mass = get_sink_mass<Tvec>(scheduler().synchronized_data);
922 u32 sink_cnt = shambase::narrow_or_throw<u32>(sink_pos.size());
926 "No sinks found for the equation of state");
931 = storage.merged_xyzh.get()
932 .template map<shamrock::solvergraph::PatchDataFieldRef<Tvec>>(
935 return mpdat.get_field<Tvec>(0);
937 xyz_refs.set_refs(refs);
942 sink_pos_buf.copy_from_stdvec(sink_pos);
943 sink_mass_buf.copy_from_stdvec(sink_mass);
945 auto eos_internal = [](Tvec R,
954 Tscal mpotential = 0;
955 for (
u32 i = 0; i < scount; i++) {
956 Tvec s_r = spos[i] - R;
957 Tscal s_m = smass[i];
958 Tscal s_r_abs = sycl::length(s_r);
959 mpotential += G * s_m / s_r_abs;
962 Tscal cs_out = h_over_r * sycl::sqrt(mpotential);
963 Tscal P_a = EOS::pressure_from_cs(cs_out * cs_out, rho_a);
970 auto &spans_rho_ = edges.spans_rho.value().get();
971 spans_rho_.check_sizes(sizes_indexes);
973 sizes_indexes.for_each([&](
u64 id,
u32 count) {
977 spans_rho_.get_spans().get(
id),
983 [G, h_over_r, sink_cnt, eos_internal](
992 Tscal rho_a = rho[gid];
1007 auto &spans_h_ = edges.spans_h.value().get();
1008 spans_h_.check_sizes(sizes_indexes);
1010 sizes_indexes.for_each([&](
u64 id,
u32 count) {
1014 spans_h_.get_spans().get(
id),
1020 [G, h_over_r, sink_cnt, pmass_, hfactd_, eos_internal](
1027 Tscal *soundspeed) {
1028 using namespace shamrock::sph;
1029 Tvec R_a =
xyz[gid];
1030 Tscal rho_a = rho_h(pmass_, h[gid], hfactd_);
1046 SolverEOS_LocallyIsothermalFA2014Extended *eos_config
1047 = std::get_if<SolverEOS_LocallyIsothermalFA2014Extended>(
1048 &solver_config.eos_config.config)) {
1050 Tscal cs0 = eos_config->cs0;
1051 Tscal r0 = eos_config->r0;
1052 Tscal q_ = eos_config->q;
1055 u32 n_sinks = eos_config->n_sinks;
1059 Tscal r0_q = sycl::pow(r0, q_);
1063 auto &all_sink_pos = get_sink_pos<Tvec>(scheduler().synchronized_data);
1064 auto &all_sink_mass = get_sink_mass<Tvec>(scheduler().synchronized_data);
1065 std::vector<Tvec> sink_pos;
1066 std::vector<Tscal> sink_mass;
1069 for (
size_t i = 0; i < all_sink_pos.size(); i++) {
1070 sink_pos.push_back(all_sink_pos[i]);
1071 sink_mass.push_back(all_sink_mass[i]);
1073 if (sink_pos.size() >= n_sinks) {
1078 if (sink_cnt == 0) {
1080 "No sinks found for the equation of state");
1085 = storage.merged_xyzh.get()
1086 .template map<shamrock::solvergraph::PatchDataFieldRef<Tvec>>(
1089 return mpdat.get_field<Tvec>(0);
1091 xyz_refs.set_refs(refs);
1096 sink_pos_buf.copy_from_stdvec(sink_pos);
1097 sink_mass_buf.copy_from_stdvec(sink_mass);
1099 auto eos_internal = [](Tvec R,
1109 Tscal sink_mass_sum = 0;
1111 for (
u32 i = 0; i < scount; i++) {
1112 Tvec s_r = spos[i] - R;
1113 Tscal s_m = smass[i];
1114 Tscal s_r_abs = sycl::length(s_r);
1115 sink_mass_sum += s_m;
1116 pot_sum += s_m / s_r_abs;
1119 Tscal cs_out = cs0 * r0_q * sycl::pow(pot_sum / sink_mass_sum, q);
1120 Tscal P_a = EOS::pressure_from_cs(cs_out * cs_out, rho_a);
1127 auto &spans_rho_ = edges.spans_rho.value().get();
1128 spans_rho_.check_sizes(sizes_indexes);
1130 sizes_indexes.for_each([&](
u64 id,
u32 count) {
1134 spans_rho_.get_spans().get(
id),
1140 [cs0, r0_q, q_, sink_cnt, eos_internal](
1147 Tscal *soundspeed) {
1148 Tvec R_a =
xyz[gid];
1149 Tscal rho_a = rho[gid];
1164 auto &spans_h_ = edges.spans_h.value().get();
1165 spans_h_.check_sizes(sizes_indexes);
1167 sizes_indexes.for_each([&](
u64 id,
u32 count) {
1171 spans_h_.get_spans().get(
id),
1177 [cs0, r0_q, q_, sink_cnt, pmass_, hfactd_, eos_internal](
1184 Tscal *soundspeed) {
1185 using namespace shamrock::sph;
1186 Tvec R_a =
xyz[gid];
1187 Tscal rho_a = rho_h(pmass_, h[gid], hfactd_);
1204 SolverEOS_Fermi *eos_config
1205 = std::get_if<SolverEOS_Fermi>(&solver_config.eos_config.config)) {
1207 auto unit_sys = *solver_config.unit_sys;
1209 Tscal mass = unit_sys.template to<shamunits::units::kilogram>();
1210 Tscal length = unit_sys.template to<shamunits::units::metre>();
1211 Tscal time = unit_sys.template to<shamunits::units::second>();
1213 auto mu_e = shamrock::solvergraph::IDataEdge<Tscal>::make_shared(
"mu_e",
"\\mu_e");
1214 mu_e->data = eos_config->mu_e;
1217 = shamrock::solvergraph::IDataEdge<Tscal>::make_shared(
"density_unit",
"\\rho_u");
1218 density_unit->data = mass / (length * length * length);
1221 = shamrock::solvergraph::IDataEdge<Tscal>::make_shared(
"pressure_unit",
"P_u");
1222 pressure_unit->data = mass / length / (time * time);
1225 = shamrock::solvergraph::IDataEdge<Tscal>::make_shared(
"velocity_unit",
"v_u");
1226 velocity_unit->data = length / time;
1243 SolverEOS_Barotropic *eos_config
1244 = std::get_if<SolverEOS_Barotropic>(&solver_config.eos_config.config)) {
1246 auto cs0 = shamrock::solvergraph::IDataEdge<Tscal>::make_shared(
"cs0",
"c_{s,0}");
1247 auto rho0 = shamrock::solvergraph::IDataEdge<Tscal>::make_shared(
"rho0",
"\\rho_0");
1248 auto gamma0 = shamrock::solvergraph::IDataEdge<Tscal>::make_shared(
"gamma0",
"\\gamma_0");
1249 cs0->data = eos_config->cs0;
1250 rho0->data = eos_config->rho0;
1251 gamma0->data = eos_config->gamma0;
1271template<
class Tvec,
template<
class>
class SPHKernel>
1276 Tscal gpart_mass = solver_config.gpart_mass;
1279 using namespace shamrock::patch;
1286 auto hfactd = shamrock::solvergraph::IDataEdge<Tscal>::make_shared(
"hfactd",
"hfactd");
1287 auto pmass = shamrock::solvergraph::IDataEdge<Tscal>::make_shared(
"pmass",
"pmass");
1289 hfactd->data = Kernel::hfactd;
1290 pmass->data = gpart_mass;
1292 auto sizes = storage.part_counts_with_ghost;
1294 auto h_refs = shamrock::solvergraph::FieldRefs<Tscal>::make_shared(
"",
"");
1296 auto refs = storage.merged_patchdata_ghost.get()
1297 .template map<shamrock::solvergraph::PatchDataFieldRef<Tscal>>(
1300 return mpdat.get_field<Tscal>(ihpart_interf);
1302 h_refs->set_refs(refs);
1305 auto uint_refs = shamrock::solvergraph::FieldRefs<Tscal>::make_shared(
"",
"");
1307 auto refs = storage.merged_patchdata_ghost.get()
1308 .template map<shamrock::solvergraph::PatchDataFieldRef<Tscal>>(
1311 return mpdat.get_field<Tscal>(iuint_interf);
1313 uint_refs->set_refs(refs);
1316 auto dev_sched = shamsys::instance::get_compute_scheduler_ptr();
1318 if (solver_config.dust_config.has_epsilon_field()) {
1321 u32 nvar_dust = solver_config.dust_config.get_dust_nvar();
1323 auto rho_g = std::make_shared<shamrock::solvergraph::Field<Tscal>>(1,
"rho_g",
"rho_g");
1324 auto uint_g = std::make_shared<shamrock::solvergraph::Field<Tscal>>(1,
"uint_g",
"uint_g");
1330 auto refs = storage.merged_patchdata_ghost.get()
1331 .template map<shamrock::solvergraph::PatchDataFieldRef<Tscal>>(
1334 return mpdat.get_field<Tscal>(iepsilon_interf);
1336 epsilon_refs.set_refs(refs);
1343 [pmass = pmass->data, hfactd = hfactd->data, nvar_dust](
1347 const Tscal *epsilon,
1350 using namespace shamrock::sph;
1351 Tscal rho_a = rho_h(pmass, h[gid], hfactd);
1352 Tscal uint_a = uint[gid];
1354 Tscal epsilon_sum = 0;
1355 for (
u32 j = 0; j < nvar_dust; j++) {
1356 epsilon_sum += epsilon[gid * nvar_dust + j];
1359 Tscal rho_g_a = rho_a * (1 - epsilon_sum);
1360 Tscal uint_g_a = uint_a / (1 - epsilon_sum);
1362 rho_g[gid] = rho_g_a;
1363 uint_g[gid] = uint_g_a;
1366 compute_eos_internal(
1374 storage.soundspeed);
1375 }
else if (solver_config.dust_config.has_s_j_field()) {
1378 u32 nvar_dust = solver_config.dust_config.get_dust_nvar();
1380 auto rho_g = std::make_shared<shamrock::solvergraph::Field<Tscal>>(1,
"rho_g",
"rho_g");
1381 auto uint_g = std::make_shared<shamrock::solvergraph::Field<Tscal>>(1,
"uint_g",
"uint_g");
1387 auto refs = storage.merged_patchdata_ghost.get()
1388 .template map<shamrock::solvergraph::PatchDataFieldRef<Tscal>>(
1391 return mpdat.get_field<Tscal>(is_j_interf);
1393 s_j_refs.set_refs(refs);
1400 [pmass = pmass->data, hfactd = hfactd->data, nvar_dust](
1407 using namespace shamrock::sph;
1408 Tscal rho_a = rho_h(pmass, h[gid], hfactd);
1409 Tscal uint_a = uint[gid];
1411 Tscal epsilon_sum = 0;
1412 for (
u32 j = 0; j < nvar_dust; j++) {
1413 Tscal s = s_j[gid * nvar_dust + j];
1414 epsilon_sum += s * s / rho_a;
1417 Tscal rho_g_a = rho_a * (1 - epsilon_sum);
1418 Tscal uint_g_a = uint_a / (1 - epsilon_sum);
1420 rho_g[gid] = rho_g_a;
1421 uint_g[gid] = uint_g_a;
1424 compute_eos_internal(
1432 storage.soundspeed);
1435 compute_eos_internal(
1443 storage.soundspeed);
constexpr const char * xyz
Position field (3D coordinates).
constexpr const char * soundspeed
Sound speed c_s (derived from EOS).
constexpr const char * pressure
Pressure P (derived from EOS).
std::reference_wrapper< PatchDataField< T > > PatchDataFieldRef
Alias for a reference to a PatchDataField.
std::uint32_t u32
32 bit unsigned integer
std::uint64_t u64
64 bit unsigned integer
A buffer allocated in USM (Unified Shared Memory).
A SYCL queue associated with a device and a context.
virtual std::string _impl_get_label() const
get the label of the node
void _impl_evaluate_internal()
evaluate the node
virtual std::string _impl_get_tex() const
get the tex of the node
void _impl_evaluate_internal()
evaluate the node
virtual std::string _impl_get_label() const
get the label of the node
virtual std::string _impl_get_tex() const
get the tex of the node
virtual std::string _impl_get_label() const
get the label of the node
virtual std::string _impl_get_tex() const
get the tex of the node
void _impl_evaluate_internal()
evaluate the node
void _impl_evaluate_internal()
evaluate the node
virtual std::string _impl_get_label() const
get the label of the node
virtual std::string _impl_get_tex() const
get the tex of the node
void _impl_evaluate_internal()
evaluate the node
virtual std::string _impl_get_tex() const
get the tex of the node
virtual std::string _impl_get_label() const
get the label of the node
virtual std::string _impl_get_label() const
get the label of the node
virtual std::string _impl_get_tex() const
get the tex of the node
void _impl_evaluate_internal()
evaluate the node
Module for computing equation of state quantities.
void compute_eos()
Computes pressure and sound speed from equation of state.
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.
virtual DDPatchDataFieldSpanPointer< T > & get_spans()
Get the DistributedData of spans attached to the underlying field.
Interface for a solver graph edge representing a field as spans.
Inode is node between data edges, takes multiple inputs, multiple outputs.
void evaluate()
Evaluate the node.
constexpr Unit h
Planck constant.
This header file contains utility functions related to exception handling in the code.
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.
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...
ExcptTypes make_except_with_loc(std::string message, SourceLocation loc=SourceLocation{})
Create an exception with a message and a location.
void throw_unimplemented(SourceLocation loc=SourceLocation{})
Throw a std::runtime_error saying that the function is unimplemented.
namespace for math utility
namespace for the main framework
Utilities for safe type narrowing conversions.
Helpers to access SPH sink particles stored as SoA synchronized data edges.
#define __shamrock_stack_entry()
Macro to create a stack entry.
shambase::details::NamedBasicStackEntry NamedStackEntry
Alias for shambase::details::NamedBasicStackEntry.
A variant of sham::MultiRef for distributed data.
A class that references multiple buffers or similar objects.
Adiabatic equation of state.
Barotropic equation of state, isothermal at low density and adiabatic at high density (e....
Isothermal equation of state.
Locally isothermal equation of state with radial dependence.
Polytropic equation of state.
The table of units: one constexpr Unit per unit, plus its name registry.