Output

struct ConstantOutputVariable{O, N} <: AbstractArray{O, N}

A struct to output a constant (time independent) variable.

Fields

• array

• dimension_labels

array is the array storing the data to be output. dimension_labels is a tuple of dimension labels. When added to an OutputWriter these labels are used to attach dimension scales (coordinates) to the output variable.

struct OutputVariable{T, N, O, A} <: AbstractArray{O, N}

A struct to create output variables.

Fields

• problem

• func

• dimension_labels

• output_array

• args

func is a function with signature func(problem::Problem, output_array::AbstractArray{T,N}, args...) that computes the output field in-place in output_array. args are the arguments to func. dimension_labels is a tuple of dimension labels. When added to an OutputWriter these labels are used to attach dimension scales (coordinates) to the output variable.

OutputVariable(
    problem::Problem{T},
    func::Function,
    dimensions::NamedTuple{S, NTuple{N, Integer}},
    type::Type,
    args
) -> OutputVariable

Create an output variable specifying the dimension labels and sizes in a named tuple.

OutputVariable(
    problem::Problem{T},
    func::Function,
    dimensions::NamedTuple{S, NTuple{N, Integer}},
    type::Type
) -> OutputVariable{_A, _B, T, Tuple{}} where {_A, _B, T}

OutputVariable(
    problem::Problem{T},
    func::Function,
    dimension_labels::NTuple{N, Union{Nothing, Symbol}},
    sizes::NTuple{N, Integer},
    type::Type,
    args
) -> OutputVariable

Create an output variable creating the output array of shape sizes and type type.

OutputVariable(
    problem::Problem{T},
    func::Function,
    dimension_labels::NTuple{N, Union{Nothing, Symbol}},
    sizes::NTuple{N, Integer},
    type::Type
) -> OutputVariable{_A, _B, T, Tuple{}} where {_A, _B, T}

OutputVariable(
    problem::Problem{T},
    func::Function,
    dimension_labels::NTuple{N, Union{Nothing, Symbol}},
    output_array::AbstractArray{O, N}
) -> OutputVariable{_A, _B, _C, Tuple{}} where {_A, _B, _C}

Create an output variable with a function that takes no additional arguments.

struct OutputWriter{T, D}

Struct for writing output to an HDF5 file.

OutputWriter(
    problem::Problem{T},
    filepath::String,
    coordinates::NamedTuple;
    overwrite
) -> OutputWriter{_A, NamedTuple{names, T}} where {_A, names, T<:Tuple}

OutputWriter(
    problem::Problem{T},
    filepath::String;
    overwrite
) -> OutputWriter{_A, NamedTuple{(:x, :z), var"#s182"}} where {_A, var"#s182"<:Tuple{Union{LinRange{Float32, Int64}, LinRange{Float64, Int64}}, Union{LinRange{Float32, Int64}, LinRange{Float64, Int64}}}}

add_output_variables!(
    output_writer::OutputWriter;
    kwargs...
)

Add OutputVariables to the OutputWriter. Excepts keyword arguments where the key is the name of the variable and the value an OutputVariable.

compute!(output_variable::OutputVariable) -> Any

Compute the output field in-place in output_variable.output_array.

integrate_periodic_gradients(
    x_derivative::XZVariable,
    z_derivative::XZVariable;
    out,
    FZ_working_space
) -> XZVariable

Integrate periodic gradients. out is the output variable and can be the same as x_derivative or z_derivative.

write!(ow::OutputWriter)

Compute and write the output variables to the output file.

write_Bx!(output_writer::OutputWriter; name)

Write the current background $B_x$ to the output writer.

write_Bz!(output_writer::OutputWriter; name)

Write the current background $B_z$ to the output writer.

write_Vx!(output_writer::OutputWriter; name)

Write the current background $V_x$ to the output writer.

write_attributes!(ow::OutputWriter, attributes...)

Write attributes to the output file. Attributes should be provided as (key,value) or key => value where key can be converted to a string.

write_attributes!(ow::OutputWriter; attributes...)

Write attributes to the output file providing the attributes as keyword arguments.

write_background_buoyancy!(ow::OutputWriter; name)

Integrate the background buoyancy gradients and write to output writer.

write_background_flow!(ow::OutputWriter; f, Vx, Bx, Bz)

Write the background flow to the output writer.

write_background_velocity!(ow::OutputWriter; name)

Integrate the background velocity gradients and write to output writer.

write_constant_array!(
    output_writer::OutputWriter,
    array::AbstractArray{T, N},
    name::String
)
write_constant_array!(
    output_writer::OutputWriter,
    array::AbstractArray{T, N},
    name::String,
    dimension_labels::NTuple{N, Union{Nothing, Symbol}}
)

Create a ConstantOutputVariable and write it to the file created by an OutputWriter in one go.

write_f!(output_writer::OutputWriter; name)

Write the background $f$ as an attribute to the output writer.

Implementation of common output variables for the Sawyer-Eliassen solver.

Exports

• b
• p
• u
• v
• w
• Ψ
• ζ
• ∂u∂x
• ∂u∂z
• ∂w∂x
• ∂w∂z
• ∂²u∂x²
• ∂²u∂x∂z
• ∂²u∂z²
• ∂²w∂x²
• ∂²w∂x∂z
• ∂²w∂z²

b(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

p(
    problem::Problem
) -> OutputVariable{_A, 2, _B, A} where {_A, _B, A<:Tuple{FZVariable}}

u(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

v(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

w(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

Ψ(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

The streamfunction Ψ.

ζ(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

The vorticity ζ.

∂u∂x(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

∂u∂z(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

∂w∂x(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

∂w∂z(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

∂²u∂x²(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

∂²u∂x∂z(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

∂²u∂z²(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

∂²w∂x²(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

∂²w∂x∂z(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}

∂²w∂z²(
    problem::Problem
) -> OutputVariable{_A, 2, _B, Tuple{}} where {_A, _B}