bluecellulab 2.6.43__tar.gz → 2.6.45__tar.gz

{bluecellulab-2.6.43 → bluecellulab-2.6.45}/PKG-INFO

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

{bluecellulab-2.6.43 → bluecellulab-2.6.45}/bluecellulab/cell/injector.py

@@ -30,6 +30,8 @@ from bluecellulab.exceptions import BluecellulabError
 from bluecellulab.rngsettings import RNGSettings
 from bluecellulab.stimulus.circuit_stimulus_definitions import (
     ClampMode,
+    Linear,
+    RelativeLinear,
     Hyperpolarizing,
     Noise,
     OrnsteinUhlenbeck,
@@ -259,12 +261,32 @@ class InjectableMixin:
         self.persistent.append(tstim)  # type: ignore
         return tstim
 
-    def add_replay_relativelinear(self, stimulus):
+    def add_replay_linear(self, stimulus: Linear):
+        """Add a linear stimulus."""
+
+        return self.add_ramp(
+            stimulus.delay,
+            stimulus.delay + stimulus.duration,
+            stimulus.amp_start,
+            stimulus.amp_end
+        )
+
+    def add_replay_relativelinear(self, stimulus: RelativeLinear):
         """Add a relative linear stimulus."""
-        tstim = neuron.h.TStim(0.5, sec=self.soma)
-        amp = stimulus.percent_start / 100.0 * self.threshold
-        tstim.pulse(stimulus.delay, stimulus.duration, amp)
-        self.persistent.append(tstim)
+        tstim = neuron.h.TStim(0.5, sec=self.soma)  # type: ignore
+        amp_start = stimulus.percent_start / 100.0 * self.threshold  # type: ignore
+        amp_end = stimulus.percent_end / 100.0 * self.threshold  # type: ignore
+
+        tstim.ramp(
+            0.0,
+            stimulus.delay,       # Time when the ramp starts
+            amp_start,      # Initial amplitude (amp_start)
+            amp_end,       # Final amplitude (amp_end)
+            stimulus.duration,    # Duration of the ramp
+            0.0,
+            0.0
+        )
+        self.persistent.append(tstim)  # type: ignore
 
         return tstim
 
@@ -493,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.43 → bluecellulab-2.6.45}/bluecellulab/circuit/circuit_access/sonata_circuit_access.py

@@ -152,8 +152,9 @@ class SonataCircuitAccess:
 
                 # make multiindex
                 synapses = synapses.reset_index(drop=True)
+                synapse_ids = list(synapses.index)
                 synapses.index = pd.MultiIndex.from_tuples(
-                    zip([edge_population_name] * len(synapses), synapses.index),
+                    [(edge_population_name, syn_id) for syn_id in synapse_ids],
                     names=["edge_name", "synapse_id"],
                 )
 

{bluecellulab-2.6.43 → bluecellulab-2.6.45}/bluecellulab/circuit_simulation.py

@@ -139,6 +139,8 @@ 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.
 
