tam203/mogreps_cube.ipynb

## mogreps_cube.ipynb
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mogreps hyper-cube:\n",
    "\n",
    "This note book was writen on and for the [Met Office Informatics Lab Pangeo environment](http://pangeo.informaticslab.co.uk/). \n",
    "\n",
    "We will try make a cube that represents all of the mogreps-uk data (for one parameter: `surface_air_pressure`) for 2013. The data is stored on a public S3 bucket `mogreps-uk`. We have mounted that bucket using a FUSE file systems. The data is accessable via the filesystem path `/s3/mogreps-uk/`. We will use `surface_air_pressure` as some of the other parameters like `air_temperature` are more complicated/messy (see accompanying blog post).\n",
    "\n",
    "Inspecting/knowlage of the data set reveals:\n",
    "\n",
    "    Models run at 03 and 09\n",
    "\n",
    "    Is a lagged ensamble:\n",
    "    03 run has realisations/members 00 - 11\n",
    "    09 run has realisations/members 00 and 12 - 22\n",
    "\n",
    "    Forecast period:\n",
    "    +0 to +36\n",
    "    Split in to files with three one hour time steps per file except the first which has four one hour time steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import iris\n",
    "import os\n",
    "import warnings\n",
    "from cf_units import Unit\n",
    "from calendar import monthrange\n",
    "from collections import namedtuple\n",
    "import dask.array as da\n",
    "import netCDF4\n",
    "import numpy as np\n",
    "from functools import reduce\n",
    "\n",
    "BASE_PATH = '/s3/mogreps-uk/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we create our proxy class. This is an object that looks like a nd-array but deferes accessing the data until a calculation is requests.\n",
    "Additionally our implementation will handle the case that the data or file doesn't exist or look as expected and return missing/fill data for that request."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Based on `iris.fileformats.netcdf.NetCDFDataProxy - https://github.com/SciTools/iris/blob/v2.1.0/lib/iris/fileformats/netcdf.py#L374\n",
    "class CheckingNetCDFDataProxy(object):\n",
    "    \"\"\"A reference to the data payload of a single NetCDF file variable.\"\"\"\n",
    "\n",
    "    def __init__(self, shape, dtype, path, variable_name, fill_value, do_safety_check=False):\n",
    "        self.safety_check_done = do_safety_check\n",
    "        self.shape = shape\n",
    "        self.dtype = dtype\n",
    "        self.path = path\n",
    "        self.variable_name = variable_name\n",
    "        self.fill_value = fill_value\n",
    "        self.fatal_fail = None\n",
    "\n",
    "    @property\n",
    "    def ndim(self):\n",
    "        return len(self.shape)\n",
    "\n",
    "    def check(self):\n",
    "        # This check runs one on first data access. If the check doesn't think the data in the file is that that was expected when the object was created\n",
    "        # or the file is missing the check 'fails' and all future data request will return masked data.\n",
    "        try:\n",
    "            dataset = netCDF4.Dataset(self.path)\n",
    "        except OSError:\n",
    "            self.fatal_fail = \"no such file %s\" % self.path\n",
    "            self.safety_check_done = True\n",
    "            return\n",
    "        \n",
    "        try:\n",
    "            variable = dataset.variables[self.variable_name]\n",
    "        except KeyError:\n",
    "            self.fatal_fail = \"no variable %s in file %s\" % (self.variable_name, self.path)\n",
    "            self.safety_check_done = True\n",
    "            return\n",
    "\n",
    "        if list(variable.shape) != list(self.shape):\n",
    "            self.fatal_fail = \"Shape of data %s doesn't match expected %s\" %(variable.shape, self.shape)\n",
    "            self.safety_check_done = True\n",
    "            return\n",
    "        \n",
    "        # TODO: check variable attributes/dims/etc? This check is very basic/simple further checking could be done but may come at a cost.\n",
    "        \n",
    "        self.safety_check_done = True\n",
    "        \n",
    "        \n",
    "    def  _null_data(self, keys):\n",
    "        # Return fill data in the correct shape\n",
    "        \n",
    "        null_data = np.ones(self.shape)[keys] * self.fill_value\n",
    "        return null_data\n",
    "        \n",
    "    def __getitem__(self, keys):\n",
    "        # Get some data. Do the safety check first and any issues return fill value data.\n",
    "        \n",
    "        if not self.safety_check_done:\n",
    "            self.check()\n",
    "            \n",
    "        if self.fatal_fail:\n",
    "            return self._null_data(keys)\n",
    "            \n",
    "        try:\n",
    "            dataset = netCDF4.Dataset(self.path)\n",
    "            variable = dataset.variables[self.variable_name]\n",
    "            # Get the NetCDF variable data and slice.\n",
    "            var = variable[keys]\n",
    "        finally:\n",
    "            if dataset:\n",
    "                dataset.close()\n",
    "        return np.asanyarray(var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 2min, sys: 2.31 s, total: 2min 3s\n",
      "Wall time: 2min 1s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# This cell currently takes a couple of minutes on first run. It's not clear why.\n",
    "\n",
    "\n",
    "VAR_NAME = 'surface_air_pressure'\n",
    "grid_latitude_len = 548\n",
    "grid_longitude_len = 421\n",
    "\n",
    "# Given a year return all the model runs in that year as RunDate objects.\n",
    "RunDate = namedtuple('RunDate',['year','month','day','hour'])\n",
    "def runs(years):\n",
    "    for year in years:\n",
    "        for month in range(1,12):\n",
    "            for day in range(1,monthrange(year,month)[1] +1):\n",
    "                for hour in (3,9):\n",
    "                    yield RunDate(year,month,day,hour)\n",
    "\n",
    "def build_lazy_masked_array(shape, filepath, var):\n",
    "    fill = 1e20\n",
    "    proxy = CheckingNetCDFDataProxy(shape=shape,  dtype='float32', # TODO: Don't assuming float32?\n",
    "                                path=filepath, variable_name=VAR_NAME,\n",
    "                                fill_value = fill)\n",
    "    lazy_array = da.from_array(proxy, shape)\n",
    "    masked_array = da.ma.masked_equal(lazy_array, fill)\n",
    "    return masked_array\n",
    "\n",
    "def build_proxy_array_for_time_step(file_details):\n",
    "    year, month, day, run_hr, realisation, time_step = file_details\n",
    "    file_tpl = \"/s3/mogreps-uk/prods_op_mogreps-uk_{year:d}{month:02d}{day:02d}_{run_hr:02d}_{realisation:02d}_{time_step:03d}.nc\"\n",
    "    grid_latitude_len = 548\n",
    "    grid_longitude_len = 421\n",
    "    \n",
    "    num_steps_in_file = 4 if run_hr == 3 else 4 # First file in a run has an extra timestep\n",
    "    forecast_periods = list(range(time_step, time_step+num_steps_in_file))\n",
    "    filepath = file_tpl.format(year=year, month=month, day=day, run_hr=run_hr, realisation=realisation, time_step=time_step)\n",
    "\n",
    "    # This is the shape our fundemental chunks i.e. the data inside our files. \n",
    "    shape=(len(forecast_periods), grid_latitude_len, grid_longitude_len)\n",
    "\n",
    "    return build_lazy_masked_array(shape, filepath, VAR_NAME)\n",
    "\n",
    "def build_data_array():\n",
    "    # Build a lazy nd-array that will underpin our hyper-cube\n",
    "    # Shape will be (realisations, runs, timesteps, lat, lon)\n",
    "    # We loop through these dimensions from outside in until we get to our bottom fundemental chunk, a file in this case.\n",
    "    \n",
    "    file_tpl = \"/s3/mogreps-uk/prods_op_mogreps-uk_{year:d}{month:02d}{day:02d}_{run:02d}_{realisation:02d}_{step:03d}.nc\"\n",
    "    realisations = range(0,22+1)\n",
    "    \n",
    "    realisation_collection = [] # each loop collects the data arrays from each iteration so that they can be joined when the loop closes/completes \n",
    "    for realisation in realisations:\n",
    "        \n",
    "        runs_collection = []\n",
    "        for year, month, day, run in runs([2013]):\n",
    "            files_in_run = ((year, month, day, run, realisation, step) for step in range(3,36+1,3))\n",
    "            run_data = da.concatenate(list(map(build_proxy_array_for_time_step, files_in_run)), 0)\n",
    "            \n",
    "            runs_collection.append(run_data)\n",
    "    \n",
    "        realisation_data = da.stack(runs_collection, 0)\n",
    "        realisation_collection.append(realisation_data)\n",
    "    \n",
    "    return da.stack(realisation_collection, 0)\n",
    "                    \n",
    "data = build_data_array()\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dask.array<stack, shape=(23, 668, 48, 548, 421), dtype=float32, chunksize=(1, 1, 4, 548, 421)>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have our data array. We can start accessing an processing the data immediately if we wished however it's useful to wrap it in a higher order object like an Iris Cube to allow higer order and geospacial aware functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "  a.iris {\n",
       "      text-decoration: none !important;\n",
       "  }\n",
       "  table.iris {\n",
       "      white-space: pre;\n",
       "      border: 1px solid;\n",
       "      border-color: #9c9c9c;\n",
       "      font-family: monaco, monospace;\n",
       "  }\n",
       "  th.iris {\n",
       "      background: #303f3f;\n",
       "      color: #e0e0e0;\n",
       "      border-left: 1px solid;\n",
       "      border-color: #9c9c9c;\n",
       "      font-size: 1.05em;\n",
       "      min-width: 50px;\n",
       "      max-width: 125px;\n",
       "  }\n",
       "  tr.iris :first-child {\n",
       "      border-right: 1px solid #9c9c9c !important;\n",
       "  }\n",
       "  td.iris-title {\n",
       "      background: #d5dcdf;\n",
       "      border-top: 1px solid #9c9c9c;\n",
       "      font-weight: bold;\n",
       "  }\n",
       "  .iris-word-cell {\n",
       "      text-align: left !important;\n",
       "      white-space: pre;\n",
       "  }\n",
       "  .iris-subheading-cell {\n",
       "      padding-left: 2em !important;\n",
       "  }\n",
       "  .iris-inclusion-cell {\n",
       "      padding-right: 1em !important;\n",
       "  }\n",
       "  .iris-panel-body {\n",
       "      padding-top: 0px;\n",
       "  }\n",
       "  .iris-panel-title {\n",
       "      padding-left: 3em;\n",
       "  }\n",
       "  .iris-panel-title {\n",
       "      margin-top: 7px;\n",
       "  }\n",
       "</style>\n",
       "<table class=\"iris\" id=\"139750899513104\">\n",
       "    <tr class=\"iris\">\n",
       "<th class=\"iris iris-word-cell\">Surface Air Pressure (Pa)</th>\n",
       "<th class=\"iris iris-word-cell\">realisation</th>\n",
       "<th class=\"iris iris-word-cell\">forecast_refrance_time</th>\n",
       "<th class=\"iris iris-word-cell\">forecast_period</th>\n",
       "<th class=\"iris iris-word-cell\">grid_latitude</th>\n",
       "<th class=\"iris iris-word-cell\">grid_longitude</th>\n",
       "</tr>\n",
       "    <tr class=\"iris\">\n",
       "<td class=\"iris-word-cell iris-subheading-cell\">Shape</td>\n",
       "<td class=\"iris iris-inclusion-cell\">23</td>\n",
       "<td class=\"iris iris-inclusion-cell\">668</td>\n",
       "<td class=\"iris iris-inclusion-cell\">48</td>\n",
       "<td class=\"iris iris-inclusion-cell\">548</td>\n",
       "<td class=\"iris iris-inclusion-cell\">421</td>\n",
       "</td>\n",
       "    <tr class=\"iris\">\n",
       "    <td class=\"iris-title iris-word-cell\">Dimension coordinates</td>\n",
       "    <td class=\"iris-title\"></td>\n",
       "    <td class=\"iris-title\"></td>\n",
       "    <td class=\"iris-title\"></td>\n",
       "    <td class=\"iris-title\"></td>\n",
       "    <td class=\"iris-title\"></td>\n",
       "</tr>\n",
       "<tr class=\"iris\">\n",
       "    <td class=\"iris-word-cell iris-subheading-cell\">\trealisation</td>\n",
       "    <td class=\"iris-inclusion-cell\">x</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "</tr>\n",
       "<tr class=\"iris\">\n",
       "    <td class=\"iris-word-cell iris-subheading-cell\">\tforecast_refrance_time</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">x</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "</tr>\n",
       "<tr class=\"iris\">\n",
       "    <td class=\"iris-word-cell iris-subheading-cell\">\tforecast_period</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">x</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "</tr>\n",
       "<tr class=\"iris\">\n",
       "    <td class=\"iris-word-cell iris-subheading-cell\">\tgrid_latitude</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">x</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "</tr>\n",
       "<tr class=\"iris\">\n",
       "    <td class=\"iris-word-cell iris-subheading-cell\">\tgrid_longitude</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">-</td>\n",
       "    <td class=\"iris-inclusion-cell\">x</td>\n",
       "</tr>\n",
       "</table>\n",
       "        "
      ],
      "text/plain": [
       "<iris 'Cube' of surface_air_pressure / (Pa) (realisation: 23; forecast_refrance_time: 668; forecast_period: 48; grid_latitude: 548; grid_longitude: 421)>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Build a cube from our data array\n",
    "\n",
    "# Given a list of points and a name create a Iris DimCoord\n",
    "def points_to_coord(var_name, points, units=None, long_name=None, standard_name=None):\n",
    "    long_name = long_name if long_name else var_name\n",
    "    return iris.coords.DimCoord(\n",
    "        points=points,\n",
    "        standard_name=standard_name,\n",
    "        long_name=long_name if long_name else var_name,\n",
    "        var_name=var_name, units=units)\n",
    "\n",
    "# Here we cheat a little rather, than defining the lat and lon coord by hand I chose one file to represent them all and just read the coord info from that.\n",
    "with warnings.catch_warnings():\n",
    "    warnings.simplefilter(\"ignore\")\n",
    "    sample_cube = iris.load(os.path.join(BASE_PATH, \"prods_op_mogreps-uk_20130101_03_00_027.nc\"), VAR_NAME)[0]\n",
    "\n",
    "\n",
    "coords = [\n",
    "    points_to_coord('realisation', list(range(data.shape[0]))),\n",
    "    points_to_coord('forecast_refrance_time', list(range(3, data.shape[1]*12, 12)), units=Unit('hours since 2013-01-01', calendar='gregorian')),\n",
    "    points_to_coord('forecast_period', list(range(0,data.shape[2])), units=Unit('hours')),\n",
    "    sample_cube.coord('grid_latitude'),\n",
    "    sample_cube.coord('grid_longitude')\n",
    "]\n",
    "\n",
    "cube = iris.cube.Cube(\n",
    "        data=data,\n",
    "        standard_name=VAR_NAME,\n",
    "        long_name=VAR_NAME,\n",
    "        var_name=VAR_NAME,\n",
    "        units = Unit('Pa'),\n",
    "        dim_coords_and_dims=[(coord, i)for i, coord in enumerate(coords)])\n",
    "\n",
    "cube"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "masked_array(\n",
       "  data=[[101867.25, 101864.625, 101861.875, ..., 100561.625, 100526.75,\n",
       "         100344.125],\n",
       "        [101908.75, 101906.25, 101903.625, ..., 100551.125, 100514.375,\n",
       "         100330.875],\n",
       "        [101959.875, 101957.625, 101955.125, ..., 100550.375, 100515.375,\n",
       "         100333.125],\n",
       "        ...,\n",
       "        [--, --, --, ..., --, --, --],\n",
       "        [--, --, --, ..., --, --, --],\n",
       "        [--, --, --, ..., --, --, --]],\n",
       "  mask=[[False, False, False, ..., False, False, False],\n",
       "        [False, False, False, ..., False, False, False],\n",
       "        [False, False, False, ..., False, False, False],\n",
       "        ...,\n",
       "        [ True,  True,  True, ...,  True,  True,  True],\n",
       "        [ True,  True,  True, ...,  True,  True,  True],\n",
       "        [ True,  True,  True, ...,  True,  True,  True]],\n",
       "  fill_value=1e+20)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Access some data\n",
    "cube[:,1,2,10,:].data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'633.8GiB'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def human_bytes(num, suffix='B'):\n",
    "    for unit in ['','Ki','Mi','Gi','Ti','Pi','Ei','Zi']:\n",
    "        if abs(num) < 1024.0:\n",
    "            return \"%3.1f%s%s\" % (num, unit, suffix)\n",
    "        num /= 1024.0\n",
    "    return \"%.1f%s%s\" % (num, 'Yi', suffix)\n",
    "\n",
    "def estimate_cube_size(cube):\n",
    "    import functools\n",
    "    import operator\n",
    "    num_points = functools.reduce(operator.mul, cube.shape, 1)\n",
    "    return human_bytes((num_points * 32) / 8)\n",
    "\n",
    "# Estimates cubesize, not accurate but an intresting metric to gague size\n",
    "estimate_cube_size(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<cartopy.mpl.feature_artist.FeatureArtist at 0x7f1a485c3a20>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1a52b66c18>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import cartopy.crs as ccrs\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import iris\n",
    "import iris.plot as iplt\n",
    "import iris.quickplot as qplt\n",
    "\n",
    "# Plot some data\n",
    "qplt.contourf(cube[0,0,0,:,:], 15, cmap='viridis')\n",
    "plt.gca().coastlines()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}