From 058a5a04da64d3b36d8bd55a50a4598e3b1e840b Mon Sep 17 00:00:00 2001
From: "Bryan W. Weber" <bryan.w.weber@gmail.com>
Date: Tue, 19 Mar 2019 11:45:26 -0400
Subject: [PATCH] Update litium_ion_battery example

Put the title of the example as the first cell, so the website example
renderer shows something useful as the example summary. Fix small typos
in some math content. Use notebook matplotlib magic for plots.
---
 electrochemistry/lithium_ion_battery.ipynb | 1726 +++++++++++++++++++-
 1 file changed, 1639 insertions(+), 87 deletions(-)

diff --git a/electrochemistry/lithium_ion_battery.ipynb b/electrochemistry/lithium_ion_battery.ipynb
index 92ba943..20437bd 100644
--- a/electrochemistry/lithium_ion_battery.ipynb
+++ b/electrochemistry/lithium_ion_battery.ipynb
@@ -1,5 +1,12 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Lithium Ion Battery Example"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -9,29 +16,10 @@
     "If the stable release of 2.5.0 is not yet available, you might consider [building from source](https://cantera.org/install/compiling-install.html). Note also that 2.5.0, once released, is more recent than and supercedes 2.5.0a2, which is an alpha release."
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Runnning Cantera version: 2.5.0a2\n"
-     ]
-    }
-   ],
-   "source": [
-    "import cantera as ct\n",
-    "print('Runnning Cantera version: ' + ct.__version__)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Lithium Ion Battery Example\n",
     "## Open circuit calculations as a function of anode and cathode lithium content.\n",
     " \n",
     "In this example we will illustrate how to calculate the open circuit voltage (voltage when the external applied current is 0) for a lithium ion battery.  The thermodynamics are based on a graphite anode and a LiCoO2 cathode (the typical/standard active materials for commercial batteries, as of 2019), and are modeled using the 'BinarySolutionTabulatedThermo' class.\n",
@@ -101,7 +89,7 @@
     "For the kinetic routine, there are three processes to determine the cell voltage $\\phi_{\\rm cathode} - \\phi_{\\rm anode}$ which corresponds to the user-provided $i_{\\rm app}$:\n",
     "1. Determine the $\\phi_{\\rm elyte,\\,anode}$ value which corresponds to $i_{\\rm app}$, given $X_{\\rm Li, anode}$, the percentage of Li in the anode active material.\n",
     "2. Determine $\\phi_{\\rm elyte,\\,cathode}$, given $\\phi_{\\rm elyte,\\,anode}$ and $i_{\\rm app}$.\n",
-    "3. Determine the $\\phi_{\\rm cathode}$ which corresponds to $i_{\\rm app}$, given $phi_{\\rm elyte,\\,cathode}$ and $X_{\\rm Li, anode}$, the percentage of Li in the anode active material.\n",
+    "3. Determine the $\\phi_{\\rm cathode}$ which corresponds to $i_{\\rm app}$, given $\\phi_{\\rm elyte,\\,cathode}$ and $X_{\\rm Li, anode}$, the percentage of Li in the anode active material.\n",
     "\n",
     "The routines below are written generally such that an interested user may set $i_{\\rm app}$ to any value of interest.\n",
     "\n",
@@ -110,13 +98,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 143,
+   "execution_count": 1,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Runnning Cantera version: 2.5.0a2\n"
+     ]
+    }
+   ],
+   "source": [
+    "import cantera as ct\n",
+    "print('Runnning Cantera version: ' + ct.__version__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from __future__ import division\n",
-    "from __future__ import print_function\n",
-    "\n",
     "import numpy as np\n",
     "\n",
     "from scipy.optimize import fsolve\n",
@@ -125,8 +130,8 @@
     "import time\n",
     "\n",
     "# Plotting:\n",
+    "%matplotlib notebook\n",
     "import matplotlib.pyplot as plt\n",
-    "import matplotlib as mpl\n",
     "\n",
     "plt.rcParams['axes.labelsize'] = 16\n",
     "plt.rcParams['xtick.labelsize'] = 12\n",
@@ -149,12 +154,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "inputCTI = 'lithium_ion_battery.cti'\n",
+    "inputCTI = 'data/lithium_ion_battery.cti'\n",
     "anode = ct.Solution(inputCTI, 'anode');\n",
-    "cathode = ct.Solution(inputCTI,'cathode');\n",
+    "cathode = ct.Solution(inputCTI, 'cathode');\n",
     "# The 'elde' electrode phase is needed as a source/sink for electrons:\n",
-    "elde = ct.Solution(inputCTI,'electron');\n",
-    "elyte = ct.Solution(inputCTI,'electrolyte');\n",
+    "elde = ct.Solution(inputCTI, 'electron');\n",
+    "elyte = ct.Solution(inputCTI, 'electrolyte');\n",
     "anode_interface = ct.Interface(inputCTI, 'edge_anode_electrolyte', [anode, elde, elyte]);\n",
     "cathode_interface = ct.Interface(inputCTI, 'edge_cathode_electrolyte', [cathode, elde, elyte]);"
    ]
@@ -177,7 +182,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 131,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -211,13 +216,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 132,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
     "phases = [anode, elde, elyte, cathode, anode_interface, cathode_interface];\n",
     "for ph in phases:\n",
