Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <memory>
       7             : #include <optional>
       8             : #include <pup.h>
       9             : #include <vector>
      10             : 
      11             : #include "DataStructures/DataBox/DataBox.hpp"
      12             : #include "DataStructures/DataBox/ObservationBox.hpp"
      13             : #include "Options/Options.hpp"
      14             : #include "Options/String.hpp"
      15             : #include "ParallelAlgorithms/EventsAndTriggers/Event.hpp"
      16             : #include "ParallelAlgorithms/EventsAndTriggers/Trigger.hpp"
      17             : #include "Utilities/Gsl.hpp"
      18             : #include "Utilities/TMPL.hpp"
      19             : 
      20             : /// \cond
      21             : namespace Parallel {
      22             : template <typename Metavariables>
      23             : class GlobalCache;
      24             : }  // namespace Parallel
      25             : namespace db {
      26             : template <typename TagsList>
      27             : class DataBox;
      28             : }  // namespace db
      29             : /// \endcond
      30             : 
      31             : /// \ingroup EventsAndTriggersGroup
      32             : /// Class that checks triggers and runs events
      33           1 : class EventsAndTriggers {
      34             :  private:
      35             :   template <typename Event>
      36           0 :   struct get_tags {
      37           0 :     using type = typename Event::compute_tags_for_observation_box;
      38             :   };
      39             : 
      40             :  public:
      41           0 :   struct TriggerAndEvents {
      42           0 :     struct Trigger {
      43           0 :       using type = std::unique_ptr<::Trigger>;
      44           0 :       static constexpr Options::String help = "Determines when the Events run.";
      45             :     };
      46           0 :     struct Events {
      47           0 :       using type = std::vector<std::unique_ptr<::Event>>;
      48           0 :       static constexpr Options::String help =
      49             :           "These events run when the Trigger fires.";
      50             :     };
      51           0 :     static constexpr Options::String help =
      52             :         "Events that run when the Trigger fires.";
      53           0 :     using options = tmpl::list<Trigger, Events>;
      54           0 :     TriggerAndEvents();
      55           0 :     TriggerAndEvents(std::unique_ptr<::Trigger> trigger_in,
      56             :                      std::vector<std::unique_ptr<::Event>> events_in);
      57           0 :     void pup(PUP::er& p);
      58           0 :     std::unique_ptr<::Trigger> trigger;
      59           0 :     std::vector<std::unique_ptr<::Event>> events;
      60             :   };
      61             : 
      62           0 :   using Storage = std::vector<TriggerAndEvents>;
      63             : 
      64           0 :   EventsAndTriggers();
      65           0 :   explicit EventsAndTriggers(Storage events_and_triggers);
      66             : 
      67             :   /// Check the triggers and run the associated events.
      68             :   ///
      69             :   /// By default the trigger check just calls the `is_triggered`
      70             :   /// method, but the last argument can be passed to override this.
      71             :   /// It must be a functor taking a `const Trigger&` and returning
      72             :   /// `bool`.
      73             :   template <typename DbTags, typename Metavariables, typename ArrayIndex,
      74             :             typename Component, typename CheckTrigger = std::nullptr_t>
      75           1 :   void run_events(const gsl::not_null<db::DataBox<DbTags>*> box,
      76             :                   Parallel::GlobalCache<Metavariables>& cache,
      77             :                   const ArrayIndex& array_index, const Component* component,
      78             :                   const Event::ObservationValue& observation_value,
      79             :                   const CheckTrigger& check_trigger = nullptr) const {
      80             :     using compute_tags = tmpl::remove_duplicates<tmpl::filter<
      81             :         tmpl::flatten<tmpl::transform<
      82             :             tmpl::at<typename Metavariables::factory_creation::factory_classes,
      83             :                      Event>,
      84             :             get_tags<tmpl::_1>>>,
      85             :         db::is_compute_tag<tmpl::_1>>>;
      86             :     std::optional<decltype(make_observation_box<compute_tags>(box))>
      87             :         observation_box{};
      88             :     for (const auto& trigger_and_events : events_and_triggers_) {
      89             :       const auto& trigger = trigger_and_events.trigger;
      90             :       const auto& events = trigger_and_events.events;
      91             :       const bool is_triggered = [&]() {
      92             :         if constexpr (std::is_same_v<std::decay_t<CheckTrigger>,
      93             :                                      std::nullptr_t>) {
      94             :           return trigger->is_triggered(*box);
      95             :         } else {
      96             :           return check_trigger(std::as_const(*trigger));
      97             :         }
      98             :       }();
      99             :       if (is_triggered) {
     100             :         if (not observation_box.has_value()) {
     101             :           observation_box = make_observation_box<compute_tags>(box);
     102             :         }
     103             :         for (const auto& event : events) {
     104             :           event->run(make_not_null(&observation_box.value()), cache,
     105             :                      array_index, component, observation_value);
     106             :         }
     107             :       }
     108             :     }
     109             :   }
     110             : 
     111             :   // NOLINTNEXTLINE(google-runtime-references)
     112           0 :   void pup(PUP::er& p);
     113             : 
     114             :   template <typename F>
     115           0 :   void for_each_event(F&& f) const {
     116             :     for (const auto& trigger_and_events : events_and_triggers_) {
     117             :       for (const auto& event : trigger_and_events.events) {
     118             :         f(*event);
     119             :       }
     120             :     }
     121             :   }
     122             : 
     123             :  private:
     124             :   // The unique pointer contents *must* be treated as const everywhere
     125             :   // in order to make the const global cache behave sanely.  They are
     126             :   // only non-const to make pup work.
     127           0 :   Storage events_and_triggers_;
     128             : };
     129             : 
     130             : template <>
     131           0 : struct Options::create_from_yaml<EventsAndTriggers> {
     132           0 :   using type = EventsAndTriggers;
     133             :   template <typename Metavariables>
     134           0 :   static type create(const Options::Option& options) {
     135             :     return type(options.parse_as<typename type::Storage, Metavariables>());
     136             :   }
     137             : };