{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Detector Response Tests (Obsolete)\n", "\n", "Demonstrate the conversion of neutrino flux at Earth to observed hits in IceCube." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", "\n", "from asteria import config, source, detector #, interactions\n", "from asteria.neutrino import Flavor\n", "from asteria.interactions import Interactions\n", "from asteria.oscillation import SimpleMixing\n", "from asteria.config import parse_quantity\n", "import asteria.IO as io\n", "\n", "import astropy.units as u\n", "\n", "import numpy as np\n", "import matplotlib as mpl\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setup styles for Plotting" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "axes_style = { 'grid' : 'True',\n", " 'labelsize' : '24',\n", " 'labelpad' : '8.0' }\n", "\n", "xtick_style = { 'direction' : 'out',\n", " 'labelsize' : '20.',\n", " 'major.size' : '5.', \n", " 'major.width' : '1.',\n", " 'minor.visible' : 'True',\n", " 'minor.size' : '2.5',\n", " 'minor.width' : '1.' }\n", "\n", "ytick_style = { 'direction' : 'out',\n", " 'labelsize' : '20.',\n", " 'major.size' : '5', \n", " 'major.width' : '1.',\n", " 'minor.visible' : 'True',\n", " 'minor.size' : '2.5',\n", " 'minor.width' : '1.' }\n", "\n", "grid_style = { 'alpha' : '0.75' }\n", "legend_style = { 'fontsize' : '18' }\n", "font_syle = { 'size' : '20'}\n", "text_style = { 'usetex' : 'True' }\n", "figure_style = { 'subplot.hspace' : '0.05' }\n", "\n", "mpl.rc( 'font', **font_syle )\n", "mpl.rc( 'text', **text_style )\n", "mpl.rc( 'axes', **axes_style )\n", "mpl.rc( 'xtick', **xtick_style )\n", "mpl.rc( 'ytick', **ytick_style )\n", "mpl.rc( 'grid', **grid_style )\n", "mpl.rc( 'legend', **legend_style )\n", "mpl.rc( 'figure', **figure_style )\n", "\n", "mpl.rcParams['text.usetex'] = True \n", "mpl.rcParams['text.latex.preamble'] = [r'\\usepackage[cm]{sfmath}']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Load Configuration\n", "\n", "This will load the source configuration from a file.\n", "\n", "For this to work, either the user needs to have done one of two things:\n", "1. Run `python setup.py install` in the ASTERIA directory.\n", "2. Run `python setup.py develop` and set the environment variable `ASTERIA` to point to the git source checkout.\n", "\n", "If these were not done, the initialization will fail because the paths will not be correctly resolved." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "conf = config.load_config('../../data/config/default.yaml')\n", "ccsn = source.initialize(conf)\n", "i3 = detector.initialize(conf)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Prepare Iterables\n", "\n", "Define the range of neutrino energies (`E_nu`) to simulate and the times (`time`) at which to perform the simulation. " ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Define neutrino energy spectrum\n", "E_min = parse_quantity(conf.simulation.energy.min).to(u.MeV).value\n", "E_max = parse_quantity(conf.simulation.energy.max).to(u.MeV).value \n", "dE = parse_quantity(conf.simulation.energy.step).to(u.MeV).value\n", "Enu = np.arange(E_min, E_max+dE, dE) * u.MeV\n", "\n", "# Define post-bounce times at which to evaluate\n", "t_min = parse_quantity(conf.simulation.time.min).to(u.s).value\n", "t_max = parse_quantity(conf.simulation.time.max).to(u.s).value \n", "dt = parse_quantity(conf.simulation.time.step).to(u.s).value\n", "time = np.arange(t_min, t_max+dt, dt) * u.s" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Compute Charged Particle Spectrum\n", "\n", "Compute the number of photons produced by $\\nu$ component interactions with charged particles given neutrino flavor and energy. `Interactions` contains a list of the interactions that are simulated. This list may be changed to turn 'off/on' specific interactions\n", "\n", "The interactions are as follows:\n", "- `InvBetaTab` : Tabulated inverse beta decay computation by Strumia and Vissani, Phys. Lett. B 564:42, 2003.\n", " - See Also: `InvBetaPar` : Inverse beta decay parameterization\n", "- `ElectronScatter` : Elastic Neutrino-electron scattering from Marciano and Parsa, J. Phys. G 29:2969, 2003.\n", "- `Oxygen16CC` : $\\nu$-$^{16}O$ charged current interaction, using estimates from Kolbe et al., PRD 66:013007, 2002.\n", "- `Oxygen16NC` : $\\nu$-$^{16}O$ neutral current interaction, using estimates from Kolbe et al., PRD 66:013007, 2002.\n", "- `Oxygen18` : $\\nu$-$^{18}O$ charged current interaction, using estimates from Kamiokande data from Haxton and Robertson, PRC 59:515, 1999.\n", "\n", "These `Interaction` objects may be used to compute the neutrino cross sections and mean energy of the produced lepton, both as a function of neutrino energy. The final state lepton energy has been integrated out. This cross section with a component of $H_2O$ is then scaled as appropriate for a $H_2O$ molecule (IE Electron scattering cross section is scaled by 10, as there are 10 electrons in $H_2O$).\n", "\n", "`photon_scaling_factor` is the number of photones per MeV of lepton energy. It is computed by taking product of the data members `photons_per_lepton_MeV` and `p2e_path_ratio` which are respectively, the number of photons emitted per unit lepton path length, and the ratio of positron path length to electron path length in ice.\n", "\n", "`photons_per_lepton_MeV` is computed by finding number of photon emitted per unit lepton path length and multiplying it by the lepton path length per MeV. This is done using the Frank-Tamm formula and index of refraction from Price and Bergstrom, AO 36:004181, 1997.\n", "\n", "This result estimates the number of photons as a function of neutrino energy. It will have units $m^2$ at the end of this cell but is later scaled by a factor of $r^2$ where $r$ is the progenitor distance, to account for the neutrinos spreading out as they travel." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "photon_spectra = np.zeros( shape=(len(Flavor), Enu.size) )\n", "\n", "for nu, flavor in enumerate(Flavor):\n", " for interaction in Interactions: \n", " xs = interaction.cross_section(flavor, Enu).to(u.m**2).value\n", " E_lep = interaction.mean_lepton_energy(flavor, Enu).value\n", " photon_scaling_factor = interaction.photon_scaling_factor(flavor).to( 1/u.MeV).value\n", " \n", " \n", " photon_spectra[nu] += xs * E_lep * photon_scaling_factor # u.m**2 \n", " \n", "photon_spectra *= u.m**2 " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Compute Signal per DOM\n", "\n", "For each flavor, compute the photonic energy deposition in one $m^3$ of ice, and then scale it to the effective volume of one DOM.\n", "\n", "`photonic_energy_per_ performs the simulation utilizing numpy broadcasting, and not iteration.\n", "\n", "1. Compute the neutrino spectrum from the model Luminosity $L$, Mean neutrino energy $\\left< E \\right>$ and pinch parameter $\\alpha$, which are specified in the SN spectrum file chosen by `config`. This spectrum is a gamma-like p.d.f. of neutrino energy, computed for every time step in `time`. \n", "\n", "2. Multiply the neutrino spectrum and photon spectrum, which are both functions of neutrino energy, then numerically integrate over neutrino energies. This is computed for every time step in `time`.\n", "\n", "3. Scale the result of the numerical integration by the neutrino flux and divide by $r^2$ to obtain the photon energy deposition per $m^3$.\n", "\n", "This result of `photonic_energy_per_vol` is scaled to the effective volume of a DOM to find the expected signal increase in a single DOM." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Beginning nu_e simulation... Completed\n", "Beginning nu_e_bar simulation... Completed\n", "Beginning nu_x simulation... Completed\n", "Beginning nu_x_bar simulation... Completed\n" ] } ], "source": [ "E_per_V = np.zeros( shape=(len(Flavor), time.size) ) * u.MeV / u.m**3\n", "total_E_per_V = np.zeros( time.size ) * u.MeV / u.m**3\n", "\n", "mixing = None\n", "if conf.simulation.hierarchy in ['normal', 'default']:\n", " mixing = SimpleMixing(33.2).normal_mixing\n", "elif conf.simulation.hierarchy in ['inverted']:\n", " mixing = SimpleMixing(33.2).inverted_mixing\n", " \n", "icecube_dt = 2e-3 #s\n", "\n", "effvol = 0.1654 * u.m**3 / u.MeV #Simple estimation of IceCube DOM Eff. Vol.\n", "\n", "for nu, (flavor, photon_spectrum) in enumerate(zip(Flavor, photon_spectra)):\n", " E_per_V[nu] = ccsn.photonic_energy_per_vol(time, Enu, flavor, photon_spectrum, mixing)\n", " total_E_per_V += E_per_V[nu]\n", "\n", "signal_per_DOM = effvol * E_per_V " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Save Simulation to File\n", "\n", "The photonic energy per volume is the quantity that is most computationally difficult to obtain, and can be used to obtain numerous high level results. Saving this information to file enables faster processing for large scale analysis. Using `IO.save` the energy per volume is stored in the file `\\data\\processed\\nakazato-shen-z0.02-t_rev300ms-s13.0.h5`, the path to which is stored in `conf`.\n", "\n", "The result is scaled to a progenitor that is 1 kpc away. See the file `\\docs\\nb\\load_simulation.ipynb` for information on reading the simulation result from file.\n", "\n", "__NOTE__: If the a simulation with the same configuration already exists in`\\data\\processed\\nakazato-shen-z0.02-t_rev300ms-s13.0.h5`, trying to save the simulation will cause `io.save` to throw an exception, which is handled in-line with a `try`/`except` block. This may be bypassed by using\n", "\n", "```io.save(conf, E_per_V_1kpc, force=True)```" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Found 0\n", "Simulation exists, Aborting. Use argument 'force = True' to force saving.\n" ] } ], "source": [ "E_per_V_1kpc = E_per_V * ccsn.progenitor_distance.to(u.kpc).value**2\n", "try:\n", " io.save(conf, E_per_V_1kpc)\n", "except FileExistsError as e:\n", " print(e)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define Helper Functions\n", "\n", "Define Functions for plotting, retrieving information from ROOT Files\n", "\n", "- `rebin` Reshape the independent variable `var` with resolution `old_binning` and dependent variable `data` (assumed to be numpy array) and return new arrays `var` and `data` with resolution `new_binning`.\n", "\n", "- `bin_hits` using the `detector` table of DOMs and their properties, determines the number of hits within the specified binning `binning`. This takes into account the artificial deadtime of the DOMs.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def rebin(var, data, old_binning, new_binning):\n", " step = int(new_binning/old_binning)\n", " new_size = int(data.size / step)\n", " rebinned_data = np.array([np.sum(data_part) for data_part in np.array_split( data, new_size )])\n", " rebinned_var = var.value[int(0.5 * step)::step]\n", " \n", " return rebinned_var, rebinned_data \n", "\n", "def bin_hits(detector, time, total_E_per_V, dt, binning):\n", " doms = detector.doms_table()\n", " n_i3_doms = len(doms[doms['type'] == 'i3'])\n", " n_dc_doms = len(doms[doms['type'] == 'dc'])\n", "\n", " deadtime = detector.deadtime\n", " dc_rel_eff = detector.dc_rel_eff\n", "\n", " i3_dom_bg_mu = detector.i3_dom_bg_mu\n", " i3_dom_bg_sig = detector.i3_dom_bg_sig\n", "\n", " dc_dom_bg_mu = detector.dc_dom_bg_mu\n", " dc_dom_bg_sig = detector.dc_dom_bg_sig\n", " \n", " time_binned, total_E_per_V_binned = rebin(time, total_E_per_V, dt, binning)\n", " eps_i3 = 0.87 / (1+deadtime*total_E_per_V_binned/binning)\n", " eps_dc = 0.87 / (1+deadtime*total_E_per_V_binned*dc_rel_eff/binning)\n", " hits_binned = i3.detector_hits(total_E_per_V_binned, eps_i3, eps_dc)\n", "\n", " sn_bg_mu = (n_i3_doms*i3_dom_bg_mu + n_dc_doms*dc_dom_bg_mu ) * binning;\n", " sn_bg_sig = np.sqrt( (n_i3_doms*i3_dom_bg_sig**2 + n_dc_doms*dc_dom_bg_sig**2) * binning )\n", " bg_binned = np.random.normal(sn_bg_mu, sn_bg_sig, time_binned.size)\n", " \n", " return time_binned, bg_binned, hits_binned" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plot Expected Signal Increase for Each Flavor\n", "This will plot the signal increase in a single DOM caused by each flavor. The curve shows the DOM response from 0.05 seconds before the core bounce to 0.65 seconds after the core bounce. Note that this is computed with the assumption that the effective volume of the DOM is 0.1654 m$^3$ MeV$^{-1}$" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(1, figsize = (6,7))\n", "\n", "for nu, flavor in enumerate(Flavor):\n", " ax.step( time, signal_per_DOM[nu], label=flavor.to_tex(), linewidth=2)\n", " \n", "ax.set_ylabel( 'Signal per DOM', horizontalalignment='right', y = 1)\n", "ax.set_xlabel(r't-t$_{bounce}$ [s]', horizontalalignment='right', x=1.0)\n", "ax.set(xlim=(-0.05, 0.65))\n", "ax.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plot Expected Signal Increase in Detector\n", "This will plot the signal increase across the entire detector. The curve shows the DOM response from 0.05 seconds before the core bounce to 0.65 seconds after the core bounce." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ8AAAHFCAYAAAAt9/QFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3df2wc930n/PfHdGTTjy0vKcuxdJYrLQMjwiH3yEvmAgpt4EbLu+fk/mE/IeUgQJE/2pC+A4oWl0ZrGQeYD1JUJt07FLjiSUlfgAQHBJWWTv2PfJdwmRpxIOHO3BUTAzFwPa3cCI9iOya5VlPZUUR/nj9mZjm7nJmd37O7fL+AxWpn58dXw9n5zPe3qCqIiIjSdEfWCSAiot2HwYeIiFLH4ENERKlj8CEiotQx+BARUeoYfIiIKHV3Zp2AXvDAAw/o4cOHE9v/hx9+iMHBwcT2T954/rPDc5+tpM9/tVp9X1X3O33H4OPD4cOHsbq6mtj+19bWcOzYscT2T954/rPDc5+tpM+/iPyD23e+go+IfCG+5Oykqj9Mcv9ERNRd/OZ8KgCSGgpBA6SDiIj6QJCbfsV8xWkCwImY90lERF0uSPBZVtW/iPPgIiJg8CEi2nX8Bp95xJ/rAYBlAMMJ7JeIiLqYr+Cjqs8mcXBVvQzgchL7JiKi7hW6k6mInIszIUREtHtI2Pl8RGRLVQdiTk9XGhsb07j6+XzwwQd4//33cevWreayW7duYc+ePbHsn4Lj+c8Oz3222s//wMAA7rvvPgwPD+Ouu+6KvH8RqarqmNN3nsVuIvIx3JtYi4hsWR92SyCK4qOPPsK7776Lhx9+GIODgzDaWwA3b97EPffck3Hqdi+e/+zw3GfLfv5VFb/5zW9w48YN/PznP8cjjzwSSwBy06nOZwVG8PlrtNbNCID/DcAxopGzX/7yl9i/fz9/bETUdUQEe/bswQMPPAAA2NjYwIEDBxI7nmedj6pOAFiA0drtBQAfq+pVVa0bX+tl65VYCvvIRx99hHvvvTfrZBARedq7dy/+8R//MdFjdGxwoKovq+qnAFQBXBWR/1dE9iaaqi4hIrMiotevX49lf7dv38add3IwByLqbp/4xCewtbXVecUIfLd2U9V5GH1yHgDwdlIJ6iaqOquqcvDgwdj2adXzEBF1qzTuU4Eew1W1AeCUiBQBFJNJEhER9btQZUCq2hznTUQOA8hhe6SCDQANVX07evKIiKgfhepkKiJfEJHvm02tr8CoD1o2X1UAV0RkXUT+RkSeii+51O0WFxchIi2vkZERzMzMoNFoxHacqakpTE1Nxba/biEiqFSSGMmK7NK6Tsld4OBjjmywDGNE6ssAXgLwou31EoCXAWwCOAVgSUT+Jq4EU29QVagqNjc3sbCwgNXVVRw5coQ/bOoqm5ubzWu1XC5jY2MDR44cQb1ezzppfS9Q8BGRrwOYghFghlR1TFWfUdVnba9nVPWU2ULuUwC+B2BKRL4Wf/Kp2+VyORSLRVSrVQwPD6NUKmWdJKKmXC7X/HehUEC5XEY+n+d1moKgOZ8ZGFMrPKOqH3RaWVXrqjoF4IcAngmTQOofhUKBT5TU9cbGxlCr1bJORt8LGnzyAML8VarmtrRLNRoNVCoVTExMZJ0UIk+rq6vI53m7SlrQ4HMZwGSI4xQB8JF3F2k0Gmg0GqjX61haWsLo6CiKxSJOnz7dXKdSqWB0dBQigqGhIceijvn5eYyMjDQrhBcXFx2PNzU1haGhoZac1czMDIaGhjAyMoJSqdQ8lvVdqVRCpVLB7/3e72F+fn7HMYeGhjA1NbWjnsqpsYOIYGlpqeXYMzMzLfuyH8M6R1NTUxARjI6Ouv7fKDn1er15rVoPR/V6HQsLCy3rlUolDA0N7bhO5+fnMTQ0tOP6LJVKO/7+MzMzjmnwut78XEduafBKdzcI2tT6LIDzIvLfAZRU9SdeK4vIFwDMAXgMRl0ROfjRj36Eu+++O+tk7PD444+H3nZoaKjl8/T0NObm5lqW1et1zM3NIZ/Po16vY2JiAiMjI5iengZg/HAWFxfx0ksvoVAooFar4Y033thxrJmZGSwtLaFarTafWGdmZlCv13H16lWcP38eMzMzLd9vbGygUqlgcXERX/va15rHnJmZQaVSwcLCAvL5PObm5nDkyBFcvXq1pX6gk42NDSwtLWFubg7Ly8tYWFhAqVTC5ORkMw1TU1NYXV1FuVxGoVDYcX66TTL9DqOPcxhyYH4AwMjISMvn6elplMvllr/11NQUarUaVlZWsLGxgZmZGYyMjDTrhqrVKnK5XDOQAWg+dM3NzaFcLuPcuXPNAGJ/AOt0vXW6jiqVimsa3NJtXetZC9rJdElEnoUxztuE+RRZg9G3xzIMo9+PlW8VGIHqe9GTS73CPlWHFWSOHDmCcrmMYtHon2z/EeTzeUxOTqJcLmN6ehqNRgPz8/NYXl5urm+tY2cFqOXlZRQKheby8+fP46WXXkIul8P09DRKpRLq9XrLOvV6HdVqFZ/+9Kdxzz33oFarYXFxEVeuXGkGCKulXqlU2vE03Ekul2veaM6cOYP5+XnU6/VmsK1UKi3/v4WFBeZ+UmZdp41GA0NDQxgdHW0JPFYQqVarzWtnbm4OZ8+exZkzZ5DL5ZDP55vvdvacvlXfubCw0Fzm93rzuo4ajYZjGrzS3ZPBBzCG2RGRMoyczNMARgCMOqxagdEke0lVr0ZKZZ/7/Oc/39cjXefz+eYPaWpqCpubm83vlpaWcO7cOdTrddRqteaN2OrrYn12UqlUmk95Y2OdB1jf2Nho+VwoFFAoFHDz5k0ARlm/200kTN8be5qsG5qVXqtC2+v/122i5DDcdMuUCtYNvlQqtdycrb/76OjOW1yxWMTw8DCGhoZQLBYxMTHRkqtpNzEx0VI06/d687qO3NLgle5uEaqTqTmy9byqjqrqsKreoap3wGh+fYf5+leq+iIDD1msDnzWjXd0dBRnz57F008/jXK5vCNX00mj0WgW2331q19t+a5YLGJhYQGNRgNLS0toNBo4depUyzrtP3qvPkhh+icFKaaj7FnFnu11KrlcrtkXyP7K5XK4cuVKs5iuVCoF6vjs93rzuo680uCW7m4RehptJ36aX9PuZT2NWfU3tVqtGXTaA4FVVOCV47CKNcrlMpaWlhzXtSpal5eXOwaDYrHYEhwtS0tLO3Io9ptDmMDk9P9jB9zsnTlzBqVSqSVn4XRN2FnFxdZ16Maq27MEud46aU+Dn3RnLdbg40ZEHhORb6ZxLOo+9XodpVIJpVKp+XRpBZu5ublm+bT9h5vP5zE9PY2pqSksLS0117E31baCSaFQaK5rqdVqmJqaalbSDg8Po5NCoYDJyUlMTU2hUqk097GxseHYWMKq3G3PdfmRz+dRLBabFc7WsShbp0+fbuYggNbrsFKpNK9D67oslUqo1Wqo1+tYXl5ueYiyGrRY13+lUsGZM2ea3we53ty4pcEr3V3DKVsW9wvAFwFspXGsJF6jo6Mah5/97GeOy//pn/4plv13g4WFBYUx+23zlcvltFgs6vLycsu6p0+fbn4/PT2tk5OTOjk52bLO3Nyc5vN5BaCFQkEXFhZUVR3XtfajqlosFnekI5/P65UrV3Zs337+T58+rfl8vpluaxtLtVrVXC6nALRYLGq1WtV8Pt/y/3NKHwAtl8vNz5ubm1osFpvHKZfLO/bT77K69q3r1Os7+9+9/Tosl8t65coVnZycbF4LhUJBq9Wqqhp//0KhoNPT05rL5TSfzzev3XZe11un68grDW7ptvM6/273qyAArKrLfVU0hTJAEfkigPOqOpD4wWIkIrMAnj9w4ADimFDurbfewtGjR3cs75ZK135hPeHZWxHV6/XmU1+1Wm1Zn+c/O/167q3+OsvLy1knxZPX+Xe7XwUhIlVVdWwNFKi1m4j8AMBQxxV36smaV1WdBTA7NjbWPbV01JHVpNpeBJLP5zEzM9P1fWmIdougTa0XAZwPeSzewCkVk5OTzTqmmZkZDA8PNzvjdUsfB6LdLlCDA1VdgtGpdEG3m1R3fIGDilKK8vk8qtUqarUaRkdHMTQ0hLNnz2Jubo45H6IuEWYm01UEn0J7PcRxiEIrFApdX95O/atcLmedhK4Xpql1HcaoBkGxsykREQEIEXzUGNkgaHHdy2pMLkdERJROJ1PalkbTdiKiKNK4TzH4pOjOO+/E7du3s04GEZGn3/zmNxgYSLZbJoNPiu6++2786le/yjoZRESebty4gfvuuy/RYzD4pGj//v345S9/iZs3b7L4jYi6iqri1q1beP/997G5uelrPMQowjS1zoyITAMowZiorgbgrNn3yO/2OQCbAKCqiczL6OXuu+/GJz/5Sbzzzjv49a9/3Vx+69Yt7NmzJ+3kkInnPzs899lqP/8DAwO477778Mgjj+Cuu+5K9NiRgo+InAAwrapPd1jvGICXVPWzEY51GsAZGMFnA8AMgLKIlFR13nPjbXMwmornO62YlPvvvx/3339/y7K1tbXIYyhReDz/2eG5z1aW5z9SsZuqrgC4Q0T+xm0dEXkMwAqMoBHFGQCjqrqoqkuqOgFjttQ5M0fjSUTyAKbNbYiIKEOR63xUdQrAgFMAMgNPBcApVf1hxEOdV9V62zJrrJTOcygb6y4B4IxdREQZi6XBgVMAags8KzEcY8bj6w2vbUWkAGASwNmo6SAiouhia+1mC0DnzDqeFcQUeDxMmMfuNFfsHICKj/WIiCgFsbZ2U9Upc86fKoCJGIraXJl1OKdhNDzwWq8IYyDUUZ/7nQXwvH3Z/v37sba2Fi6hPqyvrye6f/LG858dnvtsZXn+Y53J1Mzx/BDGyNebnVrBRThODkaAW1JVz4YMIlIFsGE2UICIzAE4HaSp9djYmK6urkZJsqe1tTUcO3Yssf2TN57/7PDcZyvp8+81k2lsxW5mHc8PAXxBVf8VOrSCi3CcIIFnEkABRpPsgln3kze/K5i5JyIiSlkswcfWuOCEqq4B3q3gIhwnB6MuaaFT4DFZwWUBRsCqwmh4APPfnHSDiCgDkYOPLfAUVfWy/bs4A5At8Jzz26nUnP5B7C8YU4HD/OyrHoiIiOIVKfiIyBEYAWFH4LGYAegOEflmlGOZx9kAUBORybZXzkxPXkQWzOI1IiLqUnG0djvhFngsqnpKRL4Y9gBmcLECitMU3lMwOpDmYIxisAxj7DciIupCkYKPqvqeGltVX45wnAaAjq3TzH48nuuZnVU9m2cTEVGyOKUCERGljsGHiIhSx+BDRESpY/AhIqLUMfgQEVHqGHyIiCh1DD5ERJQ6Bh8iIkodgw8REaWOwceDiMyKiF6/fj3rpDi6dAk4e9Z4JyLqJbHOZNpvVHUWwOzY2Fh8M+5F9MQTwKuv7lw+Pg5cvJh+eoiIwkgl5yMi6yKyZb6fNWc8pRCcAg/A3A8R9Za0it3eBnAVxojTQwBeSum4feviRWBwEBgYyDolRETBpVLs1jZpW+jRrWnb+DiwsgK89hrw3HNZp4aIKBg2OOhh4+PAmTNZp4KIKDgGHyIiSl3k4CMiJ8xGBHtty/aKyPfNRgZbIvLnUY9DRET9I46czwyAaVW9YVtWgzHd9WUAawBKIvK1GI5FRER9II7gUwRQsT6IyBcB5AFUVHXMbGywBuCZGI5FRER9II7gkwPwhu3zBAAFULYtW4YRkIiIiGIJPg20Bpai+X7etixnrkdERBRLP58ygBkRaQAYgRGIltvqgIoAVmM4FhER9YE4gs9pAGMAnjU/1wBMWV/a6oBOx3AsIiLqA5GDj6p+AGBURI6Yn6+2rVIBMKGqK1GPRURE/SG24XUcgo61/AMADDxERNTEEQ6IiCh1seR8ROT/BvA0jFZtwy6rqar+yziOlxYRmQXw/IEDB7JOChFRX4kcfETk6wBeACAdVu2aCdn86sbJ5IiI+kFcw+sARgu3IVW9w+XFmWeIiAhAPMVueQALqsp5eoiIyJc4cj61GPZBRES7SBzBpwTglIj8nzHsi4iIdoE4it2OALgKoCYiVQBVl/VUVf9dDMcjIqIeF0fweRbbA4uOmS8nCoDBh4iIYgk+U51XISIi2hbH2G6X40gIERHtHhxeh4iIUhco5yMi52A0HPiSbdlZn5urqj4X5HhERNSfgha7TcFoOPAl27KSz20VAIMPERGFCj7tRuNICBER7R6Bgo/TEDpscEBEREGxwQEREaUutplMLSKyF8A0gM8C+AGAsqreiPs4u82lS8Brr2WdCiKieATO+YjIn4rI34vIloj8T/uYbiLyGIyhduZg1A8tAqj36rhvIjIrInr9+vVMjv/EE4CI8Tp+HHiOzTWIqE8ECj4i8k0YgWUERpAZA/BDEfktc5UygCEYQ+5MAPgLGDObrsSV4DSp6qyqysGDBzM5/quvOi9/9NF000FEFDffwcfM1czAmEJhSFU/BeBTADYBLIjIH8IY4y2vqi+q6oqqlgCcAjAsIn8ef/J3h4sXgcFBYGDAeP/2t7NOERFRNEHqfM7A6KtzwqrDUdW6iJwCsAojNzSnqm/bN1LVJRGpwcgJseAohPFxYGXFqPN5/HHjMxFRLwsSfAoAFtsbD6hqTUQuAzgG4JzLtufhvzMqORgfZ9Ahov4RpM4nD+CKy3dvAICqrrl8fwVALsCxiIiojwVt7VZ3We4WlChFly4BZ88a70RE3Sz2fj6UnePHWz+fPAlcuJBNWoiIvATN+WgiqaBITp50Xu7WVJuIKGtBcz5LIuL6pYhsRUsOhXHhglHUduIEcOsWsGcP8OGHWaeKiMhdkOBzFcz5dK325tjtRXBERN3Ed/BR1ZEkE+KHiEzDaLKdh9HZ9ayqLiW1Xa9hc2wi6hU9M6q1iJyGMbSPNW7cBoCyuTz27YiIKDm91NrtDIBRVbWaey+JyDKAORFZVNVGzNsREVFCeibnA+C8LYBY5sz3sQS26wvs+0NE3ahncj6qOuPx9Ubc2/ULe8OD8XFjkFIioqz1Us7HyQRgjC+X0nY9w6nvT7/kfpibI+p9otqbradFxBprbkZVF+PaTkRmATxvX7Z//3784Ac/iJZgD+vr69i3b9+O5Y89dgwAcPmy25B53n7yk3swM/Mp3L4t2NqSSPvK2h/90RH8+Mf371j+L/7Fr/Cd7/zvSPt2O/+UPJ77bCV9/h977LGqqjpWb/Rk8BGRHIAqgCVzzqBEtxsbG9PV1dXgCfVpbW0Nx44d27Hc6s8b5U9kTb9tzYLag39uANvnwknU/5Pb+afk8dxnK+nzLyKuwafnit3SDjy9bnwcOHMm61TExz6xHhH1rp4KPmYAWQGwECLwBN6Ouo81ksM3vrG9jHVARL0ncvARkRMiclZE9tqW7RWR74vIlvmKPIW2LYCcU9X5pLej7mAFFrv23Nzx40ax4vHjRvHcE0+km0YiCi6OptYzMKbWthfu1AAcAXAZgAAoici6qv7HCMdZgdE0uiYik23fVVS1YTYmKMHI4dT8bhchTZSQJ57oPCr3yZPO63A0b6LuF0fwKQJYtj6IyBdhjKG2rKr/2lxWBfAMgFDBx8y9FGzHazcFYAnGbKnTZnpqAbajLuMUQB59tPUzR/Mm6l1xBJ8czGm0TRMwRr8u25YtA/h62AOYuROP9k7N9Wr29fxuR91rcHA7sHz72zu/52jeRL0pjuDTgJHTsVg5jPO2ZTlzPaJA7IHFbcRujuZN1HviCD5lADMi0gAwgu0itxu2dYoAkusoQ4FYfX+8bujdckwGFqL+FEfwOQ1jgM5nzc81GHUpAFrqgDiFQRdo76yZ5Hhvbo0G0hhjLosA2614LqgbRQ4+qvoBgFEROWJ+vtq2SgXAhKquRD0WhefWMizJvjFurc7S6I/TXvdz8qTRQGE3cQv+u/FcUPeJrZOpql51CDxQ1Q8YeLJ34YIxDE0WIwT4PWYcnUWdBlQFdmfza7f/8248F9R9emZKBYqHvXWYNd5b3KxiHr/H9NOnxy82v97J3mJwt58L6h6x5HxE5Jsism4b0cDpdTuOY1F0TuO9Rc11PPGEUZ8ksj3iQKdjWtwCj1suphP7EDwrzHPzXFBXipzzEZG/htGxEwDqYJPqnhNHIwS3ANLeMdSL/Ql9ZSVa5ThbyW3juaBuFEex2ykAmwDyZuODvmHN7XPgwIGsk5KIJBohXLzYWuTl1DHUjZ8+PUTUH+Kq8znfb4EHAFR1FsDs2NhYj86C481q8WSvI9nairbP9hEH2KeHiJzEEXxWAQzHsB/KSNyNEBhEomPfHOp3cQSfZwCsisgfqOq3YtgfZcAKGFbwSfrmZ98/bXNq+edVB8cgRb0qjk6mdRFZBLBovrs1OlBV/ZdRj0fpSLqTJgcAdeanDi7LkSOI4hLHZHIvwBixWszXCIBRlxd1uaQ7abrtP2yz6n7l1Sk3y5EjiOISRz8fq5n1pKre4fFKsU89hXXhQuuIBIOD29/FMQKB0/4vXuRwL+3apwp3ksVoFURxiWs+nwVV/V4M+6Iu4DZHTlxFcVFaxO0W7XVwbuskPVoFUVLiCD61zqtQr7G3WEtiumq2iIuHV0MRom4WR/ApATgvIn+tqj+JYX/UZTheWu9gQw7qFXEEnyMArgKoiUgVQNVlPVXVfxfD8SgDbkVx7YOIdrN+bpbsljtlQw7qVnEEn2exPY32mPlyogAYfHqYU1FZLz1p29OaRN+ZtPpGOXHKnUYdH48oSXEEn6nOq1C/cXrSDjKIaJqc0hq174w90PzZnwXrGBpG++CvToI05OjnXCD1hjg6mV6OIyHUW5yetIMMIpqm9rQ6jV/nt++M37mH4upz41ac5hbo/Tbk8JsLJEpKbDOZ0u7TPm9ONz9B29PqpVPfGbfAMz6eTJ8bpxloBwfDB3qnOiB2TqUsMPhQJNYkcd0ceCxeE9rZ1/ETpNo7yV686G+7sOIK9O2dfO3i6ERM5Ben0SZq46eDp1PditN2cdatxNU3yqlzahwTChIFweDjod8nk6Pw/AQCtxt6N1T2W+n/8Y/jn1CQyA8Wu3lQ1VlVlYMHD2adFMpQ0OIot741ly4ZAen4cSPHcfx49k3VneqUiNLAnA9RB0EDhNMMsarAxx/vXLdbchgcJ47SxpwP7WqXLgHf+taDjt9Fnf7B3kjgxz/u/hyGnwYZRHGJnPMRkcMwRra2ptLeANBQ1bej7psoSdt1Ms7FqnGMGtBeN8QcBpEhVPARkS/AGFC06LFOA8AygHOq+rfhkkcUvyAdN5OY/sFPazqifhc4+IjIOQCTMGYtrQFYReu02VYuqADgFIApESmr6peiJ5coup11Moo9e8S142bS0z9wGgTajQIFHxH5Ooyx3BYBlFT1gw7r5wHMwQhAb6jqfwydUqKYWbma7373F/jylw9m1uw56xZvRFkI2uBgBsCyqj7TKfAAgKrWVXUKwA8BPBMmgURJGh8H/uAP3ssk8ERt0EDUy4IGnzzCzVxaxfa0C0SEnUPdWEP1hJmanKjXBK3zuQyjvidog8wigHrAbYj6XhINGoh6QdDgcxbGlNn/HUadj+e02WaruDkAj4Hz/hA5SrpBA1E3ChR8VHVJRJ4F8AKACTE6StRg9O2xDMNo8WYVswmMQPW96MklIqJ+ELiptarOi0gZRk7maQAjAEYdVq3A6OezpKpXI6WSiDLRDYOgUn8K1cnUDCbz5qtJRO730wqOiLofp1mgJMU6thsDD1Hv8xqVmyguqQwsKiKPicg30zgWEUXDaRYoDWmNap0HMJ3SsWIjIrMiotevX886KUSp8zulOFEYnFLBAyeTo92O0yxQUoKO7fYDAEMhjpMLsQ0REfWpoK3dFgGcD3ksDbkdERH1mUDFbqq6BKNT6YKq3uH3BQ4qSkRENmHqfFbhMYmci/UQxyEioj4VJvjUYYxqEBRHOSAiIgAhgo+qzptFaUG2eVlVPxX0WERE1J/Y1JqIiFLH4ENERKnzFXxEZEtE/jTug4vI10Xkdtz7JSKi7uY35yNIrp+OdF7FXFFkWkSuiIiKSFVEJn1uVzDXD7QdERElI0ix27yZA4rtBWNSOl9E5DSMWVHnYMwltAGgbC732i4PoGquPwHgnLkdAxARUUb8jnBwGdmPUHAGwKiq1s3PSyKyDGBORBZVteGyXQlAXVUnzM8VERkB8BKApWSTTERETnwFH1V1mqk0bedtgccyB6PD6xiMmVOdnAJwtm3ZAoBpESmoai3eZBIRUSc909pNVWc8vt5wWigiORiDmrYELVvAGYsndUREFETPBB8XE0BLMGk3bL67FclxtG0iogwEHdW6a5gNCU4D8MoRdQou+xz2Owvgefuy/fv3Y21tLWgSfVtfX3fZ/zEASPTY5HX+aVsy1yLPfbayPP89GXzM4rRlAPOquuhjE7cgtGPAU1WdBTBrXzY2NqbHjh0LmEr/1tbW4LX/JI9Nnc8/bYv7PPHcZyvL899zxW5m4KkCWFLVUofVreK2YftCcx/274mIKEU9FXzMoLECYz6hToEHZuu4BnaOwm01NFiNN4VERORHzwQfW+A5p6rzATY9D2C6bdkMgAabWRMRZaOX6nxWYDSprjmMTlBR1YbZCKEEI2dkBZY5GH16yjD69xQATMK7oQIRESWoJ4KPmespmB+dZlGdgjFaQQ5GLmcZxnTfUNW6iIzCCEJlGH1+Znw2VCAiogT0RPAxh87pOACpmdvZsZ65fGLnFkRElIXIdT4ickJEzorIXtuyvSLyfdsgon8e9ThERNQ/4mhwMANgWlVv2JbVYBSPXQawBqAkIl+L4VhERNQH4gg+RdgG9RSRLwLIw2gEMGYOSroG4JkYjkVERH0gjuCTA/CG7fMEjOkXyrZlyzACEhERUSzBp4HWwGK1RjtvW5YDRxMgIiJTHK3dygBmRMQaSSAPYLmtDqgIjiZARESmOILPaRjD1Txrfq7B6HcDoKUOyHO6ayIi2j0iBx9V/QDAqIgcMT9fbVulAmBCVVeiHouIiPpDHP189gJG0HEIPFZwUns/ICIi2t3iaHCwKSJ/2GGdJWwXy/UMEZkVEb1+/XrWSSEi6itxBJ+Ow97AaFoixmoAACAASURBVPk21XGtLqOqs6oqBw8ezDopRER9Ja4pFdTtCxE5DKNBAvv5EBERgJANDkTkY7QGnEUR8RolWmDMPkpEPezSJeC114DHHwfGx7NODfWysK3dVrAdfIoArsK9E2kdxggInMKAqMcdP976+eRJ4MKFbNJCvS1U8FHV5vQEZi7oBVX9L7Glioi6ysmTwKuv7lzutIzIjzjqfBbB0QuI+tqFC8DFi8DgIDAwYLwTRRFHJ1OOVk20C4yPAysr23U+7UVwREEECj4icg6AquqXbMvO+txcVfW5IMcjou4yPs6GBhSPoDmfKRgNDb5kW1byua0CYPAhIqJQwafdaBwJISKi3SNQ8FHVlx2WXY4vOUREtBvENcIBERGRbww+RESUOt/FbiLy/YjHUlX9vyLug4iI+kCQOp+JDt8rvEe4dh18lIiIdpe4gs8UgK92WIeIiAhAgODjNQ22iBQ6rdOLRGQWwPMHDhzIOilERH2FDQ48cDI5IqJkMPgQEVHqGHyIiCh1DD5ERJQ6Bh8iIkpdkE6mez2+3meucx88+vqo6g3/SSMion4VpJ/Ppo91Gh7facDjERFRnwoSDG6AoxQQEVEMgnQyHUoyIUREtHuwwQEREaWOwYeIiFLH4ENERKlj8CEiotQx+BARUeoYfIiIKHUMPkRElDoGHw8iMisiev369ayTQkTUVxh8PHAyOSKiZDD4EBFR6oKMan024rFUVZ+LuA8iIuoDQQYWLUU8lgJg8CEiokDBZzSxVBAR0a4SZFTry0kmhIh606VLwGuvAY8/DoyPZ50a6hWc3I2IIjl+vPXzyZPAhQvZpIV6B1u7EVEoJ086L3/11XTTQb0pluAjIsdE5Psisi4iWy6v/xnHsYioO1y4AFy8CAwOAgMDxjuRX5GDj4g8BqAKYAKAALhqe7f+bX2OcpyciBREpCwiCwG2K4pIVURURK6IyHSUdBDRtvFxYGUF+MY3jHciv+Ko85kD8AGAUVW9KiI5AOsACqp6Q0TyAFYBnAt7ABGZBFAGUAeQB7Doc7sigGUA8zCaiucBzInIiKpGbTpORDACEBsaUFBxBJ8igNOqehUAVLUhIgLgCICfqGpdRM4DmAHwvTAHUNUlERky970ZYNM5AEv2QGMkDQuI3m+JiIhCiqPOpwFgX9uyOoDP2j5fATAW5SCq2gixWQHAG23LVgFARApR0kNEROHFEXxWYeR+7F5Ga87iaQC5GI4VVAWtQRAwg6Cq1tJPDhERAfEEn0UAoyJyzLbsrwGMiMjfi8jfw8iBVGI4VlAzAIoiMmc2PJiGURQ3k0FaiIjIFLnOx6yPGYWtNZvZ8OAUgJcA3A9gCcBXox4rRNrqInICRmu80+bikqr6arBARETJiGWEA6ehd1R1CUbQyYyZ01kAMGUGyQKAsoh8VlWnXLaZBfC8fdn+/fuxtraWWDrX19dd9m9kJpM8Nnmdfwou2DXLc5+tLM+/qGq0HYjsVdUbHdb5AoDVTuv5PN4mgPOq6ll0Zjb53gQw39barQCzX5Kq+ioKHBsb09XV1Qip9ra2toZjx47tWG40zAMi/omoA7fzT8EFvWZ57rOV9PkXkaqqOjY2i6POZ1NE/rDDOksAno3hWEEMm+/trd3q5jtbuxERZSSO4CM+1jkPwLGYKymqagWZibavrJZ5bO1GRJSRuEa1ds1ki8hhGM2b81EOYI6UYBm2PltBxvxcArBga0Y9A2BBRBowRjrIY7vjaRat74iICCFzPiLysTVgqLlo0W1AURgdTAuIkNMw62mumK8cgEnbZ0sOwDRsQc5s1TYBI7ezDCM4nXVrbEBEROkIm/NZwXZupwijmbXbCAR1GPUuoZs3mzkZz+I9t3XMHA5nYSUi6iKhgo+qNutRRORjAC+o6n+JLVVERNTX4hrhILl2yERE1HfiGOHgGevfZuOCAox6lzqAmqq+HfUYRETUX2Jp7SYie2G0IrMmahOYdUIiUgYwHUcHUyIi6g9xNbX+IYwczxKMVmXWpG+nzFcBwKMxHYuIiHpc5OAjIi8AeAzGcDX2iXRXALxkzkJ6XkT+XFWfi3o8IiLqfXE0OCjC6LTpOIO7OcBoBTtHGiAiol0qjuBTwPZ4aW5q4FhqRERkiiP4VNA5sBTBsdSIdo1Ll4CzZ413IidxBJ8lABMi8jWnL211QudiOFaqRGRWRPT69etZJ4Wopxw/Djz3nPF+/HjWqaFuFDn4mOOnvQzgRXPa7G+KyJ+a738PYwbRiqr+RdRjpU1VZ1VVDh48mHVSiHrCyZM7lzH3Q058Bx8R+UNzUrgdzIE6nwGwD8ZI0vPm+wiMaav/dQxpJaIud+ECcPEiMDgIDAxknRrqZkFyPvPwmJNHVRdVdRhGwJkCMKqqd6jqixHTSEQ9ZHwcWFkBvvGNrFNC3SyOOp8WqnpVVV9W1ctx75uIesP4OHDmTNapoG4We/AhIiLqhMGHiIhSx+BDRESpCzq2W1FEwvbXUVX9UshtiYiojwQNPiPmKwwFwOBDRESBg88yjJlLiYiIQgsafOqq+nIiKSEiol2DDQ6IKBUcbJTs4prJlIjIlUjr5/FxYxge2r2Y8yGixDgNNAow90MMPkSUoAsXAFUONko7BQk+ozAGFyUiCoSDjVI738HHHDD0apKJ6TacTI4oPhxslOxY7OaBk8kRESWDwYeIiFLH4ENERKlj8CEiotQx+BARUeoYfIiIKHUMPkRElDoGHyIiSh2DDxERpY7Bh4iIUsfgQ0REqWPwISKi1DH4EBFR6hh8iIgodQw+RESUOgYfIiJKHYOPB04mR0SUDAYfD5xMjihdly4BZ88a79Tf7sw6AURETzwBvPrqzuUnTwIXLqSfHkoecz5ElDmnwOO1nHofgw8RdY3BQWBgwHin/sZiNyLqGisrwGuvAY8/Dhw/nnVqKEkMPkSUiUuXgO9+90F8+cvby8bHjRf1PwYfIsqEkbM5iL/6q6xTQllgnQ8RperkyWDLqT8x+BBRqi5cAC5etBoXKAYHjc9sUr27MPgQUerGx43GBf/23/4CKyvB63mcOqOyg2pv6Zk6HxHJAcgDOANgQ1VnAmxbADAHYAzABoAFVZ1PJKFE5Mv4ODA4+B6OHfM3gohbR1S3fV+8GCFxlLieyPmIyCSATQBlAJMBt50GUAVQBzAFoASgEXcaiShZQTqcMvfT/Xoi56OqSyIypKoNEdn0u52ZW1oAMKOqi8mlkIjScvEicOIEcOsWsGePUXwHbC/b2so2feRPTwQfAFDVMLmVOQB1Bh6i/mHVF1mdUa36ImvZc89lmLged+nSzvOalJ4JPiGdAnDeLLabgVHnU1HVqWyTRURROHVGtZYx+ATnVJ+WdL1Z3wYfs8gtB6AIYBhGLqgAYE5EllV1Isv0EVFvSzOXkDSn+rSk6836NvjAaBkHAA1bTqciIg0ACyKSV9V6+0YiMgvgefuy/fv3Y21tLbGErq+vu+z/GAAkemzyOv+UNO9z3379+/09JPu7+aM/OoIf//j+Hct/+7c/wH/+z1cTOWZSts+/cc7uuutj3L4t2NoSAMnee0RVE9t5EswGB+c7NbUWkTyAKwBK9mbVZo5oEwEaIYyNjenq6mqEVHtbW1vDsWPHdiwX4++PHvsT9Ry380/J8zr31vV/8WJrXU6n30PSvxtr/0567bdqnf+w57oTEamq6pjTd32b81HVuhhntNG2vGEuz2WRLiIKJuzo1k7FYnEWlQ0Obre4+/DDaPvqFmnWm/Vt8DE1AIzaF5g5IsDo90NEXerkyZ11EY8+6n97P0Erykypfqd/6Ke6oTj1e/BZBDANo6WbxeqkWkk/OUTk14ULxo3b3qfn29/uvJ1T0HITZaZUr+kf3EZj4MgL23pihAPAyLHYci3DbZ+t7xfMoXQsZ83vlkVkUkROw2j1NhOy3xARpcjq0/ONb8D3GHCtA5eiOXBp+7IkuQU1jrywrSdyPmZAqdoWTWI7B2NV/+Vg5HKWAdSAZv3OKIxRDsowh9hR1aU00k1E0YWZYK5TR9S0Zkq1j8bAkRda9UTwUdUatoNMoHXM5tQ91afHKiMmovC8OqImpf23aw+C/dL5Na46rJ4IPrtFkFF7iaj7OOWm+mXkBbf708mTwH/4D8EDEoNPF3H6wwZp3UNE2YjaMq8XuD0Yv/rqzu/8tCLsmQYHu4m9UtRP6x4iypZTI4csf7tJTqxn/z+65XL8lOAw59OFnCpKiSg9Yeo13Bo5pCWt5t3t/8f25vB+O9wy+HShpCtFiWinOG7efn+7SXQ8Tat5d/v/sT3o+m1FyOBDRITON++4WqG2jw0Xd84ki+bdYR6YWedDRGRjr7uxiBhP9FFarJ086bw8iZyJ1TE3S8b/65895PY9gw8RkY395u32NB+mJduFC8Yo0U7BLW7j48CZM8nt3w+j+O2hf+b2PYMPEVEb6+Z98eLOgBG1JVu35EycXLt2Da+//jqAa6H34ZbDa8c6Hw/WxHIHDhzIOilElKG4W7LF2fE0vhFRruGZZ57B1tYWgIdhzKl5KPBe7APCfvih+4xADD4eVHUWwOzY2FiPTRFFRHHrplaoyYyG8ja2trbw0EMPAbgN4G2ECT7AdrA+fvzd627rMPgQEXUhr8nw3AJPtFEVDuPhhx/G7du3YYSGw1F2Zqb5/3vH7XsGHyLa1bptIN8guRp7s2qv+Y7cAtl3v/sgvvxla61DeP755/H222/jO985jLC5Hr8YfIjI1bVr1/D222/j8OHDOHQo2ZtRVtKYWiEIv4Hn0Uf910W5/x8P4q/+avvToUOHdvydkwrODD5EXSjLm/6bb76J9fV1vPfee/jOd76Dra0tDAwM4E/+5E8wMdFTs5N46qbBQO05E8vg4HaOZmXFWOaUy/Gqiwoyq+vnPrcOYF/LsvYOsXFi8CHqIm+++SbeeuutTG/66+vrAIB33nmnWQH9zjvv4K233uqr4BN2mm5LnA8ITjmTTpPh+Z3Vtf3/2BrIFHv2CF58sYZ//s9vAHgcgBGI/sf/2Ldjf3EGZwYf6jn9XBS0vr7eNTf9p556Cj/96U9x+/ZtDAwMmK2guleY6yJME2qnB4SvfOUrOHr0KD7zmc8ESrNbzuTkyfgmw/Oa1fW73/0Fvvzlg/j1r2+0bPPCC28CAO666/EdwTmu3x+DD/WE3VIUBAAPPfRQs9VRljf9Q4e2K6B/8Ytf4MEHH8wkHV7iuC6C3tCdHhDeeecd1/PjdbN2y5nE3aTbLZANDr6HY8cOutbp2APXoUNXcO1aFX/2Z9GDLsDgQz1itxQFAcCDDz7YNTd9qwL6tW5qDmaT1XVhf0B4+OGHdzwgBAmKWU/F0IkVuF577Rp++lPnoBsmN8TgQ7FzuhDjyqp3S1FQ0kV/3X7T7zZpXxf2B4TDhw/jypUrLd8HDYrd1IHVi1PQfe+99/Diiy8Gzg0x+PjwD//wa7zyyrt48slPZp2UruX2pPeVr3wFAGIrKnMqCkqzDijO8v7dJsm/k98iwjjTYG+WbAUfa//vvfceHnzwwa55WIpLe9BtNBr4u7/7O99FkHYMPj68//5deOqpIQDv4nd+ZxD//t9/iP/2327i3/ybezwD0iuvvOtrvX7g9qT3zjtGB+c4i0TsuQK3p65cLpfIjS5oeX+/CZqrTaqurv0mD+zMLdrT1Wg0En9ocLoWH3/88UyKUJMO9NY+Dx06hFwu1wywTkWQbhh8fBsAcBOvvw68/voQgAewuLiFo0ev4mc/O9Jc6/Ofv4HXX98L4F0A7uv1K/uT3sMPP4ynnnoKABJ5+tu3bx9++tOfOga7JG8yncr7+9V7772HP/7jP8bHH3+MRx55xDFX236u46yT6ZS7bk9reyBI8qHB6Vq8efMmgPSKULNqlGPPdToVQbph8PFpYGALjz4KvPXWTQAPwAhGwFtvta5nBB4A8F6vF/l5mmq/EK31knj6+8xnPrPjqevo0aN46623It1kOv0/3cr7+7kJuHVzPXDggGeu1u1cx1H85BbIrJt8e1rb03X06NFQT+h+OF2LJ06ciG3/fmTZKMepCLITBh8fHnjg13jppU08+eQRvPLKu5ic3MLHHwOqWwDucdzmb//2Hl/r9YKg9RxOQ3Qk9fTnFOw+/elPB77JBH1qbP+xtT9pez1t9mKQcrq5tudqvc51nHUy7bnr9pu8W1qtayPoE7pfbg9eYf+fYfVKPRODjw+/9Vt3Netsnnzyk1haMupyFhfvAeBcl+N3Pb+yvGFZ9Rw///nPcf/99+Pee+9NrZ7DqWy/XXuwC1MMEOWp0elJu327fuin1ClX65QL9KqTsQvygOPnJu+2Tpgn9CCcHrzanT9/PtFroFv6Z127dg0A7nX7nsHHg9tkck8++Uk8+SSwuOi9vd/13HS6YfkJSH6DVqf1HnroIXzuc5/D7du3ceeddyb+NOV2M/Ir7E0mzFNj+5O203b90k/JK1cLOOcC/fzdgjbk8HOT97OOmyQe9vbt25faCBZZN9W3rgEYdQ+OGHw8ZD2ZnNcNa3Nz0/PpyWuMMOuH9dFHH+ETn/iEY3CzF08Anfs1xMH+g3f6kbaX7Sch7FOj23bd0PQ2zVyzV8V7J1k35Eg6d2rl4EZGRnqiWCws+zUA4Jbbegw+PcB+w7rnnnuaP2qvpye3J6z2oOXUCujixYv4y7/8y5Z1HnzwwcSKLNxyOe03o6gVuH5vwl5Ndr20b9devJJ209ss+iRFqXhP4wHHS6fcqZ8iYD+6pVgsKfZrAMAet/UYfHqAU/n1tWvXOj492W/ebkHr5s2bO4IbsLMF09GjRx3TFscP0q3I5Xd/93cxPj4ey1N7kAYBXttZgdiLW/GKW9Nbv8EtaA4mqz5JQSrenbZNsk7GD6fcqdODRBRxFovFFRTjZF0D3/rWt953W4fBJ2OvvPIu/ut/vY3f//134dUowatS3e3pqf1Jsj1oWU+l7TcLwLig21sKtQtTtu+mPZdjP2bUoiI/DQL8bucViC1OxStuOQC/wS1sJXWQoqw4b2JR6luyZv89WEXTYYsSkxKkz1NWzL//r9y+Z/BJkX3Eg//0nwbx+usfwuqI+r3vbcHomOq/VZyfp6dOLcGcWgEB6PjkGqVsH9j5tO8UKOPip0GAn+28ArGTTjkAP8EtaiV1p6KsXriJZfFk3/578PMgkSa/fZ4s3di8n8EnNe+aQ/QYIx4Am2jviArcdJxNMG5xtBSKUrbv9rSf5NNyHA0Jwvxwvf5PfoJbHJXUXkVZQW9iaYszdx1F1OsgDK+hjJwasATJXVtDUNVqNezb532/SSr4M/jExMrVGJ1JW3Mvv/M7N/D66zsDzdGjwP/6X1vY2lIMDHyM2dk6fvu3B3Dt2kjXleE6CfODDFuUFVd6w5SzpxUU/Y4c4dSaLs7RwrvhyR6InruOW1pFiV7dDLwasATJXVv72tzcxMsvv+y7uDfO4M/gEwOR7XHcgJ3FZz/60V688sqHzREP7rhjC0tLxmCjRp3PNfz+7x9CLjfQNU96fgX9QUYtyupHfs9hp9Z0Tk3k3bQ/zWbxZN9JNwxZkwW3hiIAPBuwOOk0BNUDDzyAW7du+S7ujTP4M/hEYORo9qK9+Oyhhz5Ae+7HPuKBfZTrJ5/8JA4f/gWOHfsk3nzzva560ktKN97oeonbjcGtiXw7twectBsJXLt2rWOxz265VtrrQJ0a4AAIFYidzqE1BNW7777ru7g37uDP4BPBj35kDCL6yiv3tORqvvnN+x3Xt0Y8cBP1Sc9vk91u0MutobLmdGPw20S+W4qyrADYqdgH6P9rxa0OtNNQRmGbsFufn3/+eSwvL2NiYsJXcW/cwZ/BJwZuuZowwv6xw/RHod4Wpol8NxRl2QOgW7FPmrLsJ+NVB+oUdOMMxIcOHUKhUIjc+CgsBp+YdMrVBBH0j51lJX6vs4p+7r333p4M1kGbyFvbZFmUZQ+AbsU+acm6jnU314Ey+PSB3XwBR2FV2G9ubmJoaKjrG3f4EbTxQlb8FvskqVuKILN+GMgKg0+f2K0XcBjtFfZW0U8/Nu7oZn6LfZLSDUWQlqwfBrLA4NNHduMFHEZ7hb1V9LMbmvFSKz60ZYfBh3atbij6oezxoS0bd2SdgG4mIrMiotevX886KZSQrIt+iHYrBh8PqjqrqnLw4MGsk0JE1FcYfIiIKHUMPkRElDoGHyIiSh2DDxERpY7Bh4iIUsfgQ0REqWPwISKi1DH4EBFR6hh8iIgodQw+RESUOgYfIiJKnahq1mnoeiLySwD/kOAhDgJIcvRS7p/779b993Lauf/Ojqrq/+H0BYNPFxARVVXh/rn/3bb/Xk479x9t/yx2IyKi1DH47A7/D/efqV4/P718/nv93PTyuQc80s9ity6QdNaXvPH8Z4fnPltZnn/mfLpDrz/d9Dqe/+zw3Gcrs/PPnA8REaWOOR8iIkodgw8REaWOwSdBIlIQkaqIqPk+meR21CrC+Z8WkSs8/+FFvYZFJGduy3qBEKKcf3PbZRHZNH8Hp5NII4NPQkQkD6AKYAPABIBzAMqdLoKw21GrCOf/NIA58zVlbl9O6gfYj2K6hucA1BNIXt+Lcv5FZNrctg7j+i8BaCSSUFXlK4EXgAUAVxyWbSaxHV+xnf9NAPm2ZcsAFEAu6/9XL7yiXsMA8ub5XjBuUdn/n3rpFeHaz5nnfTqNdDLnk5xTMP7gdgsAciJSSGA7ahX2PJ5X1fYn7jnzfSyuxPW5qNfwHIAlJPXE3f/Cnv85AHVVXUwsZTYMPgkQkRyMp4iWm5iq1sx/Ot7Ewm5HraKcR1Wd8dj1RvTU9beo17B5c5wEcDaRBPa5iOf/FICKiEza6nzKCSWVwSchw+a725NbLubtqFXc53ECaPkBk7uo534OQIXnOrRQ598WtIoAnobxdzgLYFJEluNOJADcmcROqeMPbF/M21Gr2M6jWXl7GoBXjoi2hT73IlKEcfMbjTVFu0vY85833xuqOmX+uyIiDQALIpJ3KI6OhDmfZLldCOsJbUetIp1H82lwGcB8WuXgfSTMuWeuJz5Bz7+VUzrXtvy8+V6MnKI2zPkkw/pDDtsXmjcz+/dxbUetIp9Hc90qgCVVLcWbvL4W6tybzYALAGZsleJ587sCjCdyNr3uLNT5V9W6iOz4XlUb5vLYi/wZfBJg/iEbAEbavrIq+1bj3I5aRT2P5g91BcCCqs4nkMS+FeHcW8U+7a20AOMhoAYWx3UU8dpvoO0cm8XOQAJ9rljslpzzAKbbls3AeILzKlYIux21CnUebYHnHANPaIHPvarOq6rYXwAWze9EVRl4/At7D1mE0eLNzuqYWokpbduy7hDVry9sd5QrwygvPY22DlzmOgsACkG24yvR81+FUc9TNH949hc7mSZ47h32w06mKZ5/GEVrm+b1P5n0vSfzE9XPLxhl2MvmH7Ta/kc0v1cAk0G24yuZ84/tHt5ur8m0/w+9+gp77betw+CT8vk3g5I1oseVJK95zudDRESpY50PERGljsGHiIhSx+BDRESpY/AhIqLUMfgQEVHqGHyIiCh1DD5ERJQ6Bh8iIkodgw8REaWOwYeIiAAAIlIVEbVeAbabs29nTgzoiVMqEBFRu6BzWJ2DMVHdBHxOPMfgQ0RELTTgdCJqTNVQMyee8xV8WOxGRESpY/Ahor4gIstB6ini2pbCYfAhIqLUMfgQEVHqGHyIqKeJyIJZZFY0P9ub/OaS2nY3EZGcea42zXOzKSJlP02q3bC1GxH1ugUYU0WXYEwDPWN9oaqNBLfdTVZgTL29CGN67c/CCNh1AJUwO2TwIaKeZmvmO2N+XkxiWxGZBDCnqiMRk9xTRCQPI/DMq2qp7bvQuUMWuxER+TMBoJZ1IjKUb18QJXfI4ENE5M8YgOWsE5E2Va3DCLqTInLFrPuZjLpfBh8i6mvt45XZXoWAuyoAWE0ijT3gBIy6nTyAaQBlMxCx2I2IyEUJRkOC9lfd7w5sgSpvC2aOuSARKZidVjfNG3TR9l2xvTOrub/Ttm2vmOtVrVZlDvsvm99tishC2/6XrfTF1WJPVRuqOgFgCMa5swJR2XNDDww+RNTXVLWiqosOryD1FWPm+zCMXMAEgKKITNtXMoujyjAaJgwBmANgDwIF7Kw3si8rwripT5jHKcEo7sqb+y/CaHl2DsARc52G7dgL5jZD5v7OBPg/dmQGoUUzENXgcxw3Jww+RNQv6kCzdVbc244CWLKClqpWYDz9j1ormAHmJQAT5vdW67k6gFPmap+FrejOdrxV2/d1VS2ZwdFqxrxhvpcBTKnqkpmOmqqWbMeeMpc1YAS+MOeihdnHJ3IdTzsGHyLqF2+Y72Vbh0i/T+adti3a1rGz557OAFg1K+jd1inA6Fdk/9yw5cIKMHIvO743i+bqVmBrMw0gB2DFKo6DEag2HNYNagzbdTwL5tw9VTNtgUa/tmM/HyLqF4sAnoZxU8yZn/02EOi0bR47O1OOYWegcGqKXQCwauZO8m37/Sy8j2P/vn1dtK1XCjoVgh+qWhGRKRh1PadgnJ961OMx+BBRXzBzD6MdVwy4rdXYwOyQai2bNJctta3eUsEvInMAaqpas3JS9v0AsOppHI+DnQFt2OO/sc/ju0jM/2f7/zUSFrsREXmzxn2bNus/pmHWvbStVwZwymyNljOLyaZt6zXrX8zvrToZK7iMYWcLvDFsF/edg9H4oGhuX7S1hDsHYNoKYGYaFtDFmPMhIvK2D0Yx3ASMSvw6bI0KLKq6KCIjMFqjAcB5AEds9TkVAA2zPqYCI2DUsV2U1jKCgllMl7OWqeqSiJSw3bx5FWauyfwuD6POxzpWVwcfUeX8SUREZPQ5AlBQVQm5/WkYAXpHcG7HnA8REbWwOr36bVBgFvcVYeTefGHwISKidnPmu9/WbE8DOB3kACx2fbGnPQAAADpJREFUIyKi1LG1GxERpY7Bh4iIUsfgQ0REqWPwISKi1DH4EBFR6hh8iIgodQw+RESUOgYfIiJK3f8PJNw92pd6DvUAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "sn_dt = 0.01 #Units seconds: 10ms binning for plotting\n", "time_binned, bg_binned, signal_binned = bin_hits(i3, time, total_E_per_V.value, dt, sn_dt)\n", "\n", "# Scaled to improve readability of axis labels\n", "background = bg_binned/1e4\n", "signal = signal_binned/1e4\n", "response = background+signal\n", "\n", "fig, ax = plt.subplots(1, figsize = (6,7))\n", "ax.step(time_binned, background , lw=2, label='Background', color='k', alpha=0.25)[0] \n", "h = ax.step(time_binned, response, lw=2, label='Response', color='b')[0] \n", "# Error bars are computed on unscaled quantity and then scaled.\n", "ax.errorbar(time_binned - 0.5*sn_dt, background, yerr=np.sqrt(background)/1e4, color='k', alpha=0.5, fmt='.')\n", "ax.errorbar(time_binned - 0.5*sn_dt, response, yerr=np.sqrt(response)/1e4, color=h.get_color(), fmt='.')\n", "\n", "ylimits = ax.get_ylim()\n", "ax.set(xlim=(-0.05, 0.65), ylim=(ylimits[0], ylimits[1]+0.15))\n", "ax.set_xlabel(r't-t$_{bounce}$ [s]', horizontalalignment='right', x=1.0)\n", "ax.set_ylabel(r'Total Hits [10 ms Bins, $\\times 10^4$]', horizontalalignment='right', y=1.0)\n", "l = ax.legend(loc='upper center', ncol=2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": false }, "outputs": [], "source": [] }, { "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.3" } }, "nbformat": 4, "nbformat_minor": 2 }