-    "    ph.TP = T,P\n"
+    "    ph.TP = T, P"
    ]
   },
   {
@@ -229,14 +234,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 133,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
     "def anode_curr(phi_l,I_app,phi_s,X_Li_an):\n",
     "\n",
     "    # Set the active material mole fraction\n",
-    "    anode.X = 'Li[anode]:'+str(X_Li_an)+', V[anode]:'+str(1-X_Li_an)\n",
+    "    anode.X = 'Li[anode]:' + str(X_Li_an) + ', V[anode]:' + str(1 - X_Li_an)\n",
     "\n",
     "    # Set the electrode and electrolyte potential\n",
     "    elde.electric_potential = phi_s\n",
@@ -253,7 +258,7 @@
     "def cathode_curr(phi_s,I_app,phi_l,X_Li_ca):\n",
     "    \n",
     "    # Set the active material mole fractions\n",
-    "    cathode.X = 'Li[cathode]:'+str(X_Li_ca)+', V[cathode]:'+str(1-X_Li_ca)\n",
+    "    cathode.X = 'Li[cathode]:' + str(X_Li_ca) + ', V[cathode]:' + str(1 - X_Li_ca)\n",
     "\n",
     "    # Set the electrode and electrolyte potential\n",
     "    elde.electric_potential = phi_s\n",
@@ -277,19 +282,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 150,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "49 cell voltages calculated in 0.36 seconds.\n"
+      "49 cell voltages calculated in 0.32 seconds.\n"
      ]
     }
    ],
    "source": [
-    "#Tic\n",
+    "# Tic\n",
     "t0 = time.time()\n",
     "\n",
     "# Initialize array of OCVs:\n",
@@ -300,21 +305,21 @@
     "    phi_s_an = 0\n",
     "    E_init = 3.0\n",
     "   \n",
-    "    phi_l_an = fsolve(anode_curr,E_init,args=(I_app,phi_s_an,X_an))\n",
+    "    phi_l_an = fsolve(anode_curr,E_init,args=(I_app, phi_s_an, X_an))\n",
     "    \n",
     "    # Calculate electrolyte potential at cathode interface:\n",
     "    phi_l_ca = phi_l_an + I_app*R_elyte;\n",
     "    \n",
     "    # Calculate cathode electrode potential\n",
-    "    phi_s_ca = fsolve(cathode_curr,E_init,args=(I_app,phi_l_ca,X_Li_ca[i]))\n",
+    "    phi_s_ca = fsolve(cathode_curr,E_init,args=(I_app, phi_l_ca, X_Li_ca[i]))\n",
     "    \n",
     "    # Calculate cell voltage\n",
     "    E_cell_kin[i] = phi_s_ca - phi_s_an\n",
     "    \n",
     "    \n",
-    "#Toc\n",
+    "# Toc\n",
     "t1 = time.time()\n",
-    "print('{:d} cell voltages calculated in {:3.2f} seconds.'.format(i,t1-t0))"
+    "print('{:d} cell voltages calculated in {:3.2f} seconds.'.format(i, t1 - t0))"
    ]
   },
   {
@@ -326,28 +331,808 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 152,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "\n",
+       "mpl.get_websocket_type = function() {\n",
+       "    if (typeof(WebSocket) !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert('Your browser does not have WebSocket support.' +\n",
+       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "              'Firefox 4 and 5 are also supported but you ' +\n",
+       "              'have to enable WebSockets in about:config.');\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent = (\n",
+       "                \"This browser does not support binary websocket messages. \" +\n",
+       "                    \"Performance may be slow.\");\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = $('<div/>');\n",
+       "    this._root_extra_style(this.root)\n",
+       "    this.root.attr('style', 'display: inline-block');\n",
+       "\n",
+       "    $(parent_element).append(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen =  function () {\n",
+       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
+       "            fig.send_message(\"send_image_mode\", {});\n",
+       "            if (mpl.ratio != 1) {\n",
+       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
+       "            }\n",
+       "            fig.send_message(\"refresh\", {});\n",
+       "        }\n",
+       "\n",
+       "    this.imageObj.onload = function() {\n",
+       "            if (fig.image_mode == 'full') {\n",
+       "                // Full images could contain transparency (where diff images\n",
+       "                // almost always do), so we need to clear the canvas so that\n",
+       "                // there is no ghosting.\n",
+       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "            }\n",
+       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "        };\n",
+       "\n",
+       "    this.imageObj.onunload = function() {\n",
+       "        fig.ws.close();\n",
+       "    }\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function() {\n",
+       "    var titlebar = $(\n",
+       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
+       "        'ui-helper-clearfix\"/>');\n",
+       "    var titletext = $(\n",
+       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
+       "        'text-align: center; padding: 3px;\"/>');\n",
+       "    titlebar.append(titletext)\n",
+       "    this.root.append(titlebar);\n",
+       "    this.header = titletext[0];\n",
+       "}\n",
+       "\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = $('<div/>');\n",
+       "\n",
+       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
+       "\n",
+       "    function canvas_keyboard_event(event) {\n",
+       "        return fig.key_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
+       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
+       "    this.canvas_div = canvas_div\n",
+       "    this._canvas_extra_style(canvas_div)\n",
+       "    this.root.append(canvas_div);\n",
+       "\n",
+       "    var canvas = $('<canvas/>');\n",
+       "    canvas.addClass('mpl-canvas');\n",
+       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
+       "\n",
+       "    this.canvas = canvas[0];\n",
+       "    this.context = canvas[0].getContext(\"2d\");\n",
+       "\n",
+       "    var backingStore = this.context.backingStorePixelRatio ||\n",
+       "\tthis.context.webkitBackingStorePixelRatio ||\n",
+       "\tthis.context.mozBackingStorePixelRatio ||\n",
+       "\tthis.context.msBackingStorePixelRatio ||\n",
+       "\tthis.context.oBackingStorePixelRatio ||\n",
+       "\tthis.context.backingStorePixelRatio || 1;\n",
+       "\n",
+       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband = $('<canvas/>');\n",
+       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
+       "\n",
+       "    var pass_mouse_events = true;\n",
+       "\n",
+       "    canvas_div.resizable({\n",
+       "        start: function(event, ui) {\n",
+       "            pass_mouse_events = false;\n",
+       "        },\n",
+       "        resize: function(event, ui) {\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "        stop: function(event, ui) {\n",
+       "            pass_mouse_events = true;\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "    });\n",
+       "\n",
+       "    function mouse_event_fn(event) {\n",
+       "        if (pass_mouse_events)\n",
+       "            return fig.mouse_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
+       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
+       "\n",
+       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
+       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
+       "\n",
+       "    canvas_div.on(\"wheel\", function (event) {\n",
+       "        event = event.originalEvent;\n",
+       "        event['data'] = 'scroll'\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        mouse_event_fn(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.append(canvas);\n",
+       "    canvas_div.append(rubberband);\n",
+       "\n",
+       "    this.rubberband = rubberband;\n",
+       "    this.rubberband_canvas = rubberband[0];\n",
+       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
+       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
+       "\n",
+       "    this._resize_canvas = function(width, height) {\n",
+       "        // Keep the size of the canvas, canvas container, and rubber band\n",
+       "        // canvas in synch.\n",
+       "        canvas_div.css('width', width)\n",
+       "        canvas_div.css('height', height)\n",
+       "\n",
+       "        canvas.attr('width', width * mpl.ratio);\n",
+       "        canvas.attr('height', height * mpl.ratio);\n",
+       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
+       "\n",
+       "        rubberband.attr('width', width);\n",
+       "        rubberband.attr('height', height);\n",
+       "    }\n",
+       "\n",
+       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
+       "    // upon first draw.\n",
+       "    this._resize_canvas(600, 600);\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus () {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            // put a spacer in here.\n",
+       "            continue;\n",
+       "        }\n",
+       "        var button = $('<button/>');\n",
+       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
+       "                        'ui-button-icon-only');\n",
+       "        button.attr('role', 'button');\n",
+       "        button.attr('aria-disabled', 'false');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "\n",
+       "        var icon_img = $('<span/>');\n",
+       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
+       "        icon_img.addClass(image);\n",
+       "        icon_img.addClass('ui-corner-all');\n",
+       "\n",
+       "        var tooltip_span = $('<span/>');\n",
+       "        tooltip_span.addClass('ui-button-text');\n",
+       "        tooltip_span.html(tooltip);\n",
+       "\n",
+       "        button.append(icon_img);\n",
+       "        button.append(tooltip_span);\n",
+       "\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker_span = $('<span/>');\n",
+       "\n",
+       "    var fmt_picker = $('<select/>');\n",
+       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
+       "    fmt_picker_span.append(fmt_picker);\n",
+       "    nav_element.append(fmt_picker_span);\n",
+       "    this.format_dropdown = fmt_picker[0];\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = $(\n",
+       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
+       "        fmt_picker.append(option)\n",
+       "    }\n",
+       "\n",
+       "    // Add hover states to the ui-buttons\n",
+       "    $( \".ui-button\" ).hover(\n",
+       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
+       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
+       "    );\n",
+       "\n",
+       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function(type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function() {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1]);\n",
+       "        fig.send_message(\"refresh\", {});\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
+       "    var x0 = msg['x0'] / mpl.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
+       "    var x1 = msg['x1'] / mpl.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch(cursor)\n",
+       "    {\n",
+       "    case 0:\n",
+       "        cursor = 'pointer';\n",
+       "        break;\n",
+       "    case 1:\n",
+       "        cursor = 'default';\n",
+       "        break;\n",
+       "    case 2:\n",
+       "        cursor = 'crosshair';\n",
+       "        break;\n",
+       "    case 3:\n",
+       "        cursor = 'move';\n",
+       "        break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message(\"ack\", {});\n",
+       "}\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            /* FIXME: We get \"Resource interpreted as Image but\n",
+       "             * transferred with MIME type text/plain:\" errors on\n",
+       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "             * to be part of the websocket stream */\n",
+       "            evt.data.type = \"image/png\";\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src);\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                evt.data);\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig[\"handle_\" + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function(e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e)\n",
+       "        e = window.event;\n",
+       "    if (e.target)\n",
+       "        targ = e.target;\n",
+       "    else if (e.srcElement)\n",
+       "        targ = e.srcElement;\n",
+       "    if (targ.nodeType == 3) // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "\n",
+       "    // jQuery normalizes the pageX and pageY\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    // offset() returns the position of the element relative to the document\n",
+       "    var x = e.pageX - $(targ).offset().left;\n",
+       "    var y = e.pageY - $(targ).offset().top;\n",
+       "\n",
+       "    return {\"x\": x, \"y\": y};\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys (original) {\n",
+       "  return Object.keys(original).reduce(function (obj, key) {\n",
+       "    if (typeof original[key] !== 'object')\n",
+       "        obj[key] = original[key]\n",
+       "    return obj;\n",
+       "  }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event)\n",
+       "\n",
+       "    if (name === 'button_press')\n",
+       "    {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * mpl.ratio;\n",
+       "    var y = canvas_pos.y * mpl.ratio;\n",
+       "\n",
+       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
+       "                             step: event.step,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function(event, name) {\n",
+       "\n",
+       "    // Prevent repeat events\n",
+       "    if (name == 'key_press')\n",
+       "    {\n",
+       "        if (event.which === this._key)\n",
+       "            return;\n",
+       "        else\n",
+       "            this._key = event.which;\n",
+       "    }\n",
+       "    if (name == 'key_release')\n",
+       "        this._key = null;\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.which != 17)\n",
+       "        value += \"ctrl+\";\n",
+       "    if (event.altKey && event.which != 18)\n",
+       "        value += \"alt+\";\n",
+       "    if (event.shiftKey && event.which != 16)\n",
+       "        value += \"shift+\";\n",
+       "\n",
+       "    value += 'k';\n",
+       "    value += event.which.toString();\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, {key: value,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
+       "    if (name == 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message(\"toolbar_button\", {name: name});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.close = function() {\n",
+       "        comm.close()\n",
+       "    };\n",
+       "    ws.send = function(m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function(msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(msg['content']['data'])\n",
+       "    });\n",
+       "    return ws;\n",
+       "}\n",
+       "\n",
+       "mpl.mpl_figure_comm = function(comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = $(\"#\" + id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm)\n",
+       "\n",
+       "    function ondownload(figure, format) {\n",
+       "        window.open(figure.imageObj.src);\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy,\n",
+       "                           ondownload,\n",
+       "                           element.get(0));\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element.get(0);\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "\n",
+       "    var output_index = fig.cell_info[2]\n",
+       "    var cell = fig.cell_info[0];\n",
+       "\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
+       "    var width = fig.canvas.width/mpl.ratio\n",
+       "    fig.root.unbind('remove')\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable()\n",
+       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
+       "    fig.close_ws(fig, msg);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width/mpl.ratio\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<IPython.core.display.Javascript object>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\" width=\"640\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
      },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "plt.figure()\n",
-    "plt.plot(100*X_Li_ca, E_cell_kin,color='b',linewidth=2.5)\n",
-    "plt.ylim([2.5,4.3])\n",
-    "plt.xlabel('Li Fraction in Cathode (%)',fontname='Times New Roman',fontsize=18)\n",
-    "plt.ylabel('Open Circuit Potential (V)',fontname='Times New Roman',fontsize=18)\n",
+    "plt.plot(100*X_Li_ca, E_cell_kin, color='b', linewidth=2.5)\n",
+    "plt.ylim([2.5, 4.3])\n",
+    "plt.xlabel('Li Fraction in Cathode (%)', fontname='Times New Roman', fontsize=18)\n",
+    "plt.ylabel('Open Circuit Potential (V)', fontname='Times New Roman', fontsize=18)\n",
     "\n",
     "ax = plt.gca()\n",
     "\n",
@@ -356,9 +1141,7 @@
     "    tick.label1.set_fontname('Times New Roman')\n",
     "for tick in ax.yaxis.get_major_ticks():\n",
     "    tick.label1.set_fontsize(14)\n",
-    "    tick.label1.set_fontname('Times New Roman')\n",
-    "    \n",
-    "plt.show()\n"
+    "    tick.label1.set_fontname('Times New Roman')"
    ]
   },
   {
@@ -366,7 +1149,7 @@
    "metadata": {},
    "source": [
     "### Thermodynamic Equilibrium Calculation\n",
-    "For the I_app = 0 case, we can also calcualte the voltage using thermodynamics.  At equilibrium, the net electrochemical potential change of the reaction must be zero:\n",
+    "For the $i_{app} = 0$ case, we can also calcualte the voltage using thermodynamics.  At equilibrium, the net electrochemical potential change of the reaction must be zero:\n",
     "\n",
     "\\begin{equation}\n",
     "\\sum_k\\nu_k\\tilde{\\mu}_k = 0\n",
@@ -385,41 +1168,41 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 154,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "49 cell voltages calculated in 0.01 seconds.\n"
+      "49 cell voltages calculated in 0.02 seconds.\n"
      ]
     }
    ],
    "source": [
-    "#Tic\n",
+    "# Tic\n",
     "t0 = time.time()\n",
     "\n",
     "# Initialize array of OCVs:\n",
     "E_cell_therm = np.zeros_like(X_Li_ca)\n",
     "\n",
-    "for i,X_an in enumerate(X_Li_an):\n",
+    "for i, X_an in enumerate(X_Li_an):\n",
     "    #Set anode electrode potential to 0:\n",
-    "    anode.X = 'Li[anode]:'+str(X_an)+', V[anode]:'+str(1-X_an)\n",
+    "    anode.X = 'Li[anode]:' + str(X_an) + ', V[anode]:' + str(1 - X_an)\n",
     "    dG_an = anode_interface.delta_gibbs[0]\n",
     "    n_charge = -1.\n",
     "    E_eq_an = -dG_an/n_charge/ct.faraday\n",
     "    \n",
-    "    cathode.X = 'Li[cathode]:'+str(1.-X_an)+', V[cathode]:'+str(X_an)\n",
+    "    cathode.X = 'Li[cathode]:' + str(1. - X_an) + ', V[cathode]:' + str(X_an)\n",
     "    dG_ca = cathode_interface.delta_gibbs[0]\n",
     "    n_charge = 1.\n",
     "    E_eq_ca = -dG_ca/n_charge/ct.faraday\n",
     "    \n",
     "    E_cell_therm[i] = E_eq_ca - E_eq_an\n",
     "    \n",
-    "#Toc\n",
+    "# Toc\n",
     "t1 = time.time()\n",
-    "print('{:d} cell voltages calculated in {:3.2f} seconds.'.format(i,t1-t0))"
+    "print('{:d} cell voltages calculated in {:3.2f} seconds.'.format(i, t1 - t0))"
    ]
   },
   {
@@ -431,32 +1214,812 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 166,
+   "execution_count": 10,
    "metadata": {
     "scrolled": false
    },
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xd4VFX6wPHvGwhVQBQUFIEAAiERELBHJXYXFXRtUVEwlrXEiqtrXHtWV11RsWvQtYDlZ13BhgMrsYdFAY0oTQULAUEBgbT398e5A8MwM5lJZjJD8n6e5z6Z2845c4l5PeWeI6qKMcYYk2rSkl0AY4wxJhQLUMYYY1KSBShjjDEpyQKUMcaYlGQByhhjTEqyAGWMMSYlWYAyxhiTkixAGWOMSUkWoIwxxqSk5skuQLx16tRJe/bsmexiGGOMCWPWrFkrVLVzbdc1ugDVs2dPSktLk10MY4wxYYjId9FcZ018xhhjUpIFKGOMMSnJApQxxpiU1Oj6oIwx267KykqWLl3Khg0bkl0UEwetWrWiW7dupKen1+l+C1DGmJSxdOlS2rVrR8+ePRGRZBfH1IOqsnLlSpYuXUpGRkad0rAmPmNMytiwYQM77rijBadGQETYcccd61UbtgBljEkpFpwaj/r+WyY1QIlICxH5QkSGhzjXQUReFJHfRWS2iOybhCIaY4xJkmTXoK4CeoY5dzXwMpAL/Ai8JiJtE1aSyZMhOxuaNXM/J0+u37l4p9fQeRnTBK1cuZLBgwczePBgunTpwq677srgwYPZfvvtGTBgQLKLt8mMGTM45phjkpL366+/zu23394wmalqUjZgf+BsYAkwPMT5QwI+dwAqgb1qS3fo0KEas0mTVDMyVH0+1YoK9zMjwx2vy7mLL45veg2dlzFJ8tVXXyW7CJvccMMNeuedd6qq6uLFizUrK6vOaVVWVsarWKqqOn36dB0xYkRc00yUUP+mQKlGEyeiuSjeG9AWuNv7HDJAhbhnJdA1zLnzgFKgtHv37rE/wawsrXnPpy1a6Kbt8OY+nSdZOk+y9PDmsZ1bT8uY70lWXi1bqmZnuzj33xt9Wtk/ywWprCzVtDT304KWaSCBf8wuvVT14IPjv116aXRlCQ5Q/fv313POOUcHDBighx9+uP7xxx+qqrpgwQI98sgjdciQIZqTk6NlZWWqqnrWWWfp5ZdfrsOHD9crrrhCb7jhBj3zzDP18MMP1x49euhLL72kV111lWZnZ+uRRx6pFRUVqqo6bdo0HTx4sGZnZ+vYsWN1w4YNqqr65ptvar9+/fSAAw7QgoICHTFihFZXV2ufPn10+fLlqqpaXV2tvXv31vLycj3rrLO0oKBA99tvP83IyNAXX3xRVVXXrFmjhxxyiO65556anZ2tr7766qbv2K9fP83Pz9esrCw97bTT9N1339X9999f+/Tpo5988omqqj7xxBN60UUXqarqzz//rKNGjdKBAwfqwIED9YMPPoj4b+qX6gHqZmAnjTJAAX2Bl6JJu041qLQ0rdlYoaCbtuZUaBVpWkWaNie2czUQ8z2pklc1oj+kZ+h9x/v05ecrdNXLVrMyDSfwj9nBB+sWv5/x2g4+OLqyBAeoZs2a6ezZs1VV9aSTTtKnn35aVVUPOeQQ/eabb1RV9eOPP9bc3FxVdQFqxIgRWlVVtSm9Aw44QCsqKvTzzz/X1q1b69SpU1VVddSoUfrKK6/o+vXrtVu3bjp//nxVVR09erSOHz9+0/FvvvlGa2pq9KSTTtpUg7rxxht1/Pjxqqr69ttv6wknnLAp/xNPPFGrq6v1yy+/1N69e6uqq8399ttvqqpaXl6uvXv31pqamk3fcc6cOVpdXa1DhgzRsWPHak1Njb766qs6cuRIVd0yQJ188smb8q6qqtLVq1dH/Df1izZANfh7UCJypFe45THcdhGuvyoxMjOhpIRrrsnddKjXdyWUv5sJwIOHl7CoR/Tnql5oyYMnx3ZPsvL6umsupaXw8cewf0UJFbRgdGUxM17JhVcAcjlzt2L+cVEB71XmcdSqyXR+rAgpK3PPrbAQ8vJc4pMnQ1ERxHIu0j2mSRs8OLXSzcjIYLB389ChQ1myZAlr167lww8/5KSTTtp03caNGzd9Pumkk2jWrNmm/aOPPpr09HT22GMPqqurOeqoowDYY489WLJkCfPnzycjI4O+ffsCcNZZZ/HAAw8wfPhwMjIy2H333QE444wzePTRRwE4++yzGTlyJJdddhkTJ05k7Nixm/IbNWoUaWlpDBgwgF9++QVwlZJrr72W999/n7S0NJYtW7bpXEZGBnvssQcAWVlZHHrooYjIpvIF8/l8PPXUUwA0a9aMDh061O3hhhNNFIvnBrwLrAjYqoHfgL+Guf4w4Pho07c+qLqlt+FNn/7RNUOrEc3NqdAWLbaudZ3KJF1Ihp7UyacnjqzQ8SN9+mvHDH337En66eWTdP0uGbr0aZ8uX1aha//j05qeGVrzbB3L7v93CdfUWJdzqZKeCWtb6YO688479YYbbtDffvtNu3TpEvL+s846a1OzWnB6qqpt27bd6tzs2bP1wAMP3HR82rRpevzxx+vs2bP1oIMO2nT8tdde26IP6qijjtL33ntPe/bsuanGFpy/P78nnnhCTz755E1Nij169NDFixdv9R0D7w88F1iD6tSp06YmyHC2qRoUcBrQMmD/I+AK4O3gC0UkE+ilqo8mtET+/2MvKNj8f/JFRVv+n3ys5/bfP77pJTivlpmZ8K8iKCrCd3MJf+yTyyefwMyZ8PtrJcyfnUmhFpFPMTNW5MJr8H/k8hrFTJhYAMDRFDNjtL+2lstwiplwegEicE2bYj49NZfmzaFZs1wOqCjmyfuP5txub1J60ebje6cX89f8Ap66Ac7/oZA7+xXz1cE5DFpTwuX5+Tx9B6SlwRlfF/LQ0GK+OT6HAb+WcP55+bz0kBuQePysQp49pJjvc3PY/ZcSTrkgn2/u/pB+C6cw9YRifhmdw27flXBEQT6fvOPS2/v1Qj4YW0z55TnsvKCE/S/N54sS900Gv1jIJ+cVs/q6HLouLGHwFfn8+sKHdPp0Ct/9vZiKvXPY4asSdr4mnw1roUULSL+pECkuhpwcKCmB/Pwtf9dMo9C+fXsyMjJ48cUXOemkk1BV5syZw6BBg+qUXv/+/VmyZAkLFiygT58+PP300xx88MH079+fxYsXs3DhQnr37s3koBG355xzDmeccQajR4/eosYWym+//cZOO+1Eeno606dP57vvolr5IqRDDz2Uhx56iMsuu4zq6mrWrVtH+/bt65zeVqKJYoEbblj4fsBewM6x3h8ivSV4fVDAOKCf97kXMN7LrycwCLigtvTqVIMym4Wp7VQ+NUlr0tJ0/B0VOmqUar9+qh07Jq7/bC5ZOhzfFueG49O5ZNXp3HpaNmh6ufi0dWvVAQNUn35atXqaz9WkTETbWg1KVXXRokV65JFH6sCBAzUzM1NvuukmVa1bDUo1ukESV1999RY1qIqKCm3Xrt2mARqh8vfnV15ervvuu68OHTpU8/PztX///nWuQf3888963HHHaXZ2tg4aNEg//PDDrZ5jfWpQ4q6NTER2x/UBjQQ6BZ1eBPwbmKCqv8UaIEVkCTBGVWeIyCzgNuAD4BNgt6DLT1XV5yOlN2zYMLUFC+spXL9QdjZMmAC5m/u0Kt+ZDpcUUFUFc8+dQFmXXNasgY0boUvZdA57vQBVePHACXy5Uy5VVVBdDX2XTWfce0dz20FvMrfT5uNZy6dz/pcF7La2jCMP2kCFplNdDTU1IFWVzCxtBcDee2xgY006NTVQVeXOfbXYneux0wY2VKdTWenOaUUl66pa0IIKqtg8aWVzKtmAu6cVG2I6V0Fs6e09pJKPP2+FVFfH7Z+pMSorKyMzMzPZxdjmlJaWcvnllzNz5sxkF2Urof5NRWSWqg6r9ebaIhguYKzG9R3dC1wOnOttVwIP4YLJz8CIaKJiIjerQSVQQ/afZWW5/UA+rxZSh3M1LVtq1bs+Xb9e9fffVVetUl39ik8r+2VpRb8sXf68TxcvVl24UHXBAtWlT/t0w+5ZumH3LP3uSZ+WlanOmaNaWqo69z6fVqe31E//6dPXX1d98UXVp55Sff0Kn5Z3ydLlO2XpxNE+vewy1Z133rJ2ddxxqkvvsv6pcFKpBrWtuO2227R79+46c+bMZBclpIQMMwcEeBb4K9Cm1oRgFy+AnRZNxonaLEAlWEMNNEjRwSSxprfm1wqdONqniyRDT2XSpoEm94x0g0nsBektWYBqfBIVoM4H9owmkaD7TgUyY70vXpsFqEYkVUbdxSG9lfdP0rPP1i36tLbfXvWJJ1Rr3rP+KT8LUI1PQvqgRGSYqtapM0dEBqnqF3W5t76sD8qkMm3WjD/lbuCt9zb3Tx19WCVTfNY/BdYH1RjVpw8q0mSxdZ4ZMVnByZhUJ5mZvFlYwquvQteu7tj6aSWUaSb33w81z9oEvsb4RQpQ/xKRExqsJMY0BYWFkJ/PyPbT+eqLSu44ejrF5HOLFvJBwWR+zi/k+6smwIYNbsRkYaEFKdNkRQpQG4DjReRDEblEROL49pUxTVRenhvCX1DA9l1acdX3BfxxbRGfZORRSBGnbyym7/m5FN6YzsqBuVBc7K43oSVgyZjttttu0+epU6ey++678/333/Pwww9vmtYnVkuWLGHSpEmb9ktLS7nkkkvqXdZGL1znFHCK97MFMBp4D3gYGBhN51ayNhskYbZFa9eqVkuapge8uLzddqrXXlWhNWlpyS5eg4lpkESClozxv9A6bdo07dWrly5YsKBe6aluW8tjxFt9BkmErUGp90Ksqlao6tOqeijwKHCpiLwtIqeISDKmSjKm0WnbFtIGZDJ7Qgn77OOOrV0LH97p+qcmHTuZqkzrm9pCUZGrYebmQnq6+xmnGufMmTM599xzmTJlCr179wbgxhtv5K677gJg+PDhXH311ey999707dt30wuy1dXVXHXVVey1114MHDiQRx55BIBrrrmGmTNnMnjwYMaPH7/FgoNr165l7Nix7LHHHgwcOJCXXnqp3uVvLGIKMKr6PyBfRDriFhv8SkQmAY+q6o+JKKAxTUZhIVmF+Xz0eDHvrs/h9b+WcMVX+UzREYx4o5BjWxYz6LIcbji0hNYX29x+lJW5uQ4D5eS44/WwceNGRo4cyYwZM+jfv3/Y66qqqvj000+ZOnUqN910E9OmTaO4uJgOHTrw2WefsXHjRg444ACOOOIIbr/9du666y7eeOMNwK2I63fLLbfQoUMH5s6dC8CqVavqVf7GJOYl30WkBXA8cBbQB7gW+Gecy2VM0+P1T8klBRxxXCsmSAHr/lbEiDbTyaeYtzbm8s+70zlhQi5Vj1jflH+ZnC2UlLjj9ZCens7+++9PcXFxxOtOOMGNIfMvvQHwzjvv8NRTTzF48GD22WcfVq5cybfffhsxnWnTpnHRRRdt2u/YsWO9yt+YhA1Qwc13ItJZRG4Avgcew82TdxfQW1VHJ7SUxjQVeXkwbx5UVyPz5rHHP/LI2FDG39/KYa+93CVvvQUFz+eg9awpbPO8EZFMnw6Vle5nfr47Xg9paWm88MILfPbZZ/zjH/8Ie13Llm5RhmbNmlFVVQW4Pv0JEybw+eef8/nnn7N48WKOOOKIiPmpKiJSrzI3VpFqUOcDiEi2iDwOfAfcAKwBLgW6qepfVfWHxBfTmKZLMjM5pEUJPh8MGeKOfV1cworOTfyF1oARkbRq5X4GLydTR23atOGNN97g2WefrbUmFejII4/koYceorKyEoBvvvmGdevW0a5dO9asWRPyniOOOIL7779/07418W0WKUD9U0TmAV/g+ps+xTXt9VXV+1V1XUMU0Jgmz6spbPfZdN54pZKTO7t3py75pZDnnkt24ZIsoMbJvHlx7ZPbYYcdeOutt7j11lt57bXXorrnnHPOYcCAAQwZMoTs7GzOP/98qqqqGDhwIM2bN2fQoEGMHz9+i3uuu+46Vq1aRXZ2NoMGDWL69Olx+w7bukhTHdUAlcDzwHhVnR33zF1/1mfApao6I8T5o4ERuEDqU9X/qy1Nm+rINEoBS6Bs6JXJhcsKeWJ9Hi1awLRpcOCByS5gfNhUR41PoqY6moPrXzozEcHJcxVuMcKtiEhfoAi4RFUvBC4RkewElcOY1BZQU2j17TxO/08ezZtDRQU8dfRkNva1Ieim8YkUoG5W1aWJylhE9gd+AsI1uF4BvKWqNd7+27j1p4xp8g49FB57DE5lMn9bV8jZayew/HubHsk0LpEC1Pd1TVREBtdyvi1woqpOjHDZIcDigP35wPC6lsmYxmbMGLincxH5FDPpp1yOPSGd8uxtf3qkcN0OZttT33/LSAFqT2+p95iIyHlAbUu/Xw3cXss1uwIrA/bX4BZFDJmniJSKSGl5eXnUZTVmW7fTyjJ6nu5eVv30Uxg0CGZU1f9l1WRp1aoVK1eutCDVCKgqK1eupFWrVnVOI9JMEo8Dj4nI/4CJqrohUkIi0h3XZ/R/qro4wnVH4uZhWl5L2RRYH7DfEjdoY+sLVR/FTcPEsGHD7DfbNBmSmcmjZ5awviqX55+Hn36Cm48oIbNzJjtWQfNtbDKybt26sXTpUux/NBuHVq1a0a1btzrfH/bXV1VVRM4HbgPKReQDYC6wDFiHm0S2A5ABDAU64ZZ7LwmTpN84XO3Mv98ReE1EilT1joDrlnnn/NoBNp2SMYEKC0n/Sz6THy/m8OE5vHhpCQ9W5HNZeRHfHwyvnjKZzo+60X9kZrr+qRSeHik9PZ2MjIxkF8OkiIj/f6Wq1cBfReQpXGA5BxeUAs0BngXuV9X11O40XG3I7yPcgIi3g657F+gXsN8XsBcEjAnkBRu5pID8sjJO75XJDRuLeO6HPE79cDLrPi6k7PpiDro2x00DlG9z+JltR9j3oEJe7Ko9vYHOwB/AD6r6a70KILIEGKOqM0RkHPAfVZ3vDSl/XFX39fJ9H/iLqn4ZKT17D8o0devXw7hxcMGD2RQwgRnkMmoUjB4NI9pMp+W4Ajdk3ZgkifY9qJgCVCIEBahZwG3+F3JF5AzAm9yF/6pqra9zW4AyxtFmzdi5/QbKV6dvOtZxu0pWrGvFF+OeYdCUItK+3jaa/kzjEm2ASnoXqqr2DPg8NOjcM8AzDV0mYxoDycxk3t9LuGpqLi+/7NaXGrS2hGXsQoc7Cxm1XTG7jMnh8r1K6FdoTX8m9cS83IYxZhtRWMhOf8vn32Oms3xZJf+9cTrPtXWBKJ9i/rM2l0cmptP/glwu3a6Y368uoro6yWU2JoAFKGMaq4DZvlt3bMVBLxaw82NFdEv7kfP+ncOxx24ehv7g3Bza/lBG377w1pjJVA+wqZNM8sWliU9E2trs5sakoLy8rZrtpKiIvN1KyHs9lx9+gPvvh68eKKFsXSZ7L5pM30WFjGpbTNZlOVw2rIQu1vxnkiReNagxcUrHGJNoAQv97dalkn8eNZ3XOuez7KxCbkp3Uye9sc6t3rvL6bkUdilmzd+KqKmpPWlj4inSchtzgbZRpNEM2EVV02u9sgHYKD5johCwfEfgKD5t1ozXn9/Av+5LZ+ZMd2lzKtlAK/r3qeaefSZz1Kwimn1jo/9M3cVjFN9nQDbwNRCp6zQdN7GrMWZbEaLpD9zIv5E7ljDy/Vy++AIefBC+/3cJZRszGbZgMpkLChnRopjdRudwyZASsgvzEX96xsSbqobcgH1xq+eGvSbg2qOiua4htqFDh6oxpo4mTVLNyFD1+VQrKlR9Pq3qkaFTR0/S+S2ydDg+Bd20nbGrT5fvlKU//ODdm5Wlmpbmfk6alOxvY1IUbj7W2mNLNBdFTAD2AlrWN514bRagjKmnMIGmJi1N351aoccfr9q8ufvr0ZwKrSJNT5NJ+mPrDPX93ad//OYCm2ZkWJAyIUUboGIaJCEirUVkVxHp7t+AnYBI6zoZY7YlAav3Mm/e5vn+MjM5rFUJL78My5bB3XfDmRkllJHJ37SI09YXc8gtuXTqms6f78/l3VOLqb65yPV3ZduwdRO7qIeZi0g+8BBuUESwNXErkTEmNflH/xUXs1NODpcPLkHJZ0lRET2uO4MvO+TAavjjD3j5ZXidHDbyFT/lF/LJecXsPSWHXRbZhLUmerHUoC4F/oWb1fwZ4GwgH3gLODT+RTPGpJSAF39p1QoKCpCiIjKuzSNtQCZLn3O1q9GjYfvtIYcSKmjBaeuLOf7eXHbtmc6B1+fyyjHFVN7krfhrtSsTSTTtgK7JkHsCPhcFfD4IuDnadBK9WR+UMUkQNLii8h2fruuSodWI9tilYouBFf5+q1sGTNLfOmXo6lc2D8iwfqumgQT0QQVeu1BEcr3Pa4Bz6x8qjTHbrKDaVfPLC2hzdxFpWQNY9FQJn3zilgDp3t3VrMrIZNRXRYxcUcyOJ+Zy2NHp3Dwzl/9dVEzNLVa7Mp5oopgLeNwJLMU18aUDs4DncSvffhdtOonerAZlTAoJqllVT/Pp+l0y9N9HTdIq0rQ5oWtX1/WepCs6ZOj7N/l0+TKrXTU2xHuYuReUCvHeeQL6A/8FPgUOizYd796DgfnAKgKaDkNcdy1wnffzVryZLyJtFqCMSTHhhq1nZenn43164YWq/fq5v0bD8elcsnQuW75zlZ2teu8on67eLUvLy8OnabYNcQ9QEROBZjFc28ELOB2BEUBlqAAHHAM8FrA/ETiltvQtQBmzjQiqXf36kk/X7pyhT//J1a5aNQtduzqVSfpDeobed7xPJ/27Qr//t09r/LUrC1zbhIYOUBfEcG3rwJqQ11SYG+K6q4DnAvYfAM6rLX0LUMZsQ8IFlKwsXT/Vpz6f6vXXqx50kOrhzUPXrkD1mLY+/aVlN13RIUOnX+/ThV+75sQtmgUteKWMegcooISA0XnAXGBRiO07oDKazELk0RY3ZH2rpjsgE/gDONGrbT0PtK4tTQtQxjQCIaZcqu6ZofMKJ2m1pOnwAyq0RYsta1c1sEXgattW9YL+Pl26fZZOOWOSruuSoSte9GnNRuvTSrZ4BKjbgJMD9h/HTSD7NPBEwPYM8GM0mQWlfyDwvhd42oa5ZiSwDngTaBMhrfOAUqC0e/fuiXuqxpiGE6F2pT6fbtigWlqq+vDDqncc7dMa0JZpoZsFA2tdnTqpHnaY6sOn+HRVtyz96ivV6mesdtWQEjFIYm+gX5hzMU8WC3TFvey7AngwzDUnAocD3wL/AdJrS9dqUMY0ciFqV5qRodqtm25406cffaT64IOqF12keulAn37VLCviiMFTmaSLJEMv6O/T88ZW6PN/8em6nTP0l3smWeBKkEQEqD5hjg+JZnRdhHTHAF+GOH4w8E/v8y7AD8DVtaVnAcqYJiBU7SpM4Kp5dpJW9MvSz+7w6b/+pXrmmaoDB6oemha+T2s4Pv2ebrpIMvTcPj49M69CXy7w6YZdM1zQClcGE5VEBKhwtZwewEPRphPi/mzgnRDH7wfOD9g/C3ijtvQsQBnThIULGmH6tBYVuT6tgr9U6AEHqO6ww+baVXCflj9wfZmWpUXZk/TX7TN01l0+XfOr9WnFKi4BygseZ3rbewGfA7fbgdXRZOal2QbYM2D/r8AI7/M4fzMicA7wcMB1ZwDX15a+BShjTEi19GmpqtbUqP7yi+rn412f1mUXVehhh6l27rw5cAX3afmTu+0In67omqUffaS68UmrXUUSrwDVHLgA2IBbVbcmzHZvNJl5ae4NlAMzcbNTnBRwbhZwovc5DbgZuMYLVjcRxbpTFqCMMTGJ0KcVGLi++UZ16lVuVGBtfVoLydD83q5P6/UrXNNg5VPWNOgX1yY+4Gjc6L0eQVt3YIdo0miozQKUMSZmMfRp+a9d9bJPX31V9dprVY84QvW4dpH7tOZJll6/+yQtb5+h717r08XfVGjNe02zaTARfVCZEc7tGm06id4sQBlj4iaGPq2aDDfyr0bS9JorKzQ3V7VdOw3bNAiqu+2meuuhPl3ZNUu/v2OS1jSRmlXcA5RLEwG6eDUn/9YLuD+WdBK5WYAyxjSIKPq0qqtVv/pK9a1rfLpsB9c02CZ966bBakQXkqEj2/v0hGMr9KWLfbqxmxuBGDGvbVQialB5wEqvL2qrLdp0Er1ZgDLGJFUtTYMb3/Lpxx+r3nWX6nHHuabB9bQM2SxY1jxLHzxwkv7eOUOXP9941s1KRIAqB94FLvKGfPu3MaGGiSdrswBljEm6GJsGa0T0kfsrNC9PtWtXDdss2L+/6nnnqb57rU8r+mZFziuFJSJALQk3IAIYGm06id4sQBljUlqogBI01P3LL1VfutinS9pFHjFY0GmS/rJdhk4Z59NF87ed2lUiAtTZwJFhzu0VbTqJ3ixAGWO2ORGaBWuysvTL+316yy1uDsE2bcKvm9Wnj+o9I336W/cs/aM4dWtW0Qao5kSvGviLiHT13n3ySwNOx82ZZ4wxJlZ5ee5nQQGUlUFmJhQVQV4eAgwozGdAcTHXXZ1D1YwSqsbk8+7BRfxp8hnMbZ8Dv7vbFyyAcQtyKOArluQXct/AYna5OYeLB5fQpiB/y7y2AeKCWRQXiswGBoU5raraLG6lqodhw4ZpaWlpsothjDHxM3myC1j+4FVY6AJNdjbV90xgzo65vPMOvP02NHt/Ov+pPpqjeZMZ5AKw994w8+bptLiyAObNS/KXARGZparDar0uhgB1CbAQ+Iota1AtgCtU9YK6FDTeLEAZY5qMyZNdsCouhpwcKCmh5ux85LslXH7BRt54O52FC92lF55byQPFraC6OrllJvoAFUsT39O4gPZriMxujaVwxhhj4iBE02DaP4qgqIh7Tizhn3fncvDB8Mkn8NVjJazaNZOOyS1xTNKivVBVVwFni8idACLSSUSuEpFeqrosYSU0xhgTXl6ea7arrnY/8/JcrSo/n5YfTuf/JlcyqsN0isnn0l8K+d//kl3g6EVdgxKR64EbgRkAqrpCRO4HpojI1ar6WUJKaIwxJjYBNatuZWU83T2T838vYlJVHjP/DKWlsOOOyS1iNKKuQQHcWVsOAAAgAElEQVSnAMNxs5ADoKrrgZeB++JbLGOMMfUSULPabvE89rzDBa0lS+D001OiK6pWsQSoL1T1fbYcIAGwAzAwlkxF5GARmS8iq0TknlqubS0il4nIWSKybyz5GGOMca68Ek480X3u+PZkVnTNhmbNIDvbDbZIQbEMklju/dw07E9EegMFwKJoExGRDsABwL7A/sCrIvKGqk4LcW1H4N/AZaoadR7GGGO2JAITJ0KPDydz4Y+FnFpezBUv5XBsxxLIT813pGKpQf1HRO4F+ojIKSJyN/AFsCNwQwzpVAC3qeoqVZ0CzMG9BBzKC8B4C07GGFN/7dpBUZsiCloXM4Nczhibzne9ct0w9aKiZBdvK7GM4nsP19+0K/AYbqXdL4GRqvpyDOms96a6QETaAmV4Ay8CicixwO7AEBGZKiJ3iEiLaPMxxhiztZaLyjjnyRwAfv8dnnkG9w5VWVlyCxZC1AFKRDqq6n9V9VBVba+qrVV1H2BuXTIWkQOBN4F0oE2IS04DPsINwBgNnAqEDPEicp6IlIpIaXl5eV2KY4wxTUNmJsd3LqFnT7c7axZQUuJmqEgxsTTxhav/dfSGoMdqAfAkcChwZ4jzWcAHqlqpqitxtbbTQyWkqo+q6jBVHda5c+c6FMUYY5oI7x2pM3ebTnMqafnhdNcHVViY7JJtJeIgCRHpAfTwdnfxaj0SdFk2cDlwcywZq+pPwEQRqQGuClO2wPLNwY0YNMYYU1feQIiLLyvgesoo+yWTNY8U0S7FBkhA7aP4fgdGAOO8/WODzvuD1f/VowylQKiZKOYA/QL2q3D9VcYYY+ojL49ZHfM4+mi3+05Gai5HETFAedMbXS0i3+KC093BlwBrcKP5oiIibYB+qjrbO/Qn4F7v3DjgP6o63zs2WURaqupG3JB0eyHYGGPiYMiQzZ9nzYLDUzBCRfUelKo+LiJlqvpBHPLMxk2P9DXwMfCpN9wcIA+3cu98Vf1IRK4D7hOR+cAfqvpEHPI3xpgmb6edoFs3WLqUlJ2fL+oXdf3BSUTycC/ZVgJTVHV6LBmq6qdAyJEMqjo0aP8Z4JlY0jfGGBOdoUNTO0DFMsx8exH5GHgWN3vEFcB7IvIfez/JGGO2Pf5mvoULYfXq5JYllFiGmd8ObId7PykDaAXsBpQAN8W/aMYYYxIpsB9q9uzw1yVLLAFqADBMVZ9T1e9UtUJVl6nqP4H2CSqfMcaYBBka0Kkya1byyhFOLAHqU1XdEObczvEojDHGmIbTtSt06eI+p2I/VCwBantviPgmIpImIhcDPeNaKmOMMQ3C38yXigEqluU2ngbKRORNYDWwC26aop2BExJQNmOMMQk2dChMnQrffANr1rgZz1NFLLOZ/xc3F95A4K/AGcBK4BhVfT0xxTPGGJNI/hqUKnz+eXLLEiyWGhSqWgLsLyLbAaKqaxJTLGOMMQ0heKDEgQcmryzBapssth1wHm7C2HnAk97ovbUNUThjjDGJ1a0bdOoEK1akXj9U2AAlIjvj3nHqhZsUVoGLRGSfCKP5jDHGbENEXDPfO++kXoCK1Ad1A24AxH241XPH40brFSS+WMYYYxqKv5mvrAzWrUtuWQJFauLLBfZT1S/9B0TkWdwACWOMMY2Ef6BETQ3MmQP77Zfc8vhFqkEtCgxOAN4SGT8FXygig+NdMGOMMQ0jVWeUiBSgwk1ftDLEsePjUBZjjDFJ0LMnbL+9+5xK/VCRAtQ+IvJ98AaMCzq2ErgulkxF5GARmS8iq0TkniiuP0VEZsSShzHGmOj4B0pAatWgIvVBKfALUNuQ8ra4l3ejIiIdgANwa0rtD7wqIm+o6rQw1+8CFAK/RpuHMcaY2AwdCj4ffPklbNgArVolu0SRA9RfVfXeaBIRkStiyLMCuE1VFbey7hygOsL1VwMPAyfHkIcxxpgY+GtQ1dUwdy7stVdyywORm/jeiCGd16K9UFXXe8EJEWkLlAEzQl0rIvnAJOCPGMpijDEmRoFrQ6VKM1/YAKWqC6NNJJZr/UTkQOBNIB1oE+J8b2AHVf0kirTOE5FSESktLy+PtSjGGNPk9emzeaLYVBkoEctyG/G2AHgSNyP6nYEnRCQNuAj3cnCtVPVRVR2mqsM6d+4c73IaY0yjl5YGe+7pPqdKDSqmyWLjSVV/AiaKSA1wVdDpA3BzAJ4pIgAtgVYiskJVOzVsSY0xpmkYOhTef9/1QVVUQIsWyS1PMmtQfqXAsqBjnwL9gcHedr13nb0QbIwxCeLvh6qsdKP5ki3qACUifwpz/CgRibpWIyJtRGTPgEN/Au71zo0TkX6qulFVl/o3YBWw0ftsjDEmAVJtoEQsNahjwhz/AHgxhnSygXdEZKaI3AksVtUp3rk8YI8Y0jLGGBMn/fpBG2/IWioMlBBvxHfok66mcyHQDNgP+CjEZf2AvqqaEqMThg0bpqWlpckuhjHGbJNu6DuZk74tIpMymmVlQmEh5OXFNQ8RmaWqw2q7LuIgCVWdLSITcO857Yib4XyLS4A1wGV1LagxxpgUMXkyBb8UchLFfNYih9XjS2h+fr47F+cgFY1am/hUdQ5uKPhjqpoRtPVS1UGq+mzii2qMMSahior47PxiZpDLuop0FuyWC8XFUFSUlOJE1QelqotwCxiG5C0Nb4wxZltWVkbLQ3M27f78M5CT41YyTIKwAUpEthgBr6ohJ40V96KSNfEZY8y2LjOTjB9LNu3+/DNQUgKZmUkpTqQa1DwRecC/IyIrRKQ6eAOqgBsTXVBjjDEJVlhI95vyGc50mlNJ85nTIT/fDZRIgkiDJMbjJnL1exroBczBBSW/dGBU/ItmjDGmQeXlITUw4YwCMimj/IVMuK8oKQMkoJZh5ltcKJKJe1l2UYhz+6vqh/EuXF3YMHNjjKmfbt1g2TIYMwaeeCL+6Uc7zDzqF3VVtSxMcOoKxDybuTHGmNTUpYv7+fPPyS1H1JPFishBIQ6nAXt56dwWr0IZY4xJnp13dj+3mQCFW1QwXHvgQixAGWNMo+CvQf3yS3LLEUuAehG39HpN0P1jgMfiWCZjjDFJ5A9Qy5e7JeCbNUtOOWIJUDer6lYTsItIK9w8fe/HrVTGGGOSxt/EV10NK1fCTjslpxyxDJIItzrID8C4+BTHGGNMsvlrUJDcfqhYBklcH+Jwa+A44I+4lcgYY0xSBQaoZPZDxdLEd2OIYxXAN8DYWDIVkYOBR4GdgH+r6lZTJYlIB+Bx4EjcIIwLVPXjWPIxxhgTO38THyS3BhXLgoVFQDNVTQvYWqnqQFX1RZuIF3gOAPYFzgAuEpHDQlx6NfAybomPH4HXRKRtDOU1xhhTB9tcEx/wiEY77URkFcBtXlpTRGQOUB3iumn+wCcipwErgAHAZ3EogzHGmDDat4dWrWDDhuQ28cVSg6oSkVdEZDiAiLQXkb+JyMhYMlTV9f5A59WIynDvWAVf5wv4/BvwO7A0lryMMcbETiQ1ZpOIJUA9AIwAdgBQ1d9V9TZgrIicEGvGInIg8CZustk2tVzbF5ihqj+FOX+eiJSKSGl5eXmsRTHGGBMkFWaTiCVAdQC2V9WXg46/AtxUh7wXAE/iVuu9s5ZrLwKuCndSVR9V1WGqOqxz5851KIoxxphAqTCbRCx9UHNUNdRw8l2A3rFm7NWGJopIDRGCjzeAYkaoiWqNMcYkxrbWxNdcRLICD4jIUbjRdvUZ/l0KLAt1wlvio5eqvlKP9I0xxsTI38S3YgVUVianDLEOM39JRKaJyHMiMheYghuBVxBtIiLSRkT2DDj0J+Be79w4Eennfe4FnAe8IyI9RWSQiFwQQ3mNMcbUUeBQ8+XLk1OGWKY6+gXYB/ABbXFTHN0G7BFhGqRQsnFBZ6aI3AksVtUp3rk8YA9vjakZwGXAYm/7HPg1hnyMMcbUUSrMJhHLVEe3AF+r6j/qk6GqfgqEHMmgqkMDdrvXJx9jjDF1lwqzScTSxHcxkJmoghhjjEkdqTCbRCwB6mpgbqgTInJ+fIpjjDEmFQTWoFK+iQ+3tPteInIy8FvA8VbA0cAj8SyYMcaY5GnbFtq1gzVrkleDiiVA7QL0BTqy5aq6acB28SyUMcaY5Nt55+QGqFia+CYCuaraQ1UzArYeRHjR1hhjzLYp2bNJxFKDeg1oEeZccRzKYowxJoUkezaJsDUoEdkiGKlqVaipjkREcO8rGWOMaUSSPWFspCa+eSLygH9HRFaISHXwBlQRerVdY4wx2zB/Deq339zaUA0tUhPfeNxaTX5PA72AObig5JcOjIp/0YwxxiRT8GwSPXo0bP5hA5SqPhR06FFgY6hZxUVkarwLZowxJrmCZ5NImQAVTFXLIpz7MD7FMcYYkyqSPZtE2AAlIlcCnXDvPX2mqsVB55sDFwLFqrouoaU0xhjT4JI9YWykQRLfAWcBE4ODE7hRfcBjwHUi0ixB5TPGGJMkO+20+XMyalCRAtQewDHe7OMhqep64HHckuxRE5GDRWS+iKwSkXsiXHe0iNwvIg+KyImx5GGMMaZ+WraEjh3d55Rq4gN2UdX/1ZaAqi4Ukb2izVBEOgAHAPsC+wOvisgbqjot6Lq+uEUSh6lqjYi8LyJfq+q8aPMyxhhTP126wKpVqdfEpzGks1Ptl2xSAdymqqu8hQrn4FblDXYF8Jaq+uf9exu4MoZ8jDHG1FMyZ5OIFKBaR5OAN5NEr2gzVNX1qqrevW1x71rNCHHpIbiVdP3mA8OjzccYY0z9JXM2iUgBajsRiSbwHMuWy29ERUQOBN7EvejbJsQluwIrA/bX4GZUD5XWeSJSKiKl5eXlsRbFGGNMGKlag3oceD1SkBKRPXDrQL1Qh7wXAE8ChwJ3hjivwPqA/ZZAZaiEVPVRVR2mqsM6dw65mrwxxpg68AeoP/6AtWsbNu9IM0lM8RYn/FJEXgV8wI+4PqRdgMOAk3CB5t5YM1bVn4CJIlJD6OU6luHewfJr5+VvjDGmgQTPJtGnT8PlXdtMEucAvwKXACcHnRPgI+AEVd1YjzKU4oJRsHeBfgH7fYHp9cjHGGNMjIJnk2jIABVxwUJVrVTVy3HBoQh4CRc4HgdGAjmqGtPgQxFpIyJ7Bhz6E14NTETGiYg/KD0MHOkdF9ygiftiycsYY0z9JHM2iajm4lPVhcD1ccozG5giIl8DHwOfesPNAfKAJcB8VZ3nvaR7t3fuLlX9Mk5lMMYYE4XgJr6GFMuKunHhzUwRciSDqg4N2n8GeKYhymWMMWZrnTuDCKg2fICK2MRnjDGmaWve3AUpaPgmPgtQxhhjIkrWu1BxCVAi0iIe6RhjjEk9yZpNIl41qHPilI4xxpgUk6waVNSDJEQkCzfUvD8QWGNqDnQFHoxv0YwxxqQCf4D65Rc3WEKkYfKNZRTfK0B7YCYQOOGFYJO4GmNMo+Vv4quogNWrN68RlWixBKjOwBBVXRx8QkSOjV+RjDHGpJLg2SQaKkDF0gdVDLQNc25OHMpijDEmBSVrNolYAtSjQL6I9BSR7gFbT9zigsYYYxqhZM0mEUsTnw83GOKSMOcvrX9xjDHGpJrgJr6GEkuAesr7+S1QE3C8BXB63EpkjDEmpeywg5tRoqoqdQPURGCtqm5VPBEpjV+RjDHGpJK0NNfMt2xZivZBqeoCoIeInA4gIp1E5EQRSVfV2QkroTHGmKRLxmwSUQcoEfkz8AGQD6CqK4AvccvC7xzpXmOMMdu2ZMwmEcsovuuBmwkYUq6qZcB/gYdiyVREThCRxSKyUkTuFZGtmhpFpLmI3CEifxWRm0TksljyMMYYEz+Bs0k0lFgC1PeqejOwKuj4eiA32kREpDswCjgRuBw3j1+o4PMX4DdVvUNVbwCOFZF9YiivMcaYOPE38S1fDtXVDZNnLAHq2+ADItIa1+S3duvLw+oBnK2qs1T1KeABQge4TKBdwP4GoEMM+RhjjIkTfw2quhpWrmyYPGMJUN94/VDNRGRnETkO+AjIAh6JNhFVnamqVQGHlgHfh7j0JaBARA4QkQxgBfBuDOU1xhgTJ8mYTSKWUXwP42o1VwA/Aq96++NV9dZ6lGEv4OEQ+fmAccDbuFnUx6qqhkpARM4TkVIRKS0vL69HUYwxxoSSjNkkYloPygtEnXBBZT+gs6qOq2vmItIHKFfVL8Jcsh44GTiMCMt5qOqjqjpMVYd19q9NbIwxJm6SMZtELC/qIiLpwJFAP1yf0B/A3LpkLCLNgPOBa8KcHw20VdWpInII8IGITFfV5+uSnzHGmLpL6QAlIv2B14A+uDWgAFREJuEGPVTGmPc44C5V3Rjm/CnABABVnScidwMHAhagjDGmgbVvDy1bwsaNKdgHhesn2g24C7dAYSZwBJAO3BZLpiJyLTAbaC0ivUTkbBHZXURuFhF/nP4c2DPgtmrg01jyMcYYEx8icF67ycwlmzvubgbZ2TB5ckLzjKWJbyhwrqo+G3BsPvCeiDwZbSIich1wS9Dhr4HJwGhgKvAzbmDEbd4LuhuBCuDpGMprjDEmXiZP5uo1hZxBMS2G5/D230sgP9+dy8tLSJaxBKjPCb8w4cLAHRHpqKrBL/QCmwZahBv1lxFw3XpCv8BrjDGmoRUV8dDQYmZ8mEt2OZCbC8XFUFCQsAAVSxPfGNyIui14TXI7Bh0eW48yGWOMSTVlZawckAMEDJLIyYGysoRlGUsN6mVgJxEZi2tuA2gG7Az85r24C65Pqitwd9xKaYwxJrkyMzm3fwlZE3Lp2tU7VlICmZkJyzKWAPUJMBDXXxTyhVlPOnBQfQpljDEmxRQWMqQwnyHFxa7mNN3rgyoqSliWsQSoJ4AVqrrVnHzBvFqWMcaYxsLfz1RQ4Jr1MjNdcEpQ/xOAhJk9aOsLRToCvXDLvS9U1d8jXCvhpiVKtGHDhmlpqS3wa4wxqUpEZqnqsNquq3WQhIgMFZH3gHLce0ilwAoRmSIie4S6J1nByRhjTOMRsYlPREYBzwEtgB9w7ydV4kbtHQEMF5FTVPWNRBfUGGNM0xI2QInI7sBE4A7gIVX9Keh8e9xig8Uisq+qLk5oSY0xxjQpkWpQ1wBjVPX1UCe9Pqi7ReRb4GrcCrjGGGNMXETqg9oxXHAKpKr/wS3BYYwxxsRNpAAVcqqiMH6tb0GMMcaYQJECVHoM6WxX34IYY4wxgSIFqEoRGVpbAiKyLzEufGiMMcbUJlKAuhd4Q0RO91a/3YKItBSR83HLY4xPVAGNMcY0TWFrPqr6uYjcAjwF3Ccis4DluKDWFRiCa9r7u6p+FEumInIC8C+gPfAMcKWqVoW5dgcgH1gGfKmqX8SSlzHGmG1TxKY5VX1QRH7EzUx+WNDp74DzVfW5WDIUke7AKOBEIAt4CPcS8F0hru0J3AeMVdWVseRjjDFm21Zr35Gqvgq8KiJ7Ar0BARYAn9dxSqMewNlejWmWiGQDuQQFKBFpAbwKnGTByRhjmp6oBzeo6mxgdn0zVNWZQYeWAe1CXHo+bt2pk0VkODANuCNUUBSR84DzALp3717fIhpjjEkBsayomyh7AQ+HOH4aMAP4B26WikLgwlAJqOqjqjpMVYd17tw5UeU0xhjTgJIaoESkD1AeZuBDFvC+OguBF4HTG7SAxhhjkiZpAcobun4+bs6/UJqzZRPkHNws6sYYY5qAZNagxgF3qerGMOfnAP0C9quArxJeKmOMMSkhKQFKRK7FDbhoLSK9RORsEdldRG4WkS7eZXcDfxYR8fb3AyYko7zGGGMaXoNPUSQi1wG3BB3+GpgMjMbNTPGzqr4gIj2Af4nIcqBEVX0NW1pjjDHJ0uABSlVvBW4Nczoj6No7E18iY4wxqSgVhpkbY4wxW7EAZYwxJiVZgDLGGJOSLEAZY4xJSRagjDHGpCSp24TkqUtEynFLgUSjE7AigcXZltiz2JI9j83sWWxmz2Kz+jyLHqpa68SpjS5AxUJESlV1WLLLkQrsWWzJnsdm9iw2s2exWUM8C2viM8YYk5IsQBljjElJTT1APZrsAqQQexZbsuexmT2LzexZbJbwZ9Gk+6CMMcakrqZegzLGGJOiLEAZY4xJSRagjDHGpKQGX24jFYhIa+AOYA3QEbhaVX9PbqkajoicAPwLaA88A1ypqlUi0gkoAlYD6bjnUpm8kjYcEWkBfAZcqqozmvLviIjsC+QAC4ASYB1N8FmISCZwMe457A48qqqfN5XfDRE5HLc00imqusQ7Fva7J+S5qGqT24AnvIcOcBQwOdllasDv3h14ChgKnIn74zPOOzcd2Mf7/BfgtmSXtwGfSyHwGzC8Kf+OAGOBW4OONdVnUQrs6n3uDpQ1lecB7AwcDyjQM5rfhUQ8l6Q/iCQ8+F2AjUAbb7+590e6ZzLL1YDf/0CgecD+HcAUYF/gx4DjuwJrgbbJLnMDPJP9gbOBJcDwpvo7AhwMTMMb3esda5LPwvuu64D+3ufOwI9N6XnguoA2BahI3z1Rz6Up9kENB1ao6h8AqloFLMb9x9noqepM7zv7LQO+Bw7BPQf/dcu8j416WhcRaQucqKoTAw4Pp2n+jtwNlAETROQtETmApvssAP4PeFxE2gFnAAU0oeehqjVBh4YT/rtHOldnTTFA7QqsDDq2Bvd/AE3RXsDDNN3ncjVwe9CxJvcsRKQfsCfwmKpeDLwHvAXsRhN7FgEuBDbg+ibXqupLNMHfjQCRvntCnktTDFAKrA861hJoEoMBAolIH6BcVb+gCT4XETkSKFXV5UGnmtyzALKAX1V1jrd/PyA0zWfh1xqYDEwC7hGRw2jazyPSd0/Ic2mKo/iW4UaYBGqHa19uMkSkGXA+cI13aBnQN+C8AG1p3M9lHLCn+6qA+714DdfU1dR+R5oT8PdAVdeLyLdAM5res/B7BjhVVVeLiOKC1WU03ecR6W+nRjhXZ02xBjUd2MUbEomIpONG6Pw3qaVqeOOAu1R1o7f/LtAv4HxPoAI3kqmxOg0YHLD9CJyDG43U1H5H5gAdRGTngGNVeAMDmtizwHvlYpCqrvYO3Qr8jltrrsk9D0+kv50J+bva5AKUqv4MvAEc6h06DHgpYFBAoyci1wKzgdYi0ktEzsa9+/STiGR7lx0FTFDVimSVM9FUtVxVl/o3oBrX5Pk9Tex3RFW/Bt4ETgQQke2BFsCzNLFn4fkV2CAiuwYcW4kL5E3iecjmpgWByH87E/V3tUlOFisiHXHDq5cAXYC/qerapBaqgYjIdcAtQYe/VtVMEekBXI97LtsBhUEj/ho1EVkCjFH3om6T+x3xag334mrN3XEDJr5qis8CQEQG4QZKzMK9F/S+qv63KTyPgJGLDwI3A/eranmk756I59IkA5QxxpjU1+Sa+IwxxmwbLEAZY4xJSRagjDHGpCQLUMYYY1KSBShjjDEpyQKUMabRCHh3Jyn3m/iyAGXCEpFBInKLiKiI1IjIP0VkeITrdxWRpSJyXJjz24vIuSLyvZfmSyLypLe9KiJrROTVhH2hCETkQhH5VkRaNUBerby8LoxjmiO8Z/isiDwuIsXev91JIjKujmmmeem+LCLvxKusXtptRGSsiJSIyA1xSnME8Gfvcz+v3EUiMtl7ryfUPY+IyMCAQ31F5HIRaRmPMpn6aYpz8ZkoeZPIfiEiFwBLVfXqWm75Dbee0JIw6a0GHhOR3rhZxK9W1QX+894sFtfGo+y1EZEhqvq/gENluLJvDHNLPG308iqrb0LeSsCP4WalH6mq3wacG4p7u/+pGNMMfDaLvLQX1resQZp7aR+Aexb1IiJXAj+o6gveoUnAQ6r6uPc/PdfhfucC7zkD+CJgglxUdb6IbABeEJE8//IRJjmsBmWisdbbIlLVtao6JvA/+DA2hLl/Hm6CzoQSkT8BW9TyVHW6ql6gDfDmujoXqOr0OCT3T+BUgoKTl88s3KqowZN4huXVJi707q9R1TIC1gmLF3VLgc+MR1oicgywnz84eTNiDGFzuecDRwbd0wc4QlUfDFG273ATw04MPmcalgUok1JUdWoi0/dqFc8mMo+G4v2RvRR4LTg4+anqx7j1jKJJrxfwOlu3rAQvXBcXIRbEi5nXFPegt/ltxJU53dtPJ2ApCG8i0ztwM5OH8zywj4gcGuEak2AWoExciEh7rx/nfyIypg73j/D3b3n9E2NE5H0RuUFEbvb6p84XkRYicpeI3C8i94rIXBE5JyitviLykIjc5/VxTBSRdiKyCzAG2B44RkQeFpH9RGSAiIwXkZVB6ezgpXGniLzolecA71wLETlZ3MqzxSKyv4jMEpF1InJPhO/ZSkRG+7+bd2x3EblNRJZ5fSf/EpHVXj/VHhEe25m4iTzfi/RsVfWxgPyv8cp7p4h8IW5uRv/caxcDOwL7ec/mmKCyZ4nIByLyh4g8LW7JFv+51iJyu1f2p0TkEwnqixSR5iJyq7g+xwdE5IkQz6ezuL7Oh0SkVFy/WkaEr5fnlfn9gO+7BngZ2M87tB/wXMA9twLjVfXXCM9Mcc/1bxHyNolWn/XibWsaG65PqaSWazrh/vgrbsLVSNfe6F33LvAq8A5uaYfh3vkdgKO9az4GjgEm4JpprgN+DEjrdu/ett5+T1zfRldvv6+Xzr0B9yhwY8B+b1zNQQOOtQS+AP4ccOwG3P+dD8UtZtcLWAf8D7dMx45AkZf+kDDfvb33PTaVAegK3OYvJzDQK9MvwOsRnuOL3j3HRvnveIZ3fUtv/y/efv+gf+sng+6bgWsuK/DKWuDdN8I7L7iZ0K8MuOcsXC3muIBjTwJPBF0T+BxaAW8DHb39NsCX3iZhvtPrwKwQx9t6/16FwLn++3Gz9P89yud1BW7BvY7J/m+wqW42SMLEhaquEJGSGG+7QL1BEiJyUUBav4rI297uR6r6Bq6z37/QYmANZTluUb0dcMGiEJihqj95aX3j1bA+j1D2hSIyB7YKrAQAAAWoSURBVDg24PAYYHdcAPW7C7gEuF1VDwcWebWuear6uFe+ybiBHv1xgSs4r99F5L2gYz+JWxwQXCBd5KU1Exeswmnv/Yx2SZT5bLkGmH8l4c7A17Xc+4OqTvDK9QRwHzAAmML/t3d2IVoVYRz//V3NVqUVXS0jNEjpw8QtU5EtzFjLukgMrJsiSqjLRLIoLyyiLoogiiisCC2KvDASkWylDFLZAoPCrgpNkUWiwsosan26eGbas8f3vO6X7ms9PzgcOPOcmXnP4Z1n5pn/nIGb8YZ/VcF+E74Z5vPAVkmLcIc0t2DzHu60MnfiW4c/pF61935gKt4B+qFGvebhXxvvg5kdB54sXpPvdXU/PupC0qW48+oBPjSzPaVsDuLhzmuAj2uUHZxhwkEFw8lQtubYgo9+AJ+fSI3UsaKRmW2XtFPSKnyUcUlKyuGmRcD20j1v9KP8ct2XAr+ZWU8hn+OSvgYWFuxO0neOJotJzqsqyMz+1qnLbU6WzjmvynzwzfMALq5jUyz3ixSGXImLCManpKY6t5XrB94RAB9Fgj8r8D3FclkmqQu4V9JkYHlKOlCw+aP0HOYDR8zsiX7UJzOlUJ9K5AW9AKwxsx75coJduFPdBxyQ1G5m+wu35Xc5bQD1CYaRmIMKhoz67sI6KMys28z29qOsK/Cw30Eze5xTe7ZNwOwa900cYJUEtMpl3EW6GZojHk62pXNHPaMkCkDSRcBuYIyZPYZ3CgaMmWWlY24/spcpO8rudP4L3/4bfKRbxRigTaU1SJImKO3UWoPfqe/EM2uBd803pgRYAswAPjezn3HHeU/FvY3yvv93hIMKhkQSHiw5i0VuAL4zsyphwD5gmXp3BkbSaOCBAZazB294l5aut1IaoY0g24C9wEr1XWz6L5LGATl8+iww2szeqZPnYGT2OTR2S+l6K7DbXFL+Tbq2rMb9uR36Cg/nrS2l5zmvWhwGWupVTtIC4EIz21q4PCGdc3j0T3pHhJkcQj1UL//gzBEOKugP43HlWx/SqGQjLnaA3pDx6UJG49K58qsNkkZV2DQD10u6VtJifN4CYI6khcBzeI/3I0mrUyhwBx7OyfwKXCmpVVJ2rqNTubnur+Bii3W5Ry/fcbgNn3zPjKH2/6gyfJ4cJvR9TlkSXc6rMh9zmfYdwLdAp6TlheeWZejrgRzibAZmS7pR0nW4sANgVnqW4M/mcrkq89ZCPev9xi24o1yTR6qSWnChyyPJZhNwBHhaUoekJkkrUtoc+eLtt/Cw5VOS3parNjcAJ82s5to5fARdqfKTdAG+QLe8APwz3CnNSiPMyzh1XdZMPHxYOX8ZnGFGWqURR+Me+IR2VqUZPjrZictvu/AY/a5kOw1v1A34BJhbI7+JuDT6ULLbRkHlVbCbgkuBDe8h31VIW5quHU0284Ff8IWVzclmMT5xfgJfA3RTKf9H8fmS93Fn2Y5PxhveoLcku+m4Uq4LX2fzJnB1ShtLb8/+ML4gdjquwsvPYF6N39aCT94bPmJox+eDPk3XXsIb3NvxxroHl3+fX+c9NeOChH34Fx868bVeq/FwXrZrw8UQP6V3NRMXHnQCk5PN3cCPqT5TgQdxp3UMuA/f+nxdof43pPsmAa8DX6a8N+a0QvlX4R2FE/i28stTXV4EZiebGcAHuGP4Hpd5j6rz2xekZzSpIv01CirFUtoKXH7+KvBMjfTNFFSHcZz9I7Z8D4LgnEb+KaMtZjagTzqdJs+xeEeq3Qqf4wrOLuGggiA4p0kinc3Abeby8uHI82HghJm9PBz5BYMj5qCCIDinMbOjeChyfQ3V5YCR1AH0hHMaeWIEFQTBf4IkiFhkZjtOa1ydx0x8Pq5r+GoWDJZwUEEQBEFDEiG+IAiCoCEJBxUEQRA0JOGggiAIgoYkHFQQBEHQkISDCoIgCBqSfwDbnFz3CgDFmgAAAABJRU5ErkJggg==\n",
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "\n",
+       "mpl.get_websocket_type = function() {\n",
+       "    if (typeof(WebSocket) !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert('Your browser does not have WebSocket support.' +\n",
+       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "              'Firefox 4 and 5 are also supported but you ' +\n",
+       "              'have to enable WebSockets in about:config.');\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent = (\n",
+       "                \"This browser does not support binary websocket messages. \" +\n",
+       "                    \"Performance may be slow.\");\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = $('<div/>');\n",
+       "    this._root_extra_style(this.root)\n",
+       "    this.root.attr('style', 'display: inline-block');\n",
+       "\n",
+       "    $(parent_element).append(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen =  function () {\n",
+       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
+       "            fig.send_message(\"send_image_mode\", {});\n",
+       "            if (mpl.ratio != 1) {\n",
+       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
+       "            }\n",
+       "            fig.send_message(\"refresh\", {});\n",
+       "        }\n",
+       "\n",
+       "    this.imageObj.onload = function() {\n",
+       "            if (fig.image_mode == 'full') {\n",
+       "                // Full images could contain transparency (where diff images\n",
+       "                // almost always do), so we need to clear the canvas so that\n",
+       "                // there is no ghosting.\n",
+       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "            }\n",
+       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "        };\n",
+       "\n",
+       "    this.imageObj.onunload = function() {\n",
+       "        fig.ws.close();\n",
+       "    }\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function() {\n",
+       "    var titlebar = $(\n",
+       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
+       "        'ui-helper-clearfix\"/>');\n",
+       "    var titletext = $(\n",
+       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
+       "        'text-align: center; padding: 3px;\"/>');\n",
+       "    titlebar.append(titletext)\n",
+       "    this.root.append(titlebar);\n",
+       "    this.header = titletext[0];\n",
+       "}\n",
+       "\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = $('<div/>');\n",
+       "\n",
+       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
+       "\n",
+       "    function canvas_keyboard_event(event) {\n",
+       "        return fig.key_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
+       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
+       "    this.canvas_div = canvas_div\n",
+       "    this._canvas_extra_style(canvas_div)\n",
+       "    this.root.append(canvas_div);\n",
+       "\n",
+       "    var canvas = $('<canvas/>');\n",
+       "    canvas.addClass('mpl-canvas');\n",
+       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
+       "\n",
+       "    this.canvas = canvas[0];\n",
+       "    this.context = canvas[0].getContext(\"2d\");\n",
+       "\n",
+       "    var backingStore = this.context.backingStorePixelRatio ||\n",
+       "\tthis.context.webkitBackingStorePixelRatio ||\n",
+       "\tthis.context.mozBackingStorePixelRatio ||\n",
+       "\tthis.context.msBackingStorePixelRatio ||\n",
+       "\tthis.context.oBackingStorePixelRatio ||\n",
+       "\tthis.context.backingStorePixelRatio || 1;\n",
+       "\n",
+       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband = $('<canvas/>');\n",
+       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
+       "\n",
+       "    var pass_mouse_events = true;\n",
+       "\n",
+       "    canvas_div.resizable({\n",
+       "        start: function(event, ui) {\n",
+       "            pass_mouse_events = false;\n",
+       "        },\n",
+       "        resize: function(event, ui) {\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "        stop: function(event, ui) {\n",
+       "            pass_mouse_events = true;\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "    });\n",
+       "\n",
+       "    function mouse_event_fn(event) {\n",
+       "        if (pass_mouse_events)\n",
+       "            return fig.mouse_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
+       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
+       "\n",
+       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
+       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
+       "\n",
+       "    canvas_div.on(\"wheel\", function (event) {\n",
+       "        event = event.originalEvent;\n",
+       "        event['data'] = 'scroll'\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        mouse_event_fn(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.append(canvas);\n",
+       "    canvas_div.append(rubberband);\n",
+       "\n",
+       "    this.rubberband = rubberband;\n",
+       "    this.rubberband_canvas = rubberband[0];\n",
+       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
+       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
+       "\n",
+       "    this._resize_canvas = function(width, height) {\n",
+       "        // Keep the size of the canvas, canvas container, and rubber band\n",
+       "        // canvas in synch.\n",
+       "        canvas_div.css('width', width)\n",
+       "        canvas_div.css('height', height)\n",
+       "\n",
+       "        canvas.attr('width', width * mpl.ratio);\n",
+       "        canvas.attr('height', height * mpl.ratio);\n",
+       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
+       "\n",
+       "        rubberband.attr('width', width);\n",
+       "        rubberband.attr('height', height);\n",
+       "    }\n",
+       "\n",
+       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
+       "    // upon first draw.\n",
+       "    this._resize_canvas(600, 600);\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus () {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            // put a spacer in here.\n",
+       "            continue;\n",
+       "        }\n",
+       "        var button = $('<button/>');\n",
+       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
+       "                        'ui-button-icon-only');\n",
+       "        button.attr('role', 'button');\n",
+       "        button.attr('aria-disabled', 'false');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "\n",
+       "        var icon_img = $('<span/>');\n",
+       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
+       "        icon_img.addClass(image);\n",
+       "        icon_img.addClass('ui-corner-all');\n",
+       "\n",
+       "        var tooltip_span = $('<span/>');\n",
+       "        tooltip_span.addClass('ui-button-text');\n",
+       "        tooltip_span.html(tooltip);\n",
+       "\n",
+       "        button.append(icon_img);\n",
+       "        button.append(tooltip_span);\n",
+       "\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker_span = $('<span/>');\n",
+       "\n",
+       "    var fmt_picker = $('<select/>');\n",
+       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
+       "    fmt_picker_span.append(fmt_picker);\n",
+       "    nav_element.append(fmt_picker_span);\n",
+       "    this.format_dropdown = fmt_picker[0];\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = $(\n",
+       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
+       "        fmt_picker.append(option)\n",
+       "    }\n",
+       "\n",
+       "    // Add hover states to the ui-buttons\n",
+       "    $( \".ui-button\" ).hover(\n",
+       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
+       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
+       "    );\n",
+       "\n",
+       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function(type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function() {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1]);\n",
+       "        fig.send_message(\"refresh\", {});\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
+       "    var x0 = msg['x0'] / mpl.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
+       "    var x1 = msg['x1'] / mpl.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch(cursor)\n",
+       "    {\n",
+       "    case 0:\n",
+       "        cursor = 'pointer';\n",
+       "        break;\n",
+       "    case 1:\n",
+       "        cursor = 'default';\n",
+       "        break;\n",
+       "    case 2:\n",
+       "        cursor = 'crosshair';\n",
+       "        break;\n",
+       "    case 3:\n",
+       "        cursor = 'move';\n",
+       "        break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message(\"ack\", {});\n",
+       "}\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            /* FIXME: We get \"Resource interpreted as Image but\n",
+       "             * transferred with MIME type text/plain:\" errors on\n",
+       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "             * to be part of the websocket stream */\n",
+       "            evt.data.type = \"image/png\";\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src);\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                evt.data);\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig[\"handle_\" + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function(e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e)\n",
+       "        e = window.event;\n",
+       "    if (e.target)\n",
+       "        targ = e.target;\n",
+       "    else if (e.srcElement)\n",
+       "        targ = e.srcElement;\n",
+       "    if (targ.nodeType == 3) // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "\n",
+       "    // jQuery normalizes the pageX and pageY\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    // offset() returns the position of the element relative to the document\n",
+       "    var x = e.pageX - $(targ).offset().left;\n",
+       "    var y = e.pageY - $(targ).offset().top;\n",
+       "\n",
+       "    return {\"x\": x, \"y\": y};\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys (original) {\n",
+       "  return Object.keys(original).reduce(function (obj, key) {\n",
+       "    if (typeof original[key] !== 'object')\n",
+       "        obj[key] = original[key]\n",
+       "    return obj;\n",
+       "  }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event)\n",
+       "\n",
+       "    if (name === 'button_press')\n",
+       "    {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * mpl.ratio;\n",
+       "    var y = canvas_pos.y * mpl.ratio;\n",
+       "\n",
+       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
+       "                             step: event.step,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function(event, name) {\n",
+       "\n",
+       "    // Prevent repeat events\n",
+       "    if (name == 'key_press')\n",
+       "    {\n",
+       "        if (event.which === this._key)\n",
+       "            return;\n",
+       "        else\n",
+       "            this._key = event.which;\n",
+       "    }\n",
+       "    if (name == 'key_release')\n",
+       "        this._key = null;\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.which != 17)\n",
+       "        value += \"ctrl+\";\n",
+       "    if (event.altKey && event.which != 18)\n",
+       "        value += \"alt+\";\n",
+       "    if (event.shiftKey && event.which != 16)\n",
+       "        value += \"shift+\";\n",
+       "\n",
+       "    value += 'k';\n",
+       "    value += event.which.toString();\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, {key: value,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
+       "    if (name == 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message(\"toolbar_button\", {name: name});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.close = function() {\n",
+       "        comm.close()\n",
+       "    };\n",
+       "    ws.send = function(m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function(msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(msg['content']['data'])\n",
+       "    });\n",
+       "    return ws;\n",
+       "}\n",
+       "\n",
+       "mpl.mpl_figure_comm = function(comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = $(\"#\" + id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm)\n",
+       "\n",
+       "    function ondownload(figure, format) {\n",
+       "        window.open(figure.imageObj.src);\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy,\n",
+       "                           ondownload,\n",
+       "                           element.get(0));\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element.get(0);\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "\n",
+       "    var output_index = fig.cell_info[2]\n",
+       "    var cell = fig.cell_info[0];\n",
+       "\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
+       "    var width = fig.canvas.width/mpl.ratio\n",
+       "    fig.root.unbind('remove')\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable()\n",
+       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
+       "    fig.close_ws(fig, msg);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width/mpl.ratio\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<IPython.core.display.Javascript object>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\" width=\"640\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
      },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "plt.figure()\n",
