OSCR

CASCADE: criticality avalanche spike cross-platform analysis detection engine, a multi-manufacturer MEA bash analysis pipeline.

Code ↔ Paper

10 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 10 matches
  1. [1] § 2 Materials and methods ↔ cascade/core/spikes.py, lines 37–88 · score 0.94 · refractory period violation, electrical noise, inter spike intervals, maximum firing rate, electrode filter, removes channels
  2. [2] § 2 Materials and methods ↔ cascade/core/avalanche.py, lines 1–28 · score 0.83 · Neuronal avalanche detection, empty bins, population activity, percentile threshold, inter, consecutive
  3. [3] § 2 Materials and methods ↔ cascade/run_analysis.py, lines 220–281 · score 0.83 · refractory period violation, electrical noise, inter spike intervals, electrode filter, removes channels, RPV
  4. [4] § 2 Materials and methods ↔ cascade/utils/io.py, lines 60–118 · score 0.82 · population activity percentile, power law, duration exponent, SCE, BR, DCC
  5. [5] § 3 Result ↔ cascade/run_analysis.py, lines 1–72 · score 0.65 · percentile threshold, firing rate, post, CL1, ae, MCS
  6. [6] § 2 Materials and methods ↔ cascade/run_analysis.py, lines 326–367 · score 0.63 · Pearson correlation, spatial entropy, correlation threshold, active electrodes, connectivity, consecutive
  7. [7] § 2 Materials and methods ↔ cascade/loaders/cl1_loader.py, lines 1–38 · score 0.62 · Cortical Lab, game recording, CL1, loaders, CASCADE, spike
  8. [8] § 2 Materials and methods ↔ cascade/core/bursts.py, lines 13–54 · score 0.58 · population spike train, Network bursts
  9. [9] § 2 Materials and methods ↔ cascade/run_analysis.py, lines 1–72 · score 0.58 · Cortical Lab, unified, CL1, bxr, MCS, Axion
  10. [10] § 2 Materials and methods ↔ cascade/core/connectivity.py, lines 1–8 · score 0.55 · Pearson correlation, Functional connectivity

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 · 706 lines · 38 KB · Apache-2.0 · 4 matches

  1. #!/usr/bin/env python
  2. """
  3. run_analysis.py
  4. ---------------
  5. Unified MEA analysis pipeline.
  6. Supports 3Brain (.bxr), Maxwell (.h5), MCS (.h5), Cortical Labs (.h5),
  7. and Axion BioSystems (.csv) files.
  8. Adding a new manufacturer = write one new loader in loaders/ only.
  10. Usage examples
  11. --------------
  12. # 3Brain file:
  13. python run_analysis.py --input recording.bxr --manufacturer 3brain --output results/
  15. # Maxwell file:
  16. python run_analysis.py --input data.raw.h5 --manufacturer maxwell --output results/
  18. # CL1 file:
  19. python run_analysis.py --input recording.h5 --manufacturer cl --output results/
  21. # MCS file:
  22. python run_analysis.py --input recording.h5 --manufacturer mcs --output results/
  24. # Axion spike-list CSV:
  25. python run_analysis.py --input recording_spike_list.csv --manufacturer axion --output results/
  27. # With active-electrode filter and Habibollahi threshold:
  28. python run_analysis.py --input recording.bxr --manufacturer 3brain --ae 5 --perc 0.25 --output results/
  30. # With epoch comparison (pre vs post stimulation):
  31. python run_analysis.py --input recording.bxr --manufacturer 3brain --epochA 0,60 --epochB 120,60 --output results/
  33. Flags
  34. -----
  35. --input path to data file (auto-searched if omitted)
  36. --manufacturer 3brain | maxwell | cl | mcs | axion (required)
  37. --well well/stream name (default: first available)
  38. --start start of analysis window in seconds (default: 0)
  39. --dur duration of analysis window in seconds (default: full recording)
  40. --output output folder (default: mea_out)
  41. --bin bin size for firing rates in seconds (default: 1.0)
  42. --ae active-electrode filter: keep channels with >= X spikes/min (default: 0 = off)
  43. --max_rate noisy-electrode filter: remove channels with > X spikes/min (default: 0 = off)
  44. recommended: 1000 (≈ 17 Hz) for in-vitro MEA
  45. --max_rpv noisy-electrode filter: remove channels with > X% of ISIs < 2 ms (default: 0 = off)
  46. recommended: 1.0–2.0% for in-vitro MEA
  47. --ava_size minimum avalanche size in spikes (default: 2)
  48. --ava_dur minimum avalanche duration in bins (default: 1 — no duration filter)
  49. --perc percentile threshold for avalanche detection (default: 0.0 = off)
  50. 0.0 = any spike counts; 0.25 = Habibollahi 2022 default
  51. --aval_dt avalanche bin width in seconds (default: inferred from mean ISI)
  52. --burst_min_spikes min spikes in a run to count as a network burst (default: 5)
  53. --burst_max_gap max gap between consecutive spikes within a burst in seconds (default: 0.1)
  54. --burst_min upper xmin limit for size power-law fit (default: 12)
  55. --t_min upper xmin limit for duration power-law fit (default: 4)
  56. --conn_thr |r| threshold for connectivity edges (default: 0.3)
  57. --entropy_win window size for entropy and active-area curves in seconds (default: 10)
  58. --sc_Dmin shape collapse: min avalanche duration in bins (default: 4)
  59. --sc_Dmax shape collapse: max avalanche duration in bins (default: 20)
  60. --epochA epoch A window: 'start,duration' in seconds e.g. '0,60'
  61. --epochB epoch B window: 'start,duration' in seconds e.g. '120,60'
  62. --svg also save all figures as SVG (default: PNG only)
  63. --jpg also save all figures as JPG (default: PNG only)
  64. --verbose print progress messages
  65. """
  67. import argparse
  68. import glob
  69. import os
  70. import sys
  71. import numpy as np
  72. import pandas as pd
  74. # ── imports from this package ──────────────────────────────────────────────────
  75. from cascade.loaders.brainwave_loader import BrainwaveLoader
  76. from cascade.loaders.maxwell_loader import MaxwellLoader
  77. from cascade.loaders.cl1_loader import CL1Loader
  78. from cascade.loaders.mcs_loader import MCSLoader
  79. from cascade.loaders.axion_loader import AxionLoader
  80. from cascade.core.spikes import filter_active_electrodes, filter_noisy_electrodes, bin_spikes, compute_isi_metrics
  81. from cascade.core.bursts import compute_burst_metrics, compute_active_area
  82. from cascade.core.avalanche import infer_dt, compute_avalanches, counts_per_dt
  83. from cascade.core.criticality import compute_exponents, compute_branching_ratio, shape_collapse
  84. from cascade.core.connectivity import compute_connectivity, summarize_connectivity
  85. from cascade.core.entropy import compute_entropy
  86. from cascade.core.plots import (plot_raster, plot_rate_heatmap, plot_population_rate,
  87. plot_burst_timeline, plot_active_area_curve,
  88. plot_waveforms, plot_corr_heatmap, plot_degree_histogram,
  89. plot_avalanche_distributions, plot_loglog_linearization,
  90. plot_shape_collapse, plot_entropy_curve, plot_epoch_compare)
  91. from cascade.utils.common import say, banner, step, CYAN, GRN, YEL, RED
  92. from cascade.utils.io import write_csv, write_tsv, write_criticality_report, write_run_log, _Tee
  95. # ── manufacturer auto-detection ────────────────────────────────────────────────
  96. def _peek_h5_manufacturer(path: str) -> str:
  97. """Peek inside an HDF5 file to distinguish CL1 / MCS / Maxwell."""
  98. try:
  99. import h5py
  100. with h5py.File(path, "r") as h5:
  101. sid = h5.attrs.get("system_id", b"")
  102. if isinstance(sid, (bytes, np.bytes_)):
  103. sid = sid.decode("ascii", errors="replace")
  104. if str(sid).upper().startswith("CL1"):
  105. return "cl"
  106. if "McsHdf5ProtocolType" in h5.attrs:
  107. return "mcs"
  108. except Exception:
  109. pass
  110. return "maxwell"
  113. def detect_manufacturer(path: str) -> str:
  114. ext = os.path.splitext(path)[1].lower()
  115. if ext == ".bxr":
  116. return "3brain"
  117. if ext in (".h5", ".hdf5"):
  118. return _peek_h5_manufacturer(path)
  119. return "unknown"
  122. def get_loader(manufacturer: str):
  123. if manufacturer == "3brain":
  124. return BrainwaveLoader()
  125. if manufacturer == "maxwell":
  126. return MaxwellLoader()
  127. if manufacturer == "cl":
  128. return CL1Loader()
  129. if manufacturer == "mcs":
  130. return MCSLoader()
  131. if manufacturer == "axion":
  132. return AxionLoader()
  133. raise ValueError(f"Unknown manufacturer '{manufacturer}'. "
  134. f"Supported: 3brain, maxwell, cl, mcs, axion")
  137. # ── epoch comparison helper ────────────────────────────────────────────────────
  138. def _parse_epoch(s: str):
  139. try:
  140. a, b = s.split(",")
  141. return float(a), float(b)
  142. except Exception:
  143. return None
  146. def _epoch_stats(spike_times: dict, start: float, dur: float,
  147. all_channels: list) -> dict:
  148. end = start + dur
  149. sub = {ch: t[(t >= start) & (t < end)]
  150. for ch, t in spike_times.items()}
  151. all_t = np.concatenate(list(sub.values())) if sub else np.array([])
  153. pop_rate = 0.0
  154. if all_t.size > 0 and dur > 0:
  155. pop_rate = float(all_t.size / dur / max(len(all_channels), 1))
  157. n_active = sum(1 for t in sub.values() if t.size > 0)
  158. n_total = max(len(all_channels), 1)
  159. return dict(pop_rate=pop_rate,
  160. active_area=float(n_active / n_total))
  163. # ── main pipeline ──────────────────────────────────────────────────────────────
  164. def main():
  165. ap = argparse.ArgumentParser(
  166. prog="cascade",
  167. description=(
  168. "CASCADE — Criticality Avalanche Spike Cross-platform Analysis "
  169. "Detection Engine\n"
  170. "Unified MEA analysis pipeline supporting multiple manufacturers.\n\n"
  171. "Outputs: raster plot, rate heatmap, burst detection, active area,\n"
  172. " connectivity, neuronal avalanches, criticality metrics\n"
  173. " (DCC, branching ratio, shape collapse), entropy.\n\n"
  174. "Other CASCADE tools:\n"
  175. " cascade-info Quick recording inspector (duration, channels,\n"
  176. " active electrodes, time-window support)\n"
  177. " Usage: python scanner.py --help\n\n"
  178. " cascade-ltpltd LTP/LTD classification from firing-rate CSVs\n"
  179. " Usage: python ltpltd.py --help\n\n"
  180. "Example:\n"
  181. " cascade --input recording.bxr --output results/ --ae 5 --ava_size 2 --verbose"
  182. ),
  183. formatter_class=argparse.RawDescriptionHelpFormatter
  184. )
  186. ap.add_argument("--version", action="version", version="CASCADE v0.8.0")
  187. ap.add_argument("--test", action="store_true",
  188. help="Run the built-in self-test with synthetic data. "
  189. "No recording file required.")
  191. # ── input / output ─────────────────────────────────────────────────────────
  192. io_group = ap.add_argument_group("Input / Output")
  193. io_group.add_argument("--input",
  194. default=None,
  195. help="Path to the data file (.bxr or .h5). "
  196. "If omitted, CASCADE searches the current folder.")
  197. io_group.add_argument("--manufacturer",
  198. required=False, default=None,
  199. choices=["3brain", "maxwell", "cl", "mcs", "axion"],
  200. help="MEA manufacturer (required except with --test). "
  201. "3brain (.bxr), maxwell (.h5), cl (.h5), mcs (.h5), axion (.csv)")
  202. io_group.add_argument("--well",
  203. default=None,
  204. help="Well or stream name to analyse (e.g. Well_A1 for 3Brain, "
  205. "data0000 for Maxwell). Default: first available well.")
  206. io_group.add_argument("--output",
  207. default="mea_out",
  208. help="Output folder for all figures and data files. "
  209. "Created automatically if it does not exist. (default: mea_out)")
  210. io_group.add_argument("--svg",
  211. action="store_true",
  212. help="Also save all figures as SVG.")
  213. io_group.add_argument("--jpg",
  214. action="store_true",
  215. help="Also save all figures as JPG (300 dpi).")
  216. io_group.add_argument("--verbose",
  217. action="store_true",
  218. help="Print detailed progress messages to the terminal.")
  220. # ── recording window ───────────────────────────────────────────────────────
  221. win_group = ap.add_argument_group("Recording Window")
  222. win_group.add_argument("--start",
  223. type=float, default=0.0,
  224. help="Start of the analysis window in seconds. (default: 0)")
  225. win_group.add_argument("--dur",
  226. type=float, default=None,
  227. help="Duration of the analysis window in seconds. "
  228. "Default: full recording length.")
  230. # ── spike filtering ────────────────────────────────────────────────────────
  231. spike_group = ap.add_argument_group("Spike Filtering")
  232. spike_group.add_argument("--ae",
  233. type=float, default=0.0,
  234. help="Active electrode filter. Keep only channels that fired "
  235. "at least X spikes per minute. Set to 0 to keep all "
  236. "channels. (default: 0 = off)")
  237. spike_group.add_argument("--max_rate",
  238. type=float, default=0.0,
  239. help="Noisy-electrode filter: remove channels whose firing rate "
  240. "exceeds this value (spikes per minute). Electrodes with "
  241. "abnormally high rates are typically recording electrical "
  242. "noise rather than real neurons. Set to 0 to disable. "
  243. "Recommended starting value: 1000 (≈ 17 Hz). (default: 0 = off)")
  244. spike_group.add_argument("--max_rpv",
  245. type=float, default=0.0,
  246. help="Noisy-electrode filter: remove channels where more than "
  247. "this percentage of inter-spike intervals are shorter than "
  248. "2 ms (refractory period violation). Real neurons cannot "
  249. "fire faster than ~500 Hz; a high violation rate indicates "
  250. "electrical noise. Set to 0 to disable. "
  251. "Recommended starting value: 1.0 (1%%). (default: 0 = off)")
  252. spike_group.add_argument("--bin",
  253. type=float, default=1.0,
  254. help="Bin size in seconds for computing per-channel firing "
  255. "rates (used for heatmap and connectivity). (default: 1.0)")
  257. # ── avalanche detection ────────────────────────────────────────────────────
  258. ava_group = ap.add_argument_group("Avalanche Detection")
  259. ava_group.add_argument("--ava_size",
  260. type=int, default=2,
  261. help="Minimum avalanche size (total spikes). Avalanches with "
  262. "fewer than X spikes are discarded. (default: 2)")
  263. ava_group.add_argument("--ava_dur",
  264. type=int, default=1,
  265. help="Minimum avalanche duration (bins). Avalanches spanning "
  266. "fewer than X bins are discarded. Default is 1 (no "
  267. "duration filter) because single-bin events are valid "
  268. "avalanches — they represent synchronous bursts where "
  269. "many channels fire within one Δt window. (default: 1)")
  270. ava_group.add_argument("--aval_dt",
  271. type=float, default=None,
  272. help="Avalanche bin width in seconds. Default: automatically "
  273. "inferred from the mean inter-spike interval (ISI) of the "
  274. "population, clipped to 1–50 ms.")
  275. ava_group.add_argument("--perc",
  276. type=float, default=0.0,
  277. help="Percentile threshold for avalanche detection. The bin "
  278. "count must exceed this percentile of all bin counts to "
  279. "be included in an avalanche. 0.0 = any spike counts "
  280. "(recommended for clean in-vitro spike data). 0.25 = "
  281. "Habibollahi 2022 default for noisy recordings. (default: 0.0)")
  283. # ── criticality metrics ────────────────────────────────────────────────────
  284. crit_group = ap.add_argument_group("Criticality Metrics")
  285. crit_group.add_argument("--burst_min",
  286. type=int, default=12,
  287. help="Upper limit for the xmin search in the avalanche SIZE "
  288. "power-law fit. The algorithm tries xmin values from 1 "
  289. "to this number and picks the best one. Recommended: "
  290. "8–20. (default: 12)")
  291. crit_group.add_argument("--t_min",
  292. type=int, default=4,
  293. help="Upper limit for the xmin search in the avalanche "
  294. "DURATION power-law fit. Recommended: 3–6. (default: 4)")
  295. crit_group.add_argument("--pl_xmin_S",
  296. type=float, default=None,
  297. help="Manually override the xmin for the size power-law fit. "
  298. "Default: auto-detected. Use this if the automatic result "
  299. "looks wrong on your data.")
  300. crit_group.add_argument("--pl_xmin_D",
  301. type=float, default=None,
  302. help="Manually override the xmin for the duration power-law "
  303. "fit. Default: auto-detected.")
  304. crit_group.add_argument("--skip_rare_sizes",
  305. action="store_true",
  306. help="On the size log-log plot, exclude avalanche sizes that "
  307. "occurred only once in the recording. These rare points "
  308. "can distort the visual fit line. Does NOT affect the "
  309. "MLE exponent value.")
  310. crit_group.add_argument("--skip_rare_durations",
  311. action="store_true",
  312. help="Same as --skip_rare_sizes but for the duration log-log "
  313. "plot.")
  315. # ── shape collapse ─────────────────────────────────────────────────────────
  316. sc_group = ap.add_argument_group("Shape Collapse")
  317. sc_group.add_argument("--sc_Dmin",
  318. type=int, default=4,
  319. help="Minimum avalanche duration (in bins) to include in the "
  320. "shape collapse analysis. (default: 4)")
  321. sc_group.add_argument("--sc_Dmax",
  322. type=int, default=20,
  323. help="Maximum avalanche duration (in bins) to include in the "
  324. "shape collapse analysis. (default: 20)")
  326. # ── burst detection ────────────────────────────────────────────────────────
  327. burst_group = ap.add_argument_group("Burst Detection")
  328. burst_group.add_argument("--burst_min_spikes",
  329. type=int, default=5,
  330. help="Minimum number of spikes required for a run to be "
  331. "counted as a network burst. Lower values detect more, "
  332. "shorter bursts (MEAanalysis default: 5). "
  333. "Higher values require denser events. (default: 5)")
  334. burst_group.add_argument("--burst_max_gap",
  335. type=float, default=0.1,
  336. help="Maximum allowed gap between consecutive spikes (seconds) "
  337. "within a burst. Spikes further apart than this split the "
  338. "burst into two. (default: 0.1)")
  340. # ── connectivity ───────────────────────────────────────────────────────────
  341. conn_group = ap.add_argument_group("Connectivity")
  342. conn_group.add_argument("--conn_thr",
  343. type=float, default=0.3,
  344. help="Pearson correlation threshold for drawing a functional "
  345. "connectivity edge between two channels. Pairs with "
  346. "|r| >= this value are connected. (default: 0.3)")
  348. # ── entropy and active area ────────────────────────────────────────────────
  349. ea_group = ap.add_argument_group("Entropy and Active Area")
  350. ea_group.add_argument("--entropy_win",
  351. type=float, default=10.0,
  352. help="Window size in seconds for computing spatial entropy "
  353. "and active electrode fraction over time. (default: 10.0)")
  355. # ── epoch comparison ───────────────────────────────────────────────────────
  356. ep_group = ap.add_argument_group("Epoch Comparison (optional)")
  357. ep_group.add_argument("--epochA",
  358. default=None,
  359. help="First epoch window as 'start,duration' in seconds. "
  360. "Example: --epochA 0,60 for the first 60 seconds.")
  361. ep_group.add_argument("--epochB",
  362. default=None,
  363. help="Second epoch window as 'start,duration' in seconds. "
  364. "Example: --epochB 120,60 for 60 seconds starting at 2 min. "
  365. "Both --epochA and --epochB must be set to compare.")
  367. args = ap.parse_args()
  369. # ── self-test ──────────────────────────────────────────────────────────────
  370. if args.test:
  371. from cascade.tests.self_test import run_self_test
  372. sys.exit(run_self_test())
  374. if args.manufacturer is None:
  375. ap.error("--manufacturer is required. Choose from: 3brain, maxwell, cl, mcs, axion")
  377. svg = args.svg
  378. jpg = args.jpg
  379. v = args.verbose
  381. banner("CASCADE • Criticality Avalanche Spike Cross-platform Analysis Detection Engine • v0.8.0", enabled=v)
  383. # ── find file ──────────────────────────────────────────────────────────────
  384. path = args.input
  385. if not path:
  386. for pattern in ("*.bxr", "*.raw.h5", "*.h5"):
  387. hits = sorted(glob.glob(pattern))
  388. if hits:
  389. path = hits[0]
  390. break
  391. if not path:
  392. say("No data file found. Use --input <path>", "[FAIL]", RED)
  393. sys.exit(1)
  395. # ── load manufacturer ──────────────────────────────────────────────────────
  396. mfr = args.manufacturer
  397. loader = get_loader(mfr)
  398. say(f"File: {path}", "[DIR]", CYAN, enabled=v)
  399. say(f"Manufacturer: {loader.manufacturer_name()}", "[CHECK]", CYAN, enabled=v)
  401. # ── load data ──────────────────────────────────────────────────────────────
  402. step("Loading data", enabled=v)
  403. rec = loader.load(path,
  404. well = args.well,
  405. start_s = args.start,
  406. duration_s = args.dur)
  408. say(f"SR={rec.sampling_rate:.1f} Hz | "
  409. f"channels={rec.n_channels} | "
  410. f"duration={rec.duration:.1f} s | "
  411. f"spikes={rec.n_spikes():,}", "[OK]", GRN, enabled=v)
  413. os.makedirs(args.output, exist_ok=True)
  414. well_label = rec.metadata.get("well", "well")
  416. # ── active-electrode filter ────────────────────────────────────────────────
  417. step("Active-electrode filter", enabled=v)
  418. spike_times = filter_active_electrodes(rec.spike_times, args.ae, rec.duration)
  419. n_active = len(spike_times)
  420. say(f"Channels kept (>= {args.ae} spikes/min): {n_active}", "[DATA]", CYAN, enabled=v)
  421. if n_active == 0:
  422. print("[WARN] No active channels found after filtering. "
  423. "The recording may have very low firing activity, or --ae is set too high. "
  424. "Try lowering --ae or removing it entirely.")
  425. elif n_active == 1:
  426. print("[WARN] Only 1 active channel found. Connectivity analysis will be "
  427. "skipped (requires at least 2 channels). Avalanche and criticality metrics "
  428. "may be unreliable with a single electrode. Consider lowering --ae.")
  430. # ── noisy-electrode filter ─────────────────────────────────────────────────
  431. if args.max_rate > 0 or args.max_rpv > 0:
  432. step("Noisy-electrode filter", enabled=v)
  433. spike_times, n_removed, removed_ch = filter_noisy_electrodes(
  434. spike_times, rec.duration,
  435. max_rate_per_min=args.max_rate,
  436. max_rpv_pct=args.max_rpv,
  437. )
  438. say(f"Noisy channels removed: {n_removed} "
  439. f"(max_rate={args.max_rate} spk/min, max_rpv={args.max_rpv}%)",
  440. "[DATA]", CYAN, enabled=v)
  441. if n_removed > 0 and v:
  442. say(f"Removed channel IDs: {removed_ch[:20]}"
  443. f"{'…' if len(removed_ch) > 20 else ''}",
  444. "[DATA]", CYAN, enabled=v)
  445. n_active = len(spike_times)
  447. all_spikes = rec.all_spike_times() if (args.ae <= 0 and args.max_rate <= 0 and args.max_rpv <= 0) else \
  448. np.sort(np.concatenate(list(spike_times.values()))) \
  449. if spike_times else np.array([])
  451. # ── raster ────────────────────────────────────────────────────────────────
  452. step("Raster & rate heatmap", enabled=v)
  453. plot_raster(spike_times,
  454. f"{args.output}/raster_max_{well_label}.png",
  455. f"Spike raster — {well_label}", svg, jpg,
  456. n_channels=rec.n_channels)
  458. # active: remap electrode IDs to 0..N-1 so Y-axis max = number of active electrodes
  459. _sorted_chs = sorted(spike_times.keys())
  460. _ch_seq_map = {ch: i for i, ch in enumerate(_sorted_chs)}
  461. _st_active = {_ch_seq_map[ch]: times for ch, times in spike_times.items()}
  462. plot_raster(_st_active,
  463. f"{args.output}/raster_active_{well_label}.png",
  464. f"Spike raster (active) — {well_label}", svg, jpg)
  466. # ── firing rates ──────────────────────────────────────────────────────────
  467. rate_df = bin_spikes(spike_times, rec.duration, args.bin)
  468. write_tsv(rate_df, f"{args.output}/rates_{well_label}.tsv")
  469. plot_rate_heatmap(rate_df,
  470. f"{args.output}/rate_heatmap_max_{well_label}.png",
  471. f"Rate heatmap — {well_label} (bin={args.bin}s)", svg, jpg,
  472. n_channels=rec.n_channels)
  473. _rate_df_active = rate_df.copy()
  474. _rate_df_active["ch_idx"] = _rate_df_active["ch_idx"].map(_ch_seq_map)
  475. plot_rate_heatmap(_rate_df_active,
  476. f"{args.output}/rate_heatmap_active_{well_label}.png",
  477. f"Rate heatmap (active) — {well_label} (bin={args.bin}s)", svg, jpg)
  478. plot_population_rate(rate_df,
  479. f"{args.output}/population_rate_{well_label}.png",
  480. well_label, svg, jpg)
  482. # ── ISI metrics ────────────────────────────────────────────────────────────
  483. step("ISI metrics", enabled=v)
  484. isi_df = compute_isi_metrics(spike_times, rec.sampling_rate)
  485. write_tsv(isi_df, f"{args.output}/isi_metrics_{well_label}.tsv")
  487. # ── network bursts ─────────────────────────────────────────────────────────
  488. step("Network burst detection", enabled=v)
  489. burst_df, bsum = compute_burst_metrics(all_spikes,
  490. min_spikes=args.burst_min_spikes,
  491. max_gap_s=args.burst_max_gap)
  492. write_tsv(burst_df, f"{args.output}/bursts_{well_label}.tsv")
  493. plot_burst_timeline(burst_df, rec.duration,
  494. f"{args.output}/bursts_timeline_{well_label}.png",
  495. well_label, svg, jpg)
  496. say(f"Bursts: n={bsum['n_bursts']} "
  497. f"mean_dur={bsum['mean_duration_s']:.2f}s", "[DATA]", CYAN, enabled=v)
  498. if bsum["n_bursts"] == 0:
  499. print("[WARN] No network bursts detected. This is normal for low-activity "
  500. "recordings or recordings with sparse, uncorrelated firing.")
  502. # ── active area ────────────────────────────────────────────────────────────
  503. act_df = compute_active_area(spike_times, rec.duration, args.entropy_win)
  504. write_tsv(act_df, f"{args.output}/active_area_{well_label}.tsv")
  505. plot_active_area_curve(act_df,
  506. f"{args.output}/active_area_curve_{well_label}.png",
  507. well_label, svg, jpg)
  509. # ── waveforms (3Brain only) ────────────────────────────────────────────────
  510. if mfr == "3brain" and rec.metadata.get("has_waveforms"):
  511. step("Spike waveforms", enabled=v)
  512. waves = loader.load_waveforms(path,
  513. well = rec.metadata.get("well"),
  514. start_s = args.start,
  515. duration_s = rec.duration)
  516. if waves:
  517. plot_waveforms(waves,
  518. f"{args.output}/wave_templates_{well_label}.png",
  519. well_label, svg, jpg)
  521. # ── connectivity ───────────────────────────────────────────────────────────
  522. step("Connectivity (Pearson correlation)", enabled=v)
  523. if rate_df.shape[1] < 2:
  524. say("Skipped -- fewer than 2 active channels", "[WARN]", YEL, enabled=v)
  525. C, ch_ids = None, []
  526. else:
  527. C, ch_ids = compute_connectivity(rate_df, zscore=True)
  528. if C is not None:
  529. np.savetxt(f"{args.output}/corr_{well_label}.tsv", C, delimiter="\t")
  530. plot_corr_heatmap(C,
  531. f"{args.output}/corr_heatmap_max_{well_label}.png",
  532. args.conn_thr, well_label, svg, jpg,
  533. channel_ids=ch_ids,
  534. n_channels=rec.n_channels)
  535. plot_corr_heatmap(C,
  536. f"{args.output}/corr_heatmap_active_{well_label}.png",
  537. args.conn_thr, well_label, svg, jpg,
  538. channel_ids=ch_ids)
  539. deg_df, csum = summarize_connectivity(C, ch_ids, args.conn_thr)
  540. write_tsv(deg_df, f"{args.output}/degrees_{well_label}.tsv")
  541. plot_degree_histogram(deg_df,
  542. f"{args.output}/degree_hist_{well_label}.png",
  543. well_label, svg, jpg)
  544. say(f"Edges |r|>={args.conn_thr}: {csum['n_edges']} "
  545. f"density={csum['edge_density']:.4f}", "[DATA]", CYAN, enabled=v)
  547. # ── avalanches ─────────────────────────────────────────────────────────────
  548. step("Neuronal avalanches", enabled=v)
  549. dt = args.aval_dt if args.aval_dt is not None else infer_dt(all_spikes)
  550. say(f"Δt = {dt*1000:.2f} ms | "
  551. f"perc threshold = {args.perc*100:.0f}%", "[FAST]", CYAN, enabled=v)
  553. av_df = compute_avalanches(all_spikes, dt, perc=args.perc)
  555. # apply size/duration threshold
  556. av_df = av_df[
  557. (av_df["avalanche_size"] >= args.ava_size) &
  558. (av_df["duration_bins"] >= args.ava_dur)
  559. ].reset_index(drop=True)
  561. write_tsv(av_df, f"{args.output}/avalanches_{well_label}.tsv")
  562. plot_avalanche_distributions(av_df,
  563. f"{args.output}/avalanches_{well_label}",
  564. well_label, svg, jpg)
  565. say(f"Avalanches after threshold (size>={args.ava_size}, dur>={args.ava_dur}): {len(av_df)}", "[DATA]", CYAN, enabled=v)
  566. if av_df.empty:
  567. print("[WARN] No avalanches passed the size/duration threshold. "
  568. "Criticality metrics (tau, alpha, DCC, branching ratio) cannot be computed. "
  569. "Try lowering --ava_size (current: {}) or --ava_dur (current: {}) or --perc (current: {}).".format(
  570. args.ava_size, args.ava_dur, args.perc))
  571. elif len(av_df) < 50:
  572. print(f"[WARN] Only {len(av_df)} avalanches detected. Power-law fitting "
  573. "requires many events for reliable results -- interpret criticality metrics "
  574. "with caution. Consider lowering --ava_size, --ava_dur, or --perc.")
  576. # ── criticality metrics ────────────────────────────────────────────────────
  577. step("Criticality metrics (exponents, DCC, BR, shape collapse)", enabled=v)
  578. sizes = av_df["avalanche_size"].to_numpy() if not av_df.empty else np.array([])
  579. durations = av_df["duration_bins"].to_numpy() if not av_df.empty else np.array([])
  581. exp_metrics = compute_exponents(sizes, durations,
  582. burst_min=args.burst_min,
  583. t_min=args.t_min)
  585. # log–log plots with fitted lines
  586. # --pl_xmin_S/D override the auto-detected xmin for the visual fit line
  587. # --skip_rare_sizes/durations excludes single-occurrence points from the OLS line
  588. xmin_s = args.pl_xmin_S if args.pl_xmin_S is not None else exp_metrics.get("xmin_s")
  589. xmin_d = args.pl_xmin_D if args.pl_xmin_D is not None else exp_metrics.get("xmin_d")
  591. plot_loglog_linearization(
  592. sizes,
  593. f"{args.output}/loglog_size_{well_label}.png",
  594. f"Log–log size — {well_label}",
  595. tau=exp_metrics.get("tau"), xmin=xmin_s,
  596. exclude_singletons=args.skip_rare_sizes,
  597. save_svg=svg, save_jpg=jpg)
  598. plot_loglog_linearization(
  599. durations,
  600. f"{args.output}/loglog_duration_{well_label}.png",
  601. f"Log–log duration — {well_label}",
  602. tau=exp_metrics.get("alpha"), xmin=xmin_d,
  603. exclude_singletons=args.skip_rare_durations,
  604. save_svg=svg, save_jpg=jpg)
  606. # branching ratio
  607. counts, _ = counts_per_dt(all_spikes, dt)
  608. br, br_h, br_pts = compute_branching_ratio(counts)
  609. write_tsv(br_pts, f"{args.output}/branching_points_{well_label}.tsv")
  611. # shape collapse
  612. Dmin_eff = max(args.sc_Dmin, args.ava_dur)
  613. sc_beta, sce, sc_minerr, sc_details = shape_collapse(
  614. counts, exp_metrics.get("beta_pred", np.nan),
  615. Dmin=Dmin_eff, Dmax=args.sc_Dmax, min_size=args.ava_size)
  616. plot_shape_collapse(sc_details,
  617. f"{args.output}/shape_collapse_{well_label}.png",
  618. well_label, svg, jpg)
  620. # write text report
  621. crit_metrics = dict(
  622. well = well_label,
  623. dt = dt,
  624. ava_size_thr = args.ava_size,
  625. ava_dur_thr = args.ava_dur,
  626. perc = args.perc,
  627. tau = exp_metrics.get("tau", np.nan),
  628. xmin_s = exp_metrics.get("xmin_s", np.nan),
  629. alpha = exp_metrics.get("alpha", np.nan),
  630. xmin_d = exp_metrics.get("xmin_d", np.nan),
  631. beta_pred = exp_metrics.get("beta_pred", np.nan),
  632. beta_fit = exp_metrics.get("beta_fit", np.nan),
  633. dcc = exp_metrics.get("dcc", np.nan),
  634. br = br,
  635. br_intercept = br_h,
  636. sc_beta = sc_beta,
  637. sce = sce,
  638. sc_minerr = sc_minerr,
  639. )
  640. write_criticality_report(crit_metrics,
  641. f"{args.output}/criticality_report_{well_label}.txt")
  642. say(f"DCC={exp_metrics.get('dcc', float('nan')):.4f} "
  643. f"BR={br:.4f} SCE={sce:.4f}", "[CRIT]", CYAN, enabled=v)
  645. # ── entropy ────────────────────────────────────────────────────────────────
  646. step("Spatial entropy", enabled=v)
  647. ent_df = compute_entropy(spike_times, rec.duration, args.entropy_win)
  648. write_tsv(ent_df, f"{args.output}/entropy_{well_label}.tsv")
  649. plot_entropy_curve(ent_df,
  650. f"{args.output}/entropy_curve_{well_label}.png",
  651. well_label, svg, jpg)
  653. # ── epoch comparison (optional) ────────────────────────────────────────────
  654. if args.epochA and args.epochB:
  655. step("Epoch comparison", enabled=v)
  656. epA = _parse_epoch(args.epochA)
  657. epB = _parse_epoch(args.epochB)
  658. if epA and epB:
  659. stats = {
  660. "A": _epoch_stats(spike_times, epA[0], epA[1], rec.channel_ids),
  661. "B": _epoch_stats(spike_times, epB[0], epB[1], rec.channel_ids),
  662. }
  663. plot_epoch_compare(stats,
  664. f"{args.output}/epoch_compare_{well_label}.png",
  665. well_label, svg, jpg)
  666. say(f"Epoch A PopRate={stats['A']['pop_rate']:.3f} Hz "
  667. f"-> B PopRate={stats['B']['pop_rate']:.3f} Hz", "[DATA]", CYAN, enabled=v)
  668. else:
  669. say("Bad epoch format. Use 'start,dur' e.g. --epochA 0,60", "[WARN]", YEL)
  671. banner(f"ALL DONE • outputs in {args.output}", enabled=v)
  672. print(f"[OK] Done. Outputs saved in: {args.output}")
  675. def _run_with_log():
  676. import io as _io
  678. _cmd = "cascade " + " ".join(sys.argv[1:])
  679. _buf = _io.StringIO()
  680. _tee = _Tee(sys.stdout, _buf)
  681. sys.stdout = _tee
  683. _out = "mea_out"
  684. for _i, _arg in enumerate(sys.argv):
  685. if _arg == "--output" and _i + 1 < len(sys.argv):
  686. _out = sys.argv[_i + 1]
  687. break
  689. _status = "SUCCESS"
  690. _error = None
  691. try:
  692. main()
  693. except SystemExit:
  694. _status = "FAILED"
  695. raise
  696. except Exception as exc:
  697. _status = "FAILED"
  698. _error = str(exc)
  699. raise
  700. finally:
  701. sys.stdout = _tee._original
  702. write_run_log(_out, _cmd, _status, error=_error, output=_buf.getvalue())
  705. if __name__ == "__main__":
  706. _run_with_log()

