Time-derivative operator

[tomchor]

Would people be interested in a time-derivative operator? It should be particularly useful for budgets. I can open a PR if people agree.

[glwagner]

@xkykai has a PR open that implements operations on FieldTimeSeries which possibly should be merged first: #5761

[xkykai]

I can work on #5761 and try to merge it soon

[tomchor]

That looks like a cool PR. That said, I was thinking of an abstraction that doesn't require a FieldTimeSeries (or any other method of manually storing snapshots). I was thinking of creating an object like

mutable struct TimeDerivative{R, O, P, T, G}
    current_operand :: O
    previous_operand :: P
    previous_time :: T
end

which gets updated with every model step, such that one can call compute! on it at every time and get the result. The struct might need a couple of other things, but hopefully the idea is clear.

[glwagner]

How would this be used?

[tomchor]

I suspect that are other uses but I think the main use case is when doing budgets. At moment the easiest way to calculate the time derivative for a budget is to output two consecutive time steps and do the calculation offline. For example: https://tomchor.github.io/Oceanostics.jl/stable/generated/rayleigh_taylor_instability/#Output

I think a time-derivative like I'm proposing is a more elegant solution that'll be easier for users and make it possible to close the budget online without ad-hoc code.

[glwagner]

Can you provide some pseudocode?

[tomchor]

Sure. The idea is that it'd work like any of Field. Closing a tracer variance budget like in this example would go from

∫c² = Integral(c^2)
χ = TracerVarianceEquation.TracerVarianceDissipationRate(model, :c)
simulation.output_writers[:budget] = JLD2Writer(model, (; ∫c², ∫χ),
                                                schedule = ConsecutiveIterations(TimeInterval(1)))

to something like

∫c² = Integral(c^2)
∂t∫c² = ∂t(∫c²)
χ = TracerVarianceEquation.TracerVarianceDissipationRate(model, :c)
simulation.output_writers[:budget] = JLD2Writer(model, (; ∂t∫c², ∫χ),
                                                schedule = TimeInterval(1))

or hopefully after #5820 we can make it more elegant :)

∂t∫c² = ∂t(∫dV(c^2))
χ = TracerVarianceEquation.TracerVarianceDissipationRate(model, :c)
simulation.output_writers[:budget] = JLD2Writer(model, (; ∂t∫c², ∫χ),
                                                schedule = TimeInterval(1))

[glwagner]

Okay, I understand. I think in this case, it is not really an operator directly but rather an abstraction that can be consumed / interpreted by an output writer. So I'd propose naming it as such.

It does make sense to combine the concept of operators and output, but they can be distinct. Operators can generally be composed with both further arithmetic or operations. However I do not think that the proposed abstraction is easily used as an operator. Note that a time-derivative operator is indeed possible when working with FieldTimeSeries and could be treated similarly to spatial operations, which is part of the ultimate ambition of #5761 .

Regarding the pseudocode --- I believe that what you've written can be implemented by using a paired callback structure similar to what we use for time-averaging. I think time-averaging in fact could also be implemented in a similar way (eg as an output-specific transformation, rather than a schedule which applies to the entire output writer).