bsb-nest 6.0.3__tar.gz → 7.0.2__tar.gz

{bsb_nest-6.0.3 → bsb_nest-7.0.2}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: bsb-nest
-Version: 6.0.3
+Version: 7.0.2
 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~=7.0
 Requires-Dist: bsb-core[parallel] ; extra == "parallel"
 Provides-Extra: parallel
 

{bsb_nest-6.0.3 → bsb_nest-7.0.2}/bsb_nest/adapter.py

@@ -5,10 +5,10 @@ import typing
 import nest
 from bsb import (
     AdapterError,
-    AdapterProgress,
     SimulationData,
     SimulationResult,
     SimulatorAdapter,
+    options,
     report,
     warn,
 )
@@ -17,11 +17,13 @@ from tqdm import tqdm
 
 from .exceptions import KernelWarning, NestConnectError, NestModelError, NestModuleError
 
-if typing.TYPE_CHECKING:
+if typing.TYPE_CHECKING:  # pragma: nocover
     from .simulation import NestSimulation
 
 
 class NestResult(SimulationResult):
+    # It seems that the record method is not used,
+    # probably we will have to uniform the behavior with NeuronResult
     def record(self, nc, **annotations):
         recorder = nest.Create("spike_recorder", params={"record_to": "memory"})
         nest.Connect(nc, recorder)
@@ -38,6 +40,7 @@ class NestResult(SimulationResult):
                     **annotations,
                 )
             )
+            # Free the Memory -> not possible to free the memory while sim is running
 
         self.create_recorder(flush)
 
@@ -46,6 +49,7 @@ class NestAdapter(SimulatorAdapter):
     def __init__(self, comm=None):
         super().__init__(comm=comm)
         self.loaded_modules = set()
+        self._prev_chkpoint = 0
 
     def simulate(self, *simulations, post_prepare=None):
         try:
@@ -87,7 +91,8 @@ class NestAdapter(SimulatorAdapter):
             report("Creating connections...", level=2)
             self.connect_neurons(simulation)
             report("Creating devices...", level=2)
-            self.create_devices(simulation)
+            self.implement_components(simulation)
+            self.load_controllers(simulation)
             return self.simdata[simulation]
         except Exception:
             del self.simdata[simulation]
@@ -104,18 +109,21 @@ class NestAdapter(SimulatorAdapter):
         if unprepared:
             raise AdapterError(f"Unprepared for simulations: {', '.join(unprepared)}")
         report("Simulating...", level=2)
-        duration = max(sim.duration for sim in simulations)
-        progress = AdapterProgress(duration)
+        self._duration = max(sim.duration for sim in simulations)
+
         try:
+            results = [self.simdata[sim].result for sim in simulations]
             with nest.RunManager():
-                for oi, i in progress.steps(step=1):
-                    nest.Run(i - oi)
-                    progress.tick(i)
+                for t, checkpoint_controllers in self.get_next_checkpoint():
+                    nest.Run(t - self._prev_chkpoint)
+                    self.execute_checkpoints(checkpoint_controllers)
+                    self._prev_chkpoint = t
+
         finally:
             results = [self.simdata[sim].result for sim in simulations]
             for sim in simulations:
                 del self.simdata[sim]
-        progress.complete()
+
         report("Simulation done.", level=2)
         return results
 
@@ -156,7 +164,7 @@ class NestAdapter(SimulatorAdapter):
         simdata = self.simdata[simulation]
         iter = simulation.connection_models.values()
         if self.comm.get_rank() == 0:
-            iter = tqdm(iter, desc="", file=sys.stdout)
+            iter = tqdm(iter, desc="", file=sys.stdout, disable=options.verbosity < 2)
         for connection_model in iter:
             with contextlib.suppress(AttributeError):
                 # Only rank 0 should report progress bar
@@ -178,15 +186,8 @@ class NestAdapter(SimulatorAdapter):
                         simdata, pre_nodes, post_nodes, cs, self.comm
                     )
                 )
-            except Exception:
-                raise NestConnectError(
-                    f"{connection_model} error during connect."
-                ) from None
-
-    def create_devices(self, simulation):
-        simdata = self.simdata[simulation]
-        for device_model in simulation.devices.values():
-            device_model.implement(self, simulation, simdata)
+            except Exception as e:
+                raise NestConnectError(f"{connection_model} error during connect.") from e
 
     def set_settings(self, simulation: "NestSimulation"):
         nest.set_verbosity(simulation.verbosity)

{bsb_nest-6.0.3 → bsb_nest-7.0.2}/bsb_nest/connection.py

@@ -4,11 +4,18 @@ import sys
 import nest
 import numpy as np
 import psutil
-from bsb import ConnectionModel, compose_nodes, config, types
+from bsb import ConfigurationError, ConnectionModel, compose_nodes, config, options, types
 from tqdm import tqdm
 
 from .distributions import nest_parameter
-from .exceptions import NestConnectError
+
+
+def _is_delay_required(node):
+    model = node.get("model", NestSynapseSettings.model.default)
+    if model not in nest.Models(mtype="synapses"):
+        raise ConfigurationError(f"Unknown synapse model '{model}'.")
+    else:
+        return nest.GetDefaults(model)["has_delay"]
 
 
 @config.node
