bsb-arbor 4.0.0__py2.py3-none-any.whl → 4.1.0__py2.py3-none-any.whl

bsb_arbor/cell.py

@@ -1,81 +1,81 @@
-import abc
-import typing
-
-import arbor
-from bsb import CellModel, ConfigurationError, config, types
-
-from .adapter import SingleReceiverCollection
-
-if typing.TYPE_CHECKING:
-    from bsb import PlacementSet
-
-
-@config.dynamic(
-    attr_name="model_strategy",
-    auto_classmap=True,
-    required=True,
-    classmap_entry=None,
-)
-class ArborCell(CellModel):
-    gap = config.attr(type=bool, default=False)
-    model = config.attr(type=types.class_(), required=True)
-
-    @abc.abstractmethod
-    def cache_population_data(self, simdata, ps: "PlacementSet"):
-        pass
-
-    @abc.abstractmethod
-    def discard_population_data(self):
-        pass
-
-    @abc.abstractmethod
-    def get_prefixed_catalogue(self):
-        pass
-
-    @abc.abstractmethod
-    def get_cell_kind(self, gid):
-        pass
-
-    @abc.abstractmethod
-    def make_receiver_collection(self):
-        pass
-
-    def get_description(self, gid):
-        morphology, labels, decor = self.model.cable_cell_template()
-        labels = self._add_labels(gid, labels, morphology)
-        decor = self._add_decor(gid, decor)
-        cc = arbor.cable_cell(morphology, labels, decor)
-        return cc
-
-
-@config.node
-class LIFCell(ArborCell, classmap_entry="lif"):
-    model = config.unset()
-    constants = config.dict(type=types.any_())
-
-    def cache_population_data(self, simdata, ps: "PlacementSet"):
-        pass
-
-    def discard_population_data(self):
-        pass
-
-    def get_prefixed_catalogue(self):
-        return None, None
-
-    def get_cell_kind(self, gid):
-        return arbor.cell_kind.lif
-
-    def get_description(self, gid):
-        cell = arbor.lif_cell(f"-1_-1", f"-1_-1_0")
-        try:
-            for k, v in self.constants.items():
-                setattr(cell, k, v)
-        except AttributeError:
-            node_name = type(self).constants.get_node_name(self)
-            raise ConfigurationError(
-                f"'{k}' is not a valid LIF parameter in '{node_name}'."
-            ) from None
-        return cell
-
-    def make_receiver_collection(self):
-        return SingleReceiverCollection()
+import abc
+import typing
+
+import arbor
+from bsb import CellModel, ConfigurationError, config, types
+
+from .adapter import SingleReceiverCollection
+
+if typing.TYPE_CHECKING:
+    from bsb import PlacementSet
+
+
+@config.dynamic(
+    attr_name="model_strategy",
+    auto_classmap=True,
+    required=True,
+    classmap_entry=None,
+)
+class ArborCell(CellModel):
+    gap = config.attr(type=bool, default=False)
+    model = config.attr(type=types.class_(), required=True)
+
+    @abc.abstractmethod
+    def cache_population_data(self, simdata, ps: "PlacementSet"):
+        pass
+
+    @abc.abstractmethod
+    def discard_population_data(self):
+        pass
+
+    @abc.abstractmethod
+    def get_prefixed_catalogue(self):
+        pass
+
+    @abc.abstractmethod
+    def get_cell_kind(self, gid):
+        pass
+
+    @abc.abstractmethod
+    def make_receiver_collection(self):
+        pass
+
+    def get_description(self, gid):
+        morphology, labels, decor = self.model.cable_cell_template()
+        labels = self._add_labels(gid, labels, morphology)
+        decor = self._add_decor(gid, decor)
+        cc = arbor.cable_cell(morphology, labels, decor)
+        return cc
+
+
+@config.node
+class LIFCell(ArborCell, classmap_entry="lif"):
+    model = config.unset()
+    constants = config.dict(type=types.any_())
+
+    def cache_population_data(self, simdata, ps: "PlacementSet"):
+        pass
+
+    def discard_population_data(self):
+        pass
+
+    def get_prefixed_catalogue(self):
+        return None, None
+
+    def get_cell_kind(self, gid):
+        return arbor.cell_kind.lif
+
+    def get_description(self, gid):
+        cell = arbor.lif_cell(f"-1_-1", f"-1_-1_0")
+        try:
+            for k, v in self.constants.items():
+                setattr(cell, k, v * getattr(cell, k).units)
+        except AttributeError:
+            node_name = type(self).constants.get_node_name(self)
+            raise ConfigurationError(
+                f"'{k}' is not a valid LIF parameter in '{node_name}'."
+            ) from None
+        return cell
+
+    def make_receiver_collection(self):
+        return SingleReceiverCollection()

bsb_arbor/connection.py

