SPE-fit.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iminuit version 1.4.9\n",
      "numpy version 1.20.2\n",
      "scipy version 1.5.1\n"
     ]
    }
   ],
   "source": [
    "#Check package versions, otherwise you don't have to run this cell\n",
    "import iminuit\n",
    "import numpy\n",
    "import scipy\n",
    "print(\"iminuit version\", iminuit.__version__)\n",
    "print(\"numpy version\", numpy.__version__)\n",
    "print(\"scipy version\", scipy.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyximport\n",
    "from iminuit import Minuit\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.optimize import curve_fit\n",
    "\n",
    "pyximport.install(\n",
    "    setup_args=dict(\n",
    "        include_dirs=[np.get_include()], \n",
    "    ),\n",
    "    reload_support=True, \n",
    ") \n",
    "from Binned_LLH_cython import Binned_LLH, fit_func_for_plot, Initial_paramters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prepare data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Charge')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def gaussian(x,a,b,c):\n",
    "\n",
    "    return a*np.exp(-(x-b)**2/(2.*c**2))\n",
    "\n",
    "\n",
    "#bkc = charge of first 30ns of waveform, the pulses are normally ~70ns\n",
    "#TT = time of pulse \n",
    "#charge = charge of pulse\n",
    "#amp = amplitude of charge\n",
    "bkc, TT, charge, amp = np.loadtxt(\"data_225.txt\", usecols=(range(4)), unpack=1)\n",
    "\n",
    "#Get charges of pulses in the interval [-6.5ns:60ns] from main peak\n",
    "def clean(TT,charge,amp,bkc):\n",
    "    h = np.histogram(TT[amp>4],bins = 125,range = (20,120))\n",
    "    x = h[1][:-1]\n",
    "    y = h[0]\n",
    "    plt.figure()\n",
    "    plt.plot(x,y)\n",
    "    plt.xlabel(\"Time @ pulse max (ns)\")\n",
    "    plt.yscale(\"log\")\n",
    "\n",
    "    xmax = x[y==np.amax(y)][0]\n",
    "    tmin = xmax-6.5\n",
    "    tmax = xmax+60\n",
    "    bols = np.logical_and(TT>tmin, TT< tmax)\n",
    "    bols2 = np.invert(np.logical_and(TT>tmin, TT< tmax))\n",
    "    nch = np.append(charge[bols], bkc[bols2])\n",
    "    nch -= np.average(bkc)\n",
    "\n",
    "    return nch\n",
    "\n",
    "\n",
    "chclean = clean(TT,charge,amp,bkc)\n",
    "\n",
    "\n",
    "h = np.histogram(chclean*1e12/(50), bins = 'sqrt')\n",
    "\n",
    "bin_edges_data = h[1]\n",
    "y = h[0]\n",
    "plt.figure()\n",
    "plt.hist(chclean*1e12/(50), bins = bin_edges_data)\n",
    "plt.yscale(\"log\")\n",
    "plt.xlabel(\"Charge\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<tr> <td colspan=\"2\" style=\"text-align:center\" title=\"Minimum value of function\"> FCN = 412.1 </td> <td colspan=\"3\" title=\"No. of calls in last algorithm and total number of calls\"> Ncalls = 286 (286 total) </td> </tr>\n",
       "<tr> <td colspan=\"2\" style=\"text-align:center\" title=\"Estimated distance to minimum and target threshold\"> EDM = 8.83e-12 (Goal: 1e-15) </td> <td colspan=\"3\" title=\"Increase in FCN which corresponds to 1 standard deviation\"> up = 0.5 </td> </tr>\n",
       "<tr> <td title=\"Validity of the migrad call\"> Valid Min. </td> <td title=\"Validity of parameters\"> Valid Param. </td> <td title=\"Is EDM above goal EDM?\"> Above EDM </td> <td colspan=\"2\" title=\"Did last migrad call reach max call limit?\"> Reached call limit </td> </tr>\n",
       "<tr> <td style=\"background-color:#92CCA6;\"> True </td> <td style=\"background-color:#92CCA6;\"> True </td> <td style=\"background-color:#92CCA6;\"> False </td> <td colspan=\"2\" style=\"background-color:#92CCA6;\"> False </td> </tr>\n",
       "<tr> <td title=\"Did Hesse fail?\"> Hesse failed </td> <td title=\"Has covariance matrix\"> Has cov. </td> <td title=\"Is covariance matrix accurate?\"> Accurate </td> <td title=\"Is covariance matrix positive definite?\"> Pos. def. </td> <td title=\"Was positive definiteness enforced by Minuit?\"> Forced </td> </tr>\n",
       "<tr> <td style=\"background-color:#92CCA6;\"> False </td> <td style=\"background-color:#92CCA6;\"> True </td> <td style=\"background-color:#92CCA6;\"> True </td> <td style=\"background-color:#92CCA6;\"> True </td> <td style=\"background-color:#92CCA6;\"> False </td> </tr>\n",
       "</table>\n",
       "<table>\n",
       "<tr style=\"background-color:#F4F4F4;\"> <td/> <th title=\"Variable name\"> Name </th> <th title=\"Value of parameter\"> Value </th> <th title=\"Hesse error\"> Hesse Error </th> <th title=\"Minos lower error\"> Minos Error- </th> <th title=\"Minos upper error\"> Minos Error+ </th> <th title=\"Lower limit of the parameter\"> Limit- </th> <th title=\"Upper limit of the parameter\"> Limit+ </th> <th title=\"Is the parameter fixed in the fit\"> Fixed </th> </tr>\n",
       "<tr style=\"background-color:#FFFFFF;\"> <th> 0 </th> <td> Q0 </td> <td> -6.9e-3 </td> <td> 0.4e-3 </td> <td>  </td> <td>  </td> <td>  </td> <td>  </td> <td>  </td> </tr>\n",
       "<tr style=\"background-color:#F4F4F4;\"> <th> 1 </th> <td> s0 </td> <td> 51.46e-3 </td> <td> 0.31e-3 </td> <td>  </td> <td>  </td> <td> 1E-12 </td> <td>  </td> <td>  </td> </tr>\n",
       "<tr style=\"background-color:#FFFFFF;\"> <th> 2 </th> <td> Q1 </td> <td> 1.050 </td> <td> 0.008 </td> <td>  </td> <td>  </td> <td> 0 </td> <td>  </td> <td>  </td> </tr>\n",
       "<tr style=\"background-color:#F4F4F4;\"> <th> 3 </th> <td> s1 </td> <td> 0.379 </td> <td> 0.008 </td> <td>  </td> <td>  </td> <td> 1E-12 </td> <td> 1 </td> <td>  </td> </tr>\n",
       "<tr style=\"background-color:#FFFFFF;\"> <th> 4 </th> <td> poisson_mean </td> <td> 0.357 </td> <td> 0.011 </td> <td>  </td> <td>  </td> <td> 0.0001 </td> <td>  </td> <td>  </td> </tr>\n",
       "<tr style=\"background-color:#F4F4F4;\"> <th> 5 </th> <td> height </td> <td> 4.4189e4 </td> <td> 0.0000e4 </td> <td>  </td> <td>  </td> <td> 0 </td> <td> 1E+06 </td> <td> yes </td> </tr>\n",
       "<tr style=\"background-color:#FFFFFF;\"> <th> 6 </th> <td> n_omega </td> <td> 0.105 </td> <td> 0.009 </td> <td>  </td> <td>  </td> <td> 1E-05 </td> <td> 1 </td> <td>  </td> </tr>\n",
       "<tr style=\"background-color:#F4F4F4;\"> <th> 7 </th> <td> n_alpha </td> <td> 0.44 </td> <td> 0.05 </td> <td>  </td> <td>  </td> <td> 0.0001 </td> <td> 1 </td> <td>  </td> </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "------------------------------------------------------------------\n",
       "| FCN = 412.1                   |     Ncalls=286 (286 total)     |\n",
       "| EDM = 8.83e-12 (Goal: 1e-15)  |            up = 0.5            |\n",
       "------------------------------------------------------------------\n",
       "|  Valid Min.   | Valid Param.  | Above EDM | Reached call limit |\n",
       "------------------------------------------------------------------\n",
       "|     True      |     True      |   False   |       False        |\n",
       "------------------------------------------------------------------\n",
       "| Hesse failed  |   Has cov.    | Accurate  | Pos. def. | Forced |\n",
       "------------------------------------------------------------------\n",
       "|     False     |     True      |   True    |   True    | False  |\n",
       "------------------------------------------------------------------\n",
       "--------------------------------------------------------------------------------------------------\n",
       "|   | Name         |   Value   | Hesse Err | Minos Err- | Minos Err+ | Limit-  | Limit+  | Fixed |\n",
       "--------------------------------------------------------------------------------------------------\n",
       "| 0 | Q0           |  -6.9e-3  |  0.4e-3   |            |            |         |         |       |\n",
       "| 1 | s0           | 51.46e-3  |  0.31e-3  |            |            |  1e-12  |         |       |\n",
       "| 2 | Q1           |   1.050   |   0.008   |            |            |    0    |         |       |\n",
       "| 3 | s1           |   0.379   |   0.008   |            |            |  1e-12  |    1    |       |\n",
       "| 4 | poisson_mean |   0.357   |   0.011   |            |            | 0.0001  |         |       |\n",
       "| 5 | height       | 4.4189e4  | 0.0000e4  |            |            |    0    |  1e+06  |  yes  |\n",
       "| 6 | n_omega      |   0.105   |   0.009   |            |            |  1e-05  |    1    |       |\n",
       "| 7 | n_alpha      |   0.44    |   0.05    |            |            | 0.0001  |    1    |       |\n",
       "--------------------------------------------------------------------------------------------------"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Bounds parameter space\n",
    "limits = dict(limit_Q0 = (None,None),\n",
    "          limit_s0 = (0.000000000001,None),\n",
    "          limit_Q1 = (0.,None),\n",
    "          limit_s1 = (0.000000000001,1),\n",
    "          limit_poisson_mean = (0.0001,None),\n",
    "          limit_height = (0.,1e6),\n",
    "          limit_n_omega = (0.00001,1.0),\n",
    "          limit_n_alpha = (0.0001,1.0))\n",
    "#Initial estimate of errors, normally 10% of initial values is alright\n",
    "error = dict(error_Q0 = .1,\n",
    "         error_s0 = .05,\n",
    "         error_Q1 = .5,\n",
    "         error_s1 = .2,\n",
    "         error_poisson_mean = .5,\n",
    "         error_height = 0.,\n",
    "         error_n_omega = .1,\n",
    "         error_n_alpha = 1.)\n",
    "#If parameter is fixed, it is left constant... height should always be the total nr of counts -> fix True\n",
    "fix = dict(fix_Q0 = False,\n",
    "         fix_s0 = False,\n",
    "         fix_Q1 = False,\n",
    "         fix_s1 = False,\n",
    "         fix_poisson_mean = False,\n",
    "         fix_height = True,\n",
    "         fix_n_omega = False,\n",
    "         fix_n_alpha = False)\n",
    "\n",
    "#Get initial values, function in Binned_LLH_cython.pyx\n",
    "p0 = Initial_paramters(bin_edges_data, y, np.mean(bkc), np.std(bkc)*1e12/(50))\n",
    "\n",
    "#Class for data handling and llh in Binned_LLH_cython.pyx\n",
    "mlh = Binned_LLH(bin_edges_data, y)\n",
    "minuit_args = {**p0, **limits, **error, **fix, **dict(errordef= 0.5)}\n",
    "\n",
    "#Pass mlh.compute, which calculates -log likelihood, to Minuit\n",
    "m = Minuit(mlh.compute, **minuit_args)\n",
    "\n",
    "m.tol = 1e-12\n",
    "m.migrad() #Fits\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/anaconda3/envs/py37/lib/python3.7/site-packages/ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in log\n",
      "  \n",
      "/data/anaconda3/envs/py37/lib/python3.7/site-packages/ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in multiply\n",
      "  \n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "/* global mpl */\n",
       "window.mpl = {};\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(\n",
       "            '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",
       "\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 = document.createElement('div');\n",
       "    this.root.setAttribute('style', 'display: inline-block');\n",
       "    this._root_extra_style(this.root);\n",
       "\n",
       "    parent_element.appendChild(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 (fig.ratio !== 1) {\n",
       "            fig.send_message('set_dpi_ratio', { dpi_ratio: fig.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 = document.createElement('div');\n",
       "    titlebar.classList =\n",
       "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
       "    var titletext = document.createElement('div');\n",
       "    titletext.classList = 'ui-dialog-title';\n",
       "    titletext.setAttribute(\n",
       "        'style',\n",
       "        'width: 100%; text-align: center; padding: 3px;'\n",
       "    );\n",
       "    titlebar.appendChild(titletext);\n",
       "    this.root.appendChild(titlebar);\n",
       "    this.header = titletext;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
       "    canvas_div.setAttribute(\n",
       "        'style',\n",
       "        'border: 1px solid #ddd;' +\n",
       "            'box-sizing: content-box;' +\n",
       "            'clear: both;' +\n",
       "            'min-height: 1px;' +\n",
       "            'min-width: 1px;' +\n",
       "            'outline: 0;' +\n",
       "            'overflow: hidden;' +\n",
       "            'position: relative;' +\n",
       "            'resize: both;'\n",
       "    );\n",
       "\n",
       "    function on_keyboard_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.key_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    canvas_div.addEventListener(\n",
       "        'keydown',\n",
       "        on_keyboard_event_closure('key_press')\n",
       "    );\n",
       "    canvas_div.addEventListener(\n",
       "        'keyup',\n",
       "        on_keyboard_event_closure('key_release')\n",
       "    );\n",
       "\n",
       "    this._canvas_extra_style(canvas_div);\n",
       "    this.root.appendChild(canvas_div);\n",
       "\n",
       "    var canvas = (this.canvas = document.createElement('canvas'));\n",
       "    canvas.classList.add('mpl-canvas');\n",
       "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
       "\n",
       "    this.context = canvas.getContext('2d');\n",
       "\n",
       "    var backingStore =\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        this.context.webkitBackingStorePixelRatio ||\n",
       "        this.context.mozBackingStorePixelRatio ||\n",
       "        this.context.msBackingStorePixelRatio ||\n",
       "        this.context.oBackingStorePixelRatio ||\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        1;\n",
       "\n",
       "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
       "        'canvas'\n",
       "    ));\n",
       "    rubberband_canvas.setAttribute(\n",
       "        'style',\n",
       "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
       "    );\n",
       "\n",
       "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
       "    if (this.ResizeObserver === undefined) {\n",
       "        if (window.ResizeObserver !== undefined) {\n",
       "            this.ResizeObserver = window.ResizeObserver;\n",
       "        } else {\n",
       "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
       "            this.ResizeObserver = obs.ResizeObserver;\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
       "        var nentries = entries.length;\n",
       "        for (var i = 0; i < nentries; i++) {\n",
       "            var entry = entries[i];\n",
       "            var width, height;\n",
       "            if (entry.contentBoxSize) {\n",
       "                if (entry.contentBoxSize instanceof Array) {\n",
       "                    // Chrome 84 implements new version of spec.\n",
       "                    width = entry.contentBoxSize[0].inlineSize;\n",
       "                    height = entry.contentBoxSize[0].blockSize;\n",
       "                } else {\n",
       "                    // Firefox implements old version of spec.\n",
       "                    width = entry.contentBoxSize.inlineSize;\n",
       "                    height = entry.contentBoxSize.blockSize;\n",
       "                }\n",
       "            } else {\n",
       "                // Chrome <84 implements even older version of spec.\n",
       "                width = entry.contentRect.width;\n",
       "                height = entry.contentRect.height;\n",
       "            }\n",
       "\n",
       "            // Keep the size of the canvas and rubber band canvas in sync with\n",
       "            // the canvas container.\n",
       "            if (entry.devicePixelContentBoxSize) {\n",
       "                // Chrome 84 implements new version of spec.\n",
       "                canvas.setAttribute(\n",
       "                    'width',\n",
       "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
       "                );\n",
       "                canvas.setAttribute(\n",
       "                    'height',\n",
       "                    entry.devicePixelContentBoxSize[0].blockSize\n",
       "                );\n",
       "            } else {\n",
       "                canvas.setAttribute('width', width * fig.ratio);\n",
       "                canvas.setAttribute('height', height * fig.ratio);\n",
       "            }\n",
       "            canvas.setAttribute(\n",
       "                'style',\n",
       "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
       "            );\n",
       "\n",
       "            rubberband_canvas.setAttribute('width', width);\n",
       "            rubberband_canvas.setAttribute('height', height);\n",
       "\n",
       "            // And update the size in Python. We ignore the initial 0/0 size\n",
       "            // that occurs as the element is placed into the DOM, which should\n",
       "            // otherwise not happen due to the minimum size styling.\n",
       "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
       "                fig.request_resize(width, height);\n",
       "            }\n",
       "        }\n",
       "    });\n",
       "    this.resizeObserverInstance.observe(canvas_div);\n",
       "\n",
       "    function on_mouse_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.mouse_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousedown',\n",
       "        on_mouse_event_closure('button_press')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseup',\n",
       "        on_mouse_event_closure('button_release')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'dblclick',\n",
       "        on_mouse_event_closure('dblclick')\n",
       "    );\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousemove',\n",
       "        on_mouse_event_closure('motion_notify')\n",
       "    );\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseenter',\n",
       "        on_mouse_event_closure('figure_enter')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseleave',\n",
       "        on_mouse_event_closure('figure_leave')\n",
       "    );\n",
       "\n",
       "    canvas_div.addEventListener('wheel', function (event) {\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        on_mouse_event_closure('scroll')(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.appendChild(canvas);\n",
       "    canvas_div.appendChild(rubberband_canvas);\n",
       "\n",
       "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
       "    this.rubberband_context.strokeStyle = '#000000';\n",
       "\n",
       "    this._resize_canvas = function (width, height, forward) {\n",
       "        if (forward) {\n",
       "            canvas_div.style.width = width + 'px';\n",
       "            canvas_div.style.height = height + 'px';\n",
       "        }\n",
       "    };\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
       "        event.preventDefault();\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 toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'mpl-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'mpl-button-group';\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",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'mpl-button-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        var button = (fig.buttons[name] = document.createElement('button'));\n",
       "        button.classList = 'mpl-widget';\n",
       "        button.setAttribute('role', 'button');\n",
       "        button.setAttribute('aria-disabled', 'false');\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "\n",
       "        var icon_img = document.createElement('img');\n",
       "        icon_img.src = '_images/' + image + '.png';\n",
       "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
       "        icon_img.alt = tooltip;\n",
       "        button.appendChild(icon_img);\n",
       "\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    var fmt_picker = document.createElement('select');\n",
       "    fmt_picker.classList = 'mpl-widget';\n",
       "    toolbar.appendChild(fmt_picker);\n",
       "    this.format_dropdown = fmt_picker;\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = document.createElement('option');\n",
       "        option.selected = fmt === mpl.default_extension;\n",
       "        option.innerHTML = fmt;\n",
       "        fmt_picker.appendChild(option);\n",
       "    }\n",
       "\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\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",
       "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",
       "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], msg['forward']);\n",
       "        fig.send_message('refresh', {});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
       "    var x0 = msg['x0'] / fig.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
       "    var x1 = msg['x1'] / fig.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / fig.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,\n",
       "        0,\n",
       "        fig.canvas.width / fig.ratio,\n",
       "        fig.canvas.height / fig.ratio\n",
       "    );\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",
       "        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.handle_history_buttons = function (fig, msg) {\n",
       "    for (var key in msg) {\n",
       "        if (!(key in fig.buttons)) {\n",
       "            continue;\n",
       "        }\n",
       "        fig.buttons[key].disabled = !msg[key];\n",
       "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
       "    if (msg['mode'] === 'PAN') {\n",
       "        fig.buttons['Pan'].classList.add('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    } else if (msg['mode'] === 'ZOOM') {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.add('active');\n",
       "    } else {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    }\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",
       "            var img = evt.data;\n",
       "            if (img.type !== 'image/png') {\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",
       "                img.type = 'image/png';\n",
       "            }\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",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                img\n",
       "            );\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        } else if (\n",
       "            typeof evt.data === 'string' &&\n",
       "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
       "        ) {\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(\n",
       "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
       "                msg\n",
       "            );\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(\n",
       "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
       "                    e,\n",
       "                    e.stack,\n",
       "                    msg\n",
       "                );\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",
       "    }\n",
       "    if (e.target) {\n",
       "        targ = e.target;\n",
       "    } else if (e.srcElement) {\n",
       "        targ = e.srcElement;\n",
       "    }\n",
       "    if (targ.nodeType === 3) {\n",
       "        // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "    }\n",
       "\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    var boundingRect = targ.getBoundingClientRect();\n",
       "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
       "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\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",
       "        }\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",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * this.ratio;\n",
       "    var y = canvas_pos.y * this.ratio;\n",
       "\n",
       "    this.send_message(name, {\n",
       "        x: x,\n",
       "        y: y,\n",
       "        button: event.button,\n",
       "        step: event.step,\n",
       "        guiEvent: simpleKeys(event),\n",
       "    });\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",
       "    // Prevent repeat events\n",
       "    if (name === 'key_press') {\n",
       "        if (event.key === this._key) {\n",
       "            return;\n",
       "        } else {\n",
       "            this._key = event.key;\n",
       "        }\n",
       "    }\n",
       "    if (name === 'key_release') {\n",
       "        this._key = null;\n",
       "    }\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.key !== 'Control') {\n",
       "        value += 'ctrl+';\n",
       "    }\n",
       "    else if (event.altKey && event.key !== 'Alt') {\n",
       "        value += 'alt+';\n",
       "    }\n",
       "    else if (event.shiftKey && event.key !== 'Shift') {\n",
       "        value += 'shift+';\n",
       "    }\n",
       "\n",
       "    value += 'k' + event.key;\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, { key: value, 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",
       "\n",
       "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
       "// prettier-ignore\n",
       "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\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\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";/* global mpl */\n",
       "\n",
       "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.binaryType = comm.kernel.ws.binaryType;\n",
       "    ws.readyState = comm.kernel.ws.readyState;\n",
       "    function updateReadyState(_event) {\n",
       "        if (comm.kernel.ws) {\n",
       "            ws.readyState = comm.kernel.ws.readyState;\n",
       "        } else {\n",
       "            ws.readyState = 3; // Closed state.\n",
       "        }\n",
       "    }\n",
       "    comm.kernel.ws.addEventListener('open', updateReadyState);\n",
       "    comm.kernel.ws.addEventListener('close', updateReadyState);\n",
       "    comm.kernel.ws.addEventListener('error', updateReadyState);\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",
       "        var data = msg['content']['data'];\n",
       "        if (data['blob'] !== undefined) {\n",
       "            data = {\n",
       "                data: new Blob(msg['buffers'], { type: data['blob'] }),\n",
       "            };\n",
       "        }\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(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 = document.getElementById(id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm);\n",
       "\n",
       "    function ondownload(figure, _format) {\n",
       "        window.open(figure.canvas.toDataURL());\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\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;\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",
       "    fig.cell_info[0].output_area.element.on(\n",
       "        'cleared',\n",
       "        { fig: fig },\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
       "    var width = fig.canvas.width / fig.ratio;\n",
       "    fig.cell_info[0].output_area.element.off(\n",
       "        'cleared',\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\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.innerHTML =\n",
       "        '<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 / this.ratio;\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] =\n",
       "        '<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 () {\n",
       "        fig.push_to_output();\n",
       "    }, 1000);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'btn-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'btn-group';\n",
       "    var button;\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",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'btn-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        button = fig.buttons[name] = document.createElement('button');\n",
       "        button.classList = 'btn btn-default';\n",
       "        button.href = '#';\n",
       "        button.title = name;\n",
       "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message pull-right';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = document.createElement('div');\n",
       "    buttongrp.classList = 'btn-group inline pull-right';\n",
       "    button = document.createElement('button');\n",
       "    button.classList = 'btn btn-mini btn-primary';\n",
       "    button.href = '#';\n",
       "    button.title = 'Stop Interaction';\n",
       "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
       "    button.addEventListener('click', function (_evt) {\n",
       "        fig.handle_close(fig, {});\n",
       "    });\n",
       "    button.addEventListener(\n",
       "        'mouseover',\n",
       "        on_mouseover_closure('Stop Interaction')\n",
       "    );\n",
       "    buttongrp.appendChild(button);\n",
       "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
       "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
       "    var fig = event.data.fig;\n",
       "    if (event.target !== this) {\n",
       "        // Ignore bubbled events from children.\n",
       "        return;\n",
       "    }\n",
       "    fig.close_ws(fig, {});\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (el) {\n",
       "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
       "    // this is important to make the div 'focusable\n",
       "    el.setAttribute('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",
       "    } else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\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",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which === 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    fig.ondownload(fig, null);\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(\n",
       "        'matplotlib',\n",
       "        mpl.mpl_figure_comm\n",
       "    );\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "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"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f36cdb64850>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "goodn = mlh.goodness_of_fit(*m.np_values())\n",
    " \n",
    "xstep = (bin_edges_data[1]-bin_edges_data[0])*0.5\n",
    "x = np.linspace(bin_edges_data[0]+xstep, bin_edges_data[-1]-xstep, y.size)\n",
    "\n",
    "plt.figure()\n",
    "plt.yscale(\"log\")   \n",
    "plt.step(x,y, label= \"data\", where = \"mid\")\n",
    "\n",
    "#Plot single PE curves from 1 to 5 PE\n",
    "n = 0\n",
    "while True:\n",
    "    yfit = []\n",
    "    plot_args = {**m.values, **dict(N_start=n,N_stop=n+1)}\n",
    "    for i in range(len(y)):\n",
    "        yfit.append(fit_func_for_plot((bin_edges_data[i],bin_edges_data[i+1]), **plot_args))\n",
    "    if np.amax(yfit) < 1 or n>5:\n",
    "        break\n",
    "    plt.plot(x, yfit, ls='--', color = 'black', lw = 0.5)\n",
    "    n+=1\n",
    "\n",
    "#Plot total fit\n",
    "yfit = []\n",
    "for i in range(len(x)):\n",
    "    plot_args = {**m.values, **dict(N_start=0,N_stop=10)}\n",
    "    yfit.append(fit_func_for_plot((bin_edges_data[i],bin_edges_data[i+1]), **plot_args))\n",
    "plt.plot(x, yfit,  label = \"fit values\", color = \"red\")   \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#Plot initial values\n",
    "yfit = []\n",
    "for i in range(len(x)):\n",
    "    plot_args = {**p0, **dict(N_start=0,N_stop=10)}\n",
    "    yfit.append(fit_func_for_plot((bin_edges_data[i],bin_edges_data[i+1]), **plot_args))\n",
    "plt.plot(x, yfit, label = \"initial values\", alpha = 0.5)   \n",
    "\n",
    "\n",
    "plt.ylim(1,1e4)\n",
    "plt.xlim(-0.5, 6)\n",
    "plt.yscale('log')\n",
    "plt.ylabel('Counts')\n",
    "plt.xlabel('Charge in pC')\n",
    "plt.legend()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}