From 105ffcf4de54a119eff471cc6973e79097a4554d Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Fri, 16 Feb 2024 16:24:17 -0500
Subject: [PATCH 01/16] Ignore decreases in PreventRapidIncrease

---
 src/Time/StepChoosers/PreventRapidIncrease.hpp | 18 ++++++++++--------
 .../StepChoosers/Test_PreventRapidIncrease.cpp |  4 +++-
 2 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/src/Time/StepChoosers/PreventRapidIncrease.hpp b/src/Time/StepChoosers/PreventRapidIncrease.hpp
index 86c8fb28b9f7..c3e658706df8 100644
--- a/src/Time/StepChoosers/PreventRapidIncrease.hpp
+++ b/src/Time/StepChoosers/PreventRapidIncrease.hpp
@@ -17,10 +17,10 @@
 
 namespace StepChoosers {
 /// Avoids instabilities due to rapid increases in the step size by
-/// preventing the step size from increasing unless all steps in the
-/// time-stepper history are the same size.  If there have been recent
-/// step size changes the new size bound is the size of the most
-/// recent step, otherwise it is infinite (no restriction is imposed).
+/// preventing the step size from increasing if any step in the
+/// time-stepper history increased.  If there have been recent step
+/// size increases, the new size bound is the size of the most recent
+/// step, otherwise it is infinite (no restriction is imposed).
 template <typename StepChooserUse>
 class PreventRapidIncrease : public StepChooser<StepChooserUse> {
  public:
@@ -48,15 +48,17 @@ class PreventRapidIncrease : public StepChooser<StepChooserUse> {
     const double sloppiness =
         slab_rounding_error(history.front().time_step_id.step_time());
     std::optional<Time> previous_time{};
-    for (const auto& record : history) {
-      const Time time = record.time_step_id.step_time();
+    double newer_step = last_step_magnitude;
+    for (auto record = history.rbegin(); record != history.rend(); ++record) {
+      const Time time = record->time_step_id.step_time();
       if (previous_time.has_value()) {
+        const double this_step = abs(*previous_time - time).value();
         // Potential roundoff error comes from the inability to make
         // slabs exactly the same length.
-        if (abs(abs(*previous_time - time).value() - last_step_magnitude) >
-            sloppiness) {
+        if (this_step < newer_step - sloppiness) {
           return std::make_pair(last_step_magnitude, true);
         }
+        newer_step = this_step;
       }
       previous_time.emplace(time);
     }
diff --git a/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp b/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
index ea0da0e5b09b..75d37a8b53d4 100644
--- a/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
@@ -180,10 +180,12 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.PreventRapidIncrease",
   check_case(-1, {0, {2, 5}});
   check_case(-1, {{1, 5}, {2, 5}, {3, 5}});
   check_case(-1, {{4, 5}, {5, 5}, {6, 5}});
-  check_case({1, 5}, {{4, 5}, {5, 5}, {7, 5}});
+  check_case(-1, {{4, 5}, {5, 5}, {7, 5}});
+  check_case({1, 5}, {{4, 5}, {5, 5}, {11, 10}});
   check_case({2, 5}, {{3, 5}, {5, 5}, {6, 5}});
   check_case(-1, {{1, 5}, {2, 5}, {3, 5}, {4, 5}});
   check_case({2, 5}, {{0, 5}, {2, 5}, {3, 5}, {4, 5}});
+  check_case({1, 5}, {{1, 5}, {2, 5}, {4, 5}, {5, 5}});
   check_case({1, 20}, {{1, 5}, {1, 4}, {3, 5}, {4, 5}});
 
   // Cause roundoff errors

From abf810d8c6c64b6057ba4fa728460ef507102714 Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Mon, 29 Apr 2024 14:58:42 -0400
Subject: [PATCH 02/16] Avoid potential roundoff problems in test times

Using powers of two also matches what we do in almost all cases in an
actual evolution.
---
 .../Test_PreventRapidIncrease.cpp             | 21 +++++++++----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp b/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
index 75d37a8b53d4..4e8c11237be1 100644
--- a/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
@@ -176,17 +176,16 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.PreventRapidIncrease",
 
   // -1 indicates no expected restriction
   check_case(-1, {0});
-  check_case(-1, {{2, 5}});
-  check_case(-1, {0, {2, 5}});
-  check_case(-1, {{1, 5}, {2, 5}, {3, 5}});
-  check_case(-1, {{4, 5}, {5, 5}, {6, 5}});
-  check_case(-1, {{4, 5}, {5, 5}, {7, 5}});
-  check_case({1, 5}, {{4, 5}, {5, 5}, {11, 10}});
-  check_case({2, 5}, {{3, 5}, {5, 5}, {6, 5}});
-  check_case(-1, {{1, 5}, {2, 5}, {3, 5}, {4, 5}});
-  check_case({2, 5}, {{0, 5}, {2, 5}, {3, 5}, {4, 5}});
-  check_case({1, 5}, {{1, 5}, {2, 5}, {4, 5}, {5, 5}});
-  check_case({1, 20}, {{1, 5}, {1, 4}, {3, 5}, {4, 5}});
+  check_case(-1, {{5, 8}});
+  check_case(-1, {0, {5, 8}});
+  check_case(-1, {{4, 8}, {5, 8}, {6, 8}});
+  check_case(-1, {{7, 8}, {8, 8}, {9, 8}});
+  check_case(-1, {{7, 8}, {8, 8}, {10, 8}});
+  check_case({1, 8}, {{7, 8}, {8, 8}, {17, 16}});
+  check_case({2, 8}, {{6, 8}, {8, 8}, {9, 8}});
+  check_case(-1, {{4, 8}, {5, 8}, {6, 8}, {7, 8}});
+  check_case({2, 8}, {{3, 8}, {5, 8}, {6, 8}, {7, 8}});
+  check_case({1, 8}, {{4, 8}, {5, 8}, {7, 8}, {8, 8}});
 
   // Cause roundoff errors
   check_case(-1, {{1, 3}, {2, 3}, {3, 3}});

From 200262c37572478656db9ba7df27b62f1d7268c0 Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Mon, 29 Apr 2024 15:07:42 -0400
Subject: [PATCH 03/16] Switch to symmetric computation of Time::value()

The detailed roundoff behavior shouldn't matter in the regimes we care
about, but the symmetric form is convenient for tests where negating
all the inputs now exactly negates the output.
---
 src/Time/Time.cpp | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/Time/Time.cpp b/src/Time/Time.cpp
index 4992642cd755..2a6a8a0baa8f 100644
--- a/src/Time/Time.cpp
+++ b/src/Time/Time.cpp
@@ -94,12 +94,8 @@ bool Time::StructuralCompare::operator()(const Time& a, const Time& b) const {
 }
 
 void Time::compute_value() {
-  if (is_at_slab_end()) {
-    // Protection against rounding error.
-    value_ = slab_.end_;
-  } else {
-    value_ = slab_.start_ + (slab_.duration() * fraction_).value();
-  }
+  value_ =
+      (1 - fraction_).value() * slab_.start_ + fraction_.value() * slab_.end_;
 }
 
 void Time::range_check() const {

From 818f671124923d42eb0c594d3fc4ea7f07727b44 Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Thu, 2 May 2024 18:15:43 -0400
Subject: [PATCH 04/16] Add TimeStepRequest struct

---
 src/Time/CMakeLists.txt                  |  2 +
 src/Time/TimeStepRequest.cpp             | 26 ++++++++++
 src/Time/TimeStepRequest.hpp             | 66 ++++++++++++++++++++++++
 tests/Unit/Time/CMakeLists.txt           |  1 +
 tests/Unit/Time/Test_TimeStepRequest.cpp | 34 ++++++++++++
 5 files changed, 129 insertions(+)
 create mode 100644 src/Time/TimeStepRequest.cpp
 create mode 100644 src/Time/TimeStepRequest.hpp
 create mode 100644 tests/Unit/Time/Test_TimeStepRequest.cpp

diff --git a/src/Time/CMakeLists.txt b/src/Time/CMakeLists.txt
index 7b3876d3b8f0..66b7b36ebe1c 100644
--- a/src/Time/CMakeLists.txt
+++ b/src/Time/CMakeLists.txt
@@ -20,6 +20,7 @@ spectre_target_sources(
   Time.cpp
   TimeSequence.cpp
   TimeStepId.cpp
+  TimeStepRequest.cpp
   Utilities.cpp
   )
 
@@ -42,6 +43,7 @@ spectre_target_headers(
   Time.hpp
   TimeSequence.hpp
   TimeStepId.hpp
+  TimeStepRequest.hpp
   Utilities.hpp
   )
 
diff --git a/src/Time/TimeStepRequest.cpp b/src/Time/TimeStepRequest.cpp
new file mode 100644
index 000000000000..9b45848bffb2
--- /dev/null
+++ b/src/Time/TimeStepRequest.cpp
@@ -0,0 +1,26 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#include "Time/TimeStepRequest.hpp"
+
+#include <pup.h>
+
+#include "Utilities/Serialization/PupStlCpp17.hpp"
+
+void TimeStepRequest::pup(PUP::er& p) {
+  p | size_goal;
+  p | size;
+  p | end;
+  p | size_hard_limit;
+  p | end_hard_limit;
+}
+
+bool operator==(const TimeStepRequest& a, const TimeStepRequest& b) {
+  return a.size_goal == b.size_goal and a.size == b.size and a.end == b.end and
+         a.size_hard_limit == b.size_hard_limit and
+         a.end_hard_limit == b.end_hard_limit;
+}
+
+bool operator!=(const TimeStepRequest& a, const TimeStepRequest& b) {
+  return not(a == b);
+}
diff --git a/src/Time/TimeStepRequest.hpp b/src/Time/TimeStepRequest.hpp
new file mode 100644
index 000000000000..a97e57488d04
--- /dev/null
+++ b/src/Time/TimeStepRequest.hpp
@@ -0,0 +1,66 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#pragma once
+
+#include <optional>
+
+/// \cond
+namespace PUP {
+class er;
+}  // namespace PUP
+/// \endcond
+
+/// Information on a requested time-step size returned by `StepChooser`s.
+///
+/// Requests made using this struct control most of the changing of
+/// slab and local-time-stepping step sizes.  Slab-size changing is
+/// more complex, as it is controlled using the `ChangeSlabSize`
+/// event, which may run zero or more times per slab, and may have the
+/// application of its result delayed.  The step size for LTS is
+/// adjusted using a constant list of `StepChoosers` on every step.
+///
+/// For slab-size adjustment (including the global time step when not
+/// using LTS), a "goal" step size is maintained from step to step.
+/// It is initially the initial slab size from the input file, and can
+/// be adjusted by any request setting the `size_goal` field of this
+/// struct.  If multiple requests set new goals at the same time, the
+/// smallest value is used.  At the start of each slab, the size is
+/// chosen to be the smallest of the current goal and the temporary
+/// limits imposed by any requests processed at that time.  For the
+/// LTS step size, the current step size is used as the goal if no
+/// request sets a new one.
+///
+/// Any request with either the `size` or `end` fields set introduces
+/// a temporary step size limit.  If only one of the two is set, the
+/// chosen step size will be limited to be not larger than `*size`, or
+/// not go beyond the time `*end`.  If both are set, the tighter limit
+/// may be ignored if the looser limit is chosen as the actual step,
+/// but the step will not be chosen to be intermediate between two
+/// temporary limits from the same request object.
+///
+/// The hard limits are not used in setting the step size, but if the
+/// actual step does not satisfy all hard limits from all requests the
+/// evolution will be terminated with an error.
+///
+/// \note All step sizes are subject to roundoff error in either
+/// direction except for two cases:
+/// * Slab sizes imposed by the `end` limit of a request will always
+///   end precisely at the requested time.
+/// * LTS step sizes within a single slab will always be considered to
+///   have size ratios that are exactly powers of two for the purposes
+///   of the `size_goal` and `size` limits.
+struct TimeStepRequest {
+  std::optional<double> size_goal{};
+
+  std::optional<double> size{};
+  std::optional<double> end{};
+
+  std::optional<double> size_hard_limit{};
+  std::optional<double> end_hard_limit{};
+
+  void pup(PUP::er& p);
+};
+
+bool operator==(const TimeStepRequest& a, const TimeStepRequest& b);
+bool operator!=(const TimeStepRequest& a, const TimeStepRequest& b);
diff --git a/tests/Unit/Time/CMakeLists.txt b/tests/Unit/Time/CMakeLists.txt
index d10b3b2f0a26..af46fe1e954c 100644
--- a/tests/Unit/Time/CMakeLists.txt
+++ b/tests/Unit/Time/CMakeLists.txt
@@ -18,6 +18,7 @@ set(LIBRARY_SOURCES
   Test_Time.cpp
   Test_TimeSequence.cpp
   Test_TimeStepId.cpp
+  Test_TimeStepRequest.cpp
   Test_Utilities.cpp
   )
 
diff --git a/tests/Unit/Time/Test_TimeStepRequest.cpp b/tests/Unit/Time/Test_TimeStepRequest.cpp
new file mode 100644
index 000000000000..6608d9659db4
--- /dev/null
+++ b/tests/Unit/Time/Test_TimeStepRequest.cpp
@@ -0,0 +1,34 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#include "Framework/TestingFramework.hpp"
+
+#include <optional>
+
+#include "Framework/TestHelpers.hpp"
+#include "Time/TimeStepRequest.hpp"
+
+namespace {
+void check_eq(std::optional<double> TimeStepRequest::* const field) {
+  const TimeStepRequest request{{1.0}, {2.0}, {3.0}, {4.0}, {5.0}};
+  auto request2 = request;
+  (request2.*field).reset();
+  CHECK(request != request2);
+  CHECK_FALSE(request == request2);
+}
+
+SPECTRE_TEST_CASE("Unit.Time.TimeStepRequest", "[Unit][Time]") {
+  CHECK(TimeStepRequest{{1.0}, {2.0}, {3.0}, {4.0}, {5.0}} ==
+        TimeStepRequest{{1.0}, {2.0}, {3.0}, {4.0}, {5.0}});
+  CHECK_FALSE(TimeStepRequest{{1.0}, {2.0}, {3.0}, {4.0}, {5.0}} !=
+              TimeStepRequest{{1.0}, {2.0}, {3.0}, {4.0}, {5.0}});
+
+  check_eq(&TimeStepRequest::size_goal);
+  check_eq(&TimeStepRequest::size);
+  check_eq(&TimeStepRequest::end);
+  check_eq(&TimeStepRequest::size_hard_limit);
+  check_eq(&TimeStepRequest::end_hard_limit);
+
+  test_serialization(TimeStepRequest{{1.0}, {2.0}, {3.0}, {4.0}, {5.0}});
+}
+}  // namespace

From 3534e7fef88802ae6b31efa883bfe52b5bd393a9 Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Tue, 7 May 2024 17:59:36 -0400
Subject: [PATCH 05/16] Add TimeStepRequestProcessor

---
 src/Time/CMakeLists.txt                       |   2 +
 src/Time/TimeStepRequestProcessor.cpp         | 226 ++++++++++++
 src/Time/TimeStepRequestProcessor.hpp         |  71 ++++
 tests/Unit/Time/CMakeLists.txt                |   1 +
 .../Time/Test_TimeStepRequestProcessor.cpp    | 345 ++++++++++++++++++
 5 files changed, 645 insertions(+)
 create mode 100644 src/Time/TimeStepRequestProcessor.cpp
 create mode 100644 src/Time/TimeStepRequestProcessor.hpp
 create mode 100644 tests/Unit/Time/Test_TimeStepRequestProcessor.cpp

diff --git a/src/Time/CMakeLists.txt b/src/Time/CMakeLists.txt
index 66b7b36ebe1c..b70d8d64d5a7 100644
--- a/src/Time/CMakeLists.txt
+++ b/src/Time/CMakeLists.txt
@@ -21,6 +21,7 @@ spectre_target_sources(
   TimeSequence.cpp
   TimeStepId.cpp
   TimeStepRequest.cpp
+  TimeStepRequestProcessor.cpp
   Utilities.cpp
   )
 
@@ -44,6 +45,7 @@ spectre_target_headers(
   TimeSequence.hpp
   TimeStepId.hpp
   TimeStepRequest.hpp
+  TimeStepRequestProcessor.hpp
   Utilities.hpp
   )
 
diff --git a/src/Time/TimeStepRequestProcessor.cpp b/src/Time/TimeStepRequestProcessor.cpp
new file mode 100644
index 000000000000..4e086af3cde7
--- /dev/null
+++ b/src/Time/TimeStepRequestProcessor.cpp
@@ -0,0 +1,226 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#include "Time/TimeStepRequestProcessor.hpp"
+
+#include <algorithm>
+#include <optional>
+
+#include "Time/EvolutionOrdering.hpp"
+#include "Time/TimeStepRequest.hpp"
+#include "Utilities/ErrorHandling/Assert.hpp"
+#include "Utilities/ErrorHandling/Error.hpp"
+#include "Utilities/Serialization/PupStlCpp17.hpp"
+
+TimeStepRequestProcessor::TimeStepRequestProcessor(const bool time_runs_forward)
+    : time_runs_forward_(time_runs_forward) {
+  const double inf = evolution_less<double>{time_runs_forward}.infinity();
+  step_size_request_ = inf;
+  step_end_request_ = inf;
+  next_step_size_request_ = inf;
+  next_step_end_request_ = inf;
+  step_size_hard_limit_ = inf;
+  step_end_hard_limit_ = inf;
+}
+
+std::optional<double> TimeStepRequestProcessor::new_step_size_goal() const {
+  return step_size_goal_;
+}
+
+double TimeStepRequestProcessor::step_size(const double step_start,
+                                           const double step_size_goal) const {
+  const evolution_less<double> smaller{time_runs_forward_};
+
+  const double goal = step_size_goal_.value_or(step_size_goal);
+  const double size_from_end = step_end_request_ - step_start;
+
+  if (can_use_larger_limit_) {
+    // Both limits are from the same request
+    const double request = std::max(step_size_request_, size_from_end, smaller);
+    if (not(smaller(goal, request) or
+            smaller(next_step_size_request_, request) or
+            smaller(next_step_end_request_ - step_start, request))) {
+      return request;
+    }
+  }
+
+  return std::min({goal, step_size_request_, size_from_end}, smaller);
+}
+
+double TimeStepRequestProcessor::step_end(const double step_start,
+                                          const double step_size_goal) const {
+  const evolution_less<double> before{time_runs_forward_};
+
+  const double goal = step_start + step_size_goal_.value_or(step_size_goal);
+  const double end_from_size = step_start + step_size_request_;
+
+  if (can_use_larger_limit_) {
+    // Both limits are from the same request
+    const double request = std::max(step_end_request_, end_from_size, before);
+    if (not(before(goal, request) or
+            before(step_start + next_step_size_request_, request) or
+            before(next_step_end_request_, request))) {
+      return request;
+    }
+  }
+
+  return std::min({goal, step_end_request_, end_from_size}, before);
+}
+
+void TimeStepRequestProcessor::process(const TimeStepRequest& request) {
+  // Earlier-time and smaller-step are the same operation on doubles,
+  // but it's easier to read if they have different names.
+  const evolution_less<double> before{time_runs_forward_};
+  const evolution_less<double> smaller{time_runs_forward_};
+
+  ASSERT(not(request.size_goal.has_value() and
+             request.size.has_value() and
+             smaller(*request.size_goal, *request.size)),
+         "Requested a step size goal of " << *request.size_goal
+         << ", but a particular step size larger than that goal: "
+         << *request.size);
+
+  TimeStepRequestProcessor request_postprocessor(time_runs_forward_);
+  request_postprocessor.step_size_goal_ = request.size_goal;
+
+  request_postprocessor.step_size_request_ =
+      request.size.value_or(smaller.infinity());
+  request_postprocessor.step_end_request_ =
+      request.end.value_or(before.infinity());
+
+  request_postprocessor.can_use_larger_limit_ =
+      request.size.has_value() and request.end.has_value();
+
+  request_postprocessor.step_size_hard_limit_ =
+      request.size_hard_limit.value_or(smaller.infinity());
+  request_postprocessor.step_end_hard_limit_ =
+      request.end_hard_limit.value_or(before.infinity());
+
+  *this += request_postprocessor;
+}
+
+TimeStepRequestProcessor& TimeStepRequestProcessor::operator+=(
+    const TimeStepRequestProcessor& other) {
+  ASSERT(time_runs_forward_ == other.time_runs_forward_,
+         "Inconsistent time directions.");
+
+  // Earlier-time and smaller-step are the same operation on doubles,
+  // but it's easier to read if they have different names.
+  const evolution_less<double> before{time_runs_forward_};
+  const evolution_less<double> smaller{time_runs_forward_};
+
+  if (smaller(other.step_size_goal_.value_or(smaller.infinity()),
+              step_size_goal_.value_or(smaller.infinity()))) {
+    step_size_goal_ = other.step_size_goal_;
+  }
+
+  if (smaller(step_size_request_, other.step_size_request_)) {
+    next_step_size_request_ =
+        std::min(next_step_size_request_, other.step_size_request_, smaller);
+  } else if (smaller(other.step_size_request_, step_size_request_)) {
+    next_step_size_request_ =
+        std::min(step_size_request_, other.next_step_size_request_, smaller);
+  } else {
+    next_step_size_request_ = std::min(next_step_size_request_,
+                                       other.next_step_size_request_, smaller);
+  }
+  if (before(step_end_request_, other.step_end_request_)) {
+    next_step_end_request_ =
+        std::min(next_step_end_request_, other.step_end_request_, before);
+  } else if (before(other.step_end_request_, step_end_request_)) {
+    next_step_end_request_ =
+        std::min(step_end_request_, other.next_step_end_request_, before);
+  } else {
+    next_step_end_request_ =
+        std::min(next_step_end_request_, other.next_step_end_request_, before);
+  }
+
+  const double new_size_request =
+      std::min(step_size_request_, other.step_size_request_, smaller);
+  const double new_end_request =
+      std::min(step_end_request_, other.step_end_request_, before);
+  if ((new_size_request == step_size_request_) ==
+          (new_end_request == step_end_request_) and
+      (new_size_request == other.step_size_request_) ==
+          (new_end_request == other.step_end_request_)) {
+    if (new_size_request == step_size_request_) {
+      if (new_size_request == other.step_size_request_) {
+        can_use_larger_limit_ =
+            can_use_larger_limit_ and other.can_use_larger_limit_;
+      } else {
+        // use existing value
+      }
+    } else {
+      if (new_size_request == other.step_size_request_) {
+        can_use_larger_limit_ = other.can_use_larger_limit_;
+      } else {
+        can_use_larger_limit_ = false;
+      }
+    }
+  } else {
+    can_use_larger_limit_ = false;
+  }
+  step_size_request_ = new_size_request;
+  step_end_request_ = new_end_request;
+
+  step_size_hard_limit_ =
+      std::min(step_size_hard_limit_, other.step_size_hard_limit_, smaller);
+  step_end_hard_limit_ =
+      std::min(step_end_hard_limit_, other.step_end_hard_limit_, before);
+
+  return *this;
+}
+
+void TimeStepRequestProcessor::error_on_hard_limit(const double size,
+                                                   const double end) const {
+  // Earlier-time and smaller-step are the same operation on doubles,
+  // but it's easier to read if they have different names.
+  const evolution_less<double> before{time_runs_forward_};
+  const evolution_less<double> smaller{time_runs_forward_};
+
+  if (smaller(step_size_hard_limit_, size)) {
+    ERROR("Could not adjust step below "
+          << size << " to meet maximum step size " << step_size_hard_limit_);
+  }
+  if (before(step_end_hard_limit_, end)) {
+    ERROR("Could not adjust step to before "
+          << end << " to avoid exceeding time " << step_end_hard_limit_);
+  }
+}
+
+void TimeStepRequestProcessor::pup(PUP::er& p) {
+  p | time_runs_forward_;
+  p | step_size_goal_;
+  p | step_size_request_;
+  p | step_end_request_;
+  p | can_use_larger_limit_;
+  p | next_step_size_request_;
+  p | next_step_end_request_;
+  p | step_size_hard_limit_;
+  p | step_end_hard_limit_;
+}
+
+bool operator==(const TimeStepRequestProcessor& a,
+                const TimeStepRequestProcessor& b) {
+  return a.time_runs_forward_ == b.time_runs_forward_ and
+         a.step_size_goal_ == b.step_size_goal_ and
+         a.step_size_request_ == b.step_size_request_ and
+         a.step_end_request_ == b.step_end_request_ and
+         a.can_use_larger_limit_ == b.can_use_larger_limit_ and
+         a.next_step_size_request_ == b.next_step_size_request_ and
+         a.next_step_end_request_ == b.next_step_end_request_ and
+         a.step_size_hard_limit_ == b.step_size_hard_limit_ and
+         a.step_end_hard_limit_ == b.step_end_hard_limit_;
+}
+
+bool operator!=(const TimeStepRequestProcessor& a,
+                const TimeStepRequestProcessor& b) {
+  return not(a == b);
+}
+
+TimeStepRequestProcessor operator+(const TimeStepRequestProcessor& a,
+                                   const TimeStepRequestProcessor& b) {
+  auto result = a;
+  result += b;
+  return result;
+}
diff --git a/src/Time/TimeStepRequestProcessor.hpp b/src/Time/TimeStepRequestProcessor.hpp
new file mode 100644
index 000000000000..ee8b767422b3
--- /dev/null
+++ b/src/Time/TimeStepRequestProcessor.hpp
@@ -0,0 +1,71 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#pragma once
+
+#include <limits>
+#include <optional>
+
+/// \cond
+struct TimeStepRequest;
+namespace PUP {
+class er;
+}  // namespace PUP
+/// \endcond
+
+/// Combine TimeStepRequest objects to find a consensus step.  See
+/// that class for details.
+class TimeStepRequestProcessor {
+ public:
+  TimeStepRequestProcessor() = default;
+  explicit TimeStepRequestProcessor(bool time_runs_forward);
+
+  /// The new goal, if one was given.
+  std::optional<double> new_step_size_goal() const;
+
+  /// The new step.  Two versions are provided, as neither computing
+  /// the step size from the end or the end from the size is
+  /// guaranteed to be an exact operation on floating-point values,
+  /// and which quantity is fundamental varies between consumers.  The
+  /// \p step_size_goal is ignored if any requests have set a new
+  /// goal.
+  /// @{
+  double step_size(double step_start, double step_size_goal) const;
+  double step_end(double step_start, double step_size_goal) const;
+  /// @}
+
+  void process(const TimeStepRequest& request);
+
+  /// Merge the results from another object.
+  TimeStepRequestProcessor& operator+=(const TimeStepRequestProcessor& other);
+
+  /// ERROR if \p size and \p end do not satisfy the hard limits.
+  void error_on_hard_limit(double size, double end) const;
+
+  void pup(PUP::er& p);
+
+ private:
+  friend bool operator==(const TimeStepRequestProcessor& a,
+                         const TimeStepRequestProcessor& b);
+
+  bool time_runs_forward_ = false;
+
+  std::optional<double> step_size_goal_{};
+
+  double step_size_request_ = std::numeric_limits<double>::signaling_NaN();
+  double step_end_request_ = std::numeric_limits<double>::signaling_NaN();
+
+  bool can_use_larger_limit_ = false;
+  double next_step_size_request_ = std::numeric_limits<double>::signaling_NaN();
+  double next_step_end_request_ = std::numeric_limits<double>::signaling_NaN();
+
+  double step_size_hard_limit_ = std::numeric_limits<double>::signaling_NaN();
+  double step_end_hard_limit_ = std::numeric_limits<double>::signaling_NaN();
+};
+
+bool operator!=(const TimeStepRequestProcessor& a,
+                const TimeStepRequestProcessor& b);
+
+/// Combine the limits from two TimeStepRequestProcessor objects.
+TimeStepRequestProcessor operator+(const TimeStepRequestProcessor& a,
+                                   const TimeStepRequestProcessor& b);
diff --git a/tests/Unit/Time/CMakeLists.txt b/tests/Unit/Time/CMakeLists.txt
index af46fe1e954c..a8b94e826082 100644
--- a/tests/Unit/Time/CMakeLists.txt
+++ b/tests/Unit/Time/CMakeLists.txt
@@ -19,6 +19,7 @@ set(LIBRARY_SOURCES
   Test_TimeSequence.cpp
   Test_TimeStepId.cpp
   Test_TimeStepRequest.cpp
+  Test_TimeStepRequestProcessor.cpp
   Test_Utilities.cpp
   )
 
diff --git a/tests/Unit/Time/Test_TimeStepRequestProcessor.cpp b/tests/Unit/Time/Test_TimeStepRequestProcessor.cpp
new file mode 100644
index 000000000000..ea8a5679fb0a
--- /dev/null
+++ b/tests/Unit/Time/Test_TimeStepRequestProcessor.cpp
@@ -0,0 +1,345 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#include "Framework/TestingFramework.hpp"
+
+#include <algorithm>
+#include <cstddef>
+#include <optional>
+#include <vector>
+
+#include "Framework/TestHelpers.hpp"
+#include "Time/TimeStepRequest.hpp"
+#include "Time/TimeStepRequestProcessor.hpp"
+#include "Utilities/Literals.hpp"
+#include "Utilities/Numeric.hpp"
+
+namespace {
+// Test processing requests in all orders, with different subsets
+// combined first.
+void test_permutations_roundoff(const std::vector<TimeStepRequest>& requests,
+                                const double start, const double goal,
+                                const std::optional<double>& expected_goal,
+                                const double expected_step,
+                                const double expected_end) {
+  std::vector<size_t> ordering(requests.size());
+  alg::iota(ordering, 0_st);
+  std::vector<size_t> partition{};
+  partition.reserve(requests.size());
+  do {
+    partition.clear();
+    partition.push_back(requests.size());
+    for (;;) {
+      {
+        TimeStepRequestProcessor processor(goal > 0.0);
+        TimeStepRequestProcessor processor2(goal > 0.0);
+        size_t index = 0;
+        for (const size_t partition_element : partition) {
+          TimeStepRequestProcessor element_processor(goal > 0.0);
+          for (size_t i = 0; i < partition_element; ++i) {
+            element_processor.process(requests[ordering[index]]);
+            ++index;
+          }
+          processor2 = processor + element_processor;
+          processor += serialize_and_deserialize(element_processor);
+          CHECK(processor == processor2);
+          CHECK_FALSE(processor != processor2);
+        }
+        CHECK(processor.new_step_size_goal() == expected_goal);
+        CHECK(processor.step_size(start, goal) == expected_step);
+        CHECK(processor.step_end(start, goal) == expected_end);
+        CHECK(processor2.new_step_size_goal() == expected_goal);
+        CHECK(processor2.step_size(start, goal) == expected_step);
+        CHECK(processor2.step_end(start, goal) == expected_end);
+      }
+
+      if (requests.empty() or partition.size() == requests.size()) {
+        break;
+      }
+      size_t trailing_ones = 0;
+      while (partition.back() == 1) {
+        ++trailing_ones;
+        partition.pop_back();
+      }
+      --partition.back();
+      partition.push_back(trailing_ones + 1);
+    }
+  } while (std::next_permutation(ordering.begin(), ordering.end()));
+}
+
+// Test processing requests in all orders, with different subsets
+// combined first.  This version computes the step end from the step
+// size, so only works for the non-roundoff-sensitive tests, but it
+// removes a lot of redundancy in those.
+void test_permutations(const std::vector<TimeStepRequest>& requests,
+                       const double start, const double goal,
+                       const std::optional<double>& expected_goal,
+                       const double expected_step) {
+  test_permutations_roundoff(requests, start, goal, expected_goal,
+                             expected_step, start + expected_step);
+}
+
+void test_with_roundoff(const double start, const double step,
+                        const double end) {
+  CAPTURE(start);
+  CAPTURE(step);
+  CAPTURE(end);
+  test_permutations_roundoff({}, start, step, {}, step, start + step);
+
+  test_permutations_roundoff({{.size_goal = step}}, start, 0.5 * step, {step},
+                             step, start + step);
+  test_permutations_roundoff({{.size = step}}, start, 2.0 * step, {}, step,
+                             start + step);
+  test_permutations_roundoff({{.end = end}}, start, 2.0 * step, {}, end - start,
+                             end);
+
+  test_permutations_roundoff({{.size_goal = 0.5 * step}}, start, step,
+                             {0.5 * step}, 0.5 * step, start + 0.5 * step);
+  test_permutations_roundoff({{.size = 0.5 * step}}, start, step, {},
+                             0.5 * step, start + 0.5 * step);
+  test_permutations_roundoff({{.size_goal = 2.0 * step}}, start, step,
+                             {2.0 * step}, 2.0 * step, start + 2.0 * step);
+  test_permutations_roundoff({{.size = 2.0 * step}}, start, step, {}, step,
+                             start + step);
+
+  const double far_end = end + 0.5 * step;
+  const double close_end = start + 0.5 * step;
+  test_permutations_roundoff({{.end = close_end}}, start, step, {},
+                             close_end - start, close_end);
+  test_permutations_roundoff({{.end = far_end}}, start, step, {}, step,
+                             start + step);
+
+  // Test using the looser limit when two are given.
+  test_permutations_roundoff({{.size = step, .end = start + 0.5 * step}}, start,
+                             2.0 * step, {}, step, start + step);
+  test_permutations_roundoff({{.size = 0.5 * step, .end = end}}, start,
+                             2.0 * step, {}, end - start, end);
+}
+
+void test_processor(const bool time_runs_forward) {
+  const double time_sign = time_runs_forward ? 1.0 : -1.0;
+
+  {
+    const double start = 2.0 * time_sign;
+    const double end = 5.0 * time_sign;
+    const double step = end - start;
+    // Ignore roundoff subtleties for this part of the test.
+    CHECK(start + step == end);
+
+    {
+      TimeStepRequestProcessor processor(time_runs_forward);
+      CHECK(processor == TimeStepRequestProcessor(time_runs_forward));
+      CHECK_FALSE(processor != TimeStepRequestProcessor(time_runs_forward));
+      CHECK(processor != TimeStepRequestProcessor(not time_runs_forward));
+      CHECK_FALSE(processor == TimeStepRequestProcessor(not time_runs_forward));
+      processor.process({.end = end});
+      CHECK(processor != TimeStepRequestProcessor(time_runs_forward));
+      CHECK_FALSE(processor == TimeStepRequestProcessor(time_runs_forward));
+    }
+
+    // No requests.
+    test_permutations({}, start, step, {}, step);
+    test_permutations({{}}, start, step, {}, step);
+    test_permutations({{}, {}}, start, step, {}, step);
+
+    // Simple goal setting requests.
+    test_permutations({{.size_goal = 0.5 * step}}, start, step, {0.5 * step},
+                      0.5 * step);
+    test_permutations({{.size_goal = 2.0 * step}}, start, step, {2.0 * step},
+                      2.0 * step);
+
+    // Simple step size requests.
+    test_permutations({{.size = 0.5 * step}}, start, step, {}, 0.5 * step);
+    test_permutations({{.size = 2.0 * step}}, start, step, {}, step);
+
+    // Simple step end requests.
+    test_permutations({{.end = start + 0.5 * step}}, start, step, {},
+                      0.5 * step);
+    test_permutations({{.end = start + 2.0 * step}}, start, step, {}, step);
+
+    // Multiple requests of the same type.
+    test_permutations({{.size_goal = 0.5 * step}, {.size_goal = 0.25 * step}},
+                      start, step, {0.25 * step}, 0.25 * step);
+    test_permutations({{.size = 0.5 * step}, {.size = 0.25 * step}}, start,
+                      step, {}, 0.25 * step);
+    test_permutations(
+        {{.end = start + 0.5 * step}, {.end = start + 0.25 * step}}, start,
+        step, {}, 0.25 * step);
+
+    // Multiple requests of different types.
+    // size_goal wins
+    test_permutations({{.size_goal = 0.5 * step}, {.size = 0.6 * step}}, start,
+                      step, {0.5 * step}, 0.5 * step);
+    test_permutations({{.size_goal = 0.5 * step}, {.end = start + 0.6 * step}},
+                      start, step, {0.5 * step}, 0.5 * step);
+    test_permutations({{.size_goal = 0.5 * step},
+                       {.size = 0.6 * step},
+                       {.end = start + 0.6 * step}},
+                      start, step, {0.5 * step}, 0.5 * step);
+    // size wins
+    test_permutations({{.size_goal = 0.6 * step}, {.size = 0.5 * step}}, start,
+                      step, {0.6 * step}, 0.5 * step);
+    test_permutations({{.size = 0.5 * step}, {.end = start + 0.6 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size_goal = 0.6 * step},
+                       {.size = 0.5 * step},
+                       {.end = start + 0.6 * step}},
+                      start, step, {0.6 * step}, 0.5 * step);
+    // end wins
+    test_permutations({{.size_goal = 0.6 * step}, {.end = start + 0.5 * step}},
+                      start, step, {0.6 * step}, 0.5 * step);
+    test_permutations({{.size = 0.6 * step}, {.end = start + 0.5 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size_goal = 0.6 * step},
+                       {.size = 0.6 * step},
+                       {.end = start + 0.5 * step}},
+                      start, step, {0.6 * step}, 0.5 * step);
+
+    // Requests with both .size and .end are fulfilled if either is
+    // used without adjustment.
+    test_permutations({{.size_goal = 0.6 * step,
+                        .size = 0.4 * step,
+                        .end = start + 0.5 * step}},
+                      start, step, {0.6 * step}, 0.5 * step);
+    test_permutations({{.size_goal = 0.6 * step,
+                        .size = 0.5 * step,
+                        .end = start + 0.4 * step}},
+                      start, step, {0.6 * step}, 0.5 * step);
+    test_permutations({{.size = 0.4 * step, .end = start + 0.5 * step}}, start,
+                      step, {}, 0.5 * step);
+    test_permutations({{.size = 0.5 * step, .end = start + 0.4 * step}}, start,
+                      step, {}, 0.5 * step);
+    // .size_goal doesn't participate in that.
+    test_permutations({{.size_goal = 0.5 * step, .end = start + 0.6 * step}},
+                      start, step, {0.5 * step}, 0.5 * step);
+    test_permutations({{.size_goal = 0.6 * step, .end = start + 0.5 * step}},
+                      start, step, {0.6 * step}, 0.5 * step);
+
+    // Repeats don't affect the result.
+    test_permutations({{.size = 0.4 * step, .end = start + 0.5 * step},
+                       {.size = 0.4 * step, .end = start + 0.5 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.5 * step, .end = start + 0.4 * step},
+                       {.size = 0.5 * step, .end = start + 0.4 * step}},
+                      start, step, {}, 0.5 * step);
+
+    // Less stringent requirements don't affect that, either.
+    test_permutations(
+        {{.size = 0.4 * step, .end = start + 0.5 * step}, {.size = 0.6 * step}},
+        start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.4 * step, .end = start + 0.5 * step},
+                       {.end = start + 0.6 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations(
+        {{.size = 0.5 * step, .end = start + 0.4 * step}, {.size = 0.6 * step}},
+        start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.5 * step, .end = start + 0.4 * step},
+                       {.end = start + 0.6 * step}},
+                      start, step, {}, 0.5 * step);
+
+    // Requests with both .size and .end usually must satisfy both in
+    // other cases.
+    test_permutations({{.size = 0.5 * step, .end = start + 0.6 * step},
+                       {.size = 0.55 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.6 * step, .end = start + 0.5 * step},
+                       {.size = 0.55 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.5 * step, .end = start + 0.6 * step},
+                       {.end = start + 0.55 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.6 * step, .end = start + 0.5 * step},
+                       {.end = start + 0.55 * step}},
+                      start, step, {}, 0.5 * step);
+
+    // Including when other requests partially duplicate them.
+    test_permutations(
+        {{.size = 0.5 * step, .end = start + 0.6 * step}, {.size = 0.5 * step}},
+        start, step, {}, 0.5 * step);
+    test_permutations(
+        {{.size = 0.6 * step, .end = start + 0.5 * step}, {.size = 0.5 * step}},
+        start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.5 * step, .end = start + 0.6 * step},
+                       {.end = start + 0.5 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.6 * step, .end = start + 0.5 * step},
+                       {.end = start + 0.5 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.5 * step, .end = start + 0.6 * step},
+                       {.size = 0.5 * step},
+                       {.end = start + 0.6 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.6 * step, .end = start + 0.5 * step},
+                       {.size = 0.6 * step},
+                       {.end = start + 0.5 * step}},
+                      start, step, {}, 0.5 * step);
+
+    // And when multiple different ones occur.
+    test_permutations({{.size = 0.7 * step, .end = start + 0.6 * step},
+                       {.size = 0.65 * step, .end = start + 0.5 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.7 * step, .end = start + 0.6 * step},
+                       {.size = 0.5 * step, .end = start + 0.65 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.6 * step, .end = start + 0.7 * step},
+                       {.size = 0.65 * step, .end = start + 0.5 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.6 * step, .end = start + 0.7 * step},
+                       {.size = 0.5 * step, .end = start + 0.65 * step}},
+                      start, step, {}, 0.5 * step);
+
+    // Test with several entries.
+    test_permutations({{.size_goal = 0.6 * step, .size = 0.5 * step},
+                       {.size_goal = 0.7 * step},
+                       {.size = 0.6 * step},
+                       {.end = start + 0.6 * step},
+                       {.end = start + 0.7 * step}},
+                      start, step, {0.6 * step}, 0.5 * step);
+
+    // Hard limits don't affect the suggestion
+    test_permutations({{.size_hard_limit = 0.5 * step}}, start, step, {}, step);
+    test_permutations({{.end_hard_limit = start + 0.5 * step}}, start, step, {},
+                      step);
+
+    {
+      TimeStepRequestProcessor processor(step > 0.0);
+      processor.process({.size_hard_limit = step, .end_hard_limit = end});
+      processor.error_on_hard_limit(0.9 * step, start);
+      processor.error_on_hard_limit(step, end);
+      CHECK_THROWS_WITH(
+          processor.error_on_hard_limit(1.1 * step, end),
+          Catch::Matchers::ContainsSubstring("Could not adjust step below ") and
+              Catch::Matchers::ContainsSubstring(
+                  " to meet maximum step size "));
+      CHECK_THROWS_WITH(
+          processor.error_on_hard_limit(step, start + 1.1 * step),
+          Catch::Matchers::ContainsSubstring(
+              "Could not adjust step to before ") and
+              Catch::Matchers::ContainsSubstring(" to avoid exceeding time "));
+    }
+  }
+
+  {
+    const double start = -1.0e20 * time_sign;
+    const double end = 1.0 * time_sign;
+    const double step = 1.0e20 * time_sign;
+    CHECK(end - start == step);
+    CHECK(start + step != end);
+    test_with_roundoff(start, step, end);
+  }
+
+  {
+    const double start = 1.0 * time_sign;
+    const double end = (1.0 + 1.0e-10) * time_sign;
+    const double step = (1.0e-10 + 1.0e-20) * time_sign;
+    CHECK(end - start != step);
+    CHECK(start + step == end);
+    test_with_roundoff(start, step, end);
+  }
+}
+
+SPECTRE_TEST_CASE("Unit.Time.TimeStepRequestProcessor", "[Unit][Time]") {
+  test_processor(true);
+  test_processor(false);
+}
+}  // namespace

From 422430e96af48192c3b41039216c4f47f548e107 Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Tue, 7 May 2024 21:08:40 -0400
Subject: [PATCH 06/16] Add SlabSizeGoal tag, initialize, and project

---
 src/Evolution/Initialization/Evolution.hpp    | 19 +++++-
 src/Time/ChangeSlabSize/Tags.hpp              |  6 ++
 .../Initialization/Test_Evolution.cpp         | 64 +++++++++++++------
 tests/Unit/Time/ChangeSlabSize/Test_Tags.cpp  |  2 +
 4 files changed, 69 insertions(+), 22 deletions(-)

diff --git a/src/Evolution/Initialization/Evolution.hpp b/src/Evolution/Initialization/Evolution.hpp
index de6bfcdea451..6f832f623b9e 100644
--- a/src/Evolution/Initialization/Evolution.hpp
+++ b/src/Evolution/Initialization/Evolution.hpp
@@ -26,6 +26,7 @@
 #include "Parallel/Tags/ArrayIndex.hpp"
 #include "ParallelAlgorithms/Amr/Protocols/Projector.hpp"
 #include "Time/AdaptiveSteppingDiagnostics.hpp"
+#include "Time/ChangeSlabSize/Tags.hpp"
 #include "Time/ChooseLtsStepSize.hpp"
 #include "Time/Slab.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
@@ -114,7 +115,8 @@ struct TimeStepping {
   /// Tags for items in the DataBox that are mutated by the apply function
   using return_tags =
       tmpl::list<::Tags::Next<::Tags::TimeStepId>, ::Tags::TimeStep,
-                 ::Tags::Next<::Tags::TimeStep>>;
+                 ::Tags::Next<::Tags::TimeStep>,
+                 ::Tags::ChangeSlabSize::SlabSizeGoal>;
 
   /// Tags for mutable DataBox items that are either default initialized or
   /// initialized by the apply function
@@ -130,6 +132,7 @@ struct TimeStepping {
   static void apply(const gsl::not_null<TimeStepId*> next_time_step_id,
                     const gsl::not_null<TimeDelta*> time_step,
                     const gsl::not_null<TimeDelta*> next_time_step,
+                    const gsl::not_null<double*> slab_size_goal,
                     const double initial_time_value,
                     const double initial_dt_value,
                     const double initial_slab_size,
@@ -141,6 +144,8 @@ struct TimeStepping {
                                   time_runs_forward, time_stepper);
     *time_step = choose_lts_step_size(initial_time, initial_dt_value);
     *next_time_step = *time_step;
+    *slab_size_goal =
+        time_runs_forward ? initial_slab_size : -initial_slab_size;
   }
 
   /// Given the items fetched from a DataBox by the argument_tags, when not
@@ -148,6 +153,7 @@ struct TimeStepping {
   static void apply(const gsl::not_null<TimeStepId*> next_time_step_id,
                     const gsl::not_null<TimeDelta*> time_step,
                     const gsl::not_null<TimeDelta*> next_time_step,
+                    const gsl::not_null<double*> slab_size_goal,
                     const double initial_time_value,
                     const double initial_dt_value,
                     const double initial_slab_size,
@@ -159,6 +165,8 @@ struct TimeStepping {
                                   time_runs_forward, time_stepper);
     *time_step = (time_runs_forward ? 1 : -1) * initial_time.slab().duration();
     *next_time_step = *time_step;
+    *slab_size_goal =
+        time_runs_forward ? initial_slab_size : -initial_slab_size;
   }
 };
 
@@ -168,7 +176,8 @@ struct ProjectTimeStepping : tt::ConformsTo<amr::protocols::Projector> {
   using return_tags =
       tmpl::list<::Tags::TimeStepId, ::Tags::Next<::Tags::TimeStepId>,
                  ::Tags::TimeStep, ::Tags::Next<::Tags::TimeStep>, ::Tags::Time,
-                 ::Tags::AdaptiveSteppingDiagnostics>;
+                 ::Tags::AdaptiveSteppingDiagnostics,
+                 ::Tags::ChangeSlabSize::SlabSizeGoal>;
   using argument_tags = tmpl::list<Parallel::Tags::ArrayIndex>;
 
   static void apply(
@@ -179,6 +188,7 @@ struct ProjectTimeStepping : tt::ConformsTo<amr::protocols::Projector> {
       const gsl::not_null<double*> /*time*/,
       const gsl::not_null<AdaptiveSteppingDiagnostics*>
       /*adaptive_stepping_diagnostics*/,
+      const gsl::not_null<double*> /*slab_size_goal*/,
       const ElementId<Dim>& /*element_id*/,
       const std::pair<Mesh<Dim>, Element<Dim>>& /*old_mesh_and_element*/) {
     // Do not change anything for p-refinement
@@ -192,6 +202,7 @@ struct ProjectTimeStepping : tt::ConformsTo<amr::protocols::Projector> {
                     const gsl::not_null<double*> time,
                     const gsl::not_null<AdaptiveSteppingDiagnostics*>
                         adaptive_stepping_diagnostics,
+                    const gsl::not_null<double*> slab_size_goal,
                     const ElementId<Dim>& element_id,
                     const tuples::TaggedTuple<Tags...>& parent_items) {
     *time_step_id = get<::Tags::TimeStepId>(parent_items);
@@ -199,6 +210,7 @@ struct ProjectTimeStepping : tt::ConformsTo<amr::protocols::Projector> {
     *time_step = get<::Tags::TimeStep>(parent_items);
     *next_time_step = get<::Tags::Next<::Tags::TimeStep>>(parent_items);
     *time = get<::Tags::Time>(parent_items);
+    *slab_size_goal = get<::Tags::ChangeSlabSize::SlabSizeGoal>(parent_items);
 
     // Since AdaptiveSteppingDiagnostics are reduced over all elements, we
     // set the slab quantities to the same value over all children, and the
@@ -229,6 +241,7 @@ struct ProjectTimeStepping : tt::ConformsTo<amr::protocols::Projector> {
       const gsl::not_null<double*> time,
       const gsl::not_null<AdaptiveSteppingDiagnostics*>
           adaptive_stepping_diagnostics,
+      const gsl::not_null<double*> slab_size_goal,
       const ElementId<Dim>& /*element_id*/,
       const std::unordered_map<ElementId<Dim>, tuples::TaggedTuple<Tags...>>&
           children_items) {
@@ -248,6 +261,8 @@ struct ProjectTimeStepping : tt::ConformsTo<amr::protocols::Projector> {
     *time_step = get<::Tags::TimeStep>(slowest_child_items);
     *next_time_step = get<::Tags::Next<::Tags::TimeStep>>(slowest_child_items);
     *time = get<::Tags::Time>(slowest_child_items);
+    *slab_size_goal =
+        get<::Tags::ChangeSlabSize::SlabSizeGoal>(slowest_child_items);
     const auto& slowest_child_diagnostics =
         get<::Tags::AdaptiveSteppingDiagnostics>(slowest_child_items);
 
diff --git a/src/Time/ChangeSlabSize/Tags.hpp b/src/Time/ChangeSlabSize/Tags.hpp
index aed2107ef59f..a0ba6a4f609a 100644
--- a/src/Time/ChangeSlabSize/Tags.hpp
+++ b/src/Time/ChangeSlabSize/Tags.hpp
@@ -20,4 +20,10 @@ struct NewSlabSize : db::SimpleTag {
 struct NumberOfExpectedMessages : db::SimpleTag {
   using type = std::map<int64_t, size_t>;
 };
+
+/// Long-term desired slab size.  Used as the default size if nothing
+/// chooses a smaller one.
+struct SlabSizeGoal : db::SimpleTag {
+  using type = double;
+};
 }  // namespace Tags::ChangeSlabSize
diff --git a/tests/Unit/Evolution/Initialization/Test_Evolution.cpp b/tests/Unit/Evolution/Initialization/Test_Evolution.cpp
index d5945b20d49b..57b4f7e8b366 100644
--- a/tests/Unit/Evolution/Initialization/Test_Evolution.cpp
+++ b/tests/Unit/Evolution/Initialization/Test_Evolution.cpp
@@ -5,6 +5,7 @@
 
 #include <array>
 #include <cstddef>
+#include <limits>
 #include <memory>
 #include <unordered_map>
 #include <utility>
@@ -26,6 +27,7 @@
 #include "Parallel/Tags/ArrayIndex.hpp"
 #include "ParallelAlgorithms/Amr/Protocols/Projector.hpp"
 #include "Time/AdaptiveSteppingDiagnostics.hpp"
+#include "Time/ChangeSlabSize/Tags.hpp"
 #include "Time/ChooseLtsStepSize.hpp"
 #include "Time/Slab.hpp"
 #include "Time/StepChoosers/Increase.hpp"
@@ -83,11 +85,11 @@ void test_gts() {
           ::Tags::Time, Initialization::Tags::InitialTimeDelta,
           Initialization::Tags::InitialSlabSize<false>,
           ::Tags::Next<::Tags::TimeStepId>, ::Tags::TimeStep,
-          ::Tags::Next<::Tags::TimeStep>>,
+          ::Tags::Next<::Tags::TimeStep>, ::Tags::ChangeSlabSize::SlabSizeGoal>,
       tmpl::list<Parallel::Tags::FromGlobalCache<
           ::Tags::ConcreteTimeStepper<TimeStepper>>>>(
       &global_cache, initial_time, initial_dt, initial_slab_size, TimeStepId{},
-      TimeDelta{}, TimeDelta{});
+      TimeDelta{}, TimeDelta{}, std::numeric_limits<double>::signaling_NaN());
 
   db::mutate_apply<Initialization::TimeStepping<TestMetavariables<TimeStepper>,
                                                 TimeStepper>>(
@@ -98,6 +100,8 @@ void test_gts() {
   CHECK(db::get<::Tags::TimeStep>(box) == expected_time_step);
   CHECK(db::get<::Tags::Next<::Tags::TimeStep>>(box) ==
         expected_next_time_step);
+  CHECK(db::get<::Tags::ChangeSlabSize::SlabSizeGoal>(box) ==
+        initial_slab_size);
 }
 
 void test_lts() {
@@ -128,11 +132,11 @@ void test_lts() {
           ::Tags::Time, Initialization::Tags::InitialTimeDelta,
           Initialization::Tags::InitialSlabSize<true>,
           ::Tags::Next<::Tags::TimeStepId>, ::Tags::TimeStep,
-          ::Tags::Next<::Tags::TimeStep>>,
+          ::Tags::Next<::Tags::TimeStep>, ::Tags::ChangeSlabSize::SlabSizeGoal>,
       tmpl::list<Parallel::Tags::FromGlobalCache<
           ::Tags::ConcreteTimeStepper<LtsTimeStepper>>>>(
       &global_cache, initial_time, initial_dt, initial_slab_size, TimeStepId{},
-      TimeDelta{}, TimeDelta{});
+      TimeDelta{}, TimeDelta{}, std::numeric_limits<double>::signaling_NaN());
 
   db::mutate_apply<Initialization::TimeStepping<
       TestMetavariables<LtsTimeStepper>, LtsTimeStepper>>(make_not_null(&box));
@@ -142,18 +146,22 @@ void test_lts() {
   CHECK(db::get<::Tags::TimeStep>(box) == expected_time_step);
   CHECK(db::get<::Tags::Next<::Tags::TimeStep>>(box) ==
         expected_next_time_step);
+  CHECK(db::get<::Tags::ChangeSlabSize::SlabSizeGoal>(box) ==
+        initial_slab_size);
 }
 using items_type =
     tuples::TaggedTuple<Parallel::Tags::ArrayIndexImpl<ElementId<1>>,
                         ::Tags::TimeStepId, ::Tags::Next<::Tags::TimeStepId>,
                         ::Tags::TimeStep, ::Tags::Next<::Tags::TimeStep>,
-                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics>;
+                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics,
+                        ::Tags::ChangeSlabSize::SlabSizeGoal>;
 
 using parent_items_type =
     tuples::TaggedTuple<Parallel::Tags::ArrayIndexImpl<ElementId<1>>,
                         ::Tags::TimeStepId, ::Tags::Next<::Tags::TimeStepId>,
                         ::Tags::TimeStep, ::Tags::Next<::Tags::TimeStep>,
                         ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics,
+                        ::Tags::ChangeSlabSize::SlabSizeGoal,
                         ::amr::Tags::Info<1>>;
 
 template <typename DbTagList>
@@ -162,7 +170,8 @@ void check(const db::DataBox<DbTagList>& box,
            const TimeStepId& expected_next_time_step_id,
            const TimeDelta& expected_time_step,
            const TimeDelta& expected_next_time_step, const double expected_time,
-           const AdaptiveSteppingDiagnostics& expected_diagnostics) {
+           const AdaptiveSteppingDiagnostics& expected_diagnostics,
+           const double expected_slab_size_goal) {
   CHECK(db::get<::Tags::TimeStepId>(box) == expected_time_step_id);
   CHECK(db::get<::Tags::Next<::Tags::TimeStepId>>(box) ==
         expected_next_time_step_id);
@@ -172,6 +181,8 @@ void check(const db::DataBox<DbTagList>& box,
   CHECK(db::get<::Tags::Time>(box) == expected_time);
   CHECK(db::get<::Tags::AdaptiveSteppingDiagnostics>(box) ==
         expected_diagnostics);
+  CHECK(db::get<::Tags::ChangeSlabSize::SlabSizeGoal>(box) ==
+        expected_slab_size_goal);
 }
 
 void test_p_refine() {
@@ -188,20 +199,22 @@ void test_p_refine() {
                                      start + time_step};
   const double time = start.value();
   const AdaptiveSteppingDiagnostics diagnostics{7, 2, 13, 4, 5};
+  const double slab_size_goal = 1.34;
 
   auto box = db::create<
       db::AddSimpleTags<Parallel::Tags::ArrayIndexImpl<ElementId<1>>,
                         ::Tags::TimeStepId, ::Tags::Next<::Tags::TimeStepId>,
                         ::Tags::TimeStep, ::Tags::Next<::Tags::TimeStep>,
-                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics>>(
+                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics,
+                        ::Tags::ChangeSlabSize::SlabSizeGoal>>(
       element_id, time_step_id, next_time_step_id, time_step, next_time_step,
-      time, diagnostics);
+      time, diagnostics, slab_size_goal);
 
   db::mutate_apply<Initialization::ProjectTimeStepping<1>>(
       make_not_null(&box), std::make_pair(mesh, element));
 
   check(box, time_step_id, next_time_step_id, time_step, next_time_step, time,
-        diagnostics);
+        diagnostics, slab_size_goal);
 }
 
 void test_split() {
@@ -218,6 +231,7 @@ void test_split() {
                                      start + time_step};
   const double time = start.value();
   const AdaptiveSteppingDiagnostics diagnostics{7, 2, 13, 4, 5};
+  const double slab_size_goal = 1.34;
 
   const parent_items_type parent_items{
       parent_id,
@@ -227,35 +241,40 @@ void test_split() {
       next_time_step,
       time,
       diagnostics,
+      slab_size_goal,
       ::amr::Info<1>{std::array{::amr::Flag::Split}, Mesh<1>{}}};
 
   auto child_1_box = db::create<
       db::AddSimpleTags<Parallel::Tags::ArrayIndexImpl<ElementId<1>>,
                         ::Tags::TimeStepId, ::Tags::Next<::Tags::TimeStepId>,
                         ::Tags::TimeStep, ::Tags::Next<::Tags::TimeStep>,
-                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics>>(
+                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics,
+                        ::Tags::ChangeSlabSize::SlabSizeGoal>>(
       child_1_id, TimeStepId{}, TimeStepId{}, TimeDelta{}, TimeDelta{}, 0.0,
-      AdaptiveSteppingDiagnostics{});
+      AdaptiveSteppingDiagnostics{},
+      std::numeric_limits<double>::signaling_NaN());
 
   auto child_2_box = db::create<
       db::AddSimpleTags<Parallel::Tags::ArrayIndexImpl<ElementId<1>>,
                         ::Tags::TimeStepId, ::Tags::Next<::Tags::TimeStepId>,
                         ::Tags::TimeStep, ::Tags::Next<::Tags::TimeStep>,
-                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics>>(
+                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics,
+                        ::Tags::ChangeSlabSize::SlabSizeGoal>>(
       child_2_id, TimeStepId{}, TimeStepId{}, TimeDelta{}, TimeDelta{}, 0.0,
-      AdaptiveSteppingDiagnostics{});
+      AdaptiveSteppingDiagnostics{},
+      std::numeric_limits<double>::signaling_NaN());
 
   db::mutate_apply<Initialization::ProjectTimeStepping<1>>(
       make_not_null(&child_1_box), parent_items);
 
   check(child_1_box, time_step_id, next_time_step_id, time_step, next_time_step,
-        time, diagnostics);
+        time, diagnostics, slab_size_goal);
 
   db::mutate_apply<Initialization::ProjectTimeStepping<1>>(
       make_not_null(&child_2_box), parent_items);
 
   check(child_2_box, time_step_id, next_time_step_id, time_step, next_time_step,
-        time, AdaptiveSteppingDiagnostics{7, 2, 0, 0, 0});
+        time, AdaptiveSteppingDiagnostics{7, 2, 0, 0, 0}, slab_size_goal);
 }
 
 template <bool ForwardInTime>
@@ -274,6 +293,7 @@ void test_join() {
                                        start_1 + time_step_1};
   const double time_1 = start_1.value();
   const AdaptiveSteppingDiagnostics diagnostics_1{7, 2, 13, 4, 5};
+  const double slab_size_goal_1 = 1.34;
 
   const Slab slab_2(1., 1.5);
   const Time start_2{ForwardInTime ? slab_2.start() : slab_2.end()};
@@ -284,30 +304,34 @@ void test_join() {
                                        start_2 + time_step_2};
   const double time_2 = start_2.value();
   const AdaptiveSteppingDiagnostics diagnostics_2{7, 2, 27, 2, 8};
+  const double slab_size_goal_2 = slab_size_goal_1;
 
   std::unordered_map<ElementId<1>, items_type> children_items;
   children_items.emplace(
       child_1_id,
       items_type{child_1_id, time_step_id_1, next_time_step_id_1, time_step_1,
-                 next_time_step_1, time_1, diagnostics_1});
+                 next_time_step_1, time_1, diagnostics_1, slab_size_goal_1});
   children_items.emplace(
       child_2_id,
       items_type{child_2_id, time_step_id_2, next_time_step_id_2, time_step_2,
-                 next_time_step_2, time_2, diagnostics_2});
+                 next_time_step_2, time_2, diagnostics_2, slab_size_goal_2});
 
   auto parent_box = db::create<
       db::AddSimpleTags<Parallel::Tags::ArrayIndexImpl<ElementId<1>>,
                         ::Tags::TimeStepId, ::Tags::Next<::Tags::TimeStepId>,
                         ::Tags::TimeStep, ::Tags::Next<::Tags::TimeStep>,
-                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics>>(
+                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics,
+                        ::Tags::ChangeSlabSize::SlabSizeGoal>>(
       parent_id, TimeStepId{}, TimeStepId{}, TimeDelta{}, TimeDelta{}, 0.0,
-      AdaptiveSteppingDiagnostics{});
+      AdaptiveSteppingDiagnostics{},
+      std::numeric_limits<double>::signaling_NaN());
 
   db::mutate_apply<Initialization::ProjectTimeStepping<1>>(
       make_not_null(&parent_box), children_items);
 
   check(parent_box, time_step_id_2, next_time_step_id_2, time_step_2,
-        next_time_step_2, time_2, AdaptiveSteppingDiagnostics{7, 2, 40, 6, 13});
+        next_time_step_2, time_2, AdaptiveSteppingDiagnostics{7, 2, 40, 6, 13},
+        slab_size_goal_2);
 }
 }  // namespace
 
diff --git a/tests/Unit/Time/ChangeSlabSize/Test_Tags.cpp b/tests/Unit/Time/ChangeSlabSize/Test_Tags.cpp
index 9ddac39c4715..f14b3605f4fe 100644
--- a/tests/Unit/Time/ChangeSlabSize/Test_Tags.cpp
+++ b/tests/Unit/Time/ChangeSlabSize/Test_Tags.cpp
@@ -14,4 +14,6 @@ SPECTRE_TEST_CASE("Unit.Time.ChangeSlabSize.Tags", "[Unit][Time]") {
   TestHelpers::db::test_simple_tag<
       Tags::ChangeSlabSize::NumberOfExpectedMessages>(
       "NumberOfExpectedMessages");
+  TestHelpers::db::test_simple_tag<Tags::ChangeSlabSize::SlabSizeGoal>(
+      "SlabSizeGoal");
 }

From 38a22bcd4c6c882bc6817a4999065a315a655536 Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Tue, 30 Apr 2024 14:05:25 -0400
Subject: [PATCH 07/16] Use TimeStepRequest in StepChoosers

This does not change the StepChoosers to use new features of the
interface, although the new slab-size goal can come into effect with
the LimitTimeStep control system action (as desired).
---
 src/Time/Actions/ChangeStepSize.hpp           |  42 +++---
 src/Time/ChangeSlabSize/Action.hpp            | 125 ++++++++++--------
 src/Time/ChangeSlabSize/Event.hpp             |  53 +++++---
 src/Time/ChangeSlabSize/Tags.hpp              |   5 +-
 src/Time/StepChoosers/ByBlock.hpp             |  12 +-
 src/Time/StepChoosers/Cfl.hpp                 |  16 ++-
 src/Time/StepChoosers/Constant.hpp            |  10 +-
 src/Time/StepChoosers/ElementSizeCfl.hpp      |  10 +-
 src/Time/StepChoosers/ErrorControl.hpp        |  17 +--
 src/Time/StepChoosers/Increase.hpp            |   8 +-
 .../StepChoosers/PreventRapidIncrease.hpp     |  18 ++-
 src/Time/StepChoosers/Random.cpp              |  12 +-
 src/Time/StepChoosers/Random.hpp              |   8 +-
 src/Time/StepChoosers/StepChooser.hpp         |  52 +++++---
 src/Time/StepChoosers/StepToTimes.cpp         |   1 +
 src/Time/StepChoosers/StepToTimes.hpp         |  24 ++--
 .../Unit/Time/Actions/Test_ChangeStepSize.cpp |   6 +-
 .../Unit/Time/ChangeSlabSize/Test_Action.cpp  | 111 +++++++++++-----
 tests/Unit/Time/StepChoosers/Test_ByBlock.cpp |   4 +-
 tests/Unit/Time/StepChoosers/Test_Cfl.cpp     |   7 +-
 .../Unit/Time/StepChoosers/Test_Constant.cpp  |  12 +-
 .../Time/StepChoosers/Test_ElementSizeCfl.cpp |  11 +-
 .../Time/StepChoosers/Test_ErrorControl.cpp   |  47 ++++---
 .../Unit/Time/StepChoosers/Test_Increase.cpp  |  15 ++-
 .../Test_PreventRapidIncrease.cpp             |  35 ++---
 tests/Unit/Time/StepChoosers/Test_Random.cpp  |   9 +-
 .../Time/StepChoosers/Test_StepToTimes.cpp    |  41 +++---
 27 files changed, 438 insertions(+), 273 deletions(-)

diff --git a/src/Time/Actions/ChangeStepSize.hpp b/src/Time/Actions/ChangeStepSize.hpp
index ff8982ace95c..123a30b0567b 100644
--- a/src/Time/Actions/ChangeStepSize.hpp
+++ b/src/Time/Actions/ChangeStepSize.hpp
@@ -15,6 +15,7 @@
 #include "Time/ChooseLtsStepSize.hpp"
 #include "Time/Tags/AdaptiveSteppingDiagnostics.hpp"
 #include "Time/Tags/HistoryEvolvedVariables.hpp"
+#include "Time/TimeStepRequestProcessor.hpp"
 #include "Time/TimeSteppers/LtsTimeStepper.hpp"
 #include "Utilities/ErrorHandling/Assert.hpp"
 #include "Utilities/Gsl.hpp"
@@ -61,6 +62,20 @@ bool change_step_size(const gsl::not_null<db::DataBox<DbTags>*> box) {
 
   const auto& time_step_id = db::get<Tags::TimeStepId>(*box);
   ASSERT(time_step_id.substep() == 0, "Can't change step size on a substep.");
+
+  const auto& current_step = db::get<Tags::TimeStep>(*box);
+  const double last_step_size = current_step.value();
+
+  TimeStepRequestProcessor step_requests(time_step_id.time_runs_forward());
+  bool step_accepted = true;
+  for (const auto& step_chooser : step_choosers) {
+    const auto [step_request, step_choice_accepted] =
+        step_chooser->template desired_step<StepChoosersToUse>(last_step_size,
+                                                               *box);
+    step_requests.process(step_request);
+    step_accepted = step_accepted and step_choice_accepted;
+  }
+
   using history_tags = ::Tags::get_all_history_tags<DbTags>;
   bool can_change_step_size = true;
   tmpl::for_each<history_tags>([&box, &can_change_step_size, &time_stepper,
@@ -74,28 +89,14 @@ bool change_step_size(const gsl::not_null<db::DataBox<DbTags>*> box) {
         time_stepper.can_change_step_size(time_step_id, history);
   });
   if (not can_change_step_size) {
+    step_requests.error_on_hard_limit(
+        current_step.value(),
+        (time_step_id.step_time() + current_step).value());
     return true;
   }
 
-  const auto& current_step = db::get<Tags::TimeStep>(*box);
-
-  const double last_step_size = std::abs(db::get<Tags::TimeStep>(*box).value());
-
-  // The step choosers return the magnitude of the desired step, so
-  // we always want the minimum requirement, but we have to negate
-  // the final answer if time is running backwards.
-  double desired_step = std::numeric_limits<double>::infinity();
-  bool step_accepted = true;
-  for (const auto& step_chooser : step_choosers) {
-    const auto [step_choice, step_choice_accepted] =
-        step_chooser->template desired_step<StepChoosersToUse>(
-            last_step_size, *box);
-    desired_step = std::min(desired_step, step_choice);
-    step_accepted = step_accepted and step_choice_accepted;
-  }
-  if (not current_step.is_positive()) {
-    desired_step = -desired_step;
-  }
+  const double desired_step = step_requests.step_size(
+      time_step_id.step_time().value(), current_step.value());
 
   constexpr double smallest_relative_step_size = 1.0e-9;
   if (abs(desired_step / current_step.slab().duration().value()) <
@@ -124,6 +125,9 @@ bool change_step_size(const gsl::not_null<db::DataBox<DbTags>*> box) {
   // if step accepted, just proceed. Otherwise, change Time::Next and jump
   // back to the first instance of `UpdateU`.
   if (step_accepted) {
+    step_requests.error_on_hard_limit(
+        current_step.value(),
+        (time_step_id.step_time() + current_step).value());
     return true;
   } else {
     db::mutate<Tags::Next<Tags::TimeStepId>, Tags::TimeStep>(
diff --git a/src/Time/ChangeSlabSize/Action.hpp b/src/Time/ChangeSlabSize/Action.hpp
index b7f4a7ce2a11..ff35a2510a10 100644
--- a/src/Time/ChangeSlabSize/Action.hpp
+++ b/src/Time/ChangeSlabSize/Action.hpp
@@ -7,16 +7,18 @@
 #include <cstdint>
 #include <map>
 #include <optional>
-#include <unordered_set>
+#include <vector>
 
 #include "DataStructures/DataBox/DataBox.hpp"
 #include "Parallel/AlgorithmExecution.hpp"
 #include "Time/ChangeSlabSize/ChangeSlabSize.hpp"
 #include "Time/ChangeSlabSize/Tags.hpp"
 #include "Time/Tags/HistoryEvolvedVariables.hpp"
+#include "Time/TimeStepRequestProcessor.hpp"
 #include "Time/TimeSteppers/TimeStepper.hpp"
 #include "Utilities/Algorithm.hpp"
 #include "Utilities/ErrorHandling/Assert.hpp"
+#include "Utilities/Numeric.hpp"
 #include "Utilities/TMPL.hpp"
 
 /// \cond
@@ -25,6 +27,7 @@ template <typename Metavariables>
 class GlobalCache;
 }  // namespace Parallel
 namespace Tags {
+struct TimeStep;
 struct TimeStepId;
 template <typename StepperInterface>
 struct TimeStepper;
@@ -73,78 +76,84 @@ struct ChangeSlabSize {
       return {Parallel::AlgorithmExecution::Continue, std::nullopt};
     }
 
+    TimeStepRequestProcessor step_requests(time_step_id.time_runs_forward());
+
     const auto slab_number = time_step_id.slab_number();
     const auto& expected_messages_map =
         db::get<::Tags::ChangeSlabSize::NumberOfExpectedMessages>(box);
-    if (expected_messages_map.empty() or
-        expected_messages_map.begin()->first != slab_number) {
-      return {Parallel::AlgorithmExecution::Continue, std::nullopt};
-    }
-    const size_t expected_messages = expected_messages_map.begin()->second;
-    ASSERT(expected_messages > 0,
-           "Should only create map entries when sending messages.");
-
-    const auto& slab_size_messages =
-        db::get<::Tags::ChangeSlabSize::NewSlabSize>(box);
-    if (slab_size_messages.empty()) {
-      return {Parallel::AlgorithmExecution::Retry, std::nullopt};
+    if (not expected_messages_map.empty() and
+        expected_messages_map.begin()->first == slab_number) {
+      const size_t expected_messages = expected_messages_map.begin()->second;
+      ASSERT(expected_messages > 0,
+             "Should only create map entries when sending messages.");
+
+      const auto& slab_size_messages =
+          db::get<::Tags::ChangeSlabSize::NewSlabSize>(box);
+      if (slab_size_messages.empty()) {
+        return {Parallel::AlgorithmExecution::Retry, std::nullopt};
+      }
+      const int64_t first_received_change_slab =
+          slab_size_messages.begin()->first;
+
+      ASSERT(first_received_change_slab >= slab_number,
+             "Received data for a change at slab " << first_received_change_slab
+             << " but it is already slab " << slab_number);
+      if (first_received_change_slab != slab_number) {
+        return {Parallel::AlgorithmExecution::Retry, std::nullopt};
+      }
+
+      const auto& received_changes = slab_size_messages.begin()->second;
+      ASSERT(expected_messages >= received_changes.size(),
+             "Received " << received_changes.size()
+                         << " size change messages at slab " << slab_number
+                         << ", but only expected " << expected_messages);
+      if (received_changes.size() != expected_messages) {
+        return {Parallel::AlgorithmExecution::Retry, std::nullopt};
+      }
+
+      // We have all the data we need.
+
+      step_requests =
+          alg::accumulate(slab_size_messages.begin()->second, step_requests);
+
+      db::mutate<::Tags::ChangeSlabSize::NumberOfExpectedMessages,
+                 ::Tags::ChangeSlabSize::NewSlabSize>(
+          [](const gsl::not_null<std::map<int64_t, size_t>*> expected,
+             const gsl::not_null<
+                 std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
+                 sizes) {
+            expected->erase(expected->begin());
+            sizes->erase(sizes->begin());
+          },
+          make_not_null(&box));
     }
-    const int64_t first_received_change_slab =
-        slab_size_messages.begin()->first;
-
-    ASSERT(first_received_change_slab >= slab_number,
-           "Received data for a change at slab " << first_received_change_slab
-           << " but it is already slab " << slab_number);
-    if (first_received_change_slab != slab_number) {
-      return {Parallel::AlgorithmExecution::Retry, std::nullopt};
+    const double new_slab_end = step_requests.step_end(
+        time_step_id.step_time().value(),
+        db::get<::Tags::ChangeSlabSize::SlabSizeGoal>(box));
+
+    if (const auto new_goal = step_requests.new_step_size_goal();
+        new_goal.has_value()) {
+      db::mutate<::Tags::ChangeSlabSize::SlabSizeGoal>(
+          [&](const gsl::not_null<double*> slab_size_goal) {
+            *slab_size_goal = *new_goal;
+          },
+          make_not_null(&box));
     }
 
-    const auto& received_changes = slab_size_messages.begin()->second;
-    ASSERT(expected_messages >= received_changes.size(),
-           "Received " << received_changes.size()
-                       << " size change messages at slab "
-                       << slab_number << ", but only expected "
-                       << expected_messages);
-    if (received_changes.size() != expected_messages) {
-      return {Parallel::AlgorithmExecution::Retry, std::nullopt};
-    }
-
-    // We have all the data we need.
-
-    const double new_slab_size =
-        *alg::min_element(slab_size_messages.begin()->second);
-
-    db::mutate<::Tags::ChangeSlabSize::NumberOfExpectedMessages,
-               ::Tags::ChangeSlabSize::NewSlabSize>(
-        [](const gsl::not_null<std::map<int64_t, size_t>*> expected,
-           const gsl::not_null<
-               std::map<int64_t, std::unordered_multiset<double>>*>
-               sizes) {
-          expected->erase(expected->begin());
-          sizes->erase(sizes->begin());
-        },
-        make_not_null(&box));
-
     const TimeStepper& time_stepper =
         db::get<::Tags::TimeStepper<TimeStepper>>(box);
 
     // Sometimes time steppers need to run with a fixed step size.
     // This is generally at the start of an evolution when the history
     // is in an unusual state.
-    if (not time_stepper.can_change_step_size(
+    if (time_stepper.can_change_step_size(
             time_step_id, db::get<::Tags::HistoryEvolvedVariables<>>(box))) {
-      return {Parallel::AlgorithmExecution::Continue, std::nullopt};
+      change_slab_size(make_not_null(&box), new_slab_end);
     }
 
-    const auto current_slab = time_step_id.step_time().slab();
-
-    const double new_slab_end =
-        time_step_id.time_runs_forward()
-            ? current_slab.start().value() + new_slab_size
-            : current_slab.end().value() - new_slab_size;
-
-    change_slab_size(make_not_null(&box), new_slab_end);
-
+    step_requests.error_on_hard_limit(
+        db::get<::Tags::TimeStep>(box).value(),
+        (time_step_id.step_time() + db::get<::Tags::TimeStep>(box)).value());
     return {Parallel::AlgorithmExecution::Continue, std::nullopt};
   }
 };
diff --git a/src/Time/ChangeSlabSize/Event.hpp b/src/Time/ChangeSlabSize/Event.hpp
index 5fa7658fb489..832fb959757f 100644
--- a/src/Time/ChangeSlabSize/Event.hpp
+++ b/src/Time/ChangeSlabSize/Event.hpp
@@ -7,6 +7,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <limits>
+#include <map>
 #include <memory>
 #include <pup.h>
 #include <pup_stl.h>
@@ -14,6 +15,8 @@
 #include <vector>
 
 #include "DataStructures/DataBox/DataBox.hpp"
+#include "Options/Context.hpp"
+#include "Options/ParseError.hpp"
 #include "Options/String.hpp"
 #include "Parallel/GlobalCache.hpp"
 #include "Parallel/Reduction.hpp"
@@ -21,7 +24,10 @@
 #include "Time/ChangeSlabSize/Tags.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
+#include "Time/TimeStepRequestProcessor.hpp"
 #include "Utilities/Functional.hpp"
+#include "Utilities/PrettyType.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
 
@@ -40,11 +46,12 @@ struct StoreNewSlabSize {
   static void apply(db::DataBox<DbTags>& box,
                     Parallel::GlobalCache<Metavariables>& /*cache*/,
                     const ArrayIndex& /*array_index*/,
-                    const int64_t slab_number, const double slab_size) {
+                    const int64_t slab_number,
+                    const TimeStepRequestProcessor& requests) {
     db::mutate<::Tags::ChangeSlabSize::NewSlabSize>(
         [&](const gsl::not_null<
-            std::map<int64_t, std::unordered_multiset<double>>*>
-                sizes) { (*sizes)[slab_number].insert(slab_size); },
+            std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
+                sizes) { (*sizes)[slab_number].emplace_back(requests); },
         make_not_null(&box));
   }
 };
@@ -67,7 +74,7 @@ struct StoreNewSlabSize {
 class ChangeSlabSize : public Event {
   using ReductionData = Parallel::ReductionData<
       Parallel::ReductionDatum<int64_t, funcl::AssertEqual<>>,
-      Parallel::ReductionDatum<double, funcl::Min<>>>;
+      Parallel::ReductionDatum<TimeStepRequestProcessor, funcl::Plus<>>>;
 
  public:
   /// \cond
@@ -97,8 +104,21 @@ class ChangeSlabSize : public Event {
   ChangeSlabSize() = default;
   ChangeSlabSize(std::vector<std::unique_ptr<StepChooser<StepChooserUse::Slab>>>
                      step_choosers,
-                 const uint64_t delay_change)
-      : step_choosers_(std::move(step_choosers)), delay_change_(delay_change) {}
+                 const uint64_t delay_change, const Options::Context& context)
+      : step_choosers_(std::move(step_choosers)), delay_change_(delay_change) {
+    if (delay_change != 0) {
+      for (const auto& chooser : step_choosers_) {
+        if (not chooser->can_be_delayed()) {
+          // The runtime name might not be exactly the same as the one
+          // used by the factory, but hopefully it's close enough that
+          // the user can figure it out.
+          PARSE_ERROR(context,
+                      "The " << pretty_type::get_runtime_type_name(*chooser)
+                      << " StepChooser cannot be applied with a delay.");
+        }
+      }
+    }
+  }
 
   using compute_tags_for_observation_box = tmpl::list<>;
 
@@ -121,16 +141,15 @@ class ChangeSlabSize : public Event {
                                          : time_step_id.slab_number() + 1;
     const auto slab_to_change =
         next_changable_slab + static_cast<int64_t>(delay_change_);
+    const auto slab_start = time_step_id.step_time();
+    const auto current_slab_size = (time_step_id.time_runs_forward() ? 1 : -1) *
+                                   slab_start.slab().duration();
 
-    double desired_slab_size = std::numeric_limits<double>::infinity();
+    TimeStepRequestProcessor step_requests(time_step_id.time_runs_forward());
     bool synchronization_required = false;
     for (const auto& step_chooser : step_choosers_) {
-      desired_slab_size = std::min(
-          desired_slab_size,
-          step_chooser
-              ->desired_step(time_step_id.step_time().slab().duration().value(),
-                             *box)
-              .first);
+      step_requests.process(
+          step_chooser->desired_step(current_slab_size.value(), *box).first);
       // We must synchronize if any step chooser requires it, not just
       // the limiting one, because choosers requiring synchronization
       // can be limiting on some processors and not others.
@@ -151,15 +170,13 @@ class ChangeSlabSize : public Event {
     if (synchronization_required) {
       Parallel::contribute_to_reduction<
           ChangeSlabSize_detail::StoreNewSlabSize>(
-          ReductionData(slab_to_change, desired_slab_size), self_proxy,
+          ReductionData(slab_to_change, step_requests), self_proxy,
           component_proxy);
     } else {
       db::mutate<::Tags::ChangeSlabSize::NewSlabSize>(
           [&](const gsl::not_null<
-              std::map<int64_t, std::unordered_multiset<double>>*>
-                  sizes) {
-            (*sizes)[slab_to_change].insert(desired_slab_size);
-          },
+              std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
+                  sizes) { (*sizes)[slab_to_change].push_back(step_requests); },
           box);
     }
   }
diff --git a/src/Time/ChangeSlabSize/Tags.hpp b/src/Time/ChangeSlabSize/Tags.hpp
index a0ba6a4f609a..95cd157e543b 100644
--- a/src/Time/ChangeSlabSize/Tags.hpp
+++ b/src/Time/ChangeSlabSize/Tags.hpp
@@ -6,14 +6,15 @@
 #include <cstddef>
 #include <cstdint>
 #include <map>
-#include <unordered_set>
+#include <vector>
 
 #include "DataStructures/DataBox/Tag.hpp"
+#include "Time/TimeStepRequestProcessor.hpp"
 
 namespace Tags::ChangeSlabSize {
 /// Sizes requested for each slab by ChangeSlabSize events.
 struct NewSlabSize : db::SimpleTag {
-  using type = std::map<int64_t, std::unordered_multiset<double>>;
+  using type = std::map<int64_t, std::vector<TimeStepRequestProcessor>>;
 };
 
 /// Number of ChangeSlabSize events changing the size at each slab.
diff --git a/src/Time/StepChoosers/ByBlock.hpp b/src/Time/StepChoosers/ByBlock.hpp
index e539445ee1f1..c6ef236d03a2 100644
--- a/src/Time/StepChoosers/ByBlock.hpp
+++ b/src/Time/StepChoosers/ByBlock.hpp
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <cmath>
 #include <cstddef>
 #include <pup.h>
 #include <pup_stl.h>  // IWYU pragma: keep
@@ -10,7 +11,8 @@
 #include <vector>
 
 #include "Options/String.hpp"
-#include "Time/StepChoosers/StepChooser.hpp"  // IWYU pragma: keep
+#include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/ErrorHandling/Error.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
@@ -52,17 +54,17 @@ class ByBlock : public StepChooser<StepChooserUse> {
 
   using argument_tags = tmpl::list<domain::Tags::Element<Dim>>;
 
-  std::pair<double, bool> operator()(
-      const Element<Dim>& element,
-      const double /*last_step_magnitude*/) const {
+  std::pair<TimeStepRequest, bool> operator()(const Element<Dim>& element,
+                                              const double last_step) const {
     const size_t block = element.id().block_id();
     if (block >= sizes_.size()) {
       ERROR("Step size not specified for block " << block);
     }
-    return std::make_pair(sizes_[block], true);
+    return {{.size_goal = std::copysign(sizes_[block], last_step)}, true};
   }
 
   bool uses_local_data() const override { return true; }
+  bool can_be_delayed() const override { return true; }
 
   // NOLINTNEXTLINE(google-runtime-references)
   void pup(PUP::er& p) override { p | sizes_; }
diff --git a/src/Time/StepChoosers/Cfl.hpp b/src/Time/StepChoosers/Cfl.hpp
index 6c77b1e46114..bc07e8039b3f 100644
--- a/src/Time/StepChoosers/Cfl.hpp
+++ b/src/Time/StepChoosers/Cfl.hpp
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <cmath>
 #include <cstddef>
 #include <limits>
 #include <pup.h>
@@ -11,7 +12,8 @@
 #include "DataStructures/DataBox/DataBox.hpp"
 #include "Domain/MinimumGridSpacing.hpp"
 #include "Options/String.hpp"
-#include "Time/StepChoosers/StepChooser.hpp"  // IWYU pragma: keep
+#include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Time/TimeSteppers/TimeStepper.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
@@ -63,19 +65,21 @@ class Cfl : public StepChooser<StepChooserUse> {
       domain::Tags::MinimumGridSpacingCompute<System::volume_dim, Frame>,
       typename System::compute_largest_characteristic_speed>;
 
-  std::pair<double, bool> operator()(
-      const double minimum_grid_spacing,
-      const TimeStepper& time_stepper,
-      const double speed, const double last_step_magnitude) const {
+  std::pair<TimeStepRequest, bool> operator()(const double minimum_grid_spacing,
+                                              const TimeStepper& time_stepper,
+                                              const double speed,
+                                              const double last_step) const {
     const double time_stepper_stability_factor = time_stepper.stable_step();
     const double step_size = safety_factor_ * time_stepper_stability_factor *
                              minimum_grid_spacing /
                              (speed * System::volume_dim);
     // Reject the step if the CFL condition is violated.
-    return std::make_pair(step_size, last_step_magnitude <= step_size);
+    return {{.size_goal = std::copysign(step_size, last_step)},
+            abs(last_step) <= step_size};
   }
 
   bool uses_local_data() const override { return true; }
+  bool can_be_delayed() const override { return true; }
 
   // NOLINTNEXTLINE(google-runtime-references)
   void pup(PUP::er& p) override { p | safety_factor_; }
diff --git a/src/Time/StepChoosers/Constant.hpp b/src/Time/StepChoosers/Constant.hpp
index fe6b6977b499..cb64d6d5467f 100644
--- a/src/Time/StepChoosers/Constant.hpp
+++ b/src/Time/StepChoosers/Constant.hpp
@@ -3,13 +3,15 @@
 
 #pragma once
 
+#include <cmath>
 #include <limits>
 #include <pup.h>
 #include <utility>
 
 #include "Options/Options.hpp"
 #include "Options/String.hpp"
-#include "Time/StepChoosers/StepChooser.hpp"  // IWYU pragma: keep
+#include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/ErrorHandling/Assert.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
@@ -35,12 +37,12 @@ class Constant : public StepChooser<StepChooserUse> {
 
   using argument_tags = tmpl::list<>;
 
-  std::pair<double, bool> operator()(
-      const double /*last_step_magnitude*/) const {
-    return std::make_pair(value_, true);
+  std::pair<TimeStepRequest, bool> operator()(const double last_step) const {
+    return {{.size_goal = std::copysign(value_, last_step)}, true};
   }
 
   bool uses_local_data() const override { return false; }
+  bool can_be_delayed() const override { return true; }
 
   // NOLINTNEXTLINE(google-runtime-references)
   void pup(PUP::er& p) override { p | value_; }
diff --git a/src/Time/StepChoosers/ElementSizeCfl.hpp b/src/Time/StepChoosers/ElementSizeCfl.hpp
index ef78d3263500..68922b6a1f82 100644
--- a/src/Time/StepChoosers/ElementSizeCfl.hpp
+++ b/src/Time/StepChoosers/ElementSizeCfl.hpp
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <cmath>
 #include <cstddef>
 #include <limits>
 #include <pup.h>
@@ -12,6 +13,7 @@
 #include "Domain/SizeOfElement.hpp"
 #include "Options/String.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Time/TimeSteppers/TimeStepper.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
@@ -70,10 +72,10 @@ class ElementSizeCfl : public StepChooser<StepChooserUse> {
       tmpl::list<domain::Tags::SizeOfElementCompute<Dim>,
                  typename System::compute_largest_characteristic_speed>;
 
-  std::pair<double, bool> operator()(
+  std::pair<TimeStepRequest, bool> operator()(
       const TimeStepper& time_stepper,
       const std::array<double, Dim>& element_size, const double speed,
-      const double last_step_magnitude) const {
+      const double last_step) const {
     double min_size_of_element = std::numeric_limits<double>::infinity();
     for (auto face_to_face_dimension : element_size) {
       if (face_to_face_dimension < min_size_of_element) {
@@ -84,10 +86,12 @@ class ElementSizeCfl : public StepChooser<StepChooserUse> {
     const double step_size = safety_factor_ * time_stepper_stability_factor *
                              min_size_of_element / (speed * Dim);
     // Reject the step if the CFL condition is violated.
-    return std::make_pair(step_size, last_step_magnitude <= step_size);
+    return {{.size_goal = std::copysign(step_size, last_step)},
+            abs(last_step) <= step_size};
   }
 
   bool uses_local_data() const override { return true; }
+  bool can_be_delayed() const override { return true; }
 
   // NOLINTNEXTLINE(google-runtime-references)
   void pup(PUP::er& p) override { p | safety_factor_; }
diff --git a/src/Time/StepChoosers/ErrorControl.hpp b/src/Time/StepChoosers/ErrorControl.hpp
index 3718fef7d61c..781b0e37b55c 100644
--- a/src/Time/StepChoosers/ErrorControl.hpp
+++ b/src/Time/StepChoosers/ErrorControl.hpp
@@ -23,6 +23,7 @@
 #include "Time/Tags/IsUsingTimeSteppingErrorControl.hpp"
 #include "Time/Tags/StepperErrorTolerances.hpp"
 #include "Time/Tags/StepperErrors.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/ErrorHandling/Assert.hpp"
 #include "Utilities/Gsl.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
@@ -199,16 +200,18 @@ class ErrorControl
 
   using argument_tags = tmpl::list<::Tags::StepperErrors<EvolvedVariableTag>>;
 
-  std::pair<double, bool> operator()(
+  std::pair<TimeStepRequest, bool> operator()(
       const typename ::Tags::StepperErrors<EvolvedVariableTag>::type& errors,
       const double previous_step) const {
     // request that the step size not be changed if there isn't a new error
     // estimate
     if (not errors[1].has_value()) {
-      return std::make_pair(std::numeric_limits<double>::infinity(), true);
+      return {{.size_goal = std::copysign(
+                   std::numeric_limits<double>::infinity(), previous_step)},
+              true};
     }
     double new_step;
-    if (not errors[0].has_value()) {
+    if (not errors[0].has_value() or errors[0]->order != errors[1]->order) {
       new_step = errors[1]->step_size.value() *
                  std::clamp(safety_factor_ *
                                 pow(1.0 / std::max(errors[1]->error, 1e-14),
@@ -217,9 +220,6 @@ class ErrorControl
     } else {
       // From simple advice from Numerical Recipes 17.2.1 regarding a heuristic
       // for PI step control.
-      ASSERT(errors[0]->order == errors[1]->order,
-             "Error estimates are different orders.  Need to figure our what "
-             "to do in this case.");
       const double alpha_factor = 0.7 / (errors[1]->order + 1);
       const double beta_factor = 0.4 / (errors[0]->order + 1);
       new_step =
@@ -233,11 +233,12 @@ class ErrorControl
     // If the error is out-of-date we can still reject a step, but it
     // won't improve the reported error, so make sure to only do it
     // if we actually request a smaller step.
-    return {abs(new_step),
-            abs(new_step) >= previous_step or errors[1]->error <= 1.0};
+    return {{.size_goal = new_step},
+            abs(new_step) >= abs(previous_step) or errors[1]->error <= 1.0};
   }
 
   bool uses_local_data() const override { return true; }
+  bool can_be_delayed() const override { return true; }
 
   StepperErrorTolerances tolerances() const override {
     return {.absolute = absolute_tolerance_, .relative = relative_tolerance_};
diff --git a/src/Time/StepChoosers/Increase.hpp b/src/Time/StepChoosers/Increase.hpp
index 3ec1b4e8e6d5..e3af7cb95d17 100644
--- a/src/Time/StepChoosers/Increase.hpp
+++ b/src/Time/StepChoosers/Increase.hpp
@@ -9,7 +9,8 @@
 #include <utility>
 
 #include "Options/String.hpp"
-#include "Time/StepChoosers/StepChooser.hpp"  // IWYU pragma: keep
+#include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
 
@@ -38,11 +39,12 @@ class Increase : public StepChooser<StepChooserUse> {
 
   using argument_tags = tmpl::list<>;
 
-  std::pair<double, bool> operator()(const double last_step_magnitude) const {
-    return std::make_pair(last_step_magnitude * factor_, true);
+  std::pair<TimeStepRequest, bool> operator()(const double last_step) const {
+    return {{.size_goal = last_step * factor_}, true};
   }
 
   bool uses_local_data() const override { return false; }
+  bool can_be_delayed() const override { return true; }
 
   // NOLINTNEXTLINE(google-runtime-references)
   void pup(PUP::er& p) override { p | factor_; }
diff --git a/src/Time/StepChoosers/PreventRapidIncrease.hpp b/src/Time/StepChoosers/PreventRapidIncrease.hpp
index c3e658706df8..02e00a461920 100644
--- a/src/Time/StepChoosers/PreventRapidIncrease.hpp
+++ b/src/Time/StepChoosers/PreventRapidIncrease.hpp
@@ -11,6 +11,7 @@
 #include "Options/String.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"  // IWYU pragma: keep
 #include "Time/Tags/HistoryEvolvedVariables.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Time/Utilities.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
@@ -39,16 +40,18 @@ class PreventRapidIncrease : public StepChooser<StepChooserUse> {
   using argument_tags = tmpl::list<::Tags::HistoryEvolvedVariables<>>;
 
   template <typename History>
-  std::pair<double, bool> operator()(const History& history,
-                                     const double last_step_magnitude) const {
+  std::pair<TimeStepRequest, bool> operator()(const History& history,
+                                              const double last_step) const {
     if (history.size() < 2) {
-      return std::make_pair(std::numeric_limits<double>::infinity(), true);
+      return {{.size_goal = std::copysign(
+                   std::numeric_limits<double>::infinity(), last_step)},
+              true};
     }
 
     const double sloppiness =
         slab_rounding_error(history.front().time_step_id.step_time());
     std::optional<Time> previous_time{};
-    double newer_step = last_step_magnitude;
+    double newer_step = abs(last_step);
     for (auto record = history.rbegin(); record != history.rend(); ++record) {
       const Time time = record->time_step_id.step_time();
       if (previous_time.has_value()) {
@@ -56,7 +59,7 @@ class PreventRapidIncrease : public StepChooser<StepChooserUse> {
         // Potential roundoff error comes from the inability to make
         // slabs exactly the same length.
         if (this_step < newer_step - sloppiness) {
-          return std::make_pair(last_step_magnitude, true);
+          return {{.size_goal = last_step}, true};
         }
         newer_step = this_step;
       }
@@ -64,10 +67,13 @@ class PreventRapidIncrease : public StepChooser<StepChooserUse> {
     }
     // Request that the step size be at most infinity.  This imposes
     // no restriction on the chosen step.
-    return std::make_pair(std::numeric_limits<double>::infinity(), true);
+    return {{.size_goal = std::copysign(std::numeric_limits<double>::infinity(),
+                                        last_step)},
+            true};
   }
 
   bool uses_local_data() const override { return false; }
+  bool can_be_delayed() const override { return true; }
 };
 
 /// \cond
diff --git a/src/Time/StepChoosers/Random.cpp b/src/Time/StepChoosers/Random.cpp
index bf168d305a5d..b3d17b716c08 100644
--- a/src/Time/StepChoosers/Random.cpp
+++ b/src/Time/StepChoosers/Random.cpp
@@ -15,6 +15,7 @@
 #include "Options/ParseError.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/GenerateInstantiations.hpp"
 
 namespace StepChoosers {
@@ -37,9 +38,9 @@ Random<StepChooserUse, VolumeDim>::Random(const double minimum,
 }
 
 template <typename StepChooserUse, size_t VolumeDim>
-std::pair<double, bool> Random<StepChooserUse, VolumeDim>::operator()(
+std::pair<TimeStepRequest, bool> Random<StepChooserUse, VolumeDim>::operator()(
     const Element<VolumeDim>& element, const TimeStepId& time_step_id,
-    const double /*last_step_magnitude*/) const {
+    const double last_step) const {
   size_t local_seed = seed_;
   boost::hash_combine(local_seed, element.id());
   boost::hash_combine(local_seed, time_step_id);
@@ -49,7 +50,7 @@ std::pair<double, bool> Random<StepChooserUse, VolumeDim>::operator()(
     const double step = exp(dist(rng));
     // Don't produce out-of-range values because of roundoff.
     if (step >= minimum_ and step <= maximum_) {
-      return {step, true};
+      return {{.size_goal = std::copysign(step, last_step)}, true};
     }
   }
 }
@@ -59,6 +60,11 @@ bool Random<StepChooserUse, VolumeDim>::uses_local_data() const {
   return true;
 }
 
+template <typename StepChooserUse, size_t VolumeDim>
+bool Random<StepChooserUse, VolumeDim>::can_be_delayed() const {
+  return true;
+}
+
 template <typename StepChooserUse, size_t VolumeDim>
 void Random<StepChooserUse, VolumeDim>::pup(PUP::er& p) {
   p | minimum_;
diff --git a/src/Time/StepChoosers/Random.hpp b/src/Time/StepChoosers/Random.hpp
index 99b1ccbde5bb..87f86c0ee587 100644
--- a/src/Time/StepChoosers/Random.hpp
+++ b/src/Time/StepChoosers/Random.hpp
@@ -11,6 +11,7 @@
 #include "Options/Context.hpp"
 #include "Options/String.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
 
@@ -67,11 +68,12 @@ class Random : public StepChooser<StepChooserUse> {
   using argument_tags =
       tmpl::list<domain::Tags::Element<VolumeDim>, Tags::TimeStepId>;
 
-  std::pair<double, bool> operator()(const Element<VolumeDim>& element,
-                                     const TimeStepId& time_step_id,
-                                     double last_step_magnitude) const;
+  std::pair<TimeStepRequest, bool> operator()(const Element<VolumeDim>& element,
+                                              const TimeStepId& time_step_id,
+                                              double last_step) const;
 
   bool uses_local_data() const override;
+  bool can_be_delayed() const override;
 
   // NOLINTNEXTLINE(google-runtime-references)
   void pup(PUP::er& p) override;
diff --git a/src/Time/StepChoosers/StepChooser.hpp b/src/Time/StepChoosers/StepChooser.hpp
index c1058599ada6..e110465ff194 100644
--- a/src/Time/StepChoosers/StepChooser.hpp
+++ b/src/Time/StepChoosers/StepChooser.hpp
@@ -7,6 +7,7 @@
 
 #include "DataStructures/DataBox/DataBox.hpp"
 #include "Parallel/Tags/Metavariables.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/CallWithDynamicType.hpp"
 #include "Utilities/ErrorHandling/Assert.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
@@ -67,12 +68,13 @@ struct AllStepChoosers {};
 
 /// \ingroup TimeGroup
 ///
-/// \brief StepChoosers suggest upper bounds on step sizes.
+/// \brief StepChoosers suggest upper bounds on step sizes.  See
+/// `TimeStepRequest` for details on how the results are used.
 ///
 /// Concrete StepChoosers should define `operator()` returning the
 /// information described as the return type of `desired_step` and
-/// taking the `last_step_magnitude` and arguments specified by the
-/// class's `argument_tags` type alias.
+/// taking the `last_step` and arguments specified by the class's
+/// `argument_tags` type alias.
 ///
 /// Derived classes must indicate whether the chooser is usable as a
 /// step chooser, slab chooser, or both by inheriting from StepChooser
@@ -100,11 +102,17 @@ class StepChooser : public PUP::able {
   /// domain.  This is ignored for LTS step changing.
   ///
   /// \note As this is only used for slab-size changing, the
-  /// `last_step_magnitude` passed to the call operator is *not*
-  /// considered local data.
+  /// `last_step` passed to the call operator is *not* considered
+  /// local data.
   virtual bool uses_local_data() const = 0;
 
-  /// The `last_step_magnitude` parameter describes the step size to be
+  /// Whether the result can be applied with a delay.
+  ///
+  /// StepChoosers setting the `.end` or `.end_hard_limit` fields of
+  /// `TimeStepRequest` must return false here.
+  virtual bool can_be_delayed() const = 0;
+
+  /// The `last_step` parameter describes the step size to be
   /// adjusted.  It may be the step size or the slab size, or may be
   /// infinite if the appropriate size cannot be determined.
   ///
@@ -118,8 +126,8 @@ class StepChooser : public PUP::able {
   ///
   /// The implementations of the call operator in derived classes
   /// should always return a strictly smaller step than the
-  /// `last_step_magnitude` when they return `false` for the second
-  /// member of the pair (indicating step rejection).
+  /// `last_step` when they return `false` for the second member of
+  /// the pair (indicating step rejection).
   ///
   /// The optional template parameter `StepChoosersToUse` may be used to
   /// indicate a subset of the constructable step choosers to use for the
@@ -128,10 +136,8 @@ class StepChooser : public PUP::able {
   /// option is used when multiple components need to invoke `ChangeStepSize`
   /// with step choosers that may not be compatible with all components.
   template <typename StepChoosersToUse = AllStepChoosers, typename DbTags>
-  std::pair<double, bool> desired_step(const double last_step_magnitude,
-                                       const db::DataBox<DbTags>& box) const {
-    ASSERT(last_step_magnitude > 0.,
-           "Passed non-positive step magnitude: " << last_step_magnitude);
+  std::pair<TimeStepRequest, bool> desired_step(
+      const double last_step, const db::DataBox<DbTags>& box) const {
     using factory_classes =
         typename std::decay_t<decltype(db::get<Parallel::Tags::Metavariables>(
             box))>::factory_creation::factory_classes;
@@ -140,13 +146,23 @@ class StepChooser : public PUP::able {
                             tmpl::at<factory_classes, StepChooser>,
                             StepChoosersToUse>;
     const auto result =
-        call_with_dynamic_type<std::pair<double, bool>, step_choosers>(
-            this, [&last_step_magnitude, &box](const auto* const chooser) {
-              return db::apply(*chooser, box, last_step_magnitude);
+        call_with_dynamic_type<std::pair<TimeStepRequest, bool>, step_choosers>(
+            this, [&last_step, &box](const auto* const chooser) {
+              return db::apply(*chooser, box, last_step);
             });
-    ASSERT(
-        result.first > 0.,
-        "StepChoosers should always return positive values.  Got " << result);
+    ASSERT(not result.first.size_goal.has_value() or
+               (*result.first.size_goal > 0.) == (last_step > 0.),
+           "Step size changed sign: " << *result.first.size_goal);
+    ASSERT(not result.first.size.has_value() or
+               (*result.first.size > 0.) == (last_step > 0.),
+           "Step size changed sign: " << *result.first.size);
+    ASSERT(not result.first.size_hard_limit.has_value() or
+               (*result.first.size_hard_limit > 0.) == (last_step > 0.),
+           "Step size changed sign: " << *result.first.size_hard_limit);
+    ASSERT(not(result.first.end.has_value() and can_be_delayed()),
+           "Delayable end limits are not allowed.");
+    ASSERT(not(result.first.end_hard_limit.has_value() and can_be_delayed()),
+           "Delayable end limits are not allowed.");
     return result;
   }
 };
diff --git a/src/Time/StepChoosers/StepToTimes.cpp b/src/Time/StepChoosers/StepToTimes.cpp
index 33b6142a5dee..c40149e7eaef 100644
--- a/src/Time/StepChoosers/StepToTimes.cpp
+++ b/src/Time/StepChoosers/StepToTimes.cpp
@@ -5,6 +5,7 @@
 
 namespace StepChoosers {
 bool StepToTimes::uses_local_data() const { return false; }
+bool StepToTimes::can_be_delayed() const { return false; }
 
 PUP::able::PUP_ID StepToTimes::my_PUP_ID = 0;  // NOLINT
 }  // namespace StepChoosers
diff --git a/src/Time/StepChoosers/StepToTimes.hpp b/src/Time/StepChoosers/StepToTimes.hpp
index 058151d779fb..329f63dbc880 100644
--- a/src/Time/StepChoosers/StepToTimes.hpp
+++ b/src/Time/StepChoosers/StepToTimes.hpp
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <cmath>
 #include <limits>
 #include <memory>
 #include <pup.h>
@@ -13,6 +14,7 @@
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/TimeSequence.hpp"
 #include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Time/Utilities.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
@@ -54,8 +56,8 @@ class StepToTimes : public StepChooser<StepChooserUse::Slab> {
 
   using argument_tags = tmpl::list<::Tags::TimeStepId>;
 
-  std::pair<double, bool> operator()(const TimeStepId& time_step_id,
-                                     const double last_step_magnitude) const {
+  std::pair<TimeStepRequest, bool> operator()(const TimeStepId& time_step_id,
+                                              const double last_step) const {
     const double now = time_step_id.substep_time();
     // Trying to step to a given time might not get us exactly there
     // because of rounding errors.  Avoid taking an extra tiny step if
@@ -65,7 +67,9 @@ class StepToTimes : public StepChooser<StepChooserUse::Slab> {
     const auto goal_times = times_->times_near(now);
     if (not goal_times[1]) {
       // No times requested.
-      return std::make_pair(std::numeric_limits<double>::infinity(), true);
+      return {{.size_goal = std::copysign(
+                   std::numeric_limits<double>::infinity(), last_step)},
+              true};
     }
 
     double distance_to_next_goal = std::numeric_limits<double>::signaling_NaN();
@@ -74,7 +78,7 @@ class StepToTimes : public StepChooser<StepChooserUse::Slab> {
           *goal_times[1] > now + sloppiness ? goal_times[1] : goal_times[2];
       if (not next_time) {
         // We've passed all the times.  No restriction.
-        return std::make_pair(std::numeric_limits<double>::infinity(), true);
+        return {{.size_goal = std::numeric_limits<double>::infinity()}, true};
       }
       distance_to_next_goal = *next_time - now;
     } else {
@@ -82,26 +86,30 @@ class StepToTimes : public StepChooser<StepChooserUse::Slab> {
           *goal_times[1] < now - sloppiness ? goal_times[1] : goal_times[0];
       if (not next_time) {
         // We've passed all the times.  No restriction.
-        return std::make_pair(std::numeric_limits<double>::infinity(), true);
+        return {{.size_goal = -std::numeric_limits<double>::infinity()}, true};
       }
       distance_to_next_goal = now - *next_time;
     }
 
-    if (distance_to_next_goal < 2.0 / 3.0 * last_step_magnitude) {
+    if (distance_to_next_goal < 2.0 / 3.0 * abs(last_step)) {
       // Our goal is well within range of the expected allowed step
       // size.
-      return std::make_pair(distance_to_next_goal, true);
+      return {{.size_goal = std::copysign(distance_to_next_goal, last_step)},
+              true};
     } else {
       // We can't reach our goal in one step, or at least might not be
       // able to if the step adjusts a relatively small amount for
       // other reasons.  Prevent the step from bringing us too close
       // to the goal so that the step following this one will not be
       // too small.
-      return std::make_pair(2.0 / 3.0 * distance_to_next_goal, true);
+      return {{.size_goal =
+                   std::copysign(2.0 / 3.0 * distance_to_next_goal, last_step)},
+              true};
     }
   }
 
   bool uses_local_data() const override;
+  bool can_be_delayed() const override;
 
   // NOLINTNEXTLINE(google-runtime-references)
   void pup(PUP::er& p) override { p | times_; }
diff --git a/tests/Unit/Time/Actions/Test_ChangeStepSize.cpp b/tests/Unit/Time/Actions/Test_ChangeStepSize.cpp
index ddf4273a42ec..00f00dc19f83 100644
--- a/tests/Unit/Time/Actions/Test_ChangeStepSize.cpp
+++ b/tests/Unit/Time/Actions/Test_ChangeStepSize.cpp
@@ -30,6 +30,7 @@
 #include "Time/Tags/TimeStepper.hpp"
 #include "Time/Time.hpp"
 #include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Time/TimeSteppers/AdamsBashforth.hpp"
 #include "Time/TimeSteppers/LtsTimeStepper.hpp"
 #include "Utilities/Gsl.hpp"
@@ -57,11 +58,12 @@ struct StepRejector : public StepChooser<StepChooserUse::LtsStep> {
   explicit StepRejector(CkMigrateMessage* /*unused*/) {}
   StepRejector() = default;
 
-  std::pair<double, bool> operator()(const double last_step_magnitude) const {
-    return {last_step_magnitude, false};
+  std::pair<TimeStepRequest, bool> operator()(const double last_step) const {
+    return {{.size_goal = last_step}, false};
   }
 
   bool uses_local_data() const override { return false; }
+  bool can_be_delayed() const override { return true; }
 
   void pup(PUP::er& /*p*/) override {}
 };
diff --git a/tests/Unit/Time/ChangeSlabSize/Test_Action.cpp b/tests/Unit/Time/ChangeSlabSize/Test_Action.cpp
index f262f67ec50a..0fa00fd3a6b3 100644
--- a/tests/Unit/Time/ChangeSlabSize/Test_Action.cpp
+++ b/tests/Unit/Time/ChangeSlabSize/Test_Action.cpp
@@ -5,10 +5,10 @@
 
 #include <cstdint>
 #include <initializer_list>
+#include <map>
 #include <memory>
 #include <string>
-#include <unordered_map>
-#include <unordered_set>
+#include <vector>
 
 #include "DataStructures/DataBox/DataBox.hpp"
 #include "DataStructures/DataBox/Tag.hpp"
@@ -26,6 +26,8 @@
 #include "Time/Tags/TimeStepper.hpp"
 #include "Time/Time.hpp"
 #include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
+#include "Time/TimeStepRequestProcessor.hpp"
 #include "Time/TimeSteppers/Rk3HesthavenSsp.hpp"
 #include "Time/TimeSteppers/TimeStepper.hpp"
 #include "Utilities/Gsl.hpp"
@@ -63,7 +65,8 @@ struct Component {
   using simple_tags =
       tmpl::list<Tags::TimeStepId, Tags::Next<Tags::TimeStepId>, Tags::TimeStep,
                  Tags::Next<Tags::TimeStep>, Tags::HistoryEvolvedVariables<Var>,
-                 Tags::AdaptiveSteppingDiagnostics>;
+                 Tags::AdaptiveSteppingDiagnostics,
+                 ::Tags::ChangeSlabSize::SlabSizeGoal>;
   using compute_tags = time_stepper_ref_tags<TimeStepper>;
   using phase_dependent_action_list = tmpl::list<
       Parallel::PhaseActions<Parallel::Phase::Initialization,
@@ -86,6 +89,7 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
   auto& box = ActionTesting::get_databox<Component>(make_not_null(&runner), 0);
 
   for (const bool time_runs_forward : {true, false}) {
+    const double unit_step = time_runs_forward ? 1.0 : -1.0;
     Slab slab(1.5, 2.0);
     Time start_time;
 
@@ -108,19 +112,23 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
     };
 
     db::mutate<Tags::TimeStepId, Tags::Next<Tags::TimeStepId>, Tags::TimeStep,
-               Tags::Next<Tags::TimeStep>, Tags::AdaptiveSteppingDiagnostics>(
+               Tags::Next<Tags::TimeStep>, Tags::AdaptiveSteppingDiagnostics,
+               ::Tags::ChangeSlabSize::SlabSizeGoal>(
         [&get_step, &start_time, &time_runs_forward](
             const gsl::not_null<TimeStepId*> id,
             const gsl::not_null<TimeStepId*> next_id,
             const gsl::not_null<TimeDelta*> step,
             const gsl::not_null<TimeDelta*> next_step,
             const gsl::not_null<AdaptiveSteppingDiagnostics*> diags,
+            const gsl::not_null<double*> slab_size_goal,
             const TimeStepper& stepper) {
           *id = TimeStepId(time_runs_forward, 3, start_time);
           *step = get_step(*id);
           *next_step = get_step(*id);
           *next_id = stepper.next_time_id(*id, *step);
           *diags = AdaptiveSteppingDiagnostics{1, 2, 3, 4, 5};
+          // Step is slab/2 for test
+          *slab_size_goal = (2 * *step).value();
         },
         make_not_null(&box), db::get<Tags::TimeStepper<TimeStepper>>(box));
 
@@ -128,7 +136,8 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
     using NewSize = ::Tags::ChangeSlabSize::NewSlabSize;
 
     const auto check_box = [&box, &get_step](const TimeStepId& id,
-                                             const uint64_t changes) {
+                                             const uint64_t changes,
+                                             const double expected_goal) {
       CHECK(db::get<Tags::TimeStepId>(box) == id);
       CHECK(db::get<Tags::TimeStep>(box) == get_step(id));
       CHECK(db::get<Tags::Next<Tags::TimeStepId>>(box) ==
@@ -136,12 +145,28 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
                 db::get<Tags::TimeStepId>(box), db::get<Tags::TimeStep>(box)));
       CHECK(db::get<Tags::AdaptiveSteppingDiagnostics>(box) ==
             AdaptiveSteppingDiagnostics{1, 2 + changes, 3, 4, 5});
+      CHECK(db::get<::Tags::ChangeSlabSize::SlabSizeGoal>(box) ==
+            expected_goal);
     };
 
     // Nothing to do
     {
       runner.next_action<Component>(0);
-      check_box(TimeStepId(time_runs_forward, 3, start_time), 0);
+      check_box(TimeStepId(time_runs_forward, 3, start_time), 0,
+                ((time_runs_forward ? 1 : -1) * slab.duration()).value());
+    }
+
+    // Nothing to do, but not at the goal.
+    {
+      db::mutate<::Tags::ChangeSlabSize::SlabSizeGoal>(
+          [&unit_step](const gsl::not_null<double*> slab_size_goal) {
+            *slab_size_goal = 2.0 * unit_step;
+          },
+          make_not_null(&box));
+      runner.next_action<Component>(0);
+      resize_slab(2.0);
+      check_box(TimeStepId(time_runs_forward, 3, start_time), 1,
+                2.0 * unit_step);
     }
 
     // Simple case
@@ -155,19 +180,24 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
           make_not_null(&runner), 0));
       db::mutate<NewSize>(
           [&](const gsl::not_null<
-              std::map<int64_t, std::unordered_multiset<double>>*>
-                  sizes) { (*sizes)[3].insert(1.0); },
+              std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
+                  sizes) {
+            (*sizes)[3]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size = unit_step});
+          },
           make_not_null(&box));
 
       runner.next_action<Component>(0);
       resize_slab(1.0);
-      check_box(TimeStepId(time_runs_forward, 3, start_time), 1);
+      check_box(TimeStepId(time_runs_forward, 3, start_time), 2,
+                2.0 * unit_step);
       CHECK(db::get<ExpectedMessages>(box).empty());
       CHECK(db::get<NewSize>(box).empty());
       db::mutate<ExpectedMessages, NewSize>(
           [&](const gsl::not_null<std::map<int64_t, size_t>*> expected,
               const gsl::not_null<
-                  std::map<int64_t, std::unordered_multiset<double>>*>
+                  std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
                   sizes) {
             expected->clear();
             sizes->clear();
@@ -187,15 +217,23 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
           make_not_null(&runner), 0));
       db::mutate<NewSize>(
           [&](const gsl::not_null<
-              std::map<int64_t, std::unordered_multiset<double>>*>
-                  sizes) { (*sizes)[3].insert(2.0); },
+              std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
+                  sizes) {
+            (*sizes)[3]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size_goal = 2.0 * unit_step});
+          },
           make_not_null(&box));
       REQUIRE_FALSE(ActionTesting::next_action_if_ready<Component>(
           make_not_null(&runner), 0));
       db::mutate<NewSize>(
           [&](const gsl::not_null<
-              std::map<int64_t, std::unordered_multiset<double>>*>
-                  sizes) { (*sizes)[4].insert(0.5); },
+              std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
+                  sizes) {
+            (*sizes)[4]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size_goal = 0.5 * unit_step});
+          },
           make_not_null(&box));
       REQUIRE_FALSE(ActionTesting::next_action_if_ready<Component>(
           make_not_null(&runner), 0));
@@ -206,12 +244,17 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
           make_not_null(&box));
       db::mutate<NewSize>(
           [&](const gsl::not_null<
-              std::map<int64_t, std::unordered_multiset<double>>*>
-                  sizes) { (*sizes)[3].insert(3.0); },
+              std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
+                  sizes) {
+            (*sizes)[3]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size_goal = 3.0 * unit_step});
+          },
           make_not_null(&box));
       runner.next_action<Component>(0);
       resize_slab(2.0);
-      check_box(TimeStepId(time_runs_forward, 3, start_time), 2);
+      check_box(TimeStepId(time_runs_forward, 3, start_time), 3,
+                2.0 * unit_step);
       CHECK(db::get<ExpectedMessages>(box).size() == 1);
       CHECK(db::get<ExpectedMessages>(box).count(4) == 1);
       CHECK(db::get<NewSize>(box).size() == 1);
@@ -219,7 +262,7 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
       db::mutate<ExpectedMessages, NewSize>(
           [&](const gsl::not_null<std::map<int64_t, size_t>*> expected,
               const gsl::not_null<
-                  std::map<int64_t, std::unordered_multiset<double>>*>
+                  std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
                   sizes) {
             expected->clear();
             sizes->clear();
@@ -247,25 +290,29 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
           },
           make_not_null(&box));
       runner.next_action<Component>(0);
-      check_box(initial_id, 2);
+      check_box(initial_id, 3, 2.0 * unit_step);
       CHECK(db::get<ExpectedMessages>(box).size() == 2);
       CHECK(db::get<ExpectedMessages>(box).count(3) == 1);
       CHECK(db::get<ExpectedMessages>(box).count(4) == 1);
       CHECK(db::get<NewSize>(box).empty());
       db::mutate<NewSize>(
           [&](const gsl::not_null<
-              std::map<int64_t, std::unordered_multiset<double>>*>
+              std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
                   sizes) {
-            (*sizes)[3].insert(0.1);
-            (*sizes)[4].insert(0.1);
+            (*sizes)[3]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size_goal = 0.1 * unit_step});
+            (*sizes)[4]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size_goal = 0.1 * unit_step});
           },
           make_not_null(&box));
       runner.next_action<Component>(0);
-      check_box(initial_id, 2);
+      check_box(initial_id, 3, 2.0 * unit_step);
       db::mutate<ExpectedMessages, NewSize>(
           [&](const gsl::not_null<std::map<int64_t, size_t>*> expected,
               const gsl::not_null<
-                  std::map<int64_t, std::unordered_multiset<double>>*>
+                  std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
                   sizes) {
             expected->clear();
             sizes->clear();
@@ -297,25 +344,29 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
           },
           make_not_null(&box));
       runner.next_action<Component>(0);
-      check_box(initial_id, 2);
+      check_box(initial_id, 3, 2.0 * unit_step);
       CHECK(db::get<ExpectedMessages>(box).size() == 2);
       CHECK(db::get<ExpectedMessages>(box).count(3) == 1);
       CHECK(db::get<ExpectedMessages>(box).count(4) == 1);
       CHECK(db::get<NewSize>(box).empty());
       db::mutate<NewSize>(
           [&](const gsl::not_null<
-              std::map<int64_t, std::unordered_multiset<double>>*>
+              std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
                   sizes) {
-            (*sizes)[3].insert(0.1);
-            (*sizes)[4].insert(0.1);
+            (*sizes)[3]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size_goal = 0.1 * unit_step});
+            (*sizes)[4]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size_goal = 0.1 * unit_step});
           },
           make_not_null(&box));
       runner.next_action<Component>(0);
-      check_box(initial_id, 2);
+      check_box(initial_id, 3, 2.0 * unit_step);
       db::mutate<ExpectedMessages, NewSize>(
           [&](const gsl::not_null<std::map<int64_t, size_t>*> expected,
               const gsl::not_null<
-                  std::map<int64_t, std::unordered_multiset<double>>*>
+                  std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
                   sizes) {
             expected->clear();
             sizes->clear();
diff --git a/tests/Unit/Time/StepChoosers/Test_ByBlock.cpp b/tests/Unit/Time/StepChoosers/Test_ByBlock.cpp
index 23af0e5fcf36..9e8fcdea6089 100644
--- a/tests/Unit/Time/StepChoosers/Test_ByBlock.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_ByBlock.cpp
@@ -18,6 +18,7 @@
 #include "Parallel/Tags/Metavariables.hpp"
 #include "Time/StepChoosers/ByBlock.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
 #include "Utilities/TMPL.hpp"
@@ -56,7 +57,8 @@ void test_by_block() {
         db::AddSimpleTags<Parallel::Tags::MetavariablesImpl<Metavariables>,
                           domain::Tags::Element<volume_dim>>>(Metavariables{},
                                                               element);
-    const double expected = 0.5 * static_cast<double>(block + 5);
+    const TimeStepRequest expected{.size_goal =
+                                       0.5 * static_cast<double>(block + 5)};
 
     CHECK(by_block(element, current_step) == std::make_pair(expected, true));
     CHECK(serialize_and_deserialize(by_block)(element, current_step) ==
diff --git a/tests/Unit/Time/StepChoosers/Test_Cfl.cpp b/tests/Unit/Time/StepChoosers/Test_Cfl.cpp
index 47b0bee7eb4e..082d1dc8770d 100644
--- a/tests/Unit/Time/StepChoosers/Test_Cfl.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_Cfl.cpp
@@ -26,6 +26,7 @@
 #include "Time/StepChoosers/Cfl.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/Tags/TimeStepper.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Time/TimeSteppers/AdamsBashforth.hpp"
 #include "Time/TimeSteppers/TimeStepper.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
@@ -110,16 +111,18 @@ std::pair<double, bool> get_suggestion(const size_t stepper_order,
 
   const double current_step = std::numeric_limits<double>::infinity();
   const auto result = cfl(grid_spacing, time_stepper, speed, current_step);
+  REQUIRE(result.first.size_goal.has_value());
+  CHECK(result.first == TimeStepRequest{.size_goal = result.first.size_goal});
   CHECK(serialize_and_deserialize(cfl)(grid_spacing, time_stepper, speed,
                                        current_step) == result);
   CHECK_FALSE(result.second);
   const auto accepted_step_result =
-      cfl(grid_spacing, time_stepper, speed, result.first * 0.7);
+      cfl(grid_spacing, time_stepper, speed, *result.first.size_goal * 0.7);
   CHECK(accepted_step_result.second);
   CHECK(cfl_base->desired_step(current_step, box) == result);
   CHECK(serialize_and_deserialize(cfl_base)->desired_step(current_step, box) ==
         result);
-  return result;
+  return {*result.first.size_goal, result.second};
 }
 
 template <typename Use>
diff --git a/tests/Unit/Time/StepChoosers/Test_Constant.cpp b/tests/Unit/Time/StepChoosers/Test_Constant.cpp
index c5a64ff0c3c5..9898ead97b5a 100644
--- a/tests/Unit/Time/StepChoosers/Test_Constant.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_Constant.cpp
@@ -13,6 +13,7 @@
 #include "Options/Protocols/FactoryCreation.hpp"
 #include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
 #include "Utilities/TMPL.hpp"
@@ -43,13 +44,12 @@ void test_use() {
       std::make_unique<StepChoosers::Constant<Use>>(constant);
 
   const double current_step = std::numeric_limits<double>::infinity();
-  CHECK(constant(current_step) == std::make_pair(5.4, true));
-  CHECK(serialize_and_deserialize(constant)(current_step) ==
-        std::make_pair(5.4, true));
-  CHECK(constant_base->desired_step(current_step, box) ==
-        std::make_pair(5.4, true));
+  const std::pair<TimeStepRequest, bool> expected{{.size_goal = 5.4}, true};
+  CHECK(constant(current_step) == expected);
+  CHECK(serialize_and_deserialize(constant)(current_step) == expected);
+  CHECK(constant_base->desired_step(current_step, box) == expected);
   CHECK(serialize_and_deserialize(constant_base)
-            ->desired_step(current_step, box) == std::make_pair(5.4, true));
+            ->desired_step(current_step, box) == expected);
 
   TestHelpers::test_creation<std::unique_ptr<StepChooser<Use>>, Metavariables>(
       "Constant: 5.4");
diff --git a/tests/Unit/Time/StepChoosers/Test_ElementSizeCfl.cpp b/tests/Unit/Time/StepChoosers/Test_ElementSizeCfl.cpp
index 01ae03cecfd2..fc13eb6598f9 100644
--- a/tests/Unit/Time/StepChoosers/Test_ElementSizeCfl.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_ElementSizeCfl.cpp
@@ -31,6 +31,7 @@
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/Tags/Time.hpp"
 #include "Time/Tags/TimeStepper.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Time/TimeSteppers/AdamsBashforth.hpp"
 #include "Time/TimeSteppers/TimeStepper.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
@@ -109,18 +110,20 @@ std::pair<double, bool> get_suggestion(
   const auto& time_stepper = get<Tags::TimeStepper<TimeStepper>>(box);
 
   const double current_step = std::numeric_limits<double>::infinity();
-  const std::pair<double, bool> result =
+  const auto result =
       element_size_cfl(time_stepper, element_size, speed, current_step);
+  REQUIRE(result.first.size_goal.has_value());
+  CHECK(result.first == TimeStepRequest{.size_goal = result.first.size_goal});
   CHECK_FALSE(result.second);
-  const auto accepted_step_result =
-      element_size_cfl(time_stepper, element_size, speed, result.first * 0.7);
+  const auto accepted_step_result = element_size_cfl(
+      time_stepper, element_size, speed, *result.first.size_goal * 0.7);
   CHECK(accepted_step_result.second);
   CHECK(element_size_base->desired_step(current_step, box) == result);
   CHECK(serialize_and_deserialize(element_size_cfl)(
             time_stepper, element_size, speed, current_step) == result);
   CHECK(serialize_and_deserialize(element_size_base)
             ->desired_step(current_step, box) == result);
-  return result;
+  return {*result.first.size_goal, result.second};
 }
 }  // namespace
 
diff --git a/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp b/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp
index 222bc9defe68..e2dabf6c06f6 100644
--- a/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp
@@ -39,6 +39,7 @@
 #include "Time/Tags/StepChoosers.hpp"
 #include "Time/Tags/StepperErrorTolerances.hpp"
 #include "Time/Tags/StepperErrors.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/Gsl.hpp"
 #include "Utilities/Literals.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
@@ -120,14 +121,16 @@ std::pair<double, bool> get_suggestion(
   const std::unique_ptr<StepChooser<StepChooserUse::LtsStep>>
       error_control_base = std::make_unique<LtsErrorControl>(error_control);
 
-  const std::pair<double, bool> result =
+  const auto result =
       error_control(std::array{previous_error, error}, previous_step);
+  REQUIRE(result.first.size_goal.has_value());
+  CHECK(result.first == TimeStepRequest{.size_goal = result.first.size_goal});
   CHECK(error_control_base->desired_step(previous_step, box) == result);
   CHECK(serialize_and_deserialize(error_control)(
             std::array{previous_error, error}, previous_step) == result);
   CHECK(serialize_and_deserialize(error_control_base)
             ->desired_step(previous_step, box) == result);
-  return result;
+  return {*result.first.size_goal, result.second};
 }
 }  // namespace
 
@@ -136,6 +139,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
 
   const std::vector<size_t> stepper_orders{2_st, 5_st};
   for (const bool time_runs_forward : {true, false}) {
+    const double unit_step = time_runs_forward ? 1.0 : -1.0;
     for (size_t stepper_order : stepper_orders) {
       CAPTURE(stepper_order);
       const auto step_errors = [&](const double error_time, const double error,
@@ -152,8 +156,9 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
       {
         INFO("No data available");
         const LtsErrorControl error_control{5.0e-4, 0.0, 2.0, 0.5, 0.95};
-        const auto result = get_suggestion(error_control, {}, {}, 1.0);
-        CHECK(result.first == std::numeric_limits<double>::infinity());
+        const auto result = get_suggestion(error_control, {}, {}, unit_step);
+        CHECK(result.first ==
+              unit_step * std::numeric_limits<double>::infinity());
         CHECK(result.second);
       }
       {
@@ -161,13 +166,13 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
         const LtsErrorControl error_control{5.0e-4, 1.0e-3, 2.0, 0.5, 0.95};
         CHECK(error_control.tolerances() ==
               StepperErrorTolerances{.absolute = 5.0e-4, .relative = 1.0e-3});
-        const auto first_result =
-            get_suggestion(error_control, {step_errors(0.0, 0.3)}, {}, 1.0);
+        const auto first_result = get_suggestion(
+            error_control, {step_errors(0.0, 0.3)}, {}, unit_step);
         CHECK(approx(first_result.first) ==
-              0.95 / pow(0.3, 1.0 / stepper_order));
+              0.95 * unit_step / pow(0.3, 1.0 / stepper_order));
         CHECK(first_result.second);
         const auto second_result = get_suggestion(
-            error_control, {step_errors(0.0, 0.31, first_result.first)},
+            error_control, {step_errors(0.0, 0.31, abs(first_result.first))},
             {step_errors(-1.0, 0.3)}, first_result.first);
         CHECK(approx(second_result.first) ==
               0.95 * first_result.first /
@@ -177,21 +182,21 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
         // Check that the suggested step size is smaller if the error in
         // increasing faster.
         const auto adjusted_second_result = get_suggestion(
-            error_control, {step_errors(0.0, 0.31, first_result.first)},
+            error_control, {step_errors(0.0, 0.31, abs(first_result.first))},
             {step_errors(-1.0, 0.1)}, first_result.first);
-        CHECK(adjusted_second_result.first < second_result.first);
+        CHECK(abs(adjusted_second_result.first) < abs(second_result.first));
       }
       {
         INFO("Test error control step failure");
         const LtsErrorControl error_control{4.0e-5, 4.0e-5, 2.0, 0.5, 0.95};
-        const auto result_start =
-            get_suggestion(error_control, {step_errors(0.0, 1.2)}, {}, 1.0);
-        const auto result_end =
-            get_suggestion(error_control, {step_errors(-1.0, 1.2)}, {}, 1.0);
+        const auto result_start = get_suggestion(
+            error_control, {step_errors(0.0, 1.2)}, {}, unit_step);
+        const auto result_end = get_suggestion(
+            error_control, {step_errors(-1.0, 1.2)}, {}, unit_step);
         const auto result_end2 = get_suggestion(
             error_control, {step_errors(-1.0, 1.2)}, {}, result_end.first);
         CHECK(approx(result_start.first) ==
-              0.95 / pow(1.2, 1.0 / stepper_order));
+              0.95 * unit_step / pow(1.2, 1.0 / stepper_order));
         CHECK(result_end.first == result_start.first);
         CHECK(result_end2.first == result_start.first);
         CHECK_FALSE(result_start.second);
@@ -201,16 +206,16 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
       {
         INFO("Test error control clamped minimum");
         const LtsErrorControl error_control{4.0e-5, 4.0e-5, 2.0, 0.9, 0.95};
-        const auto first_result =
-            get_suggestion(error_control, {step_errors(0.0, 10.0)}, {}, 1.0);
-        CHECK(first_result.first == 0.9);
+        const auto first_result = get_suggestion(
+            error_control, {step_errors(0.0, 10.0)}, {}, unit_step);
+        CHECK(first_result.first == 0.9 * unit_step);
       }
       {
         INFO("Test error control clamped maximum");
         const LtsErrorControl error_control{1.0e-1, 1.0e-1, 2.0, 0.5, 0.95};
-        const auto first_result =
-            get_suggestion(error_control, {step_errors(0.0, 0.01)}, {}, 1.0);
-        CHECK(first_result == std::make_pair(2.0, true));
+        const auto first_result = get_suggestion(
+            error_control, {step_errors(0.0, 0.01)}, {}, unit_step);
+        CHECK(first_result == std::make_pair(2.0 * unit_step, true));
       }
     }
   }
diff --git a/tests/Unit/Time/StepChoosers/Test_Increase.cpp b/tests/Unit/Time/StepChoosers/Test_Increase.cpp
index 95e58028f9f7..ca500dcb2fca 100644
--- a/tests/Unit/Time/StepChoosers/Test_Increase.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_Increase.cpp
@@ -14,6 +14,7 @@
 #include "Parallel/Tags/Metavariables.hpp"
 #include "Time/StepChoosers/Increase.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
 #include "Utilities/TMPL.hpp"
@@ -41,19 +42,19 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.Increase", "[Unit][Time]") {
       db::AddSimpleTags<Parallel::Tags::MetavariablesImpl<Metavariables>>>(
       Metavariables{});
   const auto check = [&box](auto use, const double step,
-                            const double expected) {
+                            const double expected_size) {
     using Use = tmpl::type_from<decltype(use)>;
     const StepChoosers::Increase<Use> increase{5.};
     const std::unique_ptr<StepChooser<Use>> increase_base =
         std::make_unique<StepChoosers::Increase<Use>>(increase);
 
-    CHECK(increase(step) == std::make_pair(expected, true));
-    CHECK(serialize_and_deserialize(increase)(step) ==
-          std::make_pair(expected, true));
-    CHECK(increase_base->desired_step(step, box) ==
-          std::make_pair(expected, true));
+    const std::pair<TimeStepRequest, bool> expected{
+        {.size_goal = expected_size}, true};
+    CHECK(increase(step) == expected);
+    CHECK(serialize_and_deserialize(increase)(step) == expected);
+    CHECK(increase_base->desired_step(step, box) == expected);
     CHECK(serialize_and_deserialize(increase_base)->desired_step(step, box) ==
-          std::make_pair(expected, true));
+          expected);
   };
   check(tmpl::type_<StepChooserUse::LtsStep>{}, 0.25, 1.25);
   check(tmpl::type_<StepChooserUse::Slab>{}, 0.25, 1.25);
diff --git a/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp b/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
index 4e8c11237be1..661dcbeeff6c 100644
--- a/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
@@ -24,6 +24,7 @@
 #include "Time/Tags/HistoryEvolvedVariables.hpp"
 #include "Time/Time.hpp"
 #include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
 #include "Utilities/StdHelpers.hpp"
@@ -55,13 +56,14 @@ void check_case(const Frac& expected_frac, const std::vector<Frac>& times) {
   CAPTURE(expected_frac);
 
   const Slab slab(0.25, 1.5);
-  const double expected = expected_frac == -1
-                              ? std::numeric_limits<double>::infinity()
-                              : (expected_frac * slab.duration()).value();
-
   for (const auto& direction : {1, -1}) {
     CAPTURE(direction);
 
+    const double expected_size =
+        expected_frac == -1
+            ? direction * std::numeric_limits<double>::infinity()
+            : (direction * expected_frac * slab.duration()).value();
+
     const auto make_time_id = [&direction, &slab, &times](const size_t i) {
       Frac frac = -direction * times[i];
       int64_t slab_number = 0;
@@ -100,28 +102,27 @@ void check_case(const Frac& expected_frac, const std::vector<Frac>& times) {
       gts_history.insert_initial(make_gts_time_id(i), 0.0, 0.0);
     }
 
-    const auto check = [&expected](auto use, const auto& box,
-                                   const Time& current_time) {
+    const auto check = [&direction, &expected_size](auto use, const auto& box,
+                                                    const Time& current_time) {
       using Use = tmpl::type_from<decltype(use)>;
       const auto& history = db::get<history_tag>(box);
       const double current_step =
           history.size() > 0
-              ? abs(current_time - history.back().time_step_id.step_time())
-                    .value()
-              : std::numeric_limits<double>::infinity();
+              ? (current_time - history.back().time_step_id.step_time()).value()
+              : direction * std::numeric_limits<double>::infinity();
 
       const StepChoosers::PreventRapidIncrease<Use> relax{};
       const std::unique_ptr<StepChooser<Use>> relax_base =
           std::make_unique<StepChoosers::PreventRapidIncrease<Use>>(relax);
 
-      CHECK(relax(history, current_step) == std::make_pair(expected, true));
+      const std::pair<TimeStepRequest, bool> expected{
+          {.size_goal = expected_size}, true};
+      CHECK(relax(history, current_step) == expected);
       CHECK(serialize_and_deserialize(relax)(history, current_step) ==
-            std::make_pair(expected, true));
-      CHECK(relax_base->desired_step(current_step, box) ==
-            std::make_pair(expected, true));
+            expected);
+      CHECK(relax_base->desired_step(current_step, box) == expected);
       CHECK(serialize_and_deserialize(relax_base)
-                ->desired_step(current_step, box) ==
-            std::make_pair(expected, true));
+                ->desired_step(current_step, box) == expected);
     };
 
     {
@@ -166,7 +167,9 @@ void check_substep_methods() {
                  0.0, 0.0);
   const StepChoosers::PreventRapidIncrease<StepChooserUse::Slab> relax{};
   CHECK(relax(history, 3.14) ==
-        std::make_pair(std::numeric_limits<double>::infinity(), true));
+        std::pair(TimeStepRequest{.size_goal =
+                                      std::numeric_limits<double>::infinity()},
+                  true));
 }
 }  // namespace
 
diff --git a/tests/Unit/Time/StepChoosers/Test_Random.cpp b/tests/Unit/Time/StepChoosers/Test_Random.cpp
index d109a87122a0..c896ca026cd1 100644
--- a/tests/Unit/Time/StepChoosers/Test_Random.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_Random.cpp
@@ -22,6 +22,7 @@
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/Tags/TimeStepId.hpp"
 #include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/MakeString.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
@@ -69,13 +70,15 @@ double get_suggestion(const double min, const double max, const size_t seed,
   CHECK(random.uses_local_data());
 
   const auto result = random(element, time_step_id, current_step);
+  REQUIRE(result.first.size_goal.has_value());
+  CHECK(result.first == TimeStepRequest{.size_goal = result.first.size_goal});
   // Should be deterministic
   CHECK(result == random(element, time_step_id, current_step));
 
   CHECK(result.second);
 
-  CHECK(result.first >= min);
-  CHECK(result.first <= max);
+  CHECK(*result.first.size_goal >= min);
+  CHECK(*result.first.size_goal <= max);
 
   CHECK(serialize_and_deserialize(random)(element, time_step_id,
                                           current_step) == result);
@@ -84,7 +87,7 @@ double get_suggestion(const double min, const double max, const size_t seed,
       serialize_and_deserialize(random_base)->desired_step(current_step, box) ==
       result);
 
-  return result.first;
+  return *result.first.size_goal;
 }
 
 template <typename Use>
diff --git a/tests/Unit/Time/StepChoosers/Test_StepToTimes.cpp b/tests/Unit/Time/StepChoosers/Test_StepToTimes.cpp
index 135602be4bf6..65097b65cd21 100644
--- a/tests/Unit/Time/StepChoosers/Test_StepToTimes.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_StepToTimes.cpp
@@ -21,6 +21,7 @@
 #include "Time/Tags/TimeStepId.hpp"
 #include "Time/TimeSequence.hpp"
 #include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/Algorithm.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
@@ -44,13 +45,14 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.StepToTimes", "[Unit][Time]") {
   register_factory_classes_with_charm<Metavariables>();
 
   const auto requested = [](const double now, std::vector<double> times,
-                            const double step) {
-    double result = -1.0;
-    const auto impl = [&result, &step](const TimeStepId& now_id,
-                                       const std::vector<double>& impl_times) {
+                            const double last_step_magnitude) {
+    std::optional<double> result{};
+    const auto impl = [&result](const TimeStepId& now_id,
+                                const std::vector<double>& impl_times,
+                                const double last_step) {
       CAPTURE(now_id);
       CAPTURE(impl_times);
-      CAPTURE(step);
+      CAPTURE(last_step);
 
       using Specified = TimeSequences::Specified<double>;
       const StepChoosers::StepToTimes step_to_times(
@@ -63,23 +65,28 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.StepToTimes", "[Unit][Time]") {
           Parallel::Tags::MetavariablesImpl<Metavariables>, Tags::TimeStepId>>(
           Metavariables{}, now_id);
 
-      const auto answer = step_to_times(now_id, step);
-      if (result == -1.0) {
-        result = answer.first;
+      const auto answer = step_to_times(now_id, last_step);
+      REQUIRE(answer.first.size_goal.has_value());
+      CHECK(answer.first ==
+            TimeStepRequest{.size_goal = answer.first.size_goal});
+      if (not result.has_value()) {
+        result.emplace(*answer.first.size_goal);
       } else {
-        CHECK(result == answer.first);
+        CHECK(*result == *answer.first.size_goal);
       }
-      CHECK(step_to_times_base->desired_step(step, box) ==
-            std::make_pair(result, true));
-      CHECK(serialize_and_deserialize(step_to_times)(now_id, step) ==
-            std::make_pair(result, true));
+      CHECK(step_to_times_base->desired_step(last_step, box) == answer);
+      CHECK(serialize_and_deserialize(step_to_times)(now_id, last_step) ==
+            answer);
       CHECK(serialize_and_deserialize(step_to_times_base)
-                ->desired_step(step, box) == std::make_pair(result, true));
+                ->desired_step(last_step, box) == answer);
     };
-    impl(TimeStepId(true, 0, Slab(now, now + 1.0).start()), times);
+    impl(TimeStepId(true, 0, Slab(now, now + 1.0).start()), times,
+         last_step_magnitude);
     alg::for_each(times, [](double& x) { return x = -x; });
-    impl(TimeStepId(false, 0, Slab(-now, -now + 1.0).start()), times);
-    return result;
+    *result = -*result;
+    impl(TimeStepId(false, 0, Slab(-now, -now + 1.0).start()), times,
+         -last_step_magnitude);
+    return -*result;
   };
 
   static constexpr double infinity = std::numeric_limits<double>::infinity();

From 5a9315d63801b074c8cef6537d38986b81f0cbfc Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Wed, 8 May 2024 14:31:42 -0400
Subject: [PATCH 08/16] Ignore argument sign in Constant StepChooser

Instead of making people figure out which to pass for backwards
evolutions, just accept either.
---
 src/Time/StepChoosers/Constant.cpp             |  7 +------
 src/Time/StepChoosers/Constant.hpp             |  5 +----
 tests/Unit/Time/StepChoosers/Test_Constant.cpp | 12 +++---------
 3 files changed, 5 insertions(+), 19 deletions(-)

diff --git a/src/Time/StepChoosers/Constant.cpp b/src/Time/StepChoosers/Constant.cpp
index 9b63ebe6da3f..2e9587cd8829 100644
--- a/src/Time/StepChoosers/Constant.cpp
+++ b/src/Time/StepChoosers/Constant.cpp
@@ -10,12 +10,7 @@ namespace Constant_detail {
 // This function lets us avoid including ParseOptions.hpp in the
 // header.
 double parse_options(const Options::Option& options) {
-  const auto value = options.parse_as<double>();
-  if (value <= 0.) {
-    PARSE_ERROR(options.context(),
-                "Requested step magnitude should be positive.");
-  }
-  return value;
+  return options.parse_as<double>();
 }
 }  // namespace Constant_detail
 }  // namespace StepChoosers
diff --git a/src/Time/StepChoosers/Constant.hpp b/src/Time/StepChoosers/Constant.hpp
index cb64d6d5467f..6725e855d707 100644
--- a/src/Time/StepChoosers/Constant.hpp
+++ b/src/Time/StepChoosers/Constant.hpp
@@ -12,7 +12,6 @@
 #include "Options/String.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/TimeStepRequest.hpp"
-#include "Utilities/ErrorHandling/Assert.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
 
@@ -31,9 +30,7 @@ class Constant : public StepChooser<StepChooserUse> {
 
   static constexpr Options::String help{"Suggests a constant step size."};
 
-  explicit Constant(const double value) : value_(value) {
-    ASSERT(value_ > 0., "Requested step magnitude should be positive.");
-  }
+  explicit Constant(const double value) : value_(value) {}
 
   using argument_tags = tmpl::list<>;
 
diff --git a/tests/Unit/Time/StepChoosers/Test_Constant.cpp b/tests/Unit/Time/StepChoosers/Test_Constant.cpp
index 9898ead97b5a..d9240cb6ed11 100644
--- a/tests/Unit/Time/StepChoosers/Test_Constant.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_Constant.cpp
@@ -39,7 +39,8 @@ void test_use() {
       db::AddSimpleTags<Parallel::Tags::MetavariablesImpl<Metavariables>>>(
       Metavariables{});
 
-  const StepChoosers::Constant<Use> constant{5.4};
+  // Sign of argument should be ignored.
+  const StepChoosers::Constant<Use> constant{-5.4};
   const std::unique_ptr<StepChooser<Use>> constant_base =
       std::make_unique<StepChoosers::Constant<Use>>(constant);
 
@@ -52,7 +53,7 @@ void test_use() {
             ->desired_step(current_step, box) == expected);
 
   TestHelpers::test_creation<std::unique_ptr<StepChooser<Use>>, Metavariables>(
-      "Constant: 5.4");
+      "Constant: -5.4");
 }
 }  // namespace
 
@@ -63,11 +64,4 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.Constant", "[Unit][Time]") {
   test_use<StepChooserUse::Slab>();
 
   CHECK(not StepChoosers::Constant<StepChooserUse::Slab>{}.uses_local_data());
-
-  CHECK_THROWS_WITH(
-      (TestHelpers::test_creation<
-          std::unique_ptr<StepChooser<StepChooserUse::Slab>>, Metavariables>(
-          "Constant: -5.4")),
-      Catch::Matchers::ContainsSubstring(
-          "Requested step magnitude should be positive"));
 }

From 32ce1f9577838543cae2af2bccf1388c650f4b01 Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Thu, 9 May 2024 16:13:00 -0400
Subject: [PATCH 09/16] Make ErrorControl do nothing without an estimate

---
 src/Time/StepChoosers/ErrorControl.hpp        |  6 +--
 .../Time/StepChoosers/Test_ErrorControl.cpp   | 39 ++++++++++---------
 2 files changed, 23 insertions(+), 22 deletions(-)

diff --git a/src/Time/StepChoosers/ErrorControl.hpp b/src/Time/StepChoosers/ErrorControl.hpp
index 781b0e37b55c..5d9aaac77477 100644
--- a/src/Time/StepChoosers/ErrorControl.hpp
+++ b/src/Time/StepChoosers/ErrorControl.hpp
@@ -203,12 +203,10 @@ class ErrorControl
   std::pair<TimeStepRequest, bool> operator()(
       const typename ::Tags::StepperErrors<EvolvedVariableTag>::type& errors,
       const double previous_step) const {
-    // request that the step size not be changed if there isn't a new error
+    // Do not request that the step size be changed if there isn't a new error
     // estimate
     if (not errors[1].has_value()) {
-      return {{.size_goal = std::copysign(
-                   std::numeric_limits<double>::infinity(), previous_step)},
-              true};
+      return {{}, true};
     }
     double new_step;
     if (not errors[0].has_value() or errors[0]->order != errors[1]->order) {
diff --git a/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp b/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp
index e2dabf6c06f6..772c56427bbe 100644
--- a/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp
@@ -6,7 +6,6 @@
 #include <array>
 #include <cmath>
 #include <cstddef>
-#include <limits>
 #include <memory>
 #include <optional>
 #include <string>
@@ -108,7 +107,7 @@ struct Metavariables {
 using LtsErrorControl =
     StepChoosers::ErrorControl<StepChooserUse::LtsStep, EvolvedVariablesTag>;
 
-std::pair<double, bool> get_suggestion(
+std::pair<std::optional<double>, bool> get_suggestion(
     const LtsErrorControl& error_control,
     const std::optional<StepperErrorEstimate>& error,
     const std::optional<StepperErrorEstimate>& previous_error,
@@ -123,14 +122,13 @@ std::pair<double, bool> get_suggestion(
 
   const auto result =
       error_control(std::array{previous_error, error}, previous_step);
-  REQUIRE(result.first.size_goal.has_value());
   CHECK(result.first == TimeStepRequest{.size_goal = result.first.size_goal});
   CHECK(error_control_base->desired_step(previous_step, box) == result);
   CHECK(serialize_and_deserialize(error_control)(
             std::array{previous_error, error}, previous_step) == result);
   CHECK(serialize_and_deserialize(error_control_base)
             ->desired_step(previous_step, box) == result);
-  return {*result.first.size_goal, result.second};
+  return {result.first.size_goal, result.second};
 }
 }  // namespace
 
@@ -157,8 +155,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
         INFO("No data available");
         const LtsErrorControl error_control{5.0e-4, 0.0, 2.0, 0.5, 0.95};
         const auto result = get_suggestion(error_control, {}, {}, unit_step);
-        CHECK(result.first ==
-              unit_step * std::numeric_limits<double>::infinity());
+        CHECK(not result.first.has_value());
         CHECK(result.second);
       }
       {
@@ -168,34 +165,40 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
               StepperErrorTolerances{.absolute = 5.0e-4, .relative = 1.0e-3});
         const auto first_result = get_suggestion(
             error_control, {step_errors(0.0, 0.3)}, {}, unit_step);
-        CHECK(approx(first_result.first) ==
+        REQUIRE(first_result.first.has_value());
+        CHECK(approx(*first_result.first) ==
               0.95 * unit_step / pow(0.3, 1.0 / stepper_order));
         CHECK(first_result.second);
         const auto second_result = get_suggestion(
-            error_control, {step_errors(0.0, 0.31, abs(first_result.first))},
-            {step_errors(-1.0, 0.3)}, first_result.first);
-        CHECK(approx(second_result.first) ==
-              0.95 * first_result.first /
+            error_control, {step_errors(0.0, 0.31, abs(*first_result.first))},
+            {step_errors(-1.0, 0.3)}, *first_result.first);
+        REQUIRE(second_result.first.has_value());
+        CHECK(approx(*second_result.first) ==
+              0.95 * *first_result.first /
                   (pow(0.3, -0.4 / stepper_order) *
                    pow(0.31, 0.7 / stepper_order)));
         CHECK(second_result.second);
         // Check that the suggested step size is smaller if the error in
         // increasing faster.
         const auto adjusted_second_result = get_suggestion(
-            error_control, {step_errors(0.0, 0.31, abs(first_result.first))},
-            {step_errors(-1.0, 0.1)}, first_result.first);
-        CHECK(abs(adjusted_second_result.first) < abs(second_result.first));
+            error_control, {step_errors(0.0, 0.31, abs(*first_result.first))},
+            {step_errors(-1.0, 0.1)}, *first_result.first);
+        REQUIRE(adjusted_second_result.first.has_value());
+        CHECK(abs(*adjusted_second_result.first) < abs(*second_result.first));
       }
       {
         INFO("Test error control step failure");
         const LtsErrorControl error_control{4.0e-5, 4.0e-5, 2.0, 0.5, 0.95};
         const auto result_start = get_suggestion(
             error_control, {step_errors(0.0, 1.2)}, {}, unit_step);
+        REQUIRE(result_start.first.has_value());
         const auto result_end = get_suggestion(
             error_control, {step_errors(-1.0, 1.2)}, {}, unit_step);
+        REQUIRE(result_end.first.has_value());
         const auto result_end2 = get_suggestion(
-            error_control, {step_errors(-1.0, 1.2)}, {}, result_end.first);
-        CHECK(approx(result_start.first) ==
+            error_control, {step_errors(-1.0, 1.2)}, {}, *result_end.first);
+        REQUIRE(result_end2.first.has_value());
+        CHECK(approx(*result_start.first) ==
               0.95 * unit_step / pow(1.2, 1.0 / stepper_order));
         CHECK(result_end.first == result_start.first);
         CHECK(result_end2.first == result_start.first);
@@ -208,14 +211,14 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
         const LtsErrorControl error_control{4.0e-5, 4.0e-5, 2.0, 0.9, 0.95};
         const auto first_result = get_suggestion(
             error_control, {step_errors(0.0, 10.0)}, {}, unit_step);
-        CHECK(first_result.first == 0.9 * unit_step);
+        CHECK(first_result.first == std::optional(0.9 * unit_step));
       }
       {
         INFO("Test error control clamped maximum");
         const LtsErrorControl error_control{1.0e-1, 1.0e-1, 2.0, 0.5, 0.95};
         const auto first_result = get_suggestion(
             error_control, {step_errors(0.0, 0.01)}, {}, unit_step);
-        CHECK(first_result == std::make_pair(2.0 * unit_step, true));
+        CHECK(first_result == std::pair(std::optional(2.0 * unit_step), true));
       }
     }
   }

From 2bad6e1cc48f602a4c2f7c04eada4ddbe785565f Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Thu, 9 May 2024 18:16:48 -0400
Subject: [PATCH 10/16] Use new features in PreventRapidIncrease

* Do nothing when not active
* Don't set limit as a new goal
---
 src/Time/StepChoosers/PreventRapidIncrease.hpp  | 15 ++++-----------
 .../StepChoosers/Test_PreventRapidIncrease.cpp  | 17 ++++++++---------
 2 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/src/Time/StepChoosers/PreventRapidIncrease.hpp b/src/Time/StepChoosers/PreventRapidIncrease.hpp
index 02e00a461920..b1a913e037c0 100644
--- a/src/Time/StepChoosers/PreventRapidIncrease.hpp
+++ b/src/Time/StepChoosers/PreventRapidIncrease.hpp
@@ -4,7 +4,6 @@
 #pragma once
 
 #include <cmath>  // IWYU pragma: keep  // for abs
-#include <limits>
 #include <pup.h>
 #include <utility>
 
@@ -21,7 +20,7 @@ namespace StepChoosers {
 /// preventing the step size from increasing if any step in the
 /// time-stepper history increased.  If there have been recent step
 /// size increases, the new size bound is the size of the most recent
-/// step, otherwise it is infinite (no restriction is imposed).
+/// step, otherwise no restriction is imposed.
 template <typename StepChooserUse>
 class PreventRapidIncrease : public StepChooser<StepChooserUse> {
  public:
@@ -43,9 +42,7 @@ class PreventRapidIncrease : public StepChooser<StepChooserUse> {
   std::pair<TimeStepRequest, bool> operator()(const History& history,
                                               const double last_step) const {
     if (history.size() < 2) {
-      return {{.size_goal = std::copysign(
-                   std::numeric_limits<double>::infinity(), last_step)},
-              true};
+      return {{}, true};
     }
 
     const double sloppiness =
@@ -59,17 +56,13 @@ class PreventRapidIncrease : public StepChooser<StepChooserUse> {
         // Potential roundoff error comes from the inability to make
         // slabs exactly the same length.
         if (this_step < newer_step - sloppiness) {
-          return {{.size_goal = last_step}, true};
+          return {{.size = last_step}, true};
         }
         newer_step = this_step;
       }
       previous_time.emplace(time);
     }
-    // Request that the step size be at most infinity.  This imposes
-    // no restriction on the chosen step.
-    return {{.size_goal = std::copysign(std::numeric_limits<double>::infinity(),
-                                        last_step)},
-            true};
+    return {{}, true};
   }
 
   bool uses_local_data() const override { return false; }
diff --git a/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp b/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
index 661dcbeeff6c..c0df6dae9c2b 100644
--- a/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
@@ -9,6 +9,7 @@
 #include <initializer_list>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <utility>
 #include <vector>
 
@@ -59,10 +60,11 @@ void check_case(const Frac& expected_frac, const std::vector<Frac>& times) {
   for (const auto& direction : {1, -1}) {
     CAPTURE(direction);
 
-    const double expected_size =
+    const std::optional<double> expected_size =
         expected_frac == -1
-            ? direction * std::numeric_limits<double>::infinity()
-            : (direction * expected_frac * slab.duration()).value();
+            ? std::nullopt
+            : std::optional(
+                  (direction * expected_frac * slab.duration()).value());
 
     const auto make_time_id = [&direction, &slab, &times](const size_t i) {
       Frac frac = -direction * times[i];
@@ -115,8 +117,8 @@ void check_case(const Frac& expected_frac, const std::vector<Frac>& times) {
       const std::unique_ptr<StepChooser<Use>> relax_base =
           std::make_unique<StepChoosers::PreventRapidIncrease<Use>>(relax);
 
-      const std::pair<TimeStepRequest, bool> expected{
-          {.size_goal = expected_size}, true};
+      const std::pair<TimeStepRequest, bool> expected{{.size = expected_size},
+                                                      true};
       CHECK(relax(history, current_step) == expected);
       CHECK(serialize_and_deserialize(relax)(history, current_step) ==
             expected);
@@ -166,10 +168,7 @@ void check_substep_methods() {
                             (slab.start() + slab.duration() / 2).value()),
                  0.0, 0.0);
   const StepChoosers::PreventRapidIncrease<StepChooserUse::Slab> relax{};
-  CHECK(relax(history, 3.14) ==
-        std::pair(TimeStepRequest{.size_goal =
-                                      std::numeric_limits<double>::infinity()},
-                  true));
+  CHECK(relax(history, 3.14) == std::pair(TimeStepRequest{}, true));
 }
 }  // namespace
 

From 17d5db61ee111ca87e2a8f82a6176610de144ad5 Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Fri, 10 May 2024 13:10:20 -0400
Subject: [PATCH 11/16] Use new features in StepToTimes

---
 src/Time/StepChoosers/StepToTimes.hpp         |  71 +++-----
 .../Time/StepChoosers/Test_StepToTimes.cpp    | 154 ++++++++----------
 2 files changed, 97 insertions(+), 128 deletions(-)

diff --git a/src/Time/StepChoosers/StepToTimes.hpp b/src/Time/StepChoosers/StepToTimes.hpp
index 329f63dbc880..8c5c44a8f9f3 100644
--- a/src/Time/StepChoosers/StepToTimes.hpp
+++ b/src/Time/StepChoosers/StepToTimes.hpp
@@ -11,17 +11,18 @@
 #include <utility>
 
 #include "Options/String.hpp"
+#include "Time/EvolutionOrdering.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/TimeSequence.hpp"
 #include "Time/TimeStepId.hpp"
 #include "Time/TimeStepRequest.hpp"
-#include "Time/Utilities.hpp"
+#include "Utilities/Gsl.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
 
 /// \cond
 namespace Tags {
-struct TimeStepId;
+struct Time;
 }  // namespace Tags
 /// \endcond
 
@@ -54,58 +55,36 @@ class StepToTimes : public StepChooser<StepChooserUse::Slab> {
   explicit StepToTimes(std::unique_ptr<TimeSequence<double>> times)
       : times_(std::move(times)) {}
 
-  using argument_tags = tmpl::list<::Tags::TimeStepId>;
+  using argument_tags = tmpl::list<::Tags::Time>;
 
-  std::pair<TimeStepRequest, bool> operator()(const TimeStepId& time_step_id,
+  std::pair<TimeStepRequest, bool> operator()(const double now,
                                               const double last_step) const {
-    const double now = time_step_id.substep_time();
-    // Trying to step to a given time might not get us exactly there
-    // because of rounding errors.  Avoid taking an extra tiny step if
-    // we undershoot.
-    const double sloppiness = slab_rounding_error(time_step_id.step_time());
-
     const auto goal_times = times_->times_near(now);
-    if (not goal_times[1]) {
+    if (not goal_times[1].has_value()) {
       // No times requested.
-      return {{.size_goal = std::copysign(
-                   std::numeric_limits<double>::infinity(), last_step)},
-              true};
+      return {{}, true};
     }
 
-    double distance_to_next_goal = std::numeric_limits<double>::signaling_NaN();
-    if (time_step_id.time_runs_forward()) {
-      const auto next_time =
-          *goal_times[1] > now + sloppiness ? goal_times[1] : goal_times[2];
-      if (not next_time) {
-        // We've passed all the times.  No restriction.
-        return {{.size_goal = std::numeric_limits<double>::infinity()}, true};
-      }
-      distance_to_next_goal = *next_time - now;
-    } else {
-      const auto next_time =
-          *goal_times[1] < now - sloppiness ? goal_times[1] : goal_times[0];
-      if (not next_time) {
-        // We've passed all the times.  No restriction.
-        return {{.size_goal = -std::numeric_limits<double>::infinity()}, true};
-      }
-      distance_to_next_goal = now - *next_time;
+    const evolution_greater<double> after{last_step > 0.0};
+    const auto next_time = after(*goal_times[1], now)
+                               ? goal_times[1]
+                               : gsl::at(goal_times, last_step > 0.0 ? 2 : 0);
+    if (not next_time.has_value()) {
+      // We've passed all the times.  No restriction.
+      return {{}, true};
     }
 
-    if (distance_to_next_goal < 2.0 / 3.0 * abs(last_step)) {
-      // Our goal is well within range of the expected allowed step
-      // size.
-      return {{.size_goal = std::copysign(distance_to_next_goal, last_step)},
-              true};
-    } else {
-      // We can't reach our goal in one step, or at least might not be
-      // able to if the step adjusts a relatively small amount for
-      // other reasons.  Prevent the step from bringing us too close
-      // to the goal so that the step following this one will not be
-      // too small.
-      return {{.size_goal =
-                   std::copysign(2.0 / 3.0 * distance_to_next_goal, last_step)},
-              true};
-    }
+    // The calling code can ignore one part of the request if it can
+    // fulfill the other part exactly, so this will either step
+    // exactly to *next_time or step at most 2/3 of the way there.
+    // This attempts to balance out the steps to avoid a step almost
+    // to *next_time followed by a very small step.  This will work
+    // poorly if there are two copies of this StepChooser targeting
+    // times very close together, but hopefully people don't do that.
+    return {{.size = 2.0 / 3.0 * (*next_time - now),
+             .end = *next_time,
+             .end_hard_limit = *next_time},
+            true};
   }
 
   bool uses_local_data() const override;
diff --git a/tests/Unit/Time/StepChoosers/Test_StepToTimes.cpp b/tests/Unit/Time/StepChoosers/Test_StepToTimes.cpp
index 65097b65cd21..8cb997fb19c1 100644
--- a/tests/Unit/Time/StepChoosers/Test_StepToTimes.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_StepToTimes.cpp
@@ -6,6 +6,7 @@
 #include <cmath>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <pup.h>
 #include <utility>
 #include <vector>
@@ -18,9 +19,8 @@
 #include "Time/Slab.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/StepChoosers/StepToTimes.hpp"
-#include "Time/Tags/TimeStepId.hpp"
+#include "Time/Tags/Time.hpp"
 #include "Time/TimeSequence.hpp"
-#include "Time/TimeStepId.hpp"
 #include "Time/TimeStepRequest.hpp"
 #include "Utilities/Algorithm.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
@@ -39,99 +39,89 @@ struct Metavariables {
   };
   using component_list = tmpl::list<>;
 };
-}  // namespace
-
-SPECTRE_TEST_CASE("Unit.Time.StepChoosers.StepToTimes", "[Unit][Time]") {
-  register_factory_classes_with_charm<Metavariables>();
 
-  const auto requested = [](const double now, std::vector<double> times,
-                            const double last_step_magnitude) {
-    std::optional<double> result{};
-    const auto impl = [&result](const TimeStepId& now_id,
-                                const std::vector<double>& impl_times,
-                                const double last_step) {
-      CAPTURE(now_id);
-      CAPTURE(impl_times);
-      CAPTURE(last_step);
-
-      using Specified = TimeSequences::Specified<double>;
-      const StepChoosers::StepToTimes step_to_times(
-          std::make_unique<Specified>(impl_times));
-      const std::unique_ptr<StepChooser<StepChooserUse::Slab>>
-          step_to_times_base = std::make_unique<StepChoosers::StepToTimes>(
-              std::make_unique<Specified>(impl_times));
-
-      auto box = db::create<db::AddSimpleTags<
-          Parallel::Tags::MetavariablesImpl<Metavariables>, Tags::TimeStepId>>(
-          Metavariables{}, now_id);
-
-      const auto answer = step_to_times(now_id, last_step);
-      REQUIRE(answer.first.size_goal.has_value());
-      CHECK(answer.first ==
-            TimeStepRequest{.size_goal = answer.first.size_goal});
-      if (not result.has_value()) {
-        result.emplace(*answer.first.size_goal);
-      } else {
-        CHECK(*result == *answer.first.size_goal);
-      }
-      CHECK(step_to_times_base->desired_step(last_step, box) == answer);
-      CHECK(serialize_and_deserialize(step_to_times)(now_id, last_step) ==
-            answer);
-      CHECK(serialize_and_deserialize(step_to_times_base)
-                ->desired_step(last_step, box) == answer);
-    };
-    impl(TimeStepId(true, 0, Slab(now, now + 1.0).start()), times,
-         last_step_magnitude);
-    alg::for_each(times, [](double& x) { return x = -x; });
-    *result = -*result;
-    impl(TimeStepId(false, 0, Slab(-now, -now + 1.0).start()), times,
-         -last_step_magnitude);
-    return -*result;
+void check_case(const double now, std::vector<double> times,
+                const std::optional<double>& expected_end) {
+  const auto impl = [](const double local_now, const double last_step,
+                       const std::vector<double>& impl_times) {
+    CAPTURE(local_now);
+    CAPTURE(impl_times);
+
+    using Specified = TimeSequences::Specified<double>;
+    const StepChoosers::StepToTimes step_to_times(
+        std::make_unique<Specified>(impl_times));
+    const std::unique_ptr<StepChooser<StepChooserUse::Slab>>
+        step_to_times_base = std::make_unique<StepChoosers::StepToTimes>(
+            std::make_unique<Specified>(impl_times));
+
+    auto box = db::create<db::AddSimpleTags<
+        Parallel::Tags::MetavariablesImpl<Metavariables>, Tags::Time>>(
+        Metavariables{}, local_now);
+
+    const auto answer = step_to_times(local_now, last_step);
+    CHECK(answer.second);
+
+    const auto& request = answer.first;
+    CHECK(request.end == request.end_hard_limit);
+    REQUIRE(request.size.has_value() == request.end.has_value());
+    CHECK(not request.size_goal.has_value());
+    CHECK(not request.size_hard_limit.has_value());
+
+    CHECK(step_to_times_base->desired_step(last_step, box) == answer);
+    CHECK(serialize_and_deserialize(step_to_times)(local_now, last_step) ==
+          answer);
+    CHECK(serialize_and_deserialize(step_to_times_base)
+              ->desired_step(last_step, box) == answer);
+    return request.end.has_value()
+               ? std::optional(std::pair(*request.end, *request.size))
+               : std::nullopt;
   };
-
-  static constexpr double infinity = std::numeric_limits<double>::infinity();
-
-  CHECK(requested(3.0, {}, infinity) == infinity);
-  CHECK(requested(3.0, {1.0}, infinity) == infinity);
-  CHECK(requested(3.0, {3.0}, infinity) == infinity);
-  CHECK(requested(3.0, {5.0}, infinity) == 2.0);
-  {
-    const double request = requested(3.0, {5.0}, 1.0);
-    CHECK(request > 1.0);
-    CHECK(request < 2.0);
-  }
-  {
-    const double request = requested(3.0, {5.0}, 1.9375);
-    CHECK(request > 1.0);
-    CHECK(request < 1.9375);
+  const auto result = impl(now, 1.0, times);
+  alg::for_each(times, [](double& x) { return x = -x; });
+  const auto backwards_result = impl(-now, -1.0, times);
+  CHECK(backwards_result.has_value() == result.has_value());
+  if (result.has_value()) {
+    CHECK(backwards_result ==
+          std::optional(std::pair(-result->first, -result->second)));
   }
-  {
-    const double request = requested(3.0, {5.0}, 1.0625);
-    CHECK(request > 1.0);
-    CHECK(request < 2.0);
+
+  CHECK(result.has_value() == expected_end.has_value());
+  if (expected_end.has_value()) {
+    CHECK(result == std::optional(std::pair(
+                        *expected_end, 2.0 / 3.0 * (*expected_end - now))));
   }
+}
+}  // namespace
+
+SPECTRE_TEST_CASE("Unit.Time.StepChoosers.StepToTimes", "[Unit][Time]") {
+  register_factory_classes_with_charm<Metavariables>();
 
-  const auto one_five_check = [&requested](const std::vector<double>& times) {
-    CHECK(requested(0.0, times, infinity) == 1.0);
-    CHECK(requested(1.0, times, infinity) == 4.0);
-    CHECK(requested(2.0, times, infinity) == 3.0);
-    CHECK(requested(5.0, times, infinity) == infinity);
-    CHECK(requested(7.0, times, infinity) == infinity);
+  check_case(3.0, {}, {});
+  check_case(3.0, {1.0}, {});
+  check_case(3.0, {3.0}, {});
+  check_case(3.0, {5.0}, {5.0});
+
+  const auto one_five_check = [](const std::vector<double>& times) {
+    check_case(0.0, times, {1.0});
+    check_case(1.0, times, {5.0});
+    check_case(2.0, times, {5.0});
+    check_case(5.0, times, {});
+    check_case(7.0, times, {});
   };
 
   one_five_check({1.0, 5.0});
   one_five_check({5.0, 1.0});
   one_five_check({1.0, 5.0, 1.0, 5.0, 1.0, 5.0});
 
-  const auto check_rounding = [&requested](const double start,
-                                           const double step) {
+  const auto check_rounding = [](const double start, const double step) {
     CAPTURE(start);
     CAPTURE(step);
-    auto scaled_approx = Approx::custom().scale(std::abs(start));
-    CHECK(requested(std::nextafter(start, +infinity), {start, start + step},
-                    infinity) == scaled_approx(step));
-    CHECK(requested(std::nextafter(start, -infinity), {start, start + step},
-                    infinity) == scaled_approx(step));
+    static constexpr double infinity = std::numeric_limits<double>::infinity();
+    check_case(std::nextafter(start, -infinity), {start, start + step},
+               {start});
+    check_case(start, {start, start + step}, {start + step});
+    check_case(std::nextafter(start, +infinity), {start, start + step},
+               {start + step});
   };
 
   check_rounding(0.0, 1.0);

From 884f7c52877484713a3d519ad169c7c3b23969c8 Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Mon, 13 May 2024 20:14:05 -0400
Subject: [PATCH 12/16] Remove roundoff-handling from Times trigger

StepToTimes no longer has roundoff problems.
---
 src/Time/Triggers/Times.hpp             | 17 +++-------
 tests/Unit/Time/Triggers/Test_Times.cpp | 45 +++++--------------------
 2 files changed, 13 insertions(+), 49 deletions(-)

diff --git a/src/Time/Triggers/Times.hpp b/src/Time/Triggers/Times.hpp
index 036b510132e5..a1c441ecc294 100644
--- a/src/Time/Triggers/Times.hpp
+++ b/src/Time/Triggers/Times.hpp
@@ -3,8 +3,8 @@
 
 #pragma once
 
-#include <cmath>
 #include <memory>
+#include <optional>
 #include <pup.h>
 #include <pup_stl.h>
 #include <utility>
@@ -13,15 +13,12 @@
 #include "Options/String.hpp"
 #include "ParallelAlgorithms/EventsAndTriggers/Trigger.hpp"
 #include "Time/TimeSequence.hpp"
-#include "Time/TimeStepId.hpp"
-#include "Time/Utilities.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
 
 /// \cond
 namespace Tags {
 struct Time;
-struct TimeStepId;
 }  // namespace Tags
 /// \endcond
 
@@ -47,16 +44,10 @@ class Times : public Trigger {
   explicit Times(std::unique_ptr<TimeSequence<double>> times)
       : times_(std::move(times)) {}
 
-  using argument_tags = tmpl::list<Tags::Time, Tags::TimeStepId>;
+  using argument_tags = tmpl::list<Tags::Time>;
 
-  bool operator()(const double now, const TimeStepId& time_id) const {
-    const auto& step_time = time_id.step_time();
-    // Trying to step to a given time might not get us exactly there
-    // because of rounding errors.
-    const double sloppiness = slab_rounding_error(step_time);
-
-    const auto nearby_time = times_->times_near(now)[1];
-    return nearby_time and std::abs(*nearby_time - now) < sloppiness;
+  bool operator()(const double now) const {
+    return times_->times_near(now)[1] == std::optional(now);
   }
 
   // NOLINTNEXTLINE(google-runtime-references)
diff --git a/tests/Unit/Time/Triggers/Test_Times.cpp b/tests/Unit/Time/Triggers/Test_Times.cpp
index 40b20d98c0c7..9223ad629fdd 100644
--- a/tests/Unit/Time/Triggers/Test_Times.cpp
+++ b/tests/Unit/Time/Triggers/Test_Times.cpp
@@ -3,12 +3,7 @@
 
 #include "Framework/TestingFramework.hpp"
 
-#include <cmath>
-#include <initializer_list>
-#include <limits>
 #include <memory>
-#include <pup.h>
-#include <pup_stl.h>
 #include <vector>
 
 #include "DataStructures/DataBox/DataBox.hpp"
@@ -17,11 +12,8 @@
 #include "Options/Protocols/FactoryCreation.hpp"
 #include "Parallel/Tags/Metavariables.hpp"
 #include "ParallelAlgorithms/EventsAndTriggers/Trigger.hpp"
-#include "Time/Slab.hpp"
 #include "Time/Tags/Time.hpp"
-#include "Time/Tags/TimeStepId.hpp"
 #include "Time/TimeSequence.hpp"
-#include "Time/TimeStepId.hpp"
 #include "Time/Triggers/Times.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
@@ -43,46 +35,27 @@ struct Metavariables {
 SPECTRE_TEST_CASE("Unit.Time.Triggers.Times", "[Unit][Time]") {
   register_factory_classes_with_charm<Metavariables>();
 
-  const auto check = [](const double time, const double slab_size,
+  const auto check = [](const double time,
                         const std::vector<double>& trigger_times,
                         const bool expected) {
     CAPTURE(time);
-    CAPTURE(slab_size);
     CAPTURE(trigger_times);
-    const auto slab = Slab::with_duration_from_start(0.8 * time, slab_size);
-    // None of the arguments here should matter, except that they are
-    // based on the correct slab.
-    const TimeStepId time_id(false, 12, slab.start() + slab.duration() / 13);
-
     const std::unique_ptr<Trigger> trigger = std::make_unique<Triggers::Times>(
         std::make_unique<TimeSequences::Specified<double>>(trigger_times));
     const auto sent_trigger = serialize_and_deserialize(trigger);
 
-    const auto box = db::create<
-        db::AddSimpleTags<Parallel::Tags::MetavariablesImpl<Metavariables>,
-                          Tags::TimeStepId, Tags::Time>>(
-        Metavariables{}, time_id, time);
+    const auto box = db::create<db::AddSimpleTags<
+        Parallel::Tags::MetavariablesImpl<Metavariables>, Tags::Time>>(
+        Metavariables{}, time);
     CHECK(trigger->is_triggered(box) == expected);
     CHECK(sent_trigger->is_triggered(box) == expected);
   };
 
-  static constexpr double infinity = std::numeric_limits<double>::infinity();
-
-  check(1.0, 1.0, {}, false);
-  check(1.0, 1.0, {1.0}, true);
-  check(1.0, 1.0, {2.0}, false);
-  check(1.0, 1.0, {0.0, 1.0, 2.0}, true);
-  check(1.0, 1.0, {2.0, 1.0, 0.0}, true);
-  check(std::nextafter(1.0, +infinity), 1.0, {0.0, 1.0, 2.0}, true);
-  check(std::nextafter(1.0, -infinity), 1.0, {0.0, 1.0, 2.0}, true);
-
-  check(1.0e5, 1.0, {1.0e5}, true);
-  check(std::nextafter(1.0e5, +infinity), 1.0, {1.0e5}, true);
-  check(std::nextafter(1.0e5, -infinity), 1.0, {1.0e5}, true);
-
-  const double inaccurate_1 = 1.0 + 1.0e5 - std::nextafter(1.0e5, -infinity);
-  check(inaccurate_1, 1.0, {1.0}, false);
-  check(inaccurate_1, 1.0e5, {1.0}, true);
+  check(1.0, {}, false);
+  check(1.0, {1.0}, true);
+  check(1.0, {2.0}, false);
+  check(1.0, {0.0, 1.0, 2.0}, true);
+  check(1.0, {2.0, 1.0, 0.0}, true);
 
   TestHelpers::test_creation<std::unique_ptr<Trigger>, Metavariables>(
       "Times:\n"

From f31b0cbd896d3695cd85fa3a1626488c7b78847b Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Tue, 30 Apr 2024 18:10:08 -0400
Subject: [PATCH 13/16] Rename Increase to LimitIncrease, only limit step

Much more common operation than an unconditional size increase.
---
 .../Cce/CharacteristicExtractBase.hpp         |  4 +--
 .../EvolveGhBinaryBlackHole.hpp               |  5 ----
 .../GeneralizedHarmonicBase.hpp               |  5 ----
 .../GhValenciaDivCleanBase.hpp                |  5 ----
 .../ScalarTensor/ScalarTensorBase.hpp         |  5 ----
 src/Time/StepChoosers/CMakeLists.txt          |  2 +-
 src/Time/StepChoosers/Factory.hpp             |  4 +--
 .../{Increase.hpp => LimitIncrease.hpp}       | 21 +++++++-------
 support/Pipelines/Bbh/Inspiral.yaml           |  2 +-
 support/Pipelines/Bbh/Ringdown.yaml           |  2 +-
 tests/InputFiles/Burgers/Step.yaml            |  2 +-
 .../Cce/AnalyticTestBouncingBlackHole.yaml    |  2 +-
 .../InputFiles/Cce/AnalyticTestGaugeWave.yaml |  2 +-
 .../Cce/AnalyticTestLinearizedBondiSachs.yaml |  2 +-
 .../Cce/AnalyticTestRobinsonTrautman.yaml     |  2 +-
 .../AnalyticTestRotatingSchwarzschild.yaml    |  2 +-
 .../Cce/AnalyticTestTeukolskyWave.yaml        |  2 +-
 .../InputFiles/Cce/CharacteristicExtract.yaml |  2 +-
 .../PlaneWaveMinkowski1D.yaml                 |  2 +-
 .../PlaneWaveMinkowski2D.yaml                 |  2 +-
 .../PlaneWaveMinkowski3D.yaml                 |  2 +-
 .../CylindricalBinaryBlackHole.yaml           |  2 +-
 .../GeneralizedHarmonic/KerrSchild.yaml       |  2 +-
 .../GhValenciaDivClean/GhMhdBondiMichel.yaml  |  2 +-
 .../GhValenciaDivClean/GhMhdTovStar.yaml      |  2 +-
 .../FishboneMoncriefDisk.yaml                 |  4 +--
 .../NewtonianEuler/RiemannProblem1D.yaml      |  2 +-
 .../KerrSchildSphericalHarmonic.yaml          |  2 +-
 tests/InputFiles/ScalarWave/PlaneWave3D.yaml  |  2 +-
 .../Initialization/Test_Evolution.cpp         |  4 +--
 tests/Unit/Time/StepChoosers/CMakeLists.txt   |  2 +-
 .../Time/StepChoosers/Test_ErrorControl.cpp   | 18 ++++++------
 ...st_Increase.cpp => Test_LimitIncrease.cpp} | 29 ++++++++++---------
 tests/Unit/Time/Test_TakeStep.cpp             | 16 +++++-----
 34 files changed, 74 insertions(+), 90 deletions(-)
 rename src/Time/StepChoosers/{Increase.hpp => LimitIncrease.hpp} (64%)
 rename tests/Unit/Time/StepChoosers/{Test_Increase.cpp => Test_LimitIncrease.cpp} (73%)

diff --git a/src/Evolution/Executables/Cce/CharacteristicExtractBase.hpp b/src/Evolution/Executables/Cce/CharacteristicExtractBase.hpp
index 449c2c06b95a..d67f929f4dba 100644
--- a/src/Evolution/Executables/Cce/CharacteristicExtractBase.hpp
+++ b/src/Evolution/Executables/Cce/CharacteristicExtractBase.hpp
@@ -14,7 +14,7 @@
 #include "NumericalAlgorithms/SpinWeightedSphericalHarmonics/SwshTags.hpp"
 #include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/ErrorControl.hpp"
-#include "Time/StepChoosers/Increase.hpp"
+#include "Time/StepChoosers/LimitIncrease.hpp"
 #include "Utilities/TMPL.hpp"
 
 template <bool EvolveCcm>
@@ -112,7 +112,7 @@ struct CharacteristicExtractDefaults {
                           tmpl::list<Cce::Tags::CauchyAngularCoords>>;
   using cce_step_choosers =
       tmpl::list<StepChoosers::Constant<StepChooserUse::LtsStep>,
-                 StepChoosers::Increase<StepChooserUse::LtsStep>,
+                 StepChoosers::LimitIncrease<StepChooserUse::LtsStep>,
                  StepChoosers::ErrorControl<StepChooserUse::LtsStep,
                                             Tags::Variables<evolved_swsh_tags>,
                                             swsh_vars_selector>,
diff --git a/src/Evolution/Executables/GeneralizedHarmonic/EvolveGhBinaryBlackHole.hpp b/src/Evolution/Executables/GeneralizedHarmonic/EvolveGhBinaryBlackHole.hpp
index d81df2741b05..2d7de8172ef3 100644
--- a/src/Evolution/Executables/GeneralizedHarmonic/EvolveGhBinaryBlackHole.hpp
+++ b/src/Evolution/Executables/GeneralizedHarmonic/EvolveGhBinaryBlackHole.hpp
@@ -164,13 +164,8 @@
 #include "Time/Actions/UpdateU.hpp"
 #include "Time/ChangeSlabSize/Action.hpp"
 #include "Time/ChangeSlabSize/Tags.hpp"
-#include "Time/StepChoosers/Cfl.hpp"
-#include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/Factory.hpp"
-#include "Time/StepChoosers/Increase.hpp"
-#include "Time/StepChoosers/PreventRapidIncrease.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
-#include "Time/StepChoosers/StepToTimes.hpp"
 #include "Time/Tags/StepperErrors.hpp"
 #include "Time/Tags/Time.hpp"
 #include "Time/Tags/TimeStepId.hpp"
diff --git a/src/Evolution/Executables/GeneralizedHarmonic/GeneralizedHarmonicBase.hpp b/src/Evolution/Executables/GeneralizedHarmonic/GeneralizedHarmonicBase.hpp
index 9e94f95d22a2..64ea0abcdd6c 100644
--- a/src/Evolution/Executables/GeneralizedHarmonic/GeneralizedHarmonicBase.hpp
+++ b/src/Evolution/Executables/GeneralizedHarmonic/GeneralizedHarmonicBase.hpp
@@ -131,13 +131,8 @@
 #include "Time/Actions/RecordTimeStepperData.hpp"
 #include "Time/Actions/SelfStartActions.hpp"
 #include "Time/Actions/UpdateU.hpp"
-#include "Time/StepChoosers/Cfl.hpp"
-#include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/Factory.hpp"
-#include "Time/StepChoosers/Increase.hpp"
-#include "Time/StepChoosers/PreventRapidIncrease.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
-#include "Time/StepChoosers/StepToTimes.hpp"
 #include "Time/Tags/Time.hpp"
 #include "Time/TimeSequence.hpp"
 #include "Time/TimeSteppers/Factory.hpp"
diff --git a/src/Evolution/Executables/GrMhd/GhValenciaDivClean/GhValenciaDivCleanBase.hpp b/src/Evolution/Executables/GrMhd/GhValenciaDivClean/GhValenciaDivCleanBase.hpp
index 9046d648334c..bae017435b34 100644
--- a/src/Evolution/Executables/GrMhd/GhValenciaDivClean/GhValenciaDivCleanBase.hpp
+++ b/src/Evolution/Executables/GrMhd/GhValenciaDivClean/GhValenciaDivCleanBase.hpp
@@ -221,13 +221,8 @@
 #include "Time/Actions/SelfStartActions.hpp"  // IWYU pragma: keep
 #include "Time/Actions/UpdateU.hpp"
 #include "Time/ChangeSlabSize/Action.hpp"
-#include "Time/StepChoosers/Cfl.hpp"
-#include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/Factory.hpp"
-#include "Time/StepChoosers/Increase.hpp"
-#include "Time/StepChoosers/PreventRapidIncrease.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
-#include "Time/StepChoosers/StepToTimes.hpp"
 #include "Time/Tags/Time.hpp"
 #include "Time/Tags/TimeStepId.hpp"
 #include "Time/TimeSequence.hpp"
diff --git a/src/Evolution/Executables/ScalarTensor/ScalarTensorBase.hpp b/src/Evolution/Executables/ScalarTensor/ScalarTensorBase.hpp
index 3e6b48e2e583..a1ffec5b349d 100644
--- a/src/Evolution/Executables/ScalarTensor/ScalarTensorBase.hpp
+++ b/src/Evolution/Executables/ScalarTensor/ScalarTensorBase.hpp
@@ -132,13 +132,8 @@
 #include "Time/Actions/RecordTimeStepperData.hpp"
 #include "Time/Actions/SelfStartActions.hpp"
 #include "Time/Actions/UpdateU.hpp"
-#include "Time/StepChoosers/Cfl.hpp"
-#include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/Factory.hpp"
-#include "Time/StepChoosers/Increase.hpp"
-#include "Time/StepChoosers/PreventRapidIncrease.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
-#include "Time/StepChoosers/StepToTimes.hpp"
 #include "Time/Tags/Time.hpp"
 #include "Time/TimeSequence.hpp"
 #include "Time/TimeSteppers/Factory.hpp"
diff --git a/src/Time/StepChoosers/CMakeLists.txt b/src/Time/StepChoosers/CMakeLists.txt
index 14281b061449..1a0a3209777e 100644
--- a/src/Time/StepChoosers/CMakeLists.txt
+++ b/src/Time/StepChoosers/CMakeLists.txt
@@ -19,7 +19,7 @@ spectre_target_headers(
   ElementSizeCfl.hpp
   ErrorControl.hpp
   Factory.hpp
-  Increase.hpp
+  LimitIncrease.hpp
   PreventRapidIncrease.hpp
   Random.hpp
   StepChooser.hpp
diff --git a/src/Time/StepChoosers/Factory.hpp b/src/Time/StepChoosers/Factory.hpp
index ac5edcf1f314..5ec9fc32556b 100644
--- a/src/Time/StepChoosers/Factory.hpp
+++ b/src/Time/StepChoosers/Factory.hpp
@@ -9,7 +9,7 @@
 #include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/ElementSizeCfl.hpp"
 #include "Time/StepChoosers/ErrorControl.hpp"
-#include "Time/StepChoosers/Increase.hpp"
+#include "Time/StepChoosers/LimitIncrease.hpp"
 #include "Time/StepChoosers/PreventRapidIncrease.hpp"
 #include "Time/StepChoosers/StepToTimes.hpp"
 #include "Utilities/TMPL.hpp"
@@ -30,7 +30,7 @@ using common_step_choosers = tmpl::push_back<
             StepChoosers::Cfl<Use, Frame::Inertial, System>,
             StepChoosers::ElementSizeCfl<Use, System::volume_dim, System>>,
         tmpl::list<>>,
-    StepChoosers::Constant<Use>, StepChoosers::Increase<Use>>;
+    StepChoosers::Constant<Use>, StepChoosers::LimitIncrease<Use>>;
 template <typename Use, typename System>
 using step_choosers_for_step_only =
     tmpl::list<StepChoosers::PreventRapidIncrease<Use>,
diff --git a/src/Time/StepChoosers/Increase.hpp b/src/Time/StepChoosers/LimitIncrease.hpp
similarity index 64%
rename from src/Time/StepChoosers/Increase.hpp
rename to src/Time/StepChoosers/LimitIncrease.hpp
index e3af7cb95d17..8c7776f77ea7 100644
--- a/src/Time/StepChoosers/Increase.hpp
+++ b/src/Time/StepChoosers/LimitIncrease.hpp
@@ -15,32 +15,33 @@
 #include "Utilities/TMPL.hpp"
 
 namespace StepChoosers {
-/// Suggests increasing the step size by a constant ratio.
+/// Limits step increase to a constant ratio.
 template <typename StepChooserUse>
-class Increase : public StepChooser<StepChooserUse> {
+class LimitIncrease : public StepChooser<StepChooserUse> {
  public:
   /// \cond
-  Increase() = default;
-  explicit Increase(CkMigrateMessage* /*unused*/) {}
+  LimitIncrease() = default;
+  explicit LimitIncrease(CkMigrateMessage* /*unused*/) {}
   using PUP::able::register_constructor;
-  WRAPPED_PUPable_decl_template(Increase);  // NOLINT
+  WRAPPED_PUPable_decl_template(LimitIncrease);  // NOLINT
   /// \endcond
 
   struct Factor {
     using type = double;
-    static constexpr Options::String help{"Factor to increase by"};
+    static constexpr Options::String help{"Factor to allow increase by"};
     static type lower_bound() { return 1.0; }
   };
 
-  static constexpr Options::String help{"Suggests a constant factor increase."};
+  static constexpr Options::String help{
+      "Limits step increase to a constant ratio."};
   using options = tmpl::list<Factor>;
 
-  explicit Increase(const double factor) : factor_(factor) {}
+  explicit LimitIncrease(const double factor) : factor_(factor) {}
 
   using argument_tags = tmpl::list<>;
 
   std::pair<TimeStepRequest, bool> operator()(const double last_step) const {
-    return {{.size_goal = last_step * factor_}, true};
+    return {{.size = last_step * factor_}, true};
   }
 
   bool uses_local_data() const override { return false; }
@@ -55,6 +56,6 @@ class Increase : public StepChooser<StepChooserUse> {
 
 /// \cond
 template <typename StepChooserUse>
-PUP::able::PUP_ID Increase<StepChooserUse>::my_PUP_ID = 0;  // NOLINT
+PUP::able::PUP_ID LimitIncrease<StepChooserUse>::my_PUP_ID = 0;  // NOLINT
 /// \endcond
 }  // namespace StepChoosers
diff --git a/support/Pipelines/Bbh/Inspiral.yaml b/support/Pipelines/Bbh/Inspiral.yaml
index 594e0b1d1135..03fa9ccff898 100644
--- a/support/Pipelines/Bbh/Inspiral.yaml
+++ b/support/Pipelines/Bbh/Inspiral.yaml
@@ -141,7 +141,7 @@ Evolution:
   # intervals in the EventsAndTriggers
   InitialSlabSize: 0.5
   StepChoosers:
-    - Increase:
+    - LimitIncrease:
         Factor: 2
     - ElementSizeCfl:
         SafetyFactor: 0.5
diff --git a/support/Pipelines/Bbh/Ringdown.yaml b/support/Pipelines/Bbh/Ringdown.yaml
index b9e2d66dab76..802f19423049 100644
--- a/support/Pipelines/Bbh/Ringdown.yaml
+++ b/support/Pipelines/Bbh/Ringdown.yaml
@@ -50,7 +50,7 @@ Evolution:
   # you would like more frequent output, consider using dense output.
   InitialSlabSize: 0.1
   StepChoosers:
-    - Increase:
+    - LimitIncrease:
         Factor: 2
     - ElementSizeCfl:
         SafetyFactor: 0.5
diff --git a/tests/InputFiles/Burgers/Step.yaml b/tests/InputFiles/Burgers/Step.yaml
index 0da1221adf87..6e9d1b03b482 100644
--- a/tests/InputFiles/Burgers/Step.yaml
+++ b/tests/InputFiles/Burgers/Step.yaml
@@ -89,7 +89,7 @@ EventsAndTriggers:
           StepChoosers:
             - Cfl:
                 SafetyFactor: 0.5
-            - Increase:
+            - LimitIncrease:
                 Factor: 2.0
 
 EventsAndDenseTriggers:
diff --git a/tests/InputFiles/Cce/AnalyticTestBouncingBlackHole.yaml b/tests/InputFiles/Cce/AnalyticTestBouncingBlackHole.yaml
index 2e050a47ec61..9f924b57f8d3 100644
--- a/tests/InputFiles/Cce/AnalyticTestBouncingBlackHole.yaml
+++ b/tests/InputFiles/Cce/AnalyticTestBouncingBlackHole.yaml
@@ -53,7 +53,7 @@ Cce:
         Order: 3
     StepChoosers:
       - Constant: 0.1
-      - Increase:
+      - LimitIncrease:
           Factor: 2
 
   LMax: 8
diff --git a/tests/InputFiles/Cce/AnalyticTestGaugeWave.yaml b/tests/InputFiles/Cce/AnalyticTestGaugeWave.yaml
index 82b4f6b3d3f6..0a3887c34d3d 100644
--- a/tests/InputFiles/Cce/AnalyticTestGaugeWave.yaml
+++ b/tests/InputFiles/Cce/AnalyticTestGaugeWave.yaml
@@ -53,7 +53,7 @@ Cce:
         Order: 3
     StepChoosers:
       - Constant: 0.4
-      - Increase:
+      - LimitIncrease:
           Factor: 2
 
   LMax: 8
diff --git a/tests/InputFiles/Cce/AnalyticTestLinearizedBondiSachs.yaml b/tests/InputFiles/Cce/AnalyticTestLinearizedBondiSachs.yaml
index 5bc004657557..89d77c77a690 100644
--- a/tests/InputFiles/Cce/AnalyticTestLinearizedBondiSachs.yaml
+++ b/tests/InputFiles/Cce/AnalyticTestLinearizedBondiSachs.yaml
@@ -53,7 +53,7 @@ Cce:
         Order: 3
     StepChoosers:
       - Constant: 0.4
-      - Increase:
+      - LimitIncrease:
           Factor: 2
 
   LMax: 8
diff --git a/tests/InputFiles/Cce/AnalyticTestRobinsonTrautman.yaml b/tests/InputFiles/Cce/AnalyticTestRobinsonTrautman.yaml
index e115a90e7edf..cb06cb3d7327 100644
--- a/tests/InputFiles/Cce/AnalyticTestRobinsonTrautman.yaml
+++ b/tests/InputFiles/Cce/AnalyticTestRobinsonTrautman.yaml
@@ -53,7 +53,7 @@ Cce:
         Order: 3
     StepChoosers:
       - Constant: 0.1
-      - Increase:
+      - LimitIncrease:
           Factor: 2
 
   LMax: 10
diff --git a/tests/InputFiles/Cce/AnalyticTestRotatingSchwarzschild.yaml b/tests/InputFiles/Cce/AnalyticTestRotatingSchwarzschild.yaml
index 6900011df76d..9c1522ccc9eb 100644
--- a/tests/InputFiles/Cce/AnalyticTestRotatingSchwarzschild.yaml
+++ b/tests/InputFiles/Cce/AnalyticTestRotatingSchwarzschild.yaml
@@ -53,7 +53,7 @@ Cce:
         Order: 3
     StepChoosers:
       - Constant: 0.2
-      - Increase:
+      - LimitIncrease:
           Factor: 2
 
   LMax: 8
diff --git a/tests/InputFiles/Cce/AnalyticTestTeukolskyWave.yaml b/tests/InputFiles/Cce/AnalyticTestTeukolskyWave.yaml
index 0eb541d8c884..a87d4a97650f 100644
--- a/tests/InputFiles/Cce/AnalyticTestTeukolskyWave.yaml
+++ b/tests/InputFiles/Cce/AnalyticTestTeukolskyWave.yaml
@@ -53,7 +53,7 @@ Cce:
         Order: 3
     StepChoosers:
       - Constant: 0.5
-      - Increase:
+      - LimitIncrease:
           Factor: 2
 
   LMax: 8
diff --git a/tests/InputFiles/Cce/CharacteristicExtract.yaml b/tests/InputFiles/Cce/CharacteristicExtract.yaml
index f2c7c1064dce..8f61454fdb50 100644
--- a/tests/InputFiles/Cce/CharacteristicExtract.yaml
+++ b/tests/InputFiles/Cce/CharacteristicExtract.yaml
@@ -52,7 +52,7 @@ Cce:
         Order: 3 # Going to higher order doesn't seem necessary for CCE
     StepChoosers:
       - Constant: 0.1 # Don't take steps bigger than 0.1M
-      - Increase:
+      - LimitIncrease:
           Factor: 2
       - ErrorControl(SwshVars):
           AbsoluteTolerance: 1e-8
diff --git a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml
index 0a69317103a3..1671bb6904fd 100644
--- a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml
+++ b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml
@@ -37,7 +37,7 @@ Evolution:
       Order: 3
   StepChoosers:
     - Constant: 0.05
-    - Increase:
+    - LimitIncrease:
         Factor: 2
     - Cfl:
         SafetyFactor: 0.2
diff --git a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml
index 790d8eea53e8..d510ce9b71ed 100644
--- a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml
+++ b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml
@@ -37,7 +37,7 @@ Evolution:
       Order: 3
   StepChoosers:
     - Constant: 0.05
-    - Increase:
+    - LimitIncrease:
         Factor: 2
     - Cfl:
         SafetyFactor: 0.2
diff --git a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml
index 941a483abba9..498053025959 100644
--- a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml
+++ b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml
@@ -52,7 +52,7 @@ Evolution:
       Order: 3
   StepChoosers:
     - Constant: 0.05
-    - Increase:
+    - LimitIncrease:
         Factor: 2
     - Cfl:
         SafetyFactor: 0.2
diff --git a/tests/InputFiles/GeneralizedHarmonic/CylindricalBinaryBlackHole.yaml b/tests/InputFiles/GeneralizedHarmonic/CylindricalBinaryBlackHole.yaml
index bc814a43243b..7953a8fc7c55 100644
--- a/tests/InputFiles/GeneralizedHarmonic/CylindricalBinaryBlackHole.yaml
+++ b/tests/InputFiles/GeneralizedHarmonic/CylindricalBinaryBlackHole.yaml
@@ -20,7 +20,7 @@ Evolution:
   InitialTimeStep: 0.0002
   InitialSlabSize: 0.25
   StepChoosers:
-    - Increase:
+    - LimitIncrease:
         Factor: 2
     - ElementSizeCfl:
         SafetyFactor: 0.5
diff --git a/tests/InputFiles/GeneralizedHarmonic/KerrSchild.yaml b/tests/InputFiles/GeneralizedHarmonic/KerrSchild.yaml
index 46b128c7f7dc..308928ed220b 100644
--- a/tests/InputFiles/GeneralizedHarmonic/KerrSchild.yaml
+++ b/tests/InputFiles/GeneralizedHarmonic/KerrSchild.yaml
@@ -33,7 +33,7 @@ Evolution:
   # like more frequent output, consider using dense output.
   InitialSlabSize: 0.001
   StepChoosers:
-    - Increase:
+    - LimitIncrease:
         Factor: 2
     - ElementSizeCfl:
         SafetyFactor: 0.5
diff --git a/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdBondiMichel.yaml b/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdBondiMichel.yaml
index a56e7e576b4f..fda569560ed6 100644
--- a/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdBondiMichel.yaml
+++ b/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdBondiMichel.yaml
@@ -147,7 +147,7 @@ EventsAndTriggers:
           StepChoosers:
             - Cfl:
                 SafetyFactor: 0.6
-            - Increase:
+            - LimitIncrease:
                 Factor: 1.5
   - Trigger:
       Slabs:
diff --git a/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdTovStar.yaml b/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdTovStar.yaml
index bd4ccbbd7017..aae253daed48 100644
--- a/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdTovStar.yaml
+++ b/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdTovStar.yaml
@@ -181,7 +181,7 @@ EventsAndTriggers:
           StepChoosers:
             - Cfl:
                 SafetyFactor: 0.6
-            - Increase:
+            - LimitIncrease:
                 Factor: 1.5
   - Trigger:
       Slabs:
diff --git a/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml b/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml
index c626ca5e5bfd..12a92b5e457a 100644
--- a/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml
+++ b/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml
@@ -28,7 +28,7 @@ Evolution:
   # StepChoosers are needed only for local time stepping
   # StepChoosers:
   #   - Constant: 0.05
-  #   - Increase:
+  #   - LimitIncrease:
   #       Factor: 2
   #   - Cfl:
   #       SafetyFactor: 0.2
@@ -158,7 +158,7 @@ EventsAndTriggers:
           DelayChange: 0
           StepChoosers:
             - Constant: 0.05
-            - Increase:
+            - LimitIncrease:
                 Factor: 2
             - Cfl:
                 SafetyFactor: 0.2
diff --git a/tests/InputFiles/NewtonianEuler/RiemannProblem1D.yaml b/tests/InputFiles/NewtonianEuler/RiemannProblem1D.yaml
index 5e30b6f8e6df..0f4d8447b2ab 100644
--- a/tests/InputFiles/NewtonianEuler/RiemannProblem1D.yaml
+++ b/tests/InputFiles/NewtonianEuler/RiemannProblem1D.yaml
@@ -124,7 +124,7 @@ EventsAndTriggers:
       - ChangeSlabSize:
           DelayChange: 0
           StepChoosers:
-            - Increase:
+            - LimitIncrease:
                 Factor: 2.0
             - PreventRapidIncrease
 
diff --git a/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml b/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml
index 7d083d2c1790..47b0cbfdf99b 100644
--- a/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml
+++ b/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml
@@ -33,7 +33,7 @@ Evolution:
   InitialSlabSize: 0.001
   StepChoosers:
     - Constant: 0.01
-    - Increase:
+    - LimitIncrease:
         Factor: 2
     - Cfl:
         SafetyFactor: 0.2
diff --git a/tests/InputFiles/ScalarWave/PlaneWave3D.yaml b/tests/InputFiles/ScalarWave/PlaneWave3D.yaml
index 0c5d4141a5e1..e9721696e6e6 100644
--- a/tests/InputFiles/ScalarWave/PlaneWave3D.yaml
+++ b/tests/InputFiles/ScalarWave/PlaneWave3D.yaml
@@ -82,7 +82,7 @@ EventsAndTriggers:
       - ChangeSlabSize:
           DelayChange: 0
           StepChoosers:
-            - Increase:
+            - LimitIncrease:
                 Factor: 1.1
             - StepToTimes:
                 Times:
diff --git a/tests/Unit/Evolution/Initialization/Test_Evolution.cpp b/tests/Unit/Evolution/Initialization/Test_Evolution.cpp
index 57b4f7e8b366..3b0a4a8ed493 100644
--- a/tests/Unit/Evolution/Initialization/Test_Evolution.cpp
+++ b/tests/Unit/Evolution/Initialization/Test_Evolution.cpp
@@ -30,7 +30,7 @@
 #include "Time/ChangeSlabSize/Tags.hpp"
 #include "Time/ChooseLtsStepSize.hpp"
 #include "Time/Slab.hpp"
-#include "Time/StepChoosers/Increase.hpp"
+#include "Time/StepChoosers/LimitIncrease.hpp"
 #include "Time/Tags/AdaptiveSteppingDiagnostics.hpp"
 #include "Time/Tags/Time.hpp"
 #include "Time/Tags/TimeStep.hpp"
@@ -52,7 +52,7 @@ struct TestMetavariables {
       : tt::ConformsTo<Options::protocols::FactoryCreation> {
     using factory_classes = tmpl::map<tmpl::pair<
         StepChooser<StepChooserUse::LtsStep>,
-        tmpl::list<StepChoosers::Increase<StepChooserUse::LtsStep>>>>;
+        tmpl::list<StepChoosers::LimitIncrease<StepChooserUse::LtsStep>>>>;
   };
   using component_list = tmpl::list<>;
   using const_global_cache_tags =
diff --git a/tests/Unit/Time/StepChoosers/CMakeLists.txt b/tests/Unit/Time/StepChoosers/CMakeLists.txt
index 355cbc8cbec4..e82a13d169b3 100644
--- a/tests/Unit/Time/StepChoosers/CMakeLists.txt
+++ b/tests/Unit/Time/StepChoosers/CMakeLists.txt
@@ -8,7 +8,7 @@ set(LIBRARY_SOURCES
   StepChoosers/Test_Constant.cpp
   StepChoosers/Test_ElementSizeCfl.cpp
   StepChoosers/Test_ErrorControl.cpp
-  StepChoosers/Test_Increase.cpp
+  StepChoosers/Test_LimitIncrease.cpp
   StepChoosers/Test_PreventRapidIncrease.cpp
   StepChoosers/Test_Random.cpp
   StepChoosers/Test_StepToTimes.cpp
diff --git a/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp b/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp
index 772c56427bbe..677c6a9d5551 100644
--- a/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp
@@ -30,7 +30,7 @@
 #include "Time/Slab.hpp"
 #include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/ErrorControl.hpp"
-#include "Time/StepChoosers/Increase.hpp"
+#include "Time/StepChoosers/LimitIncrease.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/StepperErrorEstimate.hpp"
 #include "Time/StepperErrorTolerances.hpp"
@@ -75,7 +75,7 @@ template <bool WithErrorControl, bool WithAltErrorControl = false>
 struct Metavariables {
   template <typename Use>
   using step_choosers_without_error_control =
-      tmpl::list<StepChoosers::Increase<Use>, StepChoosers::Constant<Use>>;
+      tmpl::list<StepChoosers::LimitIncrease<Use>, StepChoosers::Constant<Use>>;
   template <typename Use>
   using step_choosers = tmpl::append<
       step_choosers_without_error_control<Use>,
@@ -275,7 +275,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
                   "    RelativeTolerance: 1.0e-4\n"
                   "    MaxFactor: 2.1\n"
                   "    MinFactor: 0.5\n"
-                  "- Increase:\n"
+                  "- LimitIncrease:\n"
                   "    Factor: 2\n"
                   "- Constant: 0.5");
         },
@@ -291,7 +291,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
           *choosers =
               TestHelpers::test_creation<typename Tags::StepChoosers::type,
                                          Metavariables<true, true>>(
-                  "- Increase:\n"
+                  "- LimitIncrease:\n"
                   "    Factor: 2\n"
                   "- Constant: 0.5");
         },
@@ -332,7 +332,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
                   "    RelativeTolerance: 1.0e-4\n"
                   "    MaxFactor: 1.1\n"
                   "    MinFactor: 0.1\n"
-                  "- Increase:\n"
+                  "- LimitIncrease:\n"
                   "    Factor: 2\n"
                   "- Constant: 0.5");
         },
@@ -360,7 +360,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
                   "    RelativeTolerance: 1.0e-8\n"
                   "    MaxFactor: 1.1\n"
                   "    MinFactor: 0.1\n"
-                  "- Increase:\n"
+                  "- LimitIncrease:\n"
                   "    Factor: 2\n"
                   "- Constant: 0.5");
         },
@@ -388,7 +388,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
                   "    RelativeTolerance: 1.0e-8\n"
                   "    MaxFactor: 1.1\n"
                   "    MinFactor: 0.1\n"
-                  "- Increase:\n"
+                  "- LimitIncrease:\n"
                   "    Factor: 2\n"
                   "- Constant: 0.5");
         },
@@ -423,7 +423,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
               "    - ChangeSlabSize:\n"
               "        DelayChange: 0\n"
               "        StepChoosers:\n"
-              "          - Increase:\n"
+              "          - LimitIncrease:\n"
               "              Factor: 2\n"
               "          - ErrorControl:\n"
               "              SafetyFactor: 0.95\n"
@@ -453,7 +453,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
               "    - ChangeSlabSize:\n"
               "        DelayChange: 0\n"
               "        StepChoosers:\n"
-              "          - Increase:\n"
+              "          - LimitIncrease:\n"
               "              Factor: 2\n"
               "          - Constant: 0.5");
         },
diff --git a/tests/Unit/Time/StepChoosers/Test_Increase.cpp b/tests/Unit/Time/StepChoosers/Test_LimitIncrease.cpp
similarity index 73%
rename from tests/Unit/Time/StepChoosers/Test_Increase.cpp
rename to tests/Unit/Time/StepChoosers/Test_LimitIncrease.cpp
index ca500dcb2fca..fdfbd5272abc 100644
--- a/tests/Unit/Time/StepChoosers/Test_Increase.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_LimitIncrease.cpp
@@ -12,7 +12,7 @@
 #include "Framework/TestHelpers.hpp"
 #include "Options/Protocols/FactoryCreation.hpp"
 #include "Parallel/Tags/Metavariables.hpp"
-#include "Time/StepChoosers/Increase.hpp"
+#include "Time/StepChoosers/LimitIncrease.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/TimeStepRequest.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
@@ -26,16 +26,18 @@ struct Metavariables {
   struct factory_creation
       : tt::ConformsTo<Options::protocols::FactoryCreation> {
     using factory_classes = tmpl::map<
-        tmpl::pair<StepChooser<StepChooserUse::LtsStep>,
-                   tmpl::list<StepChoosers::Increase<StepChooserUse::LtsStep>>>,
-        tmpl::pair<StepChooser<StepChooserUse::Slab>,
-                   tmpl::list<StepChoosers::Increase<StepChooserUse::Slab>>>>;
+        tmpl::pair<
+            StepChooser<StepChooserUse::LtsStep>,
+            tmpl::list<StepChoosers::LimitIncrease<StepChooserUse::LtsStep>>>,
+        tmpl::pair<
+            StepChooser<StepChooserUse::Slab>,
+            tmpl::list<StepChoosers::LimitIncrease<StepChooserUse::Slab>>>>;
   };
   using component_list = tmpl::list<>;
 };
 }  // namespace
 
-SPECTRE_TEST_CASE("Unit.Time.StepChoosers.Increase", "[Unit][Time]") {
+SPECTRE_TEST_CASE("Unit.Time.StepChoosers.LimitIncrease", "[Unit][Time]") {
   register_factory_classes_with_charm<Metavariables>();
 
   auto box = db::create<
@@ -44,12 +46,12 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.Increase", "[Unit][Time]") {
   const auto check = [&box](auto use, const double step,
                             const double expected_size) {
     using Use = tmpl::type_from<decltype(use)>;
-    const StepChoosers::Increase<Use> increase{5.};
+    const StepChoosers::LimitIncrease<Use> increase{5.};
     const std::unique_ptr<StepChooser<Use>> increase_base =
-        std::make_unique<StepChoosers::Increase<Use>>(increase);
+        std::make_unique<StepChoosers::LimitIncrease<Use>>(increase);
 
-    const std::pair<TimeStepRequest, bool> expected{
-        {.size_goal = expected_size}, true};
+    const std::pair<TimeStepRequest, bool> expected{{.size = expected_size},
+                                                    true};
     CHECK(increase(step) == expected);
     CHECK(serialize_and_deserialize(increase)(step) == expected);
     CHECK(increase_base->desired_step(step, box) == expected);
@@ -67,12 +69,13 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.Increase", "[Unit][Time]") {
 
   TestHelpers::test_creation<
       std::unique_ptr<StepChooser<StepChooserUse::LtsStep>>, Metavariables>(
-      "Increase:\n"
+      "LimitIncrease:\n"
       "  Factor: 5.0");
   TestHelpers::test_creation<std::unique_ptr<StepChooser<StepChooserUse::Slab>>,
                              Metavariables>(
-      "Increase:\n"
+      "LimitIncrease:\n"
       "  Factor: 5.0");
 
-  CHECK(not StepChoosers::Increase<StepChooserUse::Slab>{}.uses_local_data());
+  CHECK(not StepChoosers::LimitIncrease<StepChooserUse::Slab>{}
+                .uses_local_data());
 }
diff --git a/tests/Unit/Time/Test_TakeStep.cpp b/tests/Unit/Time/Test_TakeStep.cpp
index 5346107ab0d4..49904089235c 100644
--- a/tests/Unit/Time/Test_TakeStep.cpp
+++ b/tests/Unit/Time/Test_TakeStep.cpp
@@ -21,7 +21,7 @@
 #include "Time/ChooseLtsStepSize.hpp"
 #include "Time/Slab.hpp"
 #include "Time/StepChoosers/Cfl.hpp"
-#include "Time/StepChoosers/Increase.hpp"
+#include "Time/StepChoosers/LimitIncrease.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/StepperErrorTolerances.hpp"
 #include "Time/Tags/AdaptiveSteppingDiagnostics.hpp"
@@ -68,12 +68,11 @@ struct Metavariables {
 
   struct factory_creation
       : tt::ConformsTo<Options::protocols::FactoryCreation> {
-    using factory_classes = tmpl::map<
-        tmpl::pair<StepChooser<StepChooserUse::LtsStep>,
-                   tmpl::list<StepChoosers::Increase<StepChooserUse::LtsStep>,
-                              StepChoosers::Cfl<
-                                  StepChooserUse::LtsStep, Frame::Inertial,
-                                  typename Metavariables::system>>>>;
+    using factory_classes = tmpl::map<tmpl::pair<
+        StepChooser<StepChooserUse::LtsStep>,
+        tmpl::list<StepChoosers::LimitIncrease<StepChooserUse::LtsStep>,
+                   StepChoosers::Cfl<StepChooserUse::LtsStep, Frame::Inertial,
+                                     typename Metavariables::system>>>>;
   };
 
   using component_list = tmpl::list<>;
@@ -140,7 +139,8 @@ void test_lts() {
   std::vector<std::unique_ptr<StepChooser<StepChooserUse::LtsStep>>>
       step_choosers;
   step_choosers.emplace_back(
-      std::make_unique<StepChoosers::Increase<StepChooserUse::LtsStep>>(2.0));
+      std::make_unique<StepChoosers::LimitIncrease<StepChooserUse::LtsStep>>(
+          2.0));
   step_choosers.emplace_back(
       std::make_unique<
           StepChoosers::Cfl<StepChooserUse::LtsStep, Frame::Inertial,

From a6f47a739692130a7548c6f5adbb4815d67b1c1f Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Tue, 30 Apr 2024 17:17:23 -0400
Subject: [PATCH 14/16] Add Maximum StepChooser

Like Constant, but will not increase the step size if it is not being
changed for other reasons.

Most appearances of Constant in the examples were not useful, so
removed instead of kept or replaced.
---
 src/Time/StepChoosers/CMakeLists.txt          |  2 +
 src/Time/StepChoosers/Factory.hpp             |  4 +-
 src/Time/StepChoosers/Maximum.cpp             | 14 ++++
 src/Time/StepChoosers/Maximum.hpp             | 69 +++++++++++++++++++
 .../PlaneWaveMinkowski1D.yaml                 |  1 -
 .../PlaneWaveMinkowski2D.yaml                 |  1 -
 .../PlaneWaveMinkowski3D.yaml                 |  1 -
 .../FishboneMoncriefDisk.yaml                 |  3 +-
 .../KerrSchildSphericalHarmonic.yaml          |  1 -
 tests/Unit/Time/StepChoosers/CMakeLists.txt   |  1 +
 tests/Unit/Time/StepChoosers/Test_Maximum.cpp | 65 +++++++++++++++++
 11 files changed, 155 insertions(+), 7 deletions(-)
 create mode 100644 src/Time/StepChoosers/Maximum.cpp
 create mode 100644 src/Time/StepChoosers/Maximum.hpp
 create mode 100644 tests/Unit/Time/StepChoosers/Test_Maximum.cpp

diff --git a/src/Time/StepChoosers/CMakeLists.txt b/src/Time/StepChoosers/CMakeLists.txt
index 1a0a3209777e..9558c65cbb9c 100644
--- a/src/Time/StepChoosers/CMakeLists.txt
+++ b/src/Time/StepChoosers/CMakeLists.txt
@@ -5,6 +5,7 @@ spectre_target_sources(
   ${LIBRARY}
   PRIVATE
   Constant.cpp
+  Maximum.cpp
   Random.cpp
   StepToTimes.cpp
   )
@@ -20,6 +21,7 @@ spectre_target_headers(
   ErrorControl.hpp
   Factory.hpp
   LimitIncrease.hpp
+  Maximum.hpp
   PreventRapidIncrease.hpp
   Random.hpp
   StepChooser.hpp
diff --git a/src/Time/StepChoosers/Factory.hpp b/src/Time/StepChoosers/Factory.hpp
index 5ec9fc32556b..25e2b979ef9a 100644
--- a/src/Time/StepChoosers/Factory.hpp
+++ b/src/Time/StepChoosers/Factory.hpp
@@ -10,6 +10,7 @@
 #include "Time/StepChoosers/ElementSizeCfl.hpp"
 #include "Time/StepChoosers/ErrorControl.hpp"
 #include "Time/StepChoosers/LimitIncrease.hpp"
+#include "Time/StepChoosers/Maximum.hpp"
 #include "Time/StepChoosers/PreventRapidIncrease.hpp"
 #include "Time/StepChoosers/StepToTimes.hpp"
 #include "Utilities/TMPL.hpp"
@@ -30,7 +31,8 @@ using common_step_choosers = tmpl::push_back<
             StepChoosers::Cfl<Use, Frame::Inertial, System>,
             StepChoosers::ElementSizeCfl<Use, System::volume_dim, System>>,
         tmpl::list<>>,
-    StepChoosers::Constant<Use>, StepChoosers::LimitIncrease<Use>>;
+    StepChoosers::Constant<Use>, StepChoosers::LimitIncrease<Use>,
+    StepChoosers::Maximum<Use>>;
 template <typename Use, typename System>
 using step_choosers_for_step_only =
     tmpl::list<StepChoosers::PreventRapidIncrease<Use>,
diff --git a/src/Time/StepChoosers/Maximum.cpp b/src/Time/StepChoosers/Maximum.cpp
new file mode 100644
index 000000000000..e799bb8c6a6c
--- /dev/null
+++ b/src/Time/StepChoosers/Maximum.cpp
@@ -0,0 +1,14 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#include "Time/StepChoosers/Maximum.hpp"
+
+#include "Options/ParseOptions.hpp"
+
+namespace StepChoosers::Maximum_detail {
+// This function lets us avoid including ParseOptions.hpp in the
+// header.
+double parse_options(const Options::Option& options) {
+  return options.parse_as<double>();
+}
+}  // namespace StepChoosers::Maximum_detail
diff --git a/src/Time/StepChoosers/Maximum.hpp b/src/Time/StepChoosers/Maximum.hpp
new file mode 100644
index 000000000000..5430ace101bf
--- /dev/null
+++ b/src/Time/StepChoosers/Maximum.hpp
@@ -0,0 +1,69 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#pragma once
+
+#include <cmath>
+#include <limits>
+#include <pup.h>
+#include <utility>
+
+#include "Options/Options.hpp"
+#include "Options/String.hpp"
+#include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
+#include "Utilities/Serialization/CharmPupable.hpp"
+#include "Utilities/TMPL.hpp"
+
+namespace StepChoosers {
+
+/// Sets a constant step size limit.
+template <typename StepChooserUse>
+class Maximum : public StepChooser<StepChooserUse> {
+ public:
+  /// \cond
+  Maximum() = default;
+  explicit Maximum(CkMigrateMessage* /*unused*/) {}
+  using PUP::able::register_constructor;
+  WRAPPED_PUPable_decl_template(Maximum);  // NOLINT
+  /// \endcond
+
+  static constexpr Options::String help{"Sets a constant step size limit."};
+
+  explicit Maximum(const double value) : value_(value) {}
+
+  using argument_tags = tmpl::list<>;
+
+  std::pair<TimeStepRequest, bool> operator()(const double last_step) const {
+    return {{.size = std::copysign(value_, last_step)}, true};
+  }
+
+  bool uses_local_data() const override { return false; }
+  bool can_be_delayed() const override { return true; }
+
+  // NOLINTNEXTLINE(google-runtime-references)
+  void pup(PUP::er& p) override { p | value_; }
+
+ private:
+  double value_ = std::numeric_limits<double>::signaling_NaN();
+};
+
+/// \cond
+template <typename StepChooserUse>
+PUP::able::PUP_ID Maximum<StepChooserUse>::my_PUP_ID = 0;  // NOLINT
+/// \endcond
+
+namespace Maximum_detail {
+double parse_options(const Options::Option& options);
+}  // namespace Maximum_detail
+}  // namespace StepChoosers
+
+template <typename StepChooserUse>
+struct Options::create_from_yaml<StepChoosers::Maximum<StepChooserUse>> {
+  template <typename Metavariables>
+  static StepChoosers::Maximum<StepChooserUse> create(
+      const Options::Option& options) {
+    return StepChoosers::Maximum<StepChooserUse>(
+        StepChoosers::Maximum_detail::parse_options(options));
+  }
+};
diff --git a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml
index 1671bb6904fd..01098c4dad65 100644
--- a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml
+++ b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml
@@ -36,7 +36,6 @@ Evolution:
     AdamsBashforth:
       Order: 3
   StepChoosers:
-    - Constant: 0.05
     - LimitIncrease:
         Factor: 2
     - Cfl:
diff --git a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml
index d510ce9b71ed..2c619e0bc556 100644
--- a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml
+++ b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml
@@ -36,7 +36,6 @@ Evolution:
     AdamsBashforth:
       Order: 3
   StepChoosers:
-    - Constant: 0.05
     - LimitIncrease:
         Factor: 2
     - Cfl:
diff --git a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml
index 498053025959..97515ce122a3 100644
--- a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml
+++ b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml
@@ -51,7 +51,6 @@ Evolution:
     AdamsBashforth:
       Order: 3
   StepChoosers:
-    - Constant: 0.05
     - LimitIncrease:
         Factor: 2
     - Cfl:
diff --git a/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml b/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml
index 12a92b5e457a..a0c9cba26b29 100644
--- a/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml
+++ b/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml
@@ -27,7 +27,6 @@ Evolution:
       Order: 3
   # StepChoosers are needed only for local time stepping
   # StepChoosers:
-  #   - Constant: 0.05
   #   - LimitIncrease:
   #       Factor: 2
   #   - Cfl:
@@ -157,7 +156,7 @@ EventsAndTriggers:
           # testing.
           DelayChange: 0
           StepChoosers:
-            - Constant: 0.05
+            - Maximum: 0.05
             - LimitIncrease:
                 Factor: 2
             - Cfl:
diff --git a/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml b/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml
index 47b0cbfdf99b..35d164ef3ff3 100644
--- a/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml
+++ b/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml
@@ -32,7 +32,6 @@ Evolution:
       Order: 3
   InitialSlabSize: 0.001
   StepChoosers:
-    - Constant: 0.01
     - LimitIncrease:
         Factor: 2
     - Cfl:
diff --git a/tests/Unit/Time/StepChoosers/CMakeLists.txt b/tests/Unit/Time/StepChoosers/CMakeLists.txt
index e82a13d169b3..c01c86593086 100644
--- a/tests/Unit/Time/StepChoosers/CMakeLists.txt
+++ b/tests/Unit/Time/StepChoosers/CMakeLists.txt
@@ -9,6 +9,7 @@ set(LIBRARY_SOURCES
   StepChoosers/Test_ElementSizeCfl.cpp
   StepChoosers/Test_ErrorControl.cpp
   StepChoosers/Test_LimitIncrease.cpp
+  StepChoosers/Test_Maximum.cpp
   StepChoosers/Test_PreventRapidIncrease.cpp
   StepChoosers/Test_Random.cpp
   StepChoosers/Test_StepToTimes.cpp
diff --git a/tests/Unit/Time/StepChoosers/Test_Maximum.cpp b/tests/Unit/Time/StepChoosers/Test_Maximum.cpp
new file mode 100644
index 000000000000..c87d2d1bb6d6
--- /dev/null
+++ b/tests/Unit/Time/StepChoosers/Test_Maximum.cpp
@@ -0,0 +1,65 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#include "Framework/TestingFramework.hpp"
+
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include "DataStructures/DataBox/DataBox.hpp"
+#include "Framework/TestCreation.hpp"
+#include "Framework/TestHelpers.hpp"
+#include "Options/Protocols/FactoryCreation.hpp"
+#include "Time/StepChoosers/Maximum.hpp"
+#include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
+#include "Utilities/ProtocolHelpers.hpp"
+#include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
+#include "Utilities/TMPL.hpp"
+
+namespace {
+struct Metavariables {
+  struct factory_creation
+      : tt::ConformsTo<Options::protocols::FactoryCreation> {
+    using factory_classes = tmpl::map<
+        tmpl::pair<StepChooser<StepChooserUse::LtsStep>,
+                   tmpl::list<StepChoosers::Maximum<StepChooserUse::LtsStep>>>,
+        tmpl::pair<StepChooser<StepChooserUse::Slab>,
+                   tmpl::list<StepChoosers::Maximum<StepChooserUse::Slab>>>>;
+  };
+  using component_list = tmpl::list<>;
+};
+
+template <typename Use>
+void test_use() {
+  auto box = db::create<
+      db::AddSimpleTags<Parallel::Tags::MetavariablesImpl<Metavariables>>>(
+      Metavariables{});
+
+  // Sign of argument should be ignored.
+  const StepChoosers::Maximum<Use> maximum{-5.4};
+  const std::unique_ptr<StepChooser<Use>> maximum_base =
+      std::make_unique<StepChoosers::Maximum<Use>>(maximum);
+
+  const double current_step = std::numeric_limits<double>::infinity();
+  const std::pair<TimeStepRequest, bool> expected{{.size = 5.4}, true};
+  CHECK(maximum(current_step) == expected);
+  CHECK(serialize_and_deserialize(maximum)(current_step) == expected);
+  CHECK(maximum_base->desired_step(current_step, box) == expected);
+  CHECK(serialize_and_deserialize(maximum_base)
+            ->desired_step(current_step, box) == expected);
+
+  TestHelpers::test_creation<std::unique_ptr<StepChooser<Use>>, Metavariables>(
+      "Maximum: 5.4");
+}
+}  // namespace
+
+SPECTRE_TEST_CASE("Unit.Time.StepChoosers.Maximum", "[Unit][Time]") {
+  register_factory_classes_with_charm<Metavariables>();
+
+  test_use<StepChooserUse::LtsStep>();
+  test_use<StepChooserUse::Slab>();
+
+  CHECK(not StepChoosers::Maximum<StepChooserUse::Slab>{}.uses_local_data());
+}

From 6666bd7b95960849212acc1fe98ad9301c3e504d Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Tue, 14 May 2024 15:00:15 -0400
Subject: [PATCH 15/16] Make StepChooser help wording uniform

Always clearly indicate whether the class provides a goal or a limit.
---
 src/Time/StepChoosers/ByBlock.hpp              | 5 ++---
 src/Time/StepChoosers/Cfl.hpp                  | 4 ++--
 src/Time/StepChoosers/Constant.hpp             | 4 ++--
 src/Time/StepChoosers/ElementSizeCfl.hpp       | 4 ++--
 src/Time/StepChoosers/ErrorControl.hpp         | 5 ++---
 src/Time/StepChoosers/Maximum.hpp              | 4 ++--
 src/Time/StepChoosers/PreventRapidIncrease.hpp | 5 +++--
 7 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/src/Time/StepChoosers/ByBlock.hpp b/src/Time/StepChoosers/ByBlock.hpp
index c6ef236d03a2..11c14aa3f066 100644
--- a/src/Time/StepChoosers/ByBlock.hpp
+++ b/src/Time/StepChoosers/ByBlock.hpp
@@ -29,7 +29,7 @@ struct Element;
 /// \endcond
 
 namespace StepChoosers {
-/// Suggests specified step sizes in each block
+/// Sets a goal specified per-block.
 template <typename StepChooserUse, size_t Dim>
 class ByBlock : public StepChooser<StepChooserUse> {
  public:
@@ -46,8 +46,7 @@ class ByBlock : public StepChooser<StepChooserUse> {
         "Step sizes, indexed by block number"};
   };
 
-  static constexpr Options::String help{
-      "Suggests specified step sizes in each block"};
+  static constexpr Options::String help{"Sets a goal specified per-block."};
   using options = tmpl::list<Sizes>;
 
   explicit ByBlock(std::vector<double> sizes) : sizes_(std::move(sizes)) {}
diff --git a/src/Time/StepChoosers/Cfl.hpp b/src/Time/StepChoosers/Cfl.hpp
index bc07e8039b3f..40a0e1a44254 100644
--- a/src/Time/StepChoosers/Cfl.hpp
+++ b/src/Time/StepChoosers/Cfl.hpp
@@ -33,7 +33,7 @@ struct MinimumGridSpacing;
 /// \endcond
 
 namespace StepChoosers {
-/// Suggests a step size based on the CFL stability criterion.
+/// Sets a goal based on the CFL stability criterion.
 template <typename StepChooserUse, typename Frame, typename System>
 class Cfl : public StepChooser<StepChooserUse> {
  public:
@@ -51,7 +51,7 @@ class Cfl : public StepChooser<StepChooserUse> {
   };
 
   static constexpr Options::String help{
-      "Suggests a step size based on the CFL stability criterion."};
+      "Sets a goal based on the CFL stability criterion."};
   using options = tmpl::list<SafetyFactor>;
 
   explicit Cfl(const double safety_factor) : safety_factor_(safety_factor) {}
diff --git a/src/Time/StepChoosers/Constant.hpp b/src/Time/StepChoosers/Constant.hpp
index 6725e855d707..73cd0e22a099 100644
--- a/src/Time/StepChoosers/Constant.hpp
+++ b/src/Time/StepChoosers/Constant.hpp
@@ -17,7 +17,7 @@
 
 namespace StepChoosers {
 
-/// Suggests a constant step size.
+/// Sets a constant goal.
 template <typename StepChooserUse>
 class Constant : public StepChooser<StepChooserUse> {
  public:
@@ -28,7 +28,7 @@ class Constant : public StepChooser<StepChooserUse> {
   WRAPPED_PUPable_decl_template(Constant);  // NOLINT
   /// \endcond
 
-  static constexpr Options::String help{"Suggests a constant step size."};
+  static constexpr Options::String help{"Sets a constant goal."};
 
   explicit Constant(const double value) : value_(value) {}
 
diff --git a/src/Time/StepChoosers/ElementSizeCfl.hpp b/src/Time/StepChoosers/ElementSizeCfl.hpp
index 68922b6a1f82..d70ab4d8c143 100644
--- a/src/Time/StepChoosers/ElementSizeCfl.hpp
+++ b/src/Time/StepChoosers/ElementSizeCfl.hpp
@@ -33,7 +33,7 @@ struct SizeOfElement;
 /// \endcond
 
 namespace StepChoosers {
-/// Suggests a step size based on the CFL stability criterion, but uses the full
+/// Sets a goal based on the CFL stability criterion, but uses the full
 /// size of the element as the length scale in question.
 ///
 /// This is useful as a coarse estimate for slabs, or to place a ceiling on
@@ -55,7 +55,7 @@ class ElementSizeCfl : public StepChooser<StepChooserUse> {
   };
 
   static constexpr Options::String help{
-      "Suggests a step size based on the CFL stability criterion, but in which "
+      "Sets a goal based on the CFL stability criterion, but in which "
       "the entire size of the element is used as the spacing in the "
       "computation. This is useful primarily for placing a ceiling on another "
       "dynamically-adjusted step chooser"};
diff --git a/src/Time/StepChoosers/ErrorControl.hpp b/src/Time/StepChoosers/ErrorControl.hpp
index 5d9aaac77477..be7c7f7e80f3 100644
--- a/src/Time/StepChoosers/ErrorControl.hpp
+++ b/src/Time/StepChoosers/ErrorControl.hpp
@@ -55,8 +55,7 @@ struct ErrorControlBase : IsAnErrorControl {
 }  // namespace ErrorControl_detail
 
 /*!
- * \brief Suggests a step size based on a target absolute and/or relative error
- * measure.
+ * \brief Sets a goal based on time-stepper truncation error.
  *
  * \details The suggested step is calculated via a simple specialization of the
  * scheme suggested in \cite Hairer1993. We first compute the aggregated error
@@ -176,7 +175,7 @@ class ErrorControl
   };
 
   static constexpr Options::String help{
-      "Chooses a step based on a target relative and absolute error tolerance"};
+      "Sets a goal based on time-stepper truncation error."};
   using options = tmpl::list<AbsoluteTolerance, RelativeTolerance, MaxFactor,
                              MinFactor, SafetyFactor>;
 
diff --git a/src/Time/StepChoosers/Maximum.hpp b/src/Time/StepChoosers/Maximum.hpp
index 5430ace101bf..ee63bf131bc0 100644
--- a/src/Time/StepChoosers/Maximum.hpp
+++ b/src/Time/StepChoosers/Maximum.hpp
@@ -17,7 +17,7 @@
 
 namespace StepChoosers {
 
-/// Sets a constant step size limit.
+/// Limits the step size to a constant.
 template <typename StepChooserUse>
 class Maximum : public StepChooser<StepChooserUse> {
  public:
@@ -28,7 +28,7 @@ class Maximum : public StepChooser<StepChooserUse> {
   WRAPPED_PUPable_decl_template(Maximum);  // NOLINT
   /// \endcond
 
-  static constexpr Options::String help{"Sets a constant step size limit."};
+  static constexpr Options::String help{"Limits the step size to a constant."};
 
   explicit Maximum(const double value) : value_(value) {}
 
diff --git a/src/Time/StepChoosers/PreventRapidIncrease.hpp b/src/Time/StepChoosers/PreventRapidIncrease.hpp
index b1a913e037c0..824f8670a558 100644
--- a/src/Time/StepChoosers/PreventRapidIncrease.hpp
+++ b/src/Time/StepChoosers/PreventRapidIncrease.hpp
@@ -16,6 +16,8 @@
 #include "Utilities/TMPL.hpp"
 
 namespace StepChoosers {
+/// Limits the time step to prevent multistep integrator instabilities.
+///
 /// Avoids instabilities due to rapid increases in the step size by
 /// preventing the step size from increasing if any step in the
 /// time-stepper history increased.  If there have been recent step
@@ -32,8 +34,7 @@ class PreventRapidIncrease : public StepChooser<StepChooserUse> {
   /// \endcond
 
   static constexpr Options::String help{
-      "Prevents rapid increases in time step that can cause integrator \n"
-      "instabilities."};
+      "Limits the time step to prevent multistep integrator instabilities."};
   using options = tmpl::list<>;
 
   using argument_tags = tmpl::list<::Tags::HistoryEvolvedVariables<>>;

From 5061e657d1a5bedf54fd6761758409c5cbca8419 Mon Sep 17 00:00:00 2001
From: William Throwe <wtt6@cornell.edu>
Date: Tue, 14 May 2024 15:25:34 -0400
Subject: [PATCH 16/16] Update StepChoosers in example yaml files

---
 support/Pipelines/Bbh/Inspiral.yaml                 |  1 +
 .../CurvedScalarWave/PlaneWaveMinkowski1D.yaml      |  1 +
 .../CurvedScalarWave/PlaneWaveMinkowski2D.yaml      |  1 +
 .../CurvedScalarWave/PlaneWaveMinkowski3D.yaml      |  1 +
 .../CylindricalBinaryBlackHole.yaml                 |  1 +
 .../ValenciaDivClean/FishboneMoncriefDisk.yaml      |  1 +
 .../InputFiles/NewtonianEuler/RiemannProblem1D.yaml | 13 +++----------
 .../ScalarTensor/KerrSchildSphericalHarmonic.yaml   |  1 +
 tests/InputFiles/ScalarWave/PlaneWave3D.yaml        |  2 --
 9 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/support/Pipelines/Bbh/Inspiral.yaml b/support/Pipelines/Bbh/Inspiral.yaml
index 03fa9ccff898..e46773f0a97a 100644
--- a/support/Pipelines/Bbh/Inspiral.yaml
+++ b/support/Pipelines/Bbh/Inspiral.yaml
@@ -143,6 +143,7 @@ Evolution:
   StepChoosers:
     - LimitIncrease:
         Factor: 2
+    - PreventRapidIncrease
     - ElementSizeCfl:
         SafetyFactor: 0.5
     - ErrorControl:
diff --git a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml
index 01098c4dad65..203af53f3ae1 100644
--- a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml
+++ b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml
@@ -38,6 +38,7 @@ Evolution:
   StepChoosers:
     - LimitIncrease:
         Factor: 2
+    - PreventRapidIncrease
     - Cfl:
         SafetyFactor: 0.2
 
diff --git a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml
index 2c619e0bc556..92202b32e275 100644
--- a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml
+++ b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml
@@ -38,6 +38,7 @@ Evolution:
   StepChoosers:
     - LimitIncrease:
         Factor: 2
+    - PreventRapidIncrease
     - Cfl:
         SafetyFactor: 0.2
 
diff --git a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml
index 97515ce122a3..a0b483a4354d 100644
--- a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml
+++ b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml
@@ -53,6 +53,7 @@ Evolution:
   StepChoosers:
     - LimitIncrease:
         Factor: 2
+    - PreventRapidIncrease
     - Cfl:
         SafetyFactor: 0.2
 
diff --git a/tests/InputFiles/GeneralizedHarmonic/CylindricalBinaryBlackHole.yaml b/tests/InputFiles/GeneralizedHarmonic/CylindricalBinaryBlackHole.yaml
index 7953a8fc7c55..2981be8f271f 100644
--- a/tests/InputFiles/GeneralizedHarmonic/CylindricalBinaryBlackHole.yaml
+++ b/tests/InputFiles/GeneralizedHarmonic/CylindricalBinaryBlackHole.yaml
@@ -22,6 +22,7 @@ Evolution:
   StepChoosers:
     - LimitIncrease:
         Factor: 2
+    - PreventRapidIncrease
     - ElementSizeCfl:
         SafetyFactor: 0.5
     - ErrorControl:
diff --git a/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml b/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml
index a0c9cba26b29..a91e0bff6be4 100644
--- a/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml
+++ b/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml
@@ -29,6 +29,7 @@ Evolution:
   # StepChoosers:
   #   - LimitIncrease:
   #       Factor: 2
+  #   - PreventRapidIncrease
   #   - Cfl:
   #       SafetyFactor: 0.2
   # InitialSlabSize is only needed for local time stepping
diff --git a/tests/InputFiles/NewtonianEuler/RiemannProblem1D.yaml b/tests/InputFiles/NewtonianEuler/RiemannProblem1D.yaml
index 0f4d8447b2ab..fd5e498768b2 100644
--- a/tests/InputFiles/NewtonianEuler/RiemannProblem1D.yaml
+++ b/tests/InputFiles/NewtonianEuler/RiemannProblem1D.yaml
@@ -104,7 +104,7 @@ EventsAndTriggers:
           # number has little qualitative effect on chosen step size,
           # as long as the initial step size is not too large for the
           # requested accuracy.
-          DelayChange: &slab_update_delay 10
+          DelayChange: 10
           StepChoosers:
             - ErrorControl:
                 AbsoluteTolerance: 1.0e-3
@@ -112,16 +112,9 @@ EventsAndTriggers:
                 MaxFactor: 10000.0
                 MinFactor: 0.0
                 SafetyFactor: 0.9
-  # These step choosers require no communication, so can be applied
-  # with a delay of 0 with no downside.  We don't want them to start
-  # increasing the slab size before the error control is active,
-  # though.
-  - Trigger:
-      SlabCompares:
-        Comparison: GreaterThanOrEqualTo
-        Value: *slab_update_delay
-    Events:
       - ChangeSlabSize:
+          # These step choosers require no communication, so can be
+          # applied with a delay of 0 with no downside.
           DelayChange: 0
           StepChoosers:
             - LimitIncrease:
diff --git a/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml b/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml
index 35d164ef3ff3..740afe084094 100644
--- a/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml
+++ b/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml
@@ -34,6 +34,7 @@ Evolution:
   StepChoosers:
     - LimitIncrease:
         Factor: 2
+    - PreventRapidIncrease
     - Cfl:
         SafetyFactor: 0.2
 
diff --git a/tests/InputFiles/ScalarWave/PlaneWave3D.yaml b/tests/InputFiles/ScalarWave/PlaneWave3D.yaml
index e9721696e6e6..60f71e929e36 100644
--- a/tests/InputFiles/ScalarWave/PlaneWave3D.yaml
+++ b/tests/InputFiles/ScalarWave/PlaneWave3D.yaml
@@ -82,8 +82,6 @@ EventsAndTriggers:
       - ChangeSlabSize:
           DelayChange: 0
           StepChoosers:
-            - LimitIncrease:
-                Factor: 1.1
             - StepToTimes:
                 Times:
                   Specified: