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 <string>
      10              : 
      11              : #include "Options/String.hpp"
      12              : #include "ParallelAlgorithms/EventsAndDenseTriggers/DenseTrigger.hpp"
      13              : #include "ParallelAlgorithms/EventsAndTriggers/Trigger.hpp"
      14              : #include "Utilities/Gsl.hpp"
      15              : #include "Utilities/Serialization/CharmPupable.hpp"
      16              : #include "Utilities/TMPL.hpp"
      17              : 
      18              : /// \cond
      19              : namespace Parallel {
      20              : template <typename Metavariables>
      21              : class GlobalCache;
      22              : }  // namespace Parallel
      23              : namespace Tags {
      24              : struct DataBox;
      25              : }  // namespace Tags
      26              : namespace db {
      27              : template <typename TagsList>
      28              : class DataBox;
      29              : }  // namespace db
      30              : /// \endcond
      31              : 
      32              : namespace DenseTriggers {
      33              : /// \ingroup EventsAndTriggersGroup
      34              : /// %Filter activations of a dense trigger using a non-dense trigger.
      35              : ///
      36              : /// For example, to trigger every 10 starting at 100, one could use
      37              : ///
      38              : /// \snippet DenseTriggers/Test_Filter.cpp example
      39            1 : class Filter : public DenseTrigger {
      40              :  public:
      41              :   /// \cond
      42              :   Filter() = default;
      43              :   explicit Filter(CkMigrateMessage* const msg) : DenseTrigger(msg) {}
      44              :   using PUP::able::register_constructor;
      45              :   WRAPPED_PUPable_decl_template(Filter);  // NOLINT
      46              :   /// \endcond
      47              : 
      48            0 :   struct TriggerOption {
      49            0 :     static std::string name() { return "Trigger"; }
      50            0 :     using type = std::unique_ptr<DenseTrigger>;
      51            0 :     static constexpr Options::String help = "Dense trigger to filter";
      52              :   };
      53              : 
      54            0 :   struct FilterOption {
      55            0 :     static std::string name() { return "Filter"; }
      56            0 :     using type = std::unique_ptr<Trigger>;
      57            0 :     static constexpr Options::String help = "Non-dense trigger to filter with";
      58              :   };
      59              : 
      60            0 :   using options = tmpl::list<TriggerOption, FilterOption>;
      61            0 :   static constexpr Options::String help =
      62              :       "Filter activations of a dense trigger using a non-dense trigger.";
      63              : 
      64            0 :   explicit Filter(std::unique_ptr<DenseTrigger> trigger,
      65              :                   std::unique_ptr<Trigger> filter);
      66              : 
      67            0 :   using is_triggered_return_tags = tmpl::list<Tags::DataBox>;
      68            0 :   using is_triggered_argument_tags = tmpl::list<>;
      69              : 
      70              :   template <typename Metavariables, typename ArrayIndex, typename Component,
      71              :             typename DbTags>
      72            0 :   std::optional<bool> is_triggered(
      73              :       Parallel::GlobalCache<Metavariables>& cache,
      74              :       const ArrayIndex& array_index, const Component* component,
      75              :       const gsl::not_null<db::DataBox<DbTags>*> box) const {
      76              :     auto result = trigger_->is_triggered(box, cache, array_index, component);
      77              :     if (result == std::optional{true}) {
      78              :       return filter_->is_triggered(*box);
      79              :     }
      80              :     return result;
      81              :   }
      82              : 
      83            0 :   using next_check_time_return_tags = tmpl::list<Tags::DataBox>;
      84            0 :   using next_check_time_argument_tags = tmpl::list<>;
      85              : 
      86              :   template <typename Metavariables, typename ArrayIndex, typename Component,
      87              :             typename DbTags>
      88            0 :   std::optional<double> next_check_time(
      89              :       Parallel::GlobalCache<Metavariables>& cache,
      90              :       const ArrayIndex& array_index, const Component* component,
      91              :       const gsl::not_null<db::DataBox<DbTags>*> box) const {
      92              :     return trigger_->next_check_time(box, cache, array_index, component);
      93              :   }
      94              : 
      95              :   // NOLINTNEXTLINE(google-runtime-references)
      96            0 :   void pup(PUP::er& p) override;
      97              : 
      98              :  private:
      99            0 :   std::unique_ptr<DenseTrigger> trigger_{};
     100            0 :   std::unique_ptr<Trigger> filter_{};
     101              : };
     102              : }  // namespace DenseTriggers