(0.95.3) Reset model clock and skip time_step!ing if next actuation time is tiny

src/Simulations/run.jl

@@ -7,7 +7,7 @@ using Oceananigans: AbstractModel, run_diagnostic!, write_output!
 import Oceananigans: initialize!
 import Oceananigans.OutputWriters: checkpoint_path, set!
 import Oceananigans.TimeSteppers: time_step!
-import Oceananigans.Utils: schedule_aligned_time_step
+import Oceananigans.Utils: schedule_aligned_time_step, next_actuation_time
 
 # Simulations are for running
 
@@ -21,6 +21,15 @@ function collect_scheduled_activities(sim)
     return tuple(writers..., callbacks...)
 end
 
+function next_actuation_time(sim::Simulation)
+    activities = collect_scheduled_activities(sim)
+    nearest_next_actuation_time = Inf
+    for activity in activities
+        nearest_next_actuation_time = min(nearest_next_actuation_time, next_actuation_time(activity.schedule))
+    end
+    return nearest_next_actuation_time
+end
+
 function schedule_aligned_time_step(sim, aligned_Δt)
     clock = sim.model.clock
     activities = collect_scheduled_activities(sim)
@@ -131,7 +140,13 @@ function time_step!(sim::Simulation)
 
     else # business as usual...
         Δt = aligned_time_step(sim, sim.Δt)
-        time_step!(sim.model, Δt, callbacks=model_callbacks)
+        if Δt < sim.minimum_relative_step * sim.Δt
+            next_time = next_actuation_time(sim)
+            @warn "Reseting clock to $next_time and skipping aligned time step Δt = $Δt"
+            sim.model.clock.time = next_time
+        else
+            time_step!(sim.model, Δt, callbacks=model_callbacks)
+        end
     end
 
     # Callbacks and callback-like things

src/Simulations/simulation.jl

@@ -9,18 +9,19 @@ import Oceananigans.TimeSteppers: reset!
 default_progress(simulation) = nothing
 
 mutable struct Simulation{ML, DT, ST, DI, OW, CB}
-              model :: ML
-                 Δt :: DT
-     stop_iteration :: Float64
-          stop_time :: ST
-    wall_time_limit :: Float64
-        diagnostics :: DI
-     output_writers :: OW
-          callbacks :: CB
-      run_wall_time :: Float64
-            running :: Bool
-        initialized :: Bool
-            verbose :: Bool
+                    model :: ML
+                       Δt :: DT
+           stop_iteration :: Float64
+                stop_time :: ST
+          wall_time_limit :: Float64
+              diagnostics :: DI
+           output_writers :: OW
+                callbacks :: CB
+            run_wall_time :: Float64
+                  running :: Bool
+              initialized :: Bool
+                  verbose :: Bool
+    minimum_relative_step :: Float64
 end
 
 """
@@ -49,7 +50,8 @@ function Simulation(model; Δt,
                     verbose = true,
                     stop_iteration = Inf,
                     stop_time = Inf,
-                    wall_time_limit = Inf)
+                    wall_time_limit = Inf,
+                    minimum_relative_step = 0)
 
    if stop_iteration == Inf && stop_time == Inf && wall_time_limit == Inf
        @warn "This simulation will run forever as stop iteration = stop time " *
@@ -88,7 +90,8 @@ function Simulation(model; Δt,
                      0.0,
                      false,
                      false,
-                     verbose)
+                     verbose,
+                     Float64(minimum_relative_step))
 end
 
 function Base.show(io::IO, s::Simulation)
@@ -100,6 +103,7 @@ function Base.show(io::IO, s::Simulation)
                      "├── Stop time: $(prettytime(s.stop_time))", "\n",
                      "├── Stop iteration: $(s.stop_iteration)", "\n",
                      "├── Wall time limit: $(s.wall_time_limit)", "\n",
+                     "├── Minimum relative step: $(s.minimum_relative_step)", "\n",
                      "├── Callbacks: $(ordered_dict_show(s.callbacks, "│"))", "\n",
                      "├── Output writers: $(ordered_dict_show(s.output_writers, "│"))", "\n",
                      "└── Diagnostics: $(ordered_dict_show(s.diagnostics, "│"))")

src/Utils/schedules.jl

@@ -108,6 +108,8 @@ IterationInterval(interval; offset=0) = IterationInterval(interval, offset)
 
 (schedule::IterationInterval)(model) = (model.clock.iteration - schedule.offset) % schedule.interval == 0
 
+next_actuation_time(schedule::IterationInterval) = Inf
+
 #####
 ##### WallTimeInterval
 #####