bsb-nest 5.0.0__py3-none-any.whl

bsb_nest/devices/multimeter.py

@@ -0,0 +1,59 @@
+import nest
+import numpy as np
+import quantities as pq
+from bsb import ConfigurationError, _util, config, types
+from neo import AnalogSignal
+
+from ..device import NestDevice
+
+
+@config.node
+class Multimeter(NestDevice, classmap_entry="multimeter"):
+    weight = config.provide(1)
+    properties: list[str] = config.attr(type=types.list(str))
+    """List of properties to record in the Nest model."""
+    units: list[str] = config.attr(type=types.list(str))
+    """List of properties' units."""
+
+    def boot(self):
+        _util.assert_samelen(self.properties, self.units)
+        for i in range(len(self.units)):
+            if self.units[i] not in pq.units.__dict__:
+                raise ConfigurationError(
+                    f"Unit {self.units[i]} not in the list of known units of quantities"
+                )
+
+    def implement(self, adapter, simulation, simdata):
+        targets_dict = self.get_dict_targets(adapter, simulation, simdata)
+        nodes = self._flatten_nodes_ids(targets_dict)
+        inv_targets = self._invert_targets_dict(targets_dict)
+        device = self.register_device(
+            simdata,
+            nest.Create(
+                "multimeter",
+                params={
+                    "interval": self.simulation.resolution,
+                    "record_from": self.properties,
+                },
+            ),
+        )
+        self.connect_to_nodes(device, nodes)
+
+        def recorder(segment):
+            senders = device.events["senders"]
+            for sender in np.unique(senders):
+                sender_filter = senders == sender
+                for prop, unit in zip(self.properties, self.units, strict=False):
+                    segment.analogsignals.append(
+                        AnalogSignal(
+                            device.events[prop][sender_filter],
+                            units=pq.units.__dict__[unit],
+                            sampling_period=self.simulation.resolution * pq.ms,
+                            name=self.name,
+                            cell_type=inv_targets[sender],
+                            cell_id=sender,
+                            prop_recorded=prop,
+                        )
+                    )
+
+        simdata.result.create_recorder(recorder)

bsb_nest/devices/poisson_generator.py

@@ -0,0 +1,42 @@
+import nest
+from bsb import config
+from neo import SpikeTrain
+
+from ..device import NestDevice
+
+
+@config.node
+class PoissonGenerator(NestDevice, classmap_entry="poisson_generator"):
+    rate = config.attr(type=float, required=True)
+    """Frequency of the poisson generator"""
+    start = config.attr(type=float, required=False, default=0.0)
+    """Activation time in ms"""
+    stop = config.attr(type=float, required=False, default=None)
+    """Deactivation time in ms. 
+        If not specified, generator will last until the end of the simulation."""
+
+    def implement(self, adapter, simulation, simdata):
+        nodes = self.get_target_nodes(adapter, simulation, simdata)
+        params = {"rate": self.rate, "start": self.start}
+        if self.stop is not None and self.stop > self.start:
+            params["stop"] = self.stop
+        device = self.register_device(
+            simdata, nest.Create("poisson_generator", params=params)
+        )
+        sr = nest.Create("spike_recorder")
+        nest.Connect(device, sr)
+        self.connect_to_nodes(device, nodes)
+
+        def recorder(segment):
+            segment.spiketrains.append(
+                SpikeTrain(
+                    sr.events["times"],
+                    units="ms",
+                    array_annotations={"senders": sr.events["senders"]},
+                    t_stop=simulation.duration,
+                    device=self.name,
+                    pop_size=len(nodes),
+                )
+            )
+
+        simdata.result.create_recorder(recorder)

bsb_nest/devices/sinusoidal_poisson_generator.py

@@ -0,0 +1,63 @@
+import nest
+from bsb import ConfigurationError, config
+from neo import SpikeTrain
+
+from ..device import NestDevice
+
+
+@config.node
+class SinusoidalPoissonGenerator(
+    NestDevice, classmap_entry="sinusoidal_poisson_generator"
+):
+    rate = config.attr(type=float, required=True)
+    """Rate of the poisson generator"""
+    amplitude = config.attr(type=float, required=True)
+    """Amplitude of the sinusoidal signal"""
+    frequency = config.attr(type=float, required=True)
+    """Frequency of the sinusoidal signal"""
+    phase = config.attr(type=float, required=False, default=0.0)
+    """Phase of the sinusoidal signal"""
+    start = config.attr(type=float, required=False, default=0.0)
+    """Activation time in ms"""
+    stop = config.attr(type=float, required=False, default=None)
+    """Deactivation time in ms. 
+        If not specified, generator will last until the end of the simulation."""
+
+    def boot(self):
+        if self.stop is not None and self.stop <= self.start:
+            raise ConfigurationError(
+                f"Stop time (given: {self.stop}) must be greater than start time "
+                f"(given: {self.start})."
+            )
+
+    def implement(self, adapter, simulation, simdata):
+        nodes = self.get_target_nodes(adapter, simulation, simdata)
+        params = {
+            "rate": self.rate,
+            "start": self.start,
+            "amplitude": self.amplitude,
+            "frequency": self.frequency,
+            "phase": self.phase,
+        }
+        if self.stop is not None:
+            params["stop"] = self.stop
+        device = self.register_device(
+            simdata, nest.Create("sinusoidal_poisson_generator", params=params)
+        )
+        sr = nest.Create("spike_recorder")
+        nest.Connect(device, sr)
+        self.connect_to_nodes(device, nodes)
+
+        def recorder(segment):
+            segment.spiketrains.append(
+                SpikeTrain(
+                    sr.events["times"],
+                    units="ms",
+                    array_annotations={"senders": sr.events["senders"]},
+                    t_stop=simulation.duration,
+                    device=self.name,
+                    pop_size=len(nodes),
+                )
+            )
+
+        simdata.result.create_recorder(recorder)

