bluecellulab 2.5.10__tar.gz → 2.6.0__tar.gz

{bluecellulab-2.5.10 → bluecellulab-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bluecellulab
-Version: 2.5.10
+Version: 2.6.0
 Summary: Biologically detailed neural network simulations and analysis.
 Author: Blue Brain Project, EPFL
 License: Apache2.0

{bluecellulab-2.5.10 → bluecellulab-2.6.0}/bluecellulab/__init__.py

@@ -7,7 +7,7 @@ try:
 except ImportError:
     BLUEPY_AVAILABLE = False
 
-from .importer import *  # NOQA
+from bluecellulab.importer import import_hoc
 from .verbosity import *
 from .cell import Cell, create_ball_stick  # NOQA
 from .circuit import EmodelProperties
@@ -19,7 +19,7 @@ from .psegment import PSegment  # NOQA
 from .simulation import Simulation  # NOQA
 from .rngsettings import RNGSettings  # NOQA
 from .circuit_simulation import CircuitSimulation, CircuitSimulation  # NOQA
-
+import neuron
 
 from .simulation.neuron_globals import NeuronGlobals
 

{bluecellulab-2.5.10 → bluecellulab-2.6.0}/bluecellulab/analysis/inject_sequence.py

@@ -7,9 +7,9 @@ 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.factory import Stimulus, StimulusFactory
-from bluecellulab.utils import IsolatedProcess
 
 
 class StimulusName(Enum):
@@ -35,7 +35,6 @@ def run_stimulus(
     stimulus: Stimulus,
     section: str,
     segment: float,
-    duration: float,
 ) -> Recording:
     """Creates a cell and stimulates it with a given stimulus.
 
@@ -44,7 +43,6 @@ def run_stimulus(
         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.
@@ -61,7 +59,7 @@ def run_stimulus(
     current_vector = neuron.h.Vector()
     current_vector.record(iclamp._ref_i)
     simulation = Simulation(cell)
-    simulation.run(duration)
+    simulation.run(stimulus.stimulus_time)
     current = np.array(current_vector.to_python())
     voltage = cell.get_voltage_recording(neuron_section, segment)
     time = cell.get_time()
@@ -74,7 +72,6 @@ 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,
@@ -85,7 +82,6 @@ def apply_multiple_step_stimuli(
         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.
@@ -116,7 +112,7 @@ def apply_multiple_step_stimuli(
         else:
             raise ValueError("Unknown stimulus name.")
 
-        task_args.append((cell.template_params, stimulus, section_name, segment, duration))
+        task_args.append((cell.template_params, stimulus, section_name, segment))
 
     with IsolatedProcess(processes=n_processes) as pool:
         # Map expects a function and a list of argument tuples

{bluecellulab-2.5.10 → bluecellulab-2.6.0}/bluecellulab/circuit/circuit_access/bluepy_circuit_access.py

@@ -19,8 +19,9 @@ import os
 from pathlib import Path
 from typing import Optional
 
+import neuron
 import pandas as pd
-from bluecellulab import circuit, neuron
+from bluecellulab import circuit
 from bluecellulab.circuit.circuit_access import EmodelProperties
 from bluecellulab.circuit.config import BluepySimulationConfig
 from bluecellulab.circuit.config.definition import SimulationConfig

{bluecellulab-2.5.10 → bluecellulab-2.6.0}/bluecellulab/circuit/circuit_access/sonata_circuit_access.py

@@ -22,8 +22,9 @@ from bluepysnap.bbp import Cell as SnapCell
 from bluepysnap.circuit_ids import CircuitNodeId, CircuitEdgeIds
 from bluepysnap.exceptions import BluepySnapError
 from bluepysnap import Circuit as SnapCircuit
+import neuron
 import pandas as pd
-from bluecellulab import circuit, neuron
+from bluecellulab import circuit
 from bluecellulab.circuit.circuit_access.definition import EmodelProperties
 from bluecellulab.circuit import CellId, SynapseProperty
 from bluecellulab.circuit.config import SimulationConfig

{bluecellulab-2.5.10 → bluecellulab-2.6.0}/bluecellulab/simulation/neuron_globals.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Module that handles the global NEURON parameters."""
 
+from typing import NamedTuple
 import neuron
 from bluecellulab.circuit.config.sections import Conditions, MechanismConditions
 from bluecellulab.exceptions import error_context
@@ -62,6 +63,11 @@ def set_minis_single_vesicle_values(mech_conditions: MechanismConditions) -> Non
             )
 
 
