- {
- “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 xarrayn”, “import xclim as xcn”, “import numpy as npn”, “import xarray as xrn”, “xr.set_options(display_style=’html’)n”, “n”, “# File handling librariesn”, “import timen”, “import tempfilen”, “from pathlib import Pathn”, “n”, “# Output foldern”, “output_folder = Path(tempfile.mkdtemp()) “
]
}, {
“cell_type”: “markdown”, “metadata”: {
“keep_output”: true
}, “source”: [
“## Setting up the Dask client: parallel processingn”, “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 Clientn”, “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 datasetsn”, “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”: [
]
}, {
“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.04104n”, ” * lon (lon) float32 -120.79394 -120.71061 … -54.54659 -54.46326n”, ” * time (time) datetime64[ns] 1950-01-01 1950-01-02 … 2100-12-31n”, “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.5n”, ” 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-3n”, ” driving_experiment: historical,rcp85n”, ” institute_id: Ouranosn”, ” type: GCMn”, ” processing: bias_adjustedn”, ” dataset_description: https://www.ouranos.ca/publication-scientifiq…n”, ” bias_adjustment_method: 1D-Quantile Mappingn”, ” bias_adjustment_reference: http://doi.org/10.1002/2015JD023890n”, ” project_id: CMIP5n”, ” licence_type: permissiven”, ” terms_of_use: Terms of use at https://www.ouranos.ca/climat…n”, ” attribution: Use of this dataset should be acknowledged as…n”, ” frequency: dayn”, ” modeling_realm: atmosn”, ” 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-BOMn”
]
}
], “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(data_url, chunks={‘time’: 365, ‘lat’: 168, ‘lon’: 150}, drop_variables=[‘ts’, ‘time_vectors’])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 datasetsn”, “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 xarrayn”, “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.04084n”, ” * lon (lon) float32 -69.96264 -69.87931 -69.79598 … -65.1295 -65.04617n”, ” * time (time) datetime64[ns] 2090-01-01 2090-01-02 … 2100-12-31n”, “Attributes:n”, ” long_name: air_temperaturen”, ” standard_name: air_temperaturen”, ” units: Kn”, ” _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 frequenciesn”, “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 Januaryn”, “- YS-JUL: annual starting in Julyn”, “- MS: monthlyn”, “- QS-DEC: seasonal starting in Decembern”, “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-01n”, ” * lat (lat) float32 49.95731 49.87398 49.79065 … 45.12417 45.04084n”, ” * lon (lon) float32 -69.96264 -69.87931 -69.79598 … -65.1295 -65.04617n”, “Attributes:n”, ” long_name: Maximum daily maximum temperaturen”, ” standard_name: air_temperaturen”, ” units: Kn”, ” _ChunkSizes: [256 16 16]n”, ” cell_methods: time: maximum within days time: maximum over daysn”, ” 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 modulesn”, “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-01n”, ” * lat (lat) float32 49.95731 49.87398 49.79065 … 45.12417 45.04084n”, ” * lon (lon) float32 -69.96264 -69.87931 -69.79598 … -65.1295 -65.04617n”, “Attributes:n”, ” units: dn”
]
}
], “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-01n”, ” * lat (lat) float32 49.95731 49.87398 49.79065 … 45.12417 45.04084n”, ” * lon (lon) float32 -69.96264 -69.87931 -69.79598 … -65.1295 -65.04617n”, “Attributes:n”, ” units: daysn”, ” cell_methods: time: maximum within days time: sum over daysn”, ” 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_thresholdn”, ” long_name: Number of days with tmax > 30 cn”, ” 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-01n”, ” * lat (lat) float32 49.95731 49.87398 … 45.12417 45.04084n”, ” * lon (lon) float32 -69.96264 -69.87931 … -65.1295 -65.04617n”, “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.5n”, ” 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-3n”, ” driving_experiment: historical,rcp85n”, ” institute_id: Ouranosn”, ” type: GCMn”, ” processing: bias_adjustedn”, ” dataset_description: https://www.ouranos.ca/publication-scientifiq…n”, ” bias_adjustment_method: 1D-Quantile Mappingn”, ” bias_adjustment_reference: http://doi.org/10.1002/2015JD023890n”, ” project_id: CMIP5n”, ” licence_type: permissiven”, ” terms_of_use: Terms of use at https://www.ouranos.ca/climat…n”, ” attribution: Use of this dataset should be acknowledged as…n”, ” frequency: dayn”, ” modeling_realm: atmosn”, ” 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-BOMn”
]
}
], “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 attrsn”, “dsOut = xr.Dataset(attrs=ds2.attrs)n”, “n”, “# Add our climate index as a data variable to the datasetn”, “dsOut[out.name] = outn”, “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 sn”, “Wall time: 14.4 sn”
]
}
], “source”: [
“%%timen”, “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 tipsn”, “#### Optimizing the chunk sizen”, “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 msn”, “Wall time: 5.42 sn”
]
}
], “source”: [
“%%timen”, “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] = outn”, “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 memoryn”, “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 xclimn”, “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 datan”, “out1 = xc.atmos.precip_accumulation(ds4.pr, freq=’MS’)n”, “# Create a copy of the data converted to mm d-1n”, “pr_mmd = ds4.pr * 3600 * 24n”, “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 stuffn”, “import matplotlib.pyplot as pltn”, “%matplotlib inlinen”, “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 indicesn”, “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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”, “text/plain”: [
“<Figure size 792x360 with 1 Axes>”
]
}, “metadata”: {}, “output_type”: “display_data”
}
], “source”: [
“# Create a copy of the data converted to Cn”, “tasmax_C = ds4.tasmax - 273.15n”, “tasmax_C.attrs[‘units’] = ‘C’n”, “n”, “# Using Kelvin data, threshold in Celsiusn”, “out1 = xc.atmos.tx_days_above(ds4.tasmax, thresh=’20 C’, freq=’MS’)n”, “n”, “# Using Celsius datan”, “out2 = xc.atmos.tx_days_above(tasmax_C, thresh=’20 C’, freq=’MS’)n”, “n”, “# Using Celsius but with threshold in Kelvinn”, “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”, “language”: “python”, “name”: “python3”
}, “language_info”: {
- “codemirror_mode”: {
“name”: “ipython”, “version”: 3
}, “file_extension”: “.py”, “mimetype”: “text/x-python”, “name”: “python”, “nbconvert_exporter”: “python”, “pygments_lexer”: “ipython3”, “version”: “3.8.8”
}
}, “nbformat”: 4, “nbformat_minor”: 2
}