{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ball and stick 3: Extensible network of cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the third part of a tutorial series where we build a multicompartment cell and evolve it into a network of cells running on a parallel machine. In this part, we take the functionality of the ring network we constructed in the previous page and encapsulate it into various classes so that the network is more extensible. We also begin parameterizing the model so that particular values are not hard-coded, but remain variable so that the model is flexible."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before, we will begin by loading relevant NEURON libraries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-23T00:18:52.261516Z",
     "iopub.status.busy": "2025-05-23T00:18:52.261361Z",
     "iopub.status.idle": "2025-05-23T00:18:52.559754Z",
     "shell.execute_reply": "2025-05-23T00:18:52.559412Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from neuron import h, gui\n",
    "from neuron.units import ms, mV\n",
    "\n",
    "h.load_file(\"stdrun.hoc\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generic Cell class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the last tutorial, we created a generic `Cell` class (actually, two versions) but we can expand this to make it more powerful. For example, let's make each Cell record its spike times, some membrane potential timeseries, and keep track of NetCons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-23T00:18:52.561613Z",
     "iopub.status.busy": "2025-05-23T00:18:52.561341Z",
     "iopub.status.idle": "2025-05-23T00:18:52.567192Z",
     "shell.execute_reply": "2025-05-23T00:18:52.566841Z"
    }
   },
   "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\n",
    "        h.define_shape()\n",
    "        self._rotate_z(theta)\n",
    "        self._set_position(x, y, z)\n",
    "\n",
    "        # everything below here in this method is NEW\n",
    "        self._spike_detector = h.NetCon(self.soma(0.5)._ref_v, None, sec=self.soma)\n",
    "        self.spike_times = h.Vector()\n",
    "        self._spike_detector.record(self.spike_times)\n",
    "\n",
    "        self._ncs = []\n",
    "\n",
    "        self.soma_v = h.Vector().record(self.soma(0.5)._ref_v)\n",
    "\n",
    "    def __repr__(self):\n",
    "        return \"{}[{}]\".format(self.name, self._gid)\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(\n",
    "                    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",
    "                )\n",
    "        self.x, self.y, self.z = x, y, z\n",
    "\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": [
    "Since the `BallAndStick` has a simple geometry, we could modify it to assume that all inputs go into a single location; we will call it the `.syn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-23T00:18:52.569065Z",
     "iopub.status.busy": "2025-05-23T00:18:52.568678Z",
     "iopub.status.idle": "2025-05-23T00:18:52.573367Z",
     "shell.execute_reply": "2025-05-23T00:18:52.573036Z"
    }
   },
   "outputs": [],
   "source": [
    "class BallAndStick(Cell):\n",
    "    name = \"BallAndStick\"\n",
    "\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",
    "\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",
    "        # NEW: the synapse\n",
    "        self.syn = h.ExpSyn(self.dend(0.5))\n",
    "        self.syn.tau = 2 * ms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Due to the nature of `h.ExpSyn` decay, there is mathematically no difference between having two ExpSyn objects at the same point or one synapse where multiple inputs add linearly, so it suffices to have just the one as long as we're happy with all inputs going into `dend(0.5)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Make a Ring class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Encapsulating code into discrete objects is not only conceptually useful for code management, but as we know with cell objects, it lets us make several instances of the object for use in a network. Thinking ahead, we may very well need several networks – each network configured differently. This allows scripting of several simulations <i>en masse</i>, either in a for loop that sequentially processes the networks, or it can be used with NEURON's <a href=\"https://neuron.yale.edu/neuron/static/py_doc/modelspec/programmatic/network/parcon.html#ParallelContext.subworlds\">subworlds</a> architecture in a parallel context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-23T00:18:52.575647Z",
     "iopub.status.busy": "2025-05-23T00:18:52.574891Z",
     "iopub.status.idle": "2025-05-23T00:18:52.579826Z",
     "shell.execute_reply": "2025-05-23T00:18:52.579497Z"
    }
   },
   "outputs": [],
   "source": [
    "class Ring:\n",
    "    \"\"\"A network of *N* ball-and-stick cells where cell n makes an\n",
    "    excitatory synapse onto cell n + 1 and the last, Nth cell in the\n",
    "    network projects to the first cell.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, N=5, stim_w=0.04, stim_t=9, stim_delay=1, syn_w=0.01, syn_delay=5, r=50\n",
    "    ):\n",
    "        \"\"\"\n",
    "        :param N: Number of cells.\n",
    "        :param stim_w: Weight of the stimulus\n",
    "        :param stim_t: time of the stimulus (in ms)\n",
    "        :param stim_delay: delay of the stimulus (in ms)\n",
    "        :param syn_w: Synaptic weight\n",
    "        :param syn_delay: Delay of the synapse\n",
    "        :param r: radius of the network\n",
    "        \"\"\"\n",
    "        self._syn_w = syn_w\n",
    "        self._syn_delay = syn_delay\n",
    "        self._create_cells(N, r)\n",
    "        self._connect_cells()\n",
    "        # add stimulus\n",
    "        self._netstim = h.NetStim()\n",
    "        self._netstim.number = 1\n",
    "        self._netstim.start = stim_t\n",
    "        self._nc = h.NetCon(self._netstim, self.cells[0].syn)\n",
    "        self._nc.delay = stim_delay\n",
    "        self._nc.weight[0] = stim_w\n",
    "\n",
    "    def _create_cells(self, N, r):\n",
    "        self.cells = []\n",
    "        for i in range(N):\n",
    "            theta = i * 2 * h.PI / N\n",
    "            self.cells.append(\n",
    "                BallAndStick(i, h.cos(theta) * r, h.sin(theta) * r, 0, theta)\n",
    "            )\n",
    "\n",
    "    def _connect_cells(self):\n",
    "        for source, target in zip(self.cells, self.cells[1:] + [self.cells[0]]):\n",
    "            nc = h.NetCon(source.soma(0.5)._ref_v, target.syn, sec=source.soma)\n",
    "            nc.weight[0] = self._syn_w\n",
    "            nc.delay = self._syn_delay\n",
    "            source._ncs.append(nc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `_create_cells` method is basically the same as the `create_n_BallAndStick` function in the previous part of the tutorial; the only difference is that the cells are stored in `self._cells` instead of being returned. `_connect_cells` is shorter than the previous version because it can take advantage of the existing synapses and lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test the network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make a `Ring` object with 5 cells, render it using NEURON's built-in graphics, and run a simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-23T00:18:52.581582Z",
     "iopub.status.busy": "2025-05-23T00:18:52.581279Z",
     "iopub.status.idle": "2025-05-23T00:18:52.584305Z",
     "shell.execute_reply": "2025-05-23T00:18:52.583988Z"
    }
   },
   "outputs": [],
   "source": [
    "ring = Ring(N=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now to check that it is constructed correctly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-23T00:18:52.585737Z",
     "iopub.status.busy": "2025-05-23T00:18:52.585482Z",
     "iopub.status.idle": "2025-05-23T00:18:52.589191Z",
     "shell.execute_reply": "2025-05-23T00:18:52.588860Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape_window = h.PlotShape(True)\n",
    "shape_window.show(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks good so far; let's run the simulation and record time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-23T00:18:52.590803Z",
     "iopub.status.busy": "2025-05-23T00:18:52.590505Z",
     "iopub.status.idle": "2025-05-23T00:18:52.603182Z",
     "shell.execute_reply": "2025-05-23T00:18:52.602875Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = h.Vector().record(h._ref_t)\n",
    "h.finitialize(-65 * mV)\n",
    "h.continuerun(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that if we are running in Jupyter to make a plot appear inline we must:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-23T00:18:52.604560Z",
     "iopub.status.busy": "2025-05-23T00:18:52.604270Z",
     "iopub.status.idle": "2025-05-23T00:18:52.929308Z",
     "shell.execute_reply": "2025-05-23T00:18:52.928909Z"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now plot the trace of cell 0's soma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-23T00:18:52.931167Z",
     "iopub.status.busy": "2025-05-23T00:18:52.930922Z",
     "iopub.status.idle": "2025-05-23T00:18:53.006101Z",
     "shell.execute_reply": "2025-05-23T00:18:53.005703Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(t, ring.cells[0].soma_v)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cell 0 looks good. Let's look at the raster diagram:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-23T00:18:53.008110Z",
     "iopub.status.busy": "2025-05-23T00:18:53.007821Z",
     "iopub.status.idle": "2025-05-23T00:18:53.061272Z",
     "shell.execute_reply": "2025-05-23T00:18:53.060927Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "for i, cell in enumerate(ring.cells):\n",
    "    plt.vlines(list(cell.spike_times), i + 0.5, i + 1.5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Explore effects of parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compare two simulations: one with the same parameters as above, which we'll plot in black, and one with half the synaptic weight, which we'll plot in red:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-23T00:18:53.063154Z",
     "iopub.status.busy": "2025-05-23T00:18:53.062997Z",
     "iopub.status.idle": "2025-05-23T00:18:53.145976Z",
     "shell.execute_reply": "2025-05-23T00:18:53.145575Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "for syn_w, color in [(0.01, \"black\"), (0.005, \"red\")]:\n",
    "    ring = Ring(N=5, syn_w=syn_w)\n",
    "    h.finitialize(-65 * mV)\n",
    "    h.continuerun(100 * ms)\n",
    "    for i, cell in enumerate(ring.cells):\n",
    "        plt.vlines(list(cell.spike_times), i + 0.5, i + 1.5, color=color)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In both simulations, the first spike occurs at 10.925 ms. After that, the red spikes lag the black ones by steadily increasing amounts."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next part of the tutorial will translate this serial model into a parallel model. That part will not work in Jupyter and must be run from a terminal."
   ]
  }
 ],
 "metadata": {
  "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.12.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}