bsb_nest/devices/spike_recorder.py

@@ -0,0 +1,29 @@
+import nest
+from bsb import config
+from neo import SpikeTrain
+
+from ..device import NestDevice
+
+
+@config.node
+class SpikeRecorder(NestDevice, classmap_entry="spike_recorder"):
+    weight = config.provide(1)
+
+    def implement(self, adapter, simulation, simdata):
+        nodes = self.get_target_nodes(adapter, simulation, simdata)
+        device = self.register_device(simdata, nest.Create("spike_recorder"))
+        self.connect_to_nodes(device, nodes)
+
+        def recorder(segment):
+            segment.spiketrains.append(
+                SpikeTrain(
+                    device.events["times"],
+                    units="ms",
+                    array_annotations={"senders": device.events["senders"]},
+                    t_stop=simulation.duration,
+                    device=self.name,
+                    pop_size=len(nodes),
+                )
+            )
+
+        simdata.result.create_recorder(recorder)

bsb_nest/distributions.py

@@ -0,0 +1,60 @@
+import builtins
+import typing
+
+import errr
+import nest.random.hl_api_random as _distributions
+from bsb import DistributionCastError, Scaffold, TypeHandler, config, types
+
+_available_distributions = [d for d in _distributions.__all__]
+
+
+@config.node
+class NestRandomDistribution:
+    """
+    Class to handle NEST random distributions.
+    """
+
+    scaffold: "Scaffold"
+    distribution: str = config.attr(
+        type=types.in_(_available_distributions), required=True
+    )
+    """Distribution name. Should correspond to a function of nest.random.hl_api_random"""
+    parameters: dict[str, typing.Any] = config.catch_all(type=types.any_())
+    """Dictionary of parameters to assign to the distribution. 
+    Should correspond to NEST's"""
+
+    def __init__(self, **kwargs):
+        try:
+            self._distr = getattr(_distributions, self.distribution)(**self.parameters)
+        except Exception as e:
+            errr.wrap(
+                DistributionCastError, e, prepend=f"Can't cast to '{self.distribution}': "
+            )
+
+    def __call__(self):
+        return self._distr
+
+    def __getattr__(self, attr):
+        # hasattr does not work here. So we use __dict__
+        if "_distr" not in self.__dict__:
+            raise AttributeError("No underlying _distr found for distribution node.")
+        return getattr(self._distr, attr)
+
+
+class nest_parameter(TypeHandler):
+    """
+    Type validator. Type casts the value or node to a Nest parameter, that can be either
+    a value or a NestRandomDistribution.
+    """
+
+    def __call__(self, value, _key=None, _parent=None):
+        if isinstance(value, builtins.dict) and "distribution" in value:
+            return NestRandomDistribution(**value, _key=_key, _parent=_parent)
+        return value
+
+    @property
+    def __name__(self):  # pragma: nocover
+        return "nest parameter"
+
+    def __inv__(self, value):
+        return value

bsb_nest/exceptions.py

@@ -0,0 +1,22 @@
+class KernelWarning(Warning):
+    pass
+
+
+class NestError(Exception):
+    pass
+
+
+class NestKernelError(NestError):
+    pass
+
+
+class NestModuleError(NestKernelError):
+    pass
+
+
+class NestModelError(NestError):
+    pass
+
+
+class NestConnectError(NestError):
+    pass

bsb_nest/simulation.py

