Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <cstddef>
       7              : #include <deque>
       8              : #include <optional>
       9              : #include <pup.h>
      10              : #include <utility>
      11              : 
      12              : /// \cond
      13              : namespace domain::FunctionsOfTime {
      14              : class FunctionOfTime;
      15              : }  // namespace domain::FunctionsOfTime
      16              : /// \endcond
      17              : 
      18              : namespace control_system {
      19              : /// Class for computing the upcoming measurement times for a control
      20              : /// system measurement.
      21              : ///
      22              : /// At any time, the \ref control_system::Tags::MeasurementTimescales
      23              : /// "measurement timescales" can be queried to find the spacing
      24              : /// between control system measurements.  Most uses, however, require
      25              : /// the actual measurement times, and sometimes need to know times of
      26              : /// control-system update triggers.  This class calculates these
      27              : /// quantities from the timescales.
      28            1 : class FutureMeasurements {
      29              :  public:
      30            0 :   FutureMeasurements() = default;
      31              : 
      32            0 :   FutureMeasurements(size_t measurements_per_update,
      33              :                      double first_measurement_time);
      34              : 
      35              :   /// Next measurement time, if known.
      36            1 :   std::optional<double> next_measurement() const;
      37              :   /// Next measurement that triggers an update, if known.
      38            1 :   std::optional<double> next_update() const;
      39              : 
      40              :   /// Remove the earliest measurement form the list, generally because
      41              :   /// it has been performed.
      42            1 :   void pop_front();
      43              : 
      44              :   /// Calculate and store measurement times up through the expiration
      45              :   /// time of the argument.
      46              :   ///
      47              :   /// Given a measurement time \f$t_i\f$, the next measurement will
      48              :   /// occur at \f$t_{i+1} = t_i + \tau_m(t_i)\f$, where
      49              :   /// \f$\tau_m(t)\f$ is the measurement timescale at time \f$t\f$.
      50            1 :   void update(
      51              :       const domain::FunctionsOfTime::FunctionOfTime& measurement_timescale);
      52              : 
      53            0 :   void pup(PUP::er& p);
      54              : 
      55            0 :   friend bool operator==(const FutureMeasurements& lhs,
      56              :                          const FutureMeasurements& rhs);
      57              : 
      58              :  private:
      59              :   // This stores the most recent (or current) measurement time,
      60              :   // followed by some future measurement times.  We need to keep one
      61              :   // old entry that isn't returned so that we can use it to calculate
      62              :   // a new first entry if we need to update an "empty" list.  The
      63              :   // bookkeeping is simpler if we keep it around even when we don't
      64              :   // need it.
      65            0 :   std::deque<double> measurements_{};
      66            0 :   size_t measurements_until_update_{};
      67            0 :   size_t measurements_per_update_{};
      68              : };
      69              : 
      70            0 : bool operator!=(const FutureMeasurements& lhs, const FutureMeasurements& rhs);
      71              : }  // namespace control_system