bluecellulab 1.8.1__py3-none-any.whl → 1.8.2__py3-none-any.whl

bluecellulab/cell/core.py

@@ -51,10 +51,12 @@ logger = logging.getLogger(__name__)
 class Cell(InjectableMixin, PlottableMixin):
     """Represents a Cell object."""
 
+    max_id = 0
+
     def __init__(self,
                  template_path: str | Path,
                  morphology_path: str | Path,
-                 gid: int = 0,
+                 cell_id: Optional[CellId] = None,
                  record_dt: Optional[float] = None,
                  template_format: str = "v5",
                  emodel_properties: Optional[EmodelProperties] = None,
@@ -75,6 +77,10 @@ class Cell(InjectableMixin, PlottableMixin):
                 object used by the Cell. Defaults to None.
         """
         super().__init__()
+        if cell_id is None:
+            cell_id = CellId("", Cell.max_id)
+            Cell.max_id += 1
+        self.cell_id = cell_id
         # Persistent objects, like clamps, that exist as long
         # as the object exists
         self.persistent: list[HocObjectType] = []
@@ -84,7 +90,7 @@ class Cell(InjectableMixin, PlottableMixin):
         # Load the template
         neuron_template = NeuronTemplate(template_path, morphology_path)
         self.template_id = neuron_template.template_name  # useful to map NEURON and python objects
-        self.cell = neuron_template.get_cell(template_format, gid, emodel_properties)
+        self.cell = neuron_template.get_cell(template_format, self.cell_id.id, emodel_properties)
         self.soma = public_hoc_cell(self.cell).soma[0]
         # WARNING: this finitialize 'must' be here, otherwhise the
         # diameters of the loaded morph are wrong
@@ -93,8 +99,7 @@ class Cell(InjectableMixin, PlottableMixin):
         self.cellname = neuron.h.secname(sec=self.soma).split(".")[0]
 
         # Set the gid of the cell
-        public_hoc_cell(self.cell).gid = gid
-        self.gid = gid
+        self.cell.getCell().gid = self.cell_id.id
 
         if rng_settings is None:
             self.rng_settings = RNGSettings("Random123")  # SONATA value
@@ -213,17 +218,17 @@ class Cell(InjectableMixin, PlottableMixin):
                 for section in self.somatic:
                     for seg in section:
                         neuron.h.setdata_StochKv(seg.x, sec=section)
-                        neuron.h.setRNG_StochKv(channel_id, self.gid)
+                        neuron.h.setRNG_StochKv(channel_id, self.cell_id.id)
                         channel_id += 1
                 for section in self.basal:
                     for seg in section:
                         neuron.h.setdata_StochKv(seg.x, sec=section)
-                        neuron.h.setRNG_StochKv(channel_id, self.gid)
+                        neuron.h.setRNG_StochKv(channel_id, self.cell_id.id)
                         channel_id += 1
                 for section in self.apical:
                     for seg in section:
                         neuron.h.setdata_StochKv(seg.x, sec=section)
-                        neuron.h.setRNG_StochKv(channel_id, self.gid)
+                        neuron.h.setRNG_StochKv(channel_id, self.cell_id.id)
                         channel_id += 1
             else:
                 self.cell.re_init_rng()
@@ -445,7 +450,7 @@ class Cell(InjectableMixin, PlottableMixin):
 
         self.synapses[synapse_id] = synapse
 
-        logger.debug(f'Added synapse to cell {self.gid}')
+        logger.debug(f'Added synapse to cell {self.cell_id.id}')
 
     def add_replay_delayed_weight(
         self, sid: tuple[str, int], delay: float, weight: float
@@ -591,10 +596,10 @@ class Cell(InjectableMixin, PlottableMixin):
                     + self.rng_settings.minis_seed
                 self.ips[synapse_id].setRNGs(
                     sid + 200,
-                    self.gid + 250,
+                    self.cell_id.id + 250,
                     seed2 + 300,
                     sid + 200,
-                    self.gid + 250,
+                    self.cell_id.id + 250,
                     seed2 + 350)
             else:
                 exprng = bluecellulab.neuron.h.Random()
@@ -605,18 +610,18 @@ class Cell(InjectableMixin, PlottableMixin):
 
                 if self.rng_settings.mode == 'Compatibility':
                     exp_seed1 = sid * 100000 + 200
-                    exp_seed2 = self.gid + 250 + base_seed + \
+                    exp_seed2 = self.cell_id.id + 250 + base_seed + \
                         self.rng_settings.minis_seed
                     uniform_seed1 = sid * 100000 + 300
-                    uniform_seed2 = self.gid + 250 + base_seed + \
+                    uniform_seed2 = self.cell_id.id + 250 + base_seed + \
                         self.rng_settings.minis_seed
                 elif self.rng_settings.mode == "UpdatedMCell":
                     exp_seed1 = sid * 1000 + 200
-                    exp_seed2 = source_popid * 16777216 + self.gid + 250 + \
+                    exp_seed2 = source_popid * 16777216 + self.cell_id.id + 250 + \
                         base_seed + \
                         self.rng_settings.minis_seed
                     uniform_seed1 = sid * 1000 + 300
-                    uniform_seed2 = source_popid * 16777216 + self.gid + 250 \
+                    uniform_seed2 = source_popid * 16777216 + self.cell_id.id + 250 \
                         + base_seed + \
                         self.rng_settings.minis_seed
                 else:
@@ -789,7 +794,7 @@ class Cell(InjectableMixin, PlottableMixin):
                         spike_location=spike_location,
                     )
                     logger.debug(
-                        f"Added synapse replay from {pre_gid} to {self.gid}, {synapse_id}"
+                        f"Added synapse replay from {pre_gid} to {self.cell_id.id}, {synapse_id}"
                     )
 
                     self.connections[synapse_id] = connection

bluecellulab/cell/injector.py

@@ -156,20 +156,20 @@ class InjectableMixin:
     def _get_noise_step_rand(self, noisestim_count):
         """Return rng for noise step stimulus."""
         if self.rng_settings.mode == "Compatibility":
-            rng = bluecellulab.neuron.h.Random(self.gid + noisestim_count)
+            rng = bluecellulab.neuron.h.Random(self.cell_id.id + noisestim_count)
         elif self.rng_settings.mode == "UpdatedMCell":
             rng = bluecellulab.neuron.h.Random()
             rng.MCellRan4(
                 noisestim_count * 10000 + 100,
                 self.rng_settings.base_seed +
                 self.rng_settings.stimulus_seed +
-                self.gid * 1000)
+                self.cell_id.id * 1000)
         elif self.rng_settings.mode == "Random123":
             rng = bluecellulab.neuron.h.Random()
             rng.Random123(
                 noisestim_count + 100,
                 self.rng_settings.stimulus_seed + 500,
-                self.gid + 300)
+                self.cell_id.id + 300)
 
         self.persistent.append(rng)
         return rng
@@ -235,7 +235,7 @@ class InjectableMixin:
         if self.rng_settings.mode == "Random123":
             seed1 = stim_count + 2997  # stimulus block
             seed2 = self.rng_settings.stimulus_seed + 291204  # stimulus type
-            seed3 = self.gid + 123 if seed is None else seed  # GID
+            seed3 = self.cell_id.id + 123 if seed is None else seed  # GID
             logger.debug("Using ornstein_uhlenbeck process seeds %d %d %d" %
                          (seed1, seed2, seed3))
             rng = bluecellulab.neuron.h.Random()
@@ -251,7 +251,7 @@ class InjectableMixin:
         if self.rng_settings.mode == "Random123":
             seed1 = shotnoise_stim_count + 2997
             seed2 = self.rng_settings.stimulus_seed + 19216
-            seed3 = self.gid + 123 if seed is None else seed
+            seed3 = self.cell_id.id + 123 if seed is None else seed
             logger.debug("Using shot noise seeds %d %d %d" %
                          (seed1, seed2, seed3))
             rng = bluecellulab.neuron.h.Random()

bluecellulab/connection.py

@@ -18,6 +18,7 @@ from typing import Optional
 import numpy as np
 
 import bluecellulab
+from bluecellulab.cell.core import Cell
 from bluecellulab.circuit import SynapseProperty
 
 
@@ -28,7 +29,7 @@ class Connection:
             self,
             post_synapse,
             pre_spiketrain: Optional[np.ndarray] = None,
-            pre_cell=None,
+            pre_cell: Optional[Cell] = None,
             stim_dt=None,
             parallel_context=None,
             spike_threshold: float = -30.0,
@@ -76,7 +77,7 @@ class Connection:
             self.post_netcon = self.pre_cell.create_netcon_spikedetector(
                 self.post_synapse.hsynapse, location=spike_location,
                 threshold=spike_threshold) if self.pc is None else \
-                self.pc.gid_connect(self.pre_cell.gid, self.post_synapse.hsynapse)
+                self.pc.gid_connect(self.pre_cell.cell_id.id, self.post_synapse.hsynapse)
             self.post_netcon.weight[0] = self.post_netcon_weight
             self.post_netcon.delay = self.post_netcon_delay
             self.post_netcon.threshold = spike_threshold
@@ -94,7 +95,7 @@ class Connection:
         connection_dict = {}
 
         connection_dict['pre_cell_id'] = self.post_synapse.pre_gid
-        connection_dict['post_cell_id'] = self.post_synapse.post_gid
+        connection_dict['post_cell_id'] = self.post_synapse.post_cell_id.id
         connection_dict['post_synapse_id'] = self.post_synapse.syn_id.sid
 
         connection_dict['post_netcon'] = {}

bluecellulab/graph.py

@@ -0,0 +1,85 @@
+"""Graph representation of Cells and Synapses."""
+
+from matplotlib.cm import ScalarMappable
+from matplotlib.colors import Normalize
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+
+
+from bluecellulab.cell.cell_dict import CellDict
+
+
+def build_graph(cells: CellDict) -> nx.DiGraph:
+    G = nx.DiGraph()
+
+    # Add nodes (cells) to the graph
+    for cell_id, cell in cells.items():
+        G.add_node(cell_id, label=str(cell_id.id), population=cell_id.population_name)
+
+    # Extract and add edges (connections) to the graph from each cell
+    for cell_id, cell in cells.items():
+        for connection in cell.connections.values():
+            # Check if pre_cell exists for the connection
+            if connection.pre_cell is None:
+                continue
+
+            # Source is the pre_cell from the connection
+            source_cell_id = connection.pre_cell.cell_id
+
+            # Target is the post-synapse cell from the connection
+            target_cell_id = connection.post_synapse.post_cell_id
+
+            # Check if both source and target cells are within the current cell collection
+            if source_cell_id in cells and target_cell_id in cells:
+                G.add_edge(source_cell_id, target_cell_id, weight=connection.weight)
+
+    return G
+
+
+def plot_graph(G: nx.Graph, node_size: float = 400, edge_width: float = 0.4, node_distance: float = 1.6):
+    # Extract unique populations from the graph nodes
+    populations = list(set([cell_id.population_name for cell_id in G.nodes()]))
+
+    # Create a color map for each population
+    color_map = plt.cm.tab20(np.linspace(0, 1, len(populations)))  # type: ignore[attr-defined]
+    population_color = dict(zip(populations, color_map))
+
+    # Create node colors based on their population
+    node_colors = [population_color[node.population_name] for node in G.nodes()]
+
+    # Extract weights for edge color mapping
+    edge_weights = [d['weight'] for _, _, d in G.edges(data=True)]
+    edge_colors = plt.cm.Greens(np.interp(edge_weights, (min(edge_weights), max(edge_weights)), (0.3, 1)))  # type: ignore[attr-defined]
+
+    # Create positions using spring layout for the entire graph
+    pos = nx.spring_layout(G, k=node_distance)
+
+    # Create labels only for the node ID
+    labels = {node: node.id for node in G.nodes()}
+
+    # Create a figure and axis for the drawing
+    fig, ax = plt.subplots(figsize=(6, 5))
+
+    # Draw the graph
+    nx.draw(G, pos, with_labels=True, labels=labels, node_color=node_colors,
+            edge_color=edge_colors, width=edge_width, node_size=node_size, ax=ax, connectionstyle='arc3, rad = 0.1')
+
+    # Draw directed edges
+    nx.draw_networkx_edges(G, pos, edge_color=edge_colors, width=edge_width, ax=ax, arrowstyle='-|>', arrowsize=20, connectionstyle='arc3, rad = 0.1')
+
+    # Create a legend
+    for population, color in population_color.items():
+        plt.plot([0], [0], color=color, label=population)
+    plt.legend(loc="upper left", bbox_to_anchor=(-0.1, 1.05))  # Adjust these values as needed
+
+    # Add a colorbar for edge weights
+    sm = ScalarMappable(cmap="Greens", norm=Normalize(vmin=min(edge_weights), vmax=max(edge_weights)))
+    sm.set_array([])
+    cbar = plt.colorbar(sm, ax=ax, orientation="vertical", fraction=0.03, pad=0.04)
+    cbar.set_label('Synaptic Strength')
+
+    # Add text at the bottom of the figure
+    plt.figtext(0.5, 0.01, "Network of simulated cells", ha="center", fontsize=10, va="bottom")
+
+    plt.show()

bluecellulab/simulation/simulation.py

@@ -157,7 +157,7 @@ class Simulation:
 
         if self.pc is not None:
             for cell in self.cells:
-                self.pc.prcellstate(cell.gid, f"bluecellulab_t={bluecellulab.neuron.h.t}")
+                self.pc.prcellstate(cell.cell_id.id, f"bluecellulab_t={bluecellulab.neuron.h.t}")
 
         try:
             neuron.h.continuerun(neuron.h.tstop)

bluecellulab/ssim.py

@@ -17,7 +17,6 @@ simulations."""
 
 from __future__ import annotations
 from collections.abc import Iterable
-from collections import defaultdict
 from pathlib import Path
 from typing import Optional
 import logging
@@ -100,9 +99,6 @@ class SSim:
         self.cells: CellDict = CellDict()
 
         self.gids_instantiated = False
-        self.connections: defaultdict = defaultdict(
-            lambda: defaultdict(lambda: None)
-        )
 
         # Make sure tstop is set correctly, because it is used by the
         # TStim noise stimulus
@@ -732,7 +728,7 @@ class SSim:
         cell_kwargs = {
             'template_path': self.circuit_access.emodel_path(cell_id),
             'morphology_path': self.circuit_access.morph_filepath(cell_id),
-            'gid': cell_id.id,
+            'cell_id': cell_id,
             'record_dt': self.record_dt,
             'rng_settings': self.rng_settings,
             'template_format': self.circuit_access.get_template_format(),
@@ -746,7 +742,7 @@ class SSim:
         cell_kwargs = self.fetch_cell_kwargs(cell_id)
         return bluecellulab.Cell(template_path=cell_kwargs['template_path'],
                                  morphology_path=cell_kwargs['morphology_path'],
-                                 gid=cell_kwargs['gid'],
+                                 cell_id=cell_kwargs['cell_id'],
                                  record_dt=cell_kwargs['record_dt'],
                                  rng_settings=cell_kwargs['rng_settings'],
                                  template_format=cell_kwargs['template_format'],

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.gid, syn_hoc_args, syn_id, syn_description,
+            synapse = GabaabSynapse(cell.rng_settings, 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.gid, syn_hoc_args, syn_id, syn_description,
+            synapse = AmpanmdaSynapse(cell.rng_settings, cell.cell_id, syn_hoc_args, syn_id, syn_description,
                                       popids, extracellular_calcium)
         else:
-            synapse = GluSynapse(cell.rng_settings, cell.gid, syn_hoc_args, syn_id, syn_description,
+            synapse = GluSynapse(cell.rng_settings, 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

@@ -20,6 +20,7 @@ import logging
 
 import bluecellulab
 from bluecellulab.circuit import SynapseProperty
+from bluecellulab.circuit.node_id import CellId
 from bluecellulab.rngsettings import RNGSettings
 from bluecellulab.type_aliases import HocObjectType, NeuronSection
 
@@ -46,7 +47,7 @@ class Synapse:
     def __init__(
             self,
             rng_settings: RNGSettings,
-            gid: int,
+            cell_id: CellId,
             hoc_args: SynapseHocArgs,
             syn_id: tuple[str, int],
             syn_description: pd.Series,
@@ -72,7 +73,7 @@ class Synapse:
         self._delay_weights: list[tuple[float, float]] = []
         self._weight: Optional[float] = None
 
-        self.post_gid = gid
+        self.post_cell_id = cell_id
         self.syn_id = SynapseID(*syn_id)
         self.extracellular_calcium = extracellular_calcium
         self.syn_description: pd.Series = self.update_syn_description(syn_description)
@@ -146,7 +147,7 @@ class Synapse:
             ValueError: when rng mode is not recognised.
         """
         if self.rng_settings.mode == "Random123":
-            self.randseed1 = self.post_gid + 250
+            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
@@ -158,12 +159,12 @@ class Synapse:
             rndd = bluecellulab.neuron.h.Random()
             if self.rng_settings.mode == "Compatibility":
                 self.randseed1 = self.syn_id.sid * 100000 + 100
-                self.randseed2 = self.post_gid + \
+                self.randseed2 = self.post_cell_id.id + \
                     250 + self.rng_settings.base_seed
             elif self.rng_settings.mode == "UpdatedMCell":
                 self.randseed1 = self.syn_id.sid * 1000 + 100
                 self.randseed2 = self.source_popid * 16777216 + \
-                    self.post_gid + \
+                    self.post_cell_id.id + \
                     250 + self.rng_settings.base_seed + \
                     self.rng_settings.synapse_seed
             else:
@@ -209,7 +210,7 @@ class Synapse:
 
         synapse_dict['synapse_id'] = self.syn_id
         synapse_dict['pre_cell_id'] = self.pre_gid
-        synapse_dict['post_cell_id'] = self.post_gid
+        synapse_dict['post_cell_id'] = self.post_cell_id.id
         synapse_dict['syn_description'] = self.syn_description.to_dict()
         # if keys are enum make them str
         synapse_dict['syn_description'] = {
@@ -286,7 +287,7 @@ class GluSynapse(Synapse):
         if self.syn_description[SynapseProperty.NRRP] >= 0:
             self.hsynapse.Nrrp = self.syn_description[SynapseProperty.NRRP]
 
-        self.randseed1 = self.post_gid
+        self.randseed1 = self.post_cell_id.id
         self.randseed2 = 100000 + self.syn_id.sid
         self.randseed3 = self.rng_settings.synapse_seed + 200
         self.hsynapse.setRNG(self.randseed1, self.randseed2, self.randseed3)
@@ -330,19 +331,19 @@ class GabaabSynapse(Synapse):
             if self.rng_settings.mode == "Compatibility":
                 rng.MCellRan4(
                     self.syn_id.sid * 100000 + 100,
-                    self.post_gid + 250 + self.rng_settings.base_seed)
+                    self.post_cell_id.id + 250 + self.rng_settings.base_seed)
             elif self.rng_settings.mode == "UpdatedMCell":
                 rng.MCellRan4(
                     self.syn_id.sid * 1000 + 100,
                     self.source_popid *
                     16777216 +
-                    self.post_gid +
+                    self.post_cell_id.id +
                     250 +
                     self.rng_settings.base_seed +
                     self.rng_settings.synapse_seed)
             elif self.rng_settings.mode == "Random123":
                 rng.Random123(
-                    self.post_gid +
+                    self.post_cell_id.id +
                     250,
                     self.syn_id.sid +
                     100,

{bluecellulab-1.8.1.dist-info → bluecellulab-1.8.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bluecellulab
-Version: 1.8.1
+Version: 1.8.2
 Summary: The Pythonic Blue Brain simulator access
 Home-page: https://github.com/BlueBrain/BlueCelluLab
 Author: Blue Brain Project, EPFL
@@ -24,6 +24,7 @@ Requires-Dist: pandas <3.0.0,>=1.0.0
 Requires-Dist: bluepysnap <3.0.0,>=2.0.0
 Requires-Dist: pydantic <3.0.0,>=2.5.2
 Requires-Dist: typing-extensions >=4.8.0
+Requires-Dist: networkx >=3.1
 
 |banner|
 

{bluecellulab-1.8.1.dist-info → bluecellulab-1.8.2.dist-info}/RECORD

@@ -1,21 +1,22 @@
 bluecellulab/__init__.py,sha256=tbFwA146uSwNPO1HeVhqHNfxUBPM0VsuNk3NeMCq-Wc,620
-bluecellulab/connection.py,sha256=WoKyfuqUesXwsRL-1llVnQfDOGpETn8VSfOvy2t1eWs,4665
+bluecellulab/connection.py,sha256=zZXQZAdFw8jdqnqrOZhiXjoFffVuQe6fZpgOeK2UwA4,4737
 bluecellulab/dendrogram.py,sha256=G9_oZoxZwevHmJ4va5OGMlc8B2D3DpqK0v0G3SCGkEg,4890
 bluecellulab/exceptions.py,sha256=ggTrfzoW3y0oDFUp3ff7GR9buLo-I2LM8XwxE1vQS9k,2379
+bluecellulab/graph.py,sha256=tADNsE7mcIbaSVnC3--ism-TSmMmIrwUxumEGUS_mi0,3478
 bluecellulab/importer.py,sha256=K09SOykkks7nbZoAbQZsK2TgK0wKPI4LXaxWm0ZdiBc,2467
 bluecellulab/neuron_interpreter.py,sha256=XPbQtOPIDk-sGydl4wuanOIeKl_rWvncXEsaweYTzVw,2185
 bluecellulab/plotwindow.py,sha256=-Tym4DH5tvuxLKua5NXxBcnVUNGMUQt3EltEQhG7fyg,2728
 bluecellulab/psection.py,sha256=RxXZLD5F9iWW9oettm5QROPJd4zpshkMVQmxBkbpJsQ,6077
 bluecellulab/psegment.py,sha256=qQaUM4CCJ4JHLvDblN0Wc4IusKoAukASuP1pfk2p0zg,3309
 bluecellulab/rngsettings.py,sha256=2LIZLroSDjlwsoWFFK1IO2fPMSALga-f3a0_scGVHaM,3999
-bluecellulab/ssim.py,sha256=5zmN8rSKgFSZzFZMwglrz2ILJ_VHJaWJhdvw9sSnALQ,33332
+bluecellulab/ssim.py,sha256=e9KQfZ5gLTEaXDNjnpOJy0k8NqDeQ4J2wSjuIr7qLlc,33196
 bluecellulab/stimuli.py,sha256=tZo5hBr3ephHL1LVQXcOjdvjq3I_ziRveMChD55c_dE,15540
 bluecellulab/tools.py,sha256=jFXahRUhA6XZU1w6rhxCa-CLcSsiErTEp4JgqtaPiXY,24243
 bluecellulab/type_aliases.py,sha256=EMrunY-pIgZrsmetpAM8lA7tr0TFEzFoU5SX9sBuiOk,312
 bluecellulab/cell/__init__.py,sha256=Sbc0QOsJ8E7tSwf3q7fsXuE_SevBN6ZmoCVyyU5zfII,208
 bluecellulab/cell/cell_dict.py,sha256=BKpJLYLrJCffKGak4EfGZtgus_u0Scz0NKas7tY31vE,1346
-bluecellulab/cell/core.py,sha256=eQQ2tT53ghn225pXRQ8gU4IGcXKk6sT61X2YfSPAQns,34097
-bluecellulab/cell/injector.py,sha256=GZUKx3kdFDtOtlCe-7MJ0sBmXVW4_xTmdtBGPNt2yo0,17100
+bluecellulab/cell/core.py,sha256=NhAwPde0VLsTiCaKh-oujooASkc9evS_Di3wpCHKNis,34338
+bluecellulab/cell/injector.py,sha256=9cru7K4hxNBulsLq37t7SD9hVER8UviXI64RsDKUh5s,17135
 bluecellulab/cell/plotting.py,sha256=K_oDLeweEK-2LpiIzuZqG0Fd6cSQHoCN2vxuZsWteFs,4123
 bluecellulab/cell/random.py,sha256=s8Kf0q24fiA5rBdVCVbIdDMQGCDfQcwLwXRB72p1e1g,1773
 bluecellulab/cell/section_distance.py,sha256=KoqHkXW3B84QmrtQNhGRczwLOsUrSepLGNJXgaovPOw,3980
@@ -44,13 +45,13 @@ bluecellulab/hoc/TStim.hoc,sha256=noBJbM_ZqF6T6MEgBeowNzz21I9QeYZ5brGgUvCSm4k,84
 bluecellulab/hoc/fileUtils.hoc,sha256=LSM7BgyjYVqo2DGSOKvg4W8IIusbsL45JVYK0vgwitU,2539
 bluecellulab/simulation/__init__.py,sha256=G1md-6mqaYQkfZT8pmzqRi3WW1fMQCgkeaela2kX3OM,258
 bluecellulab/simulation/neuron_globals.py,sha256=5pdkqkstOVZcvPJ_IOwn9nfPvpsXz78TUn_U3k8r2qw,3471
-bluecellulab/simulation/simulation.py,sha256=prflVy9EoyYvqAPwRp6UBNqWyD5-0rTMMFKWn3_1I9Q,6472
+bluecellulab/simulation/simulation.py,sha256=Fj04VN8VJJ0DozJ-hgl1yxag_bLl9eriicpKDLG15rQ,6479
 bluecellulab/synapse/__init__.py,sha256=RW8XoAMXOvK7OG1nHl_q8jSEKLj9ZN4oWf2nY9HAwuk,192
-bluecellulab/synapse/synapse_factory.py,sha256=V5YoPABwLReDnKBvMyYD1NVuTAJe9RQLWkzHHLbVTZw,6790
-bluecellulab/synapse/synapse_types.py,sha256=z5uhJEDJIXZ3BefhCb5oFCglXpudCyEYWZuXrhoB4io,17004
-bluecellulab-1.8.1.dist-info/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
-bluecellulab-1.8.1.dist-info/LICENSE,sha256=xOouu1gC1GGklDxkITlaVl60I9Ab860O-nZsFbWydvU,11749
-bluecellulab-1.8.1.dist-info/METADATA,sha256=EVxTZyimR2z3ExG94NC3ZM-tf7d2CogqdHLGNW0Tahs,6689
-bluecellulab-1.8.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-bluecellulab-1.8.1.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
-bluecellulab-1.8.1.dist-info/RECORD,,
+bluecellulab/synapse/synapse_factory.py,sha256=qrtK_BMWGkpk1embG4oEkrLutt3L_ntqypuvYBxXPEA,6802
+bluecellulab/synapse/synapse_types.py,sha256=M-jF41CnMm7sEDiDhpXKv6HI9wSsRm524jhoI-Xg3qg,17123
+bluecellulab-1.8.2.dist-info/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
+bluecellulab-1.8.2.dist-info/LICENSE,sha256=xOouu1gC1GGklDxkITlaVl60I9Ab860O-nZsFbWydvU,11749
+bluecellulab-1.8.2.dist-info/METADATA,sha256=xP991eJK2iJzHgCFN362iimjph4vO8gK-DBHzAUyphQ,6719
+bluecellulab-1.8.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+bluecellulab-1.8.2.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
+bluecellulab-1.8.2.dist-info/RECORD,,