Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <memory>
       7             : #include <optional>
       8             : #include <pup.h>
       9             : 
      10             : /// \cond
      11             : namespace control_system::size {
      12             : struct State;
      13             : }  // namespace control_system::size
      14             : /// \endcond
      15             : 
      16             : namespace control_system::size {
      17             : 
      18             : /// Holds information that is saved between calls of SizeControl.
      19           1 : struct Info {
      20           0 :   Info() = default;
      21           0 :   Info(const Info& rhs);
      22           0 :   Info& operator=(const Info& rhs);
      23           0 :   Info(Info&& rhs) = default;
      24           0 :   Info& operator=(Info&& rhs) = default;
      25             : 
      26           0 :   Info(std::unique_ptr<State> in_state, double in_damping_time,
      27             :        double in_target_char_speed, double in_target_drift_velocity,
      28             :        std::optional<double> in_suggested_time_scale,
      29             :        bool in_discontinuous_change_has_occurred);
      30             : 
      31             :   // Info needs to be serializable because it will be
      32             :   // stored inside of a ControlError.
      33           0 :   void pup(PUP::er& p);
      34             : 
      35             :   /// The current state of size control.
      36           1 :   std::unique_ptr<State> state;
      37             :   /// The current damping time associated with size control.
      38           1 :   double damping_time;
      39             :   /// target_char_speed is what the characteristic speed is driven
      40             :   /// toward in state Label::AhSpeed.
      41           1 :   double target_char_speed;
      42             :   /// target_drift_velocity is what dr/dt (where r and t are distorted frame
      43             :   /// variables) of the excision boundary is driven toward in state
      44             :   /// Label::Initial.
      45           1 :   double target_drift_velocity;
      46             :   /// Sometimes State::update will request that damping_time
      47             :   /// be changed; the new suggested value is suggested_time_scale. If it is a
      48             :   /// `std::nullopt` then there is no suggestion.
      49           1 :   std::optional<double> suggested_time_scale;
      50             :   /// discontinuous_change_has_occurred is set to true by
      51             :   /// State::update if it changes anything in such a way that
      52             :   /// the control signal jumps discontinuously in time.
      53           1 :   bool discontinuous_change_has_occurred;
      54             : 
      55             :   /// Reset `discontinuous_change_has_occurred` and `suggested_time_scale`
      56           1 :   void reset();
      57             : 
      58           0 :   friend bool operator==(const Info& lhs, const Info& rhs);
      59           0 :   friend bool operator!=(const Info& lhs, const Info& rhs);
      60             : 
      61             :  private:
      62           0 :   void set_all_but_state(const Info& info);
      63             : };
      64             : 
      65             : /// Holds information about crossing times, as computed by
      66             : /// ZeroCrossingPredictors.
      67           1 : struct CrossingTimeInfo {
      68           0 :   CrossingTimeInfo(
      69             :       const std::optional<double>& char_speed_crossing_time,
      70             :       const std::optional<double>& comoving_char_speed_crossing_time,
      71             :       const std::optional<double>& delta_radius_crossing_time,
      72             :       const std::optional<double>& drift_limit_char_speed_crossing_time,
      73             :       const std::optional<double>& drift_limit_delta_radius_crossing_time);
      74             :   /// t_char_speed is the time (relative to the current time) when the
      75             :   /// minimum characteristic speed is predicted to cross zero (or nullopt if
      76             :   /// the minimum characteristic speed is increasing).
      77           1 :   std::optional<double> t_char_speed;
      78             :   /// t_comoving_char_speed is the time (relative to the current time) when the
      79             :   /// minimum comoving characteristic speed is predicted to cross zero
      80             :   /// (or nullopt if the minimum comoving characteristic speed is increasing).
      81           1 :   std::optional<double> t_comoving_char_speed;
      82             :   /// t_delta_radius is the time (relative to the current time) when the
      83             :   /// minimum distance between the horizon and the excision boundary is
      84             :   /// predicted to cross zero (or nullopt if the minimum distance is
      85             :   /// increasing).
      86           1 :   std::optional<double> t_delta_radius;
      87             :   /// t_drift_limit_delta_radius is the time (relative to the current time) when
      88             :   /// the minimum distance between the horizon and the excision boundary is
      89             :   /// predicted to cross the min_allowed_radial_distance associated with the
      90             :   /// state DeltaRDriftInward (or nullopt if the minimum distance is
      91             :   /// decreasing).
      92             :   /// In SpEC this quantity is called MaxDeltaRXTime
      93           1 :   std::optional<double> t_drift_limit_delta_radius;
      94             :   /// t_drift_limit is a convenient variable that is
      95             :   /// the minimum of t_drift_limit_delta_radius and t_drift_limit_char_speed,
      96             :   /// or nullopt if both drift limits are nullopt.
      97             :   /// In SpEC this quantity is called State3XTime
      98           1 :   std::optional<double> t_drift_limit;
      99             :   /// Extra variables to simplify the logic; these indicate whether
     100             :   /// the characteristic speed or the excision boundary (or neither) are
     101             :   /// expected to cross zero soon.
     102           1 :   bool char_speed_will_hit_zero_first{false};
     103           0 :   bool horizon_will_hit_excision_boundary_first{false};
     104             : };
     105             : }  // namespace control_system::size