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             : 
      10             : #include "DataStructures/DataVector.hpp"
      11             : 
      12             : /// \cond
      13             : namespace PUP {
      14             : class er;
      15             : }  // namespace PUP
      16             : /// \endcond
      17             : 
      18             : namespace intrp {
      19             : 
      20             : /// \ingroup NumericalAlgorithmsGroup
      21             : /// \brief A class that predicts when a function crosses zero
      22           1 : class ZeroCrossingPredictor {
      23             :  public:
      24             :   /// Uses at most max_size times for the fit; throws away old
      25             :   /// times as new times are added.
      26             :   /// The is_valid function returns false until min_size times
      27             :   /// have been added.  min_size must be at least 3.
      28           1 :   ZeroCrossingPredictor(size_t min_size, size_t max_size);
      29             : 
      30           0 :   ZeroCrossingPredictor() = default;
      31             : 
      32             :   /// Adds a data point at time t to the ZeroCrossingPredictor.
      33           1 :   void add(double t, DataVector data_at_time_t);
      34             : 
      35             :   /// For each component of the data, returns the time, relative to
      36             :   /// current_time, that a linear fit to the given component of the
      37             :   /// data crosses zero.  The length of the return value is the same
      38             :   /// as the length of `data_at_time_t` in the `add` function.
      39             :   ///
      40             :   /// The zero-crossing time that is computed has error bars
      41             :   /// associated with it.  If the error bars are large enough that it
      42             :   /// is not clear whether the zero-crossing time is positive or
      43             :   /// negative, then zero is returned instead of the best-fit
      44             :   /// zero-crossing time.
      45           1 :   DataVector zero_crossing_time(double current_time) const;
      46             : 
      47             :   /// The minimum positive value over the DataVector returned
      48             :   /// by zero_crossing_time. If there is no minimum positive value (all are
      49             :   /// negative), returns `std::nullopt`. Also returns `std::nullopt` if
      50             :   /// is_valid() is false.
      51           1 :   std::optional<double> min_positive_zero_crossing_time(
      52             :       double current_time) const;
      53             : 
      54             :   /// Returns whether we have enough data to call zero_crossing_time.
      55           1 :   bool is_valid() const;
      56             : 
      57             :   /// Clears the internal arrays.  Used to reset if there is a
      58             :   /// discontinuous change in the data that should not be fit over.
      59           1 :   void clear();
      60             : 
      61             :   // NOLINTNEXTLINE(google-runtime-references)
      62           0 :   void pup(PUP::er& p);
      63             : 
      64           0 :   friend bool operator==(const ZeroCrossingPredictor&,   // NOLINT
      65             :                          const ZeroCrossingPredictor&);  // NOLINT
      66             : 
      67             :  private:
      68           0 :   size_t min_size_{3};
      69           0 :   size_t max_size_{3};
      70           0 :   std::deque<double> times_{};
      71           0 :   std::deque<DataVector> data_{};
      72             : };
      73             : 
      74           0 : bool operator!=(const ZeroCrossingPredictor&, const ZeroCrossingPredictor&);
      75             : 
      76             : }  // namespace intrp