Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <cstddef>
       7              : #include <optional>
       8              : #include <tuple>
       9              : 
      10              : #include "DataStructures/DataBox/DataBox.hpp"
      11              : #include "DataStructures/TaggedTuple.hpp"
      12              : #include "IO/Importers/Tags.hpp"
      13              : #include "Parallel/AlgorithmExecution.hpp"
      14              : #include "Parallel/GlobalCache.hpp"
      15              : #include "Utilities/Gsl.hpp"
      16              : #include "Utilities/Literals.hpp"
      17              : #include "Utilities/TMPL.hpp"
      18              : 
      19              : namespace importers::Actions {
      20              : 
      21              : /*!
      22              :  * \brief Wait for data from a volume data file to arrive and directly move it
      23              :  * into the DataBox
      24              :  *
      25              :  * Monitors `importers::Tags::VolumeData` in the element's inbox and moves the
      26              :  * received data directly into the `FieldTagsList` in the DataBox.
      27              :  *
      28              :  * \see Dev guide on \ref dev_guide_importing
      29              :  */
      30              : template <typename FieldTagsList>
      31            1 : struct ReceiveVolumeData {
      32            0 :   using inbox_tags = tmpl::list<Tags::VolumeData<FieldTagsList>>;
      33              : 
      34              :   template <typename DbTagsList, typename... InboxTags, typename Metavariables,
      35              :             typename ArrayIndex, typename ActionList,
      36              :             typename ParallelComponent>
      37            0 :   static Parallel::iterable_action_return_t apply(
      38              :       db::DataBox<DbTagsList>& box, tuples::TaggedTuple<InboxTags...>& inboxes,
      39              :       const Parallel::GlobalCache<Metavariables>& /*cache*/,
      40              :       const ArrayIndex& /*array_index*/, const ActionList /*meta*/,
      41              :       const ParallelComponent* const /*meta*/) {
      42              :     auto& inbox = tuples::get<Tags::VolumeData<FieldTagsList>>(inboxes);
      43              :     // Using `0` for the temporal ID since we only read the volume data once, so
      44              :     // there's no need to keep track of the temporal ID.
      45              :     const auto received_data = inbox.find(0_st);
      46              :     if (received_data == inbox.end()) {
      47              :       return {Parallel::AlgorithmExecution::Retry, std::nullopt};
      48              :     }
      49              : 
      50              :     auto& element_data = received_data->second;
      51              :     tmpl::for_each<FieldTagsList>([&box, &element_data](auto tag_v) {
      52              :       using tag = tmpl::type_from<decltype(tag_v)>;
      53              :       db::mutate<tag>(
      54              :           [&element_data](const gsl::not_null<typename tag::type*> value) {
      55              :             *value = std::move(tuples::get<tag>(element_data));
      56              :           },
      57              :           make_not_null(&box));
      58              :     });
      59              :     inbox.erase(received_data);
      60              :     return {Parallel::AlgorithmExecution::Continue, std::nullopt};
      61              :   }
      62              : };
      63              : 
      64              : }  // namespace importers::Actions