run_analysis.py, under Apache-2.0 · at the source

Overview

Authors: Forbes Avila1,2, Jin Kim3,4, Jong-Chan Park5,6,7, Rian Kang7, Hyunsu Lee8,9,10, Sun-Hyun Park1,2
ORCID iDs: Sun-Hyun Park
  1. Center for Alternatives to Animal Testing, Korea Institute of Toxicology, Yuseong, Daejeon 34114, Republic of Korea
  2. Human and Environmental Toxicology, University of Science and Technology (UST), Yuseong, Daejeon 34113, Republic of Korea
  3. Department of Physiology, College of Medicine, Soonchunhyang University, Cheonan 31151, Republic of Korea
  4. Institute for Molecular Metabolism Innovation, Soonchunhyang University, Asan 31538, Republic of Korea
  5. Department of Biophysics, Institute of Quantum Biophysics, Sungkyunkwan University, Suwon 16419, Republic of Korea
  6. Department of MetaBioHealth, Sungkyunkwan University, Suwon 16419, Republic of Korea
  7. Department of Biopharmaceutical Convergence, Sungkyunkwan University, Suwon 16419, Republic of Korea
  8. Department of Physiology, School of Medicine, Pusan National University, Yangsan-si 50612, Republic of Korea
  9. Research Institute for Convergence of Biomedical Science and Technology, Pusan National University Yangsan Hospital, Yangsan-si 50612, Republic of Korea
  10. Medical Research Institute, School of Medicine, Pusan National University, Yangsan-si 50612, Republic of Korea
