Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <deque>
       7             : #include <pup.h>
       8             : #include <unordered_map>
       9             : #include <utility>
      10             : 
      11             : #include "ControlSystem/ControlErrors/Size/Info.hpp"
      12             : #include "ControlSystem/ControlErrors/Size/State.hpp"
      13             : 
      14             : namespace control_system::size {
      15             : /*!
      16             :  * \brief A struct for holding a history of control errors for each state in the
      17             :  * `control_system::Systems::Size` control system.
      18             :  */
      19           1 : struct StateHistory {
      20           0 :   StateHistory();
      21             : 
      22             :   /// \brief Only keep `num_times_to_store` entries in the state_history
      23           1 :   StateHistory(size_t num_times_to_store);
      24             : 
      25             :   /*!
      26             :    * \brief Store the control errors for all `control_system::size::State`s.
      27             :    *
      28             :    * \param time Time to store control errors at
      29             :    * \param info `control_system::size::Info`
      30             :    * \param control_error_args `control_system::size::ControlErrorArgs`
      31             :    */
      32           1 :   void store(double time, const Info& info,
      33             :              const ControlErrorArgs& control_error_args);
      34             : 
      35             :   /*!
      36             :    * \brief Return a const reference to the stored control errors from all the
      37             :    * states.
      38             :    *
      39             :    * \param state_number `size_t` corresponding to the
      40             :    * `control_system::size::State::number()` of a state.
      41             :    * \return std::deque<std::pair<double, double>> The `std::pair` holds
      42             :    * the time and control error, respectively. The `std::deque` is ordered with
      43             :    * earlier times at the "front" and later times at the "back". This is to make
      44             :    * iteration over the deque easier as we typically want to start with earlier
      45             :    * times.
      46             :    */
      47           1 :   const std::deque<std::pair<double, double>>& state_history(
      48             :       size_t state_number) const;
      49             : 
      50             :   // NOLINTNEXTLINE(google-runtime-references)
      51           0 :   void pup(PUP::er& p);
      52             : 
      53             :  private:
      54           0 :   void initialize_stored_control_errors();
      55             : 
      56           0 :   size_t num_times_to_store_{};
      57             :   std::unordered_map<size_t, std::deque<std::pair<double, double>>>
      58           0 :       stored_control_errors_{};
      59             : };
      60             : }  // namespace control_system::size