bluecellulab 2.6.42__py3-none-any.whl → 2.6.44__py3-none-any.whl

bluecellulab/analysis/inject_sequence.py

@@ -30,7 +30,7 @@ class Recording(NamedTuple):
     current: np.ndarray
     voltage: np.ndarray
     time: np.ndarray
-    spike: np.ndarray | None
+    spike: Optional[np.ndarray] = None
 
 
 StimulusRecordings = Dict[str, Recording]
@@ -46,7 +46,7 @@ def run_stimulus(
     recording_section: str = "soma[0]",
     recording_segment: float = 0.5,
     enable_spike_detection: bool = False,
-    threshold_spike_detection: float = -30,
+    threshold_spike_detection: float = -30.0,
 ) -> Recording:
     """Creates a cell from template parameters, applies a stimulus, and records
     the response.
@@ -135,9 +135,9 @@ def apply_multiple_stimuli(
     stimulus_name: StimulusName,
     amplitudes: Sequence[float],
     threshold_based: bool = True,
-    section_name: str | None = None,
+    section_name: Optional[str] = None,
     segment: float = 0.5,
-    n_processes: int | None = None,
+    n_processes: Optional[int] = None,
     cvode: bool = True,
     add_hypamp: bool = True,
 ) -> StimulusRecordings:

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
 
@@ -280,7 +302,7 @@ class InjectableMixin:
             rng = neuron.h.Random()
             rng.Random123(seed1, seed2, seed3)
         else:
-            raise BluecellulabError("Shot noise stimulus requires Random123")
+            raise BluecellulabError("Ornstein-Uhlenbeck noise stimulus requires Random123")
 
         self.persistent.append(rng)
         return rng

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/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_linear_stimuli: bool = False,
     ):
         """Instantiate a list of cells.
 
@@ -209,6 +210,11 @@ class CircuitSimulation:
                             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]
@@ -267,20 +273,23 @@ class CircuitSimulation:
             add_pulse_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_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_linear_stimuli=add_linear_stimuli
             )
 
     def _add_stimuli(self, add_noise_stimuli=False,
@@ -288,7 +297,8 @@ 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_linear_stimuli=False
                      ):
         """Instantiate all the stimuli."""
         stimuli_entries = self.circuit_access.config.get_all_stimuli_entries()
@@ -316,6 +326,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)

bluecellulab/stimulus/circuit_stimulus_definitions.py

@@ -42,6 +42,7 @@ class Pattern(Enum):
     NOISE = "noise"
     HYPERPOLARIZING = "hyperpolarizing"
     PULSE = "pulse"
+    LINEAR = "linear"
     RELATIVE_LINEAR = "relative_linear"
     SYNAPSE_REPLAY = "synapse_replay"
     SHOT_NOISE = "shot_noise"
@@ -80,6 +81,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":
@@ -141,6 +144,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 +234,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(
@@ -322,9 +335,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"))