python-data/solutions/ex04_weather_api_solutions.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Exercise: Weather API\n",
    "\n",
    "## Aim: Use a Weather API to create and graph NetCDF files\n",
    "\n",
    "### Issues covered:\n",
    "\n",
    "- Request and get data from a weather API service\n",
    "- Read and retrieve information from a JSON response\n",
    "- Write contents to a NetCDF file\n",
    "- Read a collection of NetCDF files and plot a time series graph\n",
    "\n",
    "## 1. Let's get data from a web API on the internet\n",
    "\n",
    "We will use the NOAA National Weather Service in the US as our data source:\n",
    "\n",
    "![](https://www.weather.gov/css/images/header.png)\n",
    "\n",
    "The service has a web API that allows you to request forecast data for a given grid point in the USA. Details of the API are documented at:\n",
    "\n",
    "https://www.weather.gov/documentation/services-web-api\n",
    "\n",
    "Use the endpoint `https://api.weather.gov/` as the base URL.\n",
    "\n",
    "Firstly, we want to get a grid ID and based on some latitude/longitude coordinates. To do so we will use the `points/{latitude,longitude}` endpoint of the API.\n",
    "\n",
    "**Choose the latitude and longitude of your favourite US location (this API is US only and in latitude North, longitude East). The extent of the USA is approximately:**\n",
    "- Longitude: -120, -80\n",
    "- Latitude:  30, 48\n",
    "\n",
    "Once you have queried the `points` API you will get back a `grid ID` (`GridId`). The `grid ID` can be used to get a weather forecast for your location of interest, using the `gridpoints/{grid ID}/{grid co-ordinates}` endpoint."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import the `requests` library which is great for downloading content from external URLs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import requests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "You can use the requests library to access the web API. Fill in the elipses with the `latitude` (degrees North) and `longitude` (degrees East, so use negative value) of a location in the US. \n",
    "If successful, the response code should be 200."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'https://api.weather.gov/'\n",
    "latitude, longitude = 39.7456, -97.0892\n",
    "\n",
    "# Hint: use the requests library to GET from the url: https://api.weather.gov/points/{LAT},{LON}\n",
    "response = requests.get(f'{url}points/{latitude},{longitude}')\n",
    "response.status_code"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the requests library, the results from the webAPI can be extracted into in JSON format. A JSON document behaves exactly like a dictionary.\n",
    "\n",
    "Use dictionary indexing to extract the values of the grid ID and the X/Y coordinates:\n",
    "\n",
    "- get `gridID`\n",
    "- get `gridX`\n",
    "- get `gridY`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# hint: you can view the JSON by pasting the URL directly into your browser address bar\n",
    "\n",
    "response = response.json()\n",
    "\n",
    "gridID = response['properties']['gridId']\n",
    "gridX = response['properties']['gridX']\n",
    "gridY = response['properties']['gridY']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With your `gridID`, `gridX`, and `gridY`, use the `gridpoints` API endpoint to request a weather forecast for that location. Print the status code.\n",
    "If everything is working, you should get another 200 status code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response = requests.get(f'{url}gridpoints/{gridID}/{gridX},{gridY}')\n",
    "response.status_code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you use the JSON response data to get the forecast temperature values? Use dictionary indexing to get the `values` from `temperature` in `properties`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = response.json()\n",
    "forecast = data['properties']['temperature']['values']"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The below code extracts the coordinates of the grid box you have chosen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "coords = data['geometry']['coordinates'][0][0]\n",
    "x = coords[1]\n",
    "y = coords[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Let's format that data and write it to NetCDF\n",
    "\n",
    "### Formatting the data\n",
    "\n",
    "First, format your forecast data to get the datetime and air temperature as separate\n",
    "lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from datetime import datetime as dt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loop through your `forecast` values and get the temperatures (`value`) and datetimes (`validTime`) into a list.\n",
    "`forecast` is a list of dictionaries, where each dictionary is of one time instance.\n",
    "Fill in the ellipses to format each `validTime` string to a python `datetime` object and assign and set to the variable `date`. Get each `value` and assign to the variable `temp`. These values will then be appended to the `temps` and `timeseries` lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Use the datetime module to convert the times from the data to a datetime object.\n",
    "# Hint: look at the validTime string and see how you can turn the string to datetime\n",
    "# using strptime, the format of the datetime is: '%Y-%m-%dT%H:%M:%Sz'.\n",
    "\n",
    "timeseries = []\n",
    "temps = []\n",
    "\n",
    "for item in forecast:\n",
    "    \n",
    "    date = item['validTime']\n",
    "    date = dt.strptime(date.split('/')[0], '%Y-%m-%dT%H:%M:%S%z')\n",
    "    timeseries.append(date)\n",
    "    \n",
    "    temp = item['value']\n",
    "    temps.append(temp)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Format the `timeseries` list and convert it to relative time in seconds from the start of the timeseries. When using NetCDF and the CF Metadata Conventions time is stored as an offset from a base time rather than an absolute times.\n",
    "\n",
    "If you are stuck, take look at the 'Time series' slide in the [logging data from serial ports](https://github.com/ncasuk/ncas-isc/raw/68abbfd3a573e576c32fc127fafc874bfff98b1e/python/presentations/logging-data-from-serial-ports/LDFSP_Slides.pdf) presentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "base_time = timeseries[0]\n",
    "time_values = []\n",
    "\n",
    "for t in timeseries:\n",
    "    value = t - base_time\n",
    "    ts = value.total_seconds()\n",
    "    time_values.append(ts)\n",
    "\n",
    "time_units = \"seconds since \" + base_time.strftime('%Y-%m-%d %H:%M:%S')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Convert the `temps` list from degrees C to Kelvin. As per the CF Conventions, the canonical units for Air Temperature is K. Create a new list, called `temp_values`, which is the temperature in Kelvin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "temp_values = []\n",
    "\n",
    "for t in temps:\n",
    "    t = t + 273.15\n",
    "    temp_values.append(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a netCDF4 Dataset and write the contents to a file\n",
    "\n",
    "Import the `Dataset` class from the `netCDF4` library. You can go on to create an *instance* of this class which will contain:\n",
    "- variables\n",
    "- coordinate variables\n",
    "- dimensions\n",
    "- global attributes\n",
    "\n",
    "When you create the instance of `Dataset`, you will give it a file name which will be written to when you close the `Dataset`.\n",
    "\n",
    "Also import `numpy` as `np`. This will be used to construct the data arrays from the existing lists that currently hold the weather data and coordinate information.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from netCDF4 import Dataset\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quick aside, let's make sure we have a `DATA_DIR` to write to\n",
    "\n",
    "Since this is a group exercise, everyone should be writing to the same output directory. Let's set some python variables that can be used below:\n",
    "1. `USER` - used in the output file names to ensure every NetCDF file is unique.\n",
    "2. `HOME_DIR` - your `$HOME` directory\n",
    "2. `MY_DATA_DIR` - the directory where you will write your NetCDF file.\n",
    "3. `GROUP_DATA_DIR` - the directory where all the NetCDF files will eventually be collected/available.\n",
    "\n",
    "Since `GROUP_DATA_DIR` is not writeable directly from the Notebook Service, we have set up a job to replicate files from `MY_DATA_DIR` to `GROUP_DATA_DIR` (which runs once per minute)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/users/train041/TOP-train041-temps.nc'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "USER = os.environ[\"JUPYTERHUB_USER\"]\n",
    "\n",
    "HOME_DIR = f\"/home/users/{USER}\"\n",
    "MY_DATA_DIR = os.path.join(HOME_DIR, \"weather-api-outputs\")\n",
    "\n",
    "# Create MY_DATA_DIR if it doesn't exist\n",
    "if not os.path.isdir(MY_DATA_DIR):\n",
    "    os.mkdir(MY_DATA_DIR)\n",
    "\n",
    "# All NetCDF will be automatically copied here (once per minute)\n",
    "GROUP_DATA_DIR = \"/gws/pw/j07/workshop/weather-api-data\"\n",
    "\n",
    "# The output file will initially be written here (then you will move it when complete)\n",
    "filename = f\"{gridID}-{USER}-temps.nc\"\n",
    "outfile = f\"{HOME_DIR}/{filename}\"\n",
    "outfile"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Back to our NetCDF file\n",
    "\n",
    "Create the output file, as a `netCDF4 Dataset` instance, using the `outfile` defined above.\n",
    "\n",
    "If you need help, have a look at the 'Create the NetCDF dimensions & variables' slide in the [logging data from serial ports](https://github.com/ncasuk/ncas-isc/raw/68abbfd3a573e576c32fc127fafc874bfff98b1e/python/presentations/logging-data-from-serial-ports/LDFSP_Slides.pdf) presentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "dataset = Dataset(outfile, \"w\", format=\"NETCDF4_CLASSIC\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Start by defining some dimensions\n",
    "\n",
    "Create NetCDF *dimensions*:\n",
    "- `time_dim`: *unlimited* length\n",
    "- `lat_dim`: length 1\n",
    "- `lon_dim`: length 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_dim = dataset.createDimension('time', None) # None means \"UNLIMITED\"\n",
    "lat_dim = dataset.createDimension('lat', 1)\n",
    "lon_dim = dataset.createDimension('lon', 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now define the coordinate variables and then temperature variable\n",
    "\n",
    "Create the `time` *variable* with the following properties:\n",
    "- type: numpy float (`np.float64`)\n",
    "- variable id: `time`\n",
    "- dimensions: (`time`,)\n",
    "- set the array using the `time_values` list\n",
    "- `units`: `time_units` defined earlier\n",
    "- `standard_name`: `time`\n",
    "- `calendar`: `standard`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_var = dataset.createVariable('time', np.float64, ('time',))\n",
    "time_var[:] = time_values\n",
    "time_var.units = time_units\n",
    "time_var.standard_name = 'time'\n",
    "time_var.calendar = 'standard'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the `lat` *variable* with the following properties:\n",
    "- type: numpy float (`np.float64`)\n",
    "- variable id: `lat`\n",
    "- dimensions: (`lat`,)\n",
    "- set the array of length 1 using the `gridY` value\n",
    "- `units`: `degrees_north`\n",
    "- `standard_name`: `latitude`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "lat_var = dataset.createVariable('lat', np.float64, ('lat',))\n",
    "lat_var[:] = [gridY]\n",
    "lat_var.units = 'degrees_north'\n",
    "lat_var.standard_name = 'latitude'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the `lon` *variable* with the following properties:\n",
    "- type: numpy float (`np.float64`)\n",
    "- variable id: `lon`\n",
    "- dimensions: (`lon`,)\n",
    "- set the array of length 1 using the `gridX` value\n",
    "- `units`: `degrees_east`\n",
    "- `standard_name`: `longitude`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "lon_var = dataset.createVariable('lon', np.float64, ('lon',))\n",
    "lon_var[:] = [gridX]\n",
    "lon_var.units = 'degrees_east'\n",
    "lon_var.standard_name = 'longitude'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the `temp` *variable* with the following properties:\n",
    "- type: numpy float (`np.float64`)\n",
    "- variable id: `temp`\n",
    "- dimensions: (`time`,)\n",
    "- set the array using the `temp_values` list\n",
    "- `long_name`: `air temperature (K)`\n",
    "- `units`: `K`\n",
    "- `standard_name`: `air_temperature`\n",
    "- `coordinates`: `lon lat` - to relate the longitude and latitude to this variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "temp_var = dataset.createVariable('temp', np.float32, ('time',))\n",
    "temp_var[:] = temp_values\n",
    "temp_var.var_id = 'temp'\n",
    "temp_var.long_name = 'Air Temperature (K)'\n",
    "temp_var.units = 'K'\n",
    "temp_var.standard_name = 'air_temperature'\n",
    "temp_var.coordinates = 'lon lat'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Add some global attributes\n",
    "\n",
    "The [CF Metadata Conventions](https://cfconventions.org/cf-conventions/cf-conventions.html#_overview) recommends a set of global attributes to \"provide human readable documentation of the file contents\":\n",
    "- title\n",
    "- history\n",
    "- institution\n",
    "- source\n",
    "- references\n",
    "- comment\n",
    "\n",
    "Add each of the above to your `Dataset` instance. Here are some suggested values (but you can say whatever you like):\n",
    "- title: Air Temperature forecasts for `<gridID>`\n",
    "- history: File created on: `<YYYY-MM-DD>`\n",
    "- institution: NCAS-ISC\n",
    "- source: NOAA Weather API Service\n",
    "- references: https://www.weather.gov/documentation/services-web-api\n",
    "- comment: The ISC course is teaching me about Python and NetCDF!\n",
    "\n",
    "You can add any other global attributes that you wish to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset.title = f'Air Temperature forecasts for {gridID}'\n",
    "dataset.history = f'File created on: {dt.now().strftime(\"%Y-%m-%d\")}'\n",
    "dataset.institution = 'NCAS-ISC'\n",
    "dataset.source = 'NOAA Weather API Service'\n",
    "dataset.references = 'https://www.weather.gov/documentation/services-web-api'\n",
    "dataset.comment = 'This course is OK!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Finally, close the `Dataset` to save the file\n",
    "\n",
    "Save your NetCDF file by closing the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check it is there using `os.path.isfile(...)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.isfile(outfile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IMPORTANT: Move the file to your MY_DATA_DIR so it gets copied to the GROUP_DATA_DIR\n",
    "\n",
    "Since we cannot write directly to the `GROUP_DATA_DIR`, move the file from your `HOME_DIR` to your `MY_DATA_DIR`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.rename(outfile, f\"{MY_DATA_DIR}/{filename}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 3. Find all the NetCDF files written during this exercise\n",
    "\n",
    "To find all the `.nc` files in a group workspace, we will use the glob module in Python.\n",
    "Glob let's us find all files matching a pattern, in our case:\n",
    "\n",
    "`{GROUP_DATA_DIR}/*.nc`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from glob import glob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Can you use glob to make a list of file paths of all NetCDF files in the\n",
    "group workspace?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "filepaths = glob(f\"{GROUP_DATA_DIR}/*temps.nc\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 4. Create a time-series graph of all the forecasts\n",
    "\n",
    "Now that we have a list of NetCDF file paths, we can open them and extract their data.\n",
    "\n",
    "To start, let us make the a plot using matplotlib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from netCDF4 import num2date\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.dates as mdates\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Create a subplots figure with figure and axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Can you set the x-axis locator (ticks) using dates class from matplotlib?\n",
    "- set the major locator to days.\n",
    "- set the minor locator to every 6 hours.\n",
    "- set the x-axis formatter to Day-Month for each day."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# In the matplotlib.dates module, as mdates, look at the DayLocator and HourLocator.\n",
    "fmt_day = mdates.DayLocator()\n",
    "fmt_six_hours = mdates.HourLocator(interval=6)\n",
    "\n",
    "ax.xaxis.set_major_locator(fmt_day)\n",
    "ax.xaxis.set_minor_locator(fmt_six_hours)\n",
    "ax.xaxis.set_major_formatter(mdates.DateFormatter('%d-%m'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Label the axis, `ax`, on the plot:\n",
    "- label the x-axis as `Date`\n",
    "- label the y-axis as `Air Temperature (K)`\n",
    "- set a title on your plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Air temperature Forecast')"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ax.set_xlabel(\"Date\")\n",
    "ax.set_ylabel(\"Air Temperature (K)\")\n",
    "ax.set_title(\"Air temperature Forecast\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Open each NetCDF file and extract the `temp`, `time`, `lat` and `lon` variables from the file. Then use the matplotlib `plot_date` function to plot the graph.\n",
    "\n",
    "- set the label of plot to the `<lat>, <lon>` coordinates attribute of the `temp` variable.\n",
    "\n",
    "Replace the elipses with your plotting, the `for` loop works through all the shared NetCDF files in the workspace, where `f` is the file path and `filepaths` is a list of data files.\n",
    "\n",
    "If you need help, look at the 'Plotting data with matplotlib' slide in the [logging data from serial ports](https://github.com/ncasuk/ncas-isc/raw/68abbfd3a573e576c32fc127fafc874bfff98b1e/python/presentations/logging-data-from-serial-ports/LDFSP_Slides.pdf) presentation.\n",
    "\n",
    "Plot a line graph using matplotlib: \n",
    "\n",
    "- you will need to set the marker to `-` otherwise you will get a scatter graph.\n",
    "- set the label of the plot to a string: `<lat>, <lon>`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "for f in filepaths:\n",
    "    \n",
    "    dset = Dataset(f, mode='r')\n",
    "    \n",
    "    temp = dset.variables['temp']\n",
    "    time = dset.variables['time']\n",
    "    lat = dset.variables['lat'][0]\n",
    "    lon = dset.variables['lon'][0]\n",
    "\n",
    "    times = num2date(time[:], units=time.units, calendar=time.calendar)\n",
    "    ax.plot_date(times, temp[:], '-', label=f\"{lat:.3f}, {lon:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Finally, show the plot with a legend, you might want to enable tight layout,\n",
    "and save the plot to your `MY_DATA_DIR` directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ax.grid(True)\n",
    "fig.tight_layout()\n",
    "ax.legend()\n",
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save the graph to a PNG file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig.savefig(f\"{MY_DATA_DIR}/{gridID}-{USER}-temps.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 + Jaspy",
   "language": "python",
   "name": "jaspy"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}