bluecellulab 2.3.7__py3-none-any.whl → 2.4.1__py3-none-any.whl

bluecellulab/cell/template.py

@@ -20,7 +20,7 @@ import os
 from pathlib import Path
 import re
 import string
-from typing import Optional
+from typing import NamedTuple, Optional
 
 import neuron
 
@@ -44,11 +44,19 @@ def public_hoc_cell(cell: HocObjectType) -> HocObjectType:
          from the hoc model. Either getCell() or CellRef needs to be provided""")
 
 
+class TemplateParams(NamedTuple):
+    template_filepath: str | Path
+    morph_filepath: str | Path
+    template_format: str
+    emodel_properties: Optional[EmodelProperties]
+
+
 class NeuronTemplate:
     """NeuronTemplate representation."""
 
     def __init__(
-        self, template_filepath: str | Path, morph_filepath: str | Path
+        self, template_filepath: str | Path, morph_filepath: str | Path,
+        template_format: str, emodel_properties: Optional[EmodelProperties]
     ) -> None:
         """Load the hoc template and init object."""
         if isinstance(template_filepath, Path):
@@ -63,18 +71,18 @@ class NeuronTemplate:
 
         self.template_name = self.load(template_filepath)
         self.morph_filepath = morph_filepath
+        self.template_format = template_format
+        self.emodel_properties = emodel_properties
 
-    def get_cell(
-        self, template_format: str, gid: Optional[int], emodel_properties: Optional[EmodelProperties]
-    ) -> HocObjectType:
+    def get_cell(self, gid: Optional[int]) -> HocObjectType:
         """Returns the hoc object matching the template format."""
         morph_dir, morph_fname = os.path.split(self.morph_filepath)
-        if template_format == "v6":
+        if self.template_format == "v6":
             attr_names = getattr(
                 neuron.h, self.template_name.split('_bluecellulab')[0] + "_NeededAttributes", None
             )
             if attr_names is not None:
-                if emodel_properties is None:
+                if self.emodel_properties is None:
                     raise BluecellulabError(
                         "EmodelProperties must be provided for template "
                         "format v6 that specifies _NeededAttributes"
@@ -83,7 +91,7 @@ class NeuronTemplate:
                     gid,
                     morph_dir,
                     morph_fname,
-                    *[emodel_properties.__getattribute__(name) for name in attr_names.split(";")]
+                    *[self.emodel_properties.__getattribute__(name) for name in attr_names.split(";")]
                 )
             else:
                 cell = getattr(neuron.h, self.template_name)(
@@ -91,7 +99,7 @@ class NeuronTemplate:
                     morph_dir,
                     morph_fname,
                 )
-        elif template_format == "bluepyopt":
+        elif self.template_format == "bluepyopt":
             cell = getattr(neuron.h, self.template_name)(morph_dir, morph_fname)
         else:
             cell = getattr(neuron.h, self.template_name)(gid, self.morph_filepath)
@@ -137,31 +145,21 @@ class NeuronTemplate:
         return template_name
 
 
-def shorten_and_hash_string(label, keep_length=40, hash_length=9):
-    """Convert string to a shorter string if required.
-
-    Parameters
-    ----------
-    label : string
-            a string to be converted
-    keep_length : int
-                    length of the original string to keep. Default is 40
-                    characters.
-    hash_length : int
-                    length of the hash to generate, should not be more then
-                    20. Default is 9 characters.
-
-    Returns
-    -------
-    new_label : string
-        If the length of the original label is shorter than the sum of
-        'keep_length' and 'hash_length' plus one the original string is
-        returned. Otherwise, a string with structure <partial>_<hash> is
-        returned, where <partial> is the first part of the original string
-        with length equal to <keep_length> and the last part is a hash of
-        'hash_length' characters, based on the original string.
-    """
+def shorten_and_hash_string(label: str, keep_length=40, hash_length=9) -> str:
+    """Converts a string to a shorter string if required.
+
+    Args:
+        label: A string to be converted.
+        keep_length: Length of the original string to keep.
+        hash_length: Length of the hash to generate, should not be more than 20.
 
