SpECTRE Documentation Coverage Report
Current view: top level - ParallelAlgorithms/EventsAndTriggers - LogicalTriggers.hpp Hit Total Coverage
Commit: a48770a280d0d66bc04cb5df30de1e3cc4985437 Lines: 5 36 13.9 %
Date: 2021-06-17 20:55:50
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.14