Shamrock 2025.10.0
Astrophysical Code
Loading...
Searching...
No Matches
Model.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
20#include "shambase/memory.hpp"
22#include "shambase/string.hpp"
24#include "shamcomm/logs.hpp"
39#include <functional>
40#include <random>
41#include <stdexcept>
42#include <utility>
43#include <vector>
44
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();
49 return tmp;
50}
51
52template<class Tvec, template<class> class SPHKernel>
53shammodels::sph::TimestepLog shammodels::sph::Model<Tvec, SPHKernel>::timestep() {
54 return solver.evolve_once();
55}
56
57template<class Tvec, template<class> class SPHKernel>
59
60 if (solver.solver_config.scheduler_conf.split_load_value == 0) {
62 "Scheduler load value should be greater than 0");
63 }
64
65 solver.init_required_fields();
66 ctx.init_sched(
67 solver.solver_config.scheduler_conf.split_load_value,
68 solver.solver_config.scheduler_conf.merge_load_value);
69
70 using namespace shamrock::patch;
71
72 PatchScheduler &sched = shambase::get_check_ref(ctx.sched);
73
74 sched.add_root_patch();
75
76 shamlog_debug_ln("Sys", "build local scheduler tables");
79 sched.update_local_load_value([&](shamrock::patch::Patch p) {
80 return sched.patch_data.owned_data.get(p.id_patch).get_obj_cnt();
81 });
82 solver.init_ghost_layout();
83
84 solver.init_solver_graph();
85}
86
87REGISTER_IDATAEDGESERIALIZABLE(shamrock::solvergraph::IDataEdgeSerializable<f64>);
88REGISTER_IDATAEDGESERIALIZABLE(shamrock::solvergraph::IDataEdgeSerializable<std::vector<f64>>);
89REGISTER_IDATAEDGESERIALIZABLE(shamrock::solvergraph::IDataEdgeSerializable<std::vector<f64_3>>);
90
91template<class Tvec, template<class> class SPHKernel>
92u64 shammodels::sph::Model<Tvec, SPHKernel>::get_total_part_count() {
93 PatchScheduler &sched = shambase::get_check_ref(ctx.sched);
94 return shamalgs::collective::allreduce_sum(sched.get_rank_count());
95}
96
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();
100}
101
102template<class Tvec, template<class> class SPHKernel>
103auto shammodels::sph::Model<Tvec, SPHKernel>::get_closest_part_to(Tvec pos) -> Tvec {
104 StackEntry stack_loc{};
105
106 using namespace shamrock::patch;
107
108 Tvec best_dr = shambase::VectorProperties<Tvec>::get_max();
109 Tscal best_dist2 = shambase::VectorProperties<Tscal>::get_max();
110
111 PatchScheduler &sched = shambase::get_check_ref(ctx.sched);
112
113 sched.for_each_patchdata_nonempty([&](const Patch, PatchDataLayer &pdat) {
114 auto acc = pdat.get_field<Tvec>(0).get_buf().copy_to_stdvec();
115
116 u32 cnt = pdat.get_obj_cnt();
117
118 for (u32 i = 0; i < cnt; i++) {
119 Tvec tmp = acc[i];
120 Tvec dr = tmp - pos;
121 Tscal dist2 = sycl::dot(dr, dr);
122 if (dist2 < best_dist2) {
123 best_dr = dr;
124 best_dist2 = dist2;
125 }
126 }
127 });
128
129 std::vector<Tvec> list_dr{};
130 shamalgs::collective::vector_allgatherv(std::vector<Tvec>{best_dr}, list_dr, MPI_COMM_WORLD);
131
132 // reset distances because if two rank find the same distance the return value won't be the same
133 // this bug took me a whole day to fix, aaaaaaaaaaaaah !!!!!
134 // maybe this should be moved somewhere else to prevent similar issues
135 // TODO (in a year maybe XD )
136 best_dr = shambase::VectorProperties<Tvec>::get_max();
137 best_dist2 = shambase::VectorProperties<Tscal>::get_max();
138
139 for (Tvec tmp : list_dr) {
140 Tvec dr = tmp - pos;
141 Tscal dist2 = sycl::dot(dr, dr);
142 if (dist2 < best_dist2) {
143 best_dr = dr;
144 best_dist2 = dist2;
145 }
146 }
147
148 return pos + best_dr;
149}
150
151template<class Tvec, template<class> class SPHKernel>
152void shammodels::sph::Model<Tvec, SPHKernel>::remap_positions(std::function<Tvec(Tvec)> map) {
153 StackEntry stack_loc{};
154
155 using namespace shamrock::patch;
156
157 PatchScheduler &sched = shambase::get_check_ref(ctx.sched);
158 sched.for_each_patchdata_nonempty([&](const Patch, PatchDataLayer &pdat) {
159 auto &xyz = pdat.get_field<Tvec>(0).get_buf();
160 auto acc = xyz.copy_to_stdvec();
161
162 u32 cnt = pdat.get_obj_cnt();
163
164 for (u32 i = 0; i < cnt; i++) {
165 acc[i] = map(acc[i]);
166 }
167
168 xyz.copy_from_stdvec(acc);
169 });
170
171 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
172 .update_load_balancing();
173 sched.scheduler_step(false, false);
174
175 {
176 StackEntry stack_loc{};
178 sched.patch_tree, sched.get_sim_box().get_patch_transform<Tvec>());
180 sptree.attach_buf();
181 reatrib.reatribute_patch_objects(sptree, "xyz");
182 sched.check_patchdata_locality_correctness();
183 }
184
185 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
186 .update_load_balancing();
187 sched.scheduler_step(true, true);
188
189 {
190 StackEntry stack_loc{};
192 sched.patch_tree, sched.get_sim_box().get_patch_transform<Tvec>());
193
195 sptree.attach_buf();
196 reatrib.reatribute_patch_objects(sptree, "xyz");
197 sched.check_patchdata_locality_correctness();
198 }
199}
200
201template<class Tvec>
202inline void post_insert_data(PatchScheduler &sched) {
203 StackEntry stack_loc{};
204
205 // logger::raw_ln(sched.dump_status());
206 sched.scheduler_step(false, false);
207
208 /*
209 if(shamcomm::world_rank() == 7){
210 logger::raw_ln(sched.dump_status());
211 }
212 */
213
214 auto [m, M] = sched.get_box_tranform<Tvec>();
215
216 {
217 StackEntry stack_loc{};
219 sched.patch_tree, sched.get_sim_box().get_patch_transform<Tvec>());
221 sptree.attach_buf();
222 reatrib.reatribute_patch_objects(sptree, "xyz");
223 sched.check_patchdata_locality_correctness();
224 }
225
226 sched.scheduler_step(true, true);
227
228 {
229 StackEntry stack_loc{};
231 sched.patch_tree, sched.get_sim_box().get_patch_transform<Tvec>());
232
234 sptree.attach_buf();
235 reatrib.reatribute_patch_objects(sptree, "xyz");
236 sched.check_patchdata_locality_correctness();
237 }
238
239 std::string log = "";
240
241 using namespace shamrock::patch;
242
243 u32 smallest_count = u32_max;
244 u32 largest_count = 0;
245
246 sched.for_each_local_patchdata([&](const Patch &p, PatchDataLayer &pdat) {
247 u32 tmp = pdat.get_obj_cnt();
248 smallest_count = sham::min(tmp, smallest_count);
249 largest_count = sham::max(tmp, largest_count);
250 });
251
252 smallest_count = shamalgs::collective::allreduce_min(smallest_count);
253 largest_count = shamalgs::collective::allreduce_max(largest_count);
254
255 if (shamcomm::world_rank() == 0) {
257 "Model", "current particle counts : min = ", smallest_count, "max = ", largest_count);
258 }
259
260 // sched.for_each_local_patchdata([&](const Patch p, PatchData &pdat) {
261 // log += sham::format(
262 // "\n patch id={}, N={} particles", p.id_patch, pdat.get_obj_cnt());
263 // });
264 //
265 // std::string log_gathered = "";
266 // shamalgs::collective::gather_str(log, log_gathered);
267 //
268 // if (shamcomm::world_rank() == 0)
269 // logger::info_ln("Model", "current particle counts : ", log_gathered);
270}
271
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) {
277 StackEntry stack_loc{};
278
279 using namespace shamrock::patch;
280
281 PatchScheduler &sched = shambase::get_check_ref(ctx.sched);
282
283 std::string log = "";
284
285 sched.for_each_local_patchdata([&](const Patch &p, PatchDataLayer &pdat) {
286 PatchCoordTransform<Tvec> ptransf = sched.get_sim_box().get_patch_transform<Tvec>();
287
288 shammath::CoordRange<Tvec> patch_coord = ptransf.to_obj_coord(p);
289
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]);
299 u_acc.push_back(u);
300 }
301 }
302
303 if (vec_acc.size() == 0) {
304 return;
305 }
306
307 log += sham::format(
308 "\n rank = {} patch id={}, add N={} particles, coords = {} {}",
310 p.id_patch,
311 vec_acc.size(),
312 patch_coord.lower,
313 patch_coord.upper);
314
315 PatchDataLayer tmp(sched.get_layout_ptr_old());
316 tmp.resize(vec_acc.size());
317 tmp.fields_raz();
318
319 {
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);
324 }
325
326 {
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);
331 }
332
333 {
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);
338 }
339
340 pdat.insert_elements(tmp);
341
342 sched.check_patchdata_locality_correctness();
343
344 std::string log_gathered = "";
345 shamalgs::collective::gather_str(log, log_gathered);
346
347 if (shamcomm::world_rank() == 0) {
348 logger::info_ln("Model", "Push particles : ", log_gathered);
349 }
350 log = "";
351
352 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
353 .update_load_balancing();
354
355 post_insert_data<Tvec>(sched);
356 });
357}
358
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) {
366 StackEntry stack_loc{};
367
368 using namespace shamrock::patch;
369
370 PatchScheduler &sched = shambase::get_check_ref(ctx.sched);
371
372 std::string log = "";
373
374 sched.for_each_local_patchdata([&](const Patch &p, PatchDataLayer &pdat) {
375 PatchCoordTransform<Tvec> ptransf = sched.get_sim_box().get_patch_transform<Tvec>();
376
377 shammath::CoordRange<Tvec> patch_coord = ptransf.to_obj_coord(p);
378
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]);
390 u_acc.push_back(u);
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]);
393 }
394 }
395
396 if (vec_acc.size() == 0) {
397 return;
398 }
399
400 log += sham::format(
401 "\n rank = {} patch id={}, add N={} particles, coords = {} {}",
403 p.id_patch,
404 vec_acc.size(),
405 patch_coord.lower,
406 patch_coord.upper);
407
408 PatchDataLayer tmp(sched.get_layout_ptr_old());
409 tmp.resize(vec_acc.size());
410 tmp.fields_raz();
411
412 {
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);
417 }
418
419 {
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);
424 }
425
426 {
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);
431 }
432
433 {
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);
438 }
439
440 {
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);
445 }
446
447 pdat.insert_elements(tmp);
448
449 sched.check_patchdata_locality_correctness();
450
451 std::string log_gathered = "";
452 shamalgs::collective::gather_str(log, log_gathered);
453
454 if (shamcomm::world_rank() == 0) {
455 logger::info_ln("Model", "Push particles MHD : ", log_gathered);
456 }
457 log = "";
458
459 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
460 .update_load_balancing();
461
462 post_insert_data<Tvec>(sched);
463 });
464}
465
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) {
469 shambase::Timer time_setup;
470 time_setup.start();
471
472 StackEntry stack_loc{};
473
475
476 using namespace shamrock::patch;
477
478 PatchScheduler &sched = shambase::get_check_ref(ctx.sched);
479
480 using Lattice = shammath::LatticeHCP<Tvec>;
481 using LatticeIter = typename shammath::LatticeHCP<Tvec>::IteratorDiscontinuous;
482
483 auto [idxs_min, idxs_max] = Lattice::get_box_index_bounds(dr, box.lower, box.upper);
484
485 LatticeIter gen = LatticeIter(dr, idxs_min, idxs_max);
486
487 u64 acc_count = 0;
488
489 std::string log = "";
490 while (!gen.is_done()) {
491
492 // loc maximum count of insert part
493 u64 loc_sum_ins_cnt = 0;
494 // sum_node( loc_sum_ins_cnt )
495 u64 max_loc_sum_ins_cnt = 0;
496
497 do {
498 std::vector<Tvec> to_ins = gen.next_n(sched.crit_patch_split * 2);
499 acc_count += to_ins.size();
500
501 sched.for_each_local_patchdata([&](const Patch &p, PatchDataLayer &pdat) {
502 PatchCoordTransform<Tvec> ptransf = sched.get_sim_box().get_patch_transform<Tvec>();
503
504 shammath::CoordRange<Tvec> patch_coord = ptransf.to_obj_coord(p);
505
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);
510 }
511 }
512
513 // update max insert_count
514 loc_sum_ins_cnt += vec_acc.size();
515
516 if (vec_acc.size() == 0) {
517 return;
518 }
519
520 log += sham::format(
521 "\n rank = {} patch id={}, add N={} particles, coords = {} {}",
523 p.id_patch,
524 vec_acc.size(),
525 patch_coord.lower,
526 patch_coord.upper);
527
528 // reserve space to avoid allocating during copy
529 pdat.reserve(vec_acc.size());
530
531 PatchDataLayer tmp(sched.get_layout_ptr_old());
532 tmp.resize(vec_acc.size());
533 tmp.fields_raz();
534
535 {
536 u32 len = vec_acc.size();
538 = tmp.get_field<Tvec>(sched.pdl_old().get_field_idx<Tvec>("xyz"));
539 // sycl::buffer<Tvec> buf(vec_acc.data(), len);
540 f.override(vec_acc, len);
541 }
542
543 {
545 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>("hpart"));
546 f.override(dr);
547 }
548
549 pdat.insert_elements(tmp);
550 });
551
552 max_loc_sum_ins_cnt = shamalgs::collective::allreduce_max(loc_sum_ins_cnt);
553
554 if (shamcomm::world_rank() == 0) {
556 "Model",
557 "--> insertion loop : max loc insert count = ",
558 max_loc_sum_ins_cnt,
559 "sum =",
560 acc_count);
561 }
562 } while (!gen.is_done() && max_loc_sum_ins_cnt < sched.crit_patch_split * 8);
563
564 sched.check_patchdata_locality_correctness();
565
566 // if(logger::details::loglevel >= shamcomm::logs::log_info){
567 // std::string log_gathered = "";
568 // shamalgs::collective::gather_str(log, log_gathered);
569 //
570 // if (shamcomm::world_rank() == 0) {
571 // shamlog_debug_ln("Model", "Push particles : ", log_gathered);
572 // }
573 // }
574 log = "";
575
576 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
577 .update_load_balancing();
578 post_insert_data<Tvec>(sched);
579 }
580
581 if (true) {
582 modules::ParticleReordering<Tvec, u32, SPHKernel>(ctx, solver.solver_config, solver.storage)
583 .reorder_particles();
584 }
585
586 time_setup.stop();
587 if (shamcomm::world_rank() == 0) {
588 logger::info_ln("Model", "add_cube_hcp took :", time_setup.elapsed_sec(), "s");
589 }
590}
591
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) {
595 shambase::Timer time_setup;
596 time_setup.start();
597 StackEntry stack_loc{};
598
600 using namespace shamrock::patch;
601
602 PatchScheduler &sched = shambase::get_check_ref(ctx.sched);
603
604 using Lattice = shammath::LatticeHCP<Tvec>;
605 using LatticeIter = typename shammath::LatticeHCP<Tvec>::IteratorDiscontinuous;
606
607 auto [idxs_min, idxs_max] = Lattice::get_box_index_bounds(dr, box.lower, box.upper);
608
609 LatticeIter gen = LatticeIter(dr, idxs_min, idxs_max);
610
611 shamrock::DataInserterUtility inserter(sched);
612
613 auto push_current_data = [&](std::vector<Tvec> pos_data) {
614 PatchDataLayer tmp(sched.get_layout_ptr_old());
615 tmp.resize(pos_data.size());
616 tmp.fields_raz();
617
618 {
619 u32 len = pos_data.size();
621 = tmp.get_field<Tvec>(sched.pdl_old().get_field_idx<Tvec>("xyz"));
622 // sycl::buffer<Tvec> buf(pos_data.data(), len);
623 f.override(pos_data, len);
624 }
625
626 {
628 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>("hpart"));
629 f.override(dr);
630 }
631
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();
636 });
637 pos_data.clear();
638 };
639
640 u32 insert_step = sched.crit_patch_split * 8;
641
642 auto [bmin, bmax] = sched.patch_data.sim_box.get_bounding_box<Tvec>();
643
644 auto has_pdat = [&]() {
645 bool ret = false;
646 sched.for_each_local_patchdata([&](const Patch &p, PatchDataLayer &pdat) {
647 ret = true;
648 });
649 return ret;
650 };
651
652 // Every MPI rank should be synchroneous on gen state
653 while (!gen.is_done()) {
654
655 u64 loc_gen_count = (has_pdat()) ? insert_step : 0;
656
657 auto gen_info = shamalgs::collective::fetch_view(loc_gen_count);
658
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;
662
663 shamlog_debug_ln(
664 "Gen",
665 "generate : ",
666 skip_start,
667 gen_cnt,
668 skip_end,
669 "total",
670 skip_start + gen_cnt + skip_end);
671 gen.skip(skip_start);
672 auto tmp = gen.next_n(gen_cnt);
673 gen.skip(skip_end);
674
675 std::vector<Tvec> pos_data;
676 for (Tvec r : tmp) {
677 if (Patch::is_in_patch_converted(r, bmin, bmax)) {
678 pos_data.push_back(r);
679 }
680 }
681
682 push_current_data(pos_data);
683
684 shamlog_debug_ln("Gen", "gen.is_done()", gen.is_done());
685 }
686
687 time_setup.stop();
688 if (shamcomm::world_rank() == 0) {
689 logger::info_ln("Model", "add_cube_hcp took :", time_setup.elapsed_sec(), "s");
690 }
691}
692
693template<class Tvec>
695 public:
696 using Tscal = shambase::VecComponent<Tvec>;
698
699 class DiscIterator {
700 bool done = false;
701 Tvec center;
702 Tscal central_mass;
703 u64 Npart;
704 Tscal r_in;
705 Tscal r_out;
706 Tscal disc_mass;
707 Tscal p;
708 Tscal H_r_in;
709 Tscal q;
710 Tscal G;
711
712 u64 current_index;
713
714 std::mt19937 eng;
715
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;
720
721 public:
722 DiscIterator(
723 Tvec center,
724 Tscal central_mass,
725 u64 Npart,
726 Tscal r_in,
727 Tscal r_out,
728 Tscal disc_mass,
729 Tscal p,
730 Tscal H_r_in,
731 Tscal q,
732 Tscal G,
733 std::mt19937 eng,
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) {
741
742 if (Npart == 0) {
743 done = true;
744 }
745 }
746
747 inline bool is_done() { return done; } // just to make sure the result is not tempered with
748
750
751 constexpr Tscal _2pi = 2 * shambase::constants::pi<Tscal>;
752
753 auto f_func = [&](Tscal r) {
754 return r * sigma_profile(r);
755 };
756
757 Tscal fmax = f_func(r_out);
758
759 auto find_r = [&]() {
760 while (true) {
761 Tscal u2 = shamalgs::primitives::mock_value<Tscal>(eng, 0, fmax);
762 Tscal r = shamalgs::primitives::mock_value<Tscal>(eng, r_in, r_out);
763 if (u2 < f_func(r)) {
764 return r;
765 }
766 }
767 };
768
769 auto theta = shamalgs::primitives::mock_value<Tscal>(eng, 0, _2pi);
770 auto Gauss = shamalgs::random::mock_gaussian<Tscal>(eng);
771 Tscal aspin = 2.;
772
773 Tscal r = find_r();
774
775 Tscal vk = rot_profile(r);
776 Tscal cs = cs_profile(r);
777 Tscal sigma = sigma_profile(r);
778
779 Tscal Omega_Kep = sycl::sqrt(G * central_mass / (r * r * r));
780
781 // Tscal H_r = cs/vk;
782 // Tscal H = H_r * r;
783 Tscal H = sycl::sqrt(2.) * 3. * cs
784 / Omega_Kep; // factor taken from phantom, to fasten thermalizing
785
786 Tscal z = H * Gauss;
787
788 auto pos = sycl::vec<Tscal, 3>{r * sycl::cos(theta), z, r * sycl::sin(theta)};
789
790 auto etheta = sycl::vec<Tscal, 3>{-pos.z(), 0, pos.x()};
791 etheta /= sycl::length(etheta);
792
793 auto vel = vk * etheta;
794
795 // Tscal rho = (sigma / (H * shambase::constants::pi2_sqrt<Tscal>))*
796 // sycl::exp(- z*z / (2*H*H));
797
798 Tscal fs = 1. - sycl::sqrt(r_in / r);
799 Tscal rho = (sigma * fs) * sycl::exp(-z * z / (2 * H * H));
800
801 Out out{pos, vel, cs, rho};
802
803 // increase counter + check if finished
804 current_index++;
805 if (current_index == Npart) {
806 done = true;
807 }
808
809 return out;
810 }
811
812 inline std::vector<Out> next_n(u32 nmax) {
813 std::vector<Out> ret{};
814 for (u32 i = 0; i < nmax; i++) {
815 if (done) {
816 break;
817 }
818
819 ret.push_back(next());
820 }
821 return ret;
822 }
823 };
824};
825
826template<class Tvec, template<class> class SPHKernel>
827void shammodels::sph::Model<Tvec, SPHKernel>::add_big_disc_3d(
828 Tvec center,
829 Tscal central_mass,
830 u32 Npart,
831 Tscal r_in,
832 Tscal r_out,
833 Tscal disc_mass,
834 Tscal p,
835 Tscal H_r_in,
836 Tscal q,
837 std::mt19937 eng) {
838
839 Tscal eos_gamma;
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)) {
845
846 eos_gamma = eos_config->gamma;
847
848 } else {
849 // dirty hack for disc setup in locally isothermal
850 eos_gamma = 2;
851 // shambase::throw_unimplemented();
852 }
853
854 auto sigma_profile = [=](Tscal r) {
855 // we setup with an adimensional mass since it is monte carlo
856 constexpr Tscal sigma_0 = 1;
857 return sigma_0 * sycl::pow(r / r_in, -p);
858 };
859
860 auto cs_law = [=](Tscal r) {
861 return sycl::pow(r / r_in, -q);
862 };
863
864 auto kep_profile = [&](Tscal r) {
865 Tscal G = solver.solver_config.get_constant_G();
866 return sycl::sqrt(G * central_mass / r);
867 };
868
869 auto rot_profile = [&](Tscal r) -> Tscal {
870 // carefull: needs r in cylindrical
871 Tscal G = solver.solver_config.get_constant_G();
872 Tscal c = solver.solver_config.get_constant_c();
873 Tscal aspin = 2.;
874 Tscal term = G * central_mass / r;
875 Tscal term_fs = 1. - sycl::sqrt(r_in / r);
876 Tscal term_pr
877 = -sycl::pown(cs_law(r), 2) * (1.5 + p + q); // NO CORRECTION from fs term, bad response
878 Tscal term_bh = 0.; //- (2. * aspin / sycl::pow(c, 3)) * sycl::pow(G * central_mass / r, 2);
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);
882
883 Tscal vphi = 0.5 * (term_bh + sycl::sqrt(det));
884
885 return vphi;
886 };
887
888 auto cs_profile = [&](Tscal r) {
889 Tscal cs_in = (H_r_in * r_in / r) * kep_profile(r_in); // H_r_in*rot_profile(r_in);
890 return cs_law(r) * cs_in;
891 };
892
893 auto get_hfact = []() -> Tscal {
894 return Kernel::hfactd;
895 };
896
897 auto int_rho_h = [&](Tscal h) -> Tscal {
898 return shamrock::sph::rho_h(solver.solver_config.gpart_mass, h, Kernel::hfactd);
899 };
900
901 Tscal part_mass = disc_mass / Npart;
902
903 shambase::Timer time_setup;
904 time_setup.start();
905
906 StackEntry stack_loc{};
907
908 using namespace shamrock::patch;
909
910 PatchScheduler &sched = shambase::get_check_ref(ctx.sched);
911
913 using DIter = typename BigDiscUtils<Tvec>::DiscIterator;
914
915 Tscal G = solver.solver_config.get_constant_G();
916 DIter gen = DIter(
917 center,
918 central_mass,
919 Npart,
920 r_in,
921 r_out,
922 disc_mass,
923 p,
924 H_r_in,
925 q,
926 G,
927 eng,
928 sigma_profile,
929 cs_profile,
930 rot_profile);
931
932 u64 acc_count = 0;
933
934 std::string log = "";
935 while (!gen.is_done()) {
936
937 // loc maximum count of insert part
938 u64 loc_sum_ins_cnt = 0;
939 // sum_node( loc_sum_ins_cnt )
940 u64 max_loc_sum_ins_cnt = 0;
941
942 do {
943 std::vector<Out> to_ins = gen.next_n(sched.crit_patch_split * 2);
944 acc_count += to_ins.size();
945
946 sched.for_each_local_patchdata([&](const Patch &p, PatchDataLayer &pdat) {
947 PatchCoordTransform<Tvec> ptransf = sched.get_sim_box().get_patch_transform<Tvec>();
948
949 shammath::CoordRange<Tvec> patch_coord = ptransf.to_obj_coord(p);
950
951 std::vector<Out> part_list;
952 for (Out r : to_ins) {
953 if (patch_coord.contain_pos(r.pos)) {
954 // add all part to insert in a vector
955 part_list.push_back(r);
956 }
957 }
958
959 // update max insert_count
960 loc_sum_ins_cnt += part_list.size();
961
962 if (part_list.size() == 0) {
963 return;
964 }
965
966 log += sham::format(
967 "\n rank = {} patch id={}, add N={} particles, coords = {} {}",
969 p.id_patch,
970 part_list.size(),
971 patch_coord.lower,
972 patch_coord.upper);
973
974 // extract the pos from part_list
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;
980
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 / (/*solver.eos_gamma * */ (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);
987 }
988
989 // reserve space to avoid allocating during copy
990 pdat.reserve(vec_pos.size());
991
992 PatchDataLayer tmp(sched.get_layout_ptr_old());
993 tmp.resize(vec_pos.size());
994 tmp.fields_raz();
995
996 {
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);
1001 }
1002
1003 {
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);
1008 }
1009
1010 {
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);
1015 }
1016
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);
1022 }
1023
1024 {
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);
1029 }
1030
1031 pdat.insert_elements(tmp);
1032 });
1033
1034 max_loc_sum_ins_cnt = shamalgs::collective::allreduce_max(loc_sum_ins_cnt);
1035
1036 if (shamcomm::world_rank() == 0) {
1038 "Model",
1039 "--> insertion loop : max loc insert count = ",
1040 max_loc_sum_ins_cnt,
1041 "sum =",
1042 acc_count);
1043 }
1044 } while (!gen.is_done() && max_loc_sum_ins_cnt < sched.crit_patch_split * 8);
1045
1046 sched.check_patchdata_locality_correctness();
1047
1048 // if(logger::details::loglevel >= shamcomm::logs::log_info){
1049 // std::string log_gathered = "";
1050 // shamalgs::collective::gather_str(log, log_gathered);
1051 //
1052 // if (shamcomm::world_rank() == 0) {
1053 // shamlog_debug_ln("Model", "Push particles : ", log_gathered);
1054 // }
1055 // }
1056 log = "";
1057
1058 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
1059 .update_load_balancing();
1060 post_insert_data<Tvec>(sched);
1061 }
1062
1063 if (true) {
1064 modules::ParticleReordering<Tvec, u32, SPHKernel>(ctx, solver.solver_config, solver.storage)
1065 .reorder_particles();
1066 }
1067
1068 time_setup.stop();
1069 if (shamcomm::world_rank() == 0) {
1070 logger::info_ln("Model", "add_big_disc took :", time_setup.elapsed_sec(), "s");
1071 }
1072}
1073
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) {
1077 StackEntry stack_loc{};
1078
1079 shammath::CoordRange<Tvec> box = _box;
1080
1081 using namespace shamrock::patch;
1082
1083 PatchScheduler &sched = shambase::get_check_ref(ctx.sched);
1084
1085 std::string log = "";
1086
1087 auto make_sliced = [&]() {
1088 std::vector<Tvec> vec_lst;
1089 generic::setup::generators::add_particles_fcc(
1090 dr,
1091 {box.lower, box.upper},
1092 [&](Tvec r) {
1093 return box.contain_pos(r);
1094 },
1095 [&](Tvec r, Tscal h) {
1096 vec_lst.push_back(r);
1097 });
1098
1099 std::vector<std::vector<Tvec>> sliced_buf;
1100
1101 u32 sz_buf = sched.crit_patch_split * 4;
1102
1103 std::vector<Tvec> cur_buf;
1104 for (u32 i = 0; i < vec_lst.size(); i++) {
1105 cur_buf.push_back(vec_lst[i]);
1106
1107 if (cur_buf.size() > sz_buf) {
1108 sliced_buf.push_back(std::exchange(cur_buf, std::vector<Tvec>{}));
1109 }
1110 }
1111
1112 if (cur_buf.size() > 0) {
1113 sliced_buf.push_back(std::exchange(cur_buf, std::vector<Tvec>{}));
1114 }
1115
1116 return sliced_buf;
1117 };
1118
1119 std::vector<std::vector<Tvec>> sliced_buf = make_sliced();
1120
1121 for (std::vector<Tvec> to_ins : sliced_buf) {
1122
1123 sched.for_each_local_patchdata([&](const Patch &p, PatchDataLayer &pdat) {
1124 PatchCoordTransform<Tvec> ptransf = sched.get_sim_box().get_patch_transform<Tvec>();
1125
1126 shammath::CoordRange<Tvec> patch_coord = ptransf.to_obj_coord(p);
1127
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);
1132 }
1133 }
1134
1135 if (vec_acc.size() == 0) {
1136 return;
1137 }
1138
1139 log += sham::format(
1140 "\n rank = {} patch id={}, add N={} particles, coords = {} {}",
1142 p.id_patch,
1143 vec_acc.size(),
1144 patch_coord.lower,
1145 patch_coord.upper);
1146
1147 PatchDataLayer tmp(sched.get_layout_ptr_old());
1148 tmp.resize(vec_acc.size());
1149 tmp.fields_raz();
1150
1151 {
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);
1156 }
1157
1158 {
1160 = tmp.get_field<Tscal>(sched.pdl_old().get_field_idx<Tscal>("hpart"));
1161 f.override(dr);
1162 }
1163
1164 pdat.insert_elements(tmp);
1165 });
1166
1167 sched.check_patchdata_locality_correctness();
1168
1169 std::string log_gathered = "";
1170 shamalgs::collective::gather_str(log, log_gathered);
1171
1172 if (shamcomm::world_rank() == 0) {
1173 logger::info_ln("Model", "Push particles : ", log_gathered);
1174 }
1175 log = "";
1176
1177 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
1178 .update_load_balancing();
1179 post_insert_data<Tvec>(sched);
1180 }
1181}
1182
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 {
1186 StackEntry stack_loc{};
1187 SolverConfig conf{};
1188
1189 auto massoftype = phdump.read_header_floats<Tscal>("massoftype");
1190
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");
1194
1195 conf.eos_config = get_shamrock_eosconfig<Tvec>(phdump, bypass_error);
1196 conf.artif_viscosity = get_shamrock_avconfig<Tvec>(phdump);
1197
1198 conf.set_units(get_shamrock_units<Tscal>(phdump));
1199
1200 conf.boundary_config = get_shamrock_boundary_config<Tvec>(phdump);
1201
1202 return conf;
1203}
1204
1205template<class Tvec, template<class> class SPHKernel>
1206void shammodels::sph::Model<Tvec, SPHKernel>::init_from_phantom_dump(
1207 PhantomDump &phdump, Tscal hpart_fact_load) {
1208 StackEntry stack_loc{};
1209
1210 bool has_coord_in_header = true;
1211
1212 Tscal xmin, xmax, ymin, ymax, zmin, zmax;
1213 has_coord_in_header = phdump.has_header_entry("xmin");
1214
1215 std::string log = "";
1216
1217 std::vector<Tvec> xyz, vxyz;
1218 std::vector<Tscal> h, u, alpha;
1219
1220 {
1221 std::vector<Tscal> x, y, z, vx, vy, vz;
1222
1223 phdump.blocks[0].fill_vec("x", x);
1224 phdump.blocks[0].fill_vec("y", y);
1225 phdump.blocks[0].fill_vec("z", z);
1226
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");
1234
1235 resize_simulation_box({{xmin, ymin, zmin}, {xmax, ymax, zmax}});
1236 } else {
1237 Tscal box_tolerance = 1.2;
1238
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());
1245
1246 Tvec bm = {xmin, ymin, zmin};
1247 Tvec bM = {xmax, ymax, zmax};
1248
1249 Tvec center = (bm + bM) * 0.5;
1250
1251 Tvec d = (bM - bm) * 0.5;
1252
1253 // expand the box
1254 d *= box_tolerance;
1255
1256 resize_simulation_box({center - d, center + d});
1257 }
1258
1259 phdump.blocks[0].fill_vec("h", h);
1260
1261 phdump.blocks[0].fill_vec("vx", vx);
1262 phdump.blocks[0].fill_vec("vy", vy);
1263 phdump.blocks[0].fill_vec("vz", vz);
1264
1265 phdump.blocks[0].fill_vec("u", u);
1266 phdump.blocks[0].fill_vec("alpha", alpha);
1267
1268 for (u32 i = 0; i < x.size(); i++) {
1269 xyz.push_back({x[i], y[i], z[i]});
1270 }
1271 for (u32 i = 0; i < vx.size(); i++) {
1272 vxyz.push_back({vx[i], vy[i], vz[i]});
1273 }
1274 }
1275
1276 // Load time infos
1277 f64 time_phdump = phdump.read_header_float<f64>("time");
1278 solver.set_time(time_phdump);
1279
1280 using namespace shamrock::patch;
1281
1282 PatchScheduler &sched = shambase::get_check_ref(ctx.sched);
1283
1284 u32 sz_buf = sched.crit_patch_split * 4;
1285
1286 u32 Ntot = xyz.size();
1287
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);
1292 }
1293 insert_ranges.push_back(Ntot);
1294
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];
1298
1299 u64 Nloc = end_id - start_id;
1300
1301 sched.for_each_local_patchdata([&](const Patch &p, PatchDataLayer &pdat) {
1302 PatchCoordTransform<Tvec> ptransf = sched.get_sim_box().get_patch_transform<Tvec>();
1303
1304 shammath::CoordRange<Tvec> patch_coord = ptransf.to_obj_coord(p);
1305
1306 std::vector<u64> sel_index;
1307 for (u64 i = start_id; i < end_id; i++) {
1308 Tvec r = xyz[i];
1309 Tscal h_ = h[i];
1310 if (patch_coord.contain_pos(r) && (h_ >= 0)) {
1311 sel_index.push_back(i);
1312 }
1313 }
1314
1315 if (sel_index.size() == 0) {
1316 return;
1317 }
1318
1319 log += sham::format(
1320 "\n rank = {} patch id={}, add N={} particles, coords = {} {}",
1322 p.id_patch,
1323 sel_index.size(),
1324 patch_coord.lower,
1325 patch_coord.upper);
1326
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]);
1331 }
1332 for (u64 i : sel_index) {
1333 ins_vxyz.push_back(vxyz[i]);
1334 }
1335 for (u64 i : sel_index) {
1336 ins_h.push_back(h[i] * hpart_fact_load);
1337 }
1338 if (u.size() > 0) {
1339 for (u64 i : sel_index) {
1340 ins_u.push_back(u[i]);
1341 }
1342 }
1343 if (alpha.size() > 0) {
1344 for (u64 i : sel_index) {
1345 ins_alpha.push_back(alpha[i]);
1346 }
1347 }
1348
1349 PatchDataLayer ptmp(sched.get_layout_ptr_old());
1350 ptmp.resize(sel_index.size());
1351 ptmp.fields_raz();
1352
1353 ptmp.override_patch_field("xyz", ins_xyz);
1354 ptmp.override_patch_field("vxyz", ins_vxyz);
1355 ptmp.override_patch_field("hpart", ins_h);
1356
1357 if (ins_alpha.size() > 0) {
1358 ptmp.override_patch_field("alpha_AV", ins_alpha);
1359 }
1360
1361 if (ins_u.size() > 0) {
1362 ptmp.override_patch_field("uint", ins_u);
1363 }
1364
1365 pdat.insert_elements(ptmp);
1366 });
1367
1368 sched.check_patchdata_locality_correctness();
1369
1370 std::string log_gathered = "";
1371 shamalgs::collective::gather_str(log, log_gathered);
1372
1373 if (shamcomm::world_rank() == 0) {
1374 logger::info_ln("Model", "Push particles : ", log_gathered);
1375 }
1376 log = "";
1377
1378 modules::ComputeLoadBalanceValue<Tvec, SPHKernel>(ctx, solver.solver_config, solver.storage)
1379 .update_load_balancing();
1380
1381 post_insert_data<Tvec>(sched);
1382
1383 // add sinks
1384
1385 PhantomDumpBlock &sink_block = phdump.blocks[1];
1386 {
1387 std::vector<Tscal> xsink, ysink, zsink;
1388 std::vector<Tscal> vxsink, vysink, vzsink;
1389 std::vector<Tscal> mass;
1390 std::vector<Tscal> Racc;
1391
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);
1400
1401 for (u32 i = 0; i < xsink.size(); i++) {
1402 add_sink(
1403 mass[i],
1404 {xsink[i], ysink[i], zsink[i]},
1405 {vxsink[i], vysink[i], vzsink[i]},
1406 Racc[i]);
1407 }
1408 }
1409 }
1410}
1411
1412template<class Tvec, template<class> class SPHKernel>
1413void shammodels::sph::Model<Tvec, SPHKernel>::add_pdat_to_phantom_block(
1414 PhantomDumpBlock &block, shamrock::patch::PatchDataLayer &pdat) {
1415
1416 std::vector<Tvec> xyz = pdat.fetch_data<Tvec>("xyz");
1417
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");
1421
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());
1426 }
1427
1428 std::vector<Tscal> h = pdat.fetch_data<Tscal>("hpart");
1429 u64 hid = block.get_ref_f32("h");
1430 for (auto h_ : h) {
1431 block.blocks_f32[hid].vals.push_back(h_);
1432 }
1433
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_);
1439 }
1440 }
1441
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_);
1447 }
1448 }
1449
1450 std::vector<Tvec> vxyz = pdat.fetch_data<Tvec>("vxyz");
1451
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");
1455
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());
1460 }
1461
1462 std::vector<Tscal> u = pdat.fetch_data<Tscal>("uint");
1463 u64 uid = block.get_ref_fort_real("u");
1464 for (auto u_ : u) {
1465 block.blocks_fort_real[uid].vals.push_back(u_);
1466 }
1467
1468 block.tot_count = block.blocks_fort_real[xid].vals.size();
1469}
1470
1471template<class Tvec, template<class> class SPHKernel>
1472shammodels::sph::PhantomDump shammodels::sph::Model<Tvec, SPHKernel>::make_phantom_dump() {
1473 StackEntry stack_loc{};
1474
1475 PhantomDump dump;
1476
1477 bool bypass_error_check = false;
1478
1479 auto get_sink_count = [&]() -> int {
1480 return int(get_sink_pos<Tvec>(shambase::get_check_ref(ctx.sched).synchronized_data).size());
1481 };
1482
1483 dump.override_magic_number();
1484 dump.iversion = 1;
1485 dump.fileid = sham::format("{:100s}", "FT:Phantom Shamrock writer");
1486
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);
1498
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);
1509
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);
1522
1523 dump.table_header_i32.add("iexternalforce", 0);
1524
1525 write_shamrock_eos_in_phantom_dump(solver.solver_config.eos_config, dump, bypass_error_check);
1526
1527 dump.table_header_fort_real.add("time", solver.get_time());
1528 dump.table_header_fort_real.add("dtmax", solver.get_dt_sph());
1529
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);
1538
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);
1547
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);
1552
1553 PatchScheduler &sched = shambase::get_check_ref(solver.context.sched);
1554
1555 auto box_size = sched.get_box_volume<Tvec>();
1556
1557 write_shamrock_boundaries_in_phantom_dump(
1558 solver.solver_config.boundary_config, box_size, dump, bypass_error_check);
1559
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);
1564
1565 write_shamrock_units_in_phantom_dump(solver.solver_config.unit_sys, dump, bypass_error_check);
1566
1567 PhantomDumpBlock block_part;
1568
1569 {
1570 NamedStackEntry stack_loc{"gather data"};
1571 std::vector<std::unique_ptr<shamrock::patch::PatchDataLayer>> gathered
1572 = ctx.allgather_data();
1573
1574 for (auto &dat : gathered) {
1575 add_pdat_to_phantom_block(block_part, shambase::get_check_ref(dat));
1576 }
1577 }
1578
1579 dump.blocks.push_back(std::move(block_part));
1580
1581 {
1582 auto &sync = shambase::get_check_ref(ctx.sched).synchronized_data;
1583 auto edges = get_sink_edges<Tvec>(sync);
1584 if (edges.has_sinks()) {
1585 auto sinks = to_sink_particles(edges);
1586 // add sinks to block 1
1587 PhantomDumpBlock sink_block;
1588
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");
1597
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());
1607 }
1608
1609 sink_block.tot_count = sinks.size();
1610
1611 dump.blocks.push_back(std::move(sink_block));
1612 }
1613 }
1614
1615 return dump;
1616}
1617
1618using namespace shammath;
1619
1623
constexpr const char * vxyz
3-velocity field
constexpr const char * xyz
Position field (3D coordinates).
Header file describing a Node Instance.
MPI scheduler.
double f64
Alias for double.
std::uint32_t u32
32 bit unsigned integer
std::uint64_t u64
64 bit unsigned integer
The MPI scheduler.
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.
Definition Timer.hpp:36
f64 elapsed_sec() const
Converts the stored nanosecond time to a floating point representation in seconds.
Definition Timer.hpp:88
void start()
Starts the timer.
Definition Timer.hpp:51
void stop()
Stops the timer and stores the elapsed time in nanoseconds.
Definition Timer.hpp:65
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.
Definition matrix.hpp:98
The shamrock SPH model.
Definition Model.hpp:56
void init()
Initialise the model and all the related data structures (patch scheduler in particular).
Definition Model.cpp:58
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.
Definition SimBox.hpp:248
PatchCoordTransform< T > get_patch_transform() const
Get a PatchCoordTransform object that describes the conversion between patch coordinates and domain c...
Definition SimBox.hpp:286
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...
Definition exchanges.hpp:98
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...
Definition memory.hpp:112
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.
Definition worldInfo.cpp:41
namespace for math utility
Definition AABB.hpp:26
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.
Definition logs.hpp:132
Helpers to access SPH sink particles stored as SoA synchronized data edges.
sph kernels
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.
Definition Patch.hpp:33
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
Definition Patch.hpp:210
u64 id_patch
unique key that identify the patch
Definition Patch.hpp:86