bsb-nest 4.0.0rc2__py2.py3-none-any.whl → 4.2.0__py2.py3-none-any.whl

bsb_nest/connection.py

@@ -1,165 +1,164 @@
-import functools
-import sys
-
-import nest
-import numpy as np
-import psutil
-from bsb import MPI, ConnectionModel, compose_nodes, config, types
-from tqdm import tqdm
-
-from .exceptions import NestConnectError
-
-
-@config.node
-class NestSynapseSettings:
-    model = config.attr(type=str, default="static_synapse")
-    weight = config.attr(type=float, required=True)
-    delay = config.attr(type=float, required=True)
-    receptor_type = config.attr(type=int)
-    constants = config.catch_all(type=types.any_())
-
-
-@config.node
-class NestConnectionSettings:
-    rule = config.attr(type=str)
-    constants = config.catch_all(type=types.any_())
-
-
-class LazySynapseCollection:
-    def __init__(self, pre, post):
-        self._pre = pre
-        self._post = post
-
-    def __len__(self):
-        return self.collection.__len__()
-
-    def __str__(self):
-        return self.collection.__str__()
-
-    def __iter__(self):
-        return iter(self.collection)
-
-    def __getattr__(self, attr):
-        return getattr(self.collection, attr)
-
-    @functools.cached_property
-    def collection(self):
-        return nest.GetConnections(self._pre, self._post)
-
-
-@config.dynamic(attr_name="model_strategy", required=False)
-class NestConnection(compose_nodes(NestConnectionSettings, ConnectionModel)):
-    tag = config.attr(type=str)
-    synapse = config.attr(type=NestSynapseSettings, required=True)
-
-    def create_connections(self, simdata, pre_nodes, post_nodes, cs):
-        import nest
-
-        syn_spec = self.get_syn_spec()
-        if syn_spec["synapse_model"] not in nest.Models(mtype="synapses"):
-            raise NestConnectError(
-                f"Unknown synapse model '{syn_spec['synapse_model']}'."
-            )
-        if self.rule is not None:
-            nest.Connect(pre_nodes, post_nodes, self.get_conn_spec(), syn_spec)
-        else:
-            MPI.barrier()
-            for pre_locs, post_locs in self.predict_mem_iterator(
-                pre_nodes, post_nodes, cs
-            ):
-                MPI.barrier()
-                cell_pairs, multiplicity = np.unique(
-                    np.column_stack((pre_locs[:, 0], post_locs[:, 0])),
-                    return_counts=True,
-                    axis=0,
-                )
-                prel = pre_nodes.tolist()
-                postl = post_nodes.tolist()
-                ssw = {**syn_spec}
-                bw = syn_spec["weight"]
-                ssw["weight"] = [bw * m for m in multiplicity]
-                ssw["delay"] = [syn_spec["delay"]] * len(ssw["weight"])
-                nest.Connect(
-                    [prel[x] for x in cell_pairs[:, 0]],
-                    [postl[x] for x in cell_pairs[:, 1]],
-                    "one_to_one",
-                    ssw,
-                    return_synapsecollection=False,
-                )
-            MPI.barrier()
-        return LazySynapseCollection(pre_nodes, post_nodes)
-
-    def predict_mem_iterator(self, pre_nodes, post_nodes, cs):
-        avmem = psutil.virtual_memory().available
-        predicted_all_mem = (
-            len(pre_nodes) * 8 * 2
-            + len(post_nodes) * 8 * 2
-            + len(cs) * 6 * 8 * (16 + 2)
-        ) * MPI.get_size()
-        predicted_local_mem = predicted_all_mem / len(cs.get_local_chunks("out"))
-        if predicted_local_mem > avmem / 2:
-            # Iterate block-by-block
-            return self.block_iterator(cs)
-        elif predicted_all_mem > avmem / 2:
-            # Iterate local hyperblocks
-            return self.local_iterator(cs)
-        else:
-            # Iterate all
-            return (cs.load_connections().as_globals().all(),)
-
-    def block_iterator(self, cs):
-        locals = cs.get_local_chunks("out")
-
-        def block_iter():
-            iter = locals
-            if MPI.get_rank() == 0:
-                iter = tqdm(iter, desc="hyperblocks", file=sys.stdout)
-            for local in iter:
-                inner_iter = cs.load_connections().as_globals().from_(local)
-                if MPI.get_rank() == 0:
-                    yield from tqdm(
-                        inner_iter,
-                        desc="blocks",
-                        total=len(cs.get_global_chunks("out", local)),
-                        file=sys.stdout,
-                        leave=False,
-                    )
-                else:
-                    yield from inner_iter
-
-        return block_iter()
-
-    def local_iterator(self, cs):
-        iter = cs.get_local_chunks("out")
-        if MPI.get_rank() == 0:
-            iter = tqdm(iter, desc="hyperblocks", file=sys.stdout)
-        yield from (
-            cs.load_connections().as_globals().from_(local).all() for local in iter
-        )
-
-    def get_connectivity_set(self):
-        if self.tag is not None:
-            return self.scaffold.get_connectivity_set(self.tag)
-        else:
-            return self.connection_model
-
-    def get_conn_spec(self):
-        return {
-            "rule": self.rule,
-            **self.constants,
-        }
-
-    def get_syn_spec(self):
-        return {
-            **{
-                label: value
-                for attr, label in (
-                    ("model", "synapse_model"),
-                    ["weight"] * 2,
-                    ["delay"] * 2,
-                    ["receptor_type"] * 2,
-                )
-                if (value := getattr(self.synapse, attr)) is not None
-            },
-            **self.synapse.constants,
-        }
+import functools
+import sys
+
+import nest
+import numpy as np
+import psutil
+from bsb import MPI, ConnectionModel, compose_nodes, config, types
+from tqdm import tqdm
+
+from .distributions import nest_parameter
+from .exceptions import NestConnectError
+
+
+@config.node
+class NestSynapseSettings:
+    model = config.attr(type=str, default="static_synapse")
+    weight = config.attr(type=float, required=True)
+    delay = config.attr(type=float, required=True)
+    receptor_type = config.attr(type=int)
+    constants = config.catch_all(type=nest_parameter())
+
+
+@config.node
+class NestConnectionSettings:
+    rule = config.attr(type=str)
+    constants = config.catch_all(type=types.any_())
+
+
+class LazySynapseCollection:
+    def __init__(self, pre, post):
+        self._pre = pre
+        self._post = post
+
+    def __len__(self):
+        return self.collection.__len__()
+
+    def __str__(self):
+        return self.collection.__str__()
+
+    def __iter__(self):
+        return iter(self.collection)
+
+    def __getattr__(self, attr):
+        return getattr(self.collection, attr)
+
+    @functools.cached_property
+    def collection(self):
+        return nest.GetConnections(self._pre, self._post)
+
+
+@config.dynamic(attr_name="model_strategy", required=False)
+class NestConnection(compose_nodes(NestConnectionSettings, ConnectionModel)):
+    tag = config.attr(type=str)
+    synapse = config.attr(type=NestSynapseSettings, required=True)
+
+    def create_connections(self, simdata, pre_nodes, post_nodes, cs):
+        import nest
+
+        syn_spec = self.get_syn_spec()
+        if syn_spec["synapse_model"] not in nest.Models(mtype="synapses"):
+            raise NestConnectError(
+                f"Unknown synapse model '{syn_spec['synapse_model']}'."
+            )
+        if self.rule is not None:
+            nest.Connect(pre_nodes, post_nodes, self.get_conn_spec(), syn_spec)
+        else:
+            MPI.barrier()
+            for pre_locs, post_locs in self.predict_mem_iterator(
+                pre_nodes, post_nodes, cs
+            ):
+                MPI.barrier()
+                cell_pairs, multiplicity = np.unique(
+                    np.column_stack((pre_locs[:, 0], post_locs[:, 0])),
+                    return_counts=True,
+                    axis=0,
+                )
+                prel = pre_nodes.tolist()
+                postl = post_nodes.tolist()
+                ssw = {**syn_spec}
+                bw = syn_spec["weight"]
+                ssw["weight"] = [bw * m for m in multiplicity]
+                ssw["delay"] = [syn_spec["delay"]] * len(ssw["weight"])
+                nest.Connect(
+                    [prel[x] for x in cell_pairs[:, 0]],
+                    [postl[x] for x in cell_pairs[:, 1]],
+                    "one_to_one",
+                    ssw,
+                    return_synapsecollection=False,
+                )
+            MPI.barrier()
+        return LazySynapseCollection(pre_nodes, post_nodes)
+
+    def predict_mem_iterator(self, pre_nodes, post_nodes, cs):
+        avmem = psutil.virtual_memory().available
+        predicted_all_mem = (
+            len(pre_nodes) * 8 * 2 + len(post_nodes) * 8 * 2 + len(cs) * 6 * 8 * (16 + 2)
+        ) * MPI.get_size()
+        predicted_local_mem = predicted_all_mem / len(cs.get_local_chunks("out"))
+        if predicted_local_mem > avmem / 2:
+            # Iterate block-by-block
+            return self.block_iterator(cs)
+        elif predicted_all_mem > avmem / 2:
+            # Iterate local hyperblocks
+            return self.local_iterator(cs)
+        else:
+            # Iterate all
+            return (cs.load_connections().as_globals().all(),)
+
+    def block_iterator(self, cs):
+        locals = cs.get_local_chunks("out")
+
+        def block_iter():
+            iter = locals
+            if MPI.get_rank() == 0:
+                iter = tqdm(iter, desc="hyperblocks", file=sys.stdout)
+            for local in iter:
+                inner_iter = cs.load_connections().as_globals().from_(local)
+                if MPI.get_rank() == 0:
+                    yield from tqdm(
+                        inner_iter,
+                        desc="blocks",
+                        total=len(cs.get_global_chunks("out", local)),
+                        file=sys.stdout,
+                        leave=False,
+                    )
+                else:
+                    yield from inner_iter
+
+        return block_iter()
+
+    def local_iterator(self, cs):
+        iter = cs.get_local_chunks("out")
+        if MPI.get_rank() == 0:
+            iter = tqdm(iter, desc="hyperblocks", file=sys.stdout)
+        yield from (
+            cs.load_connections().as_globals().from_(local).all() for local in iter
+        )
+
+    def get_connectivity_set(self):
+        if self.tag is not None:
+            return self.scaffold.get_connectivity_set(self.tag)
+        else:
+            return self.connection_model
+
+    def get_conn_spec(self):
+        return {
+            "rule": self.rule,
+            **self.constants,
+        }
+
+    def get_syn_spec(self):
+        return {
+            **{
+                label: value
+                for attr, label in (
+                    ("model", "synapse_model"),
+                    ["weight"] * 2,
+                    ["delay"] * 2,
+                    ["receptor_type"] * 2,
+                )
+                if (value := getattr(self.synapse, attr)) is not None
+            },
+            **self.synapse.constants,
+        }