+class NeuronGlobalParams(NamedTuple):
+    temperature: float
+    v_init: float
+
+
 class NeuronGlobals:
     _instance = None
 
@@ -96,3 +102,10 @@ class NeuronGlobals:
     def v_init(self, value):
         self._v_init = value
         neuron.h.v_init = value
+
+    def export_params(self) -> NeuronGlobalParams:
+        return NeuronGlobalParams(self.temperature, self.v_init)
+
+    def load_params(self, params: NeuronGlobalParams) -> None:
+        self.temperature = params.temperature
+        self.v_init = params.v_init

bluecellulab-2.6.0/bluecellulab/simulation/parallel.py

@@ -0,0 +1,36 @@
+"""Controlled simulations in parallel."""
+
+from __future__ import annotations
+from multiprocessing.pool import Pool
+from bluecellulab.simulation.neuron_globals import NeuronGlobals
+
+
+class IsolatedProcess(Pool):
+    """Multiprocessing Pool that restricts a worker to run max 1 process.
+
+    Use this when running isolated NEURON simulations. Running 2 NEURON
+    simulations on a single process is to be avoided. Required global
+    NEURON simulation parameters will automatically be passed to each
+    worker.
+    """
+
+    def __init__(self, processes: int | None = 1):
+        """Initialize the IsolatedProcess pool.
+
+        Args:
+            processes: The number of processes to use for running the simulations.
+                       If set to None, then the number returned by os.cpu_count() is used.
+        """
+        neuron_global_params = NeuronGlobals.get_instance().export_params()
+        super().__init__(
+            processes=processes,
+            initializer=self.init_worker,
+            initargs=(neuron_global_params,),
+            maxtasksperchild=1,
+        )
+
+    @staticmethod
+    def init_worker(neuron_global_params):
+        """Load global parameters for the NEURON environment in each worker
+        process."""
+        NeuronGlobals.get_instance().load_params(neuron_global_params)

bluecellulab-2.6.0/bluecellulab/stimulus/factory.py