+    Returns:
+        If the length of the original label is shorter than the sum of 'keep_length'
+        and 'hash_length' plus one, the original string is returned. Otherwise, a
+        string with structure <partial>_<hash> is returned, where <partial> is the
+        first part of the original string with length equal to <keep_length> and the
+        last part is a hash of 'hash_length' characters, based on the original string.
+    """
     if hash_length > 20:
         raise ValueError(
             "Parameter hash_length should not exceed 20, "
@@ -175,46 +173,24 @@ def shorten_and_hash_string(label, keep_length=40, hash_length=9):
     return "{}_{}".format(label[0:keep_length], hash_string[0:hash_length])
 
 
-def check_compliance_with_neuron(template_name):
+def check_compliance_with_neuron(template_name: str) -> bool:
     """Verify that a given name is compliant with the rules for a NEURON.
 
-    Parameters
-    ----------
-    template name : string
-                    a name should be a non-empty alphanumeric string,
-                    and start with a letter. Underscores are allowed.
-                    The length should not exceed 50 characters.
-
-    Returns
-    -------
-    compliant : boolean
-                True if compliant, false otherwise.
+    A name should be a non-empty alphanumeric string, and start with a
+    letter. Underscores are allowed. The length should not exceed 50
+    characters.
     """
     max_len = 50
     return (
-        template_name
+        bool(template_name)
         and template_name[0].isalpha()
         and template_name.replace("_", "").isalnum()
         and len(template_name) <= max_len
     )
 
 
-def get_neuron_compliant_template_name(name):
-    """Get template name that is compliant with NEURON based on given name.
-
-    Parameters
-    ----------
-    name : string
-            template_name to transform
-
-    Returns
-    -------
-    new_name : string
-                If `name` is NEURON-compliant, the same string is return.
-                Otherwise, hyphens are replaced by underscores and if
-                appropriate, the string is shortened.
-                Leading numbers are removed.
-    """
+def get_neuron_compliant_template_name(name: str) -> str:
+    """Get template name that is compliant with NEURON based on given name."""
     template_name = name
     if not check_compliance_with_neuron(template_name):
         template_name = template_name.lstrip(string.digits).replace("-", "_")

bluecellulab/hoc/RNGSettings.hoc

@@ -21,18 +21,14 @@
 {load_file("fileUtils.hoc")}
 
 rngMode = 0  // corresponds to COMPATIBILITY defined below
-ionchannelSeed = 0
-synapseSeed = 0
-stimulusSeed = 0
-minisSeed = 0
 globalSeed = 0
 
 begintemplate RNGSettings
 
-public init, interpret, getRNGMode, getIonChannelSeed, getSynapseSeed, getStimulusSeed, getMinisSeed, getGlobalSeed
+public init, interpret, getRNGMode, getGlobalSeed
 public COMPATIBILITY, RANDOM123, UPMCELLRAN4
 
-external rngMode, ionchannelSeed, synapseSeed, stimulusSeed, minisSeed, globalSeed, terminate
+external rngMode, globalSeed, terminate
 
 proc init() {
     // consts for random number handling

bluecellulab/rngsettings.py

@@ -18,35 +18,59 @@ import logging
 from typing import Optional
 
 import neuron
-from bluecellulab import Singleton
-from bluecellulab.circuit.circuit_access import CircuitAccess
+from bluecellulab.circuit.config.definition import SimulationConfig
 from bluecellulab.exceptions import UndefinedRNGException
 from bluecellulab.importer import load_hoc_and_mod_files
 
 logger = logging.getLogger(__name__)
 
 
-class RNGSettings(metaclass=Singleton):
-    """Class that represents RNG settings in bluecellulab."""
+class RNGSettings:
+    """Singleton object that represents RNG settings in bluecellulab."""
+
+    _instance = None
+
+    @classmethod
+    def get_instance(cls):
+        """Return the instance of the class."""
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
 
     @load_hoc_and_mod_files
     def __init__(
+        self,
+        mode="Random123",
+        base_seed=0,
+        synapse_seed=0,
+        ionchannel_seed=0,
+        stimulus_seed=0,
+        minis_seed=0,
+    ) -> None:
+        self.mode = mode
+        self.base_seed = base_seed
+        self.synapse_seed = synapse_seed
+        self.ionchannel_seed = ionchannel_seed
+        self.stimulus_seed = stimulus_seed
+        self.minis_seed = minis_seed
+
+    def set_seeds(
             self,
             mode: Optional[str] = None,
-            circuit_access: Optional[CircuitAccess] = None,
+            sim_config: Optional[SimulationConfig] = None,
             base_seed: Optional[int] = None):
         """Constructor.
 
         Parameters
         ----------
         mode : rng mode, if not specified mode is taken from circuit_access
