Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <optional>
       7              : #include <string>
       8              : #include <unordered_set>
       9              : 
      10              : #include "IO/Importers/Tags.hpp"
      11              : #include "Parallel/AlgorithmExecution.hpp"
      12              : #include "Parallel/Algorithms/AlgorithmNodegroup.hpp"
      13              : #include "Parallel/GlobalCache.hpp"
      14              : #include "Parallel/Local.hpp"
      15              : #include "Parallel/ParallelComponentHelpers.hpp"
      16              : #include "Parallel/Phase.hpp"
      17              : #include "Parallel/PhaseDependentActionList.hpp"
      18              : 
      19              : namespace importers {
      20              : 
      21              : namespace detail {
      22              : template <size_t Dim>
      23              : struct InitializeElementDataReader;
      24              : }  // namespace detail
      25              : 
      26              : /*!
      27              :  * \brief A nodegroup parallel component that reads in a volume data file and
      28              :  * distributes its data to elements of an array parallel component.
      29              :  *
      30              :  * Each element of the array parallel component must register itself before
      31              :  * data can be sent to it. To do so, invoke
      32              :  * `importers::Actions::RegisterWithElementDataReader` on each element. In a
      33              :  * subsequent phase you can then invoke
      34              :  * `importers::ThreadedActions::ReadVolumeData` on the `ElementDataReader`
      35              :  * component to read in the file and distribute its data to the registered
      36              :  * elements.
      37              :  *
      38              :  * \see Dev guide on \ref dev_guide_importing
      39              :  */
      40              : template <typename Metavariables>
      41            1 : struct ElementDataReader {
      42            0 :   static constexpr size_t Dim = Metavariables::volume_dim;
      43              : 
      44            0 :   using chare_type = Parallel::Algorithms::Nodegroup;
      45            0 :   static constexpr bool checkpoint_data = false;
      46            0 :   using metavariables = Metavariables;
      47            0 :   using phase_dependent_action_list = tmpl::list<Parallel::PhaseActions<
      48              :       Parallel::Phase::Initialization,
      49              :       tmpl::list<detail::InitializeElementDataReader<Dim>>>>;
      50            0 :   using simple_tags_from_options = Parallel::get_simple_tags_from_options<
      51              :       Parallel::get_initialization_actions_list<phase_dependent_action_list>>;
      52              : 
      53            0 :   static void initialize(
      54              :       Parallel::CProxy_GlobalCache<Metavariables>& /*global_cache*/) {}
      55              : 
      56            0 :   static void execute_next_phase(
      57              :       const Parallel::Phase next_phase,
      58              :       Parallel::CProxy_GlobalCache<Metavariables>& global_cache) {
      59              :     auto& local_cache = *Parallel::local_branch(global_cache);
      60              :     Parallel::get_parallel_component<ElementDataReader>(local_cache)
      61              :         .start_phase(next_phase);
      62              :   }
      63              : };
      64              : 
      65              : namespace detail {
      66              : template <size_t Dim>
      67              : struct InitializeElementDataReader {
      68              :   using simple_tags =
      69              :       tmpl::list<Tags::RegisteredElements<Dim>, Tags::ElementDataAlreadyRead>;
      70              :   using compute_tags = tmpl::list<>;
      71              : 
      72              :   template <typename DbTagsList, typename... InboxTags, typename Metavariables,
      73              :             typename ArrayIndex, typename ActionList,
      74              :             typename ParallelComponent>
      75              :   static Parallel::iterable_action_return_t apply(
      76              :       db::DataBox<DbTagsList>& /*box*/,
      77              :       const tuples::TaggedTuple<InboxTags...>& /*inboxes*/,
      78              :       const Parallel::GlobalCache<Metavariables>& /*cache*/,
      79              :       const ArrayIndex& /*array_index*/, const ActionList /*meta*/,
      80              :       const ParallelComponent* const /*meta*/) {
      81              :     return {Parallel::AlgorithmExecution::Pause, std::nullopt};
      82              :   }
      83              : };
      84              : }  // namespace detail
      85              : 
      86              : }  // namespace importers