ball-and-stick-2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This page is the second in a series where we build a multicompartment cell and evolve it into a network of cells running on a parallel machine. In this page, we build a ring network of ball-and-stick cells created in the previous page. In this case, we make N cells where cell n makes an excitatory synapse onto cell n + 1 and the last, Nth cell in the network projects to the first cell. We will drive the first cell and visualize the spikes of the network.\n",
    "\n",
    "In practice, you will likely want to separate the specification of the cell type and the use of that cell type into separate files, but we'll ignore that here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Generic cell class</h1>\n",
    "<p>We'll begin by splitting the BallAndStick class into two parts: a generic Cell class and that which is specific to the BallAndStick model. This will allow us to focus our attention on the parts that we're working on and to make code that we can reuse later.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we load the NEURON library, of course; we'll load NEURON's built-in graphics library as well to allow visual inspection of the sizes of the diameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from neuron import h, gui\n",
    "from neuron.units import ms, mV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also want to use NEURON's standard run library, so let's go ahead and load that too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.load_file('stdrun.hoc')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The generic Cell class (we'll expand this later):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cell:\n",
    "    def __init__(self, gid):\n",
    "        self._gid = gid\n",
    "        self._setup_morphology()\n",
    "        self.all = self.soma.wholetree()\n",
    "        self._setup_biophysics()\n",
    "    def __repr__(self):\n",
    "        return '{}[{}]'.format(self.name, self._gid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the BallAndStick class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BallAndStick(Cell):\n",
    "    name = 'BallAndStick'\n",
    "    def _setup_morphology(self):\n",
    "        self.soma = h.Section(name='soma', cell=self)\n",
    "        self.dend = h.Section(name='dend', cell=self)\n",
    "        self.dend.connect(self.soma)\n",
    "        self.soma.L = self.soma.diam = 12.6157\n",
    "        self.dend.L = 200\n",
    "        self.dend.diam = 1\n",
    "    def _setup_biophysics(self):\n",
    "        for sec in self.all:\n",
    "            sec.Ra = 100    # Axial resistance in Ohm * cm\n",
    "            sec.cm = 1      # Membrane capacitance in micro Farads / cm^2\n",
    "        self.soma.insert('hh')                                          \n",
    "        for seg in self.soma:\n",
    "            seg.hh.gnabar = 0.12  # Sodium conductance in S/cm2\n",
    "            seg.hh.gkbar = 0.036  # Potassium conductance in S/cm2\n",
    "            seg.hh.gl = 0.0003    # Leak conductance in S/cm2\n",
    "            seg.hh.el = -54.3     # Reversal potential in mV\n",
    "        # Insert passive current in the dendrite\n",
    "        self.dend.insert('pas')                 \n",
    "        for seg in self.dend:\n",
    "            seg.pas.g = 0.001  # Passive conductance in S/cm2\n",
    "            seg.pas.e = -65    # Leak reversal potential mV\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The only changes to the BallAndStick definition are the removal of the `__init__` and `__repr__` methods, the specification of the <tt>name</tt> of the class, the removal of the definition of <tt>self.all</tt> (now handled by the <tt>Cell</tt> class), and the change to the class declaration (the very first line) to indicate that <tt>BallAndStick</tt> is a type of <tt>Cell</tt>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Adjusting position and orientation</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we have more than one cell, we'd like to be able to position them so that we can see them clearly. We'll introduce new methods `_set_position` and `_rotate_z` to the Cell class to allow us to do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cell:\n",
    "    def __init__(self, gid, x, y, z, theta):\n",
    "        self._gid = gid\n",
    "        self._setup_morphology()\n",
    "        self.all = self.soma.wholetree()\n",
    "        self._setup_biophysics()\n",
    "        self.x = self.y = self.z = 0                     # <-- NEW\n",
    "        h.define_shape()\n",
    "        self._rotate_z(theta)                            # <-- NEW        \n",
    "        self._set_position(x, y, z)                      # <-- NEW\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return '{}[{}]'.format(self.name, self._gid)\n",
    "    \n",
    "    # everything below here is NEW\n",
    "    \n",
    "    def _set_position(self, x, y, z):\n",
    "        for sec in self.all:\n",
    "            for i in range(sec.n3d()):\n",
    "                sec.pt3dchange(i,\n",
    "                               x - self.x + sec.x3d(i),\n",
    "                               y - self.y + sec.y3d(i),\n",
    "                               z - self.z + sec.z3d(i),\n",
    "                              sec.diam3d(i))\n",
    "        self.x, self.y, self.z = x, y, z\n",
    "    def _rotate_z(self, theta):\n",
    "        \"\"\"Rotate the cell about the Z axis.\"\"\"\n",
    "        for sec in self.all:\n",
    "            for i in range(sec.n3d()):\n",
    "                x = sec.x3d(i)\n",
    "                y = sec.y3d(i)\n",
    "                c = h.cos(theta)\n",
    "                s = h.sin(theta)\n",
    "                xprime = x * c - y * s\n",
    "                yprime = x * s + y * c\n",
    "                sec.pt3dchange(i, xprime, yprime, sec.z3d(i), sec.diam3d(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are writing a script to do this, and revising the classes as we make changes, everything should be good. If you are following along in a Jupyter notebook, you will need to rerun the definition of BallAndStick above for the changes to take effect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a test cell. Note that we now have to specify `x`, `y`, `z`, and `theta` in addition to the `gid`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mycell = BallAndStick(0, 0, 0, 0, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you got a `TypeError`, that means you did not rerun the definition of BallAndStick. Go back and do that and then the above should work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We no longer need the test cell, so let's delete it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del mycell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Construct and position our cells</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to construct an arbitrary number of cells and position them in a circle. For the sake of reusability, we'll make a function that takes two parameters: `N`, the number of cells, and `r` the radius of the circle (in microns). This function will return a list of `N` cells centered around the origin on the XY plane:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_n_BallAndStick(n, r):\n",
    "    \"\"\"n = number of cells; r = radius of circle\"\"\"\n",
    "    cells = []\n",
    "    for i in range(n):\n",
    "        theta = i * 2 * h.PI / n\n",
    "        cells.append(BallAndStick(i, h.cos(theta) * r, h.sin(theta) * r, 0, theta))\n",
    "    return cells    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create 7 cells with r = 50 microns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_cells = create_n_BallAndStick(7, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot them using NEURON's built-in graphics:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ps = h.PlotShape(True)\n",
    "ps.show(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using functions like this is extremely flexible. We can switch to 5 cells like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_cells = create_n_BallAndStick(5, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The old cells disappear (they get garbage collected, as there are no longer any references to them), and the new cells appear in the existing graph."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>A first synapse, and input via a NetStim</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, we have our ball-and-stick cells arranged in a ring. Let’s now stimulate a cell and see that it responds appropriately. Instead of stimulating with a current electrode as we did before, let’s assign a virtual synapse so that we get acquainted with driving the cells through synaptic events.\n",
    "\n",
    "Event-based communication between objects in NEURON takes place via network connection objects called <a href=\"https://neuron.yale.edu/neuron/static/py_doc/modelspec/programmatic/network/netcon.html#NetCon\">NetCon</a>s. Each NetCon has a source and target, where the source is typically a spike threshold detector. When a spike is detected, the NetCon sends a message to a target, usually a synapse on a postsynaptic cell.\n",
    "\n",
    "A <a href=\"https://neuron.yale.edu/neuron/static/py_doc/modelspec/programmatic/mechanisms/mech.html#NetStim\">NetStim</a> is a spike generator that can be used as the source in a NetCon, behaving as external input onto the synapse of a target cell. The following code makes a NetStim object that generates one spike at time t=9. The NetCon then adds another ms delay to deliver a synaptic event at time t=10 onto the first cell.\n",
    "\n",
    "The code below makes a stimulator and attaches it to a synapse object (<a href=\"https://neuron.yale.edu/neuron/static/py_doc/modelspec/programmatic/mechanisms/mech.html#ExpSyn\">ExpSyn</a>) that behaves much like an AMPA synapse – it conducts current as a decaying exponential function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "stim = h.NetStim() # Make a new stimulator\n",
    "\n",
    "# Attach it to a synapse in the middle of the dendrite\n",
    "# of the first cell in the network. (Named 'syn_' to avoid\n",
    "# being overwritten with the 'syn' var assigned later.)\n",
    "syn_ = h.ExpSyn(my_cells[0].dend(0.5))\n",
    "\n",
    "stim.number = 1\n",
    "stim.start = 9\n",
    "ncstim = h.NetCon(stim, syn_)\n",
    "ncstim.delay = 1 * ms\n",
    "ncstim.weight[0] = 0.04 # NetCon weight is a vector."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exponentially decaying currents, such as that generated by the synapse `syn_` have dynamics that depend on `tau`, the time constant. Let's specify a time constant of 2 ms:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "syn_.tau = 2 * ms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The parameter `tau` specifies how quickly the currents decay. The exact value of the current depends on the cell's membrane potential, and the synapse's reversal potential, `syn_.e`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reversal potential = 0.0 mV\n"
     ]
    }
   ],
   "source": [
    "print('Reversal potential = {} mV'.format(syn_.e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Running and plotting a simulation</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Right now, there are no synapses between cells, but let's confirm that the first cell works correctly:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Recording</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "recording_cell = my_cells[0]\n",
    "soma_v = h.Vector().record(recording_cell.soma(0.5)._ref_v)\n",
    "dend_v = h.Vector().record(recording_cell.dend(0.5)._ref_v)\n",
    "t = h.Vector().record(h._ref_t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Simulating</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.finitialize(-65 * mV)\n",
    "h.continuerun(25 * ms)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Plotting</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before, if you're running in a Jupyter notebook, you'll need to tell it to display plots inline. Skip this step if you are running from a script:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(t, soma_v, label='soma(0.5)')\n",
    "plt.plot(t, dend_v, label='dend(0.5)')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Recording synaptic conductance</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To understand the above graph, we may wish to consider the time series of synaptic current. Let's create a new Vector to monitor that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "syn_i = h.Vector().record(syn_._ref_i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Only data that is explicitly recorded during a simulation is stored, so we will have to rerun the simulation to compute those currents:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.finitialize(-65 * mV)\n",
    "h.continuerun(25 * ms)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfYAAAEGCAYAAACXebelAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deZyN5f/H8dc1YzZ71qyNQpLdWL6/FqSiCBVJUkglabVVX0q7fFPfNoo2Sl+0Skmp+EYSw5eIjCXLMDJkZ4yZuX5/XHPGDDNjljNzzpx5Px+P+3Gf677vc5/P3HP4zHXd131dxlqLiIiIBIYgXwcgIiIi3qPELiIiEkCU2EVERAKIEruIiEgAUWIXEREJICV8HYA3VKpUyUZGRvo6DBERkUKzYsWKvdbayqdvD4jEHhkZSXR0tK/DEBERKTTGmG2ZbVdTvIiISABRYhcREQkgSuwiAW7y5MnUq1ePoUOHcvToUV+HIyIFLCDusYtI5v744w8GDx5M3bp1mThxIhs3buSrr74iJCTE16FJEXHy5EliY2NJSEjwdSjFVnh4ODVr1szxv1sldpEA9v777xMcHMzixYuZM2cOgwYNYvz48fzzn//0dWhSRMTGxlKmTBkiIyMxxvg6nGLHWsu+ffuIjY2lTp06OXqPmuJFAtj8+fO55JJLqFKlCnfccQc33XQTTz31FOvXr/d1aFJEJCQkULFiRSV1HzHGULFixVy1mCixiwSoEydOsHr1ai655JK0ba+99hqlSpVi+PDhPoxMiholdd/K7fVXYhcJUOvWrSM5OZmmTZumbatSpQqjRo1i7ty5LF682IfRiUhBUWIXCVAxMTEAXHTRRRm233fffZx77rk89thjWGt9EZqIFCAldpEAtX37dgDOO++8DNtLlizJ6NGjWbRoEf/97399EZqI3zp+/Djt2rUjOTkZgKlTp1KvXj3q1avH1KlTM33P2LFjqVGjBs2aNaNZs2bMnTsXgDVr1tC/f//CCj2NErtIgNqxYwdly5albNmyZ+wbOHAglSpVYsKECT6ITMR/vfvuu9xwww0EBwfz999/8+STT/Lrr7+ybNkynnzySfbv35/p+x566CFWrVrFqlWruPbaawFo3LgxsbGxaX9kFxY97iYSoLZv307t2rUz3RcREcHQoUMZO3Ys69evP6O5XiQzDz74IKtWrfLqOZs1a8a///3vbI85evQoN910E7GxsSQnJzNmzBgqVarE8OHDSUpKolWrVkyaNImwsDAiIyPp06cP33zzDSVKlGDy5Mk8+uijbNq0iREjRjB48GCOHDlC9+7d2b9/PydPnuSZZ56he/fuAEyfPp2PPvoIgG+//ZarrrqKChUqAHDVVVcxb948+vTpk+Of77rrrmPGjBmMHDkyj1co91RjFwlQO3bsoFatWlnuHzJkCOHh4bz00kuFGJVI7s2bN4/q1auzevVq1q5dS+fOnenfvz8zZ85kzZo1JCUlMWnSpLTja9euzapVq7jsssvo378/n3zyCUuXLuWJJ54A3IAvn3/+OStXrmTBggUMGzYMay2JiYls2bIFz2yhO3fuzPBvqGbNmuzcuTPTGF9//XWaNGnCwIEDM9Tqo6KiWLRoUQFclaypxi4SoHbs2EFUVFSW+ytXrsztt9/O+++/z7PPPkuVKlUKMTopis5Wsy4ojRs3ZtiwYYwaNYquXbtStmxZ6tSpQ/369QG4/fbbeeONN3jwwQcB6NatW9r7jhw5QpkyZShTpgxhYWEcOHCAUqVK8dhjj/HTTz8RFBTEzp07+euvv0hJSaF8+fK5ju+ee+5hzJgxGGMYM2YMw4YN49133wXckyi7du3y0pXIGdXYRQLQ8ePHiY+Pz7Ip3uOBBx7gxIkTaf8Jifij+vXrs3LlSho3bszo0aP54osvsj0+LCwMgKCgoLTXnnJSUhLTp08nPj6eFStWsGrVKqpWrUpCQgIREREZBoKpUaMGO3bsSCvHxsZSo0aNMz6vatWqBAcHExQUxJ133smyZcvS9nnOW5iU2EUCUFxcHECm/wmld9FFF9G+fXveeuuttF7AIv5m165dlCxZkltvvZURI0bwyy+/sHXrVjZt2gTABx98QLt27XJ8voMHD1KlShVCQkJYsGAB27a5ac3POecckpOT05J7p06d+O6779i/fz/79+/nu+++o1OnTmecz/PvDeDzzz+nUaNGaeWYmJgM5cKgpniRALR3717ANbefzT333EPv3r359ttv03rziviTNWvWMGLECIKCgggJCWHSpEkcPHiQXr16pXWeGzx4cI7P17dvX6677joaN25MVFQUDRo0SNt39dVXs3jxYq688koqVKjAmDFjaNWqFQCPP/54Wke6QYMGMXjwYKKiohg5ciSrVq3CGENkZCRvvfVW2vkWLFhAly5dvHQlcsYEwgAVUVFRNjo62tdhiPiNuXPn0qVLF5YuXUqbNm2yPTYxMZHatWvTqlUr5syZU0gRSlFR3J6aWLlyJS+//DIffPBBvs914sQJ2rVrx+LFiylRIn/16Mx+D8aYFdbaMzrSqCleJAB5auyVKlU667GhoaEMGjSIr7/+Oq1JUqS4atGiBR06dPDKrant27czbty4fCf13FJiFwlA+/btA6BixYo5Ov6uu+7CGMPkyZMLMiyRImHgwIEEBwfn+zz16tWjffv2+Q8ol5TYRQLQ3r17CQ4Oply5cjk6vnbt2nTp0oW3336bxMTEAo5ORAqSErtIANq7dy+VKlXK1XSP99xzD3v27Dnro0Qi4t+U2EUCkCex58bVV19NZGQkb775ZgFFJSKFQYldJADlJbEHBwdz5513smDBAjZs2FBAkYlIQVNiFwlAeUns4DoNeSbOEPFXY8eO5cUXX8z3eTzjyHv07NmTLVu2ALBixQoaN25M3bp1uf/++8ns0fCFCxdSrly5tOlan3rqKcA9Qnr55ZeTlJSU7xjzQoldJADlNbGfe+65XH/99bz//vscP368ACIT8U+///47ycnJnH/++YDrczJlyhQ2btzIxo0bmTdvXqbvu+yyy9Kma3388ccB9whpx44dmTlzZqHFn55GnhMJMCkpKezbty9PiR3g7rvv5uOPP+aTTz6hX79+Xo5OirQHHwQvT9tKs2aQg8llnn32WaZOnUqVKlWoVasWLVu2ZPPmzdx7773Ex8dTsmRJpkyZQoMGDejfvz9ly5YlOjqa3bt3M378eHr27Im1lvvuu4/58+dTq1YtQkND084/ffr0tKlb4+LiOHToEG3btgXgtttu44svvuCaa67J8Y/Vo0cPHn30Ufr27ZvLC5J/qrGLBJiDBw+SnJyc58TeoUMH6tWrl2FYTBFfWrFiBTNmzGDVqlXMnTuX5cuXA278hddee40VK1bw4osvMmTIkLT3xMXFsXjxYr766iseeeQRwI3jvmHDBtatW8e0adNYsmRJ2vE///wzLVu2BNx0rTVr1kzbl910rb/88gtNmzblmmuu4ffff0/b3qhRo7Q4C5tq7CIBJjejzmUmKCiIu+++m+HDh7NmzRoaN27szfCkKPPRtK2LFi3i+uuvp2TJkoCbljUhIYElS5bQq1evtONOnDiR9rpHjx4EBQXRsGFD/vrrLwB++ukn+vTpQ3BwMNWrV+eKK65IOz4uLi5Hcyuk16JFC7Zt20bp0qWZO3cuPXr0YOPGjYDrjBoaGsrhw4cpU6ZMnn/2vFCNXSTA5Dexg5vfOiwsTLV28VueudM997dXrVrF+vXr0/ann641J3OipJ+ytUaNGsTGxqbty2q61rJly1K6dGkArr32Wk6ePJn27w/cHxrh4eG5/+HySYldJMB4I7FXqlSJnj178sEHH3D06FFvhSaSJ5dffjlffPEFx48f5/Dhw8yZM4eSJUtSp04dPv74Y8Al79WrV5/1PDNnziQ5OZm4uDgWLFiQtu+iiy5Kmwa2WrVqlC1blqVLl2KtZdq0aWn339PbvXt32h8Ny5YtIyUlJW0YZ08/l5CQEK9cg9zw28RujOlsjNlgjNlkjHnE1/GIFBXeSOwAgwcP5tChQ8yYMcMbYYnkWYsWLejdu3favWzPNKrTp0/nnXfeoWnTplx88cXMnj072/Ncf/311KtXj4YNG3Lbbbfxj3/8I21fly5dWLhwYVp54sSJDBo0iLp163LBBRekdZx788030wZx+uSTT2jUqBFNmzbl/vvvZ8aMGWmjPfpiulYPv5y21RgTDMQAVwGxwHKgj7V2XWbHa9pWkVP+9a9/MXLkSA4fPpzWTJgX1loaN25MRESEzzoBie8Vl2lbjx8/TocOHfj555+9MgHMDTfcwLhx46hfv74XoguMaVtbA5ustVustYnADODMdpAC0r49vP++e33ypCt/+KErHzvmyp7HEw8edOXPPnPlvXtd2TOt9e7drux5BHLHDlf+/ntX3rLFlf/7X1fesMGVPZ011651Zc//q6tWubLniZPly1157VpXXrLElT0Dh/33v66cOuYC33/vyjt2uPK8ea68e7crz5njyp7bRJ995soHD7ryzJmufOyYK3/4oSufPOnK77/vyh5TpsCVV54qT5wI6Z8YeeUV6NbtVPnFF+HGG0+Vx42Dm28+VX76abj11lPlxx+HAQNOlR99FO6661R5+HC4995T5QcfdIvHvfe6Yzzuusudw2PAAPcZHrfe6mLwuPlmF6PHjTe6n8GjWzf3M3pcc427Bh5XXumukYc3vntLl1YmLCyMw4dL5eu79/vvhhMnviU62vVK1nev+H73kpPd7/Xvv105KcmV9+8/dfyGDXDgQMay53eXmOjKhw658okTrnz4sCsnJLjykSOufPy4K3vuAh075sqe3/3Ro67sGWrhyBFXTr1FzuHDruzpS3fokCt75jc6eNCVPd+dAwdg+/YIxox5kp07d7J/v9vvGV/m779d2TOT6759rpyS4sp795763gPs3JlImzY90pL6nj0UKn9N7DWAHenKsanb0hhj7jLGRBtjouPj4ws1OBF/dujQoVxPAJOVqlWrEhYWrk50UixcfXUnateune/zhIaG0qPHbV6IKG/8tSm+J9DZWjsotdwPaGOtHZrZ8WqKFzmle/fubNu2jVVeGkjkjjvuYObMmezcuTPH08BK4CguTfH+LhCa4ncCtdKVa6ZuE5Gz2LNnT747zqU3ePBgjh49yvTp0712ThEpOP6a2JcD9YwxdYwxocDNwJc+jkmkSNizZw9Vq1Y9c8dPP8HAgdC4MZx/Plx6qbvJu3DhqZuFmYiKiqJFixa8+eabOXoeWER8yy8Tu7U2CRgKfAusB2ZZa3/P/l0iAi6xV6lS5dSGxEQYNAjatXM90iIj4R//AGPgtdegQwe46CJ4661TvYnSMcZw9913s2bNmgxDcIqId50+21xe+WViB7DWzrXW1rfWXmCtfdbX8YgUBceOHePIkSOnEru1rpb+zjuuy3VcnOt+Pn06LFrkuvd+8AGUKweDB8PFF8MXX5xx3ltuuYXy5cvzSvpu1iIBoKCmVvXVlK3gx4ldRHLP84RIWmJ/8UWXxJ95Bp57DiIiMr6hdGn3HNWvv8KXX0JoKFx/PdxwA+zale6w0tx55518+umnbNu2rbB+HBGOHj1Kly5daNq0KY0aNWLmzJn8+OOP9OjRI+2Y+fPnc/311wPuu/rPf/6Tpk2b0rZt27Rx4tMbO3Ys/fr145JLLqFfv34kJyczYsQIWrVqRZMmTdKeArn55pv5+uuv097nqVFndfzChQu57LLL6NatGw0bNsw0doCnnnqKVq1a0ahRI+666y6v3+JSYhcJIHtSH5itUqUKbN7sHoTu0QMeeyz7NxoD110H//sfvPACfPONa55P12Fu6NChGGN44403CvJHED/n7XE+zmbevHlUr16d1atXs3btWjp37kyHDh34448/0v6Qfe+99xg4cCDg/hBo27Ytq1ev5vLLL2dK+of101m3bh3ff/89//nPf3jnnXcoV64cy5cvZ/ny5UyZMoU///yT3r17M2vWLAASExP54Ycf6NKlS5bHA6xcuZJXXnmFmJiYTGMH929p+fLlrF27luPHj/PVV1/l7OLnULaJ3RjTyqufJiIFypPYq1apAvfcAyEh8PrrLnHnREgIjBzpRp1p0sTV5m+7DQ4donbt2tx4441MmTKFI56RREQKWOPGjZk/fz6jRo1i0aJFlCtXDmMM/fr148MPP+TAgQP88ssvaUO+hoaG0rVrVwBatmzJ1q1bMz1vt27diEhtwfruu++YNm0azZo1o02bNuzbt4+NGzdyzTXXsGDBAk6cOME333zD5ZdfTkRERJbHA7Ru3Zo6depkGTu44WbbtGlD48aN+fHHHzNM9+oNZ5u2dbIxpjRu5Lf/ZDWkq4j4B09ir7NkCcyf7zrHZTIr1VldcAEsWADPPgtPPQU//wyzZvHggw8ya9Yspk6dyr3ph1WTYiPdcOqEhGQslyyZsVyuXMZypUoZy+eee/bPq1+/PitXrmTu3LmMHj2ajh078vjjjzNgwACuu+46wsPD6dWrFyVKlEiNKSRtcKbg4OAs73WXKlUq7bW1ltdee41OnTqdcVz79u359ttvmTlzJjenDkWY1fELFy7McN7MYh85ciRDhgwhOjqaWrVqMXbs2LRZ5bwl2xq7tbY50BVIAj4xxqw2xjxijIn0ahQi4hV79uyhJlDpqafg//7P1drzqkQJeOIJ95jcyZNwySW0XbeO1q1b88orr5CSzSNyIt6ya9cuSpYsya233sqIESNYuXIlANWrV6d69eo888wzDEg/tm8edOrUiUmTJnEy9amQmJiYtFkNe/fuzXvvvceiRYvSmtKzO/5ssXuSeKVKlThy5IhXesGf7mw1dqy1G4AngSeNMU1xz5T/YIzZba29xOsRiUie/b1jBx8HBWFOnoRp08ALk1lwySWwciX06YMZNIjpHTty8bJlfPPNNz6bvUqKjzVr1jBixAiCgoIICQlh0qRJafv69u1LfHx8vkfGGzRoEFu3bqVFixZYa6lcuTJfpD4dcvXVV9OvXz+6d+9OaGjoWY8/W+zly5fnzjvvpFGjRpx77rlpM9V5U46HlDXGBAEdgT7AtcAv1trrvR5RHmhIWSn2rIUff+TPnj2pfeAAwZ98knFGE29ITobRo2HcOFaGhDC+dWtmLF7s3c8Qv+PPQ8oOHTqU5s2bc8cdd/g6lALn1SFljTGXGWMm4iZiGQ4sAi70l6QuUqwdPAivvup6sF95JeWOHOHxZs28n9TB1f6ffx4+/ZSLjeGVn39mg6d7tEgha9myJb/99hu3pp9yT4Cz94rfATwPrAOaWWs7WWvfs9YeLJToRCRzhw/DqFFQsyY88ACULw/TphFVuTJxzZsX7GffcAOJixZx1Bjq3HFHhkfiRArLihUr+OmnnwgLC/N1KH7nbDX2S621lwK/Am8aY1YaY34zxqwxxvxWCPGJyOn++ANatoR//cs9e758OSxdysmbb2br7t3UqlXr7OfIpzKtW/PhffexJCXFPRI3Zky2481L0aY5Anwrt9c/285z1lrPEFMfAiOANYD+9Yr4yu7dcNVVbvz3BQvc+O+p4uLisNZSs2bNQgnlzkceof6bb/LN+edz6TPPuD84pk51zzxJwAgPD2ffvn1UrFgx7TEyKTzWWvbt20d4eHiO33PWXvGp4q21ml1NxNeGDoX4eDcEbNOmGXbFxsYCFEqNHaBatWrc0r8/V77/PnueeIKyTz0Ff/4Js2fn7dl58Us1a9YkNjY2bZQ3KXzh4eG5+oM9p4n9CWPM28APwAnPRmvtZ7kLT0TybNky+PRTePrpM5I6wPbt24HCS+wAI0aM4O233+b5Eyd4/ssvoU8fN3PcvHnQsGGhxSEFJyQkJG0kNSkacjpW/ACgGdAZuC516VpQQYlIJl56yQ3l9cADme7etGkTQKH+J1y3bl169uzJxIkTOXjZZW7GuJMn3VzvP/9caHGIyCk5TeytrLVR1trbrbUDUpeBBRqZiJxy+DB8/jn07w9lymR6yIYNG6hduzYlC/ke96hRozh06JCb4apZM1iyxI0deuWVmU4BKyIFK6eJfYkxRu1qIr7y7beuw9wNN2R5SExMDPXr1y/EoJwWLVpw1VVX8fLLL7vhMuvUcbX1Jk3c8/SpU1qKSOHIaWJvC6wyxmzQ424iPjBnDlSs6MZ/z4S1lg0bNnDhhRcWcmDOI488wu7du5k2bZrbULky/PgjdO4MgwfDyy/7JC6R4iinnec6F2gUIpK9JUvg8svdxCyZiI+P5+DBgz6psQN06NCBVq1aMX78eAYOHOhm2ipVyjXF33ILPPywG/b24Yd9Ep9IcZKjGru1dltmS0EHJyLA33/Dpk3Qpk2Wh/z2m2tAa+ijnujGGB599FE2b96ccbaqkBD46CPo1QuGDYMJE3wSn0hxktOmeBHxleXL3bp16ywPWbFiBeDud/tK9+7dadCgAePGjcs4UlZIiBt2tlcvGD4c3njDZzGKFAdK7CL+zjNzYcuWWR6yYsUKIiMjqVChQiEFdaagoCBGjRrF6tWrmTdvXsadnpp7t25w333w8ce+CVKkGFBiF/F3GzZArVpQtmyWh6xYsYKW2ST+wnLLLbdQq1Ytnn/++TN3ligBM2a4DoC33uqGxBURr1NiF/F3GzdC3bpZ7o6Li2PLli20yeYefGEJDQ1l2LBhLFq0iJ8zG6AmIgK+/BLq1YPu3WHVqsIPUiTAKbGL+LuNG10izMKC1JrvFVdcUVgRZWvQoEFUrFiRcePGZX5AhQpuyNny5d3jcJs3F26AIgFOiV3En+3fD/v2ZZvYf/jhB8qXL0+zZs0KMbCslSpVivvvv5+vvvqKNWvWZH5QzZrw3XeQlARXX+1mrRMRr1BiF/FnGze6dRZN8SkpKcybN48rrriC4ODgQgwse0OHDqV06dK88MILWR/UoAHMnQt//eVq7gcOFF6AIgFMiV3En23d6tbnn5/p7iVLlrBr1y569uxZeDHlQIUKFbj77ruZMWMGf/75Z9YHtm4Nn30G69ZBly5w8GDhBSkSoJTYRfxZXJxbV6+e6e5Zs2YRFhZG167+N9nigw8+CMDEiROzP/Dqq+E//3HP67dvD3v2FHxwIgFMiV3En8XFuWfAM3k+PTk5mU8//ZRrr72WMlnM+OZLNWvW5IYbbuCdd97h2LFj2R98442ut/yGDW4+99WrCydIkQCkxC7iz3bvhqpVIejMf6pz585l165d9O3b1weB5czQoUPZv38///nPf85+cOfObuKYhASX3N97z40vLyK5osQu4s/i4qBatUx3TZo0iWrVqtGtW7dCDirnLrvsMho3bszrr7+ecZjZrLRtCytXunHxBw6E666DHTsKPlCRAKLELuLPskjsW7ZsYd68edx5552EhIT4ILCcMcYwdOhQVq1axZIlS3L2pqpV4fvv3VSvCxa43vOPPw6HDhVssCIBwieJ3Rgz1hiz0xizKnW5Nt2+R40xm1Lnfu/ki/hE/Mbu3Zkm9ldeeYXg4GDuuusuHwSVO3379qVcuXK8/vrrOX9TcDA8+CCsXQtdu8LTT7tH/p57zj3bLyJZ8mWN/WVrbbPUZS6AMaYhcDNwMW4O+InGGP95OFekMJ08CfHxcO65GTbv37+fd955hz59+lCjRg0fBZdzpUqVol+/fnz++efsz21SrlMHZs6EZcugRQv45z/duPn33w+//14wAYsUcf7WFN8dmGGtPWGt/RPYBGQ9V6VIIPM89nVaYp88eTJHjx5l2LBhPggqbwYMGMCJEydy1okuM61auWFoV692PejffBMaNXL34t96S4PbiKTjy8Q+1BjzmzHmXWPMOanbagDpe8rEpm47gzHmLmNMtDEmOj4+vqBjFSl8f//t1pUqpW1KTEzk1VdfpWPHjjRt2tRHgeVe8+bNadKkCe+9917+TtSkCUydCjt3wksvwbFjMHiwuy/ftavrSe+5biLFVIEldmPM98aYtZks3YFJwAVAMyAOmJDb81trJ1tro6y1UZUrV/Zy9CJ+wNNsXb582qaZM2eya9euIlVbB9eJbsCAAURHR7N27dr8n7ByZXjoIfjtN9dMP3Soux8/cKBL8ldfDa+8AjExemROip0CS+zW2iuttY0yWWZba/+y1iZba1OAKZxqbt8J1Ep3mpqp20SKH0/z8jmuQctay4QJE2jYsCGdO3f2YWB507dvX0JCQvJfa0/PGNdMP2EC/PmnG71u2DDYts11vrvwQrjgArj3XpgzBw4f9t5ni/gpX/WKT9/N93rA8yf8l8DNxpgwY0wdoB6wrLDjE/ELp9XYf/zxR1avXs3DDz+MMcaHgeVN5cqVue666/jggw84efKk9z/AGIiKgnHj3Ah2mzfDG2+4e/FTp0K3bu6PpNatYfhwl+h1b14CkK/usY83xqwxxvwGdAAeArDW/g7MAtYB84B7rbXJPopRxLdOq7FPmDCBKlWq+PVIc2czYMAA4uPj+frrrwv+w84/H4YMcUPV7tsHP/wAjz0GERHw2msu0VeoAM2bu6b8Dz5wfxCkpBR8bCIFyORoNCg/FxUVZaOjo30dhoh3jR0LTz4JSUms27CBiy++mKeeeooxY8b4OrI8S0pKonbt2rRs2ZI5c+b4LpCEBPj1V/jvf92ybBkcOeL2lSvnmvfbtHG1+xYtoEYN1yIg4keMMSustVGnby/hi2BEJAcOHICyZSE4mJdeeomIiAjuueceX0eVLyVKlKB///688MIL7Nq1i+pZzFpX4MLDoV07twAkJ8Mff7gE71leeAGSktz+c85xPfLTLxdfDKVK+SZ+kWyoxi7ir26/HRYuZPevv3Leeedxxx13nH0K1CJg06ZN1KtXj+eee45HH33U1+Fk7fhx+N//3LPzv/12avHU7I1xA+hceCHUr+/Wnteq4UshyKrGrsQu4q+6d4dt23j0mmt44YUX+OOPP6hfv76vo/KKdu3asWvXLmJiYopWR8CUFNi61SX41ath/Xp3Xz4mxj1T71GypEvw558PkZFw3nlu8bxO9wijSF6pKV6kqNm/n8RSpXj11Vfp3bt3wCR1gDvuuIPbb3oNRXUAABugSURBVL+dn376iXae5vCiICjIJevzz4cePU5tt9YNmhMT4xZPsl+/Hr75xtX+0ytb1iX5mjXdXADVqrkRBj2vPeXw8EL98SQwqMYu4q+aNGH1kSO02LaN9evXB1RiP3bsGNWqVaNTp07MmjXL1+EULGth715X09+2LeN65043g9+ePZn3xi9fHqpUgYoVXQ/+ihXPXDzby5WDMmXcEhZWyD+k+IJq7Dm069df2Th+fIGcu6j9EZXXeItQw6pfa71xIysTEhgydGhAJXWAkiVLMmTIEF544QU2bNjAhRde6OuQCo4xbqS8ypVdb/vMJCe7CX/i4s5c9u51j+vt2gVr1rjXR49m/5mhoS7Bly2bce1ZSpZ0j/1FRLhWAc/rrMrh4RASAiVKuHVmS1CQ+hX4CdXYT/O/CRNoPny4V84lkl+T69bltjVrCA/AJtk9e/YQGRlJr169mDp1qq/DKVpOnHBj4u/b55a//3bz1R865EbXO9v6+HG3nDjh3bgyS/glSpxK+kFBp5bsylnt8/zh4MlbWa1zcsxpx1qAlBSstVjPOvU1KSluW+prz3EkJ7t1Soo7n2d/6nuNZ3vqUmLLFkLTzf2QX+o8l0Mnjx3jSFycV86VmYLqKOSP57X66z3fytauXbQ6l+XSiBEjePHFF/nll19o27atr8MpflJS3DP9CQmnkn36155yQoKbRjgpya0zW1L3pZw4kXFJTCQlJYWUpCRSkpOxp6/TLSkpKRnKNrVMunWKtWmLPa2cklrOsN3zOot1cmrC9twIsZmsU1LX+X3dZ9cuylVLP/Bq/iixi4jfOXz4MA0bNiQsLIxly5ZRoUIFX4fkt6y1nDx5khMnTpCYmHjGOqfbcnu8Zzl58mS2a8/rlAIeuS80NJTQ0FBCQkIyrDPbltNj0i8lSpQ4Y53Ztrzsq1ixIkFB3hvwVffYRcTvlClThlmzZtGuXTs6duzIZ599Rp06dXwd1hmSkpJISEjg+PHjXlknJCTkOvEWxPj6ISEhhIWFpSU9z+v020JDQylVqpRXEmh+jwkODg7oFixvUWIXEZ/6xz/+wZdffslNN91EgwYN6NWrFx07duTiiy+mcuXKlClTBmNM2uKptSYkJGRYp3/trQTsWSd5RqDLg6CgICIiIoiIiCA8PDxtSZ9Ay5QpQ8WKFc9IqpklWm9tCwkJUZIMUGqKFxG/sGPHDl544QWmT5/OgQKYda1EiRKEh4enJdjCWoeEhHj9ZxEB3WMXkSIiJSWFmJgYYmJi2LdvH0eOHDnVQ9laQkJCCA8PJywsLMt1+hqyZ12ihBooJbDoHruIFAlBQUE0aNCABg0a+DoUkSLJV/Oxi4iISAFQYhcREQkgAXGP3RgTD2zzdRwiIiKF6DxrbeXTNwZEYhcRERFHTfEiIiIBRIldREQkgCixi4iIBBAldhERkQCixC4iIhJAlNhFREQCiBK7iIhIAFFiFxERCSBK7CIiIgFEiV1ERCSAKLGLiIgEECV2ERGRAKLELiIiEkCU2EVERAKIEruIiEgAUWIXEREJIErsIiIiAUSJXUREJICU8HUA3lCpUiUbGRnp6zBEREQKzYoVK/Zaayufvt1vE7sxpjPwChAMvG2tHZfVsZGRkURHRxdabCIiIr5mjNmW2Xa/bIo3xgQDbwDXAA2BPsaYhr6NSkRExP/5a429NbDJWrsFwBgzA+gOrCvoD967F379taA/ReTsjIFLL4WyZX0diUjBshZSUjJfF/Y2z+KJK/3r/G675BIoUQhZ118Tew1gR7pyLNAm/QHGmLuAuwBq167ttQ/+7Tfo2tVrpxPJl0cfheee83UU4u9OnoRjx+D48YxL+m2JidkvJ0/m7JjkZLckJZ16nd9ySoqvr2DhOHAAypUr+M/x18R+VtbaycBkgKioKHv6/pMnTxIbG0tCQkKuzlu1Kvzvf96JUbzL2nCSkmoCIb4OpVB07AhHjvg6CvE2a13C/ftv2L8fDh2Cw4fdktVrT/nIkVPJOn3STk7Of1zBwRAamvkSEnJqHRzsap0hIRAefqocHHxqyW3ZswQFuZYqzzr968LY5nkN7rVnnf51fraVKpX/31NO+Gti3wnUSleumbotx2JjYylTpgyRkZEYz5WVIstay759+zh8OJY6der4OpxCERJyqgnPm44ehd9/d0mifHmoVQsqn9GvVnLCWncd//rLLbt3w549LmlntyQmnv3cERFQpoy7FVOmjFuqVYOSJd2+iIiMr7Pa5imHhZ09YUtg8NfEvhyoZ4ypg0voNwO35OYECQkJSuoBxBhDxYoViY+P93UohcYY7yb2NWtg7FiYPfvMGl6tWtC6NbRrB507Q926p2oaxdWhQ7Bjx6ll506XuD0J3JPMjx3L/P2lSkGFCqeWiy7KWK5QAc45J2Pi9rwuXbpw7sVKYPLLr461NskYMxT4Fve427vW2t9zex4l9cBS3H6fxnjv3uOMGXD77S7ZPPSQ68Rzzjnunt/mzbB8OSxdCp9+6o6vUwc6dXJJvn37wrkvWNgOHICNGyEmBrZudcl7+/ZTifzgwYzHGwOVKrnbdeeeCxdccOp1+nWVKi5ph4X55McS8c/EDmCtnQvM9XUcIr7irRr7Dz/ArbfC//0ffPaZS05Z2bwZvv3WLR9+CG++6e45RkW5e/5XXOHOU7Jk/uMqDMePw6ZNLnnHxJxK5DExcHrjT+XKruXiggvcHzO1a7uyZ6lWzTVZi/g7v03skjdbt25lyZIl3HKLu3MRHR3NtGnTePXVV30cWc6cHn9x5o3EfvCgS+r168Pcua6JNzsXXABDhrglMRF++QV+/NH9cfCvf8Hzz7vk1qSJS/YtW7qlQQPfJfuTJ12N+/TEHRPjat7pVavmrkWPHm5dr55bR0a6+9AigUCJPcBs3bqVjz76KC0xRkVFERUVVSifnZycTHC6Hjinl3Pi9PiLM28k9gkT3P3gL788e1I/XWiou+ferh08+aTrJLZoESxcCNHRrnn/rbdOHV+zpkuU9erB+edD9eoukVav7pZy5fJ+3z4pyTWTb97slvTJ+88/3X6P8uXhwgtd3PXrn1rq1nX3r0UCXbFI7A8+CKtWefeczZrBv/+d9f6jR49y0003ERsbS3JyMmPGjKFy5cq8+uqrfPHFFwDMnz+fiRMn8vnnn1O6dGkeeOABvvrqKyIiIpg9ezZVq1Zlzpw5PPPMMyQmJlKxYkWmT59O1apVGTt2LJs3b2bTpk3s3buXkSNHcuedd/LII4+wfv16mjVrxu23307z5s158cUX+eqrrzhy5Aj33Xcf0dHRGGN44oknuPHGGzPEvXz5ch544AGOHj1KWFgYP/zwA59++inR0dG8/vrrAHTt2pXhw4fTvn17Spcuzd13383333/PG2+8wa233krv3r2ZP38+I0eOpFWrVtx7773Ex8dTsmRJpkyZQoMGDejfvz9ly5YlOjqa3bt3M378eHr27HlG/A899JB3f3FFSFBQ/hL7nj3w0kvQsye0apX/eEqXhmuucQu4+/9btsDKlbBhg6stb9wIn3zien6fLjzc3YeuVAkqVsy49gzCY61rPo+Pd4NF7d7tEvm2bRk7/EVEuD8gmjaFXr1O1bzr13fnLGbdMUQyKBaJ3RfmzZtH9erV+frrrwE4ePAgZcuWZciQIcTHx1O5cmXee+89Bg4cCLg/BNq2bcuzzz7LyJEjmTJlCqNHj+bSSy9l6dKlGGN4++23GT9+PBMmTADgt99+Y+nSpRw9epTmzZvTpUsXxo0bl5bIARYuXJgW09NPP025cuVYs2YNAPv3788Qc2JiIr1792bmzJm0atWKQ4cOEXGW9smjR4/Spk2btJgAKlasyMqVKwHo2LEjb775JvXq1ePXX39lyJAh/PjjjwDExcWxePFi/vjjD7p160bPnj3PiL84y2+N/fnnXZJ8+mnvxZReUJCrBdete+a+w4chLs4tu3a5JS7OJep9+9wSE+PWhw6d+f5Spdw97ypV3B8lN9/sbhOcf75b16hx6nljEcmoWCT27GrWBaVx48YMGzaMUaNG0bVrVy677DIA+vXrx4cffsiAAQP45ZdfmDZtGgChoaF0TR3yrmXLlsyfPx9wz+P37t2buLg4EhMTMzzD3b17dyIiIoiIiKBDhw4sW7aM8uXLZxnT999/z4wZM9LK55xzTob9GzZsoFq1arRKrd6VzcFYpsHBwWfU+nv37g3AkSNHWLJkCb169Urbd+LEibTXPXr0ICgoiIYNG/LXX3+d9bOKm/z0it++HSZOhP793f3vwuZ5fKt+/bMfm5jo/hDwDOYRHq773SL5USwSuy/Ur1+flStXMnfuXEaPHk3Hjh15/PHHGTBgANdddx3h4eH06tWLEqkPq4aEhKQ9zhUcHExS6k3D++67j4cffphu3bqxcOFCxo4dm/YZpz/+VVCPg5UoUYKUdBkm/Wh+4eHhZ9xHL5U6vFJKSgrly5dnVRb3QcLSPQ9kC2IkliIuPzX2xx936yee8F48BSU01DWfi4h3qDGrgOzatYuSJUty6623MmLEiLSm6erVq1O9enWeeeYZBgwYcNbzHDx4kBo1agAwderUDPtmz55NQkIC+/btY+HChbRq1YoyZcpw+PDhTM911VVX8cYbb6SVT2+Kv/DCC4mLi2P58uUAHD58mKSkJCIjI1m1ahUpKSns2LGDZcuW5egalC1bljp16vDxxx8DLnmvXr062/dkF39xk9fEvmIFTJ3q+pZ4cRoFESkilNgLyJo1a2jdujXNmjXjySefZPTo0Wn7+vbtS61atbjooovOep6xY8fSq1cvWrZsSaXTHkBu0qQJHTp0oG3btowZM4bq1avTpEkTgoODadq0KS+//HKG40ePHs3+/ftp1KgRTZs2ZcGCBRn2h4aGMnPmTO677z6aNm3KVVddRUJCApdccgl16tShYcOG3H///bRo0SLH12H69Om88847NG3alIsvvpjZs2dne3x28Rc3eUnsJ0+6R9UqV4bHHiuYuETEv5lAaAKNioqy0dHRGbatX78+R4nTF4YOHUrz5s2544478nyOsWPHUrp0aYYPH+7FyPyfP/9evS0y0j2ydVpDTbZGjYLx42HWLNdbXEQClzFmhbX2jOeZdY+9kLVs2ZJSpUpl6EUukpncPu72yisuqd99t5K6SHGmxF7IVqxY4ZXzpO9EJ4EpN03xEye6e+o33givvVawcYmIfwvoe+yBcJtBTiluv8+cPu72zjtw773QrRt89JHGMxcp7gI2sYeHh7Nv375ilwwClWc+9vDwcF+HUmhyUmP/6CO48043C9usWe7RMREp3gK2Kb5mzZrExsYWq/m7A114eDg1a9b0dRiF5myJ/Zdf3FSs7dq5Wds0TaiIQAAn9pCQkAyjtIkUNdkl9gMHoHdvN53o559rpDYROSVgE7tIUZddr/ixY2HnTldrz2YUYREphgL2HrtIUZdVjX3HDnjjDRg0CFq3Lvy4RMS/KbGL+KmsesW/9ppL+BpZTkQyo8Qu4qcyq7EnJcG778L118N55/kmLhHxb0rsIn4qs8S+YIGbw7xvX9/EJCL+T4ldxE9lltg//RRKl4ZOnXwTk4j4PyV2ET+VVY29fXs93iYiWVNiF/FTpz/utns3xMTA5Zf7LiYR8X9K7CJ+6vRe8YsXu7USu4hkR4ldxE+d3hS/fLkbC75FC9/FJCL+T4ldxE+dntjXroUGDTR7m4hkz+8SuzGmlzHmd2NMijEmytfxiPjK6Yn999/h4ot9F4+IFA1+l9iBtcANwE++DkTEl9In9sOHYds2JXYROTu/mwTGWrsewBjj61BEfCp9r/h169y6USPfxSMiRYM/1thzxBhzlzEm2hgTrTnXJRClr7Fv3uzW9er5Lh4RKRp8UmM3xnwPnJvJrn9aa2fn5BzW2snAZICoqKgsJrcUKbrSP+62fbtb167tu3hEpGjwSWK31l7pi88VKUrS19i3b4cKFdxwsiIi2SmyTfEige70xK7auojkhN8ldmPM9caYWOAfwNfGmG99HZOILyixi0he+F1it9Z+bq2taa0Ns9ZWtdZqHisplpTYRSQvvJ7YjTEaF0vECzyPux06BAcPQq1avo5IRIoCryR243Q0xrwDxHrjnCLFnadX/F9/uXL16r6NR0SKhnwldmNMW2PMq8A2YDZutLgG3ghMpLjzNMV7hmmoVMm38YhI0ZCnxG6Mec4YsxF4FvgNaA7EW2unWmv3ezNAkeLKk9j37nXlypV9G4+IFA15fY59EBADTALmWGtPGGM0SIyIF6nGLiJ5kdem+GrAM8B1wGZjzAdAhDHG78aeFymqVGMXkbzIUyK21iYD84B5xpgwoCsQAcQaY36w1vb1YowixZKnV3x8PEREQMmSvo5IRIqCfNWwU5P6jUAk7l77NqBH/sMSEU+v+L17VVsXkZzLb9P5bOAgsAI4ARwFJuY3KBHJeI9d99dFJKfym9hrWms7eyUSEckg/T121dhFJKfyO0DNEmNMY69EIiIZqMYuInmR3xr7pUB/Y8yfuKZ4A1hrbZN8RyZSzHkS+/79cM45vo5GRIqK/Cb2a7wShYicwdMr/vBhKFfO19GISFGRr8Rurd3mrUBEJCNj4OhRSE6GMmV8HY2IFBV+N22riDjGuFndAMqW9W0sIlJ0KLGL+CkldhHJCyV2ET9lDCQkuNdqiheRnFJiF/FTxpx6rRq7iOSUEruIn0qf2FVjF5GcUmIX8VNB6f51qsYuIjmlxC7ip9QULyJ5ocQu4qfUFC8ieaHELuKnPIk9ONjNxy4ikhNK7CJ+ypPYy5bNWHsXEcmOEruIn/IkczXDi0hu+F1iN8b8yxjzhzHmN2PM58aY8r6OScQXPL3i1XFORHLD7xI7MB9olDr1awzwqI/jEfEJT429dGnfxiEiRYvfJXZr7XfW2qTU4lKgpi/jEfEVT2JXxzkRyQ2/S+ynGQh84+sgRHxBiV1E8iJf87HnlTHme+DcTHb901o7O/WYfwJJwPQsznEXcBdA7dq1CyhSEd9RYheRvPBJYrfWXpndfmNMf6Ar0NFaa7M4x2RgMkBUVFSmx4gUZUrsIpIXPkns2THGdAZGAu2stcd8HY+Iryixi0he+OM99teBMsB8Y8wqY8ybvg5IxBc8j7spsYtIbvhdjd1aW9fXMYj4A9XYRSQv/LHGLiJASopbK7GLSG4osYv4qRMn3FqJXURyQ4ldxE8lJLi1EruI5IYSu4ifUmIXkbxQYhfxU0rsIpIXSuwifkr32EUkL5TYRfyUauwikhdK7CJ+SoldRPJCiV3ETymxi0heKLGL+CkldhHJCyV2ET+lxC4ieaHELuKn1CteRPJCiV3ET6nGLiJ5ocQu4qcSE91aiV1EckOJXcTPhYf7OgIRKUqU2EX81MiRbh2kf6Uikgv6L0PET73wAljr6yhEpKhRYhcREQkgSuwiIiIBRIldREQkgBgbADfxjDHxwDYvnrISsNeL5yuudB3zT9cw/3QN80/XMP8K4hqeZ62tfPrGgEjs3maMibbWRvk6jqJO1zH/dA3zT9cw/3QN868wr6Ga4kVERAKIEruIiEgAUWLP3GRfBxAgdB3zT9cw/3QN80/XMP8K7RrqHruIiEgAUY1dREQkgCixi4iIBBAl9tMYYzobYzYYYzYZYx7xdTxFkTFmqzFmjTFmlTEm2tfxFBXGmHeNMXuMMWvTbatgjJlvjNmYuj7HlzH6uyyu4VhjzM7U7+MqY8y1vozR3xljahljFhhj1hljfjfGPJC6Xd/FHMrmGhbKd1H32NMxxgQDMcBVQCywHOhjrV3n08CKGGPMViDKWqsBLXLBGHM5cASYZq1tlLptPPC3tXZc6h+a51hrR/kyTn+WxTUcCxyx1r7oy9iKCmNMNaCatXalMaYMsALoAfRH38UcyeYa3kQhfBdVY8+oNbDJWrvFWpsIzAC6+zgmKSastT8Bf5+2uTswNfX1VNx/DpKFLK6h5IK1Ns5auzL19WFgPVADfRdzLJtrWCiU2DOqAexIV46lEH8ZAcQC3xljVhhj7vJ1MEVcVWttXOrr3UBVXwZThA01xvyW2lSvJuQcMsZEAs2BX9F3MU9Ou4ZQCN9FJXYpCJdaa1sA1wD3pjaPSj5Zd99M985ybxJwAdAMiAMm+DacosEYUxr4FHjQWnso/T59F3Mmk2tYKN9FJfaMdgK10pVrpm6TXLDW7kxd7wE+x93ikLz5K/V+nee+3R4fx1PkWGv/stYmW2tTgCno+3hWxpgQXEKabq39LHWzvou5kNk1LKzvohJ7RsuBesaYOsaYUOBm4Esfx1SkGGNKpXYWwRhTCrgaWJv9uyQbXwK3p76+HZjtw1iKJE8ySnU9+j5myxhjgHeA9dbal9Lt0ncxh7K6hoX1XVSv+NOkPn7wbyAYeNda+6yPQypSjDHn42rpACWAj3QNc8YY8x+gPW56x7+AJ4AvgFlAbdzUxDdZa9U5LAtZXMP2uKZPC2wF7k53r1hOY4y5FFgErAFSUjc/hrtHrO9iDmRzDftQCN9FJXYREZEAoqZ4ERGRAKLELiIiEkCU2EVERAKIEruIiEgAUWIXEREJIErsIgHMGFPeGDMkXbm6MeaTAvqsHsaYx71wnheNMVd4IyaR4kiPu4kEsNRxqr/yzHRWwJ+1BOiW31n9jDHnAVOstVd7JzKR4kU1dpHANg64IHXu538ZYyI9c5UbY/obY75InVt7qzFmqDHmYWPM/4wxS40xFVKPu8AYMy91Up9FxpgGp3+IMaY+cMKT1I0x7xtjJqWeZ4sxpn3qpBfrjTHvpx4TnHrcWmPMGmPMQwDW2m1ARWPMuYVziUQCSwlfByAiBeoRoJG1thmk1eDTa4SbeSoc2ASMstY2N8a8DNyGG4VxMjDYWrvRGNMGmAic3lR+CbDytG3nAP8AuuGGI70EGAQsN8Y0w43uWCPdvOnl0713Zerxn+btxxYpvpTYRYq3BanzRR82xhwE5qRuXwM0SZ2d6v+Aj93w1wCEZXKeakD8advmWGutMWYN8Je1dg2AMeZ3IBL4L3C+MeY14Gvgu3Tv3QNUz+8PJ1IcKbGLFG8n0r1OSVdOwf3/EAQc8NT4s3EcKJfFudOfN+3c1tr9xpimQCdgMHATMDD1mPDUc4pILukeu0hgOwyUyeubU+eQ/tMY0wvcrFWpyfh064G6uTm3MaYSEGSt/RQYDbRIt7s+moVNJE+U2EUCmLV2H/Bzage1f+XxNH2BO4wxq4Hfge6ZHPMT0Nyka6/PgRrAQmPMKuBD4FFIm8e6LhCdx3hFijU97iYiXmGMeQV3X/37fJ7neqCFtXaMdyITKV5UYxcRb3kOKOmF85QAJnjhPCLFkmrsIiIiAUQ1dhERkQCixC4iIhJAlNhFREQCiBK7iIhIAFFiFxERCSD/D3x43qQE9tzFAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(8,4))\n",
    "ax1 = fig.add_subplot(2, 1, 1)\n",
    "soma_plot = ax1.plot(t, soma_v, color='black', label='soma(0.5)')\n",
    "dend_plot = ax1.plot(t, dend_v, color='red', label='dend(0.5)')\n",
    "rev_plot = ax1.plot([t[0], t[-1]], [syn_.e, syn_.e], label='syn reversal',\n",
    "        color='blue', linestyle=':')\n",
    "ax1.legend()\n",
    "ax1.set_ylabel('mV')\n",
    "ax1.set_xticks([]) # Use ax2's tick labels\n",
    "\n",
    "ax2 = fig.add_subplot(2, 1, 2)\n",
    "syn_plot = ax2.plot(t, syn_i, color='blue', label='synaptic current')\n",
    "ax2.legend()\n",
    "ax2.set_ylabel(h.units('ExpSyn.i'))\n",
    "ax2.set_xlabel('time (ms)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try setting the recording vectors to one of the other cells. They should be unresponsive to the stimulus."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Connecting the cells</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay. We have our ball-and-stick cells arranged in a ring, and we have attached a stimulus onto the first cell. Next, we need to connect an axon from cell n to a synapse at the middle of the dendrite on cell n + 1. For this model, the particular dynamics of the axons do not need to be explicitly modeled. When the soma fires an action potential, we assume the spike propagates down the axon and induces a synaptic event onto the dendrite of the target cell with some delay. We can therefore connect a spike detector in the soma of the presynaptic cell that triggers a synaptic event in the target cell via a <a href=\"https://neuron.yale.edu/neuron/static/py_doc/modelspec/programmatic/network/netcon.html#NetCon\">NetCon</a>.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "syns = []\n",
    "netcons = []\n",
    "for source, target in zip(my_cells, my_cells[1:] + [my_cells[0]]):\n",
    "    syn = h.ExpSyn(target.dend(0.5))\n",
    "    nc = h.NetCon(source.soma(0.5)._ref_v, syn, sec=source.soma)\n",
    "    nc.weight[0] = 0.05\n",
    "    nc.delay = 5\n",
    "    netcons.append(nc)\n",
    "    syns.append(syn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `zip` pairs each cell with the next cell, where the addition places the first cell as the cell after the last cell. The seemingly repetitive specification of the source section in the `NetCon` constructor's `sec=` argument is required for technical reasons."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see what happens to the first cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "h.finitialize(-65 * mV)\n",
    "h.continuerun(100 * ms)\n",
    "plt.plot(t, soma_v, label='soma(0.5)')\n",
    "plt.plot(t, dend_v, label='dend(0.5)')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we of course only plotting `my_cells[0]`, but the fact that it spikes more than just once suggests that spikes are being transmitted throughout the network.\n",
    "\n",
    "<b>As an exercise</b>, try rerunning the above plotting `my_cells[1]` alternatively or in-addition to `my_cells[0]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can ask each of our existing `NetCon`s to record spike times in NEURON `Vector` objects using <a href=\"https://neuron.yale.edu/neuron/static/py_doc/modelspec/programmatic/network/netcon.html#NetCon.record\">NetCon.record</a>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "spike_times = [h.Vector() for nc in netcons]\n",
    "for nc, spike_times_vec in zip(netcons, spike_times):\n",
    "    nc.record(spike_times_vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once again, we rerun everything to 100 ms:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.finitialize(-65 * mV)\n",
    "h.continuerun(100 * ms)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print out the results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cell 0: [10.925000000099914, 43.55000000010134, 76.17500000010875]\n",
      "cell 1: [17.450000000099543, 50.075000000102825, 82.70000000011024]\n",
      "cell 2: [23.975000000099172, 56.60000000010431, 89.22500000011172]\n",
      "cell 3: [30.5000000000988, 63.12500000010579, 95.7500000001132]\n",
      "cell 4: [37.02500000009986, 69.65000000010727]\n"
     ]
    }
   ],
   "source": [
    "for i, spike_times_vec in enumerate(spike_times):\n",
    "    print('cell {}: {}'.format(i, list(spike_times_vec)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each line represents one cell and lists all the times it fires: cell 0 fires first, then 1, 2, 3, 4, back to 0, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A more intuitive way of seeing this is to use a raster plot. Here's how to do that with matplotlib:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "import matplotlib.pyplot as plt\n",
    "plt.figure()\n",
    "\n",
    "for i, spike_times_vec in enumerate(spike_times):\n",
    "    plt.vlines(spike_times_vec, i + 0.5, i + 1.5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This page has demonstrated various functionality to arrange, connect, and visualize a network and its output. As nice as it may seem, it needs some design work to make it flexible. The next part of the tutorial further organizes the functionality into more classes to make it more easily extended."
   ]
  }
 ],
 "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
}