@@ -209,6 +211,16 @@ 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,
+                                will automatically set this option to
+                                True.
         """
         if not isinstance(cells, Iterable) or isinstance(cells, tuple):
             cells = [cells]
@@ -265,22 +277,28 @@ 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
 
         if add_noise_stimuli or \
                 add_hyperpolarizing_stimuli or \
                 add_pulse_stimuli or \
                 add_relativelinear_stimuli or \
                 add_shotnoise_stimuli or \
-                add_ornstein_uhlenbeck_stimuli:
+                add_ornstein_uhlenbeck_stimuli or \
+                add_sinusoidal_stimuli or \
+                add_linear_stimuli:
             self._add_stimuli(
                 add_noise_stimuli=add_noise_stimuli,
                 add_hyperpolarizing_stimuli=add_hyperpolarizing_stimuli,
                 add_relativelinear_stimuli=add_relativelinear_stimuli,
                 add_pulse_stimuli=add_pulse_stimuli,
                 add_shotnoise_stimuli=add_shotnoise_stimuli,
-                add_ornstein_uhlenbeck_stimuli=add_ornstein_uhlenbeck_stimuli
+                add_ornstein_uhlenbeck_stimuli=add_ornstein_uhlenbeck_stimuli,
+                add_sinusoidal_stimuli=add_sinusoidal_stimuli,
+                add_linear_stimuli=add_linear_stimuli
             )
 
     def _add_stimuli(self, add_noise_stimuli=False,
@@ -288,7 +306,9 @@ class CircuitSimulation:
                      add_relativelinear_stimuli=False,
                      add_pulse_stimuli=False,
                      add_shotnoise_stimuli=False,
-                     add_ornstein_uhlenbeck_stimuli=False
+                     add_ornstein_uhlenbeck_stimuli=False,
+                     add_sinusoidal_stimuli=False,
+                     add_linear_stimuli=False
                      ):
         """Instantiate all the stimuli."""
         stimuli_entries = self.circuit_access.config.get_all_stimuli_entries()
@@ -316,6 +336,9 @@ class CircuitSimulation:
                 elif isinstance(stimulus, circuit_stimulus_definitions.Pulse):
                     if add_pulse_stimuli:
                         self.cells[cell_id].add_pulse(stimulus)
+                elif isinstance(stimulus, circuit_stimulus_definitions.Linear):
+                    if add_linear_stimuli:
+                        self.cells[cell_id].add_replay_linear(stimulus)
                 elif isinstance(stimulus, circuit_stimulus_definitions.RelativeLinear):
                     if add_relativelinear_stimuli:
                         self.cells[cell_id].add_replay_relativelinear(stimulus)
@@ -339,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.43 → bluecellulab-2.6.45}/bluecellulab/stimulus/circuit_stimulus_definitions.py

@@ -42,12 +42,14 @@ class Pattern(Enum):
     NOISE = "noise"
     HYPERPOLARIZING = "hyperpolarizing"
     PULSE = "pulse"
+    LINEAR = "linear"
     RELATIVE_LINEAR = "relative_linear"
     SYNAPSE_REPLAY = "synapse_replay"
     SHOT_NOISE = "shot_noise"
     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:
@@ -80,6 +82,8 @@ class Pattern(Enum):
             return Pattern.HYPERPOLARIZING
         elif pattern == "pulse":
             return Pattern.PULSE
+        elif pattern == "linear":
+            return Pattern.LINEAR
         elif pattern == "relative_linear":
             return Pattern.RELATIVE_LINEAR
         elif pattern == "synapse_replay":
@@ -92,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}")
 
@@ -141,6 +147,7 @@ class Stimulus:
                 delay=stimulus_entry["Delay"],
                 duration=stimulus_entry["Duration"],
                 percent_start=stimulus_entry["PercentStart"],
+                percent_end=stimulus_entry["PercentEnd"],
             )
         elif pattern == Pattern.SYNAPSE_REPLAY:
             warnings.warn("Ignoring syanpse replay stimulus as it is not supported")
@@ -230,12 +237,21 @@ class Stimulus:
                 width=stimulus_entry["width"],
                 frequency=stimulus_entry["frequency"],
             )
+        elif pattern == Pattern.LINEAR:
+            return Linear(
+                target=stimulus_entry["node_set"],
+                delay=stimulus_entry["delay"],
+                duration=stimulus_entry["duration"],
+                amp_start=stimulus_entry["amp_start"],
+                amp_end=stimulus_entry["amp_end"],
+            )
         elif pattern == Pattern.RELATIVE_LINEAR:
             return RelativeLinear(
                 target=stimulus_entry["node_set"],
                 delay=stimulus_entry["delay"],
                 duration=stimulus_entry["duration"],
                 percent_start=stimulus_entry["percent_start"],
+                percent_end=stimulus_entry["percent_end"],
             )
         elif pattern == Pattern.SYNAPSE_REPLAY:
             return SynapseReplay(
@@ -300,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}")
 
@@ -322,9 +346,16 @@ class Pulse(Stimulus):
     frequency: float
 
 
+@dataclass(frozen=True, config=dict(extra="forbid"))
+class Linear(Stimulus):
+    amp_start: float
+    amp_end: float
+
+
 @dataclass(frozen=True, config=dict(extra="forbid"))
 class RelativeLinear(Stimulus):
     percent_start: float
+    percent_end: float
 
 
 @dataclass(frozen=True, config=dict(extra="forbid"))
@@ -416,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.43 → bluecellulab-2.6.45}/bluecellulab/stimulus/factory.py

@@ -16,7 +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.stimulus import DelayedZap, Empty, Ramp, Slope, Step, StepNoise, Stimulus, OrnsteinUhlenbeck, ShotNoise, Sinusoidal
 from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus as CircuitStimulus
 
 logger = logging.getLogger(__name__)
@@ -376,6 +376,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,

{bluecellulab-2.6.43 → bluecellulab-2.6.45}/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,37 @@ 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 Step(Stimulus):
 
     def __init__(self):
@@ -780,3 +808,73 @@ 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,
+        )

{bluecellulab-2.6.43 → bluecellulab-2.6.45}/bluecellulab.egg-info/PKG-INFO

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