bluecellulab 2.4.0__py3-none-any.whl → 2.6.37__py3-none-any.whl

bluecellulab/__init__.py

@@ -7,10 +7,10 @@ try:
 except ImportError:
     BLUEPY_AVAILABLE = False
 
-from .importer import *  # NOQA
-from .tools import *  # NOQA
+from bluecellulab.importer import import_hoc
 from .verbosity import *
 from .cell import Cell, create_ball_stick  # NOQA
+from .circuit import EmodelProperties
 from .connection import Connection  # NOQA
 from .plotwindow import PlotWindow  # NOQA
 from .dendrogram import Dendrogram  # NOQA
@@ -18,4 +18,11 @@ from .psection import PSection  # NOQA
 from .psegment import PSegment  # NOQA
 from .simulation import Simulation  # NOQA
 from .rngsettings import RNGSettings  # NOQA
-from .ssim import SSim  # NOQA
+from .circuit_simulation import CircuitSimulation  # NOQA
+import neuron
+
+from .simulation.neuron_globals import NeuronGlobals
+
+logger.debug("Loading the hoc files.")
+import_hoc(neuron)
+_ = NeuronGlobals.get_instance()  # initiate the singleton

bluecellulab/analysis/inject_sequence.py

@@ -0,0 +1,165 @@
+"""Module for injecting a sequence of protocols to the cell."""
+from __future__ import annotations
+from enum import Enum, auto
+from typing import NamedTuple, Sequence, Dict
+
+import neuron
+import numpy as np
+from bluecellulab.cell.core import Cell
+from bluecellulab.cell.template import TemplateParams
+from bluecellulab.simulation.parallel import IsolatedProcess
+from bluecellulab.simulation.simulation import Simulation
+from bluecellulab.stimulus.circuit_stimulus_definitions import Hyperpolarizing
+from bluecellulab.stimulus.factory import Stimulus, StimulusFactory
+
+
+class StimulusName(Enum):
+    """Allowed values for the StimulusName."""
+    AP_WAVEFORM = auto()
+    IDREST = auto()
+    IV = auto()
+    FIRE_PATTERN = auto()
+    POS_CHEOPS = auto()
+    NEG_CHEOPS = auto()
+
+
+class Recording(NamedTuple):
+    """A tuple of the current, voltage and time recordings."""
+    current: np.ndarray
+    voltage: np.ndarray
+    time: np.ndarray
+
+
+StimulusRecordings = Dict[str, Recording]
+
+
+def run_stimulus(
+    template_params: TemplateParams,
+    stimulus: Stimulus,
+    section: str,
+    segment: float,
+    cvode: bool = True,
+    add_hypamp: bool = True,
+) -> Recording:
+    """Creates a cell and stimulates it with a given stimulus.
+
+    Args:
+        template_params: The parameters to create the cell from a template.
+        stimulus: The input stimulus to inject into the cell.
+        section: Name of the section of cell where the stimulus is to be injected.
+        segment: The segment of the section where the stimulus is to be injected.
+        cvode: True to use variable time-steps. False for fixed time-steps.
+
+    Returns:
+        The voltage-time recording at the specified location.
+
+    Raises:
+        ValueError: If the time and voltage arrays are not the same length.
+    """
+    cell = Cell.from_template_parameters(template_params)
+    neuron_section = cell.sections[section]
+    if add_hypamp:
+        hyp_stim = Hyperpolarizing(target="", delay=0.0, duration=stimulus.stimulus_time)
+        cell.add_replay_hypamp(hyp_stim)
+    cell.add_voltage_recording(neuron_section, segment)
+    iclamp, _ = cell.inject_current_waveform(
+        stimulus.time, stimulus.current, section=neuron_section, segx=segment
+    )
+    current_vector = neuron.h.Vector()
+    current_vector.record(iclamp._ref_i)
+    simulation = Simulation(cell)
+    simulation.run(stimulus.stimulus_time, cvode=cvode)
+    current = np.array(current_vector.to_python())
+    voltage = cell.get_voltage_recording(neuron_section, segment)
+    time = cell.get_time()
+    if len(time) != len(voltage) or len(time) != len(current):
+        raise ValueError("Time, current and voltage arrays are not the same length")
+    return Recording(current, voltage, time)
+
+
+def apply_multiple_stimuli(
+    cell: Cell,
+    stimulus_name: StimulusName,
+    amplitudes: Sequence[float],
+    threshold_based: bool = True,
+    section_name: str | None = None,
+    segment: float = 0.5,
+    n_processes: int | None = None,
+    cvode: bool = True,
+    add_hypamp: bool = True,
+) -> StimulusRecordings:
+    """Apply multiple stimuli to the cell on isolated processes.
+
+    Args:
+        cell: The cell to which the stimuli are applied.
+        stimulus_name: The name of the stimulus to apply.
+        amplitudes: The amplitudes of the stimuli to apply.
+        threshold_based: Whether to consider amplitudes to be
+            threshold percentages or to be raw amplitudes.
+        section_name: Section name of the cell where the stimuli are applied.
+          If None, the stimuli are applied at the soma[0] of the cell.
+        segment: The segment of the section where the stimuli are applied.
+        n_processes: The number of processes to use for running the stimuli.
+        cvode: True to use variable time-steps. False for fixed time-steps.
+        add_hypamp: True to add the cell's holding current stimulus
+
+    Returns:
+        A dictionary where the keys are the names of the stimuli and the values
+        are the recordings of the cell's response to each stimulus.
+
+    Raises:
+        ValueError: If the stimulus name is not recognized.
+    """
+    res: StimulusRecordings = {}
+    stim_factory = StimulusFactory(dt=1.0)
+    task_args = []
+    section_name = section_name if section_name is not None else "soma[0]"
+
+    # Prepare arguments for each stimulus
+    for amplitude in amplitudes:
+        if threshold_based:
+            thres_perc = amplitude
+            amp = None
+        else:
+            thres_perc = None
+            amp = amplitude
+
+        if stimulus_name == StimulusName.AP_WAVEFORM:
+            stimulus = stim_factory.ap_waveform(
+                threshold_current=cell.threshold, threshold_percentage=thres_perc, amplitude=amp
+            )
+        elif stimulus_name == StimulusName.IDREST:
+            stimulus = stim_factory.idrest(
+                threshold_current=cell.threshold, threshold_percentage=thres_perc, amplitude=amp
+            )
+        elif stimulus_name == StimulusName.IV:
+            stimulus = stim_factory.iv(
+                threshold_current=cell.threshold, threshold_percentage=thres_perc, amplitude=amp
+            )
+        elif stimulus_name == StimulusName.FIRE_PATTERN:
+            stimulus = stim_factory.fire_pattern(
+                threshold_current=cell.threshold, threshold_percentage=thres_perc, amplitude=amp
+            )
+        elif stimulus_name == StimulusName.POS_CHEOPS:
+            stimulus = stim_factory.pos_cheops(
+                threshold_current=cell.threshold, threshold_percentage=thres_perc, amplitude=amp
+            )
+        elif stimulus_name == StimulusName.NEG_CHEOPS:
+            stimulus = stim_factory.neg_cheops(
+                threshold_current=cell.threshold, threshold_percentage=thres_perc, amplitude=amp
+            )
+        else:
+            raise ValueError("Unknown stimulus name.")
+
+        task_args.append((cell.template_params, stimulus, section_name, segment, cvode, add_hypamp))
+
+    with IsolatedProcess(processes=n_processes) as pool:
+        # Map expects a function and a list of argument tuples
+        results = pool.starmap(run_stimulus, task_args)
+
+    # Associate each result with a key
+    for amplitude, result in zip(amplitudes, results):
+        key = f"{stimulus_name}_{amplitude}"
+        res[key] = result
+
+    return res

