Function and type index

Generator function pulling the resolution information from spectral_grid.

SpectralTransform(
    spectral_grid::SpectralGrid;
    one_more_degree,
    kwargs...
) -> Any

Generator function for a SpectralTransform struct pulling in parameters from a SpectralGrid struct.

Abstract super type for land-sea masks. Custom land-sea masks have to be defined as

CustomMask{NF, GridVariable2D} <: AbstractLandSeaMask

and need to have at least a field called mask::GridVariable2D that uses a GridVariable2D as defined by the spectral grid object, so of correct size and with the number format NF. All AbstractLandSeaMask have a convenient generator function to be used like mask = CustomMask(spectral_grid, option=argument), but you may add your own or customize by defining CustomMask(args...) which should return an instance of type CustomMask{NF, Grid} with parameters matching the spectral grid. Then the initialize function has to be extended for that new mask

initialize!(mask::CustomMask, model::PrimitiveEquation)

which generally is used to tweak the mask.mask grid as you like, using any other options you have included in CustomMask as fields or anything else (preferrably read-only, because this is only to initialize the land-sea mask, nothing else) from model. You can for example read something from file, set some values manually, or use coordinates from model.geometry.

The land-sea mask grid is expected to have values between [0, 1] as we use a fractional mask, allowing for grid points being, e.g. quarter land and three quarters sea for 0.25 with 0 (=sea) and 1 (=land). The surface fluxes will weight proportionally the fluxes e.g. from sea and land surface temperatures. Note however, that the land-sea mask can declare grid points being (at least partially) ocean even though the sea surface temperatures aren't defined (=NaN) in that grid point. In that case, not flux is applied.

Abstract super type for ocean models, which control the sea surface temperature and sea ice concentration as boundary conditions to a SpeedyWeather simulation. A new ocean model has to be defined as

CustomOceanModel <: AbstractOcean

and can have parameters like CustomOceanModel{T} and fields. They need to extend the following functions

function initialize!(ocean_model::CustomOceanModel, model::PrimitiveEquation)
    # your code here to initialize the ocean model itself
    # you can use other fields from model, e.g. model.geometry
end

function initialize!(
    ocean::PrognosticVariablesOcean,
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    ocean_model::CustomOceanModel,
    model::PrimitiveEquation,
)
    # your code here to initialize the prognostic variables for the ocean
    # namely, ocean.sea_surface_temperature, ocean.sea_ice_concentration, e.g.
    # ocean.sea_surface_temperature .= 300      # 300K everywhere
end

function timestep!(
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    ocean_model::CustomOceanModel,
    model::PrimitiveEquation,
)
    # your code here to change the progn.ocean.sea_surface_temperature
end

Temperatures in ocean.seasurfacetemperature have units of Kelvin, or NaN for no ocean. Note that neither sea surface temperature, land-sea mask or orography have to agree. It is possible to have an ocean on top of a mountain. For an ocean grid-cell that is (partially) masked by the land-sea mask, its value will be (fractionally) ignored in the calculation of surface fluxes (potentially leading to a zero flux depending on land surface temperatures). For an ocean grid-cell that is NaN but not masked by the land-sea mask, its value is always ignored.

Terms used to compute the adiabatic conversion term in the spectral model. Fields are:

• nlayers::Int64

• σ_lnp_A::Any: σ-related factor A needed for adiabatic conversion term

• σ_lnp_B::Any: σ-related factor B needed for adiabatic conversion term

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

AquaPlanet sea surface temperatures that are constant in time and longitude, but vary in latitude following a coslat². To be created like

ocean = AquaPlanet(spectral_grid, temp_equator=302, temp_poles=273)

Fields and options are

• temp_equator::Any: [OPTION] Temperature on the Equator [K]

• temp_poles::Any: [OPTION] Temperature at the poles [K]

• mask::Bool: [OPTION] Mask the sea surface temperature according to model.landseamask?

Land-sea mask with zero = sea everywhere.

• mask::Any: Land-sea mask [1] on grid-point space. Land=1, sea=0, land-area fraction in between.

The BarotropicModel contains all model components needed for the simulation of the barotropic vorticity equations. To be constructed like

model = BarotropicModel(spectral_grid; kwargs...)

with spectral_grid::SpectralGrid used to initalize all non-default components passed on as keyword arguments, e.g. planet=Earth(spectral_grid). Fields, representing model components, are

• spectral_grid::SpectralGrid

• architecture::Any

• geometry::Any

• planet::Any

• atmosphere::Any

• coriolis::Any

• forcing::Any

• drag::Any

• particle_advection::Any

• initial_conditions::Any

• random_process::Any

• tracers::Dict{Symbol, Tracer}

• time_stepping::Any

• spectral_transform::Any

• implicit::Any

• horizontal_diffusion::Any

• output::Any

• callbacks::Dict{Symbol, SpeedyWeather.AbstractCallback}

• feedback::Any

Boundary layer drag coefficient from the bulk Richardson number, following Frierson, 2006, Journal of the Atmospheric Sciences.

• κ::Any: von Kármán constant [1]

• z₀::Any: roughness length [m]

• Ri_c::Any: Critical Richardson number for stable mixing cutoff [1]

• drag_max::Base.RefValue: Maximum drag coefficient, κ²/log(zₐ/z₀) for zₐ from reference temperature

Century <: Period

Convenience time type representing a 100-year period.

Parameters for computing saturation vapour pressure of water using the Clausis-Clapeyron equation,

e(T) = e₀ * exp( -Lᵥ/Rᵥ * (1/T - 1/T₀)),

where T is in Kelvin, Lᵥ the the latent heat of condensation and Rᵥ the gas constant of water vapour

• e₀::AbstractFloat: Saturation water vapour pressure at 0°C [Pa]

• T₀::AbstractFloat: 0°C in Kelvin

• latent_heat_condensation::AbstractFloat: Latent heat of condensation/vaporization of water [J/kg]

• latent_heat_fusion::AbstractFloat: Latent heat of freezing/fusion of ice [J/kg]

• latent_heat_sublimation::AbstractFloat: Latent heat of freezing/sublimation of ice [J/kg]

• heat_capacity::AbstractFloat: Specific heat of air at constant pressure [J/K/kg]

• R_vapour::AbstractFloat: Gas constant of water vapour [J/kg/K]

• R_dry::AbstractFloat: Gas constant of dry air [J/kg/K]

• Lᵥ_Rᵥ::AbstractFloat: [DERIVED] Latent heat of condensation divided by gas constant of water vapour [K]

• T₀⁻¹::AbstractFloat: [DERIVED] Inverse of T₀, one over 0°C in Kelvin

• mol_ratio::AbstractFloat: [DERIVED] Ratio of molecular masses [1] of water vapour over dry air (=Rdry/Rvapour).

Functor: Saturation water vapour pressure as a function of temperature using the Clausius-Clapeyron equation,

e(T) = e₀ * exp( -Lᵥ/Rᵥ * (1/T - 1/T₀)),

where T is in Kelvin, Lᵥ the the latent heat of vaporization and Rᵥ the gas constant of water vapour, T₀ is 0˚C in Kelvin.

Clock struct keeps track of the model time, how many days to integrate for and how many time steps this takes.

• time::DateTime: current model time

• start::DateTime: start time of simulation

• period::Second: period to integrate for

• timestep_counter::Int64: Counting all time steps during simulation

• n_timesteps::Int64: number of time steps to integrate for, set in initialize!(::Clock, ::AbstractTimeStepper)

• Δt::Millisecond: Time step

Clock(
    time_stepping::SpeedyWeather.AbstractTimeStepper;
    kwargs...
) -> Clock

Create and initialize a clock from time_stepping.

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Mutable struct that contains all prognostic (copies thereof) and diagnostic variables in a single column needed to evaluate the physical parametrizations. For now the struct is mutable as we will reuse the struct to iterate over horizontal grid points. Most column vectors have nlayers entries, from [1] at the top to [end] at the lowermost model level at the planetary boundary layer.

• nlayers::Int64

• nbands_shortwave::Int64

• nbands_longwave::Int64

• ij::Int64

• jring::Int64

• lond::Any

• latd::Any

• land_fraction::Any

• orography::Any

• u::Any

• v::Any

• temp::Any

• humid::Any

• ln_pres::Any

• pres::Any

• u_tend::Any

• v_tend::Any

• temp_tend::Any

• humid_tend::Any

• flux_u_upward::Any

• flux_u_downward::Any

• flux_v_upward::Any

• flux_v_downward::Any

• flux_temp_upward::Any

• flux_temp_downward::Any

• flux_humid_upward::Any

• flux_humid_downward::Any

• random_value::Any

• boundary_layer_depth::Int64

• boundary_layer_drag::Any

• surface_geopotential::Any

• surface_u::Any

• surface_v::Any

• surface_temp::Any

• surface_humid::Any

• surface_wind_speed::Any

• skin_temperature_sea::Any

• skin_temperature_land::Any

• soil_moisture_availability::Any

• surface_humidity_flux::Any

• surface_humidity_flux_ocean::Any

• surface_humidity_flux_land::Any

• sensible_heat_flux::Any

• sensible_heat_flux_ocean::Any

• sensible_heat_flux_land::Any

• surface_air_density::Any

• sat_humid::Any

• dry_static_energy::Any

• temp_virt::Any

• geopot::Any

• cloud_top::Int64

• rain_convection::Any

• rain_large_scale::Any

• rain_rate_convection::Any

• rain_rate_large_scale::Any

• snow_convection::Any

• snow_large_scale::Any

• snow_rate_convection::Any

• snow_rate_large_scale::Any

• cos_zenith::Any

• albedo_ocean::Any

• albedo_land::Any

• surface_shortwave_down::Any

• surface_longwave_down::Any

• surface_shortwave_up::Any

• surface_shortwave_up_ocean::Any

• surface_shortwave_up_land::Any

• surface_longwave_up::Any

• surface_longwave_up_ocean::Any

• surface_longwave_up_land::Any

• outgoing_longwave_radiation::Any

• outgoing_shortwave_radiation::Any

• optical_depth_shortwave::Any

• optical_depth_longwave::Any

• a::Any

• b::Any

• c::Any

• d::Any

Constant ocean climatology that reads monthly sea surface temperature fields from file, and interpolates them only for the initial conditions in time to be stored in the prognostic variables. It is therefore an ocean from climatology but without a seasonal cycle that is constant in time. To be created like

ocean = SeasonalOceanClimatology(spectral_grid)

and the ocean time is set with initialize!(model, time=time). Fields and options are

• path::String: [OPTION] path to the folder containing the land-sea mask file, pkg path default

• file::String: [OPTION] filename of sea surface temperatures

• varname::String: [OPTION] Variable name in netcdf file

• file_Grid::Type{<:AbstractGrid}: [OPTION] Grid the sea surface temperature file comes on

• missing_value::Float64: [OPTION] The missing value in the data respresenting land

Convective heating as defined by Lee and Kim, 2003, JAS implemented as convection parameterization. Fields are

• nlat::Int64

• time_scale::Second: [OPTION] Qmax heating strength as 1K/timescale

• p₀::Any: [OPTION] Pressure of maximum heating [hPa]

• σₚ::Any: [OPTION] Vertical extent of heating [hPa]

• θ₀::Any: [OPTION] Latitude of heating [˚N]

• σθ::Any: [OPTION] Latitudinal width of heating [˚]

• lat_mask::Vector

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

• rate::Any

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

• rate::Any

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

All diagnostic variables.

• spectrum::Any: Spectral resolution: Max degree of spherical harmonics

• grid_used::Any: Grid resolution: Number of latitude rings on one hemisphere (Equator incl.)

• nlayers::Int64: Number of vertical layers

• nparticles::Int64: Number of particles for particle advection

• tendencies::Tendencies: Tendencies (spectral and grid) of the prognostic variables

• grid::GridVariables: Gridded prognostic variables

• dynamics::DynamicsVariables: Intermediate variables for the dynamical core

• physics::PhysicsVariables: Global fields returned from physics parameterizations

• particles::ParticleVariables: Intermediate variables for the particle advection

• column::ColumnVariables: Vertical column for the physics parameterizations

• temp_average::Any: Average temperature of every horizontal layer [K]

• scale::Base.RefValue: Scale applied to vorticity and divergence

DiagnosticVariables(
    SG::SpectralGrid;
    spectral_transform,
    nbands_shortwave,
    nbands_longwave
)

Generator function. If a transform is handed over, the same scratch memory is used.

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• unscale::Bool

The simplified Betts-Miller convection scheme from Frierson, 2007, https://doi.org/10.1175/JAS3935.1 but with humidity set to zero. Fields and options are

• time_scale::Second: [OPTION] Relaxation time for profile adjustment

• surface_temp::Any: [OPTION] Surface perturbation of temp to calculate the dry adiabat

Intermediate quantities for the dynamics of a given layer.

• spectrum::Any

• grid::Any

• nlayers::Int64

• a::Any: Multi-purpose a, 3D work array to be reused in various places

• b::Any: Multi-purpose b, 3D work array to be reused in various places

• a_grid::Any: Multi-purpose a, 3D work array to be reused in various places

• b_grid::Any: Multi-purpose b, 3D work array to be reused in various places

• a_2D::Any: Multi-purpose a, work array to be reused in various places

• b_2D::Any: Multi-purpose b, work array to be reused in various places

• a_2D_grid::Any: Multi-purpose a, work array to be reused in various places

• b_2D_grid::Any: Multi-purpose b, work array to be reused in various places

• uv∇lnp::Any: Pressure flux (uₖ, vₖ)⋅∇ln(pₛ)

• uv∇lnp_sum_above::Any: Sum of Δσₖ-weighted uv∇lnp above

• div_sum_above::Any: Sum of div_weighted from top to k

• temp_virt::Any: Virtual temperature [K], spectral for geopotential

• geopot::Any: Geopotential [m²/s²] on full layers

• σ_tend::Any: Vertical velocity (dσ/dt), on half levels k+1/2 below, pointing to the surface (σ=1)

• ∇lnp_x::Any: Zonal gradient of log surf pressure

• ∇lnp_y::Any: Meridional gradient of log surf pressure

• u_mean_grid::Any: Vertical average of zonal velocity [m/s]

• v_mean_grid::Any: Vertical average of meridional velocity [m/s]

• div_mean_grid::Any: Vertical average of divergence [1/s], grid

• div_mean::Any: Vertical average of divergence [1/s], spectral

• scratch_memory::Any: Scratch memory for the transforms

DynamicsVariables(SG::SpectralGrid; spectral_transform)

Generator function. If a spectral_transform is handed over, the same scratch memory is used.

Create a struct Earth<:AbstractPlanet, with the following physical/orbital characteristics. Note that radius is not part of it as this should be chosen in SpectralGrid. Keyword arguments are

• radius::AbstractFloat: Earth's radius [m]

• rotation::AbstractFloat: angular frequency of Earth's rotation [rad/s]

• gravity::AbstractFloat: gravitational acceleration [m/s^2]

• daily_cycle::Bool: switch on/off daily cycle

• length_of_day::Second: Seconds in a daily rotation

• seasonal_cycle::Bool: switch on/off seasonal cycle

• length_of_year::Second: Seconds in an orbit around the sun

• equinox::DateTime: time of spring equinox (year irrelevant)

• axial_tilt::AbstractFloat: angle [˚] rotation axis tilt wrt to orbit

• solar_constant::AbstractFloat: Total solar irradiance at the distance of 1 AU [W/m²]

Create a struct EarthAtmosphere <: AbstractAtmosphere, with the following physical/chemical characteristics. Keyword arguments are

• mol_mass_dry_air::AbstractFloat: molar mass of dry air [g/mol]

• mol_mass_vapour::AbstractFloat: molar mass of water vapour [g/mol]

• heat_capacity::AbstractFloat: specific heat at constant pressure cₚ [J/K/kg]

• R_gas::AbstractFloat: universal gas constant [J/K/mol]

• R_dry::AbstractFloat: specific gas constant for dry air [J/kg/K]

• R_vapour::AbstractFloat: specific gas constant for water vapour [J/kg/K]

• mol_ratio::AbstractFloat: Ratio of gas constants: dry air / water vapour, often called ε [1]

• μ_virt_temp::AbstractFloat: Virtual temperature Tᵥ calculation, Tᵥ = T(1 + μ*q), humidity q, absolute tempereature T

• κ::AbstractFloat: = R_dry/cₚ, gas const for air over heat capacity

• water_density::AbstractFloat: water density [kg/m³]

• latent_heat_condensation::AbstractFloat: latent heat of condensation [J/kg]

• latent_heat_sublimation::AbstractFloat: latent heat of sublimation [J/kg]

• stefan_boltzmann::AbstractFloat: stefan-Boltzmann constant [W/m²/K⁴]

• pres_ref::AbstractFloat: surface reference pressure [Pa]

• temp_ref::AbstractFloat: surface reference temperature [K]

• moist_lapse_rate::AbstractFloat: reference moist-adiabatic temperature lapse rate [K/m]

• dry_lapse_rate::AbstractFloat: reference dry-adiabatic temperature lapse rate [K/m]

• layer_thickness::AbstractFloat: layer thickness for the shallow water model [m]

Land-sea mask, fractional, read from file.

• path::String: path to the folder containing the land-sea mask file, pkg path default

• file::String: filename of land sea mask

• file_Grid::Type{<:AbstractGrid}: Grid the land-sea mask file comes on

• quantization::Float64: [OPTION] Quantization to fraction?

• mask::Any: Land-sea mask [1] on grid-point space. Land=1, sea=0, land-area fraction in between.

Earth's orography read from file, with smoothing.

• path::String: path to the folder containing the orography file, pkg path default

• file::String: filename of orography

• file_Grid::Type{<:AbstractGrid}: Grid the orography file comes on

• scale::Any: scale orography by a factor

• smoothing::Bool: smooth the orography field?

• smoothing_power::Any: power of Laplacian for smoothing

• smoothing_strength::Any: highest degree l is multiplied by

• smoothing_fraction::Any: fraction of highest wavenumbers to smooth

• orography::Any: height [m] on grid-point space.

• geopot_surf::Any: surface geopotential, height*gravity [m²/s²]

Feedback struct that contains options and object for command-line feedback like the progress meter.

• verbose::Bool: [OPTION] print feedback to REPL?, default is isinteractive(), true in interactive REPL mode

• debug::Bool: [OPTION] check for NaNs in the prognostic variables

• description::String: [OPTION] Progress description

• showspeed::Bool: [OPTION] show speed in progress meter?

• progress_meter::ProgressMeter.Progress: [DERIVED] struct containing everything progress related

• nans_detected::Bool: [DERIVED] did NaNs occur in the simulation?

Construct Geometry struct containing parameters and arrays describing an iso-latitude grid <:AbstractGrid and the vertical levels. Pass on SpectralGrid to calculate the following fields

• spectral_grid::SpectralGrid: SpectralGrid that defines spectral and grid resolution

• nlat_half::Int64: resolution parameter nlat_half of Grid, # of latitudes on one hemisphere (incl Equator)

• nlon_max::Int64: maximum number of longitudes (at/around Equator)

• nlat::Int64: number of latitude rings

• nlayers::Int64: number of vertical levels

• npoints::Int64: total number of horizontal grid points

• radius::Base.RefValue: Planet's radius [m], set from model.planet during initialize!

• lond::Any: array of longitudes in degrees (0...360˚), empty for non-full grids

• latd::Any: array of latitudes in degrees (90˚...-90˚)

• lat::Any: array of latitudes in radians (π...-π)

• colat::Any: array of colatitudes in radians (0...π)

• londs::Any: longitude (0˚...360˚) for each grid point in ring order

• latds::Any: latitude (-90˚...˚90) for each grid point in ring order

• lons::Any: longitude (0...2π) for each grid point in ring order

• lats::Any: latitude (-π/2...π/2) for each grid point in ring order

• sinlat::Any: sin of latitudes

• coslat::Any: cos of latitudes

• coslat⁻¹::Any: = 1/cos(lat)

• coslat²::Any: = cos²(lat)

• coslat⁻²::Any: # = 1/cos²(lat)

• σ_levels_half::Any: σ at half levels, σ_k+1/2

• σ_levels_full::Any: σ at full levels, σₖ

• σ_levels_thick::Any: σ level thicknesses, σₖ₊₁ - σₖ

• ln_σ_levels_full::Any: log of σ at full levels, include surface (σ=1) as last element

• full_to_half_interpolation::Any: Full to half levels interpolation

Geometry(
    SG::SpectralGrid;
    vertical_coordinates
) -> Geometry{var"#s107", _A, <:AbstractVector} where {var"#s107"<:AbstractFloat, _A}

Generator function for Geometry struct based on spectral_grid.

Callback that records the global mean surface temperature on every time step.

• timestep_counter::Int64

• temp::Vector

Transformed prognostic variables (and u, v, temp_virt) into grid-point space.

• grid::Any

• nlayers::Int64

• vor_grid::Any: Relative vorticity of the horizontal wind [1/s]

• div_grid::Any: Divergence of the horizontal wind [1/s]

• temp_grid::Any: Absolute temperature [K]

• temp_virt_grid::Any: Virtual temperature [K]

• humid_grid::Any: Specific_humidity [kg/kg]

• u_grid::Any: Zonal velocity [m/s]

• v_grid::Any: Meridional velocity [m/s]

• pres_grid::Any: Logarithm of surface pressure [Pa]

• tracers_grid::Dict{Symbol}: Tracers [?]

• random_pattern::Any: Random pattern controlled by random process [1]

• temp_grid_prev::Any: Absolute temperature [K] at previous time step

• humid_grid_prev::Any: Specific humidity [kg/kg] at previous time step

• u_grid_prev::Any: Zonal velocity [m/s] at previous time step

• v_grid_prev::Any: Meridional velocity [m/s] at previous time step

• pres_grid_prev::Any: Logarithm of surface pressure [Pa] at previous time step

• tracers_grid_prev::Dict{Symbol}: Tracers [?] at previous time step

.

GridVariables(
    SG::SpectralGrid
) -> GridVariables{var"#s107", var"#s108", _A, <:AbstractArray, <:AbstractArray} where {var"#s107"<:AbstractFloat, var"#s108"<:AbstractArray, _A}

Generator function.

Temperature relaxation from Held and Suarez, 1996 BAMS

• nlat::Int64: number of latitude rings

• nlayers::Int64: number of vertical levels

• σb::AbstractFloat: sigma coordinate below which faster surface relaxation is applied

• relax_time_slow::Second: time scale for slow global relaxation

• relax_time_fast::Second: time scale for faster tropical surface relaxation

• Tmin::AbstractFloat: minimum equilibrium temperature [K]

• Tmax::AbstractFloat: maximum equilibrium temperature [K]

• ΔTy::AbstractFloat: meridional temperature gradient [K]

• Δθz::AbstractFloat: vertical temperature gradient [K]

• κ::Base.RefValue{NF} where NF<:AbstractFloat

• p₀::Base.RefValue{NF} where NF<:AbstractFloat

• temp_relax_freq::Matrix{NF} where NF<:AbstractFloat

• temp_equil_a::Vector{NF} where NF<:AbstractFloat

• temp_equil_b::Vector{NF} where NF<:AbstractFloat

HeldSuarez(SG::SpectralGrid; kwargs...) -> HeldSuarez

create a HeldSuarez temperature relaxation with arrays allocated given spectral_grid

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Horizontal hyper diffusion of vor, div, temp, humid; implicitly in spectral space with a power of the Laplacian (default = 4) and the strength controlled by time_scale (default = 1 hour). For vorticity and divergence, by default, the time_scale (=1/strength of diffusion) is reduced with increasing resolution through resolution_scaling and the power is linearly decreased in the vertical above the tapering_σ sigma level to power_stratosphere (default 2).

For the BarotropicModel and ShallowWaterModel no tapering or scaling is applied. Fields and options are

• trunc::Int64: spectral resolution

• nlayers::Int64: number of vertical levels

• power::Any: [OPTION] power of Laplacian

• time_scale::Second: [OPTION] diffusion time scale

• time_scale_div::Second: [OPTION] diffusion time scale for temperature and humidity

• resolution_scaling::Any: [OPTION] stronger diffusion with resolution? 0: constant with trunc, 1: (inverse) linear with trunc, etc

• power_stratosphere::Any: [OPTION] different power for tropopause/stratosphere

• tapering_σ::Any: [OPTION] linearly scale towards power_stratosphere above this σ

• expl::Any

• impl::Any

• expl_div::Any

• impl_div::Any

HyperDiffusion(
    spectral_grid::SpectralGrid;
    kwargs...
) -> HyperDiffusion{<:AbstractFloat}

Generator function based on the resolutin in spectral_grid. Passes on keyword arguments.

Large-scale condensation with implicit time stepping.

• relative_humidity_threshold::AbstractFloat: [OPTION] Relative humidity threshold [1 = 100%] to trigger condensation

• reevaporation::AbstractFloat: [OPTION] Reevaporation efficiency [1/(kg/kg)], 0 for no reevaporation

• snow::Bool: [OPTION] Convert rain below freezing to snow?

• freezing_threshold::AbstractFloat: [OPTION] Freezing temperature for snow fall [K]

• melting_threshold::AbstractFloat: [OPTION] Melting temperature for snow fall [K]

• time_scale::AbstractFloat: [OPTION] Time scale in multiples of time step Δt, the larger the less immediate

Struct that holds various precomputed arrays for the semi-implicit correction to prevent gravity waves from amplifying in the primitive equation model.

• trunc::Int64: Spectral resolution

• nlayers::Int64: Number of vertical layers

• α::Any: Time-step coefficient: 0=explicit, 0.5=centred implicit, 1=backward implicit

• reinitialize::Bool: Reinitialize at restart when initialized=true

• initialized::Bool: Flag automatically set to true when initialize! has been called

• temp_profile::Any: vertical temperature profile, obtained from diagn on first time step

• ξ::Base.RefValue: time step 2α*Δt packed in RefValue for mutability

• R::Any: divergence: operator for the geopotential calculation

• U::Any: divergence: the -RdTₖ∇² term excl the eigenvalues from ∇² for divergence

• L::Any: temperature: operator for the TₖD + κTₖDlnps/Dt term

• W::Any: pressure: vertical averaging of the -D̄ term in the log surface pres equation

• L0::Any: components to construct L, 1/ 2Δσ

• L1::Any: vert advection term in the temperature equation (below+above)

• L2::Any: factor in front of the divsumabove term

• L3::Any: sumabove operator itself

• L4::Any: factor in front of div term in Dlnps/Dt

• S::Any: for every l the matrix to be inverted

• S⁻¹::Any: combined inverted operator: S = 1 - ξ²(RL + UW)

ImplicitPrimitiveEquation(
    spectral_grid::SpectralGrid;
    kwargs...
) -> ImplicitPrimitiveEquation{<:AbstractFloat, <:AbstractVector, <:AbstractMatrix, <:AbstractArray}

Generator using the resolution from SpectralGrid.

Struct that holds various precomputed arrays for the semi-implicit correction to prevent gravity waves from amplifying in the shallow water model. The implicit time step between i-1 and i+1 is controlled by the parameter α in the range [0, 1]

α = 0   means the gravity wave terms are evaluated at i-1 (forward)
α = 0.5 evaluates at i+1 and i-1 (centered implicit)
α = 1   evaluates at i+1 (backward implicit)
α ∈ [0.5, 1] are also possible which controls the strength of the gravity wave dampening.
α = 0.5 slows gravity waves and prevents them from amplifying
α > 0.5 will dampen the gravity waves within days to a few timesteps (α=1)

Fields are

• α::Any: [OPTION] coefficient for semi-implicit computations to filter gravity waves, 0.5 <= α <= 1

• time_step::Any: Time step [s], = αdt = 2αΔt (for leapfrog)

ImplicitShallowWater(
    SG::SpectralGrid;
    kwargs...
) -> ImplicitShallowWater{<:AbstractFloat}

Generator using the resolution from spectral_grid.

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Output writer for a JLD2 file that saves the PrognosticVariables and DiagnosticVariables structs directly to a JLD2 file. All internal scalings and units are still applied to these outputs. Fields are

• active::Bool

• path::String: [OPTION] path to output folder, run_???? will be created within

• run_prefix::String: [OPTION] Prefix for run folder where data is stored, e.g. 'run_'

• id::String: [OPTION] run identification, added between runprefix and runnumber

• run_number::Int64: [OPTION] run identification number, automatically determined if overwrite=false

• run_digits::Int64: [OPTION] run numbers digits

• run_folder::String: [DERIVED] folder name where data is stored, determined at initialize!

• run_path::String: [DERIVED] full path to folder where data is stored, determined at initialize!

• overwrite::Bool: [OPTION] Overwrite an existing run folder?

• filename::String: [OPTION] name of the output jld2 file

• write_restart::Bool: [OPTION] also write restart file if output=true?

• write_parameters_txt::Bool: [OPTION] also write parameters txt file if output=true?

• write_progress_txt::Bool: [OPTION] also write progress txt file if output=true?

• output_dt::Second: [OPTION] output frequency, time step

• merge_output::Bool: [OPTION] will reopen and resave the file to merge everything in one big vector. Turn off if the file is too large for memory.

• output_prognostic::Bool: [OPTION] output the PrognosticVariables

• output_diagnostic::Bool: [OPTION] output the DiagnosticVariables as well

• output_every_n_steps::Int64

• timestep_counter::Int64

• output_counter::Int64

• jld2_file::Union{Nothing, JLD2.JLDFile}

HeldSuarez-like temperature relaxation, but towards the Jablonowski temperature profile with increasing temperatures in the stratosphere.

JablonowskiRelaxation(
    SG::SpectralGrid;
    kwargs...
) -> JablonowskiRelaxation

create a JablonowskiRelaxation temperature relaxation with arrays allocated given spectral_grid

Create a struct that contains all parameters for the Jablonowski and Williamson, 2006 intitial conditions for the primitive equation model. Default values as in Jablonowski.

• η₀::Float64: conversion from σ to Jablonowski's ηᵥ-coordinates

• σ_tropopause::Float64: Sigma coordinates of the tropopause [1]

• u₀::Float64: max amplitude of zonal wind [m/s]

• ΔT::Float64: temperature difference used for stratospheric lapse rate [K], Jablonowski uses ΔT = 4.8e5 [K]

• Tmin::Float64: minimum temperature [K] of profile

Temperature flux longwave radiation from Jeevanjee and Romps, 2018, following Seeley and Wordsworth, 2023, eq (1)

dF/dT = α*(T_t - T)

