17_PDEs_waves/17_PDEs_waves-students.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 17 PDEs: Waves – Students\n",
    "\n",
    "(See *Computational Physics* Ch 21 and *Computational Modeling* Ch 6.5.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Background: waves on a string\n",
    "\n",
    "Assume a 1D string of length $L$ with mass density per unit length $\\rho$ along the $x$ direction. It is held under constant tension $T$ (force per unit length). Ignore frictional forces and the tension is so high that we can ignore sagging due to gravity.\n",
    "\n",
    "\n",
    "### 1D wave equation\n",
    "The string is displaced in the $y$ direction from its rest position, i.e., the displacement $y(x, t)$ is a function of space $x$ and time $t$.\n",
    "\n",
    "For small relative displacements $y(x, t)/L \\ll 1$ and therefore small slopes $\\partial y/\\partial x$ we can describe $y(x, t)$ with a *linear* equation of motion:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Newton's second law applied to short elements of the string with length $\\Delta x$ and mass $\\Delta m = \\rho \\Delta x$: the left hand side contains the *restoring force* that opposes the displacement, the right hand side is the acceleration of the string element:\n",
    "\n",
    "\\begin{align}\n",
    "\\sum F_{y}(x) &= \\Delta m\\, a(x, t)\\\\\n",
    "T \\sin\\theta(x+\\Delta x) - T \\sin\\theta(x) &= \\rho \\Delta x \\frac{\\partial^2 y(x, t)}{\\partial t^2}\n",
    "\\end{align}\n",
    "\n",
    "The angle $\\theta$ measures by how much the string is bent away from the resting configuration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because we assume small relative displacements, the angles are small ($\\theta \\ll 1$) and we can make the small angle approximation\n",
    "\n",
    "$$\n",
    "\\sin\\theta \\approx \\tan\\theta = \\frac{\\partial y}{\\partial x}\n",
    "$$\n",
    "\n",
    "and hence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{align}\n",
    "T \\left.\\frac{\\partial y}{\\partial x}\\right|_{x+\\Delta x} - T \\left.\\frac{\\partial y}{\\partial x}\\right|_{x}  &= \\rho \\Delta x \\frac{\\partial^2 y(x, t)}{\\partial t^2}\\\\\n",
    "\\frac{T \\left.\\frac{\\partial y}{\\partial x}\\right|_{x+\\Delta x} - T \\left.\\frac{\\partial y}{\\partial x}\\right|_{x}}{\\Delta x} &= \\rho \\frac{\\partial^2 y}{\\partial t^2}\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or in the limit $\\Delta x \\rightarrow 0$ a linear hyperbolic PDE results:\n",
    "\n",
    "\\begin{gather}\n",
    "\\frac{\\partial^2 y(x, t)}{\\partial x^2} = \\frac{1}{c^2} \\frac{\\partial^2 y(x, t)}{\\partial t^2}, \\quad c = \\sqrt{\\frac{T}{\\rho}}\n",
    "\\end{gather}\n",
    "\n",
    "where $c$ has the dimension of a velocity. This is the (linear) **wave equation**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### General solution: waves "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "General solutions are propagating waves:\n",
    "\n",
    "If $f(x)$ is a solution at $t=0$ then\n",
    "\n",
    "$$\n",
    "y_{\\mp}(x, t) = f(x \\mp ct)\n",
    "$$\n",
    "\n",
    "are also solutions at later $t > 0$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because of linearity, any linear combination is also a solution, so the most general solution contains both right and left propagating waves\n",
    "\n",
    "$$\n",
    "y(x, t) = A f(x - ct) + B g(x + ct)\n",
    "$$\n",
    "\n",
    "(If $f$ and/or $g$ are present depends on the initial conditions.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In three dimensions the wave equation is\n",
    "\n",
    "$$\n",
    "\\boldsymbol{\\nabla}^2 y(\\mathbf{x}, t) - \\frac{1}{c^2} \\frac{\\partial^2 y(\\mathbf{x}, t)}{\\partial t^2} = 0\\\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boundary and initial conditions "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The boundary conditions could be that the ends are fixed \n",
    "\n",
    "  $$y(0, t) = y(L, t) = 0$$\n",
    "  \n",
    "* The *initial condition* is a shape for the string, e.g., a Gaussian at the center\n",
    "\n",
    "  $$\n",
    "  y(x, t=0) = g(x) = y_0 \\frac{1}{\\sqrt{2\\pi\\sigma}} \\exp\\left[-\\frac{(x - x_0)^2}{2\\sigma^2}\\right]\n",
    "  $$ \n",
    "  \n",
    "  at time 0.\n",
    "* Because the wave equation is *second order in time* we need a second initial condition, for instance, the string is released from rest: \n",
    "\n",
    "  $$\n",
    "  \\frac{\\partial y(x, t=0)}{\\partial t} = 0\n",
    "  $$\n",
    "\n",
    "  (The derivative, i.e., the initial displacement velocity is provided.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analytical solution\n",
    "Solve (as always) with *separation of variables*.\n",
    "\n",
    "$$\n",
    "y(x, t) = X(x) T(t)\n",
    "$$\n",
    "\n",
    "and this yields the general solution (with boundary conditions of fixed string ends and initial condition of zero velocity) as a superposition of normal modes\n",
    "\n",
    "$$\n",
    "y(x, t) = \\sum_{n=0}^{+\\infty} B_n \\sin k_n x\\, \\cos\\omega_n t,\n",
    "\\quad \\omega_n = ck_n,\\ k_n = n \\frac{2\\pi}{L} = n k_0.\n",
    "$$\n",
    "\n",
    "(The angular frequency $\\omega$ and the wave vector $k$ are determined from the boundary conditions.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The coefficients $B_n$ are obtained from the initial shape:\n",
    "\n",
    "$$\n",
    "y(x, t=0) = \\sum_{n=0}^{+\\infty} B_n \\sin n k_0 x = g(x)\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In principle one can use the fact that $\\int_0^L dx \\sin m k_0 x \\, \\sin n k_0 x = \\pi \\delta_{mn}$ (orthogonality) to calculate the coefficients:\n",
    "\n",
    "\\begin{align}\n",
    "\\int_0^L dx \\sin m k_0 x \\sum_{n=0}^{+\\infty} B_n \\sin n k_0 x &= \\int_0^L dx \\sin(m k_0 x) \\, g(x)\\\\\n",
    "\\pi \\sum_{n=0}^{+\\infty} B_n \\delta_{mn} &= \\dots \\\\\n",
    "B_m &= \\pi^{-1} \\dots\n",
    "\\end{align}\n",
    "\n",
    "(but the analytical solution is ugly and I cannot be bothered to put it down here.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numerical solution\n",
    "\n",
    "1. discretize wave equation\n",
    "2. time stepping: leap frog algorithm (iterate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the central difference approximation for the second order derivatives:\n",
    "\n",
    "\\begin{align}\n",
    "\\frac{\\partial^2 y}{\\partial t^2} &\\approx \\frac{y(x, t+\\Delta t) + y(x, t-\\Delta t) - 2y(x, t)}{\\Delta t ^2} = \\frac{y_{i, j+1} + y_{i, j-1} - 2y_{i,j}}{\\Delta t^2}\\\\\n",
    "\\frac{\\partial^2 y}{\\partial x^2} &\\approx \\frac{y(x+\\Delta x, t) + y(x-\\Delta x, t) - 2y(x, t)}{\\Delta x ^2} = \\frac{y_{i+1, j} + y_{i-1, j} - 2y_{i,j}}{\\Delta x^2}\n",
    "\\end{align}\n",
    "\n",
    "and substitute into the wave equation to yield the *discretized* wave equation:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\frac{y_{i+1, j} + y_{i-1, j} - 2y_{i,j}}{\\Delta x^2} = \\frac{1}{c^2} \\frac{y_{i, j+1} + y_{i, j-1} - 2y_{i,j}}{\\Delta t^2}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Student activity: derive the finite difference version of the 1D wave equation\n",
    "Re-arrange so that the future terms $j+1$ can be calculated from the present $j$ and past $j-1$ terms:\n",
    "\n",
    "$$\n",
    "? = ?\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use $\\beta := \\frac{c}{\\Delta x/\\Delta t}$ to write your solution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the time stepping algorithm for the wave equation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numerical implementation \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "plt.style.use('ggplot')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement the time stepping algorithm in the code below. Look for sections `# TODO`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "L = 0.5  # m\n",
    "Nx = 50\n",
    "Nt = 100\n",
    "\n",
    "Dx = L/Nx\n",
    "# TODO: choose Dt\n",
    "Dt =   # s\n",
    "\n",
    "rho = 1.5e-2   # kg/m\n",
    "tension = 150  # N\n",
    "\n",
    "# TODO: calculate c\n",
    "c = \n",
    "\n",
    "# TODO: calculate beta\n",
    "beta = \n",
    "beta2 = \n",
    "\n",
    "print(\"c = {0} m/s\".format(c))\n",
    "print(\"Dx = {0} m,  Dt = {1} s, Dx/Dt = {2} m/s\".format(Dx, Dt, Dx/Dt))\n",
    "print(\"beta = {}\".format(beta))\n",
    "\n",
    "X = np.linspace(0, L, Nx+1)  # need N+1!\n",
    "\n",
    "def gaussian(x, y0=0.05, x0=L/2, sigma=0.1*L):\n",
    "    return y0/np.sqrt(2*np.pi*sigma) * np.exp(-(x-x0)**2/(2*sigma**2))\n",
    "\n",
    "# displacements at j-1, j, j+1\n",
    "y0 = np.zeros_like(X)\n",
    "y1 = np.zeros_like(y0)\n",
    "y2 = np.zeros_like(y0)\n",
    "\n",
    "# save array\n",
    "y_t = np.zeros((Nt+1, Nx+1))\n",
    "\n",
    "# boundary conditions\n",
    "# TODO: set boundary conditions\n",
    "y2[:] = y0\n",
    "\n",
    "# initial conditions: velocity 0, i.e. no difference between y0 and y1\n",
    "y0[1:-1] = y1[1:-1] = gaussian(X)[1:-1]\n",
    "\n",
    "# save initial\n",
    "t_index = 0\n",
    "y_t[t_index, :] = y0\n",
    "t_index += 1\n",
    "y_t[t_index, :] = y1\n",
    "\n",
    "for jt in range(2, Nt):\n",
    "    # TODO: time stepping algorithm\n",
    "    \n",
    "    t_index += 1\n",
    "    y_t[t_index, :] = y2       \n",
    "    print(\"Iteration {0:5d}\".format(jt), end=\"\\r\")\n",
    "else:\n",
    "    print(\"Completed {0:5d} iterations: t={1} s\".format(jt, jt*Dt))\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1D plot\n",
    "Plot the output in the save array `y_t`. Vary the time steps that you look at with `y_t[start:end]`.\n",
    "\n",
    "We indicate time by color changing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = plt.subplot(111)\n",
    "ax.set_prop_cycle(\"color\", [plt.cm.viridis_r(i) for i in np.linspace(0, 1, len(y_t))])\n",
    "ax.plot(X, y_t.T);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1D Animation\n",
    "For 1D animation to work in a Jupyter notebook, use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib widget"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If no animations are visible, restart kernel and execute the `%matplotlib widegt` cell as the very first one in the notebook.(You also need the `ipympl` python package – install with `conda install ipympl` before launching Jupyter.)\n",
    "\n",
    "We use `matplotlib.animation` to look at movies of our solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.animation as animation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `update_wave()` function simply re-draws our image for every `frame`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "y_limits = 1.05*y_t.min(), 1.05*y_t.max()\n",
    "\n",
    "fig1 = plt.figure(figsize=(5,5))\n",
    "ax = fig1.add_subplot(111)\n",
    "ax.set_aspect(1)\n",
    "\n",
    "def update_wave(frame, data):\n",
    "    global ax, Dt, y_limits\n",
    "    ax.clear()\n",
    "    ax.set_xlabel(\"x (m)\")\n",
    "    ax.set_ylabel(\"y (m)\")\n",
    "    ax.plot(X, data[frame])\n",
    "    ax.set_ylim(y_limits)\n",
    "    ax.text(0.1, 0.9, \"t = {0:3.1f} ms\".format(frame*Dt*1e3), transform=ax.transAxes)\n",
    "\n",
    "wave_anim = animation.FuncAnimation(fig1, update_wave, frames=len(y_t), fargs=(y_t,), \n",
    "                                    interval=30, blit=True, repeat_delay=100)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3D plot\n",
    "(Uses functions from previous lessons.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_y(y_t, Dt, Dx, step=1):\n",
    "    T, X = np.meshgrid(range(y_t.shape[0]), range(y_t.shape[1]))\n",
    "    Y = y_t.T[X, T]    # intepret index 0 as \"t\" and index 1 as \"x\", but plot x along axis 1 and t along axis 2\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111, projection=\"3d\")\n",
    "    ax.plot_wireframe(X*Dx, T*Dt*step, Y)\n",
    "    ax.set_ylabel(r\"time $t$ (s)\")\n",
    "    ax.set_xlabel(r\"position $x$ (m)\")\n",
    "    ax.set_zlabel(r\"displacement $y$ (m)\")\n",
    "    fig.tight_layout()\n",
    "    return ax\n",
    "\n",
    "def plot_surf(y_t, Dt, Dx, step=1, filename=None, offset=-1, zlabel=r'displacement',\n",
    "             elevation=40, azimuth=-20, cmap=plt.cm.coolwarm):\n",
    "    \"\"\"Plot y_t as a 3D plot with contour plot underneath.\n",
    "    \n",
    "    Arguments\n",
    "    ---------\n",
    "    y_t : 2D array\n",
    "          displacement y(t, x)\n",
    "    filename : string or None, optional (default: None)\n",
    "          If `None` then show the figure and return the axes object.\n",
    "          If a string is given (like \"contour.png\") it will only plot \n",
    "          to the filename and close the figure but return the filename.\n",
    "    offset : float, optional (default: 20)\n",
    "          position the 2D contour plot by offset along the Z direction\n",
    "          under the minimum Z value\n",
    "    zlabel : string, optional\n",
    "          label for the Z axis and color scale bar\n",
    "    elevation : float, optional\n",
    "          choose elevation for initial viewpoint\n",
    "    azimuth : float, optional\n",
    "          chooze azimuth angle for initial viewpoint\n",
    "    \"\"\"\n",
    "     \n",
    "    t = np.arange(y_t.shape[0], dtype=int)\n",
    "    x = np.arange(y_t.shape[1], dtype=int)\n",
    "    T, X = np.meshgrid(t, x)\n",
    "    Y = y_t.T[X, T]\n",
    "    \n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "    surf = ax.plot_surface(X*Dx, T*Dt*step, Y, cmap=cmap, rstride=1, cstride=1, alpha=1)\n",
    "    cset = ax.contourf(X*Dx, T*Dt*step, Y, 20, zdir='z', offset=offset+Y.min(), cmap=cmap)\n",
    "\n",
    "    ax.set_xlabel('x')\n",
    "    ax.set_ylabel('t')\n",
    "    ax.set_zlabel(zlabel)\n",
    "    ax.set_zlim(offset + Y.min(), Y.max())\n",
    "    \n",
    "    ax.view_init(elev=elevation, azim=azimuth)\n",
    "\n",
    "    cb = fig.colorbar(surf, shrink=0.5, aspect=5)\n",
    "    cb.set_label(zlabel)\n",
    "    \n",
    "    if filename:\n",
    "        fig.savefig(filename)\n",
    "        plt.close(fig)\n",
    "        return filename\n",
    "    else:\n",
    "        return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_y(y_t, Dt, Dx, step)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_surf(y_t, Dt, Dx, step, offset=0, cmap=plt.cm.coolwarm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## von Neumann stability analysis: Courant condition "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assume that the solutions of the discretized equation can be written as normal modes\n",
    "\n",
    "$$\n",
    "y_{m,j} = \\xi(k)^j e^{ikm\\Delta x}, \\quad t=j\\Delta t,\\ x=m\\Delta x \n",
    "$$\n",
    "\n",
    "The time stepping algorith is stable if\n",
    "\n",
    "$$\n",
    "|\\xi(k)| < 1\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insert normal modes into the discretized equation \n",
    "\n",
    "\n",
    "$$\n",
    "y_{i,j+1} = 2(1 - \\beta^2)y_{i,j} - y_{i, j-1} + \\beta^2 (y_{i+1,j} + y_{i-1,j}), \\quad \n",
    "\\beta := \\frac{c}{\\Delta x/\\Delta t}\n",
    "$$\n",
    "\n",
    "and simplify (use $1-\\cos x = 2\\sin^2\\frac{x}{2}$):\n",
    "\n",
    "$$\n",
    "\\xi^2 - 2(1-2\\beta^2 s^2)\\xi + 1 = 0, \\quad s=\\sin(k\\Delta x/2)\n",
    "$$\n",
    "\n",
    "The characteristic equation has roots\n",
    "\n",
    "$$\n",
    "\\xi_{\\pm} = 1 - 2\\beta^2 s^2 \\pm \\sqrt{(1-2\\beta^2 s^2)^2 - 1}.\n",
    "$$\n",
    "\n",
    "It has one root for \n",
    "\n",
    "$$\n",
    "\\left|1-2\\beta^2 s^2\\right| = 1,\n",
    "$$\n",
    "\n",
    "i.e., for\n",
    "\n",
    "$$\n",
    "\\beta s = 1\n",
    "$$\n",
    "\n",
    "We have two real roots for \n",
    "\n",
    "$$\n",
    "\\left|1-2\\beta^2 s^2\\right| < 1 \\\\\n",
    "\\beta s > 1\n",
    "$$\n",
    "\n",
    "but one of the roots is always $|\\xi| > 1$ and hence these solutions will diverge and not be stable.\n",
    "\n",
    "For \n",
    "\n",
    "$$\n",
    "\\left|1-2\\beta^2 s^2\\right| ≥ 1 \\\\\n",
    "\\beta s ≤ 1\n",
    "$$\n",
    "\n",
    "the roots will be *complex conjugates of each other*\n",
    "\n",
    "$$\n",
    "\\xi_\\pm = 1 - 2\\beta^2s^2 \\pm i\\sqrt{1-(1-2\\beta^2s^2)^2}\n",
    "$$\n",
    "\n",
    "and the *magnitude*\n",
    "\n",
    "$$\n",
    "|\\xi_{\\pm}|^2 =  (1 - 2\\beta^2s^2)^2 - (1-(1-2\\beta^2s^2)^2) = 1\n",
    "$$\n",
    "\n",
    "is unity: Thus the solutions will not grow and will be *stable* for\n",
    "\n",
    "$$\n",
    "\\beta s ≤ 1\\\\\n",
    "\\frac{c}{\\frac{\\Delta x}{\\Delta t}} \\sin\\frac{k \\Delta x}{2} ≤ 1\n",
    "$$\n",
    "\n",
    "Assuming the \"worst case\" for the $\\sin$ factor (namely, 1), the **condition for stability** is\n",
    "\n",
    "$$\n",
    "c ≤ \\frac{\\Delta x}{\\Delta t}\n",
    "$$\n",
    "\n",
    "or \n",
    "\n",
    "$$\n",
    "\\beta ≤ 1.\n",
    "$$\n",
    "\n",
    "This is also known as the **Courant condition**. When written as\n",
    "\n",
    "$$\n",
    "\\Delta t ≤ \\frac{\\Delta x}{c}\n",
    "$$\n",
    "\n",
    "it means that the time step $\\Delta t$ (for a given $\\Delta x$) must be *smaller than the time that the  wave takes to travel one grid step*.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}