bluecellulab 2.6.47__py3-none-any.whl → 2.6.48__py3-none-any.whl

bluecellulab/analysis/analysis.py

@@ -5,10 +5,10 @@ except ImportError:
     efel = None
 import numpy as np
 
-from bluecellulab.stimulus import StimulusFactory
-from bluecellulab.tools import calculate_rheobase
 from bluecellulab.analysis.inject_sequence import run_stimulus
 from bluecellulab.analysis.plotting import plot_iv_curve, plot_fi_curve
+from bluecellulab.stimulus import StimulusFactory
+from bluecellulab.tools import calculate_rheobase
 
 
 def compute_plot_iv_curve(cell,
@@ -19,8 +19,13 @@ def compute_plot_iv_curve(cell,
                           stim_start=100.0,
                           duration=500.0,
                           post_delay=100.0,
-                          threshold_voltage=-30,
-                          nb_bins=11):
+                          threshold_voltage=-20,
+                          nb_bins=11,
+                          rheobase=None,
+                          show_figure=True,
+                          save_figure=False,
+                          output_dir="./",
+                          output_fname="iv_curve.pdf"):
     """Compute and plot the Current-Voltage (I-V) curve for a given cell by
     injecting a range of currents.
 
@@ -46,6 +51,12 @@ def compute_plot_iv_curve(cell,
             response. Default is -30 mV.
         nb_bins (int, optional): The number of discrete current levels between 0 and the maximum current.
             Default is 11.
+        rheobase (float, optional): The rheobase current (in nA) for the cell. If not provided, it will
+            be calculated using the `calculate_rheobase` function.
+        show_figure (bool): Whether to display the figure. Default is True.
+        save_figure (bool): Whether to save the figure. Default is False.
+        output_dir (str): The directory to save the figure if save_figure is True. Default is "./".
+        output_fname (str): The filename to save the figure as if save_figure is True. Default is "iv_curve.png".
 
     Returns:
         tuple: A tuple containing:
@@ -57,7 +68,8 @@ def compute_plot_iv_curve(cell,
         ValueError: If the cell object is invalid, the specified sections/segments are not found, or if
             the simulation results are inconsistent.
     """
-    rheobase = calculate_rheobase(cell=cell, section=injecting_section, segx=injecting_segment)
+    if rheobase is None:
+        rheobase = calculate_rheobase(cell=cell, section=injecting_section, segx=injecting_segment)
 
     list_amp = np.linspace(rheobase - 2, rheobase - 0.1, nb_bins)  # [nA]
 
@@ -89,7 +101,7 @@ def compute_plot_iv_curve(cell,
             'stim_end': [stim_start + duration]
         }
         features_results = efel.get_feature_values([trace], ['steady_state_voltage_stimend'])
-        steady_state = features_results[0]['steady_state_voltage_stimend']
+        steady_state = features_results[0]['steady_state_voltage_stimend'][0]
         steady_states.append(steady_state)
 
     plot_iv_curve(list_amp,
@@ -97,7 +109,11 @@ def compute_plot_iv_curve(cell,
                   injecting_section=injecting_section,
                   injecting_segment=injecting_segment,
                   recording_section=recording_section,
-                  recording_segment=recording_segment)
+                  recording_segment=recording_segment,
+                  show_figure=show_figure,
+                  save_figure=save_figure,
+                  output_dir=output_dir,
+                  output_fname=output_fname)
 
     return np.array(list_amp), np.array(steady_states)
 
@@ -111,7 +127,13 @@ def compute_plot_fi_curve(cell,
                           duration=500.0,
                           post_delay=100.0,
                           max_current=0.8,
-                          nb_bins=11):
+                          threshold_voltage=-20,
+                          nb_bins=11,
+                          rheobase=None,
+                          show_figure=True,
+                          save_figure=False,
+                          output_dir="./",
+                          output_fname="fi_curve.pdf"):
     """Compute and plot the Frequency-Current (F-I) curve for a given cell by
     injecting a range of currents.
 
@@ -135,8 +157,16 @@ def compute_plot_fi_curve(cell,
             (in ms). Default is 100.0 ms.
         max_current (float, optional): The maximum amplitude of the injected current (in nA).
             Default is 0.8 nA.
+        threshold_voltage (float, optional): The voltage threshold (in mV) for detecting a steady-state
+            response. Default is -30 mV.
         nb_bins (int, optional): The number of discrete current levels between 0 and `max_current`.
             Default is 11.
+        rheobase (float, optional): The rheobase current (in nA) for the cell. If not provided, it will
+            be calculated using the `calculate_rheobase` function.
+        show_figure (bool): Whether to display the figure. Default is True.
+        save_figure (bool): Whether to save the figure. Default is False.
+        output_dir (str): The directory to save the figure if save_figure is True. Default is "./".
+        output_fname (str): The filename to save the figure as if save_figure is True. Default is "iv_curve.png".
 
     Returns:
         tuple: A tuple containing:
@@ -146,7 +176,8 @@ def compute_plot_fi_curve(cell,
     Raises:
         ValueError: If the cell object is invalid or the specified sections/segments are not found.
     """
-    rheobase = calculate_rheobase(cell=cell, section=injecting_section, segx=injecting_segment)
+    if rheobase is None:
+        rheobase = calculate_rheobase(cell=cell, section=injecting_section, segx=injecting_segment)
 
     list_amp = np.linspace(rheobase, max_current, nb_bins)  # [nA]
     steps = []
@@ -161,7 +192,8 @@ def compute_plot_fi_curve(cell,
                                  segment=injecting_segment,
                                  recording_section=recording_section,
                                  recording_segment=recording_segment,
-                                 enable_spike_detection=True)
+                                 enable_spike_detection=True,
+                                 threshold_spike_detection=threshold_voltage)
         steps.append(step_stimulus)
         spikes.append(recording.spike)
 
@@ -172,6 +204,10 @@ def compute_plot_fi_curve(cell,
                   injecting_section=injecting_section,
                   injecting_segment=injecting_segment,
                   recording_section=recording_section,
-                  recording_segment=recording_segment)
+                  recording_segment=recording_segment,
+                  show_figure=show_figure,
+                  save_figure=save_figure,
+                  output_dir=output_dir,
+                  output_fname=output_fname)
 
     return np.array(list_amp), np.array(spike_count)

bluecellulab/analysis/inject_sequence.py

@@ -36,18 +36,17 @@ class Recording(NamedTuple):
 StimulusRecordings = Dict[str, Recording]
 
 
