map_gosat_L4_data.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors\n",
    "import matplotlib.cm as cm\n",
    "import netCDF4\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy as sci\n",
    "import mpl_toolkits\n",
    "from PIL import Image\n",
    "from mpl_toolkits.basemap import Basemap\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 2009 - 2013 (monthly data)\n",
    "ncs = [\n",
    "    'GOSATTFTS2009060120091231_4AF04MV0103.nc',\n",
    "    'GOSATTFTS2010010120101231_4AF04MV0103.nc',\n",
    "    'GOSATTFTS2011010120111231_4AF04MV0103.nc',\n",
    "    'GOSATTFTS2012010120121231_4AF04MV0103.nc',\n",
    "    'GOSATTFTS2013010120130930_4AF04MV0103.nc'\n",
    "]\n",
    "\n",
    "filepath='./data/L4ACH4/{}'\n",
    "\n",
    "nc_2009 = netCDF4.Dataset(filepath.format(ncs[0]))\n",
    "nc_2010 = netCDF4.Dataset(filepath.format(ncs[1]))\n",
    "nc_2011 = netCDF4.Dataset(filepath.format(ncs[2]))\n",
    "nc_2012 = netCDF4.Dataset(filepath.format(ncs[3]))\n",
    "nc_2013 = netCDF4.Dataset(filepath.format(ncs[4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2016-06-27\n",
      "2016-01-08\n",
      "2016-01-08\n",
      "2016-01-08\n"
     ]
    }
   ],
   "source": [
    "nc_2013.data_production_date\n",
    "print nc_2012.data_production_date\n",
    "print nc_2011.data_production_date\n",
    "print nc_2010.data_production_date\n",
    "print nc_2009.data_production_date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def set_data(_data, _nc):\n",
    "    \"\"\"\n",
    "    Return a dictionary with relevant informtion\n",
    "        ant_flx_rgn_imp\n",
    "        ant_flx_grd_imp\n",
    "        lat [float]\n",
    "        lon [float]\n",
    "        time [int]\n",
    "    \"\"\"\n",
    "    _data['data'] = {\n",
    "        'flux_by_region': _nc.variables['ant_flx_rgn_imp'][:],\n",
    "        'flux_by_grid':  _nc.variables['ant_flx_grd_imp'][:]\n",
    "    }\n",
    "    _data['lat'] = _nc.variables['lat'][:]\n",
    "    _data['lon'] = _nc.variables['lon'][:]\n",
    "    _data['time'] = _nc.variables['time'][:]\n",
    "    return _data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SET DATA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data_2013 = set_data({}, nc_2013) # most recent data\n",
    "data_2012 = set_data({}, nc_2012)\n",
    "data_2011 = set_data({}, nc_2011)\n",
    "data_2010 = set_data({}, nc_2010)\n",
    "data_2009 = set_data({}, nc_2009)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_2013['data']['flux_by_grid'][0][34, 61]\n",
    "\n",
    "cal_data = []\n",
    "\n",
    "\n",
    "for month_data in data_2010['data']['flux_by_grid']:\n",
    "    cal_data.append(month_data[34, 61])\n",
    "\n",
    "for month_data in data_2011['data']['flux_by_grid']:\n",
    "    cal_data.append(month_data[34, 61])\n",
    "\n",
    "for month_data in data_2012['data']['flux_by_grid']:\n",
    "    cal_data.append(month_data[34, 61])\n",
    "\n",
    "for month_data in data_2013['data']['flux_by_grid']:\n",
    "    cal_data.append(month_data[34, 61])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(cal_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flatten DATA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# all data flattened per year\n",
    "flat_data_2013 = data_2013['data']['flux_by_grid'].flatten()\n",
    "flat_data_2012 = data_2012['data']['flux_by_grid'].flatten()\n",
    "flat_data_2011 = data_2011['data']['flux_by_grid'].flatten()\n",
    "flat_data_2010 = data_2010['data']['flux_by_grid'].flatten()\n",
    "flat_data_2009 = data_2009['data']['flux_by_grid'].flatten()\n",
    "\n",
    "#nov = get_monthly_region_data(data_2012, 11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print NUM data points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print \"total number of data points for 12 months : {}\".format(180*360*12)\n",
    "print \"total number of data points in 2012 grid data: {}\".format(flat_data_2012.size)\n",
    "print \"total number of data points for 9 months: {}\".format(180*360*9)\n",
    "print \"total number of data points in 2013 grid data: {}\".format(flat_data_2013.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function to get data by month"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# monthly range [0, 11], exception of 2013 data which ranges from [0, 9]\n",
    "get_monthly_grid_data = lambda d, m: d['data']['flux_by_grid'][m, :, :]\n",
    "\n",
    "#Focuing on grid data\n",
    "#get_monthly_region_data = lambda data, month: data['data']['flux_by_region'][month, :, :]\n",
    "\n",
    "get_monthly_grid_data(data_2012, 10).flatten().sum()\n",
    "#b=data_2009['data']['flux_by_grid']\n",
    "#b.shape\n",
    "#region_data =data_2012['data']['flux_by_region'][1,:,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_monthly_grid_data(data_2013, 0).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function to plot histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def plot_hist(_plt, _data, year, x_range, y_max=50000, color_type='green'):\n",
    "    \"\"\"\n",
    "    _plt [matplotlib.pyplot]\n",
    "    _data [2D Numpy array] input data (already flattened)\n",
    "    \"\"\"\n",
    "\n",
    "    min_val = x_range[0]\n",
    "    max_val = x_range[1]\n",
    "   \n",
    "    plt.hist(_data, 100, [min_val, max_val], color=color_type, rwidth=0.9)\n",
    "\n",
    "    # set x range\n",
    "    plt.xlim([min_val, max_val])\n",
    "    plt.ylim([0, y_max])\n",
    "        \n",
    "    # set labels and title\n",
    "    plt.xlabel('Methane Concentration [{},{}]'.format(min_val, max_val))\n",
    "    plt.ylabel('Count')\n",
    "    \n",
    "    plt.title('Methane Concentration Flux 1*1 Grid for {} [g m^-2 day^-1])'.format(year))\n",
    "    \n",
    "    # legend of zorro\n",
    "    #plt.legend(('cdf','histogram ' + hist_type), loc = 'upper left')\n",
    "\n",
    "def get_xrange(_data):\n",
    "    return (np.amin(_data), np.amax(_data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function to plot two histograms (normal range, >0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#def plot_hist(_plt, _data, hist_type, title='Histogram'):\n",
    "\n",
    "def plot_hist2(_plt, _data, _year, color_type):\n",
    "\n",
    "    # complete hist\n",
    "    _plt.subplot(211)\n",
    "    plot_hist(_plt, _data, year=_year, \n",
    "              x_range=get_xrange(flat_data_2013), \n",
    "              color_type=color_type)\n",
    "    \n",
    "    # ignoring < 0.5 (hist is skewed to left)\n",
    "    _plt.subplot(212)\n",
    "    plot_hist(_plt, _data, year=_year, \n",
    "              x_range=[0.5, 3.0], \n",
    "              y_max=20, \n",
    "              color_type=color_type)\n",
    "    _plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PLOT few sample histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plot_hist(plt, flat_data_2013, 'original', '2013 Methane Concentration')\n",
    "\n",
    "plt.figure(figsize=(8, 4))\n",
    "plot_hist2(plt, flat_data_2013, 2013, 'green')\n",
    "\n",
    "plt.figure(figsize=(8, 4))\n",
    "plot_hist2(plt, flat_data_2012, 2012, 'blue')\n",
    "\n",
    "plt.figure(figsize=(8, 4))\n",
    "plot_hist2(plt, flat_data_2009, 2009, 'purple')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print Annual Summed Concentration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def print_annual_conc(year, _data):\n",
    "    print \"{} Annual value: {}\".format(year, _data.sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Print all annual values in gm^-2 day^-1\n",
    "print_annual_conc(2009, flat_data_2009)\n",
    "print_annual_conc(2010, flat_data_2010)\n",
    "print_annual_conc(2011, flat_data_2011)\n",
    "print_annual_conc(2012, flat_data_2012)\n",
    "print_annual_conc(2013, flat_data_2013)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[get_monthly_grid_data(data_2009, m).sum() for m in xrange(7)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.contourf(data['lon'], data['lat'], get_monthly_grid_data(data_2013, 8), cmap=plt.cm.Purples)\n",
    "plt.clim(0.5,2.0)\n",
    "plt.ylim(-89.5, 89.5) # lat\n",
    "plt.xlim(-179.5, 179.5) # lon\n",
    "\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.contourf(data['lon'], data['lat'], nc.variables['ant_flx_grd_imp'][0], \n",
    "             cmap = plt.cm.PuOr_r,\n",
    "             norm = matplotlib.colors.LogNorm()) # 0 for first month\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nc.variables.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.contourf(data['lon'], data['lat'], nc.variables['ant_flx_grd_imp'][:].mean(axis=0)) # 0 for first month\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mpl_toolkits.basemap import Basemap\n",
    "import matplotlib.pyplot as plt\n",
    "# setup Lambert Conformal basemap.\n",
    "# set resolution=None to skip processing of boundary datasets.\n",
    "m = Basemap(width=12000000,height=9000000,projection='lcc',\n",
    "            resolution=None,lat_1=45.,lat_2=55,lat_0=50,lon_0=-107.)\n",
    "m.etopo()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "m = Basemap(\n",
    "    width=5000000, height=3400000, projection='aea', resolution='l',\n",
    "    lat_1=29.5, lat_2=45.5, lat_0=38.5, lon_0=-96.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mpl_toolkits.basemap import Basemap \n",
    "m = Basemap(projection='kav7',lon_0=0,resolution=None) \n",
    "map.drawcoastlines(linewidth=0.25) \n",
    "map.drawcountries(linewidth=0.25) \n",
    "map.fillcontinents(color='coral',lake_color='aqua')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Trial A\n",
    "\n",
    "resoultion is poor for California, find another map\n",
    "Source?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-- create figure and axes instances\n",
    "dpi = 100\n",
    "fig = plt.figure(figsize=(1100/dpi, 1100/dpi), dpi=dpi)\n",
    "ax  = fig.add_axes([0.1,0.1,0.8,0.9])\n",
    "\n",
    "#-- create map\n",
    "map = Basemap(projection='cyl', llcrnrlat= 30., urcrnrlat= 50.,\\\n",
    "              resolution='c',  llcrnrlon=-125.,urcrnrlon=-114.)\n",
    "\n",
    "#-- draw coastlines, state and country boundaries, edge of map\n",
    "map.drawcoastlines()\n",
    "map.drawstates()\n",
    "#map.drawcountries()\n",
    "\n",
    "#-- create and draw meridians and parallels grid lines\n",
    "#map.drawparallels(np.arange( -90., 90.,30.),labels=[1,0,0,0],fontsize=10)\n",
    "#map.drawmeridians(np.arange(-180.,180.,30.),labels=[0,0,0,1],fontsize=10)\n",
    "\n",
    "#-- convert latitude/longitude values to plot x/y values\n",
    "x, y = map(*np.meshgrid(nc_2013['lon'],nc_2013['lat']))\n",
    "\n",
    "#-- contour levels\n",
    "clevs = np.arange(0.0,3.0,0.5)\n",
    "\n",
    "# Jan Data\n",
    "jan = get_monthly_grid_data(data_2013, 0)\n",
    "\n",
    "#-- draw filled contours\n",
    "cnplot = map.contourf(x,y, jan, clevs, cmap=plt.cm.Purples)\n",
    "\n",
    "#-- add colorbar\n",
    "cbar = map.colorbar(cnplot,location='bottom',pad=\"10%\")      #-- pad: distance between map and colorbar\n",
    "cbar.set_label('g m^-2 day^-1')                                      #-- add colorbar title string\n",
    "\n",
    "#-- add plot title\n",
    "plt.title('Methane')\n",
    "\n",
    "#-- displa on screen\n",
    "plt.show()\n",
    "\n",
    "#-- maximize and save PNG file\n",
    "#plt.savefig('plot_matplotlib_contour_filled_rect.png', bbox_inches='tight', dpi=dpi)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print np.amin(jan)\n",
    "print np.amax(jan)\n",
    "jan.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "map = Basemap(projection='robin',\n",
    "              resolution='c',\n",
    "              lat_0=0,\n",
    "              lon_0=0)\n",
    "\n",
    "#datain = np.flipud( msk_array )\n",
    "fig = plt.figure(figsize=(12,5))\n",
    "\n",
    "nx = jan.shape[1]\n",
    "ny = jan.shape[0]\n",
    "\n",
    "xin = np.linspace(map.xmin, map.xmax, nx) # nx is the number of x points on the grid\n",
    "yin = np.linspace(map.ymin, map.ymax, ny) # ny in the number of y points on the grid\n",
    "\n",
    "lons = np.arange(-180,180,0.25) #from raster.GetGeoTransform()\n",
    "lats  = np.arange(-90,90,0.25) \n",
    "\n",
    "lons, lats = np.meshgrid(lons,lats) \n",
    "xout, yout = map(lons, lats)\n",
    "dataout = mpl_toolkits.basemap.interp(jan, xin, yin, xout, yout, order=1)\n",
    "\n",
    "levels = np.arange(-2.0, 3.0, 0.5)\n",
    "cntr = map.contourf(xout,yout,dataout, levels, cmap=cm.RdBu_r)\n",
    "cbar = map.colorbar(cntr, location='bottom',pad='15%')\n",
    "\n",
    "# Add some more info to the map\n",
    "cstl = map.drawcoastlines(linewidth=.5)\n",
    "meri = map.drawmeridians(np.arange(0,360,60), linewidth=.2, labels=[1,0,0,1], labelstyle='+/-', color='grey' ) \n",
    "para = map.drawparallels(np.arange(-90,90,30), linewidth=.2, labels=[1,0,0,1], labelstyle='+/-', color='grey')\n",
    "boun = map.drawmapboundary(linewidth=0.5, color='grey')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mpl_toolkits.basemap import Basemap \n",
    "plt.\n",
    "m = Basemap(projection='kav7',lon_0=0,resolution=None) \n",
    "map.drawcoastlines(linewidth=0.25) \n",
    "map.drawcountries(linewidth=0.25) \n",
    "map.fillcontinents(color='coral',lake_color='aqua')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nc_2013['lat'][:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mpl_toolkits.basemap import Basemap, cm\n",
    "# requires netcdf4-python (netcdf4-python.googlecode.com)\n",
    "from netCDF4 import Dataset as NetCDFFile\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# plot rainfall from NWS using special precipitation\n",
    "# colormap used by the NWS, and included in basemap.\n",
    "\n",
    "nc = NetCDFFile('../../../examples/nws_precip_conus_20061222.nc')\n",
    "# data from http://water.weather.gov/precip/\n",
    "\n",
    "#prcpvar = nc.variables['amountofprecip']\n",
    "#data = 0.01*prcpvar[:]\n",
    "data = 0.01 * nc_2013['data']['flux_by_grid'][:]\n",
    "latcorners = nc.variables['lat'][:]\n",
    "loncorners = -nc.variables['lon'][:]\n",
    "lon_0 = -nc.variables['true_lon'].getValue()\n",
    "lat_0 = nc.variables['true_lat'].getValue()\n",
    "# create figure and axes instances\n",
    "fig = plt.figure(figsize=(8,8))\n",
    "ax = fig.add_axes([0.1,0.1,0.8,0.8])\n",
    "# create polar stereographic Basemap instance.\n",
    "m = Basemap(projection='stere',\n",
    "            lon_0=lon_0,\n",
    "            lat_0=90.,\n",
    "            lat_ts=lat_0,\\\n",
    "            llcrnrlat=latcorners[0],urcrnrlat=latcorners[2],\\\n",
    "            llcrnrlon=loncorners[0],urcrnrlon=loncorners[2],\\\n",
    "            rsphere=6371200.,resolution='l',area_thresh=10000)\n",
    "# draw coastlines, state and country boundaries, edge of map.\n",
    "m.drawcoastlines()\n",
    "m.drawstates()\n",
    "m.drawcountries()\n",
    "# draw parallels.\n",
    "parallels = np.arange(0.,90,10.)\n",
    "m.drawparallels(parallels,labels=[1,0,0,0],fontsize=10)\n",
    "# draw meridians\n",
    "meridians = np.arange(180.,360.,10.)\n",
    "m.drawmeridians(meridians,labels=[0,0,0,1],fontsize=10)\n",
    "ny = data.shape[0]; nx = data.shape[1]\n",
    "lons, lats = m.makegrid(nx, ny) # get lat/lons of ny by nx evenly space grid.\n",
    "x, y = m(lons, lats) # compute map proj coordinates.\n",
    "# draw filled contours.\n",
    "clevs = [0,1,2.5,5,7.5,10]\n",
    "cs = m.contourf(x,y,data,clevs,cmap=cm.s3pcpn)\n",
    "# add colorbar.\n",
    "cbar = m.colorbar(cs,location='bottom',pad=\"5%\")\n",
    "cbar.set_label('mm')\n",
    "# add title\n",
    "plt.title('title')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nc_2013."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mp = Basemap(width=1284000,\n",
    "             height=1164000,\n",
    "             projection='lcc',\n",
    "             lat_1=30.,\n",
    "             lat_2=60,\\\n",
    "             lat_0=37,\n",
    "             lon_0=-120.5,\n",
    "             resolution='c', # lowest res\n",
    "             rsphere=6370000.00)\n",
    "\n",
    "# fill data: lats, lons, grid\n",
    "cs = orb.pcolor(lons,lats,grid,cmap=cm.jet,norm=colors.LogNorm(),latlon=True)\n",
    "mp.drawcounties()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dd = get_monthly_grid_data(data_2013, 0) # January data\n",
    "\n",
    "dd[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(124.5 + 113.5)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "plt.figure(figsize=(14, 16))\n",
    "\n",
    "def california_map(ax=None, lllat=31.5, urlat=42.5,\n",
    "                   lllon=-124.5, urlon=-113.5):\n",
    "    m = Basemap(ax=ax, projection='stere',\n",
    "                lon_0=(urlon + lllon) / 2,\n",
    "                lat_0=(urlat + lllat) / 2,\n",
    "                llcrnrlat=lllat, urcrnrlat=urlat,\n",
    "                llcrnrlon=lllon, urcrnrlon=urlon,\n",
    "                resolution='i')\n",
    "    m.drawstates()\n",
    "    m.drawcountries()\n",
    "    m.drawcoastlines(color='lightblue')\n",
    "    m.drawlsmask(land_color='white', ocean_color='0.8', lakes=False)\n",
    "    return m\n",
    "\n",
    "# long and lat\n",
    "lon = np.arange(-124.5, -113.5, 1.0)\n",
    "lat = np.arange(31.5, 42.5, 1.0)\n",
    "\n",
    "# Build the figure and ax objects\n",
    "fig, ax = plt.subplots()\n",
    "ax.set_title('Methane Concentration in California')\n",
    "m= california_map()\n",
    "\n",
    "\n",
    "#m.plot()\n",
    "#predDf = predDf.sort('y_pred') # Useful for plotting\n",
    "x, y = m(lon, lat)\n",
    "dd = get_monthly_grid_data(data_2013, 0) # January data\n",
    "#serieA = (np.array(predDf['y_pred']) - predDf['y_pred'].min())/(predDf['y_pred'].max()-predDf['y_pred'].min())\n",
    "z = plt.cm.jet(dd)\n",
    "z = np.array(dd)\n",
    "\n",
    "#im = m.pcolormesh(lon, lat, dd, cmap=plt.cm.jet, latlon=True)\n",
    "\n",
    "#m.scatter(x, y, c=z, s=60, alpha=0.5, edgecolors='none')\n",
    "#c = m.colorbar(location='right')\n",
    "#c.set_label(\"House Value (Thousands of $)\")\n",
    "#m.plot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Just the contingous United States\n",
    "m = Basemap(\n",
    "    width=50000000, \n",
    "    height=34000000, \n",
    "    projection='aea', \n",
    "    resolution='c',\n",
    "    lat_0=35.5, \n",
    "    llcrnrlat=32.0, urcrnrlat=42.5,\n",
    "    llcrnrlon=-124.5, urcrnrlon=-113.5,\n",
    "    lon_0=-119.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the figure and ax objects\n",
    "fig, ax = plt.subplots(figsize=(18, 8))\n",
    "ax.set_title('PRISM 2011 Tmax')\n",
    " \n",
    "# Built-in map boundaries\n",
    "m.drawcoastlines(color='dodgerblue')\n",
    "m.drawlsmask(land_color='white', ocean_color='0.8', lakes=False)\n",
    "m.drawcountries()\n",
    "m.drawstates()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Build arrays of the lat/lon points for each cell\n",
    "lon = np.arange(-124.5, -113.5, 1.0)\n",
    "lat = np.arange(31.5, 42.5, 1.0)\n",
    "lons, lats = np.meshgrid(lons, lats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}