@@ -0,0 +1,389 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+class Stimulus(ABC):
+    def __init__(self, dt: float) -> None:
+        self.dt = dt
+
+    @property
+    @abstractmethod
+    def time(self) -> np.ndarray:
+        """Time values of the stimulus."""
+        ...
+
+    @property
+    @abstractmethod
+    def current(self) -> np.ndarray:
+        """Current values of the stimulus."""
+        ...
+
+    def __len__(self) -> int:
+        return len(self.time)
+
+    @property
+    def stimulus_time(self) -> float:
+        return len(self) * self.dt
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(dt={self.dt})"
+
+    def plot(self, ax=None, **kwargs):
+        if ax is None:
+            ax = plt.gca()
+        ax.plot(self.time, self.current, **kwargs)
+        ax.set_xlabel("Time (ms)")
+        ax.set_ylabel("Current (nA)")
+        ax.set_title(self.__class__.__name__)
+        return ax
+
+    def __add__(self, other: Stimulus) -> CombinedStimulus:
+        """Override + operator to concatenate Stimulus objects."""
+        if self.dt != other.dt:
+            raise ValueError(
+                "Stimulus objects must have the same dt to be concatenated"
+            )
+        if len(self.time) == 0:
+            return CombinedStimulus(other.dt, other.time, other.current)
+        elif len(other.time) == 0:
+            return CombinedStimulus(self.dt, self.time, self.current)
+        else:
+            # shift other time
+            other_time = other.time + self.time[-1] + self.dt
+            combined_time = np.concatenate([self.time, other_time])
+            # Concatenate the current arrays
+            combined_current = np.concatenate([self.current, other.current])
+            return CombinedStimulus(self.dt, combined_time, combined_current)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Stimulus):
+            return NotImplemented
+        else:
+            return (
+                np.allclose(self.time, other.time)
+                and np.allclose(self.current, other.current)
+                and self.dt == other.dt
+            )
+
+
+class CombinedStimulus(Stimulus):
+    """Represents the Stimulus created by combining multiple stimuli."""
+
+    def __init__(self, dt: float, time: np.ndarray, current: np.ndarray) -> None:
+        super().__init__(dt)
+        self._time = time
+        self._current = current
+
+    @property
+    def time(self) -> np.ndarray:
+        return self._time
+
+    @property
+    def current(self) -> np.ndarray:
+        return self._current
+
+
+class Empty(Stimulus):
+    """Represents empty stimulus (all zeros) that has no impact on the cell.
+
+    This is required by some Stimuli that expect the cell to rest.
+    """
+
+    def __init__(self, dt: float, duration: float) -> None:
+        super().__init__(dt)
+        self.duration = duration
+
+    @property
+    def time(self) -> np.ndarray:
+        return np.arange(0.0, self.duration, self.dt)
+
+    @property
+    def current(self) -> np.ndarray:
+        return np.zeros_like(self.time)
+
+
+class Flat(Stimulus):
+    def __init__(self, dt: float, duration: float, amplitude: float) -> None:
+        super().__init__(dt)
+        self.duration = duration
+        self.amplitude = amplitude
+
+    @property
+    def time(self) -> np.ndarray:
+        return np.arange(0.0, self.duration, self.dt)
+
+    @property
+    def current(self) -> np.ndarray:
+        return np.full_like(self.time, self.amplitude)
+
+
+class Slope(Stimulus):
+    def __init__(
+        self, dt: float, duration: float, amplitude_start: float, amplitude_end: float
+    ) -> None:
+        super().__init__(dt)
+        self.duration = duration
+        self.amplitude_start = amplitude_start
+        self.amplitude_end = amplitude_end
+
+    @property
+    def time(self) -> np.ndarray:
+        return np.arange(0.0, self.duration, self.dt)
+
+    @property
+    def current(self) -> np.ndarray:
+        return np.linspace(self.amplitude_start, self.amplitude_end, len(self.time))
+
+
+class Step(Stimulus):
+
+    def __init__(self):
+        raise NotImplementedError(
+            "This class cannot be instantiated directly. "
+            "Please use the class methods 'amplitude_based' "
+            "or 'threshold_based' to create objects."
+        )
+
+    @classmethod
+    def amplitude_based(
+        cls,
+        dt: float,
+        pre_delay: float,
+        duration: float,
+        post_delay: float,
+        amplitude: float,
+    ) -> CombinedStimulus:
+        """Create a Step stimulus from given time events and amplitude.
+
+        Args:
+            dt: The time step of the stimulus.
+            pre_delay: The delay before the start of the step.
+            duration: The duration of the step.
+            post_delay: The time to wait after the end of the step.
+            amplitude: The amplitude of the step.
+        """
+        return (
+            Empty(dt, duration=pre_delay)
+            + Flat(dt, duration=duration, amplitude=amplitude)
+            + Empty(dt, duration=post_delay)
+        )
+
+    @classmethod
+    def threshold_based(
+        cls,
+        dt: float,
+        pre_delay: float,
+        duration: float,
+        post_delay: float,
+        threshold_current: float,
+        threshold_percentage: float,
+    ) -> CombinedStimulus:
+        """Creates a Step stimulus with respect to the threshold current.
+
+        Args:
+
+            dt: The time step of the stimulus.
+            pre_delay: The delay before the start of the step.
+            duration: The duration of the step.
+            post_delay: The time to wait after the end of the step.
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+        """
+        amplitude = threshold_current * threshold_percentage / 100
+        res = cls.amplitude_based(
+            dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            amplitude=amplitude,
+        )
+        return res
+
+
+class Ramp(Stimulus):
+
+    def __init__(self):
+        raise NotImplementedError(
+            "This class cannot be instantiated directly. "
+            "Please use the class methods 'amplitude_based' "
+            "or 'threshold_based' to create objects."
+        )
+
+    @classmethod
+    def amplitude_based(
+        cls,
+        dt: float,
+        pre_delay: float,
+        duration: float,
+        post_delay: float,
+        amplitude: float,
+    ) -> CombinedStimulus:
+        """Create a Ramp stimulus from given time events and amplitudes.
+
+        Args:
+            dt: The time step of the stimulus.
+            pre_delay: The delay before the start of the ramp.
+            duration: The duration of the ramp.
+            post_delay: The time to wait after the end of the ramp.
+            amplitude: The final amplitude of the ramp.
+        """
+        return (
+            Empty(dt, duration=pre_delay)
+            + Slope(
+                dt,
+                duration=duration,
+                amplitude_start=0.0,
+                amplitude_end=amplitude,
+            )
+            + Empty(dt, duration=post_delay)
+        )
+
+    @classmethod
+    def threshold_based(
+        cls,
+        dt: float,
+        pre_delay: float,
+        duration: float,
+        post_delay: float,
+        threshold_current: float,
+        threshold_percentage: float,
+    ) -> CombinedStimulus:
+        """Creates a Ramp stimulus with respect to the threshold current.
+
+        Args:
+
+            dt: The time step of the stimulus.
+            pre_delay: The delay before the start of the ramp.
+            duration: The duration of the ramp.
+            post_delay: The time to wait after the end of the ramp.
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+        """
+        amplitude = threshold_current * threshold_percentage / 100
+        res = cls.amplitude_based(
+            dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            amplitude=amplitude,
+        )
+        return res
+
+
+class StimulusFactory:
+    def __init__(self, dt: float):
+        self.dt = dt
+
+    def step(
+        self, pre_delay: float, duration: float, post_delay: float, amplitude: float
+    ) -> Stimulus:
+        return Step.amplitude_based(
+            self.dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            amplitude=amplitude,
+        )
+
+    def ramp(
+        self, pre_delay: float, duration: float, post_delay: float, amplitude: float
+    ) -> Stimulus:
+        return Ramp.amplitude_based(
+            self.dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            amplitude=amplitude,
+        )
+
+    def ap_waveform(
+        self, threshold_current: float, threshold_percentage: float = 220.0
+    ) -> Stimulus:
+        """Returns the APWaveform Stimulus object, a type of Step stimulus.
+
+        Args:
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+        """
+        pre_delay = 250.0
+        duration = 50.0
+        post_delay = 250.0
+        return Step.threshold_based(
+            self.dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            threshold_current=threshold_current,
+            threshold_percentage=threshold_percentage,
+        )
+
+    def idrest(
+        self,
+        threshold_current: float,
+        threshold_percentage: float = 200.0,
+    ) -> Stimulus:
+        """Returns the IDRest Stimulus object, a type of Step stimulus.
+
+        Args:
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+        """
+        pre_delay = 250.0
+        duration = 1350.0
+        post_delay = 250.0
+        return Step.threshold_based(
+            self.dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            threshold_current=threshold_current,
+            threshold_percentage=threshold_percentage,
+        )
+
+    def iv(
+        self,
+        threshold_current: float,
+        threshold_percentage: float = -40.0,
+    ) -> Stimulus:
+        """Returns the IV Stimulus object, a type of Step stimulus.
+
+        Args:
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+        """
+        pre_delay = 250.0
+        duration = 3000.0
+        post_delay = 250.0
+        return Step.threshold_based(
+            self.dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            threshold_current=threshold_current,
+            threshold_percentage=threshold_percentage,
+        )
+
+    def fire_pattern(
+        self,
+        threshold_current: float,
+        threshold_percentage: float = 200.0,
+    ) -> Stimulus:
+        """Returns the FirePattern Stimulus object, a type of Step stimulus.
+
+        Args:
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+        """
+        pre_delay = 250.0
+        duration = 3600.0
+        post_delay = 250.0
+        return Step.threshold_based(
+            self.dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            threshold_current=threshold_current,
+            threshold_percentage=threshold_percentage,
+        )

