fjordeco-advection-py.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A 2D Fjord Ecosystem Model\n",
    "==============================\n",
    "\n",
    "Now that we have an NPZ model that characterizes the water column of the fjord, we now aim to add advection and diffusion along with a spatial grid of our region. This requires that we reformulate our equations to handle advection and diffusion and biological processes at each time-step.\n",
    "\n",
    "\\begin{equation}\n",
    "\\begin{split}\n",
    "\\frac{\\partial N}{\\partial t} + u\\frac{\\partial N}{\\partial x}+v\\frac{\\partial N}{\\partial y}+w(N-B)&=A_T\\nabla^2 N \\nonumber - \\frac{V_m N}{k_s+N}P+mP+gZ+\\gamma R_m\\Lambda P(1-e^{-\\Lambda P})Z \\hspace{1.75in}(1)\\\\\n",
    "\\frac{\\partial P}{\\partial t} + u\\frac{\\partial P}{\\partial x}+v\\frac{\\partial P}{\\partial y}&=A_T\\nabla^2 P  + \\frac{V_m N}{k_s+N}P-mP-R_m\\Lambda P(1-e^{-\\Lambda P})Z-\\alpha P \\hspace{2in}(2)\\\\\n",
    "\\frac{\\partial Z}{\\partial t} + u\\frac{\\partial Z}{\\partial x}+v\\frac{\\partial Z}{\\partial y}&=A_T\\nabla^2 Z  + (1-\\gamma)R_m\\Lambda P(1-e^{-\\Lambda P})Z - gZ \\hspace{2.75in}(3) \\\\\n",
    "\\frac{dB}{dt}-w(N-B)& = \\alpha P. \\hspace{5.4in}(4)\n",
    "\\end{split}\n",
    "\\end{equation}\n",
    "\n",
    "*Note*: We do not employ advection and diffusion for the benthos as it is not moving on the time-scales we are concerned with.\n",
    "\n",
    "\n",
    "We are going to load a data file that includes a grid layout (identifies land, provides the geophysical coordinates, etc.) along with time and space fields of water velocity.\n",
    "\n",
    "| Parameter | Description                                    | Value        |\n",
    "|-----------|------------------------------------------------|--------------|\n",
    "|  $V_m$    | Maximum $P$ growth rate                        | 2 day$^{-1}$ |\n",
    "|  $k_s$    | Half-Saturation constant for $N$               | 1 $\\mu$gN L$^{-1}$ |\n",
    "|  $m$      | $P$ mortality rate remineralized in water water| 0.1 day$^{-1}$ |\n",
    "|  $\\alpha$ | $P$ mortality rate remineralized in benthos    | 0.025 day$^{-1}$ |\n",
    "|  $\\gamma$ | Unassimilated grazing fraction from (\"messy eating\" percentage) | 0.3 |\n",
    "|  $R_m$    | Maximum $Z$ grazing rate                       | 1.5 day$^{-1}$ |\n",
    "|  $\\Lambda$| Ivlev constant                                 | 1 L $(\\mu$gN$)^{-1}$ |\n",
    "|  $g$      | $Z$ mortality rate                             | 0.2 day$^{-1}$ |\n",
    "|  $A_T$    | Eddy diffusivity rate                          | 1 m$^2$ s$^{-1}$ |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modules\n",
    "------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import netCDF4 as nc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Parameters\n",
    "\n",
    "Now that we rely on a forcing file, we will derive many of the parameters from the file, including the run times. The following need to be specified:\n",
    "\n",
    "1. frc_name: name of the forcing file\n",
    "1. min_N: minimum level of Nitrogen [$\\mu$gN/L]\n",
    "1. min_P: minimum level of PhytoPlankton [$\\mu$gN/L]\n",
    "1. min_Z: minimum level of ZooPlankton [$\\mu$gN/L]\n",
    "1. min_B: minimum level of Benthos [$\\mu$gN/L]\n",
    "1. N0: initial level of Nitrogen [$\\mu$gN/L]\n",
    "1. P0: initial level of PhytoPlankton [$\\mu$gN/L]\n",
    "1. Z0: initial level of ZooPlankton [$\\mu$gN/L]\n",
    "1. B0: initial level of Benthos [$\\mu$gN/L]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frc_name = 'http://oos.soest.hawaii.edu/thredds/dodsC/fjordeco_30d'\n",
    "min_N  = 0.00001\n",
    "min_P  = 0.00001\n",
    "min_Z  = 0.00001\n",
    "min_B  = 0.00001\n",
    "# N0 = 1.6\n",
    "# P0 = 0.3\n",
    "# Z0 = 0.1\n",
    "# B0 = 0.1\n",
    "N0 = 15\n",
    "P0 = 1.0\n",
    "Z0 = 1.0\n",
    "B0 = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Derived Parameters\n",
    "\n",
    "Load the forcing file and set up the parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frc = nc.Dataset(frc_name)\n",
    "frc_time = frc.variables['time'][:] * 86400     # Time of the Model in seconds\n",
    "frc_dt = np.diff(frc_time).mean()\n",
    "lat = frc.variables['lat'][:]           # Latitude Array\n",
    "Ny, Nx = lat.shape\n",
    "lon = frc.variables['lon'][:]           # Longitude Array\n",
    "mask = frc.variables['mask'][:]         # Land/Sea Mask\n",
    "idx = 1 / frc.variables['dx'][:]        # Inverse Zonal Grid Spacing\n",
    "idy = 1 / frc.variables['dy'][:]        # Inverse Meridional Grid Spacing\n",
    "# Load the forcing velocities into memory for efficiency\n",
    "frc_u = frc.variables['u'][:]\n",
    "frc_u[frc_u>1]=np.ma.masked\n",
    "frc_v = frc.variables['v'][:]\n",
    "frc_v[frc_v>1]=np.ma.masked\n",
    "frc.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fields\n",
    "\n",
    "We will create the fields we use in the model, `N`, `P`, `Z`, and `B`, so that the model can integrate them forward and we can deal with them as we like. Since we need to track the previous, current, and next, we also need to keep counters for where we are. Finally, load the advection velocity fields from the file and close it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask3 = np.tile(mask,(3,1,1)).transpose(1,2,0)\n",
    "N = np.ma.masked_where(mask3 == 0, np.ma.zeros([Ny, Nx, 3]))\n",
    "P = np.ma.masked_where(mask3 == 0, np.ma.zeros([Ny, Nx, 3]))\n",
    "Z = np.ma.masked_where(mask3 == 0, np.ma.zeros([Ny, Nx, 3]))\n",
    "B = np.ma.masked_where(mask3 == 0, np.ma.zeros([Ny, Nx, 3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model Code\n",
    "----------\n",
    "\n",
    "Implement the 2D NPZ-class model with advection and diffusion\n",
    "    \n",
    "*Input*\n",
    "\n",
    "| Name | Description | Units |\n",
    "|-----------|-------------|-------|\n",
    "| `N0` | Initial Nutrients | $\\mu$gN L$^{-1}$\n",
    "| `P0` | Initial Phytoplankton | $\\mu$gN L$^{-1}$\n",
    "| `Z0` | Initial Zooplankton | $\\mu$gN L$^{-1}$\n",
    "| `B0` | Initial Benthos | $\\mu$gN L$^{-1}$\n",
    "| `Vm` | Maximum P growth rate | days$^{-1}$\n",
    "| `ks` | Half-saturation constant | $\\mu$gN L$^{-1}$\n",
    "| `m`  | Mortality-rate for phytoplankton | days$^{-1}$\n",
    "| `alpha` | export to benthos rate | days$^{-1}$\n",
    "| `gamma` | Messy Eating  | fraction\n",
    "| `Rm` | Maximum Z grazing | days$^-1$\n",
    "| `ivlev` | Ivlev constant  | L $(\\mu$gN$)^{-1}$\n",
    "| `g` | Z mortality rate | days$^{-1}$\n",
    "| `At` | Eddy Diffusivity | m$^2$ s$^{-1}$\n",
    "\n",
    "\n",
    "*Output*\n",
    "\n",
    "No output, the arrays are in the notebook for analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def npz(N, P, Z, B,                                         # Initial Conditions\n",
    "        Vm=2.0, ks=1.0, m=0.1, alpha=0.0025,                 # Phytoplankton Parameters\n",
    "        gamma=0.3, Rm=1.5, ivlev=1.0, g=0.2,                # Zooplankton Parameters\n",
    "        At=20):                                             # Mixing Parameter\n",
    "\n",
    "    # Set the parameters\n",
    "    Navg = 24\n",
    "    dt = 600\n",
    "    times = np.arange(frc_time[0], frc_time[-1], dt)\n",
    "    frc_idx = times / frc_dt\n",
    "\n",
    "    # Convert parameters to seconds\n",
    "    Vm    /= 86400\n",
    "    m     /= 86400\n",
    "    alpha /= 86400\n",
    "    Rm    /= 86400\n",
    "    g     /= 86400\n",
    "    \n",
    "    # Create the upwelling field\n",
    "    w = np.zeros([Ny, Nx])\n",
    "\n",
    "    # Create indices for the grids. m is index-1 and p is index+1\n",
    "    i = j = np.s_[1:-1]\n",
    "    ip = jp = np.s_[2:]\n",
    "    im = jm = np.s_[0:-2]\n",
    "\n",
    "    # Set up values\n",
    "    idx2 = idx * idx\n",
    "    idy2 = idy * idy\n",
    "    nprev, ncur, nnext = 0, 1, 2               # counters\n",
    "\n",
    "    for n, t in enumerate(times):\n",
    "        # Create the advection field of u and v from the forcing file for the given time\n",
    "        fidx = t / frc_dt\n",
    "        frac = fidx - int(fidx)\n",
    "        fidx = int(fidx)\n",
    "        u = (1 - frac) * frc_u[fidx, ...] + frac * frc_u[fidx + 1, ...]\n",
    "        v = (1 - frac) * frc_v[fidx, ...] + frac * frc_v[fidx + 1, ...]\n",
    "        \n",
    "        # Fill in the land with the mean values to deal with numerics\n",
    "        nfill = N[:, :, ncur].mean()\n",
    "        pfill = P[:, :, ncur].mean()\n",
    "        zfill = Z[:, :, ncur].mean()\n",
    "        bfill = B[:, :, ncur].mean()\n",
    "        ufill = u.mean()\n",
    "        vfill = v.mean()\n",
    "\n",
    "\n",
    "        # Compute the up/downwelling\n",
    "        w[j, i] = idx * (u[j, i].filled(ufill) - u[j, im].filled(ufill)) + \\\n",
    "                  idy * (v[j, i].filled(vfill) - v[jm, i].filled(vfill))\n",
    "        w /= 10        # realistic flows too great for this simple model\n",
    "\n",
    "        # Compute the biological terms\n",
    "        uptake = Vm * P[j, i, ncur] * N[j, i, ncur] / (ks + N[j, i, ncur])\n",
    "        pmortality = m * P[j, i, ncur]\n",
    "        graze = ivlev * P[j, i, ncur] * Rm * \\\n",
    "            (1.0 - np.exp(-ivlev * P[j, i, ncur])) * Z[j, i, ncur]\n",
    "        zmortality = g * Z[j, i, ncur]\n",
    "        binput = alpha * P[j, i, ncur]\n",
    "\n",
    "        # Integrate the nitrate\n",
    "        zonal = 0.5 * idx * \\\n",
    "            u[j, i] * (N[j, ip, ncur].filled(nfill) -\n",
    "                       N[j, im, ncur].filled(nfill))\n",
    "        meridional = 0.5 * idy * \\\n",
    "            v[j, i] * (N[jp, i, ncur].filled(nfill) -\n",
    "                       N[jm, i, ncur].filled(nfill))\n",
    "        upwell = w[j, i] * (N[j, i, ncur] - B[j, i, ncur])\n",
    "        diffx = idx2 * (N[j, ip, nprev].filled(nfill) - 2 * N[j, i, nprev].filled(nfill) +\n",
    "                        N[j, im, nprev].filled(nfill))\n",
    "        diffy = idy2 * (N[jp, i, nprev].filled(nfill) - 2 * N[j, i, nprev].filled(nfill) +\n",
    "                        N[jm, i, nprev].filled(nfill))\n",
    "        N[j, i, nnext] = N[j, i, nprev] + 2 * dt * \\\n",
    "            (-zonal - meridional - upwell + At * (diffx + diffy) -\n",
    "             uptake + pmortality + zmortality + gamma * graze)\n",
    "\n",
    "        # Integrate the phytoplankton\n",
    "        zonal = 0.5 * idx * \\\n",
    "            u[j, i] * (P[j, ip, ncur].filled(pfill) -\n",
    "                       P[j, im, ncur].filled(pfill))\n",
    "        meridional = 0.5 * idy * \\\n",
    "            v[j, i] * (P[jp, i, ncur].filled(pfill) -\n",
    "                       P[jm, i, ncur].filled(pfill))\n",
    "        diffx = idx2 * (P[j, ip, nprev].filled(pfill) - 2 * P[j, i, nprev].filled(pfill) +\n",
    "                        P[j, im, nprev].filled(pfill))\n",
    "        diffy = idy2 * (P[jp, i, nprev].filled(pfill) - 2 * P[j, i, nprev].filled(pfill) +\n",
    "                        P[jm, im, nprev].filled(pfill))\n",
    "        P[j, i, nnext] = P[j, i, nprev] +  2 * dt * \\\n",
    "               (-zonal - meridional + At * (diffx + diffy) +\n",
    "                uptake - pmortality - graze - binput)\n",
    "\n",
    "        # Integrate the zooplankton\n",
    "        zonal = 0.5 * idx * \\\n",
    "            u[j, i] * (Z[j, ip, ncur].filled(zfill) -\n",
    "                       Z[j, im, ncur].filled(zfill))\n",
    "        meridional = 0.5 * idy * \\\n",
    "            v[j, i] * (Z[jp, i, ncur].filled(zfill) -\n",
    "                       Z[jm, i, ncur].filled(zfill))\n",
    "        diffx = idx2 * (Z[j, ip, nprev].filled(zfill) - 2 * Z[j, i, nprev].filled(zfill) +\n",
    "                        Z[j, im, nprev].filled(zfill))\n",
    "        diffy = idy2 * (Z[jp, i, nprev].filled(zfill) - 2 * Z[j, i, nprev].filled(zfill) +\n",
    "                        Z[jm, im, nprev].filled(zfill))\n",
    "        Z[j, i, nnext] = Z[j, i, nprev] + 2 * dt * \\\n",
    "            (-zonal - meridional + At * (diffx + diffy) +\n",
    "             (1 - gamma) * graze - zmortality)\n",
    "\n",
    "\n",
    "        # Integrate the Benthic (no advection or diffusion)\n",
    "        B[j, i, nnext] = B[j, i, nprev] + 2 * dt * (upwell + binput)\n",
    "\n",
    "        # Apply T Boundary Conditions\n",
    "        N[:] = np.maximum(N[:], min_N)\n",
    "        P[:] = np.maximum(P[:], min_P)\n",
    "        Z[:] = np.maximum(Z[:], min_Z)\n",
    "        B[:] = np.maximum(B[:], min_B)\n",
    "\n",
    "        # Averaging Step to remove computational mode\n",
    "        if not np.mod(n, Navg):\n",
    "            N[:, :, nnext] = 0.5 * (N[:, :, nnext] + N[:, :, ncur])\n",
    "            N[:, :, ncur] = 0.5 * (N[:, :, nprev] + N[:, :, ncur])\n",
    "            P[:, :, nnext] = 0.5 * (P[:, :, nnext] + P[:, :, ncur])\n",
    "            P[:, :, ncur] = 0.5 * (P[:, :, nprev] + P[:, :, ncur])\n",
    "            Z[:, :, nnext] = 0.5 * (Z[:, :, nnext] + Z[:, :, ncur])\n",
    "            Z[:, :, ncur] = 0.5 * (Z[:, :, nprev] + Z[:, :, ncur])\n",
    "\n",
    "        # Yield back to the iteration\n",
    "        yield n, nnext, t\n",
    "\n",
    "        # Cycle the Records\n",
    "        nprev, ncur, nnext = ncur, nnext, nprev\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integrate our model\n",
    "\n",
    "The model is designed to time-step our model, so we want to write a function that repeatedly calls our model until it is finished. This allows us to save the data at some interval for analysis later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def integrator(model):\n",
    "    Nsave = 7200\n",
    "    total = int(frc_time[-1]/Nsave)\n",
    "\n",
    "    results = {}\n",
    "    results['t'] = np.zeros((total))\n",
    "    results['N'] = np.ma.zeros([total, Ny, Nx])\n",
    "    results['P'] = np.ma.zeros([total, Ny, Nx])\n",
    "    results['Z'] = np.ma.zeros([total, Ny, Nx])\n",
    "    results['B'] = np.ma.zeros([total, Ny, Nx])\n",
    "\n",
    "    print(\"\\r Progress: [  0%]\", end='')\n",
    "    for n, nnext, t in model:\n",
    "        if not np.mod(t,Nsave):\n",
    "            idx = int(t/Nsave)\n",
    "            print(f\"\\r Progress: [{100*idx/total:3.0f}%]\", end='')\n",
    "            results['t'][idx] = t\n",
    "            results['N'][idx, ...] = N[:, :, nnext]\n",
    "            results['P'][idx, ...] = P[:, :, nnext]\n",
    "            results['Z'][idx, ...] = Z[:, :, nnext]\n",
    "            results['B'][idx, ...] = B[:, :, nnext]\n",
    "    print(\"\\r Done.                    \")\n",
    "    return results\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialize Fields\n",
    "\n",
    "We need to set the initial state of our model variables: `N`, `P`, `Z`, and `B`. Using the values set in the parameters above, let's put a gradient with the initial values present in the fjord and a difference in the channel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N.data[:] = N0 * 1.2\n",
    "P.data[:] = P0 / 2\n",
    "Z.data[:] = Z0 / 2\n",
    "B.data[:] = B0 / 2\n",
    "N.data[:20,10:,:] = N0\n",
    "P.data[:20,10:,:] = P0\n",
    "Z.data[:20,10:,:] = Z0\n",
    "B.data[:20,10:,:] = B0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run the model\n",
    "\n",
    "Create the model we wish to use with the configuration we prefer, then integrate it using the integrator function that saves data when and where we aim to analyze."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "mymodel = npz(N, P, Z, B, Vm=1, ks=4, alpha=0.2, Rm=0.4)\n",
    "results = integrator(mymodel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analyze the Model Output\n",
    "\n",
    "Let's begin by plotting point(s) of interest around the domain.\n",
    "\n",
    "Some suggestions:\n",
    "\n",
    "- i=6; j=33 : North of Useful Island\n",
    "- i=15; j=18 : Middle of Fjord Mouth\n",
    "- i=20; j=13 : Inner Basin of Fjord\n",
    "- i=31; j=8 : Toe of the Fjord"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "i=6\n",
    "j=33\n",
    "plt.plot(results['t']/86400,results['N'][:,j,i],\n",
    "         results['t']/86400,results['P'][:,j,i],\n",
    "         results['t']/86400,results['Z'][:,j,i],\n",
    "         results['t']/86400,results['B'][:,j,i])\n",
    "plt.legend(['N','P','Z','B'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize the temporal/spatial variations of the Fjord\n",
    "\n",
    "Create a simple little function that will take our output and animate a cartoon of the field of interest so we can see how the flow field is affecting the biology."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contour_movie(result, field):\n",
    "    fig = plt.figure(figsize=(6,6))\n",
    "    ax = fig.gca()\n",
    "    ax.set_xlim(lon.min(), lon.max())\n",
    "    ax.set_ylim(lat.min(), lat.max())\n",
    "    \n",
    "    for n,t in enumerate(results['t']):\n",
    "        ax.cla()\n",
    "        ax.contourf(lon,lat,result[field][n,:,:],10,cmap=plt.get_cmap('jet'))\n",
    "        ax.set_title(f\"{field}: {t/86400:4.2f} days\")\n",
    "        fig.canvas.draw()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def movie(result, field, vmin=None, vmax=None):\n",
    "    fig = plt.figure(figsize=(6,6))\n",
    "    ax = fig.gca()\n",
    "    ax.set_xlim(lon.min(), lon.max())\n",
    "    ax.set_ylim(lat.min(), lat.max())\n",
    "    p=ax.pcolormesh(lon, lat, result[field][0,:,:])\n",
    "    if vmin is not None:\n",
    "        clim = (result[field].min(), result[field].max()*0.75)\n",
    "        p.set_clim(clim)\n",
    "        fig.colorbar(p, orientation='vertical', ax=ax)\n",
    "    fig.canvas.draw()\n",
    "    \n",
    "    for n,t in enumerate(results['t']):\n",
    "        ax.cla()\n",
    "        p=ax.pcolormesh(lon,lat,result[field][n,:,:])\n",
    "        if vmin is not None: p.set_clim(clim)\n",
    "        ax.contour(lon,lat,result[field][n,:,:],10,cmap=plt.get_cmap('jet'))            \n",
    "        ax.set_title(f\"{field}: {t/86400:4.2f} days\")\n",
    "        fig.canvas.draw()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Animate\n",
    "\n",
    "Use the function to visualize the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contour_movie(results, \"P\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "movie(results, \"P\")"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}