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

bluecellulab/__init__.py

@@ -8,9 +8,9 @@ except ImportError:
     BLUEPY_AVAILABLE = False
 
 from .importer import *  # NOQA
-from .tools import *  # NOQA
 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
@@ -19,3 +19,10 @@ from .psegment import PSegment  # NOQA
 from .simulation import Simulation  # NOQA
 from .rngsettings import RNGSettings  # NOQA
 from .ssim import SSim  # NOQA
+
+
+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,130 @@
+"""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.simulation import Simulation
+from bluecellulab.stimulus.factory import Stimulus, StimulusFactory
+from bluecellulab.utils import IsolatedProcess
+
+
+class StimulusName(Enum):
+    """Allowed values for the StimulusName."""
+    AP_WAVEFORM = auto()
+    IDREST = auto()
+    IV = auto()
+    FIRE_PATTERN = 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,
+    duration: float,
+) -> 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.
+        duration: The duration for which the simulation is to be run.
+
+    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]
+    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(duration)
+    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_step_stimuli(
+    cell: Cell,
+    stimulus_name: StimulusName,
+    amplitudes: Sequence[float],
+    duration: float,
+    section_name: str | None = None,
+    segment: float = 0.5,
+    n_processes: int | None = None,
+) -> 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.
+        duration: The duration for which each stimulus is applied.
+        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.
+
+    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 stimulus_name == StimulusName.AP_WAVEFORM:
+            stimulus = stim_factory.ap_waveform(threshold_current=cell.threshold, threshold_percentage=amplitude)
+        elif stimulus_name == StimulusName.IDREST:
+            stimulus = stim_factory.idrest(threshold_current=cell.threshold, threshold_percentage=amplitude)
+        elif stimulus_name == StimulusName.IV:
+            stimulus = stim_factory.iv(threshold_current=cell.threshold, threshold_percentage=amplitude)
+        elif stimulus_name == StimulusName.FIRE_PATTERN:
+            stimulus = stim_factory.fire_pattern(threshold_current=cell.threshold, threshold_percentage=amplitude)
+        else:
+            raise ValueError("Unknown stimulus name.")
+
+        task_args.append((cell.template_params, stimulus, section_name, segment, duration))
+
+    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/core.py

@@ -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
@@ -131,6 +155,13 @@ class Cell(InjectableMixin, PlottableMixin):
         # as the object exists
         self.persistent: list[HocObjectType] = []
 
+    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 +179,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,29 +191,10 @@ 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."""
@@ -197,7 +209,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 +244,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 +259,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 +309,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 +321,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 +343,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 +356,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 +440,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)
@@ -682,9 +696,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

bluecellulab/cell/injector.py

@@ -443,14 +443,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/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/template.py

@@ -20,7 +20,7 @@ import os
 from pathlib import Path
 import re
 import string
-from typing import Optional
+from typing import NamedTuple, Optional
 
 import neuron
 
@@ -44,6 +44,13 @@ def public_hoc_cell(cell: HocObjectType) -> HocObjectType:
          from the hoc model. Either getCell() or CellRef needs to be provided""")
 
 
+class TemplateParams(NamedTuple):
+    template_filepath: str | Path
+    morph_filepath: str | Path
+    template_format: str
+    emodel_properties: Optional[EmodelProperties]
+
+
 class NeuronTemplate:
     """NeuronTemplate representation."""
 

bluecellulab/importer.py

@@ -52,8 +52,8 @@ def import_mod_lib(neuron: ModuleType) -> str:
     return res
 
 
-def import_neurodamus(neuron: ModuleType) -> None:
-    """Import neurodamus."""
+def import_hoc(neuron: ModuleType) -> None:
+    """Import hoc dependencies."""
     neuron.h.load_file("stdrun.hoc")  # nrn
     hoc_files = [
         "Cell.hoc",  # ND
@@ -75,17 +75,15 @@ def print_header(neuron: ModuleType, mod_lib_path: str) -> None:
 
 
 @run_once
-def _load_hoc_and_mod_files() -> None:
+def _load_mod_files() -> None:
     """Import hoc and mod files."""
     logger.debug("Loading the mod files.")
     mod_lib_paths = import_mod_lib(neuron)
-    logger.debug("Loading the hoc files.")
-    import_neurodamus(neuron)
     print_header(neuron, mod_lib_paths)
 
 
-def load_hoc_and_mod_files(func):
+def load_mod_files(func):
     def wrapper(*args, **kwargs):
-        _load_hoc_and_mod_files()
+        _load_mod_files()
         return func(*args, **kwargs)
     return wrapper

bluecellulab/rngsettings.py

@@ -20,7 +20,7 @@ from typing import Optional
 import neuron
 from bluecellulab.circuit.config.definition import SimulationConfig
 from bluecellulab.exceptions import UndefinedRNGException
-from bluecellulab.importer import load_hoc_and_mod_files
+from bluecellulab.importer import load_mod_files
 
 logger = logging.getLogger(__name__)
 
@@ -37,7 +37,7 @@ class RNGSettings:
             cls._instance = cls()
         return cls._instance
 
-    @load_hoc_and_mod_files
+    @load_mod_files
     def __init__(
         self,
         mode="Random123",

bluecellulab/simulation/__init__.py

@@ -3,4 +3,3 @@
 from .simulation import Simulation
 from .neuron_globals import set_global_condition_parameters
 from .neuron_globals import set_minis_single_vesicle_values
-from .neuron_globals import set_tstop_value

bluecellulab/simulation/neuron_globals.py

@@ -62,6 +62,37 @@ def set_minis_single_vesicle_values(mech_conditions: MechanismConditions) -> Non
             )
 
 
-def set_tstop_value(tstop: float) -> None:
-    """Set the tstop value required by Tstim noise stimuli."""
-    neuron.h.tstop = tstop
+class NeuronGlobals:
+    _instance = None
+
+    def __init__(self):
+        raise RuntimeError('Call get_instance() instead')
+
+    @classmethod
+    def get_instance(cls):
+        if cls._instance is None:
+            cls._instance = cls.__new__(cls)
+            # Initialize default values
+            cls._instance._temperature = 34.0  # Default temperature
+            cls._instance.v_init = neuron.h.v_init
+            # Set the default values in NEURON
+            neuron.h.celsius = cls._instance._temperature
+        return cls._instance
+
+    @property
+    def temperature(self):
+        return self._temperature
+
+    @temperature.setter
+    def temperature(self, value):
+        self._temperature = value
+        neuron.h.celsius = value
+
+    @property
+    def v_init(self):
+        return self._v_init
+
+    @v_init.setter
+    def v_init(self, value):
+        self._v_init = value
+        neuron.h.v_init = value

bluecellulab/simulation/simulation.py

@@ -88,13 +88,11 @@ class Simulation:
             cvode=True,
             cvode_minstep=None,
             cvode_maxstep=None,
-            celsius=34,
-            v_init=-65,
             dt=0.025,
             forward_skip=None,
             forward_skip_value=False,
-            show_progress=None,
-            use_random123_stochkv=False):
+            show_progress=None
+    ):
         """Run the simulation."""
         # if maxtime <= neuron.h.t:
         #     raise Exception("Simulation: need to provide a maxtime (=%f) "
@@ -108,7 +106,6 @@ class Simulation:
             self.progress_dt = maxtime / 100
             self.init_progress_callback()
 
-        neuron.h.celsius = celsius
         neuron.h.tstop = maxtime
 
         cvode_old_status = neuron.h.cvode_active()
@@ -125,11 +122,9 @@ class Simulation:
                                "was set")
             neuron.h.cvode_active(0)
 
-        neuron.h.v_init = v_init
-
         for cell in self.cells:
             with contextlib.suppress(AttributeError):
-                cell.re_init_rng(use_random123_stochkv=use_random123_stochkv)
+                cell.re_init_rng()
         neuron.h.dt = dt
         neuron.h.steps_per_ms = 1.0 / dt
 
@@ -176,6 +171,3 @@ class Simulation:
             neuron.h.cvode_active(cvode_old_status)
 
         logger.debug("Finished simulation.")
-
-    def __del__(self):
-        pass

bluecellulab/ssim.py

@@ -39,14 +39,14 @@ from bluecellulab.circuit.config import SimulationConfig
 from bluecellulab.circuit.format import determine_circuit_format, CircuitFormat
 from bluecellulab.circuit.node_id import create_cell_id, create_cell_ids
 from bluecellulab.circuit.simulation_access import BluepySimulationAccess, SimulationAccess, SonataSimulationAccess, _sample_array
-from bluecellulab.importer import load_hoc_and_mod_files
+from bluecellulab.importer import load_mod_files
 from bluecellulab.rngsettings import RNGSettings
+from bluecellulab.simulation.neuron_globals import NeuronGlobals
 from bluecellulab.stimulus.circuit_stimulus_definitions import Noise, OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck, RelativeShotNoise, ShotNoise
 import bluecellulab.stimulus.circuit_stimulus_definitions as circuit_stimulus_definitions
 from bluecellulab.exceptions import BluecellulabError
 from bluecellulab.simulation import (
     set_global_condition_parameters,
-    set_tstop_value
 )
 from bluecellulab.synapse.synapse_types import SynapseID
 
@@ -56,7 +56,7 @@ logger = logging.getLogger(__name__)
 class SSim:
     """Class that loads a circuit simulation to do cell simulations."""
 
-    @load_hoc_and_mod_files
+    @load_mod_files
     def __init__(
         self,
         simulation_config: str | Path | SimulationConfig,
@@ -106,11 +106,6 @@ class SSim:
 
         self.gids_instantiated = False
 
-        # Make sure tstop is set correctly, because it is used by the
-        # TStim noise stimulus
-        if self.circuit_access.config.duration is not None:
-            set_tstop_value(self.circuit_access.config.duration)
-
         self.spike_threshold = self.circuit_access.config.spike_threshold
         self.spike_location = self.circuit_access.config.spike_location
 
@@ -596,8 +591,10 @@ class SSim:
             forward_skip_value = self.circuit_access.config.forward_skip
         if celsius is None:
             celsius = self.circuit_access.config.celsius
+            NeuronGlobals.get_instance().temperature = celsius
         if v_init is None:
             v_init = self.circuit_access.config.v_init
+            NeuronGlobals.get_instance().v_init = v_init
 
         sim = bluecellulab.Simulation(self.pc)
         for cell_id in self.cells:
@@ -612,8 +609,6 @@ class SSim:
             t_stop,
             cvode=cvode,
             dt=dt,
-            celsius=celsius,
-            v_init=v_init,
             forward_skip=forward_skip,
             forward_skip_value=forward_skip_value,
             show_progress=show_progress)

bluecellulab/tools.py

@@ -60,6 +60,8 @@ def calculate_SS_voltage(
     template_format: str,
     emodel_properties: EmodelProperties | None,
     step_level: float,
+    check_for_spiking=False,
+    spike_threshold=-20.0,
 ) -> float:
     """Calculate the steady state voltage at a certain current step."""
     with IsolatedProcess() as runner:
@@ -71,6 +73,8 @@ def calculate_SS_voltage(
                 template_format,
                 emodel_properties,
                 step_level,
+                check_for_spiking,
+                spike_threshold,
             ],
         )
     return SS_voltage
@@ -82,8 +86,8 @@ def calculate_SS_voltage_subprocess(
     template_format: str,
     emodel_properties: EmodelProperties | None,
     step_level: float,
-    check_for_spiking=False,
-    spike_threshold=-20.0,
+    check_for_spiking: bool,
+    spike_threshold: float,
 ) -> float:
     """Subprocess wrapper of calculate_SS_voltage.
 

bluecellulab/type_aliases.py

@@ -1,5 +1,6 @@
 """Type aliases used within the package."""
-
+from __future__ import annotations
+from typing import Dict
 from typing_extensions import TypeAlias
 from neuron import h as hoc_type
 
@@ -8,3 +9,5 @@ NeuronRNG: TypeAlias = hoc_type
 NeuronVector: TypeAlias = hoc_type
 NeuronSection: TypeAlias = hoc_type
 TStim: TypeAlias = hoc_type
+
+SectionMapping = Dict[str, NeuronSection]

bluecellulab/utils.py

@@ -50,5 +50,11 @@ class IsolatedProcess(Pool):
     Use this when running isolated NEURON simulations. Running 2 NEURON
     simulations on a single process is to be avoided.
     """
-    def __init__(self):
-        super().__init__(processes=1, maxtasksperchild=1)
+    def __init__(self, processes: int | None = 1):
+        """Initialize the IsolatedProcess pool.
+
+        Args:
+            processes: The number of processes to use for running the stimuli.
+            If set to None, then the number returned by os.cpu_count() is used.
+        """
+        super().__init__(processes=processes, maxtasksperchild=1)

{bluecellulab-2.4.0.dist-info → bluecellulab-2.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bluecellulab
-Version: 2.4.0
+Version: 2.5.0
 Summary: The Pythonic Blue Brain simulator access
 Home-page: https://github.com/BlueBrain/BlueCelluLab
 Author: Blue Brain Project, EPFL

{bluecellulab-2.4.0.dist-info → bluecellulab-2.5.0.dist-info}/RECORD

@@ -1,30 +1,33 @@
-bluecellulab/__init__.py,sha256=lYxUZtN_mLNUPJgBnKd4GbwDIVScDPD6ouC7OvWQxS0,645
+bluecellulab/__init__.py,sha256=yC97iFnCVDtwqspxdpt4C-qq9vQF7AMJOWe1h_cB0Wc,827
 bluecellulab/connection.py,sha256=volV2YKtmqAF7MOEJar5ldF1ARAo7k2vF9MB1NXybUY,4640
 bluecellulab/dendrogram.py,sha256=w0vvv0Q169DolTX1j9dAZIvHIl4H258gAjQ1xQaNiGk,6427
 bluecellulab/exceptions.py,sha256=KIxF7s_7gPVJ07TiQ-Z1D8de7ylV74gNMhzl0339CVM,2379
 bluecellulab/graph.py,sha256=ODiQy4xjRVxtNITXeXpYnqHas0wR7gZ_aXuDAF7jMq4,3419
-bluecellulab/importer.py,sha256=l5nvD0y41-AheqoDNBGAX5qFTCG6_UFlLmqyFbUo77E,2998
+bluecellulab/importer.py,sha256=zwVi1Nx2f8xzFfzxzYoXa7gfi7DQapqkRJII5sBbRyY,2900
 bluecellulab/neuron_interpreter.py,sha256=hXig_u3T6JmEHbkV8ZblEZtX0kY80ate4VpRtANNFrM,2185
 bluecellulab/plotwindow.py,sha256=UVHzml-BB83m5Qr-YGkjR9kB-vSW8mM0Owh2j95yIaU,2721
 bluecellulab/psection.py,sha256=EgAS8IS9DcYv2xOkNISgfg_CfRc0nDfRFjvgQhyi9eY,6328
 bluecellulab/psegment.py,sha256=rBryDYHC_uDK9itfXXrFZ0DL9F6WgRICL0j5EHN56QM,3125
-bluecellulab/rngsettings.py,sha256=qjwnzAEdbRt66DKd_NTD2OZnlu4hDH7UUOXxd0G9c_Q,4244
-bluecellulab/ssim.py,sha256=U8HFKso4lQkKowts_x2DQfG3ihR56KcN0ITeTlGu3hI,33533
-bluecellulab/tools.py,sha256=tS9a9VDMQOVw6zIllT3FxPIzQk4xheNlGf8lpIg01FY,10931
-bluecellulab/type_aliases.py,sha256=D-evdt299aK61rTh8YGCj-atcj_iFgZbqEoa2LcAiFw,340
-bluecellulab/utils.py,sha256=N9jOOcaxfa4DmG41d7N-M_ywtkAUrRh20llu0gOqXlQ,1743
+bluecellulab/rngsettings.py,sha256=KACk4ujPXhlHL9iAoTdAjjLuFEcUoG6aes92ZClSoQQ,4228
+bluecellulab/ssim.py,sha256=radFcT2lWRfb1C0zKlqw0JQ6JY4b9LJiDP9JDPeQIqs,33399
+bluecellulab/tools.py,sha256=8QMNdmh9lRDOWT4kz9cI_MYNVh4ulxgY8CtHZbaMbkA,11056
+bluecellulab/type_aliases.py,sha256=DvgjERv2Ztdw_sW63JrZTQGpJ0x5uMTFB5hcBHDb0WA,441
+bluecellulab/utils.py,sha256=fgqjgy3xzyL0zu-qjCPJdHp6PEAHADCzlr2FqyBmzHI,2012
 bluecellulab/verbosity.py,sha256=T0IgX7DrRo19faxrT4Xzb27gqxzoILQ8FzYKxvUeaPM,1342
+bluecellulab/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bluecellulab/analysis/inject_sequence.py,sha256=jfEESRAUKAWgjceNWfx3Rwe1gDNWhxwZL4PfnJZCzrg,4930
 bluecellulab/cell/__init__.py,sha256=Sbc0QOsJ8E7tSwf3q7fsXuE_SevBN6ZmoCVyyU5zfII,208
 bluecellulab/cell/cell_dict.py,sha256=PVmZsjhZ9jp3HC-8QmdFqp-crAcVMSVeLWujcOPLlpo,1346
-bluecellulab/cell/core.py,sha256=A-41oObOZKY5H9MkbYIPpQXAaGPeHtK3aAKWZlirjuw,30861
-bluecellulab/cell/injector.py,sha256=28R3MTcnqAB_GGz23BTyWqCurMMkDrrNorgzWDKEFRs,18078
+bluecellulab/cell/core.py,sha256=uxAWAZ6NpODJ3O77p0JWL6AVey3lOyetU3SVZxP4a9Q,31201
+bluecellulab/cell/injector.py,sha256=XC49VSHw78xCHzLJKO_-unnnVZAZXsYg5qbmZPx01AA,18091
 bluecellulab/cell/plotting.py,sha256=_hZs5oYG4vmJBVf05cJ2O_cVazi5Eap8OkL9BtIwjW8,4001
 bluecellulab/cell/random.py,sha256=FDby9BN4eJT27COwHP59bhDE2v-c6rdOKNFj3cYZTVY,1773
+bluecellulab/cell/recording.py,sha256=dekJspPb_5yrS6WR3aXtvZ6KWwMNbyhe5aIOVtNDHpY,342
 bluecellulab/cell/section_distance.py,sha256=J8-oqgCHzRaJkpfjPUR6NFtXDhwbrXad9nDaTCKNkTU,3908
 bluecellulab/cell/serialized_sections.py,sha256=UQUecO07ChRZ7xHuDp-QAQRUpUiIwROzHxjZliP9gfQ,1614
 bluecellulab/cell/sonata_proxy.py,sha256=dLT9mLlGVpXxj2O2lXN0g7Sq4BwroPLVdPikR2yNMv4,1529
 bluecellulab/cell/stimuli_generator.py,sha256=cJwjNwsQeEBHLjuJIFv6VBSqd9IpmbR7CuSMyotCiWc,6320
-bluecellulab/cell/template.py,sha256=EW7-hSa_sfWwd2hH_w48sHAlrN9O7XJSmnPfoWFdz08,7374
+bluecellulab/cell/template.py,sha256=K8Vp1-yE6-9wxjmhkLBhnjBhgciUixoMk8LU-GioTgM,7562
 bluecellulab/cell/ballstick/__init__.py,sha256=v1Z8tHFfbpWShxOBdShCUaE0utoz-7rZumuNBQtNOFI,439
 bluecellulab/cell/ballstick/emodel.hoc,sha256=7WcuepK-wB9bASRvNdCwO9Woc9-SpBCFqBqCXKgjsV8,1517
 bluecellulab/cell/ballstick/morphology.asc,sha256=EO0VIRilJAwpiDP2hIevwusfvYptNYhvsu1f5GgbSQo,190
@@ -49,18 +52,18 @@ bluecellulab/hoc/RNGSettings.hoc,sha256=okJBdqlPXET8BrpG1Q31GdaxHfpe3CE0L5P7MAhf
 bluecellulab/hoc/TDistFunc.hoc,sha256=WKX-anvL83xGuGPH9g1oIORB17UM4Pi3-iIXzKO-pUQ,2663
 bluecellulab/hoc/TStim.hoc,sha256=noBJbM_ZqF6T6MEgBeowNzz21I9QeYZ5brGgUvCSm4k,8473
 bluecellulab/hoc/fileUtils.hoc,sha256=LSM7BgyjYVqo2DGSOKvg4W8IIusbsL45JVYK0vgwitU,2539
-bluecellulab/simulation/__init__.py,sha256=G1md-6mqaYQkfZT8pmzqRi3WW1fMQCgkeaela2kX3OM,258
-bluecellulab/simulation/neuron_globals.py,sha256=PuAxrXbr734RP-5q6YkHpnOgzTVyo_8SYZux9HABlaI,3348
-bluecellulab/simulation/simulation.py,sha256=tM5Psl-w25CHA4hp2fqs3GcZ2HSjIbu_6iyOcs-1jd8,6439
+bluecellulab/simulation/__init__.py,sha256=P2ebt0SFw-08J3ihN-LeRn95HeF79tzA-Q0ReLm32dM,214
+bluecellulab/simulation/neuron_globals.py,sha256=uxgceZ7zzbVEtITrQv8oOK900zhh7w29cScFwjLWo4I,4134
+bluecellulab/simulation/simulation.py,sha256=I__cZwV_A8I7XSefn6aJDBA_jXCI3E35-pCNCLUsnvo,6206
 bluecellulab/stimulus/__init__.py,sha256=DgIgVaSyR-URf3JZzvO6j-tjCerzvktuK-ep8pjMRPQ,37
 bluecellulab/stimulus/circuit_stimulus_definitions.py,sha256=uij_s44uNdmMwMLGmTHSRgmp9K9B_vvHHshX6YPJNJU,15686
 bluecellulab/stimulus/factory.py,sha256=AOby3Sp2g8BJsRccz3afazfCyysyWIgLtcliWlyeiu0,8097
 bluecellulab/synapse/__init__.py,sha256=RW8XoAMXOvK7OG1nHl_q8jSEKLj9ZN4oWf2nY9HAwuk,192
 bluecellulab/synapse/synapse_factory.py,sha256=YkvxbdGF-u-vxYdbRNTlX-9AtSC_3t_FQRFhybwzgrk,6805
 bluecellulab/synapse/synapse_types.py,sha256=4gne-hve2vq1Lau-LAVPsfLjffVYqAYBW3kCfC7_600,16871
-bluecellulab-2.4.0.dist-info/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
-bluecellulab-2.4.0.dist-info/LICENSE,sha256=xOouu1gC1GGklDxkITlaVl60I9Ab860O-nZsFbWydvU,11749
-bluecellulab-2.4.0.dist-info/METADATA,sha256=INJHNIWkhkP13SaZcuI50UsUJ8-hTjW35YS_YcAfGZA,6907
-bluecellulab-2.4.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-bluecellulab-2.4.0.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
-bluecellulab-2.4.0.dist-info/RECORD,,
+bluecellulab-2.5.0.dist-info/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
+bluecellulab-2.5.0.dist-info/LICENSE,sha256=xOouu1gC1GGklDxkITlaVl60I9Ab860O-nZsFbWydvU,11749
+bluecellulab-2.5.0.dist-info/METADATA,sha256=cZyD4VU0diQXkzIlXFVHT6UAbNb2tsEyD01w-6UICZY,6907
+bluecellulab-2.5.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+bluecellulab-2.5.0.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
+bluecellulab-2.5.0.dist-info/RECORD,,