Institutions: Korea Institute of Toxicology (South Korea); Korea University of Science and Technology (South Korea); Soonchunhyang University (South Korea); Sungkyunkwan University (South Korea); Pusan National University Yangsan Hospital (South Korea); Pusan National University (South Korea)
Journal: Bioinformatics (Oxford, England), volume 42, issue 8, article btag570
Dates: received 21 April 2026; accepted 23 July 2026; published online 29 July 2026; in print August 2026
Type: Brief report · Language: English
License: CC BY
Identifiers: DOI 10.1093/bioinformatics/btag570 · PMID 42525390 · PMCID PMC13478863 · OpenAlex W7171740342
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: extracellular electrophysiology (units, LFP) (modality), methods / tools (subfield)
Methods: Connectivity, Single-unit activity, calcium imaging, Spectral & time-frequency, Statistics
MeSH: Action Potentials*, Neurons*, Software*, Algorithms, Animals, Electrodes, Nerve Net (* major topic)
Topic: Neuroscience and Neural Engineering (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Funding: National Research Foundation of Korea (NRF); The Korea Institute of Toxicology (KK-2607); Korea government (MSIT) (RS-2026-25520892, RS-2026-25514372); Research Institute for Convergence of Biomedical Science and Technology, Pusan National University Yangsan Hospital (30-2026-005); Korea Ministry of Food and Drug Safety (RS-2024-00331678)
Citations: not cited yet (Europe PMC); 17 references in the paper

Abstract

Summary: Multi-electrode array (MEA) recordings are widely utilized to characterize neuronal network activity. However, currently each manufacturer distributes proprietary software that operates exclusively on its own file format. Since no cross-platform, open-source pipeline currently exists. Thus, we created CASCADE (Criticality Avalanche Spike Cross-platform Analysis Detection Engine), a Python-based command-line (bash) pipeline to analyze MEA recordings from 3Brain, Axion Biosystems, Cortical Labs, Maxwell Biosystems, and Multi-Channel Systems MEA devices. CASCADE measures the standard parameters such as: network, burst, firing rate frequency, and also measures criticality and avalanches. CASCADE criticality calculation was benchmarked across six MEA recordings from five manufacturers, resulting in comparable values because all recordings were analyzed using identical computational methods regardless of manufacturer file format. Thus, CASCADE provides a flexible and robust MEA analysis pipeline that can also analyze neuronal avalanches and criticality from multiple MEA devices from different manufacturers.

Availability and implementation: CASCADE is freely available at GitHub repository (https://github.com/FA387/cascade-mea) and can be installed via PyPI (pip install cascade-mea). The source code is archived at Zenodo (https://doi.org/10.5281/zenodo.20840795). Data used in this work is available at Zenodo repository (https://doi.org/10.5281/zenodo.19161615). The data underlying this article are available in the article and in its online supplementary material.

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

Repository

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

Zenodo 20840795

License: Apache-2.0
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (18 files), pandas (12 files), h5py (7 files), Matplotlib (3 files), SciPy (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers (HTTP 200)
  • 26 September 2026: the link answers (HTTP 200)
27 files
At the source: doi.org/10.5281/zenodo.20840795

Availability and implementation

CASCADE is freely available at GitHub repository (https://github.com/FA387/cascade-mea) and can be installed via PyPI (pip install cascade-mea). The source code is archived at Zenodo (https://doi.org/10.5281/zenodo.20840795). Data used in this work is available at Zenodo repository (https://doi.org/10.5281/zenodo.19161615). The data underlying this article are available in the article and in its online supplementary material.

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

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:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 25 scripts, each with its path and the digest of its content;
  • 10 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

CASCADE is freely available at GitHub repository (https://github.com/FA387/cascade-mea) and can be installed via PyPI (pip install cascade-mea). The source code is archived at Zenodo (https://doi.org/10.5281/zenodo.20840795). Data used in this work are available at Zenodo repository (https://doi.org/10.5281/zenodo.19161615). The data underlying this article are available in the article and in its online supplementary material.

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, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 7 MeSH terms, 5 funders, 17 references.

Cite

This paper

Avila, F., Kim, J., Park, J.-C., Kang, R., Lee, H., & Park, S.-H. (2026). CASCADE: criticality avalanche spike cross-platform analysis detection engine, a multi-manufacturer MEA bash analysis pipeline. Bioinformatics (Oxford, England), 42(8), btag570. https://doi.org/10.1093/bioinformatics/btag570

BibTeX

@article{avila2026cascade,
author = {Avila, Forbes and Kim, Jin and Park, Jong-Chan and Kang, Rian and Lee, Hyunsu and Park, Sun-Hyun},
title = {{CASCADE: criticality avalanche spike cross-platform analysis detection engine, a multi-manufacturer MEA bash analysis pipeline}},
journal = {Bioinformatics (Oxford, England)},
year = {2026},
month = aug,
volume = {42},
number = {8},
pages = {btag570},
publisher = {Oxford University Press},
issn = {1367-4803},
doi = {10.1093/bioinformatics/btag570},
url = {https://doi.org/10.1093/bioinformatics/btag570},
pmid = {42525390},
pmcid = {PMC13478863}
}

RIS

TY - JOUR
AU - Avila, Forbes
AU - Kim, Jin
AU - Park, Jong-Chan
AU - Kang, Rian
AU - Lee, Hyunsu
AU - Park, Sun-Hyun
TI - CASCADE: criticality avalanche spike cross-platform analysis detection engine, a multi-manufacturer MEA bash analysis pipeline
T2 - Bioinformatics (Oxford, England)
J2 - Bioinformatics
PY - 2026
DA - 2026/08/01
VL - 42
IS - 8
SP - btag570
SN - 1367-4803
PB - Oxford University Press
DO - 10.1093/bioinformatics/btag570
UR - https://doi.org/10.1093/bioinformatics/btag570
LA - en
ER -

CSL-JSON

{
"id": "10.1093/bioinformatics/btag570",
"type": "article-journal",
"title": "CASCADE: criticality avalanche spike cross-platform analysis detection engine, a multi-manufacturer MEA bash analysis pipeline",
"container-title": "Bioinformatics (Oxford, England)",
"author": [
{
"family": "Avila",
"given": "Forbes"
},
{
"family": "Kim",
"given": "Jin"
},
{
"family": "Park",
"given": "Jong-Chan"
},
{
"family": "Kang",
"given": "Rian"
},
{
"family": "Lee",
"given": "Hyunsu"
},
{
"family": "Park",
"given": "Sun-Hyun"
}
],
"container-title-short": "Bioinformatics",
"volume": "42",
"issue": "8",
"page": "btag570",
"DOI": "10.1093/bioinformatics/btag570",
"PMID": "42525390",
"PMCID": "PMC13478863",
"ISSN": "1367-4803",
"publisher": "Oxford University Press",
"URL": "https://doi.org/10.1093/bioinformatics/btag570",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
1
]
]
}
}

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.1162/imag.a.1348 [code]
The role of high-amplitude bursts of high-gamma activity in naturalistic speech and music listening.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: h5py, pandas, SciPy, 2 other tools, 3 references
[2] doi:10.1016/j.isci.2026.117212 [code]
Critical neuronal avalanches arise from excitation-inhibition balanced spontaneous activity.
Journal: iScience
In common: 5 references
[3] doi:10.1016/j.isci.2026.115488 [code]
An integrated &lt;i&gt;i&lt;/i&gt; &lt;i&gt;n vitro&lt;/i&gt; platform and biophysical modeling approach for studying synaptic transmission in isolated neuronal pairs.
Journal: iScience
In common: h5py, pandas, SciPy, 2 other tools, 1 reference
[4] doi:10.1038/s41467-026-74466-2 [code]
Neuromorphic hierarchical modular reservoirs.
Journal: Nature communications
In common: pandas, SciPy, Matplotlib, 1 other tool, 2 references
[5] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: h5py, pandas, SciPy, 2 other tools, extracellular electrophysiology (units, LFP), methods / tools
[6] doi:10.21769/bioprotoc.5708 [code]
Measuring Electrophysiological Activity in Acute Brain Slices, Spheroids, and Organoids Using 3D High-Density Multielectrode Arrays.
Journal: Bio-protocol
In common: h5py, pandas, SciPy, 2 other tools, extracellular electrophysiology (units, LFP), methods / tools
[7] doi:10.1002/advs.202519893 [code]
NeuroSuite for Long-Term Functional and Structural Studies of Air-Liquid Interface Cerebral Organoids.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: pandas, SciPy, Matplotlib, 1 other tool, extracellular electrophysiology (units, LFP), 1 reference
[8] doi:10.1038/s41531-026-01531-4 [code]
Inconsistent subthalamic local field potential beta activity amid in- and antiphasic neuronal bursts.
Journal: NPJ Parkinson's disease
In common: h5py, pandas, SciPy, 2 other tools, extracellular electrophysiology (units, LFP)
[9] doi:10.1016/j.patter.2026.101590 [code]
Density-based longitudinal neuron tracking in high-density electrophysiological recordings.
Journal: Patterns (New York, N.Y.)
In common: h5py, pandas, SciPy, 2 other tools, extracellular electrophysiology (units, LFP)
[10] doi:10.1038/s41592-026-03076-z [code]
Neuropixels Opto: combining high-resolution electrophysiology and optogenetics.
Journal: Nature methods
In common: h5py, pandas, SciPy, 2 other tools, extracellular electrophysiology (units, LFP)

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.