{bluecellulab-2.5.10 → bluecellulab-2.6.0}/bluecellulab/tools.py

@@ -25,7 +25,8 @@ import numpy as np
 import bluecellulab
 from bluecellulab.circuit.circuit_access import EmodelProperties
 from bluecellulab.exceptions import UnsteadyCellError
-from bluecellulab.utils import CaptureOutput, IsolatedProcess
+from bluecellulab.simulation.parallel import IsolatedProcess
+from bluecellulab.utils import CaptureOutput
 
 logger = logging.getLogger(__name__)
 

{bluecellulab-2.5.10 → bluecellulab-2.6.0}/bluecellulab/utils.py

@@ -1,19 +1,21 @@
 """Utility functions used within BlueCellulab."""
+
 from __future__ import annotations
 import contextlib
 import io
 import json
-from multiprocessing.pool import Pool
 
 import numpy as np
 
 
 def run_once(func):
     """A decorator to ensure a function is only called once."""
+
     def wrapper(*args, **kwargs):
         if not wrapper.has_run:
             wrapper.has_run = True
             return func(*args, **kwargs)
+
     wrapper.has_run = False
     return wrapper
 
@@ -32,29 +34,25 @@ class CaptureOutput(list):
 
 class NumpyEncoder(json.JSONEncoder):
     def default(self, obj):
-        if isinstance(obj, (np.int_, np.intc, np.intp, np.int8,
-                            np.int16, np.int32, np.int64, np.uint8,
-                            np.uint16, np.uint32, np.uint64)):
+        if isinstance(
+            obj,
+            (
+                np.int_,
+                np.intc,
+                np.intp,
+                np.int8,
+                np.int16,
+                np.int32,
+                np.int64,
+                np.uint8,
+                np.uint16,
+                np.uint32,
+                np.uint64,
+            ),
+        ):
             return int(obj)
-        elif isinstance(obj, (np.float_, np.float16, np.float32,
-                              np.float64)):
+        elif isinstance(obj, (np.float_, np.float16, np.float32, np.float64)):
             return float(obj)
         elif isinstance(obj, np.ndarray):
             return obj.tolist()
         return json.JSONEncoder.default(self, obj)
-
-
-class IsolatedProcess(Pool):
-    """Multiprocessing Pool that restricts a worker to run max 1 process.
-
-    Use this when running isolated NEURON simulations. Running 2 NEURON
-    simulations on a single process is to be avoided.
-    """
-    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.5.10 → bluecellulab-2.6.0}/bluecellulab.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bluecellulab
-Version: 2.5.10
+Version: 2.6.0
 Summary: Biologically detailed neural network simulations and analysis.
 Author: Blue Brain Project, EPFL
 License: Apache2.0

{bluecellulab-2.5.10 → bluecellulab-2.6.0}/bluecellulab.egg-info/SOURCES.txt

@@ -76,6 +76,7 @@ bluecellulab/hoc/TStim.hoc
 bluecellulab/hoc/fileUtils.hoc
 bluecellulab/simulation/__init__.py
 bluecellulab/simulation/neuron_globals.py
+bluecellulab/simulation/parallel.py
 bluecellulab/simulation/simulation.py
 bluecellulab/stimulus/__init__.py
 bluecellulab/stimulus/circuit_stimulus_definitions.py
@@ -420,6 +421,7 @@ tests/test_circuit/test_synapse_properties.py
 tests/test_circuit/test_validate.py
 tests/test_simulation/__init__.py
 tests/test_simulation/test_neuron_globals.py
+tests/test_simulation/test_parallel.py
 tests/test_simulation/test_simulation.py
 tests/test_stimulus/__init__.py
 tests/test_stimulus/test_circuit_stimulus_definitions.py