with F the upward temperature flux between two layers with temperature difference dT, α = 0.025 W/m²/K² and T_t = 200K a prescribed tropopause temperature. Flux into the lowermost layer is 0. Flux out of uppermost layer also 0, but dT/dt = (T_t - T)/τ is added to relax the uppermost layer towards the tropopause temperature T_t with time scale τ = 24h (Seeley and Wordsworth, 2023 use 6h, which is unstable a low resolutions here). Fields are

• α::Any: [OPTION] Radiative forcing constant (W/m²/K²)

• emissivity_ocean::Any: [OPTION] Effective emissivity for surface flux over ocean [1]

• emissivity_land::Any: [OPTION] Effective emissivity for surface flux over land [1]

• temp_tropopause::Any: [OPTION] Tropopause temperature [K]

• time_scale::Second: [OPTION] Tropopause relaxation time scale to temp_tropopause

Forcing term for the Barotropic or ShallowWaterModel with an idealised jet stream similar to the initial conditions from Galewsky, 2004, but mirrored for both hemispheres.

• nlat::Int64: Number of latitude rings

• nlayers::Int64: Number of vertical layers

• latitude::Any: jet latitude [˚N]

• width::Any: jet width [˚], default ≈ 19.29˚

• sigma::Any: sigma level [1], vertical location of jet

• speed::Any: jet speed scale [m/s]

• time_scale::Second: time scale [days]

• amplitude::Any: precomputed amplitude vector [m/s²]

• tapering::Any: precomputed vertical tapering

Kolmogorov flow forcing. Fields are

• strength::Any: [OPTION] Strength of forcing [1/s²]

• wavenumber::Any: [OPTION] Wavenumber of forcing in meridional direction (pole to pole)

MITgcm's two-layer soil model (https://mitgcm.readthedocs.io/en/latest/phys_pkgs/land.html). Fields assert

• mask::Bool: [OPTION] Apply land-sea mask to set ocean-only points?

• ocean_temperature::Any: [OPTION] Initial soil temperature over ocean [K]

Defines netCDF output for a specific variable, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

• rate::Any

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

• rate::Any

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

Leapfrog time stepping defined by the following fields

• trunc::Int64: [DERIVED] Spectral resolution (max degree of spherical harmonics)

• nsteps::Int64: [CONST] Number of time steps stored simultaneously in prognostic variables

• Δt_at_T31::Second: [OPTION] Time step in minutes for T31, scale linearly to trunc

• adjust_with_output::Bool: [OPTION] Adjust Δt_at_T31 with the output_dt to reach output_dt exactly in integer time steps

• start_with_euler::Bool: [OPTION] Start integration with (1) Euler step with dt/2, (2) Leapfrog step with dt

• continue_with_leapfrog::Bool: [OPTION] Sets first_step_euler=false after first step to continue with leapfrog after 1st run! call

• first_step_euler::Bool: [DERIVED] Use Euler on first time step? (controlled by start_with_euler and continue_with_leapfrog)

• robert_filter::AbstractFloat: [OPTION] Robert (1966) time filter coefficient to suppress the computational mode

• williams_filter::AbstractFloat: [OPTION] Williams time filter (Amezcua 2011) coefficient for 3rd order acc

• radius::AbstractFloat: [DERIVED] Radius of sphere [m], used for scaling, set in initialize! to planet.radius

• Δt_millisec::Millisecond: [DERIVED] Time step Δt in milliseconds at specified resolution

• Δt_sec::AbstractFloat: [DERIVED] Time step Δt [s] at specified resolution

• Δt::AbstractFloat: [DERIVED] Time step Δt [s/m] at specified resolution, scaled by 1/radius

Leapfrog(spectral_grid::SpectralGrid; kwargs...) -> Leapfrog

Generator function for a Leapfrog struct using spectral_grid for the resolution information.

Linear boundary layer drag following Held and Suarez, 1996 BAMS

• nlayers::Int64

• σb::AbstractFloat

• time_scale::Second

• drag_coefs::Vector{NF} where NF<:AbstractFloat

LinearDrag(SG::SpectralGrid; kwargs...) -> LinearDrag

Generator function using nlayers from SG::SpectralGrid

Manual albedo field, to be used with set! and is copied into the diagnostic variables on every time step. Defined so that parameterizations can change the albedo at every time step (e.g. snow cover) without losing the information of the original surface albedo. Fields are

• albedo::Any

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Millenium <: Period

Convenience time type representing a 1000-year period.

NetCDFOutput(
    SG::SpectralGrid;
    ...
) -> NetCDFOutput{Field2D, Field3D, Interpolator} where {Field2D<:(Union{Field{_A, _B, _C, <:AbstractFullGrid{Architecture}} where Architecture, Field{_A, _B, _C, Grid} where {Architecture, Grid<:AbstractFullGrid{Architecture}}} where {_A, _B, _C<:AbstractArray}), Field3D<:(Union{Field{_A, _B, _C, <:AbstractFullGrid{Architecture}} where Architecture, Field{_A, _B, _C, Grid} where {Architecture, Grid<:AbstractFullGrid{Architecture}}} where {_A, _B, _C<:AbstractArray}), Interpolator<:AnvilInterpolator}
NetCDFOutput(
    SG::SpectralGrid,
    Model::Type{<:AbstractModel};
    output_grid,
    output_NF,
    output_dt,
    kwargs...
) -> NetCDFOutput{Field2D, Field3D, Interpolator} where {Field2D<:(Union{Field{_A, _B, _C, <:AbstractFullGrid{Architecture}} where Architecture, Field{_A, _B, _C, Grid} where {Architecture, Grid<:AbstractFullGrid{Architecture}}} where {_A, _B, _C<:AbstractArray}), Field3D<:(Union{Field{_A, _B, _C, <:AbstractFullGrid{Architecture}} where Architecture, Field{_A, _B, _C, Grid} where {Architecture, Grid<:AbstractFullGrid{Architecture}}} where {_A, _B, _C<:AbstractArray}), Interpolator<:AnvilInterpolator}

Constructor for NetCDFOutput based on S::SpectralGrid and optionally the Model type (e.g. ShallowWater, PrimitiveWet) as second positional argument. The output grid is optionally determined by keyword arguments output_Grid (its type, full grid required), nlat_half (resolution) and output_NF (number format). By default, uses the full grid equivalent of the grid and resolution used in SpectralGrid S.

Output writer for a netCDF file with (re-)gridded variables. Interpolates non-rectangular grids. Fields are

• active::Bool

• path::String: [OPTION] path to output parent folder, run folders will be created within

• run_prefix::String: [OPTION] Prefix for run folder where data is stored, e.g. 'run_'

• id::String: [OPTION] run identification, added between runprefix and runnumber

• run_number::Int64: [OPTION] run identification number, automatically determined if overwrite=false

• run_digits::Int64: [OPTION] run numbers digits

• run_folder::String: [DERIVED] folder name where data is stored, determined at initialize!

• run_path::String: [DERIVED] full path to folder where data is stored, determined at initialize!

• overwrite::Bool: [OPTION] Overwrite an existing run folder?

• filename::String: [OPTION] name of the output netcdf file

• write_restart::Bool: [OPTION] also write restart file if output=true?

• write_parameters_txt::Bool: [OPTION] also write parameters txt file if output=true?

• write_progress_txt::Bool: [OPTION] also write progress txt file if output=true?

• startdate::DateTime: [DERIVD] start date of the simulation, used for time dimension in netcdf file

• output_dt::Second: [OPTION] output frequency, time step

• variables::Dict{Symbol, SpeedyWeather.AbstractOutputVariable}: [OPTION] dictionary of variables to output, e.g. u, v, vor, div, pres, temp, humid

• output_every_n_steps::Int64

• timestep_counter::Int64

• output_counter::Int64

• netcdf_file::Union{Nothing, NCDatasets.NCDataset}

• interpolator::Any

• field2D::Any

• field3D::Any

• field3Dland::Any

Dummy callback that doesn't do anything.

Orography with zero height in orography and zero surface geopotential geopot_surf.

• orography::Any: height [m] on grid-point space.

• geopot_surf::Any: surface geopotential, height*gravity [m²/s²]

Dummy output variable that doesn't do anything.

Returns the surface temperature and humidity without perturbation from the lowermost layer.

Returns the surface temperature and humidity without perturbation from the lowermost layer. Used as a functor.

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

ParametersTxt callback. Writes a parameters.txt file with all model parameters. Options are

• path::String: [OPTION] Path for parameters.txt file, uses model.output.run_path if not specified

• filename::String: [OPTION] File name for parameters.txt file

• write_only_with_output::Bool: [OPTION] Only write with model.output.active = true?

Particle with location lon (longitude), lat (latitude) and σ (vertical coordinate). Longitude is assumed to be in [0,360˚E), latitude in [-90˚,90˚N] and σ in [0,1] but not strictly enforced at creation, see mod(::Particle) and ismod(::Particle). A particle is either active or inactive, determined by the active field. By default, a particle is active, of number format DEFAULT_NF and at 0˚N, 0˚E, σ=0.

• active::Bool: activity

• lon::AbstractFloat: longitude in [0,360˚]

• lat::AbstractFloat: latitude [-90˚,90˚]

• σ::AbstractFloat: vertical sigma coordinate [0 (top) to 1 (surface)]

A ParticleTracker is implemented as a callback to output the trajectories of particles from particle advection. To be added like

add!(model.callbacks, ParticleTracker(spectral_grid; kwargs...))

Output done via netCDF. Fields and options are

• schedule::Schedule: [OPTION] when to schedule particle tracking

• filename::String: [OPTION] File name for netCDF file

• path::String: [OPTION] Path for netCDF file, uses model.output.run_path if not specified

• compression_level::Int64: [OPTION] lossless compression level; 1=low but fast, 9=high but slow

• shuffle::Bool: [OPTION] shuffle/bittranspose filter for compression

• keepbits::Int64: [OPTION] mantissa bits to keep, (14, 15, 16) means at least (2km, 1km, 500m) accurate locations

• nparticles::Int64: Number of particles to track

• netcdf_file::Union{Nothing, NCDatasets.NCDataset}: The netcdf file to be written into, will be created at initialization

• lon::Vector

• lat::Vector

• σ::Vector

Diagnostic variables for the particle advection

• nparticles::Int64: Number of particles

• locations::Any: Work array: particle locations

• u::Any: Work array: velocity u

• v::Any: Work array: velocity v

• σ_tend::Any: Work array: velocity w = dσ/dt

• interpolator::Any: Interpolator to interpolate velocity fields onto particle positions

ParticleVariables(
    SG::SpectralGrid
) -> ParticleVariables{var"#s107", var"#s108", var"#s119", VectorNF, Interpolator} where {var"#s107"<:AbstractFloat, var"#s108"<:AbstractArray, var"#s119"<:AbstractArray, VectorNF<:(Vector{<:AbstractFloat}), Interpolator<:(AnvilInterpolator{NF, Geometry, Locator} where {Locator, Geometry, NF})}

Generator function.

Diagnostic variables of the physical parameterizations.

• grid::Any

• ocean::DynamicsVariablesOcean

• land::DynamicsVariablesLand

• rain_large_scale::Any: Accumulated large-scale rain [m]

• rain_convection::Any: Accumulated convective rain [m]

• snow_large_scale::Any: Accumulated large-scale snow [m]

• snow_convection::Any: Accumulated convective snow [m]

• total_precipitation_rate::Any: Rate of total precipitation (rain+snow) [kg/m²/s]

• cloud_top::Any: Cloud top [m]

• sensible_heat_flux::Any: Sensible heat flux [W/m²], positive up

• surface_humidity_flux::Any: Surface humidity flux [kg/s/m^2], positive up

• surface_latent_heat_flux::Any: Surface latent heat flux [W/m²], positive up

• surface_shortwave_up::Any: Surface radiation: shortwave up [W/m²]

• surface_shortwave_down::Any: Surface radiation: shortwave down [W/m²]

• surface_longwave_up::Any: Surface radiation: longwave up [W/m²]

• surface_longwave_down::Any: Surface radiation: longwave down [W/m²]

• outgoing_shortwave_radiation::Any: Outgoing shortwave radiation [W/m^2]

• outgoing_longwave_radiation::Any: Outgoing longwave radiation [W/m^2]

• albedo::Any: Albedo [1]

• cos_zenith::Any: Cosine of solar zenith angle [1]

PhysicsVariables(
    SG::SpectralGrid
) -> PhysicsVariables{var"#s107", var"#s108", _A, <:AbstractArray} where {var"#s107"<:AbstractFloat, var"#s108"<:AbstractArray, _A}

Generator function.

The PrimitiveDryModel contains all model components (themselves structs) needed for the simulation of the primitive equations without humidity. To be constructed like

model = PrimitiveDryModel(spectral_grid; kwargs...)

with spectral_grid::SpectralGrid used to initalize all non-default components passed on as keyword arguments, e.g. planet=Earth(spectral_grid). Fields, representing model components, are

• spectral_grid::SpectralGrid

• architecture::Any

• dynamics::Bool

• geometry::Any

• planet::Any

• atmosphere::Any

• coriolis::Any

• geopotential::Any

• adiabatic_conversion::Any

• particle_advection::Any

• initial_conditions::Any

• forcing::Any

• drag::Any

• random_process::Any

• tracers::Dict{Symbol, Tracer}

• orography::Any

• land_sea_mask::Any

• ocean::Any

• sea_ice::Any

• land::Any

• solar_zenith::Any

• albedo::Any

• physics::Bool

• boundary_layer_drag::Any

• temperature_relaxation::Any

• vertical_diffusion::Any

• surface_thermodynamics::Any

• surface_wind::Any

• surface_heat_flux::Any

• convection::Any

• optical_depth::Any

• shortwave_radiation::Any

• longwave_radiation::Any

• stochastic_physics::Any

• time_stepping::Any

• spectral_transform::Any

• implicit::Any

• horizontal_diffusion::Any

• vertical_advection::Any

• output::Any

• callbacks::Dict{Symbol, SpeedyWeather.AbstractCallback}

• feedback::Any

The PrimitiveWetModel contains all model components (themselves structs) needed for the simulation of the primitive equations with humidity. To be constructed like

model = PrimitiveWetModel(spectral_grid; kwargs...)

with spectral_grid::SpectralGrid used to initalize all non-default components passed on as keyword arguments, e.g. planet=Earth(spectral_grid). Fields, representing model components, are

• spectral_grid::SpectralGrid

• architecture::Any

• dynamics::Bool

• geometry::Any

• planet::Any

• atmosphere::Any

• coriolis::Any

• geopotential::Any

• adiabatic_conversion::Any

• particle_advection::Any

• initial_conditions::Any

• forcing::Any

• drag::Any

• random_process::Any

• tracers::Dict{Symbol, Tracer}

• orography::Any

• land_sea_mask::Any

• ocean::Any

• sea_ice::Any

• land::Any

• solar_zenith::Any

• albedo::Any

• physics::Bool

• clausius_clapeyron::Any

• boundary_layer_drag::Any

• temperature_relaxation::Any

• vertical_diffusion::Any

• surface_thermodynamics::Any

• surface_wind::Any

• surface_heat_flux::Any

• surface_humidity_flux::Any

• large_scale_condensation::Any

• convection::Any

• optical_depth::Any

• shortwave_radiation::Any

• longwave_radiation::Any

• stochastic_physics::Any

• time_stepping::Any

• spectral_transform::Any

• implicit::Any

• horizontal_diffusion::Any

• vertical_advection::Any

• hole_filling::Any

• output::Any

• callbacks::Dict{Symbol, SpeedyWeather.AbstractCallback}

• feedback::Any

PrognosticVariables(
    SG::SpectralGrid,
    model::AbstractModel
) -> PrognosticVariables{var"#s107", var"#s108", _A, _B, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray} where {var"#s107"<:AbstractFloat, var"#s108"<:AbstractArray, _A, _B}

Generator function.

PrognosticVariables(
    SG::SpectralGrid{Architecture, SpectrumType, GridType};
    nsteps
) -> PrognosticVariables{var"#s107", var"#s108", _A, _B, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray} where {var"#s107"<:AbstractFloat, var"#s108"<:AbstractArray, _A, _B}

Generator function.

ProgressTxt callback. Writes a progress.txt file with time stepping progress. Options are

• path::String: [OPTION] Path for progress.txt file, uses model.output.run_path if not specified

• filename::String: [OPTION] File name for progress.txt file

• write_only_with_output::Bool: [OPTION] Only write with model.output.active = true?

• every_n_percent::Int64: [OPTION] Every n% of time steps write to progress.txt, default is 5%

• file::IOStream: [DERIVED] IOStream for progress.txt file

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Start with random velocity as initial conditions

• max_speed::Float64: [OPTION] maximum speed [ms⁻¹]

• truncation::Int64: [OPTION] Maximum wavenumber after truncation

• seed::Int64: [OPTION] Random number generator seed, 0=randomly seed from Julia's GLOBAL_RNG

• random_number_generator::Random.Xoshiro: Independent random number generator for this random process

Start with random vorticity as initial conditions

• power::Float64: [OPTION] Power of the spectral distribution k^power

• amplitude::Float64: [OPTION] the (approximate) amplitude in [1/s], used as standard deviation of spherical harmonic coefficients

• max_wavenumber::Int64: [OPTION] Maximum wavenumber

• seed::Int64: [OPTION] Random number generator seed, 0=randomly seed from Julia's GLOBAL_RNG

• random_number_generator::Random.Xoshiro: Independent random number generator for this random process

Parameters for random initial conditions for the interface displacement η in the shallow water equations.

• A::Float64

• lmin::Int64

• lmax::Int64

RestartFile callback. Writes a restart file as .jld2. Options are

• filename::String: [OPTION] File name for restart file, should end with .jld2

• path::String: [OPTION] Path for restart file, uses model.output.run_path if not specified

• compress::Bool: [OPTION] Apply lossless compression in JLD2?

• write_only_with_output::Bool: [OPTION] Only write with model.output.active = true?

• pkg_version::VersionNumber: [DERIVED] package version to track possible incompatibilities

Defines netCDF output for a specific variable, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Land-sea mask with one = land everywhere.

• mask::Any: Land-sea mask [1] on grid-point space. Land=1, sea=0, land-area fraction in between.

Rossby-Haurwitz wave initial conditions as in Williamson et al. 1992, J Computational Physics with an additional cut-off amplitude c to filter out tiny harmonics in the vorticity field. Parameters are

• m::Int64

• ω::Float64

• K::Float64

• c::Float64

A schedule for callbacks, to execute them periodically after a given period has passed (first timestep excluded) or on/after specific times (initial time excluded). For two consecutive time steps i, i+1, an event is scheduled at i+1 when it occurs in (i,i+1]. Similarly, a periodic schedule of period p will be executed at start+p, but p is rounded to match the multiple of the model timestep. Periodic schedules and event schedules can be combined, executing at both. A Schedule is supposed to be added into callbacks as fields

Base.@kwdef struct MyCallback
    schedule::Schedule = Schedule(every=Day(1))
    other_fields
end

see also initialize!(::Schedule,::Clock) and isscheduled(::Schedule,::Clock). Fields

• every::Second: [OPTION] Execute every time period, first timestep excluded. Default=never.

• times::Vector{DateTime}: [OPTION] Events scheduled at times

• schedule::BitVector: Actual schedule, true=execute this timestep, false=don't

• steps::Int64: Number of scheduled executions

• counter::Int64: Count up the number of executions

Schedule(times::DateTime...) -> Schedule

A Schedule based on DateTime arguments, For two consecutive time steps i, i+1, an event is scheduled at i+1 when it occurs in (i,i+1].

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

Seasonal ocean climatology that reads monthly sea surface temperature fields from file, and interpolates them in time on every time step and writes them to the prognostic variables. Fields and options are

• grid::Any: Grid used for the model

• path::String: [OPTION] Path to the folder containing the sea surface temperatures, pkg path default

• file::String: [OPTION] Filename of sea surface temperatures

• varname::String: [OPTION] Variable name in netcdf file

• file_Grid::Type{<:AbstractGrid}: [OPTION] Grid the sea surface temperature file comes on

• missing_value::Any: [OPTION] The missing value in the data respresenting land

• monthly_temperature::Any: Monthly sea surface temperatures [K], interpolated onto Grid

The ShallowWaterModel contains all model components needed for the simulation of the shallow water equations. To be constructed like

model = ShallowWaterModel(spectral_grid; kwargs...)

with spectral_grid::SpectralGrid used to initalize all non-default components passed on as keyword arguments, e.g. planet=Earth(spectral_grid). Fields, representing model components, are

• spectral_grid::SpectralGrid

• architecture::Any

• geometry::Any

• planet::Any

• atmosphere::Any

• coriolis::Any

• orography::Any

• forcing::Any

• drag::Any

• particle_advection::Any

• initial_conditions::Any

• random_process::Any

• tracers::Dict{Symbol, Tracer}

• time_stepping::Any

• spectral_transform::Any

• implicit::Any

• horizontal_diffusion::Any

• output::Any

• callbacks::Dict{Symbol, SpeedyWeather.AbstractCallback}

• feedback::Any

Sigma coordinates for the vertical coordinates, defined by their half layers. Sigma coordinates are currently hardcoded in Geometry.

• nlayers::Int64

• σ_half::Any

The simplified Betts-Miller convection scheme from Frierson, 2007, https://doi.org/10.1175/JAS3935.1. This implements the qref-formulation in their paper. Fields and options are

• time_scale::Second: [OPTION] Relaxation time for profile adjustment

• relative_humidity::Any: [OPTION] Relative humidity for reference profile [1]

• surface_temp_humid::Any: [OPTION] Surface perturbation of temp, humid to calculate the moist pseudo adiabat

Simulation is a container struct to be used with run!(::Simulation). It contains

• prognostic_variables::Any: define the current state of the model

• diagnostic_variables::Any: contain the tendencies and auxiliary arrays to compute them

• model::AbstractModel: all parameters, constant at runtime

Coefficients to calculate the solar declination angle δ [radians] based on a simple sine function, with Earth's axial tilt as amplitude, equinox as phase shift.

• axial_tilt::Any

• equinox::DateTime

• length_of_year::Second

• length_of_day::Second

SinSolarDeclination functor, computing the solar declination angle of angular fraction of year g [radians] using the coefficients of the SinSolarDeclination struct.

Generator function using the planet's orbital parameters to adapt the solar declination calculation.

Generator function pulling the number format NF from a SpectralGrid.

Defines netCDF output for a specific variable, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Defines netCDF output for a specific variable, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• is_land::Bool

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Defines netCDF output for a specific variable, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• is_land::Bool

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

Coefficients to calculate the solar declination angle δ from

δ = 0.006918    - 0.399912*cos(g)  + 0.070257*sin(g)
                - 0.006758*cos(2g) + 0.000907*sin(2g)
                - 0.002697*cos(3g) + 0.001480*sin(3g)

with g the angular fraction of the year in radians. Following Spencer 1971, Fourier series representation of the position of the sun. Search 2(5):172.

• a::AbstractFloat

• s1::AbstractFloat

• c1::AbstractFloat

• s2::AbstractFloat

• c2::AbstractFloat

• s3::AbstractFloat

• c3::AbstractFloat

SolarDeclination functor, computing the solar declination angle of angular fraction of year g [radians] using the coefficients of the SolarDeclination struct.

Generator function pulling the number format NF from a SpectralGrid.

Coefficients for the solar time correction (also called Equation of time) which adjusts the solar hour to an oscillation of sunrise/set by about +-16min throughout the year.

Functor that returns the time correction for a angular fraction of the year g [radians], so that g=0 for Jan-01 and g=2π for Dec-31.

Solar zenith angle varying with daily and seasonal cycle.

• length_of_day::Second

• length_of_year::Second

• equation_of_time::Bool

• seasonal_cycle::Bool

• solar_declination::SpeedyWeather.SinSolarDeclination{NF} where NF<:AbstractFloat

• time_correction::SpeedyWeather.SolarTimeCorrection

• initial_time::Base.RefValue{DateTime}

Solar zenith angle varying with seasonal cycle only.

• length_of_day::Second

• length_of_year::Second

• seasonal_cycle::Bool

• solar_declination::SpeedyWeather.SinSolarDeclination{NF} where NF<:AbstractFloat

• initial_time::Base.RefValue{DateTime}

First-order auto-regressive random process (AR1) in spectral space, evolving wavenumbers with respectice time_scales and standard_deviations independently. Transformed after every time step to grid space with a clamp applied to limit extrema. For reproducability seed can be provided and an independent random_number_generator is used that is reseeded on every initialize!. Fields are:

• trunc::Int64

• time_scale::Second: [OPTION] Time scale of the AR1 process

• wavenumber::Int64: [OPTION] Wavenumber of the AR1 process

• standard_deviation::Any: [OPTION] Standard deviation of the AR1 process

• clamp::Tuple{NF, NF} where NF: [OPTION] Range to clamp values into after every transform into grid space

• seed::Int64: [OPTION] Random number generator seed, 0=randomly seed from Julia's GLOBAL_RNG

• random_number_generator::Random.Xoshiro: Independent random number generator for this random process

• autoregressive_factor::Base.RefValue: Precomputed auto-regressive factor [1], function of time scale and model time step

• noise_factors::Any: Precomputed noise factors [1] for every total wavenumber l

Spectral filter for horizontal diffusion. Fields are:

• trunc::Int64: spectral resolution

• nlayers::Int64: number of vertical levels

• shift::Any: [OPTION] shift diffusion to higher (positive shift) or lower (neg) wavenumbers, relative to trunc

• scale::Any: [OPTION] Scale-selectiveness, steepness of the sigmoid, higher is more selective

• time_scale::Second: [OPTION] diffusion time scale

• time_scale_div::Second: [OPTION] stronger diffusion time scale for divergence

• resolution_scaling::Any: [OPTION] resolution scaling to shorten time_scale with trunc

• power::Any: [OPTION] power of the tanh function

• power_div::Any: [OPTION] power of the tanh function for divergence

• expl::Any

• impl::Any

• expl_div::Any

• impl_div::Any

SpectralFilter(
    spectral_grid::SpectralGrid;
    kwargs...
) -> SpectralFilter{<:AbstractFloat}

Generator function based on the resolutin in spectral_grid. Passes on keyword arguments.

Defines the horizontal spectral resolution and corresponding grid and the vertical coordinate for SpeedyWeather.jl. Options are

• NF::Type{<:AbstractFloat}: [OPTION] number format used throughout the model

• architecture::Any: [OPTION] device architecture to run on

• ArrayType::Type{<:AbstractArray}: [OPTION] array type to use for all variables

• VectorType::Type{<:AbstractVector}: [DERIVED] Type of vector

• MatrixType::Type{<:AbstractMatrix}: [DERIVED] Type of matrix

• TensorType::Type{<:AbstractArray}: [DERIVED] Type of 3D array

• trunc::Int64: [OPTION] horizontal resolution as the maximum degree of spherical harmonics

• spectrum::Any: [DERIVED] spectral space

• SpectralVariable2D::Type{<:AbstractArray}: [DERIVED] Type of spectral variable in 2D (horizontal only, flattened into 1D vector)

• SpectralVariable3D::Type{<:AbstractArray}: [DERIVED] Type of spectral variable in 3D (horizontal only + e.g vertical, flattened into 2D matrix)

• SpectralVariable4D::Type{<:AbstractArray}: [DERIVED] Type of spectral variable in 4D (horizontal only + e.g. vertical and time, flattened into 3D array)

• dealiasing::Float64: [OPTION] how to match spectral with grid resolution: dealiasing factor, 1=linear, 2=quadratic, 3=cubic grid

• nlat_half::Int64: [DERIVED] number of latitude rings on one hemisphere (Equator incl)

• nlat::Int64: [DERIVED] number of latitude rings on both hemispheres

• npoints::Int64: [DERIVED] total number of grid points in the horizontal

• grid::Any: [DERIVED] instance of horizontal grid used for calculations in grid-point space

• Grid::Type{<:AbstractGrid}: [OPTION] type of horizontal grid used for calculations in grid-point space

• GridVariable2D::Type{<:AbstractArray}: [DERIVED] Type of grid variable in 2D (horizontal only, flattened into 1D vector)

• GridVariable3D::Type{<:AbstractArray}: [DERIVED] Type of grid variable in 3D (horizontal + e.g. vertical, flattened into 2D matrix)

• GridVariable4D::Type{<:AbstractArray}: [DERIVED] Type of grid variable in 4D (horizontal + e.g. vertical + time, flattened into 3D array)

• nparticles::Int64: [OPTION] number of particles for particle advection [1]

• ParticleVector::Type{<:AbstractArray}: [DERIVED] ArrayType of particle vector

• nlayers::Int64: [OPTION] number of vertical layers in the atmosphere

• nlayers_soil::Int64: [OPTION] number of vertical layers in the soil/land

nlat_half and npoints should not be chosen but are derived from trunc, Grid and dealiasing.

Restart from a previous SpeedyWeather.jl simulation via the restart file restart.jld2 Applies interpolation in the horizontal but not in the vertical. restart.jld2 is identified by

• path::String: path for restart file

• run_prefix::String: run prefix, e.g. 'run' in 'run_0001/restart.jld2'

• id::String: identification of run folder, e.g. 'set1' in 'runset10001/restart.jld2'

• run_number::Int64: run number, e.g. 1 in 'runset10001/restart.jld2'

• run_digits::Int64: run digits, e.g. 4 in 'runset10001/restart.jld2' for run_number=1

• run_folder::String: directly specify the run folder, e.q. 'run_0001'

• filename::String: File name of restart file, default 'restart.jld2'

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

Tendencies of the prognostic variables in spectral and grid-point space

• spectrum::Any

• grid::Any

• nlayers::Int64

• vor_tend::Any: Vorticity of horizontal wind field [1/s]

• div_tend::Any: Divergence of horizontal wind field [1/s]

• temp_tend::Any: Absolute temperature [K]

• humid_tend::Any: Specific humidity [kg/kg]

• u_tend::Any: Zonal velocity [m/s]

• v_tend::Any: Meridional velocity [m/s]

• pres_tend::Any: Logarithm of surface pressure [Pa]

• tracers_tend::Dict{Symbol}: Tracers [?]

• u_tend_grid::Any: Zonal velocity [m/s], grid

• v_tend_grid::Any: Meridinoal velocity [m/s], grid

• temp_tend_grid::Any: Absolute temperature [K], grid

• humid_tend_grid::Any: Specific humidity [kg/kg], grid

