text:
### A Pluto.jl notebook ###
# v0.17.2

using Markdown
using InteractiveUtils

# ╔═╡ 71b1447b-39d9-46e2-966d-a1e6e8dcccc6
begin
	using MeshArrays, OceanStateEstimation, MITgcmTools
	using JLD2
	import PlutoUI
	import CairoMakie as Mkie
	"Done with packages"
end

# ╔═╡ cee6124a-3043-447e-a3a3-780cadca7fd1
begin

	using Statistics

	"""
	    curl(u::MeshArray,v::MeshArray,Γ::NamedTuple)

	Compute curl of a velocity field.
	"""
	function curl(u::MeshArray,v::MeshArray,Γ::NamedTuple)

		uvcurl=similar(Γ.XC)
		fac=exchange(1.0 ./Γ.RAZ,1)
		(U,V)=exchange(u,v,1)
	    (DXC,DYC)=exchange(Γ.DXC,Γ.DYC,1)
		[DXC[i].=abs.(DXC[i]) for i in eachindex(U)]
		[DYC[i].=abs.(DYC[i]) for i in eachindex(V)]

		for i in eachindex(U)
	    ucur=U[i][2:end,:]
	    vcur=V[i][:,2:end]
	    tmpcurl=ucur[:,1:end-1]-ucur[:,2:end]
	    tmpcurl=tmpcurl-(vcur[1:end-1,:]-vcur[2:end,:])
	    tmpcurl=tmpcurl.*fac[i][1:end-1,1:end-1]

			##still needed:
			##- deal with corners
			##- if putCurlOnTpoints

			tmpcurl=1/4*(tmpcurl[1:end-1,2:end]+tmpcurl[1:end-1,1:end-1]+
						tmpcurl[2:end,2:end]+tmpcurl[2:end,1:end-1])

			uvcurl[i]=tmpcurl
		end

		return uvcurl
	end

	nanmean(x) = mean(filter(!isnan,x))
	nanmean(x,y) = mapslices(nanmean,x,dims=y)

	"""
	  UVtoUEVN(u,v,G::NamedTuple)
	    1. Interpolate to grid cell centers (uC,vC)
	    2. Convert to `Eastward/Northward` components (uE,vN)
	"""
	function UVtoUEVN(u::MeshArray,v::MeshArray,G::NamedTuple)
	    u[findall(G.hFacW[:,1].==0)].=NaN
	    v[findall(G.hFacS[:,1].==0)].=NaN

	    (u,v)=exch_UV(u,v); uC=similar(u); vC=similar(v)
	    for iF=1:u.grid.nFaces
	        tmp1=u[iF][1:end-1,:]; tmp2=u[iF][2:end,:]
	        uC[iF]=reshape(nanmean([tmp1[:] tmp2[:]],2),size(tmp1))
	        tmp1=v[iF][:,1:end-1]; tmp2=v[iF][:,2:end]
	        vC[iF]=reshape(nanmean([tmp1[:] tmp2[:]],2),size(tmp1))
	    end

	    return uC.*G.AngleCS-vC.*G.AngleSN, uC.*G.AngleSN+vC.*G.AngleCS
	end

	#Convert Velocity (m/s) to transport (m^3/s)
	function UVtoTransport(U::MeshArray,V::MeshArray,G::NamedTuple)
	  uTr=deepcopy(U)
	  vTr=deepcopy(V)
	  for i in eachindex(U)
	      tmp1=U[i]; tmp1[(!isfinite).(tmp1)] .= 0.0
	      tmp1=V[i]; tmp1[(!isfinite).(tmp1)] .= 0.0
	      uTr[i]=G.DRF[i[2]]*U[i].*G.DYG[i[1]]
	      vTr[i]=G.DRF[i[2]]*V[i].*G.DXG[i[1]]
	  end
	  return uTr,vTr
	end

end

# ╔═╡ 7046b9b2-06bf-4ed8-80a3-79d2c52dacaf
md"""# Vector Field Operations

The flow of various quantities within the climate system is often represented as gridded vector fields. On [C-grids](https://en.wikipedia.org/wiki/Arakawa_grids), which are the most commonly used grids in global models, velocity points are staggered (shifted) by half a gridded point compared to tracer points (e.g., temperature fields).

Vector fields on the C-grid are natively oriented along the grid cell axess. That is they are locally perpendicular to the grid cell edge where they are located. Often for plotting purposes or simply to facilitate analysis of model output by users, it is convenient to rotate these vector fields along Eastward and Northward axes. Doing this requires averaging them to grid cell centers first and then applying a rotation. Function `UVtoUEVN` is provided to this end.

The result can be easily be interpolated  to any geographic position using `Interpolate`, and `InterpolationFactors` provides a mean to speed-up this step when batch processing a lot of output by pre-computing interpolation factor once and for all.

Another processing step that is often useful is to convert velocities (e.g. in m/s) to transports (e.g. in m^3/s) by multiplying each value by the corresponding grid cell area. That's what function `UVtoTransport` does.

The result can then be passed to functions like `ScalarPotential` and `VectorPotential` that are useful to isolate particular transport components. These higher level functions are illustrated later on in this tutorial.

Transports can also be integrated along model grid line paths that may for examples connect two geographic locations, or track latitude circles, as explained in [Forget et al 2015](https://doi.org/10.5194/gmd-8-3071-2015). Functionalities to this end include `LatitudeCircles` (compute grid edge paths that track latitude circles) and `ThroughFlow` (integrate transports accross such grid edge paths).
"""

# ╔═╡ 3b6fcab2-ae44-41c7-adec-424025092419
PlutoUI.TableOfContents()

# ╔═╡ 1e7616f8-65ec-4cfa-960f-bd26451756bc
md"""## Eastward U , Northward V"""

# ╔═╡ 5d25c473-eb1f-4040-86c7-86dee7add5df
md"""## Meridional Transports

Two widely used ways of presenting global scale transports are demonstrated here :

- the so-called Meridional Overturning Circulation (`MOC`) is often defined by a streamfunction [e.g. Fig 1 in Rousselet et al 2021](https://doi.org/10.1126/sciadv.abf5478). The simplest approach consists in integrating transports across lines of constant latitude (e.g., using `ThroughFlow`) and then vertically starting from the sea floor as shown below.
- a related computation is that of net meridional transports which were recently discussed in detail for heat transport in [Forget and Ferreira 2019](https://doi.org/10.1038/s41561-019-0333-7). The case of sea water volume (~ proportional to mass) is shown below which also corresponds to the meridional streamfunction once intergrated all the way to the sea surface.
- a third related computation, maybe more suprisingly, is the computation of transports convergence ξ. In the time mean, ξ corresponds in first approximation to the map of evaporation-precipitation-runoff plus a globally homogeneous rate of sea level change. Integrating the anomaly in ξ from the South Pole one in turn recovers the total Northward transport (see [Forget and Ferreira 2019](https://doi.org/10.1038/s41561-019-0333-7) for more on this).

!!! note
    Results are here plotted in Sverdrup units defined as 1 Sv = $10^6$ m$^3$/s
"""

# ╔═╡ 1cd94bce-9b10-4957-95d0-f396264df162
md"""## Helmholtz Decomposition

By applying the [Helmholtz Decomposition](https://en.wikipedia.org/wiki/Helmholtz_decomposition) to vertically integrated transports over the Global Ocean, we can decompose this vector field into rotational and divergent components. The divergent component gives the above map of inferred Evaporation-Precipitation-Runoff. The rotational component in turn gives the streamfunction shown below.
"""

# ╔═╡ e59c1819-52fd-49eb-8b0c-63fbbc0baffb
md"""## x-direction U, y-direction V

The maps below reflect the native velocity field orientation. Note how this differ from the Eastward U , Northward V plots shown at the top. The apparent discontinuities in the maps below simply reflect that neighboring subdomains can have different orientaton as is evident in [Forget et al 2015](https://doi.org/10.5194/gmd-8-3071-2015).

!!! note
    Normally before interpolation one wants to apply rotation to convert to Eastward U , Northward V (see at the top of this notebook). The plot below reflects what happens if one doesn't.
"""

# ╔═╡ 0611986f-3d6e-4236-b68a-747b6018d381
md"""## Gradient And Curl"""

# ╔═╡ 87a4a232-d8eb-4612-8cc5-dc9d1c16dbe8
md"""## Particle Tracking

Materials and particles that tend to follow ocean currents or atmospheric winds can be analyzed in terms of trajectories. These are simply computed by integrating velocities over time within a [Lagrangian framework](https://en.wikipedia.org/wiki/Lagrangian_and_Eulerian_specification_of_the_flow_field).

When vector fields are represented using [MeshArrays.jl](https://github.com/JuliaClimate/MeshArrays.jl), as done in this tutorial, this is easily done via the [IndividualDisplacements.jl](https://github.com/JuliaClimate/IndividualDisplacements.jl) package as shown in [these examples](https://juliaclimate.github.io/IndividualDisplacements.jl/dev/examples/).
"""

# ╔═╡ a8ebbe41-1ac8-44da-b8c4-cbfd4d422227
md"""## Preliminary Steps

Here we load `MeshArrays.jl` and packages that provide a climatological estimate of ocean currents on the global grid defined in [Forget et al 2015](https://doi.org/10.5194/gmd-8-3071-2015) which is then used to demonstrate vector operations listed above.
"""

# ╔═╡ 3c2de9d4-b091-464b-9210-aa84f3d4c5f1
begin
	pth=MeshArrays.GRID_LLC90
	γ=GridSpec("LatLonCap",pth)
	Γ=GridLoad(γ;option="full")
	LC=LatitudeCircles(-89.0:89.0,Γ)
	"Done with grid"
end

# ╔═╡ c2788db6-3ab4-4c22-abf0-ae701a57e94d
begin
	μ =Γ.hFacC[:,1]
	μ[findall(μ.>0.0)].=1.0
	μ[findall(μ.==0.0)].=NaN

	if !isfile(joinpath(tempdir(),"interp_coeffs.jld2"))
		lon=[i for i=-179.:2.0:179., j=-89.:2.0:89.]
		lat=[j for i=-179.:2.0:179., j=-89.:2.0:89.]

		(f,i,j,w)=InterpolationFactors(Γ,vec(lon),vec(lat))
		jldsave(joinpath(tempdir(),"interp_coeffs.jld2"); lon=lon, lat=lat, f=f, i=i, j=j, w=w)
	end

	λ = load(joinpath(tempdir(),"interp_coeffs.jld2"))
	λ = MeshArrays.Dict_to_NamedTuple(λ)

	"Done with interpolation coefficients"
end

# ╔═╡ cf99ec64-d142-42ff-9767-3d851229024e
begin
	OceanStateEstimation.get_ecco_velocity_if_needed()
	✓uv1=true

	"""
	    read_velocities(γ::gcmgrid,t::Int,pth::String)

	Read velocity components `u,v` from files in `pth`for time `t`
	"""
	function read_velocities(γ::gcmgrid,t::Int,pth::String)
	    u=read_nctiles("$pth"*"UVELMASS/UVELMASS","UVELMASS",γ,I=(:,:,:,t))
	    v=read_nctiles("$pth"*"VVELMASS/VVELMASS","VVELMASS",γ,I=(:,:,:,t))
	    return u,v
	end

	"Ready to read velocity fields"
end

# ╔═╡ ea72e6df-68da-4ade-b1d9-b7689e511a40
begin
	✓uv1

	U=0.0*Γ.hFacW #varmeta not quite correct
	V=0.0*Γ.hFacS #varmeta not quite correct
	for t=1:12
		(u,v)=read_velocities(Γ.XC.grid,t,ECCOclim_path)
		for i in eachindex(U)
			U[i]=U[i]+u[i]/12.0
			V[i]=V[i]+v[i]/12.0
		end
	end

	(Utr,Vtr)=UVtoTransport(U,V,Γ)

	✓uv2=true

	"Done reading velocities, and computing transports"
end

# ╔═╡ dda89e9a-4585-49df-82cd-72db00c341fa
begin
	(uE,vN)=UVtoUEVN(U[:,1],V[:,1],Γ)
	uI=reshape(Interpolate(uE,λ.f,λ.i,λ.j,λ.w),size(λ.lon))
	vI=reshape(Interpolate(vN,λ.f,λ.i,λ.j,λ.w),size(λ.lon))
	"Done with Eastward / Westward components"
end

# ╔═╡ 60bda89f-5452-4f89-b4a4-a89568d45a6b
let
		fig1 = Mkie.Figure(resolution = (900,400),markersize=0.1)
		ax1 = Mkie.Axis(fig1[1,1], title="Eastward velocity (in m/s)")
		hm1=Mkie.contourf!(ax1,λ.lon[:,1],λ.lat[1,:],uI,levels=(-0.5:0.1:0.5)./2.0,clims=(-0.5,0.5)./2.0)
		Mkie.Colorbar(fig1[1,2], hm1, height = Mkie.Relative(0.65))
		fig1
end

# ╔═╡ 99e7e24b-578e-47be-818a-623c8e9e4381
let
		fig1 = Mkie.Figure(resolution = (900,400),markersize=0.1)
		ax1 = Mkie.Axis(fig1[1,1], title="Northward velocity (in m/s)")
		hm1=Mkie.contourf!(ax1,λ.lon[:,1],λ.lat[1,:],vI,levels=(-0.5:0.1:0.5)./5.0,clims=(-0.5,0.5)./5.0)
		Mkie.Colorbar(fig1[1,2], hm1, height = Mkie.Relative(0.65))
		fig1
end

# ╔═╡ 09dff33d-1c16-4fa6-a5af-8eb3c15816f3
begin
	nz=size(Γ.hFacC,2); nt=12; nl=length(LC)
	ov=Array{Float64,2}(undef,nl,nz)

	#integrate across latitude circles
	for z=1:nz
		UV=Dict("U"=>Utr[:,z],"V"=>Vtr[:,z],"dimensions"=>["x","y"])
		[ov[l,z]=ThroughFlow(UV,LC[l],Γ) for l=1:nl]
	end

	#integrate from bottom
	ov=reverse(cumsum(reverse(ov,dims=2),dims=2),dims=2)

	"Done with overturning"
end

# ╔═╡ a6f70839-b79f-42e1-bf4a-8c8978e6618e
let
	x=vec(-89.0:89.0); y=reverse(vec(Γ.RF[1:end-1])); #coordinate variables
	z=reverse(ov,dims=2); z[z.==0.0].=NaN

	fig1 = Mkie.Figure(resolution = (900,400),markersize=0.1)
	ax1 = Mkie.Axis(fig1[1,1], title="Meridional Overturning Streamfunction (in Sv)")
	hm1=Mkie.contourf!(ax1,x,y,1e-6*z,levels=(-40.0:5.0:40.0),clims=(-40,40))
	Mkie.Colorbar(fig1[1,2], hm1, height = Mkie.Relative(0.65))
	fig1
	#savefig("MOC_mean.png")
end

# ╔═╡ 923568dc-85f3-43c1-a631-d408a1662fb3
begin
	MT=fill(0.0,nl)

	#integrate across latitude circles and depth
	for z=1:nz
		UV=Dict("U"=>Utr[:,z],"V"=>Vtr[:,z],"dimensions"=>["x","y"])
		[MT[l]=MT[l]+ThroughFlow(UV,LC[l],Γ) for l=1:nl]
	end

	"Done with meridional transport"
end

# ╔═╡ 2d6c1787-3c30-4daf-8575-b51211f8e860
let
	x=vec(-89.0:89.0)
	fig1 = Mkie.Figure(resolution = (900,400),markersize=0.1)
	ax1 = Mkie.Axis(fig1[1,1], title="Northward Volume Transport (in Sv)")
	hm1=Mkie.lines!(x,1e-6*MT,xlabel="latitude",ylabel="Transport (in Sv)",label="ECCO estimate")
	fig1
end

# ╔═╡ 3a3ac112-cd2b-4ac9-9029-b79b8b5fa8b4
begin
	Tx=0.0*Utr[:,1]
	Ty=0.0*Vtr[:,1]
	for z=1:nz
		Tx=Tx+Utr[:,z]
		Ty=Ty+Vtr[:,z]
	end

	#convergence & land mask
	TrspCon=μ.*convergence(Tx,Ty)

	#scalar potential
	TrspPot=ScalarPotential(TrspCon)

	#Divergent transport component
	(TxD,TyD)=gradient(TrspPot,Γ)
	TxD=TxD.*Γ.DXC
	TyD=TyD.*Γ.DYC

	#Rotational transport component
	TxR = Tx-TxD
	TyR = Ty-TyD

	#vector Potential
	TrspPsi=μ.*VectorPotential(TxR,TyR,Γ)

	"Done with convergence and potentials"
end

# ╔═╡ 9928d59f-0733-4ad9-93e7-f1a8622afd1f
let
		z=reshape(Interpolate(TrspCon,λ.f,λ.i,λ.j,λ.w),size(λ.lon))

		fig1 = Mkie.Figure(resolution = (900,400),markersize=0.1)
		ax1 = Mkie.Axis(fig1[1,1], title="Evaporation - Precipitation - Runoff (in Sv; inferred)")
		hm1=Mkie.contourf!(ax1,λ.lon[:,1],λ.lat[1,:],z,levels=(-1.0:0.25:1.0).*800.0,clims=(-1.0,1.0).*800.0)
		Mkie.Colorbar(fig1[1,2], hm1, height = Mkie.Relative(0.65))
		fig1
end

# ╔═╡ c3b3a104-a1d6-4692-ae0c-2e55821afd03
let
	z=reshape(Interpolate(1e-6*TrspPsi,λ.f,λ.i,λ.j,λ.w),size(λ.lon))

	fig1 = Mkie.Figure(resolution = (900,400),markersize=0.1)
	ax1 = Mkie.Axis(fig1[1,1], title="Streamfunction (in Sv)")
	hm1=Mkie.contourf!(ax1,λ.lon[:,1],λ.lat[1,:],z,levels=(-1.0:0.25:1.0).*40.0,clims=(-1.0,1.0).*40.0)
	Mkie.Colorbar(fig1[1,2], hm1, height = Mkie.Relative(0.65))
	fig1
end

# ╔═╡ 210b5414-ada8-49a1-8ac4-9115ed33e285
let
	(dDdx, dDdy)=gradient(TrspPot,Γ)
	(dDdx, dDdy)=UVtoUEVN(dDdx, dDdy,Γ)
	dDdx=reshape(Interpolate(μ.*dDdx,λ.f,λ.i,λ.j,λ.w),size(λ.lon))
	dDdy=reshape(Interpolate(μ.*dDdy,λ.f,λ.i,λ.j,λ.w),size(λ.lon))

	fig1 = Mkie.Figure(resolution = (900,600),markersize=0.1)
	ax1 = Mkie.Axis(fig1[1,1], title="Gradient of scalar potential in Eastward direction (in 1/s)")
	hm1=Mkie.contourf!(ax1,λ.lon[:,1],λ.lat[1,:],dDdx,levels=(-1.0:0.25:1.0).*0.1)
	ax1 = Mkie.Axis(fig1[2,1], title="Gradient of scalar potential in Northward direction (in 1/s)")
	hm1=Mkie.contourf!(ax1,λ.lon[:,1],λ.lat[1,:],dDdy,levels=(-1.0:0.25:1.0).*0.1)
	Mkie.Colorbar(fig1[1:2,2], hm1, height = Mkie.Relative(0.65))
	fig1
end

# ╔═╡ e033825c-019c-44b6-86dd-30fff79f8339
let
	dDdx=U[:,1]
	dDdy=V[:,1]

	DD=Interpolate(dDdx,λ.f,λ.i,λ.j,λ.w)
	DD=reshape(DD,size(λ.lon))
	DD[findall(DD.==0.0)].=NaN
	dDdx_i=DD

	DD=Interpolate(dDdy,λ.f,λ.i,λ.j,λ.w)
	DD=reshape(DD,size(λ.lon))
	DD[findall(DD.==0.0)].=NaN
	dDdy_i=DD

	fig = Mkie.Figure(resolution = (900,600), backgroundcolor = :grey95)
	ax = Mkie.Axis(fig[1,1], title="x-direction velocity (in m/s)",xlabel="longitude",ylabel="latitude")
	hm1=Mkie.heatmap!(ax,λ.lon[:,1],λ.lat[1,:],dDdx_i,colorrange=(-1.0,1.0).*0.2)
	ax = Mkie.Axis(fig[2,1], title="y-direction velocity (in m/s)",xlabel="longitude",ylabel="latitude")
	hm1=Mkie.heatmap!(ax,λ.lon[:,1],λ.lat[1,:],dDdy_i,colorrange=(-1.0,1.0).*0.2)
	Mkie.Colorbar(fig[1:2,2], hm1, height = Mkie.Relative(0.65))
	fig
end

# ╔═╡ 0888db7a-ff14-44c0-9c20-fed722f7e41e
let
	u=U[:,1]
	v=V[:,1]
	tmp=curl(u,v,Γ)

	z=reshape(Interpolate(μ.*tmp,λ.f,λ.i,λ.j,λ.w),size(λ.lon))

	fig1 = Mkie.Figure(resolution = (900,400),markersize=0.1)
	ax1 = Mkie.Axis(fig1[1,1], title="Curl Of velocity Field (in 1/s)")
	hm1=Mkie.contourf!(ax1,λ.lon[:,1],λ.lat[1,:],z,levels=(-1.0:0.25:1.0).*1e-11)
	Mkie.Colorbar(fig1[1,2], hm1, height = Mkie.Relative(0.65))
	fig1
end

# ╔═╡ 00000000-0000-0000-0000-000000000001
PLUTO_PROJECT_TOML_CONTENTS = """
[deps]
CairoMakie = "13f3f980-e62b-5c42-98c6-ff1f3baf88f0"
JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819"
MITgcmTools = "62725fbc-3a66-4df3-9000-e33e85b3a198"
MeshArrays = "cb8c808f-1acf-59a3-9d2b-6e38d009f683"
OceanStateEstimation = "891f6deb-a4f5-4bc5-a2e3-1e8f649cdd2c"
PlutoUI = "7f904dfe-b85e-4ff6-b463-dae2292396a8"
Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"

[compat]
CairoMakie = "~0.6.6"
JLD2 = "~0.4.15"
MITgcmTools = "~0.1.31"
MeshArrays = "~0.2.26"
OceanStateEstimation = "~0.1.15"
PlutoUI = "~0.7.19"
"""

