FiniteVolumeGPU/ConvergenceShock1D.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "This notebook sets up and runs a set of benchmarks to compare\n",
    "different numerical discretizations of the SWEs\n",
    "\n",
    "Copyright (C) 2016  SINTEF ICT\n",
    "\n",
    "This program is free software: you can redistribute it and/or modify\n",
    "it under the terms of the GNU General Public License as published by\n",
    "the Free Software Foundation, either version 3 of the License, or\n",
    "(at your option) any later version.\n",
    "\n",
    "This program is distributed in the hope that it will be useful,\n",
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n",
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n",
    "GNU General Public License for more details.\n",
    "\n",
    "You should have received a copy of the GNU General Public License\n",
    "along with this program.  If not, see <http://www.gnu.org/licenses/>.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Lets have matplotlib \"inline\"\n",
    "%matplotlib inline\n",
    "\n",
    "#Python 2.7 compatibility\n",
    "from __future__ import print_function\n",
    "\n",
    "#Import packages we need\n",
    "import numpy as np\n",
    "from matplotlib import animation, rc\n",
    "from matplotlib import pyplot as plt\n",
    "#import mpld3\n",
    "\n",
    "import subprocess\n",
    "import os\n",
    "import gc\n",
    "import datetime\n",
    "\n",
    "import pycuda.driver as cuda\n",
    "\n",
    "try:\n",
    "    from StringIO import StringIO\n",
    "except ImportError:\n",
    "    from io import StringIO\n",
    "\n",
    "#Finally, import our simulator\n",
    "from SWESimulators import Common, LxF, FORCE, HLL, HLL2, KP07, KP07_dimsplit, WAF, PlotHelper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No CUDA context available\n",
      "CUDA version (9, 1, 0)\n",
      "Driver version 9010\n",
      "Using GeForce 840M\n",
      " => compute capability: (5, 0)\n",
      " => memory: 2048.0 MB\n",
      "Created context <336955222256>\n"
     ]
    }
   ],
   "source": [
    "import atexit\n",
    "def exitfunc():\n",
    "    #Clean up old context if any:\n",
    "    if 'cuda_context' in globals():\n",
    "        print(\"Cleaning up CUDA context!\")\n",
    "        cuda.Context.pop()\n",
    "        global cuda_context\n",
    "        del cuda_context\n",
    "        gc.collect()\n",
    "    else:\n",
    "        print(\"No CUDA context available\")\n",
    "        gc.collect()\n",
    "        \n",
    "atexit.register(exitfunc)\n",
    "exitfunc()\n",
    "    \n",
    "cuda_context = Common.CudaContext(verbose=True, blocking=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Misc plotting setup\n",
    "def setBwStyles(ax):\n",
    "    from cycler import cycler\n",
    "\n",
    "    ax.set_prop_cycle( cycler('marker', ['.', 'x', 4, '+', '*', '1', 5]) +\n",
    "                       cycler('linestyle', ['-.', '--', ':', '-.', '--', ':', '-.']) +\n",
    "                       #cycler('markersize', [5, 5, 5, 5, 5, 5]) +\n",
    "                       cycler('color', ['k', 'k', 'k', 'k', 'k', 'k', 'k']) )    \n",
    "\n",
    "#Set large figure sizes\n",
    "plt.rcParams['figure.figsize'] = [12, 8]\n",
    "plt.rcParams['figure.dpi'] = 100\n",
    "plt.rcParams['animation.html'] = 'html5'\n",
    "#plt.rcParams['legend.markerscale'] = 1.0\n",
    "#plt.rcParams['lines.markersize'] = 6\n",
    "plt.rcParams['lines.markeredgewidth'] = 1.5\n",
    "#plt.rcParams['savefig.dpi'] = 400"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_figure(fig, stem):\n",
    "    fig_filename = \"convergence_shock1d_\" + stem + \".pdf\"\n",
    "    \n",
    "    image_text = fig_filename + \"\\nCreated \" + str(datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"))\n",
    "    \n",
    "    #ax = fig.gca()\n",
    "    #pos1 = ax.get_position() # get the original position \n",
    "    #pos2 = [pos1.x0 + 0.3, pos1.y0 + 0.3,  pos1.width / 2.0, pos1.height / 2.0] \n",
    "    #ax.set_position(pos2) # set a new position\n",
    "    \n",
    "    #fig.gca().annotate(image_text, xy=(1.1, 0), xycoords='figure fraction', fontsize=10,\n",
    "    #                   horizontalalignment='right', verticalalignment='bottom')\n",
    "    t = plt.figtext(-0.1, .9, image_text, rotation='vertical')\n",
    "    \n",
    "    legend = fig.gca().legend_\n",
    "    if (legend != None):\n",
    "        fig.savefig(fig_filename, bbox_extra_artists=(legend,t, ), bbox_inches='tight')\n",
    "    else:\n",
    "        fig.savefig(fig_filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_reference(nx):\n",
    "    csv_filename = 'shock1d_ref_nx=' + str(nx) + '.csv'\n",
    "\n",
    "    #If we do not have the data, generate it    \n",
    "    if (not os.path.isfile(csv_filename)):\n",
    "        print(\"Generating new reference!\")\n",
    "        swashes_path = r'C:\\Users\\anbro\\Documents\\programs\\SWASHES-1.03.00_win\\bin\\swashes_win.exe'\n",
    "\n",
    "        swashes_args = [\\\n",
    "                        '1', # 1D problems \\\n",
    "                        '3', # Dam breaks \\\n",
    "                        '1', # Domain 1 \\\n",
    "                        '1', # Wet domain no friction\n",
    "                        str(nx) #Number of cells X\n",
    "                       ]\n",
    "\n",
    "        with open(csv_filename, 'w') as csv_file:\n",
    "            p = subprocess.check_call([swashes_path] + swashes_args, stdout=csv_file)\n",
    "\n",
    "    reference = np.genfromtxt(csv_filename, comments='#', delimiter='\\t', skip_header=0, usecols=(0, 1, 2))\n",
    "    x, h, u = reference[:, 0], reference[:, 1], reference[:, 2]\n",
    "    return x, h, h*u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_test_data(nx, ny, g, num_ghost_cells):\n",
    "    dx = 10.0 / float(nx)\n",
    "    dy = 1.0\n",
    "\n",
    "    h = np.zeros((ny+2*num_ghost_cells, nx+2*num_ghost_cells), dtype=np.float32); \n",
    "    hu = np.zeros((ny+2*num_ghost_cells, nx+2*num_ghost_cells), dtype=np.float32);\n",
    "    hv = np.zeros((ny+2*num_ghost_cells, nx+2*num_ghost_cells), dtype=np.float32);\n",
    "\n",
    "    #Create dam break\n",
    "    for j in range(-num_ghost_cells, ny+num_ghost_cells):\n",
    "        for i in range(-num_ghost_cells, nx+num_ghost_cells):\n",
    "            x = dx*i\n",
    "\n",
    "            if (x < 5):\n",
    "                h[j+num_ghost_cells, i+num_ghost_cells] = 0.005\n",
    "            else:\n",
    "                h[j+num_ghost_cells, i+num_ghost_cells] = 0.001\n",
    "    \n",
    "    max_h_estimate = 0.005\n",
    "    max_u_estimate = 0.3\n",
    "    dt = min(dx, dy) / (max_u_estimate + np.sqrt(g*max_h_estimate))\n",
    "    \n",
    "    return h, hu, hv, dx, dy, dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_filename(simulator, nx):\n",
    "    return \"shock1d_\" + str(simulator.__name__) + \"_\" + str(nx) + \".npz\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sanity_check(variable, variable_name):\n",
    "    maxval = np.amax(variable)\n",
    "    minval = np.amin(variable)\n",
    "    if (np.isnan(maxval) or np.isnan(minval)):\n",
    "        print(\"=== WARNING ===\")\n",
    "        print(variable_name + \" contains NaN values\")\n",
    "        print(\"=== WARNING ===\")\n",
    "\n",
    "def run_benchmark(datafilename, simulator, courant_number, nx, ny, ghost_cells, g=9.81, force_rerun=False):\n",
    "    datafilename = gen_filename(simulator, nx)\n",
    "\n",
    "    if (os.path.isfile(datafilename) and force_rerun == False):\n",
    "        print(\"=== WARNING ===\")\n",
    "        print(\"Existing simulation exists, skipping simulation\")\n",
    "        print(\"=== WARNING ===\")\n",
    "    else:\n",
    "        h0, hu0, hv0, dx, dy, dt = gen_test_data(nx, ny, g, ghost_cells)\n",
    "        dt = dt * courant_number\n",
    "\n",
    "        #Initialize simulator\n",
    "        with Common.Timer(simulator.__name__ + \"_\" + str(nx)) as timer:\n",
    "            sim = simulator(cuda_context, \\\n",
    "                            h0, hu0, hv0, \\\n",
    "                            nx, ny, \\\n",
    "                            dx, dy, dt, \\\n",
    "                            g)\n",
    "\n",
    "        t = sim.step(6.0)\n",
    "        h, hu, hv = sim.download()\n",
    "\n",
    "        h = h[ghost_cells, ghost_cells:-ghost_cells]\n",
    "        hu = hu[ghost_cells, ghost_cells:-ghost_cells]\n",
    "        hv = hv[ghost_cells, ghost_cells:-ghost_cells]\n",
    "        \n",
    "            \n",
    "        sanity_check(h, \"h\")\n",
    "        sanity_check(hu, \"hu\")\n",
    "        sanity_check(hv, \"hv\")\n",
    "\n",
    "        np.savez_compressed(datafilename, h=h, hu=hu, hv=hv)\n",
    "        \n",
    "    gc.collect() # Force run garbage collection to free up memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def downsample(highres_solution, factor):\n",
    "    assert(highres_solution.size % factor == 0)\n",
    "    nx = highres_solution.size / factor\n",
    "    return highres_solution.reshape([int(nx), int(factor)]).mean(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['test.py', 'foo.bar', 'foo.bar2', 'test.pyyy']\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "includes = re.findall('^\\W*#include\\W+(.+?)\\W*$', \"testest\\n    #include test.py    \\n   #include \\\"foo.bar\\\"\\n#include foo.bar2\\n #include <test.pyyy>\", re.M)\n",
    "#includes = re.findall(\"([\\\"])(.*?)\\1\", \"test test \\\"test\\\" 55 55\", re.M)#\\n tt    #include test.py    \\n   #include \\\"foo.bar\\\"\", re.M)\n",
    "#includes = re.findall('^(.*)$', \"testest\\n    #include test.py    \\n   #include \\\"foo.bar\\\"\", re.M)\n",
    "#includes = re.match( r'(.*) are (.*?) .*', \"dogs are cats    \", re.M|re.I)\n",
    "print(includes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> LxF_32 7222.214222 ms\n",
      "=> LxF_64 9.006023 ms\n",
      "=> LxF_128 11.015415 ms\n",
      "=> LxF_256 13.010025 ms\n",
      "=> LxF_512 14.009476 ms\n",
      "=> LxF_1024 13.002396 ms\n",
      "=> LxF_2048 9.008646 ms\n",
      "=> LxF_4096 9.008646 ms\n",
      "=> FORCE_32 5203.070402 ms\n",
      "=> FORCE_64 8.977890 ms\n",
      "=> FORCE_128 11.009216 ms\n",
      "=> FORCE_256 9.012222 ms\n",
      "=> FORCE_512 9.008169 ms\n",
      "=> FORCE_1024 9.987116 ms\n",
      "=> FORCE_2048 12.009382 ms\n",
      "=> FORCE_4096 9.038925 ms\n",
      "=> HLL_32 4817.809582 ms\n",
      "=> HLL_64 8.984327 ms\n",
      "=> HLL_128 9.980440 ms\n",
      "=> HLL_256 9.007215 ms\n",
      "=> HLL_512 10.010004 ms\n",
      "=> HLL_1024 9.981155 ms\n",
      "=> HLL_2048 9.008884 ms\n",
      "=> HLL_4096 13.010502 ms\n",
      "=> HLL2_32 4876.504421 ms\n",
      "=> HLL2_64 9.007931 ms\n",
      "=> HLL2_128 11.000872 ms\n",
      "=> HLL2_256 8.985758 ms\n",
      "=> HLL2_512 9.983778 ms\n",
      "=> HLL2_1024 13.037920 ms\n",
      "=> HLL2_2048 12.005568 ms\n",
      "=> HLL2_4096 10.001659 ms\n",
      "=> KP07_32 5231.458187 ms\n",
      "=> KP07_64 9.008408 ms\n",
      "=> KP07_128 10.007620 ms\n",
      "=> KP07_256 9.014845 ms\n",
      "=> KP07_512 10.008812 ms\n",
      "=> KP07_1024 10.008812 ms\n",
      "=> KP07_2048 9.979963 ms\n",
      "=> KP07_4096 11.012316 ms\n",
      "=> KP07_dimsplit_32 4891.648769 ms\n",
      "=> KP07_dimsplit_64 14.011383 ms\n",
      "=> KP07_dimsplit_128 14.010668 ms\n",
      "=> KP07_dimsplit_256 12.012005 ms\n",
      "=> KP07_dimsplit_512 10.011673 ms\n",
      "=> KP07_dimsplit_1024 9.979486 ms\n",
      "=> KP07_dimsplit_2048 9.009123 ms\n",
      "=> KP07_dimsplit_4096 9.008408 ms\n",
      "=> WAF_32 4762.562752 ms\n",
      "=> WAF_64 8.006573 ms\n",
      "=> WAF_128 10.034561 ms\n",
      "=> WAF_256 9.008884 ms\n",
      "=> WAF_512 10.006428 ms\n",
      "=> WAF_1024 10.014057 ms\n",
      "=> WAF_2048 9.979248 ms\n",
      "=> WAF_4096 9.010315 ms\n",
      "Completed in 54.71460556983948 seconds\n"
     ]
    }
   ],
   "source": [
    "domain_sizes = [32, 64, 128, 256, 512, 1024, 2048, 4096]\n",
    "\n",
    "simulators = [LxF.LxF, FORCE.FORCE, HLL.HLL, HLL2.HLL2, KP07.KP07, KP07_dimsplit.KP07_dimsplit, WAF.WAF]\n",
    "simulator_ghost_cells = [1, 1, 1, 2, 2, 2, 2]\n",
    "simulator_reference = [LxF.LxF, FORCE.FORCE, HLL.HLL, HLL2.HLL2, KP07.KP07, KP07_dimsplit.KP07_dimsplit, WAF.WAF]\n",
    "simulator_courant_numbers = [0.95, 0.95, 0.95, 0.95, 0.95, 0.95, 0.95]\n",
    "force_rerun=True\n",
    "\n",
    "#simulators = [HLL2.HLL2, WAF.WAF]\n",
    "#simulator_ghost_cells = [2, 2]\n",
    "#simulator_reference = [HLL2.HLL2, WAF.WAF]\n",
    "#simulator_courant_numbers = [0.95, 0.95]\n",
    "#force_rerun=True\n",
    "\n",
    "with Common.Timer(\"simulation\", verbose=False) as timer:\n",
    "    for i in range(len(simulators)):        \n",
    "        for j, nx in enumerate(domain_sizes):\n",
    "            datafilename = gen_filename(simulators[i], nx)\n",
    "            run_benchmark(datafilename, \\\n",
    "                          simulators[i], \\\n",
    "                          simulator_courant_numbers[i], \\\n",
    "                          nx, 1, \\\n",
    "                          simulator_ghost_cells[i], \\\n",
    "                          force_rerun=force_rerun)\n",
    "            gc.collect()\n",
    "print(\"Completed in \" + str(timer.secs) + \" seconds\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_solution(simulator, nx, label, **kwargs):\n",
    "    datafilename = gen_filename(simulator, nx)\n",
    "    \n",
    "    #Read the solution\n",
    "    with np.load(datafilename) as data:\n",
    "        h = data['h']\n",
    "        \n",
    "    x = np.linspace(0.5, nx-0.5, nx)*10.0/float(nx)\n",
    "    \n",
    "    plt.plot(x, h, label=label, **kwargs)\n",
    "    \n",
    "    h = None\n",
    "    x = None\n",
    "    gc.collect() # Force run garbage collection to free up memory\n",
    "\n",
    "for simulator in simulators:\n",
    "    fig = plt.figure()\n",
    "    setBwStyles(fig.gca())\n",
    "    \n",
    "    #Plot reference solution\n",
    "    ref_x, ref_h, _ = gen_reference(4096)\n",
    "    plt.plot(ref_x, ref_h, '-', label='Reference')\n",
    "    ref_x = None\n",
    "    ref_h = None\n",
    "    gc.collect()\n",
    "    \n",
    "    #Plot simulation results\n",
    "    for j, nx in enumerate(domain_sizes):\n",
    "        plot_solution(simulator, nx, 'nx=' + str(nx), marker=' ')\n",
    "    plt.title(str(simulator.__name__))\n",
    "    plt.axis([0, 10, 0, 0.0055])\n",
    "    plt.legend()\n",
    "    \n",
    "    save_figure(fig, simulator.__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def downsample(highres_solution, factor):\n",
    "    assert(highres_solution.size % factor == 0)\n",
    "    nx = highres_solution.size / factor\n",
    "    return highres_solution.reshape([int(nx), int(factor)]).mean(1)\n",
    "\n",
    "conservation = np.zeros((len(simulators), len(domain_sizes)))\n",
    "error = np.zeros((len(simulators), len(domain_sizes)))\n",
    "\n",
    "for i, simulator in enumerate(simulators):\n",
    "    #Read the reference solution\n",
    "    _, h_ref, _ = gen_reference(4096)\n",
    "    \n",
    "    #Compute conservation and error for subsequent resolutions\n",
    "    for j, nx in enumerate(domain_sizes):\n",
    "        #Read current resolution\n",
    "        datafilename = gen_filename(simulator, nx)\n",
    "        with np.load(datafilename) as data:\n",
    "            h = data['h']\n",
    "        \n",
    "        #Downsample reference to current resolution\n",
    "        h_ref_downsampled = downsample(h_ref, h_ref.size/h.size)\n",
    "        \n",
    "        #Compute error per cell\n",
    "        error[i, j] = np.linalg.norm(np.abs(h_ref_downsampled - h), ord=1) / nx\n",
    "        conservation[i, j] = (np.sum(h_ref_downsampled) - np.sum(h))\n",
    "    \n",
    "fig = plt.figure()\n",
    "setBwStyles(fig.gca())\n",
    "\n",
    "x = np.linspace(domain_sizes[0], domain_sizes[-1], 100);\n",
    "\n",
    "scaling = np.max(error[:,0]) * domain_sizes[0] * 1.5\n",
    "plt.loglog(x, scaling/x, '-', color='gray', label='Order 1')\n",
    "\n",
    "scaling = np.min(error[:,0]) * domain_sizes[0]**2 * 0.5\n",
    "plt.loglog(x, scaling/(x*x), '-', color='gray', label='Order 2')\n",
    "\n",
    "for i, simulator in enumerate(simulators):\n",
    "    plt.loglog(domain_sizes, error[i,:], label=simulators[i].__name__)\n",
    "    \n",
    "plt.axis([10**1, 10**4, 10**-8, 10**-2])\n",
    "plt.xlabel('Number of cells')\n",
    "plt.ylabel('L2 error')\n",
    "plt.legend()\n",
    "save_figure(fig, 'convergence')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "setBwStyles(fig.gca())\n",
    "\n",
    "for i, simulator in enumerate(simulators):\n",
    "    a = np.arange(1, len(domain_sizes))\n",
    "    order = np.log2(error[i, :-1] / error[i, 1:])\n",
    "    #order = np.log2(error[i, 0] / (error[i, 1:]) )/a\n",
    "    plt.plot(order, label=simulator.__name__)\n",
    "    \n",
    "plt.ylim([0, 3])\n",
    "plt.xlabel('Number of cells')\n",
    "plt.ylabel('Order')\n",
    "plt.legend()\n",
    "save_figure(fig, 'convergence2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "figLegend = plt.figure()#figsize = (1.5,1.3))\n",
    "plt.plot(0, 0)\n",
    "plt.figlegend(*fig.gca().get_legend_handles_labels(), loc = 'center')\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def plot_comparison(**kwargs):\n",
    "    ref_x, ref_h, _ = gen_reference(4096)\n",
    "    plt.plot(ref_x, ref_h, '-', color='black', label='Analytic')\n",
    "    ref_x = None\n",
    "    ref_h = None\n",
    "    gc.collect()\n",
    "\n",
    "    for i, simulator in enumerate(simulators):\n",
    "        nx = 512\n",
    "        plot_solution(simulator, nx, simulator.__name__, **kwargs)\n",
    "        \n",
    "\n",
    "fig = plt.figure()\n",
    "setBwStyles(fig.gca())\n",
    "\n",
    "boxes = np.array([\\\n",
    "         [[3.5, 4.1], [0.0044, 0.00505]], \\\n",
    "         [[4.7, 5.05], [0.0025, 0.0027]],  \\\n",
    "         [[6.2, 6.40], [0.0009, 0.0026]] \\\n",
    "         ])\n",
    "\n",
    "plot_comparison(marker=' ')\n",
    "for box_x, box_y in boxes:\n",
    "    x = np.kron(box_x, np.ones((2)))\n",
    "    y = np.hstack((box_y, box_y[::-1]))\n",
    "    fig.gca().fill(x, y, fill=True, linestyle='-', color='gray', alpha=0.5)\n",
    "plt.xlim([0, 10])\n",
    "plt.ylim([0, 0.0055])\n",
    "plt.legend(loc='lower left')\n",
    "save_figure(fig, 'solution')\n",
    "\n",
    "for i, bbox in enumerate(boxes):\n",
    "    fig = plt.figure()\n",
    "    setBwStyles(fig.gca())\n",
    "    plot_comparison()\n",
    "    plt.xlim(bbox[0])\n",
    "    plt.ylim(bbox[1])\n",
    "    plt.legend()\n",
    "    \n",
    "    save_figure(fig, \"solution_zoom_\" + str(i))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}