bluecellulab 2.5.11__tar.gz → 2.6.0__tar.gz

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

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

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

@@ -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.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.11 → bluecellulab-2.6.0}/bluecellulab.egg-info/PKG-INFO

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

{bluecellulab-2.5.11 → bluecellulab-2.6.0}/docs/source/list_of_stim.rst

@@ -37,7 +37,7 @@ Step Stimulus
    :context: close-figs
    :include-source: True
 
-   step = stim_factory.step(start=20, end=180, amplitude=70)
+   step = stim_factory.step(pre_delay=20, duration=80, post_delay=20, amplitude=70)
    step.plot()
 
 
@@ -47,19 +47,19 @@ Multiple step stimuli with different amplitudes.
    :context: close-figs
    :include-source: True
 
-   step1 = stim_factory.step(start=50, end=150, amplitude=60)
-   step2 = stim_factory.step(start=50, end=150, amplitude=80)
-   step3 = stim_factory.step(start=50, end=150, amplitude=100)
-   step4 = stim_factory.step(start=50, end=150, amplitude=120)
+   step1 = stim_factory.step(pre_delay=50, duration=100, post_delay=50, amplitude=60)
+   step2 = stim_factory.step(pre_delay=50, duration=100, post_delay=50, amplitude=80)
+   step3 = stim_factory.step(pre_delay=50, duration=100, post_delay=50, amplitude=100)
+   step4 = stim_factory.step(pre_delay=50, duration=100, post_delay=50, amplitude=120)
 
    # Create a figure and an Axes object
    fig, ax = plt.subplots()
 
    # Plot the step functions on the same axes
-   step1.plot_during_simulation(200, ax=ax, color='red')
-   step2.plot_during_simulation(200, ax=ax, color='green')
-   step3.plot_during_simulation(200, ax=ax, color='blue')
-   step4.plot_during_simulation(200, ax=ax, color='orange')
+   step1.plot(ax=ax, color='red')
+   step2.plot(ax=ax, color='green')
+   step3.plot(ax=ax, color='blue')
+   step4.plot(ax=ax, color='orange')
 
    plt.show()
 
@@ -73,7 +73,7 @@ Ramp Stimulus
    :context: close-figs
    :include-source: True
 
-   ramp = stim_factory.ramp(start=20, end=180, amplitude_start=0.25, amplitude_end=0.5)
+   ramp = stim_factory.ramp(pre_delay=20, duration=160, post_delay=70, amplitude=0.5)
 
    ramp.plot()
 
@@ -89,7 +89,7 @@ APWaveform
    :include-source: True
 
    ap_waveform = stim_factory.ap_waveform(threshold_current=0.5)
-   ap_waveform.plot_during_simulation(600)
+   ap_waveform.plot()
 
 
 IDRest
@@ -102,7 +102,7 @@ IDRest
    :include-source: True
 
    id_rest = stim_factory.idrest(threshold_current=0.5)
-   id_rest.plot_during_simulation(2000)
+   id_rest.plot()
 
 IV
 ~~
@@ -114,7 +114,7 @@ IV
    :include-source: True
 
    iv = stim_factory.iv(threshold_current=0.5)
-   iv.plot_during_simulation(4500)
+   iv.plot()
 
 FirePattern
 ~~~~~~~~~~~~~
@@ -126,7 +126,7 @@ FirePattern
    :include-source: True
 
    fire_pattern = stim_factory.fire_pattern(threshold_current=0.5)
-   fire_pattern.plot_during_simulation(4500)
+   fire_pattern.plot()
 
 
 .. plot::