# ╔═╡ 00000000-0000-0000-0000-000000000002
PLUTO_MANIFEST_TOML_CONTENTS = """
# This file is machine-generated - editing it directly is not advised

[[AWS]]
deps = ["Base64", "Compat", "Dates", "Downloads", "GitHub", "HTTP", "IniFile", "JSON", "MbedTLS", "Mocking", "OrderedCollections", "Retry", "Sockets", "URIs", "UUIDs", "XMLDict"]
git-tree-sha1 = "de871c318051314925e1cb6f20839e0c38d11799"
uuid = "fbe9abb3-538b-5e4e-ba9e-bc94f4f92ebc"
version = "1.71.0"

[[AbstractFFTs]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "485ee0867925449198280d4af84bdb46a2a404d0"
uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c"
version = "1.0.1"

[[AbstractPlutoDingetjes]]
deps = ["Pkg"]
git-tree-sha1 = "0bc60e3006ad95b4bb7497698dd7c6d649b9bc06"
uuid = "6e696c72-6542-2067-7265-42206c756150"
version = "1.1.1"

[[AbstractTrees]]
git-tree-sha1 = "03e0550477d86222521d254b741d470ba17ea0b5"
uuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
version = "0.3.4"

[[Adapt]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "84918055d15b3114ede17ac6a7182f68870c16f7"
uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
version = "3.3.1"

[[Animations]]
deps = ["Colors"]
git-tree-sha1 = "e81c509d2c8e49592413bfb0bb3b08150056c79d"
uuid = "27a7e980-b3e6-11e9-2bcd-0b925532e340"
version = "0.4.1"

[[ArgTools]]
uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f"

[[ArrayInterface]]
deps = ["Compat", "IfElse", "LinearAlgebra", "Requires", "SparseArrays", "Static"]
git-tree-sha1 = "e527b258413e0c6d4f66ade574744c94edef81f8"
uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
version = "3.1.40"

[[Artifacts]]
uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"

[[Automa]]
deps = ["Printf", "ScanByte", "TranscodingStreams"]
git-tree-sha1 = "d50976f217489ce799e366d9561d56a98a30d7fe"
uuid = "67c07d97-cdcb-5c2c-af73-a7f9c32a568b"
version = "0.8.2"

[[AxisAlgorithms]]
deps = ["LinearAlgebra", "Random", "SparseArrays", "WoodburyMatrices"]
git-tree-sha1 = "66771c8d21c8ff5e3a93379480a2307ac36863f7"
uuid = "13072b0f-2c55-5437-9ae7-d433b7a33950"
version = "1.0.1"

[[Base64]]
uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

[[Blosc]]
deps = ["Blosc_jll"]
git-tree-sha1 = "217da19d6f3a94753e580a8bc241c7cbefd9281f"
uuid = "a74b3585-a348-5f62-a45c-50e91977d574"
version = "0.7.1"

[[Blosc_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Lz4_jll", "Pkg", "Zlib_jll", "Zstd_jll"]
git-tree-sha1 = "e747dac84f39c62aff6956651ec359686490134e"
uuid = "0b7ba130-8d10-5ba8-a3d6-c5182647fed9"
version = "1.21.0+0"

[[Bzip2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "c3598e525718abcc440f69cc6d5f60dda0a1b61e"
uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0"
version = "1.0.6+5"

[[CEnum]]
git-tree-sha1 = "215a9aa4a1f23fbd05b92769fdd62559488d70e9"
uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82"
version = "0.4.1"

[[CFTime]]
deps = ["Dates", "Printf"]
git-tree-sha1 = "bca6cb6ee746e6485ca4535f6cc29cf3579a0f20"
uuid = "179af706-886a-5703-950a-314cd64e0468"
version = "0.1.1"

[[CSV]]
deps = ["CodecZlib", "Dates", "FilePathsBase", "InlineStrings", "Mmap", "Parsers", "PooledArrays", "SentinelArrays", "Tables", "Unicode", "WeakRefStrings"]
git-tree-sha1 = "74147e877531d7c172f70b492995bc2b5ca3a843"
uuid = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
version = "0.9.10"

[[Cairo]]
deps = ["Cairo_jll", "Colors", "Glib_jll", "Graphics", "Libdl", "Pango_jll"]
git-tree-sha1 = "d0b3f8b4ad16cb0a2988c6788646a5e6a17b6b1b"
uuid = "159f3aea-2a34-519c-b102-8c37f9878175"
version = "1.0.5"

[[CairoMakie]]
deps = ["Base64", "Cairo", "Colors", "FFTW", "FileIO", "FreeType", "GeometryBasics", "LinearAlgebra", "Makie", "SHA", "StaticArrays"]
git-tree-sha1 = "774ff1cce3ae930af3948c120c15eeb96c886c33"
uuid = "13f3f980-e62b-5c42-98c6-ff1f3baf88f0"
version = "0.6.6"

[[Cairo_jll]]
deps = ["Artifacts", "Bzip2_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "JLLWrappers", "LZO_jll", "Libdl", "Pixman_jll", "Pkg", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Zlib_jll", "libpng_jll"]
git-tree-sha1 = "e2f47f6d8337369411569fd45ae5753ca10394c6"
uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a"
version = "1.16.0+6"

[[CatViews]]
deps = ["Random", "Test"]
git-tree-sha1 = "23d1f1e10d4e24374112fcf800ac981d14a54b24"
uuid = "81a5f4ea-a946-549a-aa7e-2a7f63a27d31"
version = "1.0.0"

[[ChainRulesCore]]
deps = ["Compat", "LinearAlgebra", "SparseArrays"]
git-tree-sha1 = "f885e7e7c124f8c92650d61b9477b9ac2ee607dd"
uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
version = "1.11.1"

[[ChangesOfVariables]]
deps = ["LinearAlgebra", "Test"]
git-tree-sha1 = "9a1d594397670492219635b35a3d830b04730d62"
uuid = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0"
version = "0.1.1"

[[ClimateModels]]
deps = ["AWS", "CFTime", "CSV", "DataFrames", "Dates", "Downloads", "Git", "NetCDF", "OrderedCollections", "Pkg", "Statistics", "Suppressor", "TOML", "Test", "UUIDs", "Zarr"]
git-tree-sha1 = "15ba5b736e675d5e79fe5ad0e7a8f67a286ffe31"
uuid = "f6adb021-9183-4f40-84dc-8cea6f651bb0"
version = "0.1.20"

[[CodecZlib]]
deps = ["TranscodingStreams", "Zlib_jll"]
git-tree-sha1 = "ded953804d019afa9a3f98981d99b33e3db7b6da"
uuid = "944b1d66-785c-5afd-91f1-9de20f533193"
version = "0.7.0"

[[ColorBrewer]]
deps = ["Colors", "JSON", "Test"]
git-tree-sha1 = "61c5334f33d91e570e1d0c3eb5465835242582c4"
uuid = "a2cac450-b92f-5266-8821-25eda20663c8"
version = "0.4.0"

[[ColorSchemes]]
deps = ["ColorTypes", "Colors", "FixedPointNumbers", "Random"]
git-tree-sha1 = "a851fec56cb73cfdf43762999ec72eff5b86882a"
uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4"
version = "3.15.0"

[[ColorTypes]]
deps = ["FixedPointNumbers", "Random"]
git-tree-sha1 = "024fe24d83e4a5bf5fc80501a314ce0d1aa35597"
uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f"
version = "0.11.0"

[[ColorVectorSpace]]
deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "SpecialFunctions", "Statistics", "TensorCore"]
git-tree-sha1 = "45efb332df2e86f2cb2e992239b6267d97c9e0b6"
uuid = "c3611d14-8923-5661-9e6a-0046d554d3a4"
version = "0.9.7"

[[Colors]]
deps = ["ColorTypes", "FixedPointNumbers", "Reexport"]
git-tree-sha1 = "417b0ed7b8b838aa6ca0a87aadf1bb9eb111ce40"
uuid = "5ae59095-9a9b-59fe-a467-6f913c188581"
version = "0.12.8"

[[Compat]]
deps = ["Base64", "Dates", "DelimitedFiles", "Distributed", "InteractiveUtils", "LibGit2", "Libdl", "LinearAlgebra", "Markdown", "Mmap", "Pkg", "Printf", "REPL", "Random", "SHA", "Serialization", "SharedArrays", "Sockets", "SparseArrays", "Statistics", "Test", "UUIDs", "Unicode"]
git-tree-sha1 = "dce3e3fea680869eaa0b774b2e8343e9ff442313"
uuid = "34da2185-b29b-5c13-b0c7-acf172513d20"
version = "3.40.0"

[[CompilerSupportLibraries_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae"

[[ConstructionBase]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "f74e9d5388b8620b4cee35d4c5a618dd4dc547f4"
uuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9"
version = "1.3.0"

[[Contour]]
deps = ["StaticArrays"]
git-tree-sha1 = "9f02045d934dc030edad45944ea80dbd1f0ebea7"
uuid = "d38c429a-6771-53c6-b99e-75d170b6e991"
version = "0.5.7"

[[Crayons]]
git-tree-sha1 = "3f71217b538d7aaee0b69ab47d9b7724ca8afa0d"
uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f"
version = "4.0.4"

[[DataAPI]]
git-tree-sha1 = "cc70b17275652eb47bc9e5f81635981f13cea5c8"
uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"
version = "1.9.0"

[[DataFrames]]
deps = ["Compat", "DataAPI", "Future", "InvertedIndices", "IteratorInterfaceExtensions", "LinearAlgebra", "Markdown", "Missings", "PooledArrays", "PrettyTables", "Printf", "REPL", "Reexport", "SortingAlgorithms", "Statistics", "TableTraits", "Tables", "Unicode"]
git-tree-sha1 = "d785f42445b63fc86caa08bb9a9351008be9b765"
uuid = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
version = "1.2.2"

[[DataStructures]]
deps = ["Compat", "InteractiveUtils", "OrderedCollections"]
git-tree-sha1 = "7d9d316f04214f7efdbb6398d545446e246eff02"
uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
version = "0.18.10"

[[DataValueInterfaces]]
git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6"
uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464"
version = "1.0.0"

[[Dates]]
deps = ["Printf"]
uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"

[[DelimitedFiles]]
deps = ["Mmap"]
uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab"

[[DensityInterface]]
deps = ["InverseFunctions", "Test"]
git-tree-sha1 = "794daf62dce7df839b8ed446fc59c68db4b5182f"
uuid = "b429d917-457f-4dbc-8f4c-0cc954292b1d"
version = "0.3.3"

[[DiskArrays]]
git-tree-sha1 = "6a50d800025a1664c99a8e819e0568c75e3ac0c7"
uuid = "3c3547ce-8d99-4f5e-a174-61eb10b00ae3"
version = "0.2.12"

[[Distances]]
deps = ["LinearAlgebra", "Statistics", "StatsAPI"]
git-tree-sha1 = "837c83e5574582e07662bbbba733964ff7c26b9d"
uuid = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7"
version = "0.10.6"

[[Distributed]]
deps = ["Random", "Serialization", "Sockets"]
uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b"

[[Distributions]]
deps = ["ChainRulesCore", "DensityInterface", "FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SparseArrays", "SpecialFunctions", "Statistics", "StatsBase", "StatsFuns", "Test"]
git-tree-sha1 = "cce8159f0fee1281335a04bbf876572e46c921ba"
uuid = "31c24e10-a181-5473-b8eb-7969acd0382f"
version = "0.25.29"

[[DocStringExtensions]]
deps = ["LibGit2"]
git-tree-sha1 = "b19534d1895d702889b219c382a6e18010797f0b"
uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
version = "0.8.6"

[[Downloads]]
deps = ["ArgTools", "LibCURL", "NetworkOptions"]
uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6"

[[EarCut_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "3f3a2501fa7236e9b911e0f7a588c657e822bb6d"
uuid = "5ae413db-bbd1-5e63-b57d-d24a61df00f5"
version = "2.2.3+0"

[[EllipsisNotation]]
deps = ["ArrayInterface"]
git-tree-sha1 = "9aad812fb7c4c038da7cab5a069f502e6e3ae030"
uuid = "da5c29d0-fa7d-589e-88eb-ea29b0a81949"
version = "1.1.1"

[[Expat_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b3bfd02e98aedfa5cf885665493c5598c350cd2f"
uuid = "2e619515-83b5-522b-bb60-26c02a35a201"
version = "2.2.10+0"

[[ExprTools]]
git-tree-sha1 = "b7e3d17636b348f005f11040025ae8c6f645fe92"
uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04"
version = "0.1.6"

[[EzXML]]
deps = ["Printf", "XML2_jll"]
git-tree-sha1 = "0fa3b52a04a4e210aeb1626def9c90df3ae65268"
uuid = "8f5d6c58-4d21-5cfd-889c-e3ad7ee6a615"
version = "1.1.0"

[[FFMPEG]]
deps = ["FFMPEG_jll"]
git-tree-sha1 = "b57e3acbe22f8484b4b5ff66a7499717fe1a9cc8"
uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a"
version = "0.4.1"

[[FFMPEG_jll]]
deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "LibVPX_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "Pkg", "Zlib_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"]
git-tree-sha1 = "3cc57ad0a213808473eafef4845a74766242e05f"
uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5"
version = "4.3.1+4"

[[FFTW]]
deps = ["AbstractFFTs", "FFTW_jll", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"]
git-tree-sha1 = "463cb335fa22c4ebacfd1faba5fde14edb80d96c"
uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
version = "1.4.5"

[[FFTW_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "c6033cc3892d0ef5bb9cd29b7f2f0331ea5184ea"
uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a"
version = "3.3.10+0"

[[FileIO]]
deps = ["Pkg", "Requires", "UUIDs"]
git-tree-sha1 = "2db648b6712831ecb333eae76dbfd1c156ca13bb"
uuid = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549"
version = "1.11.2"

[[FilePathsBase]]
deps = ["Dates", "Mmap", "Printf", "Test", "UUIDs"]
git-tree-sha1 = "5440c1d26aa29ca9ea848559216e5ee5f16a8627"
uuid = "48062228-2e41-5def-b9a4-89aafe57970f"
version = "0.9.14"

[[FillArrays]]
deps = ["LinearAlgebra", "Random", "SparseArrays", "Statistics"]
git-tree-sha1 = "8756f9935b7ccc9064c6eef0bff0ad643df733a3"
uuid = "1a297f60-69ca-5386-bcde-b61e274b549b"
version = "0.12.7"

[[FixedPointNumbers]]
deps = ["Statistics"]
git-tree-sha1 = "335bfdceacc84c5cdf16aadc768aa5ddfc5383cc"
uuid = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
version = "0.8.4"

[[Fontconfig_jll]]
deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "35895cf184ceaab11fd778b4590144034a167a2f"
uuid = "a3f928ae-7b40-5064-980b-68af3947d34b"
version = "2.13.1+14"

[[Formatting]]
deps = ["Printf"]
git-tree-sha1 = "8339d61043228fdd3eb658d86c926cb282ae72a8"
uuid = "59287772-0a20-5a39-b81b-1366585eb4c0"
version = "0.4.2"

[[FortranFiles]]
git-tree-sha1 = "f8cec967f151a65f03afd826650c6e91d8b1da16"
uuid = "c58ffaec-ab22-586d-bfc5-781a99fd0b10"
version = "0.6.0"

[[FreeType]]
deps = ["CEnum", "FreeType2_jll"]
git-tree-sha1 = "cabd77ab6a6fdff49bfd24af2ebe76e6e018a2b4"
uuid = "b38be410-82b0-50bf-ab77-7b57e271db43"
version = "4.0.0"

[[FreeType2_jll]]
deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "cbd58c9deb1d304f5a245a0b7eb841a2560cfec6"
uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7"
version = "2.10.1+5"

[[FreeTypeAbstraction]]
deps = ["ColorVectorSpace", "Colors", "FreeType", "GeometryBasics", "StaticArrays"]
git-tree-sha1 = "19d0f1e234c13bbfd75258e55c52aa1d876115f5"
uuid = "663a7486-cb36-511b-a19d-713bb74d65c9"
version = "0.9.2"

[[FriBidi_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "aa31987c2ba8704e23c6c8ba8a4f769d5d7e4f91"
uuid = "559328eb-81f9-559d-9380-de523a88c83c"
version = "1.0.10+0"

[[Future]]
deps = ["Random"]
uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820"

[[GeometryBasics]]
deps = ["EarCut_jll", "IterTools", "LinearAlgebra", "StaticArrays", "StructArrays", "Tables"]
git-tree-sha1 = "58bcdf5ebc057b085e58d95c138725628dd7453c"
uuid = "5c1252a2-5f33-56bf-86c9-59e7332b4326"
version = "0.4.1"

[[Gettext_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "XML2_jll"]
git-tree-sha1 = "8c14294a079216000a0bdca5ec5a447f073ddc9d"
uuid = "78b55507-aeef-58d4-861c-77aaff3498b1"
version = "0.20.1+7"

[[Git]]
deps = ["Git_jll"]
git-tree-sha1 = "d7bffc3fe097e9589145493c08c41297b457e5d0"
uuid = "d7ba0133-e1db-5d97-8f8c-041e4b3a1eb2"
version = "1.2.1"

[[GitHub]]
deps = ["Base64", "Dates", "HTTP", "JSON", "MbedTLS", "Sockets", "SodiumSeal"]
git-tree-sha1 = "c8594dff1ed76e232d8063b2a2555335900af6f3"
uuid = "bc5e4493-9b4d-5f90-b8aa-2b2bcaad7a26"
version = "5.7.0"

[[Git_jll]]
deps = ["Artifacts", "Expat_jll", "Gettext_jll", "JLLWrappers", "LibCURL_jll", "Libdl", "Libiconv_jll", "OpenSSL_jll", "PCRE2_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "33be385f3432a5a5b7f6965af9592d4407f3167f"
uuid = "f8c6e375-362e-5223-8a59-34ff63f689eb"
version = "2.31.0+0"

[[Glib_jll]]
deps = ["Artifacts", "Gettext_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "04690cc5008b38ecbdfede949220bc7d9ba26397"
uuid = "7746bdde-850d-59dc-9ae8-88ece973131d"
version = "2.59.0+4"

[[Graphics]]
deps = ["Colors", "LinearAlgebra", "NaNMath"]
git-tree-sha1 = "1c5a84319923bea76fa145d49e93aa4394c73fc2"
uuid = "a2bd30eb-e257-5431-a919-1863eab51364"
version = "1.1.1"

[[Graphite2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "344bf40dcab1073aca04aa0df4fb092f920e4011"
uuid = "3b182d85-2403-5c21-9c21-1e1f0cc25472"
version = "1.3.14+0"

[[GridLayoutBase]]
deps = ["GeometryBasics", "InteractiveUtils", "Observables"]
git-tree-sha1 = "70938436e2720e6cb8a7f2ca9f1bbdbf40d7f5d0"
uuid = "3955a311-db13-416c-9275-1d80ed98e5e9"
version = "0.6.4"

[[Grisu]]
git-tree-sha1 = "53bb909d1151e57e2484c3d1b53e19552b887fb2"
uuid = "42e2da0e-8278-4e71-bc24-59509adca0fe"
version = "1.0.2"

[[HDF5_jll]]
deps = ["Artifacts", "JLLWrappers", "LibCURL_jll", "Libdl", "OpenSSL_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "fd83fa0bde42e01952757f01149dd968c06c4dba"
uuid = "0234f1f7-429e-5d53-9886-15a909be8d59"
version = "1.12.0+1"

[[HTTP]]
deps = ["Base64", "Dates", "IniFile", "Logging", "MbedTLS", "NetworkOptions", "Sockets", "URIs"]
git-tree-sha1 = "14eece7a3308b4d8be910e265c724a6ba51a9798"
uuid = "cd3eb016-35fb-5094-929b-558a96fad6f3"
version = "0.9.16"

[[HarfBuzz_jll]]
deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "Gettext_jll", "Glib_jll", "Graphite2_jll", "ICU_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg"]
git-tree-sha1 = "90bed5fc61d12d10832ebf988988104888eebaca"
uuid = "2e76f6c2-a576-52d4-95c1-20adfe4de566"
version = "2.6.1+10"

[[Hyperscript]]
deps = ["Test"]
git-tree-sha1 = "8d511d5b81240fc8e6802386302675bdf47737b9"
uuid = "47d2ed2b-36de-50cf-bf87-49c2cf4b8b91"
version = "0.0.4"

[[HypertextLiteral]]
git-tree-sha1 = "2b078b5a615c6c0396c77810d92ee8c6f470d238"
uuid = "ac1192a8-f4b3-4bfe-ba22-af5b92cd3ab2"
version = "0.9.3"

[[ICU_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "6ce9cf3c5490b045710d60ac3fd2fe48188846b3"
uuid = "a51ab1cf-af8e-5615-a023-bc2c838bba6b"
version = "67.1.0+3"

[[IOCapture]]
deps = ["Logging", "Random"]
git-tree-sha1 = "f7be53659ab06ddc986428d3a9dcc95f6fa6705a"
uuid = "b5f81e59-6552-4d32-b1f0-c071b021bf89"
version = "0.2.2"

[[IfElse]]
git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1"
uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"
version = "0.1.1"

[[ImageCore]]
deps = ["AbstractFFTs", "ColorVectorSpace", "Colors", "FixedPointNumbers", "Graphics", "MappedArrays", "MosaicViews", "OffsetArrays", "PaddedViews", "Reexport"]
git-tree-sha1 = "9a5c62f231e5bba35695a20988fc7cd6de7eeb5a"
uuid = "a09fc81d-aa75-5fe9-8630-4744c3626534"
version = "0.9.3"

[[ImageIO]]
deps = ["FileIO", "Netpbm", "OpenEXR", "PNGFiles", "TiffImages", "UUIDs"]
git-tree-sha1 = "a2951c93684551467265e0e32b577914f69532be"
uuid = "82e4d734-157c-48bb-816b-45c225c6df19"
version = "0.5.9"

[[Imath_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "87f7662e03a649cffa2e05bf19c303e168732d3e"
uuid = "905a6f67-0a94-5f89-b386-d35d92009cd1"
version = "3.1.2+0"

[[IndirectArrays]]
git-tree-sha1 = "012e604e1c7458645cb8b436f8fba789a51b257f"
uuid = "9b13fd28-a010-5f03-acff-a1bbcff69959"
version = "1.0.0"

[[Inflate]]
git-tree-sha1 = "f5fc07d4e706b84f72d54eedcc1c13d92fb0871c"
uuid = "d25df0c9-e2be-5dd7-82c8-3ad0b3e990b9"
version = "0.1.2"

[[IniFile]]
deps = ["Test"]
git-tree-sha1 = "098e4d2c533924c921f9f9847274f2ad89e018b8"
uuid = "83e8ac13-25f8-5344-8a64-a9f2b223428f"
version = "0.5.0"

[[InlineStrings]]
deps = ["Parsers"]
git-tree-sha1 = "19cb49649f8c41de7fea32d089d37de917b553da"
uuid = "842dd82b-1e85-43dc-bf29-5d0ee9dffc48"
version = "1.0.1"

[[IntelOpenMP_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "d979e54b71da82f3a65b62553da4fc3d18c9004c"
uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0"
version = "2018.0.3+2"

[[InteractiveUtils]]
deps = ["Markdown"]
uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"

[[Interpolations]]
deps = ["AxisAlgorithms", "ChainRulesCore", "LinearAlgebra", "OffsetArrays", "Random", "Ratios", "Requires", "SharedArrays", "SparseArrays", "StaticArrays", "WoodburyMatrices"]
git-tree-sha1 = "61aa005707ea2cebf47c8d780da8dc9bc4e0c512"
uuid = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59"
version = "0.13.4"

[[IntervalSets]]
deps = ["Dates", "EllipsisNotation", "Statistics"]
git-tree-sha1 = "3cc368af3f110a767ac786560045dceddfc16758"
uuid = "8197267c-284f-5f27-9208-e0e47529a953"
version = "0.5.3"

[[InverseFunctions]]
deps = ["Test"]
git-tree-sha1 = "a7254c0acd8e62f1ac75ad24d5db43f5f19f3c65"
uuid = "3587e190-3f89-42d0-90ee-14403ec27112"
version = "0.1.2"

[[InvertedIndices]]
git-tree-sha1 = "bee5f1ef5bf65df56bdd2e40447590b272a5471f"
uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f"
version = "1.1.0"

[[IrrationalConstants]]
git-tree-sha1 = "7fd44fd4ff43fc60815f8e764c0f352b83c49151"
uuid = "92d709cd-6900-40b7-9082-c6be49f344b6"
version = "0.1.1"

[[Isoband]]
deps = ["isoband_jll"]
git-tree-sha1 = "f9b6d97355599074dc867318950adaa6f9946137"
uuid = "f1662d9f-8043-43de-a69a-05efc1cc6ff4"
version = "0.1.1"

[[IterTools]]
git-tree-sha1 = "05110a2ab1fc5f932622ffea2a003221f4782c18"
uuid = "c8e1da08-722c-5040-9ed9-7db0dc04731e"
version = "1.3.0"

[[IteratorInterfaceExtensions]]
git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856"
uuid = "82899510-4779-5014-852e-03e436cf321d"
version = "1.0.0"

[[JLD2]]
deps = ["DataStructures", "FileIO", "MacroTools", "Mmap", "Pkg", "Printf", "Reexport", "TranscodingStreams", "UUIDs"]
git-tree-sha1 = "46b7834ec8165c541b0b5d1c8ba63ec940723ffb"
uuid = "033835bb-8acc-5ee8-8aae-3f567f8a3819"
version = "0.4.15"

[[JLLWrappers]]
deps = ["Preferences"]
git-tree-sha1 = "642a199af8b68253517b80bd3bfd17eb4e84df6e"
uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210"
version = "1.3.0"

[[JSON]]
deps = ["Dates", "Mmap", "Parsers", "Unicode"]
git-tree-sha1 = "8076680b162ada2a031f707ac7b4953e30667a37"
uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
version = "0.21.2"

[[KernelDensity]]
deps = ["Distributions", "DocStringExtensions", "FFTW", "Interpolations", "StatsBase"]
git-tree-sha1 = "591e8dc09ad18386189610acafb970032c519707"
uuid = "5ab0869b-81aa-558d-bb23-cbf5423bbe9b"
version = "0.6.3"

[[LAME_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "f6250b16881adf048549549fba48b1161acdac8c"
uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d"
version = "3.100.1+0"

[[LZO_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "e5b909bcf985c5e2605737d2ce278ed791b89be6"
uuid = "dd4b983a-f0e5-5f8d-a1b7-129d4a5fb1ac"
version = "2.10.1+0"

[[LaTeXStrings]]
git-tree-sha1 = "f2355693d6778a178ade15952b7ac47a4ff97996"
uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f"
version = "1.3.0"

[[LazyArtifacts]]
deps = ["Artifacts", "Pkg"]
uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3"

[[LibCURL]]
deps = ["LibCURL_jll", "MozillaCACerts_jll"]
uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21"

[[LibCURL_jll]]
deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"]
uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"

[[LibGit2]]
deps = ["Base64", "NetworkOptions", "Printf", "SHA"]
uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"

[[LibSSH2_jll]]
deps = ["Artifacts", "Libdl", "MbedTLS_jll"]
uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8"

[[LibVPX_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "12ee7e23fa4d18361e7c2cde8f8337d4c3101bc7"
uuid = "dd192d2f-8180-539f-9fb4-cc70b1dcf69a"
version = "1.10.0+0"

[[Libdl]]
uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

[[Libffi_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "0b4a5d71f3e5200a7dff793393e09dfc2d874290"
uuid = "e9f186c6-92d2-5b65-8a66-fee21dc1b490"
version = "3.2.2+1"

[[Libgcrypt_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgpg_error_jll", "Pkg"]
git-tree-sha1 = "64613c82a59c120435c067c2b809fc61cf5166ae"
uuid = "d4300ac3-e22c-5743-9152-c294e39db1e4"
version = "1.8.7+0"

[[Libgpg_error_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "c333716e46366857753e273ce6a69ee0945a6db9"
uuid = "7add5ba3-2f88-524e-9cd5-f83b8a55f7b8"
version = "1.42.0+0"

[[Libiconv_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "42b62845d70a619f063a7da093d995ec8e15e778"
uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531"
version = "1.16.1+1"

[[Libmount_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "9c30530bf0effd46e15e0fdcf2b8636e78cbbd73"
uuid = "4b2f31a3-9ecc-558c-b454-b3730dcb73e9"
version = "2.35.0+0"

[[Libuuid_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "7f3efec06033682db852f8b3bc3c1d2b0a0ab066"
uuid = "38a345b3-de98-5d2b-a5d3-14cd9215e700"
version = "2.36.0+0"

[[LinearAlgebra]]
deps = ["Libdl"]
uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

[[LogExpFunctions]]
deps = ["ChainRulesCore", "ChangesOfVariables", "DocStringExtensions", "InverseFunctions", "IrrationalConstants", "LinearAlgebra"]
git-tree-sha1 = "be9eef9f9d78cecb6f262f3c10da151a6c5ab827"
uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688"
version = "0.3.5"

[[Logging]]
uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"

[[Lz4_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "5d494bc6e85c4c9b626ee0cab05daa4085486ab1"
uuid = "5ced341a-0733-55b8-9ab6-a4889d929147"
version = "1.9.3+0"

[[MITgcmTools]]
deps = ["ClimateModels", "DataFrames", "Dates", "LazyArtifacts", "MeshArrays", "NetCDF", "OrderedCollections", "Printf", "SparseArrays", "Suppressor", "UUIDs"]
git-tree-sha1 = "32f697fca7f26636e4df369681f96b2c56f40992"
uuid = "62725fbc-3a66-4df3-9000-e33e85b3a198"
version = "0.1.31"

[[MKL_jll]]
deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "Pkg"]
git-tree-sha1 = "5455aef09b40e5020e1520f551fa3135040d4ed0"
uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7"
version = "2021.1.1+2"

[[MacroTools]]
deps = ["Markdown", "Random"]
git-tree-sha1 = "3d3e902b31198a27340d0bf00d6ac452866021cf"
uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
version = "0.5.9"

[[Makie]]
deps = ["Animations", "Base64", "ColorBrewer", "ColorSchemes", "ColorTypes", "Colors", "Contour", "Distributions", "DocStringExtensions", "FFMPEG", "FileIO", "FixedPointNumbers", "Formatting", "FreeType", "FreeTypeAbstraction", "GeometryBasics", "GridLayoutBase", "ImageIO", "IntervalSets", "Isoband", "KernelDensity", "LaTeXStrings", "LinearAlgebra", "MakieCore", "Markdown", "Match", "MathTeXEngine", "Observables", "Packing", "PlotUtils", "PolygonOps", "Printf", "Random", "RelocatableFolders", "Serialization", "Showoff", "SignedDistanceFields", "SparseArrays", "StaticArrays", "Statistics", "StatsBase", "StatsFuns", "StructArrays", "UnicodeFun"]
git-tree-sha1 = "56b0b7772676c499430dc8eb15cfab120c05a150"
uuid = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a"
version = "0.15.3"

[[MakieCore]]
deps = ["Observables"]
git-tree-sha1 = "7bcc8323fb37523a6a51ade2234eee27a11114c8"
uuid = "20f20a25-4f0e-4fdf-b5d1-57303727442b"
version = "0.1.3"

[[MappedArrays]]
git-tree-sha1 = "e8b359ef06ec72e8c030463fe02efe5527ee5142"
uuid = "dbb5928d-eab1-5f90-85c2-b9b0edb7c900"
version = "0.4.1"

[[Markdown]]
deps = ["Base64"]
uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"

[[Match]]
git-tree-sha1 = "5cf525d97caf86d29307150fcba763a64eaa9cbe"
uuid = "7eb4fadd-790c-5f42-8a69-bfa0b872bfbf"
version = "1.1.0"

[[MathTeXEngine]]
deps = ["AbstractTrees", "Automa", "DataStructures", "FreeTypeAbstraction", "GeometryBasics", "LaTeXStrings", "REPL", "RelocatableFolders", "Test"]
git-tree-sha1 = "70e733037bbf02d691e78f95171a1fa08cdc6332"
uuid = "0a4f8689-d25c-4efe-a92b-7142dfc1aa53"
version = "0.2.1"

[[MbedTLS]]
deps = ["Dates", "MbedTLS_jll", "Random", "Sockets"]
git-tree-sha1 = "1c38e51c3d08ef2278062ebceade0e46cefc96fe"
uuid = "739be429-bea8-5141-9913-cc70e7f3736d"
version = "1.0.3"

[[MbedTLS_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"

[[MeshArrays]]
deps = ["CatViews", "Dates", "LazyArtifacts", "NearestNeighbors", "Pkg", "Printf", "SparseArrays", "Statistics", "Unitful"]
git-tree-sha1 = "628c1e1ee3b69635027a76f208e2e76541cd1162"
uuid = "cb8c808f-1acf-59a3-9d2b-6e38d009f683"
version = "0.2.26"

[[Missings]]
deps = ["DataAPI"]
git-tree-sha1 = "bf210ce90b6c9eed32d25dbcae1ebc565df2687f"
uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28"
version = "1.0.2"

[[Mmap]]
uuid = "a63ad114-7e13-5084-954f-fe012c677804"

[[Mocking]]
deps = ["Compat", "ExprTools"]
git-tree-sha1 = "29714d0a7a8083bba8427a4fbfb00a540c681ce7"
uuid = "78c3b35d-d492-501b-9361-3d52fe80e533"
version = "0.7.3"

[[MosaicViews]]
deps = ["MappedArrays", "OffsetArrays", "PaddedViews", "StackViews"]
git-tree-sha1 = "b34e3bc3ca7c94914418637cb10cc4d1d80d877d"
uuid = "e94cdb99-869f-56ef-bcf0-1ae2bcbe0389"
version = "0.3.3"

[[MozillaCACerts_jll]]
uuid = "14a3606d-f60d-562e-9121-12d972cd8159"

[[NaNMath]]
git-tree-sha1 = "bfe47e760d60b82b66b61d2d44128b62e3a369fb"
uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
version = "0.3.5"

[[NearestNeighbors]]
deps = ["Distances", "StaticArrays"]
git-tree-sha1 = "16baacfdc8758bc374882566c9187e785e85c2f0"
uuid = "b8a86587-4115-5ab1-83bc-aa920d37bbce"
version = "0.4.9"

[[NetCDF]]
deps = ["DiskArrays", "Formatting", "NetCDF_jll"]
git-tree-sha1 = "23b0e32fde256a4e2e497e678abcf956ed26204b"
uuid = "30363a11-5582-574a-97bb-aa9a979735b9"
version = "0.11.3"

[[NetCDF_jll]]
deps = ["Artifacts", "HDF5_jll", "JLLWrappers", "LibCURL_jll", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Pkg", "Zlib_jll", "nghttp2_jll"]
git-tree-sha1 = "0cf4d1bf2ef45156aed85c9ac5f8c7e697d9288c"
uuid = "7243133f-43d8-5620-bbf4-c2c921802cf3"
version = "400.702.400+0"

[[Netpbm]]
deps = ["FileIO", "ImageCore"]
git-tree-sha1 = "18efc06f6ec36a8b801b23f076e3c6ac7c3bf153"
uuid = "f09324ee-3d7c-5217-9330-fc30815ba969"
version = "1.0.2"

[[NetworkOptions]]
uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908"

[[Observables]]
git-tree-sha1 = "fe29afdef3d0c4a8286128d4e45cc50621b1e43d"
uuid = "510215fc-4207-5dde-b226-833fc4488ee2"
version = "0.4.0"

[[OceanStateEstimation]]
deps = ["Downloads", "FortranFiles", "LazyArtifacts", "MITgcmTools", "MeshArrays", "Statistics"]
git-tree-sha1 = "360dc6984946dbd62d9fea096f4c99c34026f897"
uuid = "891f6deb-a4f5-4bc5-a2e3-1e8f649cdd2c"
version = "0.1.15"

[[OffsetArrays]]
deps = ["Adapt"]
git-tree-sha1 = "043017e0bdeff61cfbb7afeb558ab29536bbb5ed"
uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
version = "1.10.8"

[[Ogg_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "7937eda4681660b4d6aeeecc2f7e1c81c8ee4e2f"
uuid = "e7412a2a-1a6e-54c0-be00-318e2571c051"
version = "1.3.5+0"

[[OpenEXR]]
deps = ["Colors", "FileIO", "OpenEXR_jll"]
git-tree-sha1 = "327f53360fdb54df7ecd01e96ef1983536d1e633"
uuid = "52e1d378-f018-4a11-a4be-720524705ac7"
version = "0.3.2"

[[OpenEXR_jll]]
deps = ["Artifacts", "Imath_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "923319661e9a22712f24596ce81c54fc0366f304"
uuid = "18a262bb-aa17-5467-a713-aee519bc75cb"
version = "3.1.1+0"

[[OpenLibm_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "05823500-19ac-5b8b-9628-191a04bc5112"

[[OpenSSL_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "15003dcb7d8db3c6c857fda14891a539a8f2705a"
uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95"
version = "1.1.10+0"

[[OpenSpecFun_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "13652491f6856acfd2db29360e1bbcd4565d04f1"
uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e"
version = "0.5.5+0"

[[Opus_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "51a08fb14ec28da2ec7a927c4337e4332c2a4720"
uuid = "91d4177d-7536-5919-b921-800302f37372"
version = "1.3.2+0"

[[OrderedCollections]]
git-tree-sha1 = "85f8e6578bf1f9ee0d11e7bb1b1456435479d47c"
uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
version = "1.4.1"

[[PCRE2_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15"

[[PCRE_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b2a7af664e098055a7529ad1a900ded962bca488"
uuid = "2f80f16e-611a-54ab-bc61-aa92de5b98fc"
version = "8.44.0+0"

[[PDMats]]
deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"]
git-tree-sha1 = "c8b8775b2f242c80ea85c83714c64ecfa3c53355"
uuid = "90014a1f-27ba-587c-ab20-58faa44d9150"
version = "0.11.3"

[[PNGFiles]]
deps = ["Base64", "CEnum", "ImageCore", "IndirectArrays", "OffsetArrays", "libpng_jll"]
git-tree-sha1 = "6d105d40e30b635cfed9d52ec29cf456e27d38f8"
uuid = "f57f5aa1-a3ce-4bc8-8ab9-96f992907883"
version = "0.3.12"

[[Packing]]
deps = ["GeometryBasics"]
git-tree-sha1 = "1155f6f937fa2b94104162f01fa400e192e4272f"
uuid = "19eb6ba3-879d-56ad-ad62-d5c202156566"
version = "0.4.2"

[[PaddedViews]]
deps = ["OffsetArrays"]
git-tree-sha1 = "646eed6f6a5d8df6708f15ea7e02a7a2c4fe4800"
uuid = "5432bcbf-9aad-5242-b902-cca2824c8663"
version = "0.5.10"

[[Pango_jll]]
deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "FriBidi_jll", "Glib_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "9a336dee51d20d1ed890c4a8dca636e86e2b76ca"
uuid = "36c8627f-9965-5494-a995-c6b170f724f3"
version = "1.42.4+10"

[[Parsers]]
deps = ["Dates"]
git-tree-sha1 = "ae4bbcadb2906ccc085cf52ac286dc1377dceccc"
uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"
version = "2.1.2"

[[Pixman_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b4f5d02549a10e20780a24fce72bea96b6329e29"
uuid = "30392449-352a-5448-841d-b1acce4e97dc"
version = "0.40.1+0"

[[Pkg]]
deps = ["Artifacts", "Dates", "Downloads", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"

[[PkgVersion]]
deps = ["Pkg"]
git-tree-sha1 = "a7a7e1a88853564e551e4eba8650f8c38df79b37"
uuid = "eebad327-c553-4316-9ea0-9fa01ccd7688"
version = "0.1.1"

[[PlotUtils]]
deps = ["ColorSchemes", "Colors", "Dates", "Printf", "Random", "Reexport", "Statistics"]
git-tree-sha1 = "b084324b4af5a438cd63619fd006614b3b20b87b"
uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043"
version = "1.0.15"

[[PlutoUI]]
deps = ["AbstractPlutoDingetjes", "Base64", "Dates", "Hyperscript", "HypertextLiteral", "IOCapture", "InteractiveUtils", "JSON", "Logging", "Markdown", "Random", "Reexport", "UUIDs"]
git-tree-sha1 = "e071adf21e165ea0d904b595544a8e514c8bb42c"
uuid = "7f904dfe-b85e-4ff6-b463-dae2292396a8"
version = "0.7.19"

[[PolygonOps]]
git-tree-sha1 = "77b3d3605fc1cd0b42d95eba87dfcd2bf67d5ff6"
uuid = "647866c9-e3ac-4575-94e7-e3d426903924"
version = "0.1.2"

[[PooledArrays]]
deps = ["DataAPI", "Future"]
git-tree-sha1 = "a193d6ad9c45ada72c14b731a318bedd3c2f00cf"
uuid = "2dfb63ee-cc39-5dd5-95bd-886bf059d720"
version = "1.3.0"

[[Preferences]]
deps = ["TOML"]
git-tree-sha1 = "00cfd92944ca9c760982747e9a1d0d5d86ab1e5a"
uuid = "21216c6a-2e73-6563-6e65-726566657250"
version = "1.2.2"

[[PrettyTables]]
deps = ["Crayons", "Formatting", "Markdown", "Reexport", "Tables"]
git-tree-sha1 = "d940010be611ee9d67064fe559edbb305f8cc0eb"
uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d"
version = "1.2.3"

[[Printf]]
deps = ["Unicode"]
uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"

[[ProgressMeter]]
deps = ["Distributed", "Printf"]
git-tree-sha1 = "afadeba63d90ff223a6a48d2009434ecee2ec9e8"
uuid = "92933f4c-e287-5a05-a399-4b506db050ca"
version = "1.7.1"

[[QuadGK]]
deps = ["DataStructures", "LinearAlgebra"]
git-tree-sha1 = "78aadffb3efd2155af139781b8a8df1ef279ea39"
uuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc"
version = "2.4.2"

[[REPL]]
deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"]
uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"

[[Random]]
deps = ["Serialization"]
uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"

[[Ratios]]
deps = ["Requires"]
git-tree-sha1 = "01d341f502250e81f6fec0afe662aa861392a3aa"
uuid = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439"
version = "0.4.2"

[[Reexport]]
git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b"
uuid = "189a3867-3050-52da-a836-e630ba90ab69"
version = "1.2.2"

[[RelocatableFolders]]
deps = ["SHA", "Scratch"]
git-tree-sha1 = "cdbd3b1338c72ce29d9584fdbe9e9b70eeb5adca"
uuid = "05181044-ff0b-4ac5-8273-598c1e38db00"
version = "0.1.3"

[[Requires]]
deps = ["UUIDs"]
git-tree-sha1 = "4036a3bd08ac7e968e27c203d45f5fff15020621"
uuid = "ae029012-a4dd-5104-9daa-d747884805df"
version = "1.1.3"

[[Retry]]
git-tree-sha1 = "41ac127cd281bb33e42aba46a9d3b25cd35fc6d5"
uuid = "20febd7b-183b-5ae2-ac4a-720e7ce64774"
version = "0.4.1"

[[Rmath]]
deps = ["Random", "Rmath_jll"]
git-tree-sha1 = "bf3188feca147ce108c76ad82c2792c57abe7b1f"
uuid = "79098fc4-a85e-5d69-aa6a-4863f24498fa"
version = "0.7.0"

[[Rmath_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "68db32dff12bb6127bac73c209881191bf0efbb7"
uuid = "f50d1b31-88e8-58de-be2c-1cc44531875f"
version = "0.3.0+0"

[[SHA]]
uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"

[[SIMD]]
git-tree-sha1 = "9ba33637b24341aba594a2783a502760aa0bff04"
uuid = "fdea26ae-647d-5447-a871-4b548cad5224"
version = "3.3.1"

[[ScanByte]]
deps = ["Libdl", "SIMD"]
git-tree-sha1 = "9cc2955f2a254b18be655a4ee70bc4031b2b189e"
uuid = "7b38b023-a4d7-4c5e-8d43-3f3097f304eb"
version = "0.3.0"

[[Scratch]]
deps = ["Dates"]
git-tree-sha1 = "0b4b7f1393cff97c33891da2a0bf69c6ed241fda"
uuid = "6c6a2e73-6563-6170-7368-637461726353"
version = "1.1.0"

[[SentinelArrays]]
deps = ["Dates", "Random"]
git-tree-sha1 = "f45b34656397a1f6e729901dc9ef679610bd12b5"
uuid = "91c51154-3ec4-41a3-a24f-3f23e20d615c"
version = "1.3.8"

[[Serialization]]
uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"

[[SharedArrays]]
deps = ["Distributed", "Mmap", "Random", "Serialization"]
uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383"

[[Showoff]]
deps = ["Dates", "Grisu"]
git-tree-sha1 = "91eddf657aca81df9ae6ceb20b959ae5653ad1de"
uuid = "992d4aef-0814-514b-bc4d-f2e9a6c4116f"
version = "1.0.3"

[[SignedDistanceFields]]
deps = ["Random", "Statistics", "Test"]
git-tree-sha1 = "d263a08ec505853a5ff1c1ebde2070419e3f28e9"
uuid = "73760f76-fbc4-59ce-8f25-708e95d2df96"
version = "0.4.0"

[[Sockets]]
uuid = "6462fe0b-24de-5631-8697-dd941f90decc"

[[SodiumSeal]]
deps = ["Base64", "Libdl", "libsodium_jll"]
git-tree-sha1 = "80cef67d2953e33935b41c6ab0a178b9987b1c99"
uuid = "2133526b-2bfb-4018-ac12-889fb3908a75"
version = "0.1.1"

[[SortingAlgorithms]]
deps = ["DataStructures"]
git-tree-sha1 = "b3363d7460f7d098ca0912c69b082f75625d7508"
uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c"
version = "1.0.1"

[[SparseArrays]]
deps = ["LinearAlgebra", "Random"]
uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"

[[SpecialFunctions]]
deps = ["ChainRulesCore", "IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"]
git-tree-sha1 = "f0bccf98e16759818ffc5d97ac3ebf87eb950150"
uuid = "276daf66-3868-5448-9aa4-cd146d93841b"
version = "1.8.1"

[[StackViews]]
deps = ["OffsetArrays"]
git-tree-sha1 = "46e589465204cd0c08b4bd97385e4fa79a0c770c"
uuid = "cae243ae-269e-4f55-b966-ac2d0dc13c15"
version = "0.1.1"

[[Static]]
deps = ["IfElse"]
git-tree-sha1 = "e7bc80dc93f50857a5d1e3c8121495852f407e6a"
uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
version = "0.4.0"

[[StaticArrays]]
deps = ["LinearAlgebra", "Random", "Statistics"]
git-tree-sha1 = "3c76dde64d03699e074ac02eb2e8ba8254d428da"
uuid = "90137ffa-7385-5640-81b9-e52037218182"
version = "1.2.13"

[[Statistics]]
deps = ["LinearAlgebra", "SparseArrays"]
uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"

[[StatsAPI]]
git-tree-sha1 = "1958272568dc176a1d881acb797beb909c785510"
uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0"
version = "1.0.0"

[[StatsBase]]
deps = ["DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"]
git-tree-sha1 = "eb35dcc66558b2dda84079b9a1be17557d32091a"
uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
version = "0.33.12"

[[StatsFuns]]
deps = ["ChainRulesCore", "InverseFunctions", "IrrationalConstants", "LogExpFunctions", "Reexport", "Rmath", "SpecialFunctions"]
git-tree-sha1 = "385ab64e64e79f0cd7cfcf897169b91ebbb2d6c8"
uuid = "4c63d2b9-4356-54db-8cca-17b64c39e42c"
version = "0.9.13"

[[StructArrays]]
deps = ["Adapt", "DataAPI", "StaticArrays", "Tables"]
git-tree-sha1 = "2ce41e0d042c60ecd131e9fb7154a3bfadbf50d3"
uuid = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"
version = "0.6.3"

[[SuiteSparse]]
deps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"]
uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"

[[Suppressor]]
git-tree-sha1 = "a819d77f31f83e5792a76081eee1ea6342ab8787"
uuid = "fd094767-a336-5f1f-9728-57cf17d0bbfb"
version = "0.2.0"

[[TOML]]
deps = ["Dates"]
uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76"

[[TableTraits]]
deps = ["IteratorInterfaceExtensions"]
git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39"
uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c"
version = "1.0.1"

[[Tables]]
deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "LinearAlgebra", "TableTraits", "Test"]
git-tree-sha1 = "fed34d0e71b91734bf0a7e10eb1bb05296ddbcd0"
uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
version = "1.6.0"

[[Tar]]
deps = ["ArgTools", "SHA"]
uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e"

[[TensorCore]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "1feb45f88d133a655e001435632f019a9a1bcdb6"
uuid = "62fd8b95-f654-4bbd-a8a5-9c27f68ccd50"
version = "0.1.1"

[[Test]]
deps = ["InteractiveUtils", "Logging", "Random", "Serialization"]
uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

[[TiffImages]]
deps = ["ColorTypes", "DataStructures", "DocStringExtensions", "FileIO", "FixedPointNumbers", "IndirectArrays", "Inflate", "OffsetArrays", "PkgVersion", "ProgressMeter", "UUIDs"]
git-tree-sha1 = "c342ae2abf4902d65a0b0bf59b28506a6e17078a"
uuid = "731e570b-9d59-4bfa-96dc-6df516fadf69"
version = "0.5.2"

[[TranscodingStreams]]
deps = ["Random", "Test"]
git-tree-sha1 = "216b95ea110b5972db65aa90f88d8d89dcb8851c"
uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa"
version = "0.9.6"

[[URIs]]
git-tree-sha1 = "97bbe755a53fe859669cd907f2d96aee8d2c1355"
uuid = "5c2747f8-b7ea-4ff2-ba2e-563bfd36b1d4"
version = "1.3.0"

[[UUIDs]]
deps = ["Random", "SHA"]
uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"

[[Unicode]]
uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"

[[UnicodeFun]]
deps = ["REPL"]
git-tree-sha1 = "53915e50200959667e78a92a418594b428dffddf"
uuid = "1cfade01-22cf-5700-b092-accc4b62d6e1"
version = "0.4.1"

[[Unitful]]
deps = ["ConstructionBase", "Dates", "LinearAlgebra", "Random"]
git-tree-sha1 = "0992ed0c3ef66b0390e5752fe60054e5ff93b908"
uuid = "1986cc42-f94f-5a68-af5c-568840ba703d"
version = "1.9.2"

[[WeakRefStrings]]
deps = ["DataAPI", "InlineStrings", "Parsers"]
git-tree-sha1 = "c69f9da3ff2f4f02e811c3323c22e5dfcb584cfa"
uuid = "ea10d353-3f73-51f8-a26c-33c1cb351aa5"
version = "1.4.1"

[[WoodburyMatrices]]
deps = ["LinearAlgebra", "SparseArrays"]
git-tree-sha1 = "de67fa59e33ad156a590055375a30b23c40299d3"
uuid = "efce3f68-66dc-5838-9240-27a6d6f5f9b6"
version = "0.5.5"

[[XML2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "1acf5bdf07aa0907e0a37d3718bb88d4b687b74a"
uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a"
version = "2.9.12+0"

[[XMLDict]]
deps = ["EzXML", "IterTools", "OrderedCollections"]
git-tree-sha1 = "d9a3faf078210e477b291c79117676fca54da9dd"
uuid = "228000da-037f-5747-90a9-8195ccbf91a5"
version = "0.4.1"

[[XSLT_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgcrypt_jll", "Libgpg_error_jll", "Libiconv_jll", "Pkg", "XML2_jll", "Zlib_jll"]
git-tree-sha1 = "91844873c4085240b95e795f692c4cec4d805f8a"
uuid = "aed1982a-8fda-507f-9586-7b0439959a61"
version = "1.1.34+0"

[[Xorg_libX11_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxcb_jll", "Xorg_xtrans_jll"]
git-tree-sha1 = "5be649d550f3f4b95308bf0183b82e2582876527"
uuid = "4f6342f7-b3d2-589e-9d20-edeb45f2b2bc"
version = "1.6.9+4"

[[Xorg_libXau_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4e490d5c960c314f33885790ed410ff3a94ce67e"
uuid = "0c0b7dd1-d40b-584c-a123-a41640f87eec"
version = "1.0.9+4"

[[Xorg_libXdmcp_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4fe47bd2247248125c428978740e18a681372dd4"
uuid = "a3789734-cfe1-5b06-b2d0-1dd0d9d62d05"
version = "1.1.3+4"

[[Xorg_libXext_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "b7c0aa8c376b31e4852b360222848637f481f8c3"
uuid = "1082639a-0dae-5f34-9b06-72781eeb8cb3"
version = "1.3.4+4"

[[Xorg_libXrender_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "19560f30fd49f4d4efbe7002a1037f8c43d43b96"
uuid = "ea2f1a96-1ddc-540d-b46f-429655e07cfa"
version = "0.9.10+4"

[[Xorg_libpthread_stubs_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "6783737e45d3c59a4a4c4091f5f88cdcf0908cbb"
uuid = "14d82f49-176c-5ed1-bb49-ad3f5cbd8c74"
version = "0.1.0+3"

[[Xorg_libxcb_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "XSLT_jll", "Xorg_libXau_jll", "Xorg_libXdmcp_jll", "Xorg_libpthread_stubs_jll"]
git-tree-sha1 = "daf17f441228e7a3833846cd048892861cff16d6"
uuid = "c7cfdc94-dc32-55de-ac96-5a1b8d977c5b"
version = "1.13.0+3"

[[Xorg_xtrans_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "79c31e7844f6ecf779705fbc12146eb190b7d845"
uuid = "c5fb5394-a638-5e4d-96e5-b29de1b5cf10"
version = "1.4.0+3"

[[Zarr]]
deps = ["AWS", "Blosc", "CodecZlib", "DataStructures", "Dates", "DiskArrays", "HTTP", "JSON", "OffsetArrays", "Pkg"]
git-tree-sha1 = "18ac3fd29790edeee42bfed5020b12ae61a029d0"
uuid = "0a941bbe-ad1d-11e8-39d9-ab76183a1d99"
version = "0.6.3"

[[Zlib_jll]]
deps = ["Libdl"]
uuid = "83775a58-1f1d-513f-b197-d71354ab007a"

[[Zstd_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "cc4bf3fdde8b7e3e9fa0351bdeedba1cf3b7f6e6"
uuid = "3161d3a3-bdf6-5164-811a-617609db77b4"
version = "1.5.0+0"

[[isoband_jll]]
deps = ["Libdl", "Pkg"]
git-tree-sha1 = "a1ac99674715995a536bbce674b068ec1b7d893d"
uuid = "9a68df92-36a6-505f-a73e-abb412b6bfb4"
version = "0.2.2+0"

[[libass_jll]]
deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "acc685bcf777b2202a904cdcb49ad34c2fa1880c"
uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0"
version = "0.14.0+4"

[[libfdk_aac_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "7a5780a0d9c6864184b3a2eeeb833a0c871f00ab"
uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280"
version = "0.1.6+4"

[[libpng_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "94d180a6d2b5e55e447e2d27a29ed04fe79eb30c"
uuid = "b53b4c65-9356-5827-b1ea-8c7a1a84506f"
version = "1.6.38+0"

[[libsodium_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "848ab3d00fe39d6fbc2a8641048f8f272af1c51e"
uuid = "a9144af2-ca23-56d9-984f-0d03f7b5ccf8"
version = "1.0.20+0"

[[libvorbis_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Ogg_jll", "Pkg"]
git-tree-sha1 = "c45f4e40e7aafe9d086379e5578947ec8b95a8fb"
uuid = "f27f6e37-5d2b-51aa-960f-b287f2bc3b7a"
version = "1.3.7+0"

[[nghttp2_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"

[[p7zip_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"

[[x264_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "d713c1ce4deac133e3334ee12f4adff07f81778f"
uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a"
version = "2020.7.14+2"

[[x265_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "487da2f8f2f0c8ee0e83f39d13037d6bbf0a45ab"
uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76"
version = "3.0.0+3"
"""

# ╔═╡ Cell order:
# ╟─7046b9b2-06bf-4ed8-80a3-79d2c52dacaf
# ╟─3b6fcab2-ae44-41c7-adec-424025092419
# ╟─1e7616f8-65ec-4cfa-960f-bd26451756bc
# ╟─dda89e9a-4585-49df-82cd-72db00c341fa
# ╟─60bda89f-5452-4f89-b4a4-a89568d45a6b
# ╟─99e7e24b-578e-47be-818a-623c8e9e4381
# ╟─5d25c473-eb1f-4040-86c7-86dee7add5df
# ╟─09dff33d-1c16-4fa6-a5af-8eb3c15816f3
# ╟─a6f70839-b79f-42e1-bf4a-8c8978e6618e
# ╟─923568dc-85f3-43c1-a631-d408a1662fb3
# ╟─2d6c1787-3c30-4daf-8575-b51211f8e860
# ╟─3a3ac112-cd2b-4ac9-9029-b79b8b5fa8b4
# ╟─9928d59f-0733-4ad9-93e7-f1a8622afd1f
# ╟─1cd94bce-9b10-4957-95d0-f396264df162
# ╟─c3b3a104-a1d6-4692-ae0c-2e55821afd03
# ╟─e59c1819-52fd-49eb-8b0c-63fbbc0baffb
# ╟─e033825c-019c-44b6-86dd-30fff79f8339
# ╟─0611986f-3d6e-4236-b68a-747b6018d381
# ╟─210b5414-ada8-49a1-8ac4-9115ed33e285
# ╟─0888db7a-ff14-44c0-9c20-fed722f7e41e
# ╟─87a4a232-d8eb-4612-8cc5-dc9d1c16dbe8
# ╟─a8ebbe41-1ac8-44da-b8c4-cbfd4d422227
# ╟─71b1447b-39d9-46e2-966d-a1e6e8dcccc6
# ╟─3c2de9d4-b091-464b-9210-aa84f3d4c5f1
# ╟─c2788db6-3ab4-4c22-abf0-ae701a57e94d
# ╟─cf99ec64-d142-42ff-9767-3d851229024e
# ╟─ea72e6df-68da-4ade-b1d9-b7689e511a40
# ╟─cee6124a-3043-447e-a3a3-780cadca7fd1
# ╟─00000000-0000-0000-0000-000000000001
# ╟─00000000-0000-0000-0000-000000000002


text:
# This file was generated by the Julia Swagger Code Generator
# Do not modify this file directly. Modify the swagger specification instead.

@doc raw"""DaemonSetSpec is the specification of a daemon set.

    IoK8sApiExtensionsV1beta1DaemonSetSpec(;
        minReadySeconds=nothing,
        revisionHistoryLimit=nothing,
        selector=nothing,
        template=nothing,
        templateGeneration=nothing,
        updateStrategy=nothing,
    )

    - minReadySeconds::Int32 : The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready).
    - revisionHistoryLimit::Int32 : The number of old history to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10.
    - selector::IoK8sApimachineryPkgApisMetaV1LabelSelector : A label query over pods that are managed by the daemon set. Must match in order to be controlled. If empty, defaulted to labels on Pod template. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors
    - template::IoK8sApiCoreV1PodTemplateSpec : An object that describes the pod that will be created. The DaemonSet will create exactly one copy of this pod on every node that matches the template's node selector (or on every node if no node selector is specified). More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#pod-template
    - templateGeneration::Int64 : DEPRECATED. A sequence number representing a specific generation of the template. Populated by the system. It can be set only during the creation.
    - updateStrategy::IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy : An update strategy to replace existing DaemonSet pods with new pods.
"""
mutable struct IoK8sApiExtensionsV1beta1DaemonSetSpec <: SwaggerModel
    minReadySeconds::Any # spec type: Union{ Nothing, Int32 } # spec name: minReadySeconds
    revisionHistoryLimit::Any # spec type: Union{ Nothing, Int32 } # spec name: revisionHistoryLimit
    selector::Any # spec type: Union{ Nothing, IoK8sApimachineryPkgApisMetaV1LabelSelector } # spec name: selector
    template::Any # spec type: Union{ Nothing, IoK8sApiCoreV1PodTemplateSpec } # spec name: template
    templateGeneration::Any # spec type: Union{ Nothing, Int64 } # spec name: templateGeneration
    updateStrategy::Any # spec type: Union{ Nothing, IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy } # spec name: updateStrategy

    function IoK8sApiExtensionsV1beta1DaemonSetSpec(;minReadySeconds=nothing, revisionHistoryLimit=nothing, selector=nothing, template=nothing, templateGeneration=nothing, updateStrategy=nothing)
        o = new()
        validate_property(IoK8sApiExtensionsV1beta1DaemonSetSpec, Symbol("minReadySeconds"), minReadySeconds)
        setfield!(o, Symbol("minReadySeconds"), minReadySeconds)
        validate_property(IoK8sApiExtensionsV1beta1DaemonSetSpec, Symbol("revisionHistoryLimit"), revisionHistoryLimit)
        setfield!(o, Symbol("revisionHistoryLimit"), revisionHistoryLimit)
        validate_property(IoK8sApiExtensionsV1beta1DaemonSetSpec, Symbol("selector"), selector)
        setfield!(o, Symbol("selector"), selector)
        validate_property(IoK8sApiExtensionsV1beta1DaemonSetSpec, Symbol("template"), template)
        setfield!(o, Symbol("template"), template)
        validate_property(IoK8sApiExtensionsV1beta1DaemonSetSpec, Symbol("templateGeneration"), templateGeneration)
        setfield!(o, Symbol("templateGeneration"), templateGeneration)
        validate_property(IoK8sApiExtensionsV1beta1DaemonSetSpec, Symbol("updateStrategy"), updateStrategy)
        setfield!(o, Symbol("updateStrategy"), updateStrategy)
        o
    end
end # type IoK8sApiExtensionsV1beta1DaemonSetSpec

const _property_map_IoK8sApiExtensionsV1beta1DaemonSetSpec = Dict{Symbol,Symbol}(Symbol("minReadySeconds")=>Symbol("minReadySeconds"), Symbol("revisionHistoryLimit")=>Symbol("revisionHistoryLimit"), Symbol("selector")=>Symbol("selector"), Symbol("template")=>Symbol("template"), Symbol("templateGeneration")=>Symbol("templateGeneration"), Symbol("updateStrategy")=>Symbol("updateStrategy"))
const _property_types_IoK8sApiExtensionsV1beta1DaemonSetSpec = Dict{Symbol,String}(Symbol("minReadySeconds")=>"Int32", Symbol("revisionHistoryLimit")=>"Int32", Symbol("selector")=>"IoK8sApimachineryPkgApisMetaV1LabelSelector", Symbol("template")=>"IoK8sApiCoreV1PodTemplateSpec", Symbol("templateGeneration")=>"Int64", Symbol("updateStrategy")=>"IoK8sApiExtensionsV1beta1DaemonSetUpdateStrategy")
Base.propertynames(::Type{ IoK8sApiExtensionsV1beta1DaemonSetSpec }) = collect(keys(_property_map_IoK8sApiExtensionsV1beta1DaemonSetSpec))
Swagger.property_type(::Type{ IoK8sApiExtensionsV1beta1DaemonSetSpec }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_IoK8sApiExtensionsV1beta1DaemonSetSpec[name]))}
Swagger.field_name(::Type{ IoK8sApiExtensionsV1beta1DaemonSetSpec }, property_name::Symbol) =  _property_map_IoK8sApiExtensionsV1beta1DaemonSetSpec[property_name]

function check_required(o::IoK8sApiExtensionsV1beta1DaemonSetSpec)
    (getproperty(o, Symbol("template")) === nothing) && (return false)
    true
end

function validate_property(::Type{ IoK8sApiExtensionsV1beta1DaemonSetSpec }, name::Symbol, val)
end

ext: jl


text:
# helper.jl

using SPECTrecon: padzero!, padrepl!, pad2sizezero!, pad_it!
using SPECTrecon: fftshift!, ifftshift!, fftshift2!
using SPECTrecon: plus1di!, plus1dj!, plus2di!, plus2dj!
using SPECTrecon: plus3di!, plus3dj!, plus3dk!, scale3dj!, mul3dj!
using SPECTrecon: copy3dj!
using ImageFiltering: Fill, Pad, BorderArray
import OffsetArrays
using Test: @test, @testset

@testset "padzero!" begin
    T = Float32
    x = randn(T, 7, 5)
    y = randn(T, 3, 3)
    padzero!(x, y, (2, 2, 1, 1))
    z = OffsetArrays.no_offset_view(BorderArray(y, Fill(0, (2, 1), (2, 1))))
    @test isequal(x, z)
end

@testset "padrepl!" begin
    T = Float32
    x = randn(T, 10, 9)
    y = randn(T, 5, 4)
    padrepl!(x, y, (1, 4, 3, 2)) # up, down, left, right
    z = OffsetArrays.no_offset_view(BorderArray(y, Pad(:replicate, (1, 3), (4, 2)))) # up, left, down, right
    @test isequal(x, z)
end

@testset "pad2size!" begin
    T = Float32
    ker = reshape(Int16(1):Int16(9), 3, 3)
    padsize = (8, 8)
    z = randn(T, padsize)
    pad2sizezero!(z, ker, padsize)
    tmp = pad_it!(ker, padsize)
    @test isequal(tmp, z)
end

@testset "fftshift" begin
    T = Float32
    x = randn(T, 120, 128)
    y = similar(x)
    z = similar(x)
    fftshift!(y, x)
    @test ifftshift!(z, y) == x
    fftshift2!(z, x)
    @test isequal(y, z)
end

@testset "plus1di" begin
    T = Float32
    x = randn(T, 4, 64)
    v = randn(T, 64)
    y = x[2, :] .+ v
    plus1di!(x, v, 2)
    @test isequal(x[2, :], y)
end

@testset "plus1dj!" begin
    T = Float32
    x = randn(T, 64, 4)
    v = randn(T, 64)
    y = x[:, 2] .+ v
    plus1dj!(x, v, 2)
    @test isequal(x[:, 2], y)
end

@testset "plus2di!" begin
    T = Float32
    x = randn(64)
    v = randn(4, 64)
    y = x .+ v[2, :]
    plus2di!(x, v, 2)
    @test isequal(x, y)
end

@testset "plus2dj!" begin
    T = Float32
    x = randn(T, 64)
    v = randn(T, 64, 4)
    y = x .+ v[:, 2]
    plus2dj!(x, v, 2)
    @test isequal(x, y)
end

@testset "plus3di!" begin
    T = Float32
    x = randn(T, 64, 64)
    v = randn(T, 4, 64, 64)
    y = x .+ v[2, :, :]
    plus3di!(x, v, 2)
    @test isequal(x, y)
end

@testset "plus3dj!" begin
    T = Float32
    x = randn(T, 64, 64)
    v = randn(T, 64, 4, 64)
    y = x .+ v[:, 2, :]
    plus3dj!(x, v, 2)
    @test isequal(x, y)
end

@testset "plus3dk!" begin
    T = Float32
    x = randn(T, 64, 64)
    v = randn(T, 64, 64, 4)
    y = x .+ v[:, :, 2]
    plus3dk!(x, v, 2)
    @test isequal(x, y)
end

@testset "scale3dj!" begin
    T = Float32
    x = randn(T, 64, 64)
    v = randn(T, 64, 4, 64)
    s = -0.5
    y = s * v[:, 2, :]
    scale3dj!(x, v, 2, s)
    @test isequal(x, y)
end

@testset "mul3dj!" begin
    T = Float32
    x = randn(T, 64, 4, 64)
    v = randn(T, 64, 64)
    y = x[:,2,:] .* v
    mul3dj!(x, v, 2)
    @test isequal(x[:,2,:], y)
end

@testset "copy3dj!" begin
    T = Float32
    x = randn(T, 64, 64)
    v = randn(T, 64, 4, 64)
    y = v[:,2,:]
    copy3dj!(x, v, 2)
    @test isequal(x, y)
end


text:
module day16

# Part 1
parserange(r) = parse.(Int32, split(r, "-")) |> x -> range(first(x); stop=last(x))
parserule(rule) = match(r"(.+):\s(.+)\sor\s(.+)", rule).captures |> x -> (x[1], parserange(x[2]), parserange(x[3]))
rules, ticket, nearby = split.(strip.(split(read("day16_input.txt", String), "\n\n")), "\n")
rules = parserule.(rules)
ticket = parse.(Int32, split(last(ticket), ","))
nearby = map(x -> parse.(Int32, x), split.(nearby[2:end], ","))
valid(rule, v) = v in rule[2] || v in rule[3]
errorrate(v) = any(map(r -> valid(r, v), rules)) ? 0 : v
println("Part 1: error rate = $(sum(errorrate.(vcat(nearby...))))")

# Part 2
candidates(rule, ticket) = [i for (i, v) in enumerate(ticket) if valid(rule, v)]
decodefield(rule, tickets) = intersect(map(t -> Set(candidates(rule, t)), tickets)...)
remaining = filter(t -> sum(errorrate.(t)) == 0, nearby)
function decodefields(rules, tickets)
    fieldsets = Dict(rule[1] => decodefield(rule, tickets) for rule in rules)
    while maximum(length.(values(fieldsets))) > 1
        known = Set(only.(filter(v -> length(v) == 1, collect(values(fieldsets)))))
        fieldsets = Dict(k => length(v) == 1 ? v : setdiff(v, known) for (k, v) in fieldsets)
    end
    Dict(k => only(v) for (k, v) in fieldsets)
end
fieldindex = decodefields(rules, remaining)
deprules(rules) = filter(rule -> startswith(rule[1], "departure"), rules)
println("Part 2: result = $(prod([ticket[fieldindex[rule[1]]] for rule in deprules(rules)]))")

end

max_stars_repo_name: ericgreveson/adventofcode

max_issues_repo_name: ericgreveson/adventofcode

max_forks_repo_name: ericgreveson/adventofcode


text:
function loadSnapshot(
    filename::AbstractString;
    gridinfo_file::Union{AbstractString, Nothing} = nothing,
)
    local ocn

    Dataset(filename, "r") do ds

        Ts_clim_relax_time = nothing
        Ss_clim_relax_time = nothing

        Ts_clim = nothing
        Ss_clim = nothing

        if haskey(ds, "Ts_clim")
            Ts_clim_relax_time = ds.attrib["Ts_clim_relax_time"]
            Ts_clim = toZXY(nomissing(ds["Ts_clim"][:], NaN), :xyz)
        end

        if haskey(ds, "Ss_clim")
            Ss_clim_relax_time = ds.attrib["Ss_clim_relax_time"]
            Ss_clim = toZXY(nomissing(ds["Ss_clim"][:], NaN), :xyz)
        end

        ocn = Ocean(
            id       = 0,
            gridinfo_file = (gridinfo_file == nothing) ? ds.attrib["gridinfo_file"] : gridinfo_file,
            Nx       = ds.dim["Nx"],
            Ny       = ds.dim["Ny"],
            zs_bone  = nomissing(ds["zs_bone"][:], NaN);
            Ts       = toZXY( nomissing(ds["Ts"][:], NaN), :xyz),
            Ss       = toZXY( nomissing(ds["Ss"][:], NaN), :xyz),
            K_v      = ds.attrib["K_v"],
            Dh_T      = ds.attrib["Dh_T"],
            Dv_T      = ds.attrib["Dv_T"],
            Dh_S      = ds.attrib["Dh_S"],
            Dv_S      = ds.attrib["Dv_S"],
            fs       = nomissing(ds["fs"][:], NaN),
            ϵs       = nomissing(ds["epsilons"][:], NaN),
            T_ML     = nomissing(ds["T_ML"][:], NaN),
            S_ML     = nomissing(ds["S_ML"][:], NaN),
            h_ML     = nomissing(ds["h_ML"][:], NaN),
            h_ML_min = nomissing(ds["h_ML_min"][:], NaN),
            h_ML_max = nomissing(ds["h_ML_max"][:], NaN),
            we_max   = ds.attrib["we_max"],
            R        = ds.attrib["R"],
            ζ        = ds.attrib["zeta"],
            Ts_clim_relax_time = Ts_clim_relax_time,
            Ss_clim_relax_time = Ss_clim_relax_time,
            Ts_clim  = Ts_clim,
            Ss_clim  = Ss_clim,
            mask     = nomissing(ds["mask"][:], NaN),
            topo     = nomissing(ds["topo"][:], NaN),
            in_flds  = nothing,
        )

    end

    return ocn
end

function takeSnapshot(
    ocn::Ocean,
    filename::AbstractString;
    missing_value::Float64=1e20
)
    _createNCFile(ocn, filename, missing_value)

    Dataset(filename, "a") do ds

        ds.attrib["gridinfo_file"] = ocn.gi_file
        ds.attrib["K_v"] = ocn.K_v
        ds.attrib["Dh_T"] = ocn.Dh_T
        ds.attrib["Dv_T"] = ocn.Dv_T
        ds.attrib["Dh_S"] = ocn.Dh_S
        ds.attrib["Dv_S"] = ocn.Dv_S

        ds.attrib["we_max"] = ocn.we_max
        ds.attrib["R"]    = ocn.R
        ds.attrib["zeta"] = ocn.ζ

        if ocn.Ts_clim_relax_time != nothing
            ds.attrib["Ts_clim_relax_time"] = ocn.Ts_clim_relax_time
        end

        if ocn.Ss_clim_relax_time != nothing
            ds.attrib["Ss_clim_relax_time"] = ocn.Ss_clim_relax_time
        end

        _write2NCFile(ds, "zs_bone", ("NP_zs_bone",), ocn.zs_bone, missing_value)

        _write2NCFile(ds, "Ts", ("Nx", "Ny", "Nz_bone"), toXYZ(ocn.Ts, :zxy), missing_value)
        _write2NCFile(ds, "Ss", ("Nx", "Ny", "Nz_bone"), toXYZ(ocn.Ss, :zxy), missing_value)
        _write2NCFile(ds, "bs", ("Nx", "Ny", "Nz_bone"), toXYZ(ocn.bs, :zxy), missing_value)
        _write2NCFile(ds, "T_ML", ("Nx", "Ny",), ocn.T_ML, missing_value)
        _write2NCFile(ds, "S_ML", ("Nx", "Ny",), ocn.S_ML, missing_value)
        _write2NCFile(ds, "h_ML", ("Nx", "Ny",), ocn.h_ML, missing_value)

        _write2NCFile(ds, "h_ML_min", ("Nx", "Ny",), ocn.h_ML_min, missing_value)
        _write2NCFile(ds, "h_ML_max", ("Nx", "Ny",), ocn.h_ML_max, missing_value)

        if ocn.Ts_clim != nothing
            _write2NCFile(ds, "Ts_clim", ("Nx", "Ny", "Nz_bone"), toXYZ(ocn.Ts_clim, :zxy), missing_value)
        end

        if ocn.Ss_clim != nothing
            _write2NCFile(ds, "Ss_clim", ("Nx", "Ny", "Nz_bone"), toXYZ(ocn.Ss_clim, :zxy), missing_value)
        end

        _write2NCFile(ds, "mask", ("Nx", "Ny",), ocn.mask, missing_value)
        _write2NCFile(ds, "topo", ("Nx", "Ny",), ocn.topo, missing_value)

        _write2NCFile(ds, "fs", ("Nx", "Ny"), ocn.fs, missing_value)
        _write2NCFile(ds, "epsilons", ("Nx", "Ny"), ocn.ϵs, missing_value)

        # Additional
        _write2NCFile(ds, "area", ("Nx", "Ny",), ocn.mi.area, missing_value)
        _write2NCFile(ds, "xc",   ("Nx", "Ny",), ocn.mi.xc,   missing_value)
        _write2NCFile(ds, "yc",   ("Nx", "Ny",), ocn.mi.yc,   missing_value)

    end

end

function _createNCFile(
    ocn::Ocean,
    filename::AbstractString,
    missing_value::Float64,
)

    Dataset(filename, "c") do ds

        defDim(ds, "N_ocs", ocn.N_ocs)
        defDim(ds, "Nx", ocn.Nx)
        defDim(ds, "Ny", ocn.Ny)
        defDim(ds, "Nz_bone", ocn.Nz_bone)
        defDim(ds, "NP_zs_bone",   length(ocn.zs_bone))
        defDim(ds, "time",   Inf)

        ds.attrib["_FillValue"] = missing_value

    end

end

function _write2NCFile(
    ds            :: Dataset,
    varname       :: AbstractString,
    dim           :: Tuple,
    var_data      :: AbstractArray{T},
    missing_value :: G) where T where G

    #println("Write : ", varname)

    ds_var = defVar(ds, varname, eltype(var_data), dim)

    ds_var.attrib["_FillValue"] = missing_value
    for (k, v) in getVarDesc(varname)
        ds_var.attrib[k] = v
    end

    ds_var[:] = var_data

end

"""
    This function is meant to append field into an NC file
    along the time dimension
"""
function _write2NCFile_time(
    ds            :: Dataset,
    varname       :: String,
    dim           :: Tuple,
    time          :: Integer,
    var_data      :: AbstractArray{T};
    missing_value :: Union{T, Nothing} = nothing,
) where T where G

#    time        :: Union{Nothing, UnitRange, Integer} = nothing,
#    time_exists :: Bool = true,
#    missing_value :: Union{T, Nothing} = nothing,
#) where T <: float

    local ds_var

    # Create variable if it is not in the file yet
    if ! ( varname in keys(ds) )

        ds_var = defVar(ds, varname, T, (dim..., "time"))

        if missing_value != nothing
            ds_var.attrib["_FillValue"] = missing_value
        end
    else
        ds_var = ds[varname]
    end

    ds_var[repeat([:,], length(dim))..., time] = var_data

end

max_stars_repo_name: meteorologytoday/IOM

max_issues_repo_name: meteorologytoday/IOM

max_forks_repo_name: meteorologytoday/IOM


text:
include("WorkingDir.jl");
include("SaveResult.jl");
include("Versions.jl");
include("Parser.jl");
include("LoadResults.jl");
include("Shows.jl");
include("Edits.jl")


text:
# The main file of the project

include("const.jl")
include("wakemath.jl")
include("bioslinevortex.jl")
include("flapreponse.jl")
include("uniforminflow.jl")
include("freewake.jl")
include("aoaget.jl")
include("clcdget.jl")
include("rotorforce.jl")

# 桨叶安装角和总距角初始化
θcp = Array{Float64}(NR)  #总距角
θroot = Array{Float64}(NR)  #桨根安装角
tw_θ = Array{Float64}(NR) #桨叶扭转
θ_lon = Array{Float64}(NR)  #纵向周期变距
θ_lat = Array{Float64}(NR)  #横向周期变距

for k in 1:NR
  θcp[k] = 10.0*π/180
  θroot[k] = 50.0*π/180
  tw_θ[k] = 1.0*π/180
  θ_lon[k] = 0.0
  θ_lat[k] = 0.0
end

ψ = 0.0
index = 1
sumforce = 0.0

# The file calculate the uniform induced velocity
v_res = uniforminflow(ψ)
v_ind = v_res[1]
v_all = v_res[2]

#begin :: Calculate the rigid wake
riwake = rigidwake(v_res[3],"RIGIDWAKE.PLT")
wp = riwake[1]
ζ0 = riwake[2]
Nwp = trunc(Int,length(wp)/(NR*Nbe))
#end :: Rigid wake calculated

α_aero = aoaget(v_all,ψ)[1]
Cl = clcdget(α_aero,v_all)[1]

while ψ<=(20*π)

  wp_gen = wpgen(ψ,ζ0,wp,Nwp)
  wp = wp_gen[1]
  Nwp = trunc(Int,length(wp)/(NR*Nbe))
  ζ0 = wp_gen[2]
  fwake = freewake(wp,Nwp,ψ,ζ0,Cl,v_all)
  gama_wp = fwake[2]
  wp = fwake[1]
  vbelm = vbe(ψ,ζ0,gama_wp,wp)
  v_all = vbelm[2]

  # This file is used for get angle-of-attack

  α_aero = aoaget(v_all,ψ)[1]
  θ = aoaget(v_all,ψ)[2]

  # This file is to get the Cl and Cd of Blade Element

  Cl = clcdget(α_aero,v_all)[1]
  Cd = clcdget(α_aero,v_all)[2]

  # This file calculate the whole aerodynamic force of the rotor in the hub
  sumforce += rotorforce(v_all,α_aero,θ,Cl,Cd,
                         pwd()*"\\force_record\\bladeforce_$(index).txt")[2]

    ψ += dψ
    index += 1
end

wpplt = open("wakepoints.PLT","w")
write(wpplt,"  TITLE = 'RIGID WAKE OF ROTOR'\n")
for k in 1:NR
  for j in 1:Nbe
    write(wpplt,"  VARIABLES = 'X','Y','Z'\n")
    write(wpplt,"  ZONE I = $(Nwp)\tF = POINT\n")
    for i in 1:Nwp
      write(wpplt,
            "\t$(wp[i,j,k][1])\t$(wp[i,j,k][2])\t$(wp[i,j,k][3])\n")
    end
  end
end
close(wpplt)

print("The thrust of the rotor is : $(sumforce/index)")

max_stars_repo_name: dingzhw/RotorTrim

max_issues_repo_name: helicopterliu/RotorTrim

max_forks_repo_name: helicopterliu/RotorTrim


text:
using DifferentiableStateSpaceModels, LinearAlgebra, Optim, Test, Turing, Zygote
using DifferentiableStateSpaceModels.Examples
using Turing: @addlogprob!

Turing.setadbackend(:zygote)

# Create models from modules and then solve
# p_d = [α, β]
model_rbc = @include_example_module(Examples.rbc_observables)

p_f = (ρ=0.2, δ=0.02, σ=0.01, Ω_1=0.01)
p_d = (α=0.5, β=0.95)
p_d_input = [0.5, 0.95]
sol = generate_perturbation(model_rbc, p_d, p_f, Val(1))
sol_second = generate_perturbation(model_rbc, p_d, p_f, Val(2))

T = 20
ϵ = [randn(model_rbc.n_ϵ) for _ = 1:T]
x0 = zeros(model_rbc.n_x)
fake_z = solve(sol, x0, (0, T), DifferentiableStateSpaceModels.LTI(); noise = ϵ).z
fake_z_second = solve(sol_second, x0, (0, T), DifferentiableStateSpaceModels.QTI(); noise = ϵ).z

# Turing model, Kalman filter
@model function rbc_kalman(z, m, p_f, cache)
    α ~ Uniform(0.2, 0.8)
    β ~ Uniform(0.5, 0.99)
    p_d = (α = α, β = β)
    # println(p_d)
    sol = generate_perturbation(m, p_d, p_f, Val(1); cache)
    if !(sol.retcode == :Success)
        @addlogprob! -Inf
        return
    end
    @addlogprob! solve(sol, sol.x_ergodic, (0, length(z)); observables = z).logpdf
end

c = SolverCache(model_rbc, Val(1), p_d)
turing_model = rbc_kalman(fake_z, model_rbc, p_f, c)
n_samples = 20
n_adapts = 5
δ = 0.65
chain = sample(turing_model, NUTS(n_adapts, δ), n_samples; progress = true)
θ_MAP = optimize(turing_model, MAP())

# Turing model, Joint likelihood
@model function rbc_joint(z, m, p_f, cache, x0 = zeros(m.n_x))
    α ~ Uniform(0.2, 0.8)
    β ~ Uniform(0.5, 0.99)
    p_d = (α = α, β = β)
    T = length(z)
    ϵ_draw ~ MvNormal(T, 1.0)
    ϵ = map(i -> ϵ_draw[((i-1)*m.n_ϵ+1):(i*m.n_ϵ)], 1:T)
    # println(p_d)
    sol = generate_perturbation(m, p_d, p_f, Val(1); cache)
    if !(sol.retcode == :Success)
        @addlogprob! -Inf
        return
    end
    @addlogprob! solve(sol, x0, (0, T); noise = ϵ, observables = z).logpdf
end

c = SolverCache(model_rbc, Val(1), p_d)
turing_model = rbc_joint(fake_z, model_rbc, p_f, c)
n_samples = 20
n_adapts = 3
δ = 0.65
chain = sample(turing_model, NUTS(n_adapts, δ), n_samples; progress = true)

ϵ_leapfrog = 0.02
n_depth = 2
chain = sample(
    turing_model,
    Gibbs(HMC(ϵ_leapfrog, n_depth, :α, :β), HMC(ϵ_leapfrog, n_depth, :ϵ_draw)),
    n_samples;
    progress = true
)

# Gradient check codes
#=
density = Turing.OptimLogDensity(turing_model, DynamicPPL.DefaultContext())
g = gradient(density, θ_MAP.values.array)
g = gradient(density, [p;vcat(ϵ...)])
=#
# FiniteDiff.finite_difference_gradient(density, [p;vcat(ϵ...)])

# Turing model, Joint likelihood, Second-order
@model function rbc_second(z, m, p_f, cache, x0 = zeros(m.n_x))
    α ~ Uniform(0.2, 0.8)
    β ~ Uniform(0.5, 0.99)
    p_d = (α = α, β = β)
    T = length(z)
    ϵ_draw ~ MvNormal(T, 1.0)
    ϵ = map(i -> ϵ_draw[((i-1)*m.n_ϵ+1):(i*m.n_ϵ)], 1:T)
    # println(p_d)
    sol = generate_perturbation(m, p_d, p_f, Val(2); cache)
    if !(sol.retcode == :Success)
        @addlogprob! -Inf
        return
    end
    @addlogprob! solve(sol, x0, (0, T); noise = ϵ, observables = z).logpdf
end
c = SolverCache(model_rbc, Val(2), p_d)
turing_model = rbc_joint(fake_z, model_rbc, p_f, c)
n_samples = 20
n_adapts = 5
δ = 0.65
max_depth = 2
chain = sample(turing_model, NUTS(n_adapts, δ; max_depth), n_samples; progress = true)


text:
cd(@__DIR__)
using Pkg
Pkg.activate(".")
Pkg.instantiate()
##
using MCPhylo
using CSV
using DataFrames
using Pipe

##
families = @pipe readdir("revbayes") |>
    split.(_, ".") |> first.(_) |> string.(_)
families = [x for x in families if x != "output"]
##
for fm in families
    c1 = select(
        CSV.read("revbayes/output/$(fm)_run_1.p", DataFrame),
        ["alpha", "pi[1]", "pi[2]", "rootAge"],
    )[501:end,:]
    c2 = select(
        CSV.read("revbayes/output/$(fm)_run_2.p", DataFrame),
        ["alpha", "pi[1]", "pi[2]", "rootAge"],
    )[501:end,:]
    sim = Chains(
        cat(Array(c1), Array(c2), dims=3),
        1,
    )
    gd = gelmandiag(sim)
    if maximum(gd.value[:,1]) > 1.1
        println("$fm did not converge")
    end
end

max_stars_repo_name: gerhardJaeger/phylogeneticTypology

max_issues_repo_name: gerhardJaeger/phylogeneticTypology

max_forks_repo_name: gerhardJaeger/phylogeneticTypology


