`SLatissima` parameters do not show

Ocean Biogeochemical Modelling Environment

Description

OceanBioME was developed with generous support from the Cambridge Centre for Climate Repair CCRC and the Gordon and Betty Moore Foundation as a tool to study the effectiveness and impacts of ocean carbon dioxide removal (CDR) strategies.

OceanBioME is a flexible modelling environment written in Julia for modelling the coupled interactions between ocean biogeochemistry, carbonate chemistry, and physics. OceanBioME can be run as a stand-alone box model, or coupled with Oceananigans.jl to run as a 1D column model or with 2 and 3D physics.

Installation:

First, download and install Julia

From the Julia prompt (REPL), type:

julia> using Pkg
julia> Pkg.add("OceanBioME")

Running your first model

As a simple example lets run a Nutrient-Phytoplankton-Zooplankton-Detritus (NPZD) model in a two-dimensional simulation of a buoyancy front. This example requires Oceananigans, so we install that first:

using Pkg; Pkg.add("Oceananigans")

using OceanBioME, Oceananigans
using Oceananigans.Units

grid = RectilinearGrid(CPU(), size = (160, 32), extent = (10000meters, 500meters), topology = (Bounded, Flat, Bounded))

biogeochemistry = NutrientPhytoplanktonZooplanktonDetritus(; grid) 

model = NonhydrostaticModel(; grid, biogeochemistry,
                              advection = WENO(; grid),
			                  closure = AnisotropicMinimumDissipation(),
			                  buoyancy = SeawaterBuoyancy(constant_salinity = true))

@inline front(x, z, μ, δ) = μ + δ * tanh((x - 7000 + 4 * z) / 500)

Pᵢ(x, z) = ifelse(z > -50, 0.03, 0.01)
Nᵢ(x, z) = front(x, z, 2.5, -2)
Tᵢ(x, z) = front(x, z, 9, 0.05)

set!(model, N = Nᵢ, P = Pᵢ, Z = Pᵢ, T = Tᵢ)

simulation = Simulation(model; Δt = 50, stop_time = 4days)

simulation.output_writers[:tracers] = JLD2OutputWriter(model, model.tracers,
                                                       filename = "buoyancy_front.jld2",
                                                       schedule = TimeInterval(24minute),
                                                       overwrite_existing = true)

run!(simulation)

We can then visualise this:

T = FieldTimeSeries("buoyancy_front.jld2", "T")
N = FieldTimeSeries("buoyancy_front.jld2", "N")
P = FieldTimeSeries("buoyancy_front.jld2", "P")

xc, yc, zc = nodes(T)

times = T.times

using CairoMakie

n = Observable(1)

T_lims = (8.94, 9.06)
N_lims = (0, 4.5)
P_lims = (0.007, 0.02)

Tₙ = @lift interior(T[$n], :, 1, :)
Nₙ = @lift interior(N[$n], :, 1, :)
Pₙ = @lift interior(P[$n], :, 1, :)

fig = Figure(size = (1000, 520), fontsize = 20)

title = @lift "t = $(prettytime(times[$n]))"
Label(fig[0, :], title)

axis_kwargs = (xlabel = "x (m)", ylabel = "z (m)", width = 770, yticks = [-400, -200, 0])
ax1 = Axis(fig[1, 1]; title = "Temperature (°C)", axis_kwargs...)
ax2 = Axis(fig[2, 1]; title = "Nutrients concentration (mmol N / m³)",axis_kwargs...)
ax3 = Axis(fig[3, 1]; title = "Phytoplankton concentration (mmol N / m³)", axis_kwargs...)

hm1 = heatmap!(ax1, xc, zc, Tₙ, colorrange = T_lims, colormap = Reverse(:lajolla), interpolate = true)
hm2 = heatmap!(ax2, xc, zc, Nₙ, colorrange = N_lims, colormap = Reverse(:bamako), interpolate = true)
hm3 = heatmap!(ax3, xc, zc, Pₙ, colorrange = P_lims, colormap = Reverse(:bamako), interpolate = true)

Colorbar(fig[1, 2], hm1, ticks = [8.95, 9.0, 9.05])
Colorbar(fig[2, 2], hm2, ticks = [0, 2, 4])
Colorbar(fig[3, 2], hm3, ticks = [0.01, 0.02, 0.03])

rowgap!(fig.layout, 0)

record(fig, "buoyancy_front.gif", 1:length(times)) do i
    n[] = i
end

buoyancy_front.mp4

In this example OceanBioME is providing the biogeochemistry and the remainder is taken care of by Oceananigans. For comprehensive documentation of the physics modelling see Oceananigans' Documentation, and for biogeochemistry and other features we provide read below.

Using GPU

To run the same example on a GPU we just need to construct the grid on the GPU; the rest is taken care of!

Just replace CPU() with GPU() in the grid construction with everything else left unchanged:

grid = RectilinearGrid(GPU(), size = (256, 32), extent = (500meters, 100meters), topology = (Bounded, Flat, Bounded))

Documentation

See the documentation for full description of the software package and more examples.

Contributing

If you're interested in contributing to the development of OceanBioME we would appreciate your help!

If you'd like to work on a new feature, or if you're new to open source and want to crowd-source projects that fit your interests, please start a discussion.

For more information check out our contributor's guide.

Citing

If you use OceanBioME as part of your research, teaching, or other activities, we would be grateful if you could cite our work below and mention the package by name.

@article{OceanBioMEJOSS,
  doi = {10.21105/joss.05669},
  url = {https://doi.org/10.21105/joss.05669},
  year = {2023},
  publisher = {The Open Journal},
  volume = {8},
  number = {90},
  pages = {5669},
  author = {Jago Strong-Wright and Si Chen and Navid C. Constantinou and Simone Silvestri and Gregory LeClaire Wagner and John R. Taylor},
  title = {{OceanBioME.jl: A flexible environment for modelling the coupled interactions between ocean biogeochemistry and physics}},
  journal = {Journal of Open Source Software}
}

If on top of citing the JOSS paper above, you need to cite a specific version of the package then please cite its corresponding version from the Zenodo archive.

	"""
	NutrientPhytoplanktonZooplanktonDetritus(; grid,
	initial_photosynthetic_slope::FT = 0.1953 / day, # 1/(W/m²)/s
	base_maximum_growth::FT = 0.6989 / day, # 1/s
	nutrient_half_saturation::FT = 2.3868, # mmol N/m³
	base_respiration_rate::FT = 0.066 / day, # 1/s/(mmol N / m³)
	phyto_base_mortality_rate::FT = 0.0101 / day, # 1/s/(mmol N / m³)
	maximum_grazing_rate::FT = 2.1522 / day, # 1/s
	grazing_half_saturation::FT = 0.5573, # mmol N/m³
	assimulation_efficiency::FT = 0.9116,
	base_excretion_rate::FT = 0.0102 / day, # 1/s/(mmol N / m³)
	zoo_base_mortality_rate::FT = 0.3395 / day, # 1/s/(mmol N / m³)²
	remineralization_rate::FT = 0.1213 / day, # 1/s

	surface_phytosynthetically_active_radiation = (x, y, t) -> 100 * max(0.0, cos(t * π / 12hours)),
	light_attenuation_model::LA =
	TwoBandPhotosyntheticallyActiveRadiation(; grid,
	surface_PAR = surface_phytosynthetically_active_radiation),
	sediment_model::S = nothing,

	sinking_speeds = (P = 0.2551/day, D = 2.7489/day),
	open_bottom::Bool = true,

	particles::P = nothing)

	Construct a Nutrient-Phytoplankton-Zooplankton-Detritus ([NPZD](@ref NPZD)) biogeochemical model.

	Keyword Arguments
	=================

	- `grid`: (required) the geometry to build the model on, required to calculate sinking
	- `initial_photosynthetic_slope`, ..., `remineralization_rate`: NPZD parameter values
	- `surface_phytosynthetically_active_radiation`: funciton (or array in the future) for the photosynthetically available radiation at the surface, should be shape `f(x, y, t)`
	- `light_attenuation_model`: light attenuation model which integrated the attenuation of available light
	- `sediment_model`: slot for `AbstractSediment`
	- `sinking_speed`: named tuple of constant sinking, of fields (i.e. `ZFaceField(...)`) for any tracers which sink (convention is that a sinking speed is positive, but a field will need to follow the usual down being negative)
	- `open_bottom`: should the sinking velocity be smoothly brought to zero at the bottom to prevent the tracers leaving the domain
	- `particles`: slot for `BiogeochemicalParticles`

	Example
	=======

	```jldoctest
	julia> using OceanBioME

	julia> using Oceananigans

	julia> grid = RectilinearGrid(size=(20, 30), extent=(200, 200), topology=(Bounded, Flat, Bounded));

	julia> model = NutrientPhytoplanktonZooplanktonDetritus(; grid)
	Nutrient Phytoplankton Zooplankton Detritus model (Float64)
	Sinking Velocities:
	├── P: 0.0 to -2.9525462962962963e-6 m/s
	└── D: 0.0 to -3.181597222222222e-5 m/s
	Light attenuation: Two-band light attenuation model (Float64)
	Sediment: Nothing
	Particles: Nothing

	```
	"""
	function NutrientPhytoplanktonZooplanktonDetritus(; grid,
	initial_photosynthetic_slope::FT = 0.1953 / day, # 1/(W/m²)/s
	base_maximum_growth::FT = 0.6989 / day, # 1/s
	nutrient_half_saturation::FT = 2.3868, # mmol N/m³
	base_respiration_rate::FT = 0.066 / day, # 1/s/(mmol N / m³)
	phyto_base_mortality_rate::FT = 0.0101 / day, # 1/s/(mmol N / m³)
	maximum_grazing_rate::FT = 2.1522 / day, # 1/s
	grazing_half_saturation::FT = 0.5573, # mmol N/m³
	assimulation_efficiency::FT = 0.9116,
	base_excretion_rate::FT = 0.0102 / day, # 1/s/(mmol N / m³)
	zoo_base_mortality_rate::FT = 0.3395 / day, # 1/s/(mmol N / m³)²
	remineralization_rate::FT = 0.1213 / day, # 1/s

	surface_phytosynthetically_active_radiation = (x, y, t) -> 100 * max(0.0, cos(t * π / 12hours)),
	light_attenuation_model::LA =
	TwoBandPhotosyntheticallyActiveRadiation(; grid,
	surface_PAR = surface_phytosynthetically_active_radiation),
	sediment_model::S = nothing,

	sinking_speeds = (P = 0.2551/day, D = 2.7489/day),
	open_bottom::Bool = true,

	scale_negatives = false,

	particles::P = nothing,
	modifiers::M = nothing) where {FT, LA, S, P, M}

	zᶜ = znodes(grid, Center(), Center(), Center())
	zᶠ = znodes(grid, Center(), Center(), Face())

	∫chlʳ = @inbounds (zᶠ[grid.Nz + 1] - zᶜ[grid.Nz]) * (P[i, j, grid.Nz] * Rᶜₚ / r) ^ eʳ
	∫chlᵇ = @inbounds (zᶠ[grid.Nz + 1] - zᶜ[grid.Nz]) * (P[i, j, grid.Nz] * Rᶜₚ / r) ^ eᵇ

	# first point below surface
	@inbounds PAR[i, j, grid.Nz] = PAR⁰ * (exp(kʳ * zᶜ[grid.Nz] - χʳ * ∫chlʳ) + exp(kᵇ * zᶜ[grid.Nz] - χᵇ * ∫chlᵇ)) / 2

	@inbounds for k in grid.Nz-1:-1:1
	∫chlʳ += (zᶜ[k + 1] - zᶠ[k + 1]) * (P[i, j, k+1] * Rᶜₚ / r) ^ eʳ + (zᶠ[k + 1] - zᶜ[k]) * (P[i, j, k] * Rᶜₚ / r) ^ eʳ
	∫chlᵇ += (zᶜ[k + 1] - zᶠ[k + 1]) * (P[i, j, k+1] * Rᶜₚ / r) ^ eᵇ + (zᶠ[k + 1] - zᶜ[k]) * (P[i, j, k] * Rᶜₚ / r) ^ eᵇ
	PAR[i, j, k] = PAR⁰ * (exp(kʳ * zᶜ[k] - χʳ * ∫chlʳ) + exp(kᵇ * zᶜ[k] - χᵇ * ∫chlᵇ)) / 2
	end

	# Open the file with our data
	file = jldopen(simulation.output_writers[:fields].filepath)

	iterations = parse.(Int, keys(file["timeseries/t"]))

	times = zeros(length(iterations))

	w, P, N, DIC = ntuple(n -> zeros(grid.Nx, grid.Ny, grid.Nz, length(iterations)), 5);

	for (idx, it) in enumerate(iterations)
	w[:, :, :, idx] = file["timeseries/w/$it"][1:grid.Nx, 1:grid.Ny, 1:grid.Nz]
	P[:, :, :, idx] = file["timeseries/P/$it"][1:grid.Nx, 1:grid.Ny, 1:grid.Nz]
	N[:, :, :, idx] = file["timeseries/NO₃/$it"][1:grid.Nx, 1:grid.Ny, 1:grid.Nz] .+ file["timeseries/NH₄/$it"][1:grid.Nx, 1:grid.Ny, 1:grid.Nz]
	DIC[:, :, :, idx] = file["timeseries/DIC/$it"][1:grid.Nx, 1:grid.Ny, 1:grid.Nz]

	times[idx] = file["timeseries/t/$it"]
	end

	V(x, y, z, t, p) = p.M2 / p.f * (z - p.Lz/2)
	B(x, y, z, t, p) = p.M2 * x + p.N^2 * (z - p.Lz/2)

	using OceanBioME.SLatissima
	println(SLatissima.defaults)

oceanbiome / oceanbiome.jl Goto Github PK

oceanbiome.jl's Introduction

Ocean Biogeochemical Modelling Environment

Description

Installation:

Running your first model

Using GPU

Documentation

Contributing

Citing

oceanbiome.jl's People

Stargazers

Watchers

Forkers

oceanbiome.jl's Issues

Discussed in https://github.com/orgs/OceanBioME/discussions/86

Advantages:

Disadvantages (if any):

References

Recommend Projects

Recommend Topics

Recommend Org

Jobs