docs/notebooks/example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "keep_output": true
   },
   "source": [
    "# Workflow Examples \n",
    "\n",
    "\n",
    "`xclim` is built on very powerful multiprocessing and distributed computation libraries, notably `xarray` and `dask`.\n",
    "\n",
    "`xarray` is a python package making it easy to work with n-dimensional arrays. It labels axes with their names `[time, lat, lon, level]` instead of indices `[0,1,2,3]`, reducing the likelihood of bugs and making the code easier to understand. One of the key strengths of `xarray` is that it knows how to deal with non-standard calendars (we're looking at you, \"`360_days`\") and can easily resample daily time series to weekly, monthly, seasonal or annual periods.  Finally, `xarray` is tightly inegrated with `dask`, a package that can automatically parallelize operations.\n",
    "\n",
    "The following are a few examples to consult when using `xclim` to subset netCDF arrays and compute climate indicators, taking advantage of the parallel processing capabilities offered by `xarray` and `dask`. For more information about these projects, please see their documentation pages:\n",
    "\n",
    "* [xarray documentation](https://xarray.pydata.org/en/stable/)\n",
    "* [dask documentation](https://docs.dask.org/en/stable/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "keep_output": true
   },
   "source": [
    "## Environment configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [],
   "source": [
    "# Imports for xclim and xarray\n",
    "from __future__ import annotations\n",
    "\n",
    "import numpy as np\n",
    "import xarray as xr\n",
    "\n",
    "import xclim as xc\n",
    "\n",
    "xr.set_options(display_style=\"html\")\n",
    "\n",
    "import tempfile\n",
    "\n",
    "# File handling libraries\n",
    "import time\n",
    "from pathlib import Path\n",
    "\n",
    "# Output folder\n",
    "output_folder = Path(tempfile.mkdtemp())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "keep_output": true
   },
   "source": [
    "## Setting up the Dask client: parallel processing\n",
    "\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "\n",
    "In this example, we are using the **dask.distributed** submodule. This is not installed by default in a basic `xclim` installation. Be sure to add `distributed` to your Python installation before setting up parallel processing operations!\n",
    "    \n",
    "</div>\n",
    "\n",
    "First we create a pool of workers that will wait for jobs. The `xarray` library will automatically connect to these workers and and dispatch them jobs that can be run in parallel.  \n",
    "\n",
    "The dashboard link lets you see in real time how busy those workers are.\n",
    "\n",
    "* [dask distributed documentation](https://distributed.dask.org/en/latest/)\n",
    "\n",
    "This step is not mandatory as dask will fall back to its \"single machine scheduler\" if a `Client` is not created. However, this default scheduler doesn't allow you to set the number of threads or a memory limit and doesn't start the dashboard, which can be quite useful to understand your task's progress.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table style=\"border: 2px solid white;\">\n",
       "<tr>\n",
       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
       "<h3 style=\"text-align: left;\">Client</h3>\n",
       "<ul style=\"text-align: left; list-style: none; margin: 0; padding: 0;\">\n",
       "  <li><b>Scheduler: </b>tcp://127.0.0.1:44837</li>\n",
       "  <li><b>Dashboard: </b><a href='http://127.0.0.1:8787/status' target='_blank'>http://127.0.0.1:8787/status</a></li>\n",
       "</ul>\n",
       "</td>\n",
       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
       "<h3 style=\"text-align: left;\">Cluster</h3>\n",
       "<ul style=\"text-align: left; list-style:none; margin: 0; padding: 0;\">\n",
       "  <li><b>Workers: </b>1</li>\n",
       "  <li><b>Cores: </b>4</li>\n",
       "  <li><b>Memory: </b>4.00 GB</li>\n",
       "</ul>\n",
       "</td>\n",
       "</tr>\n",
       "</table>"
      ],
      "text/plain": [
       "<Client: 'tcp://127.0.0.1:44837' processes=1 threads=4, memory=4.00 GB>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from distributed import Client\n",
    "\n",
    "# Depending on your workstation specifications, you may need to adjust these values.\n",
    "# On a single machine, n_workers=1 is usually better.\n",
    "client = Client(n_workers=1, threads_per_worker=4, memory_limit=\"4GB\")\n",
    "client"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "keep_output": true
   },
   "source": [
    "## Creating xarray datasets\n",
    "\n",
    "To open a netCDF file with `xarray`, we use `xr.open_dataset(<path to file>)`. By default, the entire file is stored in one chunk, so there is no parallelism. To trigger parallel computations, we need to explicitly specify the **chunk size**. \n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "\n",
    "In this example, instead of opening a local file, we pass an *OPeNDAP* url to xarray. It retrieves the data automatically. Notice also that opening the dataset is quite fast. In fact, the data itself has not been downloaded yet, only the coordinates and the metadata. The downloads will be triggered only when the values need to be accessed directly.\n",
    "\n",
    "</div>\n",
    "\n",
    "`dask`'s parallelism is based on memory chunks. We need to tell `xarray` to split our netCDF array into chunks of a given size, and operations on each chunk of the array will automatically be dispatched to the workers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [],
   "source": [
    "data_url = \"https://pavics.ouranos.ca/twitcher/ows/proxy/thredds/dodsC/datasets/simulations/bias_adjusted/cmip5/ouranos/cb-oura-1.0/day_ACCESS1-3_historical+rcp85_r1i1p1_na10kgrid_qm-moving-50bins-detrend_1950-2100.ncml\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.Dataset>\n",
      "Dimensions:  (lat: 320, lon: 797, time: 55152)\n",
      "Coordinates:\n",
      "  * lat      (lat) float32 66.62331 66.53998 66.45665 ... 40.12437 40.04104\n",
      "  * lon      (lon) float32 -120.79394 -120.71061 ... -54.54659 -54.46326\n",
      "  * time     (time) datetime64[ns] 1950-01-01 1950-01-02 ... 2100-12-31\n",
      "Data variables:\n",
      "    tasmin   (time, lat, lon) float32 dask.array<chunksize=(365, 168, 150), meta=np.ndarray>\n",
      "    tasmax   (time, lat, lon) float32 dask.array<chunksize=(365, 168, 150), meta=np.ndarray>\n",
      "    pr       (time, lat, lon) float32 dask.array<chunksize=(365, 168, 150), meta=np.ndarray>\n",
      "Attributes:\n",
      "    Conventions:                CF-1.5\n",
      "    title:                      Ouranos standard ensemble of bias-adjusted cl...\n",
      "    history:                    CMIP5 compliant file produced from raw ACCESS...\n",
      "    institution:                Ouranos Consortium on Regional Climatology an...\n",
      "    source:                     ACCESS1-3 2011. Atmosphere: AGCM v1.0 (N96 gr...\n",
      "    driving_model:              ACCESS1-3\n",
      "    driving_experiment:         historical,rcp85\n",
      "    institute_id:               Ouranos\n",
      "    type:                       GCM\n",
      "    processing:                 bias_adjusted\n",
      "    dataset_description:        https://www.ouranos.ca/publication-scientifiq...\n",
      "    bias_adjustment_method:     1D-Quantile Mapping\n",
      "    bias_adjustment_reference:  http://doi.org/10.1002/2015JD023890\n",
      "    project_id:                 CMIP5\n",
      "    licence_type:               permissive\n",
      "    terms_of_use:               Terms of use at https://www.ouranos.ca/climat...\n",
      "    attribution:                Use of this dataset should be acknowledged as...\n",
      "    frequency:                  day\n",
      "    modeling_realm:             atmos\n",
      "    target_dataset:             CANADA : ANUSPLIN interpolated Canada daily 3...\n",
      "    target_dataset_references:  CANADA : https://doi.org/10.1175/2011BAMS3132...\n",
      "    driving_institution:        Commonwealth Scientific and Industrial Resear...\n",
      "    driving_institute_id:       CSIRO-BOM\n"
     ]
    }
   ],
   "source": [
    "# Chunking in memory along the time dimension.\n",
    "# Note that the data type is a 'dask.array'. xarray will automatically use client workers.\n",
    "ds = xr.open_dataset(\n",
    "    data_url,\n",
    "    chunks={\"time\": 365, \"lat\": 168, \"lon\": 150},\n",
    "    drop_variables=[\"ts\", \"time_vectors\"],\n",
    ")\n",
    "print(ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 37), (168, 152), (150, 150, 150, 150, 150, 47))\n"
     ]
    }
   ],
   "source": [
    "print(ds.tasmin.chunks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "keep_output": true
   },
   "source": [
    "## Multi-file datasets\n",
    "\n",
    "NetCDF files are often split into periods to keep file size manageable. A single dataset can be split in dozens of individual files. `xarray` has a function `open_mfdataset` that can open and aggregate a list of files and construct a unique *logical* dataset. `open_mfdataset` can aggregate files over coordinates (time, lat, lon) and variables. \n",
    "\n",
    "* Note that opening a multi-file dataset automatically chunks the array (one chunk per file).\n",
    "* Note also that because `xarray` reads every file metadata to place it in a logical order, it can take a while to load. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [],
   "source": [
    "## Create multi-file data & chunks\n",
    "# ds = xr.open_mfdataset('/path/to/files*.nc')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Subsetting and selecting data with xarray\n",
    "Usually, xclim users are encouraged to use the subsetting utilities of the [clisops](https://clisops.readthedocs.io/en/latest/notebooks/subset.html) package. Here, we will reduce the size of our data using the methods implemented in xarray ([docs here](http://xarray.pydata.org/en/stable/indexing.html))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'tasmin' (time: 4017, lat: 60, lon: 60)>\n",
      "dask.array<getitem, shape=(4017, 60, 60), dtype=float32, chunksize=(365, 60, 60), chunktype=numpy.ndarray>\n",
      "Coordinates:\n",
      "  * lat      (lat) float32 49.95731 49.87398 49.79065 ... 45.12417 45.04084\n",
      "  * lon      (lon) float32 -69.96264 -69.87931 -69.79598 ... -65.1295 -65.04617\n",
      "  * time     (time) datetime64[ns] 2090-01-01 2090-01-02 ... 2100-12-31\n",
      "Attributes:\n",
      "    long_name:      air_temperature\n",
      "    standard_name:  air_temperature\n",
      "    units:          K\n",
      "    _ChunkSizes:    [256  16  16]\n"
     ]
    }
   ],
   "source": [
    "ds2 = ds.sel(lat=slice(50, 45), lon=slice(-70, -65), time=slice(\"2090\", \"2100\"))\n",
    "print(ds2.tasmin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [],
   "source": [
    "ds3 = ds.sel(lat=46.8, lon=-71.22, method=\"nearest\").sel(time=\"1993\")\n",
    "print(ds3.tasmin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "keep_output": true
   },
   "source": [
    "## Climate index calculation & resampling frequencies\n",
    "\n",
    "`xclim` has two layers for the calculation of indicators. The bottom layer is composed of a list of functions that take one or more `xarray.DataArray`'s as input and return an `xarray.DataArray` as output. You'll find these functions in `xclim.indices`. The indicator's logic is contained in this function, as well as some unit handling, but it doesn't perform any data consistency checks (like if the time frequency is daily), and doesn't not adjust the metadata of the output array. \n",
    "\n",
    "The second layer are class instances that you'll find organized by *realm*. So far, there are three realms available in `xclim.atmos`, `xclim.seaIce` and `xclim.land`, the first one being the most exhaustive. Before running computations, these classes check if the input data is a daily average of the expected variable:\n",
    "\n",
    "1. If an indicator expects a daily mean and you pass it a daily max, a `warning` will be raised. \n",
    "2. After the computation, it also checks the number of values per period to make sure there are not missing values or `NaN` in the input data. If there are, the output is going to be set to `NaN`.  Ex. : If the indicator performs a yearly resampling but there are only 350 non-`NaN` values in one given year in the input data, that year's output will be `NaN`.\n",
    "3. The output units are set correctly as well as other properties of the output array, complying as much as possible with CF conventions. \n",
    "\n",
    "For new users, we suggest you use the classes found in `xclim.atmos` and others. If you know what you're doing and you want to circumvent the built-in checks, then you can use the `xclim.indices` directly. \n",
    "\n",
    "Almost all `xclim` indicators convert daily data to lower time frequencies, such as seasonal or annual values. This is done using `xarray.DataArray.resample` method. Resampling creates a grouped object over which you apply a reduction operation (e.g. mean, min, max). The list of available frequency is given in the link below, but the most often used are: \n",
    "\n",
    "- `YS`: annual starting in January\n",
    "- `YS-JUL`: annual starting in July\n",
    "- `MS`: monthly\n",
    "- `QS-DEC`: seasonal starting in December\n",
    "\n",
    "More info about this specification can be found in [pandas' documentation](http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#timeseries-offset-aliases)\n",
    "\n",
    "Note - not all offsets in the link are supported by cftime objects in `xarray`.\n",
    "\n",
    "\n",
    "In the example below, we're computing the **annual maximum temperature of the daily maximum temperature (tx_max)**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/phobos/Python/xclim/xclim/indicators/atmos/_temperature.py:87: UserWarning: Variable does not have a `cell_methods` attribute.\n",
      "  cfchecks.check_valid(tasmax, \"cell_methods\", \"*time: maximum within days*\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'tx_max' (time: 11, lat: 60, lon: 60)>\n",
      "dask.array<where, shape=(11, 60, 60), dtype=float32, chunksize=(1, 60, 60), chunktype=numpy.ndarray>\n",
      "Coordinates:\n",
      "  * time     (time) datetime64[ns] 2090-01-01 2091-01-01 ... 2100-01-01\n",
      "  * lat      (lat) float32 49.95731 49.87398 49.79065 ... 45.12417 45.04084\n",
      "  * lon      (lon) float32 -69.96264 -69.87931 -69.79598 ... -65.1295 -65.04617\n",
      "Attributes:\n",
      "    long_name:      Maximum daily maximum temperature\n",
      "    standard_name:  air_temperature\n",
      "    units:          K\n",
      "    _ChunkSizes:    [256  16  16]\n",
      "    cell_methods:    time: maximum within days time: maximum over days\n",
      "    xclim_history:  [2021-02-15 17:08:48] tx_max: tx_max(tasmax=<array>, freq...\n",
      "    description:    Annual maximum of daily maximum temperature.\n"
     ]
    }
   ],
   "source": [
    "out = xc.atmos.tx_max(ds2.tasmax, freq=\"YS\")\n",
    "print(out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "keep_output": true
   },
   "source": [
    "<div class=\"alert alert-info\">\n",
    "\n",
    "If you execute the cell above, you'll see that this operation is quite fast. This a feature coming from dask. Read *Lazy computation*  further down.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "keep_output": true
   },
   "source": [
    "### Comparison of **atmos** vs **indices** modules\n",
    "Using the `xclim.indices` module performs not checks and only fills the `units` attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'tasmax' (time: 11, lat: 60, lon: 60)>\n",
      "dask.array<mul, shape=(11, 60, 60), dtype=int64, chunksize=(1, 60, 60), chunktype=numpy.ndarray>\n",
      "Coordinates:\n",
      "  * time     (time) datetime64[ns] 2090-01-01 2091-01-01 ... 2100-01-01\n",
      "  * lat      (lat) float32 49.95731 49.87398 49.79065 ... 45.12417 45.04084\n",
      "  * lon      (lon) float32 -69.96264 -69.87931 -69.79598 ... -65.1295 -65.04617\n",
      "Attributes:\n",
      "    units:    d\n"
     ]
    }
   ],
   "source": [
    "out = xc.indices.tx_days_above(ds2.tasmax, thresh=\"30 C\", freq=\"YS\")\n",
    "print(out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "keep_output": true
   },
   "source": [
    "With `xclim.atmos`, checks are performed and many CF-compliant attributes are added:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'tx_days_above' (time: 11, lat: 60, lon: 60)>\n",
      "dask.array<where, shape=(11, 60, 60), dtype=float64, chunksize=(1, 60, 60), chunktype=numpy.ndarray>\n",
      "Coordinates:\n",
      "  * time     (time) datetime64[ns] 2090-01-01 2091-01-01 ... 2100-01-01\n",
      "  * lat      (lat) float32 49.95731 49.87398 49.79065 ... 45.12417 45.04084\n",
      "  * lon      (lon) float32 -69.96264 -69.87931 -69.79598 ... -65.1295 -65.04617\n",
      "Attributes:\n",
      "    units:          days\n",
      "    cell_methods:    time: maximum within days time: sum over days\n",
      "    xclim_history:  [2021-02-15 17:08:49] tx_days_above: tx_days_above(tasmax...\n",
      "    standard_name:  number_of_days_with_air_temperature_above_threshold\n",
      "    long_name:      Number of days with tmax > 30 c\n",
      "    description:    Annual number of days where daily maximum temperature exc...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/phobos/Python/xclim/xclim/indicators/atmos/_temperature.py:87: UserWarning: Variable does not have a `cell_methods` attribute.\n",
      "  cfchecks.check_valid(tasmax, \"cell_methods\", \"*time: maximum within days*\")\n"
     ]
    }
   ],
   "source": [
    "out = xc.atmos.tx_days_above(ds2.tasmax, thresh=\"30 C\", freq=\"YS\")\n",
    "print(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.Dataset>\n",
      "Dimensions:        (lat: 60, lon: 60, time: 11)\n",
      "Coordinates:\n",
      "  * time           (time) datetime64[ns] 2090-01-01 2091-01-01 ... 2100-01-01\n",
      "  * lat            (lat) float32 49.95731 49.87398 ... 45.12417 45.04084\n",
      "  * lon            (lon) float32 -69.96264 -69.87931 ... -65.1295 -65.04617\n",
      "Data variables:\n",
      "    tx_days_above  (time, lat, lon) float64 dask.array<chunksize=(1, 60, 60), meta=np.ndarray>\n",
      "Attributes:\n",
      "    Conventions:                CF-1.5\n",
      "    title:                      Ouranos standard ensemble of bias-adjusted cl...\n",
      "    history:                    CMIP5 compliant file produced from raw ACCESS...\n",
      "    institution:                Ouranos Consortium on Regional Climatology an...\n",
      "    source:                     ACCESS1-3 2011. Atmosphere: AGCM v1.0 (N96 gr...\n",
      "    driving_model:              ACCESS1-3\n",
      "    driving_experiment:         historical,rcp85\n",
      "    institute_id:               Ouranos\n",
      "    type:                       GCM\n",
      "    processing:                 bias_adjusted\n",
      "    dataset_description:        https://www.ouranos.ca/publication-scientifiq...\n",
      "    bias_adjustment_method:     1D-Quantile Mapping\n",
      "    bias_adjustment_reference:  http://doi.org/10.1002/2015JD023890\n",
      "    project_id:                 CMIP5\n",
      "    licence_type:               permissive\n",
      "    terms_of_use:               Terms of use at https://www.ouranos.ca/climat...\n",
      "    attribution:                Use of this dataset should be acknowledged as...\n",
      "    frequency:                  day\n",
      "    modeling_realm:             atmos\n",
      "    target_dataset:             CANADA : ANUSPLIN interpolated Canada daily 3...\n",
      "    target_dataset_references:  CANADA : https://doi.org/10.1175/2011BAMS3132...\n",
      "    driving_institution:        Commonwealth Scientific and Industrial Resear...\n",
      "    driving_institute_id:       CSIRO-BOM\n"
     ]
    }
   ],
   "source": [
    "# We have created an xarray data-array - We can insert this into an output xr.Dataset object with a copy of the original dataset global attrs\n",
    "dsOut = xr.Dataset(attrs=ds2.attrs)\n",
    "\n",
    "# Add our climate index as a data variable to the dataset\n",
    "dsOut[out.name] = out\n",
    "print(dsOut)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "keep_output": true
   },
   "source": [
    "## *Lazy* computation - Nothing has been computed so far !\n",
    "\n",
    "If you look at the output of those operations, they're identified as `dask.array` objects. What happens is that `dask` creates a chain of operations that when executed, will yield the values we want. We have thus far only created a schedule of tasks with a small preview and not done any actual computations. You can trigger computations by using the `load` or `compute` method, or writing the output to disk via `to_netcdf`. Of course, calling `.plot()` will also trigger the computation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.1 s, sys: 74.4 ms, total: 1.17 s\n",
      "Wall time: 14.4 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "output_file = output_folder / \"test_tx_max.nc\"\n",
    "dsOut.to_netcdf(output_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "keep_output": true
   },
   "source": [
    "*(Times may of course vary depending on the machine and the Client settings)*\n",
    "\n",
    "### Performance tips\n",
    "#### Optimizing the chunk size\n",
    "\n",
    "You can improve performance by being smart about chunk sizes. If chunks are too small, there is a lot of time lost in overhead. If chunks are too large, you may end up exceeding the individual worker memory limit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(330, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 37)\n"
     ]
    }
   ],
   "source": [
    "print(ds2.chunks[\"time\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1460, 1460, 1097)\n"
     ]
    }
   ],
   "source": [
    "# rechunk data in memory for the entire grid\n",
    "ds2c = ds2.chunk(chunks={\"time\": 4 * 365})\n",
    "print(ds2c.chunks[\"time\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/phobos/Python/xclim/xclim/indicators/atmos/_temperature.py:87: UserWarning: Variable does not have a `cell_methods` attribute.\n",
      "  cfchecks.check_valid(tasmax, \"cell_methods\", \"*time: maximum within days*\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 582 ms, sys: 75.1 ms, total: 657 ms\n",
      "Wall time: 5.42 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "out = xc.atmos.tx_max(ds2c.tasmax, freq=\"YS\")\n",
    "dsOut = xr.Dataset(data_vars=None, coords=out.coords, attrs=ds.attrs)\n",
    "dsOut[out.name] = out\n",
    "\n",
    "output_file = output_folder / \"test_tx_max.nc\"\n",
    "dsOut.to_netcdf(output_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "keep_output": true
   },
   "source": [
    "#### Loading the data in memory\n",
    "If the dataset is relatively small, it might be more efficient to simply load the data into the memory and use  numpy arrays instead of dask arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [],
   "source": [
    "ds4 = ds3.load()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "keep_output": true
   },
   "source": [
    "## Unit handling in `xclim`\n",
    "\n",
    "A lot of effort has been placed into automatic handling of input data units. `xclim` will automatically detect the input variable(s) units (e.g. °C versus °K or mm/s versus mm/day etc.) and adjust on-the-fly in order to calculate indices in the consistent manner. This comes with the obvious caveat that input data requires metadata attribute for units.\n",
    "\n",
    "In the example below, we compute weekly total precipitation in mm using inputs of mm/s and mm/d. As you see, the output is identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [],
   "source": [
    "# Compute with the original mm s-1 data\n",
    "out1 = xc.atmos.precip_accumulation(ds4.pr, freq=\"MS\")\n",
    "# Create a copy of the data converted to mm d-1\n",
    "pr_mmd = ds4.pr * 3600 * 24\n",
    "pr_mmd.attrs[\"units\"] = \"mm d-1\"\n",
    "out2 = xc.atmos.precip_accumulation(pr_mmd, freq=\"MS\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [],
   "source": [
    "# import plotting stuff\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.style.use(\"seaborn\")\n",
    "plt.rcParams[\"figure.figsize\"] = (11, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fb6e8360b50>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "out1.plot(label=\"From mm s-1\", linestyle=\"-\")\n",
    "out2.plot(label=\"From mm d-1\", linestyle=\"none\", marker=\"o\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "keep_output": true
   },
   "source": [
    "### Threshold indices\n",
    "\n",
    "`xclim` unit handling also applies to threshold indicators. Users can provide threshold in units of choice and `xclim` will adjust automatically. For example determining the number of days with tasmax > 20°C users can define a threshold input of '20 C' or '20 degC' even if input data is in Kelvin. Alernatively users can even provide a threshold in Kelvin '293.15 K' (if they really wanted to)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true,
    "tags": [
     "nbval-skip"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/phobos/Python/xclim/xclim/indicators/atmos/_temperature.py:87: UserWarning: Variable does not have a `cell_methods` attribute.\n",
      "  cfchecks.check_valid(tasmax, \"cell_methods\", \"*time: maximum within days*\")\n",
      "/home/phobos/Python/xclim/xclim/indicators/atmos/_temperature.py:87: UserWarning: Variable does not have a `cell_methods` attribute.\n",
      "  cfchecks.check_valid(tasmax, \"cell_methods\", \"*time: maximum within days*\")\n",
      "/home/phobos/Python/xclim/xclim/indicators/atmos/_temperature.py:88: UserWarning: Variable does not have a `standard_name` attribute.\n",
      "  cfchecks.check_valid(tasmax, \"standard_name\", \"air_temperature\")\n",
      "/home/phobos/Python/xclim/xclim/indicators/atmos/_temperature.py:87: UserWarning: Variable does not have a `cell_methods` attribute.\n",
      "  cfchecks.check_valid(tasmax, \"cell_methods\", \"*time: maximum within days*\")\n",
      "/home/phobos/Python/xclim/xclim/indicators/atmos/_temperature.py:88: UserWarning: Variable does not have a `standard_name` attribute.\n",
      "  cfchecks.check_valid(tasmax, \"standard_name\", \"air_temperature\")\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fb6e8190340>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a copy of the data converted to C\n",
    "tasmax_C = ds4.tasmax - 273.15\n",
    "tasmax_C.attrs[\"units\"] = \"C\"\n",
    "\n",
    "# Using Kelvin data, threshold in Celsius\n",
    "out1 = xc.atmos.tx_days_above(ds4.tasmax, thresh=\"20 C\", freq=\"MS\")\n",
    "\n",
    "# Using Celsius data\n",
    "out2 = xc.atmos.tx_days_above(tasmax_C, thresh=\"20 C\", freq=\"MS\")\n",
    "\n",
    "# Using Celsius but with threshold in Kelvin\n",
    "out3 = xc.atmos.tx_days_above(tasmax_C, thresh=\"293.15 K\", freq=\"MS\")\n",
    "\n",
    "# Plot and see that it's all identical:\n",
    "plt.figure()\n",
    "out1.plot(label=\"K and degC\", linestyle=\"-\")\n",
    "out2.plot(label=\"degC and degC\", marker=\"s\", markersize=10, linestyle=\"none\")\n",
    "out3.plot(label=\"degC and K\", marker=\"o\", linestyle=\"none\")\n",
    "plt.legend()"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}