@@ -1,67 +1,67 @@
-import arbor
-import tqdm
-from bsb import ConnectionModel, config
-
-
-class Receiver:
-    def __init__(self, conn_model, from_gid, loc_from, loc_on, index=-1):
-        self.conn_model = conn_model
-        self.from_gid = from_gid
-        self.loc_from = loc_from
-        self.loc_on = loc_on
-        self.synapse = arbor.synapse("expsyn")
-        self.index = index
-
-    def from_(self):
-        b, p = self.loc_from
-        return arbor.cell_global_label(self.from_gid, f"{b}_{p}")
-
-    def on(self):
-        # self.index is set on us by the ReceiverCollection when we are appended.
-        b, p = self.loc_on
-        return arbor.cell_local_label(f"{b}_{p}_{self.index}")
-
-    @property
-    def weight(self):
-        return self.conn_model.weight
-
-    @property
-    def delay(self):
-        return self.conn_model.delay
-
-
-class Connection:
-    def __init__(self, pre_loc, post_loc):
-        self.from_id = pre_loc[0]
-        self.to_id = post_loc[0]
-        self.pre_loc = pre_loc[1:]
-        self.post_loc = post_loc[1:]
-
-
-@config.node
-class ArborConnection(ConnectionModel):
-    gap = config.attr(type=bool, default=False)
-    weight = config.attr(type=float, required=True)
-    delay = config.attr(type=float, required=True)
-
-    def create_gap_junctions_on(self, gj_on_gid, conns):
-        for pre_loc, post_loc in conns:
-            conn = Connection(pre_loc, post_loc)
-            gj_on_gid.setdefault(conn.from_id, []).append(conn)
-
-    def create_connections_on(self, conns_on_gid, conns, pop_pre, pop_post):
-        for pre_loc, post_loc in tqdm.tqdm(conns, total=len(conns), desc=self.name):
-            conns_on_gid[post_loc[0] + pop_post.offset].append(
-                Receiver(self, pre_loc[0] + pop_pre.offset, pre_loc[1:], post_loc[1:])
-            )
-
-    def create_connections_from(self, conns_from_gid, conns, pop_pre, pop_post):
-        for pre_loc, post_loc in conns:
-            conns_from_gid[int(pre_loc[0] + pop_pre.offset)].append(pre_loc[1:])
-
-    def gap_junction(self, conn):
-        l = arbor.cell_local_label(f"gap_{conn.to_compartment.id}")
-        g = arbor.cell_global_label(
-            int(conn.from_id), f"gap_{conn.from_compartment.id}"
-        )
-        return arbor.gap_junction_connection(g, l, self.weight)
+import arbor
+import tqdm
+from bsb import ConnectionModel, config
+
+
+class Receiver:
+    def __init__(self, conn_model, from_gid, loc_from, loc_on, index=-1):
+        self.conn_model = conn_model
+        self.from_gid = from_gid
+        self.loc_from = loc_from
+        self.loc_on = loc_on
+        self.synapse = arbor.synapse("expsyn")
+        self.index = index
+
+    def from_(self):
+        b, p = self.loc_from
+        return arbor.cell_global_label(self.from_gid, f"{b}_{p}")
+
+    def on(self):
+        # self.index is set on us by the ReceiverCollection when we are appended.
+        b, p = self.loc_on
+        return arbor.cell_local_label(f"{b}_{p}_{self.index}")
+
+    @property
+    def weight(self):
+        return self.conn_model.weight
+
+    @property
+    def delay(self):
+        return self.conn_model.delay
+
+
+class Connection:
+    def __init__(self, pre_loc, post_loc):
+        self.from_id = pre_loc[0]
+        self.to_id = post_loc[0]
+        self.pre_loc = pre_loc[1:]
+        self.post_loc = post_loc[1:]
+
+
+@config.node
+class ArborConnection(ConnectionModel):
+    gap = config.attr(type=bool, default=False)
+    weight = config.attr(type=float, required=True)
+    delay = config.attr(type=float, required=True)
+
+    def create_gap_junctions_on(self, gj_on_gid, conns):
+        for pre_loc, post_loc in conns:
+            conn = Connection(pre_loc, post_loc)
+            gj_on_gid.setdefault(conn.from_id, []).append(conn)
+
+    def create_connections_on(self, conns_on_gid, conns, pop_pre, pop_post):
+        for pre_loc, post_loc in tqdm.tqdm(conns, total=len(conns), desc=self.name):
+            conns_on_gid[post_loc[0] + pop_post.offset].append(
+                Receiver(self, pre_loc[0] + pop_pre.offset, pre_loc[1:], post_loc[1:])
+            )
+
+    def create_connections_from(self, conns_from_gid, conns, pop_pre, pop_post):
+        for pre_loc, post_loc in conns:
+            conns_from_gid[int(pre_loc[0] + pop_pre.offset)].append(pre_loc[1:])
+
+    def gap_junction(self, conn):
+        l = arbor.cell_local_label(f"gap_{conn.to_compartment.id}")
+        g = arbor.cell_global_label(
+            int(conn.from_id), f"gap_{conn.from_compartment.id}"
+        )
+        return arbor.gap_junction_connection(g, l, self.weight)

bsb_arbor/device.py

