bluecellulab 2.5.11__py3-none-any.whl → 2.6.0__py3-none-any.whl

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/stimulus/factory.py

@@ -39,38 +39,38 @@ class Stimulus(ABC):
         ax.set_title(self.__class__.__name__)
         return ax
 
-    def plot_during_simulation(self, duration: float, ax=None, **kwargs):
-        if ax is None:
-            ax = plt.gca()
-        # Create an array for the entire duration
-        full_time = np.arange(0, duration, self.dt)
-        full_current = np.zeros_like(full_time)
-
-        # Replace the corresponding values with self.time and self.current
-        indices = (self.time / self.dt).astype(int)
-        full_current[indices] = self.current
-
-        ax.plot(full_time, full_current, **kwargs)
-        ax.set_xlabel("Time (ms)")
-        ax.set_ylabel("Current (nA)")
-        ax.set_title(self.__class__.__name__)
-        ax.set_xlim(0, duration)
-        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")
-        # 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)
+            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
@@ -85,11 +85,12 @@ class CombinedStimulus(Stimulus):
         return self._current
 
 
-class EmptyStimulus(Stimulus):
+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
@@ -103,152 +104,286 @@ class EmptyStimulus(Stimulus):
         return np.zeros_like(self.time)
 
 
-class Step(Stimulus):
-    def __init__(self, dt: float, start: float, end: float, amplitude: float) -> None:
+class Flat(Stimulus):
+    def __init__(self, dt: float, duration: float, amplitude: float) -> None:
         super().__init__(dt)
-        self.start = start
-        self.end = end
+        self.duration = duration
         self.amplitude = amplitude
 
-    @classmethod
-    def threshold_based(
-        cls,
-        dt: float,
-        threshold_current: float,
-        threshold_percentage: float,
-        start: float,
-        end: float,
-        post_wait: float,
-    ) -> CombinedStimulus:
-        amplitude = threshold_current * threshold_percentage / 100
-        res = cls(dt, start, end, amplitude) + EmptyStimulus(dt, duration=post_wait)
-        return res
-
     @property
     def time(self) -> np.ndarray:
-        return np.arange(self.start, self.end, self.dt)
+        return np.arange(0.0, self.duration, self.dt)
 
     @property
     def current(self) -> np.ndarray:
         return np.full_like(self.time, self.amplitude)
 
 
-class Ramp(Stimulus):
+class Slope(Stimulus):
     def __init__(
-        self,
-        dt: float,
-        start: float,
-        end: float,
-        amplitude_start: float,
-        amplitude_end: float,
+        self, dt: float, duration: float, amplitude_start: float, amplitude_end: float
     ) -> None:
         super().__init__(dt)
-        self.start = start
-        self.end = end
+        self.duration = duration
         self.amplitude_start = amplitude_start
         self.amplitude_end = amplitude_end
 
     @property
     def time(self) -> np.ndarray:
-        return np.arange(self.start, self.end, self.dt)
+        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, start: float, end: float, amplitude: float) -> Stimulus:
-        return Step(self.dt, start, end, amplitude)
+    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, start: float, end: float, amplitude_start: float, amplitude_end: float
+        self, pre_delay: float, duration: float, post_delay: float, amplitude: float
     ) -> Stimulus:
-        return Ramp(self.dt, start, end, amplitude_start, amplitude_end)
+        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,
-        start: float = 250.0,
-        end: float = 300.0,
-        post_wait: float = 250.0,
+        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.
-            start: The start time of the step.
-            end: The end time of the step.
-            post_wait: The time to wait after the end of the step.
         """
+        pre_delay = 250.0
+        duration = 50.0
+        post_delay = 250.0
         return Step.threshold_based(
-            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+            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,
-        start: float = 250.0,
-        end: float = 1600.0,
-        post_wait: float = 250.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.
-            start: The start time of the step.
-            end: The end time of the step.
-            post_wait: The time to wait after the end of the step.
         """
+        pre_delay = 250.0
+        duration = 1350.0
+        post_delay = 250.0
         return Step.threshold_based(
-            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+            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,
-        start: float = 250.0,
-        end: float = 3250.0,
-        post_wait: float = 250.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.
-            start: The start time of the step.
-            end: The end time of the step.
-            post_wait: The time to wait after the end of the step.
         """
+        pre_delay = 250.0
+        duration = 3000.0
+        post_delay = 250.0
         return Step.threshold_based(
-            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+            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,
-        start: float = 250.0,
-        end: float = 3850.0,
-        post_wait: float = 250.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.
-            start: The start time of the step.
-            end: The end time of the step.
-            post_wait: The time to wait after the end of the step.
         """
+        pre_delay = 250.0
+        duration = 3600.0
+        post_delay = 250.0
         return Step.threshold_based(
-            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+            self.dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            threshold_current=threshold_current,
+            threshold_percentage=threshold_percentage,
         )

{bluecellulab-2.5.11.dist-info → bluecellulab-2.6.0.dist-info}/METADATA

@@ -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.dist-info → bluecellulab-2.6.0.dist-info}/RECORD

