Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <optional>
       7              : #include <string>
       8              : 
       9              : #include "ControlSystem/Protocols/ControlError.hpp"
      10              : #include "ControlSystem/TimescaleTuner.hpp"
      11              : #include "IO/Logging/Verbosity.hpp"
      12              : #include "Parallel/GlobalCache.hpp"
      13              : #include "Parallel/Printf/Printf.hpp"
      14              : #include "Utilities/Gsl.hpp"
      15              : #include "Utilities/ProtocolHelpers.hpp"
      16              : #include "Utilities/TypeTraits/CreateIsCallable.hpp"
      17              : 
      18              : namespace control_system {
      19              : /*!
      20              :  * \brief Updates the TimescaleTuner with information from the ControlError, if
      21              :  * possible.
      22              :  *
      23              :  * \details We check for a suggested timescale from the ControlError. If one is
      24              :  * suggested and it is smaller than the current damping timescale, we set the
      25              :  * timescale in the TimescaleTuner to this suggested value. Otherwise, we let
      26              :  * the TimescaleTuner adjust the timescale. Regardless of whether a timescale
      27              :  * was suggested or not, we always reset the control error.
      28              :  */
      29              : template <bool AllowDecrease, typename ControlError>
      30            1 : void update_timescale_tuner(
      31              :     const gsl::not_null<TimescaleTuner<AllowDecrease>*> tuner,
      32              :     const gsl::not_null<ControlError*> control_error, ::Verbosity verbosity,
      33              :     const double time, const std::string& function_of_time_name) {
      34              :   static_assert(
      35              :       tt::assert_conforms_to_v<ControlError, protocols::ControlError>);
      36              : 
      37              :   const std::optional<double>& suggested_timescale =
      38              :       control_error->get_suggested_timescale();
      39              :   const double old_timescale = min(tuner->current_timescale());
      40              : 
      41              :   if (suggested_timescale.value_or(std::numeric_limits<double>::infinity()) <
      42              :       old_timescale) {
      43              :     tuner->set_timescale_if_in_allowable_range(suggested_timescale.value());
      44              :   }
      45              : 
      46              :   if (verbosity >= ::Verbosity::Verbose) {
      47              :     using ::operator<<;
      48              :     Parallel::printf(
      49              :         "%s, time = %.16f:\n"
      50              :         " old_timescale = %.16f\n"
      51              :         " suggested_timescale = %s\n"
      52              :         " new_timescale = %.16f\n",
      53              :         function_of_time_name, time, old_timescale,
      54              :         MakeString{} << suggested_timescale, min(tuner->current_timescale()));
      55              :   }
      56              : 
      57              :   // This reset call is ok because if there was a discontinuous change
      58              :   // above after calculating the control error, the control error class was
      59              :   // already reset so this reset won't do anything. If there wasn't a
      60              :   // discontinuous change, then this will only affect the suggested
      61              :   // timescale, which we always want to reset.
      62              :   control_error->reset();
      63              : }
      64              : }  // namespace control_system