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 <cstddef>
       8             : #include <limits>
       9             : #include <memory>
      10             : #include <optional>
      11             : #include <tuple>
      12             : #include <utility>
      13             : 
      14             : #include "ControlSystem/CombinedName.hpp"
      15             : #include "ControlSystem/FutureMeasurements.hpp"
      16             : #include "ControlSystem/Metafunctions.hpp"
      17             : #include "ControlSystem/Tags/FutureMeasurements.hpp"
      18             : #include "ControlSystem/Tags/MeasurementTimescales.hpp"
      19             : #include "ControlSystem/Tags/SystemTags.hpp"
      20             : #include "ControlSystem/Trigger.hpp"
      21             : #include "DataStructures/DataBox/DataBox.hpp"
      22             : #include "Parallel/AlgorithmExecution.hpp"
      23             : #include "Parallel/GlobalCache.hpp"
      24             : #include "ParallelAlgorithms/EventsAndDenseTriggers/DenseTrigger.hpp"
      25             : #include "ParallelAlgorithms/EventsAndDenseTriggers/EventsAndDenseTriggers.hpp"
      26             : #include "ParallelAlgorithms/EventsAndTriggers/Event.hpp"
      27             : #include "Time/ChooseLtsStepSize.hpp"
      28             : #include "Time/LtsMode.hpp"
      29             : #include "Time/Slab.hpp"
      30             : #include "Time/Time.hpp"
      31             : #include "Utilities/ErrorHandling/Error.hpp"
      32             : #include "Utilities/Gsl.hpp"
      33             : #include "Utilities/MakeVector.hpp"
      34             : #include "Utilities/TMPL.hpp"
      35             : 
      36             : /// \cond
      37             : class TimeStepper;
      38             : namespace Tags {
      39             : struct EventsAndDenseTriggers;
      40             : struct LtsMode;
      41             : struct TimeStep;
      42             : template <typename StepperInterface>
      43             : struct TimeStepper;
      44             : }  // namespace Tags
      45             : namespace domain::Tags {
      46             : struct FunctionsOfTime;
      47             : }  // namespace domain::Tags
      48             : namespace tuples {
      49             : template <typename... Tags>
      50             : class TaggedTuple;
      51             : }  // namespace tuples
      52             : /// \endcond
      53             : 
      54             : namespace control_system::Actions {
      55             : /// \ingroup ControlSystemGroup
      56             : /// \brief Set up the element component for control-system measurements.
      57             : template <typename ControlSystems>
      58           1 : struct InitializeMeasurements {
      59           0 :   using control_system_groups =
      60             :       tmpl::transform<metafunctions::measurements_t<ControlSystems>,
      61             :                       metafunctions::control_systems_with_measurement<
      62             :                           tmpl::pin<ControlSystems>, tmpl::_1>>;
      63             : 
      64           0 :   using simple_tags =
      65             :       tmpl::transform<control_system_groups,
      66             :                       tmpl::bind<Tags::FutureMeasurements, tmpl::_1>>;
      67           0 :   using const_global_cache_tags =
      68             :       tmpl::list<Tags::MeasurementsPerUpdate, Tags::DelayUpdate>;
      69           0 :   using mutable_global_cache_tags =
      70             :       tmpl::list<control_system::Tags::MeasurementTimescales>;
      71             : 
      72             :   template <typename DbTagsList, typename... InboxTags, typename Metavariables,
      73             :             typename ArrayIndex, typename ActionList,
      74             :             typename ParallelComponent>
      75           0 :   static Parallel::iterable_action_return_t apply(
      76             :       db::DataBox<DbTagsList>& box,
      77             :       const tuples::TaggedTuple<InboxTags...>& /*inboxes*/,
      78             :       const Parallel::GlobalCache<Metavariables>& cache,
      79             :       const ArrayIndex& /*array_index*/, ActionList /*meta*/,
      80             :       const ParallelComponent* const /*meta*/) {
      81             :     if (not db::get<Tags::DelayUpdate>(box) and
      82             :         not db::get<::Tags::TimeStepper<TimeStepper>>(box).monotonic()) {
      83             :       ERROR_NO_TRACE(
      84             :           "Chosen TimeStepper requires DelayUpdate: true to avoid deadlocks");
      85             :     }
      86             : 
      87             :     const double initial_time = db::get<::Tags::Time>(box);
      88             :     const int measurements_per_update =
      89             :         db::get<Tags::MeasurementsPerUpdate>(box);
      90             :     const auto& timescales = Parallel::get<Tags::MeasurementTimescales>(cache);
      91             :     tmpl::for_each<control_system_groups>([&](auto group_v) {
      92             :       using group = tmpl::type_from<decltype(group_v)>;
      93             :       const bool active =
      94             :           timescales.at(combined_name<group>())->func(initial_time)[0][0] !=
      95             :           std::numeric_limits<double>::infinity();
      96             :       db::mutate<Tags::FutureMeasurements<group>>(
      97             :           [&](const gsl::not_null<FutureMeasurements*> measurements) {
      98             :             if (active) {
      99             :               *measurements = FutureMeasurements(
     100             :                   static_cast<size_t>(measurements_per_update), initial_time);
     101             :             } else {
     102             :               *measurements = FutureMeasurements(
     103             :                   1, std::numeric_limits<double>::infinity());
     104             :             }
     105             :           },
     106             :           make_not_null(&box));
     107             :     });
     108             : 
     109             :     db::mutate<::Tags::EventsAndDenseTriggers>(
     110             :         [](const gsl::not_null<EventsAndDenseTriggers*>
     111             :                events_and_dense_triggers) {
     112             :           tmpl::for_each<metafunctions::measurements_t<ControlSystems>>(
     113             :               [&events_and_dense_triggers](auto measurement_v) {
     114             :                 using measurement = tmpl::type_from<decltype(measurement_v)>;
     115             :                 using control_system_group =
     116             :                     metafunctions::control_systems_with_measurement_t<
     117             :                         ControlSystems, measurement>;
     118             :                 using events = tmpl::transform<
     119             :                     typename measurement::submeasurements,
     120             :                     metafunctions::event_from_submeasurement<
     121             :                         tmpl::pin<control_system_group>, tmpl::_1>>;
     122             :                 std::vector<std::unique_ptr<::Event>> vector_of_events =
     123             :                     tmpl::as_pack<events>([](auto... events_v) {
     124             :                       return make_vector<std::unique_ptr<::Event>>(
     125             :                           std::make_unique<
     126             :                               tmpl::type_from<decltype(events_v)>>()...);
     127             :                     });
     128             :                 events_and_dense_triggers->add_trigger_and_events(
     129             :                     std::make_unique<
     130             :                         control_system::Trigger<control_system_group>>(),
     131             :                     std::move(vector_of_events));
     132             :               });
     133             :         },
     134             :         make_not_null(&box));
     135             : 
     136             :     // Ensure that the initial time step is small enough that we don't
     137             :     // need to perform any measurements to complete it.  This is only
     138             :     // necessary for TimeSteppers that use the self-start procedure,
     139             :     // because they cannot adjust their step size on the first step
     140             :     // after self-start, but it isn't harmful to do it in other cases.
     141             :     //
     142             :     // Unlike in the steady-state step-limiting code, we don't do
     143             :     // anything clever looking at measurement times or planning ahead
     144             :     // for future steps.  Avoiding a single non-ideal step isn't worth
     145             :     // the added complexity.
     146             :     const auto lts_mode = db::get<::Tags::LtsMode>(box);
     147             :     double earliest_expiration = std::numeric_limits<double>::infinity();
     148             :     for (const auto& fot :
     149             :          Parallel::get<domain::Tags::FunctionsOfTime>(cache)) {
     150             :       earliest_expiration =
     151             :           std::min(earliest_expiration, fot.second->time_bounds()[1]);
     152             :     }
     153             :     const auto& time_step = db::get<::Tags::TimeStep>(box);
     154             :     const auto start_time = time_step.slab().start();
     155             :     if ((start_time + time_step).value() > earliest_expiration) {
     156             :       db::mutate<::Tags::TimeStep>(
     157             :           [&](const gsl::not_null<TimeDelta*> step) {
     158             :             if (lts_mode != LtsMode::Off) {
     159             :               *step = choose_lts_step_size(
     160             :                   start_time,
     161             :                   0.99 * (earliest_expiration - start_time.value()));
     162             :             } else {
     163             :               *step = Slab(start_time.value(), earliest_expiration).duration();
     164             :             }
     165             :           },
     166             :           make_not_null(&box));
     167             :     }
     168             : 
     169             :     return {Parallel::AlgorithmExecution::Continue, std::nullopt};
     170             :   }
     171             : };
     172             : }  // namespace control_system::Actions