bluecellulab 2.6.50__tar.gz → 2.6.51__tar.gz

{bluecellulab-2.6.50 → bluecellulab-2.6.51}/PKG-INFO

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

{bluecellulab-2.6.50 → bluecellulab-2.6.51}/bluecellulab/analysis/analysis.py

@@ -4,14 +4,17 @@ try:
 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
@@ -87,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]
         }
@@ -194,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,

{bluecellulab-2.6.50 → bluecellulab-2.6.51}/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-2.6.50 → bluecellulab-2.6.51}/bluecellulab/validation/validation.py

@@ -24,6 +24,7 @@ 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
@@ -79,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,
@@ -111,13 +112,13 @@ def spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
     }
 
 
-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,
@@ -151,16 +152,16 @@ def depolarization_block_test(cell, rheobase, out_dir):
     }
 
 
-def bpap_test(cell, rheobase, out_dir="./"):
+def bpap_test(template_params, rheobase, out_dir="./"):
     """Back-propagating action potential test: exponential fit should decay.
 
     Args:
-        cell (Cell): The cell to test.
+        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)
+    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)
@@ -190,11 +191,11 @@ def bpap_test(cell, rheobase, out_dir="./"):
     }
 
 
-def ais_spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
+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 {
             "name": name,
             "passed": True,
@@ -206,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,
@@ -259,14 +260,14 @@ def ais_spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
     }
 
 
-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,
@@ -331,11 +332,11 @@ def rin_test(rin):
     }
 
 
-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,
@@ -369,11 +370,11 @@ def iv_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
     }
 
 
-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,
@@ -421,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:
@@ -437,41 +437,69 @@ 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")
-    bpap_result = bpap_test(cell, rheobase, out_dir)
+        # 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")
-    # We have to wait for ProbAMPANMDA_EMS to be present in entitycore to implement this 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
+        iv_test_result_future = pool.apply_async(
+            iv_test,
+            (cell.template_params, rheobase, out_dir, spike_threshold_voltage)
+        )
 
-    # # 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
+        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": {

{bluecellulab-2.6.50 → bluecellulab-2.6.51}/bluecellulab.egg-info/PKG-INFO

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