Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines tags related to Events and Triggers
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <memory>
      10             : #include <pup_stl.h>
      11             : #include <vector>
      12             : 
      13             : #include "DataStructures/DataBox/Tag.hpp"
      14             : #include "Options/String.hpp"
      15             : #include "ParallelAlgorithms/EventsAndTriggers/EventsAndTriggers.hpp"
      16             : #include "ParallelAlgorithms/EventsAndTriggers/WhenToCheck.hpp"
      17             : #include "Utilities/GetOutput.hpp"
      18             : #include "Utilities/Serialization/Serialize.hpp"
      19             : #include "Utilities/TMPL.hpp"
      20             : 
      21             : namespace OptionTags {
      22             : /// \ingroup OptionTagsGroup
      23             : /// \ingroup EventsAndTriggersGroup
      24             : /// Contains the events and triggers
      25             : ///
      26             : /// In yaml this is specified as a map of triggers to lists of events:
      27             : /// \code{.yaml}
      28             : /// EventsAndTriggersAtSlabs:
      29             : ///   ? TriggerA:
      30             : ///       OptionsForTriggerA
      31             : ///   : - Event1:
      32             : ///         OptionsForEvent1
      33             : ///     - Event2:
      34             : ///         OptionsForEvent2
      35             : ///   ? TriggerB:
      36             : ///       OptionsForTriggerB
      37             : ///   : - Event3:
      38             : ///         OptionsForEvent3
      39             : ///     - Event4:
      40             : ///         OptionsForEvent4
      41             : /// \endcode
      42             : template <Triggers::WhenToCheck WhenToCheck>
      43           1 : struct EventsAndTriggers {
      44           0 :   using type = ::EventsAndTriggers;
      45           0 :   static constexpr Options::String help = "Events to run at triggers";
      46             :   // When the template arguments to this struct are sufficiently
      47             :   // complicated, pretty_type::short_name() run on this struct returns
      48             :   // something that is neither pretty nor short, and leads to an
      49             :   // OptionParser run-time error saying that an option name is greater
      50             :   // than 21 characters.  Adding the name() function below bypasses
      51             :   // pretty_type::short_name().
      52           0 :   static std::string name() {
      53             :     return "EventsAndTriggers" + get_output(WhenToCheck);
      54             :   }
      55             : };
      56             : 
      57           0 : namespace EventsRunAtCleanup {
      58           0 : struct Group {
      59           0 :   static std::string name() { return "EventsRunAtCleanup"; }
      60           0 :   static constexpr Options::String help =
      61             :       "Options related to running events on failure.  This is generally "
      62             :       "intended for dumping volume data to diagnose failure reasons.";
      63             : };
      64             : 
      65             : /// \brief A list of events to run at cleanup.
      66             : ///
      67             : /// See `Actions::RunEventsOnFailure` for details and caveats.
      68           1 : struct Events {
      69           0 :   static std::string name() { return "Events"; }
      70           0 :   using type = std::vector<std::unique_ptr<::Event>>;
      71           0 :   static constexpr Options::String help =
      72             :       "Events to run during the cleanup phase.";
      73           0 :   using group = Group;
      74             : };
      75             : 
      76             : /// \brief Observation value for Actions::RunEventsOnFailure.
      77           1 : struct ObservationValue {
      78           0 :   using type = double;
      79           0 :   static constexpr Options::String help =
      80             :       "Observation value for events run during the cleanup phase.";
      81           0 :   using group = Group;
      82             : };
      83             : }  // namespace EventsRunAtCleanup
      84             : }  // namespace OptionTags
      85             : 
      86             : namespace Tags {
      87             : /// \ingroup EventsAndTriggersGroup
      88             : /// Contains the events and triggers
      89             : template <Triggers::WhenToCheck WhenToCheck>
      90           1 : struct EventsAndTriggers : db::SimpleTag {
      91           0 :   using type = ::EventsAndTriggers;
      92           0 :   using option_tags = tmpl::list<::OptionTags::EventsAndTriggers<WhenToCheck>>;
      93           0 :   static constexpr bool is_overlayable = true;
      94             : 
      95           0 :   static constexpr bool pass_metavariables = false;
      96           0 :   static type create_from_options(const type& events_and_triggers) {
      97             :     return deserialize<type>(serialize<type>(events_and_triggers).data());
      98             :   }
      99           0 :   static std::string name() {
     100             :     return "EventsAndTriggers" + get_output(WhenToCheck);
     101             :   }
     102             : };
     103             : 
     104             : /// \brief Events to be run on elements during the
     105             : /// `Parallel::Phase::PostFailureCleanup` phase.
     106             : ///
     107             : /// Useful for troubleshooting runs that are failing.
     108           1 : struct EventsRunAtCleanup : db::SimpleTag {
     109           0 :   using type = std::vector<std::unique_ptr<::Event>>;
     110           0 :   using option_tags = tmpl::list<OptionTags::EventsRunAtCleanup::Events>;
     111             : 
     112           0 :   static constexpr bool pass_metavariables = false;
     113           0 :   static type create_from_options(const type& events_run_at_cleanup) {
     114             :     return deserialize<type>(serialize<type>(events_run_at_cleanup).data());
     115             :   }
     116             : };
     117             : 
     118             : /// \brief Observation value for Actions::RunEventsOnFailure.
     119           1 : struct EventsRunAtCleanupObservationValue : db::SimpleTag {
     120           0 :   using type = double;
     121           0 :   using option_tags =
     122             :       tmpl::list<OptionTags::EventsRunAtCleanup::ObservationValue>;
     123             : 
     124           0 :   static constexpr bool pass_metavariables = false;
     125           0 :   static type create_from_options(const type& value) { return value; }
     126             : };
     127             : }  // namespace Tags