bsb-arbor 6.0.0a5__py3-none-any.whl

bsb_arbor/devices/poisson_generator.py

@@ -0,0 +1,30 @@
+import arbor
+from arbor import units as U
+from bsb import config
+
+from ..connection import Receiver
+from ..device import ArborDevice
+
+
+@config.node
+class PoissonGenerator(ArborDevice, classmap_entry="poisson_generator"):
+    record = config.attr(type=bool, default=True)
+    """Flag to save the spikes generated to file."""
+    rate = config.attr(type=float, required=True)
+    """Frequency of the poisson generator."""
+    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."""
+
+    def implement_probes(self, simdata, gid):
+        return []
+
+    def implement_generators(self, simdata, gid):
+        target = Receiver(self, None, [-1, -1], [-1, -1], 0).on()
+        gen = arbor.event_generator(
+            target,
+            self.weight,
+            arbor.poisson_schedule(tstart=0 * U.ms, freq=self.rate * U.Hz, seed=gid),
+        )
+        return [gen]

bsb_arbor/devices/probe.py

@@ -0,0 +1,54 @@
+import arbor
+from bsb.exceptions import ConfigurationError
+
+from ..device import ArborDevice
+
+
+class Probe(ArborDevice):
+    required = ["targetting", "probe_type"]
+
+    def get_probe_name(self):
+        return f"cable_probe_{self.probe_type}"
+
+    def validate_specifics(self):
+        if self.get_probe_name() not in vars(arbor):
+            raise ConfigurationError(
+                f"`{self.probe_type}` is not a valid probe type for `{self.name}`"
+            )
+
+    def implement(self, target):
+        probe_args = ("where", "mechanism", "ion", "state")
+        kwargs = dict((k, getattr(self, k)) for k in probe_args if hasattr(self, k))
+        return [getattr(arbor, self.get_probe_name())(**kwargs)]
+
+    def prepare_samples(self, sim, comm):
+        super().prepare_samples(sim, comm)
+        for probe_id, handle in zip(self._probe_ids, self._handles, strict=False):
+            self.adapter.result.add(ProbeRecorder(self, sim, probe_id, handle))
+
+
+class ProbeRecorder:
+    def __init__(self, device, sim, probe_id, handle):
+        self.path = ("recorders", device.name, *probe_id)
+        self.meta = device.get_meta()
+        self.meta["probe_id"] = probe_id
+        self._sim = sim
+        self._handle = handle
+
+    def samples(self):
+        return self._sim.samples(self._handle)
+
+    def multi_collect(self):
+        for i, sample in enumerate(self.samples()):
+            yield ProbeRecorderSample(self, i, sample)
+
+
+class ProbeRecorderSample:
+    def __init__(self, parent, i, sample):
+        self.path = tuple(list(parent.get_path()) + [i])
+        self.data = sample[0]
+        self.meta = parent.meta.copy()
+        self.meta["location"] = str(sample[1])
+
+    def get_data(self):
+        return self.data

bsb_arbor/devices/spike_recorder.py

@@ -0,0 +1,42 @@
+import neo
+from bsb import config
+
+from ..device import ArborDevice
+
+
+@config.node
+class SpikeRecorder(ArborDevice, classmap_entry="spike_recorder"):
+    def boot(self):
+        self._gids = set()
+
+    def prepare_samples(self, simdata, comm):
+        super().prepare_samples(simdata, comm)
+        if not comm.get_rank():
+
+            def record_device_spikes(segment):
+                spiketrain = list()
+                senders = list()
+                for (gid, index), time in simdata.arbor_sim.spikes():
+                    if index == 0 and gid in self._gids:
+                        spiketrain.append(time)
+                        senders.append(gid)
+                segment.spiketrains.append(
+                    neo.SpikeTrain(
+                        spiketrain,
+                        units="ms",
+                        array_annotations={"senders": senders},
+                        t_stop=self.simulation.duration,
+                        device=self.name,
+                        gids=list(self._gids),
+                        pop_size=len(self._gids),
+                    )
+                )
+
+            simdata.result.create_recorder(record_device_spikes)
+
+    def implement_probes(self, simdata, gid):
+        self._gids.add(gid)
+        return []
+
+    def implement_generators(self, simdata, gid):
+        return []

bsb_arbor/simulation.py

@@ -0,0 +1,38 @@
+import psutil
+from bsb import Simulation, config, types
+
+from .cell import ArborCell
+from .connection import ArborConnection
+from .device import ArborDevice
+
+
+@config.node
+class ArborSimulation(Simulation):
+    """
+    Interface between the scaffold model and the Arbor simulator.
+    """
+
+    resolution = config.attr(type=types.float(min=0.0), default=0.1)
+    """Simulation time step size in milliseconds."""
+    profiling = config.attr(type=bool)
+    """Flag to perform profiling during the simulation."""
+    cell_models: config._attrs.cfgdict[ArborCell] = config.dict(
+        type=ArborCell, required=True
+    )
+    """Dictionary of cell models in the simulation."""
+    connection_models: config._attrs.cfgdict[ArborConnection] = config.dict(
+        type=ArborConnection, required=True
+    )
+    """Dictionary of connection models in the simulation."""
+    devices: config._attrs.cfgdict[ArborDevice] = config.dict(
+        type=ArborDevice, required=True
+    )
+    """Dictionary of devices in the simulation."""
+
+    @config.property(default=1)
+    def threads(self):
+        return self._threads
+
+    @threads.setter
+    def threads(self, value):
+        self._threads = value if value != "all" else psutil.cpu_count(logical=False)

bsb_arbor-6.0.0a5.dist-info/METADATA

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: bsb-arbor
+Version: 6.0.0a5
+Summary: Arbor 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: numpy~=1.21
+Requires-Dist: bsb-core~=6.0
+Requires-Dist: arborize~=6.0
+Requires-Dist: arbor~=0.10; sys_platform != 'win32'
+Requires-Dist: bsb-arbor[test, docs] ; extra == "dev"
+Requires-Dist: pre-commit~=3.5 ; extra == "dev"
+Requires-Dist: ruff>=0.8.2 ; extra == "dev"
+Requires-Dist: snakeviz~=2.1 ; extra == "dev"
+Requires-Dist: furo~=2024.0 ; extra == "docs"
+Requires-Dist: sphinxext-bsb~=6.0 ; extra == "docs"
+Requires-Dist: bsb-core[parallel] ; extra == "test"
+Requires-Dist: bsb-hdf5~=6.0 ; extra == "test"
+Requires-Dist: bsb-test~=6.0 ; extra == "test"
+Requires-Dist: coverage>=7.3 ; extra == "test"
+Provides-Extra: dev
+Provides-Extra: docs
+Provides-Extra: test
+
+[![Build Status](https://github.com/dbbs-lab/bsb-arbor/actions/workflows/main.yml/badge.svg)](https://github.com/dbbs-lab/bsb-arbor/actions/workflows/main.yml)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+# bsb-arbor
+
+bsb-arbor is a plugin of the [BSB](https://github.com/dbbs-lab/bsb) (see also 
+[bsb-core](https://github.com/dbbs-lab/bsb-core)). 
+It contains the interfaces and tools to simulate BSB circuit with the 
+[Arbor simulator](https://arbor-sim.org/).

bsb_arbor-6.0.0a5.dist-info/RECORD

@@ -0,0 +1,15 @@
+bsb_arbor/__init__.py,sha256=1kJSMSgt1vnjllcKXRUfomu0XTczbqYkkRf-TjSQbP8,437
+bsb_arbor/adapter.py,sha256=2aeDo_znf7_przJMDe7AqfVse9GlRA0WA8qDDJcfEqs,16136
+bsb_arbor/cell.py,sha256=V4JxsdwS_FNfQ_wRjnJH-kFVLMwipzLSHcYbf-VgP_c,2476
+bsb_arbor/connection.py,sha256=1u3yLA7R0G3Rxxf0Zvw3AcBa242n8XeSVej_r8iXjXY,2446
+bsb_arbor/device.py,sha256=5PD6nujSlTu74BonS5Ojp7LhopusQ4cDVEEAYg1aAMA,1752
+bsb_arbor/simulation.py,sha256=3aZ1qiFWytRFp5qSpLXG_Qcjf-zoXLa09GZraG8BanE,1243
+bsb_arbor/devices/__init__.py,sha256=8PgEH4gktvNW7KywuFXIzZXsPuWayWt0BPuKz6sJyPA,188
+bsb_arbor/devices/poisson_generator.py,sha256=PGcx1YQn6WoZ3yZGXbW0nF1gtDo1fC7KGnmFYaklR3s,1045
+bsb_arbor/devices/probe.py,sha256=Dv0GiWxNUuiKRYg8wCik2xlQLvh5dJBE4e-v3-W2eLg,1732
+bsb_arbor/devices/spike_recorder.py,sha256=xJ720Tg9EO71RIc54ZEN04UqUDNyyI5TliC1ZD5UHWc,1339
+bsb_arbor-6.0.0a5.dist-info/entry_points.txt,sha256=8z5oyflKGOBD2smUKyrUit-_2JqBs85g8rm5YOM8SYg,43
+bsb_arbor-6.0.0a5.dist-info/licenses/LICENSE,sha256=ljOS4DjXvqEo5VzGfdaRwgRZPbNScGBmfwyC8PChvmQ,32422
+bsb_arbor-6.0.0a5.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+bsb_arbor-6.0.0a5.dist-info/METADATA,sha256=77X9S1tNYAPrkQvpC6tf4r1acY5vWCCVc35PDMgcMfo,1601
+bsb_arbor-6.0.0a5.dist-info/RECORD,,

bsb_arbor-6.0.0a5.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_arbor-6.0.0a5.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[bsb.simulation_backends]
+arbor=bsb_arbor
+