@@ -15,7 +15,7 @@ bluecellulab/type_aliases.py,sha256=DvgjERv2Ztdw_sW63JrZTQGpJ0x5uMTFB5hcBHDb0WA,
 bluecellulab/utils.py,sha256=SbOOkzw1YGjCKV3qOw0zpabNEy7V9BRtgMLsQJiFRq4,1526
 bluecellulab/verbosity.py,sha256=T0IgX7DrRo19faxrT4Xzb27gqxzoILQ8FzYKxvUeaPM,1342
 bluecellulab/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bluecellulab/analysis/inject_sequence.py,sha256=sL8G01uYzPohLkh1BT_8op2vHbSFx1_MlRgj2dY1cWs,4944
+bluecellulab/analysis/inject_sequence.py,sha256=qr3N1tQX4avvKzFBT0L7W6LnSgk2y_P_7Yhy0UjlGmk,4769
 bluecellulab/cell/__init__.py,sha256=Sbc0QOsJ8E7tSwf3q7fsXuE_SevBN6ZmoCVyyU5zfII,208
 bluecellulab/cell/cell_dict.py,sha256=PVmZsjhZ9jp3HC-8QmdFqp-crAcVMSVeLWujcOPLlpo,1346
 bluecellulab/cell/core.py,sha256=MtrVQAxT82dc9uQuWZyTQfc6Oczrnc_y_9hcyBqUT7w,31467
@@ -58,13 +58,13 @@ bluecellulab/simulation/parallel.py,sha256=xmlIelxYNct-vGhPip7_vF9gwyehdpomYB8kf
 bluecellulab/simulation/simulation.py,sha256=I__cZwV_A8I7XSefn6aJDBA_jXCI3E35-pCNCLUsnvo,6206
 bluecellulab/stimulus/__init__.py,sha256=DgIgVaSyR-URf3JZzvO6j-tjCerzvktuK-ep8pjMRPQ,37
 bluecellulab/stimulus/circuit_stimulus_definitions.py,sha256=uij_s44uNdmMwMLGmTHSRgmp9K9B_vvHHshX6YPJNJU,15686
-bluecellulab/stimulus/factory.py,sha256=AOby3Sp2g8BJsRccz3afazfCyysyWIgLtcliWlyeiu0,8097
+bluecellulab/stimulus/factory.py,sha256=cjnMqFx-Y31kV1XHvkSbGI2f1OpEawU3Wg_cLqcIyRc,11883
 bluecellulab/synapse/__init__.py,sha256=RW8XoAMXOvK7OG1nHl_q8jSEKLj9ZN4oWf2nY9HAwuk,192
 bluecellulab/synapse/synapse_factory.py,sha256=YkvxbdGF-u-vxYdbRNTlX-9AtSC_3t_FQRFhybwzgrk,6805
 bluecellulab/synapse/synapse_types.py,sha256=4gne-hve2vq1Lau-LAVPsfLjffVYqAYBW3kCfC7_600,16871
-bluecellulab-2.5.11.dist-info/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
-bluecellulab-2.5.11.dist-info/LICENSE,sha256=xOouu1gC1GGklDxkITlaVl60I9Ab860O-nZsFbWydvU,11749
-bluecellulab-2.5.11.dist-info/METADATA,sha256=rE7_kRYFnhuy1_9tiArH9zPRCYt2F5SmiIXbnO3GOZo,7026
-bluecellulab-2.5.11.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-bluecellulab-2.5.11.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
-bluecellulab-2.5.11.dist-info/RECORD,,
+bluecellulab-2.6.0.dist-info/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
+bluecellulab-2.6.0.dist-info/LICENSE,sha256=xOouu1gC1GGklDxkITlaVl60I9Ab860O-nZsFbWydvU,11749
+bluecellulab-2.6.0.dist-info/METADATA,sha256=X-XmGZmXo-FZIe6H5r0qIs-VBJnTN0zNVOXNVuiLW0M,7025
+bluecellulab-2.6.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+bluecellulab-2.6.0.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
+bluecellulab-2.6.0.dist-info/RECORD,,