bluecellulab 2.4.0__py3-none-any.whl → 2.6.37__py3-none-any.whl

bluecellulab/importer.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -52,8 +52,8 @@ def import_mod_lib(neuron: ModuleType) -> str:
     return res
 
 
-def import_neurodamus(neuron: ModuleType) -> None:
-    """Import neurodamus."""
+def import_hoc(neuron: ModuleType) -> None:
+    """Import hoc dependencies."""
     neuron.h.load_file("stdrun.hoc")  # nrn
     hoc_files = [
         "Cell.hoc",  # ND
@@ -75,17 +75,15 @@ def print_header(neuron: ModuleType, mod_lib_path: str) -> None:
 
 
 @run_once
-def _load_hoc_and_mod_files() -> None:
+def _load_mod_files() -> None:
     """Import hoc and mod files."""
     logger.debug("Loading the mod files.")
     mod_lib_paths = import_mod_lib(neuron)
-    logger.debug("Loading the hoc files.")
-    import_neurodamus(neuron)
     print_header(neuron, mod_lib_paths)
 
 
-def load_hoc_and_mod_files(func):
+def load_mod_files(func):
     def wrapper(*args, **kwargs):
-        _load_hoc_and_mod_files()
+        _load_mod_files()
         return func(*args, **kwargs)
     return wrapper

bluecellulab/neuron_interpreter.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

bluecellulab/plotwindow.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

bluecellulab/psection.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,6 +13,7 @@
 # limitations under the License.
 """Represents a python version of NEURON Section (for drawing)."""
 from __future__ import annotations
+import re
 import neuron
 
 import bluecellulab
@@ -75,21 +76,6 @@ class PSection:
         self.pchildren: list[PSection] = []
         self.isec = isec
 
-        if 'apic' in self.name:
-            self.section_type = 'apical'
-        elif 'dend' in self.name:
-            self.section_type = 'basal'
-        elif 'soma' in self.name:
-            self.section_type = 'somatic'
-        elif 'axon' in self.name:
-            self.section_type = 'axonal'
-        elif 'myelin' in self.name:
-            self.section_type = 'myelin'
-        else:
-            raise Exception(
-                "PSection: Section of unknown type: %s" %
-                self.name)
-
         self.psegments: list[PSegment] = []
         self.maxsegdiam = 0.0
         for hsegment in hsection:
@@ -101,6 +87,15 @@ class PSection:
         self.xSpacing = 1.0
         self.ySpacing = 5.0
 
+    @property
+    def section_type(self) -> str:
+        """Return the type of the section."""
+        # From Cell[0].soma[0] -> soma
+        matches = re.findall(r'\.([^.\[\]]+)\[', self.name)
+        if matches:
+            return matches[-1]  # Return the last match
+        return 'unknown'  # Return 'unknown' if no matches are found
+
     @property
     def is_leaf(self) -> bool:
         """Return true if section is a leaf in the morphological structure."""

bluecellulab/psegment.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,7 +17,7 @@ import neuron
 
 from bluecellulab.neuron_interpreter import eval_neuron
 
-type_colormap = {'apical': 'm', 'basal': 'r', 'somatic': 'k', 'axonal': 'b', 'myelin': 'g'}
+type_colormap = {'apic': 'm', 'dend': 'r', 'soma': 'k', 'axon': 'b', 'myelin': 'g', 'unknown': 'c'}
 
 
 class PSegment:
@@ -25,7 +25,7 @@ class PSegment:
 
     def __init__(self, hsegment, parentsection):
         # import matplotlib as plt
-        from matplotlib import cm
+        from matplotlib import colormaps
 
         self.hsegment = hsegment
         self.parentsection = parentsection
@@ -35,7 +35,7 @@ class PSegment:
         self.figure = None
         self.figX = None
         self.figY = None
-        self.color_map = cm.get_cmap("hot")
+        self.color_map = colormaps["hot"]
         self.ax = None
         self.patch = None
         self.plotvariable = None

bluecellulab/rngsettings.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -20,7 +20,7 @@ from typing import Optional
 import neuron
 from bluecellulab.circuit.config.definition import SimulationConfig
 from bluecellulab.exceptions import UndefinedRNGException
-from bluecellulab.importer import load_hoc_and_mod_files
+from bluecellulab.importer import load_mod_files
 
 logger = logging.getLogger(__name__)
 
@@ -37,7 +37,7 @@ class RNGSettings:
             cls._instance = cls()
         return cls._instance
 
-    @load_hoc_and_mod_files
+    @load_mod_files
     def __init__(
         self,
         mode="Random123",
@@ -105,7 +105,7 @@ class RNGSettings:
         options = {"Compatibility": 0, "Random123": 1, "UpdatedMCell": 2}
         if new_val not in options:
             raise UndefinedRNGException(
-                "SSim: RNG mode %s not in accepted list: %s"
+                "RNG mode's value %s is not in the accepted list: %s"
                 % (self.mode, list(options.keys()))
             )
         else:

bluecellulab/simulation/__init__.py

@@ -3,4 +3,3 @@
 from .simulation import Simulation
 from .neuron_globals import set_global_condition_parameters
 from .neuron_globals import set_minis_single_vesicle_values
-from .neuron_globals import set_tstop_value

bluecellulab/simulation/neuron_globals.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -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,49 @@ def set_minis_single_vesicle_values(mech_conditions: MechanismConditions) -> Non
             )
 
 
-def set_tstop_value(tstop: float) -> None:
-    """Set the tstop value required by Tstim noise stimuli."""
-    neuron.h.tstop = tstop
+class NeuronGlobalParams(NamedTuple):
+    temperature: float
+    v_init: float
+
+
+class NeuronGlobals:
+    _instance = None
+
+    def __init__(self):
+        raise RuntimeError('Call get_instance() instead')
+
+    @classmethod
+    def get_instance(cls):
+        if cls._instance is None:
+            cls._instance = cls.__new__(cls)
+            # Initialize default values
+            cls._instance._temperature = 34.0  # Default temperature
+            cls._instance.v_init = neuron.h.v_init
+            # Set the default values in NEURON
+            neuron.h.celsius = cls._instance._temperature
+        return cls._instance
+
+    @property
+    def temperature(self):
+        return self._temperature
+
+    @temperature.setter
+    def temperature(self, value):
+        self._temperature = value
+        neuron.h.celsius = value
+
+    @property
+    def v_init(self):
+        return self._v_init
+
+    @v_init.setter
+    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,40 @@
+"""Controlled simulations in parallel."""
+
+from __future__ import annotations
+import multiprocessing
+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. `fork` mode of multiprocessing is used to pass any other
+    global NEURON parameters 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.
+        """
+        ctx = multiprocessing.get_context("fork")
+        neuron_global_params = NeuronGlobals.get_instance().export_params()
+        super().__init__(
+            processes=processes,
+            initializer=self.init_worker,
+            initargs=(neuron_global_params,),
+            maxtasksperchild=1,
+            context=ctx,
+        )
+
+    @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/simulation/simulation.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -28,13 +28,14 @@ logger = logging.getLogger(__name__)
 class Simulation:
     """Class that represents a neuron simulation."""
 
-    def __init__(self, parallel_context=None) -> None:
+    def __init__(self, parallel_context=None, custom_progress_function=None) -> None:
         self.cells: list[bluecellulab.Cell] = []
         self.fih_progress = None
         self.progress = None
         self.progress_closed = None
         self.progress_dt: Optional[float] = None
         self.pc = parallel_context
+        self.custom_progress_function = custom_progress_function
 
     def add_cell(self, new_cell: bluecellulab.Cell) -> None:
         """Add a cell to a simulation."""
@@ -50,26 +51,29 @@ class Simulation:
 
     def progress_callback(self):
         """Callback function for the progress bar."""
-        if self.progress > 0:
-            sys.stdout.write("\x1b[3F")
-
-        self.progress += 1
-        self.progress_closed = not self.progress_closed
-        if self.progress_closed:
-            sys.stdout.write(" %s%s%s \n" % (" " * (
-                self.progress - 1), " ", " " * (100 - self.progress)))
-            sys.stdout.write("[%s%s%s]\n" % ("#" * (
-                self.progress - 1), "-", "." * (100 - self.progress)))
-            sys.stdout.write(" %s%s%s \n" % (" " * (
-                self.progress - 1), " ", " " * (100 - self.progress)))
+        if self.custom_progress_function is None:
+            if self.progress > 0:
+                sys.stdout.write("\x1b[3F")
+
+            self.progress += 1
+            self.progress_closed = not self.progress_closed
+            if self.progress_closed:
+                sys.stdout.write(" %s%s%s \n" % (" " * (
+                    self.progress - 1), " ", " " * (100 - self.progress)))
+                sys.stdout.write("[%s%s%s]\n" % ("#" * (
+                    self.progress - 1), "-", "." * (100 - self.progress)))
+                sys.stdout.write(" %s%s%s \n" % (" " * (
+                    self.progress - 1), " ", " " * (100 - self.progress)))
+            else:
+                sys.stdout.write(" %s%s%s \n" % (" " * (
+                    self.progress - 1), "/", " " * (100 - self.progress)))
+                sys.stdout.write("[%s%s%s]\n" % ("#" * (
+                    self.progress - 1), ">", "." * (100 - self.progress)))
+                sys.stdout.write(" %s%s%s \n" % (" " * (
+                    self.progress - 1), "\\", " " * (100 - self.progress)))
+            sys.stdout.flush()
         else:
-            sys.stdout.write(" %s%s%s \n" % (" " * (
-                self.progress - 1), "/", " " * (100 - self.progress)))
-            sys.stdout.write("[%s%s%s]\n" % ("#" * (
-                self.progress - 1), ">", "." * (100 - self.progress)))
-            sys.stdout.write(" %s%s%s \n" % (" " * (
-                self.progress - 1), "\\", " " * (100 - self.progress)))
-        sys.stdout.flush()
+            self.custom_progress_function()
 
         neuron.h.cvode.event(
             neuron.h.t + self.progress_dt, self.progress_callback)
@@ -88,13 +92,11 @@ class Simulation:
             cvode=True,
             cvode_minstep=None,
             cvode_maxstep=None,
-            celsius=34,
-            v_init=-65,
             dt=0.025,
             forward_skip=None,
             forward_skip_value=False,
-            show_progress=None,
-            use_random123_stochkv=False):
+            show_progress=None
+    ):
         """Run the simulation."""
         # if maxtime <= neuron.h.t:
         #     raise Exception("Simulation: need to provide a maxtime (=%f) "
@@ -108,7 +110,6 @@ class Simulation:
             self.progress_dt = maxtime / 100
             self.init_progress_callback()
 
-        neuron.h.celsius = celsius
         neuron.h.tstop = maxtime
 
         cvode_old_status = neuron.h.cvode_active()
@@ -125,11 +126,9 @@ class Simulation:
                                "was set")
             neuron.h.cvode_active(0)
 
-        neuron.h.v_init = v_init
-
         for cell in self.cells:
             with contextlib.suppress(AttributeError):
-                cell.re_init_rng(use_random123_stochkv=use_random123_stochkv)
+                cell.re_init_rng()
         neuron.h.dt = dt
         neuron.h.steps_per_ms = 1.0 / dt
 
@@ -176,6 +175,3 @@ class Simulation:
             neuron.h.cvode_active(cvode_old_status)
 
         logger.debug("Finished simulation.")
-
-    def __del__(self):
-        pass

bluecellulab/stimulus/circuit_stimulus_definitions.py

@@ -1,4 +1,4 @@
-# Copyright 2012-2024 Blue Brain Project / EPFL
+# Copyright 2023-2024 Blue Brain Project / EPFL
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -170,7 +170,7 @@ class Stimulus:
                 decay_time=stimulus_entry["DecayTime"],
                 mean_percent=stimulus_entry["MeanPercent"],
                 sd_percent=stimulus_entry["SDPercent"],
-                amp_cv=stimulus_entry["AmpCV"],
+                relative_skew=stimulus_entry.get("RelativeSkew", 0.5),
                 seed=stimulus_entry.get("Seed", None),
                 mode=mode,
                 reversal=stimulus_entry.get("Reversal", 0.0)
@@ -243,7 +243,6 @@ class Stimulus:
                 delay=stimulus_entry["delay"],
                 duration=stimulus_entry["duration"],
                 spike_file=stimulus_entry["spike_file"],
-                source=stimulus_entry["source"],
             )
         elif pattern == Pattern.SHOT_NOISE:
             return ShotNoise(
@@ -270,7 +269,7 @@ class Stimulus:
                 decay_time=stimulus_entry["decay_time"],
                 mean_percent=stimulus_entry["mean_percent"],
                 sd_percent=stimulus_entry["sd_percent"],
-                amp_cv=stimulus_entry["amp_cv"],
+                relative_skew=stimulus_entry.get("RelativeSkew", 0.5),
                 seed=stimulus_entry.get("random_seed", None),
                 mode=ClampMode(stimulus_entry.get("input_type", "current_clamp").lower()),
                 reversal=stimulus_entry.get("reversal", 0.0)
@@ -331,7 +330,6 @@ class RelativeLinear(Stimulus):
 @dataclass(frozen=True, config=dict(extra="forbid"))
 class SynapseReplay(Stimulus):
     spike_file: str
-    source: str
 
     @field_validator("spike_file")
     @classmethod
@@ -367,7 +365,7 @@ class RelativeShotNoise(Stimulus):
     decay_time: float
     mean_percent: float
     sd_percent: float
-    amp_cv: float
+    relative_skew: float = 0.5
     dt: float = 0.25
     seed: Optional[int] = None
     mode: ClampMode = ClampMode.CURRENT
@@ -380,6 +378,13 @@ class RelativeShotNoise(Stimulus):
             raise ValueError("decay_time must be greater than rise_time")
         return v
 
+    @field_validator("relative_skew")
+    @classmethod
+    def relative_skew_in_range(cls, v):
+        if v < 0.0 or v > 1.0:
+            raise ValueError("relative skewness must be in [0,1]")
+        return v
+
 
 @dataclass(frozen=True, config=dict(extra="forbid"))
 class OrnsteinUhlenbeck(Stimulus):