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.h>
       8              : #include <pup_stl.h>
       9              : #include <utility>
      10              : 
      11              : #include "DataStructures/DataBox/DataBoxTag.hpp"
      12              : #include "Options/Options.hpp"
      13              : #include "Options/ParseOptions.hpp"
      14              : #include "Options/String.hpp"
      15              : #include "ParallelAlgorithms/EventsAndTriggers/Trigger.hpp"
      16              : #include "Utilities/Serialization/CharmPupable.hpp"
      17              : #include "Utilities/TMPL.hpp"
      18              : 
      19              : /// \cond
      20              : namespace db {
      21              : template <typename TagsList>
      22              : class DataBox;
      23              : }  // namespace db
      24              : /// \endcond
      25              : 
      26              : namespace Triggers {
      27              : /*!
      28              :  * \ingroup EventsAndTriggersGroup
      29              :  * \ingroup TimeGroup
      30              :  * Check a trigger on substeps, as well as full steps.  Primarily for
      31              :  * debugging.
      32              :  *
      33              :  * In LTS mode, only substeps of the first step in each slab will be
      34              :  * checked. Such substeps may not be aligned across the domain.
      35              :  *
      36              :  * The observation value on a substep is set to the start time of the
      37              :  * step plus $10^6$ times the substep number.
      38              :  *
      39              :  * This trigger can be used as:
      40              :  *
      41              :  * ```yaml
      42              :  * - Trigger:
      43              :  *     OnSubsteps:
      44              :  *       Always:
      45              :  * ```
      46              :  */
      47            1 : class OnSubsteps : public Trigger {
      48              :  public:
      49              :   /// \cond
      50              :   OnSubsteps() = default;
      51              :   explicit OnSubsteps(CkMigrateMessage* /*unused*/) {}
      52              :   using PUP::able::register_constructor;
      53              :   WRAPPED_PUPable_decl_template(OnSubsteps);  // NOLINT
      54              :   /// \endcond
      55              : 
      56            0 :   static constexpr Options::String help =
      57              :       "Check a trigger on substeps in addition to steps.";
      58              : 
      59            0 :   explicit OnSubsteps(std::unique_ptr<Trigger> trigger)
      60              :       : trigger_(std::move(trigger)) {}
      61              : 
      62            0 :   using argument_tags = tmpl::list<Tags::DataBox>;
      63              : 
      64              :   template <typename DbTags>
      65            0 :   bool operator()(const db::DataBox<DbTags>& box) const {
      66              :     // This trigger doesn't actually do anything.  All the special
      67              :     // logic is in the RunEventsAndTriggers action.  Just forward
      68              :     // along.
      69              :     return trigger_->is_triggered(box);
      70              :   }
      71              : 
      72              :   // NOLINTNEXTLINE(google-runtime-references)
      73            0 :   void pup(PUP::er& p) override { p | trigger_; }
      74              : 
      75              :  private:
      76            0 :   std::unique_ptr<Trigger> trigger_;
      77              : };
      78              : }  // namespace Triggers
      79              : 
      80              : template <>
      81            0 : struct Options::create_from_yaml<Triggers::OnSubsteps> {
      82              :   template <typename Metavariables>
      83            0 :   static Triggers::OnSubsteps create(const Option& options) {
      84              :     return Triggers::OnSubsteps(
      85              :         options.parse_as<std::unique_ptr<Trigger>, Metavariables>());
      86              :   }
      87              : };