bsb-nest 4.2.1__tar.gz → 4.3.1__tar.gz

{bsb_nest-4.2.1 → bsb_nest-4.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: bsb-nest
-Version: 4.2.1
+Version: 4.3.1
 Summary: NEST simulation adapter for the BSB framework.
 Author-email: Robin De Schepper <robingilbert.deschepper@unipv.it>
 Description-Content-Type: text/markdown
@@ -24,7 +24,7 @@ Provides-Extra: dev
 Provides-Extra: parallel
 Provides-Extra: test
 
-[![Build Status](https://github.com/dbbs-lab/bsb-nest/actions/workflows/build.yml/badge.svg)](https://github.com/dbbs-lab/bsb-nest/actions/workflows/build.yml)
+[![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)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 # bsb-nest

{bsb_nest-4.2.1 → bsb_nest-4.3.1}/README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://github.com/dbbs-lab/bsb-nest/actions/workflows/build.yml/badge.svg)](https://github.com/dbbs-lab/bsb-nest/actions/workflows/build.yml)
+[![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)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 # bsb-nest

{bsb_nest-4.2.1 → bsb_nest-4.3.1}/bsb_nest/__init__.py

@@ -9,4 +9,4 @@ from .adapter import NestAdapter
 from .simulation import NestSimulation
 
 __plugin__ = SimulationBackendPlugin(Simulation=NestSimulation, Adapter=NestAdapter)
-__version__ = "4.2.1"
+__version__ = "4.3.1"

bsb_nest-4.3.1/bsb_nest/device.py

@@ -0,0 +1,122 @@
+import typing
+import warnings
+
+import nest
+from bsb import DeviceModel, SimulationData, Targetting, config, refs, types
+
+if typing.TYPE_CHECKING:
+    from .adapter import NestAdapter
+    from .simulation import NestSimulation
+
+
+@config.node
+class NestRule:
+    rule = config.attr(type=str, required=True)
+    constants = config.catch_all(type=types.any_())
+    cell_models = config.reflist(refs.sim_cell_model_ref)
+
+
+@config.dynamic(attr_name="device", auto_classmap=True, default="external")
+class NestDevice(DeviceModel):
+    weight = config.attr(type=float, required=True)
+    """weight of the connection between the device and its target"""
+    delay = config.attr(type=float, required=True)
+    """delay of the transmission between the device and its target"""
+    targetting = config.attr(
+        type=types.or_(Targetting, NestRule), default=dict, call_default=True
+    )
+    """Targets of the device, which should be either a population or a nest rule"""
+    receptor_type = config.attr(type=int, required=False, default=0)
+    """Integer ID of the postsynaptic target receptor"""
+
+    def get_dict_targets(
+        self,
+        adapter: "NestAdapter",
+        simulation: "NestSimulation",
+        simdata: "SimulationData",
+    ) -> dict:
+        """
+        Get a dictionary from a target group to its NEST Collection
+        for each target group of the device.
+
+        :param bsb_nest.NestAdapter adapter:
+        :param bsb_nest.NestSimulation simulation: Nest simulation instance
+        :param bsb.SimulationData simdata: Simulation data instance
+        :return: dictionary of device target group to NEST Collection
+        :rtype: dict
+        """
+        if isinstance(self.targetting, Targetting):
+            node_collector = self.targetting.get_targets(adapter, simulation, simdata)
+        else:
+            node_collector = {
+                model: simdata.populations[model][targets]
+                for model, targets in simdata.populations.items()
+                if not self.targetting.cell_models or model in self.targetting.cell_models
+            }
+        return node_collector
+
+    @staticmethod
+    def _flatten_nodes_ids(dict_targets):
+        return sum(dict_targets.values(), start=nest.NodeCollection())
+
+    @staticmethod
+    def _invert_targets_dict(dict_targets):
+        return {elem: k.name for k, v in dict_targets.items() for elem in v.tolist()}
+
+    def get_target_nodes(
+        self,
+        adapter: "NestAdapter",
+        simulation: "NestSimulation",
+        simdata: "SimulationData",
+    ):
+        """
+        Get the NEST Collection of the targets of the device.
+
+        :param bsb_nest.NestAdapter adapter:
+        :param bsb_nest.NestSimulation simulation: Nest simulation instance
+        :param bsb.SimulationData simdata: Simulation data instance
+        :return: Flattened NEST collection with all the targets of the device
+        """
+        targets_dict = self.get_dict_targets(adapter, simulation, simdata)
+        return self._flatten_nodes_ids(targets_dict)
+
+    def connect_to_nodes(self, device, nodes):
+        if len(nodes) == 0:
+            warnings.warn(f"{self.name} has no targets")
+        else:
+            try:
+                nest.Connect(
+                    device,
+                    nodes,
+                    syn_spec={
+                        "weight": self.weight,
+                        "delay": self.delay,
+                        "receptor_type": self.receptor_type,
+                    },
+                )
+
+            except Exception as e:
+                if "does not send output" not in str(e):
+                    raise
+                nest.Connect(
+                    nodes,
+                    device,
+                    syn_spec={"weight": self.weight, "delay": self.delay},
+                )
+
+    def register_device(self, simdata, device):
+        simdata.devices[self] = device
+        return device
+
+
+@config.node
+class ExtNestDevice(NestDevice, classmap_entry="external"):
+    nest_model = config.attr(type=str, required=True)
+    constants = config.dict(type=types.or_(types.number(), str))
+
+    def implement(self, adapter, simulation, simdata):
+        simdata.devices[self] = device = nest.Create(
+            self.nest_model, params=self.constants
+        )
+        nodes = self.get_target_nodes(adapter, simulation, simdata)
+        self.connect_to_nodes(device, nodes)

{bsb_nest-4.2.1 → bsb_nest-4.3.1}/bsb_nest/devices/__init__.py

@@ -1,4 +1,5 @@
 from .dc_generator import DCGenerator
 from .multimeter import Multimeter
 from .poisson_generator import PoissonGenerator
+from .sinusoidal_poisson_generator import SinusoidalPoissonGenerator
 from .spike_recorder import SpikeRecorder

{bsb_nest-4.2.1 → bsb_nest-4.3.1}/bsb_nest/devices/multimeter.py

@@ -1,4 +1,5 @@
 import nest
+import numpy as np
 import quantities as pq
 from bsb import ConfigurationError, _util, config, types
 from neo import AnalogSignal
@@ -24,7 +25,9 @@ class Multimeter(NestDevice, classmap_entry="multimeter"):
 
     def implement(self, adapter, simulation, simdata):
 
-        nodes = self.get_target_nodes(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(
@@ -38,15 +41,20 @@ class Multimeter(NestDevice, classmap_entry="multimeter"):
         self.connect_to_nodes(device, nodes)
 
         def recorder(segment):
-            for prop, unit in zip(self.properties, self.units):
-                segment.analogsignals.append(
-                    AnalogSignal(
-                        device.events[prop],
-                        units=pq.units.__dict__[unit],
-                        sampling_period=self.simulation.resolution * pq.ms,
-                        name=self.name,
-                        senders=device.events["senders"],
+            senders = device.events["senders"]
+            for sender in np.unique(senders):
+                sender_filter = senders == sender
+                for prop, unit in zip(self.properties, self.units):
+                    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-4.2.1 → bsb_nest-4.3.1}/bsb_nest/devices/poisson_generator.py

@@ -35,6 +35,7 @@ class PoissonGenerator(NestDevice, classmap_entry="poisson_generator"):
                     senders=sr.events["senders"],
                     t_stop=simulation.duration,
                     device=self.name,
+                    pop_size=len(nodes),
                 )
             )
 

bsb_nest-4.3.1/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:
+            if self.stop <= self.start:
+                raise ConfigurationError(
+                    f"Stop time (given: {self.stop}) must be greater than start time (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",
+                    senders=sr.events["senders"],
+                    t_stop=simulation.duration,
+                    device=self.name,
+                    pop_size=len(nodes),
+                )
+            )
+
+        simdata.result.create_recorder(recorder)

{bsb_nest-4.2.1 → bsb_nest-4.3.1}/pyproject.toml

@@ -46,7 +46,7 @@ profile = "black"
 known_third_party = ["nest"]
 
 [tool.bumpversion]
-current_version = "4.2.1"
+current_version = "4.3.1"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

bsb_nest-4.2.1/bsb_nest/device.py

@@ -1,72 +0,0 @@
-import warnings
-
-import nest
-from bsb import DeviceModel, Targetting, config, refs, types
-
-
-@config.node
-class NestRule:
-    rule = config.attr(type=str, required=True)
-    constants = config.catch_all(type=types.any_())
-    cell_models = config.reflist(refs.sim_cell_model_ref)
-
-
-@config.dynamic(attr_name="device", auto_classmap=True, default="external")
-class NestDevice(DeviceModel):
-    weight = config.attr(type=float, required=True)
-    """weight of the connection between the device and its target"""
-    delay = config.attr(type=float, required=True)
-    """delay of the transmission between the device and its target"""
-    targetting = config.attr(
-        type=types.or_(Targetting, NestRule), default=dict, call_default=True
-    )
-    """Targets of the device, which should be either a population or a nest rule"""
-
-    def get_target_nodes(self, adapter, simulation, simdata):
-        if isinstance(self.targetting, Targetting):
-            node_collector = self.targetting.get_targets(
-                adapter, simulation, simdata
-            ).values()
-        else:
-            node_collector = (
-                simdata.populations[model][targets]
-                for model, targets in simdata.populations.items()
-                if not self.targetting.cell_models or model in self.targetting.cell_models
-            )
-        return sum(node_collector, start=nest.NodeCollection())
-
-    def connect_to_nodes(self, device, nodes):
-        if len(nodes) == 0:
-            warnings.warn(f"{self.name} has no targets")
-        else:
-            try:
-                nest.Connect(
-                    device,
-                    nodes,
-                    syn_spec={"weight": self.weight, "delay": self.delay},
-                )
-            except Exception as e:
-                if "does not send output" not in str(e):
-                    raise
-                nest.Connect(
-                    nodes,
-                    device,
-                    syn_spec={"weight": self.weight, "delay": self.delay},
-                )
-
-    def register_device(self, simdata, device):
-        simdata.devices[self] = device
-        return device
-
-
-@config.node
-class ExtNestDevice(NestDevice, classmap_entry="external"):
-    nest_model = config.attr(type=str, required=True)
-    constants = config.dict(type=types.or_(types.number(), str))
-
-    def implement(self, adapter, simulation, simdata):
-        simdata.devices[self] = device = nest.Create(
-            self.nest_model, params=self.constants
-        )
-        nodes = self.get_target_nodes(adapter, simdata)
-        self.connect_to_nodes(device, nodes)