• pres_tend_grid::Any: Logarith of surface pressure [Pa], grid

• tracers_tend_grid::Dict{Symbol}: Tracers [?], grid

Tendencies(
    SG::SpectralGrid
) -> Tendencies{var"#s107", var"#s108", _A, _B, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray} where {var"#s107"<:AbstractFloat, var"#s108"<:AbstractArray, _A, _B}

Generator function.

Parameters for computing saturation vapour pressure of water using the Tetens' equation,

eᵢ(T) = e₀ * exp(Cᵢ * (T - T₀) / (T + Tᵢ)),

where T is in Kelvin and i = 1, 2 for saturation above and below freezing, respectively. From Tetens (1930), and Murray (1967) for below freezing.

• e₀::AbstractFloat: Saturation water vapour pressure at 0°C [Pa]

• T₀::AbstractFloat: 0°C in Kelvin

• T₁::AbstractFloat: Tetens denominator (water) [˚C]

• T₂::AbstractFloat: Tetens denominator following Murray (1967, below freezing) [˚C]

• C₁::AbstractFloat: Tetens numerator scaling [1], above freezing

• C₂::AbstractFloat: Tetens numerator scaling [1], below freezing

Functor: Saturation water vapour pressure as a function of temperature using the Tetens equation,

eᵢ(T) = e₀ * exp(Cᵢ * (T - T₀) / (T - Tᵢ)),

where T is in Kelvin and i = 1, 2 for saturation above and below freezing, respectively.

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

• transform::Any

Define tracer through a name::Symbol (used as key in the tracer dictionaries) and define it as active (=true default). active=false will (temporarily) disable the time evolution of the tracer. Fields are

• name::Symbol

• active::Bool

Uniform cooling following Paulius and Garner, 2006. JAS. https://doi.org/10.1175/JAS3705.1 imposing a default temperature tendency of -1.5K/day (=1K/16hours for a time_scale of 16 hours) on every level except for the stratosphere (diagnosed as temp < temp_min) where a relaxation term with time_scale_stratosphere towards temp_stratosphere is applied.

dT/dt = -1.5K/day for T > 207.5K else (200K-T) / 5 days

Fields are

• time_scale::Second: [OPTION] time scale of cooling, default = -1.5K/day = -1K/16hrs

• temp_min::Any: [OPTION] temperature [K] below which stratospheric relaxation is applied

• temp_stratosphere::Any: [OPTION] target temperature [K] of stratospheric relaxation

• time_scale_stratosphere::Second: [OPTION] time scale of stratospheric relaxation

Defines netCDF output of vorticity. Fields are

• name::String: [Required] short name of variable (unique) used in netCDF file and key for dictionary

• unit::String: [Required] unit of variable

• long_name::String: [Required] long name of variable used in netCDF file

• dims_xyzt::NTuple{4, Bool}: [Required] NetCDF dimensions the variable uses, lon, lat, layer, time

• missing_value::Float64: [Optional] missing value for the variable, if not specified uses NaN

• compression_level::Int64: [Optional] compression level of the lossless compressor, 1=lowest/fastest, 9=highest/slowest, 3=default

• shuffle::Bool: [Optional] bitshuffle the data for compression, false = default

• keepbits::Int64: [Optional] number of mantissa bits to keep for compression (default: 15)

• unscale::Bool: [Optional] Unscale the variable for output? (default: true)

Custom variable output defined similarly with required fields marked, optional fields otherwise use variable-independent defaults. Initialize with VorticityOutput() and non-default fields can always be passed on as keyword arguments, e.g. VorticityOutput(long_name="relative vorticity", compression_level=0). Custom variable output also requires the path(::MyOutputVariable, simulation) to be extended to return the AbstractField subject to output. Custom element-wise variable transforms, e.g. scale and/or offset to change units, or even exp(x)/100 to change from log surface pressure to hPa are passed on as transform::Function = x -> exp(x)/100.

A struct that contains all parameters for the Galewsky et al, 2004 zonal jet intitial conditions for the ShallowWaterModel. Default values as in Galewsky.

• latitude::Float64: jet latitude [˚N]

• width::Float64: jet width [˚], default ≈ 19.29˚

• umax::Float64: jet maximum velocity [m/s]

• perturb_lat::Float64: perturbation latitude [˚N], position in jet by default

• perturb_lon::Float64: perturbation longitude [˚E]

• perturb_xwidth::Float64: perturbation zonal extent [˚], default ≈ 19.1˚

• perturb_ywidth::Float64: perturbation meridinoal extent [˚], default ≈ 3.8˚

• perturb_height::Float64: perturbation amplitude [m]

Zonal ridge orography after Jablonowski and Williamson, 2006.

• η₀::Any: conversion from σ to Jablonowski's ηᵥ-coordinates

• u₀::Any: max amplitude of zonal wind [m/s] that scales orography height

• orography::Any: height [m] on grid-point space.

• geopot_surf::Any: surface geopotential, height*gravity [m²/s²]

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Defines netCDF output for a specific variables, see VorticityOutput for details. Fields are:

• name::String

• unit::String

• long_name::String

• dims_xyzt::NTuple{4, Bool}

• missing_value::Float64

• compression_level::Int64

• shuffle::Bool

• keepbits::Int64

Create a struct that contains all parameters for the Jablonowski and Williamson, 2006 intitial conditions for the primitive equation model. Default values as in Jablonowski.

• η₀::Float64: conversion from σ to Jablonowski's ηᵥ-coordinates

• u₀::Float64: [OPTION] max amplitude of zonal wind [m/s]

• perturb_lat::Float64: [OPTION] perturbation centred at [˚N]

• perturb_lon::Float64: [OPTION] perturbation centred at [˚E]

• perturb_uₚ::Float64: [OPTION] perturbation strength [m/s]

• perturb_radius::Float64: [OPTION] radius of Gaussian perturbation in units of Earth's radius [1]

copy!(
    progn_new::PrognosticVariables,
    progn_old::PrognosticVariables
)

Copies entries of progn_old into progn_new.

delete!(
    output::NetCDFOutput,
    keys::Union{String, Symbol}...
) -> NetCDFOutput

Delete output variables from output by their (short name) (Symbol or String), corresponding to the keys in the dictionary.

delete!(progn::PrognosticVariables, tracers::Tracer...)

Delete tracers in the prognostic variables progn in progn.tracers::Dict.

delete!(
    simulation::SpeedyWeather.AbstractSimulation,
    tracer::Tracer
) -> Any

Delete a tracer from a simulation, deleted from the model and the variables.

fill!(
    tendencies::Tendencies,
    x,
    _::Type{<:Barotropic}
) -> Tendencies

Set the tendencies for the barotropic model to x.

fill!(
    tendencies::Tendencies,
    x,
    _::Type{<:PrimitiveDry}
) -> Tendencies

Set the tendencies for the primitive dry model to x.

fill!(
    tendencies::Tendencies,
    x,
    _::Type{<:PrimitiveWet}
) -> Tendencies

Set the tendencies for the primitive wet model to x.

fill!(
    tendencies::Tendencies,
    x,
    _::Type{<:ShallowWater}
) -> Tendencies

Set the tendencies for the shallow-water model to x.

mod(p::Particle) -> Particle

Modulo operator for particle locations to map them back into [0,360˚E) and [-90˚,90˚N], in the horizontal and to clamp vertical σ coordinates into [0,1].

transform!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    lf::Integer,
    model::Barotropic;
    kwargs...
)

Propagate the spectral state of the prognostic variables progn to the diagnostic variables in diagn for the barotropic vorticity model. Updates grid vorticity, spectral stream function and spectral and grid velocities u, v.

transform!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    lf::Integer,
    random_process::Nothing,
    spectral_transform::SpectralTransform
)

random_process=nothing does not need to transform any random pattern from spectral to grid space.

transform!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    lf::Integer,
    model::PrimitiveEquation;
    initialize
)

Propagate the spectral state of the prognostic variables progn to the diagnostic variables in diagn for primitive equation models. Updates grid vorticity, grid divergence, grid temperature, pressure (pres_grid) and the velocities u, v.

transform!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    lf::Integer,
    model::ShallowWater;
    kwargs...
)

Propagate the spectral state of the prognostic variables progn to the diagnostic variables in diagn for the shallow water model. Updates grid vorticity, grid divergence, grid interface displacement (pres_grid) and the velocities u, v.

transform!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    lf::Integer,
    random_process::SpeedyWeather.AbstractRandomProcess,
    spectral_transform::SpectralTransform
) -> Union{Nothing, AbstractArray}

General transform for random processes <: AbstractRandomProcess. Takes the spectral random_pattern in the prognostic variables and transforms it to spectral space in diagn.grid.random_pattern.

CallbackDict(
    pairs::Pair{Symbol, <:SpeedyWeather.AbstractCallback}...
) -> Dict{Symbol, SpeedyWeather.AbstractCallback}

Create Callback dictionary like normal dictionaries.

CallbackDict(

) -> Dict{Symbol, SpeedyWeather.AbstractCallback}

Empty Callback dictionary generator.

WhichZenith(
    SG::SpectralGrid,
    P::SpeedyWeather.AbstractPlanet;
    kwargs...
) -> Union{SolarZenith, SolarZenithSeason}

Chooses from SolarZenith (daily and seasonal cycle) or SolarZenithSeason given the parameters in model.planet. In both cases the seasonal cycle can be disabled, calculating the solar declination from the initial time instead of current time.

activate!(
    simulation::SpeedyWeather.AbstractSimulation,
    tracers::Tracer...
)

Activate a deactivated (=frozen) tracers in a simulation, which is a setting in simulation.model only.

activate(p::Particle{NF}) -> Particle

Activate particle. Active particles can move.

add!(
    model::AbstractModel,
    key_callbacks::Pair{Symbol, <:SpeedyWeather.AbstractCallback}...
) -> Any

Add a or several callbacks to a model::AbstractModel. To be used like

add!(model, :my_callback => callback)
add!(model, :my_callback1 => callback, :my_callback2 => other_callback)

add!(
    model::AbstractModel,
    callbacks::SpeedyWeather.AbstractCallback...
)

Add a or several callbacks to a mdoel without specifying the key which is randomly created like callback_????. To be used like

add!(model.callbacks, callback)
add!(model.callbacks, callback1, callback2).

add!(
    model::AbstractModel,
    outputvariables::SpeedyWeather.AbstractOutputVariable...
) -> Any

Add outputvariables to the dictionary in output::NetCDFOutput of model, i.e. at model.output.variables.

add!(
    D::Dict{Symbol, SpeedyWeather.AbstractCallback},
    key_callbacks::Pair{Symbol, <:SpeedyWeather.AbstractCallback}...
)

Add a or several callbacks to a Dict{String, AbstractCallback} dictionary. To be used like

add!(model.callbacks, :my_callback => callback)
add!(model.callbacks, :my_callback1 => callback, :my_callback2 => other_callback)

add!(
    D::Dict{Symbol, SpeedyWeather.AbstractCallback},
    callbacks::SpeedyWeather.AbstractCallback...;
    verbose
)

Add a or several callbacks to a Dict{Symbol, AbstractCallback} dictionary without specifying the key which is randomly created like callback_????. To be used like

add!(model.callbacks, callback)
add!(model.callbacks, callback1, callback2).

add!(
    D::Dict{Symbol, SpeedyWeather.AbstractOutputVariable},
    outputvariables::SpeedyWeather.AbstractOutputVariable...
) -> Dict{Symbol, SpeedyWeather.AbstractOutputVariable}

Add outputvariables to a dictionary defining the variables subject to NetCDF output.

add!(
    output::NetCDFOutput,
    outputvariables::SpeedyWeather.AbstractOutputVariable...
) -> NetCDFOutput

Add outputvariables to the dictionary in output::NetCDFOutput, i.e. at output.variables.

add!(
    progn::PrognosticVariables{NF, ArrayType, SpectrumType, GridType, SpectralVariable2D, SpectralVariable3D, SpectralVariable4D},
    tracers::Tracer...
)

Add tracers to the prognostic variables progn in progn.tracers::Dict.

add_default!(
    output_variables::Dict{Symbol, SpeedyWeather.AbstractOutputVariable},
    Model::Type{<:Barotropic}
) -> Dict{Symbol, SpeedyWeather.AbstractOutputVariable}

Add default variables to output for a Barotropic model: Vorticity, zonal and meridional velocity.

add_default!(
    variables::Dict{Symbol, SpeedyWeather.AbstractOutputVariable},
    Model::Type{<:PrimitiveDry}
) -> Dict{Symbol, SpeedyWeather.AbstractOutputVariable}

Add default variables to output for a PrimitiveDry model, same as for a Barotropic model but also the surface pressure and temperature.

add_default!(
    variables::Dict{Symbol, SpeedyWeather.AbstractOutputVariable},
    Model::Type{<:PrimitiveWet}
) -> Dict{Symbol, SpeedyWeather.AbstractOutputVariable}

Add default variables to output for a PrimitiveWet model, same as for a PrimitiveDry model but also the specific humidity.

add_default!(
    variables::Dict{Symbol, SpeedyWeather.AbstractOutputVariable},
    Model::Type{<:ShallowWater}
) -> Dict{Symbol, SpeedyWeather.AbstractOutputVariable}

Add default variables to output for a ShallowWater model, same as for a Barotropic model but also the interface displacement.

bernoulli_potential!(
    diagn::DiagnosticVariables,
    S::SpectralTransform
)

Computes the Laplace operator ∇² of the Bernoulli potential B in spectral space.

1. computes the kinetic energy KE = ½(u²+v²) on the grid
2. transforms KE to spectral space
3. adds geopotential for the Bernoulli potential in spectral space
4. takes the Laplace operator.

This version is used for both ShallowWater and PrimitiveEquation, only the geopotential calculation in geopotential! differs.

boundary_layer_drag!(
    column::ColumnVariables,
    scheme::LinearDrag
)

Compute tendency for boundary layer drag of a column and add to its tendencies fields

bulk_richardson!(
    column::ColumnVariables,
    atmosphere::SpeedyWeather.AbstractAtmosphere
) -> Any

Calculate the bulk richardson number following Frierson, 2007. For vertical stability in the boundary layer.

bulk_richardson_surface(
    column::ColumnVariables,
    atmosphere::SpeedyWeather.AbstractAtmosphere
) -> Any

Calculate the bulk richardson number following Frierson, 2007. For vertical stability in the boundary layer.

callback!(
    callback::GlobalSurfaceTemperatureCallback,
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    model::AbstractModel
) -> Any

Pulls the average temperature from the lowermost layer and stores it in the next element of the callback.temp vector.

callback!(progress_txt::ProgressTxt, progn, diagn, model)

Writes the time stepping progress to the progress.txt file every every_n_percent % of time steps.

convection!(
    column::ColumnVariables{NF},
    DBM::DryBettsMiller,
    geometry::Geometry,
    atmosphere::SpeedyWeather.AbstractAtmosphere,
    model::PrimitiveEquation
)

calculates temperature tendency for the dry convection scheme following the simplified Betts-Miller convection from Frierson 2007 but with zero humidity. Starts with a first-guess relaxation to determine the convective criterion, then adjusts the reference profiles for thermodynamic consistency (e.g. in dry convection the humidity profile is non-precipitating), and relaxes current vertical profiles to the adjusted references.

