{ "cells": [ { "cell_type": "markdown", "source": [ "# Linear rotating shallow water dynamics\n", "\n", "\n", "\n", "This example solves the linear 1D rotating shallow water equations\n", "for the ``u(x, t)``, ``v(x, t)`` and the surface surface elevation ``\\eta(x, t)``,\n", "for a fluid with constant rest-depth ``H``. That is, the total fluid's depth\n", "is ``H + \\eta(x, t)`` with ``|\\eta| \\ll H``.\n", "\n", "The linearized equations for the evolution of ``u``, ``v``, ``\\eta`` are:\n", "\n", "$$\n", "\\begin{aligned}\n", "\\partial_t u - f v & = - g \\partial_x \\eta - \\mathrm{D} u, \\\\\n", "\\partial_t v + f u & = - \\mathrm{D} v, \\\\\n", "\\partial_t \\eta + H \\partial_x u & = - \\mathrm{D} \\eta.\n", "\\end{aligned}\n", "$$\n", "\n", "Above, ``g`` is the gravitational acceleration, ``f`` is the Coriolis parameter, and\n", "``\\mathrm{D}`` indicates a hyperviscous linear operator of the form ``(-1)^{n_ν} ν \\nabla^{2 n_ν}``,\n", "with ``ν`` the viscosity coefficient and ``n_ν`` the order of the operator.\n", "\n", "Rotation introduces the deformation length scale, ``L_d = \\sqrt{g H} / f``. Disturbances with\n", "length scales much smaller than ``L_d`` don't \"feel\" the rotation and propagate as inertia-gravity\n", "waves. Disturbances with length scales comparable or larger than ``L_d`` should be approximately\n", "in geostrophic balance, i.e., the Coriolis acceleration ``f \\widehat{\\bm{z}} \\times \\bm{u}``\n", "should be in approximate balance with the pressure gradient ``-g \\bm{\\nabla} \\eta``." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "using FourierFlows, Plots, Printf, Random\n", "using LinearAlgebra: mul!, ldiv!" ], "metadata": {}, "execution_count": 1 }, { "cell_type": "markdown", "source": [ "## Coding up the equations\n", "### A demonstration of FourierFlows.jl framework\n", "\n", "What follows is a step-by-step tutorial demonstrating how you can create your own solver\n", "for an equation of your liking." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "The basic building blocks for a `FourierFlows.Problem` are:\n", "- `Grid` struct containining the physical and wavenumber grid for the problem,\n", "- `Params` struct containining all the parameters of the problem,\n", "- `Vars` struct containining arrays with the variables used in the problem,\n", "- `Equation` struct containining the coefficients of the linear operator ``L`` and the function that computes the nonlinear terms, usually named `calcN!()`.\n", "\n", "The `Grid` structure is provided by FourierFlows.jl. We simply have to call one of either\n", "`OneDGrid()`, `TwoDGrid()`, or `ThreeDGrid()` constructors, depending on the dimensionality\n", "of the problem. All other structs mentioned above are problem-specific and need to be constructed\n", "for every set of equations we want to solve." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "First let's construct the `Params` struct that contains all parameters of the problem." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "struct Params{T} <: AbstractParams\n", " ν :: T # Hyperviscosity coefficient\n", " nν :: Int # Order of the hyperviscous operator\n", " g :: T # Gravitational acceleration\n", " H :: T # Fluid depth\n", " f :: T # Coriolis parameter\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 2 }, { "cell_type": "markdown", "source": [ "Now the `Vars` struct that contains all variables used in this problem. For this\n", "problem `Vars` includes the representations of the flow fields in physical space\n", "`u`, `v` and `η` and their Fourier transforms `uh`, `vh`, and `ηh`." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "struct Vars{Aphys, Atrans} <: AbstractVars\n", " u :: Aphys\n", " v :: Aphys\n", " η :: Aphys\n", " uh :: Atrans\n", " vh :: Atrans\n", " ηh :: Atrans\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 3 }, { "cell_type": "markdown", "source": [ "A constructor populates empty arrays based on the dimension of the `grid`\n", "and then creates `Vars` struct." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "\"\"\"\n", " Vars(dev, grid)\n", "Constructs Vars for 1D shallow water based on the dimensions of arrays of the `grid`.\n", "\"\"\"\n", "function Vars(::Dev, grid) where Dev\n", " T = eltype(grid)\n", " @devzeros Dev T grid.nx u v η\n", " @devzeros Dev Complex{T} grid.nkr uh vh ηh\n", "\n", " return Vars(u, v, η, uh, vh, ηh)\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 4 }, { "cell_type": "markdown", "source": [ "In Fourier space, the 1D linear shallow water dynamics read:\n", "\n", "$$\n", "\\begin{aligned}\n", "\\frac{\\partial \\hat{u}}{\\partial t} & = \\underbrace{ f \\hat{v} - i k g \\hat{\\eta} }_{N_u} \\; \\underbrace{- \\nu k^2 }_{L_u} \\hat{u} , \\\\\n", "\\frac{\\partial \\hat{v}}{\\partial t} & = \\underbrace{ - f \\hat{u} }_{N_v} \\; \\underbrace{- \\nu k^2 }_{L_v} \\hat{v} , \\\\\n", "\\frac{\\partial \\hat{\\eta}}{\\partial t} & = \\underbrace{ - i k H \\hat{u} }_{N_{\\eta}} \\; \\underbrace{- \\nu k^2 }_{L_{\\eta}} \\hat{\\eta} .\n", "\\end{aligned}\n", "$$\n", "Although, e.g., terms involving the Coriolis accelaration are, in principle, linear we include\n", "them in the nonlinear term ``N`` because they render the linear operator ``L`` non-diagonal.\n", "\n", "With these in mind, we construct function `calcN!` that computes the nonlinear terms." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "\"\"\"\n", " calcN!(N, sol, t, clock, vars, params, grid)\n", "Compute the nonlinear terms for 1D linear shallow water dynamics.\n", "\"\"\"\n", "function calcN!(N, sol, t, clock, vars, params, grid)\n", " @. vars.uh = sol[:, 1]\n", " @. vars.vh = sol[:, 2]\n", " @. vars.ηh = sol[:, 3]\n", "\n", " @. N[:, 1] = params.f * vars.vh - im * grid.kr * params.g * vars.ηh # + f v - g ∂η/∂x\n", " @. N[:, 2] = - params.f * vars.uh # - f u\n", " @. N[:, 3] = - im * grid.kr * params.H * vars.uh # - H ∂u/∂x\n", "\n", " dealias!(N, grid)\n", "\n", " return nothing\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 5 }, { "cell_type": "markdown", "source": [ "Next we construct the `Equation` struct:" ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "\"\"\"\n", " Equation(dev, params, grid)\n", "Construct the equation: the linear part, in this case the hyperviscous dissipation,\n", "and the nonlinear part, which is computed by `calcN!` function.\n", "\"\"\"\n", "function Equation(dev, params, grid)\n", " T = eltype(grid)\n", " L = zeros(dev, T, (grid.nkr, 3))\n", " D = @. - params.ν * grid.kr^(2*params.nν)\n", "\n", " L[:, 1] .= D # for u equation\n", " L[:, 2] .= D # for v equation\n", " L[:, 3] .= D # for η equation\n", "\n", " return FourierFlows.Equation(L, calcN!, grid)\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 6 }, { "cell_type": "markdown", "source": [ "We now have all necessary building blocks to construct a `FourierFlows.Problem`.\n", "It would be useful, however, to define some more \"helper functions\". For example,\n", "a function that updates all variables given the solution `sol` which comprises ``\\hat{u}``,\n", "``\\hat{v}`` and ``\\hat{\\eta}``:" ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "\"\"\"\n", " updatevars!(prob)\n", "Update the variables in `prob.vars` using the solution in `prob.sol`.\n", "\"\"\"\n", "function updatevars!(prob)\n", " vars, grid, sol = prob.vars, prob.grid, prob.sol\n", "\n", " @. vars.uh = sol[:, 1]\n", " @. vars.vh = sol[:, 2]\n", " @. vars.ηh = sol[:, 3]\n", "\n", " ldiv!(vars.u, grid.rfftplan, deepcopy(sol[:, 1])) # use deepcopy() because irfft destroys its input\n", " ldiv!(vars.v, grid.rfftplan, deepcopy(sol[:, 2])) # use deepcopy() because irfft destroys its input\n", " ldiv!(vars.η, grid.rfftplan, deepcopy(sol[:, 3])) # use deepcopy() because irfft destroys its input\n", "\n", " return nothing\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 7 }, { "cell_type": "markdown", "source": [ "Another useful function is one that prescribes an initial condition to the state variable `sol`." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "\"\"\"\n", " set_uvη!(prob, u0, v0, η0)\n", "Sets the state variable `prob.sol` as the Fourier transforms of `u0`, `v0`, and `η0`\n", "and update all variables in `prob.vars`.\n", "\"\"\"\n", "function set_uvη!(prob, u0, v0, η0)\n", " vars, grid, sol = prob.vars, prob.grid, prob.sol\n", "\n", " A = typeof(vars.u) # determine the type of vars.u\n", "\n", " mul!(vars.uh, grid.rfftplan, A(u0)) # A(u0) converts u0 to the same type as vars expects (useful if u0 is a CPU array while working on the GPU)\n", " mul!(vars.vh, grid.rfftplan, A(v0)) # A(v0) converts u0 to the same type as vars expects (useful if v0 is a CPU array while working on the GPU)\n", " mul!(vars.ηh, grid.rfftplan, A(η0)) # A(η0) converts u0 to the same type as vars expects (useful if η0 is a CPU array while working on the GPU)\n", "\n", " @. sol[:, 1] = vars.uh\n", " @. sol[:, 2] = vars.vh\n", " @. sol[:, 3] = vars.ηh\n", "\n", " updatevars!(prob)\n", "\n", " return nothing\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 8 }, { "cell_type": "markdown", "source": [ "## Let's prescibe parameter values and solve the PDE\n", "\n", "We are now ready to write up a program that sets up parameter values, constructs\n", "the problem `prob`, # time steps the solutions `prob.sol` and plots it." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Choosing a device: CPU or GPU" ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "dev = CPU() # Device (CPU/GPU)\n", "nothing # hide" ], "metadata": {}, "execution_count": 9 }, { "cell_type": "markdown", "source": [ "## Numerical parameters and time-stepping parameters" ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ " nx = 512 # grid resolution\n", "stepper = \"FilteredRK4\" # timestepper\n", " dt = 20.0 # timestep (s)\n", " nsteps = 320 # total number of time-steps\n", "nothing # hide" ], "metadata": {}, "execution_count": 10 }, { "cell_type": "markdown", "source": [ "## Physical parameters" ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "Lx = 500e3 # Domain length (m)\n", "g = 9.8 # Gravitational acceleration (m s⁻²)\n", "H = 200.0 # Fluid depth (m)\n", "f = 1e-2 # Coriolis parameter (s⁻¹)\n", "ν = 100.0 # Viscosity (m² s⁻¹)\n", "nν = 1 # Viscosity order (nν = 1 means Laplacian ∇²)\n", "nothing # hide" ], "metadata": {}, "execution_count": 11 }, { "cell_type": "markdown", "source": [ "## Construct the `struct`s and you are ready to go!\n", "Create a `grid` and also `params`, `vars`, and the `equation` structs. Then\n", "give them all as input to the `FourierFlows.Problem()` constructor to get a\n", "problem struct, `prob`, that contains all of the above." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ " grid = OneDGrid(dev, nx, Lx)\n", " params = Params(ν, nν, g, H, f)\n", " vars = Vars(dev, grid)\n", "equation = Equation(dev, params, grid)\n", "\n", " prob = FourierFlows.Problem(equation, stepper, dt, grid, vars, params, dev)\n", "nothing #hide" ], "metadata": {}, "execution_count": 12 }, { "cell_type": "markdown", "source": [ "## Setting initial conditions" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "For initial condition we take the fluid at rest (``u = v = 0``). The free surface elevation\n", "is perturbed from its rest position (``\\eta=0``); the disturbance we impose a Gaussian\n", "bump with half-width greater than the deformation radius and on top of that we\n", "superimpose some random noise with scales smaller than the deformation radius.\n", "We mask the small-scale perturbations so that it only applies in the central part\n", "of the domain by applying\n", "\n", "The system develops geostrophically-balanced jets around the Gaussian bump,\n", "while the smaller-scale noise propagates away as inertia-gravity waves." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "First let's construct the Gaussian bump." ], "metadata": {} }, { "outputs": [ { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=1}", "image/png": "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", "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "execution_count": 13 } ], "cell_type": "code", "source": [ "gaussian_width = 6e3\n", "gaussian_amplitude = 3.0\n", "gaussian_bump = @. gaussian_amplitude * exp( - grid.x^2 / (2*gaussian_width^2) )\n", "\n", "plot(grid.x/1e3, gaussian_bump, # divide with 1e3 to convert m -> km\n", " color = :black,\n", " legend = false,\n", " linewidth = 2,\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3),\n", " xlabel = \"x [km]\",\n", " ylabel = \"η [m]\",\n", " title = \"A gaussian bump with half-width ≈ \"*string(gaussian_width/1e3)*\" km\",\n", " size = (600, 260))" ], "metadata": {}, "execution_count": 13 }, { "cell_type": "markdown", "source": [ "Next the noisy perturbation. The `mask` is simply a product of hyperbolic tangent functions." ], "metadata": {} }, { "outputs": [ { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=2}", "image/png": "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", "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "execution_count": 14 } ], "cell_type": "code", "source": [ "mask = @. 1/4 * (1 + tanh( -(grid.x - 100e3) / 10e3)) * (1 + tanh( (grid.x + 100e3) / 10e3))\n", "\n", "noise_amplitude = 0.1 # the amplitude of the noise for η(x,t=0) (m)\n", "η_noise = noise_amplitude * Random.randn(size(grid.x))\n", "@. η_noise *= mask # mask the noise\n", "\n", "plot_noise = plot(grid.x/1e3, η_noise, # divide with 1e3 to convert m -> km\n", " color = :black,\n", " legend = :false,\n", " linewidth = [3 2],\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3), # divide with 1e3 to convert m -> km\n", " ylims = (-0.3, 0.3),\n", " xlabel = \"x [km]\",\n", " ylabel = \"η [m]\")\n", "\n", "plot_mask = plot(grid.x/1e3, mask, # divide with 1e3 to convert m -> km\n", " color = :gray,\n", " legend = :false,\n", " linewidth = [3 2],\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3), # divide with 1e3 to convert m -> km\n", " xlabel = \"x [km]\",\n", " ylabel = \"mask\")\n", "\n", "title = plot(title = \"Small-scale noise\",\n", " grid = false,\n", " showaxis = false,\n", " xticks = [],\n", " yticks = [],\n", " bottom_margin = -20Plots.px)\n", "\n", "plot(title, plot_noise, plot_mask,\n", " layout = @layout([A{0.01h}; [B; C]]),\n", " size = (600, 400))" ], "metadata": {}, "execution_count": 14 }, { "cell_type": "markdown", "source": [ "Sum the Gaussian bump and the noise and then call `set_uvη!()` to set the initial condition to the problem `prob`." ], "metadata": {} }, { "outputs": [ { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=1}", "image/png": "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", "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "execution_count": 15 } ], "cell_type": "code", "source": [ "η0 = @. gaussian_bump + η_noise\n", "u0 = zeros(grid.nx)\n", "v0 = zeros(grid.nx)\n", "\n", "set_uvη!(prob, u0, v0, η0)\n", "\n", "plot(grid.x/1e3, η0, # divide with 1e3 to convert m -> km\n", " color = :black,\n", " legend = false,\n", " linewidth = 2,\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3),\n", " xlabel = \"x [km]\",\n", " ylabel = \"η [m]\",\n", " title = \"initial surface elevation, η(x, t=0)\",\n", " size = (600, 260))" ], "metadata": {}, "execution_count": 15 }, { "cell_type": "markdown", "source": [ "## Visualizing the simulation" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "We define a function that plots the surface elevation ``\\eta`` and the\n", "depth-integrated velocities ``u`` and ``v``." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "function plot_output(prob)\n", " plot_η = plot(grid.x/1e3, vars.η, # divide with 1e3 to convert m -> km\n", " color = :blue,\n", " legend = false,\n", " linewidth = 2,\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3), # divide with 1e3 to convert m -> km\n", " xlabel = \"x [km]\",\n", " ylabel = \"η [m]\")\n", "\n", " plot_u = plot(grid.x/1e3, vars.u, # divide with 1e3 to convert m -> km\n", " color = :red,\n", " legend = false,\n", " linewidth = 2,\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3), # divide with 1e3 to convert m -> km\n", " ylims = (-0.3, 0.3),\n", " xlabel = \"x [km]\",\n", " ylabel = \"u [m s⁻¹]\")\n", "\n", " plot_v = plot(grid.x/1e3, vars.v, # divide with 1e3 to convert m -> km\n", " color = :green,\n", " legend = false,\n", " linewidth = 2,\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3), # divide with 1e3 to convert m -> km\n", " ylims = (-0.3, 0.3),\n", " xlabel = \"x [km]\",\n", " ylabel = \"v [m s⁻¹]\")\n", "\n", " Ld = @sprintf \"%.2f\" sqrt(g*H)/f /1e3 # divide with 1e3 to convert m -> km\n", " plottitle = \"Deformation radius √(gh) / f = \"*string(Ld)*\" km\"\n", "\n", " title = plot(title = plottitle,\n", " grid = false,\n", " showaxis = false,\n", " xticks = [],\n", " yticks = [],\n", " bottom_margin = -30Plots.px)\n", "\n", " return plot(title, plot_η, plot_u, plot_v,\n", " layout = @layout([A{0.01h}; [B; C; D]]),\n", " size = (600, 800))\n", "end\n", "nothing # hide" ], "metadata": {}, "execution_count": 16 }, { "cell_type": "markdown", "source": [ "## Time-stepping the `Problem` forward" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "We time-step the `Problem` forward in time. We update variables by calling\n", "`updatevars!()` and we also update the plot. We enclose the `for` loop in\n", "an `@animate` macro to produce an animation of the solution." ], "metadata": {} }, { "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "┌ Info: Saved animation to \n", "└ fn = \"/home/runner/work/FourierFlows.jl/FourierFlows.jl/docs/src/literated/onedshallowwater.mp4\"\n" ] }, { "output_type": "execute_result", "data": { "text/plain": "Plots.AnimatedGif(\"/home/runner/work/FourierFlows.jl/FourierFlows.jl/docs/src/literated/onedshallowwater.mp4\")", "text/html": [ "" ] }, "metadata": {}, "execution_count": 17 } ], "cell_type": "code", "source": [ "p = plot_output(prob)\n", "\n", "anim = @animate for j = 0:nsteps\n", " updatevars!(prob)\n", "\n", " p[2][1][:y] = vars.η # updates the plot for η\n", " p[2][:title] = \"t = \" * @sprintf(\"%.1f\", prob.clock.t/60) * \" min\" # updates time in the title\n", " p[3][1][:y] = vars.u # updates the plot for u\n", " p[4][1][:y] = vars.v # updates the plot for v\n", "\n", " stepforward!(prob)\n", "end\n", "\n", "mp4(anim, \"onedshallowwater.mp4\", fps=18)" ], "metadata": {}, "execution_count": 17 }, { "cell_type": "markdown", "source": [ "## Geostrophic balance" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "It is instructive to compare the solution for ``v`` with its geostrophically balanced approximation, ``f \\widehat{\\bm{z}} \\times \\bm{u}_{\\rm geostrophic} = - g \\bm{\\nabla} \\eta``, i.e.,\n", "\n", "$$\n", "\\begin{aligned}\n", "v_{\\rm geostrophic} & = \\frac{g}{f} \\frac{\\partial \\eta}{\\partial x} \\ , \\\\\n", "u_{\\rm geostrophic} & = - \\frac{g}{f} \\frac{\\partial \\eta}{\\partial y} = 0 \\ .\n", "\\end{aligned}\n", "$$\n", "The geostrophic solution should capture well the the behavior of the flow in\n", "the center of the domain, after small-scale disturbances propagate away." ], "metadata": {} }, { "outputs": [ { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=4}", "image/png": "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", "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "execution_count": 18 } ], "cell_type": "code", "source": [ "u_geostrophic = zeros(grid.nx) # -g/f ∂η/∂y = 0\n", "v_geostrophic = params.g / params.f * irfft(im * grid.kr .* vars.ηh, grid.nx) #g/f ∂η/∂x\n", "\n", "plot_u = plot(grid.x/1e3, [vars.u u_geostrophic], # divide with 1e3 to convert m -> km\n", " color = [:red :purple],\n", " labels = [\"u\" \"- g/f ∂η/∂y\"],\n", " linewidth = [3 2],\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3), # divide with 1e3 to convert m -> km\n", " ylims = (-0.3, 0.3),\n", " xlabel = \"x [km]\",\n", " ylabel = \"u [m s⁻¹]\")\n", "\n", "plot_v = plot(grid.x/1e3, [vars.v v_geostrophic], # divide with 1e3 to convert m -> km\n", " color = [:green :purple],\n", " labels = [\"v\" \"g/f ∂η/∂x\"],\n", " linewidth = [3 2],\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3), # divide with 1e3 to convert m -> km\n", " ylims = (-0.3, 0.3),\n", " xlabel = \"x [km]\",\n", " ylabel = \"v [m s⁻¹]\")\n", "\n", "title = plot(title = \"Geostrophic balance\",\n", " grid = false,\n", " showaxis = false,\n", " xticks = [],\n", " yticks = [],\n", " bottom_margin = -20Plots.px)\n", "\n", "plot(title, plot_u, plot_v,\n", " layout = @layout([A{0.01h}; [B; C]]),\n", " size = (600, 400))" ], "metadata": {}, "execution_count": 18 }, { "cell_type": "markdown", "source": [ "---\n", "\n", "*This notebook was generated using [Literate.jl](https://github.com/fredrikekre/Literate.jl).*" ], "metadata": {} } ], "nbformat_minor": 3, "metadata": { "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "1.6.4" }, "kernelspec": { "name": "julia-1.6", "display_name": "Julia 1.6.4", "language": "julia" } }, "nbformat": 4 }