-        circuit: circuit access object, if present seeds are read from simulation
+        sim_config: simulation config object, if present seeds are read from simulation
         base_seed: base seed for entire sim, overrides config value
         """
         self._mode = ""
         if mode is None:
-            if circuit_access is not None:
-                self.mode = circuit_access.config.rng_mode if circuit_access else "Compatibility"
+            if sim_config is not None:
+                self.mode = sim_config.rng_mode if sim_config else "Compatibility"
             else:
                 self.mode = "Random123"
         else:
@@ -55,7 +79,7 @@ class RNGSettings(metaclass=Singleton):
         logger.debug("Setting rng mode to: %s", self._mode)
 
         if base_seed is None:
-            self.base_seed = circuit_access.config.base_seed if circuit_access else 0
+            self.base_seed = sim_config.base_seed if sim_config else 0
         else:
             self.base_seed = base_seed
         neuron.h.globalSeed = self.base_seed
@@ -64,17 +88,11 @@ class RNGSettings(metaclass=Singleton):
             rng = neuron.h.Random()
             rng.Random123_globalindex(self.base_seed)
 
-        self.synapse_seed = circuit_access.config.synapse_seed if circuit_access else 0
-        neuron.h.synapseSeed = self.synapse_seed
-
-        self.ionchannel_seed = circuit_access.config.ionchannel_seed if circuit_access else 0
-        neuron.h.ionchannelSeed = self.ionchannel_seed
-
-        self.stimulus_seed = circuit_access.config.stimulus_seed if circuit_access else 0
-        neuron.h.stimulusSeed = self.stimulus_seed
-
-        self.minis_seed = circuit_access.config.minis_seed if circuit_access else 0
-        neuron.h.minisSeed = self.minis_seed
+        if sim_config:
+            self.synapse_seed = sim_config.synapse_seed
+            self.ionchannel_seed = sim_config.ionchannel_seed
+            self.stimulus_seed = sim_config.stimulus_seed
+            self.minis_seed = sim_config.minis_seed
 
     @property
     def mode(self):

bluecellulab/ssim.py

@@ -40,6 +40,7 @@ from bluecellulab.circuit.format import determine_circuit_format, CircuitFormat
 from bluecellulab.circuit.node_id import create_cell_id, create_cell_ids
 from bluecellulab.circuit.simulation_access import BluepySimulationAccess, SimulationAccess, SonataSimulationAccess, _sample_array
 from bluecellulab.importer import load_hoc_and_mod_files
+from bluecellulab.rngsettings import RNGSettings
 from bluecellulab.stimulus.circuit_stimulus_definitions import Noise, OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck, RelativeShotNoise, ShotNoise
 import bluecellulab.stimulus.circuit_stimulus_definitions as circuit_stimulus_definitions
 from bluecellulab.exceptions import BluecellulabError
@@ -94,10 +95,12 @@ class SSim:
 
         self.pc = neuron.h.ParallelContext() if print_cellstate else None
 
-        self.rng_settings = bluecellulab.RNGSettings(
+        self.rng_settings = RNGSettings.get_instance()
+        self.rng_settings.set_seeds(
             rng_mode,
-            self.circuit_access,
-            base_seed=base_seed)
+            self.circuit_access.config,
+            base_seed=base_seed
+        )
 
         self.cells: CellDict = CellDict()
 
@@ -733,7 +736,6 @@ class SSim:
             'morphology_path': self.circuit_access.morph_filepath(cell_id),
             'cell_id': cell_id,
             'record_dt': self.record_dt,
-            'rng_settings': self.rng_settings,
             'template_format': self.circuit_access.get_template_format(),
             'emodel_properties': emodel_properties,
         }
@@ -747,6 +749,5 @@ class SSim:
                                  morphology_path=cell_kwargs['morphology_path'],
                                  cell_id=cell_kwargs['cell_id'],
                                  record_dt=cell_kwargs['record_dt'],
-                                 rng_settings=cell_kwargs['rng_settings'],
                                  template_format=cell_kwargs['template_format'],
                                  emodel_properties=cell_kwargs['emodel_properties'])

bluecellulab/synapse/synapse_factory.py

@@ -60,13 +60,13 @@ class SynapseFactory:
                 randomize_gaba_risetime = condition_parameters.randomize_gaba_rise_time
             else:
                 randomize_gaba_risetime = True
-            synapse = GabaabSynapse(cell.rng_settings, cell.cell_id, syn_hoc_args, syn_id, syn_description,
+            synapse = GabaabSynapse(cell.cell_id, syn_hoc_args, syn_id, syn_description,
                                     popids, extracellular_calcium, randomize_gaba_risetime)
         elif syn_type == SynapseType.AMPANMDA:
-            synapse = AmpanmdaSynapse(cell.rng_settings, cell.cell_id, syn_hoc_args, syn_id, syn_description,
+            synapse = AmpanmdaSynapse(cell.cell_id, syn_hoc_args, syn_id, syn_description,
                                       popids, extracellular_calcium)
         else:
-            synapse = GluSynapse(cell.rng_settings, cell.cell_id, syn_hoc_args, syn_id, syn_description,
+            synapse = GluSynapse(cell.cell_id, syn_hoc_args, syn_id, syn_description,
                                  popids, extracellular_calcium)
 
         synapse = cls.apply_connection_modifiers(connection_modifiers, synapse)

bluecellulab/synapse/synapse_types.py

@@ -47,7 +47,6 @@ class Synapse:
 
     def __init__(
             self,
-            rng_settings: RNGSettings,
             cell_id: CellId,
             hoc_args: SynapseHocArgs,
             syn_id: tuple[str, int],
@@ -57,7 +56,6 @@ class Synapse:
         """Constructor.
 
         Args:
