bluecellulab 1.8.1__tar.gz → 1.8.2__tar.gz

{bluecellulab-1.8.1 → bluecellulab-1.8.2}/PKG-INFO

@@ -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

{bluecellulab-1.8.1 → bluecellulab-1.8.2}/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-1.8.1 → bluecellulab-1.8.2}/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-1.8.1 → bluecellulab-1.8.2}/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-1.8.2/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-1.8.1 → bluecellulab-1.8.2}/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-1.8.1 → bluecellulab-1.8.2}/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-1.8.1 → bluecellulab-1.8.2}/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-1.8.1 → bluecellulab-1.8.2}/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 → bluecellulab-1.8.2}/bluecellulab.egg-info/PKG-INFO

@@ -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

{bluecellulab-1.8.1 → bluecellulab-1.8.2}/bluecellulab.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ bluecellulab/__init__.py
 bluecellulab/connection.py
 bluecellulab/dendrogram.py
 bluecellulab/exceptions.py
+bluecellulab/graph.py
 bluecellulab/importer.py
 bluecellulab/neuron_interpreter.py
 bluecellulab/plotwindow.py
@@ -181,6 +182,7 @@ tests/__init__.py
 tests/test_ballstick.py
 tests/test_bglib.py
 tests/test_exceptions.py
+tests/test_graph.py
 tests/test_importer.py
 tests/test_load.py
 tests/test_neuron_interpreter.py

{bluecellulab-1.8.1 → bluecellulab-1.8.2}/bluecellulab.egg-info/requires.txt

@@ -5,3 +5,4 @@ pandas<3.0.0,>=1.0.0
 bluepysnap<3.0.0,>=2.0.0
 pydantic<3.0.0,>=2.5.2
 typing-extensions>=4.8.0
+networkx>=3.1