OSCR

NEURONpyxl: fast, flexible, Python-integrated simulation of biophysical neural networks with complex plastic synapses.

Code ↔ Paper

13 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 13 matches
  1. [1] § Methods › Computational approaches ↔ neuronpyxl/network.py, lines 41–154 · score 0.80 · Backward Euler, Crank Nicholson, relaxation, NEURONpyxl, interface, CVODE
  2. [2] § Results › Leaky integrator neuron model ↔ neuronpyxl/network.py, lines 41–154 · score 0.79 · absolute error tolerance, Backwards Euler, Crank Nicholson, variable timesteps, CVODE, simulation
  3. [3] § Results › Leaky integrator neuron model ↔ neuronpyxl/scripts.py, lines 136–263 · score 0.78 · absolute error tolerance, Backwards Euler, Crank Nicholson, variable timesteps, models, simulation
  4. [4] § Methods › Computational approaches ↔ neuronpyxl/scripts.py, lines 136–263 · score 0.67 · Backward Euler, Crank Nicholson, dt, Excel, variable, error
  5. [5] § Methods › Computational approaches ↔ neuronpyxl/reader.py, lines 60–165 · score 0.65 · reversal potential, Excel spreadsheet, ion pools, regulation, variables, model
  6. [6] § Methods › Computational approaches ↔ neuronpyxl/scripts.py, lines 41–99 · score 0.60 · run_sim, gen_mods, NEURON simulation, command, duration, excel
  7. [7] § Results › Noise implementation ↔ neuronpyxl/network.py, lines 657–706 · score 0.59 · driving force, synaptic weight, finitialize, intervals, noise, cell
  8. [8] § Results › Parameter search ↔ scripts/fig10.py, lines 27–83 · score 0.55 · B63 fast, B30 B63, terminated, KPP, B64, protraction
  9. [9] § Methods › Computational approaches ↔ neuronpyxl/reader.py, lines 60–165 · score 0.55 · ion channels, electrical synapses, chemical synapses, cs, cell, voltage
  10. [10] § Results › Parameter search ↔ data-gen/fig13_data-gen.py, lines 81–118 · score 0.53 · B63 fast, B30 B63, KPP, B64, protraction, retraction
  11. [11] § Results › Noise implementation ↔ neuronpyxl/network.py, lines 709–725 · score 0.52 · NetStims, noisy, noise, cell, simulations, NEURONpyxl
  12. [12] § Results › Simulating a central pattern generating circuit ↔ scripts/benchmark.py, lines 1–21 · score 0.52 · independent simulations, synaptic weight, NEURONpyxl, noisy, noise
  13. [13] § Results › Electrical synapses ↔ neuronpyxl/network.py, lines 459–486 · score 0.51 · gap junction, Electrical synapses, neurons

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 1,082 lines · 41 KB · GPL-3.0 · 5 matches

  1. """
  2. This file is part of neuronpyxl.
  4. The Network class is the central class for neuronpyxl. It takes the
  5. simplified results from the ExcelReader and generates the entire network
  6. from that information, assuming that the correctly-named mod files are
  7. already compiled (see ModBuilder). It also has capabilities to run simulations
  8. and record the data directly from NEURON. These functions can be accessed
  9. either through cmd_util.py or by creating a Network object and running the
  10. simulations from another .py file.
  12. Copyright (C) 2026 Uri Dickman, Peter J. Thomas, Hillel J. Chiel, John H. Byrne,
  13. and Curtis L. Neveu.
  15. neuronpyxl is free software: you can redistribute it and/or modify
  16. it under the terms of the GNU General Public License as published by
  17. the Free Software Foundation, either version 3 of the License, or
  18. any later version.
  20. neuronpyxl is distributed in the hope that it will be useful,
  21. but WITHOUT ANY WARRANTY; without even the implied warranty of
  22. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  23. GNU General Public License for more details.
  25. You should have received a copy of the GNU General Public License
  26. along with neuronpyxl. If not, see <https://www.gnu.org/licenses/>.
  27. """
  29. from neuron import h
  30. import numpy as np
  31. import pandas as pd
  32. import copy
  33. import os
  34. import time
  35. from scipy.interpolate import CubicSpline
  36. from .cell import Cell
  37. from .reader import ExcelReader
  38. from typing import Tuple
  40. class Network:
  41. def __init__(
  42. self,
  43. params_file : str,
  44. sim_name : str,
  45. noise : tuple,
  46. dt : float,
  47. integrator : int,
  48. atol : float,
  49. eq_time : float,
  50. simdur : float,
  51. seed : bool=False
  52. ):
  53. """Network is the main class in NEURONpyxl.
  54. It is used for interfacing with NEURON and loading the Excel files.
  55. It also handles simulation control and data saving.
  57. Args:
  58. params_file (str): Filepath of Excel file to read in.
  59. sim_name (str): sheet in the spreadsheet to run.
  60. noise (tuple): noise parameters tuple (frequency, weight, tau)
  61. dt (float): timestep. If not provided, will use variables timestep and CVODE.
  62. integrator (int): 1 -> Backwards Euler, 2 -> Crank-Nicholson if dt is constant.
  63. atol (float): absolute error tolerance
  64. eq_time (float): equilibration time
  65. simdur (float): simulation duration (ms)
  66. seed (bool): if True, uses deterministic seed (not working).
  67. """
  69. self.cwd = os.getcwd()
  70. h.load_file("stdrun.hoc") # Necessary for NEURON run procedures
  72. ############# Initialize Network Data Structures #############
  74. self.cells = {} # Dict[cell name -> Cell object] (see cell.py)
  76. # Electrical synapse dictionary
  77. # Dict[presynaptic cell name -> Dict[postsynaptic cell name -> PointProcess]]
  78. self.electrical_synapses = {}
  80. # Dict[synapse type -> Dict[presynaptic cell name ->
  81. # Dict[postsynaptic cell name ->
  82. # Dict["synapse" -> PointProcess, "netcon" -> NetCon]]]]
  83. self.chemical_synapses = {"fast": {}, "slow": {}}
  85. # This is not used, but a function exists to compute if necessary
  86. self.input_resistance = {} # Dict[name -> resistance]
  88. # Define noise parameters
  89. # Rate (Hz): firing frequency, defines Poisson interval
  90. # Scale (uS): synaptic weight
  91. # Tau (ms): time constant
  92. if noise is not None:
  93. self.noise = {"rate": noise[0], "scale": noise[1], "tau": noise[2]}
  94. else:
  95. self.noise = None
  96. # Noise connections for
  97. # Tuple of 2 dicts structured as:
  98. # Dict["netstim" -> PointProcess
  99. # "syn" -> PointProcess
  100. # "netcon" -> PointProcess]
  101. # First syn is excitatory, second is inhibitory
  102. self.noise_cons = {}
  103. self.seed = seed
  105. # There can be multiple iclamps at the same location.
  106. self.current_clamps = {} # Dict[cell name -> List[h.IClamp]]
  107. self.v0 = {} # Initial voltages
  109. # List of ion pools active in each cell
  110. self.pools_active = {} # Dict[cell name -> List[str]]
  112. # Create a 0 reference in case there are unused hoc pointers
  113. # We use the 0 reference so they can still be added without changing the value.
  114. # This is used in the ion pool mechanism.
  115. self.zero_ref = h.Vector(1)
  116. self.zero_ref.x[0] = 0 # Set the first element to zero
  118. # Prefix for each of the NEURONpyxl NMODL mechanisms:
  119. self.mech_prefix = "neuronpyxl_"
  122. ############ Simulation setup parameters #############
  123. self.dt = dt # Timestep
  124. self.integrator = integrator # 1: Backwards Euler, 2: Crank-Nicholson, 3: CVODE
  125. match self.integrator:
  126. case 1:
  127. self.secondorder = 0
  128. case 2:
  129. self.secondorder = 2
  130. case 3:
  131. self.secondorder = 2
  132. self.atol = atol
  133. self.interp = 0.005 # Interpolation timestep default
  135. self.eq_time = eq_time # Relaxation time before recording
  136. if noise is not None:
  137. self.noise_eq_time = 1000
  138. else:
  139. self.noise_eq_time = 0
  140. self.simdur = simdur # Total duration to record after relaxation
  141. self.temp = 6.3 # None of the mechanisms use this
  142. self.record_synaptic_currents = False
  144. self.sim_name = sim_name
  145. self.params_file = params_file
  147. # Set up recording dictionary -- populated during run step
  148. # Dict["t" -> time recording, cell name -> Cell recordings for cell in cells]
  149. self.recording = {}
  150. self.synaptic_currents_recording = {}
  151. self.ran_before = False
  153. ############ Build the network #############
  154. self.setup(params_file) # Load in all parameters to NEURON
  157. def add_cell(self, cell: Cell):
  158. """Function to add a cell to the network.
  160. Args:
  161. cell (Cell): a Cell object
  162. """
  163. self.cells[cell.name] = cell
  166. def print_cell_section(self, name: str, loc: float):
  167. """Given a cell name, prints all of the mechanisms and parameter \
  168. values in the provided cell name and location.
  170. Args:
  171. name (str): name of the cell to print
  172. loc (float): location at which to print
  173. """
  174. h.psection(self.cells[name].section(loc))
  177. ############ Define getters and setters for parameter values #############
  178. ############ within the network to interface with NMODL #############
  180. def get_mech_parameter(self, name: str, param: str) -> float:
  181. """Set the value of a parameter from an ion channel/pool mechanism
  183. Args:
  184. name (str): cell name
  185. param (str): parameter name (see spreadsheet)
  187. Returns:
  188. float: value of the parameter
  189. """
  190. return getattr(self.cells[name].section(0.5), param)
  193. def get_cs_parameter(self, pre: str, post: str, cstype: str, param: str) -> float:
  194. """Set the value of a parameter of a chemical synapse
  196. Args:
  197. pre (str): presynaptic cell name
  198. post (str): postsynaptic cell name
  199. cstype (str): chemical synapse type (either fast or slow)
  200. param (str): parameter name (see spreadsheet csg,cse,csfat)
  202. Returns:
  203. float: value of the parameter
  204. """
  205. return getattr(self.chemical_synapses[cstype][pre][post]["synapse"], param)
  208. def get_es_parameter(self, pre: str, post: str, param: str) -> float:
  209. """Set the value of a parameter of an electrical synapse
  211. Args:
  212. pre (str): presynaptic cell name
  213. post (str): postsynaptic cell name
  214. param (str): paramter name (see spreadsheet es)
  216. Returns:
  217. float: value of the parameter
  218. """
  219. return getattr(self.electrical_synapses[pre][post], param)
  222. def set_mech_parameter(self, name: str, param: str, val: float) -> None:
  223. """Set the value of a parameter from an ion channel/pool mechanism
  225. Args:
  226. name (str): cell name
  227. param (str): parameter name (see spreadsheet)
  228. val (float): new parameter value
  229. """
  230. setattr(self.cells[name].section(0.5), param, val)
  233. def set_cs_parameter(self, pre: str, post: str, cstype: str, param: str, val: float) -> None:
  234. """Set the value of a parameter of a chemical synapse
  236. Args:
  237. pre (str): presynaptic cell name
  238. post (str): postsynaptic cell name
  239. cstype (str): chemical synapse type (either fast or slow)
  240. param (str): parameter name (see spreadsheet csg,cse,csfat)
  241. val (float): new parameter value
  242. """
  243. setattr(self.chemical_synapses[cstype][pre][post]["synapse"], param, val)
  246. def set_es_parameter(self, pre: str, post: str, param: str, val:float) -> None:
  247. """Set the value of a parameter of an electrical synapse
  249. Args:
  250. pre (str): presynaptic cell name
  251. post (str): postsynaptic cell name
  252. param (str): paramter name (see spreadsheet es)
  253. val (float): new parameter value
  254. """
  255. setattr(self.electrical_synapses[pre][post], param, val)
  258. def setup(self, file):
  259. """Calls all of the initialization functions in order to build the network from
  260. the provided Excel file.
  262. Args:
  263. file (pd.ExcelFile): an Excel file read in by Pandas.
  264. """
  265. self.reader = ExcelReader(file, self.sim_name, 21)
  266. self.add_cells_from_reader()
  267. print("Loading simulation parameters...")
  268. self.feed_pools_from_reader()
  269. self.add_regulation_from_reader()
  270. self.add_synapses_from_reader()
  271. self.set_up_v0_from_reader()
  272. if self.noise is not None:
  273. self.add_noise()
  274. self.add_iclamps_from_reader()
  277. def add_cells_from_reader(self):
  278. """Adds all cells present in the model into the network, along with their
  279. corresponding mechanisms. Sets all parameter values of each mechanism in
  280. each cell according to those present in the spreadsheet.
  281. """
  282. cell_data = self.reader.cells_data
  283. mechs_data = (
  284. self.reader.mechs_data[self.reader.mechs_data.index != 0]
  285. .dropna(axis=0, how="all")
  286. )
  287. mechs = [
  288. m for m in mechs_data.columns.levels[0]
  289. if "Unnamed" not in m and "File" not in m
  290. ]
  291. self.all_mechs = []
  293. assert not mechs_data.empty and not cell_data.empty, \
  294. "You must run a simulation with at least one cell."
  296. for name, row in mechs_data.iterrows():
  297. vdg_parameters = {}
  298. cm = cell_data.loc[name]["cm"]
  300. for m in mechs:
  301. if m not in row:
  302. continue
  304. r = row[m]
  306. if r["vdg"].isna().to_numpy().all():
  307. continue
  309. key = m.lower().strip().replace("_", "")
  311. if key not in self.all_mechs:
  312. self.all_mechs.append(key)
  314. vdg_parameters[key] = {
  315. "g": r["vdg"]["g"],
  316. "e": r["vdg"]["E"],
  317. }
  319. if key == "leak":
  320. continue
  322. if "p" in r["vdg"].index:
  323. vdg_parameters[key]["p"] = r["vdg"]["p"]
  325. if not pd.isna(r["A"]).all():
  326. self._set_activation_parameters(vdg_parameters, key, r, "A")
  327. if not pd.isna(r["B"]).all():
  328. self._set_activation_parameters(vdg_parameters, key, r, "B")
  329. else:
  330. vdg_parameters[key]["numbtaus"] = 0
  331. else:
  332. vdg_parameters[key]["numataus"] = 0
  333. vdg_parameters[key]["numbtaus"] = 0
  335. mechs_with_prefix = [self.mech_prefix + m for m in vdg_parameters]
  336. c = Cell(name=name, current_mechs=mechs_with_prefix, cm=cm)
  338. for mech, d in vdg_parameters.items():
  339. for param, val in d.items():
  340. setattr(c.section(0.5), f"{param}_{self.mech_prefix}{mech}", val)
  342. self.add_cell(c)
  343. print(f"Added {c} to the network.")
  346. def _set_activation_parameters(self, vdg_parameters, key, r, var):
  347. """Helper function to set activation parameters of ion channel mechanisms.\
  348. A and B are identical sets of equations, so this function sets all parameter \
  349. values accounting for every possible variable combination that exists within \
  350. the SNNAP model.
  352. Args:
  353. vdg_parameters (dict): main parameter dictionary (see below)
  354. r (pd.Series): row of the df
  355. key (str): ion channel mechanism
  356. var (str): A or B
  357. """
  358. if pd.isna(r[var]["tmx"]):
  359. vdg_parameters[key][f"{var}infonly"] = 1
  360. for param, val in r[var].items():
  361. if not pd.isna(val):
  362. vdg_parameters[key][f"{param}{var}"] = val
  363. if not f"{var}infonly" in vdg_parameters[key]:
  364. if param == "tmx" and (r[var]["ts1"] == 0 or pd.isna(r[var]["ts1"])):
  365. vdg_parameters[key][f"tmx{var}only"] = 1
  366. vdg_parameters[key][f"num{var.lower()}taus"] = 1
  367. if not pd.isna(r[var]["ts1"]) and r[var]["ts1"] != 0:
  368. if pd.isna(r[var]["ts2"]) or r[var]["ts2"] == 0:
  369. vdg_parameters[key][f"num{var.lower()}taus"] = 1
  370. else:
  371. vdg_parameters[key][f"num{var.lower()}taus"] = 2
  374. def feed_pools_from_reader(self):
  375. """Sets up the ion pool feeding mechanism from Python according to the implementation in NMODL.
  376. If a channel feeds into a pool, then it has a STATE variable for that concentration
  377. contribution (e.g. cai_state). Then, the ion pool accumulator mechanism is added into the
  378. cell and reads in all the state variables which feed into the pool as pointers. The sum of
  379. those concentrations becomes the total concentration of the ion pool, which is set by the
  380. accumulator and not the channel mechanism.
  381. """
  382. possible_ions = ["ca", "na", "k", "cl"]
  383. max_channels = {}
  384. for m in self.all_mechs:
  385. for ion in possible_ions:
  386. if m.startswith(ion):
  387. max_channels.setdefault(ion, 0)
  388. max_channels[ion] += 1
  390. df = (
  391. self.reader.cond_to_ion_data
  392. [self.reader.cond_to_ion_data.index != 0]
  393. .dropna(axis=1, how="all")
  394. .dropna(axis=0, how="all")
  395. )
  396. if df.empty:
  397. return
  399. for name, row in df.iterrows():
  400. pools_data = self.reader.ion_pools_data.loc[name]
  401. pools_data = pools_data[pools_data.index != 0]
  402. pools = {}
  404. for ion_key, k1_key, k2_key in [
  405. ("ion", "K1", "K2"),
  406. ("ion_1", "K1_1", "K2_1"),
  407. ("ion_2", "K1_2", "K2_2"),
  408. ]:
  409. ion_value = pools_data[ion_key]
  410. if isinstance(ion_value, str):
  411. pool = ion_value.lower().strip()
  412. if pool not in pools:
  413. pools[pool] = {"k1": pools_data[k1_key], "k2": pools_data[k2_key]}
  415. cell : Cell = self.cells[name]
  416. ions = {}
  418. for i in range(4):
  419. ch_col = f"ch_{i}" if i > 0 else "ch"
  420. ion_col = f"ion_{i}" if i > 0 else "ion"
  421. if ch_col in df.columns and ion_col in df.columns:
  422. if isinstance(row[ch_col], str) and isinstance(row[ion_col], str):
  423. ch = row[ch_col].lower().strip()
  424. ion = row[ion_col].lower().strip()
  425. self.pools_active.setdefault(name, set()).add(ion)
  426. ions.setdefault(ion, []).append(ch)
  428. cell.load_mechanisms([f"{self.mech_prefix}{ion}pool" for ion in self.pools_active[name]])
  430. for ion, l in ions.items():
  431. for j, ch in enumerate(l):
  432. chmech = getattr(cell.section(0.5), f"{self.mech_prefix}{ion}pool")
  433. ref = getattr(cell.section(0.5), f"_ref_i_{self.mech_prefix}{ch}")
  434. h.setpointer(ref, f"i{j+1}", chmech)
  436. if j < max_channels[ion] - 1:
  437. for k in range(j + 1, max_channels[ion] - j):
  438. h.setpointer(
  439. self.zero_ref._ref_x[0],
  440. f"i{k+1}",
  441. getattr(cell.section(0.5), f"{self.mech_prefix}{ion}pool"),
  442. )
  444. setattr(cell.section(0.5), f"k1_{self.mech_prefix}{ion}pool", pools[ion]["k1"])
  445. setattr(cell.section(0.5), f"k2_{self.mech_prefix}{ion}pool", pools[ion]["k2"])
  448. def add_iclamps_from_reader(self):
  449. """Sets up current clamps to the network, if provided in the spreadsheet.
  450. """
  451. if self.reader.iclamp_data.empty:
  452. return
  453. for name, row in self.reader.iclamp_data.iterrows():
  454. self.attach_iclamp(name, delay=row["start"]*1000,
  455. dur=(row["stop"]-row["start"])*1000, amp=row["magnitude"]
  456. )
  459. def add_synapses_from_reader(self):
  460. """Function to add all of the synaptic connections to the network.
  462. Raises:
  463. ValueError: raised if a nonexistent ion is listed as facilitating.
  464. """
  465. #### Electrical synapses
  466. df_esg = self.reader.esg_data
  467. if not df_esg.empty:
  468. esg_stacked = df_esg[df_esg != 0].stack().dropna()
  469. for (pre, post), g in esg_stacked.items():
  470. presyn = self.cells[pre]
  471. postsyn = self.cells[post]
  472. syn = h.neuronpyxl_ES(postsyn.section(0.5))
  473. # Set max conductance
  474. syn.g = g
  475. # Set up presynaptic potential pointer (works the same as gap junction NEURON mechanism file)
  476. syn._ref_vpre = presyn.section(0.5)._ref_v
  477. # Update ES dictionary
  478. self.electrical_synapses.setdefault(pre, {})[post] = syn
  480. # Add chemical synapses to network
  481. df_csg = self.reader.csg
  482. df_cse = self.reader.cse
  483. df_cs_params_fast = self.reader.csfat_params_fast
  484. df_cs_params_slow = self.reader.csfat_params_slow
  485. self._add_cs(df_csg, df_cse, df_cs_params_fast, "fast")
  486. self._add_cs(df_csg, df_cse, df_cs_params_slow, "slow")
  489. def _set_attr_cs_params(self, d, syn):
  490. """Helper method to recursively set values of all
  491. params in below dictionaries
  493. Args:
  494. d (dict): dictionary
  495. syn (hoc object): synapse, a point process
  496. """
  497. for k, v in d.items():
  498. if isinstance(v, dict):
  499. self._set_attr_cs_params(v, syn)
  500. else:
  501. setattr(syn, k, v)
  504. def _add_cs(self, dfg, dfe, dfparams, type):
  505. """Add chemical synapses to a network
  507. Args:
  508. dfg (pd.DataFrame): df with synaptic conductances (csg in spreadsheet)
  509. dfe (pd.DataFrame): df with reversal potentials (esg in spreadsheet)
  510. dfparams (pd.DataFrame): df with parameters for CS mechanism (cs_fat in spreadsheet)
  511. type (str): either fast or slow
  513. Raises:
  514. ValueError: _description_
  515. """
  516. if any(len(df) == 0 for df in [dfg, dfe, dfparams]):
  517. return
  519. for pre, d in dfg[type].items():
  520. if pre == 0:
  521. continue
  522. for post, g in d.items():
  523. if post == 0:
  524. continue
  526. presyn = self.cells[pre]
  527. postsyn = self.cells[post]
  528. syn = h.neuronpyxl_CS(postsyn.section(0.5))
  530. params = {}
  531. for k, v in dfparams[pre][post].dropna().to_dict().items():
  532. params.setdefault(k[0], {})[k[1]] = v
  534. params["g"] = g
  535. params["e"] = dfe[type][pre][post]
  537. if len(params["taus"]) == 1:
  538. params["taus"]["u2"] = params["taus"]["u1"]
  539. params["taus"]["u1"] *= 1000
  540. params["taus"]["u2"] *= 1000
  542. if "Voltage dependence" in params:
  543. params["voltage_dependence"] = 1
  544. if "tx" not in params["Voltage dependence"] or params["Voltage dependence"]["tx"] == 0:
  545. params["tx"] = -1
  546. else:
  547. params["Voltage dependence"]["tx"] *= 1000
  549. if "depression" in params:
  550. params["depress"] = 1
  551. params["depression"]["ud"] *= 1000
  552. params["depression"]["ur"] *= 1000
  554. if "facilitation" in params:
  555. ion = params["facilitation"]["ion"].lower().strip()
  556. pre_sec = presyn.section(0.5)
  557. match ion:
  558. case "ca": syn._ref_mod = pre_sec._ref_cai
  559. case "na": syn._ref_mod = pre_sec._ref_nai
  560. case "k": syn._ref_mod = pre_sec._ref_ki
  561. case "cl": syn._ref_mod = pre_sec._ref_cli
  562. case _:
  563. raise ValueError(f"{ion} is not a valid facilitation ion. Must be one of Ca, Na, K, or Cl.")
  564. params["facilitation"]["u"] *= 1000
  565. params["facilitation"]["ion"] = 1
  567. self._set_attr_cs_params(params, syn)
  569. nc = h.NetCon(presyn.section(0.5)._ref_v, syn, sec=presyn.section)
  570. nc.threshold = 0.0
  571. nc.delay = 0.0
  572. nc.weight[0] = 0
  574. self.chemical_synapses[type].setdefault(pre, {})[post] = {"synapse": syn, "netcon": nc}
  577. def add_regulation_from_reader(self):
  578. """Function to set up ion regulation from an ion pool.
  580. Raises:
  581. ValueError: throws a value error if the ion regulator is not
  582. one of Ca, Na, K or Cl.
  583. """
  584. unitconv = {
  585. "p1": {1: 1000, 2: 1e-6, 3: 1, 4: 1e6, 5: 1e-6},
  586. "p2": 1000,
  587. }
  588. ions = ["ca", "na", "k", "cl"]
  589. df = (
  590. self.reader.ion_to_cond_data
  591. [self.reader.ion_to_cond_data.index != 0]
  592. .dropna(axis=1, how="all")
  593. .dropna(axis=0, how="all")
  594. )
  595. if df.empty:
  596. return
  598. for name, row in df.iterrows():
  599. cell = self.cells[name]
  600. for i in range(4):
  601. suffix = f"_{i}" if i > 0 else ""
  602. ch_col = f"ch{suffix}"
  603. ion_col = f"ion{suffix}"
  605. if ch_col not in df.columns or ion_col not in df.columns:
  606. continue
  608. ch = row[ch_col].lower().strip()
  609. ion = row[ion_col].lower().strip()
  610. opt1 = row[f"opt1{suffix}"]
  611. opt2 = row[f"opt2{suffix}"]
  612. p1 = row[f"p1{suffix}"]
  613. p2_col = f"p2{suffix}"
  614. b_col = f"b{suffix}"
  616. try:
  617. ion_num = ions.index(ion) + 1
  618. except ValueError:
  619. raise ValueError(f"{ion} is not a valid regulatory ion. Must be one of Ca, Na, K, or Cl.")
  621. sec = cell.section(0.5)
  622. setattr(sec, f"region_{self.mech_prefix}{ch}", ion_num)
  623. setattr(sec, f"opt1_{self.mech_prefix}{ch}", opt1)
  624. setattr(sec, f"opt2_{self.mech_prefix}{ch}", opt2)
  625. setattr(sec, f"p1_{self.mech_prefix}{ch}", p1 * unitconv["p1"][opt2])
  627. if p2_col in df.columns:
  628. setattr(sec, f"p2_{self.mech_prefix}{ch}", row[p2_col] * unitconv["p2"])
  630. if b_col in df.columns:
  631. setattr(sec, f"b_{self.mech_prefix}{ch}", row[b_col])
  634. def set_up_v0_from_reader(self):
  635. """Function to set all of the initial voltages of the cell membranes according to the spreadsheet.
  636. """
  637. df_v0 = self.reader.initial_voltage_data
  638. df_v0.dropna(axis=0, inplace=True)
  639. if df_v0.empty: # If voltages not provided, will default to -60 mV
  640. for c in self.cells.keys():
  641. self.v0[c] = -60.0
  642. else:
  643. self.v0 = df_v0[df_v0.index != 0].to_dict()["mV"]
  646. def compute_input_resistance(self):
  647. """
  648. Function to compute the imput resistance of each cell in the network.
  649. """
  650. for name, cell in self.cells.items():
  651. z = h.Impedance()
  652. z.loc(0.5, sec=cell.section) # Measure impedance at the center of the soma
  653. z.compute(0) # Compute impedance at frequency f=0 (DC)
  654. self.input_resistance[name] = z.input(0.5, sec=cell.section)
  657. def add_noise(self):
  658. """
  659. Function to add noise inthe form of 2 netstims with equal driving force.
  660. """
  661. e1 = 60
  662. e2 = -90
  663. rate = self.noise["rate"] / 1000 # 1 / ms
  665. def spike_num(rate, simdur):
  666. return rate*simdur
  668. h.finitialize()
  669. #h.continuerun(self.noise_eq_time)
  670. for name, cell in self.cells.items():
  671. e0 = cell.section(0.5).v
  673. num = spike_num(rate, self.simdur+self.noise_eq_time)
  675. ns1 = h.NetStim()
  676. ns1.number = num
  677. ns1.start = self.eq_time
  678. ns1.interval = 1 / rate
  679. ns1.noise = 1.0
  681. ns2 = h.NetStim()
  682. ns2.number = num
  683. ns2.start = self.eq_time
  684. ns2.interval = 1 / rate
  685. ns2.noise = 1.0
  687. syn1 = h.ExpSyn(cell.section(0.5))
  688. syn1.tau = self.noise["tau"]
  689. syn1.e = e1
  691. syn2 = h.ExpSyn(cell.section(0.5))
  692. syn2.tau = self.noise["tau"]
  693. syn2.e = e2
  695. # Connect the NetStim to the synapse via a NetCon
  696. nc1 = h.NetCon(ns1, syn1)
  697. nc1.weight[0] = np.abs((e2 - e0) / (e1 - e0)) * self.noise["scale"] # Synaptic weight in μS
  698. nc2 = h.NetCon(ns2, syn2)
  699. nc2.weight[0] = self.noise["scale"] # Synaptic weight in μS
  700. # Package the objects together and add it to the class object
  701. self.noise_cons[name] = (
  702. {"netstim": ns1, "syn": syn1, "netcon": nc1},
  703. {"netstim": ns2, "syn": syn2, "netcon": nc2}
  704. )
  706. self.set_seed()
  709. def set_seed(self):
  710. """
  711. Doesnt seem to be working yet.
  712. Intended functionality: deterministically set the seed number as a test for noisy simulations.
  713. """
  714. num_seeds = 2 * len(self.cells) # 2 seeds per NetStim, 2 NetStims per cell
  715. if self.seed:
  716. seeds = np.arange(1, num_seeds+1,dtype=int)
  717. else:
  718. seeds = np.random.choice(np.arange(1, 1000,dtype=int), size=num_seeds, replace=False)
  719. seeds = seeds.reshape(2, len(self.cells))
  721. for i, ((_, (d1, d2))) in enumerate(self.noise_cons.items()):
  722. seed1 = seeds[0, i]
  723. seed2 = seeds[1, i]
  724. d1["netstim"].seed(seed1)
  725. d2["netstim"].seed(seed2)
  728. def attach_iclamp(self, name: str, delay:float=None, dur:float=None, amp:float=None):
  729. """Add an iclamp to the network
  731. Args:
  732. name (str): name of cell to insert iclamp
  733. delay (float, optional): delay of start of current inejction (ms). Defaults to None.
  734. dur (float, optional): duration of current injection (ms). Defaults to None.
  735. amp (float, optional): amplitude of current injection (nA). Defaults to None.
  737. Returns:
  738. _type_: A hoc current clamp object
  739. """
  740. assert name in self.cells, f"Cell name '{name}' not found in cells dict"
  741. delaytime = delay+self.eq_time+self.noise_eq_time if delay is not None else None
  742. ic = self.cells[name].iclamp(delaytime, dur, amp, 0.5)
  743. self.current_clamps.setdefault(name, []).append(ic)
  744. return ic
  747. def remove_iclamp(self, name: str, index: int):
  748. """Remove an IClamp from the network
  750. Args:
  751. name (str): name of clamp to remove
  752. index (int): index in the list of clamp to remove (in order of time added)
  753. """
  754. assert name in self.current_clamps, \
  755. f"Cell '{name}' must be the name of a cell in the Network, and the IClamp must already exist"
  756. if name in self.recording:
  757. del self.recording[name]["iclamps"][index]
  758. del self.current_clamps[name][index]
  761. def record_voltage_only(self):
  762. """Record only the voltage traces of the cells in the network
  763. """
  764. self.voltage_only = True
  765. self.recording["t"] = h.Vector().record(h._ref_t)
  766. for name, cell in self.cells.items():
  767. cell.recording = {"V": h.Vector().record(cell.section(0.5)._ref_v)}
  768. self.recording[name] = cell.recording
  769. if name in self.current_clamps:
  770. self.recording[name]["iclamps"] = []
  771. for clamp in self.current_clamps[name]:
  772. self.recording[name]["iclamps"].append(h.Vector().record(clamp._ref_i))
  775. def record_all(self):
  776. """Records time, membrane potential, currents from all mechanisms, and ion pool
  777. concentrations if available. Also records injected voltage and current if available.
  778. """
  779. self.voltage_only = False
  780. self.recording["t"] = h.Vector().record(h._ref_t)
  782. for name, cell in self.cells.items():
  783. cell.set_iv_recording()
  785. if name in self.pools_active:
  786. sec = cell.section(0.5)
  787. for ion in self.pools_active[name]:
  788. cell.recording[f"{ion}i"] = h.Vector().record(getattr(sec, f"_ref_{ion}i"))
  790. if self.noise is not None:
  791. cell.recording["noise1"] = h.Vector().record(self.noise_cons[name][0]["syn"]._ref_i)
  792. cell.recording["noise2"] = h.Vector().record(self.noise_cons[name][1]["syn"]._ref_i)
  794. self.recording[name] = cell.recording
  796. if name in self.current_clamps:
  797. self.recording[name]["iclamps"] = [
  798. h.Vector().record(clamp._ref_i)
  799. for clamp in self.current_clamps[name]
  800. ]
  802. if self.record_synaptic_currents:
  803. if self.chemical_synapses:
  804. self.synaptic_currents_recording["chemical"] = {}
  805. if self.electrical_synapses:
  806. self.synaptic_currents_recording["electrical"] = {}
  808. for speed, d1 in self.chemical_synapses.items():
  809. for pre, d2 in d1.items():
  810. for post, d3 in d2.items():
  811. self.synaptic_currents_recording["chemical"].setdefault(speed,{})\
  812. [f"{pre}_2_{post}"] = \
  813. h.Vector().record(d3["synapse"]._ref_i
  814. )
  816. for pre, d in self.electrical_synapses.items():
  817. for post, syn in d.items():
  818. self.synaptic_currents_recording["electrical"][f"{pre}_2_{post}"] = \
  819. h.Vector().record(syn._ref_i)
  821. self.synaptic_currents_recording["t"] = h.Vector().record(h._ref_t)
  824. def record_other(self, name: str, ref: str):
  825. """Record a custom hoc pointer."""
  826. key = ref.replace("_ref_", "")
  827. self.recording.setdefault(name, {})[key] = h.Vector().record(
  828. getattr(self.cells[name].section(0.5), ref)
  829. )
  832. def record(self, voltage_only: bool):
  833. """Main function to record hoc pointers
  835. Args:
  836. voltage_only (bool): if passed in, only records the voltage
  837. """
  838. if voltage_only:
  839. self.record_voltage_only()
  840. else:
  841. self.record_all()
  844. def setup_run(self, record_none: bool = False, voltage_only: bool = False):
  845. for name, c in self.cells.items():
  846. for seg in c.section:
  847. seg.v = self.v0[name]
  849. if self.dt > 0:
  850. h.dt = self.dt
  851. if self.integrator == 3:
  852. h.cvode.active(True)
  853. h.cvode.atol(self.atol)
  854. h.cvode.maxstep(10)
  856. h.celsius = self.temp
  857. h.secondorder = self.secondorder
  859. if not record_none:
  860. self.record(voltage_only)
  863. def run(self, voltage_only: bool = False, record_none: bool = False):
  864. """Run the NEURON simulations --> record and call the correct solvers
  865. Prioritizes record_none first.
  867. Args:
  868. voltage_only (bool, optional): records only the voltage. Defaults to False.
  869. record_none (bool, optional): doesn't record anhything. Defaults to False.
  870. """
  871. self.setup_run(record_none=record_none, voltage_only=voltage_only)
  872. print("Running simulation...")
  873. start_time = time.time()
  874. h.finitialize()
  875. h.continuerun(self.eq_time + self.noise_eq_time + self.simdur)
  876. self.simtime = time.time() - start_time
  877. self.ran_before = True
  880. def get_synaptic_current_data(self) -> Tuple[dict]:
  881. """Returns current data from electrical and chemical synapses, if present.
  882. If one is not present, it is returned as None.
  884. Returns:
  885. Tuple[dict]: chemical synapse data, electrical synapse data
  886. """
  887. t = self.synaptic_currents_recording["t"].as_numpy() + self._adjust_t()
  889. if "chemical" in self.synaptic_currents_recording:
  890. chem_data = {"t": t}
  891. for speed, d in self.synaptic_currents_recording["chemical"].items():
  892. for k, v in d.items():
  893. chem_data[f"I_{k}_{speed}"] = v.as_numpy()
  894. else:
  895. chem_data = None
  897. if "electrical" in self.synaptic_currents_recording:
  898. elec_data = {"t": t}
  899. for k, v in self.synaptic_currents_recording["electrical"].items():
  900. elec_data[f"I_{k}"] = v.as_numpy()
  901. else:
  902. elec_data = None
  904. return copy.deepcopy(chem_data), copy.deepcopy(elec_data)
  907. def get_cell_data(self, name: str) -> dict:
  908. """Returns all data from a cell, including ion channel currents, applied current
  909. injections, membrane potential, and ion concentrations.
  911. Args:
  912. name (str): name of the cell whose data to return.
  914. Returns:
  915. dict: all of the cell's recorded data.
  916. """
  917. adjust_t = self._adjust_t()
  918. c = self.cells[name]
  919. cell_data = c.get_data()
  920. cell_data["t"] = self.recording["t"].as_numpy()
  922. indices = np.where(cell_data["t"] > (self.eq_time + self.noise_eq_time - adjust_t))[0]
  924. if self.noise is not None and not self.voltage_only:
  925. cell_data["noise"] = cell_data.pop("noise1") + cell_data.pop("noise2")
  927. for k, v in cell_data.items():
  928. if k[0] == "I" and k != "I_app":
  929. cell_data[k] = c.current_density_to_nA(v)
  931. for k in cell_data:
  932. cell_data[k] = cell_data[k][indices]
  934. cell_data["t"] -= self.eq_time + self.noise_eq_time + adjust_t
  936. return copy.deepcopy(cell_data)
  939. def _adjust_t(self) -> float:
  940. """Returns the time adjustment for the current secondorder setting."""
  941. if self.dt > 0:
  942. if self.secondorder == 1:
  943. return self.dt / 2
  944. if self.secondorder == 2:
  945. return -self.dt / 2
  946. return 0
  949. def interpolate_data(self,tvec:np.array,t:np.array,y:np.array):
  950. # Remove duplicates and ensure t is strictly increasing
  951. # I think there's a way to do this in NEURON but I havne't figured it out yet.
  952. # This way is janky.
  953. t_sorted, unique_indices = np.unique(t, return_index=True)
  954. y_sorted = y[unique_indices]
  955. cs = CubicSpline(t_sorted, y_sorted)
  956. return cs(tvec)
  959. def get_interpolated_cell_data(self, name: str, tvec: np.array) -> dict:
  960. """Returns an the cell data linearly interpolated to a time vector.
  962. Args:
  963. name (str): cell name to get
  964. tvec (iter): time vector to interpolate to.
  966. Returns:
  967. dict: dictionary of all of the interpolated data
  968. """
  969. cell_data = self.get_cell_data(name)
  970. t = cell_data["t"]
  971. cell_interp = {"t": tvec}
  973. for k, v in cell_data.items():
  974. if k != "t":
  975. cell_interp[k] = self.interpolate_data(tvec, t, v)
  976. return cell_interp
  979. def get_interpolated_syn_data(self, tvec: iter) -> Tuple[dict]:
  980. """Same as Network.get_interpolated_cell_data but interpolates synapse data
  982. Args:
  983. tvec (iter): time vector to interpolate to
  985. Returns:
  986. Tuple[dict]: interpolated electrical data, chemical data
  987. """
  988. chem_data, elec_data = self.get_synaptic_current_data()
  989. if chem_data is not None:
  990. chem_interp = {"t": tvec}
  991. tchem = chem_data["t"]
  992. for k, v in chem_data.items():
  993. if k != "t":
  994. chem_interp[k] = self.interpolate_data(tvec, tchem, v)
  995. else:
  996. chem_interp = None
  997. if elec_data is not None:
  998. elec_interp = {"t": tvec}
  999. telec = elec_data["t"]
  1000. for k, v in elec_data.items():
  1001. if k != "t":
  1002. elec_interp[k] = self.interpolate_data(tvec, telec, v)
  1003. else:
  1004. elec_interp = None
  1005. return chem_interp, elec_interp
  1008. def save_state(self,filename:str="state.bin"):
  1009. """ Saves the state of the current neuron simulation.
  1011. Args:
  1012. filename (str): filename of the state file to save to
  1014. """
  1015. ss = h.SaveState()
  1016. ss.save()
  1017. sf = h.File(filename)
  1018. ss.fwrite(sf)
  1021. def restore_state(self,filename:str):
  1022. """ Restores the state of the simulation. In order for this to work, the simulation
  1023. must be set up exactly the same as when the state file was saved.
  1025. Args:
  1026. filename (str): name of the state file to restore.
  1028. """
  1029. h.stdinit()
  1030. ss = h.SaveState()
  1031. sf = h.File(filename)
  1032. ss.fread(sf)
  1033. ss.restore()
  1036. def generate_metadata(self,voltage_only,folder):
  1037. """Interpolate metadata and information regarding the simulation.
  1038. Includes NEURON runtime, storage location, integration method, tiemstep and more.
  1039. """
  1040. def count_syns(d):
  1041. count = 0
  1042. if isinstance(d, dict):
  1043. for value in d.values():
  1044. count += count_syns(value) # Recursively count in nested dictionaries
  1045. else:
  1046. count += 1 # Base case: when it's not a dictionary, it's a value
  1047. return count
  1049. method = {
  1050. 1: "Backwards Euler",
  1051. 2: "Crank-Nicholson",
  1052. 3: "CVODE"
  1053. }
  1055. def get_timestep(dt):
  1056. if dt == -1:
  1057. return "variable"
  1058. else:
  1059. return f"{dt} ms"
  1061. metadata = {"Simulation name": self.sim_name,
  1062. "Model file": self.params_file,
  1063. "Data saved to": f"./Data/{self.sim_name}_data/",
  1064. "NEURON finished in": f"{self.simtime} s",
  1065. "Simulation duration": f"{self.simdur} ms",
  1066. "Integration method": method[self.integrator],
  1067. "Timestep": get_timestep(self.dt),
  1068. "Absolute error tolerance": self.atol,
  1069. "Number of cells": len(self.cells),
  1070. "Number of electrical synapses": int(count_syns(self.electrical_synapses)/2),
  1071. "Number of chemical synapses": int(count_syns(self.chemical_synapses)/2)}
  1073. if voltage_only:
  1074. metadata["Data saved to"] = f"{folder}/{self.sim_name}_data.h5"
  1076. if self.noise is not None:
  1077. metadata["Noise"] = f"rate = {self.noise['rate']} Hz, \
  1078. scale = {self.noise['scale']} uS, tau = {self.noise['tau']} ms"
  1080. with open(os.path.join(self.cwd, os.path.join(folder,"info.txt")), 'w') as f:
  1081. for key, value in metadata.items():
  1082. f.write(f"{key}: {value}\n")

