2_xarray_intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "05bc84da",
   "metadata": {},
   "source": [
    "# Data science with xarray\n",
    "\n",
    "Hello and welcome to your intro to `xarray` for data science as part of NCI's data science course.\n",
    "\n",
    "This notebook is designed to cover the fundamentals of `xarray` highlighting some similarities with tools you have already been introduced to such as `NumPy` and `CuPy` and some of the advantages of using `xarray`.\n",
    "\n",
    "The xarray project has extensive and well explained documentation at the xarray [homepage](https://docs.xarray.dev/en/stable/index.html). \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "894c04f2-cd54-4e2f-bf74-fb53d4d53549",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "# The jupyter notebook is launched from your $HOME directory.\n",
    "# Change the working directory to the folder\n",
    "# which was created in your username directory under /scratch/vp91\n",
    "\n",
    "#TODO \n",
    "os.chdir(os.path.expandvars(\"/scratch/vp91/$USER/Data-Analytics/\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e054ba10",
   "metadata": {},
   "source": [
    "## Intro\n",
    "\n",
    "First of all what is `xarray`? `xarray` is a project that came out of climate and geophysics research, recognising the need for rapid, scalable and easily manipulated N dimensional array data **with labels and metadata**. \n",
    "\n",
    "But wait, doesn't `NumPy` provide an N Dimensional array? Yes it does, but `xarray` provides the ability to use labelled and metadata rich arrays, providing to quote the manual a \" more intuitive, more concise, and less error-prone developer experience\".\n",
    "\n",
    "This is done by providing a label based API that simplifies a lot of the manual book keeping of working with `numpy` arrays directly.\n",
    "\n",
    "No longer will you forget what experiment this data came from, what that tensor dimension was, or what array position corresponded to with time point! Even better these, augmented N dimensional arrays can be combined to make massive datasets, enabling analysis of huge volumes of data. It's all there in  the one datastructure that can be easily stored and shared, as is done on a massive scale using `xarray` in the climate modelling, geophysics, and astrophysics communities to name just a few. \n",
    "\n",
    "\n",
    "Alright, lets jump in! "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbbec550",
   "metadata": {},
   "source": [
    "## Crash course"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2602463c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# lets import xarray and numpy\n",
    "import xarray as xr\n",
    "import numpy as np\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "769330b9",
   "metadata": {},
   "source": [
    "The `DataArray` is the `xarray` equivalent of the `numpy` `ndarray` and will be the first focus of our intro. Lets make a 2 x 3 DataArray using a numpy array, so we can get the hang of how to work with it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6a8a746",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "inp = np.arange(6).reshape(2,3)\n",
    "data = xr.DataArray(inp, dims=(\"x\", \"y\"))\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40d7b564",
   "metadata": {},
   "source": [
    "We can see that our data array looks a lot like a numpy array, but with two labelled dimensions `x` and `y`. We can access our values directly using the `values` attribute as shown below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "646d0f85",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data.values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b9187c4",
   "metadata": {},
   "source": [
    "We can also access our dimensions using the `dims` attribute as shown below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1e85548",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.dims"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a7102e2",
   "metadata": {},
   "source": [
    "The eagle eyed amongst you may have  spotted the `coords` attribute. This is used to associate a value along a particular axis with another value, that could for example correspond to the time or location it was measured. The possibilities are only limited by your imagination\n",
    "\n",
    "We set our `coords` using a dictionary corresponding to the `coords` along a particular axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4b248ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "coords = {\"x\":[10, 20], \"y\":[0.1, 0.2, 0.3]}\n",
    "data = data.assign_coords(coords)\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5c80d10",
   "metadata": {},
   "source": [
    "**Notice the detail above**, we had to assign our `DataArray` to a new object (in this case we overwrote `data`) for our change to persist. This pattern will be familiar to those who use `pandas`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cdc3b7d",
   "metadata": {},
   "source": [
    "### Challenge\n",
    "Make a different set of coordinates for `data` and assign it to a new variable.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8648192b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a different set of coordinates for data and assign it to a new variable.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0670f3c",
   "metadata": {},
   "source": [
    "<details><summary><b>Solution</b></summary>\n",
    "   <pre>\n",
    "    <br>coords = {\"x\":[2.0, 2.1], \"y\":[300, 400, 500]}\n",
    "data2 = data.assign_coords(coords)\n",
    "   </pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad17c0c0",
   "metadata": {},
   "source": [
    "## Indexing\n",
    "\n",
    "Okay cool, how can we access the data in our array? We can use four kinds of slicing. \n",
    "\n",
    "* Numpy like using integer locations\n",
    "* using `loc` like in pandas\n",
    "* using an integer select (`isel`), combining a dimension name and integer label\n",
    "* using a selection (`sel`) based on coordinate combining a dimension name and coordinate value\n",
    "\n",
    "The following selections all give the same set of values, those at `x=10`:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21cf5434",
   "metadata": {},
   "source": [
    "**Numpy like using array indexing:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "511a8494",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[0, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7797e095",
   "metadata": {},
   "source": [
    "**Pandas like using `loc`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e3ed56b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data.loc[10]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb446159",
   "metadata": {},
   "source": [
    "**An xarray integer selection**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "595b7b90",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data.isel(x=0,y=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27f7af73",
   "metadata": {},
   "source": [
    "**An xarray selection**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f256b4f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data.sel(x=10,y=0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc4b5c6b",
   "metadata": {},
   "source": [
    "When dealing with a complicated multidimensional dataset, I and the creators of `xarray` would argue that the last two are simple and powerful.\n",
    "\n",
    "Note that we can also use `pandas` style `DataArray.dim` indexing to access a given dimension eg:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c6d8f1c",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data.x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3136c30a",
   "metadata": {},
   "source": [
    "aggregation operations can also use dimension labels eg:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7d7df00",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.mean(dim=\"x\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57b07e4c",
   "metadata": {},
   "source": [
    "### Challenge\n",
    "\n",
    "select the slice of data at `y=0.2` and compute its mean.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b324234d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# select the slice of data at `y=0.2` and compute its mean.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4af5fdf",
   "metadata": {},
   "source": [
    "<details><summary><b>Solution</b></summary>\n",
    "   <pre>\n",
    "    <br> data.sel(y=0.2).mean()\n",
    "   </pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ada35f3",
   "metadata": {},
   "source": [
    "## Metadata\n",
    "\n",
    "When dealing with complex data another advantage of `xarray` is metadata. Using the `.attrs`  `dict` attribute of `DataArray` we can associate any arbitrary field with our array data. For example lets label our current dataset:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8eaf0db3",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.attrs[\"long_name\"] = \"random array\"\n",
    "data.attrs[\"units\"] = \"rad/second\"\n",
    "data.attrs[\"description\"] = \"A random variable created as an example.\"\n",
    "data.attrs[\"arbitrary\"] = \"arbitrary\"\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdb3c7b0",
   "metadata": {},
   "source": [
    "We can also associate our dimensions with metadata. For example lets add some metadata with our `x` dimension. \n",
    "\n",
    "Note here that we use pandas style `data.dim` accessing as demonstrated above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9348358e",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.x.attrs[\"units\"] = \"x units\"\n",
    "data.x.attrs[\"name\"] = \"name of x dimension\"\n",
    "data.x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00c94b62",
   "metadata": {},
   "source": [
    "Of course, just like a numpy array we can do broadcasted operations accross the whole array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2aa13bd7",
   "metadata": {},
   "outputs": [],
   "source": [
    "data += 100\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5484b4e",
   "metadata": {},
   "source": [
    "And use many of the standard numpy style shortcuts such as `.T` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ad26791",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.T"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b00977a",
   "metadata": {},
   "source": [
    "## Broadcasting, operations and labelled dimensions\n",
    "\n",
    "A fantastic feature of xarray is that operations are dimension specific. Let me show you what I mean.\n",
    "\n",
    "We are going to make three arrays for demonstration purposes. Array `x` and `y` have different `dims` while `x` and `z` share the `x` dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fee97b5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# has x as dimension\n",
    "x = xr.DataArray(np.arange(10), dims=\"x\", coords= {\"x\": np.arange(10)/10})\n",
    "\n",
    "# has y as dimension\n",
    "y = xr.DataArray(np.arange(3), dims=\"y\", coords = {\"y\": np.arange(3)/10})\n",
    "\n",
    "# has x dimension\n",
    "z = xr.DataArray(np.arange(3), dims=\"x\", coords = {\"x\": np.arange(3)/10})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0e56bf5",
   "metadata": {},
   "source": [
    "So what happens when I do an operation on arrays with non-matching dimensions?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c306b3a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x)\n",
    "print(y)\n",
    "print(z)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54af7e27",
   "metadata": {},
   "outputs": [],
   "source": [
    "# result broadcast\n",
    "result = x*y\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7eaab04d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "y*x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d91a5e89",
   "metadata": {},
   "source": [
    "Thats interesting! We actually get an **outer product** (tensor product for more than two matching dimensions) formed by broadcasting accross the non-matching dimensions.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e577af0",
   "metadata": {},
   "source": [
    "When dimensions and coordinates match, we can easily broadcast accross those instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac7346b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# result broadcast on matching dimension and coordinates\n",
    "result = x*z\n",
    "result\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10e41bf3",
   "metadata": {},
   "source": [
    "The net result of all of this is that we don't need to manually keep track of dimension ordering, indexing and alignment of our coordinates as you would have to do in numpy and don't have to pad arrays with dummy data.\n",
    "\n",
    "As an example of this, lets multiply our array by its transpose, noting that it is not a square matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d76575d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "ten_by_three = x*y\n",
    "ten_by_three"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c3cd067",
   "metadata": {},
   "outputs": [],
   "source": [
    "ten_by_three_transpose = ten_by_three.T\n",
    "ten_by_three_transpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c587f72",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "result = ten_by_three*ten_by_three.T\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7dad546",
   "metadata": {},
   "source": [
    "here, xarray took care of aligning our dimensions based on **dimension labels** even though the order of dimensions was reversed in our transpose.\n",
    "\n",
    "This is not possible in numpy as show below"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1c83afa",
   "metadata": {},
   "source": [
    "### Challenge\n",
    "\n",
    "Uncomment the below and see what happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9679c742",
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can uncomment this and find out\n",
    "\n",
    "# a = np.outer(np.arange(10), np.arange(3))\n",
    "# a*a.T"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00af9004",
   "metadata": {},
   "source": [
    "## Saving data and serialising\n",
    "\n",
    "A lot of the functionality in `xarray` is based on the netcdf binary format, and as such the reccomended format for saving a `DataArray` is as a netcdf file. \n",
    "\n",
    "We need to import either `scipy` or `netcdf4-python` to provide the interface with the format. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1587c26d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy\n",
    "result.to_netcdf(\"array.nc\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b497a00",
   "metadata": {},
   "source": [
    "## Worked example with a 4D function\n",
    "\n",
    "We are going to go through a more in depth example of how `xarray's` functionality is such a powerful tool.\n",
    "\n",
    "We are going to use an example of a 3D mesh that various over time, resulting in a 4D function with dimensions (x,y,z,t). We are going to use our imagination and pretend that these are **waves propagating  noisily in a 3D box**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "173fe12f",
   "metadata": {},
   "source": [
    " First we construct our domain:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d38b341",
   "metadata": {},
   "outputs": [],
   "source": [
    "# construct our domain\n",
    "spatial_density = 40\n",
    "time_density = 1001\n",
    "spatial_domain = (-5,5)\n",
    "time_domain = (0,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b66fd3ea",
   "metadata": {},
   "source": [
    "Then our grids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "feb378e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# turn into grid points\n",
    "x = np.linspace(spatial_domain[0], spatial_domain[1], spatial_density)\n",
    "y = np.linspace(spatial_domain[0], spatial_domain[1], spatial_density)\n",
    "z = np.linspace(spatial_domain[0], spatial_domain[1], spatial_density)\n",
    "time = np.linspace(time_domain[0], time_domain[1], time_density)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91c816f8",
   "metadata": {},
   "source": [
    "Lets convert our grids to `DataArrays` early in our computation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b66b6a58",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = xr.DataArray(x, coords={\"x\":x})\n",
    "y = xr.DataArray(y, coords={\"y\":y})\n",
    "z = xr.DataArray(z, coords={\"z\":z})\n",
    "time = xr.DataArray(time, coords={\"time\":time})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "032331e4",
   "metadata": {},
   "source": [
    "now lets define our function and use some xarray broadcasting to make it fast and automagically work with coordinates using `xr.apply_ufunc()` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64dd512d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def time_dependent_grid(x, y, z, t):\n",
    "    func = lambda x_, y_, z_, t_: np.cos(1*x_ + 2*y_ + 3*z_ + np.sin(x_*y_*t_))\n",
    "    return xr.apply_ufunc(func, x, y, z, t)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e24d63c8",
   "metadata": {},
   "source": [
    "Making use of our auto-broadcasting we now call our function on our grid, and get back values on a `40x40x40x1001` grid with **over 64M points**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37b9ffe9",
   "metadata": {},
   "outputs": [],
   "source": [
    "function_on_grid = time_dependent_grid(x,y,z,time)\n",
    "function_on_grid"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b179ac62",
   "metadata": {},
   "source": [
    "Lets not forget to add metadata so that our object makes sense for someone else\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d72196ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# add metadata to overall array\n",
    "function_on_grid.attrs[\"name\"] = \"wave intensity\"\n",
    "function_on_grid.attrs[\"units\"] = \" wavenumbers\"\n",
    "function_on_grid.attrs[\"description\"] = \"A wave propagation model used as an xarray example\"\n",
    "\n",
    "#add metadata to dimensions\n",
    "function_on_grid.x.attrs[\"name\"] = \"X dimension\"\n",
    "function_on_grid.x.attrs[\"units\"] = \"meters\"\n",
    "\n",
    "function_on_grid.y.attrs[\"name\"] = \"Y dimension\"\n",
    "function_on_grid.y.attrs[\"units\"] = \"meters\"\n",
    "\n",
    "function_on_grid.z.attrs[\"name\"] = \"Z dimension\"\n",
    "function_on_grid.z.attrs[\"units\"] = \"meters\"\n",
    "\n",
    "\n",
    "function_on_grid.time.attrs[\"name\"] = \"time dimension\"\n",
    "function_on_grid.time.attrs[\"units\"] = \"seconds\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76d890dc",
   "metadata": {},
   "source": [
    "Now we can save it for someone else to use later "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64ee53f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "function_on_grid.to_netcdf(\"wavemodel.nc\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4b17d00",
   "metadata": {},
   "source": [
    "# Plotting\n",
    "\n",
    "Now that we have created our wave model, lets have a look at it at some time and space slices just for a bit of fun. Remember that to plot a 4D function in 3D we need to fix **2** coordinates. Here  we use the powerful xarray selection syntax to pull out our function values at `t=0` and `x=-5.0` and make plots using their super easy interface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7205528",
   "metadata": {},
   "outputs": [],
   "source": [
    "func2dt0 = function_on_grid.sel(time=0.0, x=-5.0)\n",
    "func2dt0.plot.surface()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bf3d2f2",
   "metadata": {},
   "source": [
    "We can also easily make a contour plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af145dca",
   "metadata": {},
   "outputs": [],
   "source": [
    "func2dt0.plot.contour()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "778692b1",
   "metadata": {},
   "source": [
    "Okay what happens when we move forward one time unit at a time?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d9f5a6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "func2d_t1 = function_on_grid.sel(time=1.0, x=-5.0)\n",
    "func2d_t1.plot.surface()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e5a557b",
   "metadata": {},
   "outputs": [],
   "source": [
    "func2d_t1.plot.contour()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36707e59",
   "metadata": {},
   "outputs": [],
   "source": [
    "func2d_t2 = function_on_grid.sel(time=2.0, x=-5.0)\n",
    "func2d_t2.plot.surface()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba005028",
   "metadata": {},
   "outputs": [],
   "source": [
    "func2d_t2.plot.contour()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ceb8b54e",
   "metadata": {},
   "source": [
    "lets use some of `xarrays` powerful indexing to pull out a point at an index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52e20054",
   "metadata": {},
   "outputs": [],
   "source": [
    "function_on_grid.sel(x=0.0, y=1.0, z=3.0, time=3.0, method='nearest')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4009a3c2-65c3-4955-8db3-22f6d295eff4",
   "metadata": {},
   "source": [
    "## Working With Pandas  \n",
    "https://docs.xarray.dev/en/v2023.06.0/user-guide/pandas.html"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95373c73",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "Hopefully this basic intro has given you the tools to work with data in `DataArrays` with using `xarray`, and given you a sneak peak into how it might be useful. Next up we are going to cover collections of data in `Datasets`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8587a3e0-5050-4f58-b206-3446bc2fb222",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}