45template<
class Tvec,
template<
class>
class SPHKernel>
46f64 shammodels::sph::Model<Tvec, SPHKernel>::evolve_once_time_expl(
f64 t_curr,
f64 dt_input) {
47 auto tmp = solver.evolve_once_time_expl(t_curr, dt_input);
48 solver.print_timestep_logs();
52template<
class Tvec,
template<
class>
class SPHKernel>
54 return solver.evolve_once();
57template<
class Tvec,
template<
class>
class SPHKernel>
60 if (solver.solver_config.scheduler_conf.split_load_value == 0) {
62 "Scheduler load value should be greater than 0");
65 solver.init_required_fields();
67 solver.solver_config.scheduler_conf.split_load_value,
68 solver.solver_config.scheduler_conf.merge_load_value);
70 using namespace shamrock::patch;
76 shamlog_debug_ln(
"Sys",
"build local scheduler tables");
82 solver.init_ghost_layout();
84 solver.init_solver_graph();
91template<
class Tvec,
template<
class>
class SPHKernel>
92u64 shammodels::sph::Model<Tvec, SPHKernel>::get_total_part_count() {
94 return shamalgs::collective::allreduce_sum(sched.get_rank_count());
97template<
class Tvec,
template<
class>
class SPHKernel>
98f64 shammodels::sph::Model<Tvec, SPHKernel>::total_mass_to_part_mass(
f64 totmass) {
99 return totmass / get_total_part_count();
102template<
class Tvec,
template<
class>
class SPHKernel>
103auto shammodels::sph::Model<Tvec, SPHKernel>::get_closest_part_to(Tvec pos) -> Tvec {
106 using namespace shamrock::patch;
108 Tvec best_dr = shambase::VectorProperties<Tvec>::get_max();
109 Tscal best_dist2 = shambase::VectorProperties<Tscal>::get_max();
114 auto acc = pdat.get_field<Tvec>(0).get_buf().copy_to_stdvec();
118 for (
u32 i = 0; i < cnt; i++) {
121 Tscal dist2 = sycl::dot(dr, dr);
122 if (dist2 < best_dist2) {
129 std::vector<Tvec> list_dr{};
136 best_dr = shambase::VectorProperties<Tvec>::get_max();
137 best_dist2 = shambase::VectorProperties<Tscal>::get_max();
139 for (Tvec tmp : list_dr) {
141 Tscal dist2 = sycl::dot(dr, dr);
142 if (dist2 < best_dist2) {
148 return pos + best_dr;
151template<
class Tvec,
template<
class>
class SPHKernel>
152void shammodels::sph::Model<Tvec, SPHKernel>::remap_positions(std::function<Tvec(Tvec)> map) {
155 using namespace shamrock::patch;
159 auto &
xyz = pdat.get_field<Tvec>(0).get_buf();
160 auto acc =
xyz.copy_to_stdvec();
164 for (
u32 i = 0; i < cnt; i++) {
165 acc[i] = map(acc[i]);
168 xyz.copy_from_stdvec(acc);
171 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
172 .update_load_balancing();
181 reatrib.reatribute_patch_objects(sptree,
"xyz");
182 sched.check_patchdata_locality_correctness();
185 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
186 .update_load_balancing();
196 reatrib.reatribute_patch_objects(sptree,
"xyz");
197 sched.check_patchdata_locality_correctness();
214 auto [m, M] = sched.get_box_tranform<Tvec>();
222 reatrib.reatribute_patch_objects(sptree,
"xyz");
223 sched.check_patchdata_locality_correctness();
235 reatrib.reatribute_patch_objects(sptree,
"xyz");
236 sched.check_patchdata_locality_correctness();
239 std::string log =
"";
241 using namespace shamrock::patch;
244 u32 largest_count = 0;
248 smallest_count = sham::min(tmp, smallest_count);
249 largest_count = sham::max(tmp, largest_count);
252 smallest_count = shamalgs::collective::allreduce_min(smallest_count);
253 largest_count = shamalgs::collective::allreduce_max(largest_count);
257 "Model",
"current particle counts : min = ", smallest_count,
"max = ", largest_count);
272template<
class Tvec,
template<
class>
class SPHKernel>
273void shammodels::sph::Model<Tvec, SPHKernel>::push_particle(
274 std::vector<Tvec> &part_pos_insert,
275 std::vector<Tscal> &part_hpart_insert,
276 std::vector<Tscal> &part_u_insert) {
279 using namespace shamrock::patch;
283 std::string log =
"";
290 std::vector<Tvec> vec_acc;
291 std::vector<Tscal> hpart_acc;
292 std::vector<Tscal> u_acc;
293 for (
u32 i = 0; i < part_pos_insert.size(); i++) {
294 Tvec r = part_pos_insert[i];
295 Tscal u = part_u_insert[i];
296 if (patch_coord.contain_pos(r)) {
297 vec_acc.push_back(r);
298 hpart_acc.push_back(part_hpart_insert[i]);
303 if (vec_acc.size() == 0) {
308 "\n rank = {} patch id={}, add N={} particles, coords = {} {}",
316 tmp.resize(vec_acc.size());
320 u32 len = vec_acc.size();
322 = tmp.get_field<Tvec>(sched.pdl_old().get_field_idx<Tvec>(
"xyz"));
323 f.override(vec_acc, len);
327 u32 len = vec_acc.size();
329 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"hpart"));
330 f.override(hpart_acc, len);
334 u32 len = u_acc.size();
336 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"uint"));
337 f.override(u_acc, len);
340 pdat.insert_elements(tmp);
342 sched.check_patchdata_locality_correctness();
344 std::string log_gathered =
"";
352 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
353 .update_load_balancing();
355 post_insert_data<Tvec>(sched);
359template<
class Tvec,
template<
class>
class SPHKernel>
360void shammodels::sph::Model<Tvec, SPHKernel>::push_particle_mhd(
361 std::vector<Tvec> &part_pos_insert,
362 std::vector<Tscal> &part_hpart_insert,
363 std::vector<Tscal> &part_u_insert,
364 std::vector<Tvec> &part_B_on_rho_insert,
365 std::vector<Tscal> &part_psi_on_ch_insert) {
368 using namespace shamrock::patch;
372 std::string log =
"";
379 std::vector<Tvec> vec_acc;
380 std::vector<Tscal> hpart_acc;
381 std::vector<Tscal> u_acc;
382 std::vector<Tvec> B_on_rho_acc;
383 std::vector<Tscal> psi_on_ch_acc;
384 for (
u32 i = 0; i < part_pos_insert.size(); i++) {
385 Tvec r = part_pos_insert[i];
386 Tscal u = part_u_insert[i];
387 if (patch_coord.contain_pos(r)) {
388 vec_acc.push_back(r);
389 hpart_acc.push_back(part_hpart_insert[i]);
391 B_on_rho_acc.push_back(part_B_on_rho_insert[i]);
392 psi_on_ch_acc.push_back(part_psi_on_ch_insert[i]);
396 if (vec_acc.size() == 0) {
401 "\n rank = {} patch id={}, add N={} particles, coords = {} {}",
409 tmp.resize(vec_acc.size());
413 u32 len = vec_acc.size();
415 = tmp.get_field<Tvec>(sched.pdl_old().get_field_idx<Tvec>(
"xyz"));
416 f.override(vec_acc, len);
420 u32 len = vec_acc.size();
422 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"hpart"));
423 f.override(hpart_acc, len);
427 u32 len = u_acc.size();
429 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"uint"));
430 f.override(u_acc, len);
434 u32 len = vec_acc.size();
436 = tmp.get_field<Tvec>(sched.pdl_old().get_field_idx<Tvec>(
"B/rho"));
437 f.override(B_on_rho_acc, len);
441 u32 len = vec_acc.size();
443 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"psi/ch"));
444 f.override(psi_on_ch_acc, len);
447 pdat.insert_elements(tmp);
449 sched.check_patchdata_locality_correctness();
451 std::string log_gathered =
"";
459 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
460 .update_load_balancing();
462 post_insert_data<Tvec>(sched);
466template<
class Tvec,
template<
class>
class SPHKernel>
467void shammodels::sph::Model<Tvec, SPHKernel>::add_cube_hcp_3d(
468 Tscal dr, std::pair<Tvec, Tvec> _box) {
476 using namespace shamrock::patch;
483 auto [idxs_min, idxs_max] = Lattice::get_box_index_bounds(dr, box.lower, box.upper);
485 LatticeIter gen = LatticeIter(dr, idxs_min, idxs_max);
489 std::string log =
"";
490 while (!gen.is_done()) {
493 u64 loc_sum_ins_cnt = 0;
495 u64 max_loc_sum_ins_cnt = 0;
499 acc_count += to_ins.size();
506 std::vector<Tvec> vec_acc;
507 for (Tvec r : to_ins) {
508 if (patch_coord.contain_pos(r)) {
509 vec_acc.push_back(r);
514 loc_sum_ins_cnt += vec_acc.size();
516 if (vec_acc.size() == 0) {
521 "\n rank = {} patch id={}, add N={} particles, coords = {} {}",
529 pdat.reserve(vec_acc.size());
532 tmp.resize(vec_acc.size());
536 u32 len = vec_acc.size();
538 = tmp.get_field<Tvec>(sched.pdl_old().get_field_idx<Tvec>(
"xyz"));
540 f.override(vec_acc, len);
545 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"hpart"));
549 pdat.insert_elements(tmp);
552 max_loc_sum_ins_cnt = shamalgs::collective::allreduce_max(loc_sum_ins_cnt);
557 "--> insertion loop : max loc insert count = ",
562 }
while (!gen.is_done() && max_loc_sum_ins_cnt < sched.
crit_patch_split * 8);
564 sched.check_patchdata_locality_correctness();
576 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
577 .update_load_balancing();
578 post_insert_data<Tvec>(sched);
582 modules::ParticleReordering<Tvec, u32, SPHKernel>(ctx, solver.solver_config, solver.storage)
583 .reorder_particles();
592template<
class Tvec,
template<
class>
class SPHKernel>
593void shammodels::sph::Model<Tvec, SPHKernel>::add_cube_hcp_3d_v2(
594 Tscal dr, std::pair<Tvec, Tvec> _box) {
600 using namespace shamrock::patch;
607 auto [idxs_min, idxs_max] = Lattice::get_box_index_bounds(dr, box.lower, box.upper);
609 LatticeIter gen = LatticeIter(dr, idxs_min, idxs_max);
613 auto push_current_data = [&](std::vector<Tvec> pos_data) {
615 tmp.resize(pos_data.size());
619 u32 len = pos_data.size();
621 = tmp.get_field<Tvec>(sched.pdl_old().get_field_idx<Tvec>(
"xyz"));
623 f.override(pos_data, len);
628 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"hpart"));
632 inserter.push_patch_data<Tvec>(tmp,
"xyz", sched.
crit_patch_split * 8, [&]() {
633 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(
634 ctx, solver.solver_config, solver.storage)
635 .update_load_balancing();
644 auto has_pdat = [&]() {
653 while (!gen.is_done()) {
655 u64 loc_gen_count = (has_pdat()) ? insert_step : 0;
657 auto gen_info = shamalgs::collective::fetch_view(loc_gen_count);
659 u64 skip_start = gen_info.head_offset;
660 u64 gen_cnt = loc_gen_count;
661 u64 skip_end = gen_info.total_byte_count - loc_gen_count - gen_info.head_offset;
670 skip_start + gen_cnt + skip_end);
671 gen.skip(skip_start);
672 auto tmp = gen.next_n(gen_cnt);
675 std::vector<Tvec> pos_data;
678 pos_data.push_back(r);
682 push_current_data(pos_data);
684 shamlog_debug_ln(
"Gen",
"gen.is_done()", gen.is_done());
696 using Tscal = shambase::VecComponent<Tvec>;
716 std::function<Tscal(Tscal)> sigma_profile;
717 std::function<Tscal(Tscal)> cs_profile;
718 std::function<Tscal(Tscal)> rot_profile;
719 std::function<Tscal(Tscal)> vel_full_corr;
734 std::function<Tscal(Tscal)> sigma_profile,
735 std::function<Tscal(Tscal)> cs_profile,
736 std::function<Tscal(Tscal)> rot_profile)
737 : current_index(0), Npart(Npart), center(center), central_mass(central_mass),
738 r_in(r_in), r_out(r_out), disc_mass(disc_mass), p(p), H_r_in(H_r_in), q(q), G(G),
739 eng(eng), sigma_profile(sigma_profile), cs_profile(cs_profile),
740 rot_profile(rot_profile) {
747 inline bool is_done() {
return done; }
751 constexpr Tscal _2pi = 2 * shambase::constants::pi<Tscal>;
753 auto f_func = [&](Tscal r) {
754 return r * sigma_profile(r);
757 Tscal fmax = f_func(r_out);
759 auto find_r = [&]() {
763 if (u2 < f_func(r)) {
770 auto Gauss = shamalgs::random::mock_gaussian<Tscal>(eng);
775 Tscal vk = rot_profile(r);
776 Tscal cs = cs_profile(r);
777 Tscal sigma = sigma_profile(r);
779 Tscal Omega_Kep = sycl::sqrt(G * central_mass / (r * r * r));
783 Tscal H = sycl::sqrt(2.) * 3. * cs
788 auto pos = sycl::vec<Tscal, 3>{r * sycl::cos(theta), z, r * sycl::sin(theta)};
790 auto etheta = sycl::vec<Tscal, 3>{-pos.z(), 0, pos.x()};
791 etheta /= sycl::length(etheta);
793 auto vel = vk * etheta;
798 Tscal fs = 1. - sycl::sqrt(r_in / r);
799 Tscal rho = (sigma * fs) * sycl::exp(-z * z / (2 * H * H));
801 Out out{pos, vel, cs, rho};
805 if (current_index == Npart) {
812 inline std::vector<Out> next_n(
u32 nmax) {
813 std::vector<Out> ret{};
814 for (
u32 i = 0; i < nmax; i++) {
819 ret.push_back(next());
826template<
class Tvec,
template<
class>
class SPHKernel>
827void shammodels::sph::Model<Tvec, SPHKernel>::add_big_disc_3d(
840 using Config = SolverConfig;
841 using SolverConfigEOS =
typename Config::EOSConfig;
842 using SolverEOS_Adiabatic =
typename SolverConfigEOS::Adiabatic;
843 if (SolverEOS_Adiabatic *eos_config
844 = std::get_if<SolverEOS_Adiabatic>(&solver.solver_config.eos_config.config)) {
846 eos_gamma = eos_config->gamma;
854 auto sigma_profile = [=](Tscal r) {
856 constexpr Tscal sigma_0 = 1;
857 return sigma_0 * sycl::pow(r / r_in, -p);
860 auto cs_law = [=](Tscal r) {
861 return sycl::pow(r / r_in, -q);
864 auto kep_profile = [&](Tscal r) {
865 Tscal G = solver.solver_config.get_constant_G();
866 return sycl::sqrt(G * central_mass / r);
869 auto rot_profile = [&](Tscal r) -> Tscal {
871 Tscal G = solver.solver_config.get_constant_G();
872 Tscal c = solver.solver_config.get_constant_c();
874 Tscal term = G * central_mass / r;
875 Tscal term_fs = 1. - sycl::sqrt(r_in / r);
877 = -sycl::pown(cs_law(r), 2) * (1.5 + p + q);
879 Tscal det = sycl::pown(term_bh, 2) + 4. * (term + term_pr);
880 Tscal Rg = G * central_mass / sycl::pown(c, 2);
881 Tscal vkep = sqrt(G * central_mass / r);
883 Tscal vphi = 0.5 * (term_bh + sycl::sqrt(det));
888 auto cs_profile = [&](Tscal r) {
889 Tscal cs_in = (H_r_in * r_in / r) * kep_profile(r_in);
890 return cs_law(r) * cs_in;
893 auto get_hfact = []() -> Tscal {
894 return Kernel::hfactd;
897 auto int_rho_h = [&](Tscal
h) -> Tscal {
898 return shamrock::sph::rho_h(solver.solver_config.gpart_mass, h, Kernel::hfactd);
901 Tscal part_mass = disc_mass / Npart;
908 using namespace shamrock::patch;
915 Tscal G = solver.solver_config.get_constant_G();
934 std::string log =
"";
935 while (!gen.is_done()) {
938 u64 loc_sum_ins_cnt = 0;
940 u64 max_loc_sum_ins_cnt = 0;
944 acc_count += to_ins.size();
951 std::vector<Out> part_list;
952 for (Out r : to_ins) {
953 if (patch_coord.contain_pos(r.pos)) {
955 part_list.push_back(r);
960 loc_sum_ins_cnt += part_list.size();
962 if (part_list.size() == 0) {
967 "\n rank = {} patch id={}, add N={} particles, coords = {} {}",
975 std::vector<Tvec> vec_pos;
976 std::vector<Tvec> vec_vel;
977 std::vector<Tscal> vec_u;
978 std::vector<Tscal> vec_h;
979 std::vector<Tscal> vec_cs;
981 for (Out o : part_list) {
982 vec_pos.push_back(o.pos);
983 vec_vel.push_back(o.velocity);
984 vec_u.push_back(o.cs * o.cs / ( (eos_gamma - 1)));
985 vec_h.push_back(shamrock::sph::h_rho(part_mass, o.rho * 0.1, Kernel::hfactd));
986 vec_cs.push_back(o.cs);
990 pdat.reserve(vec_pos.size());
993 tmp.resize(vec_pos.size());
997 u32 len = vec_pos.size();
999 = tmp.get_field<Tvec>(sched.pdl_old().get_field_idx<Tvec>(
"xyz"));
1000 f.override(vec_pos, len);
1004 u32 len = vec_pos.size();
1006 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"hpart"));
1007 f.override(vec_h, len);
1011 u32 len = vec_pos.size();
1013 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"uint"));
1014 f.override(vec_u, len);
1017 if (solver.solver_config.is_eos_locally_isothermal()) {
1018 u32 len = vec_pos.size();
1020 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"soundspeed"));
1021 f.override(vec_cs, len);
1025 u32 len = vec_pos.size();
1027 = tmp.get_field<Tvec>(sched.pdl_old().get_field_idx<Tvec>(
"vxyz"));
1028 f.override(vec_vel, len);
1031 pdat.insert_elements(tmp);
1034 max_loc_sum_ins_cnt = shamalgs::collective::allreduce_max(loc_sum_ins_cnt);
1039 "--> insertion loop : max loc insert count = ",
1040 max_loc_sum_ins_cnt,
1044 }
while (!gen.is_done() && max_loc_sum_ins_cnt < sched.
crit_patch_split * 8);
1046 sched.check_patchdata_locality_correctness();
1058 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
1059 .update_load_balancing();
1060 post_insert_data<Tvec>(sched);
1064 modules::ParticleReordering<Tvec, u32, SPHKernel>(ctx, solver.solver_config, solver.storage)
1065 .reorder_particles();
1074template<
class Tvec,
template<
class>
class SPHKernel>
1075void shammodels::sph::Model<Tvec, SPHKernel>::add_cube_fcc_3d(
1076 Tscal dr, std::pair<Tvec, Tvec> _box) {
1081 using namespace shamrock::patch;
1085 std::string log =
"";
1087 auto make_sliced = [&]() {
1088 std::vector<Tvec> vec_lst;
1089 generic::setup::generators::add_particles_fcc(
1091 {box.lower, box.upper},
1093 return box.contain_pos(r);
1095 [&](Tvec r, Tscal
h) {
1096 vec_lst.push_back(r);
1099 std::vector<std::vector<Tvec>> sliced_buf;
1103 std::vector<Tvec> cur_buf;
1104 for (
u32 i = 0; i < vec_lst.size(); i++) {
1105 cur_buf.push_back(vec_lst[i]);
1107 if (cur_buf.size() > sz_buf) {
1108 sliced_buf.push_back(std::exchange(cur_buf, std::vector<Tvec>{}));
1112 if (cur_buf.size() > 0) {
1113 sliced_buf.push_back(std::exchange(cur_buf, std::vector<Tvec>{}));
1119 std::vector<std::vector<Tvec>> sliced_buf = make_sliced();
1121 for (std::vector<Tvec> to_ins : sliced_buf) {
1128 std::vector<Tvec> vec_acc;
1129 for (Tvec r : to_ins) {
1130 if (patch_coord.contain_pos(r)) {
1131 vec_acc.push_back(r);
1135 if (vec_acc.size() == 0) {
1139 log += sham::format(
1140 "\n rank = {} patch id={}, add N={} particles, coords = {} {}",
1148 tmp.resize(vec_acc.size());
1152 u32 len = vec_acc.size();
1154 = tmp.get_field<Tvec>(sched.pdl_old().get_field_idx<Tvec>(
"xyz"));
1155 f.override(vec_acc, len);
1160 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>(
"hpart"));
1164 pdat.insert_elements(tmp);
1167 sched.check_patchdata_locality_correctness();
1169 std::string log_gathered =
"";
1177 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
1178 .update_load_balancing();
1179 post_insert_data<Tvec>(sched);
1183template<
class Tvec,
template<
class>
class SPHKernel>
1184auto shammodels::sph::Model<Tvec, SPHKernel>::gen_config_from_phantom_dump(
1185 PhantomDump &phdump,
bool bypass_error) -> SolverConfig {
1187 SolverConfig conf{};
1189 auto massoftype = phdump.read_header_floats<Tscal>(
"massoftype");
1191 conf.gpart_mass = massoftype[0];
1192 conf.cfl_config.cfl_cour = phdump.read_header_float<Tscal>(
"C_cour");
1193 conf.cfl_config.cfl_force = phdump.read_header_float<Tscal>(
"C_force");
1195 conf.eos_config = get_shamrock_eosconfig<Tvec>(phdump, bypass_error);
1196 conf.artif_viscosity = get_shamrock_avconfig<Tvec>(phdump);
1198 conf.set_units(get_shamrock_units<Tscal>(phdump));
1200 conf.boundary_config = get_shamrock_boundary_config<Tvec>(phdump);
1205template<
class Tvec,
template<
class>
class SPHKernel>
1206void shammodels::sph::Model<Tvec, SPHKernel>::init_from_phantom_dump(
1207 PhantomDump &phdump, Tscal hpart_fact_load) {
1210 bool has_coord_in_header =
true;
1212 Tscal xmin, xmax, ymin, ymax, zmin, zmax;
1213 has_coord_in_header = phdump.has_header_entry(
"xmin");
1215 std::string log =
"";
1218 std::vector<Tscal>
h, u, alpha;
1221 std::vector<Tscal> x, y, z, vx, vy, vz;
1223 phdump.blocks[0].fill_vec(
"x", x);
1224 phdump.blocks[0].fill_vec(
"y", y);
1225 phdump.blocks[0].fill_vec(
"z", z);
1227 if (has_coord_in_header) {
1228 xmin = phdump.read_header_float<
f64>(
"xmin");
1229 xmax = phdump.read_header_float<
f64>(
"xmax");
1230 ymin = phdump.read_header_float<
f64>(
"ymin");
1231 ymax = phdump.read_header_float<
f64>(
"ymax");
1232 zmin = phdump.read_header_float<
f64>(
"zmin");
1233 zmax = phdump.read_header_float<
f64>(
"zmax");
1235 resize_simulation_box({{xmin, ymin, zmin}, {xmax, ymax, zmax}});
1237 Tscal box_tolerance = 1.2;
1239 xmin = *std::min_element(x.begin(), x.end());
1240 xmax = *std::max_element(x.begin(), x.end());
1241 ymin = *std::min_element(y.begin(), y.end());
1242 ymax = *std::max_element(y.begin(), y.end());
1243 zmin = *std::min_element(z.begin(), z.end());
1244 zmax = *std::max_element(z.begin(), z.end());
1246 Tvec bm = {xmin, ymin, zmin};
1247 Tvec bM = {xmax, ymax, zmax};
1249 Tvec center = (bm + bM) * 0.5;
1251 Tvec d = (bM - bm) * 0.5;
1256 resize_simulation_box({center - d, center + d});
1259 phdump.blocks[0].fill_vec(
"h", h);
1261 phdump.blocks[0].fill_vec(
"vx", vx);
1262 phdump.blocks[0].fill_vec(
"vy", vy);
1263 phdump.blocks[0].fill_vec(
"vz", vz);
1265 phdump.blocks[0].fill_vec(
"u", u);
1266 phdump.blocks[0].fill_vec(
"alpha", alpha);
1268 for (
u32 i = 0; i < x.size(); i++) {
1269 xyz.push_back({x[i], y[i], z[i]});
1271 for (
u32 i = 0; i < vx.size(); i++) {
1272 vxyz.push_back({vx[i], vy[i], vz[i]});
1277 f64 time_phdump = phdump.read_header_float<
f64>(
"time");
1278 solver.set_time(time_phdump);
1280 using namespace shamrock::patch;
1288 std::vector<u64> insert_ranges;
1289 insert_ranges.push_back(0);
1290 for (
u64 i = sz_buf; i < Ntot; i += sz_buf) {
1291 insert_ranges.push_back(i);
1293 insert_ranges.push_back(Ntot);
1295 for (
u64 krange = 0; krange < insert_ranges.size() - 1; krange++) {
1296 u64 start_id = insert_ranges[krange];
1297 u64 end_id = insert_ranges[krange + 1];
1299 u64 Nloc = end_id - start_id;
1306 std::vector<u64> sel_index;
1307 for (
u64 i = start_id; i < end_id; i++) {
1310 if (patch_coord.contain_pos(r) && (h_ >= 0)) {
1311 sel_index.push_back(i);
1315 if (sel_index.size() == 0) {
1319 log += sham::format(
1320 "\n rank = {} patch id={}, add N={} particles, coords = {} {}",
1327 std::vector<Tvec> ins_xyz, ins_vxyz;
1328 std::vector<Tscal> ins_h, ins_u, ins_alpha;
1329 for (
u64 i : sel_index) {
1330 ins_xyz.push_back(xyz[i]);
1332 for (
u64 i : sel_index) {
1333 ins_vxyz.push_back(vxyz[i]);
1335 for (
u64 i : sel_index) {
1336 ins_h.push_back(h[i] * hpart_fact_load);
1339 for (
u64 i : sel_index) {
1340 ins_u.push_back(u[i]);
1343 if (alpha.size() > 0) {
1344 for (
u64 i : sel_index) {
1345 ins_alpha.push_back(alpha[i]);
1350 ptmp.resize(sel_index.size());
1353 ptmp.override_patch_field(
"xyz", ins_xyz);
1354 ptmp.override_patch_field(
"vxyz", ins_vxyz);
1355 ptmp.override_patch_field(
"hpart", ins_h);
1357 if (ins_alpha.size() > 0) {
1358 ptmp.override_patch_field(
"alpha_AV", ins_alpha);
1361 if (ins_u.size() > 0) {
1362 ptmp.override_patch_field(
"uint", ins_u);
1365 pdat.insert_elements(ptmp);
1368 sched.check_patchdata_locality_correctness();
1370 std::string log_gathered =
"";
1378 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
1379 .update_load_balancing();
1381 post_insert_data<Tvec>(sched);
1385 PhantomDumpBlock &sink_block = phdump.blocks[1];
1387 std::vector<Tscal> xsink, ysink, zsink;
1388 std::vector<Tscal> vxsink, vysink, vzsink;
1389 std::vector<Tscal> mass;
1390 std::vector<Tscal> Racc;
1392 sink_block.fill_vec(
"x", xsink);
1393 sink_block.fill_vec(
"y", ysink);
1394 sink_block.fill_vec(
"z", zsink);
1395 sink_block.fill_vec(
"vx", vxsink);
1396 sink_block.fill_vec(
"vy", vysink);
1397 sink_block.fill_vec(
"vz", vzsink);
1398 sink_block.fill_vec(
"m", mass);
1399 sink_block.fill_vec(
"h", Racc);
1401 for (
u32 i = 0; i < xsink.size(); i++) {
1404 {xsink[i], ysink[i], zsink[i]},
1405 {vxsink[i], vysink[i], vzsink[i]},
1412template<
class Tvec,
template<
class>
class SPHKernel>
1413void shammodels::sph::Model<Tvec, SPHKernel>::add_pdat_to_phantom_block(
1418 u64 xid = block.get_ref_fort_real(
"x");
1419 u64 yid = block.get_ref_fort_real(
"y");
1420 u64 zid = block.get_ref_fort_real(
"z");
1422 for (
auto vec : xyz) {
1423 block.blocks_fort_real[xid].vals.push_back(
vec.x());
1424 block.blocks_fort_real[yid].vals.push_back(
vec.y());
1425 block.blocks_fort_real[zid].vals.push_back(
vec.z());
1428 std::vector<Tscal>
h = pdat.
fetch_data<Tscal>(
"hpart");
1429 u64 hid = block.get_ref_f32(
"h");
1431 block.blocks_f32[hid].vals.push_back(h_);
1434 if (solver.solver_config.has_field_alphaAV()) {
1435 std::vector<Tscal> alpha = pdat.
fetch_data<Tscal>(
"alpha_AV");
1436 u64 aid = block.get_ref_f32(
"alpha");
1437 for (
auto alp_ : alpha) {
1438 block.blocks_f32[aid].vals.push_back(alp_);
1442 if (solver.solver_config.has_field_divv()) {
1443 std::vector<Tscal> vecdivv = pdat.
fetch_data<Tscal>(
"divv");
1444 u64 divvid = block.get_ref_f32(
"divv");
1445 for (
auto d_ : vecdivv) {
1446 block.blocks_f32[divvid].vals.push_back(d_);
1452 u64 vxid = block.get_ref_fort_real(
"vx");
1453 u64 vyid = block.get_ref_fort_real(
"vy");
1454 u64 vzid = block.get_ref_fort_real(
"vz");
1456 for (
auto vec : vxyz) {
1457 block.blocks_fort_real[vxid].vals.push_back(
vec.x());
1458 block.blocks_fort_real[vyid].vals.push_back(
vec.y());
1459 block.blocks_fort_real[vzid].vals.push_back(
vec.z());
1462 std::vector<Tscal> u = pdat.
fetch_data<Tscal>(
"uint");
1463 u64 uid = block.get_ref_fort_real(
"u");
1465 block.blocks_fort_real[uid].vals.push_back(u_);
1468 block.tot_count = block.blocks_fort_real[xid].vals.size();
1471template<
class Tvec,
template<
class>
class SPHKernel>
1477 bool bypass_error_check =
false;
1479 auto get_sink_count = [&]() ->
int {
1483 dump.override_magic_number();
1485 dump.fileid = sham::format(
"{:100s}",
"FT:Phantom Shamrock writer");
1487 u32 Ntot = get_total_part_count();
1488 dump.table_header_fort_int.add(
"nparttot", Ntot);
1489 dump.table_header_fort_int.add(
"ntypes", 8);
1490 dump.table_header_fort_int.add(
"npartoftype", Ntot);
1491 dump.table_header_fort_int.add(
"npartoftype", 0);
1492 dump.table_header_fort_int.add(
"npartoftype", 0);
1493 dump.table_header_fort_int.add(
"npartoftype", 0);
1494 dump.table_header_fort_int.add(
"npartoftype", 0);
1495 dump.table_header_fort_int.add(
"npartoftype", 0);
1496 dump.table_header_fort_int.add(
"npartoftype", 0);
1497 dump.table_header_fort_int.add(
"npartoftype", 0);
1499 dump.table_header_i64.add(
"nparttot", Ntot);
1500 dump.table_header_i64.add(
"ntypes", 8);
1501 dump.table_header_i64.add(
"npartoftype", Ntot);
1502 dump.table_header_i64.add(
"npartoftype", 0);
1503 dump.table_header_i64.add(
"npartoftype", 0);
1504 dump.table_header_i64.add(
"npartoftype", 0);
1505 dump.table_header_i64.add(
"npartoftype", 0);
1506 dump.table_header_i64.add(
"npartoftype", 0);
1507 dump.table_header_i64.add(
"npartoftype", 0);
1508 dump.table_header_i64.add(
"npartoftype", 0);
1510 dump.table_header_fort_int.add(
"nblocks", 1);
1511 dump.table_header_fort_int.add(
"nptmass", get_sink_count());
1512 dump.table_header_fort_int.add(
"ndustlarge", 0);
1513 dump.table_header_fort_int.add(
"ndustsmall", 0);
1514 dump.table_header_fort_int.add(
"idust", 7);
1515 dump.table_header_fort_int.add(
"idtmax_n", 1);
1516 dump.table_header_fort_int.add(
"idtmax_frac", 0);
1517 dump.table_header_fort_int.add(
"idumpfile", 0);
1518 dump.table_header_fort_int.add(
"majorv", 2023);
1519 dump.table_header_fort_int.add(
"minorv", 0);
1520 dump.table_header_fort_int.add(
"microv", 0);
1521 dump.table_header_fort_int.add(
"isink", 0);
1523 dump.table_header_i32.add(
"iexternalforce", 0);
1527 dump.table_header_fort_real.add(
"time", solver.get_time());
1528 dump.table_header_fort_real.add(
"dtmax", solver.get_dt_sph());
1530 dump.table_header_fort_real.add(
"rhozero", 0);
1531 dump.table_header_fort_real.add(
"hfact", Kernel::hfactd);
1532 dump.table_header_fort_real.add(
"tolh", 0.0001);
1533 dump.table_header_fort_real.add(
"C_cour", solver.solver_config.cfl_config.cfl_cour);
1534 dump.table_header_fort_real.add(
"C_force", solver.solver_config.cfl_config.cfl_force);
1535 dump.table_header_fort_real.add(
"alpha", 0);
1536 dump.table_header_fort_real.add(
"alphau", 1);
1537 dump.table_header_fort_real.add(
"alphaB", 1);
1539 dump.table_header_fort_real.add(
"massoftype", solver.solver_config.gpart_mass);
1540 dump.table_header_fort_real.add(
"massoftype", 0);
1541 dump.table_header_fort_real.add(
"massoftype", 0);
1542 dump.table_header_fort_real.add(
"massoftype", 0);
1543 dump.table_header_fort_real.add(
"massoftype", 0);
1544 dump.table_header_fort_real.add(
"massoftype", 0);
1545 dump.table_header_fort_real.add(
"massoftype", 0);
1546 dump.table_header_fort_real.add(
"massoftype", 0);
1548 dump.table_header_fort_real.add(
"Bextx", 0);
1549 dump.table_header_fort_real.add(
"Bexty", 0);
1550 dump.table_header_fort_real.add(
"Bextz", 0);
1551 dump.table_header_fort_real.add(
"dum", 0);
1555 auto box_size = sched.get_box_volume<Tvec>();
1557 write_shamrock_boundaries_in_phantom_dump(
1558 solver.solver_config.boundary_config, box_size, dump, bypass_error_check);
1560 dump.table_header_fort_real.add(
"get_conserv", -1);
1561 dump.table_header_fort_real.add(
"etot_in", 0.59762);
1562 dump.table_header_fort_real.add(
"angtot_in", 0.0189694);
1563 dump.table_header_fort_real.add(
"totmom_in", 0.0306284);
1567 PhantomDumpBlock block_part;
1571 std::vector<std::unique_ptr<shamrock::patch::PatchDataLayer>> gathered
1572 = ctx.allgather_data();
1574 for (
auto &dat : gathered) {
1579 dump.blocks.push_back(std::move(block_part));
1583 auto edges = get_sink_edges<Tvec>(sync);
1584 if (edges.has_sinks()) {
1587 PhantomDumpBlock sink_block;
1589 u64 xid = sink_block.get_ref_fort_real(
"x");
1590 u64 yid = sink_block.get_ref_fort_real(
"y");
1591 u64 zid = sink_block.get_ref_fort_real(
"z");
1592 u64 mid = sink_block.get_ref_fort_real(
"m");
1593 u64 hid = sink_block.get_ref_fort_real(
"h");
1594 u64 vxid = sink_block.get_ref_fort_real(
"vx");
1595 u64 vyid = sink_block.get_ref_fort_real(
"vy");
1596 u64 vzid = sink_block.get_ref_fort_real(
"vz");
1598 for (SinkParticle<Tvec> s : sinks) {
1599 sink_block.blocks_fort_real[xid].vals.push_back(s.pos.x());
1600 sink_block.blocks_fort_real[yid].vals.push_back(s.pos.y());
1601 sink_block.blocks_fort_real[zid].vals.push_back(s.pos.z());
1602 sink_block.blocks_fort_real[mid].vals.push_back(s.mass);
1603 sink_block.blocks_fort_real[hid].vals.push_back(s.accretion_radius);
1604 sink_block.blocks_fort_real[vxid].vals.push_back(s.velocity.x());
1605 sink_block.blocks_fort_real[vyid].vals.push_back(s.velocity.y());
1606 sink_block.blocks_fort_real[vzid].vals.push_back(s.velocity.z());
1609 sink_block.tot_count = sinks.size();
1611 dump.blocks.push_back(std::move(sink_block));
constexpr const char * vxyz
3-velocity field
constexpr const char * xyz
Position field (3D coordinates).
Header file describing a Node Instance.
double f64
Alias for double.
std::uint32_t u32
32 bit unsigned integer
std::uint64_t u64
64 bit unsigned integer
SchedulerPatchData patch_data
handle the data of the patches of the scheduler
u64 crit_patch_split
splitting limit (if load value > crit_patch_split => patch split)
PatchTree patch_tree
handle the tree structure of the patches
void scheduler_step(bool do_split_merge, bool do_load_balancing)
scheduler step
SchedulerPatchList patch_list
handle the list of the patches of the scheduler
std::unordered_set< u64 > owned_patch_id
(owned_patch_id = patch_list.build_local())
void add_root_patch()
add patch to the scheduler
std::unordered_set< u64 > build_local()
select owned patches owned by the node to rebuild local
void build_local_idx_map()
recompute id_patch_to_local_idx
Class Timer measures the time elapsed since the timer was started.
f64 elapsed_sec() const
Converts the stored nanosecond time to a floating point representation in seconds.
void start()
Starts the timer.
void stop()
Stops the timer and stores the elapsed time in nanoseconds.
utility for generating HCP crystal lattices
iterator_utils::LatticeIteratorDiscontinuous< Tvec, LatticeHCP > IteratorDiscontinuous
Iterator utility to generate the lattice in a discontinuous order.
Vector class based on std::array storage and mdspan.
void init()
Initialise the model and all the related data structures (patch scheduler in particular).
Class to insert data in the PatchScheduler.
Utility class used to move the objects between patches.
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
std::vector< T > fetch_data(std::string key)
Fetch data of a patchdata field into a std::vector.
std::tuple< T, T > get_bounding_box() const
Get the stored bounding box of the domain.
PatchCoordTransform< T > get_patch_transform() const
Get a PatchCoordTransform object that describes the conversion between patch coordinates and domain c...
shamrock::patch::SimulationBoxInfo sim_box
simulation box geometry info
shambase::DistributedData< PatchData > owned_data
map container for patchdata owned by the current node (layout : id_patch,data)
constexpr Unit h
Planck constant.
This header file contains utility functions related to exception handling in the code.
std::vector< int > vector_allgatherv(const std::vector< T > &send_vec, const MPI_Datatype &send_type, std::vector< T > &recv_vec, const MPI_Datatype &recv_type, const MPI_Comm comm)
allgatherv on vector with size query (size querying variant of vector_allgatherv_ks) //TODO add fault...
void gather_str(const std::string &send_vec, std::string &recv_vec)
Gathers a string from all nodes and store the result in a std::string.
T mock_value(Engine &eng, T min_bound, T max_bound)
Generates a random mock value within specified bounds.
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.
i32 world_rank()
Gives the rank of the current process in the MPI communicator.
namespace for math utility
std::vector< SinkParticle< Tvec > > to_sink_particles(const SinkEdges< Tvec > &e)
Build an AoS sink list from the current SoA edges (Python API / dump helpers).
void write_shamrock_units_in_phantom_dump(std::optional< shamunits::UnitSystem< Tscal > > &units, PhantomDump &dump, bool bypass_error)
Write shamrock units config into the phantom dump.
void add_sink(SinkEdges< Tvec > &e, typename SinkEdges< Tvec >::Tscal mass, Tvec pos, Tvec velocity, typename SinkEdges< Tvec >::Tscal accretion_radius)
Append one sink to the SoA edges.
void write_shamrock_eos_in_phantom_dump(EOSConfig< Tvec > &cfg, PhantomDump &dump, bool bypass_error)
Write the eos config to th phantom dump header.
constexpr u32 u32_max
u32 max value
Contains traits and utilities for backend related types.
void info_ln(std::string module_name, Types... var2)
Prints a log message with multiple arguments followed by a newline.
Helpers to access SPH sink particles stored as SoA synchronized data edges.
This file contains the definition for the stacktrace related functionality.
shambase::details::NamedBasicStackEntry NamedStackEntry
Alias for shambase::details::NamedBasicStackEntry.
shambase::details::BasicStackEntry StackEntry
Alias for shambase::details::BasicStackEntry.
Class representing a Phantom dump file.
Patch object that contain generic patch information.
static bool is_in_patch_converted(sycl::vec< T, 3 > val, sycl::vec< T, 3 > min_val, sycl::vec< T, 3 > max_val)
check if particle is in the asked range, given the output of @convert_coord
u64 id_patch
unique key that identify the patch