network.py at commit 8b60bc2, under GPL-3.0 · at the source

Overview

Authors: Uri Dickman1,2, Peter J Thomas2,3,4,5,6, Hillel J Chiel3,7,8, John H Byrne9, Curtis L Neveu9
ORCID iDs: Uri Dickman
  1. Department of Mechanical Engineering, University of California, Santa Barbara, Santa Barbara, CA, United States
  2. Department of Mathematics, Applied Mathematics, and Statistics, Case Western Reserve University, Cleveland, OH, United States
  3. Department of Biology, Case Western Reserve University, Cleveland, OH, United States
  4. Department of Cognitive Science, Case Western Reserve University, Cleveland, OH, United States
  5. Department of Electrical, Computer, and Systems Engineering, Case Western Reserve University, Cleveland, OH, United States
  6. Department of Computer and Data Sciences, Case Western Reserve University, Cleveland, OH, United States
  7. Department of Neurosciences, Case Western Reserve University, Cleveland, OH, United States
  8. Department of Biomedical Engineering, Case Western Reserve University, Cleveland, OH, United States
  9. Department of Neurobiology and Anatomy, W.M. Keck Center for the Neurobiology of Learning and Memory, McGovern Medical School at the University of Texas Health Science Center, Houston, TX, United States
Institutions: University of California, Santa Barbara (United States); Case Western Reserve University (United States); The University of Texas Health Science Center at Houston (United States)
Journal: Frontiers in computational neuroscience, volume 20, article 1771884
Dates: received 19 December 2025; accepted 9 April 2026; published online 19 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fncom.2026.1771884 · PMID 42238303 · PMCID PMC13226625 · OpenAlex W7161626892
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: computational modeling (no new data) (modality), other (organism)
Methods: Machine learning
Keywords: Aplysia californica, central pattern generators, conductance-based modeling, NEURON, Python, SNNAP
Topic: Neurobiology and Insect Physiology Research (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Funding: NINDS NIH HHS (R01 NS118606)
Citations: not cited yet (Europe PMC); 71 references in the paper

Abstract

Introduction: NEURON has been widely used as an empirically-based simulation tool, especially for multi-compartment conductance-based neuronal modeling. The network mediating feeding in Aplysia californica has been extensively studied as a model central pattern generator. Understanding the relationship between network parameter values and their effect on animal behavior is of key importance in systems such as the Aplysia feeding apparatus, where detailed biophysical models can be constructed.

Objective: This study aims to develop a new Python tool called NEURONpyxl that reads parameters from a spreadsheet to construct full neural networks to make it easier to create complex models in the NEURON simulation environment, incorporating short-term forms of plasticity such as depression or facilitation.

Methods: Test simulations from well-understood networks were created in NEURONpyxl, and compared to simulation results of the same network in another neural simulator, the Simulator for Neural Networks and Action Potentials (SNNAP), which has previously been used to model conductance-based networks that include complex synaptic connections and multiple forms of synaptic plasticity. NEURONpyxl was then used to conduct a parameter grid search to optimize conductances in a previously developed network model of Aplysia feeding behavior.

Results: Simulations of the test networks in NEURONpyxl and SNNAP produced numerically equivalent results, with differences remaining within the expected margin of error arising from numerical integration and implementation details. We then located parameter values that generated simulated motor patterns with durations of protraction and retraction that matched biological feeding behavior under different mechanical loads.

Conclusion: NEURONpyxl simplifies building and simulating complex neural networks with different forms of synaptic plasticity, and locating physiologically relevant parameter values. With NEURONpyxl, future work may include the creation of ensembles of network models and the integration of biomechanics with complex conductance-based networks.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repositories

Its files are read in the Code ↔ Paper reader above, with 13 matches between paragraphs and lines of code.

CWRUChielLab/neuronpyxl

License: GPL-3.0
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 8b60bc23871401509b5800aa525d1c8708cb9b0f, 9 June 2026
Languages: Python (14), NEURON (9)
Size: 37 files, 23 scripts
Software Heritage: not archived
Found in: “Data availability statement”
Holds: license file, environment (environment.yml, setup.py), documentation
Not found: README, CITATION.cff, tests, continuous integration
Tools: NEURON (15 files), NumPy (6 files), pandas (6 files), Matplotlib (5 files), SciPy (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
24 files
At the source: github.com/CWRUChielLab/neuronpyxl

CWRUChielLab/NEURONpyxl-2026-figures

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: f61a6bdc20ad01dce46666698760893643e7e021, 18 May 2026
Languages: Python (17)
Size: 30 files, 17 scripts
Software Heritage: not archived
Found in: “Data availability statement”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: pandas (13 files), Matplotlib (12 files), NumPy (12 files), SciPy (3 files), NEURON (2 files)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
18 files, not copied: shown from their source

OSCR keeps no copy of these files: this repository has no license that allows it. The reader above shows each one from its source, fetched by your browser at commit f61a6bd, when its fingerprint is the one OSCR verified. How this works.

At the source: github.com/CWRUChielLab/NEURONpyxl-2026-figures

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 40 scripts, each with its path and the digest of its content;
  • 13 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

Datasets cited

Data availability statement

The datasets presented in this study can be found in online repositories. The names of the repository/repositories and accession number(s) can be found below: https://doi.org/10.5061/dryad.1c59zw488, Dryad; https://github.com/CWRUChielLab/neuronpyxl and https://github.com/CWRUChielLab/NEURONpyxl-2026-figures, GitHub.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 5 authors, 6 keywords, 1 funder, 70 references.

Cite

This paper

Dickman, U., Thomas, P. J., Chiel, H. J., Byrne, J. H., & Neveu, C. L. (2026). NEURONpyxl: fast, flexible, Python-integrated simulation of biophysical neural networks with complex plastic synapses. Frontiers in computational neuroscience, 20, 1771884. https://doi.org/10.3389/fncom.2026.1771884

BibTeX

@article{dickman2026neuronpyxl,
author = {Dickman, Uri and Thomas, Peter J and Chiel, Hillel J and Byrne, John H and Neveu, Curtis L},
title = {{NEURONpyxl: fast, flexible, Python-integrated simulation of biophysical neural networks with complex plastic synapses}},
journal = {Frontiers in computational neuroscience},
year = {2026},
month = may,
volume = {20},
pages = {1771884},
publisher = {Frontiers Media SA},
issn = {1662-5188},
doi = {10.3389/fncom.2026.1771884},
url = {https://doi.org/10.3389/fncom.2026.1771884},
pmid = {42238303},
pmcid = {PMC13226625}
}

RIS

TY - JOUR
AU - Dickman, Uri
AU - Thomas, Peter J
AU - Chiel, Hillel J
AU - Byrne, John H
AU - Neveu, Curtis L
TI - NEURONpyxl: fast, flexible, Python-integrated simulation of biophysical neural networks with complex plastic synapses
T2 - Frontiers in computational neuroscience
J2 - Front Comput Neurosci
PY - 2026
DA - 2026/05/19
VL - 20
SP - 1771884
SN - 1662-5188
PB - Frontiers Media SA
DO - 10.3389/fncom.2026.1771884
UR - https://doi.org/10.3389/fncom.2026.1771884
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fncom.2026.1771884",
"type": "article-journal",
"title": "NEURONpyxl: fast, flexible, Python-integrated simulation of biophysical neural networks with complex plastic synapses",
"container-title": "Frontiers in computational neuroscience",
"author": [
{
"family": "Dickman",
"given": "Uri"
},
{
"family": "Thomas",
"given": "Peter J"
},
{
"family": "Chiel",
"given": "Hillel J"
},
{
"family": "Byrne",
"given": "John H"
},
{
"family": "Neveu",
"given": "Curtis L"
}
],
"container-title-short": "Front Comput Neurosci",
"volume": "20",
"page": "1771884",
"DOI": "10.3389/fncom.2026.1771884",
"PMID": "42238303",
"PMCID": "PMC13226625",
"ISSN": "1662-5188",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fncom.2026.1771884",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
19
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1016/j.isci.2026.117375 [code]
Motor priming is associated with widespread recruitment into neural ensembles and more rapid ensemble transitions.
Journal: iScience
In common: pandas, SciPy, Matplotlib, 1 other tool, other, 11 references
[2] doi:10.1016/j.celrep.2026.117793 [code]
Clustered inputs engage dendritic nonlinearities and calcium signaling to support efficient place-field formation in CA1 pyramidal neurons.
Journal: Cell reports
In common: NEURON, pandas, SciPy, 2 other tools, computational modeling (no new data), 1 reference
[3] doi:10.1093/bioinformatics/btag328 [code]
eFEL: electrophysiology feature extraction library.
Journal: Bioinformatics (Oxford, England)
In common: NEURON, pandas, SciPy, 2 other tools, 1 reference
[4] doi:10.1126/sciadv.aec3961 [code]
Linking functional and structural dendritic spine remodeling during fear learning and extinction in vivo.
Journal: Science advances
In common: NEURON, pandas, SciPy, 2 other tools, 1 reference
[5] doi:10.1371/journal.pcbi.1014304 [code]
Linking reduced prefrontal microcircuit inhibition in schizophrenia to EEG biomarkers in silico.
Journal: PLoS computational biology
In common: NEURON, pandas, SciPy, 2 other tools, 1 reference
[6] doi:10.1371/journal.pcbi.1014458 [code]
Neuronal excitability and parameter variability in the Hodgkin-Huxley model.
Journal: PLoS computational biology
In common: pandas, SciPy, Matplotlib, 1 other tool, computational modeling (no new data), 2 references
[7] doi:10.1371/journal.pcbi.1014337 [code]
Fast reconstruction of degenerate populations of conductance-based neuron models from spike times.
Journal: PLoS computational biology
In common: pandas, SciPy, Matplotlib, 1 other tool, computational modeling (no new data), 2 references
[8] doi:10.1038/s41467-026-75704-3 [code]
A minimal model of working memory in neural systems and neuromorphic circuits.
Journal: Nature communications
In common: SciPy, Matplotlib, NumPy, computational modeling (no new data), 2 references
[9] doi:10.7554/elife.89629 [code]
Active dendrites enable robust spiking computations despite timing jitter.
Journal: eLife
In common: NEURON, pandas, Matplotlib, 1 other tool, 1 reference
[10] doi:10.1007/s12021-025-09766-x [code]
The Neural Analysis Toolkit Unifies Semi-Analytical Techniques to Simplify, Understand, and Simulate Dendrites.
Journal: Neuroinformatics
In common: computational modeling (no new data), 3 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.