bluecellulab 2.6.49__py3-none-any.whl → 2.6.51__py3-none-any.whl

bluecellulab/analysis/analysis.py

@@ -3,14 +3,31 @@ try:
     import efel
 except ImportError:
     efel = None
+from itertools import islice
+from itertools import repeat
+import logging
+from matplotlib.collections import LineCollection
+import matplotlib.pyplot as plt
+from multiprocessing import Pool
+import neuron
 import numpy as np
+import pathlib
+import seaborn as sns
 
+
+from bluecellulab import Cell
 from bluecellulab.analysis.inject_sequence import run_stimulus
 from bluecellulab.analysis.plotting import plot_iv_curve, plot_fi_curve
+from bluecellulab.analysis.utils import exp_decay
+from bluecellulab.simulation import Simulation
 from bluecellulab.stimulus import StimulusFactory
+from bluecellulab.stimulus.circuit_stimulus_definitions import Hyperpolarizing
 from bluecellulab.tools import calculate_rheobase
 
 
+logger = logging.getLogger(__name__)
+
+
 def compute_plot_iv_curve(cell,
                           injecting_section="soma[0]",
                           injecting_segment=0.5,
@@ -48,7 +65,7 @@ def compute_plot_iv_curve(cell,
         post_delay (float, optional): The delay after the stimulation ends before the simulation stops
             (in ms). Default is 100.0 ms.
         threshold_voltage (float, optional): The voltage threshold (in mV) for detecting a steady-state
-            response. Default is -30 mV.
+            response. Default is -20 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
@@ -73,30 +90,35 @@ def compute_plot_iv_curve(cell,
 
     list_amp = np.linspace(rheobase - 2, rheobase - 0.1, nb_bins)  # [nA]
 
-    steps = []
-    times = []
-    voltages = []
     # inject step current and record voltage response
     stim_factory = StimulusFactory(dt=0.1)
-    for amp in list_amp:
-        step_stimulus = stim_factory.step(pre_delay=stim_start, duration=duration, post_delay=post_delay, amplitude=amp)
-        recording = run_stimulus(cell.template_params,
-                                 step_stimulus,
-                                 section=injecting_section,
-                                 segment=injecting_segment,
-                                 recording_section=recording_section,
-                                 recording_segment=recording_segment)
-        steps.append(step_stimulus)
-        times.append(recording.time)
-        voltages.append(recording.voltage)
+    steps = [
+        stim_factory.step(pre_delay=stim_start, duration=duration, post_delay=post_delay, amplitude=amp)
+        for amp in list_amp
+    ]
+
+    with Pool(len(steps)) as p:
+        recordings = p.starmap(
+            run_stimulus,
+            zip(
+                repeat(cell.template_params),
+                steps,
+                repeat(injecting_section),
+                repeat(injecting_segment),
+                repeat(True),  # cvode
+                repeat(True),  # add_hypamp
+                repeat(recording_section),
+                repeat(recording_segment),
+            )
+        )
 
     steady_states = []
     # compute steady state response
     efel.set_setting('Threshold', threshold_voltage)
-    for voltage, t in zip(voltages, times):
+    for recording in recordings:
         trace = {
-            'T': t,
-            'V': voltage,
+            'T': recording.time,
+            'V': recording.voltage,
             'stim_start': [stim_start],
             'stim_end': [stim_start + duration]
         }
@@ -158,7 +180,7 @@ def compute_plot_fi_curve(cell,
         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.
+            response. Default is -20 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
@@ -180,24 +202,30 @@ def compute_plot_fi_curve(cell,
         rheobase = calculate_rheobase(cell=cell, section=injecting_section, segx=injecting_segment)
 
     list_amp = np.linspace(rheobase, max_current, nb_bins)  # [nA]
-    steps = []
-    spikes = []
-    # inject step current and record spike response
     stim_factory = StimulusFactory(dt=0.1)
-    for amp in list_amp:
-        step_stimulus = stim_factory.step(pre_delay=stim_start, duration=duration, post_delay=post_delay, amplitude=amp)
-        recording = run_stimulus(cell.template_params,
-                                 step_stimulus,
-                                 section=injecting_section,
-                                 segment=injecting_segment,
-                                 recording_section=recording_section,
-                                 recording_segment=recording_segment,
-                                 enable_spike_detection=True,
-                                 threshold_spike_detection=threshold_voltage)
-        steps.append(step_stimulus)
-        spikes.append(recording.spike)
-
-    spike_count = [len(spike) for spike in spikes]
+    steps = [
+        stim_factory.step(pre_delay=stim_start, duration=duration, post_delay=post_delay, amplitude=amp)
+        for amp in list_amp
+    ]
+
+    with Pool(len(steps)) as p:
+        recordings = p.starmap(
+            run_stimulus,
+            zip(
+                repeat(cell.template_params),
+                steps,
+                repeat(injecting_section),
+                repeat(injecting_segment),
+                repeat(True),  # cvode
+                repeat(True),  # add_hypamp
+                repeat(recording_section),
+                repeat(recording_segment),
+                repeat(True),  # enable_spike_detection
+                repeat(threshold_voltage),  # threshold_spike_detection
+            )
+        )
+
+    spike_count = [len(recording.spike) for recording in recordings]
 
     plot_fi_curve(list_amp,
                   spike_count,
@@ -211,3 +239,264 @@ def compute_plot_fi_curve(cell,
                   output_fname=output_fname)
 
     return np.array(list_amp), np.array(spike_count)
+
+
+class BPAP:
+    # taken from the examples
+
+    def __init__(self, cell: Cell) -> None:
+        self.cell = cell
+        self.dt = 0.025
+        self.stim_start = 1000
+        self.stim_duration = 3
+        self.basal_cmap = sns.color_palette("crest", as_cmap=True)
+        self.apical_cmap = sns.color_palette("YlOrBr_r", as_cmap=True)
+
+    @property
+    def start_index(self) -> int:
+        """Get the index of the start of the stimulus."""
+        return int(self.stim_start / self.dt)
+
+    @property
+    def end_index(self) -> int:
+        """Get the index of the end of the stimulus."""
+        return int((self.stim_start + self.stim_duration) / self.dt)
+
+    def get_recordings(self):
+        """Get the soma, basal and apical recordings."""
+        all_recordings = self.cell.get_allsections_voltagerecordings()
+        soma_rec = None
+        dend_rec = {}
+        apic_rec = {}
+        for key, value in all_recordings.items():
+            if "soma" in key:
+                soma_rec = value
+            elif "dend" in key:
+                dend_rec[key] = value
+            elif "apic" in key:
+                apic_rec[key] = value
+
+        return soma_rec, dend_rec, apic_rec
+
+    def run(self, duration: float, amplitude: float) -> None:
+        """Apply depolarization and hyperpolarization at the same time."""
+        sim = Simulation()
+        sim.add_cell(self.cell)
+        self.cell.add_allsections_voltagerecordings()
+        self.cell.add_step(start_time=self.stim_start, stop_time=self.stim_start + self.stim_duration, level=amplitude)
+        hyperpolarizing = Hyperpolarizing("single-cell", delay=0, duration=duration)
+        self.cell.add_replay_hypamp(hyperpolarizing)
+        sim.run(duration, dt=self.dt, cvode=False)
+
+    def amplitudes(self, recs) -> list[float]:
+        """Return amplitude across given sections."""
+        efel_feature_name = "maximum_voltage_from_voltagebase"
+        traces = [
+            {
+                'T': self.cell.get_time(),
+                'V': rec,
+                'stim_start': [self.stim_start],
+                'stim_end': [self.stim_start + self.stim_duration]
+            }
+            for rec in recs.values()
+        ]
+        features_results = efel.get_feature_values(traces, [efel_feature_name])
+        amps = [feat_res[efel_feature_name][0] for feat_res in features_results]
+
+        return amps
+
+    def distances_to_soma(self, recs) -> list[float]:
+        """Return the distance to the soma for each section."""
+        res = []
+        soma = self.cell.soma
+        for key in recs.keys():
+            section_name = key.rsplit(".")[-1].split("[")[0]  # e.g. "dend"
+            section_idx = int(key.rsplit(".")[-1].split("[")[1].split("]")[0])  # e.g. 0
+            attribute_value = getattr(self.cell.cell.getCell(), section_name)
+            section = next(islice(attribute_value, section_idx, None))
+            # section e.g. cADpyr_L2TPC_bluecellulab_x[0].dend[0]
+            res.append(neuron.h.distance(soma(0.5), section(0.5)))
+        return res
+
+    def get_amplitudes_and_distances(self):
+        soma_rec, dend_rec, apic_rec = self.get_recordings()
+        soma_amp = self.amplitudes({"soma": soma_rec})[0]
+        dend_amps = None
+        dend_dist = None
+        apic_amps = None
+        apic_dist = None
+        if dend_rec:
+            dend_amps = self.amplitudes(dend_rec)
+            dend_dist = self.distances_to_soma(dend_rec)
+        if apic_rec:
+            apic_amps = self.amplitudes(apic_rec)
+            apic_dist = self.distances_to_soma(apic_rec)
+
+        return soma_amp, dend_amps, dend_dist, apic_amps, apic_dist
+
+    def fit(self, soma_amp, dend_amps, dend_dist, apic_amps, apic_dist):
+        """Fit the amplitudes vs distances to an exponential decay function."""
+        from scipy.optimize import curve_fit
+
+        popt_dend = None
+        if dend_amps and dend_dist:
+            dist = [0] + dend_dist  # add soma distance
+            amps = [soma_amp] + dend_amps  # add soma amplitude
+            popt_dend, _ = curve_fit(exp_decay, dist, amps)
+
+        popt_apic = None
+        if apic_amps and apic_dist:
+            dist = [0] + apic_dist  # add soma distance
+            amps = [soma_amp] + apic_amps  # add soma amplitude
+            popt_apic, _ = curve_fit(exp_decay, dist, amps)
+
+        return popt_dend, popt_apic
+
+    def validate(self, soma_amp, dend_amps, dend_dist, apic_amps, apic_dist):
+        """Check that the exponential fit is decaying."""
+        validated = True
+        notes = ""
+        popt_dend, popt_apic = self.fit(soma_amp, dend_amps, dend_dist, apic_amps, apic_dist)
+        if popt_dend is None:
+            logger.debug("No dendritic recordings found.")
+            notes += "No dendritic recordings found.\n"
+        elif popt_dend[1] <= 0:
+            logger.debug("Dendritic fit is not decaying.")
+            validated = False
+            notes += "Dendritic fit is not decaying.\n"
+        else:
+            notes += "Dendritic validation passed: dendritic amplitude is decaying with distance relative to soma.\n"
+        if popt_apic is None:
+            logger.debug("No apical recordings found.")
+            notes += "No apical recordings found.\n"
+        elif popt_apic[1] <= 0:
+            logger.debug("Apical fit is not decaying.")
+            validated = False
+            notes += "Apical fit is not decaying.\n"
+        else:
+            notes += "Apical validation passed: apical amplitude is decaying with distance relative to soma.\n"
+
+        return validated, notes
+
+    def plot_amp_vs_dist(
+        self,
+        soma_amp,
+        dend_amps,
+        dend_dist,
+        apic_amps,
+        apic_dist,
+        show_figure=True,
+        save_figure=False,
+        output_dir="./",
+        output_fname="bpap.pdf",
+    ):
+        """Plot the results of the BPAP analysis."""
+        popt_dend, popt_apic = self.fit(soma_amp, dend_amps, dend_dist, apic_amps, apic_dist)
+
+        outpath = pathlib.Path(output_dir) / output_fname
+        fig, ax1 = plt.subplots(figsize=(10, 6))
+        ax1.scatter([0], [soma_amp], marker="^", color='black', label='Soma')
+        if dend_amps and dend_dist:
+            ax1.scatter(
+                dend_dist,
+                dend_amps,
+                c=dend_dist,
+                cmap=self.basal_cmap,
+                label='Basal Dendrites',
+            )
+            if popt_dend is not None:
+                x = np.linspace(0, max(dend_dist), 100)
+                y = exp_decay(x, *popt_dend)
+                ax1.plot(x, y, color='darkgreen', linestyle='--', label='Basal Dendritic Fit')
+        if apic_amps and apic_dist:
+            ax1.scatter(
+                apic_dist,
+                apic_amps,
+                c=apic_dist,
+                cmap=self.apical_cmap,
+                label='Apical Dendrites'
+            )
+            if popt_apic is not None:
+                x = np.linspace(0, max(apic_dist), 100)
+                y = exp_decay(x, *popt_apic)
+                ax1.plot(x, y, color='goldenrod', linestyle='--', label='Apical Fit')
+        ax1.set_xlabel('Distance to Soma (um)')
+        ax1.set_ylabel('Amplitude (mV)')
+        ax1.legend()
+        fig.suptitle('Back-propagating Action Potential Analysis')
+        fig.tight_layout()
+        if save_figure:
+            fig.savefig(outpath)
+        if show_figure:
+            plt.show()
+
+        return outpath
+
+    def plot_one_axis_recordings(self, fig, ax, rec_list, dist, cmap):
+        """Plot the soma and dendritic recordings on one axis.
+
+        Args:
+            fig (matplotlib.figure.Figure): The figure to plot on.
+            ax (matplotlib.axes.Axes): The axis to plot on.
+            rec_list (list): List of recordings to plot.
+            dist (list): List of distances from the soma for each recording.
+            cmap (matplotlib.colors.Colormap): Colormap to use for the recordings.
+        """
+        time = self.cell.get_time()
+        line_collection = LineCollection(
+            [np.column_stack([time, rec]) for rec in rec_list],
+            array=dist,
+            cmap=cmap,
+        )
+        ax.set_xlim(
+            self.stim_start - 0.1,
+            self.stim_start + 30
+        )
+        ax.set_ylim(
+            min([min(rec[self.start_index:]) for rec in rec_list]) - 2,
+            max([max(rec[self.start_index:]) for rec in rec_list]) + 2
+        )
+        ax.add_collection(line_collection)
+        fig.colorbar(line_collection, label="soma distance (um)", ax=ax)
+
+    def plot_recordings(
+        self,
+        show_figure=True,
+        save_figure=False,
+        output_dir="./",
+        output_fname="bpap_recordings.pdf",
+    ):
+        """Plot the recordings from all dendrites."""
+        soma_rec, dend_rec, apic_rec = self.get_recordings()
+        dend_dist = []
+        apic_dist = []
+        if dend_rec:
+            dend_dist = self.distances_to_soma(dend_rec)
+        if apic_rec:
+            apic_dist = self.distances_to_soma(apic_rec)
+        # add soma_rec to the lists
+        dend_rec_list = [soma_rec] + list(dend_rec.values())
+        dend_dist = [0] + dend_dist
+        apic_rec_list = [soma_rec] + list(apic_rec.values())
+        apic_dist = [0] + apic_dist
+
+        outpath = pathlib.Path(output_dir) / output_fname
+        fig, (ax1, ax2) = plt.subplots(figsize=(10, 12), nrows=2, sharex=True)
+
+        self.plot_one_axis_recordings(fig, ax1, dend_rec_list, dend_dist, self.basal_cmap)
+        self.plot_one_axis_recordings(fig, ax2, apic_rec_list, apic_dist, self.apical_cmap)
+
+        # plt.setp(ax1.get_xticklabels(), visible=False)
+        ax1.set_title('Basal Dendritic Recordings')
+        ax2.set_title('Apical Dendritic Recordings')
+        ax1.set_ylabel('Voltage (mV)')
+        ax2.set_ylabel('Voltage (mV)')
+        ax2.set_xlabel('Time (ms)')
+        fig.suptitle('Back-propagating Action Potential Recordings')
+        fig.tight_layout()
+        if save_figure:
+            fig.savefig(outpath)
+        if show_figure:
+            plt.show()
+
+        return outpath

bluecellulab/analysis/utils.py

@@ -0,0 +1,7 @@
+"""Utility functions for analysis."""
+
+import numpy as np
+
+
+def exp_decay(x, a, b, c):
+    return a * np.exp(-b * x) + c

bluecellulab/circuit/circuit_access/bluepy_circuit_access.py

@@ -233,7 +233,7 @@ class BluepyCircuitAccess:
         source_popid, target_popid = zip(*pop_ids)
 
         result = result.assign(
-            source_popid=source_popid, target_popid=target_popid
+            source_popid=pd.Series(source_popid), target_popid=pd.Series(target_popid)
         )
 
         if result.empty:

bluecellulab/utils.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 import contextlib
 import io
 import json
+import multiprocessing
+from multiprocessing import pool
 
 import numpy as np
 
@@ -56,3 +58,27 @@ class NumpyEncoder(json.JSONEncoder):
         elif isinstance(obj, np.ndarray):
             return obj.tolist()
         return json.JSONEncoder.default(self, obj)
+
+
+class NoDaemonProcess(multiprocessing.Process):
+    """Class that represents a non-daemon process."""
+
+    # pylint: disable=dangerous-default-value
+
+    def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):
+        """Ensures group=None, for macosx."""
+        super().__init__(group=None, target=target, name=name, args=args, kwargs=kwargs)
+
+    @property
+    def daemon(self):
+        return False
+
+    @daemon.setter
+    def daemon(self, val):
+        pass
+
+
+class NestedPool(pool.Pool):  # pylint: disable=abstract-method
+    """Class that represents a MultiProcessing nested pool."""
+
+    Process = NoDaemonProcess

bluecellulab/validation/validation.py

@@ -19,10 +19,12 @@ import pathlib
 
 import efel
 
+from bluecellulab.analysis.analysis import BPAP
 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.cell.core import Cell
 from bluecellulab.stimulus.factory import IDRestTimings
 from bluecellulab.stimulus.factory import StimulusFactory
 from bluecellulab.tools import calculate_input_resistance
@@ -78,12 +80,12 @@ def plot_traces(recordings, out_dir, fname, title, labels=None, xlim=None):
     return outpath
 
 
-def spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
+def spiking_test(template_params, 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,
+        template_params,
         step_stimulus,
         "soma[0]",
         0.5,
@@ -101,20 +103,22 @@ def spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
         title="Spiking Test - Step at 200% of Rheobase",
     )
 
+    notes = "Validation passed: Spikes detected." if passed else "Validation failed: No spikes detected."
     return {
-        "skipped": False,
+        "name": "Simulatable Neuron Spiking Validation",
         "passed": passed,
+        "validation_details": notes,
         "figures": [outpath],
     }
 
 
-def depolarization_block_test(cell, rheobase, out_dir):
+def depolarization_block_test(template_params, 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,
+        template_params,
         step_stimulus,
         "soma[0]",
         0.5,
@@ -139,20 +143,63 @@ def depolarization_block_test(cell, rheobase, out_dir):
         title="Depolarization Block Test - Step at 200% of Rheobase",
     )
 
+    notes = "Validation passed: No depolarization block detected." if not depol_block else "Validation failed: Depolarization block detected."
     return {
-        "skipped": False,
+        "name": "Simulatable Neuron Depolarization Block Validation",
         "passed": not depol_block,
+        "validation_details": notes,
         "figures": [outpath],
     }
 
 
-def ais_spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
+def bpap_test(template_params, rheobase, out_dir="./"):
+    """Back-propagating action potential test: exponential fit should decay.
+
+    Args:
+        template_params (dict): The template parameters for creating the cell.
+        rheobase (float): The rheobase current to use for the test.
+        out_dir (str): Directory to save the figure.
+    """
+    amplitude = 10. * rheobase  # Use 1000% of the rheobase current
+    bpap = BPAP(Cell.from_template_parameters(template_params))
+    bpap.run(duration=1500, amplitude=amplitude)
+    soma_amp, dend_amps, dend_dist, apic_amps, apic_dist = bpap.get_amplitudes_and_distances()
+    validated, notes = bpap.validate(soma_amp, dend_amps, dend_dist, apic_amps, apic_dist)
+    outpath_amp_dist = bpap.plot_amp_vs_dist(
+        soma_amp,
+        dend_amps,
+        dend_dist,
+        apic_amps,
+        apic_dist,
+        show_figure=False,
+        save_figure=True,
+        output_dir=out_dir,
+        output_fname="bpap.pdf"
+    )
+    outpath_recordings = bpap.plot_recordings(
+        show_figure=False,
+        save_figure=True,
+        output_dir=out_dir,
+        output_fname="bpap_recordings.pdf",
+    )
+
+    return {
+        "name": "Simulatable Neuron Back-propagating Action Potential Validation",
+        "validation_details": notes,
+        "passed": validated,
+        "figures": [outpath_amp_dist, outpath_recordings],
+    }
+
+
+def ais_spiking_test(template_params, rheobase, out_dir, spike_threshold_voltage=-30.):
     """AIS spiking test: axon should spike before soma."""
+    name = "Simulatable Neuron AIS Spiking Validation"
     # Check that the cell has an axon
-    if len(cell.axonal) == 0:
+    if len(Cell.from_template_parameters(template_params).axonal) == 0:
         return {
-            "skipped": True,
-            "passed": False,
+            "name": name,
+            "passed": True,
+            "validation_details": "Validation skipped: Cell does not have an axon section.",
             "figures": [],
         }
 
@@ -160,7 +207,7 @@ def ais_spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
     stim_factory = StimulusFactory(dt=1.0)
     step_stimulus = stim_factory.idrest(threshold_current=rheobase, threshold_percentage=200)
     recordings = run_multirecordings_stimulus(
-        cell.template_params,
+        template_params,
         step_stimulus,
         "soma[0]",
         0.5,
@@ -192,27 +239,35 @@ def ais_spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
     for recording in recordings:
         if recording.spike is None or len(recording.spike) == 0:
             return {
-                "skipped": False,
+                "name": name,
                 "passed": False,
+                "validation_details": "Validation failed: No spikes detected in one or both recordings.",
                 "figures": [outpath1, outpath2],
             }
 
     # Check if axon spike happens before soma spike
     passed = bool(axon_recording.spike[0] < soma_recording.spike[0])
+    notes = (
+        "Validation passed: Axon spikes before soma."
+        if passed
+        else "Validation failed: Axon does not spike before soma."
+    )
     return {
-        "skipped": False,
+        "name": name,
         "passed": passed,
+        "validation_details": notes,
         "figures": [outpath1, outpath2],
     }
 
 
-def hyperpolarization_test(cell, rheobase, out_dir):
+def hyperpolarization_test(template_params, rheobase, out_dir):
     """Hyperpolarization test: hyperpolarized voltage should be lower than RMP."""
+    name = "Simulatable Neuron Hyperpolarization Validation"
     # 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,
+        template_params,
         step_stimulus,
         "soma[0]",
         0.5,
@@ -240,15 +295,22 @@ def hyperpolarization_test(cell, rheobase, out_dir):
     ss_voltage = features_results[0]["steady_state_voltage_stimend"][0]
     if rmp is None or ss_voltage is None:
         return {
-            "skipped": False,
+            "name": name,
             "passed": False,
+            "validation_details": "Validation failed: Could not determine RMP or steady state voltage.",
             "figures": [outpath],
         }
     hyperpol_bool = bool(ss_voltage < rmp)
 
+    notes = (
+        f"Validation passed: Hyperpolarized voltage ({ss_voltage:.2f} mV) is lower than RMP ({rmp:.2f} mV)."
+        if hyperpol_bool
+        else f"Validation failed: Hyperpolarized voltage ({ss_voltage:.2f} mV) is not lower than RMP ({rmp:.2f} mV)."
+    )
     return {
-        "skipped": False,
+        "name": name,
         "passed": hyperpol_bool,
+        "validation_details": notes,
         "figures": [outpath],
     }
 
@@ -257,17 +319,24 @@ def rin_test(rin):
     """Rin should have an acceptable biological range (< 1000 MOhm)"""
     passed = bool(rin < 1000)
 
+    notes = (
+        f"Validation passed: Input resistance (Rin) = {rin:.2f} MOhm is smaller than 1000 MOhm."
+        if passed
+        else f"Validation failed: Input resistance (Rin) = {rin:.2f} MOhm is higher than 1000 MOhm, which is not realistic."
+    )
     return {
-        "skipped": False,
+        "name": "Simulatable Neuron Input Resistance Validation",
         "passed": passed,
+        "validation_details": notes,
         "figures": [],
     }
 
 
-def iv_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
+def iv_test(template_params, rheobase, out_dir, spike_threshold_voltage=-30.):
     """IV curve should have a positive slope."""
+    name = "Simulatable Neuron IV Curve Validation"
     amps, steady_states = compute_plot_iv_curve(
-        cell,
+        Cell.from_template_parameters(template_params),
         rheobase=rheobase,
         threshold_voltage=spike_threshold_voltage,
         nb_bins=5,
@@ -281,23 +350,31 @@ def iv_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
     # Check for positive slope
     if len(amps) < 2 or len(steady_states) < 2:
         return {
-            "skipped": False,
+            "name": name,
             "passed": False,
+            "validation_details": "Validation failed: Not enough data points to determine slope.",
             "figures": [outpath],
         }
     slope = numpy.polyfit(amps, steady_states, 1)[0]
     passed = bool(slope > 0)
+    notes = (
+        f"Validation passed: Slope of IV curve = {slope:.2f} is positive."
+        if passed
+        else f"Validation failed: Slope of IV curve = {slope:.2f} is not positive."
+    )
     return {
-        "skipped": False,
+        "name": name,
+        "validation_details": notes,
         "passed": passed,
         "figures": [outpath],
     }
 
 
-def fi_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
+def fi_test(template_params, rheobase, out_dir, spike_threshold_voltage=-30.):
     """FI curve should have a positive slope."""
+    name = "Simulatable Neuron FI Curve Validation"
     amps, spike_counts = compute_plot_fi_curve(
-        cell,
+        Cell.from_template_parameters(template_params),
         rheobase=rheobase,
         threshold_voltage=spike_threshold_voltage,
         nb_bins=5,
@@ -311,14 +388,21 @@ def fi_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
     # Check for positive slope
     if len(amps) < 2 or len(spike_counts) < 2:
         return {
-            "skipped": False,
+            "name": name,
             "passed": False,
+            "validation_details": "Validation failed: Not enough data points to determine slope.",
             "figures": [outpath],
         }
     slope = numpy.polyfit(amps, spike_counts, 1)[0]
     passed = bool(slope > 0)
+    notes = (
+        f"Validation passed: Slope of FI curve = {slope:.2f} is positive."
+        if passed
+        else f"Validation failed: Slope of FI curve = {slope:.2f} is not positive."
+    )
     return {
-        "skipped": False,
+        "name": name,
+        "validation_details": notes,
         "passed": passed,
         "figures": [outpath],
     }
@@ -338,7 +422,6 @@ def run_validations(
     out_dir = pathlib.Path(output_dir) / 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:
@@ -354,48 +437,79 @@ def run_validations(
         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)
+    logger.debug("Running validations...")
+    from bluecellulab.utils import NestedPool
+    with NestedPool(processes=8) as pool:
+        # Validation 1: Spiking Test
+        spiking_test_result_future = pool.apply_async(
+            spiking_test,
+            (cell.template_params, 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 2: Depolarization Block Test
+        depolarization_block_result_future = pool.apply_async(
+            depolarization_block_test,
+            (cell.template_params, rheobase, out_dir)
+        )
 
-    # Validation 3: Backpropagating AP Test
-    # logger.debug("Running backpropagating AP test")
+        # Validation 3: Backpropagating AP Test
+        bpap_result_future = pool.apply_async(
+            bpap_test,
+            (cell.template_params, rheobase, out_dir)
+        )
 
-    # Validation 4: Postsynaptic Potential Test
-    # logger.debug("Running postsynaptic potential test")
+        # Validation 4: Postsynaptic Potential Test
+        # We have to wait for ProbAMPANMDA_EMS to be present in entitycore to implement this 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 5: AIS Spiking Test
+        ais_spiking_test_result_future = pool.apply_async(
+            ais_spiking_test,
+            (cell.template_params, rheobase, out_dir, spike_threshold_voltage)
+        )
 
-    # Validation 6: Hyperpolarization Test
-    logger.debug("Running hyperpolarization test")
-    hyperpolarization_result = hyperpolarization_test(cell, rheobase, out_dir)
+        # Validation 6: Hyperpolarization Test
+        hyperpolarization_result_future = pool.apply_async(
+            hyperpolarization_test,
+            (cell.template_params, rheobase, out_dir)
+        )
 
-    # Validation 7: Rin Test
-    logger.debug("Running Rin test")
-    rin_result = rin_test(rin)
+        # Validation 7: Rin Test
+        rin_result_future = pool.apply_async(
+            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 8: IV Test
+        iv_test_result_future = pool.apply_async(
+            iv_test,
+            (cell.template_params, rheobase, out_dir, spike_threshold_voltage)
+        )
+
+        # # Validation 9: FI Test
+        fi_test_result_future = pool.apply_async(
+            fi_test,
+            (cell.template_params, 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)
+        # Wait for all validations to complete
+        spiking_test_result = spiking_test_result_future.get()
+        depolarization_block_result = depolarization_block_result_future.get()
+        bpap_result = bpap_result_future.get()
+        ais_spiking_test_result = ais_spiking_test_result_future.get()
+        hyperpolarization_result = hyperpolarization_result_future.get()
+        rin_result = rin_result_future.get()
+        iv_test_result = iv_test_result_future.get()
+        fi_test_result = fi_test_result_future.get()
 
     return {
         "memodel_properties": {
-            "holding_current": float(holding_current),
-            "rheobase": float(rheobase),
-            "rin": float(rin),
+            "holding_current": holding_current,
+            "rheobase": rheobase,
+            "rin": rin,
         },
         "spiking_test": spiking_test_result,
         "depolarization_block_test": depolarization_block_result,
+        "bpap_test": bpap_result,
         "ais_spiking_test": ais_spiking_test_result,
         "hyperpolarization_test": hyperpolarization_result,
         "rin_test": rin_result,

{bluecellulab-2.6.49.dist-info → bluecellulab-2.6.51.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bluecellulab
-Version: 2.6.49
+Version: 2.6.51
 Summary: Biologically detailed neural network simulations and analysis.
 Author: Blue Brain Project, EPFL
 License: Apache2.0
@@ -27,6 +27,7 @@ Requires-Dist: pydantic<3.0.0,>=2.5.2
 Requires-Dist: typing-extensions>=4.8.0
 Requires-Dist: networkx>=3.1
 Requires-Dist: h5py>=3.8.0
+Requires-Dist: seaborn
 Dynamic: license-file
 
 |banner|

{bluecellulab-2.6.49.dist-info → bluecellulab-2.6.51.dist-info}/RECORD

@@ -12,12 +12,13 @@ bluecellulab/psegment.py,sha256=PTgoGLqM4oFIdF_8QHFQCU59j-8TQmtq6PakiGUQhIo,3138
 bluecellulab/rngsettings.py,sha256=2Ykb4Ylk3XTs58x1UIxjg8XJqjSpnCgKRZ8avXCDpxk,4237
 bluecellulab/tools.py,sha256=hF1HJcera0oggetsfN5PNTRYCpFS0sQiZlVxw4jRd1g,17968
 bluecellulab/type_aliases.py,sha256=DvgjERv2Ztdw_sW63JrZTQGpJ0x5uMTFB5hcBHDb0WA,441
-bluecellulab/utils.py,sha256=SbOOkzw1YGjCKV3qOw0zpabNEy7V9BRtgMLsQJiFRq4,1526
+bluecellulab/utils.py,sha256=0NhwlzyLnSi8kziSfDsQf7pokO4qDkMJVAO33kSX4O0,2227
 bluecellulab/verbosity.py,sha256=T0IgX7DrRo19faxrT4Xzb27gqxzoILQ8FzYKxvUeaPM,1342
 bluecellulab/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bluecellulab/analysis/analysis.py,sha256=3gDJRau5SL6wOhAUJ16vqP7aYLtoAZ7f1qZbSUVoUU8,10818
+bluecellulab/analysis/analysis.py,sha256=53g6SW_9ZbG3fbhuXJqurAPRR4VG1jsZYK6efq-EwfA,21229
 bluecellulab/analysis/inject_sequence.py,sha256=uU6Q6y0ErMDDEgdsTZBXCJ4LgwkATY7G8Fa6mmjpL98,12523
 bluecellulab/analysis/plotting.py,sha256=PqRoaZz33ULMw8A9YnZXXrxcUd84M_dwlYMTFhG7YT4,3999
+bluecellulab/analysis/utils.py,sha256=eMirP557D11BuedgSqjripDxOq1haIldNbnYNetV1bg,121
 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
@@ -41,7 +42,7 @@ bluecellulab/circuit/simulation_access.py,sha256=keME58gzLVAPEg2nnWD_bwEm9V2Kjeq
 bluecellulab/circuit/synapse_properties.py,sha256=TvUMiXZAAeYo1zKkus3z1EUvrE9QCIQ3Ze-jSnPSJWY,6374
 bluecellulab/circuit/validate.py,sha256=wntnr7oIDyasqD1nM-kqz1NpfWDxBGhx0Ep3e5hHXIw,3593
 bluecellulab/circuit/circuit_access/__init__.py,sha256=sgp6m5kP-pq60V1IFGUiSUR1OW01zdxXNNUJmPA8anI,201
-bluecellulab/circuit/circuit_access/bluepy_circuit_access.py,sha256=aXvtZR8EwpVEkB4KAupjC4DX_1xYC4OrHwMUQcQIWrQ,14273
+bluecellulab/circuit/circuit_access/bluepy_circuit_access.py,sha256=m5PWSYrrkORb55HN1ZgJpQFLeSHxsNBtzyJ1n0zuVro,14295
 bluecellulab/circuit/circuit_access/definition.py,sha256=_sUU0DkesGOFW82kS1G9vki0o0aQP76z3Ltk7Vo9KK4,4435
 bluecellulab/circuit/circuit_access/sonata_circuit_access.py,sha256=tADHxVZw4VgZAz2z4NKMUwc0rd_EO40EZggw5fDhnF4,10411
 bluecellulab/circuit/config/__init__.py,sha256=aaoJXRKBJzpxxREo9NxKc-_CCPmVeuR1mcViRXcLrC4,215
@@ -65,10 +66,10 @@ bluecellulab/stimulus/stimulus.py,sha256=a_hKJUtZmIgjiFjbJf6RzUPokELqn0IHCgIWGw5
 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/validation/validation.py,sha256=irP617pC2fdT_wJafaedkSTDHJ-5I2Badml5jj_b-OI,13141
-bluecellulab-2.6.49.dist-info/licenses/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
-bluecellulab-2.6.49.dist-info/licenses/LICENSE,sha256=dAMAR2Sud4Nead1wGFleKiwTZfkTNZbzmuGfcTKb3kg,11335
-bluecellulab-2.6.49.dist-info/METADATA,sha256=btGOUwph6uJAQSrUhhatlF7JHau3kt4UnyMSjyTyuCk,8236
-bluecellulab-2.6.49.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-bluecellulab-2.6.49.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
-bluecellulab-2.6.49.dist-info/RECORD,,
+bluecellulab/validation/validation.py,sha256=EN9HMty70VPwnEPhWUmN5F-MGWbMN3uU0DmNnjL0ucw,18209
+bluecellulab-2.6.51.dist-info/licenses/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
+bluecellulab-2.6.51.dist-info/licenses/LICENSE,sha256=dAMAR2Sud4Nead1wGFleKiwTZfkTNZbzmuGfcTKb3kg,11335
+bluecellulab-2.6.51.dist-info/METADATA,sha256=uWxsjFCkKomqMrGyVsZuhcUdDHi32Swj5sASJ4faKJE,8259
+bluecellulab-2.6.51.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bluecellulab-2.6.51.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
+bluecellulab-2.6.51.dist-info/RECORD,,

{bluecellulab-2.6.49.dist-info → bluecellulab-2.6.51.dist-info}/WHEEL

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