300 auto &sync_data = scheduler().synchronized_data;
303 auto ensure_sync_edge
304 = [&](
const std::string &name,
const std::string &tex_symbol,
auto init_value) {
305 using T =
decltype(init_value);
306 if (!sync_data.has_edge(name)) {
307 auto edge = sync_data.register_edge(
309 edge->data = std::move(init_value);
313 ensure_sync_edge(
"time",
"t", Tscal{0});
314 ensure_sync_edge(
"dt",
"dt", Tscal{0});
320 bool enable_mem_free =
false;
322 auto get_optional_free_mem = [&](
auto &bind_to,
auto &add_to) {
323 if (enable_mem_free) {
325 node.set_edges(bind_to);
326 add_to.push_back(std::make_shared<
decltype(node)>(std::move(node)));
331 storage.ghost_layout = std::make_shared<shamrock::patch::PatchDataLayerLayout>();
335 ghost_layout.
add_field<TgridVec>(
"cell_min", 1);
336 ghost_layout.
add_field<TgridVec>(
"cell_max", 1);
337 ghost_layout.
add_field<Tscal>(
"rho", AMRBlock::block_size);
338 ghost_layout.
add_field<Tscal>(
"rhoetot", AMRBlock::block_size);
339 ghost_layout.
add_field<Tvec>(
"rhovel", AMRBlock::block_size);
341 if (solver_config.is_dust_on()) {
342 auto ndust = solver_config.dust_config.ndust;
343 ghost_layout.
add_field<Tscal>(
"rho_dust", ndust * AMRBlock::block_size);
344 ghost_layout.
add_field<Tvec>(
"rhovel_dust", ndust * AMRBlock::block_size);
347 if (solver_config.is_gravity_on()) {
348 ghost_layout.
add_field<Tscal>(
"phi", AMRBlock::block_size);
349 ghost_layout.
add_field<Tscal>(
"phi_old", AMRBlock::block_size);
352 if (solver_config.is_gas_passive_scalar_on()) {
353 u32 npscal_gas = solver_config.npscal_gas_config.npscal_gas;
354 ghost_layout.
add_field<Tscal>(
"rho_gas_pscal", npscal_gas * AMRBlock::block_size);
362 using namespace shamrock::solvergraph;
369 "global_patch_boxes",
375 edge.
patch_tree = std::ref(storage.serial_patch_tree.get());
381 storage.local_patch_ids
382 = std::make_shared<shamrock::solvergraph::IDataEdge<std::vector<u64>>>(
"",
"");
385 = std::make_shared<shamrock::solvergraph::ScalarEdge<shammath::AABB<TgridVec>>>(
386 "sim_box",
"sim_box");
388 storage.exchange_gz_edge = std::make_shared<shamrock::solvergraph::PatchDataLayerDDShared>(
389 "exchange_gz_edge",
"exchange_gz_edge");
391 storage.idx_in_ghost = std::make_shared<shamrock::solvergraph::DDSharedBuffers<u32>>(
392 "idx_in_ghost",
"idx_in_ghost");
394 storage.ghost_layers_candidates_edge = std::make_shared<
396 "ghost_layers_candidates",
"ghost_layers_candidates");
398 storage.patch_rank_owner = std::make_shared<shamrock::solvergraph::RankGetter>(
399 [&](
u64 patch_id) ->
u32 {
400 return scheduler().get_patch_rank_owner(patch_id);
405 storage.source_patches = std::make_shared<shamrock::solvergraph::PatchDataLayerRefs>(
406 "source_patches",
"P_{\\rm source}");
408 storage.merged_patchdata_ghost = std::make_shared<shamrock::solvergraph::PatchDataLayerEdge>(
409 "merged_patchdata_ghost",
"patchdata_{\\rm ghost}", storage.ghost_layout);
412 = std::make_shared<shamrock::solvergraph::Indexes<u32>>(
"block_count",
"N_{\\rm block}");
414 storage.block_counts_with_ghost = std::make_shared<shamrock::solvergraph::Indexes<u32>>(
415 "block_count_with_ghost",
"N_{\\rm block, with ghost}");
418 storage.refs_block_min = std::make_shared<shamrock::solvergraph::FieldRefs<TgridVec>>(
419 "block_min",
"\\mathbf{r}_{\\rm block, min}");
420 storage.refs_block_max = std::make_shared<shamrock::solvergraph::FieldRefs<TgridVec>>(
421 "block_max",
"\\mathbf{r}_{\\rm block, max}");
423 storage.refs_rho = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>(
"rho",
"\\rho");
425 = std::make_shared<shamrock::solvergraph::FieldRefs<Tvec>>(
"rhovel",
"(\\rho \\mathbf{v})");
427 = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>(
"rhoetot",
"(\\rho E)");
429 if (solver_config.is_dust_on()) {
430 storage.refs_rho_dust = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>(
431 "rho_dust",
"\\rho_{\\rm dust}");
432 storage.refs_rhov_dust = std::make_shared<shamrock::solvergraph::FieldRefs<Tvec>>(
433 "rhovel_dust",
"(\\rho_{\\rm dust} \\mathbf{v}_{\\rm dust})");
437 storage.vel = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
438 AMRBlock::block_size,
"vel",
"\\mathbf{v}");
440 = std::make_shared<shamrock::solvergraph::Field<Tscal>>(AMRBlock::block_size,
"P",
"P");
442 if (!solver_config.amr_mode.old_amr) {
443 storage.rho_primitive = std::make_shared<shamrock::solvergraph::Field<Tscal>>(
444 AMRBlock::block_size,
"rho-prim",
"rho-prim");
449 if (std::get_if<AMRmode_None>(&solver_config.amr_mode.config) ==
nullptr) {
450 storage.rho_snap = std::make_shared<shamrock::solvergraph::Field<Tscal>>(
451 AMRBlock::block_size,
"rho_snap",
"rho_snap");
452 storage.rhoe_snap = std::make_shared<shamrock::solvergraph::Field<Tscal>>(
453 AMRBlock::block_size,
"rhoe_snap",
"rhoe_snap");
454 storage.rho_vel_snap = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
455 AMRBlock::block_size,
"rhov_snap",
"rhov_snap");
458 if (solver_config.is_dust_on()) {
459 u32 ndust = solver_config.dust_config.ndust;
462 storage.vel_dust = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
463 AMRBlock::block_size * ndust,
"vel_dust",
"{\\mathbf{v}_{\\rm dust}}");
467 = std::make_shared<solvergraph::TreeEdge<u_morton, TgridVec>>(
"trees",
"\\text{trees}");
469 storage.block_graph_edge = std::make_shared<
471 "block_graph_edge",
"\\text{block graph edge}");
473 storage.cell_graph_edge = std::make_shared<
475 "cell_graph_edge",
"\\text{cell graph edge}");
478 storage.block_cell_sizes = std::make_shared<shamrock::solvergraph::Field<Tscal>>(
479 1,
"block_cell_sizes",
"s_{\\rm cell}");
480 storage.cell0block_aabb_lower = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
481 1,
"cell0block_aabb_lower",
"\\mathbf{s}_{\\rm inf,block}");
483 if (solver_config.is_coordinate_field_required()) {
485 storage.coordinates = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
486 AMRBlock::block_size,
"coordinates",
"\\mathbf{r}");
489 if (solver_config.amr_mode.need_level_zero_compute()) {
491 storage.level0_size = std::make_shared<shamrock::solvergraph::ScalarsEdge<TgridVec>>(
492 "level0_amr",
"level0_amr");
495 if (solver_config.amr_mode.need_amr_level_compute()) {
496 using TgridUint =
typename std::make_unsigned<shambase::VecComponent<TgridVec>>::type;
497 storage.amr_block_levels
498 = std::make_shared<shamrock::solvergraph::Field<TgridUint>>(1,
"",
"");
501 storage.grad_rho = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
502 AMRBlock::block_size,
"grad_rho",
"\\nabla \\rho");
503 storage.dx_v = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
504 AMRBlock::block_size,
"dx_v",
"\\nabla_x \\mathbf{v}");
505 storage.dy_v = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
506 AMRBlock::block_size,
"dy_v",
"\\nabla_y \\mathbf{v}");
507 storage.dz_v = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
508 AMRBlock::block_size,
"dz_v",
"\\nabla_z \\mathbf{v}");
509 storage.grad_P = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
510 AMRBlock::block_size,
"grad_P",
"\\nabla P");
516 storage.euler_dt_rho = std::make_shared<shamrock::solvergraph::Field<Tscal>>(
517 AMRBlock::block_size,
"euler_dt_rho",
"\\partial_t \\rho");
518 storage.euler_dt_vel = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
519 AMRBlock::block_size,
"euler_dt_vel",
"\\partial_t \\mathbf{v}");
520 if (solver_config.eos_config.is_hydro_adiabatic()) {
521 storage.euler_dt_press = std::make_shared<shamrock::solvergraph::Field<Tscal>>(
522 AMRBlock::block_size,
"euler_dt_press",
"\\partial_t P");
525 if (solver_config.is_dust_on()) {
526 u32 ndust = solver_config.dust_config.ndust;
527 storage.grad_rho_dust = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
528 AMRBlock::block_size * ndust,
"grad_rho_dust",
"\\nabla \\rho_{\\rm dust}");
529 storage.dx_v_dust = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
530 AMRBlock::block_size * ndust,
"dx_v_dust",
"\\nabla_x \\mathbf{v}_{\\rm dust}");
531 storage.dy_v_dust = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
532 AMRBlock::block_size * ndust,
"dy_v_dust",
"\\nabla_y \\mathbf{v}_{\\rm dust}");
533 storage.dz_v_dust = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
534 AMRBlock::block_size * ndust,
"dz_v_dust",
"\\nabla_z \\mathbf{v}_{\\rm dust}");
537 storage.euler_dt_rho_dust = std::make_shared<shamrock::solvergraph::Field<Tscal>>(
538 AMRBlock::block_size * ndust,
"euler_dt_rho_dust",
"\\partial_t \\rho_{\\rm dust}");
539 storage.euler_dt_vel_dust = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
540 AMRBlock::block_size * ndust,
542 "\\partial_t \\mathbf{v}_{\\rm dust}");
548 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
549 "rho_face_xp",
"rho_face_xp", 1);
551 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
552 "rho_face_xm",
"rho_face_xm", 1);
554 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
555 "rho_face_yp",
"rho_face_yp", 1);
557 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
558 "rho_face_ym",
"rho_face_ym", 1);
560 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
561 "rho_face_zp",
"rho_face_zp", 1);
563 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
564 "rho_face_zm",
"rho_face_zm", 1);
567 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>>>(
568 "vel_face_xp",
"vel_face_xp", 1);
570 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>>>(
571 "vel_face_xm",
"vel_face_xm", 1);
573 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>>>(
574 "vel_face_yp",
"vel_face_yp", 1);
576 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>>>(
577 "vel_face_ym",
"vel_face_ym", 1);
579 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>>>(
580 "vel_face_zp",
"vel_face_zp", 1);
582 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>>>(
583 "vel_face_zm",
"vel_face_zm", 1);
585 storage.press_face_xp
586 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
587 "press_face_xp",
"press_face_xp", 1);
588 storage.press_face_xm
589 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
590 "press_face_xm",
"press_face_xm", 1);
591 storage.press_face_yp
592 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
593 "press_face_yp",
"press_face_yp", 1);
594 storage.press_face_ym
595 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
596 "press_face_ym",
"press_face_ym", 1);
597 storage.press_face_zp
598 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
599 "press_face_zp",
"press_face_zp", 1);
600 storage.press_face_zm
601 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
602 "press_face_zm",
"press_face_zm", 1);
605 if (solver_config.is_dust_on()) {
606 u32 ndust = solver_config.dust_config.ndust;
608 storage.rho_dust_face_xp
609 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
610 "rho_dust_face_xp",
"rho_dust_face_xp", ndust);
611 storage.rho_dust_face_xm
612 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
613 "rho_dust_face_xm",
"rho_dust_face_xm", ndust);
614 storage.rho_dust_face_yp
615 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
616 "rho_dust_face_yp",
"rho_dust_face_yp", ndust);
617 storage.rho_dust_face_ym
618 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
619 "rho_dust_face_ym",
"rho_dust_face_ym", ndust);
620 storage.rho_dust_face_zp
621 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
622 "rho_dust_face_zp",
"rho_dust_face_zp", ndust);
623 storage.rho_dust_face_zm
624 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tscal, 2>>>(
625 "rho_dust_face_zm",
"rho_dust_face_zm", ndust);
627 storage.vel_dust_face_xp
628 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>>>(
629 "vel_dust_face_xp",
"vel_dust_face_xp", ndust);
630 storage.vel_dust_face_xm
631 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>>>(
632 "vel_dust_face_xm",
"vel_dust_face_xm", ndust);
633 storage.vel_dust_face_yp
634 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>>>(
635 "vel_dust_face_yp",
"vel_dust_face_yp", ndust);
636 storage.vel_dust_face_ym
637 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>>>(
638 "vel_dust_face_ym",
"vel_dust_face_ym", ndust);
639 storage.vel_dust_face_zp
640 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>>>(
641 "vel_dust_face_zp",
"vel_dust_face_zp", ndust);
642 storage.vel_dust_face_zm
643 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<std::array<Tvec, 2>>>(
644 "vel_dust_face_zm",
"vel_dust_face_zm", ndust);
647 if (solver_config.should_compute_rho_mean()) {
648 storage.cell_mass = std::make_shared<shamrock::solvergraph::Field<Tscal>>(
649 AMRBlock::block_size,
"cell_mass",
"m");
651 = std::make_shared<shamrock::solvergraph::ScalarEdge<Tscal>>(
"rho_mean",
"< \\rho >");
652 storage.simulation_volume = std::make_shared<shamrock::solvergraph::ScalarEdge<Tscal>>(
653 "simulation_volume",
"V_{\\rm sim}");
656 storage.dt = std::make_shared<shamrock::solvergraph::ScalarEdge<Tscal>>(
"dt",
"\\Delta t");
658 = std::make_shared<shamrock::solvergraph::ScalarEdge<Tscal>>(
"dt_half",
"dt_{half}");
662 storage.flux_rho_face_xm = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
663 "flux_rho_face_xm",
"flux_rho_face_xm", 1);
665 storage.flux_rho_face_xp = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
666 "flux_rho_face_xp",
"flux_rho_face_xp", 1);
668 storage.flux_rho_face_ym = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
669 "flux_rho_face_ym",
"flux_rho_face_ym", 1);
671 storage.flux_rho_face_yp = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
672 "flux_rho_face_yp",
"flux_rho_face_yp", 1);
674 storage.flux_rho_face_zm = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
675 "flux_rho_face_zm",
"flux_rho_face_zm", 1);
677 storage.flux_rho_face_zp = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
678 "flux_rho_face_zp",
"flux_rho_face_zp", 1);
680 storage.flux_rhov_face_xm = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tvec>>(
681 "flux_rhov_face_xm",
"flux_rhov_face_xm", 1);
683 storage.flux_rhov_face_xp = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tvec>>(
684 "flux_rhov_face_xp",
"flux_rhov_face_xp", 1);
686 storage.flux_rhov_face_ym = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tvec>>(
687 "flux_rhov_face_ym",
"flux_rhov_face_ym", 1);
689 storage.flux_rhov_face_yp = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tvec>>(
690 "flux_rhov_face_yp",
"flux_rhov_face_yp", 1);
692 storage.flux_rhov_face_zm = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tvec>>(
693 "flux_rhov_face_zm",
"flux_rhov_face_zm", 1);
695 storage.flux_rhov_face_zp = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tvec>>(
696 "flux_rhov_face_zp",
"flux_rhov_face_zp", 1);
698 storage.flux_rhoe_face_xm = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
699 "flux_rhoe_face_xm",
"flux_rhoe_face_xm", 1);
701 storage.flux_rhoe_face_xp = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
702 "flux_rhoe_face_xp",
"flux_rhoe_face_xp", 1);
704 storage.flux_rhoe_face_ym = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
705 "flux_rhoe_face_ym",
"flux_rhoe_face_ym", 1);
707 storage.flux_rhoe_face_yp = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
708 "flux_rhoe_face_yp",
"flux_rhoe_face_yp", 1);
710 storage.flux_rhoe_face_zm = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
711 "flux_rhoe_face_zm",
"flux_rhoe_face_zm", 1);
713 storage.flux_rhoe_face_zp = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
714 "flux_rhoe_face_zp",
"flux_rhoe_face_zp", 1);
717 if (solver_config.is_dust_on()) {
718 u32 ndust = solver_config.dust_config.ndust;
720 storage.flux_rho_dust_face_xm
721 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
722 "flux_rho_dust_face_xm",
"flux_rho_dust_face_xm", ndust);
724 storage.flux_rho_dust_face_xp
725 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
726 "flux_rho_dust_face_xp",
"flux_rho_dust_face_xp", ndust);
728 storage.flux_rho_dust_face_ym
729 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
730 "flux_rho_dust_face_ym",
"flux_rho_dust_face_ym", ndust);
732 storage.flux_rho_dust_face_yp
733 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
734 "flux_rho_dust_face_yp",
"flux_rho_dust_face_yp", ndust);
736 storage.flux_rho_dust_face_zm
737 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
738 "flux_rho_dust_face_zm",
"flux_rho_dust_face_zm", ndust);
740 storage.flux_rho_dust_face_zp
741 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tscal>>(
742 "flux_rho_dust_face_zp",
"flux_rho_dust_face_zp", ndust);
744 storage.flux_rhov_dust_face_xm
745 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tvec>>(
746 "flux_rhov_dust_face_xm",
"flux_rhov_dust_face_xm", ndust);
748 storage.flux_rhov_dust_face_xp
749 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tvec>>(
750 "flux_rhov_dust_face_xp",
"flux_rhov_dust_face_xp", ndust);
752 storage.flux_rhov_dust_face_ym
753 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tvec>>(
754 "flux_rhov_dust_face_ym",
"flux_rhov_dust_face_ym", ndust);
756 storage.flux_rhov_dust_face_yp
757 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tvec>>(
758 "flux_rhov_dust_face_yp",
"flux_rhov_dust_face_yp", ndust);
760 storage.flux_rhov_dust_face_zm
761 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tvec>>(
762 "flux_rhov_dust_face_zm",
"flux_rhov_dust_face_zm", ndust);
764 storage.flux_rhov_dust_face_zp
765 = std::make_shared<solvergraph::NeighGraphLinkFieldEdge<Tvec>>(
766 "flux_rhov_dust_face_zp",
"flux_rhov_dust_face_zp", ndust);
769 storage.dtrho = std::make_shared<shamrock::solvergraph::Field<Tscal>>(
770 AMRBlock::block_size,
"dtrho",
"dtrho");
771 storage.dtrhov = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
772 AMRBlock::block_size,
"dtrhov",
"dtrhov");
773 storage.dtrhoe = std::make_shared<shamrock::solvergraph::Field<Tscal>>(
774 AMRBlock::block_size,
"dtrhoe",
"dtrhoe");
776 if (solver_config.is_dust_on()) {
777 u32 ndust = solver_config.dust_config.ndust;
778 storage.dtrho_dust = std::make_shared<shamrock::solvergraph::Field<Tscal>>(
779 AMRBlock::block_size * ndust,
"dtrho_dust",
"dtrho_dust");
780 storage.dtrhov_dust = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
781 AMRBlock::block_size * ndust,
"dtrhov_dust",
"dtrhov_dust");
787 std::vector<std::shared_ptr<shamrock::solvergraph::INode>> solver_sequence;
791 auto cfg_bc_to_geom = [](BCConfig::GhostType ghost_type) {
792 switch (ghost_type) {
793 case BCConfig::GhostType::Periodic :
return modules::GhostType::Periodic;
794 case BCConfig::GhostType::Reflective:
return modules::GhostType::Reflective;
795 case BCConfig::GhostType::Outflow :
return modules::GhostType::Reflective;
798 "Unsupported ghost type: " + std::to_string(
static_cast<int>(ghost_type)));
803 cfg_bc_to_geom(solver_config.bc_config.get_x()),
804 cfg_bc_to_geom(solver_config.bc_config.get_y()),
805 cfg_bc_to_geom(solver_config.bc_config.get_z())};
808 bool transform_vec_x = solver_config.bc_config.get_x() != BCConfig::GhostType::Outflow;
809 bool transform_vec_y = solver_config.bc_config.get_y() != BCConfig::GhostType::Outflow;
810 bool transform_vec_z = solver_config.bc_config.get_z() != BCConfig::GhostType::Outflow;
815 ghost_layer_gen_mode);
816 find_ghost_layer_candidates.set_edges(
817 storage.local_patch_ids,
818 storage.sim_box_edge,
821 storage.ghost_layers_candidates_edge);
822 solver_sequence.push_back(
823 std::make_shared<
decltype(find_ghost_layer_candidates)>(
824 std::move(find_ghost_layer_candidates)));
827 find_ghost_layer_indices.set_edges(
828 storage.sim_box_edge,
829 storage.source_patches,
830 storage.ghost_layers_candidates_edge,
832 storage.idx_in_ghost);
833 solver_sequence.push_back(
834 std::make_shared<
decltype(find_ghost_layer_indices)>(
835 std::move(find_ghost_layer_indices)));
839 std::vector<std::shared_ptr<shamrock::solvergraph::INode>> gz_xchg_sequence;
841 auto &ghost_layout_ptr = storage.ghost_layout;
843 auto copy_fields = std::make_shared<shamrock::solvergraph::CopyPatchDataLayerFields>(
844 scheduler().get_layout_ptr_old(), ghost_layout_ptr);
846 copy_fields->set_edges(storage.source_patches, storage.merged_patchdata_ghost);
847 gz_xchg_sequence.push_back(std::move(copy_fields));
852 = std::make_shared<shammodels::basegodunov::modules::ExtractGhostLayer>(
855 extract_gz_node->set_edges(
856 storage.merged_patchdata_ghost, storage.idx_in_ghost, storage.exchange_gz_edge);
857 gz_xchg_sequence.push_back(std::move(extract_gz_node));
861 auto transform_gz_node = std::make_shared<
863 ghost_layer_gen_mode,
869 transform_gz_node->set_edges(
870 storage.sim_box_edge,
871 storage.ghost_layers_candidates_edge,
872 storage.exchange_gz_edge);
873 gz_xchg_sequence.push_back(std::move(transform_gz_node));
877 auto exchange_gz_node
878 = std::make_shared<shamrock::solvergraph::ExchangeGhostLayer>(ghost_layout_ptr);
879 exchange_gz_node->set_edges(storage.patch_rank_owner, storage.exchange_gz_edge);
880 gz_xchg_sequence.push_back(std::move(exchange_gz_node));
885 = std::make_shared<shammodels::basegodunov::modules::FuseGhostLayer>();
886 fuse_gz_node->set_edges(storage.exchange_gz_edge, storage.merged_patchdata_ghost);
887 gz_xchg_sequence.push_back(std::move(fuse_gz_node));
904 "Ghost zone exchange", std::move(gz_xchg_sequence));
905 solver_sequence.push_back(std::make_shared<
decltype(seq)>(std::move(seq)));
913 extract_counts_node.set_edges(storage.source_patches, storage.block_counts);
914 solver_sequence.push_back(
915 std::make_shared<
decltype(extract_counts_node)>(std::move(extract_counts_node)));
921 extract_counts_node.set_edges(
922 storage.merged_patchdata_ghost, storage.block_counts_with_ghost);
923 solver_sequence.push_back(
924 std::make_shared<
decltype(extract_counts_node)>(std::move(extract_counts_node)));
930 attach_block_min.set_edges(storage.merged_patchdata_ghost, storage.refs_block_min);
931 solver_sequence.push_back(
932 std::make_shared<
decltype(attach_block_min)>(std::move(attach_block_min)));
936 attach_block_max.set_edges(storage.merged_patchdata_ghost, storage.refs_block_max);
937 solver_sequence.push_back(
938 std::make_shared<
decltype(attach_block_max)>(std::move(attach_block_max)));
944 attach_rho.set_edges(storage.merged_patchdata_ghost, storage.refs_rho);
945 solver_sequence.push_back(
946 std::make_shared<
decltype(attach_rho)>(std::move(attach_rho)));
950 attach_rhov.set_edges(storage.merged_patchdata_ghost, storage.refs_rhov);
951 solver_sequence.push_back(
952 std::make_shared<
decltype(attach_rhov)>(std::move(attach_rhov)));
956 storage.ghost_layout,
"rhoetot");
957 attach_rhoe.set_edges(storage.merged_patchdata_ghost, storage.refs_rhoe);
958 solver_sequence.push_back(
959 std::make_shared<
decltype(attach_rhoe)>(std::move(attach_rhoe)));
962 if (solver_config.is_dust_on()) {
965 storage.ghost_layout,
"rho_dust");
966 attach_rho_dust.set_edges(storage.merged_patchdata_ghost, storage.refs_rho_dust);
967 solver_sequence.push_back(
968 std::make_shared<
decltype(attach_rho_dust)>(std::move(attach_rho_dust)));
972 storage.ghost_layout,
"rhovel_dust");
973 attach_rhov_dust.set_edges(storage.merged_patchdata_ghost, storage.refs_rhov_dust);
974 solver_sequence.push_back(
975 std::make_shared<
decltype(attach_rhov_dust)>(std::move(attach_rhov_dust)));
983 storage.block_counts_with_ghost,
984 storage.refs_block_min,
985 storage.refs_block_max,
988 solver_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
992 std::vector<std::shared_ptr<shamrock::solvergraph::INode>> neigh_table_sequence;
996 storage.block_counts_with_ghost,
997 storage.refs_block_min,
998 storage.refs_block_max,
1000 storage.block_graph_edge);
1005 storage.block_counts_with_ghost,
1006 storage.refs_block_min,
1007 storage.refs_block_max,
1008 storage.block_graph_edge,
1009 storage.cell_graph_edge);
1012 neigh_table_sequence.push_back(std::make_shared<
decltype(node1)>(std::move(node1)));
1013 get_optional_free_mem(storage.trees, neigh_table_sequence);
1014 neigh_table_sequence.push_back(std::make_shared<
decltype(node2)>(std::move(node2)));
1015 get_optional_free_mem(storage.block_graph_edge, neigh_table_sequence);
1018 "Compute neigh table", std::move(neigh_table_sequence));
1019 solver_sequence.push_back(std::make_shared<
decltype(seq)>(std::move(seq)));
1025 AMRBlock::Nside, solver_config.grid_coord_to_pos_fact};
1028 storage.block_counts_with_ghost,
1029 storage.refs_block_min,
1030 storage.refs_block_max,
1031 storage.block_cell_sizes,
1032 storage.cell0block_aabb_lower);
1033 solver_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1036 if (solver_config.is_coordinate_field_required()) {
1039 AMRBlock::block_size,
1041 solver_config.grid_coord_to_pos_fact,
1044 node_coordinates.set_edges(
1045 storage.block_counts,
1046 storage.refs_block_min,
1047 storage.refs_block_max,
1048 storage.coordinates);
1050 solver_sequence.push_back(
1051 std::make_shared<
decltype(node_coordinates)>(std::move(node_coordinates)));
1054 if (solver_config.amr_mode.need_level_zero_compute()) {
1057 node_level0_sizes.set_edges(
1059 storage.source_patches,
1060 storage.level0_size);
1061 solver_sequence.push_back(
1062 std::make_shared<
decltype(node_level0_sizes)>(std::move(node_level0_sizes)));
1065 if (solver_config.amr_mode.need_amr_level_compute()) {
1067 node_amr_level.set_edges(
1068 storage.block_counts,
1069 storage.level0_size,
1070 storage.refs_block_min,
1071 storage.refs_block_max,
1072 storage.amr_block_levels);
1073 solver_sequence.push_back(
1074 std::make_shared<
decltype(node_amr_level)>(std::move(node_amr_level)));
1077 if (solver_config.should_compute_rho_mean()) {
1080 storage.block_counts, storage.block_cell_sizes, storage.refs_rho, storage.cell_mass);
1081 solver_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1085 storage.block_counts, storage.cell_mass, storage.simulation_volume, storage.rho_mean);
1086 solver_sequence.push_back(std::make_shared<
decltype(node2)>(std::move(node2)));
1090 std::vector<std::shared_ptr<shamrock::solvergraph::INode>> const_to_prim_sequence;
1092 auto push_adiabatic_node = [&](Tscal gamma) {
1095 storage.block_counts_with_ghost,
1102 const_to_prim_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1108 [&](
const typename EOS::Adiabatic &cfg) {
1109 push_adiabatic_node(cfg.gamma);
1111 [&](
const typename EOS::Barotropic &cfg) {
1113 AMRBlock::block_size, cfg.rho_crit, cfg.cs0, cfg.gamma};
1115 storage.block_counts_with_ghost,
1121 const_to_prim_sequence.push_back(
1122 std::make_shared<
decltype(node)>(std::move(node)));
1125 solver_config.eos_config.config);
1127 if (solver_config.is_dust_on()) {
1128 u32 ndust = solver_config.dust_config.ndust;
1131 storage.block_counts_with_ghost,
1132 storage.refs_rho_dust,
1133 storage.refs_rhov_dust,
1136 const_to_prim_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1140 "Cons to Prim", std::move(const_to_prim_sequence));
1141 solver_sequence.push_back(std::make_shared<
decltype(seq)>(std::move(seq)));
1146 std::vector<std::shared_ptr<shamrock::solvergraph::INode>> grad_sequence;
1150 AMRBlock::block_size, 1, solver_config.slope_config};
1152 storage.block_counts_with_ghost,
1153 storage.cell_graph_edge,
1154 storage.block_cell_sizes,
1157 grad_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1162 AMRBlock::block_size, 1, solver_config.slope_config};
1164 storage.block_counts_with_ghost,
1165 storage.cell_graph_edge,
1166 storage.block_cell_sizes,
1171 grad_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1175 AMRBlock::block_size, 1, solver_config.slope_config};
1177 storage.block_counts_with_ghost,
1178 storage.cell_graph_edge,
1179 storage.block_cell_sizes,
1182 grad_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1185 if (solver_config.is_dust_on()) {
1186 u32 ndust = solver_config.dust_config.ndust;
1188 AMRBlock::block_size, ndust, solver_config.slope_config};
1190 storage.block_counts_with_ghost,
1191 storage.cell_graph_edge,
1192 storage.block_cell_sizes,
1193 storage.refs_rho_dust,
1194 storage.grad_rho_dust);
1195 grad_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1198 AMRBlock::block_size, ndust, solver_config.slope_config};
1200 storage.block_counts_with_ghost,
1201 storage.cell_graph_edge,
1202 storage.block_cell_sizes,
1207 grad_sequence.push_back(std::make_shared<
decltype(node2)>(std::move(node2)));
1211 "Slope limited gradients", std::move(grad_sequence));
1212 solver_sequence.push_back(std::make_shared<
decltype(seq)>(std::move(seq)));
1219 std::vector<std::shared_ptr<shamrock::solvergraph::INode>> dt_prim_sequence;
1222 auto push_adiabatic_node = [&](Tscal gamma) {
1224 AMRBlock::block_size, gamma};
1226 storage.block_counts_with_ghost,
1235 storage.euler_dt_rho,
1236 storage.euler_dt_vel,
1237 storage.euler_dt_press);
1238 dt_prim_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1244 [&](
const typename EOS::Adiabatic &cfg) {
1245 push_adiabatic_node(cfg.gamma);
1247 [&](
const typename EOS::Barotropic &) {
1249 AMRBlock::block_size};
1251 storage.block_counts_with_ghost,
1259 storage.euler_dt_rho,
1260 storage.euler_dt_vel);
1261 dt_prim_sequence.push_back(
1262 std::make_shared<
decltype(node)>(std::move(node)));
1265 solver_config.eos_config.config);
1268 if (solver_config.is_dust_on()) {
1269 u32 ndust = solver_config.dust_config.ndust;
1272 storage.block_counts_with_ghost,
1273 storage.refs_rho_dust,
1275 storage.grad_rho_dust,
1279 storage.euler_dt_rho_dust,
1280 storage.euler_dt_vel_dust);
1281 dt_prim_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1285 "Euler time derivatives", std::move(dt_prim_sequence));
1286 solver_sequence.push_back(std::make_shared<
decltype(seq)>(std::move(seq)));
1290 std::vector<std::shared_ptr<shamrock::solvergraph::INode>> interp_sequence;
1295 storage.cell_graph_edge,
1296 storage.block_cell_sizes,
1297 storage.cell0block_aabb_lower,
1300 storage.euler_dt_rho,
1301 storage.rho_face_xp,
1302 storage.rho_face_xm,
1303 storage.rho_face_yp,
1304 storage.rho_face_ym,
1305 storage.rho_face_zp,
1306 storage.rho_face_zm);
1307 interp_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1314 storage.cell_graph_edge,
1315 storage.block_cell_sizes,
1316 storage.cell0block_aabb_lower,
1321 storage.euler_dt_vel,
1322 storage.vel_face_xp,
1323 storage.vel_face_xm,
1324 storage.vel_face_yp,
1325 storage.vel_face_ym,
1326 storage.vel_face_zp,
1327 storage.vel_face_zm);
1328 interp_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1333 if (solver_config.eos_config.is_hydro_adiabatic()) {
1337 storage.cell_graph_edge,
1338 storage.block_cell_sizes,
1339 storage.cell0block_aabb_lower,
1342 storage.euler_dt_press,
1343 storage.press_face_xp,
1344 storage.press_face_xm,
1345 storage.press_face_yp,
1346 storage.press_face_ym,
1347 storage.press_face_zp,
1348 storage.press_face_zm);
1349 interp_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1352 if (solver_config.is_dust_on()) {
1353 u32 ndust = solver_config.dust_config.ndust;
1357 storage.cell_graph_edge,
1358 storage.block_cell_sizes,
1359 storage.cell0block_aabb_lower,
1360 storage.refs_rho_dust,
1361 storage.grad_rho_dust,
1362 storage.euler_dt_rho_dust,
1363 storage.rho_dust_face_xp,
1364 storage.rho_dust_face_xm,
1365 storage.rho_dust_face_yp,
1366 storage.rho_dust_face_ym,
1367 storage.rho_dust_face_zp,
1368 storage.rho_dust_face_zm);
1369 interp_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1372 if (solver_config.is_dust_on()) {
1373 u32 ndust = solver_config.dust_config.ndust;
1377 storage.cell_graph_edge,
1378 storage.block_cell_sizes,
1379 storage.cell0block_aabb_lower,
1384 storage.euler_dt_vel_dust,
1385 storage.vel_dust_face_xp,
1386 storage.vel_dust_face_xm,
1387 storage.vel_dust_face_yp,
1388 storage.vel_dust_face_ym,
1389 storage.vel_dust_face_zp,
1390 storage.vel_dust_face_zm);
1391 interp_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1395 "Interpolate to face", std::move(interp_sequence));
1396 solver_sequence.push_back(std::make_shared<
decltype(seq)>(std::move(seq)));
1401 std::vector<std::shared_ptr<shamrock::solvergraph::INode>> flux_sequence;
1404 auto push_gas_flux_node = [&](
auto mode_tag) {
1405 constexpr modules::RiemannSolverMode mode =
decltype(mode_tag)::value;
1408 solver_config.get_eos_gamma(),
1409 storage.cell_graph_edge,
1410 storage.rho_face_xp,
1411 storage.rho_face_xm,
1412 storage.rho_face_yp,
1413 storage.rho_face_ym,
1414 storage.rho_face_zp,
1415 storage.rho_face_zm,
1416 storage.vel_face_xp,
1417 storage.vel_face_xm,
1418 storage.vel_face_yp,
1419 storage.vel_face_ym,
1420 storage.vel_face_zp,
1421 storage.vel_face_zm,
1422 storage.press_face_xp,
1423 storage.press_face_xm,
1424 storage.press_face_yp,
1425 storage.press_face_ym,
1426 storage.press_face_zp,
1427 storage.press_face_zm,
1428 storage.flux_rho_face_xp,
1429 storage.flux_rho_face_xm,
1430 storage.flux_rho_face_yp,
1431 storage.flux_rho_face_ym,
1432 storage.flux_rho_face_zp,
1433 storage.flux_rho_face_zm,
1434 storage.flux_rhov_face_xp,
1435 storage.flux_rhov_face_xm,
1436 storage.flux_rhov_face_yp,
1437 storage.flux_rhov_face_ym,
1438 storage.flux_rhov_face_zp,
1439 storage.flux_rhov_face_zm,
1440 storage.flux_rhoe_face_xp,
1441 storage.flux_rhoe_face_xm,
1442 storage.flux_rhoe_face_yp,
1443 storage.flux_rhoe_face_ym,
1444 storage.flux_rhoe_face_zp,
1445 storage.flux_rhoe_face_zm);
1446 flux_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1449 using RSM = modules::RiemannSolverMode;
1450 switch (solver_config.riemann_config) {
1451 case RSM::Rusanov: push_gas_flux_node(std::integral_constant<RSM, RSM::Rusanov>{});
break;
1452 case RSM::HLL : push_gas_flux_node(std::integral_constant<RSM, RSM::HLL>{});
break;
1453 case RSM::HLLC_PVRS:
1454 push_gas_flux_node(std::integral_constant<RSM, RSM::HLLC_PVRS>{});
1456 case RSM::HLLC_Davis:
1457 push_gas_flux_node(std::integral_constant<RSM, RSM::HLLC_Davis>{});
1459 case RSM::HLLC_RAMSES:
1460 push_gas_flux_node(std::integral_constant<RSM, RSM::HLLC_RAMSES>{});
1465 if (solver_config.is_dust_on()) {
1466 u32 ndust = solver_config.dust_config.ndust;
1467 if (solver_config.dust_config.dust_riemann_config ==
DHLL) {
1469 NodeComputeFluxDustMode<Tvec, TgridVec, modules::DustRiemannSolverMode::DHLL>
1471 "Dust flux compute",
1473 storage.cell_graph_edge,
1474 storage.rho_dust_face_xp,
1475 storage.rho_dust_face_xm,
1476 storage.rho_dust_face_yp,
1477 storage.rho_dust_face_ym,
1478 storage.rho_dust_face_zp,
1479 storage.rho_dust_face_zm,
1480 storage.vel_dust_face_xp,
1481 storage.vel_dust_face_xm,
1482 storage.vel_dust_face_yp,
1483 storage.vel_dust_face_ym,
1484 storage.vel_dust_face_zp,
1485 storage.vel_dust_face_zm,
1486 storage.flux_rho_dust_face_xp,
1487 storage.flux_rho_dust_face_xm,
1488 storage.flux_rho_dust_face_yp,
1489 storage.flux_rho_dust_face_ym,
1490 storage.flux_rho_dust_face_zp,
1491 storage.flux_rho_dust_face_zm,
1492 storage.flux_rhov_dust_face_xp,
1493 storage.flux_rhov_dust_face_xm,
1494 storage.flux_rhov_dust_face_yp,
1495 storage.flux_rhov_dust_face_ym,
1496 storage.flux_rhov_dust_face_zp,
1497 storage.flux_rhov_dust_face_zm);
1498 flux_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1499 }
else if (solver_config.dust_config.dust_riemann_config ==
HB) {
1502 "Dust flux compute",
1504 storage.cell_graph_edge,
1505 storage.rho_dust_face_xp,
1506 storage.rho_dust_face_xm,
1507 storage.rho_dust_face_yp,
1508 storage.rho_dust_face_ym,
1509 storage.rho_dust_face_zp,
1510 storage.rho_dust_face_zm,
1511 storage.vel_dust_face_xp,
1512 storage.vel_dust_face_xm,
1513 storage.vel_dust_face_yp,
1514 storage.vel_dust_face_ym,
1515 storage.vel_dust_face_zp,
1516 storage.vel_dust_face_zm,
1517 storage.flux_rho_dust_face_xp,
1518 storage.flux_rho_dust_face_xm,
1519 storage.flux_rho_dust_face_yp,
1520 storage.flux_rho_dust_face_ym,
1521 storage.flux_rho_dust_face_zp,
1522 storage.flux_rho_dust_face_zm,
1523 storage.flux_rhov_dust_face_xp,
1524 storage.flux_rhov_dust_face_xm,
1525 storage.flux_rhov_dust_face_yp,
1526 storage.flux_rhov_dust_face_ym,
1527 storage.flux_rhov_dust_face_zp,
1528 storage.flux_rhov_dust_face_zm);
1529 flux_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1536 solver_sequence.push_back(std::make_shared<
decltype(seq)>(std::move(seq)));
1541 AMRBlock::block_size, solver_config.grid_coord_to_pos_fact};
1543 storage.block_counts,
1544 storage.cell_graph_edge,
1545 storage.block_cell_sizes,
1546 storage.cell0block_aabb_lower,
1547 storage.flux_rho_face_xp,
1548 storage.flux_rho_face_xm,
1549 storage.flux_rho_face_yp,
1550 storage.flux_rho_face_ym,
1551 storage.flux_rho_face_zp,
1552 storage.flux_rho_face_zm,
1553 storage.flux_rhov_face_xp,
1554 storage.flux_rhov_face_xm,
1555 storage.flux_rhov_face_yp,
1556 storage.flux_rhov_face_ym,
1557 storage.flux_rhov_face_zp,
1558 storage.flux_rhov_face_zm,
1559 storage.flux_rhoe_face_xp,
1560 storage.flux_rhoe_face_xm,
1561 storage.flux_rhoe_face_yp,
1562 storage.flux_rhoe_face_ym,
1563 storage.flux_rhoe_face_zp,
1564 storage.flux_rhoe_face_zm,
1568 solver_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1571 if (solver_config.is_dust_on()) {
1573 AMRBlock::block_size,
1574 solver_config.grid_coord_to_pos_fact,
1575 solver_config.dust_config.ndust};
1577 storage.block_counts,
1578 storage.cell_graph_edge,
1579 storage.block_cell_sizes,
1580 storage.cell0block_aabb_lower,
1581 storage.flux_rho_dust_face_xp,
1582 storage.flux_rho_dust_face_xm,
1583 storage.flux_rho_dust_face_yp,
1584 storage.flux_rho_dust_face_ym,
1585 storage.flux_rho_dust_face_zp,
1586 storage.flux_rho_dust_face_zm,
1587 storage.flux_rhov_dust_face_xp,
1588 storage.flux_rhov_dust_face_xm,
1589 storage.flux_rhov_dust_face_yp,
1590 storage.flux_rhov_dust_face_ym,
1591 storage.flux_rhov_dust_face_zp,
1592 storage.flux_rhov_dust_face_zm,
1594 storage.dtrhov_dust);
1595 solver_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1598 if (solver_config.has_ext_forces() || solver_config.is_gravity_on()) {
1608 const bool trapezoidal
1611 std::vector<std::shared_ptr<shamrock::solvergraph::INode>> ext_force_sequence;
1614 storage.a_ext = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
1615 AMRBlock::block_size,
"a_ext",
"\\mathbf{a}_{\\rm ext}^{n}");
1616 storage.a_ext_next = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
1617 AMRBlock::block_size,
"a_ext_next",
"\\mathbf{a}_{\\rm ext}^{n+1}");
1619 storage.a_ext = std::make_shared<shamrock::solvergraph::Field<Tvec>>(
1620 AMRBlock::block_size,
"a_ext",
"\\mathbf{a}_{\\rm ext}");
1626 std::vector<std::pair<std::shared_ptr<shamrock::solvergraph::Field<Tvec>>, Tscal>>
1629 a_ext_levels.push_back({storage.a_ext, Tscal{0}});
1630 a_ext_levels.push_back({storage.a_ext_next, Tscal{1}});
1632 a_ext_levels.push_back({storage.a_ext, Tscal{0.5}});
1636 for (
auto &[a_ext_level, dt_level] : a_ext_levels) {
1638 node.set_edges(storage.block_counts, a_ext_level);
1639 ext_force_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1645 auto attach_source_field = [&]<
class T>(
1646 std::shared_ptr<shamrock::solvergraph::FieldRefs<T>> &refs,
1647 const std::string &field_name) {
1649 attach.set_edges(storage.source_patches, refs);
1650 ext_force_sequence.push_back(std::make_shared<
decltype(attach)>(std::move(attach)));
1653 if (solver_config.is_gravity_on()) {
1659 const u32 block_size = AMRBlock::block_size;
1661 storage.refs_phi = std::make_shared<FieldRefs<Tscal>>(
"phi_old",
"\\phi^{n}");
1662 storage.refs_phi_new = std::make_shared<FieldRefs<Tscal>>(
"phi",
"\\phi^{n+1}");
1664 = std::make_shared<Field<Tscal>>(block_size,
"rho_next",
"\\rho^{n+1}");
1666 = std::make_shared<Field<Tvec>>(block_size,
"phi_g",
"\\mathbf{g}_{\\rm sg}");
1668 auto &work = storage.poisson_work;
1669 auto field = [&](
const std::string &name) {
1670 return std::make_shared<Field<Tscal>>(block_size, name, name);
1672 auto scal = [&](
const std::string &name) {
1673 return IDataEdge<Tscal>::make_shared(name, name);
1675 work.res = field(
"phi_res");
1676 work.res_bis = field(
"phi_res_bis");
1677 work.p = field(
"phi_p");
1678 work.a_p = field(
"phi_Ap");
1679 work.s = field(
"phi_s");
1680 work.a_s = field(
"phi_As");
1681 work.z = field(
"phi_z");
1682 work.rhs = field(
"phi_rhs");
1683 work.hadamard_prod = field(
"phi_hadamard_prod");
1684 work.rz_hadamard_prod = field(
"rz_hadamard_prod");
1685 work.old_values = scal(
"old_values");
1686 work.new_values = scal(
"new_values");
1687 work.e_norm = scal(
"e_norm");
1688 work.alpha = scal(
"alpha");
1689 work.beta = scal(
"beta");
1690 work.w_stab = scal(
"w_stab");
1691 work.shadow_res_norm = scal(
"shadow_res_norm");
1692 work.rhs_norm = scal(
"rhs_norm");
1693 work.rz_old_values = scal(
"rz_old_values");
1694 work.rz_new_values = scal(
"rz_new_values");
1698 std::shared_ptr<ScalarEdge<Tscal>> rho_mean_n, rho_mean_np1;
1699 if (solver_config.should_compute_rho_mean()) {
1700 storage.rho_mean_next
1701 = std::make_shared<ScalarEdge<Tscal>>(
"rho_mean_next",
"< \\rho^{n+1} >");
1702 rho_mean_n = storage.rho_mean;
1703 rho_mean_np1 = storage.rho_mean_next;
1705 rho_mean_n = std::make_shared<ScalarEdge<Tscal>>(
"rho_mean_zero",
"0");
1706 rho_mean_n->value = 0;
1707 rho_mean_np1 = rho_mean_n;
1714 attach_phi.set_edges(storage.merged_patchdata_ghost, storage.refs_phi);
1715 ext_force_sequence.push_back(
1716 std::make_shared<
decltype(attach_phi)>(std::move(attach_phi)));
1719 attach_phi_new.set_edges(storage.merged_patchdata_ghost, storage.refs_phi_new);
1720 ext_force_sequence.push_back(
1721 std::make_shared<
decltype(attach_phi_new)>(std::move(attach_phi_new)));
1724 for (
auto &[a_ext_level, dt_level] : a_ext_levels) {
1726 std::shared_ptr<IFieldSpan<Tscal>> rho_level;
1727 std::shared_ptr<ScalarEdge<Tscal>> rho_mean_level;
1728 std::shared_ptr<FieldRefs<Tscal>> phi_level;
1730 if (dt_level == 0) {
1731 rho_level = storage.refs_rho;
1732 rho_mean_level = rho_mean_n;
1733 phi_level = storage.refs_phi;
1734 }
else if (dt_level == 1) {
1738 node_rho_next.set_edges(
1740 storage.block_counts,
1741 storage.block_counts_with_ghost,
1745 ext_force_sequence.push_back(
1746 std::make_shared<
decltype(node_rho_next)>(std::move(node_rho_next)));
1748 if (solver_config.should_compute_rho_mean()) {
1750 node_mass.set_edges(
1751 storage.block_counts,
1752 storage.block_cell_sizes,
1755 ext_force_sequence.push_back(
1756 std::make_shared<
decltype(node_mass)>(std::move(node_mass)));
1759 node_mean.set_edges(
1760 storage.block_counts,
1762 storage.simulation_volume,
1763 storage.rho_mean_next);
1764 ext_force_sequence.push_back(
1765 std::make_shared<
decltype(node_mean)>(std::move(node_mean)));
1768 rho_level = storage.rho_next;
1769 rho_mean_level = rho_mean_np1;
1770 phi_level = storage.refs_phi_new;
1773 sham::format(
"self-gravity at the time level t^n + {} dt", dt_level));
1777 switch (solver_config.gravity_config.gravity_mode) {
1781 solver_config.get_constant_4piG(),
1782 solver_config.gravity_config.Niter_max,
1783 solver_config.get_grav_tol()};
1785 storage.block_counts_with_ghost,
1786 storage.block_counts,
1787 storage.cell_graph_edge,
1788 storage.block_cell_sizes,
1791 storage.idx_in_ghost,
1792 storage.patch_rank_owner,
1808 work.rz_hadamard_prod);
1809 ext_force_sequence.push_back(
1810 std::make_shared<
decltype(node)>(std::move(node)));
1816 solver_config.get_constant_4piG(),
1817 solver_config.gravity_config.Niter_max,
1818 solver_config.get_grav_tol(),
1819 solver_config.get_happy_bk_grav_tol()};
1821 storage.block_counts_with_ghost,
1822 storage.block_counts,
1823 storage.cell_graph_edge,
1824 storage.block_cell_sizes,
1827 storage.idx_in_ghost,
1828 storage.patch_rank_owner,
1843 work.shadow_res_norm,
1846 ext_force_sequence.push_back(
1847 std::make_shared<
decltype(node)>(std::move(node)));
1852 "self-gravity: only the cg and bicgstab Poisson solvers are "
1860 storage.block_counts,
1861 storage.cell_graph_edge,
1862 storage.block_cell_sizes,
1865 ext_force_sequence.push_back(
1866 std::make_shared<
decltype(node)>(std::move(node)));
1871 node.set_edges(storage.block_counts, storage.phi_g, a_ext_level);
1872 ext_force_sequence.push_back(
1873 std::make_shared<
decltype(node)>(std::move(node)));
1879 auto refs_phi_source
1880 = std::make_shared<FieldRefs<Tscal>>(
"phi_old_source",
"\\phi^{n}");
1881 auto refs_phi_new_source
1882 = std::make_shared<FieldRefs<Tscal>>(
"phi_source",
"\\phi^{n+1}");
1883 attach_source_field(refs_phi_source,
"phi_old");
1884 attach_source_field(refs_phi_new_source,
"phi");
1887 copy_phi.set_edges(storage.refs_phi, refs_phi_source);
1888 ext_force_sequence.push_back(
1889 std::make_shared<
decltype(copy_phi)>(std::move(copy_phi)));
1892 copy_phi_new.set_edges(storage.refs_phi_new, refs_phi_new_source);
1893 ext_force_sequence.push_back(
1894 std::make_shared<
decltype(copy_phi_new)>(std::move(copy_phi_new)));
1898 "self-gravity requires the trapezoidal coupling of the external forces");
1910 for (
const auto &var_force : solver_config.ext_force_config.ext_forces) {
1913 [&](
const ConstantGravity &cfg) {
1915 for (
auto &[a_ext_level, dt_level] : a_ext_levels) {
1917 AMRBlock::block_size, cfg.g};
1918 node.set_edges(storage.block_counts, a_ext_level);
1919 ext_force_sequence.push_back(
1920 std::make_shared<
decltype(node)>(std::move(node)));
1923 [&](
const PointMassGravity &cfg) {
1924 for (
auto &[a_ext_level, dt_level] : a_ext_levels) {
1929 = std::make_shared<shamrock::solvergraph::ScalarEdge<Tscal>>(
1931 constant_G->value = solver_config.get_constant_G();
1934 AMRBlock::block_size, cfg.mass, cfg.pos, cfg.epsilon_soft};
1936 storage.block_counts, storage.coordinates, constant_G, a_ext_level);
1937 ext_force_sequence.push_back(
1938 std::make_shared<
decltype(node)>(std::move(node)));
1947 = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>(
"rho_source",
"\\rho");
1948 auto refs_rhov = std::make_shared<shamrock::solvergraph::FieldRefs<Tvec>>(
1949 "rhovel_source",
"(\\rho \\mathbf{v})");
1950 auto refs_rhoe = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>(
1951 "rhoetot_source",
"(\\rho E)");
1953 attach_source_field(refs_rho,
"rho");
1954 attach_source_field(refs_rhov,
"rhovel");
1955 attach_source_field(refs_rhoe,
"rhoetot");
1961 storage.block_counts,
1969 ext_force_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1974 storage.block_counts,
1981 ext_force_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
1985 if (solver_config.is_dust_on()) {
1986 auto refs_rho_dust = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>(
1987 "rho_dust_source",
"\\rho_{\\rm dust}");
1988 auto refs_rhov_dust = std::make_shared<shamrock::solvergraph::FieldRefs<Tvec>>(
1989 "rhovel_dust_source",
"(\\rho_{\\rm dust} \\mathbf{v}_{\\rm dust})");
1991 attach_source_field(refs_rho_dust,
"rho_dust");
1992 attach_source_field(refs_rhov_dust,
"rhovel_dust");
1996 AMRBlock::block_size, solver_config.dust_config.ndust};
1999 storage.block_counts,
2005 ext_force_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
2008 AMRBlock::block_size, solver_config.dust_config.ndust};
2011 storage.block_counts,
2016 ext_force_sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
2021 "External forces", std::move(ext_force_sequence));
2022 solver_sequence.push_back(std::make_shared<
decltype(seq)>(std::move(seq)));
2030 auto attach_source_field = [&]<
class T>(
2031 std::vector<std::shared_ptr<INode>> &sequence,
2032 std::shared_ptr<FieldRefs<T>> &refs,
2033 const std::string &field_name) {
2035 attach.set_edges(storage.source_patches, refs);
2036 sequence.push_back(std::make_shared<
decltype(attach)>(std::move(attach)));
2041 auto add_forward_euler_before_drag = [&]() {
2042 const u32 ndust = solver_config.dust_config.ndust;
2044 storage.rho_next_no_drag = std::make_shared<Field<Tscal>>(
2045 AMRBlock::block_size,
"rho_next_bf_drag",
"\\rho^{n+1}_{\\rm no\\,drag}");
2046 storage.rhov_next_no_drag = std::make_shared<Field<Tvec>>(
2047 AMRBlock::block_size,
2048 "rhov_next_bf_drag",
2049 "(\\rho \\mathbf{v})^{n+1}_{\\rm no\\,drag}");
2050 storage.rhoe_next_no_drag = std::make_shared<Field<Tscal>>(
2051 AMRBlock::block_size,
"rhoe_next_bf_drag",
"(\\rho E)^{n+1}_{\\rm no\\,drag}");
2052 storage.rho_d_next_no_drag = std::make_shared<Field<Tscal>>(
2053 ndust * AMRBlock::block_size,
2054 "rho_d_next_bf_drag",
2055 "\\rho^{n+1}_{\\rm dust,\\,no\\,drag}");
2056 storage.rhov_d_next_no_drag = std::make_shared<Field<Tvec>>(
2057 ndust * AMRBlock::block_size,
2058 "rhov_d_next_bf_drag",
2059 "(\\rho_{\\rm dust} \\mathbf{v}_{\\rm dust})^{n+1}_{\\rm no\\,drag}");
2061 std::vector<std::shared_ptr<INode>> sequence;
2063 auto copy_source_field = [&]<
class T>(
2064 const std::string &field_name,
2065 const std::string &label,
2066 const std::string &tex,
2067 const std::shared_ptr<Field<T>> &target) {
2068 auto refs = std::make_shared<FieldRefs<T>>(label, tex);
2069 attach_source_field(sequence, refs, field_name);
2072 copy.set_edges(refs, target);
2073 sequence.push_back(std::make_shared<
decltype(copy)>(std::move(copy)));
2076 copy_source_field(
"rho",
"rho_source",
"\\rho", storage.rho_next_no_drag);
2078 "rhovel",
"rhovel_source",
"(\\rho \\mathbf{v})", storage.rhov_next_no_drag);
2079 copy_source_field(
"rhoetot",
"rhoetot_source",
"(\\rho E)", storage.rhoe_next_no_drag);
2081 "rho_dust",
"rho_dust_source",
"\\rho_{\\rm dust}", storage.rho_d_next_no_drag);
2084 "rhovel_dust_source",
2085 "(\\rho_{\\rm dust} \\mathbf{v}_{\\rm dust})",
2086 storage.rhov_d_next_no_drag);
2092 storage.block_counts,
2096 storage.rho_next_no_drag,
2097 storage.rhov_next_no_drag,
2098 storage.rhoe_next_no_drag);
2099 sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
2106 storage.block_counts,
2108 storage.dtrhov_dust,
2109 storage.rho_d_next_no_drag,
2110 storage.rhov_d_next_no_drag);
2111 sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
2115 solver_sequence.push_back(std::make_shared<
decltype(seq)>(std::move(seq)));
2119 auto add_drag = [&]<
class NodeDrag>(const std::string &name) {
2120 const u32 ndust = solver_config.dust_config.ndust;
2122 std::vector<std::shared_ptr<INode>> sequence;
2124 auto refs_rho = std::make_shared<FieldRefs<Tscal>>(
"rho_source",
"\\rho");
2126 = std::make_shared<FieldRefs<Tvec>>(
"rhovel_source",
"(\\rho \\mathbf{v})");
2127 auto refs_rhoe = std::make_shared<FieldRefs<Tscal>>(
"rhoetot_source",
"(\\rho E)");
2129 = std::make_shared<FieldRefs<Tscal>>(
"rho_dust_source",
"\\rho_{\\rm dust}");
2130 auto refs_rhov_dust = std::make_shared<FieldRefs<Tvec>>(
2131 "rhovel_dust_source",
"(\\rho_{\\rm dust} \\mathbf{v}_{\\rm dust})");
2133 attach_source_field(sequence, refs_rho,
"rho");
2134 attach_source_field(sequence, refs_rhov,
"rhovel");
2135 attach_source_field(sequence, refs_rhoe,
"rhoetot");
2136 attach_source_field(sequence, refs_rho_dust,
"rho_dust");
2137 attach_source_field(sequence, refs_rhov_dust,
"rhovel_dust");
2141 const auto &alphas = solver_config.drag_config.alphas;
2144 AMRBlock::block_size,
2146 std::vector<Tscal>(alphas.begin(), alphas.end()),
2147 solver_config.drag_config.enable_frictional_heating};
2150 storage.block_counts,
2151 storage.rho_next_no_drag,
2152 storage.rhov_next_no_drag,
2153 storage.rhoe_next_no_drag,
2154 storage.rho_d_next_no_drag,
2155 storage.rhov_d_next_no_drag,
2161 sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
2165 solver_sequence.push_back(std::make_shared<
decltype(seq)>(std::move(seq)));
2168 if (solver_config.drag_config.drag_solver_config == DragSolverMode::NoDrag) {
2170 std::vector<std::shared_ptr<INode>> sequence;
2173 auto refs_rho = std::make_shared<FieldRefs<Tscal>>(
"rho_source",
"\\rho");
2175 = std::make_shared<FieldRefs<Tvec>>(
"rhovel_source",
"(\\rho \\mathbf{v})");
2176 auto refs_rhoe = std::make_shared<FieldRefs<Tscal>>(
"rhoetot_source",
"(\\rho E)");
2178 attach_source_field(sequence, refs_rho,
"rho");
2179 attach_source_field(sequence, refs_rhov,
"rhovel");
2180 attach_source_field(sequence, refs_rhoe,
"rhoetot");
2185 storage.block_counts,
2192 sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
2195 if (solver_config.is_dust_on()) {
2197 = std::make_shared<FieldRefs<Tscal>>(
"rho_dust_source",
"\\rho_{\\rm dust}");
2198 auto refs_rhov_dust = std::make_shared<FieldRefs<Tvec>>(
2199 "rhovel_dust_source",
"(\\rho_{\\rm dust} \\mathbf{v}_{\\rm dust})");
2201 attach_source_field(sequence, refs_rho_dust,
"rho_dust");
2202 attach_source_field(sequence, refs_rhov_dust,
"rhovel_dust");
2205 AMRBlock::block_size, solver_config.dust_config.ndust};
2208 storage.block_counts,
2210 storage.dtrhov_dust,
2213 sequence.push_back(std::make_shared<
decltype(node)>(std::move(node)));
2217 solver_sequence.push_back(std::make_shared<
decltype(seq)>(std::move(seq)));
2219 }
else if (solver_config.drag_config.drag_solver_config == DragSolverMode::IRK1) {
2220 add_forward_euler_before_drag();
2222 }
else if (solver_config.drag_config.drag_solver_config == DragSolverMode::EXPO) {
2223 add_forward_euler_before_drag();
2231 storage.solver_sequence = std::make_shared<decltype(seq)>(std::move(seq));