bluecellulab 1.5.0__tar.gz → 1.5.2__tar.gz

{bluecellulab-1.5.0 → bluecellulab-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bluecellulab
-Version: 1.5.0
+Version: 1.5.2
 Summary: The Pythonic Blue Brain simulator access
 Home-page: https://github.com/BlueBrain/BlueCelluLab
 Author: Blue Brain Project, EPFL

{bluecellulab-1.5.0 → bluecellulab-1.5.2}/bluecellulab/cell/core.py

@@ -102,8 +102,8 @@ class Cell(InjectableMixin, PlottableMixin):
         self.synapses: dict[tuple[str, int], Synapse] = {}
         self.connections: dict[tuple[str, int], bluecellulab.Connection] = {}
 
-        self.ips: dict[int, HocObjectType] = {}
-        self.syn_mini_netcons: dict[int, HocObjectType] = {}
+        self.ips: dict[tuple[str, int], HocObjectType] = {}
+        self.syn_mini_netcons: dict[tuple[str, int], HocObjectType] = {}
         self.serialized = None
 
         # Be careful when removing this,
@@ -503,7 +503,8 @@ class Cell(InjectableMixin, PlottableMixin):
         """Get recorded values."""
         return np.array(self.recordings[var_name].to_python())
 
-    def add_replay_synapse(self, synapse_id: tuple[str, int],
+    def add_replay_synapse(self,
+                           synapse_id: tuple[str, int],
                            syn_description: pd.Series,
                            connection_modifiers: dict,
                            condition_parameters: Conditions,
@@ -638,13 +639,17 @@ class Cell(InjectableMixin, PlottableMixin):
         result = self.recordings[f"spike_detector_{location}_{threshold}"]
         return result.to_python()
 
-    def add_replay_minis(self, syn_id, syn_description, connection_parameters,
-                         base_seed=None, popids=(0, 0), mini_frequencies=None):
+    def add_replay_minis(self,
+                         synapse_id: tuple[str, int],
+                         syn_description: pd.Series,
+                         connection_modifiers: dict,
+                         base_seed: int | None,
+                         popids: tuple[int, int],
+                         mini_frequencies: tuple[float | None, float | None]) -> None:
         """Add minis from the replay."""
-
         source_popid, target_popid = popids
 
-        sid = syn_id[1]
+        sid = synapse_id[1]
 
         if base_seed is None:
             base_seed = self.rng_settings.base_seed
@@ -659,19 +664,19 @@ class Cell(InjectableMixin, PlottableMixin):
                 synlocation_to_segx(post_sec_id, post_seg_id,
                                     post_seg_distance)
         # todo: False
-        if 'Weight' in connection_parameters:
-            weight_scalar = connection_parameters['Weight']
+        if 'Weight' in connection_modifiers:
+            weight_scalar = connection_modifiers['Weight']
         else:
             weight_scalar = 1.0
 
         exc_mini_frequency, inh_mini_frequency = mini_frequencies \
             if mini_frequencies is not None else (None, None)
 
-        synapse = self.synapses[syn_id]
+        synapse = self.synapses[synapse_id]
 
         # SpontMinis in sim config takes precedence of values in nodes file
-        if 'SpontMinis' in connection_parameters:
-            spont_minis_rate = connection_parameters['SpontMinis']
+        if 'SpontMinis' in connection_modifiers:
+            spont_minis_rate = connection_modifiers['SpontMinis']
         else:
             if synapse.mech_name in ["GluSynapse", "ProbAMPANMDA_EMS"]:
                 spont_minis_rate = exc_mini_frequency
@@ -681,25 +686,25 @@ class Cell(InjectableMixin, PlottableMixin):
         if spont_minis_rate is not None and spont_minis_rate > 0:
             sec = self.get_hsection(post_sec_id)
             # add the *minis*: spontaneous synaptic events
-            self.ips[syn_id] = bluecellulab.neuron.h.\
+            self.ips[synapse_id] = bluecellulab.neuron.h.\
                 InhPoissonStim(location, sec=sec)
 
-            self.syn_mini_netcons[syn_id] = bluecellulab.neuron.h.\
-                NetCon(self.ips[syn_id], synapse.hsynapse, sec=sec)
-            self.syn_mini_netcons[syn_id].delay = 0.1
-            self.syn_mini_netcons[syn_id].weight[0] = weight * weight_scalar
+            self.syn_mini_netcons[synapse_id] = bluecellulab.neuron.h.\
+                NetCon(self.ips[synapse_id], synapse.hsynapse, sec=sec)
+            self.syn_mini_netcons[synapse_id].delay = 0.1
+            self.syn_mini_netcons[synapse_id].weight[0] = weight * weight_scalar
             # set netcon type
             nc_param_name = 'nc_type_param_{}'.format(
                 synapse.hsynapse).split('[')[0]
             if hasattr(bluecellulab.neuron.h, nc_param_name):
                 nc_type_param = int(getattr(bluecellulab.neuron.h, nc_param_name))
                 # NC_SPONTMINI
-                self.syn_mini_netcons[syn_id].weight[nc_type_param] = 1
+                self.syn_mini_netcons[synapse_id].weight[nc_type_param] = 1
 
             if self.rng_settings.mode == 'Random123':
                 seed2 = source_popid * 65536 + target_popid \
                     + self.rng_settings.minis_seed
-                self.ips[syn_id].setRNGs(
+                self.ips[synapse_id].setRNGs(
                     sid + 200,
                     self.gid + 250,
                     seed2 + 300,
@@ -739,7 +744,7 @@ class Cell(InjectableMixin, PlottableMixin):
                 uniformrng.MCellRan4(uniform_seed1, uniform_seed2)
                 uniformrng.uniform(0.0, 1.0)
 
-                self.ips[syn_id].setRNGs(exprng, uniformrng)
+                self.ips[synapse_id].setRNGs(exprng, uniformrng)
 
             tbins_vec = bluecellulab.neuron.h.Vector(1)
             tbins_vec.x[0] = 0.0
@@ -747,8 +752,8 @@ class Cell(InjectableMixin, PlottableMixin):
             rate_vec.x[0] = spont_minis_rate
             self.persistent.append(tbins_vec)
             self.persistent.append(rate_vec)
-            self.ips[syn_id].setTbins(tbins_vec)
-            self.ips[syn_id].setRate(rate_vec)
+            self.ips[synapse_id].setTbins(tbins_vec)
+            self.ips[synapse_id].setRate(rate_vec)
 
     def locate_bapsite(self, seclist_name, distance):
         """Return the location of the BAP site.

{bluecellulab-1.5.0 → bluecellulab-1.5.2}/bluecellulab/circuit/circuit_access.py

@@ -137,7 +137,7 @@ class CircuitAccess(Protocol):
     def fetch_cell_info(self, cell_id: CellId) -> pd.Series:
         raise NotImplementedError
 
-    def fetch_mini_frequencies(self, cell_id: CellId) -> tuple:
+    def fetch_mini_frequencies(self, cell_id: CellId) -> tuple[float | None, float | None]:
         raise NotImplementedError
 
     @property
@@ -432,7 +432,7 @@ class BluepyCircuitAccess:
 
         return emodel_name
 
-    def fetch_mini_frequencies(self, cell_id: CellId) -> tuple:
+    def fetch_mini_frequencies(self, cell_id: CellId) -> tuple[float | None, float | None]:
         """Get inhibitory frequency of gid."""
         cell_info = self.fetch_cell_info(cell_id)
         # mvd uses inh_mini_frequency, sonata uses inh-mini_frequency
@@ -650,7 +650,7 @@ class SonataCircuitAccess:
     def fetch_cell_info(self, cell_id: CellId) -> pd.Series:
         return self._circuit.nodes[cell_id.population_name].get(cell_id.id)
 
-    def fetch_mini_frequencies(self, cell_id: CellId) -> tuple:
+    def fetch_mini_frequencies(self, cell_id: CellId) -> tuple[float | None, float | None]:
         cell_info = self.fetch_cell_info(cell_id)
         exc_mini_frequency = cell_info['exc-mini_frequency'] \
             if 'exc-mini_frequency' in cell_info else None

{bluecellulab-1.5.0 → bluecellulab-1.5.2}/bluecellulab/rngsettings.py

@@ -32,8 +32,7 @@ class RNGSettings(metaclass=Singleton):
             self,
             mode: Optional[str] = None,
             circuit_access: Optional[CircuitAccess] = None,
-            base_seed: Optional[int] = None,
-            base_noise_seed: Optional[int] = None):
+            base_seed: Optional[int] = None):
         """Constructor.
 
         Parameters
@@ -41,7 +40,6 @@ class RNGSettings(metaclass=Singleton):
         mode : rng mode, if not specified mode is taken from circuit_access
         circuit: circuit access object, if present seeds are read from simulation
         base_seed: base seed for entire sim, overrides config value
-        base_noise_seed: base seed for the noise stimuli
         """
 
         self._mode = ""
@@ -77,11 +75,6 @@ class RNGSettings(metaclass=Singleton):
         self.minis_seed = circuit_access.config.minis_seed if circuit_access else 0
         bluecellulab.neuron.h.minisSeed = self.minis_seed
 
-        if base_noise_seed is None:
-            self.base_noise_seed = 0
-        else:
-            self.base_noise_seed = base_noise_seed
-
     @property
     def mode(self):
         return self._mode
@@ -103,14 +96,12 @@ class RNGSettings(metaclass=Singleton):
     def __repr__(self) -> str:
         """Returns a string representation of the object."""
         return "RNGSettings(mode={mode}, base_seed={base_seed}, " \
-               "base_noise_seed={base_noise_seed}, " \
                "synapse_seed={synapse_seed}, " \
                "ionchannel_seed={ionchannel_seed}, " \
                "stimulus_seed={stimulus_seed}, " \
                "minis_seed={minis_seed})".format(
                    mode=self.mode,
                    base_seed=self.base_seed,
-                   base_noise_seed=self.base_noise_seed,
                    synapse_seed=self.synapse_seed,
                    ionchannel_seed=self.ionchannel_seed,
                    stimulus_seed=self.stimulus_seed,

{bluecellulab-1.5.0 → bluecellulab-1.5.2}/bluecellulab/ssim.py

@@ -59,7 +59,6 @@ class SSim:
         dt: float = 0.025,
         record_dt: Optional[float] = None,
         base_seed: Optional[int] = None,
-        base_noise_seed: Optional[int] = None,
         rng_mode: Optional[str] = None,
         print_cellstate: bool = False,
     ):
@@ -75,11 +74,6 @@ class SSim:
                     Has to positive integer.
                     When this is not set, and no seed is set in the
                     simulation config, the seed will be 0.
-        base_noise_seed :
-                    Base seed used for the noise stimuli in the simulation.
-                    Not setting this will result in the default Neurodamus
-                    behavior (i.e. seed=0)
-                    Has to positive integer.
         rng_mode : String with rng mode, if not specified mode is taken from
                     simulation config. Possible values are Compatibility, Random123
                     and UpdatedMCell.
@@ -103,8 +97,7 @@ class SSim:
         self.rng_settings = bluecellulab.RNGSettings(
             rng_mode,
             self.circuit_access,
-            base_seed=base_seed,
-            base_noise_seed=base_noise_seed)
+            base_seed=base_seed)
 
         self.cells: CellDict = CellDict()
 
@@ -549,7 +542,9 @@ class SSim:
                     syn_description,
                     syn_connection_parameters,
                     popids=popids,
-                    mini_frequencies=mini_frequencies)
+                    mini_frequencies=mini_frequencies,
+                    base_seed=None
+                )
 
     def run(
         self,

{bluecellulab-1.5.0 → bluecellulab-1.5.2}/bluecellulab.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bluecellulab
-Version: 1.5.0
+Version: 1.5.2
 Summary: The Pythonic Blue Brain simulator access
 Home-page: https://github.com/BlueBrain/BlueCelluLab
 Author: Blue Brain Project, EPFL

{bluecellulab-1.5.0 → bluecellulab-1.5.2}/tests/test_rngsettings.py

@@ -36,7 +36,7 @@ def test_str_repr_obj():
     """Test the str and repr methods of RNGSettings."""
     rng_obj = bluecellulab.RNGSettings(mode="UpdatedMCell")
     assert repr(rng_obj) == "RNGSettings(mode=UpdatedMCell, base_seed=0, " \
-                            "base_noise_seed=0, synapse_seed=0, " \
+                            "synapse_seed=0, " \
                             "ionchannel_seed=0, stimulus_seed=0, " \
                             "minis_seed=0)"