convection!(
    column::ColumnVariables{NF},
    SBM::SimplifiedBettsMiller,
    clausius_clapeyron::SpeedyWeather.AbstractClausiusClapeyron,
    geometry::Geometry,
    planet::SpeedyWeather.AbstractPlanet,
    atmosphere::SpeedyWeather.AbstractAtmosphere,
    time_stepping::SpeedyWeather.AbstractTimeStepper,
    model::PrimitiveWet
)

calculates temperature and humidity tendencies for the convection scheme following the simplified Betts-Miller convection. Starts with a first-guess relaxation to determine the convective criteria (none, dry/shallow or deep), then adjusts reference profiles for thermodynamic consistency (e.g. in dry convection the humidity profile is non-precipitating), and relaxes current vertical profiles to the adjusted references.

coriolis!(f::AbstractField; rotation) -> AbstractField

Return the Coriolis parameter f on the grid Grid of resolution nlat_half on a planet of rotation [1/s]. Default rotation of Earth.

coriolis(field::AbstractField; kwargs...) -> AbstractField

Return the Coriolis parameter f on the same grid as field on a planet of kwarg rotation [1/s]. Default rotation of Earth.

cos_zenith!(
    cos_zenith::AbstractField,
    S::SolarZenith,
    time::DateTime,
    geometry::SpeedyWeather.AbstractGeometry
)

Calculate cos of solar zenith angle with a daily cycle at time time. Seasonal cycle or time correction may be disabled, depending on parameters in SolarZenith.

cos_zenith!(
    cos_zenith::AbstractField,
    S::SolarZenithSeason,
    time::DateTime,
    geometry::SpeedyWeather.AbstractGeometry
)

Calculate cos of solar zenith angle as daily average at time time. Seasonal cycle or time correction may be disabled, depending on parameters in SolarZenithSeason.

create_run_folder!(
    output::SpeedyWeather.AbstractOutput
) -> String

Creates a new folder prefix_id_number with the identification id. Also returns the full path run_path of that folder.

deactivate!(
    simulation::SpeedyWeather.AbstractSimulation,
    tracers::Tracer...
)

Deactivate a tracer in a simulation, which is a setting in simulation.model only.

deactivate(p::Particle{NF}) -> Particle

Deactivate particle. Inactive particles cannot move.

default_sigma_coordinates(
    nlayers::Integer
) -> Vector{T} where T<:Union{Float16, Float32, Float64}

Vertical sigma coordinates defined by their nlayers+1 half levels σ_levels_half. Sigma coordinates are fraction of surface pressure (p/p0) and are sorted from top (stratosphere) to bottom (surface). The first half level is at 0 the last at 1. Default levels are equally spaced from 0 to 1 (including).

determine_run_folder!(
    output::SpeedyWeather.AbstractOutput
) -> String

Checks existing folders in path and determine run_numberby counting up. E.g. if folder run0001 exists then runnumber is 2. Does not create a folder for the returned run id.

drag!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    drag::LinearVorticityDrag,
    lf::Integer,
    model::AbstractModel
)

Linear drag for the vorticity equations of the form F = -cξ with c drag coefficient [1/s].

drag!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    drag::QuadraticDrag,
    lf::Integer,
    model::AbstractModel
)

Quadratic drag for the momentum equations.

F = -c_D/H*|(u, v)|*(u, v)

with c_D the non-dimensional drag coefficient as defined in drag::QuadraticDrag. c_D and layer thickness H are precomputed in initialize!(::QuadraticDrag, ::AbstractModel) and scaled by the radius as are the momentum equations.

dry_adiabat!(
    temp_ref_profile::AbstractVector,
    temp_environment::AbstractVector,
    temp_parcel::Real,
    σ::AbstractVector,
    atmosphere::SpeedyWeather.AbstractAtmosphere
) -> Int64

Calculates the moist pseudo adiabat given temperature and humidity of surface parcel. Follows the dry adiabat till condensation and then continues on the pseudo moist-adiabat with immediate condensation to the level of zero buoyancy. Levels above are skipped, set to NaN instead and should be skipped in the relaxation.

dry_static_energy!(
    column::ColumnVariables,
    atmosphere::SpeedyWeather.AbstractAtmosphere
)

Compute the dry static energy SE = cₚT + Φ (latent heat times temperature plus geopotential) for the column.

dynamics_tendencies!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    lf::Integer,
    model::Barotropic
)

Calculate all tendencies for the BarotropicModel.

dynamics_tendencies!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    lf::Integer,
    model::PrimitiveEquation
)

Calculate all tendencies for the PrimitiveEquation model (wet or dry).

dynamics_tendencies!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    lf::Integer,
    model::ShallowWater
)

Calculate all tendencies for the ShallowWaterModel.

finalize!(F::Feedback)

Finalises the progress meter and the progress txt file.

finalize!(progress_txt::ProgressTxt, progn, diagn, model)

Finalizes the ProgressTxt callback by writing the total time taken to the progress.txt file and closing it.

finalize!(
    restart::RestartFile,
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    model::AbstractModel
) -> Any

A restart file restart.jld2 with the prognostic variables is written to the output folder (or current path) that can be used to restart the model. restart.jld2 will then be used as initial conditions. Variables in restart file are not scaled.

finalize!(
    simulation::SpeedyWeather.AbstractSimulation
) -> Any

Finalize a simulation. Finishes the progress meter, unscales variables, finalizes the output, writes a restart file and finalizes callbacks.

first_timesteps!(
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    model::AbstractModel
)

Performs the first two initial time steps (Euler forward, unfiltered leapfrog) to populate the prognostic variables with two time steps (t=0, Δt) that can then be used in the normal leap frogging.

first_timesteps!(
    simulation::SpeedyWeather.AbstractSimulation
)

First 1 or 2 time steps of simulation. If model.time_stepping.start_with_euler is true, then start with one Euler step with dt/2, followed by one Leapfrog step with dt. If false, continue with leapfrog steps at 2Δt (e.g. restart).

flux_divergence!(
    A_tend::LowerTriangularArray,
    A_grid::AbstractField,
    diagn::DiagnosticVariables,
    G::Geometry,
    S::SpectralTransform;
    add,
    flipsign
)

Computes ∇⋅((u, v)*A) with the option to add/overwrite A_tend and to flip_sign of the flux divergence by doing so.

• A_tend = ∇⋅((u, v)*A) for add=false, flip_sign=false
• A_tend = -∇⋅((u, v)*A) for add=false, flip_sign=true
• A_tend += ∇⋅((u, v)*A) for add=true, flip_sign=false
• A_tend -= ∇⋅((u, v)*A) for add=true, flip_sign=true

fluxes_to_tendencies!(
    column::ColumnVariables,
    geometry::Geometry,
    planet::SpeedyWeather.AbstractPlanet,
    atmosphere::SpeedyWeather.AbstractAtmosphere
)

Convert the fluxes on half levels to tendencies on full levels.

forcing!(
    diagn::DiagnosticVariables,
    forcing::JetStreamForcing
)

Set for every latitude ring the tendency to the precomputed forcing in the momentum equations following the JetStreamForcing. The forcing is precomputed in initialize!(::JetStreamForcing, ::AbstractModel).

geopotential!(
    geopot::AbstractVector,
    temp::AbstractVector,
    G::Geopotential
)
geopotential!(
    geopot::AbstractVector,
    temp::AbstractVector,
    G::Geopotential,
    geopot_surf::Real
)

Calculate the geopotential based on temp in a single column. This exclues the surface geopotential that would need to be added to the returned vector. Function not used in the dynamical core but for post-processing and analysis.

geopotential!(
    diagn::DiagnosticVariables,
    geopotential::Geopotential,
    orography::SpeedyWeather.AbstractOrography
)

Compute spectral geopotential geopot from spectral temperature temp and spectral surface geopotential geopot_surf (orography*gravity).

geopotential!(
    diagn::DiagnosticVariables,
    pres::LowerTriangularArray,
    planet::SpeedyWeather.AbstractPlanet
)

calculates the geopotential in the ShallowWaterModel as g*η, i.e. gravity times the interface displacement (field pres)

Recalculate ring index if not provided.

get_column!(
    C::ColumnVariables,
    D::DiagnosticVariables,
    P::PrognosticVariables,
    ij::Integer,
    jring::Integer,
    geometry::Geometry,
    planet::SpeedyWeather.AbstractPlanet,
    orography::SpeedyWeather.AbstractOrography,
    land_sea_mask::SpeedyWeather.AbstractLandSeaMask,
    implicit::SpeedyWeather.AbstractImplicit
) -> Any

Update C::ColumnVariables by copying the prognostic variables from D::DiagnosticVariables at gridpoint index ij. Provide G::Geometry for coordinate information.

get_full_output_file_path(
    output::SpeedyWeather.AbstractOutput
) -> String

Returns the full path of the output file after it was created.

get_step(
    coeffs::LowerTriangularArray{T, 2, ArrayType} where ArrayType<:AbstractArray{T, 2},
    i
) -> LowerTriangularArray

Get the i-th step of a LowerTriangularArray as a view (wrapped into a LowerTriangularArray). "step" refers to the last dimension, for prognostic variables used for the leapfrog time step. This method is for a 2D spectral variable (horizontal only) with steps in the 3rd dimension.

get_step(
    coeffs::LowerTriangularArray{T, 3, ArrayType} where ArrayType<:AbstractArray{T, 3},
    i
) -> LowerTriangularArray

Get the i-th step of a LowerTriangularArray as a view (wrapped into a LowerTriangularArray). "step" refers to the last dimension, for prognostic variables used for the leapfrog time step. This method is for a 3D spectral variable (horizontal+vertical) with steps in the 4rd dimension.

get_thermodynamics!(
    column::ColumnVariables,
    model::PrimitiveEquation
)

Calculate geopotentiala and dry static energy for the primitive equation model.

get_Δt_millisec(
    Δt_at_T31::Dates.TimePeriod,
    trunc,
    radius,
    adjust_with_output::Bool
) -> Any
get_Δt_millisec(
    Δt_at_T31::Dates.TimePeriod,
    trunc,
    radius,
    adjust_with_output::Bool,
    output_dt::Dates.TimePeriod
) -> Any

Computes the time step in [ms]. Δt_at_T31 is always scaled with the resolution trunc of the model. In case adjust_Δt_with_output is true, the Δt_at_T31 is additionally adjusted to the closest divisor of output_dt so that the output time axis is keeping output_dt exactly.

grad(CC::ClausiusClapeyron{NF}, temp_kelvin) -> Any

Gradient of Clausius-Clapeyron wrt to temperature, evaluated at temp_kelvin.

grad(
    TetensCoefficients::TetensEquation{NF},
    temp_kelvin
) -> Any

Gradient of the Tetens equation wrt to temperature, evaluated at temp_kelvin.

grad_saturation_humidity(
    CC::ClausiusClapeyron{NF},
    temp_kelvin,
    pres
) -> Any

Gradient of Clausius-Clapeyron wrt to temperature, evaluated at temp_kelvin.

has(Model::Type{<:AbstractModel}, var_name::Symbol) -> Any

Returns true if the model M has a prognostic variable var_name, false otherwise. The default fallback is that all variables are included.

horizontal_diffusion!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    diffusion::SpeedyWeather.AbstractHorizontalDiffusion,
    model::Barotropic
)
horizontal_diffusion!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    diffusion::SpeedyWeather.AbstractHorizontalDiffusion,
    model::Barotropic,
    lf::Integer
)

Apply horizontal diffusion to vorticity in the BarotropicModel.

horizontal_diffusion!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    diffusion::SpeedyWeather.AbstractHorizontalDiffusion,
    model::PrimitiveEquation
)
horizontal_diffusion!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    diffusion::SpeedyWeather.AbstractHorizontalDiffusion,
    model::PrimitiveEquation,
    lf::Integer
)

Apply horizontal diffusion applied to vorticity, divergence, temperature, and humidity (PrimitiveWet only) in the PrimitiveEquation models.

horizontal_diffusion!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    diffusion::SpeedyWeather.AbstractHorizontalDiffusion,
    model::ShallowWater
)
horizontal_diffusion!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    diffusion::SpeedyWeather.AbstractHorizontalDiffusion,
    model::ShallowWater,
    lf::Integer
)

Apply horizontal diffusion to vorticity and divergence in the ShallowWaterModel.

horizontal_diffusion!(
    tendency::LowerTriangularArray,
    var::LowerTriangularArray,
    expl::AbstractMatrix,
    impl::AbstractMatrix
)

Apply horizontal diffusion to a 2D field var in spectral space by updating its tendency tendency with an implicitly calculated diffusion term. The implicit diffusion of the next time step is split into an explicit part expl and an implicit part impl, such that both can be calculated in a single forward step by using var as well as its tendency tendency.

implicit_correction!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    implicit::ImplicitPrimitiveEquation,
    model::PrimitiveEquation
)

Apply the implicit corrections to dampen gravity waves in the primitive equation models.

implicit_correction!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    implicit::ImplicitShallowWater,
    model::ShallowWater
)

Apply correction to the tendencies in diagn to prevent the gravity waves from amplifying. The correction is implicitly evaluated using the parameter implicit.α to switch between forward, centered implicit or backward evaluation of the gravity wave terms.

initialize!(
    land_sea_mask::AquaPlanetMask,
    model::PrimitiveEquation
)

Sets all grid points to 0 = sea.

initialize!(
    model::Barotropic;
    time
) -> Simulation{Model, Progn, Diagn} where {Model<:Barotropic, Progn<:(PrognosticVariables{var"#s107", var"#s108", _A, _B, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray} where {var"#s107"<:AbstractFloat, var"#s108"<:AbstractArray, _A, _B}), Diagn<:(DiagnosticVariables{var"#s107", var"#s108", _A, _B, var"#s112", var"#s113", var"#s116", var"#s117", var"#s119", var"#s109", var"#s110", SpeedyTransforms.ScratchMemory{NF, ArrayComplexType, VectorType, VectorComplexType}, AnvilInterpolator{NF1, Geometry, Locator}} where {var"#s107"<:AbstractFloat, var"#s108"<:AbstractArray, _A, _B, var"#s112"<:AbstractArray, var"#s113"<:AbstractArray, var"#s116"<:AbstractArray, var"#s117"<:AbstractArray, var"#s119"<:AbstractArray, var"#s109"<:(AbstractVector), var"#s110"<:(AbstractMatrix), NF, ArrayComplexType, VectorType, VectorComplexType, Locator, Geometry, NF1})}

Calls all initialize! functions for most fields, representing components, of model, except for model.output and model.feedback which are always called at in time_stepping!.

initialize!(
    clock::Clock,
    Δt::Dates.Period,
    period::Dates.Period
) -> Clock

Initialize the clock with the time step Δt and period to integrate for.

initialize!(
    clock::Clock,
    Δt::Dates.Period,
    n_timesteps::Integer
) -> Clock

Initialize the clock with the time step Δt and the number of time steps n_timesteps.

initialize!(
    clock::Clock,
    time_stepping::SpeedyWeather.AbstractTimeStepper,
    args...
)

Initialize the clock with the time step Δt from time_stepping.

initialize!(clock::Clock) -> Clock

Initialize the clock with setting the start time and resetting the timestep counter.

initialize!(
    land_sea_mask::EarthLandSeaMask,
    model::PrimitiveEquation
) -> AbstractArray

Reads a high-resolution land-sea mask from file and interpolates (grid-cell average) onto the model grid for a fractional sea mask.

