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.
" ] }, { "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": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.020961Z", "iopub.status.busy": "2025-05-23T00:18:50.020823Z", "iopub.status.idle": "2025-05-23T00:18:50.318298Z", "shell.execute_reply": "2025-05-23T00:18:50.317882Z" } }, "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": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.320467Z", "iopub.status.busy": "2025-05-23T00:18:50.320237Z", "iopub.status.idle": "2025-05-23T00:18:50.325518Z", "shell.execute_reply": "2025-05-23T00:18:50.325162Z" } }, "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": 3, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.327852Z", "iopub.status.busy": "2025-05-23T00:18:50.327226Z", "iopub.status.idle": "2025-05-23T00:18:50.330699Z", "shell.execute_reply": "2025-05-23T00:18:50.330351Z" } }, "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", "\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": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.332671Z", "iopub.status.busy": "2025-05-23T00:18:50.332292Z", "iopub.status.idle": "2025-05-23T00:18:50.337050Z", "shell.execute_reply": "2025-05-23T00:18:50.336719Z" } }, "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" ] }, { "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 name of the class, the removal of the definition of self.all (now handled by the Cell class), and the change to the class declaration (the very first line) to indicate that BallAndStick is a type of Cell." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Adjusting position and orientation" ] }, { "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": 5, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.338944Z", "iopub.status.busy": "2025-05-23T00:18:50.338791Z", "iopub.status.idle": "2025-05-23T00:18:50.344048Z", "shell.execute_reply": "2025-05-23T00:18:50.343730Z" } }, "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(\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": [ "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": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.345588Z", "iopub.status.busy": "2025-05-23T00:18:50.345227Z", "iopub.status.idle": "2025-05-23T00:18:50.349064Z", "shell.execute_reply": "2025-05-23T00:18:50.348764Z" } }, "outputs": [], "source": [ "## Run only for jupyter\n", "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" ] }, { "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": 7, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.350322Z", "iopub.status.busy": "2025-05-23T00:18:50.350055Z", "iopub.status.idle": "2025-05-23T00:18:50.352591Z", "shell.execute_reply": "2025-05-23T00:18:50.352265Z" } }, "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": 8, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.353795Z", "iopub.status.busy": "2025-05-23T00:18:50.353595Z", "iopub.status.idle": "2025-05-23T00:18:50.355650Z", "shell.execute_reply": "2025-05-23T00:18:50.355357Z" } }, "outputs": [], "source": [ "del mycell" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Construct and position our cells" ] }, { "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": 9, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.356937Z", "iopub.status.busy": "2025-05-23T00:18:50.356634Z", "iopub.status.idle": "2025-05-23T00:18:50.359230Z", "shell.execute_reply": "2025-05-23T00:18:50.358945Z" } }, "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": 10, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.360448Z", "iopub.status.busy": "2025-05-23T00:18:50.360176Z", "iopub.status.idle": "2025-05-23T00:18:50.363293Z", "shell.execute_reply": "2025-05-23T00:18:50.362977Z" } }, "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": 11, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.364898Z", "iopub.status.busy": "2025-05-23T00:18:50.364538Z", "iopub.status.idle": "2025-05-23T00:18:50.367356Z", "shell.execute_reply": "2025-05-23T00:18:50.367062Z" } }, "outputs": [ { "data": { "text/plain": [ "1.0" ] }, "execution_count": 11, "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": 12, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.368637Z", "iopub.status.busy": "2025-05-23T00:18:50.368437Z", "iopub.status.idle": "2025-05-23T00:18:50.371705Z", "shell.execute_reply": "2025-05-23T00:18:50.371400Z" } }, "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": [ "## A first synapse, and input via a NetStim" ] }, { "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 NetCons. 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 NetStim 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 (ExpSyn) that behaves much like an AMPA synapse – it conducts current as a decaying exponential function." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.372946Z", "iopub.status.busy": "2025-05-23T00:18:50.372811Z", "iopub.status.idle": "2025-05-23T00:18:50.376000Z", "shell.execute_reply": "2025-05-23T00:18:50.375675Z" } }, "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": 14, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.377581Z", "iopub.status.busy": "2025-05-23T00:18:50.377163Z", "iopub.status.idle": "2025-05-23T00:18:50.379625Z", "shell.execute_reply": "2025-05-23T00:18:50.379295Z" } }, "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": 15, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.380945Z", "iopub.status.busy": "2025-05-23T00:18:50.380817Z", "iopub.status.idle": "2025-05-23T00:18:50.383111Z", "shell.execute_reply": "2025-05-23T00:18:50.382834Z" } }, "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": [ "## Running and plotting a simulation" ] }, { "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": [ "### Recording" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.384521Z", "iopub.status.busy": "2025-05-23T00:18:50.384188Z", "iopub.status.idle": "2025-05-23T00:18:50.387212Z", "shell.execute_reply": "2025-05-23T00:18:50.386882Z" } }, "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": [ "### Simulating" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.388676Z", "iopub.status.busy": "2025-05-23T00:18:50.388293Z", "iopub.status.idle": "2025-05-23T00:18:50.394242Z", "shell.execute_reply": "2025-05-23T00:18:50.393929Z" } }, "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": [ "### Plotting" ] }, { "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": 18, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.395754Z", "iopub.status.busy": "2025-05-23T00:18:50.395488Z", "iopub.status.idle": "2025-05-23T00:18:50.715637Z", "shell.execute_reply": "2025-05-23T00:18:50.715236Z" } }, "outputs": [], "source": [ "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "execution": { "iopub.execute_input": "2025-05-23T00:18:50.717686Z", "iopub.status.busy": "2025-05-23T00:18:50.717407Z", "iopub.status.idle": "2025-05-23T00:18:50.802271Z", "shell.execute_reply": "2025-05-23T00:18:50.801946Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "