bluecellulab 2.6.44__tar.gz → 2.6.46__tar.gz

{bluecellulab-2.6.44 → bluecellulab-2.6.46}/PKG-INFO

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

{bluecellulab-2.6.44 → bluecellulab-2.6.46}/bluecellulab/cell/injector.py

@@ -515,3 +515,12 @@ class InjectableMixin:
         syn.e = e
         self.persistent.append(syn)  # type: ignore
         return syn
+
+    def add_sinusoidal(self, stimulus) -> TStim:
+        """Inject sinusoidal stimulus for replay."""
+        return self.add_sin_current(
+            stimulus.amp_start,
+            stimulus.delay,
+            stimulus.duration,
+            stimulus.frequency,
+        )

{bluecellulab-2.6.44 → bluecellulab-2.6.46}/bluecellulab/circuit_simulation.py

@@ -139,6 +139,7 @@ class CircuitSimulation:
         pre_spike_trains: None | dict[tuple[str, int], Iterable] | dict[int, Iterable] = None,
         add_shotnoise_stimuli: bool = False,
         add_ornstein_uhlenbeck_stimuli: bool = False,
+        add_sinusoidal_stimuli: bool = False,
         add_linear_stimuli: bool = False,
     ):
         """Instantiate a list of cells.
@@ -210,6 +211,11 @@ class CircuitSimulation:
                             of the simulation config,
                             Setting add_stimuli=True,
                             will automatically set this option to True.
+        add_sinusoidal_stimuli : Process the 'sinusoidal' stimuli
+                            blocks of the simulation config.
+                            Setting add_stimuli=True,
+                            will automatically set this option to
+                            True.
         add_linear_stimuli : Process the 'linear' stimuli
                                 blocks of the simulation config.
                                 Setting add_stimuli=True,
@@ -271,6 +277,7 @@ class CircuitSimulation:
             add_hyperpolarizing_stimuli = True
             add_relativelinear_stimuli = True
             add_pulse_stimuli = True
+            add_sinusoidal_stimuli = True
             add_shotnoise_stimuli = True
             add_ornstein_uhlenbeck_stimuli = True
             add_linear_stimuli = True
@@ -281,6 +288,7 @@ class CircuitSimulation:
                 add_relativelinear_stimuli or \
                 add_shotnoise_stimuli or \
                 add_ornstein_uhlenbeck_stimuli or \
+                add_sinusoidal_stimuli or \
                 add_linear_stimuli:
             self._add_stimuli(
                 add_noise_stimuli=add_noise_stimuli,
@@ -289,6 +297,7 @@ class CircuitSimulation:
                 add_pulse_stimuli=add_pulse_stimuli,
                 add_shotnoise_stimuli=add_shotnoise_stimuli,
                 add_ornstein_uhlenbeck_stimuli=add_ornstein_uhlenbeck_stimuli,
+                add_sinusoidal_stimuli=add_sinusoidal_stimuli,
                 add_linear_stimuli=add_linear_stimuli
             )
 
@@ -298,6 +307,7 @@ class CircuitSimulation:
                      add_pulse_stimuli=False,
                      add_shotnoise_stimuli=False,
                      add_ornstein_uhlenbeck_stimuli=False,
+                     add_sinusoidal_stimuli=False,
                      add_linear_stimuli=False
                      ):
         """Instantiate all the stimuli."""
@@ -352,6 +362,9 @@ class CircuitSimulation:
                         self.cells[cell_id].add_relative_ornstein_uhlenbeck(
                             self.cells[cell_id].soma, 0.5, stimulus,
                             stim_count=ornstein_uhlenbeck_stim_count)
+                elif isinstance(stimulus, circuit_stimulus_definitions.Sinusoidal):
+                    if add_sinusoidal_stimuli:
+                        self.cells[cell_id].add_sinusoidal(stimulus)
                 elif isinstance(stimulus, circuit_stimulus_definitions.SynapseReplay):  # sonata only
                     if self.circuit_access.target_contains_cell(
                         stimulus.target, cell_id

{bluecellulab-2.6.44 → bluecellulab-2.6.46}/bluecellulab/stimulus/circuit_stimulus_definitions.py

@@ -49,6 +49,7 @@ class Pattern(Enum):
     RELATIVE_SHOT_NOISE = "relative_shot_noise"
     ORNSTEIN_UHLENBECK = "ornstein_uhlenbeck"
     RELATIVE_ORNSTEIN_UHLENBECK = "relative_ornstein_uhlenbeck"
+    SINUSOIDAL = "sinusoidal"
 
     @classmethod
     def from_blueconfig(cls, pattern: str) -> Pattern:
@@ -95,6 +96,8 @@ class Pattern(Enum):
             return Pattern.ORNSTEIN_UHLENBECK
         elif pattern == "relative_ornstein_uhlenbeck":
             return Pattern.RELATIVE_ORNSTEIN_UHLENBECK
+        elif pattern == "sinusoidal":
+            return Pattern.SINUSOIDAL
         else:
             raise ValueError(f"Unknown pattern {pattern}")
 
@@ -313,6 +316,14 @@ class Stimulus:
                 mode=ClampMode(stimulus_entry.get("input_type", "current_clamp").lower()),
                 reversal=stimulus_entry.get("reversal", 0.0)
             )
+        elif pattern == Pattern.SINUSOIDAL:
+            return Sinusoidal(
+                target=stimulus_entry["node_set"],
+                delay=stimulus_entry["delay"],
+                duration=stimulus_entry["duration"],
+                amp_start=stimulus_entry["amp_start"],
+                frequency=stimulus_entry["frequency"],
+            )
         else:
             raise ValueError(f"Unknown pattern {pattern}")
 
@@ -436,3 +447,9 @@ class RelativeOrnsteinUhlenbeck(Stimulus):
     seed: Optional[int] = None
     mode: ClampMode = ClampMode.CURRENT
     reversal: float = 0.0
+
+
+@dataclass(frozen=True, config=dict(extra="forbid"))
+class Sinusoidal(Stimulus):
+    amp_start: float
+    frequency: float

{bluecellulab-2.6.44 → bluecellulab-2.6.46}/bluecellulab/stimulus/factory.py

@@ -16,8 +16,7 @@
 from __future__ import annotations
 from typing import Optional
 import logging
-from bluecellulab.stimulus.stimulus import DelayedZap, Empty, Ramp, Slope, Step, StepNoise, Stimulus, OrnsteinUhlenbeck, ShotNoise
-from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus as CircuitStimulus
+from bluecellulab.stimulus.stimulus import DelayedZap, Empty, Ramp, Slope, Step, StepNoise, Stimulus, OrnsteinUhlenbeck, ShotNoise, Sinusoidal, Pulse
 
 logger = logging.getLogger(__name__)
 
@@ -376,6 +375,72 @@ class StimulusFactory:
 
         raise TypeError("You have to give either threshold_current or amplitude")
 
+    def sinusoidal(
+        self,
+        pre_delay: float,
+        post_delay: float,
+        duration: float,
+        frequency: float,
+        amplitude: Optional[float] = None,
+        amplitude_percent: Optional[float] = None,
+        threshold_current: Optional[float] = None,
+        dt: float = 0.025,
+    ) -> Stimulus:
+        """Creates a Sinusoidal stimulus (factory-compatible).
+
+        Args:
+            pre_delay: Delay before the sinusoidal stimulus starts (ms).
+            post_delay: Delay after the stimulus ends (ms).
+            duration: Duration of the stimulus (ms).
+            frequency: Frequency of oscillation (Hz).
+            amplitude: Absolute amplitude (nA). Used if provided.
+            amplitude_percent: Amplitude as a percentage of threshold current.
+            threshold_current: Reference threshold current for percentage-based calculation.
+            dt: Time step of the stimulus (ms).
+
+        Returns:
+            A `Stimulus` object (Sinusoidal) that can be plotted and injected.
+
+        Notes:
+            - If `amplitude` is provided, `amplitude_percent` is ignored.
+            - If `threshold_current` is not provided, threshold-based parameters cannot be used.
+        """
+        is_amplitude_based = amplitude is not None
+        is_threshold_based = (
+            threshold_current is not None
+            and threshold_current != 0
+            and amplitude_percent is not None
+        )
+
+        if is_amplitude_based:
+            if is_threshold_based:
+                logger.info(
+                    "amplitude, threshold_current, and amplitude_percent are all set in Sinusoidal."
+                    " Using absolute amplitude and ignoring threshold-based parameters."
+                )
+
+            return Sinusoidal.amplitude_based(
+                dt=dt,
+                pre_delay=pre_delay,
+                post_delay=post_delay,
+                duration=duration,
+                frequency=frequency,
+                amplitude=amplitude,  # type: ignore[arg-type]
+            )
+
+        if is_threshold_based:
+            return Sinusoidal.threshold_based(
+                dt=dt,
+                pre_delay=pre_delay,
+                post_delay=post_delay,
+                duration=duration,
+                frequency=frequency,
+                amplitude_percent=amplitude_percent,  # type: ignore[arg-type]
+                threshold_current=threshold_current,  # type: ignore[arg-type]
+            )
+
+        raise TypeError("You have to provide either `amplitude` or `threshold_current` with `amplitude_percent`.")
+
     def ornstein_uhlenbeck(
         self,
         pre_delay: float,
@@ -612,6 +677,38 @@ class StimulusFactory:
 
         raise TypeError("You must provide either `mean` and `sigma`, or `threshold_current` and `mean_percent` and `sigma_percent`  with percentage values.")
 
-    def from_sonata(cls, circuit_stimulus: CircuitStimulus):
-        """Convert a SONATA stimulus into a factory-based stimulus."""
-        raise ValueError(f"Unsupported circuit stimulus type: {type(circuit_stimulus)}")
+    def pulse(
+        self,
+        pre_delay: float,
+        duration: float,
+        post_delay: float,
+        frequency: float,
+        width: float,
+        threshold_current: Optional[float] = None,
+        threshold_percentage: Optional[float] = None,
+        amplitude: Optional[float] = None,
+    ) -> Stimulus:
+        """Creates a pulse stimulus.
+
+        Args:
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+            amplitude: Raw amplitude of input current.
+            pre_delay: Delay before the first pulse (ms).
+            duration: Duration of the pulse train (ms).
+            post_delay: Delay after the last pulse (ms).
+            frequency: Frequency of the pulses (Hz).
+            width: Width of each pulse (ms).
+        """
+        if amplitude is not None:
+            if threshold_current is not None and threshold_current != 0 and threshold_percentage is not None:
+                logger.info(
+                    "amplitude, threshold_current and threshold_percentage are all set in pulse."
+                    " Will only keep amplitude value."
+                )
+            return Pulse.amplitude_based(self.dt, pre_delay, duration, post_delay, amplitude, frequency, width)
+
+        if threshold_current is not None and threshold_current != 0 and threshold_percentage is not None:
+            return Pulse.threshold_based(self.dt, pre_delay, duration, post_delay, threshold_current, threshold_percentage, frequency, width)
+
+        raise TypeError("You have to give either threshold_current or amplitude")

{bluecellulab-2.6.44 → bluecellulab-2.6.46}/bluecellulab/stimulus/stimulus.py

@@ -18,6 +18,7 @@ from abc import ABC, abstractmethod
 from typing import Optional
 import logging
 import matplotlib.pyplot as plt
+import neuron
 import numpy as np
 from bluecellulab.cell.stimuli_generator import get_relative_shotnoise_params
 from bluecellulab.exceptions import BluecellulabError
@@ -57,7 +58,6 @@ class Stimulus(ABC):
         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:
@@ -203,7 +203,6 @@ class OUProcess(Stimulus):
         """Generates an Ornstein-Uhlenbeck noise signal."""
         from bluecellulab.cell.stimuli_generator import gen_ornstein_uhlenbeck
         from bluecellulab.rngsettings import RNGSettings
-        import neuron
 
         rng_settings = RNGSettings.get_instance()
         rng = neuron.h.Random()
@@ -251,7 +250,6 @@ class ShotNoiseProcess(Stimulus):
         """Generates the shot noise time and current vectors."""
         from bluecellulab.cell.stimuli_generator import gen_shotnoise_signal
         from bluecellulab.rngsettings import RNGSettings
-        import neuron
 
         rng_settings = RNGSettings.get_instance()
         rng = neuron.h.Random()
@@ -310,12 +308,11 @@ class StepNoiseProcess(Stimulus):
     def _generate_step_noise(self):
         """Generates the step noise time and current vectors using NEURON’s
         random generator."""
-        from neuron import h
         from bluecellulab.rngsettings import RNGSettings
 
         # Get NEURON RNG settings
         rng_settings = RNGSettings.get_instance()
-        rng = h.Random()
+        rng = neuron.h.Random()
 
         if rng_settings.mode == "Random123":
             seed1, seed2, seed3 = 2997, 19216, self.seed if self.seed else 123
@@ -341,6 +338,72 @@ class StepNoiseProcess(Stimulus):
         return np.array(time_values), np.array(current_values)
 
 
+class SinusoidalWave(Stimulus):
+    """Generates a sinusoidal current wave."""
+
+    def __init__(self, dt: float, duration: float, amplitude: float, frequency: float):
+        super().__init__(dt)
+        self.duration = duration
+        self.amplitude = amplitude
+        self.frequency = frequency
+
+        self._time, self._current = self._generate_sinusoidal_signal()
+
+    @property
+    def time(self) -> np.ndarray:
+        return self._time
+
+    @property
+    def current(self) -> np.ndarray:
+        return self._current
+
+    def _generate_sinusoidal_signal(self):
+        """Generate the sinusoidal waveform."""
+        tvec = neuron.h.Vector()
+        tvec.indgen(0.0, self.duration, self.dt)  # Time points using NEURON
+
+        stim = neuron.h.Vector(len(tvec))
+        stim.sin(self.frequency, 0.0, self.dt)  # Generate sinusoidal wave using NEURON
+        stim.mul(self.amplitude)  # Scale by amplitude
+
+        return np.array(tvec.to_python()), np.array(stim.to_python())
+
+
+class PulseTrain(Stimulus):
+    """Generates a pulse train signal."""
+
+    def __init__(self, dt: float, duration: float, amplitude: float, frequency: float, width: float):
+        super().__init__(dt)
+        self.duration = duration
+        self.amplitude = amplitude
+        self.frequency = frequency
+        self.width = width
+
+        self._time, self._current = self._generate_pulse_train()
+
+    @property
+    def time(self) -> np.ndarray:
+        return self._time
+
+    @property
+    def current(self) -> np.ndarray:
+        return self._current
+
+    def _generate_pulse_train(self):
+        total_duration = self.duration
+        time_steps = int(total_duration / self.dt)
+        time = np.linspace(0, total_duration, time_steps)
+        current = np.zeros_like(time)
+
+        start_time = 0
+        while start_time + self.width < self.duration:
+            pulse_indices = (time >= start_time) & (time < start_time + self.width)
+            current[pulse_indices] = self.amplitude
+            start_time += 1000.0 / self.frequency
+
+        return time, current
+
+
 class Step(Stimulus):
 
     def __init__(self):
@@ -780,3 +843,104 @@ class StepNoise(Stimulus):
             sigma=sigma,
             seed=seed,
         )
+
+
+class Sinusoidal(Stimulus):
+    """Factory-compatible Sinusoidal Stimulus."""
+
+    def __init__(self):
+        """Prevents direct instantiation."""
+        raise NotImplementedError(
+            "This class cannot be instantiated directly. "
+            "Please use 'amplitude_based' or 'threshold_based' methods."
+        )
+
+    @classmethod
+    def amplitude_based(
+        cls,
+        dt: float,
+        pre_delay: float,
+        duration: float,
+        post_delay: float,
+        amplitude: float,
+        frequency: float,
+    ) -> CombinedStimulus:
+        """Creates a sinusoidal stimulus with a specified amplitude.
+
+        Args:
+            dt: Time step of the stimulus.
+            pre_delay: Delay before the sinusoidal wave starts.
+            duration: Duration of the sinusoidal signal.
+            post_delay: Delay after the wave ends.
+            amplitude: Amplitude of the sinusoidal wave.
+            frequency: Frequency of the wave in Hz.
+        """
+        return (
+            Empty(dt, duration=pre_delay)
+            + SinusoidalWave(dt, duration, amplitude, frequency)
+            + Empty(dt, duration=post_delay)
+        )
+
+    @classmethod
+    def threshold_based(
+        cls,
+        dt: float,
+        pre_delay: float,
+        duration: float,
+        post_delay: float,
+        frequency: float,
+        threshold_current: float,
+        amplitude_percent: float,
+    ) -> CombinedStimulus:
+        """Creates a sinusoidal stimulus relative to the threshold current.
+
+        Args:
+            dt: Time step of the stimulus.
+            pre_delay: Delay before the sinusoidal wave starts.
+            duration: Duration of the sinusoidal signal.
+            post_delay: Delay after the wave ends.
+            frequency: Frequency of the wave in Hz.
+            threshold_current: Baseline threshold current.
+            amplitude_percent: Amplitude as a percentage of the threshold current.
+        """
+        amplitude = (amplitude_percent / 100) * threshold_current
+
+        return cls.amplitude_based(
+            dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            amplitude=amplitude,
+            frequency=frequency,
+        )
+
+
+class Pulse(Stimulus):
+    """Factory-compatible Pulse Stimulus."""
+
+    def __init__(self):
+        """Prevents direct instantiation of the class."""
+        raise NotImplementedError(
+            "This class cannot be instantiated directly. "
+            "Please use 'amplitude_based' or 'threshold_based' methods."
+        )
+
+    @classmethod
+    def amplitude_based(
+        cls, dt: float, pre_delay: float, duration: float, post_delay: float, amplitude: float, frequency: float, width: float
+    ) -> CombinedStimulus:
+        """Creates a Pulse stimulus from given time events and amplitude."""
+        return (
+            Empty(dt, duration=pre_delay)
+            + PulseTrain(dt, duration, amplitude, frequency, width)
+            + 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,
+        frequency: float, width: float
+    ) -> CombinedStimulus:
+        """Creates a Pulse stimulus with respect to the threshold current."""
+        amplitude = threshold_current * (threshold_percentage / 100)
+        return cls.amplitude_based(dt, pre_delay, duration, post_delay, amplitude, frequency, width)

{bluecellulab-2.6.44 → bluecellulab-2.6.46}/bluecellulab.egg-info/PKG-INFO

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