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

bluecellulab/__init__.py

@@ -7,7 +7,7 @@ try:
 except ImportError:
     BLUEPY_AVAILABLE = False
 
-from .importer import *  # NOQA
+from bluecellulab.importer import import_hoc
 from .verbosity import *
 from .cell import Cell, create_ball_stick  # NOQA
 from .circuit import EmodelProperties
@@ -19,7 +19,7 @@ from .psegment import PSegment  # NOQA
 from .simulation import Simulation  # NOQA
 from .rngsettings import RNGSettings  # NOQA
 from .circuit_simulation import CircuitSimulation, CircuitSimulation  # NOQA
-
+import neuron
 
 from .simulation.neuron_globals import NeuronGlobals
 

bluecellulab/analysis/inject_sequence.py

@@ -7,9 +7,9 @@ import neuron
 import numpy as np
 from bluecellulab.cell.core import Cell
 from bluecellulab.cell.template import TemplateParams
+from bluecellulab.simulation.parallel import IsolatedProcess
 from bluecellulab.simulation.simulation import Simulation
 from bluecellulab.stimulus.factory import Stimulus, StimulusFactory
-from bluecellulab.utils import IsolatedProcess
 
 
 class StimulusName(Enum):
@@ -35,7 +35,6 @@ def run_stimulus(
     stimulus: Stimulus,
     section: str,
     segment: float,
-    duration: float,
 ) -> Recording:
     """Creates a cell and stimulates it with a given stimulus.
 
@@ -44,7 +43,6 @@ def run_stimulus(
         stimulus: The input stimulus to inject into the cell.
         section: Name of the section of cell where the stimulus is to be injected.
         segment: The segment of the section where the stimulus is to be injected.
-        duration: The duration for which the simulation is to be run.
 
     Returns:
         The voltage-time recording at the specified location.
@@ -61,7 +59,7 @@ def run_stimulus(
     current_vector = neuron.h.Vector()
     current_vector.record(iclamp._ref_i)
     simulation = Simulation(cell)
-    simulation.run(duration)
+    simulation.run(stimulus.stimulus_time)
     current = np.array(current_vector.to_python())
     voltage = cell.get_voltage_recording(neuron_section, segment)
     time = cell.get_time()
@@ -74,7 +72,6 @@ def apply_multiple_step_stimuli(
     cell: Cell,
     stimulus_name: StimulusName,
     amplitudes: Sequence[float],
-    duration: float,
     section_name: str | None = None,
     segment: float = 0.5,
     n_processes: int | None = None,
@@ -85,7 +82,6 @@ def apply_multiple_step_stimuli(
         cell: The cell to which the stimuli are applied.
         stimulus_name: The name of the stimulus to apply.
         amplitudes: The amplitudes of the stimuli to apply.
-        duration: The duration for which each stimulus is applied.
         section_name: Section name of the cell where the stimuli are applied.
           If None, the stimuli are applied at the soma[0] of the cell.
         segment: The segment of the section where the stimuli are applied.
@@ -116,7 +112,7 @@ def apply_multiple_step_stimuli(
         else:
             raise ValueError("Unknown stimulus name.")
 
-        task_args.append((cell.template_params, stimulus, section_name, segment, duration))
+        task_args.append((cell.template_params, stimulus, section_name, segment))
 
     with IsolatedProcess(processes=n_processes) as pool:
         # Map expects a function and a list of argument tuples

bluecellulab/circuit/circuit_access/bluepy_circuit_access.py

@@ -19,8 +19,9 @@ import os
 from pathlib import Path
 from typing import Optional
 
+import neuron
 import pandas as pd
-from bluecellulab import circuit, neuron
+from bluecellulab import circuit
 from bluecellulab.circuit.circuit_access import EmodelProperties
 from bluecellulab.circuit.config import BluepySimulationConfig
 from bluecellulab.circuit.config.definition import SimulationConfig

bluecellulab/circuit/circuit_access/sonata_circuit_access.py

@@ -22,8 +22,9 @@ from bluepysnap.bbp import Cell as SnapCell
 from bluepysnap.circuit_ids import CircuitNodeId, CircuitEdgeIds
 from bluepysnap.exceptions import BluepySnapError
 from bluepysnap import Circuit as SnapCircuit
+import neuron
 import pandas as pd
-from bluecellulab import circuit, neuron
+from bluecellulab import circuit
 from bluecellulab.circuit.circuit_access.definition import EmodelProperties
 from bluecellulab.circuit import CellId, SynapseProperty
 from bluecellulab.circuit.config import SimulationConfig

bluecellulab/simulation/neuron_globals.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Module that handles the global NEURON parameters."""
 
