Line data    Source code

       1            0 : 
       2              : // Distributed under the MIT License.
       3              : // See LICENSE.txt for details.
       4              : 
       5              : #pragma once
       6              : 
       7              : #include <charm++.h>
       8              : #include <iterator>
       9              : #include <memory>
      10              : #include <utility>
      11              : #include <vector>
      12              : 
      13              : #include "Parallel/Callback.hpp"
      14              : #include "Parallel/GlobalCache.hpp"
      15              : #include "Parallel/Phase.hpp"
      16              : #include "ParallelAlgorithms/Amr/Actions/SendDataToChildren.hpp"
      17              : #include "Utilities/Algorithm.hpp"
      18              : #include "Utilities/ErrorHandling/Assert.hpp"
      19              : 
      20              : /// \cond
      21              : namespace db {
      22              : template <typename>
      23              : class DataBox;
      24              : }  // namespace db
      25              : /// \endcond
      26              : 
      27              : namespace amr::Actions {
      28              : /// \brief Creates a new element in an ArrayAlgorithm whose id is `child_id`
      29              : ///
      30              : /// \details This action is meant to be initially invoked by
      31              : /// amr::Actions::AdjustDomain on the amr::Component.  This action inserts a new
      32              : /// element with id `children_ids[index_of_child_id]` in the array referenced by
      33              : /// `element_proxy`.  A Parallel::SimpleActionCallback is passed to the
      34              : /// constructor of the new DistributedObject.  If `index_of_child_id` is that of
      35              : /// the last element of `children_ids`, the Parallel::SimpleActionCallback will
      36              : /// invoke amr::Actions::SendDataToChildren on the element with id `parent_id`.
      37              : /// Otherwise, it will invoke amr::Actions::CreateChild on the next element of
      38              : /// `children_ids`.
      39              : ///
      40              : /// This action does not modify anything in the DataBox
      41            1 : struct CreateChild {
      42              :   template <typename ParallelComponent, typename DbTagList,
      43              :             typename Metavariables, typename ElementProxy>
      44            0 :   static void apply(
      45              :       db::DataBox<DbTagList>& /*box*/,
      46              :       Parallel::GlobalCache<Metavariables>& cache, const int /*array_index*/,
      47              :       ElementProxy element_proxy,
      48              :       ElementId<Metavariables::volume_dim> parent_id,
      49              :       std::vector<ElementId<Metavariables::volume_dim>> children_ids,
      50              :       const size_t index_of_child_id,
      51              :       const std::unordered_map<Parallel::Phase, size_t>
      52              :           parent_phase_bookmarks) {
      53              :     auto my_proxy = Parallel::get_parallel_component<ParallelComponent>(cache);
      54              :     const ElementId<Metavariables::volume_dim>& child_id =
      55              :         children_ids[index_of_child_id];
      56              :     if (index_of_child_id + 1 == children_ids.size()) {
      57              :       auto parent_proxy = element_proxy[parent_id];
      58              :       element_proxy[child_id].insert(
      59              :           cache.get_this_proxy(), Parallel::Phase::AdjustDomain,
      60              :           parent_phase_bookmarks,
      61              :           std::make_unique<Parallel::SimpleActionCallback<
      62              :               SendDataToChildren, decltype(parent_proxy),
      63              :               std::vector<ElementId<Metavariables::volume_dim>>>>(
      64              :               parent_proxy, std::move(children_ids)));
      65              :     } else {
      66              :       element_proxy[child_id].insert(
      67              :           cache.get_this_proxy(), Parallel::Phase::AdjustDomain,
      68              :           parent_phase_bookmarks,
      69              :           std::make_unique<Parallel::SimpleActionCallback<
      70              :               CreateChild, decltype(my_proxy), ElementProxy,
      71              :               ElementId<Metavariables::volume_dim>,
      72              :               std::vector<ElementId<Metavariables::volume_dim>>, size_t,
      73              :               std::unordered_map<Parallel::Phase, size_t>>>(
      74              :               my_proxy, std::move(element_proxy), std::move(parent_id),
      75              :               std::move(children_ids), index_of_child_id + 1,
      76              :               parent_phase_bookmarks));
      77              :     }
      78              :   }
      79              : };
      80              : }  // namespace amr::Actions