From 30d31a2f739bdb01cdd9c186587e64e130d21728 Mon Sep 17 00:00:00 2001 From: irfan-farmer Date: Mon, 27 Jan 2025 14:21:53 +0100 Subject: [PATCH] Add Dockerfile with necessary packagesand example notebooks (#232) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: irfan-farmer <“khan@dkrz-de”> --- .github/workflows/d4science-images.yml | 1 + single-user-d4science-dkrzwps/Dockerfile | 24 + .../notebooks/demo-rooki-subset-by-time.ipynb | 948 ++++++ ...rooki-subset-by-time.ipynb:Zone.Identifier | 4 + .../temperature_threshold_analysis_new.ipynb | 2659 +++++++++++++++++ ...reshold_analysis_new.ipynb:Zone.Identifier | 4 + 6 files changed, 3640 insertions(+) create mode 100644 single-user-d4science-dkrzwps/Dockerfile create mode 100644 single-user-d4science-dkrzwps/notebooks/demo-rooki-subset-by-time.ipynb create mode 100644 single-user-d4science-dkrzwps/notebooks/demo-rooki-subset-by-time.ipynb:Zone.Identifier create mode 100644 single-user-d4science-dkrzwps/notebooks/temperature_threshold_analysis_new.ipynb create mode 100644 single-user-d4science-dkrzwps/notebooks/temperature_threshold_analysis_new.ipynb:Zone.Identifier diff --git a/.github/workflows/d4science-images.yml b/.github/workflows/d4science-images.yml index 0230acf..6be3f68 100644 --- a/.github/workflows/d4science-images.yml +++ b/.github/workflows/d4science-images.yml @@ -28,6 +28,7 @@ jobs: "single-user-sobigdata-itineris-evs/Dockerfile" "single-user-sobigdata-itinerisclima/Dockerfile" "single-user-d4science-jericocore/Dockerfile" + "single-user-d4science-dkrzwps/Dockerfile" base-image: diff --git a/single-user-d4science-dkrzwps/Dockerfile b/single-user-d4science-dkrzwps/Dockerfile new file mode 100644 index 0000000..b49f45f --- /dev/null +++ b/single-user-d4science-dkrzwps/Dockerfile @@ -0,0 +1,24 @@ +FROM quay.io/jupyter/minimal-notebook:2024-04-19 + +# Install necessary Python packages using pip +RUN pip install --no-cache-dir \ + numpy \ + pandas \ + xarray \ + intake \ + intake-esm \ + folium \ + hvplot \ + requests \ + ipywidgets \ + aiohttp \ + pyproj \ + pyparsing \ + zarr \ + fsspec \ + geopy \ + rooki + +# Copy sample notebooks to the working directory +COPY notebooks/ /home/jovyan/work/ + diff --git a/single-user-d4science-dkrzwps/notebooks/demo-rooki-subset-by-time.ipynb b/single-user-d4science-dkrzwps/notebooks/demo-rooki-subset-by-time.ipynb new file mode 100644 index 0000000..a74845e --- /dev/null +++ b/single-user-d4science-dkrzwps/notebooks/demo-rooki-subset-by-time.ipynb @@ -0,0 +1,948 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Run subset by time operation\n", + "\n", + "**Rooki** calls climate data operations on the **rook** processing service." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ['ROOK_URL'] = 'http://rook.dkrz.de/wps'\n", + "\n", + "from rooki import rooki" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**parameters of subset operation**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mrooki\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mcollection\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mpre_checked\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mapply_fixes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0moriginal_files\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtime_components\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0marea\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mlevel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Run subsetting on climate model data. Calls daops operators.\n", + "\n", + "Parameters\n", + "----------\n", + "collection : string\n", + " A dataset identifier or list of comma separated identifiersExample: c3s-cmip5.output1.ICHEC.EC-EARTH.historical.day.atmos.day.r1i1p1.tas.latest\n", + "time : string\n", + " The time interval (start/end) to subset over separated by '/' or a list of time points separated by ','. The format is according to the ISO-8601 standard. Example: 1860-01-01/1900-12-30 or 1860-01-01, 1870-01-01, 1880-01-01\n", + "time_components : string\n", + " Optional time components to describe parts of the time period (e.g. year, month and day). Example: month:01,02,03 or year:1970,1980|month:01,02,03\n", + "area : string\n", + " The area to subset over as 4 comma separated values.Example: 0.,49.,10.,65\n", + "level : string\n", + " The level range to subset over separated by a / or a list of level values separated by ','.Example: 1000/2000 or 1000, 2000, 3000\n", + "pre_checked : boolean\n", + " Use checked data only.\n", + "apply_fixes : boolean\n", + " Apply fixes to datasets.\n", + "original_files : boolean\n", + " Return original files only.\n", + "\n", + "Returns\n", + "-------\n", + "output : ComplexData:mimetype:`application/metalink+xml; version=4.0`\n", + " Metalink v4 document with references to NetCDF files.\n", + "prov : ComplexData:mimetype:`application/json`\n", + " Provenance document using W3C standard.\n", + "prov_plot : ComplexData:mimetype:`image/png`\n", + " Provenance document as diagram.\n", + "\u001b[0;31mFile:\u001b[0m ~/\n", + "\u001b[0;31mType:\u001b[0m method" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rooki.subset?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**data inventory**\n", + "\n", + "https://github.com/cp4cds/c3s_34g_manifests/tree/master/inventories\n", + "\n", + "using:\n", + "https://github.com/cp4cds/c3s_34g_manifests/blob/master/inventories/c3s-cmip6/c3s-cmip6_v20210126.yml" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**run subset**" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "resp = rooki.subset(\n", + " collection='c3s-cmip6.ScenarioMIP.INM.INM-CM5-0.ssp245.r1i1p1f1.day.tas.gr1.v20190619',\n", + " time='2016-01-01/2016-12-30',\n", + ")\n", + "resp.ok" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**show metalink output**" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'http://rook7.cloud.dkrz.de:80/outputs/rook/9acf3060-d80e-11ef-8c79-fa163eb671ca/input.meta4'" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "resp.url" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + " 2025-01-21T16:44:35Z\n", + " PyWPS/4.5.2\n", + "\n", + " \n", + " NetCDF file\n", + " 18951905\n", + " http://rook7.cloud.dkrz.de:80/outputs/rook/9d9dec78-d80e-11ef-87be-fa163eb671ca/tas_day_INM-CM5-0_ssp245_r1i1p1f1_gr1_20160101-20161230.nc\n", + " \n", + " \n", + "\n", + "\n" + ] + } + ], + "source": [ + "print(resp.xml)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Size in MBytes**" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "18.07394504547119" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "resp.size_in_mb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**URLs in metalink document ...**" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['http://rook7.cloud.dkrz.de:80/outputs/rook/9d9dec78-d80e-11ef-87be-fa163eb671ca/tas_day_INM-CM5-0_ssp245_r1i1p1f1_gr1_20160101-20161230.nc']" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "resp.download_urls()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**download files ...**" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading to /tmp/metalink_r3b75l6o/tas_day_INM-CM5-0_ssp245_r1i1p1f1_gr1_20160101-20161230.nc.\n" + ] + }, + { + "data": { + "text/plain": [ + "['/tmp/metalink_r3b75l6o/tas_day_INM-CM5-0_ssp245_r1i1p1f1_gr1_20160101-20161230.nc']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "resp.download()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**... and open with xarray**" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Already downloaded tas_day_INM-CM5-0_ssp245_r1i1p1f1_gr1_20160101-20161230.nc.\n" + ] + } + ], + "source": [ + "dsets = resp.datasets()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 31MB\n",
+       "Dimensions:    (time: 364, bnds: 2, lat: 120, lon: 180)\n",
+       "Coordinates:\n",
+       "  * time       (time) object 3kB 2016-01-01 12:00:00 ... 2016-12-30 12:00:00\n",
+       "  * lat        (lat) float64 960B -89.25 -87.75 -86.25 ... 86.25 87.75 89.25\n",
+       "  * lon        (lon) float64 1kB 0.0 2.0 4.0 6.0 8.0 ... 352.0 354.0 356.0 358.0\n",
+       "    height     float64 8B ...\n",
+       "Dimensions without coordinates: bnds\n",
+       "Data variables:\n",
+       "    time_bnds  (time, bnds) object 6kB ...\n",
+       "    lat_bnds   (lat, bnds) float64 2kB ...\n",
+       "    lon_bnds   (lon, bnds) float64 3kB ...\n",
+       "    tas        (time, lat, lon) float32 31MB ...\n",
+       "Attributes: (12/47)\n",
+       "    Conventions:            CF-1.7 CMIP-6.2\n",
+       "    activity_id:            ScenarioMIP\n",
+       "    branch_method:          standard\n",
+       "    branch_time_in_child:   60225.0\n",
+       "    branch_time_in_parent:  60225.0\n",
+       "    contact:                Evgeny Volodin (volodinev@gmail.com)\n",
+       "    ...                     ...\n",
+       "    title:                  INM-CM5-0 output prepared for CMIP6\n",
+       "    tracking_id:            hdl:21.14100/89cab4a2-c867-4bb5-a215-622f969cd844\n",
+       "    variable_id:            tas\n",
+       "    variant_label:          r1i1p1f1\n",
+       "    license:                CMIP6 model data produced by Lawrence Livermore P...\n",
+       "    cmor_version:           3.4.0
" + ], + "text/plain": [ + " Size: 31MB\n", + "Dimensions: (time: 364, bnds: 2, lat: 120, lon: 180)\n", + "Coordinates:\n", + " * time (time) object 3kB 2016-01-01 12:00:00 ... 2016-12-30 12:00:00\n", + " * lat (lat) float64 960B -89.25 -87.75 -86.25 ... 86.25 87.75 89.25\n", + " * lon (lon) float64 1kB 0.0 2.0 4.0 6.0 8.0 ... 352.0 354.0 356.0 358.0\n", + " height float64 8B ...\n", + "Dimensions without coordinates: bnds\n", + "Data variables:\n", + " time_bnds (time, bnds) object 6kB ...\n", + " lat_bnds (lat, bnds) float64 2kB ...\n", + " lon_bnds (lon, bnds) float64 3kB ...\n", + " tas (time, lat, lon) float32 31MB ...\n", + "Attributes: (12/47)\n", + " Conventions: CF-1.7 CMIP-6.2\n", + " activity_id: ScenarioMIP\n", + " branch_method: standard\n", + " branch_time_in_child: 60225.0\n", + " branch_time_in_parent: 60225.0\n", + " contact: Evgeny Volodin (volodinev@gmail.com)\n", + " ... ...\n", + " title: INM-CM5-0 output prepared for CMIP6\n", + " tracking_id: hdl:21.14100/89cab4a2-c867-4bb5-a215-622f969cd844\n", + " variable_id: tas\n", + " variant_label: r1i1p1f1\n", + " license: CMIP6 model data produced by Lawrence Livermore P...\n", + " cmor_version: 3.4.0" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds = dsets[0]\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Conventions': 'CF-1.7 CMIP-6.2',\n", + " 'activity_id': 'ScenarioMIP',\n", + " 'branch_method': 'standard',\n", + " 'branch_time_in_child': np.float64(60225.0),\n", + " 'branch_time_in_parent': np.float64(60225.0),\n", + " 'contact': 'Evgeny Volodin (volodinev@gmail.com)',\n", + " 'creation_date': '2019-06-18T15:27:34Z',\n", + " 'data_specs_version': '01.00.29',\n", + " 'experiment': 'update of RCP4.5 based on SSP2',\n", + " 'experiment_id': 'ssp245',\n", + " 'external_variables': 'areacella',\n", + " 'forcing_index': np.int32(1),\n", + " 'frequency': 'day',\n", + " 'further_info_url': 'https://furtherinfo.es-doc.org/CMIP6.INM.INM-CM5-0.ssp245.none.r1i1p1f1',\n", + " 'grid': 'gs2x1.5',\n", + " 'grid_label': 'gr1',\n", + " 'history': '2019-06-18T15:27:33Z ;rewrote data to be consistent with ScenarioMIP for variable clt found in table day.',\n", + " 'initialization_index': np.int32(1),\n", + " 'institution': 'Institute for Numerical Mathematics, Russian Academy of Science, Moscow 119991, Russia',\n", + " 'institution_id': 'INM',\n", + " 'mip_era': 'CMIP6',\n", + " 'nominal_resolution': '100 km',\n", + " 'parent_activity_id': 'CMIP',\n", + " 'parent_experiment_id': 'historical',\n", + " 'parent_mip_era': 'CMIP6',\n", + " 'parent_source_id': 'INM-CM5-0',\n", + " 'parent_time_units': 'days since 1850-01-01',\n", + " 'parent_variant_label': 'r1i1p1f1',\n", + " 'physics_index': np.int32(1),\n", + " 'product': 'model-output',\n", + " 'realization_index': np.int32(1),\n", + " 'realm': 'atmos',\n", + " 'references': 'RJNAMM 2018, 367-374. DOI: 10.1515/rnam-2018-0032',\n", + " 'run_variant': 'standard',\n", + " 'source': 'INM-CM5-0 (2016): \\naerosol: INM-AER1\\natmos: INM-AM5-0 (2x1.5; 180 x 120 longitude/latitude; 73 levels; top level sigma = 0.0002)\\natmosChem: none\\nland: INM-LND1\\nlandIce: none\\nocean: INM-OM5 (North Pole shifted to 60N, 90E. 0.5x0.25; 720 x 720 longitude/latitude; 40 levels; vertical sigma coordinate)\\nocnBgchem: none\\nseaIce: INM-ICE1',\n", + " 'source_id': 'INM-CM5-0',\n", + " 'source_type': 'AOGCM AER',\n", + " 'sub_experiment': 'none',\n", + " 'sub_experiment_id': 'none',\n", + " 'table_id': 'day',\n", + " 'table_info': 'Creation Date:(20 February 2019) MD5:951084b632bd52c3f6224e495b1cb65e',\n", + " 'title': 'INM-CM5-0 output prepared for CMIP6',\n", + " 'tracking_id': 'hdl:21.14100/89cab4a2-c867-4bb5-a215-622f969cd844',\n", + " 'variable_id': 'tas',\n", + " 'variant_label': 'r1i1p1f1',\n", + " 'license': 'CMIP6 model data produced by Lawrence Livermore PCMDI is licensed under a Creative Commons Attribution ShareAlike 4.0 International License (https://creativecommons.org/licenses). Consult https://pcmdi.llnl.gov/CMIP6/TermsOfUse for terms of use governing CMIP6 output, including citation requirements and proper acknowledgment. Further information about this data, including some limitations, can be found via the further_info_url (recorded as a global attribute in this file) and at https:///pcmdi.llnl.gov/. The data producers and data providers make no warranty, either express or implied, including, but not limited to, warranties of merchantability and fitness for a particular purpose. All liabilities arising from the supply of the information (including any liability arising in negligence) are excluded to the fullest extent permitted by law.',\n", + " 'cmor_version': '3.4.0'}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds.attrs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**provenance**" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'http://rook7.cloud.dkrz.de:80/outputs/rook/9acf3060-d80e-11ef-8c79-fa163eb671ca/provenance.png'" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prov_plot_url = resp.provenance_image()\n", + "prov_plot_url" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "Image(prov_plot_url)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "WPS Environment", + "language": "python", + "name": "wps_env" + }, + "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.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/single-user-d4science-dkrzwps/notebooks/demo-rooki-subset-by-time.ipynb:Zone.Identifier b/single-user-d4science-dkrzwps/notebooks/demo-rooki-subset-by-time.ipynb:Zone.Identifier new file mode 100644 index 0000000..5d9065f --- /dev/null +++ b/single-user-d4science-dkrzwps/notebooks/demo-rooki-subset-by-time.ipynb:Zone.Identifier @@ -0,0 +1,4 @@ +[ZoneTransfer] +ZoneId=3 +ReferrerUrl=https://jupyterhub.d4science.org/user/khan/lab/tree/demo-rooki-subset-by-time.ipynb +HostUrl=https://jupyterhub.d4science.org/user/khan/files/demo-rooki-subset-by-time.ipynb?_xsrf=2%7Cfe84d425%7Cbf04ba7801193c7745b06b35eb348b1e%7C1736772124 diff --git a/single-user-d4science-dkrzwps/notebooks/temperature_threshold_analysis_new.ipynb b/single-user-d4science-dkrzwps/notebooks/temperature_threshold_analysis_new.ipynb new file mode 100644 index 0000000..8be633c --- /dev/null +++ b/single-user-d4science-dkrzwps/notebooks/temperature_threshold_analysis_new.ipynb @@ -0,0 +1,2659 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#
Analyze and Visualize Data with Intake-ESM, XArray and hvPlot
\n", + "##
A Climate Data Use Case
\n", + "\n", + "We will show here how to count the annual summer days for a particular geolocation of your choice using the results of a climate model, in particular, we can chose one of the historical or one of the shared socioeconomic pathway (ssp) experiments of the Coupled Model Intercomparison Project [CMIP6](https://pcmdi.llnl.gov/CMIP6/).\n", + "\n", + "This Jupyter notebook is meant to run in the Jupyterhub server of the German Climate Computing Center [DKRZ](https://www.dkrz.de/) which is an [ESGF](https://esgf.llnl.gov/) repository that hosts 4 petabytes of CMIP6 data. Please, choose the Python 3 unstable kernel on the Kernel tab above, it contains all the common geoscience packages. See more information on how to run Jupyter notebooks at DKRZ [here](https://www.dkrz.de/up/systems/mistral/programming/jupyter-notebook). Find there how to run this Jupyter notebook in the DKRZ server out of the Jupyterhub, which will entail that you create the environment accounting for the required package dependencies. Running this Jupyter notebook in your premise, which is also known as [client-side](https://en.wikipedia.org/wiki/Client-side) computing, will also require that you install the necessary packages on you own but it will anyway fail because you will not have direct access to the data pool. Direct access to the data pool is one of the main benefits of the [server-side](https://en.wikipedia.org/wiki/Server-side) data-near computing we demonstrate in this use case. \n", + "\n", + "Thanks to the data and computer scientists Marco Kulüke, Fabian Wachsmann, Regina Kwee-Hinzmann, Caroline Arnold, Felix Stiehler, Maria Moreno, and Stephan Kindermann at DKRZ for their contribution to this notebook." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this use case you will learn the following:\n", + "- How to access a dataset from the DKRZ CMIP6 model data archive\n", + "- How to count the annual number of summer days for a particular geolocation using this model dataset\n", + "- How to visualize the results\n", + "\n", + "\n", + "You will use:\n", + "- [Intake](https://github.com/intake/intake) for finding the data in the catalog of the DKRZ archive \n", + "- [Xarray](http://xarray.pydata.org/en/stable/) for loading and processing the data \n", + "- [Pandas](https://pandas.pydata.org/) for structuring the data \n", + "- [hvPlot](https://hvplot.holoviz.org/index.html) for visualizing the data in the Jupyter notebook and save the plots on your local computer " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 0. Load Packages" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " const force = true;\n", + " const py_version = '3.6.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " const reloading = false;\n", + " const Bokeh = root.Bokeh;\n", + "\n", + " // Set a timeout for this load but only if we are not already initializing\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks;\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + " if (js_exports == null) js_exports = {};\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + "\n", + " if (root._bokeh_is_loading > 0) {\n", + " // Don't load bokeh if it is still initializing\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " // There is nothing to load\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + " window._bokeh_on_load = on_load\n", + "\n", + " function on_error(e) {\n", + " const src_el = e.srcElement\n", + " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", + " }\n", + "\n", + " const skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", + " root._bokeh_is_loading = css_urls.length + 0;\n", + " } else {\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", + " }\n", + "\n", + " const existing_stylesheets = []\n", + " const links = document.getElementsByTagName('link')\n", + " for (let i = 0; i < links.length; i++) {\n", + " const link = links[i]\n", + " if (link.href != null) {\n", + " existing_stylesheets.push(link.href)\n", + " }\n", + " }\n", + " for (let i = 0; i < css_urls.length; i++) {\n", + " const url = css_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", + " on_load()\n", + " continue;\n", + " }\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " } var existing_scripts = []\n", + " const scripts = document.getElementsByTagName('script')\n", + " for (let i = 0; i < scripts.length; i++) {\n", + " var script = scripts[i]\n", + " if (script.src != null) {\n", + " existing_scripts.push(script.src)\n", + " }\n", + " }\n", + " for (let i = 0; i < js_urls.length; i++) {\n", + " const url = js_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " const element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (let i = 0; i < js_modules.length; i++) {\n", + " const url = js_modules[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (const name in js_exports) {\n", + " const url = js_exports[name];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " element.textContent = `\n", + " import ${name} from \"${url}\"\n", + " window.${name} = ${name}\n", + " window._bokeh_on_load()\n", + " `\n", + " document.head.appendChild(element);\n", + " }\n", + " if (!js_urls.length && !js_modules.length) {\n", + " on_load()\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " const js_urls = [\"https://cdn.holoviz.org/panel/1.5.5/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.6.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.5/dist/panel.min.js\"];\n", + " const js_modules = [];\n", + " const js_exports = {};\n", + " const css_urls = [];\n", + " const inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {} // ensure no trailing comma for IE\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if ((root.Bokeh !== undefined) || (force === true)) {\n", + " for (let i = 0; i < inline_js.length; i++) {\n", + " try {\n", + " inline_js[i].call(root, root.Bokeh);\n", + " } catch(e) {\n", + " if (!reloading) {\n", + " throw e;\n", + " }\n", + " }\n", + " }\n", + " // Cache old bokeh versions\n", + " if (Bokeh != undefined && !reloading) {\n", + " var NewBokeh = root.Bokeh;\n", + " if (Bokeh.versions === undefined) {\n", + " Bokeh.versions = new Map();\n", + " }\n", + " if (NewBokeh.version !== Bokeh.version) {\n", + " Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", + " }\n", + " root.Bokeh = Bokeh;\n", + " }\n", + " } else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " }\n", + " root._bokeh_is_initializing = false\n", + " }\n", + "\n", + " function load_or_wait() {\n", + " // Implement a backoff loop that tries to ensure we do not load multiple\n", + " // versions of Bokeh and its dependencies at the same time.\n", + " // In recent versions we use the root._bokeh_is_initializing flag\n", + " // to determine whether there is an ongoing attempt to initialize\n", + " // bokeh, however for backward compatibility we also try to ensure\n", + " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", + " // before older versions are fully initialized.\n", + " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", + " // If the timeout and bokeh was not successfully loaded we reset\n", + " // everything and try loading again\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_is_initializing = false;\n", + " root._bokeh_onload_callbacks = undefined;\n", + " root._bokeh_is_loading = 0\n", + " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", + " load_or_wait();\n", + " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", + " setTimeout(load_or_wait, 100);\n", + " } else {\n", + " root._bokeh_is_initializing = true\n", + " root._bokeh_onload_callbacks = []\n", + " const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n", + " if (!reloading && !bokeh_loaded) {\n", + " if (root.Bokeh) {\n", + " root.Bokeh = undefined;\n", + " }\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " }\n", + " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", + " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + " run_inline_js();\n", + " });\n", + " }\n", + " }\n", + " // Give older versions of the autoload script a head-start to ensure\n", + " // they initialize before we start loading newer version.\n", + " setTimeout(load_or_wait, 100)\n", + "}(window));" + ], + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n const py_version = '3.6.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = false;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.5.5/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.6.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.5/dist/panel.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", + " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", + "}\n", + "\n", + "\n", + " function JupyterCommManager() {\n", + " }\n", + "\n", + " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", + " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " comm_manager.register_target(comm_id, function(comm) {\n", + " comm.on_msg(msg_handler);\n", + " });\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", + " comm.onMsg = msg_handler;\n", + " });\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " console.log(message)\n", + " var content = {data: message.data, comm_id};\n", + " var buffers = []\n", + " for (var buffer of message.buffers || []) {\n", + " buffers.push(new DataView(buffer))\n", + " }\n", + " var metadata = message.metadata || {};\n", + " var msg = {content, buffers, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " })\n", + " }\n", + " }\n", + "\n", + " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", + " if (comm_id in window.PyViz.comms) {\n", + " return window.PyViz.comms[comm_id];\n", + " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", + " if (msg_handler) {\n", + " comm.on_msg(msg_handler);\n", + " }\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", + " comm.open();\n", + " if (msg_handler) {\n", + " comm.onMsg = msg_handler;\n", + " }\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", + " comm_promise.then((comm) => {\n", + " window.PyViz.comms[comm_id] = comm;\n", + " if (msg_handler) {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " var content = {data: message.data};\n", + " var metadata = message.metadata || {comm_id};\n", + " var msg = {content, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " }) \n", + " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", + " return comm_promise.then((comm) => {\n", + " comm.send(data, metadata, buffers, disposeOnDone);\n", + " });\n", + " };\n", + " var comm = {\n", + " send: sendClosure\n", + " };\n", + " }\n", + " window.PyViz.comms[comm_id] = comm;\n", + " return comm;\n", + " }\n", + " window.PyViz.comm_manager = new JupyterCommManager();\n", + " \n", + "\n", + "\n", + "var JS_MIME_TYPE = 'application/javascript';\n", + "var HTML_MIME_TYPE = 'text/html';\n", + "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", + "var CLASS_NAME = 'output';\n", + "\n", + "/**\n", + " * Render data to the DOM node\n", + " */\n", + "function render(props, node) {\n", + " var div = document.createElement(\"div\");\n", + " var script = document.createElement(\"script\");\n", + " node.appendChild(div);\n", + " node.appendChild(script);\n", + "}\n", + "\n", + "/**\n", + " * Handle when a new output is added\n", + " */\n", + "function handle_add_output(event, handle) {\n", + " var output_area = handle.output_area;\n", + " var output = handle.output;\n", + " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + " if (id !== undefined) {\n", + " var nchildren = toinsert.length;\n", + " var html_node = toinsert[nchildren-1].children[0];\n", + " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var scripts = [];\n", + " var nodelist = html_node.querySelectorAll(\"script\");\n", + " for (var i in nodelist) {\n", + " if (nodelist.hasOwnProperty(i)) {\n", + " scripts.push(nodelist[i])\n", + " }\n", + " }\n", + "\n", + " scripts.forEach( function (oldScript) {\n", + " var newScript = document.createElement(\"script\");\n", + " var attrs = [];\n", + " var nodemap = oldScript.attributes;\n", + " for (var j in nodemap) {\n", + " if (nodemap.hasOwnProperty(j)) {\n", + " attrs.push(nodemap[j])\n", + " }\n", + " }\n", + " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", + " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", + " oldScript.parentNode.replaceChild(newScript, oldScript);\n", + " });\n", + " if (JS_MIME_TYPE in output.data) {\n", + " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", + " }\n", + " output_area._hv_plot_id = id;\n", + " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", + " window.PyViz.plot_index[id] = Bokeh.index[id];\n", + " } else {\n", + " window.PyViz.plot_index[id] = null;\n", + " }\n", + " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " var bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var script_attrs = bk_div.children[0].attributes;\n", + " for (var i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + "function handle_clear_output(event, handle) {\n", + " var id = handle.cell.output_area._hv_plot_id;\n", + " var server_id = handle.cell.output_area._bokeh_server_id;\n", + " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", + " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", + " if (server_id !== null) {\n", + " comm.send({event_type: 'server_delete', 'id': server_id});\n", + " return;\n", + " } else if (comm !== null) {\n", + " comm.send({event_type: 'delete', 'id': id});\n", + " }\n", + " delete PyViz.plot_index[id];\n", + " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", + " var doc = window.Bokeh.index[id].model.document\n", + " doc.clear();\n", + " const i = window.Bokeh.documents.indexOf(doc);\n", + " if (i > -1) {\n", + " window.Bokeh.documents.splice(i, 1);\n", + " }\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle kernel restart event\n", + " */\n", + "function handle_kernel_cleanup(event, handle) {\n", + " delete PyViz.comms[\"hv-extension-comm\"];\n", + " window.PyViz.plot_index = {}\n", + "}\n", + "\n", + "/**\n", + " * Handle update_display_data messages\n", + " */\n", + "function handle_update_output(event, handle) {\n", + " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", + " handle_add_output(event, handle)\n", + "}\n", + "\n", + "function register_renderer(events, OutputArea) {\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " var toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[0]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " events.on('output_added.OutputArea', handle_add_output);\n", + " events.on('output_updated.OutputArea', handle_update_output);\n", + " events.on('clear_output.CodeCell', handle_clear_output);\n", + " events.on('delete.Cell', handle_clear_output);\n", + " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", + "\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " safe: true,\n", + " index: 0\n", + " });\n", + "}\n", + "\n", + "if (window.Jupyter !== undefined) {\n", + " try {\n", + " var events = require('base/js/events');\n", + " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " } catch(err) {\n", + " }\n", + "}\n" + ], + "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "57a87336-72e6-4688-ac0f-92aa2a4c608e" + } + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np # fundamental package for scientific computing\n", + "import pandas as pd # data analysis and manipulation tool\n", + "import xarray as xr # handling labelled multi-dimensional arrays\n", + "import intake # to find data in a catalog, this notebook explains how it works\n", + "from ipywidgets import widgets # to use widgets in the Jupyer Notebook\n", + "from geopy.geocoders import Nominatim # Python client for several popular geocoding web services\n", + "import folium # visualization tool for maps\n", + "import hvplot.pandas # visualization tool for interactive plots\n", + "import fsspec # unify various projects and classes to work with remote filesystems andfile-system-like abstractions using a standard pythonic interface\n", + "import zarr\n", + "import intake_esm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Which dataset do we need? -> Place, and Year\n", + "\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feel free to change the default values.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1bb6a02052174481a52f47aab8388b1d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Text(value='Hamburg', description='Enter place:')" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7f1b3ef990384d61a0f7aedf6b25ee82", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Dropdown(description='Select year: ', options=(2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 202…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Produce the widget where we can select what geolocation and year are interested on \n", + "\n", + "print(\"Feel free to change the default values.\")\n", + "\n", + "place_box = widgets.Text(description=\"Enter place:\", value=\"Hamburg\")\n", + "display(place_box)\n", + "\n", + "year_box = widgets.Dropdown(options=range(2015, 2101), description=\"Select year: \", disabled=False,)\n", + "display(year_box)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1 Find Coordinates of chosen Place\n", + "If ambiguous, the most likely coordinates will be chosen, e.g. \"Hamburg\" results in \"Hamburg, 20095, Deutschland\", (53.55 North, 10.00 East)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hamburg, Deutschland\n", + "(53.550341, 10.000654)\n" + ] + } + ], + "source": [ + "# We use the module Nominatim, which gives us the geographical coordinates of the place we selected above\n", + "\n", + "geolocator = Nominatim(user_agent=\"any_agent\")\n", + "location = geolocator.geocode(place_box.value)\n", + "\n", + "print(location.address)\n", + "print((location.latitude, location.longitude))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "### 1.2 Show Place on a Map" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Make this Notebook Trusted to load map: File -> Trust Notebook
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# We use the folium package to plot our selected geolocation in a map\n", + "\n", + "m = folium.Map(location=[location.latitude, location.longitude])\n", + "tooltip = location.latitude, location.longitude\n", + "folium.Marker([location.latitude, location.longitude], tooltip=tooltip).add_to(m)\n", + "display(m)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have defined the place and time. Now, we can search for the climate model dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Intake Catalog\n", + "Similar to the shopping catalog at your favorite online bookstore, the intake catalog contains information (e.g. model, variables, and time range) about each dataset (the title, author, and number of pages of the book, for instance) that you can access before loading the data. It means that thanks to the catalog, you can find where is the book just by using some keywords and you do not need to hold it in your hand to know the number of pages, for instance.\n", + "\n", + "### 2.1 Load the Intake Catalog\n", + "We load the catalog descriptor with the intake package. The catalog is updated daily. The catalog descriptor is created by the DKRZ developers that manage the catalog, you do not need to care so much about it, knowing where it is and loading it is enough:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/lib/python3.12/site-packages/intake_esm/cat.py:249: DtypeWarning: Columns (21,22,23) have mixed types. Specify dtype option on import or set low_memory=False.\n", + " df = pd.read_csv(\n" + ] + } + ], + "source": [ + "# Open the catalog with the intake package and name it \"col\" as short for \"collection\"\n", + "col=intake.open_esm_datastore(\"https://gitlab.dkrz.de/data-infrastructure-services/intake-esm/-/raw/master/esm-collections/cloud-access/dkrz_cmip6_disk.json\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['activity_id', 'institution_id', 'source_id', 'experiment_id',\n", + " 'member_id', 'table_id', 'variable_id', 'grid_label', 'dcpp_init_year',\n", + " 'version', 'time_range', 'path', 'opendap_url', 'project',\n", + " 'simulation_id', 'grid_id', 'frequency', 'time_reduction', 'long_name',\n", + " 'units', 'realm', 'level_type', 'time_min', 'time_max', 'format',\n", + " 'uri'],\n", + " dtype='object')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "col.df.columns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see what is inside the intake catalog. The underlying data base is given as a pandas dataframe which we can access with \"col.df\". Then, \"col.df.head()\" shows us the first rows of the table of the catalog." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This catalog contains all datasets of the CMIP6 archive at DKRZ. In the next step we narrow the results down by chosing a model and variable." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.2 Browse the Intake Catalog\n", + "In this example we chose the Max-Planck Earth System Model in High Resolution Mode (\"MPI-ESM1-2-HR\") and the maximum temperature near surface (\"tasmax\") as variable. We also choose an experiment. CMIP6 comprises several kind of experiments. Each experiment has various simulation members. you can find more information in the [CMIP6 Model and Experiment Documentation](https://pcmdi.llnl.gov/CMIP6/Guide/dataUsers.html#5-model-and-experiment-documentation)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
activity_idinstitution_idsource_idexperiment_idmember_idtable_idvariable_idgrid_labeldcpp_init_yearversion...frequencytime_reductionlong_nameunitsrealmlevel_typetime_mintime_maxformaturi
0CMIPMPI-MMPI-ESM1-2-HR1pctCO2r1i1p1f1daytasmaxgnNaNv20190710...daymaximumDaily Maximum Near-Surface Air TemperatureKatmosNaN18500101.018541231netcdf/work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E...
1CMIPMPI-MMPI-ESM1-2-HR1pctCO2r1i1p1f1daytasmaxgnNaNv20190710...daymaximumDaily Maximum Near-Surface Air TemperatureKatmosNaN18550101.018591231netcdf/work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E...
2CMIPMPI-MMPI-ESM1-2-HR1pctCO2r1i1p1f1daytasmaxgnNaNv20190710...daymaximumDaily Maximum Near-Surface Air TemperatureKatmosNaN18600101.018641231netcdf/work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E...
3CMIPMPI-MMPI-ESM1-2-HR1pctCO2r1i1p1f1daytasmaxgnNaNv20190710...daymaximumDaily Maximum Near-Surface Air TemperatureKatmosNaN18650101.018691231netcdf/work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E...
4CMIPMPI-MMPI-ESM1-2-HR1pctCO2r1i1p1f1daytasmaxgnNaNv20190710...daymaximumDaily Maximum Near-Surface Air TemperatureKatmosNaN18700101.018741231netcdf/work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E...
..................................................................
648ScenarioMIPDKRZMPI-ESM1-2-HRssp585r1i1p1f1daytasmaxgnNaNv20190710...daymaximumDaily Maximum Near-Surface Air TemperatureKatmosNaN20800101.020841231netcdf/work/ik1017/CMIP6/data/CMIP6/ScenarioMIP/DKRZ...
649ScenarioMIPDKRZMPI-ESM1-2-HRssp585r1i1p1f1daytasmaxgnNaNv20190710...daymaximumDaily Maximum Near-Surface Air TemperatureKatmosNaN20850101.020891231netcdf/work/ik1017/CMIP6/data/CMIP6/ScenarioMIP/DKRZ...
650ScenarioMIPDKRZMPI-ESM1-2-HRssp585r1i1p1f1daytasmaxgnNaNv20190710...daymaximumDaily Maximum Near-Surface Air TemperatureKatmosNaN20900101.020941231netcdf/work/ik1017/CMIP6/data/CMIP6/ScenarioMIP/DKRZ...
651ScenarioMIPDKRZMPI-ESM1-2-HRssp585r1i1p1f1daytasmaxgnNaNv20190710...daymaximumDaily Maximum Near-Surface Air TemperatureKatmosNaN20950101.020991231netcdf/work/ik1017/CMIP6/data/CMIP6/ScenarioMIP/DKRZ...
652ScenarioMIPDKRZMPI-ESM1-2-HRssp585r1i1p1f1daytasmaxgnNaNv20190710...daymaximumDaily Maximum Near-Surface Air TemperatureKatmosNaN21000101.021001231netcdf/work/ik1017/CMIP6/data/CMIP6/ScenarioMIP/DKRZ...
\n", + "

653 rows × 26 columns

\n", + "
" + ], + "text/plain": [ + " activity_id institution_id source_id experiment_id member_id \\\n", + "0 CMIP MPI-M MPI-ESM1-2-HR 1pctCO2 r1i1p1f1 \n", + "1 CMIP MPI-M MPI-ESM1-2-HR 1pctCO2 r1i1p1f1 \n", + "2 CMIP MPI-M MPI-ESM1-2-HR 1pctCO2 r1i1p1f1 \n", + "3 CMIP MPI-M MPI-ESM1-2-HR 1pctCO2 r1i1p1f1 \n", + "4 CMIP MPI-M MPI-ESM1-2-HR 1pctCO2 r1i1p1f1 \n", + ".. ... ... ... ... ... \n", + "648 ScenarioMIP DKRZ MPI-ESM1-2-HR ssp585 r1i1p1f1 \n", + "649 ScenarioMIP DKRZ MPI-ESM1-2-HR ssp585 r1i1p1f1 \n", + "650 ScenarioMIP DKRZ MPI-ESM1-2-HR ssp585 r1i1p1f1 \n", + "651 ScenarioMIP DKRZ MPI-ESM1-2-HR ssp585 r1i1p1f1 \n", + "652 ScenarioMIP DKRZ MPI-ESM1-2-HR ssp585 r1i1p1f1 \n", + "\n", + " table_id variable_id grid_label dcpp_init_year version ... frequency \\\n", + "0 day tasmax gn NaN v20190710 ... day \n", + "1 day tasmax gn NaN v20190710 ... day \n", + "2 day tasmax gn NaN v20190710 ... day \n", + "3 day tasmax gn NaN v20190710 ... day \n", + "4 day tasmax gn NaN v20190710 ... day \n", + ".. ... ... ... ... ... ... ... \n", + "648 day tasmax gn NaN v20190710 ... day \n", + "649 day tasmax gn NaN v20190710 ... day \n", + "650 day tasmax gn NaN v20190710 ... day \n", + "651 day tasmax gn NaN v20190710 ... day \n", + "652 day tasmax gn NaN v20190710 ... day \n", + "\n", + " time_reduction long_name units realm \\\n", + "0 maximum Daily Maximum Near-Surface Air Temperature K atmos \n", + "1 maximum Daily Maximum Near-Surface Air Temperature K atmos \n", + "2 maximum Daily Maximum Near-Surface Air Temperature K atmos \n", + "3 maximum Daily Maximum Near-Surface Air Temperature K atmos \n", + "4 maximum Daily Maximum Near-Surface Air Temperature K atmos \n", + ".. ... ... ... ... \n", + "648 maximum Daily Maximum Near-Surface Air Temperature K atmos \n", + "649 maximum Daily Maximum Near-Surface Air Temperature K atmos \n", + "650 maximum Daily Maximum Near-Surface Air Temperature K atmos \n", + "651 maximum Daily Maximum Near-Surface Air Temperature K atmos \n", + "652 maximum Daily Maximum Near-Surface Air Temperature K atmos \n", + "\n", + " level_type time_min time_max format \\\n", + "0 NaN 18500101.0 18541231 netcdf \n", + "1 NaN 18550101.0 18591231 netcdf \n", + "2 NaN 18600101.0 18641231 netcdf \n", + "3 NaN 18650101.0 18691231 netcdf \n", + "4 NaN 18700101.0 18741231 netcdf \n", + ".. ... ... ... ... \n", + "648 NaN 20800101.0 20841231 netcdf \n", + "649 NaN 20850101.0 20891231 netcdf \n", + "650 NaN 20900101.0 20941231 netcdf \n", + "651 NaN 20950101.0 20991231 netcdf \n", + "652 NaN 21000101.0 21001231 netcdf \n", + "\n", + " uri \n", + "0 /work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E... \n", + "1 /work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E... \n", + "2 /work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E... \n", + "3 /work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E... \n", + "4 /work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E... \n", + ".. ... \n", + "648 /work/ik1017/CMIP6/data/CMIP6/ScenarioMIP/DKRZ... \n", + "649 /work/ik1017/CMIP6/data/CMIP6/ScenarioMIP/DKRZ... \n", + "650 /work/ik1017/CMIP6/data/CMIP6/ScenarioMIP/DKRZ... \n", + "651 /work/ik1017/CMIP6/data/CMIP6/ScenarioMIP/DKRZ... \n", + "652 /work/ik1017/CMIP6/data/CMIP6/ScenarioMIP/DKRZ... \n", + "\n", + "[653 rows x 26 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Store the name of the model we chose in a variable named \"climate_model\"\n", + "\n", + "climate_model = \"MPI-ESM1-2-HR\" # here we choose Max-Plack Institute's Earth Sytem Model in high resolution\n", + "\n", + "# This is how we tell intake what data we want\n", + "\n", + "query = dict(\n", + " source_id = climate_model, # the model\n", + "# experiment_id = \"ssp370\",\n", + " member_id = \"r1i1p1f1\",\n", + " variable_id = \"tasmax\", # temperature at surface, maximum\n", + " table_id = \"day\", # daily maximum\n", + ")\n", + "\n", + "# Intake looks for the query we just defined in the catalog of the CMIP6 data pool at DKRZ\n", + "cat = col.search(**query)\n", + "\n", + "# Show query results\n", + "cat.df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The result of the query are like the list of results you get when you search for articles in the internet by writing keywords in your search engine (Duck duck go, Ecosia, Google,...). Thanks to the intake package, we did not need to know the path of each dataset, just selecting some keywords (the model name, the variable,...) was enough to obtain the results. If advance users are still interested in the location of the data inside the DKRZ archive, intake also provides the path and the OpenDAP URL (see the last columns above). \n", + "\n", + "\n", + "Now we will find which file in the dataset contains our selected year so in the next section we can just load that specific file and not the whole dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3 Find the Dataset That Contains the Year You Selected in Drop Down Menu Above" + ] + }, + { + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
activity_idinstitution_idsource_idexperiment_idmember_idtable_idvariable_idgrid_labeldcpp_init_yearversion...long_nameunitsrealmlevel_typetime_mintime_maxformaturistart_yearend_year
0CMIPMPI-MMPI-ESM1-2-HR1pctCO2r1i1p1f1daytasmaxgnNaNv20190710...Daily Maximum Near-Surface Air TemperatureKatmosNaN18500101.018541231netcdf/work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E...18501854
1CMIPMPI-MMPI-ESM1-2-HR1pctCO2r1i1p1f1daytasmaxgnNaNv20190710...Daily Maximum Near-Surface Air TemperatureKatmosNaN18550101.018591231netcdf/work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E...18551859
2CMIPMPI-MMPI-ESM1-2-HR1pctCO2r1i1p1f1daytasmaxgnNaNv20190710...Daily Maximum Near-Surface Air TemperatureKatmosNaN18600101.018641231netcdf/work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E...18601864
\n", + "

3 rows × 27 columns

\n", + "
" + ], + "text/plain": [ + " activity_id institution_id source_id experiment_id member_id table_id \\\n", + "0 CMIP MPI-M MPI-ESM1-2-HR 1pctCO2 r1i1p1f1 day \n", + "1 CMIP MPI-M MPI-ESM1-2-HR 1pctCO2 r1i1p1f1 day \n", + "2 CMIP MPI-M MPI-ESM1-2-HR 1pctCO2 r1i1p1f1 day \n", + "\n", + " variable_id grid_label dcpp_init_year version ... \\\n", + "0 tasmax gn NaN v20190710 ... \n", + "1 tasmax gn NaN v20190710 ... \n", + "2 tasmax gn NaN v20190710 ... \n", + "\n", + " long_name units realm level_type \\\n", + "0 Daily Maximum Near-Surface Air Temperature K atmos NaN \n", + "1 Daily Maximum Near-Surface Air Temperature K atmos NaN \n", + "2 Daily Maximum Near-Surface Air Temperature K atmos NaN \n", + "\n", + " time_min time_max format \\\n", + "0 18500101.0 18541231 netcdf \n", + "1 18550101.0 18591231 netcdf \n", + "2 18600101.0 18641231 netcdf \n", + "\n", + " uri start_year end_year \n", + "0 /work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E... 1850 1854 \n", + "1 /work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E... 1855 1859 \n", + "2 /work/ik1017/CMIP6/data/CMIP6/CMIP/MPI-M/MPI-E... 1860 1864 \n", + "\n", + "[3 rows x 27 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a copy of cat.df, thus further modifications do not affect it\n", + "\n", + "query_result_df = cat.df.copy() # new dataframe\n", + "\n", + "\n", + "# Each dataset contains many files, extract the initial and final year of each file\n", + "\n", + "query_result_df[\"start_year\"] = query_result_df[\"time_range\"].str[0:4].astype(int) # add column with start year\n", + "query_result_df[\"end_year\"] = query_result_df[\"time_range\"].str[9:13].astype(int) # add column with end year\n", + "\n", + "\n", + "# Delete the time range column\n", + "\n", + "query_result_df.drop(columns=[\"time_range\"], inplace = True) # \"inplace = False\" will drop the column in the view but not in the actual dataframe\n", + "query_result_df.iloc[0:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'http://esgf3.dkrz.de/thredds/dodsC/cmip6/CMIP/MPI-M/MPI-ESM1-2-HR/piControl/r1i1p1f1/day/tasmax/gn/v20190710/tasmax_day_MPI-ESM1-2-HR_piControl_r1i1p1f1_gn_20150101-20191231.nc'" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Select the file that contains the year we selected in the drop down menu above, e.g. 2015\n", + "\n", + "selected_file = query_result_df[(year_box.value >= query_result_df[\"start_year\"]) & (\n", + " year_box.value <= query_result_df[\"end_year\"])]\n", + "\n", + "\n", + "# Path of the file that contains the selected year\n", + "\n", + "selected_path = selected_file[\"opendap_url\"].values[0] \n", + "\n", + "\n", + "# Show the path of the file that contains the selected year\n", + "\n", + "selected_path" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloaded: tasmax_day_MPI-ESM1-2-HR_piControl_r1i1p1f1_gn_20150101-20191231.nc\n", + "Dataset loaded successfully.\n", + "Data for the selected year sliced successfully.\n" + ] + } + ], + "source": [ + "# This script dynamically constructs fileServer URLs and fetches data for loading into the model.\n", + "import os\n", + "import requests\n", + "import xarray as xr\n", + "\n", + "# Define the HTTP download function\n", + "def download_data(url, save_path):\n", + " \"\"\"Downloads data from an HTTP URL and saves it to a specified path.\"\"\"\n", + " response = requests.get(url, stream=True)\n", + " if response.status_code == 200:\n", + " with open(save_path, 'wb') as f:\n", + " for chunk in response.iter_content(chunk_size=8192):\n", + " f.write(chunk)\n", + " print(f\"Downloaded: {save_path}\")\n", + " else:\n", + " raise Exception(f\"Failed to download data. Status code: {response.status_code}\")\n", + "\n", + "# Function to fetch and load data based on the selected year\n", + "def fetch_and_load_data(selected_file):\n", + " \"\"\"Fetches the data file for the selected year and loads it.\"\"\"\n", + " # Extract the OPeNDAP URL\n", + " opendap_url = selected_file[\"opendap_url\"].values[0]\n", + "\n", + " # Construct the fileServer URL from the OPeNDAP URL\n", + " file_server_url = opendap_url.replace(\"dodsC\", \"fileServer\")\n", + "\n", + " # Extract the file name from the URL\n", + " save_file = os.path.basename(file_server_url)\n", + "\n", + " # Download the file\n", + " download_data(file_server_url, save_file)\n", + "\n", + " # Load the data using xarray\n", + " try:\n", + " ds = xr.open_dataset(save_file)\n", + " print(\"Dataset loaded successfully.\")\n", + " return ds\n", + " except Exception as e:\n", + " raise Exception(f\"Error loading dataset: {e}\")\n", + "\n", + "# Example selection logic for the year\n", + "selected_file = query_result_df[(year_box.value >= query_result_df[\"start_year\"]) & (\n", + " year_box.value <= query_result_df[\"end_year\"])]\n", + "\n", + "if not selected_file.empty:\n", + " # Fetch and load the dataset\n", + " ds_tasmax = fetch_and_load_data(selected_file)\n", + "\n", + " # Open variable \"tasmax\" over the whole time range\n", + " tasmax_xr = ds_tasmax[\"tasmax\"]\n", + "\n", + " # Define start and end time string\n", + " time_start = str(year_box.value) + \"-01-01T12:00:00.000000000\"\n", + " time_end = str(year_box.value) + \"-12-31T12:00:00.000000000\"\n", + "\n", + " # Slice selected year\n", + " tasmax_year_xr = tasmax_xr.loc[time_start:time_end, :, :]\n", + " print(\"Data for the selected year sliced successfully.\")\n", + "else:\n", + " print(\"No data file available for the selected year.\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Load the model data" + ] + }, + { + "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 'tasmax' (time: 365, lat: 192, lon: 384)> Size: 108MB\n",
+       "[26910720 values with dtype=float32]\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 3kB 2015-01-01T12:00:00 ... 2015-12-31T12:...\n",
+       "  * lat      (lat) float64 2kB -89.28 -88.36 -87.42 -86.49 ... 87.42 88.36 89.28\n",
+       "  * lon      (lon) float64 3kB 0.0 0.9375 1.875 2.812 ... 357.2 358.1 359.1\n",
+       "    height   float64 8B ...\n",
+       "Attributes:\n",
+       "    standard_name:  air_temperature\n",
+       "    long_name:      Daily Maximum Near-Surface Air Temperature\n",
+       "    comment:        maximum near-surface (usually, 2 meter) air temperature (...\n",
+       "    units:          K\n",
+       "    cell_methods:   area: mean time: maximum\n",
+       "    cell_measures:  area: areacella\n",
+       "    history:        2019-08-14T18:59:51Z altered by CMOR: Treated scalar dime...
" + ], + "text/plain": [ + " Size: 108MB\n", + "[26910720 values with dtype=float32]\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 3kB 2015-01-01T12:00:00 ... 2015-12-31T12:...\n", + " * lat (lat) float64 2kB -89.28 -88.36 -87.42 -86.49 ... 87.42 88.36 89.28\n", + " * lon (lon) float64 3kB 0.0 0.9375 1.875 2.812 ... 357.2 358.1 359.1\n", + " height float64 8B ...\n", + "Attributes:\n", + " standard_name: air_temperature\n", + " long_name: Daily Maximum Near-Surface Air Temperature\n", + " comment: maximum near-surface (usually, 2 meter) air temperature (...\n", + " units: K\n", + " cell_methods: area: mean time: maximum\n", + " cell_measures: area: areacella\n", + " history: 2019-08-14T18:59:51Z altered by CMOR: Treated scalar dime..." + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Let's have a look at the xarray data array\n", + "\n", + "tasmax_year_xr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see not only the numbers, but also information about it, such as long name, units, and the data history. This information is called metadata." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Compare Model Grid Cell with chosen Location" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Find nearest model coordinate by finding the index of the nearest grid point\n", + "\n", + "abslat = np.abs(tasmax_year_xr[\"lat\"] - location.latitude)\n", + "abslon = np.abs(tasmax_year_xr[\"lon\"] - location.longitude)\n", + "c = np.maximum(abslon, abslat)\n", + "\n", + "([xloc], [yloc]) = np.where(c == np.min(c)) # xloc and yloc are the indices of the neares model grid point" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Make this Notebook Trusted to load map: File -> Trust Notebook
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw map again\n", + "\n", + "m = folium.Map(location=[location.latitude, location.longitude], zoom_start=8)\n", + "\n", + "\n", + "tooltip = location.latitude, location.longitude\n", + "folium.Marker(\n", + " [location.latitude, location.longitude],\n", + " tooltip=tooltip,\n", + " popup=\"Location selected by You\",\n", + ").add_to(m)\n", + "\n", + "\n", + "tooltip = float(tasmax_year_xr[\"lat\"][yloc].values), float(tasmax_year_xr[\"lon\"][xloc].values)\n", + "folium.Marker(\n", + " [tasmax_year_xr[\"lat\"][yloc], tasmax_year_xr[\"lon\"][xloc]],\n", + " tooltip=tooltip,\n", + " popup=\"Model Grid Cell Center\",\n", + ").add_to(m)\n", + "\n", + "\n", + "# Define coordinates of model grid cell (just for visualization)\n", + "\n", + "rect_lat1_model = (tasmax_year_xr[\"lat\"][yloc - 1] + tasmax_year_xr[\"lat\"][yloc]) / 2\n", + "rect_lon1_model = (tasmax_year_xr[\"lon\"][xloc - 1] + tasmax_year_xr[\"lon\"][xloc]) / 2\n", + "rect_lat2_model = (tasmax_year_xr[\"lat\"][yloc + 1] + tasmax_year_xr[\"lat\"][yloc]) / 2\n", + "rect_lon2_model = (tasmax_year_xr[\"lon\"][xloc + 1] + tasmax_year_xr[\"lon\"][xloc]) / 2\n", + "\n", + "\n", + "# Draw model grid cell\n", + "\n", + "folium.Rectangle(\n", + " bounds=[[rect_lat1_model, rect_lon1_model], [rect_lat2_model, rect_lon2_model]],\n", + " color=\"#ff7800\",\n", + " fill=True,\n", + " fill_color=\"#ffff00\",\n", + " fill_opacity=0.2,\n", + ").add_to(m)\n", + "\n", + "m" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Climate models have a finite resolution. Hence, models do not provide the data of a particular point, but the mean over a model grid cell. Take this in mind when comparing model data with observed data (e.g. weather stations).\n", + "\n", + "\n", + "Now, we will visualize the daily maximum temperature time series of the model grid cell." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Draw Temperature Time Series and Count Summer days" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The definition of a summer day varies from region to region. According to the [German Weather Service](https://www.dwd.de/EN/ourservices/germanclimateatlas/explanations/elements/_functions/faqkarussel/sommertage.html), \"a summer day is a day on which the maximum air temperature is at least 25.0°C\". Depending on the place you selected, you might want to apply a different threshold to calculate the summer days index. " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + ":NdOverlay [Variable]\n", + " :Curve [index] (Temperature in °C)" + ] + }, + "execution_count": 14, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "ccaf0711-7739-4969-bd75-2644f2ee7e38" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "tasmax_year_place_xr = tasmax_year_xr[:, yloc, xloc] - 273.15 # Convert Kelvin to °C\n", + "tasmax_year_place_df = pd.DataFrame(index = tasmax_year_place_xr['time'].values, \n", + " columns = ['Model Temperature', 'Summer Day Threshold']) # create the dataframe\n", + "\n", + "tasmax_year_place_df.loc[:, 'Model Temperature'] = tasmax_year_place_xr.values # insert model data into the dataframe\n", + "tasmax_year_place_df.loc[:, 'Summer Day Threshold'] = 25 # insert the threshold into the dataframe\n", + "\n", + "\n", + "# Plot data and define title and legend\n", + "\n", + "tasmax_year_place_df.hvplot.line(y=['Model Temperature', 'Summer Day Threshold'], \n", + " value_label='Temperature in °C', legend='bottom', \n", + " title='Daily maximum Temperature near Surface for '+place_box.value, \n", + " height=500, width=620)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see, the maximum daily temperature is highly variable over the year. As we are using the mean temperature in a model grid cell, the amount of summer days might we different that what you would expect at a single location." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "According to the German Weather Service definition, in the ssp370 scenario the MPI-ESM1-2-HR model shows 3 summer days for Hamburg in 2015.\n" + ] + } + ], + "source": [ + "# Summer days index calculation\n", + "\n", + "no_summer_days_model = tasmax_year_place_df[\"Model Temperature\"][tasmax_year_place_df[\"Model Temperature\"] > 25].size # count the number of summer days\n", + "\n", + "\n", + "# Print results in a sentence\n", + "\n", + "print(\"According to the German Weather Service definition, in the ssp370 scenario the \" \n", + " +climate_model +\" model shows \" +str(no_summer_days_model) +\" summer days for \" +str(place_box.value) \n", + " + \" in \" + str(year_box.value) +\".\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Try another location and year](#selection)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/single-user-d4science-dkrzwps/notebooks/temperature_threshold_analysis_new.ipynb:Zone.Identifier b/single-user-d4science-dkrzwps/notebooks/temperature_threshold_analysis_new.ipynb:Zone.Identifier new file mode 100644 index 0000000..a82967c --- /dev/null +++ b/single-user-d4science-dkrzwps/notebooks/temperature_threshold_analysis_new.ipynb:Zone.Identifier @@ -0,0 +1,4 @@ +[ZoneTransfer] +ZoneId=3 +ReferrerUrl=https://mvre.diva.cloud.awi.de/user/khan@dkrz.de/lab/workspaces/auto-y/tree/work/temperature_threshold_analysis_new.ipynb +HostUrl=https://mvre.diva.cloud.awi.de/user/khan@dkrz.de/files/work/temperature_threshold_analysis_new.ipynb?_xsrf=MnwxOjB8MTA6MTczNzQ2NzcyMXw1Ol94c3JmfDE0ODpkbTU0YW5sZlJqQlZVa2RMWm0xemRrUTJOV2hxWmxWMGRWQkllVnBvVVZwQ1JuVTVkbkprYW1wME1EMDZOekEzWkRaak9UVmhNREppTURCbU1HUmtZalEzWkdRNE5HVmlObUZqT1RFM1l6YzJPR05rT0dNNVkyTTRZalV5TVdWbU1XVTFaREE0WWpVNVpEUXhNZz09fDgwN2UxYjNiMTUyMWQzNGY2ZjhmMWY2MWI4OTNjYzRiYjMzOThmZjNlNGUwNDY3MmE0ZTE4M2Y0MDkzZTNkNjQ