examples/seismic/acoustic/accuracy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.special import hankel2\n",
    "from examples.seismic.acoustic import AcousticWaveSolver\n",
    "from examples.seismic import Model, RickerSource, Receiver, TimeAxis, AcquisitionGeometry\n",
    "from devito import set_log_level\n",
    "from benchmarks.user.tools.plotter import LinePlotter\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Switch to error logging so that info is printed but runtime is hidden\n",
    "from devito import configuration\n",
    "configuration['log-level'] = 'ERROR'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model with fixed time step value\n",
    "class ModelBench(Model):\n",
    "    \"\"\"\n",
    "    Physical model used for accuracy benchmarking.\n",
    "    The critical dt is made small enough to ignore\n",
    "    time discretization errors\n",
    "    \"\"\"\n",
    "\n",
    "    @property\n",
    "    def critical_dt(self):\n",
    "        \"\"\"Critical computational time step value.\"\"\"\n",
    "        return .1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Verification\n",
    "\n",
    "We compute the error between the numerical and reference solutions for varying spatial discretization order and grid spacing. We also compare the time to solution to the error for these parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Discretization order\n",
    "orders = (2, 4, 6, 8, 10)\n",
    "norder = len(orders)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t0, tn, dt, nt; 0.0000 150.0000 0.1000 1501\n"
     ]
    }
   ],
   "source": [
    "# Number of time steps\n",
    "nt = 1501\n",
    "# Time axis\n",
    "dt = 0.1\n",
    "t0 = 0.\n",
    "tn = dt * (nt-1)\n",
    "time = np.linspace(t0, tn, nt)\n",
    "print(\"t0, tn, dt, nt; %.4f %.4f %.4f %d\" % (t0, tn, dt, nt))\n",
    "# Source peak frequency in KHz\n",
    "f0 = .09"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Domain sizes and gird spacing\n",
    "shapes = ((201, 2.0), (161, 2.5), (101, 4.0))\n",
    "dx = [2.0, 2.5, 4.0]\n",
    "nshapes = len(shapes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fine grid model\n",
    "c0 = 1.5\n",
    "model = ModelBench(vp=c0, origin=(0., 0.), spacing=(.5, .5), \n",
    "                   shape=(801, 801), space_order=20, nbl=40, dtype=np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Source and receiver geometries\n",
    "src_coordinates = np.empty((1, 2))\n",
    "src_coordinates[0, :] = 200.\n",
    "\n",
    "# Single receiver offset 100 m from source\n",
    "rec_coordinates = np.empty((1, 2))\n",
    "rec_coordinates[:, :] = 260.\n",
    "\n",
    "print(\"The computational Grid has (%s, %s) grid points \"\n",
    "       \"and a physical extent of (%sm, %sm)\" % (*model.grid.shape, *model.grid.extent))\n",
    "print(\"Source is at the center with coordinates (%sm, %sm)\" % tuple(src_coordinates[0]))\n",
    "print(\"Receiver (single receiver) is located at (%sm, %sm) \" %  tuple(rec_coordinates[0]))\n",
    "    \n",
    "# Note: gets time sampling from model.critical_dt\n",
    "geometry = AcquisitionGeometry(model, rec_coordinates, src_coordinates, \n",
    "                               t0=t0, tn=tn, src_type='Ricker', f0=f0, t0w=1.5/f0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reference solution for numerical convergence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solver = AcousticWaveSolver(model, geometry, kernel='OT2', space_order=8)\n",
    "ref_rec, ref_u, _ = solver.forward()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analytical solution for comparison with the reference numerical solution\n",
    "\n",
    "The analytical solution of the 2D acoustic wave-equation with a source pulse is defined as:\n",
    "\n",
    "$$\n",
    "u_s(r, t) = \\frac{1}{2\\pi} \\int_{-\\infty}^{\\infty} \\{ -i \\pi H_0^{(2)}\\left(k r \\right) q(\\omega) e^{i\\omega t} d\\omega\\}\n",
    "$$\n",
    "\n",
    "$$\n",
    "r = \\sqrt{(x - x_{src})^2+(y - y_{src})^2}\n",
    "$$\n",
    "\n",
    "where $H_0^{(2)}$ is the Hankel function of the second kind, $F(\\omega)$ is the Fourier spectrum of the source time function at angular frequencies $\\omega$ and $k = \\frac{\\omega}{v}$ is the wavenumber.\n",
    "\n",
    "We look at the analytical and numerical solution at a single grid point. We ensure that this grid point is on-the-grid for all discretizations analyised in the further verification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Source and receiver coordinates\n",
    "sx, sz = src_coordinates[0, :]\n",
    "rx, rz = rec_coordinates[0, :]\n",
    "\n",
    "# Define a Ricker wavelet shifted to zero lag for the Fourier transform\n",
    "def ricker(f, T, dt, t0):\n",
    "    t = np.linspace(-t0, T-t0, int(T/dt))\n",
    "    tt = (np.pi**2) * (f**2) * (t**2)\n",
    "    y = (1.0 - 2.0 * tt) * np.exp(- tt)\n",
    "    return y\n",
    "\n",
    "def analytical(nt, model, time, **kwargs):\n",
    "    dt = kwargs.get('dt', model.critical_dt)\n",
    "    # Fourier constants\n",
    "    nf = int(nt/2 + 1)\n",
    "    fnyq = 1. / (2 * dt)\n",
    "    df = 1.0 / time[-1]\n",
    "    faxis = df * np.arange(nf)\n",
    "\n",
    "    wavelet = ricker(f0, time[-1], dt, 1.5/f0)\n",
    "\n",
    "    # Take the Fourier transform of the source time-function\n",
    "    R = np.fft.fft(wavelet)\n",
    "    R = R[0:nf]\n",
    "    nf = len(R)\n",
    "\n",
    "    # Compute the Hankel function and multiply by the source spectrum\n",
    "    U_a = np.zeros((nf), dtype=complex)\n",
    "    for a in range(1, nf-1):\n",
    "        k = 2 * np.pi * faxis[a] / c0\n",
    "        tmp = k * np.sqrt(((rx - sx))**2 + ((rz - sz))**2)\n",
    "        U_a[a] = -1j * np.pi * hankel2(0.0, tmp) * R[a]\n",
    "\n",
    "    # Do inverse fft on 0:dt:T and you have analytical solution\n",
    "    U_t = 1.0/(2.0 * np.pi) * np.real(np.fft.ifft(U_a[:], nt))\n",
    "    \n",
    "    # The analytic solution needs be scaled by dx^2 to convert to pressure\n",
    "    return np.real(U_t) * (model.spacing[0]**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time1 = np.linspace(0.0, 3000., 30001)\n",
    "U_t = analytical(30001, model, time1, dt=time1[1] - time1[0])\n",
    "U_t = U_t[0:1501]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Numerical data min,max,abs; %+12.6e %+12.6e %+12.6e\" % \n",
    "      (np.min(ref_rec.data), np.max(ref_rec.data), np.max(np.abs(ref_rec.data)) ))\n",
    "print(\"Analytic  data min,max,abs; %+12.6e %+12.6e %+12.6e\" % \n",
    "      (np.min(U_t), np.max(U_t), (np.max(np.abs(U_t)))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot wavefield and source/rec position\n",
    "plt.figure(figsize=(8,8))\n",
    "amax = np.max(np.abs(ref_u.data[1,:,:]))\n",
    "plt.imshow(ref_u.data[1,:,:], vmin=-1.0 * amax, vmax=+1.0 * amax, cmap=\"seismic\")\n",
    "plt.plot(2*sx+40, 2*sz+40, 'r*', markersize=11, label='source')   # plot position of the source in model, add nbl for correct position\n",
    "plt.plot(2*rx+40, 2*rz+40, 'k^', markersize=8, label='receiver')  # plot position of the receiver in model, add nbl for correct position\n",
    "plt.legend()\n",
    "plt.xlabel('x position (m)')\n",
    "plt.ylabel('z position (m)')\n",
    "plt.savefig('wavefieldperf.pdf')\n",
    "\n",
    "# Plot trace\n",
    "plt.figure(figsize=(12,8))\n",
    "plt.subplot(2,1,1)\n",
    "plt.plot(time, ref_rec.data[:, 0], '-b', label='numerical')\n",
    "plt.plot(time, U_t[:], '--r', label='analytical')\n",
    "plt.xlim([0,150])\n",
    "plt.ylim([1.15*np.min(U_t[:]), 1.15*np.max(U_t[:])])\n",
    "plt.xlabel('time (ms)')\n",
    "plt.ylabel('amplitude')\n",
    "plt.legend()\n",
    "plt.subplot(2,1,2)\n",
    "plt.plot(time, 100 *(ref_rec.data[:, 0] - U_t[:]), '-b', label='difference x100')\n",
    "plt.xlim([0,150])\n",
    "plt.ylim([1.15*np.min(U_t[:]), 1.15*np.max(U_t[:])])\n",
    "plt.xlabel('time (ms)')\n",
    "plt.ylabel('amplitude x100')\n",
    "plt.legend()\n",
    "plt.savefig('ref.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "error_time = np.zeros(5)\n",
    "error_time[0] = np.linalg.norm(U_t[:-1] - ref_rec.data[:-1, 0], 2) / np.sqrt(nt)\n",
    "errors_plot = [(time, U_t[:-1] - ref_rec.data[:-1, 0])]\n",
    "print(error_time[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convergence in time\n",
    "\n",
    "\n",
    "We first show the convergence of the time discretization for a fix high-order spatial discretization (20th order).\n",
    "\n",
    "After we show that the time discretization converges in $O(dt^2)$ and therefore only contains the error in time, we will take the numerical solution for `dt=.1ms` as a reference for the spatial discretization analysis.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "dt = [0.1000, 0.0800, 0.0750, 0.0625, 0.0500]\n",
    "nnt = (np.divide(150.0, dt) + 1).astype(int)\n",
    "\n",
    "for i in range(1, 5):\n",
    "    # Time axis\n",
    "    t0 = 0.0\n",
    "    tn = 150.0\n",
    "    time = np.linspace(t0, tn, nnt[i])\n",
    "\n",
    "    # Source geometry\n",
    "    src_coordinates = np.empty((1, 2))\n",
    "    src_coordinates[0, :] = 200.\n",
    "\n",
    "    # Single receiver offset 100 m from source\n",
    "    rec_coordinates = np.empty((1, 2))\n",
    "    rec_coordinates[:, :] = 260.\n",
    "\n",
    "    geometry = AcquisitionGeometry(model, rec_coordinates, src_coordinates, \n",
    "                                   t0=t0, tn=tn, src_type='Ricker', f0=f0, t0w=1.5/f0)\n",
    "\n",
    "    # Note: incorrect data size will be generated here due to AcquisitionGeometry bug ... \n",
    "    # temporarily fixed below by resizing the output from the solver\n",
    "    geometry.resample(dt[i])\n",
    "    print(\"geometry.time_axes; \", geometry.time_axis)\n",
    "    \n",
    "    solver = AcousticWaveSolver(model, geometry, time_order=2, space_order=8)\n",
    "    ref_rec1, ref_u1, _ = solver.forward(dt=dt[i])\n",
    "    ref_rec1_data = ref_rec1.data[0:nnt[i],:]\n",
    "\n",
    "    time1 = np.linspace(0.0, 3000., 20*(nnt[i]-1) + 1)\n",
    "    U_t1 = analytical(20*(nnt[i]-1) + 1, model, time1, dt=time1[1] - time1[0])\n",
    "    U_t1 = U_t1[0:nnt[i]]\n",
    "\n",
    "    error_time[i] = np.linalg.norm(U_t1[:-1] - ref_rec1_data[:-1, 0], 2) / np.sqrt(nnt[i]-1)\n",
    "\n",
    "    ratio_d = dt[i-1]/dt[i] if i > 0 else 1.0\n",
    "    ratio_e = error_time[i-1]/error_time[i] if i > 0 else 1.0\n",
    "    print(\"error for dt=%.4f is %12.6e -- ratio dt^2,ratio err; %12.6f %12.6f \\n\" % \n",
    "          (dt[i], error_time[i], ratio_d**2, ratio_e))\n",
    "    errors_plot.append((geometry.time_axis.time_values, U_t1[:-1] - ref_rec1_data[:-1, 0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(20, 10))\n",
    "theory = [t**2 for t in dt]\n",
    "theory = [error_time[0]*th/theory[0] for th in theory]\n",
    "plt.loglog([t for t in dt], error_time, '-ob', label=('Numerical'), linewidth=4, markersize=10)\n",
    "plt.loglog([t for t in dt], theory, '-^r', label=('Theory (2nd order)'), linewidth=4, markersize=10)\n",
    "for x, y, a in zip([t for t in dt], theory, [('dt = %s ms' % (t)) for t in dt]):\n",
    "            plt.annotate(a, xy=(x, y), xytext=(4, 2),\n",
    "                         textcoords='offset points', size=20,\n",
    "                         horizontalalignment='left', verticalalignment='top')\n",
    "plt.xlabel(\"Time-step $dt$ (ms)\", fontsize=20)\n",
    "plt.ylabel(\"$|| u_{num} - u_{ana}||_2$\", fontsize=20)\n",
    "plt.tick_params(axis='both', which='both', labelsize=20)\n",
    "plt.tight_layout()\n",
    "plt.xlim((0.05, 0.1))\n",
    "plt.legend(fontsize=20, ncol=4, fancybox=True, loc='best')\n",
    "plt.savefig(\"TimeConvergence.pdf\", format='pdf', facecolor='white',\n",
    "            orientation='landscape', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "stylel = ('--y', '--b', '--r', '--g', '--c')\n",
    "\n",
    "start_t = lambda dt: int(50/dt)\n",
    "end_t = lambda dt: int(100/dt)\n",
    "\n",
    "\n",
    "plt.figure(figsize=(20, 10))\n",
    "\n",
    "for i, dti in enumerate(dt):\n",
    "    timei, erri = errors_plot[i]\n",
    "    s, e = start_t(dti), end_t(dti)\n",
    "    if i == 0:\n",
    "        plt.plot(timei[s:e], U_t[s:e], 'k', label='analytical', linewidth=2)\n",
    "    plt.plot(timei[s:e], 100*erri[s:e], stylel[i], label=\"100 x error dt=%sms\"%dti, linewidth=2)\n",
    "plt.xlim([50,100])\n",
    "plt.xlabel(\"Time (ms)\", fontsize=20)\n",
    "plt.legend(fontsize=20)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pf = np.polyfit(np.log([t for t in dt]), np.log(error_time), deg=1)\n",
    "print(\"Convergence rate in time is: %.4f\" % pf[0])\n",
    "assert np.isclose(pf[0], 1.9, atol=0, rtol=.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convergence in space\n",
    "We have a correct reference solution we can use for space discretization analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "errorl2 = np.zeros((norder, nshapes))\n",
    "timing = np.zeros((norder, nshapes))\n",
    "\n",
    "set_log_level(\"ERROR\")\n",
    "ind_o = -1\n",
    "for spc in orders:\n",
    "    ind_o +=1\n",
    "    ind_spc = -1\n",
    "    for nn, h in shapes:\n",
    "        ind_spc += 1\n",
    "        time = np.linspace(0., 150., nt)\n",
    "\n",
    "        model_space = ModelBench(vp=c0, origin=(0., 0.), spacing=(h, h), \n",
    "                           shape=(nn, nn), space_order=spc, nbl=40, dtype=np.float32)\n",
    "\n",
    "        # Source geometry\n",
    "        src_coordinates = np.empty((1, 2))\n",
    "        src_coordinates[0, :] = 200.\n",
    "\n",
    "        # Single receiver offset 100 m from source\n",
    "        rec_coordinates = np.empty((1, 2))\n",
    "        rec_coordinates[:, :] = 260.\n",
    "\n",
    "        geometry = AcquisitionGeometry(model_space, rec_coordinates, src_coordinates, \n",
    "                                       t0=t0, tn=tn, src_type='Ricker', f0=f0, t0w=1.5/f0)\n",
    "\n",
    "        solver = AcousticWaveSolver(model_space, geometry, time_order=2, space_order=spc)\n",
    "        loc_rec, loc_u, summary = solver.forward()\n",
    "\n",
    "        # Note: we need to correct for fixed spacing pressure corrections in both analytic  \n",
    "        # (run at the old model spacing) and numerical (run at the new model spacing) solutions\n",
    "        c_ana = 1 / model.spacing[0]**2\n",
    "        c_num = 1 / model_space.spacing[0]**2\n",
    "\n",
    "        # Compare to reference solution\n",
    "        # Note: we need to normalize by the factor of grid spacing squared \n",
    "        errorl2[ind_o, ind_spc] = np.linalg.norm(loc_rec.data[:-1, 0] * c_num - U_t[:-1] * c_ana, 2) / np.sqrt(U_t.shape[0] - 1)\n",
    "        timing[ind_o, ind_spc] = np.max([v for _, v in summary.timings.items()])\n",
    "        print(\"starting space order %s with (%s, %s) grid points the error is %s for %s seconds runtime\" %\n",
    "              (spc, nn, nn, errorl2[ind_o, ind_spc], timing[ind_o, ind_spc]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stylel = ('-^k', '-^b', '-^r', '-^g', '-^c')\n",
    "\n",
    "plt.figure(figsize=(20, 10))\n",
    "for i in range(0, 5):\n",
    "    plt.loglog(errorl2[i, :], timing[i, :], stylel[i], label=('order %s' % orders[i]), linewidth=4, markersize=10)\n",
    "    for x, y, a in zip(errorl2[i, :], timing[i, :], [('dx = %s m' % (sc)) for sc in dx]):\n",
    "                plt.annotate(a, xy=(x, y), xytext=(4, 2),\n",
    "                             textcoords='offset points', size=20)\n",
    "plt.xlabel(\"$|| u_{num} - u_{ref}||_{inf}$\", fontsize=20)\n",
    "plt.ylabel(\"Runtime (sec)\", fontsize=20)\n",
    "plt.tick_params(axis='both', which='both', labelsize=20)\n",
    "plt.tight_layout()\n",
    "plt.legend(fontsize=20, ncol=3, fancybox=True, loc='lower left')\n",
    "plt.savefig(\"TimeAccuracy.pdf\", format='pdf', facecolor='white',\n",
    "            orientation='landscape', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stylel = ('-^k', '-^b', '-^r', '-^g', '-^c')\n",
    "style2 = ('--k', '--b', '--r', '--g', '--c')\n",
    "\n",
    "plt.figure(figsize=(20, 10))\n",
    "for i in range(0, 5):\n",
    "    theory = [k**(orders[i]) for k in dx]\n",
    "    theory = [errorl2[i, 2]*th/theory[2] for th in theory]\n",
    "    plt.loglog([sc for sc in dx], errorl2[i, :], stylel[i], label=('Numerical order %s' % orders[i]),\n",
    "               linewidth=4, markersize=10)\n",
    "    plt.loglog([sc for sc in dx], theory, style2[i], label=('Theory order %s' % orders[i]),\n",
    "               linewidth=4, markersize=10)\n",
    "plt.xlabel(\"Grid spacing $dx$ (m)\", fontsize=20)\n",
    "plt.ylabel(\"$||u_{num} - u_{ref}||_{inf}$\", fontsize=20)\n",
    "plt.tick_params(axis='both', which='both', labelsize=20)\n",
    "plt.tight_layout()\n",
    "plt.legend(fontsize=20, ncol=2, fancybox=True, loc='lower right')\n",
    "# plt.xlim((2.0, 4.0))\n",
    "plt.savefig(\"Convergence.pdf\", format='pdf', facecolor='white',\n",
    "            orientation='landscape', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "for i in range(5):\n",
    "    pf = np.polyfit(np.log([sc for sc in dx]), np.log(errorl2[i, :]), deg=1)[0]\n",
    "    if i==3:\n",
    "        pf = np.polyfit(np.log([sc for sc in dx][1:]), np.log(errorl2[i, 1:]), deg=1)[0]\n",
    "    print(\"Convergence rate for order %s is %s\" % (orders[i], pf))\n",
    "    if i<4:\n",
    "        assert np.isclose(pf, orders[i], atol=0, rtol=.2)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "hide_input": false,
  "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.7.6"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}