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

Project.toml

@@ -1,7 +1,7 @@
 name = "Oceananigans"
 uuid = "9e8cae18-63c1-5223-a75c-80ca9d6e9a09"
 authors = ["Climate Modeling Alliance and contributors"]
-version = "0.95.2"
+version = "0.95.3"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"

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,19 @@ 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
+
+    # Align nearest_next_actuation_time with simulation stop_time
+    nearest_next_actuation_time = min(nearest_next_actuation_time, sim.stop_time)
+
+    return nearest_next_actuation_time
+end
+
 function schedule_aligned_time_step(sim, aligned_Δt)
     clock = sim.model.clock
     activities = collect_scheduled_activities(sim)
@@ -102,11 +115,24 @@ end
 
 const ModelCallsite = Union{TendencyCallsite, UpdateStateCallsite}
 
+
+function time_step_or_skip!(sim)
+    model_callbacks = Tuple(cb for cb in values(sim.callbacks) if cb.callsite isa ModelCallsite)
+    Δt = aligned_time_step(sim, sim.Δt)
+    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
+
+
 """ Step `sim`ulation forward by one time step. """
 function time_step!(sim::Simulation)
 
     start_time_step = time_ns()
-    model_callbacks = Tuple(cb for cb in values(sim.callbacks) if cb.callsite isa ModelCallsite)
 
     if !(sim.initialized) # execute initialization step
         initialize!(sim)
@@ -118,8 +144,7 @@ function time_step!(sim::Simulation)
                 start_time = time_ns()
             end
 
-            Δt = aligned_time_step(sim, sim.Δt)
-            time_step!(sim.model, Δt, callbacks=model_callbacks)
+            time_step_or_skip!(sim)
 
             if sim.verbose
                 elapsed_initial_step_time = prettytime(1e-9 * (time_ns() - start_time))
@@ -130,8 +155,7 @@ function time_step!(sim::Simulation)
         end
 
     else # business as usual...
-        Δt = aligned_time_step(sim, sim.Δt)
-        time_step!(sim.model, Δt, callbacks=model_callbacks)
+        time_step_or_skip!(sim)
     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
 
 """
@@ -44,12 +45,16 @@ Keyword arguments
 
 - `wall_time_limit`: Stop the simulation if it's been running for longer than this many
                      seconds of wall clock time.
+- `minimum_relative_step`: time steps smaller than `Δt * minimum_relative_step` will be skipped.
+                           This avoids extremely high values when writing the pressure to disk.
+                           Default value is 0. See github.com/CliMA/Oceananigans.jl/issues/3593 for details.
 """
 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 +93,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 +106,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: ", prettysummary(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
 #####

test/test_simulations.jl

@@ -153,9 +153,17 @@ function run_basic_simulation_tests(arch)
     simulation.callbacks[:tester] = Callback(capture_call_time, schedule, parameters=called_at)
     run!(simulation)
 
-    @show called_at
     @test all(called_at .≈ 0.0:schedule.interval:simulation.stop_time)
 
+
+    # Test that minimum_relative_step is running correctly
+    final_time = 1.0 + 1e-11
+    simulation = Simulation(model, Δt=1, stop_time=final_time, minimum_relative_step=1e-10)
+    run!(simulation)
+
+    @test simulation.model.clock.time == final_time
+    @test simulation.model.clock.iteration == 1
+
     return nothing
 end