@@ -0,0 +1,36 @@
+from bsb import Simulation, config, types
+
+from .cell import NestCell
+from .connection import NestConnection
+from .device import NestDevice
+
+
+@config.node
+class NestSimulation(Simulation):
+    """
+    Interface between the scaffold model and the NEST simulator.
+    """
+
+    modules = config.list(type=str)
+    """List of NEST modules to load at the beginning of the simulation"""
+    threads = config.attr(type=types.int(min=1), default=1)
+    """Number of threads to use during simulation"""
+    resolution = config.attr(type=types.float(min=0.0), required=True)
+    """Simulation time step size in milliseconds"""
+    verbosity = config.attr(type=str, default="M_ERROR")
+    """NEST verbosity level"""
+    seed = config.attr(type=int, default=None)
+    """Random seed for the simulations"""
+
+    cell_models: config._attrs.cfgdict[NestCell] = config.dict(
+        type=NestCell, required=True
+    )
+    """Dictionary of cell models in the simulation."""
+    connection_models: config._attrs.cfgdict[NestConnection] = config.dict(
+        type=NestConnection, required=True
+    )
+    """Dictionary of connection models in the simulation."""
+    devices: config._attrs.cfgdict[NestDevice] = config.dict(
+        type=NestDevice, required=True
+    )
+    """Dictionary of devices in the simulation."""

bsb_nest-5.0.0.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: bsb-nest
+Version: 5.0.0
+Summary: NEST simulation adapter for the BSB framework.
+Author-email: Robin De Schepper <robin@alexandria.sc>, Dimitri Rodarie <dimitri.rodarie@unipv.it>
+Requires-Python: >=3.10,<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~=6.0
+Requires-Dist: bsb-core[parallel] ; extra == "parallel"
+Provides-Extra: parallel
+
+[![Build Status](https://github.com/dbbs-lab/bsb-nest/actions/workflows/main.yml/badge.svg)](https://github.com/dbbs-lab/bsb-nest/actions/workflows/main.yml)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+# bsb-nest
+
+bsb-nest is a plugin of the [BSB](https://github.com/dbbs-lab/bsb). 
+It contains the interfaces and tools to simulate BSB circuit with the 
+[NEST simulator](https://www.nest-simulator.org/).
+

bsb_nest-5.0.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+bsb_nest/__init__.py,sha256=xWFB0-jFsVcMg3EiAbWXgIVLQeh7XGE2Vnj3bUpVVAc,558
+bsb_nest/adapter.py,sha256=jdUTfPo_ui6KBYnBFIrs8l7ObOxjMfe_OD6Zl9HIGwI,7782
+bsb_nest/cell.py,sha256=dkTpnF8z0rg5LjMXVMHeN2zXgwBEHlbee0MHxRxltZ8,1109
+bsb_nest/connection.py,sha256=PdJWQrDl-pmOhKv019c7GUVVMW7hTNEZ-GfHn2XkHEw,6553
+bsb_nest/device.py,sha256=ttLPsf4wZ4dwHEeTBSPpbjEVeM06xnE6dUJM8U3zT8Y,5276
+bsb_nest/distributions.py,sha256=qkQk9KqlqDDS4WXbokwhNTnu4IA-fcLFcTbqbVfj5fM,1903
+bsb_nest/exceptions.py,sha256=NX4oiGWIshrLG1DCak_nTfI8cQI7GTdewR71qNzsXGM,264
+bsb_nest/simulation.py,sha256=BOQkJ5X2o1tIL1nGpT0Q-JFuhTAB-HdyTYzIOoqHTTc,1301
+bsb_nest/devices/__init__.py,sha256=PJKVn09saFObRuiOYJ8fWAfDuxfvaZAJYqLp4altOAY,363
+bsb_nest/devices/dc_generator.py,sha256=g-jRZorCl2yYhr5bx2I00ZlxYrblDcqVbtk0XYZzmdI,953
+bsb_nest/devices/multimeter.py,sha256=Gy_rRBpEoxbPZVHCI14rVqp19GM31RMxoZL6_PQgq64,2246
+bsb_nest/devices/poisson_generator.py,sha256=g0t-L0s-JdGjT7x17vNi9HwLcBIBZybcAim0I4rPvl8,1529
+bsb_nest/devices/sinusoidal_poisson_generator.py,sha256=4L_EIXqn9qaUcozv17m3FK4IHlXW-mxEJcQAhRyC1ZI,2271
+bsb_nest/devices/spike_recorder.py,sha256=1ViQBtFICt1xACzoemSf-f9WSD949QCdggRk_muwrww,916
+bsb_nest-5.0.0.dist-info/entry_points.txt,sha256=uJlX9h2VeYfAumav18IM2PTJ3FssfwDUnUmfSFdR2SA,41
+bsb_nest-5.0.0.dist-info/licenses/LICENSE,sha256=ljOS4DjXvqEo5VzGfdaRwgRZPbNScGBmfwyC8PChvmQ,32422
+bsb_nest-5.0.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+bsb_nest-5.0.0.dist-info/METADATA,sha256=DQ9rCxDtoV_C7yDLQR47m6WXmAA6ItYoW0I2WzOOcMU,1013
+bsb_nest-5.0.0.dist-info/RECORD,,

bsb_nest-5.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any

bsb_nest-5.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[bsb.simulation_backends]
+nest=bsb_nest
+