bsb_nest/device.py

@@ -1,70 +1,72 @@
-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)
-    delay = config.attr(type=float, required=True)
-    targetting = config.attr(
-        type=types.or_(Targetting, NestRule), default=dict, call_default=True
-    )
-
-    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)
+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)

bsb_nest/devices/__init__.py

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

bsb_nest/devices/dc_generator.py

@@ -0,0 +1,23 @@
+import nest
+from bsb import config
+
+from ..device import NestDevice
+
+
+@config.node
+class DCGenerator(NestDevice, classmap_entry="dc_generator"):
+    amplitude = config.attr(type=float, required=True)
+    """Current amplitude of the dc 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 = {"amplitude": self.amplitude, "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("dc_generator", params=params))
+        self.connect_to_nodes(device, nodes)

bsb_nest/devices/multimeter.py

@@ -0,0 +1,52 @@
+import nest
+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 not self.units[i] in pq.units.__dict__.keys():
+                raise ConfigurationError(
+                    f"Unit {self.units[i]} not in the list of known units of quantities"
+                )
+
+    def implement(self, adapter, simulation, simdata):
+
+        nodes = self.get_target_nodes(adapter, simulation, simdata)
+        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):
+            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"],
+                    )
+                )
+
+        simdata.result.create_recorder(recorder)

bsb_nest/devices/poisson_generator.py

@@ -1,32 +1,41 @@
-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)
-
-    def implement(self, adapter, simulation, simdata):
-        nodes = self.get_target_nodes(adapter, simulation, simdata)
-        device = self.register_device(
-            simdata, nest.Create("poisson_generator", params={"rate": self.rate})
-        )
-        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,
-                )
-            )
-
-        simdata.result.create_recorder(recorder)
+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",
+                    senders=sr.events["senders"],
+                    t_stop=simulation.duration,
+                    device=self.name,
+                )
+            )
+
+        simdata.result.create_recorder(recorder)