@@ -1,45 +1,45 @@
-import abc
-
-import arbor
-from bsb import DeviceModel, Targetting, config, types
-
-
-@config.dynamic(attr_name="device", auto_classmap=True, classmap_entry=None)
-class ArborDevice(DeviceModel):
-    targetting = config.attr(type=Targetting, required=True)
-    resolution = config.attr(type=float)
-    sampling_policy = config.attr(type=types.in_(["exact"]))
-
-    def __init__(self, **kwargs):
-        self._probe_ids = []
-
-    def __boot__(self):
-        self.resolution = self.resolution or self.simulation.resolution
-
-    def register_probe_id(self, gid, tag):
-        self._probe_ids.append((gid, tag))
-
-    def prepare_samples(self, simdata):
-        self._handles = [
-            self.sample(simdata.arbor_sim, probe_id) for probe_id in self._probe_ids
-        ]
-
-    def sample(self, sim, probe_id):
-        schedule = arbor.regular_schedule(self.resolution)
-        sampling_policy = getattr(arbor.sampling_policy, self.sampling_policy)
-        return sim.sample(probe_id, schedule, sampling_policy)
-
-    def get_samples(self, sim):
-        return [sim.samples(handle) for handle in self._handles]
-
-    def get_meta(self):
-        attrs = ("name", "sampling_policy", "resolution")
-        return dict(zip(attrs, (getattr(self, attr) for attr in attrs)))
-
-    @abc.abstractmethod
-    def implement_probes(self, simdata, target):
-        pass
-
-    @abc.abstractmethod
-    def implement_generators(self, simdata, target):
-        pass
+import abc
+
+import arbor
+from bsb import DeviceModel, Targetting, config, types
+
+
+@config.dynamic(attr_name="device", auto_classmap=True, classmap_entry=None)
+class ArborDevice(DeviceModel):
+    targetting = config.attr(type=Targetting, required=True)
+    resolution = config.attr(type=float)
+    sampling_policy = config.attr(type=types.in_(["exact"]))
+
+    def __init__(self, **kwargs):
+        self._probe_ids = []
+
+    def __boot__(self):
+        self.resolution = self.resolution or self.simulation.resolution
+
+    def register_probe_id(self, gid, tag):
+        self._probe_ids.append((gid, tag))
+
+    def prepare_samples(self, simdata):
+        self._handles = [
+            self.sample(simdata.arbor_sim, probe_id) for probe_id in self._probe_ids
+        ]
+
+    def sample(self, sim, probe_id):
+        schedule = arbor.regular_schedule(self.resolution)
+        sampling_policy = getattr(arbor.sampling_policy, self.sampling_policy)
+        return sim.sample(probe_id, schedule, sampling_policy)
+
+    def get_samples(self, sim):
+        return [sim.samples(handle) for handle in self._handles]
+
+    def get_meta(self):
+        attrs = ("name", "sampling_policy", "resolution")
+        return dict(zip(attrs, (getattr(self, attr) for attr in attrs)))
+
+    @abc.abstractmethod
+    def implement_probes(self, simdata, target):
+        pass
+
+    @abc.abstractmethod
+    def implement_generators(self, simdata, target):
+        pass

bsb_arbor/devices/__init__.py

@@ -1,3 +1,3 @@
-from .poisson_generator import PoissonGenerator
-from .probe import Probe
-from .spike_recorder import SpikeRecorder
+from .poisson_generator import PoissonGenerator
+from .probe import Probe
+from .spike_recorder import SpikeRecorder

bsb_arbor/devices/poisson_generator.py

@@ -1,23 +1,26 @@
-import arbor
-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)
-    rate = config.attr(type=float, required=True)
-    weight = config.attr(type=float, required=True)
-    delay = config.attr(type=float, required=True)
-
-    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(0, self.rate / 1000, gid)
-        )
-        return [gen]
+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)
+    rate = config.attr(type=float, required=True)
+    weight = config.attr(type=float, required=True)
+    delay = config.attr(type=float, required=True)
+
+    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

@@ -1,55 +1,55 @@
-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):
-        super().prepare_samples(sim)
-        for probe_id, handle in zip(self._probe_ids, self._handles):
-            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
+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):
+        super().prepare_samples(sim)
+        for probe_id, handle in zip(self._probe_ids, self._handles):
+            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

@@ -1,43 +1,43 @@
-import neo
-from bsb import config
-from bsb.services import MPI
-
-from ..device import ArborDevice
-
-
-@config.node
-class SpikeRecorder(ArborDevice, classmap_entry="spike_recorder"):
-    def boot(self):
-        self._gids = set()
-
-    def prepare_samples(self, simdata):
-        super().prepare_samples(simdata)
-        if not MPI.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",
-                        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 []
+import neo
+from bsb import config
+from bsb.services import MPI
+
+from ..device import ArborDevice
+
+
+@config.node
+class SpikeRecorder(ArborDevice, classmap_entry="spike_recorder"):
+    def boot(self):
+        self._gids = set()
+
+    def prepare_samples(self, simdata):
+        super().prepare_samples(simdata)
+        if not MPI.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",
+                        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 []