bluecellulab/cell/cell_dict.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

bluecellulab/cell/core.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -27,24 +27,25 @@ import numpy as np
 import pandas as pd
 
 import bluecellulab
+from bluecellulab.cell.recording import section_to_voltage_recording_str
 from bluecellulab.psection import PSection, init_psections
 from bluecellulab.cell.injector import InjectableMixin
 from bluecellulab.cell.plotting import PlottableMixin
 from bluecellulab.cell.section_distance import EuclideanSectionDistance
 from bluecellulab.cell.sonata_proxy import SonataProxy
-from bluecellulab.cell.template import NeuronTemplate, public_hoc_cell
+from bluecellulab.cell.template import NeuronTemplate, TemplateParams, public_hoc_cell
 from bluecellulab.circuit.config.sections import Conditions
 from bluecellulab.circuit import EmodelProperties, SynapseProperty
 from bluecellulab.circuit.node_id import CellId
 from bluecellulab.circuit.simulation_access import get_synapse_replay_spikes
 from bluecellulab.exceptions import BluecellulabError
-from bluecellulab.importer import load_hoc_and_mod_files
+from bluecellulab.importer import load_mod_files
 from bluecellulab.neuron_interpreter import eval_neuron
 from bluecellulab.rngsettings import RNGSettings
 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
