diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8ca7523 --- /dev/null +++ b/.gitignore @@ -0,0 +1,25 @@ +# Python cache +__pycache__/ +*.pyc +*.pyo +*.pyd + +# VS Code settings +.vscode/ + +# Generated figures (optional - remove if you want to track them) +figures/* +!figures/.gitkeep + +# NEURON compiled mechanisms +channels/x86_64/ +*.o +*.lo +*.la +.libs/ + +# Other common patterns +*.swp +*.swo +*~ +.DS_Store \ No newline at end of file diff --git a/SYLLABUS_MAPPING.md b/SYLLABUS_MAPPING.md new file mode 100644 index 0000000..63cf930 --- /dev/null +++ b/SYLLABUS_MAPPING.md @@ -0,0 +1,73 @@ +# Syllabus Mapping: Workshop Demo Cells to Weekly Goals + +--- + +## Cell 1 -- Imports + +Syllabus connection: +- Week 2: Python and conda setup. Install Brian2 via conda, set up environment. +- Week 5: Open science workflow. The environment.yml pins all dependency versions. + +--- + +## Cell 2 -- Neuron Equations (Gunay et al. 2015 kinetics) + +Syllabus connection: +- Week 3: Brian2 basics. Differential equations, NeuronGroup, how simulators step through time. +- Week 4: Reading the paper. Parameters come from Table 1, channel kinetics from Gunay et al. (2015). These are Boltzmann steady-state formulations, not classic HH alpha/beta. + +--- + +## Cell 3 -- Neuron Groups (GF, TTMn, PSI, DLMn) + +Syllabus connection: +- Week 3: Brian2 basics. NeuronGroup is the basic building block. Initial conditions from steady-state at resting potential. +- Week 4: Paper reading. Figure 2A shows the four-cell architecture: GF, TTMn, PSI, DLMn. Each cell has a defined role in the escape pathway. +- Week 6: Building the model. The single-compartment version here is the starting skeleton. The paper uses multi-compartment neurons (1-3 sections, 51 segments each). + +--- + +## Cell 4 -- Synapses (gap junctions + chemical synapse) + +Syllabus connection: +- Week 4: Paper reading. The paper emphasizes that gap junction conductance reduction with age accounts for increased escape latency. g_gap young = 135 uS, old = 34.5 uS. +- Week 6: Building the model. Three connections: two gap junctions (GF->TTMn, GF->PSI) and one chemical synapse (PSI->DLMn with double-exponential kinetics). + +--- + +## Cell 5 -- Stimulus and Simulation + +Syllabus connection: +- Week 3: Brian2 simulation mechanics. Network construction, network_operation for stimulus injection, run() method. +- Week 6: First simulation run. Apply stimulus to GF and propagate through the circuit. + +--- + +## Cell 6 -- Latency Measurement + +Syllabus connection: +- Week 4: Paper reading. The paper measures latency as time from stimulus to AP peak, plus 0.35 ms NMJ delay. Experimental values: young TTM = 0.93 ms, DLM = 1.44 ms; old TTM = 1.22 ms, DLM = 1.85 ms. +- Week 7 (future): Refine latency measurement. Compare model output to paper values and debug discrepancies. + +--- + +## Cell 7 -- Voltage Traces + +Syllabus connection: +- Week 2: Basic plotting with matplotlib. +- Week 6: Validate model behavior visually. Signal propagation order: GF -> TTMn/PSI -> DLMn. + +--- + +## Cells 8-9 -- Parameter Sweep and Latency Plot + +Syllabus connection: +- Week 6: Parameter exploration. Sweep g_gap and observe the latency trend. +- Week 8 (future): Reproduce Figure 2C quantitatively. Explore additional parameters (Na/K conductances, Figure 3; anatomic changes, Figure 4). +- Week 9 (future): Compare sweep output to the published latency curves. + +--- + +## Cell 10 -- Summary + +Maps all cells to syllabus weeks 1-6 and lists remaining work for weeks 7-11. diff --git a/contributors/Gillian-Durta.md b/contributors/Gillian-Durta.md new file mode 100644 index 0000000..e69de29 diff --git a/contributors/bianca-blevins.md b/contributors/bianca-blevins.md new file mode 100644 index 0000000..caf7bb6 --- /dev/null +++ b/contributors/bianca-blevins.md @@ -0,0 +1,4 @@ +Name: Bianca Blevins +Major: Computer Science +Role: Members +Hobbies: Photography, hiking, and video games \ No newline at end of file diff --git a/contributors/cooper-wherley.md b/contributors/cooper-wherley.md new file mode 100644 index 0000000..e69de29 diff --git a/contributors/jonathan-alcineus.md b/contributors/jonathan-alcineus.md new file mode 100644 index 0000000..7f665fa --- /dev/null +++ b/contributors/jonathan-alcineus.md @@ -0,0 +1,6 @@ +# Jonathan Alcineus + +Name: Jonathan Alcineus +Major: Post-Bacc (Graduated with Computer Science and Statistics major) +Role: Lead Research Intern +Hobbies: Surviving diff --git a/contributors/sebastian-davalos.md b/contributors/sebastian-davalos.md new file mode 100644 index 0000000..e69de29 diff --git a/contributors/template.md b/contributors/template.md new file mode 100644 index 0000000..e69de29 diff --git a/environment.yml b/environment.yml new file mode 100644 index 0000000..450cb7e --- /dev/null +++ b/environment.yml @@ -0,0 +1,9 @@ +name: neuron2018 +channels: + - conda-forge + - https://repo.anaconda.com/pkgs/main + - https://repo.anaconda.com/pkgs/r +dependencies: + - matplotlib + - ipykernel + - brian2 diff --git a/gfs_param_scan_conductances.py b/gfs_param_scan_conductances.py index 721e066..7d093bd 100644 --- a/gfs_param_scan_conductances.py +++ b/gfs_param_scan_conductances.py @@ -46,7 +46,7 @@ param1 = 'g_gap' param2s = ['gnatbar', 'gkbar', 'gleak'] -fig1 = plt.figure() +fig1 = plt.figure(figsize=(15, 10)) # Width, height in inches ii = 1 for p2 in param2s: @@ -57,14 +57,17 @@ y_young = g.params[param1] y_old = old_g_gap - x_young = (double(len(ranges[param2])) - 1.) * (x_young - ranges[param2][0]) / (ranges[param2][-1] - ranges[param2][0]) - y_young = (double(len(ranges[param1])) - 1.) * (y_young - ranges[param1][0]) / (ranges[param1][-1] - ranges[param1][0]) - y_old = (double(len(ranges[param1])) - 1.) * (y_old - ranges[param1][0]) / (ranges[param1][-1] - ranges[param1][0]) + + # 2026 + # added call to np name space to make sure the division is done in double precision, otherwise it can cause overflow when multiplying by the length of the range + x_young = (np.double(len(ranges[param2])) - 1.) * (x_young - ranges[param2][0]) / (ranges[param2][-1] - ranges[param2][0]) + y_young = (np.double(len(ranges[param1])) - 1.) * (y_young - ranges[param1][0]) / (ranges[param1][-1] - ranges[param1][0]) + y_old = (np.double(len(ranges[param1])) - 1.) * (y_old - ranges[param1][0]) / (ranges[param1][-1] - ranges[param1][0]) delay_dict = g.param_mesh(param1, ranges[param1], param2, ranges[param2]) - delay_dict['DLMn_delays'][delay_dict['DLMn_delays']==-1] = nan - delay_dict['TTMn_delays'][delay_dict['TTMn_delays']==-1] = nan + delay_dict['DLMn_delays'][delay_dict['DLMn_delays']==-1] = np.nan + delay_dict['TTMn_delays'][delay_dict['TTMn_delays']==-1] = np.nan tcks = np.linspace(np.min(delay_dict['TTMn_delays']), np.max(delay_dict['TTMn_delays']), 20) @@ -107,4 +110,9 @@ plt.scatter([x_young], [y_young]) plt.scatter([x_young], [y_old]) - ii += 1 \ No newline at end of file + + ii += 1 +# 2026 +# Added savefig line to save the figure after running in command line +plt.tight_layout() +plt.savefig('gfs_param_scan_conductances_' + param2 + '.png') \ No newline at end of file diff --git a/readme b/readme index f8b723e..dabd8bb 100644 --- a/readme +++ b/readme @@ -1,37 +1,101 @@ -Model files from the manuscript: +# Fork Escape Response -Augustin, H, Zylbertal, A and Partridge L, "A computational model of the escape latency in the Giant Fiber System of D. melanogaster" (preprint) -The file gfs_param_scan_conductances.py reproduces the protocol used -in Fig. 3 of the article by calling the module gfpn.py. +This repository is a fork of the 2019 eNeuron paper model: -Questions on how to use this model should be directed to +"A Computational Model of the Escape Response Latency in the Giant Fiber System of Drosophila melanogaster" +by Augustin H, Zylbertal A, and Partridge L + +The purpose of this fork is to create a shared starting point for the Spring 2026 Pena Lab Project Team to work toward reproducing the paper using Brian2. + +We installed `neuron=7.5.0` because it was released around the time of the original paper and was the earliest version that worked on WSL during testing. + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +## Model files from the manuscript + +Augustin H, Zylbertal A, and Partridge L +"A computational model of the escape latency in the Giant Fiber System of D. melanogaster" (preprint) + +The file `gfs_param_scan_conductances.py` reproduces the protocol used in Figure 3 of the article by calling the module `gfpn.py`. + +Questions about how to use the original model should be directed to: asaph.zylbertal at mail.huji.ac.il -Synopsis: - -The Giant Fiber System (GFS) is a multi-component neuronal pathway mediating rapid escape -response in adult fruit-fly Drosophila melanogaster, usually in the face of a threatening visual -stimulus. Two branches of the circuit promote the response by stimulating an escape jump -followed by flight initiation. Our recent work demonstrated an age-associated decline in the -speed of signal propagation through the circuit, likely due to the diminishing number of gap -junctions between its components in ageing flies. In this work, we generated a realistic -conductance-based computational model of the GFS that recapitulates our experimental -results and identifies some of the critical anatomical and physiological components governing -the response latency of the circuit. Overall, anatomical properties of the GFS neurons have a -stronger impact on the transmission speed compared to the effect of changes in neuronal -membrane conductance densities. Our model and provides testable predictions for improving -the circuit’s performance in ageing animals by means of experimental interventions. - -This example protocol plots the GFS latency as a function of gap junction conductance and: -1) Transient voltage gated sodium conductance -2) Voltage gated potassium conductance -3) Leak conductance - -Example use: - -Extract the archive, run nrnivmodl in the channels directory -(linux/unix) or mknrndll (mswin or mac os x) (see +## Synopsis + +The Giant Fiber System (GFS) is a multi-component neuronal pathway that mediates rapid escape responses in adult fruit fly Drosophila melanogaster, usually in response to a threatening visual stimulus. Two branches of the circuit promote the response by stimulating an escape jump followed by flight initiation. + +Prior work showed an age-associated decline in the speed of signal propagation through the circuit, likely due to a diminishing number of gap junctions between circuit components in aging flies. This model reproduces those experimental results and identifies several critical anatomical and physiological components that influence response latency. + +Overall, the model suggests that anatomical properties of GFS neurons have a stronger effect on transmission speed than changes in neuronal membrane conductance densities. The model also provides testable predictions for improving circuit performance in aging animals through experimental intervention. + +## Example protocol + +This protocol plots GFS latency as a function of gap junction conductance and: + +1. Transient voltage-gated sodium conductance +2. Voltage-gated potassium conductance +3. Leak conductance + +## Example use + +Extract the archive, then compile the channels in the `channels` directory. + +- On Linux/Unix, run `nrnivmodl` +- On Windows or macOS, run `mknrndll` + +For more help with compiling NEURON channel mechanisms: http://senselab.med.yale.edu/ModelDB/NEURON_DwnldGuide.html -for more help) to compile the channels, and run the file -gfs_param_scan_conductances.py. After a while, it will plot -the latency maps. + +After compiling the channels, run: + +`gfs_param_scan_conductances.py` + +After some time, the script will generate the latency maps. + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +## Contributors + +Each project member should create their own file in the `contributors` folder instead of editing one shared contributor file. This helps reduce merge conflicts. + +### Contributor steps + +1. Pull the latest version of the repo +2. Create a new file in the `contributors` folder using the template +3. Name the file with your own name +4. Fill out your information +5. Commit and push your changes + +### Contributor file format + +Name: +Major: +Role: +Hobbies: + +### Suggested file name + +`contributors/your-name.md` + +Example: +`contributors/sebastian-davalos.md` + +### Example workflow + +Pull the latest changes: + +`git pull origin master` + +Create your file in the `contributors` folder and fill it out using the template. + +Then run: + +`git add contributors/your-name.md` +`git commit -m "Add contributor profile for Your Name"` +`git push origin master` + +If your push is rejected, pull the latest changes and try again: + +`git pull origin master` +`git push origin master` \ No newline at end of file diff --git a/workshop_demo.ipynb b/workshop_demo.ipynb new file mode 100644 index 0000000..f082152 --- /dev/null +++ b/workshop_demo.ipynb @@ -0,0 +1,1084 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4640934c", + "metadata": {}, + "source": [ + "# Escape Response Latency in the *Drosophila* Giant Fiber System\n", + "\n", + "Workshop 3 -- Pena Lab Project -- Spring 2026\n", + "\n", + "This notebook walks through a simplified Brian2 model of the *Drosophila melanogaster* giant fiber system (GFS), based on Augustin, Zylbertal & Partridge (eNeuro, 2019). The original paper was implemented in NEURON; our project goal is to replicate it in Brian2.\n", + "\n", + "Latency = time from stimulus at the giant fiber to motor neuron activation.\n", + "\n", + "### What this notebook covers\n", + "1. Environment setup and imports (Weeks 1-2)\n", + "2. Neuron equations from the paper (Week 3 / Brian2 basics)\n", + "3. GFS circuit: GF, TTMn, PSI, DLMn connected by gap junctions and a chemical synapse (Week 4 / paper reading)\n", + "4. Stimulus, simulation, and latency measurement (Week 6 / model building)\n", + "5. Parameter exploration: how g_gap affects latency (Weeks 7-8 preview)" + ] + }, + { + "cell_type": "markdown", + "id": "af916935", + "metadata": {}, + "source": [ + "---\n", + "## 1 -- Imports and Environment\n", + "\n", + "Brian2 is a Python-based neural simulator. We also use NumPy and Matplotlib.\n", + "\n", + "To set up your environment: `conda env create -f environment.yml`, then `conda activate `." + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "03cfe0a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Brian2 version: 2.4.2\n" + ] + } + ], + "source": [ + "# --- Brian2 Imports ---\n", + "#\n", + "# \"import brian2\" loads the library as a module.\n", + "# \"from brian2 import *\" dumps ALL Brian2 names (mV, ms, NeuronGroup, etc.)\n", + "# into the current namespace so you can use them directly without typing\n", + "# \"brian2.mV\" every time. This is the standard way to use Brian2.\n", + "import brian2\n", + "from brian2 import *\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Brian2 can compile equations to C++ (fast) or use pure NumPy (slower but\n", + "# always works). We pick 'numpy' here because it does not need a C compiler.\n", + "# If you have a compiler installed, try 'cython' for faster simulations.\n", + "brian2.prefs.codegen.target = 'numpy'\n", + "\n", + "# Tell Jupyter to show plots directly in the notebook\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (12, 4)\n", + "plt.rcParams['font.size'] = 12\n", + "\n", + "print(f'Brian2 version: {brian2.__version__}')" + ] + }, + { + "cell_type": "markdown", + "id": "862dbbef", + "metadata": {}, + "source": [ + "---\n", + "## 2 -- Neuron Equations\n", + "\n", + "The paper (Augustin et al., 2019) uses channel kinetics from Gunay et al. (2015). These are *not* classic Hodgkin-Huxley alpha/beta equations -- they use Boltzmann steady-state activation and voltage-dependent time constants.\n", + "\n", + "Channels in the original NEURON model:\n", + "- **Transient Na (nat):** $g_{Na_t} \\cdot m^3 h \\cdot (V - E_{Na})$, with Boltzmann $m_\\infty$, $h_\\infty$ and voltage-dependent $\\tau_m$, $\\tau_h$\n", + "- **Persistent Na (nap):** $g_{Na_p} \\cdot m \\cdot (V - E_{Na})$, Boltzmann $m_\\infty$, constant $\\tau_m = 1$ ms\n", + "- **Potassium (k):** $g_K \\cdot m \\cdot (V - E_K)$, Boltzmann $m_\\infty$, constant $\\tau_m = 1$ ms (note: single gate, not $m^4$)\n", + "- **Leak (pas):** $g_L \\cdot (V - E_L)$\n", + "\n", + "Parameters from Table 1 of the paper." + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "710f67c4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Neuron equations defined (Gunay et al., 2015 kinetics).\n" + ] + } + ], + "source": [ + "# --- Brian2 Concept: start_scope() ---\n", + "#\n", + "# start_scope() resets Brian2's internal list of objects. Without it, if you\n", + "# re-run cells, Brian2 would try to include objects from previous runs and\n", + "# throw errors. Always call it at the top of a new simulation.\n", + "start_scope()\n", + "\n", + "# --- Brian2 Concept: Physical Units ---\n", + "#\n", + "# Brian2 has a built-in unit system. When you write \"65 * mV\", Brian2 creates\n", + "# a Quantity object that knows it is in millivolts. If you later try to add\n", + "# mV to ms, Brian2 will raise an error. This catches bugs early.\n", + "#\n", + "# Common units used here:\n", + "# mV = millivolts (voltage)\n", + "# ms = milliseconds (time)\n", + "# uF / cm**2 = microfarads per square centimeter (capacitance density)\n", + "# msiemens / cm**2 = millisiemens per square centimeter (conductance density)\n", + "#\n", + "# The \"**\" is Python's power operator: cm**2 means cm-squared.\n", + "# Brian2 reads \"uF / cm**2\" as microfarads divided by centimeters-squared.\n", + "\n", + "# Parameters from Table 1 (Augustin et al., 2019; Gunay et al., 2015)\n", + "C_m = 1 * uF / cm**2 # membrane capacitance density\n", + "g_NaT = 300 * msiemens / cm**2 # transient sodium max conductance\n", + "g_NaP = 0.11 * msiemens / cm**2 # persistent sodium max conductance\n", + "g_K = 10 * msiemens / cm**2 # potassium max conductance\n", + "g_L = 0.03 * msiemens / cm**2 # leak conductance\n", + "E_Na = 65 * mV # sodium reversal potential\n", + "E_K = -74 * mV # potassium reversal potential\n", + "E_L = -85 * mV # leak reversal potential\n", + "\n", + "# --- Brian2 Concept: Equation Strings ---\n", + "#\n", + "# In Brian2, you define neuron behavior as a multi-line Python string.\n", + "# Each line is one equation. Brian2 parses this string and builds the\n", + "# differential equation system automatically.\n", + "#\n", + "# SYNTAX RULES for equation strings:\n", + "#\n", + "# 1) Differential equations use the form:\n", + "# dv/dt = (some expression) : unit\n", + "# The \"d...dt\" tells Brian2 this variable changes over time.\n", + "# The \": unit\" after the colon declares what unit the variable has.\n", + "# For voltage: \": volt\". For dimensionless gating variables: \": 1\".\n", + "#\n", + "# 2) Static equations (computed each timestep, not integrated) look like:\n", + "# minf_NaT = 1.0 / (1.0 + exp(...)) : 1\n", + "# No \"d/dt\" means Brian2 recalculates it every timestep from current v.\n", + "#\n", + "# 3) Parameters (values set from Python, not computed by equations):\n", + "# I_syn : amp/meter**2\n", + "# No equals sign means this is a parameter you control from outside.\n", + "# Brian2 will not update it -- you or a synapse sets its value.\n", + "#\n", + "# 4) Inside the string, you can use variables defined earlier in Python\n", + "# (like g_NaT, E_Na) because Brian2 looks them up in the namespace.\n", + "# Math functions like exp() are provided by Brian2 automatically.\n", + "#\n", + "# 5) \"v/mV\" divides the voltage by millivolts to get a plain number.\n", + "# This is needed when the Boltzmann equation expects a dimensionless\n", + "# argument inside exp(). Brian2 would complain if you passed mV into exp().\n", + "\n", + "neuron_eqs = '''\n", + " dv/dt = (-g_NaT*m_NaT**3*h_NaT*(v - E_Na)\n", + " -g_NaP*m_NaP*(v - E_Na)\n", + " -g_K*m_K*(v - E_K)\n", + " -g_L*(v - E_L)\n", + " + I_syn + I_ext) / C_m : volt\n", + "\n", + " # Transient Na activation gate (m). Boltzmann steady-state with\n", + " # voltage-dependent time constant. v1_2 = -29.13 mV, slope k = -8.92 mV.\n", + " # Negative k means the gate OPENS (goes toward 1) at more positive voltages.\n", + " dm_NaT/dt = (minf_NaT - m_NaT) / mtau_NaT : 1\n", + " minf_NaT = 1.0 / (1.0 + exp((v/mV + 29.13) / (-8.92))) : 1\n", + " mtau_NaT = (0.13 + 3.43 / (1.0 + exp((v/mV + 45.35) / 5.98))) * ms : second\n", + "\n", + " # Transient Na inactivation gate (h). Positive k = +5 means the gate\n", + " # CLOSES (goes toward 0) at more positive voltages.\n", + " dh_NaT/dt = (hinf_NaT - h_NaT) / htau_NaT : 1\n", + " hinf_NaT = 1.0 / (1.0 + exp((v/mV + 47.0) / 5.0)) : 1\n", + " htau_NaT = (0.36 + exp((v/mV + 20.65) / -10.47)) * ms : second\n", + "\n", + " # Persistent Na activation: same Boltzmann form, fixed 1 ms time constant\n", + " dm_NaP/dt = (minf_NaP - m_NaP) / tau_NaP : 1\n", + " minf_NaP = 1.0 / (1.0 + exp((v/mV + 48.77) / (-3.68))) : 1\n", + " tau_NaP = 1.0 * ms : second\n", + "\n", + " # Potassium activation: single gate (not m**4), fixed 1 ms time constant\n", + " dm_K/dt = (minf_K - m_K) / tau_K : 1\n", + " minf_K = 1.0 / (1.0 + exp((v/mV + 12.85) / (-19.91))) : 1\n", + " tau_K = 1.0 * ms : second\n", + "\n", + " # These are parameters -- their values come from synapses or Python code,\n", + " # not from a differential equation. Brian2 will not update them on its own.\n", + " I_syn : amp/meter**2\n", + " I_ext : amp/meter**2\n", + "'''\n", + "\n", + "print('Neuron equations defined (Gunay et al., 2015 kinetics).')" + ] + }, + { + "cell_type": "markdown", + "id": "6ee1af09", + "metadata": {}, + "source": [ + "---\n", + "## 3 -- GFS Circuit Architecture\n", + "\n", + "From Figure 2A of the paper, the giant fiber system has four cells:\n", + "- **GF** (giant fiber): receives stimulus, relays signal via electrical synapses\n", + "- **TTMn** (TTM motor neuron): drives the jump muscle, receives gap junction from GF\n", + "- **PSI** (peripherally synapsing interneuron): receives gap junction from GF\n", + "- **DLMn** (DLM motor neuron): drives the flight muscle, receives chemical synapse from PSI\n", + "\n", + "In the original NEURON model each cell has multiple compartments. Here we simplify to single-compartment neurons to focus on the circuit-level behavior.\n", + "\n", + "Gap junctions are electrical synapses where current flows proportional to the voltage difference:\n", + "$I_{gap} = g_{gap} \\cdot (V_{pre} - V_{post})$\n", + "\n", + "The PSI-to-DLMn synapse is chemical (modeled as a double-exponential conductance)." + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "ccbdd15a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Created neuron groups: GF, TTMn, PSI, DLMn\n", + "Resting potential: -0.065\n" + ] + } + ], + "source": [ + "# --- Brian2 Concept: NeuronGroup ---\n", + "#\n", + "# NeuronGroup is the core object in Brian2. It represents a population of\n", + "# neurons that all share the same equations but can have different states.\n", + "#\n", + "# NeuronGroup(N, equations, threshold, refractory, method, dt)\n", + "# N = number of neurons in this group. We use 1 per cell here.\n", + "# equations = the equation string we defined above (neuron_eqs).\n", + "# threshold = a string condition. When this becomes True, Brian2 records\n", + "# a \"spike event\". Here: 'v > -20*mV' means a spike is\n", + "# detected when voltage crosses -20 mV.\n", + "# refractory = after a spike, the neuron is \"locked\" for this duration\n", + "# and cannot fire again. Prevents double-counting spikes.\n", + "# method = the numerical integration method. 'euler' is the simplest:\n", + "# it steps forward by dt each timestep. Good enough for small dt.\n", + "# dt = the simulation timestep. 0.01*ms = 10 microseconds.\n", + "# Smaller dt = more accurate but slower. 0.01 ms is standard\n", + "# for fast spiking neurons.\n", + "\n", + "# Create one NeuronGroup per cell in the circuit (4 total)\n", + "GF = NeuronGroup(1, neuron_eqs, threshold='v > -20*mV', refractory=2*ms,\n", + " method='euler', dt=0.01*ms)\n", + "TTMn = NeuronGroup(1, neuron_eqs, threshold='v > -20*mV', refractory=2*ms,\n", + " method='euler', dt=0.01*ms)\n", + "PSI = NeuronGroup(1, neuron_eqs, threshold='v > -20*mV', refractory=2*ms,\n", + " method='euler', dt=0.01*ms)\n", + "DLMn = NeuronGroup(1, neuron_eqs, threshold='v > -20*mV', refractory=2*ms,\n", + " method='euler', dt=0.01*ms)\n", + "\n", + "# --- Brian2 Concept: Setting Initial Conditions ---\n", + "#\n", + "# After creating a NeuronGroup, all state variables start at 0 by default.\n", + "# You set initial values by assigning to group.variable_name directly.\n", + "# For example, \"GF.v = -65 * mV\" sets the voltage of all neurons in group GF.\n", + "# You MUST include the unit (here, mV) or Brian2 will raise an error.\n", + "#\n", + "# For gating variables (m_NaT, h_NaT, etc.), we compute their steady-state\n", + "# value at resting voltage (-65 mV) using the Boltzmann formula. This avoids\n", + "# a transient at the start where gates slowly relax to their resting values.\n", + "# We use np.exp (NumPy) instead of exp (Brian2) because we are outside the\n", + "# equation string. Brian2's exp() only works inside equation strings.\n", + "\n", + "V_rest = -65 * mV\n", + "for group in [GF, TTMn, PSI, DLMn]:\n", + " group.v = V_rest\n", + " group.m_NaT = 1.0 / (1.0 + np.exp((-65.0 + 29.13) / (-8.92))) # ~0.018\n", + " group.h_NaT = 1.0 / (1.0 + np.exp((-65.0 + 47.0) / 5.0)) # ~0.973\n", + " group.m_NaP = 1.0 / (1.0 + np.exp((-65.0 + 48.77) / (-3.68))) # ~0.012\n", + " group.m_K = 1.0 / (1.0 + np.exp((-65.0 + 12.85) / (-19.91))) # ~0.068\n", + "\n", + "print('Created neuron groups: GF, TTMn, PSI, DLMn')\n", + "print(f'Resting potential: {V_rest}')" + ] + }, + { + "cell_type": "markdown", + "id": "e2a356cc", + "metadata": {}, + "source": [ + "---\n", + "## 4 -- Gap Junctions and Chemical Synapse\n", + "\n", + "From the paper's NEURON code (`gap2.mod`), the gap junction parameter `g` is declared in **nanosiemens (nS)** with the equation `i = (v - vgap) * g * 0.001` (the 0.001 converts nS·mV to nA). Note: the paper's Figure 2C axis and plotting code label this as µS, but the MOD file and dimensional analysis confirm nS.\n", + "\n", + "- Young fly: g_gap = 135 nS\n", + "- Old fly: g_gap = 34.5 nS (a ~4-fold reduction)\n", + "\n", + "Since Brian2 uses current densities (A/m²), we convert absolute conductance to density by dividing by each cell's total membrane area (computed from Table 1 dimensions). Gap junctions are unidirectional: GF drives TTMn and PSI. The PSI-DLMn connection is a chemical synapse (double-exponential, matching NEURON's `Exp2Syn`)." + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "1a4860b4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Synapses created:\n", + " GF -> TTMn (gap junction, g_gap = 135 nS, density = 5.12 mS/cm^2)\n", + " GF -> PSI (gap junction, g_gap = 135 nS, density = 3.67 mS/cm^2)\n", + " PSI -> DLMn (chemical synapse, w_peak = 7.3 mS/cm^2, delay = 0.15 ms)\n" + ] + } + ], + "source": [ + "# --- Unit Conversion Setup ---\n", + "#\n", + "# The paper's NEURON model uses absolute conductances (nanosiemens).\n", + "# Brian2's equations use conductance DENSITIES (siemens per meter-squared).\n", + "# To convert: density = absolute_conductance / membrane_area.\n", + "# We compute membrane area from Table 1 geometry: A = pi * diameter * length.\n", + "\n", + "# Membrane areas in cm^2 (the \"e-4\" converts micrometers to centimeters)\n", + "# TTMn: diameter 6 um, total length 140 um\n", + "A_TTMn_cm2 = np.pi * 6e-4 * 140e-4 # about 2639 um^2\n", + "# PSI: diameter 4.5 um, total length 260 um\n", + "A_PSI_cm2 = np.pi * 4.5e-4 * 260e-4 # about 3676 um^2\n", + "# DLMn: two cylindrical sections summed\n", + "A_DLMn_cm2 = np.pi * (3e-4 * 50e-4 + 2e-4 * 100e-4) # about 1100 um^2\n", + "\n", + "def nS_to_Sm2(g_nS, area_cm2):\n", + " \"\"\"Convert absolute conductance in nanosiemens to density in S/m^2.\"\"\"\n", + " # 1 nS = 1e-9 S. 1 cm^2 = 1e-4 m^2. So density = g*1e-9 / (area*1e-4).\n", + " return g_nS * 1e-9 / (area_cm2 * 1e-4)\n", + "\n", + "# Gap junction conductance -- the key parameter from the paper\n", + "# gap2.mod: g in nanosiemens. Young fly: 135 nS, Old fly: 34.5 nS\n", + "g_gap_nS = 135 # young fly default\n", + "\n", + "# Different cells have different membrane areas, so the same absolute\n", + "# conductance (135 nS) becomes a different density for TTMn vs PSI.\n", + "g_gap_TTMn_Sm2 = nS_to_Sm2(g_gap_nS, A_TTMn_cm2)\n", + "g_gap_PSI_Sm2 = nS_to_Sm2(g_gap_nS, A_PSI_cm2)\n", + "\n", + "# --- Brian2 Concept: Synapses ---\n", + "#\n", + "# Synapses(source, target, model=...) creates a synapse object.\n", + "# source = the presynaptic NeuronGroup (where the signal comes from)\n", + "# target = the postsynaptic NeuronGroup (where the signal goes to)\n", + "# model = an equation string describing the synapse's behavior\n", + "#\n", + "# After creating a Synapses object, you MUST call .connect() to actually\n", + "# wire neurons together. Without .connect(), no connections exist.\n", + "# Here, .connect() with no arguments connects every neuron in source\n", + "# to every neuron in target. Since each group has 1 neuron, this makes\n", + "# one connection.\n", + "#\n", + "# --- Brian2 Concept: Synapse Equation Keywords ---\n", + "#\n", + "# Inside synapse equations, Brian2 provides special variable names:\n", + "# v_pre = voltage of the presynaptic neuron (the source)\n", + "# v_post = voltage of the postsynaptic neuron (the target)\n", + "# You use these to compute current flow between neurons.\n", + "#\n", + "# The \"(summed)\" keyword at the end of a synapse equation means:\n", + "# \"Add up this value from ALL synapses arriving at the same target neuron\n", + "# and write the total into the target neuron's variable.\"\n", + "# Here, I_syn_post is a summed variable: it takes the gap junction current\n", + "# and feeds it into the target neuron's I_syn parameter.\n", + "# The \"_post\" suffix tells Brian2 which neuron group the variable belongs to.\n", + "\n", + "# We use Python f-strings to bake the computed density value directly into\n", + "# the equation string. The number replaces {g_gap_TTMn_Sm2} before Brian2\n", + "# ever sees the string.\n", + "gap_eqs_TTMn = f'''\n", + " I_syn_post = {g_gap_TTMn_Sm2} * siemens / meter**2 * (v_pre - v_post) : amp/meter**2 (summed)\n", + "'''\n", + "gap_eqs_PSI = f'''\n", + " I_syn_post = {g_gap_PSI_Sm2} * siemens / meter**2 * (v_pre - v_post) : amp/meter**2 (summed)\n", + "'''\n", + "\n", + "# Create the two gap junction connections\n", + "syn_GF_TTMn = Synapses(GF, TTMn, model=gap_eqs_TTMn)\n", + "syn_GF_TTMn.connect() # wire GF neuron 0 to TTMn neuron 0\n", + "\n", + "syn_GF_PSI = Synapses(GF, PSI, model=gap_eqs_PSI)\n", + "syn_GF_PSI.connect() # wire GF neuron 0 to PSI neuron 0\n", + "\n", + "# --- Brian2 Concept: Chemical Synapses with on_pre ---\n", + "#\n", + "# Chemical synapses are different from gap junctions: they are triggered by\n", + "# a presynaptic spike, not by continuous voltage difference.\n", + "#\n", + "# on_pre = 's += w_chem'\n", + "# This is a string of code that Brian2 executes whenever the presynaptic\n", + "# neuron fires a spike. Here it means: \"when PSI spikes, add w_chem to\n", + "# the synapse variable s\". This kick to s then decays and drives g_syn\n", + "# through the differential equations, producing a transient conductance.\n", + "#\n", + "# The \"(clock-driven)\" keyword tells Brian2 to integrate these synapse\n", + "# equations at every timestep using the ODE solver, not just at spike times.\n", + "# This is needed for smooth conductance dynamics (rise and decay).\n", + "\n", + "chem_eqs = '''\n", + " dg_syn/dt = -g_syn / tau_d + s : siemens/meter**2 (clock-driven)\n", + " ds/dt = -s / tau_r : siemens/meter**2/second (clock-driven)\n", + " I_syn_post = g_syn * (E_syn - v_post) : amp/meter**2 (summed)\n", + "'''\n", + "E_syn = 0 * mV # excitatory reversal potential (0 mV for glutamate)\n", + "tau_r = 0.1 * ms # rise time constant\n", + "tau_d = 1.0 * ms # decay time constant\n", + "\n", + "# Convert chemical synapse weight from absolute (80 nS) to density\n", + "g_peak_mScm2 = 80e-9 / (A_DLMn_cm2 * 1e-4) * 0.1 # S/m^2 -> mS/cm^2\n", + "w_chem = (g_peak_mScm2 / 0.0774) * msiemens / cm**2 / ms\n", + "\n", + "# Create the chemical synapse with on_pre action and explicit timestep\n", + "syn_PSI_DLMn = Synapses(PSI, DLMn, model=chem_eqs,\n", + " on_pre='s += w_chem', dt=0.01*ms)\n", + "syn_PSI_DLMn.connect()\n", + "\n", + "# --- Brian2 Concept: Synapse Delay ---\n", + "#\n", + "# syn.delay sets a time delay between when the presynaptic neuron fires\n", + "# and when the on_pre code executes. Models the travel time of the signal.\n", + "syn_PSI_DLMn.delay = 0.15 * ms # chemical synapse delay from Table 1\n", + "\n", + "print('Synapses created:')\n", + "print(f' GF -> TTMn (gap junction, g_gap = {g_gap_nS} nS, density = {g_gap_TTMn_Sm2*0.1:.2f} mS/cm^2)')\n", + "print(f' GF -> PSI (gap junction, g_gap = {g_gap_nS} nS, density = {g_gap_PSI_Sm2*0.1:.2f} mS/cm^2)')\n", + "print(f' PSI -> DLMn (chemical synapse, w_peak = {g_peak_mScm2:.1f} mS/cm^2, delay = 0.15 ms)')" + ] + }, + { + "cell_type": "markdown", + "id": "37422dec", + "metadata": {}, + "source": [ + "---\n", + "## 5 -- Stimulus and Simulation\n", + "\n", + "The paper stimulates the proximal end of the GF with 120 nA for 0.03 ms. For a single-compartment model the stimulus parameters need to be scaled to compensate for the reduced membrane area. Here we use a larger current density and longer pulse to reliably trigger an action potential, then record from all four cells." + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "c3fe9e26", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running 15 ms simulation...\n", + "Starting simulation at t=0. s for a duration of 15. ms\n", + "15. ms (100%) simulated in 1s\n", + "Done.\n" + ] + } + ], + "source": [ + "# --- Brian2 Concept: StateMonitor ---\n", + "#\n", + "# A StateMonitor records the value of a variable over time during simulation.\n", + "# StateMonitor(group, 'v', record=True, dt=0.01*ms)\n", + "# group = which NeuronGroup to record from\n", + "# 'v' = which variable to record (here, voltage)\n", + "# record = True means record ALL neurons in the group.\n", + "# You could also pass record=[0] to only record neuron 0.\n", + "# dt = how often to save a data point. 0.01*ms means one sample\n", + "# every 0.01 ms. This can differ from the simulation dt.\n", + "#\n", + "# After the simulation, you access the data as:\n", + "# mon.t = array of time points (with Brian2 units)\n", + "# mon.v[0] = voltage trace for neuron 0 (with Brian2 units)\n", + "\n", + "mon_GF = StateMonitor(GF, 'v', record=True, dt=0.01*ms)\n", + "mon_TTMn = StateMonitor(TTMn, 'v', record=True, dt=0.01*ms)\n", + "mon_PSI = StateMonitor(PSI, 'v', record=True, dt=0.01*ms)\n", + "mon_DLMn = StateMonitor(DLMn, 'v', record=True, dt=0.01*ms)\n", + "\n", + "# --- Stimulus Setup ---\n", + "#\n", + "# We inject current into GF only during a short time window.\n", + "# stim_onset and stim_offset define when the pulse starts and ends.\n", + "# stim_amp is the current density (in uA/cm^2) injected.\n", + "stim_onset = 5 * ms\n", + "stim_offset = 5.5 * ms # 0.5 ms duration\n", + "stim_amp = 500 * uA / cm**2\n", + "\n", + "# --- Brian2 Concept: network_operation ---\n", + "#\n", + "# @network_operation is a decorator that turns a Python function into\n", + "# something Brian2 calls at every timestep during the simulation.\n", + "# The function receives the current simulation time \"t\" as its argument.\n", + "#\n", + "# Here we use it to turn on a current pulse at stim_onset and turn it off\n", + "# at stim_offset, by directly setting GF.I_ext (the external current\n", + "# parameter we declared in the neuron equations).\n", + "#\n", + "# dt=0.01*ms means this function runs every 0.01 ms (same as simulation dt).\n", + "\n", + "@network_operation(dt=0.01*ms)\n", + "def inject_stimulus(t):\n", + " if stim_onset <= t < stim_offset:\n", + " GF.I_ext = stim_amp\n", + " else:\n", + " GF.I_ext = 0 * uA / cm**2\n", + "\n", + "# --- Brian2 Concept: Network and run() ---\n", + "#\n", + "# By default, Brian2 automatically collects all objects created since\n", + "# start_scope() and simulates them together (called \"magic mode\").\n", + "# But here we use an explicit Network object for full control.\n", + "#\n", + "# Network(...) takes all the objects that should participate in the\n", + "# simulation: NeuronGroups, Synapses, StateMonitors, and network_operations.\n", + "# If you forget to include something, it will not be simulated.\n", + "#\n", + "# net.run(15*ms) advances the simulation by 15 milliseconds.\n", + "# report='text' prints a progress bar to the output.\n", + "\n", + "net = Network(GF, TTMn, PSI, DLMn,\n", + " syn_GF_TTMn, syn_GF_PSI, syn_PSI_DLMn,\n", + " mon_GF, mon_TTMn, mon_PSI, mon_DLMn,\n", + " inject_stimulus)\n", + "\n", + "print('Running 15 ms simulation...')\n", + "net.run(15*ms, report='text')\n", + "print('Done.')" + ] + }, + { + "cell_type": "markdown", + "id": "1e01d3d3", + "metadata": {}, + "source": [ + "---\n", + "## 6 -- Measure Latency\n", + "\n", + "Latency = time from stimulus onset to action potential peak in the motor neuron.\n", + "\n", + "The paper measures latency to the AP peak in TTMn and DLMn, then adds a 0.35 ms neuromuscular junction delay. Experimental values:\n", + "- Young flies: TTM = 0.93 ms, DLM = 1.44 ms\n", + "- Old flies: TTM = 1.22 ms, DLM = 1.85 ms" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "a35a198d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Latency Results ===\n", + " GF : 0.12 ms (+ 0.35 ms NMJ = 0.47 ms total)\n", + " TTMn : 0.25 ms (+ 0.35 ms NMJ = 0.60 ms total)\n", + " PSI : 0.28 ms (+ 0.35 ms NMJ = 0.63 ms total)\n", + " DLMn : 0.69 ms (+ 0.35 ms NMJ = 1.04 ms total)\n", + "\n", + "Paper reference (young): TTM = 0.93 ms, DLM = 1.44 ms\n", + "Paper reference (old): TTM = 1.22 ms, DLM = 1.85 ms\n" + ] + } + ], + "source": [ + "def measure_latency(voltage_mV, time_ms, stim_onset_ms, threshold_mV=-20):\n", + " \"\"\"\n", + " Measure latency from stimulus onset to first threshold crossing.\n", + " Returns latency in ms, or None if threshold was never crossed.\n", + " \"\"\"\n", + " # np.where returns indices where the condition is True\n", + " above = np.where((voltage_mV > threshold_mV) & (time_ms > stim_onset_ms))[0]\n", + " if len(above) > 0:\n", + " return time_ms[above[0]] - stim_onset_ms\n", + " return None\n", + "\n", + "# NMJ (neuromuscular junction) delay from the paper -- added to model latency\n", + "nmj_delay = 0.35 # ms\n", + "\n", + "# --- Brian2 Concept: Extracting Data from Monitors ---\n", + "#\n", + "# After a simulation, StateMonitor holds the recorded data.\n", + "#\n", + "# mon_GF.t gives the time array WITH Brian2 units (e.g., in seconds).\n", + "# Dividing by \"ms\" strips the units and converts to plain milliseconds:\n", + "# mon_GF.t / ms --> numpy array of floats in milliseconds\n", + "#\n", + "# mon_GF.v[0] gives the voltage trace for neuron index 0, WITH units.\n", + "# Dividing by \"mV\" strips units and converts to plain millivolts:\n", + "# mon_GF.v[0] / mV --> numpy array of floats in millivolts\n", + "#\n", + "# You need to strip units before passing data to NumPy or Matplotlib,\n", + "# because those libraries do not understand Brian2 unit objects.\n", + "\n", + "t_ms = mon_GF.t / ms # time array in plain ms (no Brian2 units)\n", + "v_GF = mon_GF.v[0] / mV # GF voltage in plain mV\n", + "v_TTMn = mon_TTMn.v[0] / mV\n", + "v_PSI = mon_PSI.v[0] / mV\n", + "v_DLMn = mon_DLMn.v[0] / mV\n", + "\n", + "# stim_onset is a Brian2 Quantity; divide by ms to get a plain number\n", + "stim_onset_ms = stim_onset / ms\n", + "\n", + "# Measure latency for each cell\n", + "lat_GF = measure_latency(v_GF, t_ms, stim_onset_ms)\n", + "lat_TTMn = measure_latency(v_TTMn, t_ms, stim_onset_ms)\n", + "lat_PSI = measure_latency(v_PSI, t_ms, stim_onset_ms)\n", + "lat_DLMn = measure_latency(v_DLMn, t_ms, stim_onset_ms)\n", + "\n", + "print('=== Latency Results ===')\n", + "for name, lat in [('GF', lat_GF), ('TTMn', lat_TTMn), ('PSI', lat_PSI), ('DLMn', lat_DLMn)]:\n", + " if lat is not None:\n", + " total = lat + nmj_delay\n", + " print(f' {name:5s}: {lat:.2f} ms (+ {nmj_delay} ms NMJ = {total:.2f} ms total)')\n", + " else:\n", + " print(f' {name:5s}: no spike detected')\n", + "\n", + "print(f'\\nPaper reference (young): TTM = 0.93 ms, DLM = 1.44 ms')\n", + "print(f'Paper reference (old): TTM = 1.22 ms, DLM = 1.85 ms')" + ] + }, + { + "cell_type": "markdown", + "id": "17035e97", + "metadata": {}, + "source": [ + "---\n", + "## 7 -- Voltage Traces\n", + "\n", + "Voltage traces for all four cells. Compare the signal propagation pathway:\n", + "- GF fires first (directly stimulated)\n", + "- TTMn and PSI fire next (one gap junction away)\n", + "- DLMn fires last (chemical synapse from PSI)" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "c57ee362", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# --- Plotting voltage traces ---\n", + "# This cell is standard Matplotlib. No Brian2 syntax here because we\n", + "# already extracted the data as plain NumPy arrays (t_ms, v_GF, etc.)\n", + "# in the previous cell by dividing out the Brian2 units.\n", + "\n", + "fig, axes = plt.subplots(4, 1, figsize=(12, 10), sharex=True)\n", + "\n", + "# Each tuple: (cell name, voltage array, color, latency value)\n", + "traces = [\n", + " ('GF', v_GF, '#2196F3', lat_GF),\n", + " ('TTMn', v_TTMn, '#4CAF50', lat_TTMn),\n", + " ('PSI', v_PSI, '#FF9800', lat_PSI),\n", + " ('DLMn', v_DLMn, '#F44336', lat_DLMn),\n", + "]\n", + "\n", + "for ax, (name, v, color, lat) in zip(axes, traces):\n", + " ax.plot(t_ms, v, color=color, linewidth=1.5)\n", + " # Gold shading marks the stimulus window\n", + " ax.axvspan(stim_onset_ms, stim_onset_ms + 0.03, alpha=0.3, color='gold')\n", + " # Dashed line at -20 mV shows the spike threshold\n", + " ax.axhline(y=-20, color='gray', linestyle='--', linewidth=0.5, alpha=0.5)\n", + " if lat is not None:\n", + " # Vertical dotted line marks when this cell crossed threshold\n", + " ax.axvline(x=stim_onset_ms + lat, color=color, linestyle=':', linewidth=1.2, alpha=0.7)\n", + " ax.annotate(f'{lat:.2f} ms', xy=(stim_onset_ms + lat, -20),\n", + " xytext=(stim_onset_ms + lat + 0.5, 10),\n", + " arrowprops=dict(arrowstyle='->', color=color),\n", + " color=color, fontsize=10)\n", + " ax.set_ylabel('mV')\n", + " ax.set_title(name, fontsize=12, color=color)\n", + " ax.set_ylim(-100, 60)\n", + " ax.grid(True, alpha=0.3)\n", + "\n", + "axes[-1].set_xlabel('Time (ms)')\n", + "fig.suptitle('GFS Escape Response: Voltage Traces', fontsize=14, y=1.01)\n", + "plt.tight_layout()\n", + "plt.savefig('figures/escape_response_traces.png', dpi=150, bbox_inches='tight')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7bebe651", + "metadata": {}, + "source": [ + "---\n", + "## 8 -- Parameter Exploration: g_gap vs. Latency\n", + "\n", + "The central finding of the paper (Figure 2C): latency decreases monotonically as g_gap increases. A ~4-fold reduction in g_gap (135 nS to 34.5 nS) accounts for the age-related increase in escape latency.\n", + "\n", + "We sweep g_gap from 20 to 160 nS (matching the paper's range) and measure TTMn and DLMn latency for each value. The absolute conductance in nS is converted to a density (S/m²) for each cell using its membrane area from Table 1." + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "e5b8a008", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running parameter sweep...\n", + " g_gap = 20.0 nS -> TTMn: 0.85 ms, DLMn: 1.67 ms\n", + " g_gap = 30.0 nS -> TTMn: 0.60 ms, DLMn: 1.21 ms\n", + " g_gap = 40.0 nS -> TTMn: 0.48 ms, DLMn: 1.03 ms\n", + " g_gap = 50.0 nS -> TTMn: 0.41 ms, DLMn: 0.93 ms\n", + " g_gap = 60.0 nS -> TTMn: 0.37 ms, DLMn: 0.87 ms\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING \"v\" is an internal variable of group \"neurongroup_29\", but also exists in the run namespace with the value array([-65. , -65.06332539, -65.12619992, ..., -63.05259903,\n", + " -63.08749792, -63.12232627]). The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " g_gap = 70.0 nS -> TTMn: 0.33 ms, DLMn: 0.82 ms\n", + " g_gap = 80.0 nS -> TTMn: 0.31 ms, DLMn: 0.79 ms\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING \"v\" is an internal variable of group \"neurongroup_30\", but also exists in the run namespace with the value array([-65. , -65.06332539, -65.12619992, ..., -63.05259903,\n", + " -63.08749792, -63.12232627]). The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n", + "WARNING \"v\" is an internal variable of group \"neurongroup_31\", but also exists in the run namespace with the value array([-65. , -65.06332539, -65.12619992, ..., -63.05259903,\n", + " -63.08749792, -63.12232627]). The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " g_gap = 90.0 nS -> TTMn: 0.29 ms, DLMn: 0.76 ms\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING \"v\" is an internal variable of group \"neurongroup_32\", but also exists in the run namespace with the value array([-65. , -65.06332539, -65.12619992, ..., -63.05259903,\n", + " -63.08749792, -63.12232627]). The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n", + "WARNING \"v\" is an internal variable of group \"neurongroup_33\", but also exists in the run namespace with the value array([-65. , -65.06332539, -65.12619992, ..., -63.05259903,\n", + " -63.08749792, -63.12232627]). The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " g_gap = 100.0 nS -> TTMn: 0.28 ms, DLMn: 0.74 ms\n", + " g_gap = 110.0 nS -> TTMn: 0.27 ms, DLMn: 0.72 ms\n", + " g_gap = 120.0 nS -> TTMn: 0.26 ms, DLMn: 0.71 ms\n", + " g_gap = 130.0 nS -> TTMn: 0.25 ms, DLMn: 0.70 ms\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING \"v\" is an internal variable of group \"neurongroup_34\", but also exists in the run namespace with the value array([-65. , -65.06332539, -65.12619992, ..., -63.05259903,\n", + " -63.08749792, -63.12232627]). The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n", + "WARNING \"v\" is an internal variable of group \"neurongroup_35\", but also exists in the run namespace with the value array([-65. , -65.06332539, -65.12619992, ..., -63.05259903,\n", + " -63.08749792, -63.12232627]). The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " g_gap = 140.0 nS -> TTMn: 0.24 ms, DLMn: 0.69 ms\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING \"v\" is an internal variable of group \"neurongroup_36\", but also exists in the run namespace with the value array([-65. , -65.06332539, -65.12619992, ..., -63.05259903,\n", + " -63.08749792, -63.12232627]). The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n", + "WARNING \"v\" is an internal variable of group \"neurongroup_37\", but also exists in the run namespace with the value array([-65. , -65.06332539, -65.12619992, ..., -63.05259903,\n", + " -63.08749792, -63.12232627]). The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " g_gap = 150.0 nS -> TTMn: 0.24 ms, DLMn: 0.68 ms\n", + " g_gap = 160.0 nS -> TTMn: 0.23 ms, DLMn: 0.67 ms\n", + "Sweep complete.\n" + ] + } + ], + "source": [ + "# --- Brian2 Concept: Rebuilding the Network in a Function ---\n", + "#\n", + "# Brian2 objects (NeuronGroup, Synapses, etc.) are stateful -- they remember\n", + "# their current voltages, gating variables, and simulation time. There is no\n", + "# simple \"reset\" to put everything back to initial conditions.\n", + "#\n", + "# The cleanest way to run the same model many times with different parameters\n", + "# is to create ALL objects fresh inside a function, preceded by start_scope().\n", + "# start_scope() tells Brian2 to forget all previous objects.\n", + "#\n", + "# This is why run_with_g_gap() rebuilds everything from scratch each call.\n", + "# It is slower than resetting, but avoids subtle bugs from leftover state.\n", + "\n", + "def run_with_g_gap(g_gap_nS, duration=15*ms):\n", + " \"\"\"Run the GFS model with a given g_gap (in nS) and return TTMn and DLMn latency.\"\"\"\n", + "\n", + " # Reset Brian2's object registry for this run\n", + " start_scope()\n", + "\n", + " # Convert absolute conductance (nS) to density (S/m^2) for each cell\n", + " g_TTMn_Sm2 = nS_to_Sm2(g_gap_nS, A_TTMn_cm2)\n", + " g_PSI_Sm2 = nS_to_Sm2(g_gap_nS, A_PSI_cm2)\n", + "\n", + " # Build equation strings with the new conductance values baked in\n", + " gap_eqs_TTMn_local = f'''\n", + " I_syn_post = {g_TTMn_Sm2} * siemens / meter**2 * (v_pre - v_post) : amp/meter**2 (summed)\n", + " '''\n", + " gap_eqs_PSI_local = f'''\n", + " I_syn_post = {g_PSI_Sm2} * siemens / meter**2 * (v_pre - v_post) : amp/meter**2 (summed)\n", + " '''\n", + "\n", + " chem_eqs_local = '''\n", + " dg_syn/dt = -g_syn / tau_d + s : siemens/meter**2 (clock-driven)\n", + " ds/dt = -s / tau_r : siemens/meter**2/second (clock-driven)\n", + " I_syn_post = g_syn * (E_syn - v_post) : amp/meter**2 (summed)\n", + " '''\n", + "\n", + " # Create fresh NeuronGroups (same parameters as before)\n", + " gf = NeuronGroup(1, neuron_eqs, threshold='v > -20*mV', refractory=2*ms,\n", + " method='euler', dt=0.01*ms)\n", + " ttmn = NeuronGroup(1, neuron_eqs, threshold='v > -20*mV', refractory=2*ms,\n", + " method='euler', dt=0.01*ms)\n", + " psi = NeuronGroup(1, neuron_eqs, threshold='v > -20*mV', refractory=2*ms,\n", + " method='euler', dt=0.01*ms)\n", + " dlmn = NeuronGroup(1, neuron_eqs, threshold='v > -20*mV', refractory=2*ms,\n", + " method='euler', dt=0.01*ms)\n", + "\n", + " # Set initial conditions (same as in the single-run cell above)\n", + " for grp in [gf, ttmn, psi, dlmn]:\n", + " grp.v = V_rest\n", + " grp.m_NaT = 1.0 / (1.0 + np.exp((-65.0 + 29.13) / (-8.92)))\n", + " grp.h_NaT = 1.0 / (1.0 + np.exp((-65.0 + 47.0) / 5.0))\n", + " grp.m_NaP = 1.0 / (1.0 + np.exp((-65.0 + 48.77) / (-3.68)))\n", + " grp.m_K = 1.0 / (1.0 + np.exp((-65.0 + 12.85) / (-19.91)))\n", + "\n", + " # Create fresh synapses and connect them\n", + " s1 = Synapses(gf, ttmn, model=gap_eqs_TTMn_local); s1.connect()\n", + " s2 = Synapses(gf, psi, model=gap_eqs_PSI_local); s2.connect()\n", + " s3 = Synapses(psi, dlmn, model=chem_eqs_local,\n", + " on_pre='s += w_chem', dt=0.01*ms); s3.connect()\n", + " s3.delay = 0.15 * ms\n", + "\n", + " # Record only TTMn and DLMn (we only need their latencies)\n", + " mon_t = StateMonitor(ttmn, 'v', record=True, dt=0.01*ms)\n", + " mon_d = StateMonitor(dlmn, 'v', record=True, dt=0.01*ms)\n", + "\n", + " # Stimulus injection (same as before, but references local \"gf\" variable)\n", + " @network_operation(dt=0.01*ms)\n", + " def stim(t):\n", + " if stim_onset <= t < stim_offset:\n", + " gf.I_ext = stim_amp\n", + " else:\n", + " gf.I_ext = 0 * uA / cm**2\n", + "\n", + " # Build network with all local objects and run\n", + " net = Network(gf, ttmn, psi, dlmn, s1, s2, s3, mon_t, mon_d, stim)\n", + " net.run(duration)\n", + "\n", + " # Extract latencies (strip Brian2 units, measure threshold crossing)\n", + " t_arr = mon_t.t / ms\n", + " lat_t = measure_latency(mon_t.v[0] / mV, t_arr, stim_onset / ms)\n", + " lat_d = measure_latency(mon_d.v[0] / mV, t_arr, stim_onset / ms)\n", + " return lat_t, lat_d\n", + "\n", + "# --- Parameter Sweep ---\n", + "# Sweep g_gap from 20 to 160 nS in steps of 10 nS (matching paper Figure 2C)\n", + "g_gap_values_nS = np.arange(20, 170, 10)\n", + "ttm_latencies = []\n", + "dlm_latencies = []\n", + "\n", + "print('Running parameter sweep...')\n", + "for g_nS in g_gap_values_nS:\n", + " lt, ld = run_with_g_gap(g_nS)\n", + " ttm_latencies.append(lt)\n", + " dlm_latencies.append(ld)\n", + " lt_str = f'{lt:.2f}' if lt else 'none'\n", + " ld_str = f'{ld:.2f}' if ld else 'none'\n", + " print(f' g_gap = {g_nS:6.1f} nS -> TTMn: {lt_str} ms, DLMn: {ld_str} ms')\n", + "\n", + "print('Sweep complete.')" + ] + }, + { + "cell_type": "markdown", + "id": "95270158", + "metadata": {}, + "source": [ + "---\n", + "## 9 -- Plot: Latency vs. Gap Junction Conductance\n", + "\n", + "This reproduces the key result from Figure 2C of the paper. Both TTMn (TTM pathway) and DLMn (DLM pathway) latencies should decrease monotonically as g_gap increases. Dashed horizontal lines show the experimentally measured latencies from Augustin et al. (2017); vertical bars mark the model's young (135 nS) and old (34.5 nS) g_gap values." + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "23bb65ba", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved to figures/latency_vs_g_gap.png\n" + ] + } + ], + "source": [ + "# --- Plotting the parameter sweep results ---\n", + "# No Brian2 syntax here -- this is pure Matplotlib.\n", + "# The sweep data (g_gap_values_nS, ttm_latencies, dlm_latencies) are plain\n", + "# Python lists of numbers, so no unit stripping is needed.\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 5))\n", + "\n", + "# Add NMJ delay (0.35 ms) to model latencies for fair comparison with paper\n", + "# (the paper's reported values include NMJ delay)\n", + "nmj = 0.35\n", + "\n", + "# Filter out None values (in case a neuron did not spike at some g_gap)\n", + "# TTMn pathway\n", + "valid_t = [(g, l + nmj) for g, l in zip(g_gap_values_nS, ttm_latencies) if l is not None]\n", + "if valid_t:\n", + " gt, lt = zip(*valid_t)\n", + " ax.plot(gt, lt, 'o-', color='#4CAF50', linewidth=2, markersize=6, label='TTMn (model)')\n", + "\n", + "# DLMn pathway\n", + "valid_d = [(g, l + nmj) for g, l in zip(g_gap_values_nS, dlm_latencies) if l is not None]\n", + "if valid_d:\n", + " gd, ld = zip(*valid_d)\n", + " ax.plot(gd, ld, 's-', color='#F44336', linewidth=2, markersize=6, label='DLMn (model)')\n", + "\n", + "# Horizontal lines = experimental latencies from the paper\n", + "ax.axhline(y=0.93, color='#4CAF50', linestyle='--', alpha=0.5, label='TTM young expt (0.93 ms)')\n", + "ax.axhline(y=1.22, color='#4CAF50', linestyle=':', alpha=0.5, label='TTM old expt (1.22 ms)')\n", + "ax.axhline(y=1.44, color='#F44336', linestyle='--', alpha=0.5, label='DLM young expt (1.44 ms)')\n", + "ax.axhline(y=1.85, color='#F44336', linestyle=':', alpha=0.5, label='DLM old expt (1.85 ms)')\n", + "\n", + "# Vertical shaded bars = the paper's g_gap values for young and old flies\n", + "ax.axvline(x=135, color='magenta', linestyle='-', alpha=0.3, linewidth=8, label='young (135 nS)')\n", + "ax.axvline(x=34.5, color='red', linestyle='-', alpha=0.3, linewidth=8, label='old (34.5 nS)')\n", + "\n", + "ax.set_xlabel('g_gap (nS)')\n", + "ax.set_ylabel('Latency (ms, incl. NMJ delay)')\n", + "ax.set_title('Latency vs. Gap Junction Conductance (cf. Figure 2C)')\n", + "ax.legend(fontsize=7, loc='upper right')\n", + "ax.grid(True, alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('figures/latency_vs_g_gap.png', dpi=150, bbox_inches='tight')\n", + "plt.show()\n", + "print('Saved to figures/latency_vs_g_gap.png')" + ] + }, + { + "cell_type": "markdown", + "id": "9f15e78e", + "metadata": {}, + "source": [ + "---\n", + "## 10 -- Summary and Next Steps\n", + "\n", + "### What this notebook replicates\n", + "\n", + "The central finding of Augustin et al. (2019) is that a ~4-fold reduction in gap junction conductance (135 nS to 34.5 nS) accounts for the age-related increase in escape response latency. Our single-compartment Brian2 model **qualitatively reproduces** this:\n", + "\n", + "- Latency decreases monotonically with increasing g_gap (cf. Figure 2C)\n", + "- DLMn latency > TTMn latency at all g_gap values\n", + "- The curve shape (steep at low g_gap, flattening at high g_gap) matches\n", + "\n", + "### Quantitative discrepancies\n", + "\n", + "Model latencies are consistently ~0.3-0.4 ms shorter than the paper. At 135 nS: TTMn = 0.60 ms (paper: 0.93 ms), DLMn = 1.05 ms (paper: 1.44 ms). This offset is expected because the single-compartment model eliminates cable propagation delays present in the multi-compartment NEURON model.\n", + "\n", + "### Unit discovery\n", + "\n", + "The paper's `gap2.mod` mechanism specifies g_gap in **nanosiemens (nS)**, not µS as labeled in the paper's figures and plotting code. This was confirmed by dimensional analysis of the MOD file equation `i = (v-vgap)*g*0.001` (the 0.001 converts nS·mV to nA).\n", + "\n", + "### Next steps (Weeks 7-11)\n", + "- Add multi-compartment morphology to recover cable delays\n", + "- Reproduce Figure 2C quantitatively\n", + "- Explore Na/K conductance co-dependencies (Figure 3)\n", + "- Explore anatomic parameter effects (Figure 4)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "neuron2018", + "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.6.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}