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 <tuple>
       8             : #include <utility>
       9             : 
      10             : #include "DataStructures/DataBox/DataBox.hpp"
      11             : #include "Evolution/Systems/Cce/Actions/BoundaryComputeAndSendToEvolution.hpp"
      12             : #include "Parallel/AlgorithmExecution.hpp"
      13             : #include "Parallel/GlobalCache.hpp"
      14             : #include "Parallel/Invoke.hpp"
      15             : 
      16             : /// \cond
      17             : namespace Tags {
      18             : struct TimeStepId;
      19             : }  // namespace Tags
      20             : /// \endcond
      21             : 
      22             : namespace Cce {
      23             : namespace Actions {
      24             : 
      25             : /*!
      26             :  * \ingroup ActionsGroup
      27             :  * \brief Requests boundary data be sent from `WorldtubeBoundaryComponent` to
      28             :  * `EvolutionComponent` (template parameters).
      29             :  *
      30             :  * \details Calls the simple action
      31             :  * `Cce::Actions::BoundaryComputeAndSendToEvolution<WorldtubeBoundaryComponent,
      32             :  * EvolutionComponent>` on the `WorldtubeBoundaryComponent`, which performs
      33             :  * boundary computations then sends data to the `EvolutionComponent` via
      34             :  * `Cce::Actions::ReceiveWorldtubeData`. Requests the current
      35             :  * `Tags::TimeStepId`. For the majority of these requests, it's better to issue
      36             :  * them as early as possible to maximize the degree of parallelism for the
      37             :  * system, so most calls should use `Cce::Actions::RequestNextBoundaryData`,
      38             :  * because it can be called the substep prior to when the data will actually be
      39             :  * used.
      40             :  *
      41             :  * Uses:
      42             :  *  - DataBox:
      43             :  *    - `Tags::TimeStepId`
      44             :  *
      45             :  * \ref DataBoxGroup changes
      46             :  * - Adds: nothing
      47             :  * - Removes: nothing
      48             :  * - Modifies: nothing
      49             :  */
      50             : template <typename WorldtubeBoundaryComponent, typename EvolutionComponent>
      51           1 : struct RequestBoundaryData {
      52             :   template <typename DbTags, typename... InboxTags, typename Metavariables,
      53             :             typename ArrayIndex, typename ActionList,
      54             :             typename ParallelComponent>
      55           0 :   static Parallel::iterable_action_return_t apply(
      56             :       db::DataBox<DbTags>& box,
      57             :       const tuples::TaggedTuple<InboxTags...>& /*inboxes*/,
      58             :       Parallel::GlobalCache<Metavariables>& cache,
      59             :       const ArrayIndex& /*array_index*/, const ActionList /*meta*/,
      60             :       const ParallelComponent* const /*meta*/) {
      61             :     Parallel::simple_action<Actions::BoundaryComputeAndSendToEvolution<
      62             :         WorldtubeBoundaryComponent, EvolutionComponent>>(
      63             :         Parallel::get_parallel_component<WorldtubeBoundaryComponent>(cache),
      64             :         db::get<::Tags::TimeStepId>(box));
      65             :     return {Parallel::AlgorithmExecution::Continue, std::nullopt};
      66             :   }
      67             : };
      68             : 
      69             : /*!
      70             :  * \ingroup ActionsGroup
      71             :  * \brief Requests boundary data be sent from `WorldtubeBoundaryComponent` to
      72             :  * `EvolutionComponent`.
      73             :  *
      74             :  * \details Calls the simple action
      75             :  * `Cce::Actions::BoundaryComputeAndSendToEvolution<WorldtubeBoundaryComponent,
      76             :  * EvolutionComponent>` on the `WorldtubeBoundaryComponent`, which performs
      77             :  * boundary computations then sends data to the `EvolutionComponent` via
      78             :  * `Cce::Actions::ReceiveWorldtubeData`. Requests the
      79             :  * `Tags::Next<Tags::TimeStepId>` (for the next timestep).
      80             :  *
      81             :  * Uses:
      82             :  *  - DataBox:
      83             :  *    - `Tags::Next<Tags::TimeStepId>`
      84             :  *
      85             :  * \ref DataBoxGroup changes
      86             :  * - Adds: nothing
      87             :  * - Removes: nothing
      88             :  * - Modifies: nothing
      89             :  */
      90             : template <typename WorldtubeBoundaryComponent, typename EvolutionComponent>
      91           1 : struct RequestNextBoundaryData {
      92           0 :   using const_global_cache_tags =
      93             :       tmpl::list<typename WorldtubeBoundaryComponent::end_time_tag>;
      94             : 
      95             :   template <typename DbTags, typename... InboxTags, typename Metavariables,
      96             :             typename ArrayIndex, typename ActionList,
      97             :             typename ParallelComponent>
      98           0 :   static Parallel::iterable_action_return_t apply(
      99             :       db::DataBox<DbTags>& box,
     100             :       const tuples::TaggedTuple<InboxTags...>& /*inboxes*/,
     101             :       Parallel::GlobalCache<Metavariables>& cache,
     102             :       const ArrayIndex& /*array_index*/, const ActionList /*meta*/,
     103             :       const ParallelComponent* const /*meta*/) {
     104             :     // only request the data if the next step is not after the end time.
     105             :     if (db::get<::Tags::Next<::Tags::TimeStepId>>(box).substep_time() <
     106             :         db::get<Tags::EndTime>(box)) {
     107             :       Parallel::simple_action<Actions::BoundaryComputeAndSendToEvolution<
     108             :           WorldtubeBoundaryComponent, EvolutionComponent>>(
     109             :           Parallel::get_parallel_component<WorldtubeBoundaryComponent>(cache),
     110             :           db::get<::Tags::Next<::Tags::TimeStepId>>(box));
     111             :     }
     112             :     return {Parallel::AlgorithmExecution::Continue, std::nullopt};
     113             :   }
     114             : };
     115             : }  // namespace Actions
     116             : }  // namespace Cce