{
 "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-08-18T03:35:45.605739Z",
     "iopub.status.busy": "2025-08-18T03:35:45.605024Z",
     "iopub.status.idle": "2025-08-18T03:35:46.008563Z",
     "shell.execute_reply": "2025-08-18T03:35:46.008139Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from neuron import n, gui\n",
    "from neuron.units import ms, mV\n",
    "\n",
    "n.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-08-18T03:35:46.074578Z",
     "iopub.status.busy": "2025-08-18T03:35:46.071721Z",
     "iopub.status.idle": "2025-08-18T03:35:46.084374Z",
     "shell.execute_reply": "2025-08-18T03:35:46.083985Z"
    }
   },
   "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",
    "        n.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 = n.NetCon(self.soma(0.5)._ref_v, None, sec=self.soma)\n",
    "        self.spike_times = n.Vector()\n",
    "        self._spike_detector.record(self.spike_times)\n",
    "\n",
    "        self._ncs = []\n",
    "\n",
    "        self.soma_v = n.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 = n.cos(theta)\n",
    "                s = n.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-08-18T03:35:46.086054Z",
     "iopub.status.busy": "2025-08-18T03:35:46.085914Z",
     "iopub.status.idle": "2025-08-18T03:35:46.093364Z",
     "shell.execute_reply": "2025-08-18T03:35:46.092987Z"
    }
   },
   "outputs": [],
   "source": [
    "class BallAndStick(Cell):\n",
    "    name = \"BallAndStick\"\n",
    "\n",
    "    def _setup_morphology(self):\n",
    "        self.soma = n.Section(\"soma\", self)\n",
    "        self.dend = n.Section(\"dend\", 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(n.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(n.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 = n.ExpSyn(self.dend(0.5))\n",
    "        self.syn.tau = 2 * ms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Due to the nature of `n.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-08-18T03:35:46.095073Z",
     "iopub.status.busy": "2025-08-18T03:35:46.094926Z",
     "iopub.status.idle": "2025-08-18T03:35:46.102425Z",
     "shell.execute_reply": "2025-08-18T03:35:46.102037Z"
    }
   },
   "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 = n.NetStim()\n",
    "        self._netstim.number = 1\n",
    "        self._netstim.start = stim_t\n",
    "        self._nc = n.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 * n.PI / N\n",
    "            self.cells.append(\n",
    "                BallAndStick(i, n.cos(theta) * r, n.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 = n.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-08-18T03:35:46.105555Z",
     "iopub.status.busy": "2025-08-18T03:35:46.103933Z",
     "iopub.status.idle": "2025-08-18T03:35:46.155612Z",
     "shell.execute_reply": "2025-08-18T03:35:46.153328Z"
    }
   },
   "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-08-18T03:35:46.157409Z",
     "iopub.status.busy": "2025-08-18T03:35:46.157247Z",
     "iopub.status.idle": "2025-08-18T03:35:46.163096Z",
     "shell.execute_reply": "2025-08-18T03:35:46.162580Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape_window = n.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-08-18T03:35:46.165211Z",
     "iopub.status.busy": "2025-08-18T03:35:46.164635Z",
     "iopub.status.idle": "2025-08-18T03:35:46.197592Z",
     "shell.execute_reply": "2025-08-18T03:35:46.197010Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = n.Vector().record(n._ref_t)\n",
    "n.finitialize(-65 * mV)\n",
    "n.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-08-18T03:35:46.199099Z",
     "iopub.status.busy": "2025-08-18T03:35:46.198952Z",
     "iopub.status.idle": "2025-08-18T03:35:46.770594Z",
     "shell.execute_reply": "2025-08-18T03:35:46.770147Z"
    }
   },
   "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-08-18T03:35:46.773637Z",
     "iopub.status.busy": "2025-08-18T03:35:46.772915Z",
     "iopub.status.idle": "2025-08-18T03:35:46.981696Z",
     "shell.execute_reply": "2025-08-18T03:35:46.981287Z"
    }
   },
   "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, list(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-08-18T03:35:46.986051Z",
     "iopub.status.busy": "2025-08-18T03:35:46.985885Z",
     "iopub.status.idle": "2025-08-18T03:35:47.098186Z",
     "shell.execute_reply": "2025-08-18T03:35:47.097792Z"
    }
   },
   "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-08-18T03:35:47.101019Z",
     "iopub.status.busy": "2025-08-18T03:35:47.100860Z",
     "iopub.status.idle": "2025-08-18T03:35:47.292638Z",
     "shell.execute_reply": "2025-08-18T03:35:47.290463Z"
    }
   },
   "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",
    "    n.finitialize(-65 * mV)\n",
    "    n.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
}