bsb-neuron 7.6.0__tar.gz → 8.0.1__tar.gz

{bsb_neuron-7.6.0 → bsb_neuron-8.0.1}/PKG-INFO

@@ -1,17 +1,15 @@
 Metadata-Version: 2.4
 Name: bsb-neuron
-Version: 7.6.0
+Version: 8.0.1
 Summary: NEURON simulator adapter for the BSB framework.
 Author-email: Robin De Schepper <robin@alexandria.sc>, Dimitri Rodarie <dimitri.rodarie@unipv.it>
-Requires-Python: >=3.10,<4
+Requires-Python: >=3.11,<4
 Description-Content-Type: text/markdown
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 License-File: LICENSE
-Requires-Dist: bsb-core~=7.0
-Requires-Dist: nrn-patch~=7.0; sys_platform != 'win32'
-Requires-Dist: arborize[neuron]~=7.0; sys_platform != 'win32'
-Requires-Dist: bsb-core[parallel] ; extra == "parallel"
-Provides-Extra: parallel
+Requires-Dist: bsb-core~=8.0
+Requires-Dist: nrn-patch~=8.0 ; sys_platform != 'win32'
+Requires-Dist: arborize[neuron]~=8.0 ; sys_platform != 'win32'
 
 [![Build Status](https://github.com/dbbs-lab/bsb/actions/workflows/main.yml/badge.svg)](https://github.com/dbbs-lab/bsb/actions/workflows/main.yml)
 [![Documentation](https://readthedocs.org/projects/bsb-neuron/badge/?version=latest)](https://bsb-neuron.readthedocs.io/en/latest/?badge=latest)

{bsb_neuron-7.6.0 → bsb_neuron-8.0.1}/bsb_neuron/adapter.py

@@ -1,4 +1,3 @@
-import contextlib
 import itertools
 
 import numpy as np
@@ -6,10 +5,12 @@ from bsb import (
     AdapterError,
     Chunk,
     DatasetNotFoundError,
+    ResultsError,
     SimulationData,
     SimulationError,
     SimulationResult,
     SimulatorAdapter,
+    multiplex_channels,
     report,
 )
 from neo import AnalogSignal
@@ -26,35 +27,94 @@ class NeuronSimulationData(SimulationData):
 
 
 class NeuronResult(SimulationResult):
-    def record(self, obj, **annotations):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # A device's channels, recorded across however many calls to `record` it
+        # makes, one flush of one multiplexed signal apiece: keyed on the device, not
+        # drawn per call, so every point/synapse of a device lands in the one signal.
+        self._channels = {}
+
+    def record(self, obj, *, device, target: dict, name: str, units: str):
+        """
+        Record a NEURON variable every time step, as a recording of a device.
+
+        Every call for the same device joins one multiplexed signal, flushed as a
+        single ``AnalogSignal`` with one channel per call, rather than one signal per
+        call: cheap to write and to merge across ranks, at the scale of a device
+        rather than the scale of a cell.
+
+        :param obj: Reference to the NEURON variable to record, such as ``seg._ref_v``.
+        :param device: The device the recording belongs to.
+        :type device: bsb_neuron.device.NeuronDevice
+        :param target: What is recorded, as the annotations of
+          :func:`~bsb.simulation.results.cell_annotations`,
+          :func:`~bsb.simulation.results.point_annotations` or
+          :func:`~bsb.simulation.results.synapse_annotations` give them.
+        :param name: What the recorded variable measures, such as ``v`` or ``i``. Has
+          to agree with every other call for the same device.
+        :param units: Units of the recorded variable. Has to agree with every other
+          call for the same device.
+        """
         from patch import p
-        from quantities import ms
 
-        v = p.record(obj)
+        if "bsb_recording_kind" not in target or "bsb_direction" not in target:
+            raise AdapterError(
+                f"Device '{device.name}' has to say what it records: pass the "
+                "annotations of `cell_annotations`, `point_annotations` or "
+                "`synapse_annotations` as `target`."
+            )
+        entry = self._channels.get(device)
+        if entry is None:
+            entry = self._channels[device] = {
+                "name": name,
+                "units": units,
+                "channels": [],
+            }
+            self.create_recorder(
+                lambda segment: self._flush_device(segment, device), device=device
+            )
+        elif entry["name"] != name or entry["units"] != units:
+            raise AdapterError(
+                f"Device '{device.name}' recorded '{entry['name']}' in "
+                f"'{entry['units']}' before, and now '{name}' in '{units}': every "
+                "channel of a device has to measure the same thing, in the same units."
+            )
+        entry["channels"].append((p.record(obj), target))
+
+    def _flush_device(self, segment, device):
+        """Combine every channel a device recorded since the last flush into one
+        multiplexed ``AnalogSignal``, and free the NEURON vectors that held them."""
+        from patch import p
+        from quantities import ms
 
-        def flush(segment):
-            if "units" not in annotations:
-                annotations["units"] = "mV"
-            segment.analogsignals.append(
-                AnalogSignal(list(v), sampling_period=p.dt * ms, **annotations)
+        entry = self._channels[device]
+        channels = entry["channels"]
+        lengths = {v.size() for v, _ in channels}
+        if len(lengths) > 1:
+            raise ResultsError(
+                f"Device '{device.name}' recorded channels of different lengths "
+                f"{sorted(lengths)} this checkpoint; they cannot be combined into one "
+                "signal."
             )
-            # Free the memory
+        data = np.array([list(v) for v, _ in channels]).T
+        baseline, array_annotations = multiplex_channels(
+            [target for _, target in channels]
+        )
+        segment.analogsignals.append(
+            AnalogSignal(
+                data,
+                sampling_period=p.dt * ms,
+                name=entry["name"],
+                units=entry["units"],
+                array_annotations=array_annotations,
+                **baseline,
+            )
+        )
+        # Free the memory
+        for v, _ in channels:
             if v.size():
                 v.remove(0, v.size() - 1)
 
-        self.create_recorder(flush)
-
-
-@contextlib.contextmanager
-def fill_parameter_data(parameters, data):
-    for param in parameters:
-        if hasattr(param, "load_data"):
-            param.load_data(*data)
-    yield
-    for param in parameters:
-        if hasattr(param, "load_data"):
-            param.drop_data()
-
 
 class NeuronAdapter(SimulatorAdapter):
     initial = -65
@@ -70,7 +130,7 @@ class NeuronAdapter(SimulatorAdapter):
 
         return engine
 
-    def prepare(self, simulation):
+    def prepare(self, simulation, filename=None):
         """
         Prepare the simulation environment and data structures for running a NEURON
         simulation.
@@ -90,7 +150,13 @@ class NeuronAdapter(SimulatorAdapter):
         """
 
         self.simdata[simulation] = NeuronSimulationData(
-            simulation, result=NeuronResult(simulation)
+            simulation,
+            result=NeuronResult(
+                simulation,
+                filename=filename,
+                comm=self.comm,
+                simulation_id=self.new_run_id(),
+            ),
         )
         try:
             report("Preparing simulation", level=2)
@@ -170,10 +236,9 @@ class NeuronAdapter(SimulatorAdapter):
         self._allocate_transmitters(simulation)
         for conn_model in simulation.connection_models.values():
             cs = simulation.scaffold.get_connectivity_set(conn_model.name)
-            with fill_parameter_data(conn_model.parameters, []):
-                simdata.connections[conn_model] = conn_model.create_connections(
-                    simulation, simdata, cs
-                )
+            simdata.connections[conn_model] = conn_model.create_connections(
+                simulation, simdata, cs
+            )
 
     def _allocate_transmitters(self, simulation):
         simdata = self.simdata[simulation]
@@ -282,9 +347,8 @@ class NeuronAdapter(SimulatorAdapter):
             except DatasetNotFoundError:
                 data.append(itertools.repeat(None))
 
-        with fill_parameter_data(cell_model.parameters, data):
-            instances = cell_model.create_instances(len(ps), *data)
-            simdata.populations[cell_model] = NeuronPopulation(cell_model, instances)
+        instances = cell_model.create_instances(len(ps), *data)
+        simdata.populations[cell_model] = NeuronPopulation(cell_model, instances)
 
 
 class NeuronPopulation(list):

{bsb_neuron-7.6.0 → bsb_neuron-8.0.1}/bsb_neuron/connection.py

@@ -1,5 +1,8 @@
+import dataclasses
+import typing
+
 import numpy as np
-from bsb import AdapterError, ConnectionModel, Parameter, config, types
+from bsb import AdapterError, ConnectionModel, config, types
 
 from bsb_neuron._util import ignore_arborize_proxy_warnings
 
@@ -42,16 +45,46 @@ class SynapseSpec:
     """Name of the synapse model."""
     weight = config.attr(type=float, default=0.004)
     """Weight of the connection between the presynaptic and the postsynaptic cells."""
-    delay = config.attr(type=float, default=0.0)
-    """Delay of the transmission between the presynaptic and the postsynaptic cells."""
-    parameters = config.list(type=Parameter)
-    """List of parameters to assign to the synapse model."""
+    delay = config.attr(type=float, default=1.0)
+    """
+    Delay of the transmission between the presynaptic and the postsynaptic cells, in
+    milliseconds. Defaults to NEURON's own ``NetCon`` delay of 1 ms.
+
+    The delays of a network set NEURON's ``mindelay``, which
+    ``ParallelContext.set_maxstep`` requires to be strictly positive and at least one
+    :attr:`~bsb_neuron.simulation.NeuronSimulation.resolution` step. A delay of 0
+    therefore aborts the simulation with ``usable mindelay is 0``.
+    """
 
     def __init__(self, synapse_name=None, /, **kwargs):
         if synapse_name is not None:
             self._synapse = synapse_name
 
 
+@dataclasses.dataclass(frozen=True, slots=True)
+class Receiver:
+    """
+    A synapse a connection makes on a cell, and the connection it belongs to.
+
+    Every synapse a connection model creates keeps its receiver as ``receiver``.
+    """
+
+    #: The transmitter gid the synapse receives from.
+    gid: int
+    #: The postsynaptic cell.
+    cell: typing.Any
+    #: Branch and point of the synapse on the postsynaptic cell.
+    location: tuple[int, int]
+    #: The synapse specification.
+    spec: SynapseSpec
+    #: The cell model of the presynaptic cell.
+    pre_model: typing.Any
+    #: Cell id, branch and point where the connection starts on the presynaptic cell.
+    pre: tuple[int, int, int]
+    #: Name of the connectivity set the connection is in.
+    connectivity_set: str
+
+
 @config.node
 class TransceiverModel(NeuronConnection, classmap_entry="transceiver"):
     synapses = config.list(
@@ -59,8 +92,6 @@ class TransceiverModel(NeuronConnection, classmap_entry="transceiver"):
         required=True,
     )
     """List of synapse models to use for a connection."""
-    parameters = config.list(type=Parameter)
-    """List of parameters to assign to the connection."""
     source = config.attr(type=str)
     """Source variable to assign to the connection."""
 
@@ -101,24 +132,55 @@ class TransceiverModel(NeuronConnection, classmap_entry="transceiver"):
         :type simdata: bsb_neuron.simulation.NeuronSimulationData
         :type cs: bsb.storage.interfaces.ConnectivitySet
         """
-        for post_cm, post_pop in simdata.populations.items():  # noqa: B007
-            if post_cm.cell_type == cs.post_type:
+        for receiver in self.iter_receivers(simdata, cs):
+            receiver.cell.insert_receiver(
+                receiver.gid,
+                receiver.spec.synapse,
+                receiver.location,
+                source=self.source,
+                weight=receiver.spec.weight,
+                delay=receiver.spec.delay,
+            )
+            # The receiver's synapse is the one it just appended to its section.
+            location = receiver.cell.get_location(receiver.location)
+            location.section.synapses[-1].receiver = receiver
+
+    def iter_receivers(self, simdata, cs):
+        """
+        Iterate the synapses the connectivity set makes on the cells of this rank, in
+        the order :meth:`create_receivers` inserts them.
+
+        :type simdata: bsb_neuron.simulation.NeuronSimulationData
+        :type cs: bsb.storage.interfaces.ConnectivitySet
+        :returns: The receivers, one per synapse.
+        :rtype: typing.Iterator[Receiver]
+        """
+        for post_model, post_pop in simdata.populations.items():  # noqa: B007
+            if post_model.cell_type == cs.post_type:
                 break
         else:
             raise AdapterError(f"No pop found for {cs.pre_type.name}")
-        pre, post = cs.load_connections().incoming().to(simdata.chunks).all()
+        pre_model = next(
+            (cm for cm in simdata.populations if cm.cell_type == cs.pre_type), None
+        )
+        query = cs.load_connections().incoming().to(simdata.chunks)
+        pre, post = query.all()
+        # The same connections with the presynaptic cells as placement set ids, which
+        # is how a synapse names the cell it receives from.
+        pre_globals = query.as_globals().all()[0]
         transmitters = simdata.transmap[self]["receivers"]
-        for pre_loc, post_loc in zip(pre[:, :2], post, strict=False):
-            gid = transmitters[tuple(pre_loc)]
+        for pre_loc, pre_global, post_loc in zip(pre, pre_globals, post, strict=True):
+            gid = transmitters[tuple(pre_loc[:2])]
             cell = post_pop[post_loc[0]]
             for spec in self.synapses:
-                cell.insert_receiver(
-                    gid,
-                    spec.synapse,
-                    post_loc[1:],
-                    source=self.source,
-                    weight=spec.weight,
-                    delay=spec.delay,
+                yield Receiver(
+                    gid=gid,
+                    cell=cell,
+                    location=tuple(int(i) for i in post_loc[1:]),
+                    spec=spec,
+                    pre_model=pre_model,
+                    pre=tuple(int(i) for i in pre_global),
+                    connectivity_set=cs.tag,
                 )
 
     def __lt__(self, other):

{bsb_neuron-7.6.0 → bsb_neuron-8.0.1}/bsb_neuron/devices/current_clamp.py

@@ -1,4 +1,4 @@
-from bsb import LocationTargetting, config, warn
+from bsb import LocationTargetting, config, point_annotations, warn
 
 from .._util import ignore_arborize_proxy_warnings
 from ..device import NeuronDevice
@@ -24,19 +24,22 @@ class CurrentClamp(NeuronDevice, classmap_entry="current_clamp"):
                 for location in self.locations.get_locations(target):
                     if clamped:
                         warn(f"Multiple current clamps placed on {target}")
-                    self._add_clamp(
-                        simdata,
-                        location,
-                        name=self.name,
-                        cell_type=target.cell_model.name,
-                        cell_id=target.id,
-                    )
+                    self._add_clamp(simdata, target, location)
                     clamped = True
 
     @ignore_arborize_proxy_warnings()
-    def _add_clamp(self, simdata, location, **annotations):
+    def _add_clamp(self, simdata, target, location):
         sx = location.arc(0.5)
         clamp = location.section.iclamp(
             x=sx, delay=self.before, duration=self.duration, amplitude=self.amplitude
         )
-        simdata.result.record(clamp._ref_i, **annotations, units="nA")
+        # The clamp records the current it injects.
+        simdata.result.record(
+            clamp._ref_i,
+            device=self,
+            target=point_annotations(
+                target.cell_model, target.id, *location._loc, sx, "stimulate"
+            ),
+            name="i",
+            units="nA",
+        )

bsb_neuron-8.0.1/bsb_neuron/devices/synapse_recorder.py

@@ -0,0 +1,59 @@
+from bsb import LocationTargetting, config, synapse_annotations, warn
+
+from .._util import ignore_arborize_proxy_warnings
+from ..device import NeuronDevice
+
+
+@config.node
+class SynapseRecorder(NeuronDevice, classmap_entry="synapse_recorder"):
+    locations = config.attr(type=LocationTargetting, required=True)
+    """Location of the synapse recorder on the section"""
+    synapse_types = config.list()
+    """List of synaptic types"""
+
+    @ignore_arborize_proxy_warnings()
+    def implement(self, adapter, simulation, simdata):
+        for _model, pop in self.targetting.get_targets(
+            adapter, simulation, simdata
+        ).items():
+            for target in pop:
+                # Locations on the same section share its synapses, so each synapse
+                # is recorded once however many of the targeted locations hold it.
+                synapses = {
+                    id(synapse): synapse
+                    for location in self.locations.get_locations(target)
+                    for synapse in location.section.synapses
+                    if not self.synapse_types
+                    or synapse.synapse_name in self.synapse_types
+                }
+                for synapse in synapses.values():
+                    self._record_synaptic_current(simdata.result, target, synapse)
+
+    def _record_synaptic_current(self, result, target, synapse):
+        receiver = getattr(synapse, "receiver", None)
+        if receiver is None:
+            warn(
+                f"Device '{self.name}' cannot record a '{synapse.synapse_name}' synapse "
+                f"of cell {target.id}: it was not made by a connection, so where it is "
+                "and what it connects is unknown."
+            )
+            return
+        pre_id, pre_branch, pre_point = receiver.pre
+        location = target.get_location(receiver.location)
+        result.record(
+            synapse._pp._ref_i,
+            device=self,
+            name="i",
+            units="nA",
+            target=synapse_annotations(
+                (target.cell_model, target.id, *receiver.location, location.arc(0.5)),
+                synapse.synapse_name,
+                "record",
+                pre=(
+                    None
+                    if receiver.pre_model is None
+                    else (receiver.pre_model, pre_id, pre_branch, pre_point)
+                ),
+                connectivity_set=receiver.connectivity_set,
+            ),
+        )

{bsb_neuron-7.6.0 → bsb_neuron-8.0.1}/bsb_neuron/devices/voltage_clamp.py

@@ -1,6 +1,6 @@
 import warnings
 
-from bsb import LocationTargetting, config, types
+from bsb import LocationTargetting, config, point_annotations, types
 
 from .._util import ignore_arborize_proxy_warnings
 from ..device import NeuronDevice
@@ -25,25 +25,22 @@ class VoltageClamp(NeuronDevice, classmap_entry="vclamp"):
     """Voltage value in the `before` and `after` delays"""
 
     def implement(self, adapter, simulation, simdata):
-        for target in self.targetting.get_targets(adapter, simulation, simdata):
-            clamped = False
-            for location in self.locations.get_locations(target):
-                if clamped:
-                    warnings.warn(
-                        f"Multiple voltage clamps placed on {target}",
-                        stacklevel=2,
-                    )
-                self._add_clamp(
-                    simdata.results,
-                    location,
-                    name=self.name,
-                    cell_type=target.cell_model.name,
-                    cell_id=target.id,
-                )
-                clamped = True
+        for _model, pop in self.targetting.get_targets(
+            adapter, simulation, simdata
+        ).items():
+            for target in pop:
+                clamped = False
+                for location in self.locations.get_locations(target):
+                    if clamped:
+                        warnings.warn(
+                            f"Multiple voltage clamps placed on {target}",
+                            stacklevel=2,
+                        )
+                    self._add_clamp(simdata.result, target, location)
+                    clamped = True
 
     @ignore_arborize_proxy_warnings()
-    def _add_clamp(self, results, location, **annotations):
+    def _add_clamp(self, results, target, location):
         sx = location.arc(0.5)
         clamp = location.section.vclamp(
             voltage=self.voltage,
@@ -54,4 +51,13 @@ class VoltageClamp(NeuronDevice, classmap_entry="vclamp"):
                 if (v := getattr(self, k)) is not None
             },
         )
-        results.record(clamp, **annotations)
+        # The clamp records the current it injects to hold the voltage.
+        results.record(
+            clamp._ref_i,
+            device=self,
+            target=point_annotations(
+                target.cell_model, target.id, *location._loc, sx, "stimulate"
+            ),
+            name="i",
+            units="nA",
+        )

{bsb_neuron-7.6.0 → bsb_neuron-8.0.1}/bsb_neuron/devices/voltage_recorder.py

@@ -1,4 +1,4 @@
-from bsb import LocationTargetting, config
+from bsb import LocationTargetting, config, point_annotations
 
 from .._util import ignore_arborize_proxy_warnings
 from ..device import NeuronDevice
@@ -17,16 +17,18 @@ class VoltageRecorder(NeuronDevice, classmap_entry="voltage_recorder"):
         ).items():
             for target in pop:
                 for location in self.locations.get_locations(target):
-                    self._add_voltage_recorder(
-                        simdata.result,
-                        location,
-                        name=self.name,
-                        cell_type=target.cell_model.name,
-                        cell_id=target.id,
-                    )
+                    self._add_voltage_recorder(simdata.result, target, location)
 
     @ignore_arborize_proxy_warnings()
-    def _add_voltage_recorder(self, results, location, **annotations):
+    def _add_voltage_recorder(self, results, target, location):
         section = location.section
         x = location.arc(0)
-        results.record(section(x)._ref_v, **annotations)
+        results.record(
+            section(x)._ref_v,
+            device=self,
+            target=point_annotations(
+                target.cell_model, target.id, *location._loc, x, "record"
+            ),
+            name="v",
+            units="mV",
+        )

{bsb_neuron-7.6.0 → bsb_neuron-8.0.1}/pyproject.toml

@@ -6,18 +6,19 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "bsb-neuron"
-version = "7.6.0"
+version = "8.0.1"
 readme = "README.md"
-requires-python = ">=3.10,<4"
+requires-python = ">=3.11,<4"
 dynamic = [ "description" ]
 classifiers = [
   "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)"
 ]
 dependencies = [
-  "bsb-core~=7.0",
-  "nrn-patch~=7.0; sys_platform != 'win32'",
-  "arborize[neuron]~=7.0; sys_platform != 'win32'"
+  "bsb-core~=8.0",
+  "nrn-patch~=8.0 ; sys_platform != 'win32'",
+  "arborize[neuron]~=8.0 ; sys_platform != 'win32'"
 ]
+optional-dependencies = { }
 
   [[project.authors]]
   name = "Robin De Schepper"
@@ -30,15 +31,27 @@ dependencies = [
   [project.license]
   file = "LICENSE"
 
-  [project.optional-dependencies]
-  parallel = [ "bsb-core[parallel]" ]
-
 [project.entry-points."bsb.simulation_backends"]
 neuron = "bsb_neuron"
 
 [tool.uv]
 default-groups = [ "dev", "docs", "test" ]
-sources = { }
+
+[tool.uv.sources.bsb-hdf5]
+path = "../bsb-hdf5"
+editable = true
+
+[tool.uv.sources.bsb-test]
+path = "../bsb-test"
+editable = true
+
+[tool.uv.sources.bsb-otel]
+path = "../bsb-otel"
+editable = true
+
+[tool.uv.sources.sphinxext-bsb]
+path = "../../libs/sphinxext-bsb"
+editable = true
 
 [tool.flit.module]
 name = "bsb_neuron"

bsb_neuron-7.6.0/bsb_neuron/devices/synapse_recorder.py

@@ -1,37 +0,0 @@
-from bsb import LocationTargetting, config
-
-from .._util import ignore_arborize_proxy_warnings
-from ..device import NeuronDevice
-
-
-@config.node
-class SynapseRecorder(NeuronDevice, classmap_entry="synapse_recorder"):
-    locations = config.attr(type=LocationTargetting, required=True)
-    """Location of the synapse recorder on the section"""
-    synapse_types = config.list()
-    """List of synaptic types"""
-
-    @ignore_arborize_proxy_warnings()
-    def implement(self, adapter, simulation, simdata):
-        for _model, pop in self.targetting.get_targets(
-            adapter, simulation, simdata
-        ).items():
-            for target in pop:
-                for location in self.locations.get_locations(target):
-                    for synapse in location.section.synapses:
-                        if (
-                            not self.synapse_types
-                            or synapse.synapse_name in self.synapse_types
-                        ):
-                            _record_synaptic_current(
-                                simdata.result,
-                                synapse,
-                                name=self.name,
-                                cell_type=target.cell_model.name,
-                                cell_id=target.id,
-                                synapse_type=synapse.synapse_name,
-                            )
-
-
-def _record_synaptic_current(result, synapse, **annotations):
-    result.record(synapse._pp._ref_i, **annotations, units="nA")

{bsb_neuron-7.6.0 → bsb_neuron-8.0.1}/bsb_neuron/simulation.py

@@ -11,10 +11,10 @@ class NeuronSimulation(Simulation):
     Interface between the scaffold model and the NEURON simulator.
     """
 
-    initial = config.attr(type=float, default=-65.0)
-    """Initial membrane potential for all neurons."""
     resolution = config.attr(type=types.float(min=0.0), default=0.1)
     """Simulation time step size in milliseconds."""
+    initial = config.attr(type=float, default=-65.0)
+    """Initial membrane potential for all neurons."""
     temperature = config.attr(type=float, required=True)
     """Temperature of the circuit during simulation."""
     cell_models: config._attrs.cfgdict[NeuronCell] = config.dict(