+from typing import NamedTuple
 import neuron
 from bluecellulab.circuit.config.sections import Conditions, MechanismConditions
 from bluecellulab.exceptions import error_context
@@ -62,6 +63,11 @@ def set_minis_single_vesicle_values(mech_conditions: MechanismConditions) -> Non
             )
 
 
+class NeuronGlobalParams(NamedTuple):
+    temperature: float
+    v_init: float
+
+
 class NeuronGlobals:
     _instance = None
 
@@ -96,3 +102,10 @@ class NeuronGlobals:
     def v_init(self, value):
         self._v_init = value
         neuron.h.v_init = value
+
+    def export_params(self) -> NeuronGlobalParams:
+        return NeuronGlobalParams(self.temperature, self.v_init)
+
+    def load_params(self, params: NeuronGlobalParams) -> None:
+        self.temperature = params.temperature
+        self.v_init = params.v_init

bluecellulab/simulation/parallel.py

@@ -0,0 +1,36 @@
+"""Controlled simulations in parallel."""
+
+from __future__ import annotations
+from multiprocessing.pool import Pool
+from bluecellulab.simulation.neuron_globals import NeuronGlobals
+
+
+class IsolatedProcess(Pool):
+    """Multiprocessing Pool that restricts a worker to run max 1 process.
+
+    Use this when running isolated NEURON simulations. Running 2 NEURON
+    simulations on a single process is to be avoided. Required global
+    NEURON simulation parameters will automatically be passed to each
+    worker.
+    """
+
+    def __init__(self, processes: int | None = 1):
+        """Initialize the IsolatedProcess pool.
+
+        Args:
+            processes: The number of processes to use for running the simulations.
+                       If set to None, then the number returned by os.cpu_count() is used.
+        """
+        neuron_global_params = NeuronGlobals.get_instance().export_params()
+        super().__init__(
+            processes=processes,
+            initializer=self.init_worker,
+            initargs=(neuron_global_params,),
+            maxtasksperchild=1,
+        )
+
+    @staticmethod
+    def init_worker(neuron_global_params):
+        """Load global parameters for the NEURON environment in each worker
+        process."""
+        NeuronGlobals.get_instance().load_params(neuron_global_params)

bluecellulab/stimulus/factory.py

@@ -39,38 +39,38 @@ class Stimulus(ABC):
         ax.set_title(self.__class__.__name__)
         return ax
 
-    def plot_during_simulation(self, duration: float, ax=None, **kwargs):
-        if ax is None:
-            ax = plt.gca()
-        # Create an array for the entire duration
-        full_time = np.arange(0, duration, self.dt)
-        full_current = np.zeros_like(full_time)
-
-        # Replace the corresponding values with self.time and self.current
-        indices = (self.time / self.dt).astype(int)
-        full_current[indices] = self.current
-
-        ax.plot(full_time, full_current, **kwargs)
-        ax.set_xlabel("Time (ms)")
-        ax.set_ylabel("Current (nA)")
-        ax.set_title(self.__class__.__name__)
-        ax.set_xlim(0, duration)
-        return ax
-
     def __add__(self, other: Stimulus) -> CombinedStimulus:
         """Override + operator to concatenate Stimulus objects."""
         if self.dt != other.dt:
-            raise ValueError("Stimulus objects must have the same dt to be concatenated")
-        # shift other time
-        other_time = other.time + self.time[-1] + self.dt
-        combined_time = np.concatenate([self.time, other_time])
-        # Concatenate the current arrays
-        combined_current = np.concatenate([self.current, other.current])
-        return CombinedStimulus(self.dt, combined_time, combined_current)
+            raise ValueError(
+                "Stimulus objects must have the same dt to be concatenated"
+            )
+        if len(self.time) == 0:
+            return CombinedStimulus(other.dt, other.time, other.current)
+        elif len(other.time) == 0:
+            return CombinedStimulus(self.dt, self.time, self.current)
+        else:
+            # shift other time
+            other_time = other.time + self.time[-1] + self.dt
+            combined_time = np.concatenate([self.time, other_time])
+            # Concatenate the current arrays
+            combined_current = np.concatenate([self.current, other.current])
+            return CombinedStimulus(self.dt, combined_time, combined_current)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Stimulus):
+            return NotImplemented
+        else:
+            return (
+                np.allclose(self.time, other.time)
+                and np.allclose(self.current, other.current)
+                and self.dt == other.dt
+            )
 
 
 class CombinedStimulus(Stimulus):
     """Represents the Stimulus created by combining multiple stimuli."""
+
     def __init__(self, dt: float, time: np.ndarray, current: np.ndarray) -> None:
         super().__init__(dt)
         self._time = time
@@ -85,11 +85,12 @@ class CombinedStimulus(Stimulus):
         return self._current
 
 
-class EmptyStimulus(Stimulus):
+class Empty(Stimulus):
     """Represents empty stimulus (all zeros) that has no impact on the cell.
 
     This is required by some Stimuli that expect the cell to rest.
     """
+
     def __init__(self, dt: float, duration: float) -> None:
         super().__init__(dt)
         self.duration = duration
@@ -103,152 +104,286 @@ class EmptyStimulus(Stimulus):
         return np.zeros_like(self.time)
 
 
-class Step(Stimulus):
-    def __init__(self, dt: float, start: float, end: float, amplitude: float) -> None:
+class Flat(Stimulus):
+    def __init__(self, dt: float, duration: float, amplitude: float) -> None:
         super().__init__(dt)
-        self.start = start
-        self.end = end
+        self.duration = duration
         self.amplitude = amplitude
 
-    @classmethod
-    def threshold_based(
-        cls,
-        dt: float,
-        threshold_current: float,
-        threshold_percentage: float,
-        start: float,
-        end: float,
-        post_wait: float,
-    ) -> CombinedStimulus:
-        amplitude = threshold_current * threshold_percentage / 100
-        res = cls(dt, start, end, amplitude) + EmptyStimulus(dt, duration=post_wait)
-        return res
-
     @property
     def time(self) -> np.ndarray:
-        return np.arange(self.start, self.end, self.dt)
+        return np.arange(0.0, self.duration, self.dt)
 
     @property
     def current(self) -> np.ndarray:
         return np.full_like(self.time, self.amplitude)
 
 
-class Ramp(Stimulus):
+class Slope(Stimulus):
     def __init__(
-        self,
-        dt: float,
-        start: float,
-        end: float,
-        amplitude_start: float,
-        amplitude_end: float,
+        self, dt: float, duration: float, amplitude_start: float, amplitude_end: float
     ) -> None:
         super().__init__(dt)
-        self.start = start
-        self.end = end
+        self.duration = duration
         self.amplitude_start = amplitude_start
         self.amplitude_end = amplitude_end
 
     @property
     def time(self) -> np.ndarray:
-        return np.arange(self.start, self.end, self.dt)
+        return np.arange(0.0, self.duration, self.dt)
 
     @property
     def current(self) -> np.ndarray:
         return np.linspace(self.amplitude_start, self.amplitude_end, len(self.time))
 
 
