From ffb0acfb5780b29d26c19570d6d63459da6a3e8b Mon Sep 17 00:00:00 2001 From: Romain Date: Tue, 4 Apr 2023 12:11:11 +0200 Subject: [PATCH 1/4] update nemo example --- 04_nemo_idealized.ipynb | 3034 ++++++++++++++++++++++++++++++++------- 1 file changed, 2492 insertions(+), 542 deletions(-) diff --git a/04_nemo_idealized.ipynb b/04_nemo_idealized.ipynb index 34773a8..0a3350c 100644 --- a/04_nemo_idealized.ipynb +++ b/04_nemo_idealized.ipynb @@ -6,7 +6,7 @@ "source": [ "# NEMO Example \n", "\n", - "For this example, the NEMO output files have already been saved as netCDF with the right coordinate names. The [xorca](https://github.com/willirath/xorca) package is designed to open NEMO datasets so they are understandable by xgcm. The [xnemogcm](https://github.com/rcaneill/xnemogcm) does a similar work on idealized configurations.\n", + "For this example, the NEMO output files have already been saved as netCDF with the right coordinate names. The [xnemogcm](https://github.com/rcaneill/xnemogcm) package is designed to open NEMO datasets so they are understandable by xgcm.\n", "\n", "Below are some example of how to make calculations using xgcm.\n", "\n", @@ -23,307 +23,1909 @@ "import numpy as np\n", "import xgcm\n", "from matplotlib import pyplot as plt\n", + "\n", + "xr.set_options(display_expand_attrs=False, display_expand_data=False)\n", + "\n", "%matplotlib inline\n", - "plt.rcParams['figure.figsize'] = (6,10)" + "plt.rcParams['figure.figsize'] = (4,5)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'0.8.1'" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xgcm.__version__" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we open the NEMO example dataset, from the BASIN configuration.\n", + "\n", + "We get a dataset produced for the purpose of this documentation, as the time average of the reference run of the paper \n", + "The Polar Transition from Alpha to Beta Regions Set by a Surface Buoyancy Flux Inversion, [Caneill et al 2022, JPO](https://doi.org/10.1175/JPO-D-21-0295.1)\n", + "\n", + "\n", + "Link to the dataset: [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7795560.svg)](https://doi.org/10.5281/zenodo.7795560)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:        (z_c: 36, axis_nbounds: 2, y_c: 79, x_c: 42, x_f: 42,\n",
+       "                    y_f: 79, z_f: 36)\n",
+       "Coordinates: (12/18)\n",
+       "  * z_c            (z_c) int64 0 1 2 3 4 5 6 7 8 ... 27 28 29 30 31 32 33 34 35\n",
+       "  * x_c            (x_c) int64 0 1 2 3 4 5 6 7 8 ... 33 34 35 36 37 38 39 40 41\n",
+       "  * y_c            (y_c) int64 0 1 2 3 4 5 6 7 8 ... 70 71 72 73 74 75 76 77 78\n",
+       "    gdept_1d       (z_c) float64 ...\n",
+       "  * x_f            (x_f) float64 0.5 1.5 2.5 3.5 4.5 ... 38.5 39.5 40.5 41.5\n",
+       "  * y_f            (y_f) float64 0.5 1.5 2.5 3.5 4.5 ... 75.5 76.5 77.5 78.5\n",
+       "    ...             ...\n",
+       "    gphit          (y_c, x_c) float64 ...\n",
+       "    gphiu          (y_c, x_f) float64 ...\n",
+       "    gphiv          (y_f, x_c) float64 ...\n",
+       "    gphif          (y_f, x_f) float64 ...\n",
+       "    gdept_0        (z_c, y_c, x_c) float64 ...\n",
+       "    gdepw_0        (z_f, y_c, x_c) float64 ...\n",
+       "Dimensions without coordinates: axis_nbounds\n",
+       "Data variables: (12/46)\n",
+       "    deptht_bounds  (z_c, axis_nbounds) float32 ...\n",
+       "    e3t            (z_c, y_c, x_c) float32 ...\n",
+       "    thetao         (z_c, y_c, x_c) float32 ...\n",
+       "    so             (z_c, y_c, x_c) float32 ...\n",
+       "    tos            (y_c, x_c) float32 ...\n",
+       "    zos            (y_c, x_c) float32 ...\n",
+       "    ...             ...\n",
+       "    hv_0           (y_f, x_c) float64 ...\n",
+       "    tmask          (z_c, y_c, x_c) int8 ...\n",
+       "    umask          (z_c, y_c, x_f) int8 ...\n",
+       "    vmask          (z_c, y_f, x_c) int8 ...\n",
+       "    fmask          (z_c, y_f, x_f) int8 ...\n",
+       "    mbathy         (y_c, x_c) int32 ...
" + ], + "text/plain": [ + "\n", + "Dimensions: (z_c: 36, axis_nbounds: 2, y_c: 79, x_c: 42, x_f: 42,\n", + " y_f: 79, z_f: 36)\n", + "Coordinates: (12/18)\n", + " * z_c (z_c) int64 0 1 2 3 4 5 6 7 8 ... 27 28 29 30 31 32 33 34 35\n", + " * x_c (x_c) int64 0 1 2 3 4 5 6 7 8 ... 33 34 35 36 37 38 39 40 41\n", + " * y_c (y_c) int64 0 1 2 3 4 5 6 7 8 ... 70 71 72 73 74 75 76 77 78\n", + " gdept_1d (z_c) float64 ...\n", + " * x_f (x_f) float64 0.5 1.5 2.5 3.5 4.5 ... 38.5 39.5 40.5 41.5\n", + " * y_f (y_f) float64 0.5 1.5 2.5 3.5 4.5 ... 75.5 76.5 77.5 78.5\n", + " ... ...\n", + " gphit (y_c, x_c) float64 ...\n", + " gphiu (y_c, x_f) float64 ...\n", + " gphiv (y_f, x_c) float64 ...\n", + " gphif (y_f, x_f) float64 ...\n", + " gdept_0 (z_c, y_c, x_c) float64 ...\n", + " gdepw_0 (z_f, y_c, x_c) float64 ...\n", + "Dimensions without coordinates: axis_nbounds\n", + "Data variables: (12/46)\n", + " deptht_bounds (z_c, axis_nbounds) float32 ...\n", + " e3t (z_c, y_c, x_c) float32 ...\n", + " thetao (z_c, y_c, x_c) float32 ...\n", + " so (z_c, y_c, x_c) float32 ...\n", + " tos (y_c, x_c) float32 ...\n", + " zos (y_c, x_c) float32 ...\n", + " ... ...\n", + " hv_0 (y_f, x_c) float64 ...\n", + " tmask (z_c, y_c, x_c) int8 ...\n", + " umask (z_c, y_c, x_f) int8 ...\n", + " vmask (z_c, y_f, x_c) int8 ...\n", + " fmask (z_c, y_f, x_f) int8 ...\n", + " mbathy (y_c, x_c) int32 ..." + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# download the data\n", + "import urllib.request\n", + "import shutil\n", + "from pathlib import Path\n", + "\n", + "url = 'https://zenodo.org/record/7795560/files/nemo_dataset.nc'\n", + "name = 'nemo_dataset.nc'\n", + "path = Path('nemo_idealized_data/')\n", + "path.mkdir(parents=True, exist_ok=True)\n", + "\n", + "with urllib.request.urlopen(url) as response, open(path/name, 'wb') as out_file:\n", + " shutil.copyfileobj(response, out_file)\n", + "\n", + "# open the data\n", + "ds = xr.open_dataset(path/name)\n", + "\n", + "for i in ds:\n", + " if i[0] == 'g':\n", + " ds.coords[i] = ds[i] \n", + " \n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# In this configuration, the model is symmetric at the equator. For simplicity, we remove the southern bondaries for thi example:\n", + "ds['tmask'] = ds.tmask.where(ds.y_c > 0, 0)\n", + "ds['umask'] = ds.umask.where(ds.y_c > 0, 0)\n", + "ds['vmask'] = ds.vmask.where(ds.y_f > 0, 0)\n", + "ds['fmask'] = ds.fmask.where(ds.y_f > 0, 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "In the coordinates, the *_c* suffix means *center* while the *_f* suffix means *face*. Thus the (x_c, y_c, z_c) point is the T point, the (x_c, y_f, z_c) is the V point, etc." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Geometry of the basin\n", + "The geometry of the simulation is a closed basin, with a bottom bathymetry, going from 2000 m at the coasts, to 4000 m in the interior of the basin. Terrain following coordinates are used and the free surface is linear (fixed vertical levels).\n", + "A 2 degrees Mercator grid is used." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ds.ht_0.where(ds.tmask.isel(z_c=0)).plot.contourf(x='glamt', y='gphit', vmin=2000, vmax=4000, levels=21)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creating the grid object\n", + "\n", + "Next we create a `Grid` object from the dataset.\n", + "All the axes are here non-periodic.\n", + "The `metrics` dict contains the scale factors." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Y Axis (not periodic, boundary=None):\n", + " * center y_c --> right\n", + " * right y_f --> center\n", + "Z Axis (not periodic, boundary=None):\n", + " * center z_c --> left\n", + " * left z_f --> center\n", + "X Axis (not periodic, boundary=None):\n", + " * center x_c --> right\n", + " * right x_f --> center\n" + ] + } + ], + "source": [ + "\n", + "metrics = {\n", + " ('X',): ['e1t', 'e1u', 'e1v', 'e1f'], # X distances\n", + " ('Y',): ['e2t', 'e2u', 'e2v', 'e2f'], # Y distances\n", + " ('Z',): ['e3t', 'e3u', 'e3v', 'e3w'], # Z distances\n", + "}\n", + "grid = xgcm.Grid(ds, metrics=metrics, periodic=False)\n", + "print(grid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that xgcm identified for different axes: X (longitude), Y (latitude), Z (depth). There is no time, as the dataset we use has been already time averaged." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Computation examples\n", + "### Horizontal gradient of SST\n", + "\n", + "We will compute the horizontal component of the gradient of SST in the longitude\n", + "direction as a first example to understand the logic behind the\n", + "xgcm grids.\n", + "\n", + "We want to compute\n", + "$\\frac{\\partial SST}{\\partial x}$.\n", + "The SST is the variable `tos` (Temperature Ocean Surface) in our dataset.\n", + "\n", + "In discrete form, using the NEMO notation, the derivative becomes [1]\n", + "\n", + "$$\\frac{\\partial SST}{\\partial x} = \\frac{1}{e_{1u}} \\delta_{i+1/2} SST\n", + "= \\frac{1}{e_{1u}} (SST_{i+1} - SST_i) \\ .$$\n", + "\n", + "The last T point is an earth point here, such as the 2 last U points: we set up the\n", + "`boundary` argument to 'fill' and the fill value to zero (this value does not play an important role here, as we fill earth points).\n", + "\n", + "The gradient is first computed with the `diff` function and\n", + "then with the `derivative` function, the result is the same as the `derivative`\n", + "function is aware of which scale factor to use.\n", + "\n", + "
\n", + "[1] NEMO book v4.0.1, pp 22" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coordinates:\n", + " * y_c (y_c) int64 0 1 2 3 4 5 6 7 8 9 ... 69 70 71 72 73 74 75 76 77 78\n", + " * x_f (x_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 37.5 38.5 39.5 40.5 41.5\n" + ] + } + ], + "source": [ + "sst = ds.tos\n", + "\n", + "grad_T_lon0 = grid.diff(sst, axis='X', boundary='fill', fill_value=0) / ds.e1u\n", + "grad_T_lon1 = grid.derivative(sst, axis='X', boundary='fill', fill_value=0)\n", + "print(grad_T_lon1.coords)\n", + "\n", + "assert np.allclose(grad_T_lon0, grad_T_lon1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As expected the result of the 2 operations is the same.\n", + "The position of the derivative is now on the U point." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Divergence Calculation\n", + "\n", + "Here we show how to calculate the divergence of the flow.\n", + "The precise details of how to do this calculation are highly model- and configuration-dependent (e.g. free-surface vs. rigid lid, etc.)\n", + "In this example, the flow is incompressible, without precipitations\n", + "or evaporation, with a linear free surface, satisfying the continuity equation\n", + "\n", + "$$ \\vec{\\nabla} \\cdot \\vec{u} = \n", + " \\frac{\\partial u}{\\partial x} + \\frac{\\partial v}{\\partial y}\n", + " + \\frac{\\partial w}{\\partial z} = 0 \\ .$$\n", + " \n", + "In non-linear free surface, the divergence of $\\vec{u}$ is not 0 anymore, it is linked to\n", + "the time variation of the $e_{3}$ scale factors.\n", + "\n", + "In discrete form, using NEMO notation, the equation becomes [1]\n", + "\n", + "$$ \\vec{\\nabla} \\cdot \\vec{u} = \\frac{1}{e_{1t}e_{2t}e_{3t}} \\left[\n", + " \\delta_i(u \\cdot e_{2u} \\cdot e_{3u})\n", + " + \\delta_j(v \\cdot e_{1v} \\cdot e_{3v}) \\right]\n", + " + \\frac{1}{e_{3t}} \\delta_k(w) \\ .$$\n", + "\n", + "The equation for the divergence calculation could be simplified due to the geometry of our basin, but we will keep it in the general form.\n", + "\n", + "
\n", + "[1] NEMO book v4.0.1, pp 22" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3d flow\n", + "\n", + "The first T point along x is an earth point, we can use a 'fill' `boundary` with a 0 `fill_value`. The same argument applies along y and z.\n", + "\n", + "⚠ We need to use a negative sign for the vertical derivative, as the k-axis increases with depth.\n", + "\n", + "⚠ If the model is ran without linear free surface the e3 scale factors are not constant in time, we need to take the e3t and not e3t_0 (and similar for e3u, e3v, e3f). The data are are \"thickness weighted\"." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray ()>\n",
+       "6.281e-11
" + ], + "text/plain": [ + "\n", + "6.281e-11" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bd={'boundary':'fill', 'fill_value':0}\n", + "\n", + "div_uv = (\n", + " grid.diff(ds.uo * ds.e2u * ds.e3u, 'X', **bd) / (ds.e1t * ds.e2t * ds.e3t)\n", + " + grid.diff(ds.vo * ds.e1v * ds.e3v, 'Y', **bd) / (ds.e1t * ds.e2t * ds.e3t)\n", + ").where(ds.tmask)\n", + "\n", + "div_w = - grid.diff(ds.woce, 'Z', **bd) / ds.e3t\n", + "\n", + "div_uvw = div_uv + div_w\n", + "np.abs(div_uvw).max()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As expected the divergence of the flow is zero (if we neglect the truncation error)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Vertical velocity\n", + "\n", + "In NEMO the vertical velocity is computed from the divergence of the horizontal velocity.\n", + "In non-linear free surface, the vertical velocity can't be computed offline because it also takes the time\n", + "variations of the vertical scale factors into account.\n", + "However, we are using here a linear free surface, so that\n", + "\n", + "$$\n", + "w(z) = \\int_{bottom}^z \\vec{\\nabla}_h \\cdot \\vec{u} \\, \\text{d}z' \n", + "= \\int_{surf}^z \\vec{\\nabla}_h \\cdot \\vec{u} \\, \\text{d}z' - \\int_{surf}^{bottom} \\vec{\\nabla}_h \\cdot \\vec{u} \\, \\text{d}z' \\ .\n", + "$$\n", + "\n", + "This is written in discrete form\n", + "\n", + "$$\n", + "w(n) = \\sum_0^n \\left(\\vec{\\nabla}_h \\cdot \\vec{u}(k)\\right) e_{3t}(k)\n", + "- \\sum_0^{n_{bot}} \\left(\\vec{\\nabla}_h \\cdot \\vec{u}(k)\\right) e_{3t}(k) \\ .\n", + "$$\n", + "\n", + "We use the `grid.cumint` to perform the integration, and then we remove the total integral." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "w = grid.cumint((div_uv), axis='Z', boundary='fill', fill_value=0) # integral from top\n", + "w = w - w.isel({'z_f':-1}) # now from bot" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now compare the computed vertical velocity with the one outputed by the model, at the bottom of the uper grid cell." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 2, figsize=(9,5))\n", + "ds.woce.where(ds.tmask.isel(z_c=0)).isel({'z_f':1}).plot(ax=ax[0], x='glamt', y='gphit')\n", + "w.where(ds.tmask.isel(z_c=0)).isel({'z_f':1}).plot(ax=ax[1], x='glamt', y='gphit')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The 2 fields look similar, which is confirmed by computing the difference." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray ()>\n",
+       "4.189e-09\n",
+       "Coordinates:\n",
+       "    z_c       int64 0\n",
+       "    gdept_1d  float64 5.0
" + ], + "text/plain": [ + "\n", + "4.189e-09\n", + "Coordinates:\n", + " z_c int64 0\n", + " gdept_1d float64 5.0" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "abs((w - ds.woce).where(ds.tmask.isel(z_c=0))).max().compute()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Vorticity\n", + "Here we compute more derived quantities from the velocity field.\n", + "\n", + "The vertical component of the vorticity is a fundamental quantity of interest in ocean circulation theory. It is defined as\n", + "\n", + "$$ \\zeta = \\frac{\\partial v}{\\partial x} - \\frac{\\partial u}{\\partial y} \\ . $$\n", + "\n", + "The NEMO discretization is [1]\n", + "\n", + "$$\n", + "\\zeta = \\frac{1}{e_{1f} e_{2f}} \\left[\\delta_{i+1/2}(v \\cdot e_{2v}) - \\delta_{j+1/2}(u \\cdot e_{1u}) \\right] \n", + "$$\n", + "\n", + "
\n", + "[1] NEMO book v4.0.1, pp 22\n", + "
\n", + "\n", + "In xgcm, we calculate this quantity as" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('y_f', 'x_f', 'z_c')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "zeta = 1/(ds.e1f*ds.e2f) * (grid.diff(ds.vo*ds.e2v, 'X', **bd) - grid.diff(ds.uo*ds.e1u, 'Y', **bd)) * ds.fmask\n", + "zeta.dims" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now we open the NEMO example dataset, from the BASIN configuration. The *ds* dataset contains the variables data (e.g. temperature, velocities) while the *domcfg* dataset contains the grid data (position, scale factor, etc).\n", + "$\\zeta$ is located in the F point (*x_f*, *y_f*, *z_c*).\n", "\n", - "We get a dataset produced for the purpose of this documentation \n", - "[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3736803.svg)](https://doi.org/10.5281/zenodo.3736803).\n", - "In this dataset, we have not outputed the vertical scale factors in the *file_def_nemo-oce.xml* to save space. In a real case, the scale factors need to be saved to use properly the \"thickness weighted\" variables. The *domcfg* dataset has also been filtered to remove many unused variables in this notebook (e.g. *umask*)." + "We want to plot the vertical integral of this quantity, i.e. the barotropic vorticity, but before we need to have an estimate of `e3f`:" ] }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, + "execution_count": 13, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ - "# download the data\n", - "import urllib.request\n", - "import shutil\n", - "\n", - "url = 'https://zenodo.org/record/3736803/files/'\n", - "file_name_domcfg = 'xnemogcm.domcfg.nc'\n", - "with urllib.request.urlopen(url + file_name_domcfg) as response, open(file_name_domcfg, 'wb') as out_file:\n", - " shutil.copyfileobj(response, out_file)\n", - "file_name_basin = 'xnemogcm.nemo.nc'\n", - "with urllib.request.urlopen(url + file_name_basin) as response, open(file_name_basin, 'wb') as out_file:\n", - " shutil.copyfileobj(response, out_file)\n", - " \n", - "# open the data\n", - "domcfg = xr.open_dataset(file_name_domcfg)\n", - "ds = xr.open_dataset(file_name_basin)" + "ds['e3f'] = grid.interp(ds.e3u, 'Y', boundary='extend')" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 14, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaMAAAHACAYAAAAP9QcAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABaC0lEQVR4nO39fVxUZeI//r9guFNgQFQYUFTMG2C9oVBxsu1OEldstWg/6vJezUh+tYOpmKb9DKw01DKNUunGFdvVtdhd20LFJbwrRcRRK++w0gLEAV2EAYy7Yb5/uJwYGG5mmGFuzuv5eMyjPOeaM9cZZs5rrutc51wOWq1WCyIiIgtytHQFiIiIGEZERGRxDCMiIrI4hhEREVkcw4iIiCyOYURERBbHMCIiIotjGBERkcU5WboC5tbU1ISSkhJ4enrCwcHB0tUhIhPSarWoqqpCQEAAHB0N/21dW1uL+vp6k9XHxcUFbm5uJtuemNh9GJWUlCAwMNDS1SAiMyoqKsLAgQMNek5tbS369vLAHWhMVg+pVAp/f384OjpCoVBAoVCYbNv2zu7DyNPTEwDw7aUrwv8TkX2oqqrCmJARRn236+vrcQcaxGIAXExwxqIeTdilvo6ioiJIpdJub09sLB5G169fx0svvYQDBw7gzp07GDZsGHbs2IFx48YBuNsMT05OxocffoiKigpMmjQJ27Ztw/Dhw7u0/eauOU9PT3i2+IB4aqpNvzNEZBJVEg+DynenC94FjiYJI+oei/4Fbt++jUmTJsHZ2RkHDhzAxYsXsXHjRvTp00cos2HDBqSmpiItLQ15eXlwd3dHVFQUamtrjXpNT001g4jIyvF7Kj4WbRmtX78egYGB2LFjh7AsKChI+H+tVovNmzdj1apVmDFjBgDg448/hp+fHz777DPMnj27y6/loamBp4a/fkiX5HaxpasgCpo+hp3PadYcSIa2lMj2WDSMPv/8c0RFReEPf/gDjh49igEDBuDPf/4zFixYAAC4du0aVCoVIiMjhed4eXkhIiICubm5esOorq4OdXV1wr/VarX5d0RkeADvGZriK5auQrskA0cYVr6Dz0xXgspTU81AsnMWDaOrV69i27ZtSExMxMsvv4z8/Hy88MILcHFxwbx586BSqQAAfn5+Os/z8/MT1rWWkpKCV1991ex1tzUMEMuz5nAxlKb4isGB1B7J7WKjW05kPywaRk1NTRg3bhzeeOMNAMC9996L8+fPIy0tDfPmzTNqmytXrkRiYqLwb7VabRdDuxkm1sWegsVYDCQyJYuGkb+/P0JDQ3WWhYSE4J///CcAQCaTAQBKS0vh7+8vlCktLUVYWJjebbq6usLV1dU8FTYCQ8R6MVC6j4FEpmLRM/qTJk1CQUGBzrIrV65g8ODBAO4OZpDJZMjJyRHWq9Vq5OXlQS6X92hdu0Jyu7jNg6wTg8g68TsjXhZtGS1ZsgT3338/3njjDfy///f/cOrUKXzwwQf44IMPANy9dmDx4sVYs2YNhg8fjqCgILzyyisICAjAzJkzLVl1Ab88tqn1r3mGk+FM1SJqs122kETJomE0fvx47N27FytXrsRrr72GoKAgbN68GbGxsUKZ5cuXo6amBvHx8aioqMADDzyArKwsi97/iQFkf9o7sDKkdJkrgIgctFqt1tKVMCe1Wg0vLy/c/PkHSKXdvx0Qg4has9fAsmTw6GsZ6RvaXaVWI2igPyorKw2+BU/zsWE+Ak12O6AdKDKqLmQFtwOyFQwhag9bC6bHrjrxYRh1giFERGR+vD9OBxhEREQ9g2GkB4dlE1kev4Piwm66Fmzlw98Tfem28l7YA1s5N8LPhOlt2bIFb775JlQqFcaOHYt3330XEyZMaLd8RkYGXnnlFfz0008YPnw41q9fj2nTpgnruzLlztq1a7Fv3z6cO3cOLi4uqKio0HmNb775BuvWrcPXX3+NW7duYciQIXjuueewaNEik+9/SwwjWO+XzJIHKVs5QFLP6ewzYa3fI2v1ySefIDExEWlpaYiIiMDmzZsRFRWFgoIC+Pr6til/4sQJzJkzBykpKZg+fTp2796NmTNn4syZMxg1ahSAX6fc2blzp3BdZlRUFC5evChcDlNfX48//OEPkMvl2L59e5vXUSqV8PX1xd/+9jcEBgbixIkTiI+Ph0QiQUJCgtneD9EP7bamLxADgGydqb9PLb8T9ja0OyIiAuPHj8d7770H4O69OgMDA7Fw4UKsWLGiTflZs2ahpqYGmZmZwrKJEyciLCwMaWlp0Gq1CAgIwNKlS/Hiiy8CACorK+Hn54f09PQ2sxykp6dj8eLFbVpG+igUCly6dAmHDh3qtKyxRHvOyJrOC2n6DGQQkV3g5/huyLV8tJzSpll9fT2USqXO9DiOjo6IjIxEbm6u3u3m5ubqlAeAqKgooXxnU+50R2VlJXx8fLq1jc6wm87C+OUle6PpM9DoH3qmvPFqV4V4uqCXg6Tb2/lFqwGq0GaWgOTkZKxevVpn2a1bt6DRaPROj3P58mW921epVB1Op2PMlDtdceLECXzyySfYt2+f0dvoCoaRhTCEyJ4ZE0jNd7KwRCCZUlFRkU43nTXNImCo8+fPY8aMGUhOTsaUKVPM+lqi7aazJAYRkf2SSqU6D31h1K9fP0gkEpSWluosLy0tFabOaU0mk3VYvuWUO13dZkcuXryIyZMnIz4+HqtWrTL4+YZiGPUwBhGJhSk+69ZyXtfUXFxcEB4erjM9TlNTE3JyctqdHkcul+uUB4Ds7GyhvCmn3Llw4QIeeeQRzJs3D2vXrjXoucZiN10PYhCRPvpGiQGAp6a6h2tCPSkxMRHz5s3DuHHjMGHCBGzevBk1NTWYP38+AGDu3LkYMGAAUlJSAACLFi3CQw89hI0bNyI6Ohp79uzB6dOnDZ5yp7CwEOXl5SgsLIRGo8G5c+cAAMOGDYOHhwfOnz+PRx99FFFRUUhMTBTON0kkEvTv399s7wfDqIcwiOxHe+Fhidex9sDqzmAGezdr1izcvHkTSUlJUKlUCAsLQ1ZWljAAobCwEI6Ov3Ze3X///di9ezdWrVqFl19+GcOHD8dnn30mXGMEdG3KnaSkJOzcuVP497333gsAOHz4MB5++GH84x//wM2bN/G3v/0Nf/vb34RygwcPxk8//WSut0O81xn19BeEYWSdeipYeoK1BlNXv2stp+JoOYCh+btjruuMNnjeY7LRdMurfuQUEkZiy6gHMIjMx57CpLtavhfWFExsHVFXMIzIohgm5tH8vlpTKBmDP+TEg2FEPYKhI27NodJRC0kycITNX2NExmMYmZnYftkxdKgj7LKj9jCMyCgMHetnrV10HQUSW0XiJcow4i8zwzF8bIe1hhBRR0QZRj3FHrroGEK2w5ZCiN111BrDiNpgANkWWwqhlhhI1BLDiAQMIdthqwFE1B6GEQmaD3AMJetjr+HTUevIHrq5qesYRmZiy18khpLl2Wv4ELWHYUTtan1AZDiZj5jDh+eOCGAYkQE6OmAyqDon5sAh6gzDiEyiswOtvYcVg6Z7WreObLmbm4zDMKIe0d2DtSnDjMFBZH0YRmQTGCD2z1Lnju7p7w53SffnM6rRaIAqYPz48ZBIJFAoFFAoFCaooTgwjIjIathD91x+fj4n1zOCY+dFiIiIzIthREREFscwIiIii2MYERGRxTGMiIjI4hhGRERkcQwjIiKyONGFEW/ISERkfUQXRkREZH0YRkREZHEMIyKyevZ+13fivemIyEoxgMSFYUREFsGwoZYYRkTUIxg+1BGeM2pFU3wFmuIrlq4GkV1hEFFnGEbtYCARmQaDqH1btmzBkCFD4ObmhoiICJw6darD8hkZGQgODoabmxtGjx6N/fv366zXarVISkqCv78/evXqhcjISHz//fc6ZcrLyxEbGwupVApvb2/ExcWhulp38spPP/0UYWFh6N27NwYPHow333zTNDvcAYZRC60DiIFEZLwqiQeDqAOffPIJEhMTkZycjDNnzmDs2LGIiopCWVmZ3vInTpzAnDlzEBcXh7Nnz2LmzJmYOXMmzp8/L5TZsGEDUlNTkZaWhry8PLi7uyMqKgq1tbVCmdjYWFy4cAHZ2dnIzMzEsWPHEB8fL6w/cOAAYmNj8dxzz+H8+fPYunUrNm3ahPfee898bwYAB61WqzXrK1iYWq2Gl5cXbv78A6RSzw7vwNBe+EgGjjDoNe1htkoiY/VkAFWp1Qga6I/KykqDZ1dtPjb8c+gYk007HnP12y7XJSIiAuPHjxcO8k1NTQgMDMTChQuxYsWKNuVnzZqFmpoaZGZmCssmTpyIsLAwpKWlQavVIiAgAEuXLsWLL74IAKisrISfnx/S09Mxe/ZsXLp0CaGhocjPz8e4ceMAAFlZWZg2bRqKi4sREBCAP/7xj2hoaEBGRobwOu+++y42bNiAwsJCODg4dOt9ag9bRv/TUSuILSSijjW3gtgSuhtyLR91dXVtytTX10OpVCIyMlJY5ujoiMjISOTm5urdbm5urk55AIiKihLKX7t2DSqVSqeMl5cXIiIihDK5ubnw9vYWgggAIiMj4ejoiLy8PABAXV0d3NzcdF6nV69eKC4uxs8//2zIW2EQi4bR6tWr4eDgoPMIDg4W1tfW1kKhUKBv377w8PBATEwMSktLTV4Phg2RcewhgPoH94VvaL9uP/oH9wUABAYGwsvLS3ikpKS0ec1bt25Bo9HAz89PZ7mfnx9UKpXeeqpUqg7LN/+3szK+vr46652cnODj4yOUiYqKwr/+9S/k5OSgqakJV65cwcaNGwEAN27c6PwNNZLFh3b/5je/wZdffin828np1yotWbIE+/btQ0ZGBry8vJCQkIAnn3wSx48f7/F6aoqvGNxdR2SvbD2AzKmoqEinm87V1dWCtTHcggUL8OOPP2L69OloaGiAVCrFokWLsHr1ajg6mq/9YvFuOicnJ8hkMuHRr18/AHf7Ordv3463334bjz76KMLDw7Fjxw6cOHECJ0+eNNnrs1VE1HX20BIyN6lUqvPQF0b9+vWDRCJp09NTWloKmUymd7symazD8s3/7axM6wESjY2NKC8vF8o4ODhg/fr1qK6uxs8//wyVSoUJEyYAAIYOHdql98AYFg+j77//HgEBARg6dChiY2NRWFgIAFAqlWhoaNDp/wwODsagQYPa7VMlIrIFLi4uCA8PR05OjrCsqakJOTk5kMvlep8jl8t1ygNAdna2UD4oKAgymUynjFqtRl5enlBGLpejoqICSqVSKHPo0CE0NTUhIiJCZ9sSiQQDBgyAi4sL/v73v0Mul6N///7d2/EOWLSbLiIiAunp6Rg5ciRu3LiBV199Fb/97W9x/vx5qFQquLi4wNvbW+c5HfWpAndPvrU8YahWq9sta2irqCtddRxJR/aKLSLTSkxMxLx58zBu3DhMmDABmzdvRk1NDebPnw8AmDt3LgYMGCCcc1q0aBEeeughbNy4EdHR0dizZw9Onz6NDz74AMDdFs3ixYuxZs0aDB8+HEFBQXjllVcQEBCAmTNnAgBCQkIwdepULFiwAGlpaWhoaEBCQgJmz56NgIAAAHfPZ/3jH//Aww8/jNraWuzYsQMZGRk4evSoWd8Pi4bR7373O+H/x4wZg4iICAwePBiffvopevXqZdQ2U1JS8Oqrr+pdx4n1iIzDIDK9WbNm4ebNm0hKSoJKpUJYWBiysrKEAQiFhYU652juv/9+7N69G6tWrcLLL7+M4cOH47PPPsOoUaOEMsuXL0dNTQ3i4+NRUVGBBx54AFlZWTqj43bt2oWEhARMnjwZjo6OiImJQWpqqk7ddu7ciRdffBFarRZyuRxHjhwRuurMxequMxo/fjwiIyPx2GOPYfLkybh9+7ZO62jw4MFYvHgxlixZovf5+lpGgYGBuPnzD+ijqRSWG3uuiC0jEhtrDiJTXGd0bNoj8HDu/u/y6oZGPLj/sFF1ISs4Z9RSdXU1fvzxR/j7+yM8PBzOzs46/Z8FBQUoLCxst08VuDtypfUJRCIyjjUHEdkXi3bTvfjii3j88ccxePBglJSUIDk5GRKJBHPmzIGXlxfi4uKQmJgIHx8fSKVSLFy4EHK5HBMnTrRktdvFVhERkXEsGkbFxcWYM2cO/vvf/6J///544IEHcPLkSWHExqZNm4Q+zbq6OkRFRWHr1q2WrDKRaLBVRD3JomG0Z8+eDte7ublhy5Yt2LJlSw/VyLKqJB7w1FR3XpDIzBhE1NOs6pyRmDV/+XkQIEvjZ5AsweK3A7IX3TlfxC8/WQN+DsmS2DIiIgYRWRxbRgYwx41SeRAgS+Lnj6yFKMPIWm6OygMBWQI/d2SNRBlGpmbM+SIeEKin8LNGtoBhZAE8OJC58LNFtophRGSDGDpkbxhGRFaIYUNiwzAisgBrDZvWdwCx1nqS/WEYEZmArR60O7v9VPN6W92/rvAZ6Q9PV5dub8elrh7Yf3caHIlEAoVCAYVCYYIaigPDqJsMHUlnz19qeyGWv5Eh90H01FSL5n3prvz8fE5dYwSGEYkCD6S/MvZmvAwkMieGUReZ4+4LZBo8QHYN7whP1oxhRGbBgLAepgwhto7IXBhG1G08OFkvtobIVjCMyGAMH9vAICJbwjCyQtY64ytDyDZY42eHqDMMI+oUQ8h2MIjIVjGMqF0MIdvRkyHEQQxkDpzp1UpZ8steJfHgwcaGsDVE9oAtIyvW0+eOGEC2hSFE9oRh1AX2fsErQ8j2MIjI3oiym86WwsWcXWbsjrNNDCKyR2wZ2QhTdtkxgGwTQ4jsGcOoh3VnJFLz84w5KDGAbBuDiOwdw8gGdRQsYph/RmwYRCQGojxnZAhbOr8E8DyQvWEQ2bctW7ZgyJAhcHNzQ0REBE6dOtVh+YyMDAQHB8PNzQ2jR4/G/v37ddZrtVokJSXB398fvXr1QmRkJL7//nudMuXl5YiNjYVUKoW3tzfi4uJQXV3dZjtvvfUWRowYAVdXVwwYMABr1641zU63g2FEZIU8NdUMIjv3ySefIDExEcnJyThz5gzGjh2LqKgolJWV6S1/4sQJzJkzB3FxcTh79ixmzpyJmTNn4vz580KZDRs2IDU1FWlpacjLy4O7uzuioqJQW1srlImNjcWFCxeQnZ2NzMxMHDt2DPHx8TqvtWjRInz00Ud46623cPnyZXz++eeYMGGCed6I/3HQarVas76ChanVanh5eeHmzz+gj6ZSZ52m+Eqnz++sZWToTK8Au9CoY7YQQtbyGa5SqxE00B+VlZUGz67afGw4v+SPJpl2vKquHqM27e5yXSIiIjB+/Hi89957AICmpiYEBgZi4cKFWLFiRZvys2bNQk1NDTIzM4VlEydORFhYGNLS0qDVahEQEIClS5fixRdfBABUVlbCz88P6enpmD17Ni5duoTQ0FDk5+dj3LhxAICsrCxMmzYNxcXFCAgIwKVLlzBmzBicP38eI0eO7Pb70lWiahm1Do7OgsbWuujI9tlCEFH31dfXQ6lUIjIyUljm6OiIyMhI5Obm6n1Obm6uTnkAiIqKEspfu3YNKpVKp4yXlxciIiKEMrm5ufD29haCCAAiIyPh6OiIvLw8AMAXX3yBoUOHIjMzE0FBQRgyZAieffZZlJeXm2bn2yGqMNJHMnCE3tBhEFFPYxDZB7VarfOoq6trU+bWrVvQaDTw8/PTWe7n5weVSqV3uyqVqsPyzf/trIyvr6/OeicnJ/j4+Ahlrl69ip9//hkZGRn4+OOPkZ6eDqVSiaeeeqqrb4FROJrufyQDR3Sp247IHBhEluM9chCkvVy7vR3JL3dDJzAwUGd5cnIyVq9e3e3t95SmpibU1dXh448/xogRd3+Ub9++HeHh4SgoKDBb1x3DqAVDW0PGnC8iao1BZF+Kiop0zhm5urYNun79+kEikaC0tFRneWlpKWQymd7tymSyDss3/7e0tBT+/v46ZcLCwoQyrQdINDY2ory8XHi+v78/nJychCACgJCQEABAYWGh2cJI9N10RESmJJVKdR76wsjFxQXh4eHIyckRljU1NSEnJwdyuVzvduVyuU55AMjOzhbKBwUFQSaT6ZRRq9XIy8sTysjlclRUVECpVAplDh06hKamJkRERAAAJk2ahMbGRvz4449CmStX7vYaDR482KD3whBsGRFZEFtF4pWYmIh58+Zh3LhxmDBhAjZv3oyamhrMnz8fADB37lwMGDAAKSkpAO4Ot37ooYewceNGREdHY8+ePTh9+jQ++OADAICDgwMWL16MNWvWYPjw4QgKCsIrr7yCgIAAzJw5E8DdFs7UqVOxYMECpKWloaGhAQkJCZg9ezYCAgIA3B3QcN999+GZZ57B5s2b0dTUBIVCgccee0yntWRqDCMiC7HVILKWYd22btasWbh58yaSkpKgUqkQFhaGrKwsYQBCYWEhHB1/7by6//77sXv3bqxatQovv/wyhg8fjs8++wyjRo0Syixfvhw1NTWIj49HRUUFHnjgAWRlZcHNzU0os2vXLiQkJGDy5MlwdHRETEwMUlNThfWOjo744osvsHDhQjz44INwd3fH7373O2zcuNGs74eorjOSSj0huV1ssm0be86IX2YCGEamYIrrjIrTVphkAIP6lzoMfG6dUXUhnjMisghbDSIicxFdGHEEHFkDa2pdEFkD0YWRqTDUiIhMh2FERF3GFh2ZC8OIiIgsjmHUw/jLkprxs0D0K4YRkQXZUiDZUl3J9jCMjMDBC2RKnJ2XSKRhxDAha8RAIjETZRgRWStrbSVZY53IvjCMiKyQtYYSkbkwjAzELj7qSQwkEguGEZGVYyuJxEC0YcQWDtkaS4USg5B6gtWE0bp164TJoZrV1tZCoVCgb9++8PDwQExMTJtpd7tD02egQaHU3QDjl5pMoTmU+Hkie2IVk+vl5+fj/fffx5gxY3SWL1myBPv27UNGRga8vLyQkJCAJ598EsePHzfp62v6DOx0niO2pMgatQwkTkthHNfBw+Hq3rv726m5AwAYP348JBIJFAoFFApFt7crFhYPo+rqasTGxuLDDz/EmjVrhOWVlZXYvn07du/ejUcffRQAsGPHDoSEhODkyZOYOHGiSevRXiAxhMhWVEk8GEhWID8/n5PrGcHi3XQKhQLR0dGIjIzUWa5UKtHQ0KCzPDg4GIMGDUJubm6726urq4NardZ5dFXL4DG0C4/IGpi6645dgdRTLNoy2rNnD86cOYP8/Pw261QqFVxcXODt7a2z3M/PDyqVqt1tpqSk4NVXXzW6TgwgIqKeZ7GWUVFRERYtWoRdu3bBzc3NZNtduXIlKisrhUdRUZHJtk1EROZhsTBSKpUoKyvDfffdBycnJzg5OeHo0aNITU2Fk5MT/Pz8UF9fj4qKCp3nlZaWQiaTtbtdV1dXSKVSnQcREVk3i3XTTZ48Gd99953Osvnz5yM4OBgvvfQSAgMD4ezsjJycHMTExAAACgoKUFhYCLlcbokqi0J7J8B57kB8+DennmSxMPL09MSoUaN0lrm7u6Nv377C8ri4OCQmJsLHxwdSqRQLFy6EXC43+Ug6sevKCKyWZXiQIiJTs/jQ7o5s2rQJjo6OiImJQV1dHaKiorB161ZLV8so1noAN2YocPNzrHWfiMj2WFUYHTlyROffbm5u2LJlC7Zs2WKZCtk5XpNCRNbC4tcZkWUwiOyTqf6ubPVST2MYiZCpDlgMNMvw1FQLDyJ7YVXddESkX3vBw0Aie8GWkciY+uDFg6F5sQVEYsGWkYjwoGY7LPm34vkisgSGEZEV4Q8GEivRdNNVS9xF/YuPBznrx78RiZlowqgZZ8gka8KRceK2ZcsWDBkyBG5uboiIiMCpU6c6LJ+RkYHg4GC4ublh9OjR2L9/v856rVaLpKQk+Pv7o1evXoiMjMT333+vU6a8vByxsbGQSqXw9vZGXFwcqqt//fwVFBTgkUcegZ+fH9zc3DB06FCsWrUKDQ0NpttxPUQXRs0YSGRJDCD65JNPkJiYiOTkZJw5cwZjx45FVFQUysrK9JY/ceIE5syZg7i4OJw9exYzZ87EzJkzcf78eaHMhg0bkJqairS0NOTl5cHd3R1RUVGora0VysTGxuLChQvIzs5GZmYmjh07hvj4eGG9s7Mz5s6di//85z8oKCjA5s2b8eGHHyI5Odl8bwYAB61WqzXrK1iYWq2Gl5cXrhXfgKeeO3j31AHBkuFn7n1ksHeNrYSPLf09q9RqBA30R2VlpcF36G8+Ntw8sB1SE0w7rq65g/6/i+tyXSIiIjB+/Hi89957AICmpiYEBgZi4cKFWLFiRZvys2bNQk1NDTIzM4VlEydORFhYGNLS0qDVahEQEIClS5fixRdfBHB3xmw/Pz+kp6dj9uzZuHTpEkJDQ5Gfn49x48YBALKysjBt2jQUFxcjICBAb10TExORn5+Pr776yuD3patE2zJqZktfPGvE969j7IYTn9YzTdfV1bUpU19fD6VSqTOTtaOjIyIjI9udyTo3N7fNjNhRUVFC+WvXrkGlUumU8fLyQkREhFAmNzcX3t7eQhABQGRkJBwdHZGXl6f3dX/44QdkZWXhoYce6uI7YByOpiMyMQaPbZEEDIPEs/s/qiRVd//ugYGBOsuTk5OxevVqnWW3bt2CRqOBn5+fznI/Pz9cvnxZ7/ZVKpXe8s0zXzf/t7Myvr6+OuudnJzg4+PTZgbt+++/H2fOnEFdXR3i4+Px2muv6a2XqTCMcPfXvb0eQOx1v6wN32dqVlRUpNNN5+rqasHaGO+TTz5BVVUVvvnmGyxbtgxvvfUWli9fbrbXYxj9jz0Hkrmwi44hRG11ZYbpfv36QSKRoLS0VGd5RzNZy2SyDss3/7e0tBT+/v46ZcLCwoQyrQdINDY2ory8vM3rNrfwQkNDodFoEB8fj6VLl0IikXS4b8YS/Tmjlnhwpa7geSDqLhcXF4SHhyMnJ0dY1tTUhJycnHZnspbL5TrlASA7O1soHxQUBJlMplNGrVYjLy9PKCOXy1FRUQGlUimUOXToEJqamhAREdFufZuamtDQ0ICmpibDd7aL2DKyY+Y8WIotuBk8ZGqJiYmYN28exo0bhwkTJmDz5s2oqanB/PnzAQBz587FgAEDkJKSAgBYtGgRHnroIWzcuBHR0dHYs2cPTp8+jQ8++AAA4ODggMWLF2PNmjUYPnw4goKC8MorryAgIAAzZ84EAISEhGDq1KlYsGAB0tLS0NDQgISEBMyePVsYSbdr1y44Oztj9OjRcHV1xenTp7Fy5UrMmjULzs7OZns/GEatsLuOWuJngcxl1qxZuHnzJpKSkqBSqRAWFoasrCxhAEJhYSEcHX/tvLr//vuxe/durFq1Ci+//DKGDx+Ozz77DKNGjRLKLF++HDU1NYiPj0dFRQUeeOABZGVlwc3NTSiza9cuJCQkYPLkycJM2qmpqcJ6JycnrF+/HleuXIFWq8XgwYORkJCAJUuWmPX9EP11RvqY4wBkiZYEW0bGEXsA2dLf1hTXGZV/cxRSE4ymU1dVw2fsQ0bVhXjOSC9b+jK2h0FkOJ4HIrIchhER2BoisjSGERnEXltFdBf/vmQpDKN22PKXkr/yDcP3i8jyGEZERGRxDCPqMltuLbaHrSIi68Aw6oA9HnyJ2sPPO1kSw4i6xF4PVJz5l8g6MIzsjL1csNvTxLCPHRH7/pPlMYx6AL/otoGtJCLLYRh1QuwHJzHuvxj32Vx4h3PqKlGHUWlNo6WrQFZKTIFkrn1tHUAMJOqIqMOIOiamA7I+zd129vw+9PS+MZCoPaKdQqK5VVRa0wg/d9G+DdRFLQ/a9nBANXcI2cN7RD2LLSPSy55bA91l660lSwcRg4r0YZMAnbeOOOEe6dN8ULeVz4Y1Bainptpq6qPxHgCN1LP725FUAQDGjx8PiUQChUIBhULR7e2KBcOIqJusNZTsbUJHW5Gfn8/J9YzAMKI2rOUXq62xhvNKlvzbMYioOxhG/8OBDGRKrUPB3AdqS/+AYBBRd4ny6Mvri9pn6YOavTJXOFnD34tBRKbQ5dF0iYmJqKmpAQAcO3YMjY32d0BnSFFPaXkNkyGBYuzzzIVBRKbS5TB69913UV1994P3yCOPoLy83GyVIsuwhoObWLUOmfYe9sKe9oVMo8vddEOGDEFqaiqmTJkCrVaL3Nxc9OnTR2/ZBx980GQVtBYc3k2ki98HMqUuh9Gbb76J5557DikpKXBwcMATTzyht5yDgwM0Go3JKtjTxDqQgb9UyRAMIjK1Lh91Z86ciZkzZ6K6uhpSqRQFBQXw9fU1Z93shjVd4EfUXQwiMgeDmwAeHh44fPgwgoKC4OQkvhYEkZgxiMhcupwmarVauKr43nvvxZ07d9ota+tXH7fXVWev543YaqOusMfPPlmPLodRnz59cOPGDfj6+sLb2xsODg5tymi1Wqs/Z8Th20SGM2UQ8ccP6dPlMDp06BB8fHwAAIcPHzZbhahn8cBAnWGLiHpCl8PooYce0vv/RERE3WX0CISKigqcOnUKZWVlaGpq0lk3d+7cblesJ1y9/QuG9ull0HPs9bwRkT78rFNPMSqMvvjiC8TGxgrDvFueP3JwcLCZMOpJ1ji829rqQ9aFQUQ9yaiZXpcuXYpnnnkG1dXVqKiowO3bt4WHvdwmiAMdSMzMFUT8AaRry5YtGDJkCNzc3BAREYFTp051WD4jIwPBwcFwc3PD6NGjsX//fp31Wq0WSUlJ8Pf3R69evRAZGYnvv/9ep0x5eTliY2MhlUrh7e2NuLg44VZvzb799lv89re/hZubGwIDA7FhwwbT7HAHjAqj69ev44UXXkDv3r1NXZ8ed/X2L5augkXwoEDtYYuoZ3zyySdITExEcnIyzpw5g7FjxyIqKgplZWV6y584cQJz5sxBXFwczp49K9yI4Pz580KZDRs2IDU1FWlpacjLy4O7uzuioqJQW1srlImNjcWFCxeQnZ2NzMxMHDt2DPHx8cJ6tVqNKVOmYPDgwVAqlXjzzTexevVqfPDBB+Z7M2BkGEVFReH06dPdfvFt27ZhzJgxkEqlkEqlkMvlOHDggLC+trYWCoUCffv2hYeHB2JiYlBaWtrt1wXEG0JEHWEQ9Zy3334bCxYswPz58xEaGoq0tDT07t0bf/nLX/SWf+eddzB16lQsW7YMISEheP3113HffffhvffeA3C3VbR582asWrUKM2bMwJgxY/Dxxx+jpKQEn332GQDg0qVLyMrKwkcffYSIiAg88MADePfdd7Fnzx6UlJQAAHbt2oX6+nr85S9/wW9+8xvMnj0bL7zwAt5++22zvh9dPmf0+eefC/8fHR2NZcuW4eLFixg9ejScnZ11yv7+97/v0jYHDhyIdevWYfjw4dBqtdi5cydmzJiBs2fP4je/+Q2WLFmCffv2ISMjA15eXkhISMCTTz6J48ePd7XaXWLMQAZj9MR5Iw6wIGPxc2MaarVa59+urq5wdXXVWVZfXw+lUomVK1cKyxwdHREZGYnc3Fy9283NzUViYqLOsqioKCForl27BpVKhcjISGG9l5cXIiIikJubi9mzZyM3Nxfe3t4YN26cUCYyMhKOjo7Iy8vDE088gdzcXDz44INwcXHReZ3169fj9u3b7d4gu7sMujdda6+99lqbZYZc9Pr444/r/Hvt2rXYtm0bTp48iYEDB2L79u3YvXs3Hn30UQDAjh07EBISgpMnT2LixIldrTq1wi46aq0ngshaP3fVEnc4mKBu1ZK7o4oDAwN1licnJ2P16tU6y27dugWNRgM/Pz+d5X5+frh8+bLe7atUKr3lVSqVsL55WUdlWt9T1MnJCT4+PjplgoKC2myjeZ3Fw6j18G1T02g0yMjIQE1NDeRyOZRKJRoaGnRSPjg4GIMGDUJubm67YVRXV4e6ujrh361/pbRHX+tIrHfwJnFhi8i0ioqKdG6J1rpVRPoZdc7IlL777jt4eHjA1dUVzz33HPbu3YvQ0FCoVCq4uLjA29tbp3zLlNcnJSUFXl5ewqP1rxRTsNZfeESGYhCZXvM58OaHvjDq168fJBJJm3PgpaWlkMlkercrk8k6LN/8387KtB4g0djYiPLycp0y+rbR8jXMwegwysnJwfTp03HPPffgnnvuwfTp0/Hll18avJ2RI0fi3LlzyMvLw/PPP4958+bh4sWLxlYLK1euRGVlpfAoKirq8nN7YlCDpb/8DFJqZunPopi5uLggPDwcOTk5wrKmpibk5ORALpfrfY5cLtcpDwDZ2dlC+aCgIMhkMp0yarUaeXl5Qhm5XI6KigoolUqhzKFDh9DU1ISIiAihzLFjx9DQ0KDzOiNHjjRbFx1gZBht3boVU6dOhaenJxYtWoRFixZBKpVi2rRp2LJli0HbcnFxwbBhwxAeHo6UlBSMHTsW77zzDmQyGerr61FRUaFTvqNfDsDdJnHrXybCc0Vy7ZA9TlNNptXTQcTPYluJiYn48MMPsXPnTly6dAnPP/88ampqMH/+fAB372TTcoDDokWLkJWVhY0bN+Ly5ctYvXo1Tp8+jYSEBAB3z9cvXrwYa9asweeff47vvvsOc+fORUBAgHDOPyQkBFOnTsWCBQtw6tQpHD9+HAkJCZg9ezYCAgIAAH/84x/h4uKCuLg4XLhwAZ988gneeeedNoMnTM2oEyJvvPEGNm3aJLwJAPDCCy9g0qRJeOONN6BQKIyuUFNTE+rq6hAeHg5nZ2fk5OQgJiYGAFBQUIDCwsJ2fzl0VUctoJ4aWddTmg8C/BVMzfhZsA6zZs3CzZs3kZSUBJVKhbCwMGRlZQmDBQoLC+Ho+Gt74f7778fu3buxatUqvPzyyxg+fDg+++wzjBo1SiizfPly1NTUID4+HhUVFXjggQeQlZUFNzc3ocyuXbuQkJCAyZMnw9HRETExMUhNTRXWe3l54T//+Q8UCgXCw8PRr18/JCUl6VyLZA4OWq1Wa+iTPDw8cO7cOQwbNkxn+ffff4977723zdW87Vm5ciV+97vfYdCgQaiqqsLu3buxfv16HDx4EI899hief/557N+/H+np6ZBKpVi4cCGAuxd/dZVarYaXlxeuFd/AHcndi3Q7645rGUbtDWDozheavxLJUiwVROb6zFep1Qga6I/KykqD51FreWzwNMEcbN2pCxnZMvr973+PvXv3YtmyZTrL//3vf2P69Old3k5ZWRnmzp2LGzduwMvLC2PGjBGCCAA2bdokJHddXR2ioqKwdetWY6pMJHpsEZE1M6pltGbNGrz11luYNGmS0GV28uRJHD9+HEuXLtX5VfDCCy+YrrZG6KhldOVWNUb0a/uLrXU3nb7WUXe/2GwdUU+yZBCZ87POlpH9MKpltH37dvTp0wcXL17UGfnm7e2N7du3C/92cHCweBgRiR1bRGQLjAqja9eumboeFtNe64jIHjCIyFYYFUbtDfFzcHCAm5sbhg8fjt///vfCNOW2pidG1Fnj/EZkX6whiPgZp64yKozOnj2LM2fOQKPRYOTIkQCAK1euQCKRIDg4GFu3bkViYiK++uor/OY3vzFphU3lyq1qnf9n64jsiTUEEZEhjLrodcaMGYiMjERJSQmUSiWUSiWKi4vx2GOPYc6cObh+/ToefPBBs18kRUTWi60iMoRRYfTmm2/i9ddf1xkx4uXlhdWrV2PDhg3o3bs3kpKSdG45QUQ9g60iskVGhVFlZaXe2Qhv3rwp3CXb29sb9fX13atdD2rZbddTeNAgU+NnimyV0d10zzzzDPbu3Yvi4mIUFxdj7969iIuLE+6BdOrUKYwYMcKUdTWJrt4MlTPBEhmPXXRkKKMGMLz//vtYsmQJZs+ejcbGuzcfdXJywrx587Bp0yYAd+ce+uijj0xX0x7AgQxky9gqIltmVBh5eHjgww8/xKZNm3D16lUAwNChQ+Hh8euBPCwszCQVJKLOMYjI1nVrGlMPDw+MGTPGVHXpcd8WVWJMoJelq0FkV9hFR8aw+Eyv1sYSAxmIuoOtIrIHogwjQwNHLJPyERFZSre66eyBpbvqeFsgIssqu9OIO5Lu/+CsvnN3G+PHj4dEIoFCoejWRKNiI/owIrJl1tZFxx9WQH5+PqeQMIIou+mAuy0iff9PRMaztnAk2yHaMOqK9i585ReOiMi0GEZERGRxDKP/adlVx+HdREQ9i2FERCbFbmwyhqjD6AcOXCAyCwYSGUrUYdQaR9URmY6nppqhRF0mmjAqu8O7KJD9sYXrehhI1BWiCaP2sKuOyPwYSNQZ0YcRka2zhdYRUWdEFUZXb//S6bBtnjciW2QLgcTWEXVEVGHU7NuiSp3uObF01fFgQJbGzyC1R5Rh1BW88JVsTZXEgy0kslkMI5HgAUA8bCWUiFpiGJmA5HaxpatA1EZzKFljMPHHEbXGMPofY88bNQcRA4msmTUHE3WuvLwcsbGxkEql8Pb2RlxcHKqrOw702tpaKBQK9O3bFx4eHoiJiUFpaalOmcLCQkRHR6N3797w9fXFsmXL0Nioe03mkSNHcN9998HV1RXDhg1Denq6zvpt27ZhzJgxkEqlkEqlkMvlOHDggMH7KOowulWiNun2rDWQWv4K5S9SspZg4mex62JjY3HhwgVkZ2cjMzMTx44dQ3x8fIfPWbJkCb744gtkZGTg6NGjKCkpwZNPPims12g0iI6ORn19PU6cOIGdO3ciPT0dSUlJQplr164hOjoajzzyCM6dO4fFixfj2WefxcGDB4UyAwcOxLp166BUKnH69Gk8+uijmDFjBi5cuGDQPjpotVqtQc+wMWq1Gl5eXsi7UoSyRmdcuVUtjKa7VaJGv4BfZ2Qc9r/px5unIR/RzwND+/QCAPi5/zopbssvUesA0vQZaHAdzX1QaP2lt/RBiKyPpYKhu5/FKrUaQQP9UVlZafDsqi2PDR6e3Z+ZtbpKjYgRgUbVpSOXLl1CaGgo8vPzMW7cOABAVlYWpk2bhuLiYgQEBLR5TmVlJfr374/du3fjqaeeAgBcvnwZISEhyM3NxcSJE3HgwAFMnz4dJSUl8PPzAwCkpaXhpZdews2bN+Hi4oKXXnoJ+/btw/nz54Vtz549GxUVFcjKymq3zj4+PnjzzTcRFxfX5f0UdcvIHKytdcRfn0Q9S61W6zzq6uq6tb3c3Fx4e3sLQQQAkZGRcHR0RF5ent7nKJVKNDQ0IDIyUlgWHByMQYMGITc3V9ju6NGjhSACgKioKKjVaqFVk5ubq7ON5jLN22hNo9Fgz549qKmpgVwuN2g/nTovQi3x4E5kX36qqEXvRudub+dOdS0AIDAwUGd5cnIyVq9ebfR2VSoVfH19dZY5OTnBx8cHKpWq3ee4uLjA29tbZ7mfn5/wHJVKpRNEzeub13VURq1W45dffkGvXnd7jr777jvI5XLU1tbCw8MDe/fuRWhoqEH7KfqWkanPGwHW1zoi6gy7bk2nqKgIlZWVwmPlypV6y61YsQIODg4dPi5fvtzDtTfOyJEjce7cOeTl5eH555/HvHnzcPHiRYO2wZZRCz8UVQrnjbpLcrvYqPNHpsRWHFk7T0213QVh86iyzixduhRPP/10h2WGDh0KmUyGsrIyneWNjY0oLy+HTCbT+zyZTIb6+npUVFTotI5KS0uF58hkMpw6dUrnec2j7VqWaT0Cr7S0FFKpVGgVAYCLiwuGDRsGAAgPD0d+fj7eeecdvP/++x3uX0sMIz2+LaoUBjEQEZlD//790b9//07LyeVyVFRUQKlUIjw8HABw6NAhNDU1ISIiQu9zwsPD4ezsjJycHMTExAAACgoKUFhYKJzLkcvlWLt2LcrKyoRuwOzsbEilUqGLTS6XY//+/Trbzs7O7vR8UFNTk8HnykTfTWev2Coisg8hISGYOnUqFixYgFOnTuH48eNISEjA7NmzhZF0169fR3BwsNDS8fLyQlxcHBITE3H48GEolUrMnz8fcrkcEydOBABMmTIFoaGh+NOf/oRvvvkGBw8exKpVq6BQKODq6goAeO6553D16lUsX74cly9fxtatW/Hpp59iyZIlQv1WrlyJY8eO4aeffsJ3332HlStX4siRI4iNjTVoP0XbMjLHuaLWLNVV11kQ2WPXCHUPf7xYt127diEhIQGTJ0+Go6MjYmJikJqaKqxvaGhAQUEB7ty5IyzbtGmTULaurg5RUVHYunWrsF4ikSAzMxPPP/885HI53N3dMW/ePLz22mtCmaCgIOzbtw9LlizBO++8g4EDB+Kjjz5CVFSUUKasrAxz587FjRs34OXlhTFjxuDgwYN47LHHDNpH0V5ndDKvSKdc8/VGLa810nedUUfXGOnTlTAydTB05cDCMKKWLBlG3fksmuI6o09OfY/eHp5G16HZneoqzJow3OTXGYkFu+mIiMjiGEZEIscuOrIGogwjsUymR0RkK0QZRs3KC3+0dBWIiAgiDyN9bL3VxC4XMgQ/L2QtGEYWxlFtZCkMIrImDCMiIrI4hhGRCFlTq8ia6kKWwzAiEhke/MkaMYz+pyduD0RERPpZNIxSUlIwfvx4eHp6wtfXFzNnzkRBQYFOmdraWigUCvTt2xceHh6IiYlpc0tzQ3zbjdFy/EVJto6fYbJWFg2jo0ePQqFQ4OTJk8jOzkZDQwOmTJmCmpoaocySJUvwxRdfICMjA0ePHkVJSQmefPJJC9baPvCgRETWxKJ37c7KytL5d3p6Onx9faFUKvHggw+isrIS27dvx+7du/Hoo48CAHbs2IGQkBCcPHlSuBU6EXWOP0DImlnVOaPKyrtdaD4+PgAApVKJhoYGREZGCmWCg4MxaNAg5Obm6t1GXV0d1Gq1zqMjxt6FgVOLky1hEJG1s5r5jJqamrB48WJMmjQJo0aNAgCoVCq4uLjoTJsLAH5+flCpVHq3k5KSgldffdXc1SUiO/HDf6vhVuvQ7e3U1twN/PHjx0MikUChUEChUHR7u2JhNWGkUChw/vx5fP31193azsqVK5GYmCj8W61WIzAwsLvVswn89Uv68HPRs/Lz8zmfkRGsIowSEhKQmZmJY8eOYeDAXyejk8lkqK+vR0VFhU7rqLS0FDKZTO+2XF1dhSlzicSOQUS2wqLnjLRaLRISErB3714cOnQIQUFBOuvDw8Ph7OyMnJwcYVlBQQEKCwshl8t7urpENoVBRLbEoi0jhUKB3bt349///jc8PT2F80BeXl7o1asXvLy8EBcXh8TERPj4+EAqlWLhwoWQy+UcSUdEZEcsGkbbtm0DADz88MM6y3fs2IGnn34aALBp0yY4OjoiJiYGdXV1iIqKwtatW3u0nn7u5nmbeMduMhe2isjWWDSMtFptp2Xc3NywZcsWbNmypQdqRGT7bDGIPDXV/HEmclZ1nREREYkTw0ik+CuUiKwJw4jIjthiFx0RwDAiIiIrwDAishNsFZEtE30Y+Qy6x9JVICISPdGHUbN+AXfvJTUs0MvCNTE/Dl4gImvDMOoidoEQEZkPw8hC2Doh0sUffOLGMBIZhiARWSOGERERWZzowmhMFwYodKWMLWKryL7x72u/ysvLERsbC6lUCm9vb8TFxaG6uuNuzdraWigUCvTt2xceHh6IiYlBaWmpTpnCwkJER0ejd+/e8PX1xbJly9DY2KhT5siRI7jvvvvg6uqKYcOGIT09vc1rXb9+Hf/3f/+Hvn37olevXhg9ejROnz5t0D6KLozEigcqceDf2T7FxsbiwoULyM7OFiYijY+P7/A5S5YswRdffIGMjAwcPXoUJSUlePLJJ4X1Go0G0dHRqK+vx4kTJ7Bz506kp6cjKSlJKHPt2jVER0fjkUcewblz57B48WI8++yzOHjwoFDm9u3bmDRpEpydnXHgwAFcvHgRGzduRJ8+fQzaR6uY6dVeafoM7LyQCVVJPPSeBOYBish2Xbp0CVlZWcjPz8e4ceMAAO+++y6mTZuGt956CwEBAW2eU1lZie3bt2P37t149NFHAdydmickJAQnT57ExIkT8Z///AcXL17El19+CT8/P4SFheH111/HSy+9hNWrV8PFxQVpaWkICgrCxo0bAQAhISH4+uuvsWnTJkRFRQEA1q9fj8DAQOzYsUN4/dYTpXYFW0ZEdoY/PixLrVbrPOrq6rq1vdzcXHh7ewtBBACRkZFwdHREXl6e3ucolUo0NDQgMjJSWBYcHIxBgwYhNzdX2O7o0aPh5+cnlImKioJarcaFCxeEMi230VymeRsA8Pnnn2PcuHH4wx/+AF9fX9x777348MMPDd5PUbeMmu++0HzBa0sj+pnvC92TBwsemMSpvVYytXW+WA2X3k3d3k79nbvvd2BgoM7y5ORkrF692ujtqlQq+Pr66ixzcnKCj4+PMDu2vue4uLjA29tbZ7mfn5/wHJVKpRNEzeub13VURq1W45dffkGvXr1w9epVbNu2DYmJiXj55ZeRn5+PF154AS4uLpg3b16X91PUYdSaPdx9oeVBiEFE1POKiooglf76A9fV1VVvuRUrVmD9+vUdbuvSpUsmrZs5NDU1Ydy4cXjjjTcAAPfeey/Onz+PtLQ0hlFnhgV64VaJ2tLVMBuGEAG/fg7YQupZUqlUJ4zas3TpUjz99NMdlhk6dChkMhnKysp0ljc2NqK8vBwymUzv82QyGerr61FRUaHTOiotLRWeI5PJcOrUKZ3nNY+2a1mm9Qi80tJSSKVS9OrVCwDg7++P0NBQnTIhISH45z//2eG+tSbKMOoJPT14gag97LKzTv3790f//v07LSeXy1FRUQGlUonw8HAAwKFDh9DU1ISIiAi9zwkPD4ezszNycnIQExMDACgoKEBhYSHkcrmw3bVr16KsrEzoBszOzoZUKhXCRS6XY//+/Trbzs7OFrYBAJMmTUJBQYFOmStXrmDw4MFdeRsEoh3AoO88EZG9qpJ4sMVso0JCQjB16lQsWLAAp06dwvHjx5GQkIDZs2cLI+muX7+O4OBgoaXj5eWFuLg4JCYm4vDhw1AqlZg/fz7kcjkmTpwIAJgyZQpCQ0Pxpz/9Cd988w0OHjyIVatWQaFQCF2Lzz33HK5evYrly5fj8uXL2Lp1Kz799FMsWbJEqN+SJUtw8uRJvPHGG/jhhx+we/dufPDBB1AoFAbtp2jDqBlDicSEgWSbdu3aheDgYEyePBnTpk3DAw88gA8++EBY39DQgIKCAty5c0dYtmnTJkyfPh0xMTF48MEHIZPJ8K9//UtYL5FIkJmZCYlEArlcjv/7v//D3Llz8dprrwllgoKCsG/fPmRnZ2Ps2LHYuHEjPvroI2FYNwCMHz8ee/fuxd///neMGjUKr7/+OjZv3ozY2FiD9tFBq9VqjXlzbIVarYaXlxfyrhShrNEZV25V49uiSvxQVIlbJWq9U0eMCfTCiH4eGNrnbp+on7tTm24Oye3iDl+3o246HhDIGlhj152h340qtRpBA/1RWVnZpfM0LTUfG+Z8eBQuvbv/nay/U42/L3jIqLoQW0ZmwfNFZAv4o4isCcOoFXu9Lx2RPtZ0Lsla6kGWIeow6s75IrZ+yJ5YUyiROIk6jJqZ8mLXzkKKX3iyZgwlshSGkR7mvBUQkS1gIFFPYxi1wPNFRL9iK4l6kujuwNCy1fNDUWW3uug0fQbqDPHmeSSyR7ytEPUEUbWMmq8bIiLDsZVE5iSaMPLt3XEjsL0uOj/3rjUeu9Iq4peZbJ25uu743SDRhJE+phhFx645EiOeTyJTE3UYNWvZKmo+p2RIlx4DicTKFIHEUCOAYdRj+IUje8VWEpmCaMOIw7iJTIuBRN0hyjBqObxbXxcdERnH0FYSA4yaie46o5Z6Koj4hSOx6crsstbyvbh6XQ0nN023t9NYWwPg7vw+EokECoXC4AnmxEx0YTS0Ty9cvf1Lp2Va49TNRIaxlrDpafn5+ZzPyAii7KZrja0iIiLLEm0YNQcQg4iIyPJEG0bt6ej6IoYLEZF5iDKMmgOndauodRB19VZA+jC4iIi6TlRh1FG4dPWOC10ZusogIiIyjKjCqD36gqizVpG+wOGV6ERExhFtGDUHUHemlWgZPAwhIiLjiS6MWrZ4TDG/EVtDRETdJ7ow6oruDFwgIiLDiTKMOgobBhERUc8T7ZHXz90JpTWNwv8TEZHliPoozBAiIrIOouymIyIi68IwIiIii7NoGB07dgyPP/44AgIC4ODggM8++0xnvVarRVJSEvz9/dGrVy9ERkbi+++/t0xliYjIbCwaRjU1NRg7diy2bNmid/2GDRuQmpqKtLQ05OXlwd3dHVFRUaitre32a3tqqnUeRETWqry8HLGxsZBKpfD29kZcXByqqzs+btXW1kKhUKBv377w8PBATEwMSktLdcoUFhYiOjoavXv3hq+vL5YtW4bGxkadMkeOHMF9990HV1dXDBs2DOnp6Trrq6qqsHjxYgwePBi9evXC/fffj/z8fIP30aJh9Lvf/Q5r1qzBE0880WadVqvF5s2bsWrVKsyYMQNjxozBxx9/jJKSkjYtKEPpCx8GExFZq9jYWFy4cAHZ2dnIzMzEsWPHEB8f3+FzlixZgi+++AIZGRk4evQoSkpK8OSTTwrrNRoNoqOjUV9fjxMnTmDnzp1IT09HUlKSUObatWuIjo7GI488gnPnzmHx4sV49tlncfDgQaHMs88+i+zsbPz1r3/Fd999hylTpiAyMhLXr183aB8dtFqt1qBnmImDgwP27t2LmTNnAgCuXr2Ke+65B2fPnkVYWJhQ7qGHHkJYWBjeeecdvdupq6tDXV2d8G+1Wo3AwEBcK74BT6m0y2HDuyoQWb8qtRpBA/1RWVlp8OyqarUaXl5eiFj9BZzc3Ltdl8baGuStftyounTk0qVLCA0NRX5+PsaNGwcAyMrKwrRp01BcXIyAgIA2z6msrET//v2xe/duPPXUUwCAy5cvIyQkBLm5uZg4cSIOHDiA6dOno6SkBH5+fgCAtLQ0vPTSS7h58yZcXFzw0ksvYd++fTh//ryw7dmzZ6OiogJZWVn45Zdf4OnpiX//+9+Ijo4WyoSHhwuNja6y2gEMKpUKAIQ3qZmfn5+wTp+UlBR4eXkJj8DAQGGdIa0etpCIyBrk5ubC29tbCCIAiIyMhKOjI/Ly8vQ+R6lUoqGhAZGRkcKy4OBgDBo0CLm5ucJ2R48erXOMjYqKglqtxoULF4QyLbfRXKZ5G42NjdBoNHBzc9Mp06tXL3z99dcG7afVhpGxVq5cicrKSuFRVFQEAPDQ1OiUk9wuFh5ERKaiVqt1Hi17aoyhUqng6+urs8zJyQk+Pj7t/jBXqVRwcXGBt7e3zvKWP+ZVKpXeH/vN6zoqo1arhVaRXC7H66+/jpKSEmg0Gvztb39Dbm4ubty4YdB+Wu1VnzKZDABQWloKf39/YXlpaalOt11rrq6ucHV17XDbrQNIcrsYmj4D25Tz1FSzu47Izv33RhUkrppub0dTdwcAdHpjACA5ORmrV69uU37FihVYv359h9u8dOlSt+tlbn/961/xzDPPYMCAAZBIJLjvvvswZ84cKJVKg7ZjtWEUFBQEmUyGnJwcIXzUajXy8vLw/PPPG73d9lpCDCQiMoWioiKdc0bt/TheunQpnn766Q63NXToUMhkMpSVleksb2xsRHl5ufCjvTWZTIb6+npUVFTotI5KS0uF58hkMpw6dUrnec2j7VqWaT0Cr7S0FFKpFL163Z314J577sHRo0dRU1MDtVoNf39/zJo1C0OHDu1w31qzaBhVV1fjhx9+EP597do1nDt3Dj4+Phg0aBAWL16MNWvWYPjw4QgKCsIrr7yCgIAAYZCDqbUXSEREXSWVSrs0gKF///7o379/p+XkcjkqKiqgVCoRHh4OADh06BCampoQERGh9znh4eFwdnZGTk4OYmJiAAAFBQUoLCyEXC4Xtrt27VqUlZUJ3YDZ2dmQSqUIDQ0Vyuzfv19n29nZ2cI2WnJ3d4e7uztu376NgwcPYsOGDZ3uW0sWDaPTp0/jkUceEf6dmJgIAJg3bx7S09OxfPly1NTUID4+HhUVFXjggQeQlZXV5mSZMTTFVwAAkoEjur0tIiJzCQkJwdSpU7FgwQKkpaWhoaEBCQkJmD17tjCS7vr165g8eTI+/vhjTJgwAV5eXoiLi0NiYiJ8fHwglUqxcOFCyOVyTJw4EQAwZcoUhIaG4k9/+hM2bNgAlUqFVatWQaFQCK255557Du+99x6WL1+OZ555BocOHcKnn36Kffv2CfU7ePAgtFotRo4ciR9++AHLli1DcHAw5s+fb9B+WjSMHn74YXQ0stzBwQGvvfYaXnvtNZO8nr4uOk3xFZ1AYuuIiKzNrl27kJCQgMmTJ8PR0RExMTFITU0V1jc0NKCgoAB37twRlm3atEkoW1dXh6ioKGzdulVYL5FIkJmZieeffx5yuRzu7u6YN2+ezvE2KCgI+/btw5IlS/DOO+9g4MCB+OijjxAVFSWUqaysxMqVK1FcXAwfHx/ExMRg7dq1cHZ2NmgfreY6I3Npvpbg5s8/oI+mEsCvraKWWreQWgYSzxkRWSdTXGc07P+3GxLX3t2ui6buDn54/48mv85ILOxuaLc58JojIiLzEk0YSSru3pqiuVVUd+0y6q5dFtbray0REVHPEE0YERGR9RJ9GLXXOjLnnRla3zFc34OISEys9qJXc2oZQD2tq0HTuhwHUZAYNH/u+XkXH1GGUWt11y7DNSjY7K/TnRYPw4nsWevPN0NJfEQVRi274W5f+hkA0CdkcI+8tqm73qy1K48HDzJUR59lhpJ4iCqMuqL1RbCmYK3BYQ49va88SNkuQ6d04d/avokujNo7X6Svq84Ud2MQUxBZgjW8vzxIts8a/j5kG0QXRq3dvvRzl7rqjPllxi+iONjC39lUgWkL+0q2SZRh1Hy+yJz4pSVrws8jWTvRX2dERESWJ9ow+u+l6/jvpbu3CGpuKTWfT+rurYH4K5SIyDCiDSNzYRARERmOYdQJc94WiIiI7hLlAAYioma3i6/B0bn7s0c3NdQCAMaPHw+JRAKFQgGFQtHt7YqF6MPov5euo2/IAJNsi110RJSfn8/J9YzAbrr/aT3cW98gBoYNEZF5iCaMNCU/dKlcZ3f0ZiAREZmeaMIIuBs0ty/9LAzpNpa+QGJIEREZT1Rh1FLZxVsou3irS2X1jahj+BARmY5ow6glY1tKDCSinsGb0do/hlEHunonBoYSkfkwiMSBYdSCMTdQZRARmUeVxINBJCIMIz06G1FHRObDEBInhhEREVkcw6iLeI86IiLzYRh1orvTSRARUecYRq20ntuIiIjMj2H0P929KwMRERmPYWQAnjciIjIPhlEX8LwREZF5MYw6oO+8EVtHRNTTysvLERsbC6lUCm9vb8TFxaG6uuML7mtra6FQKNC3b194eHggJiYGpaWlOmUKCwsRHR2N3r17w9fXF8uWLUNjY6Ow/saNG/jjH/+IESNGwNHREYsXL27zOh9++CF++9vfok+fPujTpw8iIyNx6tQpg/eRYUREVoV3NWkrNjYWFy5cQHZ2NjIzM3Hs2DHEx8d3+JwlS5bgiy++QEZGBo4ePYqSkhI8+eSTwnqNRoPo6GjU19fjxIkT2LlzJ9LT05GUlCSUqaurQ//+/bFq1SqMHTtW7+scOXIEc+bMweHDh5Gbm4vAwEBMmTIF168bdh7eQavVag16ho1Rq9Xw8vLCzQPb4VpWKEwh0XzHbt/QfkLZljO+9gkZDABwDQoGAEgGjtDZrqbPQHNXnUjUunIXhiq1GkED/VFZWWnw7KrNx4a+0WtNNu34f/f9/42qS0cuXbqE0NBQ5OfnY9y4cQCArKwsTJs2DcXFxQgICGjznMrKSvTv3x+7d+/GU089BQC4fPkyQkJCkJubi4kTJ+LAgQOYPn06SkpK4OfnBwBIS0vDSy+9hJs3b8LFxUVnmw8//DDCwsKwefPmDuur0WjQp08fvPfee5g7d26X91OULaO+IQPgG9qv3SAiIsuz1RaSWq3WedTV1XVre7m5ufD29haCCAAiIyPh6OiIvLw8vc9RKpVoaGhAZGSksCw4OBiDBg1Cbm6usN3Ro0cLQQQAUVFRUKvVuHDhgtH1vXPnDhoaGuDj42PQ85yMfkUbIwkYBlf33ugD426ISkQ9z1NTbfb71FUWXoSDxKXzgp3QauoBAIGBgTrLk5OTsXr1aqO3q1Kp4Ovrq7PMyckJPj4+UKlU7T7HxcUF3t7eOsv9/PyE56hUKp0gal7fvM5YL730EgICAnSCsCtEE0bdpSm+otNVJ7ldzK46oh7QE4FkSkVFRTrddK6urnrLrVixAuvXr+9wW5cuXTJp3cxt3bp12LNnD44cOQI3N8O6PhlGRGT1bCmQpFJpl84ZLV26FE8//XSHZYYOHQqZTIaysjKd5Y2NjSgvL4dMJtP7PJlMhvr6elRUVOi0jkpLS4XnyGSyNqPemkfbtbfdjrz11ltYt24dvvzyS4wZM8bg5zOMwPNFRNTz+vfvj/79+3daTi6Xo6KiAkqlEuHh4QCAQ4cOoampCREREXqfEx4eDmdnZ+Tk5CAmJgYAUFBQgMLCQsjlcmG7a9euRVlZmdANmJ2dDalUitDQUIP2ZcOGDVi7di0OHjyoc27LEKIcwNASg4iIrFlISAimTp2KBQsW4NSpUzh+/DgSEhIwe/ZsYSTd9evXERwcLLR0vLy8EBcXh8TERBw+fBhKpRLz58+HXC7HxIkTAQBTpkxBaGgo/vSnP+Gbb77BwYMHsWrVKigUCp2uxXPnzuHcuXOorq7GzZs3ce7cOVy8eFFYv379erzyyiv4y1/+giFDhkClUkGlUnV6HVRromwZNQ/bNnQdEZEl7Nq1CwkJCZg8eTIcHR0RExOD1NRUYX1DQwMKCgpw584dYdmmTZuEsnV1dYiKisLWrVuF9RKJBJmZmXj++echl8vh7u6OefPm4bXXXtN57XvvvVf4f6VSid27d2Pw4MH46aefAADbtm1DfX29MIS8maEDN0RznVH5N0fhXlkC4O6dFfSNqNMXRM3XGQFtrzUCeL0RUU/Rd87IFNcZOY2ONdlousbvdpn8OiOxEGXLqLX2WkMtg4iIiMxHVGEkGThCuOkpu+OIiKyH6AcwdJW+LjoiIjIN0YSRxvvXUXNd6X7r7FwRwPNFRESmIqpuOuDXrrqung9iEBERmZ9oWkbArwHS1S43BhERUc8QVRgBXQ8SniMiIuo5NhFGW7ZswZAhQ+Dm5oaIiAijZhFsTTJwRIeP9rBVRERkelYfRp988gkSExORnJyMM2fOYOzYsYiKimpz40BDGBMomj4DGURERGZi9WH09ttvY8GCBZg/fz5CQ0ORlpaG3r174y9/+Uu3ttscLi0fHa0nIsuxlTt2k/GsOozq6+uhVCp1JmlydHREZGSkMFthV1VL3Dstw/Ahsi5VEg8GkUhY9dDuW7duQaPR6J2N8PLly3qfU1dXpzPNr1qtFv6/+UNtq9MZE4kFA0h8rDqMjJGSkoJXX321wzL8oBMRWRer7qbr168fJBKJMPtgs5azFba2cuVKVFZWCo+ioqKeqCoREXWDVbeMXFxcEB4ejpycHMycORMA0NTUhJycHCQkJOh9jqurq87EUM0zZFRVVZm9vkTUs5q/192aCUfTAJPMo6NpMMVWxEtr5fbs2aN1dXXVpqenay9evKiNj4/Xent7a1UqVZee/+OPP2oB8MEHH3b8KCoqMvjY8ssvv2hlMplJ6yGVSrUjR47UhoSEaN977z2D6yRmVt0yAoBZs2bh5s2bSEpKgkqlQlhYGLKystoMamiPj48PAKCwsBBeXl7mrKpVUKvVCAwMRFFRkWgm+BLbPottf4H291mr1aKqqkqYftsQbm5uuHbtGurr601WTxcXF7i5uZlse2IimplexTL7otj2FxDfPottfwFx7rPYWPUABiIiEgeGERERWZzdh5GrqyuSk5N1RtjZM7HtLyC+fRbb/gLi3GexsftzRkREZP3svmVERETWj2FEREQWxzAiIiKLYxgREZHF2XUYmWO6cmtx7NgxPP744wgICICDgwM+++wznfVarRZJSUnw9/dHr169EBkZie+//94ylTWBlJQUjB8/Hp6envD19cXMmTNRUFCgU6a2thYKhQJ9+/aFh4cHYmJi2txk15Zs27YNY8aMgVQqhVQqhVwux4EDB4T19ra/ra1btw4ODg5YvHixsMze91nM7DaMzDFduTWpqanB2LFjsWXLFr3rN2zYgNTUVKSlpSEvLw/u7u6IiopCbW1tD9fUNI4ePQqFQoGTJ08iOzsbDQ0NmDJlCmpqaoQyS5YswRdffIGMjAwcPXoUJSUlePLJJy1Y6+4ZOHAg1q1bB6VSidOnT+PRRx/FjBkzcOHCBQD2t78t5efn4/3338eYMWN0ltvzPoueJW+MZ04TJkzQKhQK4d8ajUYbEBCgTUlJsWCtzAOAdu/evcK/m5qatDKZTPvmm28KyyoqKrSurq7av//97xaooemVlZVpAWiPHj2q1Wrv7p+zs7M2IyNDKHPp0iUtAG1ubq6lqmlyffr00X700Ud2vb9VVVXa4cOHa7Ozs7UPPfSQdtGiRVqtVjx/Y7Gyy5aRKacrt0XXrl2DSqXS2X8vLy9ERETYzf5XVlYC+PVGuEqlEg0NDTr7HBwcjEGDBtnFPms0GuzZswc1NTWQy+V2vb8KhQLR0dE6+wbY/99Y7Kz+rt3GMGa6cnuiUqkAQO/+N6+zZU1NTVi8eDEmTZqEUaNGAbi7zy4uLvD29tYpa+v7/N1330Eul6O2thYeHh7Yu3cvQkNDce7cObvc3z179uDMmTPIz89vs85e/8Z0l12GEdk3hUKB8+fP4+uvv7Z0Vcxu5MiROHfuHCorK/GPf/wD8+bNw9GjRy1dLbMoKirCokWLkJ2dzWkYRMguu+mMma7cnjTvoz3uf0JCAjIzM3H48GEMHDhQWC6TyVBfX4+Kigqd8ra+zy4uLhg2bBjCw8ORkpKCsWPH4p133rHL/VUqlSgrK8N9990HJycnODk54ejRo0hNTYWTkxP8/Pzsbp/pV3YZRi2nK2/WPF25XC63YM16RlBQEGQymc7+q9Vq5OXl2ez+a7VaJCQkYO/evTh06BCCgoJ01oeHh8PZ2VlnnwsKClBYWGiz+6xPU1MT6urq7HJ/J0+ejO+++w7nzp0THuPGjUNsbKzw//a2z9SCpUdQmEt3pyu3dlVVVdqzZ89qz549qwWgffvtt7Vnz57V/vzzz1qtVqtdt26d1tvbW/vvf/9b++2332pnzJihDQoK0v7yyy8Wrrlxnn/+ea2Xl5f2yJEj2hs3bgiPO3fuCGWee+457aBBg7SHDh3Snj59WiuXy7VyudyCte6eFStWaI8ePaq9du2a9ttvv9WuWLFC6+DgoP3Pf/6j1Wrtb3/1aTmaTqsVxz6Lld2GkVar1b777rvaQYMGaV1cXLQTJkzQnjx50tJVMpnDhw9rAbR5zJs3T6vV3h3e/corr2j9/Py0rq6u2smTJ2sLCgosW+lu0LevALQ7duwQyvzyyy/aP//5z9o+ffpoe/furX3iiSe0N27csFylu+mZZ57RDh48WOvi4qLt37+/dvLkyUIQabX2t7/6tA4jMeyzWHEKCSIisji7PGdERES2hWFEREQWxzAiIiKLYxgREZHFMYyIiMjiGEZERGRxDCMiIrI4hhHZjCFDhmDz5s1mf507d+4gJiYGUqkUDg4Obe6FRkSmx7t2E7Wyc+dOfPXVVzhx4gT69esHLy8vS1eJyO4xjIha+fHHHxESEiLMlURE5sduOrIaVVVViI2Nhbu7O/z9/bFp0yY8/PDDWLx4sd7yb7/9NkaPHg13d3cEBgbiz3/+M6qrq4X16enp8Pb2RmZmJkaOHInevXvjqaeewp07d7Bz504MGTIEffr0wQsvvACNRgMAePjhh7Fx40YcO3YMDg4OePjhh3tgz4mIYURWIzExEcePH8fnn3+O7OxsfPXVVzhz5ky75R0dHZGamooLFy5g586dOHToEJYvX65T5s6dO0hNTcWePXuQlZWFI0eO4IknnsD+/fuxf/9+/PWvf8X777+Pf/zjHwCAf/3rX1iwYAHkcjlu3LiBf/3rX2bdZyK6i910ZBWqqqqwc+dO7N69G5MnTwYA7NixAwEBAe0+p2WLaciQIVizZg2ee+45bN26VVje0NCAbdu24Z577gEAPPXUU/jrX/+K0tJSeHh4IDQ0FI888ggOHz6MWbNmwcfHB71794aLiwsnbCPqQQwjsgpXr15FQ0MDJkyYICzz8vLCyJEj233Ol19+iZSUFFy+fBlqtRqNjY2ora3FnTt30Lt3bwBA7969hSACAD8/PwwZMgQeHh46y8rKysywV0TUVeymI5v0008/Yfr06RgzZgz++c9/QqlUYsuWLQCA+vp6oZyzs7PO8xwcHPQua2pqMn+liahdDCOyCkOHDoWzszPy8/OFZZWVlbhy5Yre8kqlEk1NTdi4cSMmTpyIESNGoKSkpKeqS0Qmxm46sgqenp6YN28eli1bBh8fH/j6+iI5ORmOjo5wcHBoU37YsGFoaGjAu+++i8cffxzHjx9HWlqaBWpORKbAlhFZjbfffhtyuRzTp09HZGQkJk2ahJCQELi5ubUpO3bsWLz99ttYv349Ro0ahV27diElJcUCtSYiU+C042S1ampqMGDAAGzcuBFxcXGWrg4RmRG76chqnD17FpcvX8aECRNQWVmJ1157DQAwY8YMC9eMiMyNYURW5a233kJBQQFcXFwQHh6Or776Cv369bN0tYjIzNhNR0REFscBDEREZHEMIyIisjiGERERWRzDiIiILI5hREREFscwIiIii2MYERGRxTGMiIjI4hhGRERkcf8f5zKRxKZogJcAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "Add the vertical scale factors to *ds* (output of the model in real cases):" + "zeta_bt = (zeta * ds.e3f).sum(dim='z_c')\n", + "zeta_bt.plot.contourf(\n", + " x='glamf', y='gphif', levels=21\n", + ")" ] }, { - "cell_type": "code", - "execution_count": 3, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "points = ['t', 'u', 'v', 'f', 'w']\n", - "for point in points:\n", - " ds[f\"e3{point}\"] = domcfg[f\"e3{point}_0\"]" + "### Barotropic Transport Streamfunction\n", + "\n", + "We can use the barotropic velocity to calcuate the barotropic transport streamfunction, defined via\n", + "\n", + "$$ u_{bt} = - \\frac{\\partial \\Psi}{\\partial y} \\ , \\ \\ v_{bt} = \\frac{\\partial \\Psi}{\\partial x} \\ .$$\n", + "\n", + "$$ \\Psi(x,y) = \\int_0^x \\int_{bottom}^{surface} v_{bt}(x,y) \\, \\text{d}z \\, \\text{d}x $$\n", + "\n", + "We calculate this by integrating $v_{bt}$ along the X axis using the grid object's `cumint` method:" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n", - " domcfg \n", - " \n", - "Dimensions: (x_c: 20, x_f: 20, y_c: 40, y_f: 40, z_c: 36, z_f: 36)\n", "Coordinates:\n", - " * x_c (x_c) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19\n", - " * y_c (y_c) int64 0 1 2 3 4 5 6 7 8 9 ... 30 31 32 33 34 35 36 37 38 39\n", - " * x_f (x_f) float64 0.5 1.5 2.5 3.5 4.5 ... 15.5 16.5 17.5 18.5 19.5\n", - " * y_f (y_f) float64 0.5 1.5 2.5 3.5 4.5 ... 35.5 36.5 37.5 38.5 39.5\n", - " * z_c (z_c) float32 5.0 15.0 25.0 35.0 ... 3.38e+03 3.787e+03 4.22e+03\n", - " * z_f (z_f) float32 4.5 14.5 24.5 ... 3.379e+03 3.786e+03 4.219e+03\n", - "Data variables:\n", - " glamt (y_c, x_c) float64 ...\n", - " glamf (y_f, x_f) float64 ...\n", - " gphit (y_c, x_c) float64 ...\n", - " gphif (y_f, x_f) float64 ...\n", - " e1t (y_c, x_c) float64 ...\n", - " e1u (y_c, x_f) float64 ...\n", - " e1v (y_f, x_c) float64 ...\n", - " e1f (y_f, x_f) float64 ...\n", - " e2t (y_c, x_c) float64 ...\n", - " e2u (y_c, x_f) float64 ...\n", - " e2v (y_f, x_c) float64 ...\n", - " e2f (y_f, x_f) float64 ...\n", - " e3t_0 (z_c, y_c, x_c) float64 ...\n", - " e3u_0 (z_c, y_c, x_f) float64 ...\n", - " e3v_0 (z_c, y_f, x_c) float64 ...\n", - " e3f_0 (z_c, y_f, x_f) float64 ...\n", - " e3w_0 (z_f, y_c, x_c) float64 ...\n", - " ht_0 (y_c, x_c) float64 ...\n", - " fmaskutil (y_f, x_f) float64 ...\n", - "Attributes:\n", - " DOMAIN_number_total: 1\n", - " DOMAIN_number: 1\n", - " DOMAIN_dimensions_ids: [1 2]\n", - " DOMAIN_size_global: [20 40]\n", - " DOMAIN_size_local: [20 40]\n", - " DOMAIN_position_first: [1 1]\n", - " DOMAIN_position_last: [20 40]\n", - " DOMAIN_halo_size_start: [0 0]\n", - " DOMAIN_halo_size_end: [0 0]\n", - " DOMAIN_type: BOX\n", - " nn_cfg: 2\n", - " cn_cfg: BASIN\n", - "\n", - " ds \n", - " \n", - "Dimensions: (axis_nbounds: 2, t: 1, x_c: 20, x_f: 20, y_c: 40, y_f: 40, z_c: 36, z_f: 36)\n", - "Coordinates:\n", - " * z_f (z_f) float32 4.5 14.5 24.5 ... 3.379e+03 3.786e+03 4.219e+03\n", - " * t (t) object 1050-07-01 00:00:00\n", - " * x_c (x_c) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19\n", - " * y_c (y_c) int64 0 1 2 3 4 5 6 7 8 ... 31 32 33 34 35 36 37 38 39\n", - " * z_c (z_c) float32 5.0 15.0 25.0 ... 3.38e+03 3.787e+03 4.22e+03\n", - " * x_f (x_f) float64 0.5 1.5 2.5 3.5 4.5 ... 16.5 17.5 18.5 19.5\n", - " * y_f (y_f) float64 0.5 1.5 2.5 3.5 4.5 ... 36.5 37.5 38.5 39.5\n", - "Dimensions without coordinates: axis_nbounds\n", - "Data variables:\n", - " depthw_bounds (z_f, axis_nbounds) float32 ...\n", - " t_bounds (t, axis_nbounds) object ...\n", - " woce (t, z_f, y_c, x_c) float64 ...\n", - " deptht_bounds (z_c, axis_nbounds) float32 ...\n", - " thetao (t, z_c, y_c, x_c) float64 ...\n", - " so (t, z_c, y_c, x_c) float64 ...\n", - " tos (t, y_c, x_c) float64 ...\n", - " zos (t, y_c, x_c) float64 ...\n", - " depthu_bounds (z_c, axis_nbounds) float32 ...\n", - " uos (t, y_c, x_f) float64 ...\n", - " uo (t, z_c, y_c, x_f) float64 ...\n", - " depthv_bounds (z_c, axis_nbounds) float32 ...\n", - " vos (t, y_f, x_c) float64 ...\n", - " vo (t, z_c, y_f, x_c) float64 ...\n", - " e3t (z_c, y_c, x_c) float64 ...\n", - " e3u (z_c, y_c, x_f) float64 ...\n", - " e3v (z_c, y_f, x_c) float64 ...\n", - " e3f (z_c, y_f, x_f) float64 ...\n", - " e3w (z_f, y_c, x_c) float64 ...\n", - "Attributes:\n", - " name: NEMO dataset \n", - " description: Ocean grid variables, set on the proper positions\n", - " title: Ocean grid variables\n" + " * x_f (x_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 37.5 38.5 39.5 40.5 41.5\n", + " * y_f (y_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 74.5 75.5 76.5 77.5 78.5\n", + " glamf (y_f, x_f) float64 0.0 1.0 2.0 3.0 4.0 ... 37.0 38.0 39.0 40.0 41.0\n", + " gphif (y_f, x_f) float64 -0.5 -0.5 -0.5 -0.5 ... 61.01 61.01 61.01 61.01\n" ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "print('\\n domcfg \\n', domcfg)\n", - "print('\\n ds \\n', ds)" + "ds['psi'] = grid.cumint(grid.integrate(ds.vo, 'Z'),'X', **bd) * 1e-6\n", + "print(ds.psi.coords)\n", + "ds.psi.plot.contourf(\n", + " x='glamf', y='gphif', levels=25\n", + ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "In the coordinates, the *_c* suffix means *center* while the *_f* suffix means *face*. Thus the (x_c, y_c, z_c) point is the T point, the (x_c, y_f, z_c) is the V point, etc." + "By construction, $\\psi$ is 0 at the western boundary." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Geometry of the basin\n", - "The geometry of the simulation is a closed basin, with a bottom bathymetry, going from 2000 m at the coasts, to 4000 m in the interior of the basin. Terrain following coordinates are used and the free surface is linear (fixed vertical levels).\n", - "A 2 degrees Mercator grid is used." + "### Kinetic Energy\n", + "\n", + "Finally, we plot the surface kinetic energy $1/2 (u^2 + v^2)$ by interpoloting both quantities the cell center point." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 5, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "plt.contourf(domcfg.glamt, domcfg.gphit, domcfg.ht_0)\n", - "plt.colorbar()" + "# an example of calculating kinetic energy\n", + "ke = 0.5*(grid.interp((ds.uo)**2, 'X', **bd) + grid.interp((ds.vo)**2, 'Y', **bd))\n", + "ke.where(ds.tmask).isel(z_c=0).plot(robust=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Creating the grid object\n", + "### Potential vorticity\n", "\n", - "Next we create a `Grid` object from the dataset.\n", - "All the axes are here non-periodic.\n", - "The `metrics` dict contains the scale factors." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Z Axis (not periodic, boundary=None):\n", - " * center z_c --> left\n", - " * left z_f --> center\n", - "X Axis (not periodic, boundary=None):\n", - " * center x_c --> right\n", - " * right x_f --> center\n", - "Y Axis (not periodic, boundary=None):\n", - " * center y_c --> right\n", - " * right y_f --> center\n" - ] - } - ], - "source": [ + "We compute potential vorticity $qv = (\\zeta + f) \\cdot N^2$ on the F point.\n", "\n", - "metrics = {\n", - " ('X',): ['e1t', 'e1u', 'e1v', 'e1f'], # X distances\n", - " ('Y',): ['e2t', 'e2u', 'e2v', 'e2f'], # Y distances\n", - " ('Z',): ['e3t_0', 'e3u_0', 'e3v_0', 'e3f_0', 'e3w_0'], # Z distances\n", - " #('X', 'Y'): [] # Areas TODO\n", - "}\n", - "grid = xgcm.Grid(domcfg, metrics=metrics, periodic=False)\n", - "print(grid)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We see that xgcm identified three different axes: X (longitude), Y (latitude), Z (depth)." + "We have already computed the potential vorticity, the planetary vorticity is outputed by NEMO.\n", + "We need to compute $N^2 = -\\frac{g}{\\rho_0} \\frac{\\partial \\rho}{\\partial z}$ and interpolate it on the F point." ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 19, "metadata": {}, + "outputs": [], "source": [ - "## Computation examples\n", - "### Horizontal gradient of SST\n", - "\n", - "We will compute the horizontal component of the gradient of SST in the longitude\n", - "direction as a first example to understand the logic behind the\n", - "xgcm grids.\n", - "\n", - "We want to compute\n", - "$\\frac{\\partial SST}{\\partial x}$.\n", - "The SST is the variable `tos` (Temperature Ocean Surface) in our dataset.\n", - "\n", - "In discrete form, using the NEMO notation, the derivative becomes [1]\n", + "# Comment: the NEMO run used here is using a simplified non-linear equation of state,\n", + "# ln_seos = .true. in namelist &nameos\n", + "# gsw.sigma0 should be used for NEMO runs that use the TEOS-10 equation of state\n", "\n", - "$$\\frac{\\partial SST}{\\partial x} = \\frac{1}{e_{1u}} \\delta_{i+1/2} SST\n", - "= \\frac{1}{e_{1u}} (SST_{i+1} - SST_i) \\ .$$\n", - "\n", - "The last T point is an earth point here, such as the 2 last U points: we set up the\n", - "`boundary` argument to 'fill' and the fill value to zero (this value does not play an important role here, as we fill earth points).\n", + "rn_a0, rn_b0, rn_lambda1 = 1.655e-1, 7.6554e-1, 0.06\n", "\n", - "The gradient is first computed with the `diff` function and\n", - "then with the `derivative` function, the result is the same as the `derivative`\n", - "function is aware of which scale factor to use.\n", + "def sigma0(T, S):\n", + " \"\"\"\n", + " Compute the density using the simplified EOS\n", + " \"\"\"\n", + " Ta, Sa = T - 10, S - 35\n", + " return 26 - rn_a0 * (1 + 0.5 * rn_lambda1 * Ta) * Ta + rn_b0 * Sa\n", "\n", - "
\n", - "[1] NEMO book v4.0.1, pp 22" + "ds['sigma0'] = sigma0(ds.so, ds.thetao)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 20, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Coordinates:\n", - " * t (t) object 1050-07-01 00:00:00\n", - " * y_c (y_c) int64 0 1 2 3 4 5 6 7 8 9 ... 30 31 32 33 34 35 36 37 38 39\n", - " * x_f (x_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 15.5 16.5 17.5 18.5 19.5\n" - ] - }, { "data": { "text/html": [ @@ -358,6 +1960,7 @@ "}\n", "\n", "html[theme=dark],\n", + "body[data-theme=dark],\n", "body.vscode-dark {\n", " --xr-font-color0: rgba(255, 255, 255, 1);\n", " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", @@ -370,7 +1973,7 @@ "}\n", "\n", ".xr-wrap {\n", - " display: block;\n", + " display: block !important;\n", " min-width: 300px;\n", " max-width: 700px;\n", "}\n", @@ -587,6 +2190,11 @@ " grid-column: 4;\n", "}\n", "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", ".xr-var-name,\n", ".xr-var-dims,\n", ".xr-var-dtype,\n", @@ -608,14 +2216,16 @@ "}\n", "\n", ".xr-var-attrs,\n", - ".xr-var-data {\n", + ".xr-var-data,\n", + ".xr-index-data {\n", " display: none;\n", " background-color: var(--xr-background-color) !important;\n", " padding-bottom: 5px !important;\n", "}\n", "\n", ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", - ".xr-var-data-in:checked ~ .xr-var-data {\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", " display: block;\n", "}\n", "\n", @@ -625,13 +2235,16 @@ "\n", ".xr-var-name span,\n", ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", ".xr-attrs {\n", " padding-left: 25px !important;\n", "}\n", "\n", ".xr-attrs,\n", ".xr-var-attrs,\n", - ".xr-var-data {\n", + ".xr-var-data,\n", + ".xr-index-data {\n", " grid-column: 1 / -1;\n", "}\n", "\n", @@ -669,7 +2282,8 @@ "}\n", "\n", ".xr-icon-database,\n", - ".xr-icon-file-text2 {\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", " display: inline-block;\n", " vertical-align: middle;\n", " width: 1em;\n", @@ -678,84 +2292,248 @@ " stroke: currentColor;\n", " fill: currentColor;\n", "}\n", - "
<xarray.DataArray ()>\n",
-       "array(True)
" + "
<xarray.DataArray (y_f: 79, x_f: 42, z_c: 36)>\n",
+       "1.319e-12 2.52e-12 2.39e-11 9.742e-11 1.771e-10 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "Coordinates:\n",
+       "  * x_f       (x_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 37.5 38.5 39.5 40.5 41.5\n",
+       "  * y_f       (y_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 74.5 75.5 76.5 77.5 78.5\n",
+       "    glamf     (y_f, x_f) float64 0.0 1.0 2.0 3.0 4.0 ... 38.0 39.0 40.0 41.0\n",
+       "    gphif     (y_f, x_f) float64 -0.5 -0.5 -0.5 -0.5 ... 61.01 61.01 61.01 61.01\n",
+       "  * z_c       (z_c) int64 0 1 2 3 4 5 6 7 8 9 ... 26 27 28 29 30 31 32 33 34 35\n",
+       "    gdept_1d  (z_c) float64 ...
" ], "text/plain": [ - "\n", - "array(True)" + "\n", + "1.319e-12 2.52e-12 2.39e-11 9.742e-11 1.771e-10 ... 0.0 0.0 0.0 0.0 0.0\n", + "Coordinates:\n", + " * x_f (x_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 37.5 38.5 39.5 40.5 41.5\n", + " * y_f (y_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 74.5 75.5 76.5 77.5 78.5\n", + " glamf (y_f, x_f) float64 0.0 1.0 2.0 3.0 4.0 ... 38.0 39.0 40.0 41.0\n", + " gphif (y_f, x_f) float64 -0.5 -0.5 -0.5 -0.5 ... 61.01 61.01 61.01 61.01\n", + " * z_c (z_c) int64 0 1 2 3 4 5 6 7 8 9 ... 26 27 28 29 30 31 32 33 34 35\n", + " gdept_1d (z_c) float64 ..." ] }, - "execution_count": 7, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "grad_T_lon0 = grid.diff(ds.tos, axis='X', boundary='fill', fill_value=0) / domcfg.e1u\n", - "grad_T_lon1 = grid.derivative(ds.tos, axis='X', boundary='fill', fill_value=0)\n", - "print(grad_T_lon1.coords)\n", - "(grad_T_lon0 == grad_T_lon1).all()" + "g = 9.81\n", + "rho0 = 1026\n", + "\n", + "N2 = -g/rho0 * (-grid.derivative(ds.sigma0, 'Z', boundary='extend'))\n", + "# We have an extra minus sign in the derivative as the Z axis is oriented downward in NEMO\n", + "\n", + "qv = (zeta + ds.ff_f) * grid.interp(N2, ['X', 'Y', 'Z'], boundary='extend')\n", + "qv" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 21, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "As expected the result of the 2 operations is the same.\n", - "The position of the derivative is now on the U point." + "qv.isel(z_c=5).plot()" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Divergence Calculation\n", - "\n", - "Here we show how to calculate the divergence of the flow.\n", - "The precise details of how to do this calculation are highly model- and configuration-dependent (e.g. free-surface vs. rigid lid, etc.)\n", - "In this example, the flow is incompressible, without precipitations\n", - "or evaporation, with a linear free surface, satisfying the continuity equation\n", - "\n", - "$$ \\vec{\\nabla} \\cdot \\vec{u} = \n", - " \\frac{\\partial u}{\\partial x} + \\frac{\\partial v}{\\partial y}\n", - " + \\frac{\\partial w}{\\partial z} = 0 \\ .$$\n", - " \n", - "In non-linear free surface, the divergence of $\\vec{u}$ is not 0 anymore, it is linked to\n", - "the time variation of the $e_{3}$ scale factors.\n", + "## The `transform` function\n", "\n", - "In discrete form, using NEMO notation, the equation becomes [1]\n", + "It is possible whith xgcm to remap variables from one coordinate to another (e.g. remap the velocities into density coordinates to compute the meridional overturning streamfunction in density coordinates).\n", "\n", - "$$ \\vec{\\nabla} \\cdot \\vec{u} = \\frac{1}{e_{1t}e_{2t}e_{3t}} \\left[\n", - " \\delta_i(u \\cdot e_{2u} \\cdot e_{3u})\n", - " + \\delta_j(v \\cdot e_{1v} \\cdot e_{3v}) \\right]\n", - " + \\frac{1}{e_{3t}} \\delta_k(w) \\ .$$\n", + "We will show here 2 examples of usage: one to remap from the terrain following coordinates to constant depth levels (using the conservative remapping), and one to compute the temperature 10 meters below the MLD.\n", "\n", - "The equation for the divergence calculation could be simplified due to the geometry of our basin, but we will keep it in the general form.\n", + "### Conservative remapping of depth coordinates\n", "\n", - "
\n", - "[1] NEMO book v4.0.1, pp 22" + "The remapping transformation does not work yet (example written at xgcm version 0.8.1) for center/right or left/center axes but only for outer/center axes. As the vertical coordinate in NEMO is a left/center axis, we will need to remove the last T point (that is an earth point, inside the bathymetry) in our dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Frozen({'z_c': 35, 'axis_nbounds': 2, 'y_c': 79, 'x_c': 42, 'x_f': 42, 'y_f': 79, 'z_f': 36})" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds = ds.isel(z_c=slice(None,-1))\n", + "ds.dims" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Y Axis (not periodic, boundary=None):\n", + " * center y_c --> right\n", + " * right y_f --> center\n", + "Z Axis (not periodic, boundary=None):\n", + " * center z_c --> outer\n", + " * outer z_f --> center\n", + "X Axis (not periodic, boundary=None):\n", + " * center x_c --> right\n", + " * right x_f --> center\n" + ] + } + ], + "source": [ + "grid = xgcm.Grid(ds, metrics=metrics, periodic=False)\n", + "print(grid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Z Axis is now an outer/center axis." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### 3d flow\n", - "\n", - "We can't use the `grid.derivative` function for *w* even if this is a simple vertical derivative: xgcm does not use the temporaly varying scale factors but the *domcfg.e3t_0* initial vertical scale factors. In this simple linear free surface case, the scale factors don't vary in time, but we will use here a more general approach.\n", - "\n", - "For *u* and *v* we use the `grid.diff` as this is not a simple derivative, even if the horizontal scale factors are fixed in time in any case.\n", - "The first T point along x is an earth point, we can use a 'fill' `boundary` with a 0 `fill_value`. The same argument applies along y and z.\n", + "The conservative function works for extensive variables, e.g. for the temperature, salinity, velocities, concentrations, etc one must multiply the variable by the height of the cell.\n", "\n", - "⚠ We need to use a negative sign for the vertical derivative, as the k-axis increases with depth.\n", + "> Note: extensive variable means that the variable increases if the studied volume is taken bigger, as for example the heat content or the mass. On the contrary an intensive variable does not change with the size of the studied volume, as the temperature (if the temperature is constant in the domain of course).\n", "\n", - "⚠ If the model is ran without linear free surface the e3 scale factors are not constant in time, we need to take the e3 from *ds* and not from *domcfg*. The data are are \"thickness weighted\". To stay general, we use here the e3 scale factors from *ds*." + "We will remap here the meridional velocity, we thus use the meridional velocity flux." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 60, "metadata": {}, "outputs": [ { @@ -792,6 +2570,7 @@ "}\n", "\n", "html[theme=dark],\n", + "body[data-theme=dark],\n", "body.vscode-dark {\n", " --xr-font-color0: rgba(255, 255, 255, 1);\n", " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", @@ -804,7 +2583,7 @@ "}\n", "\n", ".xr-wrap {\n", - " display: block;\n", + " display: block !important;\n", " min-width: 300px;\n", " max-width: 700px;\n", "}\n", @@ -1021,6 +2800,11 @@ " grid-column: 4;\n", "}\n", "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", ".xr-var-name,\n", ".xr-var-dims,\n", ".xr-var-dtype,\n", @@ -1042,14 +2826,16 @@ "}\n", "\n", ".xr-var-attrs,\n", - ".xr-var-data {\n", + ".xr-var-data,\n", + ".xr-index-data {\n", " display: none;\n", " background-color: var(--xr-background-color) !important;\n", " padding-bottom: 5px !important;\n", "}\n", "\n", ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", - ".xr-var-data-in:checked ~ .xr-var-data {\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", " display: block;\n", "}\n", "\n", @@ -1059,13 +2845,16 @@ "\n", ".xr-var-name span,\n", ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", ".xr-attrs {\n", " padding-left: 25px !important;\n", "}\n", "\n", ".xr-attrs,\n", ".xr-var-attrs,\n", - ".xr-var-data {\n", + ".xr-var-data,\n", + ".xr-index-data {\n", " grid-column: 1 / -1;\n", "}\n", "\n", @@ -1103,7 +2892,8 @@ "}\n", "\n", ".xr-icon-database,\n", - ".xr-icon-file-text2 {\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", " display: inline-block;\n", " vertical-align: middle;\n", " width: 1em;\n", @@ -1112,70 +2902,165 @@ " stroke: currentColor;\n", " fill: currentColor;\n", "}\n", - "
<xarray.DataArray ()>\n",
-       "array(5.44218669e-19)
" + "
<xarray.DataArray 'Fv' (z_c: 35, y_f: 79, x_c: 42)>\n",
+       "0.0 0.8437 -0.004764 -0.6617 -0.8594 -0.7288 -0.5642 ... 0.0 0.0 0.0 0.0 0.0 0.0\n",
+       "Coordinates:\n",
+       "  * z_c       (z_c) int64 0 1 2 3 4 5 6 7 8 9 ... 25 26 27 28 29 30 31 32 33 34\n",
+       "  * x_c       (x_c) int64 0 1 2 3 4 5 6 7 8 9 ... 32 33 34 35 36 37 38 39 40 41\n",
+       "    gdept_1d  (z_c) float64 ...\n",
+       "  * y_f       (y_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 74.5 75.5 76.5 77.5 78.5\n",
+       "    glamv     (y_f, x_c) float64 ...\n",
+       "    gphiv     (y_f, x_c) float64 ...\n",
+       "    gdepv_0   (z_c, y_f, x_c) float64 5.0 5.0 5.0 5.0 ... 883.4 924.3 981.3
" ], "text/plain": [ - "\n", - "array(5.44218669e-19)" + "\n", + "0.0 0.8437 -0.004764 -0.6617 -0.8594 -0.7288 -0.5642 ... 0.0 0.0 0.0 0.0 0.0 0.0\n", + "Coordinates:\n", + " * z_c (z_c) int64 0 1 2 3 4 5 6 7 8 9 ... 25 26 27 28 29 30 31 32 33 34\n", + " * x_c (x_c) int64 0 1 2 3 4 5 6 7 8 9 ... 32 33 34 35 36 37 38 39 40 41\n", + " gdept_1d (z_c) float64 ...\n", + " * y_f (y_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 74.5 75.5 76.5 77.5 78.5\n", + " glamv (y_f, x_c) float64 ...\n", + " gphiv (y_f, x_c) float64 ...\n", + " gdepv_0 (z_c, y_f, x_c) float64 5.0 5.0 5.0 5.0 ... 883.4 924.3 981.3" ] }, - "execution_count": 8, + "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "bd={'boundary':'fill', 'fill_value':0}\n", - "\n", - "div_uv = grid.diff(ds.uo * domcfg.e2u * ds.e3u, 'X', **bd) / (domcfg.e1t * domcfg.e2t * ds.e3t) \\\n", - " + grid.diff(ds.vo * domcfg.e1v * ds.e3v, 'Y', **bd) / (domcfg.e1t * domcfg.e2t * ds.e3t)\n", - "\n", - "div_w = - grid.diff(ds.woce, 'Z', **bd) / ds.e3t\n", - "\n", - "div_uvw = div_uv + div_w\n", - "div_uvw.max()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As expected the divergence of the flow is zero (if we neglect the truncation error)." + "ds['Fv'] = (ds.vo.astype(np.float64) * ds.e3v) # We use here float64 to verify afterward that the remapping is conservative\n", + "ds.Fv" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Vertical velocity\n", - "\n", - "In NEMO the vertical velocity is computed from the divergence of the horizontal velocity.\n", - "In non-linear free surface, the vertical velocity can't be computed offline because it also takes the time\n", - "variations of the vertical scale factors into account.\n", - "However, we are using here a linear free surface, so that\n", - "\n", - "$$\n", - "w(z) = \\int_{bottom}^z \\vec{\\nabla}_h \\cdot \\vec{u} \\, \\text{d}z' \n", - "= \\int_{surf}^z \\vec{\\nabla}_h \\cdot \\vec{u} \\, \\text{d}z' - \\int_{surf}^{bottom} \\vec{\\nabla}_h \\cdot \\vec{u} \\, \\text{d}z' \\ .\n", - "$$\n", - "\n", - "This is written in discrete form\n", - "\n", - "$$\n", - "w(n) = \\sum_0^n \\left(\\vec{\\nabla}_h \\cdot \\vec{u}(k)\\right) e_{3t}(k)\n", - "- \\sum_0^{n_{bot}} \\left(\\vec{\\nabla}_h \\cdot \\vec{u}(k)\\right) e_{3t}(k) \\ .\n", - "$$\n", - "\n", - "We use the `grid.cumsum` to perform the integration, and then we remove the total integral.\n", - "This is shown here with 2 methods that give the same numerical result, however the first method runs faster." + "We are ready to compute the depth transformation. The conservative remapping works will the depth bounds (the depths at the W points) and not the depths at the cell center." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 52, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/romain/.local/share/virtualenvs/xgcm-examples-rCMMOxDs/lib/python3.10/site-packages/xgcm/grid.py:989: FutureWarning: From version 0.8.0 the Axis computation methods will be removed, in favour of using the Grid computation methods instead. i.e. use `Grid.transform` instead of `Axis.transform`\n", + " warnings.warn(\n", + "/home/romain/.local/share/virtualenvs/xgcm-examples-rCMMOxDs/lib/python3.10/site-packages/xgcm/transform.py:247: FutureWarning: ``output_sizes`` should be given in the ``dask_gufunc_kwargs`` parameter. It will be removed as direct parameter in a future version.\n", + " out = xr.apply_ufunc(\n" + ] + }, { "data": { "text/html": [ @@ -1210,6 +3095,7 @@ "}\n", "\n", "html[theme=dark],\n", + "body[data-theme=dark],\n", "body.vscode-dark {\n", " --xr-font-color0: rgba(255, 255, 255, 1);\n", " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", @@ -1222,7 +3108,7 @@ "}\n", "\n", ".xr-wrap {\n", - " display: block;\n", + " display: block !important;\n", " min-width: 300px;\n", " max-width: 700px;\n", "}\n", @@ -1439,6 +3325,11 @@ " grid-column: 4;\n", "}\n", "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", ".xr-var-name,\n", ".xr-var-dims,\n", ".xr-var-dtype,\n", @@ -1460,14 +3351,16 @@ "}\n", "\n", ".xr-var-attrs,\n", - ".xr-var-data {\n", + ".xr-var-data,\n", + ".xr-index-data {\n", " display: none;\n", " background-color: var(--xr-background-color) !important;\n", " padding-bottom: 5px !important;\n", "}\n", "\n", ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", - ".xr-var-data-in:checked ~ .xr-var-data {\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", " display: block;\n", "}\n", "\n", @@ -1477,13 +3370,16 @@ "\n", ".xr-var-name span,\n", ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", ".xr-attrs {\n", " padding-left: 25px !important;\n", "}\n", "\n", ".xr-attrs,\n", ".xr-var-attrs,\n", - ".xr-var-data {\n", + ".xr-var-data,\n", + ".xr-index-data {\n", " grid-column: 1 / -1;\n", "}\n", "\n", @@ -1521,7 +3417,8 @@ "}\n", "\n", ".xr-icon-database,\n", - ".xr-icon-file-text2 {\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", " display: inline-block;\n", " vertical-align: middle;\n", " width: 1em;\n", @@ -1530,114 +3427,236 @@ " stroke: currentColor;\n", " fill: currentColor;\n", "}\n", - "
<xarray.DataArray ()>\n",
-       "array(True)
" + "
<xarray.DataArray 'Fv_transformed' (y_f: 79, x_c: 42, depth_T_uniform: 100)>\n",
+       "0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n",
+       "Coordinates:\n",
+       "  * x_c              (x_c) int64 0 1 2 3 4 5 6 7 8 ... 34 35 36 37 38 39 40 41\n",
+       "  * y_f              (y_f) float64 0.5 1.5 2.5 3.5 4.5 ... 75.5 76.5 77.5 78.5\n",
+       "    glamv            (y_f, x_c) float64 ...\n",
+       "    gphiv            (y_f, x_c) float64 ...\n",
+       "  * depth_T_uniform  (depth_T_uniform) float64 20.0 60.0 ... 3.94e+03 3.98e+03
" ], "text/plain": [ - "\n", - "array(True)" + "\n", + "0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", + "Coordinates:\n", + " * x_c (x_c) int64 0 1 2 3 4 5 6 7 8 ... 34 35 36 37 38 39 40 41\n", + " * y_f (y_f) float64 0.5 1.5 2.5 3.5 4.5 ... 75.5 76.5 77.5 78.5\n", + " glamv (y_f, x_c) float64 ...\n", + " gphiv (y_f, x_c) float64 ...\n", + " * depth_T_uniform (depth_T_uniform) float64 20.0 60.0 ... 3.94e+03 3.98e+03" ] }, - "execution_count": 9, + "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "w = grid.cumsum((div_uv*ds.e3t), axis='Z', boundary='fill', fill_value=0) # integral from top\n", - "w = w - w.isel({'z_f':-1}) # now from bot\n", + "# target: new horizontally uniform depths of W points\n", + "# target_data: original depth of W points\n", "\n", - "w_alt = grid.cumsum((div_uv*ds.e3t), axis='Z', boundary='fill', fill_value=0) - (div_uv*ds.e3t).sum(dim='z_c')\n", + "h = 40 # new vertical resolution\n", "\n", - "(w == w_alt).all()" + "ds['Fv_transformed'] = grid.transform(\n", + " ds.Fv,\n", + " 'Z',\n", + " target=xr.DataArray(np.arange(0,4000+h,h), dims=['depth_T_uniform']),\n", + " method='conservative',\n", + " target_data=grid.interp(ds.gdepw_0, 'Y', boundary='extend')\n", + ")\n", + "ds.Fv_transformed" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 53, "metadata": {}, + "outputs": [], "source": [ - "Remark: the first method runs faster, indeed we perfom only once the integral." + "ds['vo_transformed'] = ds.Fv_transformed / h" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 54, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "4.19 ms ± 86.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", - "6.41 ms ± 232 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" - ] + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "def w1(grid, div_uv, ds):\n", - " w = grid.cumsum((div_uv*ds.e3t), axis='Z', boundary='fill', fill_value=0) # integral from top\n", - " return w - w.isel({'z_f':-1}) # now from bot\n", + "ds.coords['gdepv_0'] = grid.interp(ds.gdept_0, 'Y', **bd)\n", "\n", - "def w2(grid, div_uv, ds):\n", - " return grid.cumsum((div_uv*ds.e3t), axis='Z', boundary='fill', fill_value=0) - (div_uv*ds.e3t).sum(dim='z_c')\n", + "fig, ax = plt.subplots(2, 1, figsize=(8,5), sharex=True, sharey=True)\n", "\n", - "%timeit w1(grid, div_uv, ds)\n", - "%timeit w2(grid, div_uv, ds)" + "vmin=-0.02\n", + "\n", + "ds.vo.where(ds.vmask).isel(y_f=20).plot(x='glamv', y='gdepv_0', yincrease=False, ax=ax[0], vmin=vmin)\n", + "ds.vo_transformed.where(ds.depth_T_uniform <= ds.gdepv_0.isel(z_c=-1)).isel(y_f=20).plot(x='glamv', y='depth_T_uniform', yincrease=False, ax=ax[1], vmin=vmin)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We now compare the computed vertical velocity with the one outputed by the model, at the bottom of the uper grid cell." + "We verify that the remapping is conservative:" ] }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, + "execution_count": 58, + "metadata": { + "tags": [] + }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": 58, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "fig, ax = plt.subplots(2, 1)\n", - "ds.woce.isel({'z_f':1}).plot(ax=ax[0])\n", - "w.isel({'z_f':1}).plot(ax=ax[1])" + "(grid.integrate(ds.vo.astype(np.float64), 'Z') - (ds.vo_transformed * h).sum('depth_T_uniform')).plot(robust=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The 2 fields look similar, which is confirmed by computing the difference." + "### Compute temperature 10 meters below the MLD\n", + "\n", + "Here we compute the temperature 10 meters below the MLD, using the linear interpolation. For the linear remapping, we need to provide the center value and not the bound values.\n", + "As the MLD is not the same everywhere, we cannot use the xarray interpolation tool." ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 49, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/romain/.local/share/virtualenvs/xgcm-examples-rCMMOxDs/lib/python3.10/site-packages/xgcm/grid.py:989: FutureWarning: From version 0.8.0 the Axis computation methods will be removed, in favour of using the Grid computation methods instead. i.e. use `Grid.transform` instead of `Axis.transform`\n", + " warnings.warn(\n" + ] + }, { "data": { "text/html": [ @@ -1672,6 +3691,7 @@ "}\n", "\n", "html[theme=dark],\n", + "body[data-theme=dark],\n", "body.vscode-dark {\n", " --xr-font-color0: rgba(255, 255, 255, 1);\n", " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", @@ -1684,7 +3704,7 @@ "}\n", "\n", ".xr-wrap {\n", - " display: block;\n", + " display: block !important;\n", " min-width: 300px;\n", " max-width: 700px;\n", "}\n", @@ -1901,6 +3921,11 @@ " grid-column: 4;\n", "}\n", "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", ".xr-var-name,\n", ".xr-var-dims,\n", ".xr-var-dtype,\n", @@ -1922,14 +3947,16 @@ "}\n", "\n", ".xr-var-attrs,\n", - ".xr-var-data {\n", + ".xr-var-data,\n", + ".xr-index-data {\n", " display: none;\n", " background-color: var(--xr-background-color) !important;\n", " padding-bottom: 5px !important;\n", "}\n", "\n", ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", - ".xr-var-data-in:checked ~ .xr-var-data {\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", " display: block;\n", "}\n", "\n", @@ -1939,13 +3966,16 @@ "\n", ".xr-var-name span,\n", ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", ".xr-attrs {\n", " padding-left: 25px !important;\n", "}\n", "\n", ".xr-attrs,\n", ".xr-var-attrs,\n", - ".xr-var-data {\n", + ".xr-var-data,\n", + ".xr-index-data {\n", " grid-column: 1 / -1;\n", "}\n", "\n", @@ -1983,7 +4013,8 @@ "}\n", "\n", ".xr-icon-database,\n", - ".xr-icon-file-text2 {\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", " display: inline-block;\n", " vertical-align: middle;\n", " width: 1em;\n", @@ -1992,237 +4023,156 @@ " stroke: currentColor;\n", " fill: currentColor;\n", "}\n", - "
<xarray.DataArray ()>\n",
-       "array(2.07489191e-17)
" + "
<xarray.DataArray 'thetao' (y_c: 79, x_c: 42, dim_0: 1)>\n",
+       "nan nan nan nan nan nan nan nan nan nan ... nan nan nan nan nan nan nan nan nan\n",
+       "Coordinates:\n",
+       "  * x_c      (x_c) int64 0 1 2 3 4 5 6 7 8 9 ... 32 33 34 35 36 37 38 39 40 41\n",
+       "  * y_c      (y_c) int64 0 1 2 3 4 5 6 7 8 9 ... 69 70 71 72 73 74 75 76 77 78\n",
+       "    glamt    (y_c, x_c) float64 -0.5 0.5 1.5 2.5 3.5 ... 37.5 38.5 39.5 40.5\n",
+       "    gphit    (y_c, x_c) float64 -0.9999 -0.9999 -0.9999 ... 60.76 60.76 60.76\n",
+       "Dimensions without coordinates: dim_0
" ], "text/plain": [ - "\n", - "array(2.07489191e-17)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "abs((w - ds.woce)).max()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Vorticity\n", - "Here we compute more derived quantities from the velocity field.\n", - "\n", - "The vertical component of the vorticity is a fundamental quantity of interest in ocean circulation theory. It is defined as\n", - "\n", - "$$ \\zeta = \\frac{\\partial v}{\\partial x} - \\frac{\\partial u}{\\partial y} \\ . $$\n", - "\n", - "The NEMO discretization is [1]\n", - "\n", - "$$\n", - "\\zeta = \\frac{1}{e_{1f} e_{2f}} \\left[\\delta_{i+1/2}(v \\cdot e_{2v}) - \\delta_{j+1/2}(u \\cdot e_{1u}) \\right] \n", - "$$\n", - "\n", - "
\n", - "[1] NEMO book v4.0.1, pp 22\n", - "
\n", - "\n", - "In xgcm, we calculate this quantity as" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ + "\n", + "nan nan nan nan nan nan nan nan nan nan ... nan nan nan nan nan nan nan nan nan\n", "Coordinates:\n", - " * x_f (x_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 15.5 16.5 17.5 18.5 19.5\n", - " * y_f (y_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 35.5 36.5 37.5 38.5 39.5\n", - " * t (t) object 1050-07-01 00:00:00\n", - " * z_c (z_c) float32 5.0 15.0 25.0 35.0 ... 3.38e+03 3.787e+03 4.22e+03" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "zeta = 1/(domcfg.e1f*domcfg.e2f) * (grid.diff(ds.vo*domcfg.e2v, 'X', **bd) - grid.diff(ds.uo*domcfg.e1u, 'Y', **bd)) * domcfg.fmaskutil\n", - "zeta.coords" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "$\\zeta$ is located in the F point (*x_f*, *y_f*).\n", - "\n", - "We plot the vertical integral of this quantity, i.e. the barotropic vorticity:" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" + " * x_c (x_c) int64 0 1 2 3 4 5 6 7 8 9 ... 32 33 34 35 36 37 38 39 40 41\n", + " * y_c (y_c) int64 0 1 2 3 4 5 6 7 8 9 ... 69 70 71 72 73 74 75 76 77 78\n", + " glamt (y_c, x_c) float64 -0.5 0.5 1.5 2.5 3.5 ... 37.5 38.5 39.5 40.5\n", + " gphit (y_c, x_c) float64 -0.9999 -0.9999 -0.9999 ... 60.76 60.76 60.76\n", + "Dimensions without coordinates: dim_0" ] }, - "execution_count": 14, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" } ], "source": [ - "zeta_bt = (zeta * ds.e3f).sum(dim='z_c')\n", - "plt.contourf(\n", - " domcfg.glamf,\n", - " domcfg.gphif,\n", - " zeta_bt.isel({'t':0}),\n", - " levels=np.linspace(-abs(zeta_bt).max(), abs(zeta_bt).max(), 21),\n", - " cmap='RdBu_r'\n", + "theta_10m_below_MLD = grid.transform(\n", + " ds.thetao.where(ds.tmask),\n", + " 'Z',\n", + " xr.DataArray(np.array([10])),\n", + " target_data=ds.gdept_0 - ds.mldr10_1\n", ")\n", - "plt.colorbar()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Barotropic Transport Streamfunction\n", - "\n", - "We can use the barotropic velocity to calcuate the barotropic transport streamfunction, defined via\n", - "\n", - "$$ u_{bt} = - \\frac{\\partial \\Psi}{\\partial y} \\ , \\ \\ v_{bt} = \\frac{\\partial \\Psi}{\\partial x} \\ .$$\n", - "\n", - "$$ \\Psi(x,y) = \\int_0^x \\int_{bottom}^{surface} v_{bt}(x,y) \\, \\text{d}z \\, \\text{d}x $$\n", - "\n", - "We calculate this by integrating $v_{bt}$ along the X axis using the grid object's `cumint` method:" + "theta_10m_below_MLD" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 50, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Coordinates:\n", - " * t (t) object 1050-07-01 00:00:00\n", - " * y_f (y_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 35.5 36.5 37.5 38.5 39.5\n", - " * x_f (x_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 15.5 16.5 17.5 18.5 19.5\n" - ] - }, { "data": { "text/plain": [ - "(0.0, 60.0)" + "" ] }, - "execution_count": 15, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "psi = grid.cumint((ds.vo*ds.e3v).sum(dim='z_c'),'X', **bd) * 1e-6\n", - "print(psi.coords)\n", - "plt.contourf(\n", - " domcfg.glamf,\n", - " domcfg.gphif,\n", - " psi.isel({'t':0}),\n", - " levels=25,\n", - " cmap='RdBu_r'\n", - ")\n", - "plt.colorbar(label='Psi barotropic [Sv]')\n", - "plt.ylim(0,60)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "By construction, $\\psi$ is 0 at the western boundary." + "theta_10m_below_MLD.plot(robust=True)" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, - "source": [ - "### Kinetic Energy\n", - "\n", - "Finally, we plot the surface kinetic energy $1/2 (u^2 + v^2)$ by interpoloting both quantities the cell center point." - ] + "outputs": [], + "source": [] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# an example of calculating kinetic energy\n", - "ke = 0.5*(grid.interp((ds.uo)**2, 'X', **bd) + grid.interp((ds.vo)**2, 'Y', **bd))\n", - "ke[0,0].plot()" - ] + "outputs": [], + "source": [] }, { "cell_type": "code", @@ -2234,7 +4184,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -2248,7 +4198,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.6" + "version": "3.10.6" } }, "nbformat": 4, From 0a3b6163f3a600b107860f5e6c4d35af3e08e1b9 Mon Sep 17 00:00:00 2001 From: Romain Date: Tue, 4 Apr 2023 12:14:31 +0200 Subject: [PATCH 2/4] correct typo --- 04_nemo_idealized.ipynb | 220 ++++++++++++++++------------------------ 1 file changed, 89 insertions(+), 131 deletions(-) diff --git a/04_nemo_idealized.ipynb b/04_nemo_idealized.ipynb index 0a3350c..5260cd9 100644 --- a/04_nemo_idealized.ipynb +++ b/04_nemo_idealized.ipynb @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -41,7 +41,7 @@ "'0.8.1'" ] }, - "execution_count": 48, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -467,40 +467,40 @@ " umask (z_c, y_c, x_f) int8 ...\n", " vmask (z_c, y_f, x_c) int8 ...\n", " fmask (z_c, y_f, x_f) int8 ...\n", - " mbathy (y_c, x_c) int32 ...
    • " ], "text/plain": [ "\n", @@ -586,7 +586,7 @@ }, "outputs": [], "source": [ - "# In this configuration, the model is symmetric at the equator. For simplicity, we remove the southern bondaries for thi example:\n", + "# In this configuration, the model is symmetric at the equator. For simplicity, we mask the southern bondaries for this example:\n", "ds['tmask'] = ds.tmask.where(ds.y_c > 0, 0)\n", "ds['umask'] = ds.umask.where(ds.y_c > 0, 0)\n", "ds['vmask'] = ds.vmask.where(ds.y_f > 0, 0)\n", @@ -619,7 +619,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 5, @@ -1172,7 +1172,7 @@ " fill: currentColor;\n", "}\n", "
    <xarray.DataArray ()>\n",
-       "6.281e-11
    " + "6.281e-11" ], "text/plain": [ "\n", @@ -1256,7 +1256,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 10, @@ -1662,7 +1662,7 @@ "4.189e-09\n", "Coordinates:\n", " z_c int64 0\n", - " gdept_1d float64 5.0" + " gdept_1d float64 5.0" ], "text/plain": [ "\n", @@ -1754,7 +1754,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 14, @@ -1796,7 +1796,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -1806,17 +1806,17 @@ "Coordinates:\n", " * x_f (x_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 37.5 38.5 39.5 40.5 41.5\n", " * y_f (y_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 74.5 75.5 76.5 77.5 78.5\n", - " glamf (y_f, x_f) float64 0.0 1.0 2.0 3.0 4.0 ... 37.0 38.0 39.0 40.0 41.0\n", - " gphif (y_f, x_f) float64 -0.5 -0.5 -0.5 -0.5 ... 61.01 61.01 61.01 61.01\n" + " glamf (y_f, x_f) float64 ...\n", + " gphif (y_f, x_f) float64 ...\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 33, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, @@ -1857,16 +1857,16 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 18, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, @@ -1901,7 +1901,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -1923,7 +1923,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -2300,7 +2300,7 @@ " glamf (y_f, x_f) float64 0.0 1.0 2.0 3.0 4.0 ... 38.0 39.0 40.0 41.0\n", " gphif (y_f, x_f) float64 -0.5 -0.5 -0.5 -0.5 ... 61.01 61.01 61.01 61.01\n", " * z_c (z_c) int64 0 1 2 3 4 5 6 7 8 9 ... 26 27 28 29 30 31 32 33 34 35\n", - " gdept_1d (z_c) float64 ...
    • " ], "text/plain": [ "\n", @@ -2397,7 +2397,7 @@ " gdept_1d (z_c) float64 ..." ] }, - "execution_count": 20, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -2415,16 +2415,16 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 21, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, @@ -2467,7 +2467,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -2476,7 +2476,7 @@ "Frozen({'z_c': 35, 'axis_nbounds': 2, 'y_c': 79, 'x_c': 42, 'x_f': 42, 'y_f': 79, 'z_f': 36})" ] }, - "execution_count": 22, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -2488,7 +2488,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -2533,7 +2533,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -2910,8 +2910,7 @@ " gdept_1d (z_c) float64 ...\n", " * y_f (y_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 74.5 75.5 76.5 77.5 78.5\n", " glamv (y_f, x_c) float64 ...\n", - " gphiv (y_f, x_c) float64 ...\n", - " gdepv_0 (z_c, y_f, x_c) float64 5.0 5.0 5.0 5.0 ... 883.4 924.3 981.3
    • " ], "text/plain": [ "\n", @@ -3025,11 +2984,10 @@ " gdept_1d (z_c) float64 ...\n", " * y_f (y_f) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 74.5 75.5 76.5 77.5 78.5\n", " glamv (y_f, x_c) float64 ...\n", - " gphiv (y_f, x_c) float64 ...\n", - " gdepv_0 (z_c, y_f, x_c) float64 5.0 5.0 5.0 5.0 ... 883.4 924.3 981.3" + " gphiv (y_f, x_c) float64 ..." ] }, - "execution_count": 60, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -3048,7 +3006,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -3434,7 +3392,7 @@ " * y_f (y_f) float64 0.5 1.5 2.5 3.5 4.5 ... 75.5 76.5 77.5 78.5\n", " glamv (y_f, x_c) float64 ...\n", " gphiv (y_f, x_c) float64 ...\n", - " * depth_T_uniform (depth_T_uniform) float64 20.0 60.0 ... 3.94e+03 3.98e+03
    • " ], "text/plain": [ "\n", @@ -3528,7 +3486,7 @@ " * depth_T_uniform (depth_T_uniform) float64 20.0 60.0 ... 3.94e+03 3.98e+03" ] }, - "execution_count": 52, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -3551,7 +3509,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -3560,16 +3518,16 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 54, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" }, @@ -3604,7 +3562,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 26, "metadata": { "tags": [] }, @@ -3612,10 +3570,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 58, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" }, @@ -3646,7 +3604,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -4030,7 +3988,7 @@ " * y_c (y_c) int64 0 1 2 3 4 5 6 7 8 9 ... 69 70 71 72 73 74 75 76 77 78\n", " glamt (y_c, x_c) float64 -0.5 0.5 1.5 2.5 3.5 ... 37.5 38.5 39.5 40.5\n", " gphit (y_c, x_c) float64 -0.9999 -0.9999 -0.9999 ... 60.76 60.76 60.76\n", - "Dimensions without coordinates: dim_0
    • " ], "text/plain": [ "\n", @@ -4115,7 +4073,7 @@ "Dimensions without coordinates: dim_0" ] }, - "execution_count": 49, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -4132,16 +4090,16 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 50, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" }, From f5f92541e6e924a3471b94cc46480bed3c024b1e Mon Sep 17 00:00:00 2001 From: Romain Date: Tue, 4 Apr 2023 12:16:23 +0200 Subject: [PATCH 3/4] del empty cells --- 04_nemo_idealized.ipynb | 21 --------------------- 1 file changed, 21 deletions(-) diff --git a/04_nemo_idealized.ipynb b/04_nemo_idealized.ipynb index 5260cd9..165b9dc 100644 --- a/04_nemo_idealized.ipynb +++ b/04_nemo_idealized.ipynb @@ -4117,27 +4117,6 @@ "source": [ "theta_10m_below_MLD.plot(robust=True)" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 024cc3de30d255584a28dffe2fee0231a660aca8 Mon Sep 17 00:00:00 2001 From: Romain Date: Tue, 4 Apr 2023 12:21:58 +0200 Subject: [PATCH 4/4] minor typos + small reshaping of cells --- 04_nemo_idealized.ipynb | 41 ++++++++++++++++++++--------------------- 1 file changed, 20 insertions(+), 21 deletions(-) diff --git a/04_nemo_idealized.ipynb b/04_nemo_idealized.ipynb index 165b9dc..b6fb85b 100644 --- a/04_nemo_idealized.ipynb +++ b/04_nemo_idealized.ipynb @@ -606,9 +606,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Geometry of the basin\n", + "### Geometry of the basin\n", "The geometry of the simulation is a closed basin, with a bottom bathymetry, going from 2000 m at the coasts, to 4000 m in the interior of the basin. Terrain following coordinates are used and the free surface is linear (fixed vertical levels).\n", - "A 2 degrees Mercator grid is used." + "A 1 degree Mercator grid is used." ] }, { @@ -696,8 +696,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Computation examples\n", - "### Horizontal gradient of SST\n", + "# Computation examples\n", + "## Horizontal gradient of SST\n", "\n", "We will compute the horizontal component of the gradient of SST in the longitude\n", "direction as a first example to understand the logic behind the\n", @@ -760,7 +760,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Divergence Calculation\n", + "## Divergence Calculation\n", "\n", "Here we show how to calculate the divergence of the flow.\n", "The precise details of how to do this calculation are highly model- and configuration-dependent (e.g. free-surface vs. rigid lid, etc.)\n", @@ -797,7 +797,7 @@ "\n", "⚠ We need to use a negative sign for the vertical derivative, as the k-axis increases with depth.\n", "\n", - "⚠ If the model is ran without linear free surface the e3 scale factors are not constant in time, we need to take the e3t and not e3t_0 (and similar for e3u, e3v, e3f). The data are are \"thickness weighted\"." + "⚠ If the model is ran without linear free surface the e3 scale factors are not constant in time, we need to take the e3t and not e3t_0 (and similar for e3u, e3v, e3f). The data must be \"thickness weighted\"." ] }, { @@ -1209,7 +1209,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Vertical velocity\n", + "## Vertical velocity\n", "\n", "In NEMO the vertical velocity is computed from the divergence of the horizontal velocity.\n", "In non-linear free surface, the vertical velocity can't be computed offline because it also takes the time\n", @@ -1685,7 +1685,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Vorticity\n", + "## Vorticity\n", "Here we compute more derived quantities from the velocity field.\n", "\n", "The vertical component of the vorticity is a fundamental quantity of interest in ocean circulation theory. It is defined as\n", @@ -1783,7 +1783,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Barotropic Transport Streamfunction\n", + "## Barotropic Transport Streamfunction\n", "\n", "We can use the barotropic velocity to calcuate the barotropic transport streamfunction, defined via\n", "\n", @@ -1832,7 +1832,10 @@ } ], "source": [ - "ds['psi'] = grid.cumint(grid.integrate(ds.vo, 'Z'),'X', **bd) * 1e-6\n", + "ds['psi'] = grid.cumint(\n", + " grid.integrate(ds.vo, 'Z'),\n", + " 'X', **bd\n", + ") * 1e-6\n", "print(ds.psi.coords)\n", "ds.psi.plot.contourf(\n", " x='glamf', y='gphif', levels=25\n", @@ -1850,9 +1853,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Kinetic Energy\n", + "## Kinetic Energy\n", "\n", - "Finally, we plot the surface kinetic energy $1/2 (u^2 + v^2)$ by interpoloting both quantities the cell center point." + "Finally, we plot the surface kinetic energy $\\frac{1}{2} (u^2 + v^2)$ by interpolating both quantities the cell center point." ] }, { @@ -1883,7 +1886,10 @@ ], "source": [ "# an example of calculating kinetic energy\n", - "ke = 0.5*(grid.interp((ds.uo)**2, 'X', **bd) + grid.interp((ds.vo)**2, 'Y', **bd))\n", + "ke = 0.5 * (\n", + " grid.interp((ds.uo)**2, 'X', **bd)\n", + " + grid.interp((ds.vo)**2, 'Y', **bd)\n", + ")\n", "ke.where(ds.tmask).isel(z_c=0).plot(robust=True)" ] }, @@ -1891,7 +1897,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Potential vorticity\n", + "## Potential vorticity\n", "\n", "We compute potential vorticity $qv = (\\zeta + f) \\cdot N^2$ on the F point.\n", "\n", @@ -2443,13 +2449,6 @@ "qv.isel(z_c=5).plot()" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "metadata": {},