-    "plt.plot(100*X_Li_ca, E_cell_therm,color='b',linewidth=2.5)\n",
-    "plt.plot(100*X_Li_ca, E_cell_kin,linewidth=0.,marker='o',markerfacecolor='none',markeredgecolor='r')\n",
-    "plt.ylim([2.5,4.3])\n",
-    "plt.xlabel('Li Fraction in Cathode (%)',fontname='Times New Roman',fontsize=18)\n",
-    "plt.ylabel('Open Circuit Potential (V)',fontname='Times New Roman',fontsize=18)\n",
-    "plt.legend(['Thermodynamic','Kinetic'])\n",
+    "plt.plot(100*X_Li_ca, E_cell_therm,color='b', linewidth=2.5)\n",
+    "plt.plot(100*X_Li_ca, E_cell_kin,linewidth=0., marker='o', markerfacecolor='none', markeredgecolor='r')\n",
+    "plt.ylim([2.5, 4.3])\n",
+    "plt.xlabel('Li Fraction in Cathode (%)', fontname='Times New Roman', fontsize=18)\n",
+    "plt.ylabel('Open Circuit Potential (V)', fontname='Times New Roman', fontsize=18)\n",
+    "plt.legend(['Thermodynamic', 'Kinetic'])\n",
     "\n",
     "ax = plt.gca()\n",
     "\n",
@@ -465,9 +2028,7 @@
     "    tick.label1.set_fontname('Times New Roman')\n",
     "for tick in ax.yaxis.get_major_ticks():\n",
     "    tick.label1.set_fontsize(14)\n",
-    "    tick.label1.set_fontname('Times New Roman')\n",
-    "    \n",
-    "plt.show()"
+    "    tick.label1.set_fontname('Times New Roman')"
    ]
   },
   {
@@ -480,15 +2041,6 @@
     "\n",
     "However, it is at last important to note that, while slower, the kinetic method is of course more robust, and can be used to find results away from equilibrium.  The thermodynamic method is only applicable at equilibrium (zero current)."
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -507,7 +2059,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.8"
+   "version": "3.7.2"
   }
  },
  "nbformat": 4,