+class Step(Stimulus):
+
+    def __init__(self):
+        raise NotImplementedError(
+            "This class cannot be instantiated directly. "
+            "Please use the class methods 'amplitude_based' "
+            "or 'threshold_based' to create objects."
+        )
+
+    @classmethod
+    def amplitude_based(
+        cls,
+        dt: float,
+        pre_delay: float,
+        duration: float,
+        post_delay: float,
+        amplitude: float,
+    ) -> CombinedStimulus:
+        """Create a Step stimulus from given time events and amplitude.
+
+        Args:
+            dt: The time step of the stimulus.
+            pre_delay: The delay before the start of the step.
+            duration: The duration of the step.
+            post_delay: The time to wait after the end of the step.
+            amplitude: The amplitude of the step.
+        """
+        return (
+            Empty(dt, duration=pre_delay)
+            + Flat(dt, duration=duration, amplitude=amplitude)
+            + Empty(dt, duration=post_delay)
+        )
+
+    @classmethod
+    def threshold_based(
+        cls,
+        dt: float,
+        pre_delay: float,
+        duration: float,
+        post_delay: float,
+        threshold_current: float,
+        threshold_percentage: float,
+    ) -> CombinedStimulus:
+        """Creates a Step stimulus with respect to the threshold current.
+
+        Args:
+
+            dt: The time step of the stimulus.
+            pre_delay: The delay before the start of the step.
+            duration: The duration of the step.
+            post_delay: The time to wait after the end of the step.
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+        """
+        amplitude = threshold_current * threshold_percentage / 100
+        res = cls.amplitude_based(
+            dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            amplitude=amplitude,
+        )
+        return res
+
+
+class Ramp(Stimulus):
+
+    def __init__(self):
+        raise NotImplementedError(
+            "This class cannot be instantiated directly. "
+            "Please use the class methods 'amplitude_based' "
+            "or 'threshold_based' to create objects."
+        )
+
+    @classmethod
+    def amplitude_based(
+        cls,
+        dt: float,
+        pre_delay: float,
+        duration: float,
+        post_delay: float,
+        amplitude: float,
+    ) -> CombinedStimulus:
+        """Create a Ramp stimulus from given time events and amplitudes.
+
+        Args:
+            dt: The time step of the stimulus.
+            pre_delay: The delay before the start of the ramp.
+            duration: The duration of the ramp.
+            post_delay: The time to wait after the end of the ramp.
+            amplitude: The final amplitude of the ramp.
+        """
+        return (
+            Empty(dt, duration=pre_delay)
+            + Slope(
+                dt,
+                duration=duration,
+                amplitude_start=0.0,
+                amplitude_end=amplitude,
+            )
+            + Empty(dt, duration=post_delay)
+        )
+
+    @classmethod
+    def threshold_based(
+        cls,
+        dt: float,
+        pre_delay: float,
+        duration: float,
+        post_delay: float,
+        threshold_current: float,
+        threshold_percentage: float,
+    ) -> CombinedStimulus:
+        """Creates a Ramp stimulus with respect to the threshold current.
+
+        Args:
+
+            dt: The time step of the stimulus.
+            pre_delay: The delay before the start of the ramp.
+            duration: The duration of the ramp.
+            post_delay: The time to wait after the end of the ramp.
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+        """
+        amplitude = threshold_current * threshold_percentage / 100
+        res = cls.amplitude_based(
+            dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            amplitude=amplitude,
+        )
+        return res
+
+
 class StimulusFactory:
     def __init__(self, dt: float):
         self.dt = dt
 
-    def step(self, start: float, end: float, amplitude: float) -> Stimulus:
-        return Step(self.dt, start, end, amplitude)
+    def step(
+        self, pre_delay: float, duration: float, post_delay: float, amplitude: float
+    ) -> Stimulus:
+        return Step.amplitude_based(
+            self.dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            amplitude=amplitude,
+        )
 
     def ramp(
-        self, start: float, end: float, amplitude_start: float, amplitude_end: float
+        self, pre_delay: float, duration: float, post_delay: float, amplitude: float
     ) -> Stimulus:
-        return Ramp(self.dt, start, end, amplitude_start, amplitude_end)
+        return Ramp.amplitude_based(
+            self.dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            amplitude=amplitude,
+        )
 
     def ap_waveform(
-        self,
-        threshold_current: float,
-        threshold_percentage: float = 220.0,
-        start: float = 250.0,
-        end: float = 300.0,
-        post_wait: float = 250.0,
+        self, threshold_current: float, threshold_percentage: float = 220.0
     ) -> Stimulus:
         """Returns the APWaveform Stimulus object, a type of Step stimulus.
 
         Args:
             threshold_current: The threshold current of the Cell.
             threshold_percentage: Percentage of desired threshold_current amplification.
-            start: The start time of the step.
-            end: The end time of the step.
-            post_wait: The time to wait after the end of the step.
         """
+        pre_delay = 250.0
+        duration = 50.0
+        post_delay = 250.0
         return Step.threshold_based(
-            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+            self.dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            threshold_current=threshold_current,
+            threshold_percentage=threshold_percentage,
         )
 
     def idrest(
         self,
         threshold_current: float,
         threshold_percentage: float = 200.0,
-        start: float = 250.0,
-        end: float = 1600.0,
-        post_wait: float = 250.0,
     ) -> Stimulus:
         """Returns the IDRest Stimulus object, a type of Step stimulus.
 
         Args:
             threshold_current: The threshold current of the Cell.
             threshold_percentage: Percentage of desired threshold_current amplification.
-            start: The start time of the step.
-            end: The end time of the step.
-            post_wait: The time to wait after the end of the step.
         """
+        pre_delay = 250.0
+        duration = 1350.0
+        post_delay = 250.0
         return Step.threshold_based(
-            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+            self.dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            threshold_current=threshold_current,
+            threshold_percentage=threshold_percentage,
         )
 
     def iv(
         self,
         threshold_current: float,
         threshold_percentage: float = -40.0,
-        start: float = 250.0,
-        end: float = 3250.0,
-        post_wait: float = 250.0,
     ) -> Stimulus:
         """Returns the IV Stimulus object, a type of Step stimulus.
 
         Args:
             threshold_current: The threshold current of the Cell.
             threshold_percentage: Percentage of desired threshold_current amplification.
-            start: The start time of the step.
-            end: The end time of the step.
-            post_wait: The time to wait after the end of the step.
         """
+        pre_delay = 250.0
+        duration = 3000.0
+        post_delay = 250.0
         return Step.threshold_based(
-            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+            self.dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            threshold_current=threshold_current,
+            threshold_percentage=threshold_percentage,
         )
 
     def fire_pattern(
         self,
         threshold_current: float,
         threshold_percentage: float = 200.0,
-        start: float = 250.0,
-        end: float = 3850.0,
-        post_wait: float = 250.0,
     ) -> Stimulus:
         """Returns the FirePattern Stimulus object, a type of Step stimulus.
 
         Args:
             threshold_current: The threshold current of the Cell.
             threshold_percentage: Percentage of desired threshold_current amplification.
-            start: The start time of the step.
-            end: The end time of the step.
-            post_wait: The time to wait after the end of the step.
         """
+        pre_delay = 250.0
+        duration = 3600.0
+        post_delay = 250.0
         return Step.threshold_based(
-            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+            self.dt,
+            pre_delay=pre_delay,
+            duration=duration,
+            post_delay=post_delay,
+            threshold_current=threshold_current,
+            threshold_percentage=threshold_percentage,
         )

bluecellulab/tools.py

@@ -25,7 +25,8 @@ import numpy as np
 import bluecellulab
 from bluecellulab.circuit.circuit_access import EmodelProperties
 from bluecellulab.exceptions import UnsteadyCellError
