lecture-11.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{u'start_slideshow_at': 'selected', u'theme': 'sky', u'transition': 'zoom'}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.html.services.config import ConfigManager\n",
    "from IPython.utils.path import locate_profile\n",
    "cm = ConfigManager(profile_dir=locate_profile(get_ipython().profile))\n",
    "cm.update('livereveal', {\n",
    "              'theme': 'sky',\n",
    "              'transition': 'zoom',\n",
    "              'start_slideshow_at': 'selected',\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#Lecture 11. Going fast: the Barnes-Hut algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Previous lecture \n",
    "- Discretization of the integral equations, Galerkin methods\n",
    "- Computation of singular integrals\n",
    "- Idea of the Barnes-Hut method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Todays lecture\n",
    "- Barnes-Hut in details\n",
    "- The road to the FMM\n",
    "- Algebraic versions of the FMM/Fast Multipole"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The discretization of the integral equation leads to **dense matrices**.  \n",
    "\n",
    "The main question is how to compute the **matrix-by-vector product**, \n",
    "\n",
    "i.e. the summation of the form:\n",
    "\n",
    "$$\\sum_{j=1}^M A_{ij} q_j = V_i, \\quad i = 1, \\ldots, N.$$\n",
    "\n",
    "The matrix $A$ is **dense**, i.e. its element can not be omitted. The complexity is $\\mathcal{O}(N^2)$.  \n",
    "\n",
    "Can we make it faster?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The simplest case is the computation of the **potentials** from the **system of charges**\n",
    "\n",
    "\n",
    "$$V_i = \\sum_{j} \\frac{q_j}{\\Vert r_i - r_j \\Vert}$$\n",
    "\n",
    "This summation appears in:\n",
    "\n",
    "- Modelling of large systems of charges\n",
    "- Astronomy (where instead of $q_j$ we have **masses**, i.e. start..)\n",
    "\n",
    "It is called <font color='red'> the N-body problem </font>.  \n",
    "\n",
    "There is no problem with memory, since you only have two cycles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "from numba import jit\n",
    "N = 10000\n",
    "x = np.random.randn(N, 2);\n",
    "y = np.random.randn(N, 2);\n",
    "charges = np.ones(N)\n",
    "res = np.zeros(N)\n",
    "\n",
    "\n",
    "@jit\n",
    "def compute_nbody_direct(N, x, y, charges, res):\n",
    "    for i in xrange(N):\n",
    "        res[i] = 0.0\n",
    "        for j in xrange(N):\n",
    "            dist = (x[i, 0] - y[i, 0]) ** 2 + (x[i, 1] - y[i, 1]) ** 2\n",
    "            dist = math.sqrt(dist)\n",
    "            res[i] += charges[j] / dist\n",
    "                    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 loops, best of 3: 976 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit compute_nbody_direct(N, x, y, charges, res)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question\n",
    "What is the typical size of particle system?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Millenium run\n",
    "One of the most famous N-body computations is the [Millenium run](http://en.wikipedia.org/wiki/Millennium_Run)\n",
    "\n",
    "- More than 10 billions particles ($2000^3$)\n",
    "- $>$ **1 month** of computations, **25 Terabytes** of storage\n",
    "- Each \"particle\" represents approximately a billion solar masses of dark matter\n",
    "- Study, how the matter is distributed through the Universy (cosmology)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"400\"\n",
       "            height=\"300\"\n",
       "            src=\"https://www.youtube.com/embed/UC5pDPY5Nz4\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x1042c4510>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "\n",
    "YouTubeVideo('UC5pDPY5Nz4')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Smoothed particle hydrodynamics\n",
    "The particle systems can be used to model a lot of things. \n",
    "\n",
    "For nice examples, see the website of [Ron Fedkiw](http://physbam.stanford.edu/~fedkiw/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"400\"\n",
       "            height=\"300\"\n",
       "            src=\"https://www.youtube.com/embed/6bdIHFTfTdU\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x10483fe90>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "\n",
    "YouTubeVideo('6bdIHFTfTdU')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Applications\n",
    "Where the N-body problem arises in different problems with **long-range** interactions`\n",
    "- Cosmology (interacting masses)\n",
    "- Electrostatics (interacting charges)\n",
    "- Molecular dynamics (more complicated interactions, maybe even 3-4 body terms).\n",
    "- Particle modelling (**smoothed particle hydrodynamics**)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Fast computation\n",
    "$$\n",
    "   V_i = \\sum_{j} \\frac{q_j}{\\Vert x_i - y_j \\Vert}\n",
    "$$\n",
    "\n",
    "Direct computation takes $\\mathcal{O}(N^2)$ operations.\n",
    "\n",
    "How to compute it fast?\n",
    "\n",
    "The core idea: Barnes, Hut (Nature, 1986) \n",
    "\n",
    "Use clustering of particles!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Idea on one slide\n",
    "The idea was simple:\n",
    "If a charge is far from a cluster of sources, it they are seen as one big \"particle\". \n",
    "\n",
    "<img src=\"earth-andromeda.jpeg\" width = 70%>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Barnes-Hut\n",
    "\n",
    "$$\\sum_j q_j F(x, y_j) \\approx Q F(x, y_C)$$\n",
    "\n",
    "$$Q = \\sum_j q_j, \\quad y_C = \\frac{1}{J} \\sum_{j} y_j$$\n",
    "\n",
    "To compute the interaction, it is sufficient to replace by the a center-of-mass and a total mass!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The idea of Barnes and Hut was to split the <font color='red'>  sources </font> into big blocks using the <font color='red'> cluster tree </font>\n",
    "\n",
    "<img width=90% src='clustertree.png'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The algorithm is recursive.\n",
    "Let $\\mathcal{T}$ be the tree, and $x$ is the point where we need to\n",
    "compute the potential.\n",
    "\n",
    "- Set $N$ to the <font color='red'> root node </font>\n",
    "- If $x$ and $N$ <font color='red'> are separated </font> , then  set $V(x) = Q V(y_{\\mathrm{center}})$\n",
    "- If $x$ and $N$ are not separated, compute $V(x) = \\sum_{C \\in\n",
    "  \\mathrm{sons}(N)} V(C, x)$ <font color='red'> recursion </font>\n",
    "\n",
    "The complexity is $\\mathcal{O}(\\log N)$ for 1 point!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Trees \n",
    "There are many options for the **tree** construction.\n",
    "\n",
    "- Quadtree/Octree\n",
    "- KD-tree\n",
    "- Recursive intertial bisection\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Octtree\n",
    "The simplest one: **quadtree/ octtree, when you split the square into 4 squares and do that until the number of points is less that a parameter.  \n",
    "\n",
    "\n",
    "It leads to the unbalanced tree, adding points is simple (but can unbalance it more).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## KD-tree\n",
    "Another popular choice of the tree is the KD-tree\n",
    "\n",
    "The construction is simple as well:  \n",
    "\n",
    "Split along x-axis, then y-axis in such a way that the tree is **balanced** (i.e. the number of points in the left child/right child is similar).\n",
    "\n",
    "The tree is always balanced, but biased towards the coordinate axis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Recursive inertial bisection\n",
    "\n",
    "Compute the center-of-mass and select a hyperplane such that sum of squares of distances to it is minimal.\n",
    "\n",
    "$$\\sum_{j} \\rho^2(x_j, \\Pi) \\rightarrow \\min.$$\n",
    "\n",
    "Often gives best complexity, but adding/removing points can be difficult."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The scheme \n",
    "You can actually code it from this description!\n",
    "\n",
    "- Construct the cluster tree\n",
    "- Fill the tree with charges\n",
    "- For any point we now can compute the potential in $\\mathcal{O}(\\log N)$ flops (instead of $\\mathcal{O}(N)$).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Notes on the complexity\n",
    "\n",
    "For each node of the tree, we need to compute its total mass and the center-of-mass. If we do it in a cycle, then the complexity will be $\\mathcal{O}(N^2)$ for the tree constuction.  \n",
    "\n",
    "However, it is easy to construct it in a smarter way.\n",
    "\n",
    "- Start from the children (which contain only few particles) and fill then\n",
    "- Bottom-to-top graph traversal: if we know the charges for the children, we can cheaply compute the total charge/center of massfor the father\n",
    "\n",
    "Now you can actually code this (minor things remaining are the **bounding box** and separation criteria)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Problems with Barnes-Hut\n",
    "What are the problems with Barnes-Hut?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Well, several\n",
    "- The logarithmic term \n",
    "- Low accuracy $\\varepsilon = 10^{-2}$ is ok, but if we want $\\varepsilon=10^{-5}$\n",
    "  we have to take larger <font color='red'> separation criteria </font>  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Solving problems with Barnes-Hut\n",
    "- **Complexity**: To avoid the logarithmic term, we need to store two trees, for the sources, and for receivers\n",
    "- **Accuracy**: instead of the <font color='red'> piecewise-constant approximation </font> which is inheritant in the BH algorithm, use more accurate representations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Double tree Barnes-Hut\n",
    "Principal scheme of the Double-tree BH:\n",
    "\n",
    "- Construct **two trees** for sources & receivers\n",
    "- Fill the tree for sources with charges (bottom-to-top)\n",
    "- Compute the interaction between **nodes** of the treess\n",
    "- Fill the tree for receivers with potentials (top-to-bottom)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The original BH method has low accuracy, and is based on the expansion  \n",
    "\n",
    "$$f(x, y) \\approx f(x_0, y_0)$$  \n",
    "\n",
    "**What to do?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Answer:** Use higher-order expansions!\n",
    "\n",
    "$$f(x + \\delta x, y + \\delta y) \\approx f(x, y) + \\sum_{k, l=0}^p\n",
    "(D^{k} D^{l} f)  \\delta ^k\n",
    "\\delta y^l \\frac{1}{k!} \\frac{1}{l!} + \\ldots\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "For the Coloumb interaction $\\frac{1}{r}$ we have the **multipole expansion**\n",
    "\n",
    "$$\n",
    "     v(R) = \\frac{Q}{R} + \\frac{1}{R^3} \\sum_{\\alpha} P_{\\alpha} R_{\\alpha} + \\frac{1}{6R^5} \\sum_{\\alpha, \\beta} Q_{\\alpha \\beta} (3R_{\\alpha \\beta} - \\delta_{\\alpha \\beta}R^2) + \\ldots,\n",
    "$$\n",
    "\n",
    "where $P_{\\alpha}$ is the **dipole moment**, $Q_{\\alpha \\beta}$ is the **quadrupole moment** (by actually, nothing more than the Taylor series expansion)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Fast multipole method\n",
    "\n",
    "This combination is very powerful, and \n",
    "\n",
    "\n",
    "<font color='red' size=6.0> Double tree + multipole expansion $\\approx$ the Fast Multipole Method (FMM).  </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## FMM\n",
    "We will talk about the exact implementation and the complexity issues in the next lecture."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Problems with FMM\n",
    "\n",
    "FMM has problems:\n",
    "- It relies on analytic expansions; maybe difficult to obtain for the integral equations\n",
    "- the higher is the order of the expansion, the larger is the complexity.\n",
    "- That is why the **algebraic interpretation** (or kernel-independent FMM) is of great importance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## FMM hardware\n",
    "\n",
    "For cosmology this problem is so important, so that they have released a special hardware [Gravity Pipe](http://en.wikipedia.org/wiki/Gravity_Pipe) for solving the N-body problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##FMM software\n",
    "**Sidenote**, When you Google for \"FMM\", you will also encounter **fast marching method** (even in the scikit).\n",
    "\n",
    "Everyone uses its own **in-house** software, so a good Python open-source software is yet to be written.  \n",
    "\n",
    "This is also a perfect test for the **GPU** programming (you can try to take such project in the App Period, by the way).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Overview of todays lecture\n",
    "\n",
    "- The cluster tree\n",
    "- Barnes-Hut and its problems\n",
    "- Double tree / fast multipole method\n",
    "- **Important difference**: element evaluation is **fast**. In integral equations, it is **slow**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Next lecture\n",
    "- More detailed overview of the FMM algorithm, along with complexity estimates.\n",
    "- Algebraic interpretation of the FMM\n",
    "- Application of the FMM to the solution of integral equations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n",
       "<style>\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "    }\n",
       "    div.cell{\n",
       "        /*width:80%;*/\n",
       "        /*margin-left:auto !important;\n",
       "        margin-right:auto;*/\n",
       "    }\n",
       "    h1 {\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "    }\n",
       "    h2 {\n",
       "        font-family: 'Fenix', serif;\n",
       "    }\n",
       "    h3{\n",
       "\t\tfont-family: 'Fenix', serif;\n",
       "        margin-top:12px;\n",
       "        margin-bottom: 3px;\n",
       "       }\n",
       "\th4{\n",
       "\t\tfont-family: 'Fenix', serif;\n",
       "       }\n",
       "    h5 {\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "    }\t   \n",
       "    div.text_cell_render{\n",
       "        font-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n",
       "        line-height: 1.2;\n",
       "        font-size: 100%;\n",
       "        /*width:70%;*/\n",
       "        /*margin-left:auto;*/\n",
       "        margin-right:auto;\n",
       "    }\n",
       "    .CodeMirror{\n",
       "            font-family: \"Source Code Pro\";\n",
       "\t\t\tfont-size: 90%;\n",
       "    }\n",
       "/*    .prompt{\n",
       "        display: None;\n",
       "    }*/\n",
       "    .text_cell_render h1 {\n",
       "        font-weight: 200;\n",
       "        font-size: 50pt;\n",
       "\t\tline-height: 100%;\n",
       "        color:#CD2305;\n",
       "        margin-bottom: 0.5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\t\n",
       "    .text_cell_render h5 {\n",
       "        font-weight: 300;\n",
       "        font-size: 16pt;\n",
       "        color: #CD2305;\n",
       "        font-style: italic;\n",
       "        margin-bottom: .5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\n",
       "    \n",
       "    li {\n",
       "        line-height: 100%;\n",
       "    }\n",
       "    .warning{\n",
       "        color: rgb( 240, 20, 20 )\n",
       "        }  \n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"]\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
       "                }\n",
       "        });\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "def css_styling():\n",
    "    styles = open(\"./styles/alex.css\", \"r\").read()\n",
    "    return HTML(styles)\n",
    "css_styling()"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}