text:
using Test
using Blosc2
include("main/main.jl")
include("dev.jl")


text:
"""
    calc_resid(X, Y, Z, B)

Calculate residuals

# Arguments

- X = 2d array of floats consisting of the row covariates, standardized as
  necessary
- Y = 2d array of floats consisting of the multivariate response
  observations, standardized as necessary
- Z = 2d array of floats consisting of the column covariates, standardized
  as necessary
- B = 2d array of floats consisting of coefficient estimates

# Value

2d array of floats

"""
function calc_resid(X::AbstractArray{Float64,2}, Y::AbstractArray{Float64,2},
                    Z::AbstractArray{Float64,2}, B::AbstractArray{Float64,2})

    # Obtain fitted values
    resid = calc_preds(X, Z, B)

    # Compute residuals over fitted values
    resid .= Y .- resid

    return resid
end

"""
    calc_resid!(resid, X, Y, Z, B)

Calculate residuals in place

# Arguments

- resid = 2d array of floats consisting of the residuals, to be updated in
  place
- X = 2d array of floats consisting of the row covariates, standardized as
  necessary
- Y = 2d array of floats consisting of the multivariate response
  observations, standardized as necessary
- Z = 2d array of floats consisting of the column covariates, standardized
  as necessary
- B = 2d array of floats consisting of coefficient estimates

# Value

None; updates residuals in place.

"""
function calc_resid!(resid::AbstractArray{Float64,2},
                     X::AbstractArray{Float64,2},
                     Y::AbstractArray{Float64,2},
                     Z::AbstractArray{Float64,2},
                     B::AbstractArray{Float64,2})

    # Obtain fitted values in place
    calc_preds!(resid, X, Z, B)

    # Compute residuals in place over fitted values
    resid .= Y .- resid
end


text:
struct ScalarFunctions{T,F}
    coord::T
    func::F
end

### Radial Functions
struct HeunConfluentRadial
    η::Complex{Float64}; α::Complex{Float64}; ξ::Complex{Float64}; ζ::Complex{Float64}
    r₊::Float64; r₋::Float64
    coeffs::Array{Complex{Float64},1}
end

function (ψᵣ::HeunConfluentRadial)(r::Union{Float64,Complex{Float64}})
    η = ψᵣ.η;
    α = ψᵣ.α;
    ξ = ψᵣ.ξ;
    ζ = ψᵣ.ζ;
    r₊ = ψᵣ.r₊;
    r₋ = ψᵣ.r₋
    asymptoticpart = (r₊-r₋)^(α)*(im*(r-r₋))^(η-α)*(im*(r-r₊))^(ξ)*exp(ζ*r)
    x = (r-r₊)/(r-r₋)
    finalsum = 0
    for n in 1:length(ψᵣ.coeffs)
       finalsum += ψᵣ.coeffs[n]*x^(n-1)
    end
    #print(asymptoticpart)
    asymptoticpart*finalsum
end

function ComplexPlot(ψ::HeunConfluentRadial; ztopleft = 0.8 + 1.0im, zbottomright = 2.0 - 0.5im)
    img = portrait(ztopleft, zbottomright, Ψ;
        point_color = cs_d(; colormap=hsv_colors()))
    display(img)
    img
end

### Angular Functions
struct SpinWeightedSpherical
    s::Int64; l::Int64; m::Int64
end

function sterlings(n)
    return sqrt(2*pi*n)*(n/exp(1))^n
end

function SpinWeightedSphericalCalculation(z,s,l,m)
    ### Convention is that θ goes from 0 to pi, and hence cos(θ)
    ### goes from 1 to -1, which means θ/2 is in the first quadrant
    ### hence all cot terms are positive, which is why I take the
    ### positive root whereever needed.
    ### Pulled from
    ### https://en.wikipedia.org/wiki/Spin-weighted_spherical_harmonics
    #Define the overall factor
    #println((l+m > 20),"  ",(l+s > 20),"  ",(l-m > 20),"  ",(l-s > 20))
    #println(((l+m > 20) | (l+s > 20) | (l-m > 20) | (l-s > 20)))
    if ((l+m > 20) | (l+s > 20) | (l-m > 20) | (l-s > 20))
        term1 = (2*l+1)*(sterlings(l+m)/sterlings(l+s))*(sterlings(l-m)/sterlings(l-s))
    else
        term1 = (2*l+1)*(factorial(l+m)/factorial(l+s))*(factorial(l-m)/factorial(l-s))
    end
    #println((l=l,m=m,s=s), (fact = factorial(l+m),), term1)
    A = sqrt(term1/(4*pi))*(-1)^m

    #The sin term right outside the summation
    sinterm = ((1-z)/2)^l

    #The summation terms
    sumterms = 0
    for r = 0:(l-s)
        consts = binomial(l-s,r)*binomial(l+s,r+s-m)*(-1)^(l-r-s)
        cotterm = ((1+z)/(1-z))^((2*r+s-m)/2)
        sumterms += consts*cotterm
    end

    return A*sinterm*sumterms
end

function (Ψ::SpinWeightedSpherical)(z)
    s = Ψ.s; l = Ψ.l; m = Ψ.m;
    if (l >= min(abs(m),abs(s))) & (l >= abs(m))
        return SpinWeightedSphericalCalculation(z,s,l,m)
    end
    return Complex(0.0)
end

function (Ψ::SpinWeightedSpherical)(z,ϕ)
    Ψ(z)*exp(im*Ψ.m*ϕ)
end

struct SpinWeightedSpheroidal
    s::Int64; l::Int64; m::Int64
    Cllʼ::Array{Complex{Float64},1}
    lmin::Int64; lmax::Int64
end

function SpinWeightedSpheroidal(s,l,m,Cllʼ)
    lmins = max(abs(s),abs(m));
    lmax = length(Cllʼ) + lmins -1
    SpinWeightedSpheroidal(s,l,m,Cllʼ,lmins, lmax)
end

function SpinWeightedSpheroidalCalculation(z,s,l,m,Cllʼ,lmin,lmax)
    N = lmax - lmin + 1
    val = Complex(0.0)
    for j = 1:N
        lʼ = j+lmin-1;
        #println(lʼ)
        val += Cllʼ[j]*SpinWeightedSphericalCalculation(z,s,lʼ,m)
    end
    val
end

function (Ψ::SpinWeightedSpheroidal)(z)
    s = Ψ.s; l = Ψ.l; m = Ψ.m;
    lmin = Ψ.lmin; lmax = Ψ.lmax; Cllʼ = Ψ.Cllʼ;
    SpinWeightedSpheroidalCalculation(z,s,l,m,Cllʼ,lmin,lmax)
end

(Ψ::SpinWeightedSpheroidal)(z,ϕ) = Ψ(z)*exp(im*Ψ.m*ϕ)

function RadialCoefficients(D₀, D₁, D₂, D₃, D₄; N = 250)
    αₙ(n) = (n+1)*(n+D₀)
    βₙ(n) = -2*n^2 + (D₁+2)*n + D₃
    γₙ(n) = (n-1)*(n+D₂-2) + D₄

    an(n) = βₙ(n)/αₙ(n) ; bn(n) = γₙ(n)/αₙ(n);

    ##Set largest rN value
    u1,u2,u3,u4 = rNCoeffs(D₀,D₁,D₂,D₃,D₄)
    rN = 1 + u1*N^(-0.5) + u2*N^(-1) + u3*N^(1.5) + u4*N^(-2)

    ComputeSeriesFromab(an,bn; rN=rN, PreN=0)
end

function ComputeSeriesFromab(an::Function,bn::Function; N=250, rN = 0.0*im, PreN = 40)
    ##Initialize rn and fn vectors
    rₙ = zeros(Complex{Float64},N+1)
    fₙ = zeros(Complex{Float64},N+1)

    rold = rN
    ##Startup Pass for rₙ
    for n = (N+PreN):-1:(N+1)
        rnew = -bn(n)/(an(n) + rold)
        rold = rnew
    end
    rₙ[N+1] = rold;
    ##Pass for rn
    for n= N:-1:1
        rₙ[n] = -bn(n)/(an(n) + rₙ[n+1])
    end

    fₙ[1] = 1;
    ##Pass for fn
    for n = 2:(N+1)
        fₙ[n] = rₙ[n-1]*fₙ[n-1]
    end
    fₙ
end

### Combining the Mode radial and angular Information
struct QuasinormalModeFunction
    s::Int64; l::Int64; m::Int64; a::Float64
    ω::Complex{Float64}
    Alm::Complex{Float64}
    R::HeunConfluentRadial
    S::SpinWeightedSpheroidal
end

function qnmfunction(; s=-2,l=2,m=2,n=0,a=0.00)
    ω, Alm, Cllʼ = qnm(l=l,m=m,s=s,n=n, a=a)

    ((ζ,ξ,η),(p,α,γ,δ,σ),(D₀,D₁,D₂,D₃,D₄)) = ParameterTransformations(l,m,s,a,ω,Alm)
    r₊ = 1 + sqrt(1-a^2); r₋ = 1 - sqrt(1-a^2)

    ##Radial WaveFunction
    aₙ = RadialCoefficients(D₀, D₁, D₂, D₃, D₄)
    Ψᵣ = HeunConfluentRadial(η,α,ξ,ζ,r₊,r₋,aₙ)

    ##Angular WaveFunction
    Ψᵪ = SpinWeightedSpheroidal(s,l,m,Cllʼ)

    QuasinormalModeFunction(s,l,m,a,ω,Alm,Ψᵣ,Ψᵪ)
end

(Ψ::QuasinormalModeFunction)(r::Number) =  Ψ.R(r)
(Ψ::QuasinormalModeFunction)(r::Number, θ::Number) =  Ψ.R(r)*Ψ.S(cos(θ))
(Ψ::QuasinormalModeFunction)(r::Number, θ::Number, ϕ::Number) =  Ψ.R(r)*Ψ.S(cos(θ))*exp(im*Ψ.m*ϕ)
(Ψ::QuasinormalModeFunction)(r::Number, θ::Number, ϕ::Number, t::Number) =  Ψ.R(r)*Ψ.S(cos(θ))*exp(im*Ψ.m*ϕ)*exp(-im*Ψ.ω*t)

(Ψ::QuasinormalModeFunction)(x::NamedTuple{(:r,),Tuple{Number}}) = Ψ.R(x[:r])
(Ψ::QuasinormalModeFunction)(x::NamedTuple{(:θ,),Tuple{Number}}) = Ψ.S(cos(x[:θ]))
(Ψ::QuasinormalModeFunction)(x::NamedTuple{(:z,),Tuple{Number}}) = Ψ.S(x[:z])
(Ψ::QuasinormalModeFunction)(x::NamedTuple{(:r, :θ),Tuple{Number,Number}}) = Ψ.R(x[:r])*Ψ.S(cos(x[:θ]))
(Ψ::QuasinormalModeFunction)(x::NamedTuple{(:r, :z),Tuple{Number,Number}}) = Ψ.R(x[:r])*Ψ.S(x[:z])
(Ψ::QuasinormalModeFunction)(x::NamedTuple{(:r, :θ, :ϕ),Tuple{Number,Number,Number}}) = Ψ.R(x[:r])*Ψ.S(cos(x[:θ]))*exp(im*Ψ.m*ϕ)
(Ψ::QuasinormalModeFunction)(x::NamedTuple{(:r, :z, :ϕ),Tuple{Number,Number,Number}}) = Ψ.R(x[:r])*Ψ.S(x[:z])*exp(im*Ψ.m*ϕ)
(Ψ::QuasinormalModeFunction)(x::NamedTuple{(:r, :θ, :ϕ, :t),Tuple{Number,Number,Number,Number}}) = Ψ.R(x[:r])*Ψ.S(cos(x[:θ]))*exp(im*Ψ.m*ϕ)
(Ψ::QuasinormalModeFunction)(x::NamedTuple{(:r, :z, :ϕ, :t),Tuple{Number,Number,Number,Number}}) = Ψ.R(x[:r])*Ψ.S(x[:z])*exp(im*Ψ.m*ϕ)

print("Here")


text:
# This file is a part of BAT.jl, licensed under the MIT License (MIT).

@doc doc"""
    autocrl(xv::AbstractVector{T}, kv::AbstractVector{Int} = Vector{Int}())

*BAT-internal, not part of stable public API.*

autocorrelation := Σ Cov[x_i,x_(i+k)]/Var[x]

Computes the autocorrelations at various leg k of the
input vector (time series) xv.
The vector kv is the collections of lags to take into account
"""
function autocrl(xv::AbstractVector{T}, kv::AbstractVector{Int} = Vector{Int}()) where T<:Real
       N = size(xv)[1]
       if size(kv)[1] == 0
           kv = 1:(N-1)
       end
       x_avg = sum(xv)/N
       result = Vector{Float64}(zeros(size(kv)))
       for k in kv
           autocrl_num = 0.0
           autocrl_den = 0.0
           for i in 1:N-k
               autocrl_num += (xv[i+k] - x_avg)*(xv[i]-x_avg)
               autocrl_den += (xv[i]-x_avg)^2
           end
           result[k] = autocrl_num/autocrl_den
       end
       return result
end

@doc doc"""
    wgt_effective_sample_size(w::AbstractVector{T})

*BAT-internal, not part of stable public API.*

Kish's approximation for weighted samples effective_sample_size estimation.
Computes the weighting factor for weigthed samples, where w is the vector of
weigths.
"""
function wgt_effective_sample_size(w::AbstractVector{T}) where T<:Real
    return sum(w)^2/sum(w.^2)
end

@doc doc"""
    effective_sample_size(xv, w; ...)

*BAT-internal, not part of stable public API.*

Effective size estimation for a vector of samples xv. If a weight vector w is provided,
the Kish approximation is applied.

By default computes the autocorrelation up to the square root of the number of entries
in the vector, unless an explicit list of lags is provided (kv).
"""
function effective_sample_size(xv::AbstractVector{T1}, w::AbstractVector{T2} = Vector{Float64}(zeros(0)), kv::AbstractVector{Int} = Vector{Int}(1:floor(Int,sqrt(length(xv))))) where T1<:Real where T2<:Number
    atc = StatsBase.autocor(xv,kv)
    # we need to break the sum when ρ_k + ρ_k+1 < 0
    # (see Thompson2010 - arXiv1011.0175 and Geyer2002)
    sumatc = 0
    for k in 1:(length(atc)-1)
        if atc[k]+atc[k+1] >= 0
            sumatc = sumatc+atc[k]
        else
            break
        end
    end
    result = size(xv)[1]/(1 + 2*sumatc)
    w_correction = 1.0
    if size(w) == size(xv)
        w_correction = wgt_effective_sample_size(w)/size(w)[1]
    end
    return min(length(xv),result*w_correction)
end

@doc doc"""
    effective_sample_size(params::AbstractArray, weights::AbstractVector; with_weights=true)

*BAT-internal, not part of stable public API.*

Effective size estimation for a (multidimensional) ElasticArray.
By default applies the Kish approximation with the weigths available, but
can be turned off (with_weights=false).
"""
function effective_sample_size(params::AbstractArray, weights::AbstractVector; with_weights=true)
        ess = size(params, 2)
        for dim in axes(params, 1)
            tmpview = view(params,dim,:)
            tmp = with_weights ?
                effective_sample_size(tmpview, weights) : effective_sample_size(tmpview)
            if tmp < ess
                ess = tmp
            end
        end
        return ess
    end

@doc doc"""
    effective_sample_size(samples::DensitySampleVector; with_weights=true)

*BAT-internal, not part of stable public API.*

Effective size estimation for a (multidimensional) DensitySampleVector.
By default applies the Kish approximation with the weigths available, but
can be turned off (with_weights=false).
"""
function effective_sample_size(samples::DensitySampleVector; with_weights=true)
    return effective_sample_size(samples.params, samples.weight, with_weights=with_weights)
end