-from bluecellulab.utils import CaptureOutput, IsolatedProcess
+from bluecellulab.simulation.parallel import IsolatedProcess
+from bluecellulab.utils import CaptureOutput
 
 logger = logging.getLogger(__name__)
 

bluecellulab/utils.py

@@ -1,19 +1,21 @@
 """Utility functions used within BlueCellulab."""
+
 from __future__ import annotations
 import contextlib
 import io
 import json
-from multiprocessing.pool import Pool
 
 import numpy as np
 
 
 def run_once(func):
     """A decorator to ensure a function is only called once."""
+
     def wrapper(*args, **kwargs):
         if not wrapper.has_run:
             wrapper.has_run = True
             return func(*args, **kwargs)
+
     wrapper.has_run = False
     return wrapper
 
@@ -32,29 +34,25 @@ class CaptureOutput(list):
 
 class NumpyEncoder(json.JSONEncoder):
     def default(self, obj):
-        if isinstance(obj, (np.int_, np.intc, np.intp, np.int8,
-                            np.int16, np.int32, np.int64, np.uint8,
-                            np.uint16, np.uint32, np.uint64)):
+        if isinstance(
+            obj,
+            (
+                np.int_,
+                np.intc,
+                np.intp,
+                np.int8,
+                np.int16,
+                np.int32,
+                np.int64,
+                np.uint8,
+                np.uint16,
+                np.uint32,
+                np.uint64,
+            ),
+        ):
             return int(obj)
-        elif isinstance(obj, (np.float_, np.float16, np.float32,
-                              np.float64)):
+        elif isinstance(obj, (np.float_, np.float16, np.float32, np.float64)):
             return float(obj)
         elif isinstance(obj, np.ndarray):
             return obj.tolist()
         return json.JSONEncoder.default(self, obj)
-
-
-class IsolatedProcess(Pool):
-    """Multiprocessing Pool that restricts a worker to run max 1 process.
-
-    Use this when running isolated NEURON simulations. Running 2 NEURON
-    simulations on a single process is to be avoided.
-    """
-    def __init__(self, processes: int | None = 1):
-        """Initialize the IsolatedProcess pool.
-
-        Args:
-            processes: The number of processes to use for running the stimuli.
-            If set to None, then the number returned by os.cpu_count() is used.
-        """
-        super().__init__(processes=processes, maxtasksperchild=1)

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

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

