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              : 
      10              : #include "Options/Options.hpp"
      11              : #include "Options/ParseOptions.hpp"
      12              : #include "Options/String.hpp"
      13              : #include "ParallelAlgorithms/EventsAndDenseTriggers/DenseTrigger.hpp"
      14              : #include "Time/TimeSequence.hpp"
      15              : #include "Utilities/Serialization/CharmPupable.hpp"
      16              : #include "Utilities/TMPL.hpp"
      17              : 
      18              : /// \cond
      19              : class TimeStepId;
      20              : namespace Parallel {
      21              : template <typename Metavariables>
      22              : class GlobalCache;
      23              : }  // namespace Parallel
      24              : namespace Tags {
      25              : struct Time;
      26              : struct TimeStepId;
      27              : }  // namespace Tags
      28              : /// \endcond
      29              : 
      30              : namespace DenseTriggers {
      31              : /// \ingroup EventsAndTriggersGroup
      32              : /// \ingroup TimeGroup
      33              : /// Trigger at specified times.
      34            1 : class Times : public DenseTrigger {
      35              :  public:
      36              :   /// \cond
      37              :   Times() = default;
      38              :   explicit Times(CkMigrateMessage* const msg) : DenseTrigger(msg) {}
      39              :   using PUP::able::register_constructor;
      40              :   WRAPPED_PUPable_decl_template(Times);  // NOLINT
      41              :   /// \endcond
      42              : 
      43            0 :   static constexpr Options::String help{"Trigger at specified times."};
      44              : 
      45            0 :   explicit Times(std::unique_ptr<TimeSequence<double>> times);
      46              : 
      47            0 :   using is_triggered_return_tags = tmpl::list<>;
      48            0 :   using is_triggered_argument_tags = tmpl::list<Tags::Time>;
      49              : 
      50              :   template <typename Metavariables, typename ArrayIndex, typename Component>
      51            0 :   std::optional<bool> is_triggered(
      52              :       Parallel::GlobalCache<Metavariables>& /*cache*/,
      53              :       const ArrayIndex& /*array_index*/, const Component* /*component*/,
      54              :       const double time) const {
      55              :     return is_triggered_impl(time);
      56              :   }
      57              : 
      58            0 :   using next_check_time_return_tags = tmpl::list<>;
      59            0 :   using next_check_time_argument_tags =
      60              :       tmpl::list<Tags::TimeStepId, Tags::Time>;
      61              : 
      62              :   template <typename Metavariables, typename ArrayIndex, typename Component>
      63            0 :   std::optional<double> next_check_time(
      64              :       Parallel::GlobalCache<Metavariables>& /*cache*/,
      65              :       const ArrayIndex& /*array_index*/, const Component* /*component*/,
      66              :       const TimeStepId& time_step_id, const double time) const {
      67              :     return next_check_time_impl(time_step_id, time);
      68              :   }
      69              : 
      70              :   // NOLINTNEXTLINE(google-runtime-references)
      71            0 :   void pup(PUP::er& p) override;
      72              : 
      73              :  private:
      74            0 :   std::optional<bool> is_triggered_impl(const double time) const;
      75              : 
      76            0 :   std::optional<double> next_check_time_impl(const TimeStepId& time_step_id,
      77              :                                              const double time) const;
      78              : 
      79            0 :   std::unique_ptr<TimeSequence<double>> times_{};
      80              : };
      81              : }  // namespace DenseTriggers
      82              : 
      83              : template <>
      84            0 : struct Options::create_from_yaml<DenseTriggers::Times> {
      85              :   template <typename Metavariables>
      86            0 :   static DenseTriggers::Times create(const Option& options) {
      87              :     return DenseTriggers::Times(
      88              :         options
      89              :             .parse_as<std::unique_ptr<TimeSequence<double>>, Metavariables>());
      90              :   }
      91              : };