bluecellulab 2.6.61__tar.gz → 2.6.77__tar.gz

{bluecellulab-2.6.61 → bluecellulab-2.6.77}/.github/workflows/test.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
 
     steps:
     - uses: actions/checkout@v4

{bluecellulab-2.6.61 → bluecellulab-2.6.77}/.gitignore

@@ -27,4 +27,7 @@ nrnivmodl.log
 *.btr
 *.whl
 .ipynb_checkpoints
-cADpyr_L2TPC_dendrogram.png
+cADpyr_L2TPC_dendrogram.png
+ex2_sonatagraph.pdf
+.venv
+bad_dendritic_fit.png

{bluecellulab-2.6.61 → bluecellulab-2.6.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bluecellulab
-Version: 2.6.61
+Version: 2.6.77
 Summary: Biologically detailed neural network simulations and analysis.
 Author: Blue Brain Project, EPFL
 License: Apache2.0
@@ -14,12 +14,12 @@ Classifier: Operating System :: POSIX
 Classifier: Topic :: Scientific/Engineering
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Utilities
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 License-File: AUTHORS.txt
 Requires-Dist: NEURON<9.0.0,>=8.0.2
-Requires-Dist: numpy<2.0.0,>=1.8.0
+Requires-Dist: numpy<2.4,>=2.0.0
 Requires-Dist: matplotlib<4.0.0,>=3.0.0
 Requires-Dist: pandas<3.0.0,>=1.0.0
 Requires-Dist: bluepysnap<4.0.0,>=3.0.0
@@ -28,6 +28,11 @@ Requires-Dist: typing-extensions>=4.8.0
 Requires-Dist: networkx>=3.1
 Requires-Dist: h5py>=3.8.0
 Requires-Dist: seaborn
+Requires-Dist: efel>=5.7.19
+Requires-Dist: neo>=0.14.0
+Requires-Dist: quantities>=0.16.2
+Provides-Extra: examples
+Requires-Dist: ipywidgets; extra == "examples"
 Dynamic: license-file
 
 |banner|
@@ -98,8 +103,8 @@ We are providing support on `Gitter <https://gitter.im/openbraininstitute/BlueCe
 Main dependencies
 =================
 
-* `Python 3.9+ <https://www.python.org/downloads/release/python-390/>`_
-* `Neuron 8.0.2+ <https://pypi.org/project/NEURON/>`_
+* `Python 3.10+ <https://www.python.org/downloads/release/python-390/>`_
+* `NEURON <=8.2.7 <https://pypi.org/project/NEURON/>`__
 
 Installation
 ============

{bluecellulab-2.6.61 → bluecellulab-2.6.77}/README.rst

@@ -66,8 +66,8 @@ We are providing support on `Gitter <https://gitter.im/openbraininstitute/BlueCe
 Main dependencies
 =================
 
-* `Python 3.9+ <https://www.python.org/downloads/release/python-390/>`_
-* `Neuron 8.0.2+ <https://pypi.org/project/NEURON/>`_
+* `Python 3.10+ <https://www.python.org/downloads/release/python-390/>`_
+* `NEURON <=8.2.7 <https://pypi.org/project/NEURON/>`__
 
 Installation
 ============

{bluecellulab-2.6.61 → bluecellulab-2.6.77}/bluecellulab/analysis/analysis.py

@@ -4,9 +4,11 @@ try:
 except ImportError:
     efel = None
 from itertools import islice
+from itertools import repeat
 import logging
 from matplotlib.collections import LineCollection
 import matplotlib.pyplot as plt
+from multiprocessing import Pool
 import neuron
 import numpy as np
 import pathlib
@@ -18,6 +20,7 @@ from bluecellulab.analysis.inject_sequence import run_stimulus
 from bluecellulab.analysis.plotting import plot_iv_curve, plot_fi_curve
 from bluecellulab.analysis.utils import exp_decay
 from bluecellulab.simulation import Simulation
+from bluecellulab.simulation.neuron_globals import set_neuron_globals
 from bluecellulab.stimulus import StimulusFactory
 from bluecellulab.stimulus.circuit_stimulus_definitions import Hyperpolarizing
 from bluecellulab.tools import calculate_rheobase
@@ -40,7 +43,10 @@ def compute_plot_iv_curve(cell,
                           show_figure=True,
                           save_figure=False,
                           output_dir="./",
-                          output_fname="iv_curve.pdf"):
+                          output_fname="iv_curve.pdf",
+                          n_processes=None,
+                          celsius=None,
+                          v_init=None):
     """Compute and plot the Current-Voltage (I-V) curve for a given cell by
     injecting a range of currents.
 
@@ -72,6 +78,11 @@ def compute_plot_iv_curve(cell,
         save_figure (bool): Whether to save the figure. Default is False.
         output_dir (str): The directory to save the figure if save_figure is True. Default is "./".
         output_fname (str): The filename to save the figure as if save_figure is True. Default is "iv_curve.png".
+        n_processes (int, optional): The number of processes to use for parallel execution.
+            If None or if it is higher than the number of steps,
+            it will use the number of steps as the number of processes.
+        celsius (float, optional): Temperature in Celsius.
+        v_init (float, optional): Initial membrane potential.
 
     Returns:
         tuple: A tuple containing:
@@ -95,15 +106,22 @@ def compute_plot_iv_curve(cell,
         for amp in list_amp
     ]
 
-    recordings = []
-    for step in steps:
-        recording = run_stimulus(cell.template_params,
-                                 step,
-                                 section=injecting_section,
-                                 segment=injecting_segment,
-                                 recording_section=recording_section,
-                                 recording_segment=recording_segment)
-        recordings.append(recording)
+    if n_processes is None or n_processes > len(steps):
+        n_processes = len(steps)
+    with Pool(n_processes, initializer=set_neuron_globals, initargs=(celsius, v_init)) as p:
+        recordings = p.starmap(
+            run_stimulus,
+            zip(
+                repeat(cell.template_params),
+                steps,
+                repeat(injecting_section),
+                repeat(injecting_segment),
+                repeat(True),  # cvode
+                repeat(True),  # add_hypamp
+                repeat(recording_section),
+                repeat(recording_segment),
+            )
+        )
 
     steady_states = []
     # compute steady state response
@@ -148,7 +166,10 @@ def compute_plot_fi_curve(cell,
                           show_figure=True,
                           save_figure=False,
                           output_dir="./",
-                          output_fname="fi_curve.pdf"):
+                          output_fname="fi_curve.pdf",
+                          n_processes=None,
+                          celsius=None,
+                          v_init=None):
     """Compute and plot the Frequency-Current (F-I) curve for a given cell by
     injecting a range of currents.
 
