clima / parameterestimocean.jl Goto Github PK

View Code? Open in Web Editor NEW

20.0 4.0 5.0 116.8 MB

🎲 Parameter estimation for Oceananigans using EnsembleKalmanProcesses

Home Page: https://clima.github.io/ParameterEstimoceanDocumentation/dev/

License: MIT License

Julia 100.00%

julia ocean-modelling turbulence-models turbulence-closures machine-learning parameter-estimation climate-science

parameterestimocean.jl's Introduction

ParameterEstimocean.jl

A Julia package that leverages Oceananigans.jl and EnsembleKalmanProcesses.jl to calibrate ocean turbulence parametrizations.

ParameterEstimocean.jl is developed by the Climate Modeling Alliance and heroic external collaborators.

Continuous Integration:

Code Coverage:

Stable Release Documentation:

Latest Documentation:

Zenodo:

Installation

To install, use Julia's built-in package manager (accessed by pressing ] in the Julia REPL command prompt) to add the package and also to instantiate/build all the required dependencies. To install the latest tagged version of the package, use

julia> ]
(v1.6) pkg> add ParameterEstimocean
(v1.6) pkg> instantiate

Alternatively, if you'd like to be in the cutting-edge of the package's latest developments you may install the version on the #main branch (or any other branch or commit), e.g.

julia> ]
(v1.6) pkg> add ParameterEstimocean#main
(v1.6) pkg> instantiate

Citing

The code is citable via zenodo. Please cite as:

Adeline Hillier, Gregory L. Wagner, and Navid C. Constantinou. (2022). CliMA/ParameterEstimocean.jl: ParameterEstimocean.jl v0.14.1 (Version v0.14.1). Zenodo. http://doi.org/10.5281/zenodo.5762810

parameterestimocean.jl's People

Contributors

Stargazers

Watchers

Forkers

adelinehillier chanjeunlam pitmonticone zwei961120 vtamsitt

parameterestimocean.jl's Issues

Set correct initial conditions for fields excluded from calibration

We need a way to be able to set initial conditions for fields that are not to be included in the calibration. Currently, if we want to calibrate the purely convective simulation considering only the field b and we start the calibration from 3 hours, fields u, v, and e will be set to all zeros because they have not been stored in the observation. It seems to me that we should automatically store all available fields at all time steps in observations and:

(1) remove field_names from the arguments of SyntheticObservations and provide some kind of Exclude normalization option that will remove the field from the forward map output altogether, or automatically exclude all fields whose normalizations have not been specified.
(2) add a field_names attribute to InverseProblem that keeps track of, for each observation, which fields are to be included in the output map (and therefore which fields are to be tracked in the time_series_collector).
(3) add a ‘field_namesattribute toSyntheticObservations` that keeps track of which fields are to be included in the output map for that observation.

I think option (1) makes the most sense since the choice of field_names directly pertains to the output map. Thoughts?

`iterate!` counts iterations wrong

I think that these lines below

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/050ab5982e276dc8f4269ccc176a69a015ee7261/src/EnsembleKalmanInversions.jl#L381-L382

must be replaced with

 first_iteration = eki.iteration
 final_iteration = eki.iteration + iterations

since, as it currently stands, when we initiate an EKI object it has eki.iteration = 0 and then we iterate once and we end up with eki.iteration = 2!

Bug with multiple observations

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/d6987337a42eacae3fd3eabb963226d2e551e5a0/examples/calibrate_CATKE_to_LESbrary/perfect_model_calibration.jl#L151-L153

When calibrating to 2 observations, the observation map and forward map for the second observation (row 2 in the figure below) do not line up. However, they line up exactly for the first observation (row 1 in the figure below). I've confirmed that the ensemble boundary conditions and closure parameters are set correctly for both observations, so I don't yet know how to explain the error.

Proper `BatchedObservations` with optional weights?

Sometimes we'd like to emphasize some SyntheticObservations over others. We can express this by introducing an object BatchedObservations rather than using a simple Vector:

struct BatchedObservations
    batch
    weights
end

By default the weights are all 1, but this could be overridden to emphasize / demphasize certain members of the batch.

Add docstring for `construct_object`

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/6591d67571e95a07f2fff93589f38f39cdcb9dd5/src/TurbulenceClosureParameters.jl#L86

Make sure that the docstring points out the recursive nature of the function.

Docs need a bit of an introductory sections

This is definitely related or can be combined with #67.

User interface to `Scented` and `Unscented` Kalman inversions

Constructors

The user interface to scented and unscented inversions defines two constructor-looking functions UnscentedKalmanInversion and UnscentedKalmanInversionPostprocess:

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/111e4c50fe33d46d9f7061e3256b9b16d70682c5/src/EnsembleKalmanInversions.jl#L204

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/111e4c50fe33d46d9f7061e3256b9b16d70682c5/src/EnsembleKalmanInversions.jl#L240

However, there are no objects / structs with names corresponding to those constructors.

Should we tweak the interface a little bit? It looks like there is a type called Unscented in EnsembleKalmanProcesses.jl:

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/111e4c50fe33d46d9f7061e3256b9b16d70682c5/src/EnsembleKalmanInversions.jl#L224

We could have users construct this object and pass to EnsembleKalmanInversion. It looks like the constructor for EnsembleKalmanProcess is slightly inconsistent for scented vs unscented inversion --- the scented flavor is

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/111e4c50fe33d46d9f7061e3256b9b16d70682c5/src/EnsembleKalmanInversions.jl#L155

We can still handle this.

Post-processing

If we want to keep the post-processing function, I think we should call it something like postprocess(eki::EnsembleKalmanInversion); then we can do the right thing whether eki represents a scented or unscented process.

However, another possibility is to give a kwarg to iterate!:

function iterate!(eki; iterations=1, postprocess=false)

when users select postprocess=true, we post-process results and store them inside the EKI object.

What do others think about these ideas? @adelinehillier @Zhengyu-Huang @navidcy

Implement `resampler` property in `EnsembleKalmanInversion` object

We need a new property resampler in EnsembleKalmanInversion so that we can provide inputs to control resampling behavior. The resampling code is currently in iterate!

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/08f65160758a21e9b14252d7f4d2eaa2e38561d6/src/EnsembleKalmanInversions.jl#L398-L420

We can move this code to a new function resample!(eki.resampler, args...). Then we might have

resample!(::Nothing, args...) = nothing # default, no resampling

resample!(resampler::NaNResampler, args...) = # currently implemented code

We'd like the NaNResampler to look something like

struct NaNResampler{D}
    abort_fraction :: Float64
    distribution :: D
end

abort_fraction controls when an iteration is aborted because the fraction of failed particles is larger than abort_fraction (currently set at 0.9). For distribution we can provide options for the distribution to resample from: either the FullEnsembleDistribution(), or ValidEnsembleDistribution() (which excludes failed particles), or perhaps some other prespecified distribution. (Other names are fine for these options).

`get_iterations` sometimes returns an _unsorted_ list of iterations

This can lead to bad things like tricking us into thinking the time-steps are negative.

Debug `test_forward_map.jl` and include it in tests

https://github.com/adelinehillier/OceanTurbulenceParameterEstimation.jl/blob/3e7b7e00b0667d79347589cd5fa38f881e264bfd/test/runtests.jl#L4

(Just making this issue to act as a reminder.)

`ensemble_slice_model_simulation` is in order

Similarly to ensemble_column_model_simulation,

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/f7086e11e82e72f3bb7e533c6553ef9cac86031c/src/EnsembleSimulations.jl#L7

it'll be useful to add an ensemble_slice_model_simulation.

simulation = ensemble_slice_model_simulation(observations;
                                             Nensemble = Nensemble,
                                             architecture = architecture,
                                             tracers = (:b, :e, :c),
                                             free_closures = gent_mcwilliams_diffusivity,
                                             additional_closures = closures::Tuple
                                             )

There is an additional difficulty here: the slice simulations usually need to include more than one closures. That is, in the case of the mesoscale eddy fluxes closure we want to be able to calibrate for the gent_mcwilliams_diffusivity (free_closures) but allow for the model ensembles to also include other closures, same for all ensemble members (the additional_closures).

cc @glwagner

Interface and documentation of `ConstrainedNormal`

In the ConstrainedNormal prior, the properties μ and σ indicate the mean and variance of the unconstrained (Normal) parameter distribution:

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/f7086e11e82e72f3bb7e533c6553ef9cac86031c/src/EnsembleKalmanInversions.jl#L28-L35

This is mentioned in the docstring on lines 29-30 above (though it escaped my attention until now).

This means that the priors in the lesbrary_catke_calibration example probably don't make sense:

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/f7086e11e82e72f3bb7e533c6553ef9cac86031c/examples/lesbrary_catke_calibration.jl#L113-L115

(The same applies to our ongoing "production" work in five_case_catke_calibration.)

I believe (but we should discuss here) that users will almost always want to specify properties of the prior distribution that apply to the constrained parameter distribution. So, I propose we come up with a constructor for ConstrainedNormal that provides such an interface, calculating μ and σ given user inputs that (somehow) specify the "mode" and "width" of the constrained parameter distribution.

@adelinehillier points out that if μ=0 and σ=1, then the mode of the constrained parameter distribution will be (upper_bound - lower_bound) / 2. (Do we know what the variance / standard deviation of that distribution would be?)

Four-day strong wind weak cooling case on Engaging is corrupted.

https://github.com/adelinehillier/OceanTurbulenceParameterEstimation/blob/dd98186ac192939114fa340791b140c4f8995b6e/projects/OceanBoundaryLayerParameterizations/src/lesbrary_paths.jl#L31

The four-day strong wind weak cooling case on Engaging is corrupted and may need to be regenerated. (The whole LESbrary suite could be replaced with a higher-vertical-resolution equivalent)

"Unscented" functionality via `resampler`?

I'm entertaining the idea of adding an option to the resampler to resample all particles (not just the ones that have NaN'd). Thoughts?

@adelinehillier @navidcy

There are a lot of comments here!

https://github.com/adelinehillier/OceanTurbulenceParameterEstimation/blob/8d0a15b7d6a9eca8c20dabb322190dff139768f2/src/ParameterEstimation/catke_vertical_diffusivity_model_setup.jl#L6-L10

Is the forward transform (transform to unconstrained space) wrong for `ConstrainedNormal`?

The forward transform:

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/f7086e11e82e72f3bb7e533c6553ef9cac86031c/src/EnsembleKalmanInversions.jl#L48-L49

implies an inverse transform (transform to the physical variate Y given unconstrained variate X)

Y = U - (U - L) * exp(X)

where U is upper_bound and L is lower_bound.

I think the correct forward transform that corresponds to the relationship

Y = L + (U - L) / (1 + exp(X))

X = log((U - Y) / (Y - L))

Unless my arithmetic is wrong?

cc @adelinehillier

Streamlining convective adjustment examples

Here's an idea to reduce the amount of example code we need to maintain a bit:

Make two new examples:
- "intro to Observations" (defines utilities for generating convective adjustment data and illustrates construction of OneDimensionalTimeSeries)
- "Intro to InverseProblem" (defines a utility for building the convective adjustment ensemble simulation)
Use the utilities developed in the first two examples in two more examples that illustrate 1. EKI and 2. UKI for convective adjustment

Nuke these?

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/808ff3a25c4213d95f8cef09d9eac620cf5e619e/src/InverseProblems.jl#L126-L127

Are they being used?

Dependency cleanup?

https://github.com/adelinehillier/OceanTurbulenceParameterEstimation.jl/blob/f5ab0bc11b1b11ac439e1b70e8d5aaa202909dd0/Project.toml#L7-L28

E.g., Revise?

Expand docstring for `EnsembleKalmanInversions.UnscentedKalmanInversion`

The docstring for EnsembleKalmanInversions.UnscentedKalmanInversion only describes the function's arguments. A small description is in order perhaps?

https://github.com/adelinehillier/OceanTurbulenceParameterEstimation.jl/blob/3e3dce2cc2ac3594365d1b7ba9307592e0c3101b/src/EnsembleKalmanInversions.jl#L137-L155

cc @Zhengyu-Huang

Should the package name end in `.jl`?

Right now it does not end in .jl.

Add `show()` method for `EnsembleKalmanInversion()`

This needs to be prettified a bit.

Currently, e.g.,

julia> eki = EnsembleKalmanInversion(calibration; noise_covariance = 1e-2)
EnsembleKalmanInversion{InverseProblem{OceanTurbulenceParameterEstimation.InverseProblems.ConcatenatedOutputMap, OneDimensionalTimeSeries{NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}, Vector{Float64}}, FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}, Vector{Float64}}}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Vector{Float64}, String, NamedTuple{(:grid, :coriolis, :closure), Tuple{NamedTuple{(:Nx, :Ny, :Nz, :Hx, :Hy, :Hz, :Lx, :Ly, :Lz, :Δx, :Δy, :Δz, :xC, :yC, :zC, :xF, :yF, :zF), Tuple{Int64, Int64, Int64, Int64, Int64, Int64, Float64, Float64, Float64, Float64, Float64, Float64, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}}}, NamedTuple{(:f₀, :β), Tuple{Float64, Float64}}, NamedTuple{(:κ_skew, :κ_symmetric, :isopycnal_tensor, :slope_limiter), Tuple{Float64, Float64, NamedTuple{(:minimum_bz,), Tuple{Int64}}, NamedTuple{(:max_slope,), Tuple{Float64}}}}}}, Dict{Symbol, ZScore{Float64}}}, Simulation{HydrostaticFreeSurfaceModel{Oceananigans.TimeSteppers.QuasiAdamsBashforth2TimeStepper{Float64, NamedTuple{(:u, :v, :η, :b, :c), Tuple{Field{Face, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Oceananigans.Fields.ReducedField{Center, Center, Nothing, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing}, Vector{IsopycnalSkewSymmetricDiffusivity{Float64, Float64, Oceananigans.TurbulenceClosures.SmallSlopeIsopycnalTensor{Int64}, Oceananigans.TurbulenceClosures.FluxTapering{Float64}}}, CPU, ExplicitFreeSurface{Oceananigans.Fields.ReducedField{Center, Center, Nothing, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Float64}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, NamedTuple{(:momentum, :b, :c), Tuple{WENO5, WENO5, WENO5}}, Buoyancy{BuoyancyTracer, Oceananigans.Grids.ZDirection}, Vector{BetaPlane{Float64}}, NamedTuple{(:u, :v, :η, :b, :c), NTuple{5, typeof(Oceananigans.Forcings.zeroforcing)}}, Nothing, NamedTuple{(:u, :v, :w), Tuple{Field{Face, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Face, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:pHY′,), Tuple{Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing, NamedTuple{(), Tuple{}}}, Float64, Vector{Any}, Float64, Float64, Float64, Float64, typeof(print_progress), Int64, Nothing}, OceanTurbulenceParameterEstimation.Observations.FieldTimeSeriesCollector{RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}, FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Vector{Float64}}, FreeParameters{Tuple{Symbol, Symbol}, NamedTuple{(:κ_skew, :κ_symmetric), Tuple{ConstrainedNormal{Float64}, ConstrainedNormal{Float64}}}}}, EnsembleKalmanProcesses.ParameterDistributionStorage.ParameterDistribution{EnsembleKalmanProcesses.ParameterDistributionStorage.Parameterized, EnsembleKalmanProcesses.ParameterDistributionStorage.ConstraintType, String}, EnsembleKalmanProcesses.EnsembleKalmanProcessModule.EnsembleKalmanProcess{Float64, Int64, EnsembleKalmanProcesses.EnsembleKalmanProcessModule.Inversion}, Vector{Float64}, Matrix{Float64}, OceanTurbulenceParameterEstimation.EnsembleKalmanInversions.var"#G#11"{InverseProblem{OceanTurbulenceParameterEstimation.InverseProblems.ConcatenatedOutputMap, OneDimensionalTimeSeries{NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}, Vector{Float64}}, FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}, Vector{Float64}}}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Vector{Float64}, String, NamedTuple{(:grid, :coriolis, :closure), Tuple{NamedTuple{(:Nx, :Ny, :Nz, :Hx, :Hy, :Hz, :Lx, :Ly, :Lz, :Δx, :Δy, :Δz, :xC, :yC, :zC, :xF, :yF, :zF), Tuple{Int64, Int64, Int64, Int64, Int64, Int64, Float64, Float64, Float64, Float64, Float64, Float64, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}}}, NamedTuple{(:f₀, :β), Tuple{Float64, Float64}}, NamedTuple{(:κ_skew, :κ_symmetric, :isopycnal_tensor, :slope_limiter), Tuple{Float64, Float64, NamedTuple{(:minimum_bz,), Tuple{Int64}}, NamedTuple{(:max_slope,), Tuple{Float64}}}}}}, Dict{Symbol, ZScore{Float64}}}, Simulation{HydrostaticFreeSurfaceModel{Oceananigans.TimeSteppers.QuasiAdamsBashforth2TimeStepper{Float64, NamedTuple{(:u, :v, :η, :b, :c), Tuple{Field{Face, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Oceananigans.Fields.ReducedField{Center, Center, Nothing, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing}, Vector{IsopycnalSkewSymmetricDiffusivity{Float64, Float64, Oceananigans.TurbulenceClosures.SmallSlopeIsopycnalTensor{Int64}, Oceananigans.TurbulenceClosures.FluxTapering{Float64}}}, CPU, ExplicitFreeSurface{Oceananigans.Fields.ReducedField{Center, Center, Nothing, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Float64}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, NamedTuple{(:momentum, :b, :c), Tuple{WENO5, WENO5, WENO5}}, Buoyancy{BuoyancyTracer, Oceananigans.Grids.ZDirection}, Vector{BetaPlane{Float64}}, NamedTuple{(:u, :v, :η, :b, :c), NTuple{5, typeof(Oceananigans.Forcings.zeroforcing)}}, Nothing, NamedTuple{(:u, :v, :w), Tuple{Field{Face, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Face, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:pHY′,), Tuple{Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing, NamedTuple{(), Tuple{}}}, Float64, Vector{Any}, Float64, Float64, Float64, Float64, typeof(print_progress), Int64, Nothing}, OceanTurbulenceParameterEstimation.Observations.FieldTimeSeriesCollector{RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}, FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Vector{Float64}}, FreeParameters{Tuple{Symbol, Symbol}, NamedTuple{(:κ_skew, :κ_symmetric), Tuple{ConstrainedNormal{Float64}, ConstrainedNormal{Float64}}}}}, NamedTuple{(:κ_skew, :κ_symmetric), Tuple{ConstrainedNormal{Float64}, ConstrainedNormal{Float64}}}}, Vector{Any}, Set{Any}}(InverseProblem{ConcatenatedOutputMap}
├── observations: OneDimensionalTimeSeries of (:b, :c) on RegularRectilinearGrid{Float64, Flat, Bounded, Bounded}(Nx=1, Ny=64, Nz=16)
├── simulation: Simulation on RegularRectilinearGrid{Float64, Flat, Bounded, Bounded}(Nx=10, Ny=64, Nz=16) with Δt=15.0
├── free_parameters: (:κ_skew, :κ_symmetric)
└── output map: ConcatenatedOutputMap, EnsembleKalmanProcesses.ParameterDistributionStorage.ParameterDistribution{EnsembleKalmanProcesses.ParameterDistributionStorage.Parameterized, EnsembleKalmanProcesses.ParameterDistributionStorage.ConstraintType, String}(EnsembleKalmanProcesses.ParameterDistributionStorage.Parameterized[EnsembleKalmanProcesses.ParameterDistributionStorage.Parameterized(Normal{Float64}(μ=0.0, σ=1.0)), EnsembleKalmanProcesses.ParameterDistributionStorage.Parameterized(Normal{Float64}(μ=0.0, σ=1.0))], EnsembleKalmanProcesses.ParameterDistributionStorage.ConstraintType[EnsembleKalmanProcesses.ParameterDistributionStorage.Constraint(EnsembleKalmanProcesses.ParameterDistributionStorage.var"#5#7"(), EnsembleKalmanProcesses.ParameterDistributionStorage.var"#6#8"()), EnsembleKalmanProcesses.ParameterDistributionStorage.Constraint(EnsembleKalmanProcesses.ParameterDistributionStorage.var"#5#7"(), EnsembleKalmanProcesses.ParameterDistributionStorage.var"#6#8"())], ["κ_skew", "κ_symmetric"]), EnsembleKalmanProcesses.EnsembleKalmanProcessModule.EnsembleKalmanProcess{Float64, Int64, EnsembleKalmanProcesses.EnsembleKalmanProcessModule.Inversion}(EnsembleKalmanProcesses.DataStorage.DataContainer{Float64}[EnsembleKalmanProcesses.DataStorage.DataContainer{Float64}([0.39333117661720324 -1.044445708842891 … -0.9599240658021925 -1.0974343107955382; -0.8137139591201445 -1.6091296947466487 … 0.5021181577244778 0.12407383652784736])], [-1.7028074263345871, -1.7028074263345871, -1.7028074263345871, -1.7028074263345871, -1.7028074263345871, -1.7028074263345871, -1.7028074263345871, -1.7028074263345871, -1.7028074263345871, -1.7028074263345871  …  -0.36059709655457056, -0.36059709638571785, -0.360597096448951, -0.360597096352275, -0.3605970964207959, -0.3605970965054562, -0.3605970965012046, -0.3605970964722509, -0.360597096472108, -0.360597096493088], [0.01 0.0 … 0.0 0.0; 0.0 0.01 … 0.0 0.0; … ; 0.0 0.0 … 0.01 0.0; 0.0 0.0 … 0.0 0.01], 10, EnsembleKalmanProcesses.DataStorage.DataContainer{Float64}[], Float64[], [1.0], EnsembleKalmanProcesses.EnsembleKalmanProcessModule.Inversion()), [-1.7028074263345871, -1.7028074263345871, -1.7028074263345871, -1.7028074263345871, -1.7028074263345871, -1.7028074263345871, -1.7028074263345871, -1.7028074263345871, -1.7028074263345871, -1.7028074263345871  …  -0.36059709655457056, -0.36059709638571785, -0.360597096448951, -0.360597096352275, -0.3605970964207959, -0.3605970965054562, -0.3605970965012046, -0.3605970964722509, -0.360597096472108, -0.360597096493088], [0.01 0.0 … 0.0 0.0; 0.0 0.01 … 0.0 0.0; … ; 0.0 0.0 … 0.01 0.0; 0.0 0.0 … 0.0 0.01], OceanTurbulenceParameterEstimation.EnsembleKalmanInversions.var"#G#11"{InverseProblem{OceanTurbulenceParameterEstimation.InverseProblems.ConcatenatedOutputMap, OneDimensionalTimeSeries{NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}, Vector{Float64}}, FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}, Vector{Float64}}}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Vector{Float64}, String, NamedTuple{(:grid, :coriolis, :closure), Tuple{NamedTuple{(:Nx, :Ny, :Nz, :Hx, :Hy, :Hz, :Lx, :Ly, :Lz, :Δx, :Δy, :Δz, :xC, :yC, :zC, :xF, :yF, :zF), Tuple{Int64, Int64, Int64, Int64, Int64, Int64, Float64, Float64, Float64, Float64, Float64, Float64, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}}}, NamedTuple{(:f₀, :β), Tuple{Float64, Float64}}, NamedTuple{(:κ_skew, :κ_symmetric, :isopycnal_tensor, :slope_limiter), Tuple{Float64, Float64, NamedTuple{(:minimum_bz,), Tuple{Int64}}, NamedTuple{(:max_slope,), Tuple{Float64}}}}}}, Dict{Symbol, ZScore{Float64}}}, Simulation{HydrostaticFreeSurfaceModel{Oceananigans.TimeSteppers.QuasiAdamsBashforth2TimeStepper{Float64, NamedTuple{(:u, :v, :η, :b, :c), Tuple{Field{Face, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Oceananigans.Fields.ReducedField{Center, Center, Nothing, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing}, Vector{IsopycnalSkewSymmetricDiffusivity{Float64, Float64, Oceananigans.TurbulenceClosures.SmallSlopeIsopycnalTensor{Int64}, Oceananigans.TurbulenceClosures.FluxTapering{Float64}}}, CPU, ExplicitFreeSurface{Oceananigans.Fields.ReducedField{Center, Center, Nothing, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Float64}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, NamedTuple{(:momentum, :b, :c), Tuple{WENO5, WENO5, WENO5}}, Buoyancy{BuoyancyTracer, Oceananigans.Grids.ZDirection}, Vector{BetaPlane{Float64}}, NamedTuple{(:u, :v, :η, :b, :c), NTuple{5, typeof(Oceananigans.Forcings.zeroforcing)}}, Nothing, NamedTuple{(:u, :v, :w), Tuple{Field{Face, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Face, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:pHY′,), Tuple{Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing, NamedTuple{(), Tuple{}}}, Float64, Vector{Any}, Float64, Float64, Float64, Float64, typeof(print_progress), Int64, Nothing}, OceanTurbulenceParameterEstimation.Observations.FieldTimeSeriesCollector{RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}, FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, CPU, OffsetArrays.OffsetArray{Float64, 3, Array{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Vector{Float64}}, FreeParameters{Tuple{Symbol, Symbol}, NamedTuple{(:κ_skew, :κ_symmetric), Tuple{ConstrainedNormal{Float64}, ConstrainedNormal{Float64}}}}}, NamedTuple{(:κ_skew, :κ_symmetric), Tuple{ConstrainedNormal{Float64}, ConstrainedNormal{Float64}}}}(InverseProblem{ConcatenatedOutputMap}
├── observations: OneDimensionalTimeSeries of (:b, :c) on RegularRectilinearGrid{Float64, Flat, Bounded, Bounded}(Nx=1, Ny=64, Nz=16)
├── simulation: Simulation on RegularRectilinearGrid{Float64, Flat, Bounded, Bounded}(Nx=10, Ny=64, Nz=16) with Δt=15.0
├── free_parameters: (:κ_skew, :κ_symmetric)
└── output map: ConcatenatedOutputMap, (κ_skew = ConstrainedNormal{Float64}(0.0, 1.0, 300.0, 900.0), κ_symmetric = ConstrainedNormal{Float64}(0.0, 1.0, 800.0, 2000.0))), 0, Any[], Set{Any}())

Add documentation

This should happen at some point.

CI tests on GPU

At some point we'll have to do that. E.g., #123 is already pushing to that direction. ;)

Better name for `transform_observations`?

@navidcy suggests that we can do better with transform_observations.

Perhaps transform_time_series would be better?

Note that this function takes in a time series as input. Then, for map::ConcatenatedOutputMap, it concatenates flattened, normalized data for each field in the time series:

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/4658e4c2ac0cbd0a9b6fda3a64f8634cfb31ffed/src/InverseProblems.jl#L196-L214

Note that for another type of output_map other than ConcatenatedOutputMap (not currently implemented) the transformation could be different; for example the transformation could involve the computation of some kind of custom loss function.

Perfect convective adjustment example is broken

It might be just a plotting issue, a functionality issue, or both. In the docs now the convective adjustment example does not appear to converge any more:

Images taken from: https://clima.github.io/OceanTurbulenceParameterEstimation.jl/dev/literated/perfect_convective_adjustment_calibration/

The unscented version seems to have fared no better.

But baroclinic adjustment is doing fine.

If we can figure out what's gone wrong maybe we can also figure out how to prevent it from happening again.

EKI iterations don't just work on GPU -- scalar operations are involved

julia> params = iterate!(eki; iterations = iterations)
0.0%┣                                                                                                                                 ┫ 0/11 [00:00<00:-1, -0s/it]
ERROR: Scalar indexing is disallowed.
Invocation of setindex! resulted in scalar indexing of a GPU array.
This is typically caused by calling an iterating implementation of a method.
Such implementations *do not* execute on the GPU, but very slowly on the CPU,
and therefore are only permitted from the REPL for prototyping purposes.
If you did intend to index this array, annotate the caller with @allowscalar.
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:33
  [2] assertscalar(op::String)
    @ GPUArrays /g/data/v45/nc3020/.julia/packages/GPUArrays/3sW6s/src/host/indexing.jl:53
  [3] setindex!(xs::CUDA.CuArray{Float64, 3}, v::Float64, I::Int64)
    @ GPUArrays /g/data/v45/nc3020/.julia/packages/GPUArrays/3sW6s/src/host/indexing.jl:94
  [4] copyto_unaliased!(deststyle::IndexLinear, dest::CUDA.CuArray{Float64, 3}, srcstyle::IndexLinear, src::SubArray{Float64, 3, Array{Float64, 4}, Tuple{Base.Slice{Base.OneTo{Int64}}, Base.Slice{Base.OneTo{Int64}}, Base.Slice{Base.OneTo{Int64}}, Int64}, true})
    @ Base ./abstractarray.jl:970
  [5] copyto!(dest::CUDA.CuArray{Float64, 3}, src::SubArray{Float64, 3, Array{Float64, 4}, Tuple{Base.Slice{Base.OneTo{Int64}}, Base.Slice{Base.OneTo{Int64}}, Base.Slice{Base.OneTo{Int64}}, Int64}, true})
    @ Base ./abstractarray.jl:950
  [6] set!(u::Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, v::Field{Nothing, Center, Center, CPU, SubArray{Float64, 3, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, Tuple{Base.Slice{OffsetArrays.IdOffsetRange{Int64, Base.OneTo{Int64}}}, Base.Slice{OffsetArrays.IdOffsetRange{Int64, Base.OneTo{Int64}}}, Base.Slice{OffsetArrays.IdOffsetRange{Int64, Base.OneTo{Int64}}}, Int64}, true}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, Nothing})
    @ Oceananigans.Fields /g/data/v45/nc3020/.julia/packages/Oceananigans/ZaDUA/src/Fields/set!.jl:65
  [7] set!(model::HydrostaticFreeSurfaceModel{Oceananigans.TimeSteppers.QuasiAdamsBashforth2TimeStepper{Float64, NamedTuple{(:u, :v, :η, :b, :c), Tuple{Field{Face, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Oceananigans.Fields.ReducedField{Center, Center, Nothing, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing}, Vector{IsopycnalSkewSymmetricDiffusivity{Float64, Float64, Oceananigans.TurbulenceClosures.SmallSlopeIsopycnalTensor{Int64}, Oceananigans.TurbulenceClosures.FluxTapering{Float64}}}, GPU, ExplicitFreeSurface{Oceananigans.Fields.ReducedField{Center, Center, Nothing, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Float64}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, NamedTuple{(:momentum, :b, :c), Tuple{WENO5, WENO5, WENO5}}, Buoyancy{BuoyancyTracer, Oceananigans.Grids.ZDirection}, Vector{BetaPlane{Float64}}, NamedTuple{(:u, :v, :η, :b, :c), NTuple{5, typeof(Oceananigans.Forcings.zeroforcing)}}, Nothing, NamedTuple{(:u, :v, :w), Tuple{Field{Face, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Face, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:pHY′,), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing, NamedTuple{(), Tuple{}}}, ts::OneDimensionalTimeSeries{NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Nothing, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}, FieldTimeSeries{Nothing, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Vector{Float64}, String, NamedTuple{(:grid, :coriolis), Tuple{NamedTuple{(:Nx, :Ny, :Nz, :Hx, :Hy, :Hz, :Lx, :Ly, :Lz, :Δx, :Δy, :Δz, :xC, :yC, :zC, :xF, :yF, :zF), Tuple{Int64, Int64, Int64, Int64, Int64, Int64, Float64, Float64, Float64, Float64, Float64, Float64, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}}}, NamedTuple{(:f₀, :β), Tuple{Float64, Float64}}}}, Dict{Symbol, ZScore{Float64}}}, index::Int64)
    @ OceanTurbulenceParameterEstimation.Observations /g/data/v45/nc3020/mesoscale_parametrizations/OceanTurbulenceParameterEstimation.jl/src/Observations.jl:94
  [8] initialize_simulation!(simulation::Simulation{HydrostaticFreeSurfaceModel{Oceananigans.TimeSteppers.QuasiAdamsBashforth2TimeStepper{Float64, NamedTuple{(:u, :v, :η, :b, :c), Tuple{Field{Face, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Oceananigans.Fields.ReducedField{Center, Center, Nothing, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing}, Vector{IsopycnalSkewSymmetricDiffusivity{Float64, Float64, Oceananigans.TurbulenceClosures.SmallSlopeIsopycnalTensor{Int64}, Oceananigans.TurbulenceClosures.FluxTapering{Float64}}}, GPU, ExplicitFreeSurface{Oceananigans.Fields.ReducedField{Center, Center, Nothing, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Float64}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, NamedTuple{(:momentum, :b, :c), Tuple{WENO5, WENO5, WENO5}}, Buoyancy{BuoyancyTracer, Oceananigans.Grids.ZDirection}, Vector{BetaPlane{Float64}}, NamedTuple{(:u, :v, :η, :b, :c), NTuple{5, typeof(Oceananigans.Forcings.zeroforcing)}}, Nothing, NamedTuple{(:u, :v, :w), Tuple{Field{Face, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Face, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:pHY′,), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing, NamedTuple{(), Tuple{}}}, Float64, Vector{Any}, Float64, Float64, Float64, Float64, typeof(print_progress), Int64, Nothing}, ts::OneDimensionalTimeSeries{NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Nothing, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}, FieldTimeSeries{Nothing, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Vector{Float64}, String, NamedTuple{(:grid, :coriolis), Tuple{NamedTuple{(:Nx, :Ny, :Nz, :Hx, :Hy, :Hz, :Lx, :Ly, :Lz, :Δx, :Δy, :Δz, :xC, :yC, :zC, :xF, :yF, :zF), Tuple{Int64, Int64, Int64, Int64, Int64, Int64, Float64, Float64, Float64, Float64, Float64, Float64, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}}}, NamedTuple{(:f₀, :β), Tuple{Float64, Float64}}}}, Dict{Symbol, ZScore{Float64}}}, time_series_collector::OceanTurbulenceParameterEstimation.Observations.FieldTimeSeriesCollector{RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}, FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Vector{Float64}}, time_index::Int64) (repeats 2 times)
    @ OceanTurbulenceParameterEstimation.Observations /g/data/v45/nc3020/mesoscale_parametrizations/OceanTurbulenceParameterEstimation.jl/src/Observations.jl:165
  [9] run_simulation_with_params!(ip::InverseProblem{OceanTurbulenceParameterEstimation.InverseProblems.ConcatenatedOutputMap, OneDimensionalTimeSeries{NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Nothing, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}, FieldTimeSeries{Nothing, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Vector{Float64}, String, NamedTuple{(:grid, :coriolis), Tuple{NamedTuple{(:Nx, :Ny, :Nz, :Hx, :Hy, :Hz, :Lx, :Ly, :Lz, :Δx, :Δy, :Δz, :xC, :yC, :zC, :xF, :yF, :zF), Tuple{Int64, Int64, Int64, Int64, Int64, Int64, Float64, Float64, Float64, Float64, Float64, Float64, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}}}, NamedTuple{(:f₀, :β), Tuple{Float64, Float64}}}}, Dict{Symbol, ZScore{Float64}}}, Simulation{HydrostaticFreeSurfaceModel{Oceananigans.TimeSteppers.QuasiAdamsBashforth2TimeStepper{Float64, NamedTuple{(:u, :v, :η, :b, :c), Tuple{Field{Face, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Oceananigans.Fields.ReducedField{Center, Center, Nothing, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing}, Vector{IsopycnalSkewSymmetricDiffusivity{Float64, Float64, Oceananigans.TurbulenceClosures.SmallSlopeIsopycnalTensor{Int64}, Oceananigans.TurbulenceClosures.FluxTapering{Float64}}}, GPU, ExplicitFreeSurface{Oceananigans.Fields.ReducedField{Center, Center, Nothing, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Float64}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, NamedTuple{(:momentum, :b, :c), Tuple{WENO5, WENO5, WENO5}}, Buoyancy{BuoyancyTracer, Oceananigans.Grids.ZDirection}, Vector{BetaPlane{Float64}}, NamedTuple{(:u, :v, :η, :b, :c), NTuple{5, typeof(Oceananigans.Forcings.zeroforcing)}}, Nothing, NamedTuple{(:u, :v, :w), Tuple{Field{Face, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Face, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:pHY′,), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing, NamedTuple{(), Tuple{}}}, Float64, Vector{Any}, Float64, Float64, Float64, Float64, typeof(print_progress), Int64, Nothing}, OceanTurbulenceParameterEstimation.Observations.FieldTimeSeriesCollector{RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}, FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Vector{Float64}}, FreeParameters{Tuple{Symbol, Symbol}, NamedTuple{(:κ_skew, :κ_symmetric), Tuple{ConstrainedNormal{Float64}, ConstrainedNormal{Float64}}}}}, θ::Vector{NamedTuple{(:κ_skew, :κ_symmetric), Tuple{Float64, Float64}}})
    @ OceanTurbulenceParameterEstimation.InverseProblems /g/data/v45/nc3020/mesoscale_parametrizations/OceanTurbulenceParameterEstimation.jl/src/InverseProblems.jl:120
 [10] forward_map(ip::InverseProblem{OceanTurbulenceParameterEstimation.InverseProblems.ConcatenatedOutputMap, OneDimensionalTimeSeries{NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Nothing, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}, FieldTimeSeries{Nothing, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Vector{Float64}, String, NamedTuple{(:grid, :coriolis), Tuple{NamedTuple{(:Nx, :Ny, :Nz, :Hx, :Hy, :Hz, :Lx, :Ly, :Lz, :Δx, :Δy, :Δz, :xC, :yC, :zC, :xF, :yF, :zF), Tuple{Int64, Int64, Int64, Int64, Int64, Int64, Float64, Float64, Float64, Float64, Float64, Float64, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}}}, NamedTuple{(:f₀, :β), Tuple{Float64, Float64}}}}, Dict{Symbol, ZScore{Float64}}}, Simulation{HydrostaticFreeSurfaceModel{Oceananigans.TimeSteppers.QuasiAdamsBashforth2TimeStepper{Float64, NamedTuple{(:u, :v, :η, :b, :c), Tuple{Field{Face, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Oceananigans.Fields.ReducedField{Center, Center, Nothing, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing}, Vector{IsopycnalSkewSymmetricDiffusivity{Float64, Float64, Oceananigans.TurbulenceClosures.SmallSlopeIsopycnalTensor{Int64}, Oceananigans.TurbulenceClosures.FluxTapering{Float64}}}, GPU, ExplicitFreeSurface{Oceananigans.Fields.ReducedField{Center, Center, Nothing, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Float64}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, NamedTuple{(:momentum, :b, :c), Tuple{WENO5, WENO5, WENO5}}, Buoyancy{BuoyancyTracer, Oceananigans.Grids.ZDirection}, Vector{BetaPlane{Float64}}, NamedTuple{(:u, :v, :η, :b, :c), NTuple{5, typeof(Oceananigans.Forcings.zeroforcing)}}, Nothing, NamedTuple{(:u, :v, :w), Tuple{Field{Face, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Face, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:pHY′,), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing, NamedTuple{(), Tuple{}}}, Float64, Vector{Any}, Float64, Float64, Float64, Float64, typeof(print_progress), Int64, Nothing}, OceanTurbulenceParameterEstimation.Observations.FieldTimeSeriesCollector{RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}, FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Vector{Float64}}, FreeParameters{Tuple{Symbol, Symbol}, NamedTuple{(:κ_skew, :κ_symmetric), Tuple{ConstrainedNormal{Float64}, ConstrainedNormal{Float64}}}}}, θ::Vector{Vector{Float64}})
    @ OceanTurbulenceParameterEstimation.InverseProblems /g/data/v45/nc3020/mesoscale_parametrizations/OceanTurbulenceParameterEstimation.jl/src/InverseProblems.jl:135
 [11] G
    @ /g/data/v45/nc3020/mesoscale_parametrizations/OceanTurbulenceParameterEstimation.jl/src/EnsembleKalmanInversions.jl:136 [inlined]
 [12] iterate!(eki::EnsembleKalmanInversion{InverseProblem{OceanTurbulenceParameterEstimation.InverseProblems.ConcatenatedOutputMap, OneDimensionalTimeSeries{NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Nothing, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}, FieldTimeSeries{Nothing, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Vector{Float64}, String, NamedTuple{(:grid, :coriolis), Tuple{NamedTuple{(:Nx, :Ny, :Nz, :Hx, :Hy, :Hz, :Lx, :Ly, :Lz, :Δx, :Δy, :Δz, :xC, :yC, :zC, :xF, :yF, :zF), Tuple{Int64, Int64, Int64, Int64, Int64, Int64, Float64, Float64, Float64, Float64, Float64, Float64, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}}}, NamedTuple{(:f₀, :β), Tuple{Float64, Float64}}}}, Dict{Symbol, ZScore{Float64}}}, Simulation{HydrostaticFreeSurfaceModel{Oceananigans.TimeSteppers.QuasiAdamsBashforth2TimeStepper{Float64, NamedTuple{(:u, :v, :η, :b, :c), Tuple{Field{Face, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Oceananigans.Fields.ReducedField{Center, Center, Nothing, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing}, Vector{IsopycnalSkewSymmetricDiffusivity{Float64, Float64, Oceananigans.TurbulenceClosures.SmallSlopeIsopycnalTensor{Int64}, Oceananigans.TurbulenceClosures.FluxTapering{Float64}}}, GPU, ExplicitFreeSurface{Oceananigans.Fields.ReducedField{Center, Center, Nothing, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Float64}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, NamedTuple{(:momentum, :b, :c), Tuple{WENO5, WENO5, WENO5}}, Buoyancy{BuoyancyTracer, Oceananigans.Grids.ZDirection}, Vector{BetaPlane{Float64}}, NamedTuple{(:u, :v, :η, :b, :c), NTuple{5, typeof(Oceananigans.Forcings.zeroforcing)}}, Nothing, NamedTuple{(:u, :v, :w), Tuple{Field{Face, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Face, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:pHY′,), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing, NamedTuple{(), Tuple{}}}, Float64, Vector{Any}, Float64, Float64, Float64, Float64, typeof(print_progress), Int64, Nothing}, OceanTurbulenceParameterEstimation.Observations.FieldTimeSeriesCollector{RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}, FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Vector{Float64}}, FreeParameters{Tuple{Symbol, Symbol}, NamedTuple{(:κ_skew, :κ_symmetric), Tuple{ConstrainedNormal{Float64}, ConstrainedNormal{Float64}}}}}, EnsembleKalmanProcesses.ParameterDistributionStorage.ParameterDistribution{EnsembleKalmanProcesses.ParameterDistributionStorage.Parameterized, EnsembleKalmanProcesses.ParameterDistributionStorage.ConstraintType, String}, EnsembleKalmanProcesses.EnsembleKalmanProcessModule.EnsembleKalmanProcess{Float64, Int64, EnsembleKalmanProcesses.EnsembleKalmanProcessModule.Inversion}, Vector{Float64}, Matrix{Float64}, OceanTurbulenceParameterEstimation.EnsembleKalmanInversions.var"#G#11"{InverseProblem{OceanTurbulenceParameterEstimation.InverseProblems.ConcatenatedOutputMap, OneDimensionalTimeSeries{NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Nothing, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}, FieldTimeSeries{Nothing, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}}}, RegularRectilinearGrid{Float64, Periodic, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Vector{Float64}, String, NamedTuple{(:grid, :coriolis), Tuple{NamedTuple{(:Nx, :Ny, :Nz, :Hx, :Hy, :Hz, :Lx, :Ly, :Lz, :Δx, :Δy, :Δz, :xC, :yC, :zC, :xF, :yF, :zF), Tuple{Int64, Int64, Int64, Int64, Int64, Int64, Float64, Float64, Float64, Float64, Float64, Float64, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}}}, NamedTuple{(:f₀, :β), Tuple{Float64, Float64}}}}, Dict{Symbol, ZScore{Float64}}}, Simulation{HydrostaticFreeSurfaceModel{Oceananigans.TimeSteppers.QuasiAdamsBashforth2TimeStepper{Float64, NamedTuple{(:u, :v, :η, :b, :c), Tuple{Field{Face, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Oceananigans.Fields.ReducedField{Center, Center, Nothing, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing}, Vector{IsopycnalSkewSymmetricDiffusivity{Float64, Float64, Oceananigans.TurbulenceClosures.SmallSlopeIsopycnalTensor{Int64}, Oceananigans.TurbulenceClosures.FluxTapering{Float64}}}, GPU, ExplicitFreeSurface{Oceananigans.Fields.ReducedField{Center, Center, Nothing, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, 1, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Float64}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, NamedTuple{(:momentum, :b, :c), Tuple{WENO5, WENO5, WENO5}}, Buoyancy{BuoyancyTracer, Oceananigans.Grids.ZDirection}, Vector{BetaPlane{Float64}}, NamedTuple{(:u, :v, :η, :b, :c), NTuple{5, typeof(Oceananigans.Forcings.zeroforcing)}}, Nothing, NamedTuple{(:u, :v, :w), Tuple{Field{Face, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Face, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Open, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Face, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, NamedTuple{(:pHY′,), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Nothing, NamedTuple{(), Tuple{}}}, Float64, Vector{Any}, Float64, Float64, Float64, Float64, typeof(print_progress), Int64, Nothing}, OceanTurbulenceParameterEstimation.Observations.FieldTimeSeriesCollector{RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, NamedTuple{(:b, :c), Tuple{FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}, FieldTimeSeries{Center, Center, Center, InMemory, CPU, Float64, OffsetArrays.OffsetArray{Float64, 4, Array{Float64, 4}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Nothing, Vector{Float64}}}}, NamedTuple{(:b, :c), Tuple{Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}, Field{Center, Center, Center, GPU, OffsetArrays.OffsetArray{Float64, 3, CUDA.CuArray{Float64, 3}}, RegularRectilinearGrid{Float64, Flat, Bounded, Bounded, OffsetArrays.OffsetVector{Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Float64, FieldBoundaryConditions{Nothing, Nothing, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}, BoundaryCondition{Oceananigans.BoundaryConditions.Flux, Nothing}}}}}, Vector{Float64}}, FreeParameters{Tuple{Symbol, Symbol}, NamedTuple{(:κ_skew, :κ_symmetric), Tuple{ConstrainedNormal{Float64}, ConstrainedNormal{Float64}}}}}, NamedTuple{(:κ_skew, :κ_symmetric), Tuple{ConstrainedNormal{Float64}, ConstrainedNormal{Float64}}}}, Vector{Any}, Set{Any}}; iterations::Int64)
    @ OceanTurbulenceParameterEstimation.EnsembleKalmanInversions /g/data/v45/nc3020/mesoscale_parametrizations/OceanTurbulenceParameterEstimation.jl/src/EnsembleKalmanInversions.jl:192
 [13] top-level scope
    @ REPL[70]:1
 [14] top-level scope
    @ /g/data/v45/nc3020/.julia/packages/CUDA/DL5Zo/src/initialization.jl:52

Observation noise uncertainty

At some point we should think more deeply about how to set the observation noise variance. Currently observation_map_variance_across_time is being used even when very few time steps are being saved. In such cases, a scaled identity matrix is a decent option. Otherwise, we might try coming up with a more scientific uncertainty estimate, e.g. derived by perturbing the IC or BCs.

Register package

What do we need to

Few general docs sections #69
Some file structure cleanup? (e.g., #70, https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/main/src/visualize_distributions.jl seems project-specific, ...)
#68

@glwagner, @adelinehillier feel free to edit this list

Extraction of ensemble member from `forward_map` is transposed?

Should this line:

https://github.com/adelinehillier/OceanTurbulenceParameterEstimation.jl/blob/4295e6a19e8b83c02aefd99cb777f4fd4cf0f575/examples/convective_adjustment_perfect_model_calibration.jl#L128

read

 x = forward_map(calibration, [θ★ for _ in 1:ensemble_size])[:, 1:1]

cc @adelinehillier @navidcy

Large forward maps make Julia crash

When trying to calibrate to LESbrary simulations, the forward map typically has over half a million elements, making it impossible to store a covariance matrix for EKI. How do you guys want to handle this? We could

Look into using sparse matrices.
Store fewer time steps in observations. This would make it harder to animate the solution downstream.
Add a time_range attribute to ConcatenatedOutputMap that specifies which time steps to track--defaults to all time steps.
Delete OceanTurbulenceParameterEstimation.jl and sip guava juice from Costco while brainstorming alternative research topics.

@glwagner @navidcy What do you guys think?

Add tests that we can run locally (and eventually with CI?)

Should `IterationSummary` be done after the iteration?

As it stands now there is a 0-th iteration summary that includes the initial free parameters.

But then, the first iteration repeats that, so the first iteration summary, to a great extent, same as the 0-th one. Thus, the figures, e.g.

https://clima.github.io/OceanTurbulenceParameterEstimation.jl/dev/literated/perfect_convective_adjustment_calibration/

have "Iteration 1" lying on top of "Initial ensemble".

I think that within iterate!. the iteration summary should come after the update_ensemble! step. Does that sound reasonable? Would that mean that we need to call

θ = get_u_final(eki.ensemble_kalman_process) # (N_params, ensemble_size) array
G = eki.inverting_forward_map(θ) # (len(G), ensemble_size)

both before and after update_ensemble!? That's no good... How do we avoid that?

Make `IterationSummary` an `OffsetArray`?

That way index 0 could correspond to iteration = 0.

cc @glwagner

Need tests for `update_closure_ensemble_member!` and `closure_with_parameters!`

This is a complex, slightly inscrutable, and crucial part of our algorithm. #53 suggests we need them!

Literate examples?

Should we literate some of the examples?

Does `projects/` directory belong in this repo?

`normalize!` is commented out in `transform_observations`

We are not normalizing observations or forward map data currently on main because normalize! is commented out:

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/4658e4c2ac0cbd0a9b6fda3a64f8634cfb31ffed/src/InverseProblems.jl#L206

This may be related to #95 .

We need an integration test to ensure that our input for normalization is respected both when transforming observations and also when calculating the forward_map.

Merge `Oceananigans.jl#glw-ah/parameter-estimation` to `Oceananigans.jl#main`

Currently Manifest.toml relies on Oceananigans.jl#glw-ah/parameter-estimation. Should we try to merge https://github.com/CliMA/Oceananigans.jl/tree/glw-ah/parameter-estimation to Oceananigans.jl main branch? Is there work to be done for that?

Should we avoid creating trivial batches in the examples?

I think lines like this might be confusing to new comers:

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/5ebdaeda4430798335bba48177cce39890be17bc/examples/convective_adjustment_perfect_model_calibration_eki.jl#L100

I think the objective here is to test whether batches work. I propose that we use tests for that, and keep the examples simple. Hopefully we'll have more examples with "real" batched observations soon.

Convective adjustment with UKI seems to be failing?

It seems to me that the UKI doesn't converge to the true parameter values. Am I interpreting this correctly?

See figure at the bottom of https://clima.github.io/OceanTurbulenceParameterEstimation.jl/dev/literated/unscented_perfect_convective_adjustment_calibration/

cc @Zhengyu-Huang

Renaming `OneDimensionalTimeSeries`

Apparently as of #31 the OneDimensionalTimeSeries can also be used for two-dimensional time serieses.

Perhaps we can generalize the name to cover all cases where we have a time-series of fields (as opposed to a time-series of statistics, which could actually warrant a new type of AbstractObservation) ?

Maybe something like ObservedFieldTimeSeries...

Rescaling `Normal(mu, sig)` by `1/abs(mu)` is undefined when `mu=0`

We rescale Normal by it's mean value (ostensibly producing distributions with a mean of 1):

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/b1351f5cbe5e7159d5107b6754f75442b08e908d/src/Parameters.jl#L165

but this is undefined for distributions with 0 mean.

What we are trying to achieve with this rescaling? Does it make more sense to divide by standard deviation?

@adelinehillier let me know what you think.

Original `EnsembleKalmanProcess` is used in `inverting_forward_map` without update

inverting_forward_map ignore the input θ and instead uses the "original" ensemble_kalman_process:

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/6fe61fb48bcb949a2d426988ac2e4397957013c0/src/EnsembleKalmanInversions.jl#L196-L201

that's defined in EnsembleKalmanInversion constructor to extract parameters. This produces wrong behavior when the process is updated during resampling:

https://github.com/CliMA/OceanTurbulenceParameterEstimation.jl/blob/6fe61fb48bcb949a2d426988ac2e4397957013c0/src/EnsembleKalmanInversions.jl#L443-L446

In particular, if a particle fails, it cannot be rescued. But the problem is hard to detect, because new_process above is used to update the parameter ensemble.

We need a test that catches this issue.

cc @adelinehillier

Unsuccessful regrid for reduced Nx x Ny x Nz grid onto 1 x 1 x Nz grid

The following regridding bug is revealed by the changes in #146.

julia> using OceanTurbulenceParameterEstimation, DataDeps

julia> data_path = datadep"two_day_suite_4m/free_convection_instantaneous_statistics.jld2";

julia> observations = SyntheticObservations(data_path; (:b,), normalize=ZScore, regrid_size=(1, 1, 64))
┌ Info: Regridding synthetic observations...
│     original grid: 64×64×64 RectilinearGrid{Float64, Oceananigans.Grids.Periodic, Oceananigans.Grids.Periodic, Oceananigans.Grids.Bounded} on Oceananigans.Architectures.CPU with 3×3×3 halo
└          new grid: 1×1×64 RectilinearGrid{Float64, Oceananigans.Grids.Periodic, Oceananigans.Grids.Periodic, Oceananigans.Grids.Bounded} on Oceananigans.Architectures.CPU with 3×3×3 halo
ERROR: ArgumentError: Regridding
1×1×64 Field{Nothing, Nothing, Oceananigans.Grids.Center} reduced over dims = (1, 2) on Oceananigans.Grids.RectilinearGrid on Oceananigans.Architectures.CPU on 64×64×64 RectilinearGrid{Float64, Oceananigans.Grids.Periodic, Oceananigans.Grids.Periodic, Oceananigans.Grids.Bounded} on Oceananigans.Architectures.CPU with 3×3×3 halo
to 1×1×64 Field{Oceananigans.Grids.Center, Oceananigans.Grids.Center, Oceananigans.Grids.Center} on Oceananigans.Grids.RectilinearGrid on Oceananigans.Architectures.CPU on 1×1×64 RectilinearGrid{Float64, Oceananigans.Grids.Periodic, Oceananigans.Grids.Periodic, Oceananigans.Grids.Bounded} on Oceananigans.Architectures.CPU with 3×3×3 halo
is not supported.

Suppressor suppresses too much :)

The @suppress statement here:
https://github.com/adelinehillier/OceanTurbulenceParameterEstimation.jl/blob/973d1799272970f0a8dc5bd1df14b3cdc81b4ad9/src/EnsembleKalmanInversions.jl#L267-L283
also suppresses @show summary.mean_square_errors. I don't think this is what we want, right?

Is this line here broken?
https://github.com/adelinehillier/OceanTurbulenceParameterEstimation.jl/blob/9b26575121d527d3ba0aa765ee655ccfb56e960f/examples/convective_adjustment_perfect_model_calibration.jl#L143
given that
https://github.com/adelinehillier/OceanTurbulenceParameterEstimation.jl/blob/9b26575121d527d3ba0aa765ee655ccfb56e960f/src/EnsembleKalmanInversions.jl#L277
?

cc: @adelinehillier

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.