initialize!(
    orog::EarthOrography,
    P::SpeedyWeather.AbstractPlanet,
    S::SpectralTransform
)

Initialize the arrays orography, geopot_surf in orog by reading the orography field from file.

initialize!(
    feedback::Feedback,
    clock::Clock,
    model::AbstractModel
) -> ProgressMeter.Progress

Initializes the a Feedback struct.

initialize!(
    geopotential::Geopotential,
    model::PrimitiveEquation
)

Precomputes constants for the vertical integration of the geopotential, defined as

Φ_{k+1/2} = Φ_{k+1} + R*T_{k+1}*(ln(p_{k+1}) - ln(p_{k+1/2})) (half levels) Φ_k = Φ_{k+1/2} + R*T_k*(ln(p_{k+1/2}) - ln(p_k)) (full levels)

Same formula but k → k-1/2.

initialize!(scheme::HeldSuarez, model::PrimitiveEquation)

initialize the HeldSuarez temperature relaxation by precomputing terms for the equilibrium temperature Teq.

initialize!(diffusion::HyperDiffusion, model::AbstractModel)

Precomputes the hyper diffusion terms in diffusion based on the model time step, and possibly with a changing strength/power in the vertical.

initialize!(
    diffusion::HyperDiffusion,
    G::SpeedyWeather.AbstractGeometry,
    L::SpeedyWeather.AbstractTimeStepper
)

Precomputes the hyper diffusion terms for all layers based on the model time step in L, the vertical level sigma level in G.

initialize!(
    implicit::ImplicitShallowWater,
    dt::Real,
    args...
)

Update the implicit terms in implicit for the shallow water model as they depend on the time step dt.

initialize!(
    output::JLD2Output,
    feedback::SpeedyWeather.AbstractFeedback,
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    model::AbstractModel
) -> Union{Nothing, Bool}

Initialize JLD2 output by creating a JLD2 file. To be called just before the first timesteps.

initialize!(
    scheme::JablonowskiRelaxation,
    model::PrimitiveEquation
)

initialize the JablonowskiRelaxation temperature relaxation by precomputing terms for the equilibrium temperature Teq and the frequency (strength of relaxation).

initialize!(L::Leapfrog, model::AbstractModel)

Initialize leapfrogging L by recalculating the time step given the output time step output_dt from model.output. Recalculating will slightly adjust the time step to be a divisor such that an integer number of time steps matches exactly with the output time step.

initialize!(scheme::LinearDrag, model::PrimitiveEquation)

Precomputes the drag coefficients for this BoundaryLayerDrag scheme.

initialize!(
    output::NetCDFOutput,
    feedback::SpeedyWeather.AbstractFeedback,
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    model::AbstractModel
)

Initialize NetCDF output by creating a netCDF file and storing the initial conditions of diagn (and progn). To be called just before the first timesteps.

initialize!(
    parameters_txt::ParametersTxt,
    progn,
    diagn,
    model
)

Initialize ParametersTxt by writing the model parameters (via defined show of model components) into a text file.

initialize!(
    model::PrimitiveDry;
    time
) -> Simulation{Model, Progn, Diagn} where {Model<:PrimitiveDry, Progn<:(PrognosticVariables{var"#s107", var"#s108", _A, _B, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray} where {var"#s107"<:AbstractFloat, var"#s108"<:AbstractArray, _A, _B}), Diagn<:(DiagnosticVariables{var"#s107", var"#s108", _A, _B, var"#s112", var"#s113", var"#s116", var"#s117", var"#s119", var"#s109", var"#s110", SpeedyTransforms.ScratchMemory{NF, ArrayComplexType, VectorType, VectorComplexType}, AnvilInterpolator{NF1, Geometry, Locator}} where {var"#s107"<:AbstractFloat, var"#s108"<:AbstractArray, _A, _B, var"#s112"<:AbstractArray, var"#s113"<:AbstractArray, var"#s116"<:AbstractArray, var"#s117"<:AbstractArray, var"#s119"<:AbstractArray, var"#s109"<:(AbstractVector), var"#s110"<:(AbstractMatrix), NF, ArrayComplexType, VectorType, VectorComplexType, Locator, Geometry, NF1})}

Calls all initialize! functions for components of model, except for model.output and model.feedback which are always called at in time_stepping! and model.implicit which is done in first_timesteps!.

initialize!(
    model::PrimitiveWet;
    time
) -> Simulation{Model, Progn, Diagn} where {Model<:PrimitiveWet, Progn<:(PrognosticVariables{var"#s107", var"#s108", _A, _B, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray} where {var"#s107"<:AbstractFloat, var"#s108"<:AbstractArray, _A, _B}), Diagn<:(DiagnosticVariables{var"#s107", var"#s108", _A, _B, var"#s112", var"#s113", var"#s116", var"#s117", var"#s119", var"#s109", var"#s110", SpeedyTransforms.ScratchMemory{NF, ArrayComplexType, VectorType, VectorComplexType}, AnvilInterpolator{NF1, Geometry, Locator}} where {var"#s107"<:AbstractFloat, var"#s108"<:AbstractArray, _A, _B, var"#s112"<:AbstractArray, var"#s113"<:AbstractArray, var"#s116"<:AbstractArray, var"#s117"<:AbstractArray, var"#s119"<:AbstractArray, var"#s109"<:(AbstractVector), var"#s110"<:(AbstractMatrix), NF, ArrayComplexType, VectorType, VectorComplexType, Locator, Geometry, NF1})}

Calls all initialize! functions for components of model, except for model.output and model.feedback which are always called at in time_stepping! and model.implicit which is done in first_timesteps!.

initialize!(
    progn::PrognosticVariables,
    _::PressureOnOrography,
    model::PrimitiveEquation
)

Initialize surface pressure on orography by integrating the hydrostatic equation with the reference temperature lapse rate.

initialize!(
    progn::PrognosticVariables,
    initial_conditions::RossbyHaurwitzWave,
    model::AbstractModel
)

Rossby-Haurwitz wave initial conditions as in Williamson et al. 1992, J Computational Physics with an additional cut-off amplitude c to filter out tiny harmonics in the vorticity field.

initialize!(
    progn_new::PrognosticVariables,
    initial_conditions::StartFromFile,
    model::AbstractModel
)

Restart from a previous SpeedyWeather.jl simulation via the restart file restart.jld2 Applies interpolation in the horizontal but not in the vertical.

initialize!(
    progn::PrognosticVariables,
    initial_conditions::ZonalJet,
    model::AbstractModel
)

Initial conditions from Galewsky, 2004, Tellus

initialize!(progress_txt::ProgressTxt, progn, diagn, model)

Initializes the ProgressTxt callback by creating a progress.txt file and writing some initial information to it.

initialize!(
    land_sea_mask::RockyPlanetMask,
    model::PrimitiveEquation
)

Sets all grid points to 1 = land.

initialize!(scheduler::Schedule, clock::Clock) -> Schedule

Initialize a Schedule with a Clock (which is assumed to have been initialized). Takes both scheduler.every and scheduler.times into account, such that both periodic and events can be scheduled simulataneously. But execution will happen only once if they coincide on a given time step.

initialize!(
    model::ShallowWater;
    time
) -> Simulation{Model, Progn, Diagn} where {Model<:ShallowWater, Progn<:(PrognosticVariables{var"#s107", var"#s108", _A, _B, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray, <:AbstractArray} where {var"#s107"<:AbstractFloat, var"#s108"<:AbstractArray, _A, _B}), Diagn<:(DiagnosticVariables{var"#s107", var"#s108", _A, _B, var"#s112", var"#s113", var"#s116", var"#s117", var"#s119", var"#s109", var"#s110", SpeedyTransforms.ScratchMemory{NF, ArrayComplexType, VectorType, VectorComplexType}, AnvilInterpolator{NF1, Geometry, Locator}} where {var"#s107"<:AbstractFloat, var"#s108"<:AbstractArray, _A, _B, var"#s112"<:AbstractArray, var"#s113"<:AbstractArray, var"#s116"<:AbstractArray, var"#s117"<:AbstractArray, var"#s119"<:AbstractArray, var"#s109"<:(AbstractVector), var"#s110"<:(AbstractMatrix), NF, ArrayComplexType, VectorType, VectorComplexType, Locator, Geometry, NF1})}

Calls all initialize! functions for most components (=fields) of model, except for model.output and model.feedback which are always initialized in time_stepping! and model.implicit which is done in first_timesteps!.

initialize!(
    simulation::SpeedyWeather.AbstractSimulation;
    period,
    steps,
    output
) -> Any

Initializes a simulation. Scales the variables, initializes the output, stores initial conditions, initializes the progress meter feedback, callbacks and performs the first two initial time steps to spin up the leapfrogging scheme.

initialize!(
    orog::ZonalRidge,
    P::SpeedyWeather.AbstractPlanet,
    S::SpectralTransform,
    G::Geometry
)

Initialize the arrays orography, geopot_surf in orog following Jablonowski and Williamson, 2006.

initialize!(
    callback::GlobalSurfaceTemperatureCallback{NF},
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    model::AbstractModel
) -> Int64

Initializes callback.temp vector that records the global mean surface temperature on every time step. Allocates vector of correct length (number of elements = total time steps plus one) and stores the global surface temperature of the initial conditions

initialize!(
    implicit::ImplicitPrimitiveEquation,
    dt::Real,
    diagn::DiagnosticVariables{NF},
    geometry::SpeedyWeather.AbstractGeometry,
    geopotential::SpeedyWeather.AbstractGeopotential,
    atmosphere::SpeedyWeather.AbstractAtmosphere,
    adiabatic_conversion::SpeedyWeather.AbstractAdiabaticConversion
)

Initialize the implicit terms for the PrimitiveEquation models.

initialize!(
    progn::PrognosticVariables{NF},
    initial_conditions::JablonowskiTemperature,
    model::PrimitiveEquation
)

Initial conditions from Jablonowski and Williamson, 2006, QJR Meteorol. Soc

initialize!(
    progn::PrognosticVariables{NF},
    initial_conditions::RandomVelocity,
    model::Barotropic
)

Start with random vorticity as initial conditions

initialize!(
    progn::PrognosticVariables{NF},
    initial_conditions::RandomVorticity,
    model::Barotropic
)

Start with random vorticity as initial conditions

initialize!(
    progn::PrognosticVariables{NF},
    initial_conditions::RandomWaves,
    model::ShallowWater
)

Random initial conditions for the interface displacement η in the shallow water equations. The flow (u, v) is zero initially. This kicks off gravity waves that will interact with orography.

initialize!(
    progn::PrognosticVariables{NF},
    initial_conditions::ZonalWind,
    model::PrimitiveEquation
)

Initial conditions from Jablonowski and Williamson, 2006, QJR Meteorol. Soc

initialize!(
    particles::AbstractArray{P<:Particle, 1},
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    particle_advection::ParticleAdvection2D,
    model::AbstractModel
)

Initialize particle locations uniformly in latitude, longitude and in the vertical σ coordinates. This uses a cosin-distribution in latitude for an equal-area uniformity.

initialize!(
    diagn::DiagnosticVariables,
    particles::AbstractArray{P<:Particle, 1},
    progn::PrognosticVariables,
    particle_advection::ParticleAdvection2D,
    model::AbstractModel
) -> Any

Initialize particle advection time integration: Store u,v interpolated initial conditions in diagn.particles.u and .v to be used when particle advection actually executed for first time.

isactive(p::Particle{NF}) -> Bool

Check whether particle is active.

ismod(p::Particle) -> Bool

Check that a particle is in longitude [0,360˚E), latitude [-90˚,90˚N], and σ in [0,1].

isscheduled(S::Schedule, clock::Clock) -> Bool

Evaluate whether (e.g. a callback) should be scheduled at the timestep given in clock. Returns true for scheduled executions, false for no execution on this time step.

large_scale_condensation!(
    column::ColumnVariables,
    condensation::ImplicitCondensation,
    clausius_clapeyron::SpeedyWeather.AbstractClausiusClapeyron,
    geometry::Geometry,
    planet::SpeedyWeather.AbstractPlanet,
    atmosphere::SpeedyWeather.AbstractAtmosphere,
    time_stepping::SpeedyWeather.AbstractTimeStepper
)

Large-scale condensation for a column by relaxation back to 100% relative humidity. Calculates the tendencies for specific humidity and temperature from latent heat release and integrates the large-scale precipitation vertically for output.

later_timestep!(
    simulation::SpeedyWeather.AbstractSimulation
)

Perform one single "normal" time step of simulation, after first_timesteps!.

leapfrog!(
    progn::PrognosticVariables,
    tend::Tendencies,
    dt::Real,
    lf::Int64,
    model::AbstractModel
)

Leapfrog time stepping for all prognostic variables in progn using their tendencies in tend. Depending on model decides which variables to time step.

leapfrog!(
    A_old::LowerTriangularArray,
    A_new::LowerTriangularArray,
    tendency::LowerTriangularArray,
    dt::Real,
    lf::Int64,
    L::Leapfrog{NF}
)

Performs one leapfrog time step with (lf=2) or without (lf=1) Robert+Williams filter (see Williams (2009), Montly Weather Review, Eq. 7-9).

linear_pressure_gradient!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    lf::Int64,
    atmosphere::SpeedyWeather.AbstractAtmosphere,
    implicit::ImplicitPrimitiveEquation
)

Add the linear contribution of the pressure gradient to the geopotential. The pressure gradient in the divergence equation takes the form

-∇⋅(Rd * Tᵥ * ∇lnpₛ) = -∇⋅(Rd * Tᵥ' * ∇lnpₛ) - ∇²(Rd * Tₖ * lnpₛ)

So that the second term inside the Laplace operator can be added to the geopotential. Rd is the gas constant, Tᵥ the virtual temperature and Tᵥ' its anomaly wrt to the average or reference temperature Tₖ, lnpₛ is the logarithm of surface pressure.

linear_virtual_temperature!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    lf::Integer,
    model::PrimitiveDry
) -> Any

Linear virtual temperature for model::PrimitiveDry: Just copy over arrays from temp to temp_virt at timestep lf in spectral space as humidity is zero in this model.

linear_virtual_temperature!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    lf::Integer,
    model::PrimitiveEquation
) -> Any

Calculates a linearised virtual temperature Tᵥ as

Tᵥ = T + Tₖμq

With absolute temperature T, layer-average temperarture Tₖ (computed in temperature_average!), specific humidity q and

μ = (1-ξ)/ξ, ξ = R_dry/R_vapour.

in spectral space.

load_trajectory(
    var_name::Union{String, Symbol},
    model::AbstractModel
) -> Any

Loads a var_name trajectory of the model M that has been saved in a netCDF file during the time stepping.

merge_output(output::JLD2Output)

We can't directly push to arrays in a JLD2 file or have extendable dimensions. This routine rewrites the file to a single vector. Might be turned off if the file doesn't fit into the memory or speed is a concern.

moist_static_energy!(
    column::ColumnVariables,
    clausius_clapeyron::SpeedyWeather.AbstractClausiusClapeyron
)

Compute the moist static energy

MSE = SE + Lc*Q = cₚT + Φ + Lc*Q

with the static energy SE, the latent heat of condensation Lc, the geopotential Φ. As well as the saturation moist static energy which replaces Q with Q_sat

move(
    p::Particle{NF},
    dlon,
    dlat,
    dσ
) -> Particle{NF} where NF

