06_02_pyNIO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using PyNIO to examine NetCDF, GRIB, and HDF-EOS files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import Nio as nio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NetCDF file with a rectilinear grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename=\"../Data/ts_Amon_CESM1-CAM5_historical_r1i1p1_185001-200512.nc\"\n",
    "f = nio.open_file(filename)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WRF ouput file (NetCDF) with a curvilinear grid\n",
    "\n",
    "The WRF file doesn't have a \".nc\" suffix; watch what happens if you forget to add it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This code will produce an error about an invalid extension\n",
    "filename=\"Data/wrfout_d03_2012-04-22_23_00_00\"\n",
    "f = nio.open_file(filename)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add the \".nc\" to the WRF filename"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename=\"../Data/wrfout_d03_2012-04-22_23_00_00.nc\"\n",
    "f = nio.open_file(filename)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GRIB1 file - curvilinear grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "filename=\"../Data/ruc.grb\"\n",
    "f = nio.open_file(filename)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GRIB2 file - curvilinear grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "filename=\"../Data/MET9_IR108_cosmode_0909210000.grb2\"\n",
    "f = nio.open_file(filename)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### HDF-EOS file with an \".hdf\" suffix\n",
    "Note the top part of the \"global attributes\" output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "filename=\"../Data/MOD06_L2.A2010031.1430.005.2010031221343.hdf\"\n",
    "f = nio.open_file(filename)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add \".he2\" suffix and open file again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "filename = filename + \".he2\"\n",
    "f = nio.open_file(filename)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: Write short python script to output contents of any supported file, by passing the filename via a command line argument\n",
    "\n",
    "For example:\n",
    "\n",
    "python niodump.py -f MOD06_L2.A2010031.1430.005.2010031221343.hdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Open a NetCDF file and read a rectilinear grid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import required modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import Nio as nio\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = \"../Data/ts_Amon_CESM1-CAM5_historical_r1i1p1_185001-200512_partial.nc\"\n",
    "f   = nio.open_file(filename)\n",
    "#print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Print all the variables on the file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vnames = f.variables.keys()\n",
    "print vnames"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read ts, lat, lon off the file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ts  = f.variables[\"ts\"]           # Get the \"ts\" variable object                          \n",
    "lat = f.variables[\"lat\"][:]       # [:] reads the values                            \n",
    "lon = f.variables[\"lon\"][:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Print some info about variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print \"ts type\",type(ts)\n",
    "print \"lat type\",type(lat)\n",
    "print \"lon type\",type(lon)\n",
    "print \"ts dimension sizes\",ts.shape\n",
    "print \"lat dimension sizes\",lat.shape\n",
    "print \"lon dimension sizes\",lon.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Print attributes and dimension names of ts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print \"Attributes\",     ts.attributes\n",
    "print \"Dimension names\",ts.dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing individual attributes and dimension names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print \"Variable is %s (%s)\" % (ts.long_name,ts.units)\n",
    "print \"Name of dimension 0 is\", ts.dimensions[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use [:] to access values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tvals = ts[:]             # Reads all dimensions, all values\n",
    "print \"type\",type(tvals)\n",
    "print \"shape\",tvals.shape\n",
    "print \"dtype = %s\" % tvals.dtype\n",
    "print tvals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Two ways to get the min/max\n",
    "print \"min / max = %g / %g\" % (np.min(tvals),np.max(tvals))\n",
    "print \"min / max = %g / %g\" % (tvals.min(),tvals.max())\n",
    "print \"average = \",np.average(tvals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a contour plot using PyNGL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from plot_ts_Amon_ngl import *\n",
    "plot_ts_Amon_ngl(ts,lat,lon)\n",
    "from IPython.display import Image\n",
    "Image(filename='plot_ts_Amon.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subset \"ts\" using coordinate subscripting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ts  = f.variables[\"ts\"]['time|i0 lat|0:60 lon|45:135']\n",
    "print ts.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise: use coordinate subscripting to subscript lat/lon arrays using the same lat/lon range as \"ts\", and plot using \"plot_ts_Amon_subset_ngl\".\n",
    "(Note: the plotting code will be similar to the one above, but the routine name and the PNG file name are different.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Open a WRF output file with a curvilinear grid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import required modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import Nio as nio\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Open the file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Don't forget to add the \".nc\"\n",
    "filename=\"../Data/wrfout_d03_2012-04-22_23_00_00.nc\"\n",
    "f = nio.open_file(filename)\n",
    "#print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Print all the variables on the file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "vnames = f.variables.keys()\n",
    "print vnames"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read \"HGT\" variable off file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "h = f.variables[\"HGT\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Print some information about \"h\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print \"type\",type(h)\n",
    "print \"dimension sizes\",h.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Print attributes and dimension names of \"h\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print \"Attributes\",     h.attributes\n",
    "print \"Dimension names\",h.dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing individual attributes and dimension names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print \"Variable is %s (%s)\" % (h.description,h.units)\n",
    "print \"Name of dimension 0 is\", h.dimensions[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use [:] to access values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "hvals = h[:]             # Reads all dimensions, all values\n",
    "print \"type\",type(hvals)\n",
    "print \"shape\",hvals.shape\n",
    "print \"dtype = %s\" % hvals.dtype\n",
    "print hvals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Two ways to get the min/max\n",
    "print \"min / max = %g / %g\" % (np.min(hvals),np.max(hvals))\n",
    "print \"min / max = %g / %g\" % (hvals.min(),hvals.max())\n",
    "print \"average = \",np.average(hvals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reread \"hgt\" variable as numpy array\n",
    "\"h\" is a 3D variable (time,lat,lon), so be sure to subscript it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "h = f.variables[\"HGT\"][0,:,:]\n",
    "print \"type(h)\",type(h)\n",
    "print \"h.shape\",h.shape\n",
    "print h.min(),h.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create a color contour plot using PyNGL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from wrf_plot_ngl import *\n",
    "wrf_plot_var(h,contour_type=\"raster\")\n",
    "#wrf_plot_from_file(filename,\"HGT\",contour_type=\"raster\")\n",
    "from IPython.display import Image\n",
    "Image(filename='wrfplot.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create a contour plot using matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from wrf_plot_hgt_mpl import WRF_Plotter\n",
    "wplt = WRF_Plotter(fname = \"../Data/wrfout_d03_2012-04-22_23_00_00\", vname = \"HGT\")\n",
    "wplt.plot(varname = 'HGT')\n",
    "wplt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: read and plot \"T2\" using wrf_plot_from_file, or wrf_plot_var, or wrf_plot_T2_mpl to plot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Examine an HDF-EOS file with missing data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import required modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import Nio as nio\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename=\"../Data/MOD06_L2.A2010031.1430.005.2010031221343.hdf\"\n",
    "f = nio.open_file(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read \"Cloud_Top_Temperature\" and print some information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ctt = f.variables[\"Cloud_Top_Temperature\"]\n",
    "print ctt.shape\n",
    "print ctt\n",
    "print \"min/max CTT = %g / %g\" % (np.min(ctt[:]) ,np.max(ctt[:]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note the \"scale_factor\" and \"add_offset\" attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print \"scale_factor\",ctt.scale_factor\n",
    "print \"add_offset\",ctt.add_offset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Apply these attributes to unpack the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cttf = ctt.scale_factor * (ctt[:] - ctt.add_offset)\n",
    "\n",
    "print \"min/max CTT = %g / %g\" % (np.min(cttf) ,np.max(cttf))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What happens if we take the average?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print \"average = \",np.average(cttf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note that cttf has a fill value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print ctt._FillValue         # This is a NioVariable\n",
    "print cttf.get_fill_value()  # This is a MaskedArray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### You can test for a MaskedArray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print \"Is cttf a MaskedArray?\",isinstance(cttf, np.ma.MaskedArray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We have a masked array, so use \"ma\" module to take average"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy.ma as ma\n",
    "print \"average = \",ma.average(cttf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### This will work too"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print \"average = \",cttf.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a color contour plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from plot_ctt_ngl import *\n",
    "\n",
    "# Read lat/lon off the file for plotting                                                  \n",
    "lat = f.variables[\"Latitude\"][:]\n",
    "lon = f.variables[\"Longitude\"][:]\n",
    "\n",
    "title = \"%s (%s)\" % (ctt.hdf_name,ctt.units)\n",
    "msg_val = float(ctt._FillValue)\n",
    "plot_ctt(cttf,msg_val,lat,lon)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "Image(filename='ctt_plot.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Open WRF output file and read some variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy, Nio, Ngl, os\n",
    "\n",
    "filename = \"../Data/wrfout_d03_2012-04-22_23_00_00.nc\"\n",
    "f  = Nio.open_file(filename,\"w\")      # Open WRF output file as \"write\"\n",
    "T  = f.variables[\"T\"]                 # potential temperature\n",
    "P  = f.variables[\"P\"]                 # perturbation pressure\n",
    "PB = f.variables[\"PB\"]                # base pressure\n",
    "print T     # These are NioVariable objects\n",
    "print P\n",
    "print PB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate temperature from T, P, PB using \"wrf_tk\" function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "THETA = T[:] + 300          # perturbation + reference temperature\n",
    "PPB   = P[:] + PB[:]\n",
    "TK    = Ngl.wrf_tk(PPB, THETA)\n",
    "\n",
    "print \"TK min/max = %g / %g\" % (numpy.min(TK[:]),numpy.max(TK[:]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Write TK to same NetCDF file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define variable on file using another variable's dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "new_var_name = \"TK\"\n",
    "f.create_variable(new_var_name,'d',T.dimensions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write attributes of variable to file, changing \"description\" and \"units\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "varAtts = T.__dict__.keys()    # Get all of T's attributes\n",
    "varAtts.sort()\n",
    "for att in varAtts:\n",
    "    if att is \"description\":\n",
    "        value = \"Temperature\"\n",
    "    elif att is \"units\":\n",
    "        value = \"degK\"      # Better than just \"K\"\n",
    "    else:\n",
    "        value = getattr(T,att)\n",
    "        \n",
    "    setattr(f.variables[new_var_name],att,value)   # Write attribute and value to file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write data values to file and close it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "f.variables[new_var_name].assign_value(TK)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reopen file and print it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "f2 = Nio.open_file(filename,\"r\")\n",
    "print f2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read TK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tk = f2.variables[\"TK\"]\n",
    "print \"TK after reading back in: %g / %g\" % (numpy.min(tk[:]),numpy.max(tk[:]))\n",
    "print TK.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot TK directly from file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from wrf_plot_ngl import *\n",
    "wrf_plot_from_file(filename,\"TK\")\n",
    "from IPython.display import Image\n",
    "Image(filename='wrfplot.png')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.1"
  },
  "name": "_merged"
 },
 "nbformat": 4,
 "nbformat_minor": 1
}