Calculate diffusion term in tracer conservation equations using ∇_dot_qᶜ

[syou83syou83]

Hello,
I'd like to calculate diffusion term in tracer ( particularly DIC ) conservation equations, using the following lines of code:

durations=10days 
function diffusion_callback!(sim, param)
    for j=1:Nz
        param.diffusion_record[j,floor(Int,sim.model.clock.time/days)+1] = ∇_dot_qᶜ(1, 1, j, grid, sim.model.closure, sim.model.diffusivity_fields, Val(12), sim.model.tracers.DIC[1,1,j], model.buoyancy)
    end
end
diffusion_record = zeros(Nz,floor(Int,duration/days)+1)
simulation.callbacks[:diffusion] = Callback(diffusion_callback!, TimeInterval(1day), (; diffusion_record))

My model is:

julia> model
NonhydrostaticModel{CPU, RectilinearGrid}(time = 10 days, iteration = 2761)
├── grid: 1×1×50 RectilinearGrid{Float64, Oceananigans.Grids.Periodic, Oceananigans.Grids.Periodic, Bounded} on CPU with 3×3×3 halo
├── timestepper: RungeKutta3TimeStepper
├── tracers: (b, NO₃, NH₄, P, Z, D, DD, DOM, DIC, ALK, OXY)
├── closure: ScalarDiffusivity{ExplicitTimeDiscretization}(ν=κₜ (generic function with 1 method), κ=(b=κₜ (generic function with 1 method), NO₃=κₜ (generic function with 1 method), NH₄=κₜ (generic function with 1 method), P=κₜ (generic function with 1 method), Z=κₜ (generic function with 1 method), D=κₜ (generic function with 1 method), DD=κₜ (generic function with 1 method), DOM=κₜ (generic function with 1 method), DIC=κₜ (generic function with 1 method), ALK=κₜ (generic function with 1 method), OXY=κₜ (generic function with 1 method)))
├── buoyancy: BuoyancyTracer with -ĝ = ZDirection
├── coriolis: FPlane{Float64}(f=0.0001)
└── particles: 100 LagrangianParticles with eltype Particle and properties (:x, :y, :z, :u, :v, :w, :A, :N, :C, :j_NO₃, :j_NH₄, :j_DIC, :j_OXY, :e, :ν, :NO₃, :NH₄, :PAR)

But the ∇_dot_qᶜ outputs all zeros and I don't quite understand the syntax of ∇_dot_qᶜ . For example, is the tracer_index of DIC 12 in my model? May I have your insights what might be the problem?

And is there a way to calculate the diffusion term in the postprocessing, given the DIC has been obtained and diffusivity is defined, instead of using callback as shown above?
Thank you very much.

Best,
Si

[glwagner]

Your error is using

sim.model.tracers.DIC[1,1,j]

as an argument rather than

sim.model.tracers.DIC

But, I think you should use AbstractOperations instead. Here's a utility that returns the flux divergence operation for tracer_name:

using Oceananigans
using Oceananigans.TurbulenceClosures: ∇_dot_qᶜ

"""
    diffusive_flux_divergence(tracer_name, model, model=model.closure)

Returns a KernelFunctionOperation corresponding to the diffusive flux divergence
associated with `closure`, where `tracer_name` is one of `keys(model.tracers)`.

`model.closure` is used by default if `closure` is not provided.
"""
function diffusive_flux_divergence(tracer_name, model, closure=model.closure)
    tracers = model.tracers
    id = findfirst(name -> name === :tracer_name, keys(tracers))
    c = tracers[id]
    computed_dependencies = (model.diffusivity_fields, Val(id), c, model.buoyancy)
    diffusion_op = KernelFunctionOperation{Center, Center, Center}(∇_dot_qᶜ, model.grid; computed_dependencies)
    return diffusion_op
end

You can use this as

flux_div_op = diffusive_flux_divergence(:DIC, model)

Field(flux_div_op) # 3D field
Field(Average(flux_div_op, dims=1)) # Averaged over x

You can also pass flux_div_op directly to output writers to be output.

[syou83syou83]

Thank you @glwagner. I will look into it and let you know if I have further questions.

[syou83syou83]

Hi @glwagner, I implemented the above code, but again it still outputs all zeros for flux_div_op .

I put them in the one-dimensional diffusion example https://github.com/CliMA/Oceananigans.jl/blob/main/examples/one_dimensional_diffusion.jl like

function diffusive_flux_divergence(tracer_name, model, closure=model.closure)
    tracers = model.tracers
    id = findfirst(name -> name === tracer_name, keys(tracers))   
    c = tracers[id]
    computed_dependencies = (model.diffusivity_fields, Val(id), c, model.buoyancy)
    diffusion_op = KernelFunctionOperation{Center, Center, Center}(∇_dot_qᶜ, model.grid; computed_dependencies)
    return diffusion_op
end
flux_div_op = diffusive_flux_divergence(:T, model)
filename = "diffusion"

simulation.output_writers[:slices] =
    JLD2OutputWriter(model, merge(model.tracers, (f=flux_div_op,)),
                     filename = filename * ".jld2",
                     schedule = TimeInterval(0.005),
                     overwrite_existing = true)
run!(simulation)

But it is still all zeros. Did I do anything wrong? Thanks.

[glwagner]

The problem was my code! It was very off.

Here's a corrected version that (hopefully) works:

function diffusive_flux_divergence(tracer_name, model::NonhydrostaticModel, closure=model.closure)
    tracers = model.tracers
    id = findfirst(name -> name === tracer_name, keys(tracers))
    c = tracers[id]
    model_fields = merge(model.velocities, model.tracers, model.auxiliary_fields)
    computed_dependencies = (model.closure, model.diffusivity_fields, Val(id), c, model.clock, model_fields, model.buoyancy)
    diffusion_op = KernelFunctionOperation{Center, Center, Center}(∇_dot_qᶜ, model.grid; computed_dependencies)
    return diffusion_op
end

It'd be good to add this to the source eventually somehow...

[glwagner]

A better word would also be "closure_term" or something. The idea of being able to compute from individual closures is interesting too, but this function actually doesn't achieve that.

[glwagner]

@syou83syou83 did this work for you?

[syou83syou83]

Hi @glwagner, sorry for the later response. I am trying to understand the physics, but it works. Thank you very much!