-def run_stimulus(
+def run_multirecordings_stimulus(
     template_params: TemplateParams,
     stimulus: Stimulus,
     section: str,
     segment: float,
     cvode: bool = True,
     add_hypamp: bool = True,
-    recording_section: str = "soma[0]",
-    recording_segment: float = 0.5,
+    recording_locations: list[tuple[str, float]] = [("soma[0]", 0.5)],
     enable_spike_detection: bool = False,
-    threshold_spike_detection: float = -30.0,
-) -> Recording:
+    threshold_spike_detection: float = -20.0,
+) -> list[Recording]:
     """Creates a cell from template parameters, applies a stimulus, and records
     the response.
 
@@ -66,16 +65,17 @@ def run_stimulus(
         cvode (bool, optional): Whether to use variable time-step integration. Defaults to True.
         add_hypamp (bool, optional): If True, adds a hyperpolarizing stimulus before applying
             the main stimulus. Defaults to True.
-        recording_section (str): Name of the section of the cell where voltage is recorded.
-        recording_segment (float): The normalized position (0.0 to 1.0) along the recording
+        recording_location (list): List of tuples containing the name of the section of the cell
+            where voltage is recorded and the normalized position (0.0 to 1.0) along the recording
             section where voltage is recorded.
+            (e.g. [("soma[0]", 0.5), ("dend[0]", 0.5)])
         enable_spike_detection (bool, optional): If True, enables spike detection at the
             recording location. Defaults to False.
         threshold_spike_detection (float, optional): The voltage threshold (mV) for spike detection.
-            Defaults to -30 mV.
+            Defaults to -20 mV.
 
     Returns:
-        Recording: A `Recording` object containing the following:
+        list[Recording]: `Recording` objects containing the following:
             - `current` (np.ndarray): The injected current waveform (nA).
             - `voltage` (np.ndarray): The recorded membrane potential (mV) over time.
             - `time` (np.ndarray): The simulation time points (ms).
@@ -88,19 +88,22 @@ def run_stimulus(
     cell = Cell.from_template_parameters(template_params)
 
     validate_section_and_segment(cell, section, segment)
-    validate_section_and_segment(cell, recording_section, recording_segment)
+    for recording_section, recording_segment in recording_locations:
+        validate_section_and_segment(cell, recording_section, recording_segment)
 
     if add_hypamp:
         hyp_stim = Hyperpolarizing(target="", delay=0.0, duration=stimulus.stimulus_time)
         cell.add_replay_hypamp(hyp_stim)
 
-    cell.add_voltage_recording(cell.sections[recording_section], recording_segment)
+    for recording_section, recording_segment in recording_locations:
+        cell.add_voltage_recording(cell.sections[recording_section], recording_segment)
 
     # Set up spike detection if enabled
     spikes: Optional[np.ndarray] = None
     if enable_spike_detection:
-        recording_location = f"{recording_section}({str(recording_segment)})"
-        cell.start_recording_spikes(None, location=recording_location, threshold=threshold_spike_detection)
+        for recording_section, recording_segment in recording_locations:
+            recording_location = f"{recording_section}({str(recording_segment)})"
+            cell.start_recording_spikes(None, location=recording_location, threshold=threshold_spike_detection)
 
     # Inject the stimulus and run the simulation
     iclamp, _ = cell.inject_current_waveform(
@@ -113,21 +116,90 @@ def run_stimulus(
     simulation.run(stimulus.stimulus_time, cvode=cvode)
 
     # Retrieve simulation results
+    recordings = []
     current = np.array(current_vector.to_python())
-    voltage = cell.get_voltage_recording(cell.sections[recording_section], recording_segment)
-    time = cell.get_time()
+    for recording_section, recording_segment in recording_locations:
+        recording_location = f"{recording_section}({str(recording_segment)})"
+        voltage = cell.get_voltage_recording(cell.sections[recording_section], recording_segment)
+        time = cell.get_time()
 
-    if len(time) != len(voltage) or len(time) != len(current):
-        raise ValueError("Time, current, and voltage arrays are not the same length")
+        if len(time) != len(voltage) or len(time) != len(current):
+            raise ValueError("Time, current, and voltage arrays are not the same length")
 
-    if enable_spike_detection:
-        results = cell.get_recorded_spikes(location=recording_location, threshold=threshold_spike_detection)
-        if results is not None:
-            spikes = np.array(results)
-        else:
-            spikes = None
+        if enable_spike_detection:
+            results = cell.get_recorded_spikes(location=recording_location, threshold=threshold_spike_detection)
+            if results is not None:
+                spikes = np.array(results)
+            else:
+                spikes = None
+
+        recordings.append(
+            Recording(current=current, voltage=voltage, time=time, spike=spikes)
+        )
 
-    return Recording(current=current, voltage=voltage, time=time, spike=spikes)
+    return recordings
+
+
+def run_stimulus(
+    template_params: TemplateParams,
+    stimulus: Stimulus,
+    section: str,
+    segment: float,
+    cvode: bool = True,
+    add_hypamp: bool = True,
+    recording_section: str = "soma[0]",
+    recording_segment: float = 0.5,
+    enable_spike_detection: bool = False,
+    threshold_spike_detection: float = -20.0,
+) -> Recording:
+    """Creates a cell from template parameters, applies a stimulus, and records
+    the response.
+
+    This function simulates the electrical activity of a neuronal cell model by injecting
+    a stimulus into a specified section and segment, recording the voltage response, and
+    optionally detecting spikes.
+
+    Args:
+        template_params (TemplateParams): Parameters required to create the cell from a
+            specified template, including morphology and mechanisms.
+        stimulus (Stimulus): The stimulus waveform to inject, defined by time and current arrays.
+        section (str): Name of the section of the cell where the stimulus is applied.
+            (e.g. soma[0])
+        segment (float): The normalized position (0.0 to 1.0) along the injecting
+            section where the stimulus is applied.
+        cvode (bool, optional): Whether to use variable time-step integration. Defaults to True.
+        add_hypamp (bool, optional): If True, adds a hyperpolarizing stimulus before applying
+            the main stimulus. Defaults to True.
+        recording_section (str): Name of the section of the cell where voltage is recorded.
+        recording_segment (float): The normalized position (0.0 to 1.0) along the recording
+            section where voltage is recorded.
+        enable_spike_detection (bool, optional): If True, enables spike detection at the
+            recording location. Defaults to False.
+        threshold_spike_detection (float, optional): The voltage threshold (mV) for spike detection.
+            Defaults to -20 mV.
+
+    Returns:
+        Recording: A `Recording` object containing the following:
+            - `current` (np.ndarray): The injected current waveform (nA).
+            - `voltage` (np.ndarray): The recorded membrane potential (mV) over time.
+            - `time` (np.ndarray): The simulation time points (ms).
+            - `spike` (np.ndarray or None): The detected spikes, if spike detection is enabled.
+
+    Raises:
+        ValueError: If the time, current, and voltage arrays do not have the same length,
+            or if the specified sections or segments are not found in the cell model.
+    """
+    return run_multirecordings_stimulus(
+        template_params=template_params,
+        stimulus=stimulus,
+        section=section,
+        segment=segment,
+        cvode=cvode,
+        add_hypamp=add_hypamp,
+        recording_locations=[(recording_section, recording_segment)],
+        enable_spike_detection=enable_spike_detection,
+        threshold_spike_detection=threshold_spike_detection,
+    )[0]
 
 
 def apply_multiple_stimuli(

bluecellulab/analysis/plotting.py

@@ -1,9 +1,21 @@
 """Module for plotting analysis results of cell simulations."""
 
 import matplotlib.pyplot as plt
+import pathlib
 
 
-def plot_iv_curve(currents, voltages, injecting_section, injecting_segment, recording_section, recording_segment):
+def plot_iv_curve(
+    currents,
+    voltages,
+    injecting_section,
+    injecting_segment,
+    recording_section,
+    recording_segment,
+    show_figure=True,
+    save_figure=False,
+    output_dir="./",
+    output_fname="iv_curve.pdf",
+):
     """Plots the IV curve.
 
     Args:
@@ -13,6 +25,10 @@ def plot_iv_curve(currents, voltages, injecting_section, injecting_segment, reco
         injecting_segment (float): The segment position (0.0 to 1.0) where the current was injected.
         recording_section (str): The section in the cell where spikes were recorded.
         recording_segment (float): The segment position (0.0 to 1.0) where spikes were recorded.
+        show_figure (bool): Whether to display the figure. Default is True.
+        save_figure (bool): Whether to save the figure. Default is False.
+        output_dir (str): The directory to save the figure if save_figure is True. Default is "./".
+        output_fname (str): The filename to save the figure as if save_figure is True. Default is "iv_curve.pdf".
 
     Raises:
         ValueError: If the lengths of currents and voltages do not match.
@@ -27,10 +43,27 @@ def plot_iv_curve(currents, voltages, injecting_section, injecting_segment, reco
     plt.ylabel(f"Steady state voltage [mV] at {recording_section}({recording_segment:.2f})")
     plt.grid(True)
     plt.tight_layout()
-    plt.show()
+    if show_figure:
+        plt.show()
 
+    if save_figure:
+        pathlib.Path(output_dir).mkdir(parents=True, exist_ok=True)
+        plt.savefig(pathlib.Path(output_dir) / output_fname, format='pdf')
+        plt.close()
 
-def plot_fi_curve(currents, spike_count, injecting_section, injecting_segment, recording_section, recording_segment):
+
+def plot_fi_curve(
+    currents,
+    spike_count,
+    injecting_section,
+    injecting_segment,
+    recording_section,
+    recording_segment,
+    show_figure=True,
+    save_figure=False,
+    output_dir="./",
+    output_fname="fi_curve.pdf",
+):
     """Plots the F-I (Frequency-Current) curve.
 
     Args:
@@ -40,6 +73,10 @@ def plot_fi_curve(currents, spike_count, injecting_section, injecting_segment, r
         injecting_segment (float): The segment position (0.0 to 1.0) where the current was injected.
         recording_section (str): The section in the cell where spikes were recorded.
         recording_segment (float): The segment position (0.0 to 1.0) where spikes were recorded.
+        show_figure (bool): Whether to display the figure. Default is True.
+        save_figure (bool): Whether to save the figure. Default is False.
+        output_dir (str): The directory to save the figure if save_figure is True. Default is "./".
+        output_fname (str): The filename to save the figure as if save_figure is True. Default is "fi_curve.pdf".
 
     Raises:
         ValueError: If the lengths of currents and spike counts do not match.
@@ -54,4 +91,10 @@ def plot_fi_curve(currents, spike_count, injecting_section, injecting_segment, r
     plt.ylabel(f"Spike Count recorded at {recording_section}({recording_segment:.2f})")
     plt.grid(True)
     plt.tight_layout()
-    plt.show()
+    if show_figure:
+        plt.show()
+
+    if save_figure:
+        pathlib.Path(output_dir).mkdir(parents=True, exist_ok=True)
+        plt.savefig(pathlib.Path(output_dir) / output_fname, format='pdf')
+        plt.close()

bluecellulab/stimulus/factory.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 
 from __future__ import annotations
+from enum import Enum
 from typing import Optional
 import logging
 from bluecellulab.stimulus.stimulus import DelayedZap, Empty, Ramp, Slope, Step, StepNoise, Stimulus, OrnsteinUhlenbeck, ShotNoise, Sinusoidal, Pulse
@@ -21,6 +22,61 @@ from bluecellulab.stimulus.stimulus import DelayedZap, Empty, Ramp, Slope, Step,
 logger = logging.getLogger(__name__)
 
 
+class APWaveformTimings(Enum):
+    """APWaveform timings."""
+    PRE_DELAY = 250.0
+    DURATION = 50.0
+    POST_DELAY = 250.0
+
+
+class IDRestTimings(Enum):
+    """IDRest timings."""
+    PRE_DELAY = 250.0
+    DURATION = 1350.0
+    POST_DELAY = 250.0
+
+
+class IVTimings(Enum):
+    """IV timings."""
+    PRE_DELAY = 250.0
+    DURATION = 3000.0
+    POST_DELAY = 250.0
+
+
+class FirePatternTimings(Enum):
+    """FirePattern timings."""
+    PRE_DELAY = 250.0
+    DURATION = 3600.0
+    POST_DELAY = 250.0
+
+
+class PosCheopsTimings(Enum):
+    """PosCheops timings."""
+    PRE_DELAY = 250.0
+    RAMP1_DURATION = 4000.0
+    RAMP2_DURATION = 2000.0
+    RAMP3_DURATION = 1333.0
+    INTER_DELAY = 2000.0
+    POST_DELAY = 250.0
+
+
+class NegCheopsTimings(Enum):
+    """NegCheops timings."""
+    PRE_DELAY = 1750.0
+    RAMP1_DURATION = 3333.0
+    RAMP2_DURATION = 1666.0
+    RAMP3_DURATION = 1111.0
+    INTER_DELAY = 2000.0
+    POST_DELAY = 250.0
+
+
+class SineSpecTimings(Enum):
+    """SineSpec timings."""
+    PRE_DELAY = 0
+    DURATION = 5000.0
+    POST_DELAY = 0
+
+
 class StimulusFactory:
     def __init__(self, dt: float):
         self.dt = dt
@@ -84,9 +140,6 @@ class StimulusFactory:
             threshold_percentage: Percentage of desired threshold_current amplification.
             amplitude: Raw amplitude of input current.
         """
-        pre_delay = 250.0
-        duration = 50.0
-        post_delay = 250.0
 
         if amplitude is not None:
             if threshold_current is not None and threshold_current != 0 and threshold_percentage is not None:
@@ -96,18 +149,18 @@ class StimulusFactory:
                 )
             return Step.amplitude_based(
                 self.dt,
-                pre_delay=pre_delay,
-                duration=duration,
-                post_delay=post_delay,
+                pre_delay=APWaveformTimings.PRE_DELAY.value,
+                duration=APWaveformTimings.DURATION.value,
+                post_delay=APWaveformTimings.POST_DELAY.value,
                 amplitude=amplitude,
             )
 
         if threshold_current is not None and threshold_current != 0 and threshold_percentage is not None:
             return Step.threshold_based(
                 self.dt,
-                pre_delay=pre_delay,
-                duration=duration,
-                post_delay=post_delay,
+                pre_delay=APWaveformTimings.PRE_DELAY.value,
+                duration=APWaveformTimings.DURATION.value,
+                post_delay=APWaveformTimings.POST_DELAY.value,
                 threshold_current=threshold_current,
                 threshold_percentage=threshold_percentage,
             )
@@ -127,9 +180,6 @@ class StimulusFactory:
             threshold_percentage: Percentage of desired threshold_current amplification.
             amplitude: Raw amplitude of input current.
         """
-        pre_delay = 250.0
-        duration = 1350.0
-        post_delay = 250.0
 
         if amplitude is not None:
             if threshold_current is not None and threshold_current != 0 and threshold_percentage is not None:
@@ -139,18 +189,18 @@ class StimulusFactory:
                 )
             return Step.amplitude_based(
                 self.dt,
-                pre_delay=pre_delay,
-                duration=duration,
-                post_delay=post_delay,
+                pre_delay=IDRestTimings.PRE_DELAY.value,
+                duration=IDRestTimings.DURATION.value,
+                post_delay=IDRestTimings.POST_DELAY.value,
                 amplitude=amplitude,
             )
 
         if threshold_current is not None and threshold_current != 0 and threshold_percentage is not None:
             return Step.threshold_based(
                 self.dt,
-                pre_delay=pre_delay,
-                duration=duration,
-                post_delay=post_delay,
+                pre_delay=IDRestTimings.PRE_DELAY.value,
+                duration=IDRestTimings.DURATION.value,
+                post_delay=IDRestTimings.POST_DELAY.value,
                 threshold_current=threshold_current,
                 threshold_percentage=threshold_percentage,
             )
@@ -170,9 +220,6 @@ class StimulusFactory:
             threshold_percentage: Percentage of desired threshold_current amplification.
             amplitude: Raw amplitude of input current.
         """
-        pre_delay = 250.0
-        duration = 3000.0
-        post_delay = 250.0
 
         if amplitude is not None:
             if threshold_current is not None and threshold_current != 0 and threshold_percentage is not None:
@@ -182,18 +229,18 @@ class StimulusFactory:
                 )
             return Step.amplitude_based(
                 self.dt,
-                pre_delay=pre_delay,
-                duration=duration,
-                post_delay=post_delay,
+                pre_delay=IVTimings.PRE_DELAY.value,
+                duration=IVTimings.DURATION.value,
+                post_delay=IVTimings.POST_DELAY.value,
                 amplitude=amplitude,
             )
 
         if threshold_current is not None and threshold_current != 0 and threshold_percentage is not None:
             return Step.threshold_based(
                 self.dt,
-                pre_delay=pre_delay,
-                duration=duration,
-                post_delay=post_delay,
+                pre_delay=IVTimings.PRE_DELAY.value,
+                duration=IVTimings.DURATION.value,
+                post_delay=IVTimings.POST_DELAY.value,
                 threshold_current=threshold_current,
                 threshold_percentage=threshold_percentage,
             )
