notebooks/CSSP_20CRDS_Tutorials/tutorial_1_data_access.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# <b>Tutorial 1: Accessing and exploring CSSP China 20CR datasets</b>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning Objectives:\n",
    "\n",
    "1. How to load data into Xarrays format\n",
    "2. How to convert the data xarrays into iris cube format\n",
    "3. How to perform basic cube operations "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contents\n",
    "\n",
    "1. [Use Xarray to access monthly data](#access_zarr) <b>\n",
    "2. [Retrieve single (or list of) variables](#get_vars)\n",
    "3. [Convert datasets to iris cube](#to_iris)\n",
    "4. [Explore cube attributes and coordinates](#explore_iris)\n",
    "5. [Exercises](#exercise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Prerequisites</b><br> \n",
    "- Basic programming skills in python<br>\n",
    "- Familiarity with python libraries Numpy and Matplotlib<br>\n",
    "- Basic understanding of climate data<br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Use Xarray to access monthly data<a id='access_zarr'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Import libraries.\n",
    "Import the necessary libraries. Current datasets are in zarr format, we need zarr and xarray libraries to access the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import xarray as xr\n",
    "import zarr\n",
    "from scripts.xarray_iris_coord_system import XarrayIrisCoordSystem as xics\n",
    "\n",
    "xi = xics()\n",
    "xr.set_options(\n",
    "    display_style=\"text\"\n",
    ")  # Work around for AML bug that won't display HTML output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Set up authentication for the Azure blob store\n",
    "\n",
    "The data for this course is held online in an Azure Blob Storage Service. To access this we use a SAS (shared access signature).  You should have been given the credentials for this service before the course, but if not please ask your instructor. We use the getpass module here to avoid putting the token into the public domain. Run the cell below and in the box enter your SAS and press return. This will store the password in the variable SAS."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import getpass\n",
    "\n",
    "# SAS WITHOUT leading '?'\n",
    "SAS = getpass.getpass()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now use the Zarr library to connect to this storage. This is a little like opening a file on a local file system but works without downloading the data. This makes use of the Azure Blob Storage service. The zarr.ABStore method returns a zarr.storage.ABSStore object which we can now use to access the Zarr data in the same way we would use a local file. If you have a Zarr file on a local file system you could skip this step and instead just use the path to the Zarr data below when opening the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "store = zarr.ABSStore(\n",
    "    container=\"metoffice-20cr-ds\",\n",
    "    prefix=\"monthly/\",\n",
    "    account_name=\"metdatasa\",\n",
    "    blob_service_kwargs={\"sas_token\": SAS},\n",
    ")\n",
    "type(store)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Read monthly data\n",
    "A Dataset consists of coordinates and data variables. Let's use the xarray's **open_zarr()** method to read all our zarr data into a dataset object and display it's metadata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use the open_zarr() method to read in the whole dataset metadata\n",
    "dataset = xr.open_zarr(store)\n",
    "# print out the metadata\n",
    "dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> The dataset lists coordinates and data variables.<br>\n",
    "<b>Note:</b>If you get an error \"resource not found\", you have probably entered your SAS incorrectly. Please check and try again.\n",
    "  \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "We can also access and print list of all the variables in our dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# display all the variables in our dataset\n",
    "dataset.data_vars"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Retrieve single (or list of) variables<a id='get_vars'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Read mean air temperature at 2 m \n",
    "Access and print just a single variable i.e minumum air temperature at 2m\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> The DataArrays in our dataset can be accessed either as attributes or indexed by name\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Access the variable by indexing it with its name\n",
    "t2m_mean = dataset[\"air_temperature_mean\"]\n",
    "# print the metadata\n",
    "t2m_mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Access the variable like an attribute\n",
    "t2m_mean = dataset.air_temperature_mean\n",
    "# print the metadata\n",
    "t2m_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Read list of variables \n",
    "We can also create a smaller dataset containing a subset of our variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating a list containing a subset of our variables\n",
    "varlist = [\n",
    "    \"relative_humidity_mean\",\n",
    "    \"relative_humidity_at_pressure_mean\",\n",
    "    \"specific_humidity\",\n",
    "    \"surface_temperature\",\n",
    "]\n",
    "\n",
    "# extracting the list of variables from dataset\n",
    "mini_ds = dataset[varlist]\n",
    "\n",
    "# print the metadata\n",
    "mini_ds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "    <b>Task:</b><br><ul>\n",
    "        <li>Access \"cloud_area_fraction\" using both index and attribute method in the cell below and save it in varaible named **caf**</li>\n",
    "        <li>Create a dataset **pres_ds** containing all the pressure variables, <i>(hint: use for loop)</i></li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Retrieve \"cloud_area_fraction\"\n",
    "# write your code here ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Retrieve all the pressure variables\n",
    "# write your code here ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Convert datasets to iris cube<a id='to_iris'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Convert a variable to an Iris Cube\n",
    "We now convert the minimum air temperature variable that we accessed in section 2.1 into iris cube. This can be done simply using the method **DataArray.to_iris()**.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the method to_iris() to convert the xarray data array into an iris cube\n",
    "cube_t2m_mean = t2m_mean.to_iris()\n",
    "cube_t2m_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 3.2 Convert whole Dataset to an Iris Cubelist\n",
    "Instead of converting all variables one by one into iris cube one by one, we can convert the whole dataset (or a subset of dataset) into an iris cubelist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> This is not as simple as done for single variable above but it is straightforward with the <b>dataset.apply()</b> method, obviousely will take a bit longer to complete!\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# first import the Iris library\n",
    "import iris"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create an empty list to hold the iris cubes\n",
    "cubelist = iris.cube.CubeList([])\n",
    "\n",
    "# use the DataSet.apply() to convert the dataset to Iris Cublelist\n",
    "# the apply method loops over each variable in the dataset and runs the\n",
    "# supplied function on it\n",
    "# the variable da is a single variable from the dataset.\n",
    "# this variable is converted to a cube and appended to the empty\n",
    "# cubelist we made above\n",
    "dataset.apply(lambda da: cubelist.append(xi.to_iris(da)))\n",
    "\n",
    "# print out the cubelist\n",
    "cubelist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Note:</b> By clicking on any variable above, you can see its dimension coordinates and matadata\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "</pre><div class=\"alert alert-block alert-success\">\n",
    "    <b>Task:</b><br><ul>\n",
    "        <li>convert <b>caf</b> variable into iris cube **caf_cube**</li>\n",
    "        <li>create a cube list containing pressure variables only</li>\n",
    "        <li>Can you note the difference between cube and cubelist?</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## convert clf into iris cube\n",
    "# write your code here ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## convert pressure dataset into iris cube list\n",
    "# write your code here ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Explore cube attributes and coordinates<a id='explore_iris'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 Accessing cube from cubelist\n",
    "Now that we have our variables in cubelist we can extract any varaible using the variable name. For instance the following code indices for **precipitation_flux** variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lets load and print the Precipitation Flux variable\n",
    "precipitation_cube = cubelist.extract_strict(\"precipitation_flux\")\n",
    "precipitation_cube"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> We can see that we  have <b>time</b>, <b>grid_latitude</b> and <b>grig_longitude</b> dimensions, and a cell method of <b>mean</b>: time (1 hour) which means that the cube contains monthly mean Precipitation Flux data.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Cube attributes\n",
    "We can explore the cube information further"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can print its shape\n",
    "precipitation_cube.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can print its dimensions\n",
    "precipitation_cube.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can print all of the data values (takes a bit of time as it is a large dataset!)\n",
    "precipitation_cube.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Or we can take a slice of the data using indexing\n",
    "precipitation_cube.data[10, 1, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also print the maximum, minimum and mean value in data\n",
    "print(\"Maximum value: \", precipitation_cube.data.max())\n",
    "print(\"Minimum value: \", precipitation_cube.data.min())\n",
    "print(\"Mean value: \", precipitation_cube.data.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can print cube's name\n",
    "precipitation_cube.name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can print the unit of data\n",
    "precipitation_cube.units"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can also print cube's general attributes\n",
    "precipitation_cube.attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 Rename the cube\n",
    "Rename the precipitation_flux cube"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> The <b>name</b>, <b>standard_name</b>, <b>long_name</b> and to an extent <b>var_name</b> are all attributes to describe the phenomenon that the cube represents.\n",
    "    \n",
    "<b>standard_name</b> is restricted to be a CF standard name (see the <a href=\"http://cfconventions.org/standard-names.html\">CF standard name table</a>).  \n",
    "\n",
    "If there is not a suitable CF standard name, <b>cube.standard_name</b> is set to <b>None</b> and the <b>long_name</b> is used instead.  \n",
    "<b>long_name</b> is less restrictive and can be set to be any string.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(precipitation_cube.standard_name)\n",
    "print(precipitation_cube.long_name)\n",
    "print(precipitation_cube.var_name)\n",
    "print(precipitation_cube.name())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# changing the cube name to 'pflx' using \"rename\" method\n",
    "precipitation_cube.rename(\"pflx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(precipitation_cube.standard_name)\n",
    "print(precipitation_cube.long_name)\n",
    "print(precipitation_cube.var_name)\n",
    "print(precipitation_cube.name())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that standard_name and var_name are not set to be a non CF standard name, they are changed to None and long_name is renamed as pflx instead. The cube.name() method first tries standard_name, then ‘long_name’, then ‘var_name’, then the STASH attribute before falling back to the value of default (which itself defaults to ‘unknown’).\n",
    "\n",
    "We can also rename the specific name of the cube. Suppose if we only want to change standard_name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "precipitation_cube.standard_name = \"precipitation_flux\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(precipitation_cube.standard_name)\n",
    "print(precipitation_cube.long_name)\n",
    "print(precipitation_cube.var_name)\n",
    "print(precipitation_cube.name())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can change long_name, var_name, and name without using rename method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 Change the cube units\n",
    "Change precipitation_cube units from kg m-2 s-1 to kg m-2 day-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> The units attribute on a cube tells us the units of the numbers held in the data array. To convert to 'kg m-2 day-1', we could just multiply the raw data by 86400 seconds, but a clearer way is to use the <b>convert_units()</b> method with the name of the units we want to convert the data into. It will automatically update the data array.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# inspect the current unit and maximum data value\n",
    "print(precipitation_cube.units)\n",
    "print(precipitation_cube.data.max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert the units to 'mm day-1' using convert_units method\n",
    "precipitation_cube.convert_units(\"kg m-2 day-1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# inspect the current unit and maximum data value after the conversion\n",
    "print(precipitation_cube.units)\n",
    "print(precipitation_cube.data.max())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4 Add or remove the attributes\n",
    "In section 4.2 we see how to access the cube attributes. In this section we will try to add or remove the attributes \n",
    "\n",
    "Let's try to add new attribute to the precipitation_flux. \n",
    "We want to keep the information of original units of the cube. Best way is to add this information in the attribute.\n",
    "Define the new attribute as a key value pair and we can add the attribute using **update** method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# defining new attribute\n",
    "new_attr = {\"original_units\": \"kg m-2 s-1\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# List the attibutes\n",
    "precipitation_cube.attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add new attribute using .update() method\n",
    "precipitation_cube.attributes.update(new_attr)\n",
    "\n",
    "# now printing the attributes list to see if new attribute has updated\n",
    "precipitation_cube.attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, we got 'original_units' in attributes list. \n",
    "\n",
    "We can also delete any specific attribute. For example, in our precipitation_cube attributes list, we do not need 'source' and we can think of deleting it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del precipitation_cube.attributes[\"source\"]\n",
    "precipitation_cube.attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.5 Accessing cube coordinates\n",
    "Access cube's coordinates and explore coordinates attribute"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> \n",
    "    <ul>\n",
    "        <li>Cubes need coordinate information to help us describe the underlying phenomenon. Typically a cube's coordinates are accessed with the coords or coord methods. The latter must return exactly one coordinate for the given parameter filters, where the former returns a list of matching coordinates.</li>\n",
    "        <li>The coordinate interface is very similar to that of a cube. The attributes that exist on both cubes and coordinates are: <b>standard_name</b>, <b>long_name</b>, <b>var_name</b>, <b>units</b>, <b>attributes</b> and <b>shape</b>. </li>\n",
    "        <li>Coordinate does not have data, instead it has points and bounds (bounds may be None), so we can access the actual point data</li>\n",
    "    </ul>    \n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's print out all cube's coordinates\n",
    "print([coord.name() for coord in precipitation_cube.coords()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's access the 'grid_latitude' coordinate and print out the last 10 values\n",
    "grid_latitude = precipitation_cube.coord(\"grid_latitude\")\n",
    "grid_latitude[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print the maximum and minimum value of 'grid_latitude' coordinate\n",
    "print(grid_latitude.points.max())\n",
    "print(grid_latitude.points.min())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "    <b>Task:</b><br><ul>\n",
    "        <li> Inspect the following attributes of <b>caf_cube</b> you created in previous task</li>\n",
    "            <ul>\n",
    "                <li>name (standard_name)</li>\n",
    "                <li>dimensions (ndim)</li>\n",
    "                <li>units</li>\n",
    "                <li>mean of data</li>\n",
    "            </ul>\n",
    "        <li> Print all the coordinates of <b>caf_cube</b>, <i>(hint: use for loop)</i></li>\n",
    "        <li> Explore attributes of \"grid_latitude\"</i></li>\n",
    "           <ul>\n",
    "                <li>name (standard_name)</li>\n",
    "                <li>shape</li>\n",
    "                <li>units</li>\n",
    "           </ul>\n",
    "    \n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Inspect attributes\n",
    "# write your code here .."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Inspect coordinates\n",
    "# write your code here .."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Exercise<a id='exercise'></a>\n",
    "\n",
    "In this exercise we will explore the variables and attributes of monthly data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1: Load hourly data\n",
    "Load monthly data into xarrays and display all variables\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your code here .."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2: Convert to iris cublist\n",
    "Convert the dataset into iris cublist and display the cubelist\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your code here .."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3: Extract variable\n",
    "Extract **x_wind** variable from cubelist and display the cube"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your code here .."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4: Explore cube attributes \n",
    "Using the Iris cube in previous excercise explore its attributes as follow:\n",
    "- print out the dimensions\n",
    "- print out its shape\n",
    "- print out its coordinates\n",
    "- print out the maximum and minimum values of latitude and longitude\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your code here .."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your code here .."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your code here .."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your code here .."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5: Change units and add the original units to attributes list \n",
    "\n",
    "- change the units of x_wind to km/hr\n",
    "- add the original units to the attributes list\n",
    "- print out the attributes to see if new attribtue has added successfully\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your code here .."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your code here .."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your code here .."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b>Summary</b><br> \n",
    "    In this session we learned how:<br>\n",
    "    <ul>\n",
    "        <li>to load data from a zarr database into xarray dataset <b> and explore its metadata.</li>\n",
    "        <li><b>to convert xarray dataset into iris cube and explore its metadata</b></li>\n",
    "        <li><b>to further explore iris cube's attributes</b> through simple operations</li>\n",
    "    </ul>\n",
    "\n",
    "</div>\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p><img src=\"../img/MO_MASTER_black_mono_for_light_backg_RBG.png\" alt=\"Met Office Logo\" style=\"float: center; height: 100px;\"/></p>\n",
    "<center>© Crown Copyright, Met Office. All rights reserved.</center>\n",
    "<center>This file is part of PyPrecis and is released under the BSD 3-Clause license.</center>\n",
    "<center>See LICENSE in the root of the repository for full licensing details.</center>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "cssp37",
   "language": "python",
   "name": "cssp37"
  },
  "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.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}