diff --git a/.circleci/config.yml b/.circleci/config.yml index 59e3675..e357842 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -26,7 +26,8 @@ commands: name: Install the conda environment command: | which conda || source $HOME/miniconda3/bin/activate base - conda env create -f .circleci/environment.yml -n docs + conda install mamba -n base -c conda-forge + mamba env create -f .circleci/environment.yml -n docs - run: name: Build the docs command: | diff --git a/.circleci/environment.yml b/.circleci/environment.yml index 42bca46..3b31ac6 100644 --- a/.circleci/environment.yml +++ b/.circleci/environment.yml @@ -12,3 +12,11 @@ dependencies: - ipython - ipykernel - seaborn +- matplotlib<3.4 +- cartopy>=0.18 +- pyinterp +- scikit-learn +- ipympl +- pip +- pip: + - git+https://github.com/psyplot/psy-transect.git diff --git a/binder/environment.yml b/binder/environment.yml index d031cb8..b6f16ba 100644 --- a/binder/environment.yml +++ b/binder/environment.yml @@ -3,6 +3,7 @@ channels: - psyplot - manics # Used by jupyter-desktop-server - conda-forge +- nodefaults dependencies: - psy-view - psy-reg @@ -10,10 +11,15 @@ dependencies: - pip - ncview - seaborn -- matplotlib>=3.3 +- matplotlib<3.4 - cartopy>=0.18 +- pyinterp +- scikit-learn +- ipympl # Required for jupyter-desktop-server - websockify - pip: - jupyter-desktop-server + - sphinx_rtd_theme + - git+https://github.com/psyplot/psy-transect diff --git a/binder/start b/binder/start index 42a99c5..2200677 100644 --- a/binder/start +++ b/binder/start @@ -7,7 +7,7 @@ PACKAGES="" mkdir .psyplot-packages -for PKG in psyplot psy-simple psy-maps psy-reg psyplot-gui psy-view; do +for PKG in psyplot psy-simple psy-maps psy-reg psyplot-gui psy-view psy-transect; do git clone https://github.com/psyplot/${PKG}.git .psyplot-packages/${PKG} PACKAGES="${PACKAGES} .psyplot-packages/${PKG}/" diff --git a/transects/data/icon_clm_demo.nc b/transects/data/icon_clm_demo.nc new file mode 100644 index 0000000..965e3a4 Binary files /dev/null and b/transects/data/icon_clm_demo.nc differ diff --git a/transects/data/icon_clm_orography.nc b/transects/data/icon_clm_orography.nc new file mode 100644 index 0000000..2619c7a Binary files /dev/null and b/transects/data/icon_clm_orography.nc differ diff --git a/transects/example_icon_clm.ipynb b/transects/example_icon_clm.ipynb new file mode 100644 index 0000000..1d69a64 --- /dev/null +++ b/transects/example_icon_clm.ipynb @@ -0,0 +1,2085 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fc81684b", + "metadata": {}, + "source": [ + "# Transect example for ICON CLM\n", + "\n", + "This example uses a regional ICON model output for transect visualization.\n", + "\n", + "We show you how to use the power of psyplot in visualizing unstructured grids to display vertically and horizontally unstructured data on its native grid for an interactive analysis.\n", + "\n", + "**Notes:** \n", + "\n", + "- psy-transect is still under development. So please be cautios and let us know at https://github.com/psyplot/psy-transect/issues if you encounter any issues.\n", + "- you should run this notebook interactively. You can either do this on mybinder.org using the following button, or install the examples yourself from the [psy-transect branch of the psyplot examples](https://github.com/psyplot/examples/tree/psy-transect).\n", + "- if you run this example on mybinder or locally, you can also use the psyplot GUI. On mybinder, click [here](/desktop) and open the `Psyplot` desktop application. Then execute the following commands from the console in the GUI:\n", + "\n", + " ```\n", + " cd ../transects\n", + " run example_icon_clm.ipynb\n", + " ```" + ] + }, + { + "cell_type": "markdown", + "id": "32466da6", + "metadata": {}, + "source": [ + "**If you are running this example in a jupyter notebook, you should uncomment the following line to make it interactive.**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "063be98d", + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment the following line when running a jupyter notebook\n", + "# %matplotlib widget" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2fd25aad", + "metadata": {}, + "outputs": [], + "source": [ + "import cartopy.crs as ccrs\n", + "import psyplot.project as psy\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from psy_transect import utils" + ] + }, + { + "cell_type": "markdown", + "id": "0cf41ec6", + "metadata": {}, + "source": [ + "The first file contains a 4D-temperature for a region model on the ICON grid (triangular bounds for longitude and latitude). " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f31f8bdf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'temp' (time: 1, height_2: 60, ncells: 17108)>\n",
+       "[1026480 values with dtype=float32]\n",
+       "Coordinates:\n",
+       "  * time      (time) datetime64[ns] 1979-01-01\n",
+       "    clon      (ncells) float32 -0.6416 -0.6749 -0.6503 ... 0.6867 0.6921 0.7017\n",
+       "    clat      (ncells) float32 1.256 1.25 1.251 1.217 ... 0.4118 0.4222 0.4435\n",
+       "  * height_2  (height_2) float64 1.0 2.0 3.0 4.0 5.0 ... 57.0 58.0 59.0 60.0\n",
+       "Dimensions without coordinates: ncells\n",
+       "Attributes:\n",
+       "    standard_name:                air_temperature\n",
+       "    long_name:                    Temperature\n",
+       "    units:                        K\n",
+       "    param:                        0.0.0\n",
+       "    CDI_grid_type:                unstructured\n",
+       "    number_of_grid_in_reference:  1\n",
+       "    institution:                  MPIMET
" + ], + "text/plain": [ + "\n", + "[1026480 values with dtype=float32]\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 1979-01-01\n", + " clon (ncells) float32 ...\n", + " clat (ncells) float32 ...\n", + " * height_2 (height_2) float64 1.0 2.0 3.0 4.0 5.0 ... 57.0 58.0 59.0 60.0\n", + "Dimensions without coordinates: ncells\n", + "Attributes:\n", + " standard_name: air_temperature\n", + " long_name: Temperature\n", + " units: K\n", + " param: 0.0.0\n", + " CDI_grid_type: unstructured\n", + " number_of_grid_in_reference: 1\n", + " institution: MPIMET" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "icon_ds = psy.open_dataset(\"data/icon_clm_demo.nc\")\n", + "icon_ds.temp" + ] + }, + { + "cell_type": "markdown", + "id": "131dab25", + "metadata": {}, + "source": [ + "The vertical dimension (`height_2`) is a generic variable for vertical layers. They are not very informative for the visualization as one cannot infer from the dimension what level corresponds to what vertical height." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "847f8d82", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'height_2' (height_2: 60)>\n",
+       "array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12., 13., 14.,\n",
+       "       15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28.,\n",
+       "       29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42.,\n",
+       "       43., 44., 45., 46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56.,\n",
+       "       57., 58., 59., 60.])\n",
+       "Coordinates:\n",
+       "  * height_2  (height_2) float64 1.0 2.0 3.0 4.0 5.0 ... 57.0 58.0 59.0 60.0\n",
+       "Attributes:\n",
+       "    standard_name:  height\n",
+       "    long_name:      generalized_height\n",
+       "    axis:           Z\n",
+       "    bounds:         height_2_bnds
" + ], + "text/plain": [ + "\n", + "array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14.,\n", + " 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28.,\n", + " 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42.,\n", + " 43., 44., 45., 46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56.,\n", + " 57., 58., 59., 60.])\n", + "Coordinates:\n", + " * height_2 (height_2) float64 1.0 2.0 3.0 4.0 5.0 ... 57.0 58.0 59.0 60.0\n", + "Attributes:\n", + " standard_name: height\n", + " long_name: generalized_height\n", + " axis: Z\n", + " bounds: height_2_bnds" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "icon_ds.height_2" + ] + }, + { + "cell_type": "markdown", + "id": "71742637", + "metadata": {}, + "source": [ + "But we have the height information for the individual layers at the different positions available. Let's have a look:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "60441629", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'HHL' (height: 61, ncells: 17108)>\n",
+       "[1043588 values with dtype=float32]\n",
+       "Coordinates:\n",
+       "    clon     (ncells) float32 -0.6416 -0.6749 -0.6503 ... 0.6867 0.6921 0.7017\n",
+       "    clat     (ncells) float32 1.256 1.25 1.251 1.217 ... 0.4118 0.4222 0.4435\n",
+       "  * height   (height) float64 1.0 2.0 3.0 4.0 5.0 ... 57.0 58.0 59.0 60.0 61.0\n",
+       "Dimensions without coordinates: ncells\n",
+       "Attributes:\n",
+       "    standard_name:                altitude\n",
+       "    long_name:                    geometric height at half level center\n",
+       "    units:                        m\n",
+       "    CDI_grid_type:                unstructured\n",
+       "    number_of_grid_in_reference:  1\n",
+       "    cell_methods:                 time: point
" + ], + "text/plain": [ + "\n", + "[1043588 values with dtype=float32]\n", + "Coordinates:\n", + " clon (ncells) float32 ...\n", + " clat (ncells) float32 ...\n", + " * height (height) float64 1.0 2.0 3.0 4.0 5.0 ... 57.0 58.0 59.0 60.0 61.0\n", + "Dimensions without coordinates: ncells\n", + "Attributes:\n", + " standard_name: altitude\n", + " long_name: geometric height at half level center\n", + " units: m\n", + " CDI_grid_type: unstructured\n", + " number_of_grid_in_reference: 1\n", + " cell_methods: time: point" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "orography = psy.open_dataset(\"data/icon_clm_orography.nc\").psy.HHL\n", + "orography" + ] + }, + { + "cell_type": "markdown", + "id": "ca1b6485", + "metadata": {}, + "source": [ + "Each grid cell in this `HHL` variable contains its altitude in metres. Note what we have 61 vertical layers in the `height` dimension of this file whereas the `height_2` dimension of the `temp` has 60 layers. This is because the `HHL` variable stores the upper and lower altitude of the individual grid cell at a given layer.\n", + "\n", + "This is why the vertical dimension of `HHL` contains one more layer than `temp`. `psyplot` cannot handle this case. We can handle 3D coordinates, but we can not handle two different grids.\n", + "\n", + "There are two transformations that we have to do:\n", + "\n", + "1. we compute the mean of the orography levels to bring it to the same dimension of `height_2` and store it as a `coordinate` for `temp`, and\n", + "2. we use the `bounds` attribute from the CF-Conventions\n", + "\n", + "`psy-transect` has a utility function that turns such a staggered grid into CF-conform bounds. You just give the variable that you want to transform, specify the name of the original dimension that you want to replace (`height`) and the name of the new dimension that you want to use `height_2`). Then you can optionally provide a dataset where we change the `coordinates` attribute accordingly." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "958acd42", + "metadata": {}, + "outputs": [], + "source": [ + "new_ds = utils.mesh_to_cf_bounds(orography, \"height\", \"height_2\", icon_ds)" + ] + }, + { + "cell_type": "markdown", + "id": "4c4e0f09", + "metadata": {}, + "source": [ + "`new_ds` now has a `HHL` and a `HHL_bnds` coordinate." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ff3b4058", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:        (bnds: 2, height_2: 60, ncells: 17108, time: 1, vertices: 3)\n",
+       "Coordinates:\n",
+       "  * time           (time) datetime64[ns] 1979-01-01\n",
+       "    clon           (ncells) float32 -0.6416 -0.6749 -0.6503 ... 0.6921 0.7017\n",
+       "    clon_bnds      (ncells, vertices) float32 -0.629 -0.6632 ... 0.7064 0.6952\n",
+       "    clat           (ncells) float32 1.256 1.25 1.251 ... 0.4118 0.4222 0.4435\n",
+       "    clat_bnds      (ncells, vertices) float32 1.262 1.256 ... 0.4482 0.4456\n",
+       "  * height_2       (height_2) float64 1.0 2.0 3.0 4.0 ... 57.0 58.0 59.0 60.0\n",
+       "    height_2_bnds  (height_2, bnds) float64 1.0 2.0 2.0 3.0 ... 60.0 60.0 61.0\n",
+       "    HHL_bnds       (height_2, ncells, bnds) float32 nan nan ... 1.263e+03\n",
+       "    HHL            (height_2, ncells) float32 nan nan nan ... 831.8 1.273e+03\n",
+       "Dimensions without coordinates: bnds, ncells, vertices\n",
+       "Data variables:\n",
+       "    temp           (time, height_2, ncells) float32 ...\n",
+       "Attributes:\n",
+       "    CDI:                  Climate Data Interface version 1.9.8 (https://mpime...\n",
+       "    Conventions:          CF-1.6\n",
+       "    history:              Tue Jun 08 11:00:07 2021: cdo selname,temp icon_197...\n",
+       "    number_of_grid_used:  99\n",
+       "    uuidOfHGrid:          0fd960b5-09da-c2a1-3b03-710a726125a0\n",
+       "    uuidOfVGrid:          96fbc4ad-735b-2bb8-0ab9-982fffb12e60\n",
+       "    source:               git@gitlab.dkrz.de:icon/icon-nwp.git@5538446faa8884...\n",
+       "    institution:          Max Planck Institute for Meteorology\n",
+       "    title:                ICON simulation\n",
+       "    references:           see MPIM/DWD publications\n",
+       "    comment:              Burkhardt Rockel (g266006) on m11257 (Linux 2.6.32-...\n",
+       "    CDO:                  Climate Data Operators version 1.9.8 (https://mpime...
" + ], + "text/plain": [ + "\n", + "Dimensions: (bnds: 2, height_2: 60, ncells: 17108, time: 1, vertices: 3)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 1979-01-01\n", + " clon (ncells) float32 -0.6416 -0.6749 -0.6503 ... 0.6921 0.7017\n", + " clon_bnds (ncells, vertices) float32 ...\n", + " clat (ncells) float32 1.256 1.25 1.251 ... 0.4118 0.4222 0.4435\n", + " clat_bnds (ncells, vertices) float32 ...\n", + " * height_2 (height_2) float64 1.0 2.0 3.0 4.0 ... 57.0 58.0 59.0 60.0\n", + " height_2_bnds (height_2, bnds) float64 ...\n", + " HHL_bnds (height_2, ncells, bnds) float32 nan nan ... 1.263e+03\n", + " HHL (height_2, ncells) float32 nan nan nan ... 831.8 1.273e+03\n", + "Dimensions without coordinates: bnds, ncells, vertices\n", + "Data variables:\n", + " temp (time, height_2, ncells) float32 ...\n", + "Attributes:\n", + " CDI: Climate Data Interface version 1.9.8 (https://mpime...\n", + " Conventions: CF-1.6\n", + " history: Tue Jun 08 11:00:07 2021: cdo selname,temp icon_197...\n", + " number_of_grid_used: 99\n", + " uuidOfHGrid: 0fd960b5-09da-c2a1-3b03-710a726125a0\n", + " uuidOfVGrid: 96fbc4ad-735b-2bb8-0ab9-982fffb12e60\n", + " source: git@gitlab.dkrz.de:icon/icon-nwp.git@5538446faa8884...\n", + " institution: Max Planck Institute for Meteorology\n", + " title: ICON simulation\n", + " references: see MPIM/DWD publications\n", + " comment: Burkhardt Rockel (g266006) on m11257 (Linux 2.6.32-...\n", + " CDO: Climate Data Operators version 1.9.8 (https://mpime..." + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_ds" + ] + }, + { + "cell_type": "markdown", + "id": "95e94fe2", + "metadata": {}, + "source": [ + "and this coordinate is also listed in the `coordinates` attribute of `temp`" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "dbcb78c0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'HHL clat clon'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_ds.temp.encoding[\"coordinates\"]" + ] + }, + { + "cell_type": "markdown", + "id": "4cc59445", + "metadata": {}, + "source": [ + "The last thing we have to do is a little fix to transform the `clat` and `clon` variables from `radians` to degrees." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "94ba84b3", + "metadata": {}, + "outputs": [], + "source": [ + "new_ds[\"clon\"] = new_ds.clon.copy(data=np.rad2deg(new_ds.clon))\n", + "new_ds[\"clat\"] = new_ds.clat.copy(data=np.rad2deg(new_ds.clat))\n", + "new_ds[\"clon\"].attrs[\"units\"] = \"degrees_east\"\n", + "new_ds[\"clat\"].attrs[\"units\"] = \"degrees_north\"\n", + "new_ds[\"clat_bnds\"] = new_ds.clat_bnds.copy(data=np.rad2deg(new_ds.clat_bnds))\n", + "new_ds[\"clon_bnds\"] = new_ds.clon_bnds.copy(data=np.rad2deg(new_ds.clon_bnds))\n", + "\n", + "encodings = {v: var.encoding for v, var in new_ds.variables.items()}\n", + "attrs = {v: var.attrs for v, var in new_ds.variables.items()}\n", + "\n", + "new_ds = new_ds.where(new_ds.HHL.notnull().any(\"height_2\"), drop=True)\n", + "\n", + "for v, enc in encodings.items():\n", + " new_ds[v].encoding.update(enc)\n", + "\n", + "for v, att in attrs.items():\n", + " new_ds[v].attrs.update(att)" + ] + }, + { + "cell_type": "markdown", + "id": "ec0fa69a", + "metadata": {}, + "source": [ + "And now we can create two plots. One is a horizontal transect at a given altitude, the second one is a vertical transect along a path.\n", + "\n", + "We can connect them to each other. We connect the two axes to each other. You can draw a line with your mouse on the left map and this will update the vertical transect. And you can move the red line in the right plot to change the horizontal transect in the right plot." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a211297a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/psommer/Documents/code/development/psyplot/psy-simple/psy_simple/plotters.py:3009: MatplotlibDeprecationWarning: \n", + "The on_mappable_changed function was deprecated in Matplotlib 3.3 and will be removed two minor releases later. Use update_normal instead.\n", + " mappable.changed()\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(9, 3.7))\n", + "\n", + "new_ds.psy.plot.horizontal_maptransect(\n", + " name=\"temp\", \n", + " decoder={\"z\": {\"HHL\"}},\n", + " # we start with a transect at 1000m\n", + " transect=1000,\n", + " # display the variable name and chosen transect on the top of the map\n", + " title=\"%(long_name)s at %(transect)1.0f metre\",\n", + " # some formatting things\n", + " cmap=\"Reds\",\n", + " xgrid=False, ygrid=False,\n", + " bounds=[\"rounded\", 11, 5, 95],\n", + " cticks=[\"bounds\", 2],\n", + " clabel=\"{desc}\",\n", + " lsm={\"ocean\": \"0.95\", \"land\": \"0.7\", \"coast\": \"k\"},\n", + " # datagrid=\"k-\", # you can uncomment this to see the unstructured horizontal grid\n", + " # create a new subplot for this map in our figure\n", + " ax=fig.add_subplot(121, projection=ccrs.PlateCarree()),\n", + " clear=True,\n", + ")\n", + "\n", + "new_ds.psy.plot.vertical_maptransect(\n", + " name=\"temp\",\n", + " decoder={\"z\": {\"HHL\"}},\n", + " # as we use unstructed data here, we should specify the minimum resolution for the\n", + " # transect in the units of coordinates (here 0.1 degrees)\n", + " transect_resolution=0.1,\n", + " # we use the haversine distance for cells along the transect for the\n", + " # x-axis\n", + " coord=\"haversine\",\n", + " # color for the background of the plot. This will show mountaineous areas for instance.\n", + " background=\"0.5\",\n", + " # datagrid=\"k-\", # you can uncomment this to see the unstructured vertical grid\n", + " xlim=\"minmax\",\n", + " xlabel=\"{desc}\",\n", + " clabel=\"{desc}\",\n", + " ylim=(0, 6000),\n", + " yticks=np.linspace(0, 6000, 7),\n", + " ax=fig.add_subplot(122),\n", + ")\n", + "\n", + "# now we connect the two plots such that you can move the line of the right\n", + "# plot to update the map, and draw a line on the map to update the vertical\n", + "# transect\n", + "p1, p2 = psy.gcp(True).plotters[-2:]\n", + "p1.connect_ax(p2.ax)\n", + "p2.connect_ax(p1.ax)\n", + "p1.share(p2, [\"colors\", \"cticklabels\", \"cticks\"])\n", + "p2.update(ylim=p2.ylim.value, yticks=p2.yticks.value, force=True)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.6" + }, + "supplementary_files": [ + "icon_grid_demo.nc", + "ugrid_demo.nc" + ], + "thumbnail_figure": 1 + }, + "nbformat": 4, + "nbformat_minor": 5 +}