Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <limits>
       7              : #include <optional>
       8              : 
       9              : /// \cond
      10              : struct TimeStepRequest;
      11              : namespace PUP {
      12              : class er;
      13              : }  // namespace PUP
      14              : /// \endcond
      15              : 
      16              : /// Combine TimeStepRequest objects to find a consensus step.  See
      17              : /// that class for details.
      18            1 : class TimeStepRequestProcessor {
      19              :  public:
      20            0 :   TimeStepRequestProcessor() = default;
      21            0 :   explicit TimeStepRequestProcessor(bool time_runs_forward);
      22              : 
      23              :   /// The new goal, if one was given.
      24            1 :   std::optional<double> new_step_size_goal() const;
      25              : 
      26              :   /// The new step.  Two versions are provided, as neither computing
      27              :   /// the step size from the end or the end from the size is
      28              :   /// guaranteed to be an exact operation on floating-point values,
      29              :   /// and which quantity is fundamental varies between consumers.  The
      30              :   /// \p step_size_goal is ignored if any requests have set a new
      31              :   /// goal.
      32              :   /// @{
      33            1 :   double step_size(double step_start, double step_size_goal) const;
      34            1 :   double step_end(double step_start, double step_size_goal) const;
      35              :   /// @}
      36              : 
      37            0 :   void process(const TimeStepRequest& request);
      38              : 
      39              :   /// Merge the results from another object.
      40            1 :   TimeStepRequestProcessor& operator+=(const TimeStepRequestProcessor& other);
      41              : 
      42              :   /// ERROR if \p size and \p end do not satisfy the hard limits.
      43            1 :   void error_on_hard_limit(double size, double end) const;
      44              : 
      45            0 :   void pup(PUP::er& p);
      46              : 
      47              :  private:
      48            0 :   friend bool operator==(const TimeStepRequestProcessor& a,
      49              :                          const TimeStepRequestProcessor& b);
      50              : 
      51            0 :   bool time_runs_forward_ = false;
      52              : 
      53            0 :   std::optional<double> step_size_goal_{};
      54              : 
      55            0 :   double step_size_request_ = std::numeric_limits<double>::signaling_NaN();
      56            0 :   double step_end_request_ = std::numeric_limits<double>::signaling_NaN();
      57              : 
      58            0 :   bool can_use_larger_limit_ = false;
      59            0 :   double next_step_size_request_ = std::numeric_limits<double>::signaling_NaN();
      60            0 :   double next_step_end_request_ = std::numeric_limits<double>::signaling_NaN();
      61              : 
      62            0 :   double step_size_hard_limit_ = std::numeric_limits<double>::signaling_NaN();
      63            0 :   double step_end_hard_limit_ = std::numeric_limits<double>::signaling_NaN();
      64              : };
      65              : 
      66            0 : bool operator!=(const TimeStepRequestProcessor& a,
      67              :                 const TimeStepRequestProcessor& b);
      68              : 
      69              : /// Combine the limits from two TimeStepRequestProcessor objects.
      70            1 : TimeStepRequestProcessor operator+(const TimeStepRequestProcessor& a,
      71              :                                    const TimeStepRequestProcessor& b);