Move a particle with increments (dlon, dlat, dσ) in those respective coordinates.

move(p::Particle{NF}, dlon, dlat) -> Particle{NF} where NF

Move a particle with increments (dlon, dlat) in 2D. No movement in vertical σ.

nan_detection!(
    feedback::Feedback,
    progn::PrognosticVariables
) -> Union{Nothing, Bool}

Detect NaN (Not-a-Number, or Inf) in the prognostic variables.

output!(output::NetCDFOutput, time::DateTime)

Write the current time time::DateTime to the netCDF file in output.

output!(
    output::NetCDFOutput,
    variable::SpeedyWeather.AbstractOutputVariable,
    simulation::SpeedyWeather.AbstractSimulation
)

Output a variable into the netCDF file output.netcdf_file. Interpolates onto the output grid and resolution as specified in output. Method used for all output variables <: AbstractOutputVariable with dispatch over the second argument. Interpolates, scales, custom transform, bitrounding and writes to file.

output!(
    output::NetCDFOutput,
    variable::SpeedyWeather.AbstractRateOutputVariable,
    acc_variable::SpeedyWeather.AbstractOutputVariable
)

Post-process the netCDF output file to convert accumulated precipitation rain/snow to rates.

output!(
    output::NetCDFOutput,
    variable::Union{SpeedyWeather.MeridionalVelocity10mOutput, SpeedyWeather.ZonalVelocity10mOutput},
    simulation::SpeedyWeather.AbstractSimulation
)

10m wind is defined using a logarithmic profile from the lowermost model layer.

\[u_{10}=u_{bottom} * ln(10/z₀) / ln(z_{bottom}/z₀)\]

(with z in m), with

\[z_{bottom} = z_{surf} + T_{bottom} * Δp_geopot_{bottom} / g\]

output!(
    output::SpeedyWeather.AbstractOutput,
    output_variables::Dict{Symbol, SpeedyWeather.AbstractOutputVariable},
    simulation::SpeedyWeather.AbstractSimulation
)

Loop over every variable in output.variables to call the respective output! method to write into the output.netcdf_file.

output!(
    output::SpeedyWeather.AbstractOutput,
    simulation::SpeedyWeather.AbstractSimulation
) -> Any

Writes the variables from progn or diagn of time step i at time time into output.netcdf_file. Simply escapes for no netcdf output or if output shouldn't be written on this time step. Interpolates onto output grid and resolution as specified in output, converts to output number format, truncates the mantissa for higher compression and applies lossless compression.

parameterization_tendencies!(
    column::ColumnVariables,
    progn::PrognosticVariables,
    model::PrimitiveEquation
)

Calls for column one physics parameterization after another and convert fluxes to tendencies.

parameterization_tendencies!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    time::DateTime,
    model::PrimitiveEquation
)

Compute tendencies for u, v, temp, humid from physical parametrizations. Extract for each vertical atmospheric column the prognostic variables (stored in diagn as they are grid-point transformed), loop over all grid-points, compute all parametrizations on a single-column basis, then write the tendencies back into a horizontal field of tendencies.

path(_::SpeedyWeather.VorticityOutput, simulation) -> Any

To be extended for every output variable to define the path where in simulation to find that output variable ::AbstractField.

physics_tendencies_only!(
    diagn::DiagnosticVariables,
    model::PrimitiveEquation
)

For dynamics=false, after calling parameterization_tendencies! call this function to transform the physics tendencies from grid-point to spectral space including the necessary coslat⁻¹ scaling.

pressure_gradient_flux!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    lf::Integer,
    S::SpectralTransform
)

Compute the gradient ∇lnps of the logarithm of surface pressure, followed by its flux, (u,v) * ∇lnps.

pseudo_adiabat!(
    temp_ref_profile::AbstractVector,
    temp_parcel,
    humid_parcel::Real,
    temp_virt_environment::AbstractVector,
    geopot::AbstractVector,
    pres::Real,
    σ::AbstractVector,
    clausius_clapeyron::SpeedyWeather.AbstractClausiusClapeyron
) -> Int64

Calculates the moist pseudo adiabat given temperature and humidity of surface parcel. Follows the dry adiabat till condensation and then continues on the pseudo moist-adiabat with immediate condensation to the level of zero buoyancy. Levels above are skipped, set to NaN instead and should be skipped in the relaxation.

readable_secs(secs::Real) -> Dates.CompoundPeriod

Returns Dates.CompoundPeriod rounding to either (days, hours), (hours, minutes), (minutes, seconds), or seconds with 1 decimal place accuracy for >10s and two for less. E.g.

julia> using SpeedyWeather: readable_secs

julia> readable_secs(12345)

remaining_time(p::ProgressMeter.Progress) -> String

Estimates the remaining time from a ProgresssMeter.Progress. Adapted from ProgressMeter.jl

reset_column!(column::ColumnVariables{NF})

Set the accumulators (tendencies but also vertical sums and similar) back to zero for column to be reused at other grid points.

run!(
    simulation::SpeedyWeather.AbstractSimulation;
    period,
    steps,
    output
)

Run a SpeedyWeather.jl simulation. The simulation.model is assumed to be initialized.

run_folder_name(
    prefix::String,
    id::String,
    number::Int64;
    fmt
) -> String

Concatenate the run folder name from prefix, id and number to e.g. "run0001" or "runshallowconvection0001".

saturation_humidity!(
    column::ColumnVariables,
    clausius_clapeyron::SpeedyWeather.AbstractClausiusClapeyron
)

Compute the saturation water vapour pressure [Pa], the saturation humidity [kg/kg] and the relative humidity following clausius_clapeyron.

saturation_humidity(
    temp_kelvin,
    pres,
    clausius_clapeyron::SpeedyWeather.AbstractClausiusClapeyron
) -> Any

Saturation humidity [kg/kg] from temperature [K], pressure [Pa] via

sat_vap_pres = clausius_clapeyron(temperature)
saturation humidity = mol_ratio * sat_vap_pres / pressure

saturation_humidity(sat_vap_pres, pres; mol_ratio) -> Any

Saturation humidity from saturation vapour pressure and pressure via

qsat = mol_ratio*sat_vap_pres/pres

with both pressures in same units and qsat in kg/kg.

scale!(
    diagn::DiagnosticVariables,
    var::Symbol,
    scale::Real
) -> Any

Scale the variable var inside diagn with scalar scale.

scale!(
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    scale::Real
) -> Real

Scales the prognostic variables vorticity and divergence with the Earth's radius which is used in the dynamical core.

scale!(
    progn::PrognosticVariables,
    var::Symbol,
    scale::Real
) -> Any

Scale the variable var inside progn with scalar scale.

set!(
    model::AbstractModel;
    orography,
    land_sea_mask,
    kwargs...
)

Sets a boundary condition fields for model. The input can be a function, RingGrid, LowerTriangularMatrix, or scalar as for other set! functions. If the keyword add==true the input is added to the exisiting field instead.

set!(
    progn::PrognosticVariables,
    geometry::Geometry;
    u,
    v,
    vor,
    div,
    temp,
    humid,
    pres,
    sea_surface_temperature,
    sea_ice_concentration,
    soil_temperature,
    snow_depth,
    soil_moisture,
    lf,
    add,
    spectral_transform,
    coslat_scaling_included,
    kwargs...
)

Sets new values for the keyword arguments (velocities, vorticity, divergence, etc..) into the prognostic variable struct progn at timestep index lf. If add==true they are added to the current value instead. If a SpectralTransform S is provided, it is used when needed to set the variable, otherwise it is recomputed. In case u and v are provied, actually the divergence and vorticity are set and coslat_scaling_included specficies whether or not the 1/cos(lat) scaling is already included in the arrays or not (default: false)

The input may be:

• A function or callable object f(lond, latd, σ) -> value (multilevel variables)
• A function or callable object f(lond, latd) -> value (surface level variables)
• An instance of AbstractField
• An instance of LowerTriangularArray
• A scalar <: Number (interpreted as a constant field in grid space)

set!(S::SpeedyWeather.AbstractSimulation; kwargs...) -> Any

Sets properties of the simuluation S. Convenience wrapper to call the other concrete set! methods. All kwargs are forwarded to these methods, which are documented seperately. See their documentation for possible kwargs.

set!(
    L::SpeedyWeather.AbstractTimeStepper,
    Δt::Dates.Period
) -> SpeedyWeather.AbstractTimeStepper

Change time step of timestepper L to Δt (unscaled) and disables adjustment to output frequency.

sigma_okay(nlayers::Integer, σ_half::AbstractVector) -> Bool

Check that nlayers and σ_half match.

solar_hour_angle(
    _::Type{T},
    time::DateTime,
    λ,
    length_of_day::Second
) -> Any

Fraction of day as angle in radians [0...2π]. TODO: Takes length of day as argument, but a call to Dates.Time() currently have this hardcoded anyway.

speedstring(sec_per_iter, dt_in_sec) -> String

Define a ProgressMeter.speedstring method that also takes a time step dt_in_sec to translate sec/iteration to days/days-like speeds.

surface_pressure_tendency!( Prog::PrognosticVariables,
                            Diag::DiagnosticVariables,
                            lf::Int,
                            M::PrimitiveEquation)

Computes the tendency of the logarithm of surface pressure as

-(ū*px + v̄*py) - D̄

with ū, v̄ being the vertically averaged velocities; px, py the gradients of the logarithm of surface pressure ln(p_s) and D̄ the vertically averaged divergence.

1. Calculate ∇ln(p_s) in spectral space, convert to grid.
2. Multiply ū, v̄ with ∇ln(p_s) in grid-point space, convert to spectral.
3. D̄ is subtracted in spectral space.
4. Set tendency of the l=m=0 mode to 0 for better mass conservation.

temperature_anomaly!(
    diagn::DiagnosticVariables,
    implicit::ImplicitPrimitiveEquation
)

Convert absolute and virtual temperature to anomalies wrt to the reference profile

temperature_average!(
    diagn::DiagnosticVariables,
    temp::LowerTriangularArray,
    S::SpectralTransform
)

Calculates the average temperature of a layer from the l=m=0 harmonic and stores the result in diagn.temp_average

temperature_relaxation!(
    column::ColumnVariables,
    scheme::HeldSuarez,
    atmosphere::SpeedyWeather.AbstractAtmosphere
)

Apply temperature relaxation following Held and Suarez 1996, BAMS.

temperature_relaxation!(
    column::ColumnVariables,
    scheme::JablonowskiRelaxation
)

Apply HeldSuarez-like temperature relaxation to the Jablonowski and Williamson vertical profile.

temperature_tendency!(
    diagn::DiagnosticVariables,
    adiabatic_conversion::SpeedyWeather.AbstractAdiabaticConversion,
    atmosphere::SpeedyWeather.AbstractAtmosphere,
    implicit::ImplicitPrimitiveEquation,
    G::Geometry,
    S::SpectralTransform
)

Compute the temperature tendency

∂T/∂t += -∇⋅((u, v)*T') + T'D + κTᵥ*Dlnp/Dt

+= because the tendencies already contain parameterizations and vertical advection. T' is the anomaly with respect to the reference/average temperature. Tᵥ is the virtual temperature used in the adiabatic term κTᵥ*Dlnp/Dt.

time_stepping!(simulation::SpeedyWeather.AbstractSimulation)

Main time loop that loops over all time steps.

timestep!(
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    dt::Real,
    model::ShallowWater
)
timestep!(
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    dt::Real,
    model::ShallowWater,
    lf1::Integer
)
timestep!(
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    dt::Real,
    model::ShallowWater,
    lf1::Integer,
    lf2::Integer
)

Calculate a single time step for the model <: ShallowWater.

timestep!(
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    dt::Real,
    model::PrimitiveEquation
)
timestep!(
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    dt::Real,
    model::PrimitiveEquation,
    lf1::Integer
)
timestep!(
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    dt::Real,
    model::PrimitiveEquation,
    lf1::Integer,
    lf2::Integer
)

Calculate a single time step for the model<:PrimitiveEquation

timestep!(
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    dt::Real,
    model::Barotropic
)
timestep!(
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    dt::Real,
    model::Barotropic,
    lf1::Integer
)
timestep!(
    progn::PrognosticVariables,
    diagn::DiagnosticVariables,
    dt::Real,
    model::Barotropic,
    lf1::Integer,
    lf2::Integer
)

Calculate a single time step for the barotropic model.

timestep!(simulation::SpeedyWeather.AbstractSimulation)

Perform one single time step of simulation including possibly output and callbacks.

tree(M::AbstractModel; modules, with_size, kwargs...)

Create a tree of fields inside a model and fields within these fields as long as they are defined within the modules argument (default SpeedyWeather). Other keyword arguments are max_level::Integer=10, with_types::Bool=false or with_size::Bool=false.

tree(S; modules, with_size, kwargs...)

Create a tree of fields inside S and fields within these fields as long as they are defined within the modules argument (default SpeedyWeather). Other keyword arguments are max_level::Integer=10, with_types::Bool=false or with_size::Bool=false.

tree(S::Simulation{M}; modules, with_size, kwargs...)

Create a tree of fields inside a Simulation instance and fields within these fields as long as they are defined within the modules argument (default SpeedyWeather). Other keyword arguments are max_level::Integer=10, with_types::Bool=false or with_size::Bool=false.

unscale!(variable::AbstractArray, scale::Real) -> Any

Undo the radius-scaling for any variable. Method used for netcdf output.

unscale!(diagn::DiagnosticVariables) -> Int64

Undo the radius-scaling of vorticity and divergence from scale!(diagn, scale::Real).

unscale!(progn::PrognosticVariables) -> Int64

Undo the radius-scaling of vorticity and divergence from scale!(progn, scale::Real).

vertical_integration!(
    diagn::DiagnosticVariables,
    progn::PrognosticVariables,
    lf::Integer,
    geometry::Geometry
)

Calculates the vertically averaged (weighted by the thickness of the σ level) velocities (*coslat) and divergence. E.g.

u_mean = ∑_k=1^nlayers Δσ_k * u_k

u, v are averaged in grid-point space, divergence in spectral space.

vertical_interpolate!(
    A_half::Vector,
    A_full::Vector,
    G::Geometry
)

Given a vector in column defined at full levels, do a linear interpolation in log(σ) to calculate its values at half-levels, skipping top (k=1/2), extrapolating to bottom (k=nlayers+1/2).

virtual_temperature!(
    diagn::DiagnosticVariables,
    model::PrimitiveDry
)

Virtual temperature in grid-point space: For the PrimitiveDry temperature and virtual temperature are the same (humidity=0). Just copy over the arrays.

virtual_temperature!(
    diagn::DiagnosticVariables,
    model::PrimitiveWet
)

Calculates the virtual temperature Tᵥ as

Tᵥ = T(1+μq)

With absolute temperature T, specific humidity q and

μ = (1-ξ)/ξ, ξ = R_dry/R_vapour.

in grid-point space.

volume_flux_divergence!(
    diagn::DiagnosticVariables,
    orog::SpeedyWeather.AbstractOrography,
    atmosphere::SpeedyWeather.AbstractAtmosphere,
    G::SpeedyWeather.AbstractGeometry,
    S::SpectralTransform
)

Computes the (negative) divergence of the volume fluxes uh, vh for the continuity equation, -∇⋅(uh, vh).

vordiv_tendencies!(
    diagn::DiagnosticVariables,
    model::PrimitiveEquation
)

Function barrier to unpack model.