@@ -182,6 +203,11 @@ def compute_plot_fi_curve(cell,
         save_figure (bool): Whether to save the figure. Default is False.
         output_dir (str): The directory to save the figure if save_figure is True. Default is "./".
         output_fname (str): The filename to save the figure as if save_figure is True. Default is "iv_curve.png".
+        n_processes (int, optional): The number of processes to use for parallel execution.
+            If None or if it is higher than the number of steps,
+            it will use the number of steps as the number of processes.
+        celsius (float, optional): Temperature in Celsius.
+        v_init (float, optional): Initial membrane potential.
 
     Returns:
         tuple: A tuple containing:
@@ -201,19 +227,26 @@ def compute_plot_fi_curve(cell,
         for amp in list_amp
     ]
 
-    spikes = []
-    for step in steps:
-        recording = run_stimulus(cell.template_params,
-                                 step,
-                                 section=injecting_section,
-                                 segment=injecting_segment,
-                                 recording_section=recording_section,
-                                 recording_segment=recording_segment,
-                                 enable_spike_detection=True,
-                                 threshold_spike_detection=threshold_voltage)
-        spikes.append(recording.spike)
+    if n_processes is None or n_processes > len(steps):
+        n_processes = len(steps)
+    with Pool(n_processes, initializer=set_neuron_globals, initargs=(celsius, v_init)) as p:
+        recordings = p.starmap(
+            run_stimulus,
+            zip(
+                repeat(cell.template_params),
+                steps,
+                repeat(injecting_section),
+                repeat(injecting_segment),
+                repeat(True),  # cvode
+                repeat(True),  # add_hypamp
+                repeat(recording_section),
+                repeat(recording_segment),
+                repeat(True),  # enable_spike_detection
+                repeat(threshold_voltage),  # threshold_spike_detection
+            )
+        )
 
-    spike_count = [len(spike) for spike in spikes]
+    spike_count = [len(recording.spike) for recording in recordings]
 
     plot_fi_curve(list_amp,
                   spike_count,
@@ -327,54 +360,69 @@ class BPAP:
         return soma_amp, dend_amps, dend_dist, apic_amps, apic_dist
 
     @staticmethod
-    def fit(soma_amp, dend_amps, dend_dist, apic_amps, apic_dist):
+    def fit(soma_amp, branch_amps, branch_dist):
         """Fit the amplitudes vs distances to an exponential decay function."""
         from scipy.optimize import curve_fit
 
-        popt_dend = None
-        if dend_amps and dend_dist:
-            dist = [0] + dend_dist  # add soma distance
-            amps = soma_amp + dend_amps  # add soma amplitude
-            popt_dend, _ = curve_fit(exp_decay, dist, amps)
-
-        popt_apic = None
-        if apic_amps and apic_dist:
-            dist = [0] + apic_dist  # add soma distance
-            amps = soma_amp + apic_amps  # add soma amplitude
-            popt_apic, _ = curve_fit(exp_decay, dist, amps)
-
-        return popt_dend, popt_apic
-
-    def validate(self, soma_amp, dend_amps, dend_dist, apic_amps, apic_dist):
+        if not branch_amps or not branch_dist or len(branch_amps) != len(branch_dist):
+            return None, False
+        try:
+            dist = [0] + branch_dist
+            amps = soma_amp + branch_amps
+            popt, _ = curve_fit(exp_decay, dist, amps)
+            return popt, False
+        except RuntimeError:
+            return None, True
+
+    def validate(self, soma_amp, dend_amps, dend_dist, apic_amps, apic_dist, validate_with_fit=True):
         """Check that the exponential fit is decaying."""
         validated = True
         notes = ""
-        popt_dend, popt_apic = self.fit(soma_amp, dend_amps, dend_dist, apic_amps, apic_dist)
-        if dend_amps is not None:
-            plt.cla()
-            plt.plot([0], soma_amp, '.')
-            plt.plot(dend_dist, dend_amps, '.')
-            x = np.linspace(0, max(dend_dist), 100)
-            plt.plot(x, exp_decay(x, *popt_dend), color='darkgreen', linestyle='--', label='Basal Dendritic Fit')
-            plt.savefig("bad_dendritic_fit.png")
-        if popt_dend is None:
-            logger.debug("No dendritic recordings found.")
-            notes += "No dendritic recordings found.\n"
-        elif popt_dend[1] <= 0 or popt_dend[0] <= 0:
-            logger.debug("Dendritic fit is not decaying.")
-            validated = False
-            notes += "Dendritic fit is not decaying.\n"
+        if validate_with_fit:
+            popt_dend, dend_fit_error = self.fit(soma_amp, dend_amps, dend_dist)
+            popt_apic, apic_fit_error = self.fit(soma_amp, apic_amps, apic_dist)
+            if dend_fit_error or apic_fit_error:
+                logger.debug("Fitting error occurred.")
+                validated = False
+                notes += "Validation failed: Fitting error occurred.\n"
+                return validated, notes
+            if popt_dend is None:
+                logger.debug("No dendritic recordings found.")
+                notes += "No dendritic recordings found.\n"
+            elif popt_dend[1] <= 0 or popt_dend[0] <= 0:
+                logger.debug("Dendritic fit is not decaying.")
+                validated = False
+                notes += "Dendritic fit is not decaying.\n"
+            else:
+                notes += "Dendritic validation passed: dendritic amplitude is decaying with distance relative to soma.\n"
+            if popt_apic is None:
+                logger.debug("No apical recordings found.")
+                notes += "No apical recordings found.\n"
+            elif popt_apic[1] <= 0 or popt_apic[0] <= 0:
+                logger.debug("Apical fit is not decaying.")
+                validated = False
+                notes += "Apical fit is not decaying.\n"
+            else:
+                notes += "Apical validation passed: apical amplitude is decaying with distance relative to soma.\n"
         else:
-            notes += "Dendritic validation passed: dendritic amplitude is decaying with distance relative to soma.\n"
-        if popt_apic is None:
-            logger.debug("No apical recordings found.")
-            notes += "No apical recordings found.\n"
-        elif popt_apic[1] <= 0 or popt_apic[0] <= 0:
-            logger.debug("Apical fit is not decaying.")
-            validated = False
-            notes += "Apical fit is not decaying.\n"
-        else:
-            notes += "Apical validation passed: apical amplitude is decaying with distance relative to soma.\n"
+            if dend_amps and dend_dist:
+                furthest_dend_idx = np.argmax(dend_dist)
+                if dend_amps[furthest_dend_idx] < soma_amp[0]:
+                    notes += "Dendritic validation passed: dendritic amplitude is decaying with distance relative to soma.\n"
+                else:
+                    validated = False
+                    notes += "Dendritic validation failed: dendritic amplitude is not decaying with distance relative to soma.\n"
+            else:
+                notes += "No dendritic recordings found.\n"
+            if apic_amps and apic_dist:
+                furthest_apic_idx = np.argmax(apic_dist)
+                if apic_amps[furthest_apic_idx] < soma_amp[0]:
+                    notes += "Apical validation passed: apical amplitude is decaying with distance relative to soma.\n"
+                else:
+                    validated = False
+                    notes += "Apical validation failed: apical amplitude is not decaying with distance relative to soma.\n"
+            else:
+                notes += "No apical recordings found.\n"
 
         return validated, notes
 
@@ -389,9 +437,14 @@ class BPAP:
         save_figure=False,
         output_dir="./",
         output_fname="bpap.pdf",
+        do_fit=True,
     ):
         """Plot the results of the BPAP analysis."""
-        popt_dend, popt_apic = self.fit(soma_amp, dend_amps, dend_dist, apic_amps, apic_dist)
+        popt_dend = None
+        popt_apic = None
+        if do_fit:
+            popt_dend, _ = self.fit(soma_amp, dend_amps, dend_dist)
+            popt_apic, _ = self.fit(soma_amp, apic_amps, apic_dist)
 
         outpath = pathlib.Path(output_dir) / output_fname
         fig, ax1 = plt.subplots(figsize=(10, 6))

{bluecellulab-2.6.61 → bluecellulab-2.6.77}/bluecellulab/cell/core.py

@@ -19,7 +19,7 @@ import logging
 
 from pathlib import Path
 import queue
-from typing import Optional
+from typing import List, Optional, Tuple
 from typing_extensions import deprecated
 
 import neuron
@@ -47,6 +47,7 @@ from bluecellulab.stimulus.circuit_stimulus_definitions import SynapseReplay
 from bluecellulab.synapse import SynapseFactory, Synapse
 from bluecellulab.synapse.synapse_types import SynapseID
 from bluecellulab.type_aliases import HocObjectType, NeuronSection, SectionMapping
+from bluecellulab.cell.section_tools import currents_vars, section_to_variable_recording_str
 
 logger = logging.getLogger(__name__)
 
@@ -250,6 +251,10 @@ class Cell(InjectableMixin, PlottableMixin):
         else:
             self._default_disable_ttx()
 
+    @property
+    def ttx_enabled(self):
+        return getattr(self, "_ttx_enabled", False)
+
     def _default_enable_ttx(self) -> None:
         """Default enable_ttx implementation."""
         for section in self.sections.values():
@@ -760,17 +765,66 @@ class Cell(InjectableMixin, PlottableMixin):
         """Get a vector of AIS voltage."""
         return self.get_recording('self.axonal[1](0.5)._ref_v')
 
-    def add_variable_recording(self, variable: str, section, segx):
-        if variable == "v":
-            self.add_voltage_recording(section, segx)
-        else:
-            raise ValueError(f"Unsupported variable for recording: {variable}")
+    def add_variable_recording(
+        self,
+        variable: str,
+        section: Optional[NeuronSection] = None,
+        segx: float = 0.5,
+        dt: Optional[float] = None
+    ) -> None:
+        """Add a recording of any NEURON RANGE variable (e.g., gna, gk, ina)
+        from a given section and segment.
 
-    def get_variable_recording(self, variable: str, section, segx) -> np.ndarray:
-        if variable == "v":
-            return self.get_voltage_recording(section=section, segx=segx)
+        Args:
+            variable: The NEURON variable name to record (e.g., "gna").
+            section: The section to record from (defaults to soma).
+            segx: Segment position between 0 and 1.
+            dt: Optional recording time step.
+        """
+
+        if section is None:
+            section = self.soma
+
+        # validate before constructing the string
+        seg = section(segx)
+        if "." in variable:
+            mech, var = variable.split(".", 1)
+            mobj = getattr(seg, mech, None)
+            if mobj is None or not hasattr(mobj, f"_ref_{var}"):
+                raise AttributeError(
+                    f"'{variable}' not recordable at {section.name()}({segx}). "
+                    f"Mechanisms here: {list(section.psection()['density_mechs'].keys())}"
+                )
         else:
-            raise ValueError(f"Unsupported variable '{variable}'")
+            if not hasattr(seg, f"_ref_{variable}"):
+                raise AttributeError(
+                    f"'{variable}' not recordable at {section.name()}({segx}). "
+                    f"(Top-level vars are typically v/ina/ik/ica)"
+                )
+
+        var_name = section_to_variable_recording_str(section, segx, variable)
+        self.add_recording(var_name, dt)
+
+    def get_variable_recording(
+        self, variable: str, section: Optional[NeuronSection], segx: float
+    ) -> np.ndarray:
+        """Get a recording of any variable recorded from a section and segment.
+
+        Args:
+            variable: The name of the recorded variable (e.g., 'v', 'gna').
+            section: The NEURON section object.
+            segx: Segment location from 0 to 1.
+
+        Returns:
+            NumPy array of recorded values.
+
+        Raises:
+            ValueError: If the recording is not found.
+        """
+        if section is None:
+            section = self.soma
+        recording_name = section_to_variable_recording_str(section, segx, variable)
+        return self.get_recording(recording_name)
 
     @property
     def n_segments(self) -> int:
@@ -784,7 +838,18 @@ class Cell(InjectableMixin, PlottableMixin):
         connected to that cell."""
         if self.sonata_proxy is None:
             raise BluecellulabError("Cell: add_synapse_replay requires a sonata proxy.")
-        synapse_spikes: dict = get_synapse_replay_spikes(stimulus.spike_file)
+
+        file_path = Path(stimulus.spike_file).expanduser()
+        if not file_path.is_absolute():
+            config_dir = stimulus.config_dir
+            if config_dir is not None:
+                file_path = Path(config_dir) / file_path
+
+        file_path = file_path.resolve()
+
+        if not file_path.exists():
+            raise FileNotFoundError(f"Spike file not found: {str(file_path)}")
+        synapse_spikes: dict = get_synapse_replay_spikes(str(file_path))
         for synapse_id, synapse in self.synapses.items():
             source_population = synapse.syn_description["source_population_name"]
             pre_gid = CellId(
@@ -843,3 +908,186 @@ class Cell(InjectableMixin, PlottableMixin):
 
     def __del__(self):
         self.delete()
+
+    def get_section(self, section_name: str) -> NeuronSection:
+        """Return a single, fully specified NEURON section (e.g., 'soma[0]',
+        'dend[3]').
+
+        Raises:
+            ValueError or TypeError if the section is not found or invalid.
+        """
+        if section_name in self.sections:
+            section = self.sections[section_name]
+            if hasattr(section, "nseg"):
+                return section
+            raise TypeError(f"'{section_name}' exists but is not a NEURON section.")
+
+        available = ", ".join(self.sections.keys())
+        raise ValueError(f"Section '{section_name}' not found. Available: [{available}]")
+
+    def get_sections(self, section_name: str) -> List[NeuronSection]:
+        """Return a list of NEURON sections.
+
+        If the section name is a fully specified one (e.g., 'dend[3]'), return it as a list of one.
+        If the section name is a base name (e.g., 'dend'), return all matching sections like 'dend[0]', 'dend[1]', etc.
+
+        Raises:
+            ValueError if no valid sections are found.
+        """
+        # Try to interpret as fully qualified section name
+        try:
+            return [self.get_section(section_name)]
+        except ValueError:
+            pass  # Not a precise match; try prefix match
+
+        # Fallback to prefix-based match (e.g., 'dend' → 'dend[0]', 'dend[1]', ...)
+        matched = [
+            section for name, section in self.sections.items()
+            if name.startswith(f"{section_name}[")
+        ]
+        if matched:
+            return matched
+
+        available = ", ".join(self.sections.keys())
+        raise ValueError(f"Section '{section_name}' not found. Available: [{available}]")
+
+    def get_section_by_id(self, section_id: int) -> NeuronSection:
+        """Return NEURON section by global section index (LibSONATA
+        ordering)."""
+        if not self.psections:
+            self._init_psections()
+
+        try:
+            return self.psections[int(section_id)].hsection
+        except KeyError:
+            raise IndexError(f"Section ID {section_id} is out of range for cell {self.cell_id.id}")
+
+    def resolve_segments_from_compartment_set(self, node_id, compartment_nodes) -> List[Tuple[NeuronSection, str, float]]:
+        """Resolve segments for a cell using a predefined compartment node
+        list.
+
+        Supports both LibSONATA format ([node_id, section_id, seg]) and
+        name-based format ([node_id, section_name, seg]).
+        """
+        result = []
+        for n_id, sec_ref, seg in compartment_nodes:
+            if n_id != node_id:
+                continue
+
+            if isinstance(sec_ref, str):
+                # Name-based: e.g., "dend[5]"
+                section = self.get_section(sec_ref)
+                sec_name = section.name().split(".")[-1]
+            elif isinstance(sec_ref, int):
+                # ID-based: resolve by section index
+                try:
+                    section = self.get_section_by_id(sec_ref)
+                    sec_name = section.name().split(".")[-1]
+                except AttributeError:
+                    raise ValueError(f"Cell object does not support section lookup by index: {sec_ref}")
+            else:
+                raise TypeError(f"Unsupported section reference type: {type(sec_ref)}")
+
+            result.append((section, sec_name, seg))
+        return result
+
+    def resolve_segments_from_config(self, report_cfg) -> List[Tuple[NeuronSection, str, float]]:
+        """Resolve segments from NEURON sections based on config."""
+        compartment = report_cfg.get("compartments", "center")
+        if compartment not in {"center", "all"}:
+            raise ValueError(
+                f"Unsupported 'compartments' value '{compartment}' — must be 'center' or 'all'."
+            )
+
+        section_name = report_cfg.get("sections", "soma")
+        sections = self.get_sections(section_name)
+
+        targets = []
+        for sec in sections:
+            sec_name = sec.name().split(".")[-1]
+            if compartment == "center":
+                targets.append((sec, sec_name, 0.5))
+            elif compartment == "all":
+                for seg in sec:
+                    targets.append((sec, sec_name, seg.x))
+        return targets
+
+    def configure_recording(self, recording_sites, variable_name, report_name):
+        """Configure recording of a variable on a single cell.
+
+        This function sets up the recording of the specified variable (e.g., membrane voltage)
+        in the target cell, for each resolved segment.
+
+        Parameters
+        ----------
+        cell : Any
+            The cell object on which to configure recordings.
+
+        recording_sites : list of tuples
+            List of tuples (section, section_name, segment) where:
+            - section is the section object in the cell.
+            - section_name is the name of the section.
+            - segment is the Neuron segment index (0-1).
+
+        variable_name : str
+            The name of the variable to record (e.g., "v" for membrane voltage).
+
+        report_name : str
+            The name of the report (used in logging).
+        """
+        node_id = self.cell_id.id
+
+        for sec, sec_name, seg in recording_sites:
+            try:
+                self.add_variable_recording(variable=variable_name, section=sec, segx=seg)
+                logger.info(
+                    f"Recording '{variable_name}' at {sec_name}({seg}) on GID {node_id} for report '{report_name}'"
+                )
+            except AttributeError:
+                logger.warning(
+                    f"Recording for variable '{variable_name}' is not implemented in Cell."
+                )
+                return
+            except Exception as e:
+                logger.warning(
+                    f"Failed to record '{variable_name}' at {sec_name}({seg}) on GID {node_id} for report '{report_name}': {e}"
+                )
+
+    def add_currents_recordings(
+        self,
+        section,
+        segx: float = 0.5,
+        *,
+        include_nonspecific: bool = True,
+        include_point_processes: bool = False,
+        dt: float | None = None,
+    ) -> list[str]:
+        """Record all available currents (ionic + optionally nonspecific) at
+        (section, segx)."""
+
+        # discover what’s available at this site
+        available = currents_vars(section)
+        chosen: list[str] = []
+
+        for name, meta in available.items():
+            kind = meta.get("kind")
+
+            if kind == "ionic_current":
+                self.add_variable_recording(name, section=section, segx=segx, dt=dt)
+                chosen.append(name)
+
+            elif kind == "nonspecific_current":
+                if not include_nonspecific:
+                    continue
+                # density-mech nonspecific currents
+                self.add_variable_recording(name, section=section, segx=segx, dt=dt)
+                chosen.append(name)
+
+            elif kind == "point_process_current":
+                if not include_point_processes:
+                    continue
+                # point process nonspecific currents
+                self.add_variable_recording(name, section=section, segx=segx, dt=dt)
+                chosen.append(name)
+
+        return chosen