@@ -213,9 +260,6 @@ class StimulusFactory:
             threshold_percentage: Percentage of desired threshold_current amplification.
             amplitude: Raw amplitude of input current.
         """
-        pre_delay = 250.0
-        duration = 3600.0
-        post_delay = 250.0
 
         if amplitude is not None:
             if threshold_current is not None and threshold_current != 0 and threshold_percentage is not None:
@@ -225,18 +269,18 @@ class StimulusFactory:
                 )
             return Step.amplitude_based(
                 self.dt,
-                pre_delay=pre_delay,
-                duration=duration,
-                post_delay=post_delay,
+                pre_delay=FirePatternTimings.PRE_DELAY.value,
+                duration=FirePatternTimings.DURATION.value,
+                post_delay=FirePatternTimings.POST_DELAY.value,
                 amplitude=amplitude,
             )
 
         if threshold_current is not None and threshold_current != 0 and threshold_percentage is not None:
             return Step.threshold_based(
                 self.dt,
-                pre_delay=pre_delay,
-                duration=duration,
-                post_delay=post_delay,
+                pre_delay=FirePatternTimings.PRE_DELAY.value,
+                duration=FirePatternTimings.DURATION.value,
+                post_delay=FirePatternTimings.POST_DELAY.value,
                 threshold_current=threshold_current,
                 threshold_percentage=threshold_percentage,
             )
@@ -257,12 +301,6 @@ class StimulusFactory:
             threshold_percentage: Percentage of desired threshold_current amplification.
             amplitude: Raw amplitude of input current.
         """
-        delay = 250.0
-        ramp1_duration = 4000.0
-        ramp2_duration = 2000.0
-        ramp3_duration = 1333.0
-        inter_delay = 2000.0
-        post_delay = 250.0
 
         if amplitude is None:
             if threshold_current is None or threshold_current == 0 or threshold_percentage is None:
@@ -274,16 +312,16 @@ class StimulusFactory:
                 " Will only keep amplitude value."
             )
         result = (
-            Empty(self.dt, duration=delay)
-            + Slope(self.dt, duration=ramp1_duration, amplitude_start=0.0, amplitude_end=amplitude)
-            + Slope(self.dt, duration=ramp1_duration, amplitude_start=amplitude, amplitude_end=0.0)
-            + Empty(self.dt, duration=inter_delay)
-            + Slope(self.dt, duration=ramp2_duration, amplitude_start=0.0, amplitude_end=amplitude)
-            + Slope(self.dt, duration=ramp2_duration, amplitude_start=amplitude, amplitude_end=0.0)
-            + Empty(self.dt, duration=inter_delay)
-            + Slope(self.dt, duration=ramp3_duration, amplitude_start=0.0, amplitude_end=amplitude)
-            + Slope(self.dt, duration=ramp3_duration, amplitude_start=amplitude, amplitude_end=0.0)
-            + Empty(self.dt, duration=post_delay)
+            Empty(self.dt, duration=PosCheopsTimings.PRE_DELAY.value)
+            + Slope(self.dt, duration=PosCheopsTimings.RAMP1_DURATION.value, amplitude_start=0.0, amplitude_end=amplitude)
+            + Slope(self.dt, duration=PosCheopsTimings.RAMP1_DURATION.value, amplitude_start=amplitude, amplitude_end=0.0)
+            + Empty(self.dt, duration=PosCheopsTimings.INTER_DELAY.value)
+            + Slope(self.dt, duration=PosCheopsTimings.RAMP2_DURATION.value, amplitude_start=0.0, amplitude_end=amplitude)
+            + Slope(self.dt, duration=PosCheopsTimings.RAMP2_DURATION.value, amplitude_start=amplitude, amplitude_end=0.0)
+            + Empty(self.dt, duration=PosCheopsTimings.INTER_DELAY.value)
+            + Slope(self.dt, duration=PosCheopsTimings.RAMP3_DURATION.value, amplitude_start=0.0, amplitude_end=amplitude)
+            + Slope(self.dt, duration=PosCheopsTimings.RAMP3_DURATION.value, amplitude_start=amplitude, amplitude_end=0.0)
+            + Empty(self.dt, duration=PosCheopsTimings.POST_DELAY.value)
         )
         return result
 
@@ -301,12 +339,6 @@ class StimulusFactory:
             threshold_percentage: Percentage of desired threshold_current amplification.
             amplitude: Raw amplitude of input current.
         """
-        delay = 1750.0
-        ramp1_duration = 3333.0
-        ramp2_duration = 1666.0
-        ramp3_duration = 1111.0
-        inter_delay = 2000.0
-        post_delay = 250.0
 
         if amplitude is None:
             if threshold_current is None or threshold_current == 0 or threshold_percentage is None:
@@ -318,16 +350,16 @@ class StimulusFactory:
                 " Will only keep amplitude value."
             )
         result = (
-            Empty(self.dt, duration=delay)
-            + Slope(self.dt, duration=ramp1_duration, amplitude_start=0.0, amplitude_end=amplitude)
-            + Slope(self.dt, duration=ramp1_duration, amplitude_start=amplitude, amplitude_end=0.0)
-            + Empty(self.dt, duration=inter_delay)
-            + Slope(self.dt, duration=ramp2_duration, amplitude_start=0.0, amplitude_end=amplitude)
-            + Slope(self.dt, duration=ramp2_duration, amplitude_start=amplitude, amplitude_end=0.0)
-            + Empty(self.dt, duration=inter_delay)
-            + Slope(self.dt, duration=ramp3_duration, amplitude_start=0.0, amplitude_end=amplitude)
-            + Slope(self.dt, duration=ramp3_duration, amplitude_start=amplitude, amplitude_end=0.0)
-            + Empty(self.dt, duration=post_delay)
+            Empty(self.dt, duration=NegCheopsTimings.PRE_DELAY.value)
+            + Slope(self.dt, duration=NegCheopsTimings.RAMP1_DURATION.value, amplitude_start=0.0, amplitude_end=amplitude)
+            + Slope(self.dt, duration=NegCheopsTimings.RAMP1_DURATION.value, amplitude_start=amplitude, amplitude_end=0.0)
+            + Empty(self.dt, duration=NegCheopsTimings.INTER_DELAY.value)
+            + Slope(self.dt, duration=NegCheopsTimings.RAMP2_DURATION.value, amplitude_start=0.0, amplitude_end=amplitude)
+            + Slope(self.dt, duration=NegCheopsTimings.RAMP2_DURATION.value, amplitude_start=amplitude, amplitude_end=0.0)
+            + Empty(self.dt, duration=NegCheopsTimings.INTER_DELAY.value)
+            + Slope(self.dt, duration=NegCheopsTimings.RAMP3_DURATION.value, amplitude_start=0.0, amplitude_end=amplitude)
+            + Slope(self.dt, duration=NegCheopsTimings.RAMP3_DURATION.value, amplitude_start=amplitude, amplitude_end=0.0)
+            + Empty(self.dt, duration=NegCheopsTimings.POST_DELAY.value)
         )
         return result
 
@@ -346,8 +378,6 @@ class StimulusFactory:
             amplitude: Raw amplitude of input current.
             pre_delay: delay before the start of the stimulus
         """
-        duration = 5000.0
-        post_delay = 0
 
         if amplitude is not None:
             if threshold_current is not None and threshold_current != 0 and threshold_percentage is not None:
@@ -358,8 +388,8 @@ class StimulusFactory:
             return DelayedZap.amplitude_based(
                 self.dt,
                 pre_delay=pre_delay,
-                duration=duration,
-                post_delay=post_delay,
+                duration=SineSpecTimings.DURATION.value,
+                post_delay=SineSpecTimings.POST_DELAY.value,
                 amplitude=amplitude,
             )
 
@@ -367,8 +397,8 @@ class StimulusFactory:
             return DelayedZap.threshold_based(
                 self.dt,
                 pre_delay=pre_delay,
-                duration=duration,
-                post_delay=post_delay,
+                duration=SineSpecTimings.DURATION.value,
+                post_delay=SineSpecTimings.POST_DELAY.value,
                 threshold_current=threshold_current,
                 threshold_percentage=threshold_percentage,
             )

bluecellulab/tools.py

