Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <algorithm>
       7              : #include <cmath>
       8              : #include <limits>
       9              : #include <pup.h>
      10              : #include <pup_stl.h>
      11              : #include <string>
      12              : #include <utility>
      13              : 
      14              : #include "Options/Context.hpp"
      15              : #include "Options/Options.hpp"
      16              : #include "Options/ParseError.hpp"
      17              : #include "Options/String.hpp"
      18              : #include "ParallelAlgorithms/EventsAndTriggers/Trigger.hpp"
      19              : #include "Time/Time.hpp"
      20              : #include "Time/TimeSequence.hpp"
      21              : #include "Utilities/Serialization/CharmPupable.hpp"
      22              : #include "Utilities/TMPL.hpp"
      23              : 
      24              : /// \cond
      25              : namespace Tags {
      26              : struct Time;
      27              : struct TimeStep;
      28              : }  // namespace Tags
      29              : /// \endcond
      30              : 
      31              : namespace Triggers {
      32            0 : namespace NearTimes_enums {
      33            0 : enum class Unit { Time, Slab, Step };
      34            0 : enum class Direction { Before, After, Both };
      35              : }  // namespace NearTimes_enums
      36              : 
      37              : /// \ingroup EventsAndTriggersGroup
      38              : /// \ingroup TimeGroup
      39              : /// Trigger in intervals surrounding particular times.
      40              : ///
      41              : /// When using adaptive time stepping, intervals specified in terms of
      42              : /// slabs or steps are approximate.
      43              : ///
      44              : /// \see Times
      45            1 : class NearTimes : public Trigger {
      46              :  public:
      47              :   /// \cond
      48              :   NearTimes() = default;
      49              :   explicit NearTimes(CkMigrateMessage* /*unused*/) {}
      50              :   using PUP::able::register_constructor;
      51              :   WRAPPED_PUPable_decl_template(NearTimes);  // NOLINT
      52              :   /// \endcond
      53              : 
      54            0 :   using Unit = NearTimes_enums::Unit;
      55            0 :   using Direction = NearTimes_enums::Direction;
      56              : 
      57            0 :   struct OptionTags {
      58            0 :     struct Times {
      59            0 :       using type = std::unique_ptr<TimeSequence<double>>;
      60            0 :       static constexpr Options::String help = "Times to trigger at";
      61              :     };
      62              : 
      63            0 :     struct Range {
      64            0 :       using type = double;
      65            0 :       static type lower_bound() { return 0.0; }
      66            0 :       static constexpr Options::String help =
      67              :           "Maximum time difference to trigger at";
      68              :     };
      69              : 
      70            0 :     struct Unit {
      71            0 :       using type = NearTimes::Unit;
      72            0 :       static constexpr Options::String help =
      73              :           "Interpret Range as 'Time', 'Step's, or 'Slab's";
      74              :     };
      75              : 
      76            0 :     struct Direction {
      77            0 :       using type = NearTimes::Direction;
      78            0 :       static constexpr Options::String help =
      79              :           "Trigger 'Before', 'After', or 'Both' from the times";
      80              :     };
      81              :   };
      82              : 
      83            0 :   static constexpr Options::String help =
      84              :       "Trigger in intervals surrounding particular times.";
      85            0 :   using options =
      86              :       tmpl::list<typename OptionTags::Times, typename OptionTags::Range,
      87              :                  typename OptionTags::Unit, typename OptionTags::Direction>;
      88              : 
      89            0 :   NearTimes(std::unique_ptr<TimeSequence<double>> times, const double range,
      90              :             const Unit unit, const Direction direction)
      91              :       : times_(std::move(times)),
      92              :         range_(range),
      93              :         unit_(unit),
      94              :         direction_(direction) {}
      95              : 
      96            0 :   using argument_tags = tmpl::list<Tags::Time, Tags::TimeStep>;
      97              : 
      98            0 :   bool operator()(const double now, const TimeDelta& time_step) const;
      99              : 
     100              :   // NOLINTNEXTLINE(google-runtime-references)
     101            0 :   void pup(PUP::er& p) override;
     102              : 
     103              :  private:
     104            0 :   std::unique_ptr<TimeSequence<double>> times_{};
     105            0 :   double range_ = std::numeric_limits<double>::signaling_NaN();
     106            0 :   Unit unit_{};
     107            0 :   Direction direction_{};
     108              : };
     109              : }  // namespace Triggers
     110              : 
     111              : template <>
     112            0 : struct Options::create_from_yaml<Triggers::NearTimes_enums::Unit> {
     113            0 :   using type = Triggers::NearTimes_enums::Unit;
     114              :   template <typename Metavariables>
     115            0 :   static type create(const Options::Option& options) {
     116              :     const auto unit = options.parse_as<std::string>();
     117              :     if (unit == "Time") {
     118              :       return type::Time;
     119              :     } else if (unit == "Step") {
     120              :       return type::Step;
     121              :     } else if (unit == "Slab") {
     122              :       return type::Slab;
     123              :     } else {
     124              :       PARSE_ERROR(options.context(), "Unit must be 'Time', 'Step', or 'Slab'");
     125              :     }
     126              :   }
     127              : };
     128              : 
     129              : template <>
     130            0 : struct Options::create_from_yaml<
     131              :     typename Triggers::NearTimes_enums::Direction> {
     132            0 :   using type = Triggers::NearTimes_enums::Direction;
     133              :   template <typename Metavariables>
     134            0 :   static type create(const Options::Option& options) {
     135              :     const auto unit = options.parse_as<std::string>();
     136              :     if (unit == "Before") {
     137              :       return type::Before;
     138              :     } else if (unit == "After") {
     139              :       return type::After;
     140              :     } else if (unit == "Both") {
     141              :       return type::Both;
     142              :     } else {
     143              :       PARSE_ERROR(options.context(),
     144              :                   "Direction must be 'Before', 'After', or 'Both'");
     145              :     }
     146              :   }
     147              : };