netcdf-by-coordinates.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:fcfcc45c4099153f7f060a87d83a0b2ebecb21093998d37e54a6f4d7d4bbf249"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Using numpy and KD-trees with netCDF data\n",
      "\n",
      "There is now a Unidata Developer's [Blog entry](http://www.unidata.ucar.edu/blogs/developer/en/entry/accessing_netcdf_data_by_coordinates) accompanying this iPython notebook.\n",
      "\n",
      "The goal is to demonstrate how to quickly access netCDF data based on geospatial coordinates instead of array indices.\n",
      "\n",
      "- First we show a naive and slow way to do this, in which we also have to worry about longitude anomalies\n",
      "- Then we speed up access with numpy arrays\n",
      "- Next, we demonstrate how to eliminate longitude anomalies\n",
      "- Finally, we use a kd-tree data structure to significantly speed up access by coordinates for large problems"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Getting data by coordinates from a netCDF File\n",
      "\n",
      "Let's look at a netCDF file from the *Atlantic Real-Time Ocean Forecast System*.  If you have cloned the [Unidata 2013 TDS-Python Workshop](https://github.com/Unidata/tds-python-workshop), this data is already available in 'data/rtofs_glo_3dz_f006_6hrly_reg3.nc'.  Otherwise you can get it from [rtofs_glo_3dz_f006_6hrly_reg3.nc](https://github.com/Unidata/tds-python-workshop/blob/master/data/rtofs_glo_3dz_f006_6hrly_reg3.nc)."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Looking at netCDF metadata from Python\n",
      "\n",
      "In iPython, we could invoke the **ncdump** utility like this:\n",
      "    \n",
      "    filename = 'data/rtofs_glo_3dz_f006_6hrly_reg3.nc'\n",
      "    !ncdump -h $filename\n",
      "    \n",
      "*if* we know that a recent version of **ncdump** is installed that\n",
      "can read compressed data from netCDF-4 classic model files.\n",
      "\n",
      "Alternatively, we'll use the netCDF4python package to show information about\n",
      "the file in a form that's somewhat less familiar, but contains the information\n",
      "we need for the subsequent examples.  This works for any netCDF file format:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import netCDF4\n",
      "filename = 'data/rtofs_glo_3dz_f006_6hrly_reg3.nc'\n",
      "ncfile = netCDF4.Dataset(filename, 'r')\n",
      "print ncfile                # shows global attributes, dimensions, and variables\n",
      "ncvars = ncfile.variables   # a dictionary of variables\n",
      "# print information about specific variables, including type, shape, and attributes\n",
      "for varname in ['temperature', 'salinity', 'Latitude', 'Longitude']:\n",
      "    print ncvars[varname]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'netCDF4.Dataset'>\n",
        "root group (NETCDF4_CLASSIC file format):\n",
        "    Conventions: CF-1.0\n",
        "    title: HYCOM ATLb2.00\n",
        "    institution: National Centers for Environmental Prediction\n",
        "    source: HYCOM archive file\n",
        "    experiment: 90.9\n",
        "    history: archv2ncdf3z\n",
        "    dimensions = (u'MT', u'Y', u'X', u'Depth')\n",
        "    variables = (u'MT', u'Date', u'Depth', u'Y', u'X', u'Latitude', u'Longitude', u'u', u'v', u'temperature', u'salinity')\n",
        "    groups = ()\n",
        "\n",
        "<type 'netCDF4.Variable'>\n",
        "float32 temperature(u'MT', u'Depth', u'Y', u'X')\n",
        "    coordinates: Longitude Latitude Date\n",
        "    standard_name: sea_water_potential_temperature\n",
        "    units: degC\n",
        "    _FillValue: 1.26765e+30\n",
        "    valid_range: [ -5.07860279  11.14989948]\n",
        "    long_name:   temp [90.9H]\n",
        "unlimited dimensions = (u'MT',)\n",
        "current size = (1, 10, 850, 712)\n",
        "\n",
        "<type 'netCDF4.Variable'>\n",
        "float32 salinity(u'MT', u'Depth', u'Y', u'X')\n",
        "    coordinates: Longitude Latitude Date\n",
        "    standard_name: sea_water_salinity\n",
        "    units: psu\n",
        "    _FillValue: 1.26765e+30\n",
        "    valid_range: [ 11.61832619  35.04695129]\n",
        "    long_name:  salinity [90.9H]\n",
        "unlimited dimensions = (u'MT',)\n",
        "current size = (1, 10, 850, 712)\n",
        "\n",
        "<type 'netCDF4.Variable'>\n",
        "float32 Latitude(u'Y', u'X')\n",
        "    standard_name: latitude\n",
        "    units: degrees_north\n",
        "unlimited dimensions = ()\n",
        "current size = (850, 712)\n",
        "\n",
        "<type 'netCDF4.Variable'>\n",
        "float32 Longitude(u'Y', u'X')\n",
        "    standard_name: longitude\n",
        "    units: degrees_east\n",
        "unlimited dimensions = ()\n",
        "current size = (850, 712)\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Here's a sparse picture (every 25th point on each axis) of what the grid looks like on which Latitude, Longitude, Temperature, Salinity, and other variables are defined:\n",
      "\n",
      "![Example lat-lon grid](http://www.unidata.ucar.edu/software/netcdf/workshops/images/20130811_rew_blog_grid.png)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Example query: sea surface temperature and salinity at 50N, 140W?\n",
      "\n",
      "- So **Longitude** and **Latitude** are 2D netCDF variables of shape 850 x 712, indexed by **Y** and **X** dimensions\n",
      "- That's 605200 values for each\n",
      "- There's no _direct_ way in this file (and many netCDF files) to compute grid indexes from coordinates via a coordinate system and projection parameters.  Instead, we have to rely on the latitude and longitude auxiliary coordinate variables, as required by the CF conventions for data not on a simple lat,lon grid.\n",
      "- To get the temperature at 50N, 140W, we need to find **Y** and **X** indexes **iy** and **ix** such that (**Longitude[iy, ix]**, **Latitude[iy, ix]**) is \"close\" to (50.0, -140.0)."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Naive, slow way using nested loops\n",
      "\n",
      "- Initially, for simplicity, we just use Euclidean distance squared, as if the Earth is flat, latitude and longitude are $x$- and $y$-coordinates, and the distance squared between points $(lat_1,lon_1)$ and $(lat_0,lon_0)$ is $( lat_1 - lat_0 )^2 + ( lon_1 - lon_0 )^2$.\n",
      "- Note: these assumptions are wrong near the poles and on opposite sides of longitude boundary discontinuity.\n",
      "- So, keeping things simple, we want to find **iy** and **ix** to minimize\n",
      "\n",
      "    ``(Latitude[iy, ix] - lat0)**2 + (Longitude[iy, ix] - lon0)**2``\n",
      "    \n",
      "![Flat Earth](http://www.unidata.ucar.edu/software/netcdf/workshops/images/unproj.gif)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Reading netCDF data into numpy arrays\n",
      "\n",
      "To access netCDF data, rather than just metadata, we will also need NumPy:\n",
      "\n",
      "- A Python library for scientific programming.\n",
      "- Supports n-dimensional array-based calculations similar to Fortran and IDL.\n",
      "- Includes fast mathematical functions to act on scalars and arrays.\n",
      "\n",
      "With the Python netCDF4 package, using \"[ ... ]\" to index a netCDF variable object reads or writes a numpy array from the associated netCDF file.\n",
      "\n",
      "The code below reads latitude and longitude values into 2D numpy arrays named **latvals** and **lonvals**:"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### First version: slow and spatially challenged\n",
      "Here's a function that uses simple nested loops to find indices that minimize the distance to the desired coordinates, written as if using Fortran or C rather than Python.  We'll call this function in the cell following this definition ..."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np\n",
      "import netCDF4\n",
      "\n",
      "def naive_slow(latvar,lonvar,lat0,lon0):\n",
      "    '''\n",
      "    Find \"closest\" point in a set of (lat,lon) points to specified point\n",
      "    latvar - 2D latitude variable from an open netCDF dataset\n",
      "    lonvar - 2D longitude variable from an open netCDF dataset\n",
      "    lat0,lon0 - query point\n",
      "    Returns iy,ix such that \n",
      "     (lonval[iy,ix] - lon0)**2 + (latval[iy,ix] - lat0)**2\n",
      "    is minimum.  This \"closeness\" measure works badly near poles and\n",
      "    longitude boundaries.\n",
      "    '''\n",
      "    # Read from file into numpy arrays\n",
      "    latvals = latvar[:]\n",
      "    lonvals = lonvar[:]\n",
      "    ny,nx = latvals.shape\n",
      "    dist_sq_min = 1.0e30\n",
      "    for iy in range(ny):\n",
      "        for ix in range(nx):\n",
      "            latval = latvals[iy, ix]\n",
      "            lonval = lonvals[iy, ix]\n",
      "            dist_sq = (latval - lat0)**2 + (lonval - lon0)**2\n",
      "            if dist_sq < dist_sq_min:\n",
      "                iy_min, ix_min, dist_sq_min = iy, ix, dist_sq\n",
      "    return iy_min,ix_min"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "When we call the function above it takes several seconds to run, because it calculates distances one point at a time, for each of the 605200 $(lat, lon)$ points.  Note that once indices for the point nearest to (50, -140) are found, they can be used to access temperature, salinity, and other netCDF variables that use the same dimensions."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ncfile = netCDF4.Dataset(filename, 'r')\n",
      "latvar = ncfile.variables['Latitude']\n",
      "lonvar = ncfile.variables['Longitude']\n",
      "iy,ix = naive_slow(latvar, lonvar, 50.0, -140.0)\n",
      "print 'Closest lat lon:', latvar[iy,ix], lonvar[iy,ix]\n",
      "tempvar = ncfile.variables['temperature']\n",
      "salvar = ncfile.variables['salinity']\n",
      "print 'temperature:', tempvar[0, 0, iy, ix], tempvar.units\n",
      "print 'salinity:', salvar[0, 0, iy, ix], salvar.units\n",
      "ncfile.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Closest lat lon: 49.9867 -139.982\n",
        "temperature: 6.46312 degC\n",
        "salinity: 32.6572 psu\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### NumPy arrays instead of loops: fast, but still assumes flat earth\n",
      "\n",
      "The above function is slow, because it doesn't make good use of NumPy arrays.  It's much faster to use whole array operations to eliminate loops and element-at-a-time computation.  NumPy functions that help eliminate loops include:\n",
      "\n",
      "- The `argmin()` method that returns a 1D index of the minimum value of a NumPy array\n",
      "- The `unravel_index()` function that converts a 1D index back into a multidimensional index"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np\n",
      "import netCDF4\n",
      "\n",
      "def naive_fast(latvar,lonvar,lat0,lon0):\n",
      "    # Read latitude and longitude from file into numpy arrays\n",
      "    latvals = latvar[:]\n",
      "    lonvals = lonvar[:]\n",
      "    ny,nx = latvals.shape\n",
      "    dist_sq = (latvals-lat0)**2 + (lonvals-lon0)**2\n",
      "    minindex_flattened = dist_sq.argmin()  # 1D index of min element\n",
      "    iy_min,ix_min = np.unravel_index(minindex_flattened, latvals.shape)\n",
      "    return iy_min,ix_min\n",
      "\n",
      "ncfile = netCDF4.Dataset(filename, 'r')\n",
      "latvar = ncfile.variables['Latitude']\n",
      "lonvar = ncfile.variables['Longitude']\n",
      "iy,ix = naive_fast(latvar, lonvar, 50.0, -140.0)\n",
      "print 'Closest lat lon:', latvar[iy,ix], lonvar[iy,ix]\n",
      "ncfile.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Closest lat lon: 49.9867 -139.982\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Spherical Earth with tunnel distance: fast _and_ correct\n",
      "\n",
      "Though assuming a flat Earth may work OK for this example, we'd like to not worry about whether longitudes are from 0 to 360 or -180 to 180, or whether points are close to the poles.\n",
      "The code below fixes this by using the square of \"tunnel distance\" between (lat,lon) points. This version is both fast and correct (for a _spherical_ Earth)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np\n",
      "import netCDF4\n",
      "from math import pi\n",
      "from numpy import cos, sin\n",
      "\n",
      "def tunnel_fast(latvar,lonvar,lat0,lon0):\n",
      "    '''\n",
      "    Find closest point in a set of (lat,lon) points to specified point\n",
      "    latvar - 2D latitude variable from an open netCDF dataset\n",
      "    lonvar - 2D longitude variable from an open netCDF dataset\n",
      "    lat0,lon0 - query point\n",
      "    Returns iy,ix such that the square of the tunnel distance\n",
      "    between (latval[it,ix],lonval[iy,ix]) and (lat0,lon0)\n",
      "    is minimum.\n",
      "    '''\n",
      "    rad_factor = pi/180.0 # for trignometry, need angles in radians\n",
      "    # Read latitude and longitude from file into numpy arrays\n",
      "    latvals = latvar[:] * rad_factor\n",
      "    lonvals = lonvar[:] * rad_factor\n",
      "    ny,nx = latvals.shape\n",
      "    lat0_rad = lat0 * rad_factor\n",
      "    lon0_rad = lon0 * rad_factor\n",
      "    # Compute numpy arrays for all values, no loops\n",
      "    clat,clon = cos(latvals),cos(lonvals)\n",
      "    slat,slon = sin(latvals),sin(lonvals)\n",
      "    delX = cos(lat0_rad)*cos(lon0_rad) - clat*clon\n",
      "    delY = cos(lat0_rad)*sin(lon0_rad) - clat*slon\n",
      "    delZ = sin(lat0_rad) - slat;\n",
      "    dist_sq = delX**2 + delY**2 + delZ**2\n",
      "    minindex_1d = dist_sq.argmin()  # 1D index of minimum element\n",
      "    iy_min,ix_min = np.unravel_index(minindex_1d, latvals.shape)\n",
      "    return iy_min,ix_min\n",
      "\n",
      "ncfile = netCDF4.Dataset(filename, 'r')\n",
      "latvar = ncfile.variables['Latitude']\n",
      "lonvar = ncfile.variables['Longitude']\n",
      "iy,ix = tunnel_fast(latvar, lonvar, 50.0, -140.0)\n",
      "print 'Closest lat lon:', latvar[iy,ix], lonvar[iy,ix]\n",
      "ncfile.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Closest lat lon: 49.9867 -139.982\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### KD-Trees: faster data structure for lots of queries\n",
      "\n",
      "We can still do better, by using a data structure designed to support efficient nearest-neighbor queries: the [KD-tree](http://en.wikipedia.org/wiki/K-d_tree).  It works like a multidimensional binary tree, so finding the point nearest to a query point is _much_ faster than computing all the distances to find the minimum.  It takes some setup time to load all the points into the data structure, but that only has to be done once for a given set of points.  \n",
      "    \n",
      "For a single point query, it's still more than twice as fast as the naive slow version above, but building the KD-tree for 605,200 points takes more time than the fast numpy search through all the points, so in this case using the KD-tree for a _single_ point query is sort of pointless ..."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np\n",
      "import netCDF4\n",
      "from math import pi\n",
      "from numpy import cos, sin\n",
      "from scipy.spatial import cKDTree\n",
      "\n",
      "def kdtree_fast(latvar,lonvar,lat0,lon0):\n",
      "    rad_factor = pi/180.0 # for trignometry, need angles in radians\n",
      "    # Read latitude and longitude from file into numpy arrays\n",
      "    latvals = latvar[:] * rad_factor\n",
      "    lonvals = lonvar[:] * rad_factor\n",
      "    ny,nx = latvals.shape\n",
      "    clat,clon = cos(latvals),cos(lonvals)\n",
      "    slat,slon = sin(latvals),sin(lonvals)\n",
      "    # Build kd-tree from big arrays of 3D coordinates\n",
      "    triples = zip(np.ravel(clat*clon), np.ravel(clat*slon), np.ravel(slat))\n",
      "    kdt = cKDTree(triples)\n",
      "    lat0_rad = lat0 * rad_factor\n",
      "    lon0_rad = lon0 * rad_factor\n",
      "    clat0,clon0 = cos(lat0_rad),cos(lon0_rad)\n",
      "    slat0,slon0 = sin(lat0_rad),sin(lon0_rad)\n",
      "    dist_sq_min, minindex_1d = kdt.query([clat0*clon0, clat0*slon0, slat0])\n",
      "    iy_min, ix_min = np.unravel_index(minindex_1d, latvals.shape)\n",
      "    return iy_min,ix_min\n",
      "                \n",
      "ncfile = netCDF4.Dataset(filename, 'r')\n",
      "latvar = ncfile.variables['Latitude']\n",
      "lonvar = ncfile.variables['Longitude']\n",
      "iy,ix = kdtree_fast(latvar, lonvar, 50.0, -140.0)\n",
      "print 'Closest lat lon:', latvar[iy,ix], lonvar[iy,ix]\n",
      "ncfile.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Closest lat lon: 49.9867 -139.982\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Timing the functions\n",
      "\n",
      "If you're curious about actual times for the versions above, the iPython notebook \"%%timeit\" statement gets accurate timings of all of them.  Below, we time just a single query point, in this case (50.0, -140.0).  To get accurate timings, the \"%%timeit\" statement lets us do untimed setup first on the same line, before running the function call in a loop."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "%%timeit ncfile = netCDF4.Dataset(filename,'r');latvar = ncfile.variables['Latitude'];lonvar = ncfile.variables['Longitude']\n",
      "naive_slow(latvar, lonvar, 50.0, -140.0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 loops, best of 3: 7.54 s per loop\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit ncfile = netCDF4.Dataset(filename,'r');latvar = ncfile.variables['Latitude'];lonvar = ncfile.variables['Longitude']\n",
      "naive_fast(latvar, lonvar, 50.0, -140.0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100 loops, best of 3: 7.65 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit ncfile = netCDF4.Dataset(filename,'r');latvar = ncfile.variables['Latitude'];lonvar = ncfile.variables['Longitude']\n",
      "tunnel_fast(latvar, lonvar, 50.0, -140.0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10 loops, best of 3: 35.8 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit ncfile = netCDF4.Dataset(filename,'r');latvar = ncfile.variables['Latitude'];lonvar = ncfile.variables['Longitude']\n",
      "kdtree_fast(latvar, lonvar, 50.0, -140.0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 loops, best of 3: 2.54 s per loop\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ncfile.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 11
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Separating setup from query\n",
      "\n",
      "The above use of the KD-tree data structure is not the way it's meant to be used.  Instead, it should be initialized _once_ with all the k-dimensional data for which nearest-neighbors are desired, then used repeatedly on each query, amortizing the work done to build the data structure over all the following queries.  By separately timing the setup and the time required per query, the threshold for number of queries beyond which the KD-tree is faster can be determined.\n",
      "\n",
      "That's exactly what we'll do now.  We split each algorithm into two functions, a setup function and a query function.  The times per query go from seconds (the naive version) to milliseconds (the array-oriented numpy version) to microseconds (the turbo-charged KD-tree, once it's built).\n",
      "                                                                                                                                                                                                                                                   \n",
      "Rather than just using functions, we define a Class for each algorithm, do the setup in the class constructor, and provide a query method.                                                                                                                                                                                                                                                  "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Split naive_slow into initialization and query, so we can time them separately\n",
      "import numpy as np\n",
      "import netCDF4\n",
      "\n",
      "class Naive_slow(object):\n",
      "    def __init__(self, ncfile, latvarname, lonvarname):\n",
      "        self.ncfile = ncfile\n",
      "        self.latvar = self.ncfile.variables[latvarname]\n",
      "        self.lonvar = self.ncfile.variables[lonvarname]\n",
      "        # Read latitude and longitude from file into numpy arrays\n",
      "        self.latvals = self.latvar[:]\n",
      "        self.lonvals = self.lonvar[:]\n",
      "        self.shape = self.latvals.shape\n",
      "\n",
      "    def query(self,lat0,lon0):\n",
      "        ny,nx = self.shape\n",
      "        dist_sq_min = 1.0e30\n",
      "        for iy in range(ny):\n",
      "            for ix in range(nx):\n",
      "                latval = self.latvals[iy, ix]\n",
      "                lonval = self.lonvals[iy, ix]\n",
      "                dist_sq = (latval - lat0)**2 + (lonval - lon0)**2\n",
      "                if dist_sq < dist_sq_min:\n",
      "                    iy_min, ix_min, dist_sq_min = iy, ix, dist_sq\n",
      "        return iy_min,ix_min\n",
      "\n",
      "ncfile = netCDF4.Dataset(filename, 'r')\n",
      "ns = Naive_slow(ncfile,'Latitude','Longitude')\n",
      "iy,ix = ns.query(50.0, -140.0)\n",
      "print 'Closest lat lon:', ns.latvar[iy,ix], ns.lonvar[iy,ix]\n",
      "ncfile.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Closest lat lon: 49.9867 -139.982\n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Split naive_fast into initialization and query, so we can time them separately\n",
      "import numpy as np\n",
      "import netCDF4\n",
      "\n",
      "class Naive_fast(object):\n",
      "    def __init__(self, ncfile, latvarname, lonvarname):\n",
      "        self.ncfile = ncfile\n",
      "        self.latvar = self.ncfile.variables[latvarname]\n",
      "        self.lonvar = self.ncfile.variables[lonvarname]        \n",
      "        # Read latitude and longitude from file into numpy arrays\n",
      "        self.latvals = self.latvar[:]\n",
      "        self.lonvals = self.lonvar[:]\n",
      "        self.shape = self.latvals.shape\n",
      "        \n",
      "\n",
      "    def query(self,lat0,lon0):\n",
      "        dist_sq = (self.latvals-lat0)**2 + (self.lonvals-lon0)**2\n",
      "        minindex_flattened = dist_sq.argmin()                             # 1D index\n",
      "        iy_min, ix_min = np.unravel_index(minindex_flattened, self.shape) # 2D indexes\n",
      "        return iy_min,ix_min\n",
      "\n",
      "ncfile = netCDF4.Dataset(filename, 'r')\n",
      "ns = Naive_fast(ncfile,'Latitude','Longitude')\n",
      "iy,ix = ns.query(50.0, -140.0)\n",
      "print 'Closest lat lon:', ns.latvar[iy,ix], ns.lonvar[iy,ix]\n",
      "ncfile.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Closest lat lon: 49.9867 -139.982\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Split tunnel_fast into initialization and query, so we can time them separately\n",
      "import numpy as np\n",
      "import netCDF4\n",
      "from math import pi\n",
      "from numpy import cos, sin\n",
      "\n",
      "class Tunnel_fast(object):\n",
      "    def __init__(self, ncfile, latvarname, lonvarname):\n",
      "        self.ncfile = ncfile\n",
      "        self.latvar = self.ncfile.variables[latvarname]\n",
      "        self.lonvar = self.ncfile.variables[lonvarname]        \n",
      "        # Read latitude and longitude from file into numpy arrays\n",
      "        rad_factor = pi/180.0 # for trignometry, need angles in radians\n",
      "        self.latvals = self.latvar[:] * rad_factor\n",
      "        self.lonvals = self.lonvar[:] * rad_factor\n",
      "        self.shape = self.latvals.shape\n",
      "        clat,clon,slon = cos(self.latvals),cos(self.lonvals),sin(self.lonvals)\n",
      "        self.clat_clon = clat*clon\n",
      "        self.clat_slon = clat*slon\n",
      "        self.slat = sin(self.latvals)\n",
      " \n",
      "    def query(self,lat0,lon0):\n",
      "        # for trignometry, need angles in radians\n",
      "        rad_factor = pi/180.0 \n",
      "        lat0_rad = lat0 * rad_factor\n",
      "        lon0_rad = lon0 * rad_factor\n",
      "        delX = cos(lat0_rad)*cos(lon0_rad) - self.clat_clon\n",
      "        delY = cos(lat0_rad)*sin(lon0_rad) - self.clat_slon\n",
      "        delZ = sin(lat0_rad) - self.slat;\n",
      "        dist_sq = delX**2 + delY**2 + delZ**2\n",
      "        minindex_1d = dist_sq.argmin()                              # 1D index \n",
      "        iy_min, ix_min = np.unravel_index(minindex_1d, self.shape)  # 2D indexes\n",
      "        return iy_min,ix_min\n",
      "\n",
      "ncfile = netCDF4.Dataset(filename, 'r')\n",
      "ns = Tunnel_fast(ncfile,'Latitude','Longitude')\n",
      "iy,ix = ns.query(50.0, -140.0)\n",
      "print 'Closest lat lon:', ns.latvar[iy,ix], ns.lonvar[iy,ix]\n",
      "ncfile.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Closest lat lon: 49.9867 -139.982\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Split kdtree_fast into initialization and query, so we can time them separately\n",
      "import numpy as np\n",
      "import netCDF4\n",
      "from math import pi\n",
      "from numpy import cos, sin\n",
      "from scipy.spatial import cKDTree\n",
      "\n",
      "class Kdtree_fast(object):\n",
      "    def __init__(self, ncfile, latvarname, lonvarname):\n",
      "        self.ncfile = ncfile\n",
      "        self.latvar = self.ncfile.variables[latvarname]\n",
      "        self.lonvar = self.ncfile.variables[lonvarname]        \n",
      "        # Read latitude and longitude from file into numpy arrays\n",
      "        rad_factor = pi/180.0 # for trignometry, need angles in radians\n",
      "        self.latvals = self.latvar[:] * rad_factor\n",
      "        self.lonvals = self.lonvar[:] * rad_factor\n",
      "        self.shape = self.latvals.shape\n",
      "        clat,clon = cos(self.latvals),cos(self.lonvals)\n",
      "        slat,slon = sin(self.latvals),sin(self.lonvals)\n",
      "        clat_clon = clat*clon\n",
      "        clat_slon = clat*slon\n",
      "        triples = zip(np.ravel(clat*clon), np.ravel(clat*slon), np.ravel(slat))\n",
      "        self.kdt = cKDTree(triples)\n",
      "\n",
      "    def query(self,lat0,lon0):\n",
      "        rad_factor = pi/180.0 \n",
      "        lat0_rad = lat0 * rad_factor\n",
      "        lon0_rad = lon0 * rad_factor\n",
      "        clat0,clon0 = cos(lat0_rad),cos(lon0_rad)\n",
      "        slat0,slon0 = sin(lat0_rad),sin(lon0_rad)\n",
      "        dist_sq_min, minindex_1d = self.kdt.query([clat0*clon0,clat0*slon0,slat0])\n",
      "        iy_min, ix_min = np.unravel_index(minindex_1d, self.shape)\n",
      "        return iy_min,ix_min\n",
      "\n",
      "ncfile = netCDF4.Dataset(filename, 'r')\n",
      "ns = Kdtree_fast(ncfile,'Latitude','Longitude')\n",
      "iy,ix = ns.query(50.0, -140.0)\n",
      "print 'Closest lat lon:', ns.latvar[iy,ix], ns.lonvar[iy,ix]\n",
      "ncfile.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Closest lat lon: 49.9867 -139.982\n"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Setup times for the four algorithms"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit ncfile = netCDF4.Dataset(filename, 'r')\n",
      "ns = Naive_slow(ncfile,'Latitude','Longitude')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100 loops, best of 3: 3.76 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit ncfile = netCDF4.Dataset(filename, 'r')\n",
      "ns = Naive_fast(ncfile,'Latitude','Longitude')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100 loops, best of 3: 3.8 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit ncfile = netCDF4.Dataset(filename, 'r')\n",
      "ns = Tunnel_fast(ncfile,'Latitude','Longitude')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10 loops, best of 3: 27.4 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit ncfile = netCDF4.Dataset(filename, 'r')\n",
      "ns = Kdtree_fast(ncfile,'Latitude','Longitude')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 loops, best of 3: 2.52 s per loop\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Query times for the four algorithms"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "%%timeit ncfile = netCDF4.Dataset(filename, 'r'); ns = Naive_slow(ncfile,'Latitude','Longitude')\n",
      "iy,ix = ns.query(50.0, -140.0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 loops, best of 3: 7.79 s per loop\n"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "%%timeit ncfile = netCDF4.Dataset(filename, 'r'); ns = Naive_fast(ncfile,'Latitude','Longitude')\n",
      "iy,ix = ns.query(50.0, -140.0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100 loops, best of 3: 2.46 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit ncfile = netCDF4.Dataset(filename, 'r'); ns = Tunnel_fast(ncfile,'Latitude','Longitude')\n",
      "iy,ix = ns.query(50.0, -140.0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100 loops, best of 3: 5.14 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "%%timeit ncfile = netCDF4.Dataset(filename, 'r'); ns = Kdtree_fast(ncfile,'Latitude','Longitude')\n",
      "iy,ix = ns.query(50.0, -140.0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000 loops, best of 3: 73.8 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In the next cell, we copy the results of the %%timeit runs into Python variables.  _(Is there a way to capture %%timeit output, so we don't have to do this manually?)_"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ns0,nf0,tf0,kd0 = 3.76, 3.8, 27.4, 2520  # setup times in msec\n",
      "nsq,nfq,tfq,kdq = 7790, 2.46, 5.14, .0738 # query times in msec"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 26
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Summary of timings\n",
      "\n",
      "The naive_slow method is always slower than all other methods.  The naive_fast method would only be worth considering if non-flatness of the Earth is irrelevant, for example in a relatively small region not close to the poles and not crossing a longitude discontinuity.\n",
      "\n",
      "Total time for running initialization followed by N queries is:\n",
      "\n",
      "  - naive_slow:    $ns0 + nsq * N$\n",
      "  - naive_fast:    $nf0 + nfq * N$\n",
      "  - tunnel_fast:   $nt0 + ntq * N$\n",
      "  - kdtree_fast:   $kd0 + kdq * N$"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "N = 10000\n",
      "print N, \"queries using naive_slow:\", round((ns0 + nsq*N)/1000,1), \"seconds\"\n",
      "print N, \"queries using naive_fast:\", round((nf0 + nfq*N)/1000,1), \"seconds\"\n",
      "print N, \"queries using tunnel_fast:\", round((tf0 + tfq*N)/1000,1), \"seconds\"\n",
      "print N, \"queries using kdtree_fast:\", round((kd0 + kdq*N)/1000,1), \"seconds\"\n",
      "print\n",
      "print \"kd_tree_fast outperforms naive_fast above:\", int((kd0-nf0)/(nfq-kdq)), \"queries\"\n",
      "print \"kd_tree_fast outperforms tunnel_fast above:\", int((kd0-tf0)/(tfq-kdq)), \"queries\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000 queries using naive_slow: 77900.0 seconds\n",
        "10000 queries using naive_fast: 24.6 seconds\n",
        "10000 queries using tunnel_fast: 51.4 seconds\n",
        "10000 queries using kdtree_fast: 3.3 seconds\n",
        "\n",
        "kd_tree_fast outperforms naive_fast above: 1054 queries\n",
        "kd_tree_fast outperforms tunnel_fast above: 492 queries\n"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The advantage of using KD-trees is much greater for more search set points, as KD-tree query complexity is O(log(N)), but the other algorithms are O(N), the same as the difference between using binary search versus linear search."
     ]
    }
   ],
   "metadata": {}
  }
 ]
}