+from bluecellulab.type_aliases import HocObjectType, NeuronSection, SectionMapping
 
 logger = logging.getLogger(__name__)
 
@@ -54,7 +55,25 @@ class Cell(InjectableMixin, PlottableMixin):
 
     last_id = 0
 
-    @load_hoc_and_mod_files
+    @classmethod
+    def from_template_parameters(
+        cls, template_params: TemplateParams, cell_id: Optional[CellId] = None,
+        record_dt: Optional[float] = None
+    ) -> Cell:
+        """Create a cell from a TemplateParams object.
+
+        Useful in isolating runs.
+        """
+        return cls(
+            template_path=template_params.template_filepath,
+            morphology_path=template_params.morph_filepath,
+            cell_id=cell_id,
+            record_dt=record_dt,
+            template_format=template_params.template_format,
+            emodel_properties=template_params.emodel_properties,
+        )
+
+    @load_mod_files
     def __init__(self,
                  template_path: str | Path,
                  morphology_path: str | Path,
@@ -73,6 +92,12 @@ class Cell(InjectableMixin, PlottableMixin):
             emodel_properties: Template specific emodel properties.
         """
         super().__init__()
+        self.template_params = TemplateParams(
+            template_filepath=template_path,
+            morph_filepath=morphology_path,
+            template_format=template_format,
+            emodel_properties=emodel_properties,
+        )
         if cell_id is None:
             cell_id = CellId("", Cell.last_id)
             Cell.last_id += 1
@@ -86,17 +111,16 @@ class Cell(InjectableMixin, PlottableMixin):
             if emodel_properties is None:
                 raise BluecellulabError('EmodelProperties must be provided for v6 template')
             self.hypamp: float | None = emodel_properties.holding_current
-            self.threshold: float | None = emodel_properties.threshold_current
+            self.threshold: float = emodel_properties.threshold_current
         else:
             try:
                 self.hypamp = self.cell.getHypAmp()
             except AttributeError:
                 self.hypamp = None
-
             try:
                 self.threshold = self.cell.getThreshold()
             except AttributeError:
-                self.threshold = None
+                self.threshold = 0.0
         self.soma = public_hoc_cell(self.cell).soma[0]
         # WARNING: this finitialize 'must' be here, otherwhise the
         # diameters of the loaded morph are wrong
@@ -118,7 +142,8 @@ class Cell(InjectableMixin, PlottableMixin):
                             dt=self.record_dt)
 
         self.delayed_weights = queue.PriorityQueue()  # type: ignore
-        self.psections, self.secname_to_psection = init_psections(public_hoc_cell(self.cell))
+        self.psections: dict[int, PSection] = {}
+        self.secname_to_psection: dict[str, PSection] = {}
 
         # Keep track of when a cell is made passive by make_passive()
         # Used to know when re_init_rng() can be executed
@@ -131,6 +156,18 @@ class Cell(InjectableMixin, PlottableMixin):
         # as the object exists
         self.persistent: list[HocObjectType] = []
 
+    def _init_psections(self) -> None:
+        """Initialize the psections of the cell."""
+        if not self.psections:
+            self.psections, self.secname_to_psection = init_psections(public_hoc_cell(self.cell))
+
+    def _extract_sections(self, sections) -> SectionMapping:
+        res: SectionMapping = {}
+        for section in sections:
+            key_name = str(section).split(".")[-1]
+            res[key_name] = section
+        return res
+
     @property
     def somatic(self) -> list[NeuronSection]:
         return list(public_hoc_cell(self.cell).somatic)
@@ -148,8 +185,8 @@ class Cell(InjectableMixin, PlottableMixin):
         return list(public_hoc_cell(self.cell).axonal)
 
     @property
-    def all(self) -> list[NeuronSection]:
-        return list(public_hoc_cell(self.cell).all)
+    def sections(self) -> SectionMapping:
+        return self._extract_sections(public_hoc_cell(self.cell).all)
 
     def __repr__(self) -> str:
         base_info = f"Cell Object: {super().__repr__()}"
@@ -160,32 +197,14 @@ class Cell(InjectableMixin, PlottableMixin):
         """Connect this cell to a circuit via sonata proxy."""
         self.sonata_proxy = sonata_proxy
 
-    def re_init_rng(self, use_random123_stochkv: bool = False) -> None:
+    def re_init_rng(self) -> None:
         """Reinitialize the random number generator for stochastic channels."""
-
         if not self.is_made_passive:
-            if use_random123_stochkv:
-                channel_id = 0
-                for section in self.somatic:
-                    for seg in section:
-                        neuron.h.setdata_StochKv(seg.x, sec=section)
-                        neuron.h.setRNG_StochKv(channel_id, self.cell_id.id)
-                        channel_id += 1
-                for section in self.basal:
-                    for seg in section:
-                        neuron.h.setdata_StochKv(seg.x, sec=section)
-                        neuron.h.setRNG_StochKv(channel_id, self.cell_id.id)
-                        channel_id += 1
-                for section in self.apical:
-                    for seg in section:
-                        neuron.h.setdata_StochKv(seg.x, sec=section)
-                        neuron.h.setRNG_StochKv(channel_id, self.cell_id.id)
-                        channel_id += 1
-            else:
-                self.cell.re_init_rng()
+            self.cell.re_init_rng()
 
     def get_psection(self, section_id: int | str) -> PSection:
         """Return a python section with the specified section id."""
+        self._init_psections()
         if isinstance(section_id, int):
             return self.psections[section_id]
         elif isinstance(section_id, str):
@@ -197,7 +216,7 @@ class Cell(InjectableMixin, PlottableMixin):
 
     def make_passive(self) -> None:
         """Make the cell passive by deactivating all the active channels."""
-        for section in self.all:
+        for section in self.sections.values():
             mech_names = set()
             for seg in section:
                 for mech in seg:
@@ -232,14 +251,14 @@ class Cell(InjectableMixin, PlottableMixin):
 
     def _default_enable_ttx(self) -> None:
         """Default enable_ttx implementation."""
-        for section in self.all:
+        for section in self.sections.values():
             if not neuron.h.ismembrane("TTXDynamicsSwitch"):
                 section.insert('TTXDynamicsSwitch')
             section.ttxo_level_TTXDynamicsSwitch = 1.0
 
     def _default_disable_ttx(self) -> None:
         """Default disable_ttx implementation."""
-        for section in self.all:
+        for section in self.sections.values():
             if not neuron.h.ismembrane("TTXDynamicsSwitch"):
                 section.insert('TTXDynamicsSwitch')
             section.ttxo_level_TTXDynamicsSwitch = 1e-14
@@ -247,7 +266,7 @@ class Cell(InjectableMixin, PlottableMixin):
     def area(self) -> float:
         """The total surface area of the cell."""
         area = 0.0
-        for section in self.all:
+        for section in self.sections.values():
             x_s = np.arange(1.0 / (2 * section.nseg), 1.0,
                             1.0 / (section.nseg))
             for x in x_s:
@@ -297,7 +316,7 @@ class Cell(InjectableMixin, PlottableMixin):
         self.add_recording("self.axonal[1](0.5)._ref_v", dt=dt)
 
     def add_voltage_recording(
-        self, section: "neuron.h.Section", segx: float = 0.5, dt: Optional[float] = None
+        self, section: Optional[NeuronSection] = None, segx: float = 0.5, dt: Optional[float] = None
     ) -> None:
         """Add a voltage recording to a certain section at a given segment
         (segx).
@@ -309,11 +328,13 @@ class Cell(InjectableMixin, PlottableMixin):
             dt: Recording time step. If not provided, the recording step will
                 default to the simulator's time step.
         """
-        var_name = f"neuron.h.{section.name()}({segx})._ref_v"
+        if section is None:
+            section = self.soma
+        var_name = section_to_voltage_recording_str(section, segx)
         self.add_recording(var_name, dt)
 
     def get_voltage_recording(
-        self, section: "neuron.h.Section", segx: float = 0.5
+        self, section: Optional[NeuronSection] = None, segx: float = 0.5
     ) -> np.ndarray:
         """Get a voltage recording for a certain section at a given segment
         (segx).
@@ -329,7 +350,9 @@ class Cell(InjectableMixin, PlottableMixin):
         Raises:
             BluecellulabError: If voltage recording was not added previously using add_voltage_recording.
         """
-        recording_name = f"neuron.h.{section.name()}({segx})._ref_v"
+        if section is None:
+            section = self.soma
+        recording_name = section_to_voltage_recording_str(section, segx)
         if recording_name in self.recordings:
             return self.get_recording(recording_name)
         else:
@@ -340,15 +363,13 @@ class Cell(InjectableMixin, PlottableMixin):
 
     def add_allsections_voltagerecordings(self):
         """Add a voltage recording to every section of the cell."""
-        all_sections = public_hoc_cell(self.cell).all
-        for section in all_sections:
+        for section in self.sections.values():
             self.add_voltage_recording(section, dt=self.record_dt)
 
     def get_allsections_voltagerecordings(self) -> dict[str, np.ndarray]:
         """Get all the voltage recordings from all the sections."""
         all_section_voltages = {}
-        all_sections = public_hoc_cell(self.cell).all
-        for section in all_sections:
+        for section in self.sections.values():
             recording = self.get_voltage_recording(section)
             all_section_voltages[section.name()] = recording
         return all_section_voltages
@@ -426,10 +447,10 @@ class Cell(InjectableMixin, PlottableMixin):
         """
         if location == "soma":
             sec = public_hoc_cell(self.cell).soma[0]
-            source = public_hoc_cell(self.cell).soma[0](1)._ref_v
+            source = sec(1)._ref_v
         elif location == "AIS":
             sec = public_hoc_cell(self.cell).axon[1]
-            source = public_hoc_cell(self.cell).axon[1](0.5)._ref_v
+            source = sec(0.5)._ref_v
         else:
             raise ValueError("Spike detection location must be soma or AIS")
         netcon = neuron.h.NetCon(source, target, sec=sec)
@@ -476,10 +497,6 @@ class Cell(InjectableMixin, PlottableMixin):
         # numpy int to int
         post_sec_id = int(syn_description[SynapseProperty.POST_SECTION_ID])
 
-        location = SynapseFactory.determine_synapse_location(
-            syn_description, self
-        )
-
         weight_scalar = connection_modifiers.get('Weight', 1.0)
         exc_mini_frequency, inh_mini_frequency = mini_frequencies \
             if mini_frequencies is not None else (None, None)
@@ -495,13 +512,15 @@ class Cell(InjectableMixin, PlottableMixin):
             spont_minis_rate = inh_mini_frequency
 
         if spont_minis_rate is not None and spont_minis_rate > 0:
-            sec = self.get_psection(post_sec_id).hsection
+            synapse_hoc_args = SynapseFactory.determine_synapse_location(
+                syn_description, self
+            )
             # add the *minis*: spontaneous synaptic events
             self.ips[synapse_id] = neuron.h.\
-                InhPoissonStim(location, sec=sec)
+                InhPoissonStim(synapse_hoc_args.location, sec=synapse_hoc_args.section)
 
             self.syn_mini_netcons[synapse_id] = neuron.h.\
-                NetCon(self.ips[synapse_id], synapse.hsynapse, sec=sec)
+                NetCon(self.ips[synapse_id], synapse.hsynapse, sec=synapse_hoc_args.section)
             self.syn_mini_netcons[synapse_id].delay = 0.1
             self.syn_mini_netcons[synapse_id].weight[0] = weight * weight_scalar
             # set netcon type
@@ -682,9 +701,10 @@ class Cell(InjectableMixin, PlottableMixin):
         """Get a vector of AIS voltage."""
         return self.get_recording('self.axonal[1](0.5)._ref_v')
 
-    def getNumberOfSegments(self) -> int:
+    @property
+    def n_segments(self) -> int:
         """Get the number of segments in the cell."""
-        return sum(section.nseg for section in self.all)
+        return sum(section.nseg for section in self.sections.values())
 
     def add_synapse_replay(
         self, stimulus: SynapseReplay, spike_threshold: float, spike_location: str
@@ -699,27 +719,26 @@ class Cell(InjectableMixin, PlottableMixin):
             pre_gid = CellId(
                 source_population, int(synapse.syn_description[SynapseProperty.PRE_GID])
             )
-            if self.sonata_proxy.circuit_access.target_contains_cell(stimulus.source, pre_gid):
-                if pre_gid.id in synapse_spikes:
-                    spikes_of_interest = synapse_spikes[pre_gid.id]
-                    # filter spikes of interest >=stimulus.delay, <=stimulus.duration
-                    spikes_of_interest = spikes_of_interest[
-                        (spikes_of_interest >= stimulus.delay)
-                        & (spikes_of_interest <= stimulus.duration)
-                    ]
-                    connection = bluecellulab.Connection(
-                        synapse,
-                        pre_spiketrain=spikes_of_interest,
-                        pre_cell=None,
-                        stim_dt=self.record_dt,
-                        spike_threshold=spike_threshold,
-                        spike_location=spike_location,
-                    )
-                    logger.debug(
-                        f"Added synapse replay from {pre_gid} to {self.cell_id.id}, {synapse_id}"
-                    )
-
-                    self.connections[synapse_id] = connection
+            if pre_gid.id in synapse_spikes:
+                spikes_of_interest = synapse_spikes[pre_gid.id]
+                # filter spikes of interest >=stimulus.delay, <=stimulus.duration
+                spikes_of_interest = spikes_of_interest[
+                    (spikes_of_interest >= stimulus.delay)
+                    & (spikes_of_interest <= stimulus.duration)
+                ]
+                connection = bluecellulab.Connection(
+                    synapse,
+                    pre_spiketrain=spikes_of_interest,
+                    pre_cell=None,
+                    stim_dt=self.record_dt,
+                    spike_threshold=spike_threshold,
+                    spike_location=spike_location,
+                )
+                logger.debug(
+                    f"Added synapse replay from {pre_gid} to {self.cell_id.id}, {synapse_id}"
+                )
+
+                self.connections[synapse_id] = connection
 
     @property
     def info_dict(self):

bluecellulab/cell/injector.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -360,17 +360,15 @@ class InjectableMixin:
             stimulus: RelativeShotNoise,
             shotnoise_stim_count=0):
         """Add a replay relative shot noise stimulus."""
-        cv_square = stimulus.amp_cv**2
 
         stim_mode = stimulus.mode
         rel_prop = self.relativity_proportion(stim_mode)
 
         mean = stimulus.mean_percent / 100 * rel_prop
         sd = stimulus.sd_percent / 100 * rel_prop
-        var = sd * sd
 
         rate, amp_mean, amp_var = get_relative_shotnoise_params(
-            mean, var, stimulus.decay_time, stimulus.rise_time, cv_square)
+            mean, sd, stimulus.decay_time, stimulus.rise_time, stimulus.relative_skew)
 
         rng = self._get_shotnoise_step_rand(shotnoise_stim_count, stimulus.seed)
         tvec, svec = gen_shotnoise_signal(stimulus.decay_time, stimulus.rise_time, rate, amp_mean,
@@ -443,14 +441,14 @@ class InjectableMixin:
         time_vector = neuron.h.Vector().from_python(t_content)
         current_vector = neuron.h.Vector().from_python(i_content)
 
-        pulse = neuron.h.IClamp(segx, sec=section)
-        self.persistent.extend([pulse, time_vector, current_vector])
+        iclamp = neuron.h.IClamp(segx, sec=section)
+        self.persistent.extend([iclamp, time_vector, current_vector])
 
-        pulse.delay = t_content[0]
-        pulse.dur = t_content[-1] - t_content[0]
-        current_vector.play(pulse._ref_amp, time_vector)
+        iclamp.delay = t_content[0]
+        iclamp.dur = t_content[-1] - t_content[0]
+        current_vector.play(iclamp._ref_amp, time_vector)
 
-        return current_vector
+        return iclamp, current_vector
 
     @deprecated("Use add_sin_current instead.")
     def addSineCurrentInject(self, start_time, stop_time, freq,

bluecellulab/cell/plotting.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -60,6 +60,7 @@ class PlottableMixin:
             scale_bar_size=10.0,
             fig_title=None):
         """Show a dendrogram of the cell."""
+        self._init_psections()
         cell_dendrogram = bluecellulab.Dendrogram(
             self.psections,
             variable=variable,

bluecellulab/cell/random.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

bluecellulab/cell/recording.py

@@ -0,0 +1,8 @@
+"""Neuron recordings related functions."""
+from __future__ import annotations
+from bluecellulab.type_aliases import NeuronSection
+
+
+def section_to_voltage_recording_str(section: NeuronSection, segment=0.5) -> str:
+    """Converts a section and segment to voltage recording string."""
+    return f"neuron.h.{section.name()}({segment})._ref_v"

bluecellulab/cell/section_distance.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.