58 using Tscal = shambase::VecComponent<Tvec>;
59 static constexpr u32 dim = shambase::VectorProperties<Tvec>::dimension;
60 using Kernel = SPHKernel<Tscal>;
62 using Solver = Solver<Tvec, SPHKernel>;
63 using SolverConfig =
typename Solver::Config;
84 solver.solver_config.scheduler_conf.split_load_value = crit_split;
85 solver.solver_config.scheduler_conf.merge_load_value = crit_merge;
89 template<std::enable_if_t<dim == 3,
int> = 0>
90 inline Tvec get_box_dim_fcc_3d(Tscal dr,
u32 xcnt,
u32 ycnt,
u32 zcnt) {
91 return generic::setup::generators::get_box_dim(dr, xcnt, ycnt, zcnt);
97 template<std::enable_if_t<dim == 3,
int> = 0>
102 inline void set_cfl_cour(Tscal cfl_cour) {
103 solver.solver_config.cfl_config.cfl_cour = cfl_cour;
105 inline void set_cfl_force(Tscal cfl_force) {
106 solver.solver_config.cfl_config.cfl_force = cfl_force;
108 inline void set_eta_sink(Tscal eta_sink) {
109 solver.solver_config.cfl_config.eta_sink = eta_sink;
112 inline Tscal get_time() {
return solver.get_time(); }
113 inline void set_time(Tscal t) { solver.set_time(t); }
114 inline Tscal get_dt_sph() {
return solver.get_dt_sph(); }
115 inline void set_next_dt(Tscal dt) { solver.set_next_dt(dt); }
116 inline Tscal get_cfl_multipler() {
return solver.get_cfl_multipler(); }
117 inline void set_cfl_multipler(Tscal lambda) { solver.set_cfl_multipler(lambda); }
119 inline void set_particle_mass(Tscal gpart_mass) {
120 solver.solver_config.gpart_mass = gpart_mass;
123 inline Tscal get_particle_mass() {
return solver.solver_config.gpart_mass; }
125 inline void resize_simulation_box(std::pair<Tvec, Tvec> box) {
126 ctx.set_coord_domain_bound({box.first, box.second});
129 SolverConfig gen_config_from_phantom_dump(PhantomDump &phdump,
bool bypass_error);
130 void init_from_phantom_dump(PhantomDump &phdump, Tscal hpart_fact_load = 1.0);
131 PhantomDump make_phantom_dump();
133 void do_vtk_dump(std::string filename,
bool add_patch_world_id) {
134 solver.vtk_do_dump(filename, add_patch_world_id);
137 void set_debug_dump(
bool _do_debug_dump, std::string _debug_dump_filename) {
138 solver.set_debug_dump(_do_debug_dump, _debug_dump_filename);
141 u64 get_total_part_count();
143 f64 total_mass_to_part_mass(
f64 totmass);
145 Tscal get_hfact() {
return Kernel::hfactd; }
147 Tscal rho_h(Tscal h) {
148 return shamrock::sph::rho_h(solver.solver_config.gpart_mass, h, Kernel::hfactd);
151 void add_cube_fcc_3d(Tscal dr, std::pair<Tvec, Tvec> _box);
152 void add_cube_hcp_3d(Tscal dr, std::pair<Tvec, Tvec> _box);
153 void add_cube_hcp_3d_v2(Tscal dr, std::pair<Tvec, Tvec> _box);
155 inline std::unique_ptr<modules::SPHSetup<Tvec, SPHKernel>> get_setup() {
156 return std::make_unique<modules::SPHSetup<Tvec, SPHKernel>>(
157 ctx, solver.solver_config, solver.storage);
179 void add_big_disc_3d(
191 inline void add_sink(Tscal mass, Tvec pos, Tvec velocity, Tscal accretion_radius) {
192 if (!ctx.is_scheduler_initialized()) {
194 "add_sink() requires that the scheduler has been initialized. "
195 "Call init_scheduler(...) before add_sink().");
200 "add_sink() requires that sink edges are registered. "
201 "Call init_scheduler(...) before add_sink().");
205 shamlog_debug_ln(
"SPH",
"add sink :", mass, pos, velocity, accretion_radius);
215 auto &dust_config = solver.solver_config.dust_config;
216 return dust_config.is_monofluid_tva() ? dust_config.get_dust_nvar() : 0;
232 get_sink_accreted_dust_mass<Tvec>(sync),
238 inline void set_field_value_lambda(
239 std::string field_name,
const std::function<T(Tvec)> pos_to_val,
const u32 offset) {
253 auto f_nvar = f.get_nvar();
254 if (offset >= f_nvar) {
256 "offset ({}) is out of bounds for field '{}' with nvar {}",
262 auto acc = f.get_buf().copy_to_stdvec();
263 auto acc_xyz = xyz.get_buf().copy_to_stdvec();
266 for (
u32 i = 0; i < obj_cnt; i++) {
267 acc[i * f_nvar + offset] = pos_to_val(acc_xyz[i]);
270 f.get_buf().copy_from_stdvec(acc);
275 inline void overwrite_field_value(
276 std::string field_name,
277 const std::function<std::vector<T>(shamrock::PatchDataLazyGetter &)> field_compute,
287 [&](
u64 patch_id, shamrock::patch::PatchDataLayer &pdat) {
288 PatchDataField<T> &f = pdat.template get_field<T>(ifield);
290 auto f_nvar = f.get_nvar();
291 if (offset >= f_nvar) {
293 "offset ({}) is out of bounds for field '{}' with nvar {}",
299 shamrock::PatchDataLazyGetter getter(pdat);
300 auto result = field_compute(getter);
302 if (result.size() != f.get_obj_cnt()) {
304 "result.size() != f.get_obj_cnt() ({} != {})",
309 auto acc = f.get_buf().copy_to_stdvec();
312 for (
u32 i = 0; i < obj_cnt; i++) {
313 acc[i * f_nvar + offset] = result[i];
316 f.get_buf().copy_from_stdvec(acc);
334 template<std::enable_if_t<dim == 3,
int> = 0>
346 Tscal G = solver.solver_config.get_constant_G();
349 using Config = SolverConfig;
350 using SolverConfigEOS =
typename Config::EOSConfig;
351 using SolverEOS_Adiabatic =
typename SolverConfigEOS::Adiabatic;
352 if (SolverEOS_Adiabatic *eos_config
353 = std::get_if<SolverEOS_Adiabatic>(&solver.solver_config.eos_config.config)) {
355 eos_gamma = eos_config->gamma;
365 auto sigma_profile = [=](Tscal r) {
367 constexpr Tscal sigma_0 = 1;
368 return sigma_0 * sycl::pow(r / r_in, -p);
371 auto cs_law = [=](Tscal r) {
372 return sycl::pow(r / r_in, -q);
375 auto rot_profile = [=](Tscal r) {
376 return sycl::sqrt(G * central_mass / r);
379 Tscal cs_in = H_r_in * rot_profile(r_in);
380 auto cs_profile = [&](Tscal r) {
381 return cs_law(r) * cs_in;
384 std::vector<Out> part_list;
391 return sigma_profile(r);
394 return cs_profile(r);
397 return rot_profile(r);
400 part_list.push_back(out);
403 Tscal part_mass = disc_mass / Npart;
405 using namespace shamrock::patch;
409 std::string log =
"";
416 std::vector<Tvec> vec_pos;
417 std::vector<Tvec> vec_vel;
418 std::vector<Tscal> vec_u;
419 std::vector<Tscal> vec_h;
421 std::vector<Tscal> vec_cs;
423 Tscal G = solver.solver_config.get_constant_G();
425 for (Out o : part_list) {
426 vec_pos.push_back(o.pos + center);
427 vec_vel.push_back(o.velocity);
433 vec_u.push_back(o.cs * o.cs / ( (eos_gamma - 1)));
434 vec_h.push_back(shamrock::sph::h_rho(part_mass, o.rho, Kernel::hfactd));
435 vec_cs.push_back(o.cs);
439 "\n patch id={}, add N={} particles", ptch.
id_patch, vec_pos.size());
442 tmp.resize(vec_pos.size());
446 u32 len = vec_pos.size();
448 = tmp.get_field<Tvec>(sched.pdl_old().get_field_idx<Tvec>(
"xyz"));
449 f.override(vec_pos, len);
453 u32 len = vec_pos.size();
455 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"hpart"));
456 f.override(vec_h, len);
460 u32 len = vec_pos.size();
462 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"uint"));
463 f.override(vec_u, len);
466 if (solver.solver_config.is_eos_locally_isothermal()) {
467 u32 len = vec_pos.size();
469 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"soundspeed"));
470 f.override(vec_cs, len);
474 u32 len = vec_pos.size();
476 = tmp.get_field<Tvec>(sched.pdl_old().get_field_idx<Tvec>(
"vxyz"));
477 f.override(vec_vel, len);
480 pdat.insert_elements(tmp);
483 std::string log_gathered =
"";
491 ctx, solver.solver_config, solver.storage)
492 .update_load_balancing();
497 auto [m, M] = sched.get_box_tranform<Tvec>();
512 sched.check_patchdata_locality_correctness();
519 "\n patch id={}, N={} particles", p.id_patch, pdat.
get_obj_cnt());
530 template<std::enable_if_t<dim == 3,
int> = 0>
531 inline void add_cube_disc_3d(
544 using SolverConfigEOS =
typename Config::EOSConfig;
545 using SolverEOS_Adiabatic =
typename SolverConfigEOS::Adiabatic;
546 if (SolverEOS_Adiabatic *eos_config
547 = std::get_if<SolverEOS_Adiabatic>(&solver.solver_config.eos_config.config)) {
549 eos_gamma = eos_config->gamma;
555 auto cs = [&](Tscal u) {
556 return sycl::sqrt(eos_gamma * (eos_gamma - 1) * u);
559 auto U = [&](Tscal cs) {
560 return cs * cs / (eos_gamma * (eos_gamma - 1));
563 using namespace shamrock::patch;
567 std::string log =
"";
569 sched.for_each_local_patchdata([&](
const Patch &ptch, PatchDataLayer &pdat) {
572 shammath::CoordRange<Tvec> patch_coord = ptransf.to_obj_coord(ptch);
574 std::vector<Tvec> vec_acc;
575 std::vector<Tvec> vec_vel;
576 std::vector<Tscal> vec_u;
578 Tscal G = solver.solver_config.get_constant_G();
581 Npart, p, rho_0, m, r_in, r_out, q, [&](Tvec r, Tscal h) {
582 vec_acc.push_back(r + center);
584 Tscal R = sycl::length(r);
586 Tscal V = sycl::sqrt(G * cmass / R);
588 Tvec etheta = {-r.z(), 0, r.x()};
589 etheta /= sycl::length(etheta);
591 vec_vel.push_back(V * etheta);
594 Tscal cs = cs0 * sycl::pow(R, -q);
596 vec_u.push_back(U(cs));
600 "\n patch id={}, add N={} particles", ptch.
id_patch, vec_acc.size());
602 PatchDataLayer tmp(sched.get_layout_ptr_old());
603 tmp.resize(vec_acc.size());
607 u32 len = vec_acc.size();
608 PatchDataField<Tvec> &f
609 = tmp.get_field<Tvec>(sched.pdl_old().get_field_idx<Tvec>(
"xyz"));
610 f.override(vec_acc, len);
614 PatchDataField<Tscal> &f
615 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"hpart"));
620 u32 len = vec_acc.size();
621 PatchDataField<Tscal> &f
622 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"uint"));
623 f.override(vec_u, len);
627 u32 len = vec_acc.size();
628 PatchDataField<Tvec> &f
629 = tmp.get_field<Tvec>(sched.pdl_old().get_field_idx<Tvec>(
"vxyz"));
630 f.override(vec_vel, len);
633 pdat.insert_elements(tmp);
636 std::string log_gathered =
"";
640 logger::info_ln(
"Model",
"Push particles : ", log_gathered);
643 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(
644 ctx, solver.solver_config, solver.storage)
645 .update_load_balancing();
650 auto [m, M] = sched.get_box_tranform<Tvec>();
652 SerialPatchTree<Tvec> sptree(
657 shamrock::ReattributeDataUtility reatrib(sched);
662 reatrib.reatribute_patch_objects(sptree,
"xyz");
665 sched.check_patchdata_locality_correctness();
670 sched.for_each_local_patchdata([&](
const Patch &p, PatchDataLayer &pdat) {
679 logger::info_ln(
"Model",
"current particle counts : ", log_gathered);
682 void remap_positions(std::function<Tvec(Tvec)> map);
685 std::vector<Tvec> &part_pos_insert,
686 std::vector<Tscal> &part_hpart_insert,
687 std::vector<Tscal> &part_u_insert);
689 void push_particle_mhd(
690 std::vector<Tvec> &part_pos_insert,
691 std::vector<Tscal> &part_hpart_insert,
692 std::vector<Tscal> &part_u_insert,
693 std::vector<Tvec> &part_B_on_rho_insert,
694 std::vector<Tscal> &part_psi_on_ch_insert);
697 inline void set_value_in_a_box(
698 std::string field_name, T val, std::pair<Tvec, Tvec> box,
u32 ivar) {
702 [&](
u64 patch_id, shamrock::patch::PatchDataLayer &pdat) {
703 PatchDataField<Tvec> &
xyz
704 = pdat.template get_field<Tvec>(sched.pdl_old().
get_field_idx<Tvec>(
"xyz"));
707 = pdat.template get_field<T>(sched.pdl_old().
get_field_idx<T>(field_name));
709 if (ivar >= f.get_nvar()) {
711 "You are trying to set value in a box for field ({}) with "
712 "ivar ({}) >= f.get_nvar ({})",
718 u32 nvar = f.get_nvar();
721 auto acc = f.get_buf().template mirror_to<sham::host>();
722 auto acc_xyz =
xyz.get_buf().template mirror_to<sham::host>();
724 for (
u32 i = 0; i < f.get_obj_cnt(); i++) {
727 if (BBAA::is_coord_in_range(r, std::get<0>(box), std::get<1>(box))) {
728 acc[i * nvar + ivar] = val;
736 inline void set_value_in_sphere(std::string field_name, T val, Tvec center, Tscal radius) {
740 [&](
u64 patch_id, shamrock::patch::PatchDataLayer &pdat) {
741 PatchDataField<Tvec> &
xyz
742 = pdat.template get_field<Tvec>(sched.pdl_old().
get_field_idx<Tvec>(
"xyz"));
745 = pdat.template get_field<T>(sched.pdl_old().
get_field_idx<T>(field_name));
747 if (f.get_nvar() != 1) {
751 Tscal r2 = radius * radius;
753 auto acc = f.get_buf().template mirror_to<sham::host>();
754 auto acc_xyz =
xyz.get_buf().template mirror_to<sham::host>();
756 for (
u32 i = 0; i < f.get_obj_cnt(); i++) {
757 Tvec dr = acc_xyz[i] - center;
759 if (sycl::dot(dr, dr) < r2) {
768 inline void add_kernel_value(std::string field_name, T val, Tvec center, Tscal h_ker) {
772 [&](
u64 patch_id, shamrock::patch::PatchDataLayer &pdat) {
773 PatchDataField<Tvec> &
xyz
774 = pdat.template get_field<Tvec>(sched.pdl_old().
get_field_idx<Tvec>(
"xyz"));
777 = pdat.template get_field<T>(sched.pdl_old().
get_field_idx<T>(field_name));
779 if (f.get_nvar() != 1) {
784 auto acc = f.get_buf().template mirror_to<sham::host>();
785 auto acc_xyz =
xyz.get_buf().template mirror_to<sham::host>();
787 for (
u32 i = 0; i < f.get_obj_cnt(); i++) {
788 Tvec dr = acc_xyz[i] - center;
790 Tscal r = sycl::length(dr);
792 acc[i] += val * Kernel::W_3d(r, h_ker);
799 inline T get_sum(std::string name) {
801 T sum = shambase::VectorProperties<T>::get_zero();
805 [&](
u64 patch_id, shamrock::patch::PatchDataLayer &pdat) {
806 PatchDataField<T> &
xyz
807 = pdat.template get_field<T>(sched.pdl_old().
get_field_idx<T>(name));
809 sum +=
xyz.compute_sum();
812 return shamalgs::collective::allreduce_sum(sum);
815 Tvec get_closest_part_to(Tvec pos);
817 inline void apply_momentum_offset(Tvec offset) {
826 sched.for_each_patchdata_nonempty(
827 [&](shamrock::patch::Patch p, shamrock::patch::PatchDataLayer &pdat) {
828 tot_mass += solver.solver_config.gpart_mass * pdat.
get_obj_cnt();
831 tot_mass = shamalgs::collective::allreduce_sum(tot_mass);
835 auto &mass = get_sink_mass<Tvec>(sync);
837 for (
size_t i = 0; i < mass.size(); i++) {
843 Tvec offset_vel = (tot_mass > 0) ? (offset / tot_mass)
844 : shambase::VectorProperties<Tvec>::get_zero();
847 auto &vel = get_sink_vel<Tvec>(sync);
849 for (
size_t i = 0; i < vel.size(); i++) {
850 vel[i] += offset_vel;
855 sched.for_each_patchdata_nonempty(
856 [&](shamrock::patch::Patch p, shamrock::patch::PatchDataLayer &pdat) {
857 PatchDataField<Tvec> &
vxyz = pdat.get_field<Tvec>(ivxyz);
858 vxyz.apply_offset(offset_vel);
862 inline void apply_position_offset(Tvec offset) {
871 for (
size_t i = 0; i < pos.size(); i++) {
877 sched.for_each_patchdata_nonempty(
878 [&](shamrock::patch::Patch p, shamrock::patch::PatchDataLayer &pdat) {
879 PatchDataField<Tvec> &
xyz = pdat.get_field<Tvec>(ixyz);
880 xyz.apply_offset(offset);
892 inline void set_solver_config(
typename Solver::Config cfg) {
893 if (ctx.is_scheduler_initialized()) {
895 "Cannot change solver config after scheduler is initialized");
898 solver.solver_config = cfg;
901 inline f64 solver_logs_last_rate() {
return solver.solve_logs.get_last_rate(); }
902 inline u64 solver_logs_last_obj_count() {
return solver.solve_logs.get_last_obj_count(); }
903 inline f64 solver_logs_cumulated_step_time() {
904 return solver.solve_logs.get_cumulated_step_time();
906 inline void solver_logs_reset_cumulated_step_time() {
907 solver.solve_logs.reset_cumulated_step_time();
909 inline u64 solver_logs_step_count() {
return solver.solve_logs.get_step_count(); }
910 inline void solver_logs_reset_step_count() { solver.solve_logs.reset_step_count(); }
912 inline void change_htolerances(Tscal in_coarse, Tscal in_fine) {
913 if (in_coarse < in_fine) {
915 "in_coarse ({}) must be greater than in_fine ({})", in_coarse, in_fine));
917 solver.solver_config.htol_up_coarse_cycle = in_coarse;
918 solver.solver_config.htol_up_fine_cycle = in_fine;
940 std::string metadata_user{};
944 nlohmann::json j = nlohmann::json::parse(metadata_user);
946 j.at(
"solver_config").get_to(solver.solver_config);
955 solver.init_ghost_layout();
957 solver.init_solver_graph();
960 if (!had_time_edge) {
961 if (j.at(
"solver_config").contains(
"time_state")) {
965 "Migrated time/dt/cfl from solver_config.time_state into scheduler "
967 const auto &ts = j.at(
"solver_config").at(
"time_state");
968 solver.set_time(ts.at(
"time").get<Tscal>());
969 solver.set_next_dt(ts.at(
"dt_sph").get<Tscal>());
970 solver.set_cfl_multipler(ts.at(
"cfl_multiplier").get<Tscal>());
973 "this should never happen: dump has neither time edges nor "
974 "solver_config.time_state");
980 if (j.contains(
"sinks") && !j.at(
"sinks").is_null()) {
981 std::vector<SinkParticle<Tvec>> out;
982 j.at(
"sinks").get_to(out);
990 shamlog_debug_ln(
"Sys",
"build local scheduler tables");
1004 inline void dump(std::string fname) {
1009 solver.update_sync_load_values();
1011 nlohmann::json metadata;
1012 metadata[
"solver_config"] = solver.solver_config;
1024 f64 evolve_once_time_expl(
f64 t_curr,
f64 dt_input);
1028 inline void evolve_once() {
1029 solver.evolve_once();
1030 solver.print_timestep_logs();
1033 inline EvolveUntilResults evolve_until(
1034 Tscal target_time,
i32 niter_max,
f64 max_walltime = -1) {
1035 return solver.evolve_until(target_time, niter_max, max_walltime);
1039 void add_pdat_to_phantom_block(
1042 template<
class Tscal>
1043 inline void warp_disc(
1044 std::vector<Tvec> &pos,
1045 std::vector<Tvec> &vel,
1050 Tvec k = Tvec(-std::sin(posangle), std::cos(posangle), 0.);
1053 u32 len = pos.size();
1056 Tscal incl_rad = incl * shambase::constants::pi<Tscal> / 180.;
1058 for (
i32 i = 0; i < len; i++) {
1059 Tvec R_vec = pos[i];
1060 Tscal R = sycl::sqrt(sycl::dot(R_vec, R_vec));
1061 if (R < Rwarp - Hwarp) {
1063 }
else if (R < Rwarp + 3. * Hwarp && R > Rwarp - Hwarp) {
1067 + sycl::sin(shambase::constants::pi<Tscal> / (2. * Hwarp) * (R - Rwarp)))
1068 * sycl::sin(incl_rad));
1069 psi = shambase::constants::pi<Tscal>
1070 * Rwarp / (4. * Hwarp) * sycl::sin(incl_rad)
1071 / sycl::sqrt(1. - (0.5 * sycl::pow(sycl::sin(incl_rad), 2)));
1072 Tscal psimax = sycl::max(psimax, psi);
1073 Tscal x = pos[i].x();
1074 Tscal y = pos[i].y();
1075 Tscal z = pos[i].z();
1081 Tvec kk = Tvec(0., 0., 1.);
1082 Tvec w = sycl::cross(kk, pos[i]);
1084 pos[i] = pos[i] * sycl::cos(inc) + w * sycl::sin(inc)
1085 + kk * sycl::dot(kk, pos[i]) * (1. - sycl::cos(inc));
1093 inline void rotate_vector(Tvec &u, Tvec &v, Tscal theta) {
1095 Tvec vunit = v / sycl::sqrt(sycl::dot(v, v));
1096 Tvec w = sycl::cross(vunit, u);
1098 u = u * sycl::cos(theta) + w * sycl::sin(theta)
1099 + vunit * sycl::dot(vunit, u) * (1. - sycl::cos(theta));