@@ -437,18 +437,17 @@ def calculate_max_thresh_current(cell: Cell,
 
 
 def calculate_rheobase(cell: Cell,
-                       threshold_voltage: float = -30.0,
+                       threshold_voltage: float = -20.0,
                        threshold_search_stim_start: float = 300.0,
                        threshold_search_stim_stop: float = 1000.0,
                        section: str = "soma[0]",
-                       segx: float = 0.5,
-                       step_thresh: float = -20.) -> float:
+                       segx: float = 0.5) -> float:
     """Calculate the rheobase by first computing the upper bound threshold
     current.
 
     Args:
         cell (bluecellulab.cell.Cell): The initialized cell model.
-        threshold_voltage (float, optional): Voltage threshold for spike detection. Default is -30.0 mV.
+        threshold_voltage (float, optional): Voltage threshold for spike detection. Default is -20.0 mV.
         threshold_search_stim_start (float, optional): Start time for threshold search stimulation (in ms). Default is 300.0 ms.
         threshold_search_stim_stop (float, optional): Stop time for threshold search stimulation (in ms). Default is 1000.0 ms.
         section (str, optional): The section where current is injected.

bluecellulab/validation/validation.py

@@ -0,0 +1,401 @@
+# Copyright 2025 Open Brain Institute
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import matplotlib.pyplot as plt
+import numpy
+import pathlib
+
+import efel
+
+from bluecellulab.analysis.analysis import compute_plot_fi_curve
+from bluecellulab.analysis.analysis import compute_plot_iv_curve
+from bluecellulab.analysis.inject_sequence import run_multirecordings_stimulus
+from bluecellulab.analysis.inject_sequence import run_stimulus
+from bluecellulab.stimulus.factory import IDRestTimings
+from bluecellulab.stimulus.factory import StimulusFactory
+from bluecellulab.tools import calculate_input_resistance
+from bluecellulab.tools import calculate_rheobase
+
+logger = logging.getLogger(__name__)
+
+
+def plot_trace(recording, out_dir, fname, title):
+    """Plot a trace with inout current given a recording."""
+    outpath = out_dir / fname
+    fig, ax1 = plt.subplots(figsize=(10, 6))
+    plt.plot(recording.time, recording.voltage, color="black")
+    current_axis = ax1.twinx()
+    current_axis.plot(recording.time, recording.current, color="gray", alpha=0.6)
+    current_axis.set_ylabel("Stimulus Current [nA]")
+    fig.suptitle(title)
+    ax1.set_xlabel("Time [ms]")
+    ax1.set_ylabel("Voltage [mV]")
+    fig.tight_layout()
+    fig.savefig(outpath)
+
+    return outpath
+
+
+def plot_traces(recordings, out_dir, fname, title, labels=None, xlim=None):
+    """Plot a trace with inout current given a recording."""
+    outpath = out_dir / fname
+    fig, ax1 = plt.subplots(figsize=(10, 6))
+    prop_cycle = plt.rcParams["axes.prop_cycle"]
+    colors = prop_cycle.by_key()["color"]
+    N_colors = len(colors)
+    for i, recording in enumerate(recordings):
+        if i == 0:
+            color = "black"
+        else:
+            color = colors[(i - 1) % N_colors]
+        label = labels[i] if labels is not None else None
+        plt.plot(recording.time, recording.voltage, color=color, label=label)
+    current_axis = ax1.twinx()
+    current_axis.plot(recordings[0].time, recordings[0].current, color="gray", alpha=0.6)
+    current_axis.set_ylabel("Stimulus Current [nA]")
+    fig.suptitle(title)
+    ax1.set_xlabel("Time [ms]")
+    ax1.set_ylabel("Voltage [mV]")
+    if labels is not None:
+        ax1.legend()
+    if xlim is not None:
+        ax1.set_xlim(xlim)
+    fig.tight_layout()
+    fig.savefig(outpath)
+
+    return outpath
+
+
+def spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
+    """Spiking test: cell should spike."""
+    stim_factory = StimulusFactory(dt=1.0)
+    step_stimulus = stim_factory.idrest(threshold_current=rheobase, threshold_percentage=200)
+    recording = run_stimulus(
+        cell.template_params,
+        step_stimulus,
+        "soma[0]",
+        0.5,
+        add_hypamp=True,
+        enable_spike_detection=True,
+        threshold_spike_detection=spike_threshold_voltage,
+    )
+    passed = recording.spike is not None and len(recording.spike) > 0
+
+    # plotting
+    outpath = plot_trace(
+        recording,
+        out_dir,
+        fname="spiking_test.pdf",
+        title="Spiking Test - Step at 200% of Rheobase",
+    )
+
+    return {
+        "skipped": False,
+        "passed": passed,
+        "figures": [outpath],
+    }
+
+
+def depolarization_block_test(cell, rheobase, out_dir):
+    """Depolarization block test: no depolarization block should be detected."""
+    # Run the stimulus
+    stim_factory = StimulusFactory(dt=1.0)
+    step_stimulus = stim_factory.idrest(threshold_current=rheobase, threshold_percentage=200)
+    recording = run_stimulus(
+        cell.template_params,
+        step_stimulus,
+        "soma[0]",
+        0.5,
+        add_hypamp=True,
+        enable_spike_detection=False,
+    )
+    # Check for depolarization block
+    trace = {
+        "T": recording.time,
+        "V": recording.voltage,
+        "stim_start": [IDRestTimings.PRE_DELAY.value],
+        "stim_end": [IDRestTimings.PRE_DELAY.value + IDRestTimings.DURATION.value],
+    }
+    features_results = efel.get_feature_values([trace], ["depol_block_bool"])
+    depol_block = bool(features_results[0]["depol_block_bool"][0])
+
+    # plotting
+    outpath = plot_trace(
+        recording,
+        out_dir,
+        fname="depolarization_block_test.pdf",
+        title="Depolarization Block Test - Step at 200% of Rheobase",
+    )
+
+    return {
+        "skipped": False,
+        "passed": not depol_block,
+        "figures": [outpath],
+    }
+
+
+def ais_spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
+    """AIS spiking test: axon should spike before soma."""
+    # Check that the cell has an axon
+    if len(cell.axonal) == 0:
+        return {
+            "skipped": True,
+            "passed": False,
+            "figures": [],
+        }
+
+    # Run the stimulus
+    stim_factory = StimulusFactory(dt=1.0)
+    step_stimulus = stim_factory.idrest(threshold_current=rheobase, threshold_percentage=200)
+    recordings = run_multirecordings_stimulus(
+        cell.template_params,
+        step_stimulus,
+        "soma[0]",
+        0.5,
+        add_hypamp=True,
+        recording_locations=[("axon[0]", 0.5), ("soma[0]", 0.5)],
+        enable_spike_detection=True,
+        threshold_spike_detection=spike_threshold_voltage,
+    )
+    axon_recording, soma_recording = recordings
+
+    # plotting
+    outpath1 = plot_traces(
+        recordings,
+        out_dir,
+        fname="ais_spiking_test.pdf",
+        title="AIS Spiking Test - Step at 200% of Rheobase",
+        labels=["axon[0]", "soma[0]"],
+    )
+    outpath2 = plot_traces(
+        recordings,
+        out_dir,
+        fname="ais_spiking_test_zoomed.pdf",
+        title="AIS Spiking Test - Step at 200% of Rheobase (zoomed)",
+        labels=["axon[0]", "soma[0]"],
+        xlim=(IDRestTimings.PRE_DELAY.value, IDRestTimings.PRE_DELAY.value + 100),
+    )
+
+    # Check for spiking
+    for recording in recordings:
+        if recording.spike is None or len(recording.spike) == 0:
+            return {
+                "skipped": False,
+                "passed": False,
+                "figures": [outpath1, outpath2],
+            }
+
+    # Check if axon spike happens before soma spike
+    passed = bool(axon_recording.spike[0] < soma_recording.spike[0])
+    return {
+        "skipped": False,
+        "passed": passed,
+        "figures": [outpath1, outpath2],
+    }
+
+
+def hyperpolarization_test(cell, rheobase, out_dir):
+    """Hyperpolarization test: hyperpolarized voltage should be lower than RMP."""
+    # Run the stimulus
+    stim_factory = StimulusFactory(dt=1.0)
+    step_stimulus = stim_factory.iv(threshold_current=rheobase, threshold_percentage=-40)
+    recording = run_stimulus(
+        cell.template_params,
+        step_stimulus,
+        "soma[0]",
+        0.5,
+        add_hypamp=True,
+        enable_spike_detection=False,
+    )
+
+    # plotting
+    outpath = plot_trace(
+        recording,
+        out_dir,
+        fname="hyperpolarization_test.pdf",
+        title="Hyperpolarization Test - Step at -40% of Rheobase",
+    )
+
+    # Check for hyperpolarization
+    trace = {
+        "T": recording.time,
+        "V": recording.voltage,
+        "stim_start": [IDRestTimings.PRE_DELAY.value],
+        "stim_end": [IDRestTimings.PRE_DELAY.value + IDRestTimings.DURATION.value],
+    }
+    features_results = efel.get_feature_values([trace], ["voltage_base", "steady_state_voltage_stimend"])
+    rmp = features_results[0]["voltage_base"][0]
+    ss_voltage = features_results[0]["steady_state_voltage_stimend"][0]
+    if rmp is None or ss_voltage is None:
+        return {
+            "skipped": False,
+            "passed": False,
+            "figures": [outpath],
+        }
+    hyperpol_bool = bool(ss_voltage < rmp)
+
+    return {
+        "skipped": False,
+        "passed": hyperpol_bool,
+        "figures": [outpath],
+    }
+
+
+def rin_test(rin):
+    """Rin should have an acceptable biological range (< 1000 MOhm)"""
+    passed = bool(rin < 1000)
+
+    return {
+        "skipped": False,
+        "passed": passed,
+        "figures": [],
+    }
+
+
+def iv_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
+    """IV curve should have a positive slope."""
+    amps, steady_states = compute_plot_iv_curve(
+        cell,
+        rheobase=rheobase,
+        threshold_voltage=spike_threshold_voltage,
+        nb_bins=5,
+        show_figure=False,
+        save_figure=True,
+        output_dir=out_dir,
+        output_fname="iv_curve.pdf")
+
+    outpath = pathlib.Path(out_dir) / "iv_curve.pdf"
+
+    # Check for positive slope
+    if len(amps) < 2 or len(steady_states) < 2:
+        return {
+            "skipped": False,
+            "passed": False,
+            "figures": [outpath],
+        }
+    slope = numpy.polyfit(amps, steady_states, 1)[0]
+    passed = bool(slope > 0)
+    return {
+        "skipped": False,
+        "passed": passed,
+        "figures": [outpath],
+    }
+
+
+def fi_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
+    """FI curve should have a positive slope."""
+    amps, spike_counts = compute_plot_fi_curve(
+        cell,
+        rheobase=rheobase,
+        threshold_voltage=spike_threshold_voltage,
+        nb_bins=5,
+        show_figure=False,
+        save_figure=True,
+        output_dir=out_dir,
+        output_fname="fi_curve.pdf")
+
+    outpath = pathlib.Path(out_dir) / "fi_curve.pdf"
+
+    # Check for positive slope
+    if len(amps) < 2 or len(spike_counts) < 2:
+        return {
+            "skipped": False,
+            "passed": False,
+            "figures": [outpath],
+        }
+    slope = numpy.polyfit(amps, spike_counts, 1)[0]
+    passed = bool(slope > 0)
+    return {
+        "skipped": False,
+        "passed": passed,
+        "figures": [outpath],
+    }
+
+
+def run_validations(cell, cell_name, spike_threshold_voltage=-30):
+    """Run all the validations on the cell.
+
+    Args:
+        cell (Cell): The cell to validate.
+        cell_name (str): The name of the cell, used in the output directory.
+        spike_threshold_voltage (float): The voltage threshold for spike detection.
+    """
+    out_dir = pathlib.Path("memodel_validation_figures") / cell_name
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    # cell = Cell.from_template_parameters(template_params)
+    # get me-model properties
+    holding_current = cell.hypamp if cell.hypamp else 0.0
+    if cell.threshold:
+        rheobase = cell.threshold
+    else:
+        rheobase = calculate_rheobase(
+            cell=cell, section="soma[0]", segx=0.5, threshold_voltage=spike_threshold_voltage
+        )
+    rin = calculate_input_resistance(
+        template_path=cell.template_params.template_filepath,
+        morphology_path=cell.template_params.morph_filepath,
+        template_format=cell.template_params.template_format,
+        emodel_properties=cell.template_params.emodel_properties,
+    )
+
+    # Validation 1: Spiking Test
+    logger.debug("Running spiking test")
+    spiking_test_result = spiking_test(cell, rheobase, out_dir, spike_threshold_voltage)
+
+    # Validation 2: Depolarization Block Test
+    logger.debug("Running depolarization block test")
+    depolarization_block_result = depolarization_block_test(cell, rheobase, out_dir)
+
+    # Validation 3: Backpropagating AP Test
+    # logger.debug("Running backpropagating AP test")
+
+    # Validation 4: Postsynaptic Potential Test
+    # logger.debug("Running postsynaptic potential test")
+
+    # Validation 5: AIS Spiking Test
+    logger.debug("Running AIS spiking test")
+    ais_spiking_test_result = ais_spiking_test(cell, rheobase, out_dir, spike_threshold_voltage)
+
+    # Validation 6: Hyperpolarization Test
+    logger.debug("Running hyperpolarization test")
+    hyperpolarization_result = hyperpolarization_test(cell, rheobase, out_dir)
+
+    # Validation 7: Rin Test
+    logger.debug("Running Rin test")
+    rin_result = rin_test(rin)
+
+    # Validation 8: IV Test
+    logger.debug("Running IV test")
+    iv_test_result = iv_test(cell, rheobase, out_dir, spike_threshold_voltage)
+
+    # Validation 9: FI Test
+    logger.debug("Running FI test")
+    fi_test_result = fi_test(cell, rheobase, out_dir, spike_threshold_voltage)
+
+    return {
+        "memodel_properties": {
+            "holding_current": holding_current,
+            "rheobase": rheobase,
+            "rin": rin,
+        },
+        "spiking_test": spiking_test_result,
+        "depolarization_block_test": depolarization_block_result,
+        "ais_spiking_test": ais_spiking_test_result,
+        "hyperpolarization_test": hyperpolarization_result,
+        "rin_test": rin_result,
+        "iv_test": iv_test_result,
+        "fi_test": fi_test_result,
+    }

{bluecellulab-2.6.47.dist-info → bluecellulab-2.6.48.dist-info}/METADATA

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

{bluecellulab-2.6.47.dist-info → bluecellulab-2.6.48.dist-info}/RECORD

@@ -10,14 +10,14 @@ bluecellulab/plotwindow.py,sha256=ePU-EegZ1Sqk0SoYYiQ6k24ZO4s3Hgfpx10uePiJ5xM,27
 bluecellulab/psection.py,sha256=FSOwRNuOTyB469BM-jPEf9l1J59FamXmzrQgBI6cnP4,6174
 bluecellulab/psegment.py,sha256=PTgoGLqM4oFIdF_8QHFQCU59j-8TQmtq6PakiGUQhIo,3138
 bluecellulab/rngsettings.py,sha256=2Ykb4Ylk3XTs58x1UIxjg8XJqjSpnCgKRZ8avXCDpxk,4237
-bluecellulab/tools.py,sha256=yy2_XBANaCQEqBeCIRiQfWJUidth9_igldVOSuSp5l4,18018
+bluecellulab/tools.py,sha256=hF1HJcera0oggetsfN5PNTRYCpFS0sQiZlVxw4jRd1g,17968
 bluecellulab/type_aliases.py,sha256=DvgjERv2Ztdw_sW63JrZTQGpJ0x5uMTFB5hcBHDb0WA,441
 bluecellulab/utils.py,sha256=SbOOkzw1YGjCKV3qOw0zpabNEy7V9BRtgMLsQJiFRq4,1526
 bluecellulab/verbosity.py,sha256=T0IgX7DrRo19faxrT4Xzb27gqxzoILQ8FzYKxvUeaPM,1342
 bluecellulab/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bluecellulab/analysis/analysis.py,sha256=ItRtUeXeIoYN6gkSZh-U5lBv-plClNZECU6y6YlaNCI,8615
-bluecellulab/analysis/inject_sequence.py,sha256=ehYSXFgz7do9-zQjiGS2WVAiEmcjM24mWQFQty9pWDw,9012
-bluecellulab/analysis/plotting.py,sha256=-ArjWHZsAlUoNSu_t0HQjQmFhGI1tCQtdAoICgwstFs,2588
+bluecellulab/analysis/analysis.py,sha256=3gDJRau5SL6wOhAUJ16vqP7aYLtoAZ7f1qZbSUVoUU8,10818
+bluecellulab/analysis/inject_sequence.py,sha256=uU6Q6y0ErMDDEgdsTZBXCJ4LgwkATY7G8Fa6mmjpL98,12523
+bluecellulab/analysis/plotting.py,sha256=PqRoaZz33ULMw8A9YnZXXrxcUd84M_dwlYMTFhG7YT4,3999
 bluecellulab/cell/__init__.py,sha256=Sbc0QOsJ8E7tSwf3q7fsXuE_SevBN6ZmoCVyyU5zfII,208
 bluecellulab/cell/cell_dict.py,sha256=VE7pi-NsMVRSmo-PSdbiLYmolDOu0Gc6JxFBkuQpFdk,1346
 bluecellulab/cell/core.py,sha256=BualY0WOtC0arKmvKzQ3sQ0fhc2jrtd6wqSd9M-e25E,33797
@@ -60,14 +60,15 @@ bluecellulab/simulation/parallel.py,sha256=oQ_oV2EKr8gP4yF2Dq8q9MiblDyi89_wBgLzQ
 bluecellulab/simulation/simulation.py,sha256=VhftOMYU1Rfrphvud6f0U4kvbUivSviQ5TlVljuTb88,6486
 bluecellulab/stimulus/__init__.py,sha256=DgIgVaSyR-URf3JZzvO6j-tjCerzvktuK-ep8pjMRPQ,37
 bluecellulab/stimulus/circuit_stimulus_definitions.py,sha256=dTpwfRxH4c4yJDYyKrO6X-2Nqdy-QT3GxGQjfsRhNVY,17158
-bluecellulab/stimulus/factory.py,sha256=K8d8krPr12tchYcqGrKzm-QOdOZh9QKwcml1Mk90M1M,29359
+bluecellulab/stimulus/factory.py,sha256=4fvVFFjOGHSqBidLe_W1zQozfMEeePXWO6yYCs30-SM,30780
 bluecellulab/stimulus/stimulus.py,sha256=a_hKJUtZmIgjiFjbJf6RzUPokELqn0IHCgIWGw5XLm8,30322
 bluecellulab/synapse/__init__.py,sha256=RW8XoAMXOvK7OG1nHl_q8jSEKLj9ZN4oWf2nY9HAwuk,192
 bluecellulab/synapse/synapse_factory.py,sha256=NHwRMYMrnRVm_sHmyKTJ1bdoNmWZNU4UPOGu7FCi-PE,6987
 bluecellulab/synapse/synapse_types.py,sha256=zs_yBvGTH4QrbQF3nEViidyq1WM_ZcTSFdjUxB3khW0,16871
-bluecellulab-2.6.47.dist-info/licenses/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
-bluecellulab-2.6.47.dist-info/licenses/LICENSE,sha256=dAMAR2Sud4Nead1wGFleKiwTZfkTNZbzmuGfcTKb3kg,11335
-bluecellulab-2.6.47.dist-info/METADATA,sha256=rydGOCvn6Y2v-KNPtssf3Au4IxaW2B_mo5nT5hf1QXA,8236
-bluecellulab-2.6.47.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-bluecellulab-2.6.47.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
-bluecellulab-2.6.47.dist-info/RECORD,,
+bluecellulab/validation/validation.py,sha256=iGOgtgpZ3Yid1VlxsCycS14a0qRkP42zhj4WFPCBX4Q,13017
+bluecellulab-2.6.48.dist-info/licenses/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
+bluecellulab-2.6.48.dist-info/licenses/LICENSE,sha256=dAMAR2Sud4Nead1wGFleKiwTZfkTNZbzmuGfcTKb3kg,11335
+bluecellulab-2.6.48.dist-info/METADATA,sha256=a7gi6zv56VtPk9dN6g2qWN926WnR3VdX-_7T1SvT2h4,8236
+bluecellulab-2.6.48.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+bluecellulab-2.6.48.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
+bluecellulab-2.6.48.dist-info/RECORD,,

{bluecellulab-2.6.47.dist-info → bluecellulab-2.6.48.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any