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             : #include <type_traits>
      11             : 
      12             : #include "ControlSystem/CombinedName.hpp"
      13             : #include "ControlSystem/FutureMeasurements.hpp"
      14             : #include "ControlSystem/Metafunctions.hpp"
      15             : #include "IO/Logging/Verbosity.hpp"
      16             : #include "Parallel/ArrayCollection/IsDgElementCollection.hpp"
      17             : #include "Parallel/ArrayCollection/PerformAlgorithmOnElement.hpp"
      18             : #include "Parallel/ArrayCollection/Tags/ElementLocations.hpp"
      19             : #include "Parallel/ArrayComponentId.hpp"
      20             : #include "Parallel/Callback.hpp"
      21             : #include "Parallel/GlobalCache.hpp"
      22             : #include "Parallel/Printf/Printf.hpp"
      23             : #include "ParallelAlgorithms/Actions/GetItemFromDistributedObject.hpp"
      24             : #include "ParallelAlgorithms/EventsAndDenseTriggers/DenseTrigger.hpp"
      25             : #include "Utilities/ErrorHandling/Assert.hpp"
      26             : #include "Utilities/GetOutput.hpp"
      27             : #include "Utilities/Gsl.hpp"
      28             : #include "Utilities/PrettyType.hpp"
      29             : #include "Utilities/Serialization/CharmPupable.hpp"
      30             : #include "Utilities/TMPL.hpp"
      31             : 
      32             : /// \cond
      33             : namespace Tags {
      34             : struct Time;
      35             : }  // namespace Tags
      36             : namespace control_system::Tags {
      37             : template <typename ControlSystems>
      38             : struct FutureMeasurements;
      39             : struct MeasurementTimescales;
      40             : struct Verbosity;
      41             : }  // namespace control_system::Tags
      42             : /// \endcond
      43             : 
      44             : namespace control_system {
      45             : /// \ingroup ControlSystemGroup
      46             : /// \ingroup EventsAndTriggersGroup
      47             : /// Trigger for control system measurements.
      48             : ///
      49             : /// This trigger is only intended to be used with the
      50             : /// `control_system::Event` event.  A specialization of this trigger
      51             : /// will be created during control system initialization for each
      52             : /// unique \ref control_system::protocols::Measurement "measurement".
      53             : ///
      54             : /// These triggers must be added to the \ref
      55             : /// Options::protocols::FactoryCreation "factory_creation" struct in
      56             : /// the metavariables, even though they cannot be created from the
      57             : /// input file.  The `control_system::control_system_triggers`
      58             : /// metafunction provides the list of triggers to include.
      59             : template <typename ControlSystems>
      60           1 : class Trigger : public DenseTrigger {
      61             :   static_assert(tmpl::size<ControlSystems>::value > 0);
      62           0 :   using measurement = typename tmpl::front<ControlSystems>::measurement;
      63             :   static_assert(tmpl::all<ControlSystems,
      64             :                           std::is_same<metafunctions::measurement<tmpl::_1>,
      65             :                                        tmpl::pin<measurement>>>::value);
      66             : 
      67             :  public:
      68             :   /// \cond
      69             :   // LCOV_EXCL_START
      70             :   explicit Trigger(CkMigrateMessage* const msg) : DenseTrigger(msg) {}
      71             :   using PUP::able::register_constructor;
      72             :   WRAPPED_PUPable_decl_template(Trigger);  // NOLINT
      73             :   // LCOV_EXCL_STOP
      74             :   /// \endcond
      75             : 
      76             :   // This trigger is created during control system initialization, not
      77             :   // from the input file.
      78           0 :   static constexpr bool factory_creatable = false;
      79           0 :   Trigger() = default;
      80             : 
      81           0 :   using is_triggered_return_tags = tmpl::list<>;
      82           0 :   using is_triggered_argument_tags =
      83             :       tmpl::list<::Tags::Time,
      84             :                  control_system::Tags::FutureMeasurements<ControlSystems>>;
      85             : 
      86             :   template <typename Metavariables, size_t Dim, typename Component>
      87           0 :   std::optional<bool> is_triggered(
      88             :       Parallel::GlobalCache<Metavariables>& cache,
      89             :       const ElementId<Dim>& array_index, const Component* /*component*/,
      90             :       const double time,
      91             :       const control_system::FutureMeasurements& measurement_times) {
      92             :     const auto next_measurement = measurement_times.next_measurement();
      93             :     ASSERT(next_measurement.has_value(),
      94             :            "Checking trigger without knowing next time.");
      95             :     const bool triggered = time == *next_measurement;
      96             : 
      97             :     if (Parallel::get<Tags::Verbosity>(cache) >= ::Verbosity::Debug) {
      98             :       Parallel::printf(
      99             :           "%s, time = %.16f: Trigger for control systems (%s) is%s "
     100             :           "triggered.\n",
     101             :           get_output(array_index), time,
     102             :           pretty_type::list_of_names<ControlSystems>(),
     103             :           (triggered ? "" : " not"));
     104             :     }
     105             : 
     106             :     return triggered;
     107             :   }
     108             : 
     109           0 :   using next_check_time_return_tags =
     110             :       tmpl::list<control_system::Tags::FutureMeasurements<ControlSystems>>;
     111           0 :   using next_check_time_argument_tags = tmpl::list<::Tags::Time>;
     112             : 
     113             :   template <typename Metavariables, size_t Dim, typename Component>
     114           0 :   std::optional<double> next_check_time(
     115             :       Parallel::GlobalCache<Metavariables>& cache,
     116             :       const ElementId<Dim>& array_index, const Component* /*component*/,
     117             :       const gsl::not_null<control_system::FutureMeasurements*>
     118             :           measurement_times,
     119             :       const double time) {
     120             :     if (measurement_times->next_measurement() == std::optional(time)) {
     121             :       measurement_times->pop_front();
     122             :     }
     123             : 
     124             :     if (not measurement_times->next_measurement().has_value()) {
     125             :       auto& proxy = ::Parallel::get_parallel_component<Component>(cache);
     126             :       const bool is_ready = Parallel::mutable_cache_item_is_ready<
     127             :           control_system::Tags::MeasurementTimescales>(
     128             :           cache, Parallel::make_array_component_id<Component>(array_index),
     129             :           [&](const auto& measurement_timescales) {
     130             :             const std::string& measurement_name =
     131             :                 control_system::combined_name<ControlSystems>();
     132             :             ASSERT(measurement_timescales.count(measurement_name) == 1,
     133             :                    "Control system trigger expects a measurement timescale "
     134             :                    "with the name '"
     135             :                        << measurement_name
     136             :                        << "' but could not find one. Available names are: "
     137             :                        << keys_of(measurement_timescales));
     138             :             measurement_times->update(
     139             :                 *measurement_timescales.at(measurement_name));
     140             :             if (not measurement_times->next_measurement().has_value()) {
     141             :               if constexpr (Parallel::is_dg_element_collection_v<Component>) {
     142             :                 // Note: The ArrayComponentId is still created with the
     143             :                 // array_index (ElementId) because we only support 1 callback
     144             :                 // per ArrayComponentId. This would mean for nodegroups we would
     145             :                 // discard a lot of callbacks that we need. Alternatively, the
     146             :                 // callback could do a broadcast to all elements on the
     147             :                 // nodegroup.
     148             :                 const auto element_location = static_cast<int>(
     149             :                     Parallel::local_synchronous_action<
     150             :                         Parallel::Actions::GetItemFromDistributedOject<
     151             :                             Parallel::Tags::ElementLocations<Dim>>>(
     152             :                         Parallel::get_parallel_component<Component>(cache))
     153             :                         ->at(array_index));
     154             :                 return std::unique_ptr<Parallel::Callback>(
     155             :                     new Parallel::ThreadedActionCallback<
     156             :                         Parallel::Actions::PerformAlgorithmOnElement<false>,
     157             :                         decltype(proxy[element_location]),
     158             :                         std::decay_t<decltype(array_index)>>{
     159             :                         proxy[element_location], array_index});
     160             :               } else {
     161             :                 return std::unique_ptr<Parallel::Callback>(
     162             :                     new Parallel::PerformAlgorithmCallback(proxy[array_index]));
     163             :               }
     164             :             }
     165             :             return std::unique_ptr<Parallel::Callback>{};
     166             :           });
     167             : 
     168             :       if (not is_ready) {
     169             :         if (Parallel::get<Tags::Verbosity>(cache) >= ::Verbosity::Debug) {
     170             :           Parallel::printf(
     171             :               "%s, time = %.16f: Trigger for control systems (%s) - Cannot "
     172             :               "calculate next_check_time\n",
     173             :               get_output(array_index), time,
     174             :               pretty_type::list_of_names<ControlSystems>());
     175             :         }
     176             :         return std::nullopt;
     177             :       }
     178             :     }
     179             : 
     180             :     const double next_trigger = *measurement_times->next_measurement();
     181             :     ASSERT(next_trigger > time,
     182             :            "Next trigger is in the past: " << next_trigger << " > " << time);
     183             : 
     184             :     if (Parallel::get<Tags::Verbosity>(cache) >= ::Verbosity::Debug) {
     185             :       Parallel::printf(
     186             :           "%s, time = %.16f: Trigger for control systems (%s) - next check "
     187             :           "time is %.16f\n",
     188             :           get_output(array_index), time,
     189             :           pretty_type::list_of_names<ControlSystems>(), next_trigger);
     190             :     }
     191             : 
     192             :     return {next_trigger};
     193             :   }
     194             : };
     195             : 
     196             : /// \cond
     197             : template <typename ControlSystems>
     198             : PUP::able::PUP_ID Trigger<ControlSystems>::my_PUP_ID = 0;  // NOLINT
     199             : /// \endcond
     200             : 
     201             : // This metafunction is tested in Test_EventTriggerMetafunctions.cpp
     202             : 
     203             : /// \ingroup ControlSystemGroup
     204             : /// The list of triggers needed for measurements for a list of control
     205             : /// systems.
     206             : template <typename ControlSystems>
     207           1 : using control_system_triggers = tmpl::transform<
     208             :     metafunctions::measurements_t<ControlSystems>,
     209             :     tmpl::bind<Trigger, metafunctions::control_systems_with_measurement<
     210             :                             tmpl::pin<ControlSystems>, tmpl::_1>>>;
     211             : }  // namespace control_system