From 21766ed3f37872ed6db6470f2428e0ec90aa9cbe Mon Sep 17 00:00:00 2001 From: mvdebolskiy <80036033+mvdebolskiy@users.noreply.github.com> Date: Mon, 13 May 2024 10:20:08 +0200 Subject: [PATCH 1/3] add catalogs description. --- docs/data/local-data.rst | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/docs/data/local-data.rst b/docs/data/local-data.rst index f6e5ca9..f7b67ca 100644 --- a/docs/data/local-data.rst +++ b/docs/data/local-data.rst @@ -21,6 +21,14 @@ Mounted data directories: - ``~/shared-craas1-ns9989k-geo4992/catalogs`` - various intake catalogs for local + pangeo data access. + - ``./cmip6.json`` local CMIP6 data corresponding to ``~/shared-craas1-nn9989k-cmip6/`` + + - ``./merged-cmip6.json`` same as above but with pangeo catalog merged + + - ``./cesm-ppe-pi-mon.json`` cesm ppe pre-industrial monthly variables + + - ``./cesm-ppe.json`` cesm present day variables. + - ``~/shared-craas1-ns9989k-geo4992/data/data_group1/``: - ``./data_group1/deposited2022/modis_cdnc_sampling_gridded/`` MODIS based dataset for cloud droplet number concentration from Gryspeerdt et al. (2022, https://amt.copernicus.org/articles/15/3875/2022/) From bad357ec65baa3e954127711577faf3621b823ed Mon Sep 17 00:00:00 2001 From: mvdebolskiy <80036033+mvdebolskiy@users.noreply.github.com> Date: Wed, 15 May 2024 11:06:56 +0200 Subject: [PATCH 2/3] add group3 update --- docs/data/local-data.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/data/local-data.rst b/docs/data/local-data.rst index f7b67ca..a242c76 100644 --- a/docs/data/local-data.rst +++ b/docs/data/local-data.rst @@ -41,6 +41,8 @@ Mounted data directories: - ``./echam_salsa_zep/`` Model output from ECHAM-SALSA with nudged surface meteorology, collocated with Zeppelin observatory from 2011-2020. Aerosol, basic meteorology and radiation parameters. + - ``./ec-earth/`` variables from ec-earth project. + - ``~/shared-craas1-ns9989k-geo4992/data/data_group4/`` Fire emissions from CAMS and MERRA2 + aerosol data from ``_ and ``_. - ``~/scraas1-ns9989k-geo4992/data/data_group6/`` Hysplit(2018-2019), AMS, CCN and cloud radar derived cloud base Updraft data (warm non-precipitating clouds) from Zeppelin (Ny-Ålesund). From a2b2744345a73907637da6eb07c45b24a27da063 Mon Sep 17 00:00:00 2001 From: Erik Holmgren Date: Mon, 20 May 2024 09:23:50 +0200 Subject: [PATCH 3/3] Notebook on dask tips and tricks Notebook from my presentation on dask. --- docs/learning/notebooks/dask_intro.ipynb | 1957 ++++++++++++++++++++++ 1 file changed, 1957 insertions(+) create mode 100644 docs/learning/notebooks/dask_intro.ipynb diff --git a/docs/learning/notebooks/dask_intro.ipynb b/docs/learning/notebooks/dask_intro.ipynb new file mode 100644 index 0000000..127d8b6 --- /dev/null +++ b/docs/learning/notebooks/dask_intro.ipynb @@ -0,0 +1,1957 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "76fe4fd3-0cb6-456c-b8d6-335e47bbd839", + "metadata": {}, + "source": [ + "# Brief introduction to Dask\n", + "[Dask](https://docs.dask.org/en/stable/) is a library that makes it relatively easy to perform parallel and distributed computations in python.\n", + "\n", + "The key concept for us is that allows for computations that **require more memory than available** on your machine." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1972f4d9-03f5-4ade-ad56-8e13415adbbb", + "metadata": {}, + "outputs": [], + "source": [ + "# First some imports.\n", + "import dask\n", + "import dask.array as da\n", + "import numpy as np\n", + "import xarray as xr\n", + "\n", + "from dask.distributed import Client\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "843f3d7e-4fa3-4a74-abe7-7818560777dc", + "metadata": {}, + "source": [ + "I like to start a client, since this allows me to control how many workers and memory it can use.\n", + "And it starts the dashboard, which can give use some nice insights on our computations." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fad26351-61ba-4384-8af7-0a22f4d4c394", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "from dask.distributed import Client\n", + "\n", + "client = Client()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ad1e949b-8af2-481f-b237-92898cee6611", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + "
\n", + "

Client

\n", + "

Client-06c2a091-1679-11ef-95d4-4efbcbc71aa6

\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
Connection method: Cluster objectCluster type: distributed.LocalCluster
\n", + " Dashboard: /user/fc%3Auid%3A8be9434f-5560-4397-97c0-882449c50503/proxy/8787/status\n", + "
\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "

Cluster Info

\n", + "
\n", + "
\n", + "
\n", + "
\n", + "

LocalCluster

\n", + "

51649bec

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + "
\n", + " Dashboard: /user/fc%3Auid%3A8be9434f-5560-4397-97c0-882449c50503/proxy/8787/status\n", + " \n", + " Workers: 4\n", + "
\n", + " Total threads: 16\n", + " \n", + " Total memory: 16.00 GiB\n", + "
Status: runningUsing processes: True
\n", + "\n", + "
\n", + " \n", + "

Scheduler Info

\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + "
\n", + "

Scheduler

\n", + "

Scheduler-fe5e2768-ee8a-4e3b-b87b-5340ff36ac59

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " Comm: tcp://127.0.0.1:42435\n", + " \n", + " Workers: 4\n", + "
\n", + " Dashboard: /user/fc%3Auid%3A8be9434f-5560-4397-97c0-882449c50503/proxy/8787/status\n", + " \n", + " Total threads: 16\n", + "
\n", + " Started: Just now\n", + " \n", + " Total memory: 16.00 GiB\n", + "
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "

Workers

\n", + "
\n", + "\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: 0

\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + " Comm: tcp://127.0.0.1:36459\n", + " \n", + " Total threads: 4\n", + "
\n", + " Dashboard: /user/fc%3Auid%3A8be9434f-5560-4397-97c0-882449c50503/proxy/36155/status\n", + " \n", + " Memory: 4.00 GiB\n", + "
\n", + " Nanny: tcp://127.0.0.1:46681\n", + "
\n", + " Local directory: /tmp/dask-scratch-space/worker-j12jor3x\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: 1

\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + " Comm: tcp://127.0.0.1:33879\n", + " \n", + " Total threads: 4\n", + "
\n", + " Dashboard: /user/fc%3Auid%3A8be9434f-5560-4397-97c0-882449c50503/proxy/32817/status\n", + " \n", + " Memory: 4.00 GiB\n", + "
\n", + " Nanny: tcp://127.0.0.1:37427\n", + "
\n", + " Local directory: /tmp/dask-scratch-space/worker-x3k19g2n\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: 2

\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + " Comm: tcp://127.0.0.1:40011\n", + " \n", + " Total threads: 4\n", + "
\n", + " Dashboard: /user/fc%3Auid%3A8be9434f-5560-4397-97c0-882449c50503/proxy/36419/status\n", + " \n", + " Memory: 4.00 GiB\n", + "
\n", + " Nanny: tcp://127.0.0.1:44065\n", + "
\n", + " Local directory: /tmp/dask-scratch-space/worker-hiatit97\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: 3

\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + " Comm: tcp://127.0.0.1:46511\n", + " \n", + " Total threads: 4\n", + "
\n", + " Dashboard: /user/fc%3Auid%3A8be9434f-5560-4397-97c0-882449c50503/proxy/32781/status\n", + " \n", + " Memory: 4.00 GiB\n", + "
\n", + " Nanny: tcp://127.0.0.1:40891\n", + "
\n", + " Local directory: /tmp/dask-scratch-space/worker-xszymmhf\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "\n", + "
\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "\n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "client" + ] + }, + { + "cell_type": "markdown", + "id": "78eb8224-3ed3-4f63-b327-7a284c40ff96", + "metadata": {}, + "source": [ + "
\n", + " Info\n", + " If you are running multiple notebooks at the same time, utilising dask, it is a good idea to start the client through the dask extension available on the left side menu.\n", + " This enables you to run all computations on the same client.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "2f1cd2aa-b280-4264-8477-42a43d365d4c", + "metadata": {}, + "source": [ + "Let's say we have some large array we want to do some work on.\n", + "Here we'll illustrate this with a `(100000, 20000)` array with random numbers " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "835f8c81-8654-4f90-9db5-715b88de391b", + "metadata": {}, + "outputs": [], + "source": [ + "rng = np.random.default_rng()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "76dfd3a9-145f-43b4-9751-f55f34036cab", + "metadata": {}, + "outputs": [], + "source": [ + "data_np = rng.standard_normal((100000, 25000))" + ] + }, + { + "cell_type": "markdown", + "id": "0608dcbc-f56e-4078-a696-6ba862bbd3a7", + "metadata": {}, + "source": [ + "Likely, your kernel is going to crash running this cell.\n", + "\n", + "Let us instead try it with dask:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "98aba150-b782-4258-baf3-a80a9d75a7d0", + "metadata": {}, + "outputs": [], + "source": [ + "rng_da = da.random.default_rng()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a96e63ef-64e5-43a5-90b2-250bb9ebb243", + "metadata": {}, + "outputs": [], + "source": [ + "data_da = rng_da.standard_normal((100000, 25000))" + ] + }, + { + "cell_type": "markdown", + "id": "6d0702cf-bb87-49a5-b50c-0d6bb5eae500", + "metadata": {}, + "source": [ + "Have a look at the data, this is currently a lazy Dask array." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9c49f1db-3b43-40f4-ad84-f930b11371f1", + "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", + "
Array Chunk
Bytes 18.63 GiB 128.00 MiB
Shape (100000, 25000) (4096, 4096)
Dask graph 175 chunks in 1 graph layer
Data type float64 numpy.ndarray
\n", + "
\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 25000\n", + " 100000\n", + "\n", + "
" + ], + "text/plain": [ + "dask.array" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_da" + ] + }, + { + "cell_type": "markdown", + "id": "472961a5-c50c-4f91-8c4a-c11782798db4", + "metadata": {}, + "source": [ + "Then we can create the histogram computation" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4497f41f-5124-429d-811e-5fb7d523fc6a", + "metadata": {}, + "outputs": [], + "source": [ + "hist, bins = da.histogram(data_da, bins=20, range=(-3, 3))" + ] + }, + { + "cell_type": "markdown", + "id": "61c5e1c8-9e8c-498f-bf72-49f26d8d510a", + "metadata": {}, + "source": [ + "Note that the histogram hasn't been computed yet (it is lazy).\n", + "Here we can also double-check that the result will fit in memory." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d94eb266-3c5f-48c7-b5d7-470999628cbd", + "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", + "
Array Chunk
Bytes 160 B 160 B
Shape (20,) (20,)
Dask graph 1 chunks in 7 graph layers
Data type int64 numpy.ndarray
\n", + "
\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 1\n", + "\n", + "
" + ], + "text/plain": [ + "dask.array" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hist" + ] + }, + { + "cell_type": "markdown", + "id": "a533cf0b-a33d-4dc1-8024-752ad27bb3a2", + "metadata": {}, + "source": [ + "To actually compute the result, we call the `compute` method on the result." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d9893e2d-17a5-48a1-9217-3ca31e401024", + "metadata": {}, + "outputs": [], + "source": [ + "hist = hist.compute()" + ] + }, + { + "cell_type": "markdown", + "id": "21c41397-d8a8-4419-8515-ea0bd08a860c", + "metadata": {}, + "source": [ + "Plot it to make sure it follows the normal distribution we would expect." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "6222fdf5-c7f0-4252-b8c4-7cb4d6fca70a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGsCAYAAAAPJKchAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAgJUlEQVR4nO3dfVBUh9n38d8WdDEV1qgBYVwF82KMNtZAUnEk1dBi0LHaGiftZJSmyR9kfJnI2Ilop2nSF0xupzU2RuNEcaxJtFN860CMzFTANtqIgZhJ1BqDYhBKSaa7SjuL4nn+yOM+z94gughe7Pr9zJyZ7Nlzdq89UfnO2bOLy3EcRwAAAEa+Zj0AAAC4tREjAADAFDECAABMESMAAMAUMQIAAEwRIwAAwBQxAgAATBEjAADAFDECAABMESMAAMBURMVIVVWVZs6cqZSUFLlcLu3atSvsx3j33Xc1ceJExcfH64477tCcOXNUV1fX88MCAIDrElEx0traqvHjx+vVV1/t1v6fffaZZs2apUceeUS1tbV699131dLSoh/84Ac9PCkAALherkj9RXkul0s7d+7U7Nmzg+va2tr0s5/9TG+++ab+/e9/a9y4cXrppZc0ZcoUSdKf/vQn/ehHP1IgENDXvvZVh/35z3/WrFmzFAgE1K9fP4NXAgDArS2izoxcy5NPPqm//e1v2rZtm44ePaq5c+fq0Ucf1cmTJyVJGRkZiomJUXFxsdrb2+Xz+fSHP/xBOTk5hAgAAEai5szIqVOndPfdd+vzzz9XSkpKcLvvfOc7euihh/Sb3/xG0lfXncydO1dffPGF2tvblZmZqbKyMg0aNMjgVQAAgKg5M/LBBx/IcRzdc889GjhwYHCprKzUqVOnJElNTU16+umnlZeXp8OHD6uyslL9+/fXY489pghtMgAAIl6s9QA95fLly4qJidGRI0cUExMTct/AgQMlSWvXrlVCQoJefvnl4H1bt26V1+vV3//+d02cOPGmzgwAAKIoRiZMmKD29nY1NzcrKyur023+85//dAiVK7cvX77c6zMCAICOIuptmgsXLqi2tla1tbWSpLq6OtXW1qq+vl733HOPnnjiCc2fP187duxQXV2dDh8+rJdeekllZWWSpBkzZujw4cN68cUXdfLkSX3wwQd68sknNXLkSE2YMMHwlQEAcOuKqAtYKyoqNHXq1A7r8/LytHnzZl28eFG/+tWvtGXLFjU0NGjIkCHKzMzUCy+8oG984xuSpG3btunll1/WP/7xD912223KzMzUSy+9pHvvvfdmvxwAAKAIixEAABB9IuptGgAAEH2IEQAAYCoiPk1z+fJlnTt3TvHx8XK5XNbjAACA6+A4js6fP6+UlJTgr2HpTETEyLlz5+T1eq3HAAAA3XD27FkNHz78qvdHRIzEx8dL+urFJCQkGE8DAACuh9/vl9frDf4cv5qIiJErb80kJCQQIwAARJhrXWLBBawAAMAUMQIAAEwRIwAAwBQxAgAATIUVI+vWrdP9998fvJA0MzNT77zzTpf7VFZWKj09XXFxcRo1apTWr19/QwMDAIDoElaMDB8+XCtXrlR1dbWqq6v1yCOPaNasWfr444873b6urk7Tp09XVlaWampqtHz5ci1evFglJSU9MjwAAIh8N/yL8gYPHqz/+Z//0VNPPdXhvueee0579uzRsWPHguvy8/P14Ycf6uDBg9f9HH6/Xx6PRz6fj4/2AgAQIa7353e3rxlpb2/Xtm3b1NraqszMzE63OXjwoHJyckLWTZs2TdXV1bp48eJVHzsQCMjv94csAAAgOoUdIx999JEGDhwot9ut/Px87dy5U/fdd1+n2zY1NSkpKSlkXVJSki5duqSWlparPkdRUZE8Hk9w4avgAQCIXmHHyOjRo1VbW6tDhw7pmWeeUV5enj755JOrbv+/v3XtyrtCXX0bW2FhoXw+X3A5e/ZsuGMCAIAIEfbXwffv31933XWXJCkjI0OHDx/WK6+8otdff73DtsOGDVNTU1PIuubmZsXGxmrIkCFXfQ632y232x3uaAAAIALd8PeMOI6jQCDQ6X2ZmZkqLy8PWbdv3z5lZGSoX79+N/rUAAAgCoQVI8uXL9eBAwd0+vRpffTRR1qxYoUqKir0xBNPSPrq7ZX58+cHt8/Pz9eZM2dUUFCgY8eOadOmTdq4caOWLl3as68CAABErLDepvnnP/+pefPmqbGxUR6PR/fff7/27t2r7373u5KkxsZG1dfXB7dPS0tTWVmZlixZorVr1yolJUVr1qzRnDlzevZVAACAiHXD3zNyM/A9I0DPSF1Waj1CRDm9cob1CEBE6/XvGQEAAOgJxAgAADBFjAAAAFPECAAAMEWMAAAAU8QIAAAwRYwAAABTxAgAADBFjAAAAFPECAAAMEWMAAAAU8QIAAAwRYwAAABTxAgAADBFjAAAAFPECAAAMEWMAAAAU8QIAAAwRYwAAABTxAgAADBFjAAAAFPECAAAMEWMAAAAU8QIAAAwRYwAAABTxAgAADBFjAAAAFPECAAAMEWMAAAAU7HWAwDoXOqyUusRbnm98f/g9MoZPf6YQKTjzAgAADBFjAAAAFPECAAAMEWMAAAAU8QIAAAwRYwAAABTxAgAADBFjAAAAFPECAAAMEWMAAAAU8QIAAAwRYwAAABTxAgAADBFjAAAAFPECAAAMEWMAAAAU8QIAAAwRYwAAABTxAgAADAVVowUFRXpwQcfVHx8vBITEzV79mydOHGiy30qKirkcrk6LMePH7+hwQEAQHQIK0YqKyu1YMECHTp0SOXl5bp06ZJycnLU2tp6zX1PnDihxsbG4HL33Xd3e2gAABA9YsPZeO/evSG3i4uLlZiYqCNHjujhhx/uct/ExEQNGjQo7AEBAEB0u6FrRnw+nyRp8ODB19x2woQJSk5OVnZ2tvbv39/ltoFAQH6/P2QBAADRqdsx4jiOCgoKNHnyZI0bN+6q2yUnJ2vDhg0qKSnRjh07NHr0aGVnZ6uqquqq+xQVFcnj8QQXr9fb3TEBAEAf53Icx+nOjgsWLFBpaan++te/avjw4WHtO3PmTLlcLu3Zs6fT+wOBgAKBQPC23++X1+uVz+dTQkJCd8YFIk7qslLrEdALTq+cYT0CcNP4/X55PJ5r/vzu1pmRRYsWac+ePdq/f3/YISJJEydO1MmTJ696v9vtVkJCQsgCAACiU1gXsDqOo0WLFmnnzp2qqKhQWlpat560pqZGycnJ3doXAABEl7BiZMGCBXrrrbe0e/duxcfHq6mpSZLk8Xg0YMAASVJhYaEaGhq0ZcsWSdLq1auVmpqqsWPHqq2tTVu3blVJSYlKSkp6+KUAAIBIFFaMrFu3TpI0ZcqUkPXFxcX68Y9/LElqbGxUfX198L62tjYtXbpUDQ0NGjBggMaOHavS0lJNnz79xiYHAABRodsXsN5M13sBDBBNuIA1OnEBK24lvXoBKwAAQE8hRgAAgCliBAAAmCJGAACAKWIEAACYIkYAAIApYgQAAJgiRgAAgCliBAAAmCJGAACAKWIEAACYIkYAAIApYgQAAJgiRgAAgCliBAAAmCJGAACAKWIEAACYIkYAAIApYgQAAJgiRgAAgCliBAAAmCJGAACAqVjrAYBokLqs1HoERIje+LNyeuWMHn9M4GbizAgAADBFjAAAAFPECAAAMEWMAAAAU8QIAAAwRYwAAABTxAgAADBFjAAAAFPECAAAMEWMAAAAU8QIAAAwRYwAAABTxAgAADBFjAAAAFPECAAAMEWMAAAAU8QIAAAwRYwAAABTxAgAADBFjAAAAFPECAAAMEWMAAAAU8QIAAAwRYwAAABTxAgAADAVVowUFRXpwQcfVHx8vBITEzV79mydOHHimvtVVlYqPT1dcXFxGjVqlNavX9/tgQEAQHQJK0YqKyu1YMECHTp0SOXl5bp06ZJycnLU2tp61X3q6uo0ffp0ZWVlqaamRsuXL9fixYtVUlJyw8MDAIDIFxvOxnv37g25XVxcrMTERB05ckQPP/xwp/usX79eI0aM0OrVqyVJY8aMUXV1tVatWqU5c+Z0b2oAABA1buiaEZ/PJ0kaPHjwVbc5ePCgcnJyQtZNmzZN1dXVunjxYqf7BAIB+f3+kAUAAESnbseI4zgqKCjQ5MmTNW7cuKtu19TUpKSkpJB1SUlJunTpklpaWjrdp6ioSB6PJ7h4vd7ujgkAAPq4bsfIwoULdfToUb399tvX3NblcoXcdhyn0/VXFBYWyufzBZezZ892d0wAANDHhXXNyBWLFi3Snj17VFVVpeHDh3e57bBhw9TU1BSyrrm5WbGxsRoyZEin+7jdbrnd7u6MBgAAIkxYZ0Ycx9HChQu1Y8cO/eUvf1FaWto198nMzFR5eXnIun379ikjI0P9+vULb1oAABB1woqRBQsWaOvWrXrrrbcUHx+vpqYmNTU16b///W9wm8LCQs2fPz94Oz8/X2fOnFFBQYGOHTumTZs2aePGjVq6dGnPvQoAABCxwoqRdevWyefzacqUKUpOTg4u27dvD27T2Nio+vr64O20tDSVlZWpoqJC3/zmN/XLX/5Sa9as4WO9AABAUpjXjFy58LQrmzdv7rDu29/+tj744INwngoAANwi+N00AADAFDECAABMESMAAMAUMQIAAEwRIwAAwBQxAgAATBEjAADAFDECAABMESMAAMAUMQIAAEwRIwAAwBQxAgAATBEjAADAFDECAABMESMAAMAUMQIAAEwRIwAAwBQxAgAATBEjAADAFDECAABMESMAAMAUMQIAAEwRIwAAwBQxAgAATBEjAADAFDECAABMxVoPANxsqctKrUcAelRP/5k+vXJGjz4ecC2cGQEAAKaIEQAAYIoYAQAApogRAABgihgBAACmiBEAAGCKGAEAAKaIEQAAYIoYAQAApogRAABgihgBAACmiBEAAGCKGAEAAKaIEQAAYIoYAQAApogRAABgihgBAACmiBEAAGCKGAEAAKaIEQAAYIoYAQAApogRAABgKuwYqaqq0syZM5WSkiKXy6Vdu3Z1uX1FRYVcLleH5fjx492dGQAARJHYcHdobW3V+PHj9eSTT2rOnDnXvd+JEyeUkJAQvH3HHXeE+9QAACAKhR0jubm5ys3NDfuJEhMTNWjQoLD3AwAA0e2mXTMyYcIEJScnKzs7W/v37+9y20AgIL/fH7IAAIDo1OsxkpycrA0bNqikpEQ7duzQ6NGjlZ2draqqqqvuU1RUJI/HE1y8Xm9vjwkAAIy4HMdxur2zy6WdO3dq9uzZYe03c+ZMuVwu7dmzp9P7A4GAAoFA8Lbf75fX65XP5wu57gTojtRlpdYjAH3a6ZUzrEdAlPD7/fJ4PNf8+W3y0d6JEyfq5MmTV73f7XYrISEhZAEAANHJJEZqamqUnJxs8dQAAKCPCfvTNBcuXNCnn34avF1XV6fa2loNHjxYI0aMUGFhoRoaGrRlyxZJ0urVq5WamqqxY8eqra1NW7duVUlJiUpKSnruVQAAgIgVdoxUV1dr6tSpwdsFBQWSpLy8PG3evFmNjY2qr68P3t/W1qalS5eqoaFBAwYM0NixY1VaWqrp06f3wPgAACDS3dAFrDfL9V4AA1wPLmAFusYFrOgpffoCVgAAgCuIEQAAYIoYAQAApogRAABgihgBAACmiBEAAGCKGAEAAKaIEQAAYIoYAQAApogRAABgihgBAACmiBEAAGCKGAEAAKaIEQAAYIoYAQAApogRAABgihgBAACmiBEAAGCKGAEAAKaIEQAAYIoYAQAApogRAABgihgBAACmiBEAAGCKGAEAAKaIEQAAYIoYAQAApogRAABgKtZ6AKArqctKrUcAbjm98ffu9MoZPf6YiB6cGQEAAKaIEQAAYIoYAQAApogRAABgihgBAACmiBEAAGCKGAEAAKaIEQAAYIoYAQAApogRAABgihgBAACmiBEAAGCKGAEAAKaIEQAAYIoYAQAApogRAABgihgBAACmiBEAAGCKGAEAAKaIEQAAYCrsGKmqqtLMmTOVkpIil8ulXbt2XXOfyspKpaenKy4uTqNGjdL69eu7MysAAIhCYcdIa2urxo8fr1dfffW6tq+rq9P06dOVlZWlmpoaLV++XIsXL1ZJSUnYwwIAgOgTG+4Oubm5ys3Nve7t169frxEjRmj16tWSpDFjxqi6ulqrVq3SnDlzwn16AAAQZXr9mpGDBw8qJycnZN20adNUXV2tixcvdrpPIBCQ3+8PWQAAQHTq9RhpampSUlJSyLqkpCRdunRJLS0tne5TVFQkj8cTXLxeb2+PCQAAjNyUT9O4XK6Q247jdLr+isLCQvl8vuBy9uzZXp8RAADYCPuakXANGzZMTU1NIeuam5sVGxurIUOGdLqP2+2W2+3u7dEAAEAf0OtnRjIzM1VeXh6ybt++fcrIyFC/fv16++kBAEAfF3aMXLhwQbW1taqtrZX01Ud3a2trVV9fL+mrt1jmz58f3D4/P19nzpxRQUGBjh07pk2bNmnjxo1aunRpz7wCAAAQ0cJ+m6a6ulpTp04N3i4oKJAk5eXlafPmzWpsbAyGiSSlpaWprKxMS5Ys0dq1a5WSkqI1a9bwsV4AACBJcjlXribtw/x+vzwej3w+nxISEqzHwU2UuqzUegQAPeD0yhnWI8DA9f785nfTAAAAU8QIAAAwRYwAAABTxAgAADBFjAAAAFPECAAAMEWMAAAAU8QIAAAwRYwAAABTxAgAADBFjAAAAFPECAAAMEWMAAAAU8QIAAAwRYwAAABTxAgAADBFjAAAAFPECAAAMEWMAAAAU8QIAAAwFWs9AKJL6rJS6xEA9EG98W/D6ZUzevwxYYMzIwAAwBQxAgAATBEjAADAFDECAABMESMAAMAUMQIAAEwRIwAAwBQxAgAATBEjAADAFDECAABMESMAAMAUMQIAAEwRIwAAwBQxAgAATBEjAADAFDECAABMESMAAMAUMQIAAEwRIwAAwBQxAgAATBEjAADAFDECAABMESMAAMAUMQIAAEwRIwAAwBQxAgAATBEjAADAFDECAABMdStGXnvtNaWlpSkuLk7p6ek6cODAVbetqKiQy+XqsBw/frzbQwMAgOgRdoxs375dzz77rFasWKGamhplZWUpNzdX9fX1Xe534sQJNTY2Bpe7776720MDAIDoEXaM/Pa3v9VTTz2lp59+WmPGjNHq1avl9Xq1bt26LvdLTEzUsGHDgktMTEy3hwYAANEjrBhpa2vTkSNHlJOTE7I+JydH7733Xpf7TpgwQcnJycrOztb+/fu73DYQCMjv94csAAAgOoUVIy0tLWpvb1dSUlLI+qSkJDU1NXW6T3JysjZs2KCSkhLt2LFDo0ePVnZ2tqqqqq76PEVFRfJ4PMHF6/WGMyYAAIggsd3ZyeVyhdx2HKfDuitGjx6t0aNHB29nZmbq7NmzWrVqlR5++OFO9yksLFRBQUHwtt/vJ0gAAIhSYZ0ZGTp0qGJiYjqcBWlubu5wtqQrEydO1MmTJ696v9vtVkJCQsgCAACiU1gx0r9/f6Wnp6u8vDxkfXl5uSZNmnTdj1NTU6Pk5ORwnhoAAESpsN+mKSgo0Lx585SRkaHMzExt2LBB9fX1ys/Pl/TVWywNDQ3asmWLJGn16tVKTU3V2LFj1dbWpq1bt6qkpEQlJSU9+0oAAEBECjtGHn/8cX3xxRd68cUX1djYqHHjxqmsrEwjR46UJDU2NoZ850hbW5uWLl2qhoYGDRgwQGPHjlVpaammT5/ec68C3ZK6rNR6BADott74N+z0yhk9/pi4NpfjOI71ENfi9/vl8Xjk8/m4fqQHESMAEIoY6VnX+/Ob300DAABMESMAAMAUMQIAAEwRIwAAwBQxAgAATBEjAADAFDECAABMESMAAMAUMQIAAEwRIwAAwBQxAgAATBEjAADAFDECAABMESMAAMAUMQIAAEwRIwAAwBQxAgAATBEjAADAFDECAABMESMAAMAUMQIAAEwRIwAAwBQxAgAATMVaD4Drk7qs1HoEAIh6vfFv7emVM3r8MaMNZ0YAAIApYgQAAJgiRgAAgCliBAAAmCJGAACAKWIEAACYIkYAAIApYgQAAJgiRgAAgCliBAAAmCJGAACAKWIEAACYIkYAAIApYgQAAJiKtR4gGvXGr6AGAESmnv6ZcHrljB59vL6AMyMAAMAUMQIAAEwRIwAAwBQxAgAATBEjAADAFDECAABMESMAAMDULf89I3wnCAAgkvTGzy3r7y7hzAgAADDVrRh57bXXlJaWpri4OKWnp+vAgQNdbl9ZWan09HTFxcVp1KhRWr9+fbeGBQAA0SfsGNm+fbueffZZrVixQjU1NcrKylJubq7q6+s73b6urk7Tp09XVlaWampqtHz5ci1evFglJSU3PDwAAIh8LsdxnHB2+Na3vqUHHnhA69atC64bM2aMZs+eraKiog7bP/fcc9qzZ4+OHTsWXJefn68PP/xQBw8evK7n9Pv98ng88vl8SkhICGfca+KaEQDAra63rhm53p/fYV3A2tbWpiNHjmjZsmUh63NycvTee+91us/BgweVk5MTsm7atGnauHGjLl68qH79+nXYJxAIKBAIBG/7fD5JX72onnY58J8ef0wAACJJb/x8/f8f91rnPcKKkZaWFrW3tyspKSlkfVJSkpqamjrdp6mpqdPtL126pJaWFiUnJ3fYp6ioSC+88EKH9V6vN5xxAQDAdfCs7t3HP3/+vDwez1Xv79ZHe10uV8htx3E6rLvW9p2tv6KwsFAFBQXB25cvX9aXX36pIUOGdPk8fZ3f75fX69XZs2d7/O2mSMZx6Yhj0hHHpHMcl444Jh1ZHRPHcXT+/HmlpKR0uV1YMTJ06FDFxMR0OAvS3Nzc4ezHFcOGDet0+9jYWA0ZMqTTfdxut9xud8i6QYMGhTNqn5aQkMBfkE5wXDrimHTEMekcx6UjjklHFsekqzMiV4T1aZr+/fsrPT1d5eXlIevLy8s1adKkTvfJzMzssP2+ffuUkZHR6fUiAADg1hL2R3sLCgr0xhtvaNOmTTp27JiWLFmi+vp65efnS/rqLZb58+cHt8/Pz9eZM2dUUFCgY8eOadOmTdq4caOWLl3ac68CAABErLCvGXn88cf1xRdf6MUXX1RjY6PGjRunsrIyjRw5UpLU2NgY8p0jaWlpKisr05IlS7R27VqlpKRozZo1mjNnTs+9igjhdrv1/PPPd3gL6lbHcemIY9IRx6RzHJeOOCYd9fVjEvb3jAAAAPQkfjcNAAAwRYwAAABTxAgAADBFjAAAAFPEiJHvfe97GjFihOLi4pScnKx58+bp3Llz1mOZOn36tJ566imlpaVpwIABuvPOO/X888+rra3NejRTv/71rzVp0iTddtttUfXlf+F67bXXlJaWpri4OKWnp+vAgQPWI5mqqqrSzJkzlZKSIpfLpV27dlmPZK6oqEgPPvig4uPjlZiYqNmzZ+vEiRPWY5lat26d7r///uCXnWVmZuqdd96xHqsDYsTI1KlT9cc//lEnTpxQSUmJTp06pccee8x6LFPHjx/X5cuX9frrr+vjjz/W7373O61fv17Lly+3Hs1UW1ub5s6dq2eeecZ6FDPbt2/Xs88+qxUrVqimpkZZWVnKzc0N+RqBW01ra6vGjx+vV1991XqUPqOyslILFizQoUOHVF5erkuXLiknJ0etra3Wo5kZPny4Vq5cqerqalVXV+uRRx7RrFmz9PHHH1uPFspBn7B7927H5XI5bW1t1qP0KS+//LKTlpZmPUafUFxc7Hg8HusxTDz00ENOfn5+yLp7773XWbZsmdFEfYskZ+fOndZj9DnNzc2OJKeystJ6lD7l9ttvd9544w3rMUJwZqQP+PLLL/Xmm29q0qRJfEX+/+Lz+TR48GDrMWCora1NR44cUU5OTsj6nJwcvffee0ZTIRL4fD5J4t+Q/6u9vV3btm1Ta2urMjMzrccJQYwYeu655/T1r39dQ4YMUX19vXbv3m09Up9y6tQp/f73vw/+qgHcmlpaWtTe3t7hl3EmJSV1+CWcwBWO46igoECTJ0/WuHHjrMcx9dFHH2ngwIFyu93Kz8/Xzp07dd9991mPFYIY6UG/+MUv5HK5ulyqq6uD2//0pz9VTU2N9u3bp5iYGM2fP19OFH4hbrjHRZLOnTunRx99VHPnztXTTz9tNHnv6c4xudW5XK6Q247jdFgHXLFw4UIdPXpUb7/9tvUo5kaPHq3a2lodOnRIzzzzjPLy8vTJJ59YjxUi7N9Ng6tbuHChfvjDH3a5TWpqavC/hw4dqqFDh+qee+7RmDFj5PV6dejQoT53+uxGhXtczp07p6lTpyozM1MbNmzo5elshHtMbmVDhw5VTExMh7Mgzc3NHc6WAJK0aNEi7dmzR1VVVRo+fLj1OOb69++vu+66S5KUkZGhw4cP65VXXtHrr79uPNn/Q4z0oCtx0R1XzogEAoGeHKlPCOe4NDQ0aOrUqUpPT1dxcbG+9rXoPHl3I39WbjX9+/dXenq6ysvL9f3vfz+4vry8XLNmzTKcDH2N4zhatGiRdu7cqYqKCqWlpVmP1Cc5jtPnftYQIwbef/99vf/++5o8ebJuv/12ffbZZ/r5z3+uO++8M+rOioTj3LlzmjJlikaMGKFVq1bpX//6V/C+YcOGGU5mq76+Xl9++aXq6+vV3t6u2tpaSdJdd92lgQMH2g53kxQUFGjevHnKyMgInjGrr6+/pa8nunDhgj799NPg7bq6OtXW1mrw4MEaMWKE4WR2FixYoLfeeku7d+9WfHx88Gyax+PRgAEDjKezsXz5cuXm5srr9er8+fPatm2bKioqtHfvXuvRQll+lOdWdfToUWfq1KnO4MGDHbfb7aSmpjr5+fnO559/bj2aqeLiYkdSp8utLC8vr9Njsn//fuvRbqq1a9c6I0eOdPr37+888MADt/zHNffv39/pn4u8vDzr0cxc7d+P4uJi69HM/OQnPwn+vbnjjjuc7OxsZ9++fdZjdeBynCi8YhIAAESM6HxDHgAARAxiBAAAmCJGAACAKWIEAACYIkYAAIApYgQAAJgiRgAAgCliBAAAmCJGAACAKWIEAACYIkYAAIApYgQAAJj6P2zR5Irt+nhOAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(bins[:-1], hist)" + ] + }, + { + "cell_type": "markdown", + "id": "4e9306fe-0508-4a14-9180-1613bea32df6", + "metadata": {}, + "source": [ + "# Xarray + Dask\n", + "xarray is an interface to array data like Numpy, or often Dask.\n", + "\n", + "Below we load some MERRA data.\n", + "Specifying `chunks=\"auto\"` is optional but it makes sure data is read as Dask arrays." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "760d942b-3f96-4a59-a4e7-0e8d882df568", + "metadata": {}, + "outputs": [], + "source": [ + "merra_ds = xr.open_mfdataset(\n", + " \"/mnt/craas1-ns9989k-ns9600k/escience_course/MERRA2/MERRA2_300.inst3_3d_aer_Nv.200*.SUB.nc\",\n", + " chunks=\"auto\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "73744035-82c1-4230-a8c2-7a191cb6bd60", + "metadata": {}, + "source": [ + "One of the variables of the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "2c96d8a9-d015-48dc-a10f-eb842af59d8b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'SS001' (time: 8768, lev: 3, lat: 121, lon: 576)> Size: 7GB\n",
+       "dask.array<concatenate, shape=(8768, 3, 121, 576), dtype=float32, chunksize=(8, 3, 121, 576), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 70kB 2007-01-01 ... 2009-12-31T21:00:00\n",
+       "  * lon      (lon) float64 5kB -180.0 -179.4 -178.8 -178.1 ... 178.1 178.8 179.4\n",
+       "  * lat      (lat) float64 968B 30.0 30.5 31.0 31.5 32.0 ... 88.5 89.0 89.5 90.0\n",
+       "  * lev      (lev) float64 24B 56.0 63.0 67.0\n",
+       "Attributes:\n",
+       "    standard_name:   Sea Salt Mixing Ratio (bin 001)\n",
+       "    long_name:       Sea Salt Mixing Ratio (bin 001)\n",
+       "    units:           kg kg-1\n",
+       "    fmissing_value:  1000000000000000.0\n",
+       "    vmax:            1000000000000000.0\n",
+       "    vmin:            -1000000000000000.0
" + ], + "text/plain": [ + " Size: 7GB\n", + "dask.array\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 70kB 2007-01-01 ... 2009-12-31T21:00:00\n", + " * lon (lon) float64 5kB -180.0 -179.4 -178.8 -178.1 ... 178.1 178.8 179.4\n", + " * lat (lat) float64 968B 30.0 30.5 31.0 31.5 32.0 ... 88.5 89.0 89.5 90.0\n", + " * lev (lev) float64 24B 56.0 63.0 67.0\n", + "Attributes:\n", + " standard_name: Sea Salt Mixing Ratio (bin 001)\n", + " long_name: Sea Salt Mixing Ratio (bin 001)\n", + " units: kg kg-1\n", + " fmissing_value: 1000000000000000.0\n", + " vmax: 1000000000000000.0\n", + " vmin: -1000000000000000.0" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "merra_ds.SS001" + ] + }, + { + "cell_type": "markdown", + "id": "6f7641ee-af52-4ac1-bdd3-f97fd7b9b96a", + "metadata": {}, + "source": [ + "Xarray recognizes that the data is in the form of a dask array.\n", + "The following will work as we expect, and be “parallelized” in the background using dask (Look at the Progress in the dashboard)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b6166da8-f6fe-4aed-8f1b-9291aa293bca", + "metadata": {}, + "outputs": [], + "source": [ + "mean_ds = merra_ds.SS001.mean(dim=\"time\").compute()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "d4f8c477-79f6-4e4f-8448-07c97649a5fc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mean_ds.isel(lev=0).plot()" + ] + }, + { + "cell_type": "markdown", + "id": "c96902d7-6e4d-43f9-8892-3f09b767da78", + "metadata": {}, + "source": [ + "## Working with chunks\n", + "But some computations are a bit more tricky.\n", + "This won't work." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "8cbe4ce7-bb99-4d9e-83b3-a90a02dfd0e5", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "ename": "ValueError", + "evalue": "dimension time on 0th function argument to apply_ufunc with dask='parallelized' consists of multiple chunks, but is also a core dimension. To fix, either rechunk into a single array chunk along this dimension, i.e., ``.chunk(dict(time=-1))``, or pass ``allow_rechunk=True`` in ``dask_gufunc_kwargs`` but beware that this may significantly increase memory usage.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[16], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mmerra_ds\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mSS001\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mquantile\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0.85\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdim\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtime\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/conda/envs/pangeo-notebook/lib/python3.11/site-packages/xarray/util/deprecation_helpers.py:115\u001b[0m, in \u001b[0;36m_deprecate_positional_args.._decorator..inner\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 111\u001b[0m kwargs\u001b[38;5;241m.\u001b[39mupdate({name: arg \u001b[38;5;28;01mfor\u001b[39;00m name, arg \u001b[38;5;129;01min\u001b[39;00m zip_args})\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m func(\u001b[38;5;241m*\u001b[39margs[:\u001b[38;5;241m-\u001b[39mn_extra_args], \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 115\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/conda/envs/pangeo-notebook/lib/python3.11/site-packages/xarray/core/dataarray.py:5187\u001b[0m, in \u001b[0;36mDataArray.quantile\u001b[0;34m(self, q, dim, method, keep_attrs, skipna, interpolation)\u001b[0m\n\u001b[1;32m 5077\u001b[0m \u001b[38;5;129m@_deprecate_positional_args\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mv2023.10.0\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 5078\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mquantile\u001b[39m(\n\u001b[1;32m 5079\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 5086\u001b[0m interpolation: QuantileMethods \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 5087\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Self:\n\u001b[1;32m 5088\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Compute the qth quantile of the data along the specified dimension.\u001b[39;00m\n\u001b[1;32m 5089\u001b[0m \n\u001b[1;32m 5090\u001b[0m \u001b[38;5;124;03m Returns the qth quantiles(s) of the array elements.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 5184\u001b[0m \u001b[38;5;124;03m The American Statistician, 50(4), pp. 361-365, 1996\u001b[39;00m\n\u001b[1;32m 5185\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 5187\u001b[0m ds \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_to_temp_dataset\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mquantile\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 5188\u001b[0m \u001b[43m \u001b[49m\u001b[43mq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5189\u001b[0m \u001b[43m \u001b[49m\u001b[43mdim\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdim\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5190\u001b[0m \u001b[43m \u001b[49m\u001b[43mkeep_attrs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkeep_attrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5191\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5192\u001b[0m \u001b[43m \u001b[49m\u001b[43mskipna\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mskipna\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5193\u001b[0m \u001b[43m \u001b[49m\u001b[43minterpolation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minterpolation\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5194\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 5195\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_from_temp_dataset(ds)\n", + "File \u001b[0;32m/opt/conda/envs/pangeo-notebook/lib/python3.11/site-packages/xarray/util/deprecation_helpers.py:115\u001b[0m, in \u001b[0;36m_deprecate_positional_args.._decorator..inner\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 111\u001b[0m kwargs\u001b[38;5;241m.\u001b[39mupdate({name: arg \u001b[38;5;28;01mfor\u001b[39;00m name, arg \u001b[38;5;129;01min\u001b[39;00m zip_args})\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m func(\u001b[38;5;241m*\u001b[39margs[:\u001b[38;5;241m-\u001b[39mn_extra_args], \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 115\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/conda/envs/pangeo-notebook/lib/python3.11/site-packages/xarray/core/dataset.py:8183\u001b[0m, in \u001b[0;36mDataset.quantile\u001b[0;34m(self, q, dim, method, numeric_only, keep_attrs, skipna, interpolation)\u001b[0m\n\u001b[1;32m 8177\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcoords:\n\u001b[1;32m 8178\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m 8179\u001b[0m \u001b[38;5;129;01mnot\u001b[39;00m numeric_only\n\u001b[1;32m 8180\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m np\u001b[38;5;241m.\u001b[39missubdtype(var\u001b[38;5;241m.\u001b[39mdtype, np\u001b[38;5;241m.\u001b[39mnumber)\n\u001b[1;32m 8181\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m var\u001b[38;5;241m.\u001b[39mdtype \u001b[38;5;241m==\u001b[39m np\u001b[38;5;241m.\u001b[39mbool_\n\u001b[1;32m 8182\u001b[0m ):\n\u001b[0;32m-> 8183\u001b[0m variables[name] \u001b[38;5;241m=\u001b[39m \u001b[43mvar\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mquantile\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 8184\u001b[0m \u001b[43m \u001b[49m\u001b[43mq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 8185\u001b[0m \u001b[43m \u001b[49m\u001b[43mdim\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreduce_dims\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 8186\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 8187\u001b[0m \u001b[43m \u001b[49m\u001b[43mkeep_attrs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkeep_attrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 8188\u001b[0m \u001b[43m \u001b[49m\u001b[43mskipna\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mskipna\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 8189\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 8191\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 8192\u001b[0m variables[name] \u001b[38;5;241m=\u001b[39m var\n", + "File \u001b[0;32m/opt/conda/envs/pangeo-notebook/lib/python3.11/site-packages/xarray/core/variable.py:1907\u001b[0m, in \u001b[0;36mVariable.quantile\u001b[0;34m(self, q, dim, method, keep_attrs, skipna, interpolation)\u001b[0m\n\u001b[1;32m 1903\u001b[0m axis \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mlen\u001b[39m(dim) \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 1905\u001b[0m kwargs \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mq\u001b[39m\u001b[38;5;124m\"\u001b[39m: q, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124maxis\u001b[39m\u001b[38;5;124m\"\u001b[39m: axis, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmethod\u001b[39m\u001b[38;5;124m\"\u001b[39m: method}\n\u001b[0;32m-> 1907\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mapply_ufunc\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[43m \u001b[49m\u001b[43m_wrapper\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1909\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1910\u001b[0m \u001b[43m \u001b[49m\u001b[43minput_core_dims\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mdim\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1911\u001b[0m \u001b[43m \u001b[49m\u001b[43mexclude_dims\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mset\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mdim\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1912\u001b[0m \u001b[43m \u001b[49m\u001b[43moutput_core_dims\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mquantile\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1913\u001b[0m \u001b[43m \u001b[49m\u001b[43moutput_dtypes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfloat64\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1914\u001b[0m \u001b[43m \u001b[49m\u001b[43mdask_gufunc_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mdict\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43moutput_sizes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mquantile\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mq\u001b[49m\u001b[43m)\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1915\u001b[0m \u001b[43m \u001b[49m\u001b[43mdask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mparallelized\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1916\u001b[0m \u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1917\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1919\u001b[0m \u001b[38;5;66;03m# for backward compatibility\u001b[39;00m\n\u001b[1;32m 1920\u001b[0m result \u001b[38;5;241m=\u001b[39m result\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mquantile\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m)\n", + "File \u001b[0;32m/opt/conda/envs/pangeo-notebook/lib/python3.11/site-packages/xarray/core/computation.py:1280\u001b[0m, in \u001b[0;36mapply_ufunc\u001b[0;34m(func, input_core_dims, output_core_dims, exclude_dims, vectorize, join, dataset_join, dataset_fill_value, keep_attrs, kwargs, dask, output_dtypes, output_sizes, meta, dask_gufunc_kwargs, on_missing_core_dim, *args)\u001b[0m\n\u001b[1;32m 1278\u001b[0m \u001b[38;5;66;03m# feed Variables directly through apply_variable_ufunc\u001b[39;00m\n\u001b[1;32m 1279\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28many\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(a, Variable) \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m args):\n\u001b[0;32m-> 1280\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvariables_vfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1281\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1282\u001b[0m \u001b[38;5;66;03m# feed anything else through apply_array_ufunc\u001b[39;00m\n\u001b[1;32m 1283\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m apply_array_ufunc(func, \u001b[38;5;241m*\u001b[39margs, dask\u001b[38;5;241m=\u001b[39mdask)\n", + "File \u001b[0;32m/opt/conda/envs/pangeo-notebook/lib/python3.11/site-packages/xarray/core/computation.py:771\u001b[0m, in \u001b[0;36mapply_variable_ufunc\u001b[0;34m(func, signature, exclude_dims, dask, output_dtypes, vectorize, keep_attrs, dask_gufunc_kwargs, *args)\u001b[0m\n\u001b[1;32m 769\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m axis, dim \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(core_dims, start\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m-\u001b[39m\u001b[38;5;28mlen\u001b[39m(core_dims)):\n\u001b[1;32m 770\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(data\u001b[38;5;241m.\u001b[39mchunks[axis]) \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m--> 771\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 772\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdimension \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdim\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m on \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mn\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124mth function argument to \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 773\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mapply_ufunc with dask=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mparallelized\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m consists of \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 774\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmultiple chunks, but is also a core dimension. To \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 775\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfix, either rechunk into a single array chunk along \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 776\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthis dimension, i.e., ``.chunk(dict(\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdim\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m=-1))``, or \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 777\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpass ``allow_rechunk=True`` in ``dask_gufunc_kwargs`` \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 778\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbut beware that this may significantly increase memory usage.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 779\u001b[0m )\n\u001b[1;32m 780\u001b[0m dask_gufunc_kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mallow_rechunk\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 782\u001b[0m output_sizes \u001b[38;5;241m=\u001b[39m dask_gufunc_kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moutput_sizes\u001b[39m\u001b[38;5;124m\"\u001b[39m, {})\n", + "\u001b[0;31mValueError\u001b[0m: dimension time on 0th function argument to apply_ufunc with dask='parallelized' consists of multiple chunks, but is also a core dimension. To fix, either rechunk into a single array chunk along this dimension, i.e., ``.chunk(dict(time=-1))``, or pass ``allow_rechunk=True`` in ``dask_gufunc_kwargs`` but beware that this may significantly increase memory usage." + ] + } + ], + "source": [ + "merra_ds.SS001.quantile(0.85, dim=\"time\")" + ] + }, + { + "cell_type": "markdown", + "id": "cf3f280c-5f44-4ee3-b8a2-646d85a7bc6a", + "metadata": {}, + "source": [ + "If we read the error message, it says something about that the dimension on the 0th function argument to `apply_ufunc` consists of multiple chunks.\n", + "This has to do with that there is no parallel implementation of the quantile algorithm — it needs to see all time steps.\n", + "To solve this, we can `rechunk` our data.\n", + "In this case, we declare that the data should not be chunked along the time dimension, but can be chunked freely along other dimensions.\n", + "\n", + "
\n", + " Note that rechunking adds some extra computations.\n", + "
\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7098132e-00e9-482b-bdb7-c9a0c32b4a9c", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-05-20 09:20:43,990 - distributed.worker.memory - WARNING - Unmanaged memory use is high. This may indicate a memory leak or the memory may not be released to the OS; see https://distributed.dask.org/en/latest/worker-memory.html#memory-not-released-back-to-the-os for more information. -- Unmanaged memory: 2.60 GiB -- Worker memory limit: 4.00 GiB\n", + "2024-05-20 09:20:44,768 - distributed.worker.memory - WARNING - Unmanaged memory use is high. This may indicate a memory leak or the memory may not be released to the OS; see https://distributed.dask.org/en/latest/worker-memory.html#memory-not-released-back-to-the-os for more information. -- Unmanaged memory: 2.43 GiB -- Worker memory limit: 4.00 GiB\n", + "2024-05-20 09:20:58,762 - distributed.worker.memory - WARNING - Unmanaged memory use is high. This may indicate a memory leak or the memory may not be released to the OS; see https://distributed.dask.org/en/latest/worker-memory.html#memory-not-released-back-to-the-os for more information. -- Unmanaged memory: 2.49 GiB -- Worker memory limit: 4.00 GiB\n" + ] + } + ], + "source": [ + "qtile = merra_ds.SS001.chunk({\"time\":-1, \"lon\": \"auto\", \"lat\": \"auto\", \"lev\": \"auto\"}).quantile(0.85, dim=\"time\").compute()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "afdce204-891b-4e20-8226-303dfabe51f4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qtile.isel(lev=0).plot()" + ] + }, + { + "cell_type": "markdown", + "id": "d144c438-5808-443c-a647-5c659b579e1a", + "metadata": {}, + "source": [ + "## Accessing the dask array\n", + "Not all operations available in Numpy/Dask are wrapped by xarray.\n", + "For instance, to compute the histogram (not plotting) you could do something like this:\n", + "```python\n", + "np.histogram(merra_ds.SS0001.values)\n", + "```\n", + "where calling `values` **always** gives us the underlying Numpy array.\n", + "If the dataset is backed by Dask arrays, they will be loaded into memory — which is a problem if the data is too big.\n", + "Instead you could use the `data` attribute of a dataset, which will return the Dask array:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "f1156c72-30b9-495c-9d23-4b4a24026727", + "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", + "
Array Chunk
Bytes 6.83 GiB 6.38 MiB
Shape (8768, 3, 121, 576) (8, 3, 121, 576)
Dask graph 1096 chunks in 2193 graph layers
Data type float32 numpy.ndarray
\n", + "
\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 8768\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 576\n", + " 121\n", + " 3\n", + "\n", + "
" + ], + "text/plain": [ + "dask.array" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "merra_ds.SS001.data" + ] + }, + { + "cell_type": "markdown", + "id": "92a3a901-c1b2-4763-89bc-a59abecdd3c2", + "metadata": {}, + "source": [ + "With this we have an array we can pass to Dask array specific functions such as" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "7e4e3c64-9e56-40e9-9d78-4ba58721fa57", + "metadata": {}, + "outputs": [], + "source": [ + "hist, bins = da.histogram(merra_ds.SS001.data, bins=10, range=(0, merra_ds.SS001.max()))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "6d6a58bc-ebd3-4a92-ab5b-2d84cd2466c9", + "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", + "
Array Chunk
Bytes 88 B 88 B
Shape (11,) (11,)
Dask graph 1 chunks in 2207 graph layers
Data type float64 numpy.ndarray
\n", + "
\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 11\n", + " 1\n", + "\n", + "
" + ], + "text/plain": [ + "dask.array" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bins" + ] + }, + { + "cell_type": "markdown", + "id": "245a892f-595e-43a6-9a96-86ef0816dce1", + "metadata": {}, + "source": [ + "Then we have to compute the histogram" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "b230d91f-28ba-4d5b-ba5c-905308387f76", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1833234752, 47344, 1173, 202, 80,\n", + " 24, 5, 2, 1, 1])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hist.compute()" + ] + }, + { + "cell_type": "markdown", + "id": "901d2afc-be4a-474d-93e8-a28bdedb6d83", + "metadata": {}, + "source": [ + "# Numba\n", + "[Numba](https://numba.pydata.org/) is a just-in-time compiler for python, which can speed up your slow python-loops, if they work on the supported data types (see documentation)." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "91552ddd-562e-4cf0-b24b-8889898324f1", + "metadata": {}, + "outputs": [], + "source": [ + "rng = np.random.default_rng()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "3f80704d-9d91-4671-8236-fc75a291b837", + "metadata": {}, + "outputs": [], + "source": [ + "test = rng.random((10000, 2))\n", + "test2 = rng.random((10000, 2))" + ] + }, + { + "cell_type": "markdown", + "id": "76963497-3871-4dac-bd1f-b576af5b88df", + "metadata": {}, + "source": [ + "The `njit` decorator will try to compile a function the first time it is run.\n", + "It will raise an error if numba is not able to compile the function. " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "2e57abaf-1014-480a-a922-f53e8d891a14", + "metadata": {}, + "outputs": [], + "source": [ + "from numba import njit" + ] + }, + { + "cell_type": "markdown", + "id": "ae7cd4e3-0056-433c-9bf5-347f7828eeea", + "metadata": {}, + "source": [ + "Here, we have two identical functions that search for matching coordinate pairs in two relatively large arrays.\n", + "In reality this could be real coordinates, now we just use random numbers." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "b4d85344-7048-4f1b-83bb-c8b0ea6430b3", + "metadata": {}, + "outputs": [], + "source": [ + "def slow_coord_isin(ds_locs, merra_locs):\n", + " mask = np.zeros(ds_locs.shape[0])\n", + " for i, ds_coord in enumerate(ds_locs):\n", + " for merra_coord in merra_locs:\n", + " if ds_coord[0] == merra_coord[0] and ds_coord[1] == merra_coord[1]:\n", + " mask[i] = 1\n", + " break\n", + " return mask\n", + "\n", + "# Here we add the njit decorator.\n", + "@njit\n", + "def fast_coord_isin(ds_locs, merra_locs):\n", + " mask = np.zeros(ds_locs.shape[0])\n", + " for i, ds_coord in enumerate(ds_locs):\n", + " for merra_coord in merra_locs:\n", + " if ds_coord[0] == merra_coord[0] and ds_coord[1] == merra_coord[1]:\n", + " mask[i] = 1\n", + " break\n", + " return mask" + ] + }, + { + "cell_type": "markdown", + "id": "b503cdb2-64eb-46f6-8e8a-1063297c9ec2", + "metadata": {}, + "source": [ + "Use the `%%time` cell magic to time the functions.\n", + "For more robust timings use the `%%timeit` cell magic." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "9bc207c4-79e1-4ffa-9a5b-215f4712da2e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 10.9 s, sys: 72.2 ms, total: 10.9 s\n", + "Wall time: 10.9 s\n" + ] + }, + { + "data": { + "text/plain": [ + "array([1., 1., 1., ..., 1., 1., 1.])" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "slow_coord_isin(test, test)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "2cb7bde2-8e0c-423e-84a3-b4c59673a493", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 639 ms, sys: 60.8 ms, total: 700 ms\n", + "Wall time: 690 ms\n" + ] + }, + { + "data": { + "text/plain": [ + "array([1., 1., 1., ..., 1., 1., 1.])" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "fast_coord_isin(test, test)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:pangeo-notebook]", + "language": "python", + "name": "conda-env-pangeo-notebook-py" + }, + "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.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}