@@ -21,7 +28,7 @@ class NestSynapseSettings:
     """Importable reference to the NEST model describing the synapse type."""
     weight = config.attr(type=float, required=True)
     """Weight of the connection between the presynaptic and the postsynaptic cells."""
-    delay = config.attr(type=float, required=True)
+    delay = config.attr(type=float, required=_is_delay_required, default=None)
     """Delay of the transmission between the presynaptic and the postsynaptic cells."""
     receptor_type = config.attr(type=int)
     """Index of the postsynaptic receptor to target."""
@@ -36,7 +43,7 @@ class NestConnectionSettings:
     """
 
     rule = config.attr(type=str)
-    """Importable reference to the Nest connection rule used to connect the cells."""
+    """Importable reference to the NEST connection rule used to connect the cells."""
     constants = config.catch_all(type=types.any_())
     """Dictionary of parameters to assign to the connection rule."""
 
@@ -76,19 +83,20 @@ class NestConnection(compose_nodes(NestConnectionSettings, ConnectionModel)):
     management.
     """
 
-    synapse = config.attr(type=NestSynapseSettings, required=True)
-    """Nest synapse model with its parameters."""
+    synapses = config.list(type=NestSynapseSettings, required=True)
+    """List of synapse models to use for a connection."""
 
     def create_connections(self, simdata, pre_nodes, post_nodes, cs, comm):
         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']}'."
-            )
+        syn_specs = self.get_syn_specs()
         if self.rule is not None:
-            nest.Connect(pre_nodes, post_nodes, self.get_conn_spec(), syn_spec)
+            nest.Connect(
+                pre_nodes,
+                post_nodes,
+                self.get_conn_spec(),
+                nest.CollocatedSynapses(*syn_specs),
+            )
         else:
             comm.barrier()
             for pre_locs, post_locs in self.predict_mem_iterator(
@@ -104,17 +112,21 @@ class NestConnection(compose_nodes(NestConnectionSettings, ConnectionModel)):
                 )
                 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,
-                )
+                # cannot use CollocatedSynapses with a list of weight and delay
+                # so loop over the syn_specs
+                for syn_spec in syn_specs:
+                    ssw = {**syn_spec}
+                    bw = syn_spec["weight"]
+                    ssw["weight"] = [bw * m for m in multiplicity]
+                    if "delay" in syn_spec:
+                        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,
+                    )
             comm.barrier()
         return LazySynapseCollection(pre_nodes, post_nodes)
 
@@ -141,7 +153,12 @@ class NestConnection(compose_nodes(NestConnectionSettings, ConnectionModel)):
         def block_iter():
             iter = locals
             if comm.get_rank() == 0:
-                iter = tqdm(iter, desc="hyperblocks", file=sys.stdout)
+                iter = tqdm(
+                    iter,
+                    desc="hyperblocks",
+                    file=sys.stdout,
+                    disable=options.verbosity < 2,
+                )
             for local in iter:
                 inner_iter = cs.load_connections().as_globals().from_(local)
                 if comm.get_rank() == 0:
@@ -160,7 +177,9 @@ class NestConnection(compose_nodes(NestConnectionSettings, ConnectionModel)):
     def local_iterator(self, cs, comm):
         iter = cs.get_local_chunks("out")
         if comm.get_rank() == 0:
-            iter = tqdm(iter, desc="hyperblocks", file=sys.stdout)
+            iter = tqdm(
+                iter, desc="hyperblocks", file=sys.stdout, disable=options.verbosity < 2
+            )
         yield from (
             cs.load_connections().as_globals().from_(local).all() for local in iter
         )
@@ -177,17 +196,20 @@ class NestConnection(compose_nodes(NestConnectionSettings, ConnectionModel)):
             **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,
-        }
+    def get_syn_specs(self):
+        return [
+            {
+                **{
+                    label: value
+                    for attr, label in (
+                        ("model", "synapse_model"),
+                        ["weight"] * 2,
+                        ["delay"] * 2,
+                        ["receptor_type"] * 2,
+                    )
+                    if (value := getattr(synapse, attr)) is not None
+                },
+                **synapse.constants,
+            }
+            for synapse in self.synapses
+        ]

{bsb_nest-6.0.3 → bsb_nest-7.0.2}/bsb_nest/device.py

@@ -119,7 +119,7 @@ class NestDevice(DeviceModel):
         adapter,
         simulation,
         simdata,
-    ):
+    ):  # pragma: nocover
         """
         Create, connect and register the Nest device.
 

{bsb_nest-6.0.3 → bsb_nest-7.0.2}/pyproject.toml

@@ -6,14 +6,14 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "bsb-nest"
-version = "6.0.3"
+version = "7.0.2"
 readme = "README.md"
 requires-python = ">=3.10,<4"
 dynamic = [ "description" ]
 classifiers = [
   "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)"
 ]
-dependencies = [ "bsb-core~=6.0" ]
+dependencies = [ "bsb-core~=7.0" ]
 
   [[project.authors]]
   name = "Robin De Schepper"
@@ -44,7 +44,7 @@ branch = true
 source = [ "bsb_nest" ]
 
 [tool.coverage.report]
-exclude_lines = [ "if TYPE_CHECKING:" ]
+exclude_lines = [ "if typing.TYPE_CHECKING:", "pragma: nocover" ]
 show_missing = true
 
 [tool.ruff]