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 <pup_stl.h>
       8             : #include <vector>
       9             : 
      10             : #include "Options/Options.hpp"
      11             : #include "Options/String.hpp"
      12             : #include "ParallelAlgorithms/EventsAndTriggers/Trigger.hpp"
      13             : #include "Utilities/Serialization/CharmPupable.hpp"
      14             : #include "Utilities/TMPL.hpp"
      15             : 
      16             : namespace Triggers {
      17             : /// \ingroup EventsAndTriggersGroup
      18             : /// Always triggers.
      19           1 : class Always : public Trigger {
      20             :  public:
      21             :   /// \cond
      22             :   explicit Always(CkMigrateMessage* /*unused*/) {}
      23             :   using PUP::able::register_constructor;
      24             :   WRAPPED_PUPable_decl_template(Always);  // NOLINT
      25             :   /// \endcond
      26             : 
      27           0 :   using options = tmpl::list<>;
      28           0 :   static constexpr Options::String help = {"Always trigger."};
      29             : 
      30           0 :   Always() = default;
      31             : 
      32           0 :   using argument_tags = tmpl::list<>;
      33             : 
      34           0 :   bool operator()() const { return true; }
      35             : };
      36             : 
      37             : /// \ingroup EventsAndTriggersGroup
      38             : /// Negates another trigger.
      39           1 : class Not : public Trigger {
      40             :  public:
      41             :   /// \cond
      42             :   Not() = default;
      43             :   explicit Not(CkMigrateMessage* /*unused*/) {}
      44             :   using PUP::able::register_constructor;
      45             :   WRAPPED_PUPable_decl_template(Not);  // NOLINT
      46             :   /// \endcond
      47             : 
      48           0 :   static constexpr Options::String help = {"Negates another trigger."};
      49             : 
      50           0 :   explicit Not(std::unique_ptr<Trigger> negated_trigger)
      51             :       : negated_trigger_(std::move(negated_trigger)) {}
      52             : 
      53           0 :   using argument_tags = tmpl::list<Tags::DataBox>;
      54             : 
      55             :   template <typename DbTags>
      56           0 :   bool operator()(const db::DataBox<DbTags>& box) const {
      57             :     return not negated_trigger_->is_triggered(box);
      58             :   }
      59             : 
      60             :   // NOLINTNEXTLINE(google-runtime-references)
      61           0 :   void pup(PUP::er& p) { p | negated_trigger_; }
      62             : 
      63             :  private:
      64           0 :   std::unique_ptr<Trigger> negated_trigger_;
      65             : };
      66             : 
      67             : /// \ingroup EventsAndTriggersGroup
      68             : /// Short-circuiting logical AND of other triggers.
      69           1 : class And : public Trigger {
      70             :  public:
      71             :   /// \cond
      72             :   And() = default;
      73             :   explicit And(CkMigrateMessage* /*unused*/) {}
      74             :   using PUP::able::register_constructor;
      75             :   WRAPPED_PUPable_decl_template(And);  // NOLINT
      76             :   /// \endcond
      77             : 
      78           0 :   static constexpr Options::String help = {
      79             :       "Short-circuiting logical AND of other triggers."};
      80             : 
      81           0 :   explicit And(std::vector<std::unique_ptr<Trigger>> combined_triggers)
      82             :       : combined_triggers_(std::move(combined_triggers)) {}
      83             : 
      84           0 :   using argument_tags = tmpl::list<Tags::DataBox>;
      85             : 
      86             :   template <typename DbTags>
      87           0 :   bool operator()(const db::DataBox<DbTags>& box) const {
      88             :     for (auto& trigger : combined_triggers_) {
      89             :       if (not trigger->is_triggered(box)) {
      90             :         return false;
      91             :       }
      92             :     }
      93             :     return true;
      94             :   }
      95             : 
      96             :   // NOLINTNEXTLINE(google-runtime-references)
      97           0 :   void pup(PUP::er& p) { p | combined_triggers_; }
      98             : 
      99             :  private:
     100           0 :   std::vector<std::unique_ptr<Trigger>> combined_triggers_;
     101             : };
     102             : 
     103             : /// \ingroup EventsAndTriggersGroup
     104             : /// Short-circuiting logical OR of other triggers.
     105           1 : class Or : public Trigger {
     106             :  public:
     107             :   /// \cond
     108             :   Or() = default;
     109             :   explicit Or(CkMigrateMessage* /*unused*/) {}
     110             :   using PUP::able::register_constructor;
     111             :   WRAPPED_PUPable_decl_template(Or);  // NOLINT
     112             :   /// \endcond
     113             : 
     114           0 :   static constexpr Options::String help = {
     115             :       "Short-circuiting logical OR of other triggers."};
     116             : 
     117           0 :   explicit Or(std::vector<std::unique_ptr<Trigger>> combined_triggers)
     118             :       : combined_triggers_(std::move(combined_triggers)) {}
     119             : 
     120           0 :   using argument_tags = tmpl::list<Tags::DataBox>;
     121             : 
     122             :   template <typename DbTags>
     123           0 :   bool operator()(const db::DataBox<DbTags>& box) const {
     124             :     for (auto& trigger : combined_triggers_) {
     125             :       if (trigger->is_triggered(box)) {
     126             :         return true;
     127             :       }
     128             :     }
     129             :     return false;
     130             :   }
     131             : 
     132             :   // NOLINTNEXTLINE(google-runtime-references)
     133           0 :   void pup(PUP::er& p) { p | combined_triggers_; }
     134             : 
     135             :  private:
     136           0 :   std::vector<std::unique_ptr<Trigger>> combined_triggers_;
     137             : };
     138             : 
     139             : /// A list of all the logical triggers.
     140           1 : using logical_triggers = tmpl::list<Always, And, Not, Or>;
     141             : }  // namespace Triggers
     142             : 
     143             : template <>
     144           0 : struct Options::create_from_yaml<Triggers::Not> {
     145             :   template <typename Metavariables>
     146           0 :   static Triggers::Not create(const Options::Option& options) {
     147             :     return Triggers::Not(
     148             :         options.parse_as<std::unique_ptr<Trigger>, Metavariables>());
     149             :   }
     150             : };
     151             : 
     152             : template <>
     153           0 : struct Options::create_from_yaml<Triggers::And> {
     154             :   template <typename Metavariables>
     155           0 :   static Triggers::And create(const Options::Option& options) {
     156             :     return Triggers::And(
     157             :         options
     158             :             .parse_as<std::vector<std::unique_ptr<Trigger>>, Metavariables>());
     159             :   }
     160             : };
     161             : 
     162             : template <>
     163           0 : struct Options::create_from_yaml<Triggers::Or> {
     164             :   template <typename Metavariables>
     165           0 :   static Triggers::Or create(const Options::Option& options) {
     166             :     return Triggers::Or(
     167             :         options
     168             :             .parse_as<std::vector<std::unique_ptr<Trigger>>, Metavariables>());
     169             :   }
     170             : };