Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <limits>
       7             : #include <vector>
       8             : 
       9             : #include "DataStructures/DataBox/DataBox.hpp"
      10             : #include "Domain/Structure/ElementId.hpp"
      11             : #include "Parallel/ElementRegistration.hpp"
      12             : #include "Parallel/GlobalCache.hpp"
      13             : #include "Parallel/Invoke.hpp"
      14             : #include "ParallelAlgorithms/Amr/Actions/InitializeChild.hpp"
      15             : #include "ParallelAlgorithms/Amr/Tags.hpp"
      16             : 
      17             : namespace amr::Actions {
      18             : /// \brief Sends data from the parent element to its children elements during
      19             : /// adaptive mesh refinement
      20             : ///
      21             : /// \details  This action should be called after all children elements have been
      22             : /// created by amr::Actions::CreateChild.  This action sends a copy of all items
      23             : /// corresponding to the mutable_item_creation_tags of `box` to each of the
      24             : /// elements with `ids_of_children`.  Finally, the parent element destroys
      25             : /// itself.
      26           1 : struct SendDataToChildren {
      27             :   template <typename ParallelComponent, typename DbTagList,
      28             :             typename Metavariables, size_t Dim>
      29           0 :   static void apply(db::DataBox<DbTagList>& box,
      30             :                     Parallel::GlobalCache<Metavariables>& cache,
      31             :                     const ElementId<Dim>& element_id,
      32             :                     const std::vector<ElementId<Dim>>& ids_of_children) {
      33             :     auto& array_proxy =
      34             :         Parallel::get_parallel_component<ParallelComponent>(cache);
      35             :     for (const auto& child_id : ids_of_children) {
      36             :       Parallel::simple_action<amr::Actions::InitializeChild>(
      37             :           array_proxy[child_id],
      38             :           db::copy_items<
      39             :               typename db::DataBox<DbTagList>::mutable_item_creation_tags>(
      40             :               box));
      41             :     }
      42             : 
      43             :     if constexpr (Metavariables::amr::keep_coarse_grids) {
      44             :       if (db::get<amr::Tags::MaxCoarseLevels>(box).value_or(
      45             :               std::numeric_limits<size_t>::max()) > 0) {
      46             :         // Register the children elements in the parent element
      47             :         Parallel::deregister_element<ParallelComponent>(box, cache, element_id);
      48             :         ::Initialization::mutate_assign<tmpl::list<amr::Tags::ChildIds<Dim>>>(
      49             :             make_not_null(&box),
      50             :             std::unordered_set<ElementId<Dim>>{ids_of_children.begin(),
      51             :                                                ids_of_children.end()});
      52             :         Parallel::register_element<ParallelComponent>(box, cache, element_id);
      53             :         // Note: we don't run AMR projectors on the parent element because the
      54             :         // parent element didn't change, with the exception of
      55             :         // `amr::Tags::ChildIds<Dim>`.
      56             :         // Reset the AMR flags
      57             :         db::mutate<amr::Tags::Info<Dim>, amr::Tags::NeighborInfo<Dim>>(
      58             :             [](const gsl::not_null<amr::Info<Dim>*> amr_info,
      59             :                const gsl::not_null<
      60             :                    std::unordered_map<ElementId<Dim>, amr::Info<Dim>>*>
      61             :                    amr_info_of_neighbors) {
      62             :               amr_info_of_neighbors->clear();
      63             :               for (size_t d = 0; d < Dim; ++d) {
      64             :                 amr_info->flags[d] = amr::Flag::Undefined;
      65             :               }
      66             :             },
      67             :             make_not_null(&box));
      68             :         return;
      69             :       }
      70             :     }
      71             : 
      72             :     // Destroy the parent element
      73             :     Parallel::deregister_element<ParallelComponent>(box, cache, element_id);
      74             :     array_proxy[element_id].ckDestroy();
      75             :   }
      76             : };
      77             : }  // namespace amr::Actions