-            rng_settings: Random number generator settings.
             gid: The post-synaptic cell gid.
             hoc_args: The synapse location and section in hoc.
             syn_id: A tuple containing a synapse identifier, where the string is
@@ -88,8 +86,6 @@ class Synapse:
         self.mech_name: str = "not-yet-defined"
         self.randseed3: Optional[int] = None
 
-        self.rng_settings = rng_settings
-
     @property
     def delay_weights(self) -> list[tuple[float, float]]:
         """Adjustments to synapse delay and weight."""
@@ -147,31 +143,32 @@ class Synapse:
         Raises:
             ValueError: when rng mode is not recognised.
         """
-        if self.rng_settings.mode == "Random123":
+        rng_settings = RNGSettings.get_instance()
+        if rng_settings.mode == "Random123":
             self.randseed1 = self.post_cell_id.id + 250
             self.randseed2 = self.syn_id.sid + 100
             self.randseed3 = self.source_popid * 65536 + self.target_popid + \
-                self.rng_settings.synapse_seed + 300
+                rng_settings.synapse_seed + 300
             self.hsynapse.setRNG(  # type: ignore
                 self.randseed1,
                 self.randseed2,
                 self.randseed3)
         else:
             rndd = neuron.h.Random()
-            if self.rng_settings.mode == "Compatibility":
+            if rng_settings.mode == "Compatibility":
                 self.randseed1 = self.syn_id.sid * 100000 + 100
                 self.randseed2 = self.post_cell_id.id + \
-                    250 + self.rng_settings.base_seed
-            elif self.rng_settings.mode == "UpdatedMCell":
+                    250 + rng_settings.base_seed
+            elif rng_settings.mode == "UpdatedMCell":
                 self.randseed1 = self.syn_id.sid * 1000 + 100
                 self.randseed2 = self.source_popid * 16777216 + \
                     self.post_cell_id.id + \
-                    250 + self.rng_settings.base_seed + \
-                    self.rng_settings.synapse_seed
+                    250 + rng_settings.base_seed + \
+                    rng_settings.synapse_seed
             else:
                 raise ValueError(
                     "Synapse: unknown RNG mode: %s" %
-                    self.rng_settings.mode)
+                    rng_settings.mode)
             self.randseed3 = None  # Not used in this case
             rndd.MCellRan4(self.randseed1, self.randseed2)
             rndd.uniform(0, 1)
@@ -241,8 +238,8 @@ class Synapse:
 
 class GluSynapse(Synapse):
 
-    def __init__(self, rng_settings, gid, hoc_args, syn_id, syn_description, popids, extracellular_calcium):
-        super().__init__(rng_settings, gid, hoc_args, syn_id, syn_description, popids, extracellular_calcium)
+    def __init__(self, gid, hoc_args, syn_id, syn_description, popids, extracellular_calcium):
+        super().__init__(gid, hoc_args, syn_id, syn_description, popids, extracellular_calcium)
         self.use_glusynapse_helper()
 
     def use_glusynapse_helper(self) -> None:
@@ -290,7 +287,8 @@ class GluSynapse(Synapse):
 
         self.randseed1 = self.post_cell_id.id
         self.randseed2 = 100000 + self.syn_id.sid
-        self.randseed3 = self.rng_settings.synapse_seed + 200
+        rng_settings = RNGSettings.get_instance()
+        self.randseed3 = rng_settings.synapse_seed + 200
         self.hsynapse.setRNG(self.randseed1, self.randseed2, self.randseed3)
         self.hsynapse.synapseID = self.syn_id.sid
 
@@ -303,8 +301,8 @@ class GluSynapse(Synapse):
 
 class GabaabSynapse(Synapse):
 
-    def __init__(self, rng_settings, gid, hoc_args, syn_id, syn_description, popids, extracellular_calcium, randomize_risetime=True):
-        super().__init__(rng_settings, gid, hoc_args, syn_id, syn_description, popids, extracellular_calcium)
+    def __init__(self, gid, hoc_args, syn_id, syn_description, popids, extracellular_calcium, randomize_risetime=True):
+        super().__init__(gid, hoc_args, syn_id, syn_description, popids, extracellular_calcium)
         self.use_gabaab_helper(randomize_risetime)
 
     def use_gabaab_helper(self, randomize_gaba_risetime: bool) -> None:
@@ -329,20 +327,21 @@ class GabaabSynapse(Synapse):
 
         if randomize_gaba_risetime is True:
             rng = neuron.h.Random()
-            if self.rng_settings.mode == "Compatibility":
+            rng_settings = RNGSettings.get_instance()
+            if rng_settings.mode == "Compatibility":
                 rng.MCellRan4(
                     self.syn_id.sid * 100000 + 100,
-                    self.post_cell_id.id + 250 + self.rng_settings.base_seed)
-            elif self.rng_settings.mode == "UpdatedMCell":
+                    self.post_cell_id.id + 250 + rng_settings.base_seed)
+            elif rng_settings.mode == "UpdatedMCell":
                 rng.MCellRan4(
                     self.syn_id.sid * 1000 + 100,
                     self.source_popid *
                     16777216 +
                     self.post_cell_id.id +
                     250 +
-                    self.rng_settings.base_seed +
-                    self.rng_settings.synapse_seed)
-            elif self.rng_settings.mode == "Random123":
+                    rng_settings.base_seed +
+                    rng_settings.synapse_seed)
+            elif rng_settings.mode == "Random123":
                 rng.Random123(
                     self.post_cell_id.id +
                     250,
@@ -351,12 +350,12 @@ class GabaabSynapse(Synapse):
                     self.source_popid *
                     65536 +
                     self.target_popid +
-                    self.rng_settings.synapse_seed +
+                    rng_settings.synapse_seed +
                     450)
             else:
                 raise ValueError(
                     "Synapse: unknown RNG mode: %s" %
-                    self.rng_settings.mode)
+                    rng_settings.mode)
 
             rng.lognormal(0.2, 0.1)
             self.hsynapse.tau_r_GABAA = rng.repick()
@@ -386,8 +385,8 @@ class GabaabSynapse(Synapse):
 
 class AmpanmdaSynapse(Synapse):
 
-    def __init__(self, rng_settings, gid, hoc_args, syn_id, syn_description, popids, extracellular_calcium):
-        super().__init__(rng_settings, gid, hoc_args, syn_id, syn_description, popids, extracellular_calcium)
+    def __init__(self, gid, hoc_args, syn_id, syn_description, popids, extracellular_calcium):
+        super().__init__(gid, hoc_args, syn_id, syn_description, popids, extracellular_calcium)
         self.use_ampanmda_helper()
 
     def use_ampanmda_helper(self) -> None: