Time offset for scheduling output on TimeInterval

[ammtD]

Hello,

I would like to save average fields every x-seconds. The averages will be computed over a period T (T<=0.5x). Then I would like to also store full fields every x-seconds, but staggered such that I have a full field in the middle of the period over which the average is computed.
e.g. 120s average stored at t= 600s, 1200s, 1800s etc., fields stored at t = 540s, 1140s, 1740s.
To achieve this I imagine I'd need to specify the time of the first output, next to the interval and window.... I bet this is this possible, could someone please guide me how?

# using NetCDF output writer:
simulation.output_writers[:field_writer] = NetCDFOutputWriter(model, outputs, filename="WSf_fields_all.nc", 
    schedule=TimeInterval(600),  overwrite_existing = true)

simulation.output_writers[:avg_output] = NetCDFOutputWriter(model, outputs, filename="WSf_avgs_all.nc", 
    schedule=AveragedTimeInterval(600, window=120), overwrite_existing = true)

[glwagner]

For this application I think you can use AveragedTimeInterval as is for the averaged fields.

For the unaveraged, "centered" fields, there's a few options. One is to provide the second (undocumented) argument to TimeInterval, which allows you to offset the interval:

schedule = TimeInterval(600, -60) # assuming that the model starts at t=0.

You may also use the SpecifiedTimes schedule (for which you explicitly specify all the times where you'd like output).

If you find the "offset" method useful, we may want to document it (and perhaps clarify the naming of that second property, which is now called previous_actuation_time).

If you want to understand how this works in the code, see here:

Oceananigans.jl/src/Utils/schedules.jl

Lines 17 to 54 in 2234f02

	"""
	struct TimeInterval <: AbstractSchedule
	Callable `TimeInterval` schedule for periodic output or diagnostic evaluation
	according to `model.clock.time`.
	"""
	mutable struct TimeInterval <: AbstractSchedule
	interval :: Float64
	previous_actuation_time :: Float64
	end
	"""
	TimeInterval(interval)
	Return a callable `TimeInterval` that schedules periodic output or diagnostic evaluation
	on a `interval` of simulation time, as kept by `model.clock`.
	"""
	TimeInterval(interval) = TimeInterval(Float64(interval), 0.0)
	function (schedule::TimeInterval)(model)
	time = model.clock.time
	if time == schedule.previous_actuation_time + schedule.interval
	schedule.previous_actuation_time = time
	return true
	elseif time > schedule.previous_actuation_time + schedule.interval
	# Shave overshoot off previous_actuation_time to prevent overshoot from accumulating
	schedule.previous_actuation_time = time - rem(time, schedule.interval)
	return true
	else
	return false
	end
	end
	function aligned_time_step(schedule::TimeInterval, clock, Δt)
	next_actuation_time = schedule.previous_actuation_time + schedule.interval
	return min(Δt, next_actuation_time - clock.time)
	end

[glwagner]

Also do you mind if I elaborate the title of this discussion? I think this might be useful to others.

[ammtD]

Thanks, I am going to try the offset option. Feel free to change the title of the discussion to make it clearer for others what this is about.

[glwagner]

Let us know if it works!

[ammtD]

I wrote it up as follows:

avg_window = 180     # seconds
offset = -1* avg_window/2     
simulation.output_writers[:field_writer] = NetCDFOutputWriter(model, outputs, filename="WSf_fields_all.nc", 
    schedule=TimeInterval(600, offset),  overwrite_existing = true)

simulation.output_writers[:avg_output] = NetCDFOutputWriter(model, outputs, filename="WSf_avgs_all.nc", 
    schedule=AveragedTimeInterval(600, window=avg_window), overwrite_existing = true)

Fieldwriter writes output at t=0, 510, 110, 1710 s.... etc., Averagewriter at t=0, 600, 1200, 1800 s .... etc., so I believe it works!

[glwagner]

Nice! We should update the docstring to advertise this feature then!