{bluecellulab-2.5.10.dist-info → bluecellulab-2.6.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-bluecellulab/__init__.py,sha256=-DopR1_1ji4NQlsRi4fLSUETM358o6UCdJtnhQ8wrQA,873
+bluecellulab/__init__.py,sha256=JvigOm_7WDjVAodm4R_TyRzj7vd9hmEbvLJDUVtgeqo,899
 bluecellulab/circuit_simulation.py,sha256=GLy_O5onhiSa-RajorDHlgP1rkFxjUONB4G6B4upyg0,33672
 bluecellulab/connection.py,sha256=volV2YKtmqAF7MOEJar5ldF1ARAo7k2vF9MB1NXybUY,4640
 bluecellulab/dendrogram.py,sha256=w0vvv0Q169DolTX1j9dAZIvHIl4H258gAjQ1xQaNiGk,6427
@@ -10,12 +10,12 @@ bluecellulab/plotwindow.py,sha256=UVHzml-BB83m5Qr-YGkjR9kB-vSW8mM0Owh2j95yIaU,27
 bluecellulab/psection.py,sha256=SYI2mGUIp8UiuMkyp9ITChHVLbJ0fDsEmen1pAbgNJQ,6174
 bluecellulab/psegment.py,sha256=02DkvazPGjnwjfjn1K8CZqdcVWnUhYpgrjqjoHNz6jM,3133
 bluecellulab/rngsettings.py,sha256=Dlt34dc4AoWyxCCzUK3Jlui90VCK20xHg6gD_OJzPIw,4237
-bluecellulab/tools.py,sha256=JrAfMVozfucwcyGklweMvEM7uGnTnWIDmk4eqI-43Es,11169
+bluecellulab/tools.py,sha256=Bg6F0allDJrQrvxfvPdMdFe47a_CF7Q-KmF2TWNDE44,11213
 bluecellulab/type_aliases.py,sha256=DvgjERv2Ztdw_sW63JrZTQGpJ0x5uMTFB5hcBHDb0WA,441
-bluecellulab/utils.py,sha256=fgqjgy3xzyL0zu-qjCPJdHp6PEAHADCzlr2FqyBmzHI,2012
+bluecellulab/utils.py,sha256=SbOOkzw1YGjCKV3qOw0zpabNEy7V9BRtgMLsQJiFRq4,1526
 bluecellulab/verbosity.py,sha256=T0IgX7DrRo19faxrT4Xzb27gqxzoILQ8FzYKxvUeaPM,1342
 bluecellulab/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bluecellulab/analysis/inject_sequence.py,sha256=jfEESRAUKAWgjceNWfx3Rwe1gDNWhxwZL4PfnJZCzrg,4930
+bluecellulab/analysis/inject_sequence.py,sha256=qr3N1tQX4avvKzFBT0L7W6LnSgk2y_P_7Yhy0UjlGmk,4769
 bluecellulab/cell/__init__.py,sha256=Sbc0QOsJ8E7tSwf3q7fsXuE_SevBN6ZmoCVyyU5zfII,208
 bluecellulab/cell/cell_dict.py,sha256=PVmZsjhZ9jp3HC-8QmdFqp-crAcVMSVeLWujcOPLlpo,1346
 bluecellulab/cell/core.py,sha256=MtrVQAxT82dc9uQuWZyTQfc6Oczrnc_y_9hcyBqUT7w,31467
@@ -39,9 +39,9 @@ bluecellulab/circuit/simulation_access.py,sha256=QHVEN-sEZbCCvblhBHEShGX0-NEXCD1
 bluecellulab/circuit/synapse_properties.py,sha256=6PpMWeothomR2c-mx63yVIISJc4eSL9xMnaIM2nryNM,5494
 bluecellulab/circuit/validate.py,sha256=7EUN15u0JFFlLf389jUBqLwDOHyZdfKtoidI-xLUVYA,3593
 bluecellulab/circuit/circuit_access/__init__.py,sha256=sgp6m5kP-pq60V1IFGUiSUR1OW01zdxXNNUJmPA8anI,201
-bluecellulab/circuit/circuit_access/bluepy_circuit_access.py,sha256=msAbAKH7XEPn77lTPA7-ntRiY-fCIxvLuA250gjo__Q,14681
+bluecellulab/circuit/circuit_access/bluepy_circuit_access.py,sha256=HxQaRTz1HaeOVV87fiptJBXRNWCitT-5YHn71WtSsLg,14687
 bluecellulab/circuit/circuit_access/definition.py,sha256=SnKBFEgdXFG-QexYRrGSzVAd7bSj7NwN0IuTsjDOrDY,4435
-bluecellulab/circuit/circuit_access/sonata_circuit_access.py,sha256=P1ElK_VA10_JyyKbAnqzuAlduEYE2c_NSec2TZuix1U,10345
+bluecellulab/circuit/circuit_access/sonata_circuit_access.py,sha256=c0MMJuoT6_dRW8O5HSRS5hHv1zDKdW0sBR-DaP0F1bk,10351
 bluecellulab/circuit/config/__init__.py,sha256=aaoJXRKBJzpxxREo9NxKc-_CCPmVeuR1mcViRXcLrC4,215
 bluecellulab/circuit/config/bluepy_simulation_config.py,sha256=tUyHvzlxFWRxh8rBNvU0FdUqGqJR2G8OXifATQ9W7yw,6974
 bluecellulab/circuit/config/definition.py,sha256=o0751Dd83f8TWGw95EAQ8coJrYGasdshrIrXViF5lzg,2774
@@ -53,17 +53,18 @@ bluecellulab/hoc/TDistFunc.hoc,sha256=WKX-anvL83xGuGPH9g1oIORB17UM4Pi3-iIXzKO-pU
 bluecellulab/hoc/TStim.hoc,sha256=noBJbM_ZqF6T6MEgBeowNzz21I9QeYZ5brGgUvCSm4k,8473
 bluecellulab/hoc/fileUtils.hoc,sha256=LSM7BgyjYVqo2DGSOKvg4W8IIusbsL45JVYK0vgwitU,2539
 bluecellulab/simulation/__init__.py,sha256=P2ebt0SFw-08J3ihN-LeRn95HeF79tzA-Q0ReLm32dM,214
-bluecellulab/simulation/neuron_globals.py,sha256=uxgceZ7zzbVEtITrQv8oOK900zhh7w29cScFwjLWo4I,4134
+bluecellulab/simulation/neuron_globals.py,sha256=_8xmJPQMfCyhVn6KppK7i3jaUZaALMLgyxyHMKi02yo,4508
+bluecellulab/simulation/parallel.py,sha256=xmlIelxYNct-vGhPip7_vF9gwyehdpomYB8kf9xV-S8,1314
 bluecellulab/simulation/simulation.py,sha256=I__cZwV_A8I7XSefn6aJDBA_jXCI3E35-pCNCLUsnvo,6206
 bluecellulab/stimulus/__init__.py,sha256=DgIgVaSyR-URf3JZzvO6j-tjCerzvktuK-ep8pjMRPQ,37
 bluecellulab/stimulus/circuit_stimulus_definitions.py,sha256=uij_s44uNdmMwMLGmTHSRgmp9K9B_vvHHshX6YPJNJU,15686
-bluecellulab/stimulus/factory.py,sha256=AOby3Sp2g8BJsRccz3afazfCyysyWIgLtcliWlyeiu0,8097
+bluecellulab/stimulus/factory.py,sha256=cjnMqFx-Y31kV1XHvkSbGI2f1OpEawU3Wg_cLqcIyRc,11883
 bluecellulab/synapse/__init__.py,sha256=RW8XoAMXOvK7OG1nHl_q8jSEKLj9ZN4oWf2nY9HAwuk,192
 bluecellulab/synapse/synapse_factory.py,sha256=YkvxbdGF-u-vxYdbRNTlX-9AtSC_3t_FQRFhybwzgrk,6805
 bluecellulab/synapse/synapse_types.py,sha256=4gne-hve2vq1Lau-LAVPsfLjffVYqAYBW3kCfC7_600,16871
-bluecellulab-2.5.10.dist-info/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
-bluecellulab-2.5.10.dist-info/LICENSE,sha256=xOouu1gC1GGklDxkITlaVl60I9Ab860O-nZsFbWydvU,11749
-bluecellulab-2.5.10.dist-info/METADATA,sha256=MEgGgaV3rXDUcTU5EntzGyw3GinZSWicJnC0cQuPrXo,7026
-bluecellulab-2.5.10.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-bluecellulab-2.5.10.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
-bluecellulab-2.5.10.dist-info/RECORD,,
+bluecellulab-2.6.0.dist-info/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
+bluecellulab-2.6.0.dist-info/LICENSE,sha256=xOouu1gC1GGklDxkITlaVl60I9Ab860O-nZsFbWydvU,11749
+bluecellulab-2.6.0.dist-info/METADATA,sha256=X-XmGZmXo-FZIe6H5r0qIs-VBJnTN0zNVOXNVuiLW0M,7025
+bluecellulab-2.6.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+bluecellulab-2.6.0.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
+bluecellulab-2.6.0.dist-info/RECORD,,