bluecellulab 2.6.50__tar.gz → 2.6.52__tar.gz

{bluecellulab-2.6.50 → bluecellulab-2.6.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bluecellulab
-Version: 2.6.50
+Version: 2.6.52
 Summary: Biologically detailed neural network simulations and analysis.
 Author: Blue Brain Project, EPFL
 License: Apache2.0

{bluecellulab-2.6.50 → bluecellulab-2.6.52}/bluecellulab/analysis/analysis.py

@@ -4,14 +4,17 @@ try:
 except ImportError:
     efel = None
 from itertools import islice
+from itertools import repeat
 import logging
 from matplotlib.collections import LineCollection
 import matplotlib.pyplot as plt
+from multiprocessing import Pool
 import neuron
 import numpy as np
 import pathlib
 import seaborn as sns
 
+
 from bluecellulab import Cell
 from bluecellulab.analysis.inject_sequence import run_stimulus
 from bluecellulab.analysis.plotting import plot_iv_curve, plot_fi_curve
@@ -87,30 +90,35 @@ def compute_plot_iv_curve(cell,
 
     list_amp = np.linspace(rheobase - 2, rheobase - 0.1, nb_bins)  # [nA]
 
-    steps = []
-    times = []
-    voltages = []
     # inject step current and record voltage response
     stim_factory = StimulusFactory(dt=0.1)
-    for amp in list_amp:
-        step_stimulus = stim_factory.step(pre_delay=stim_start, duration=duration, post_delay=post_delay, amplitude=amp)
-        recording = run_stimulus(cell.template_params,
-                                 step_stimulus,
-                                 section=injecting_section,
-                                 segment=injecting_segment,
-                                 recording_section=recording_section,
-                                 recording_segment=recording_segment)
-        steps.append(step_stimulus)
-        times.append(recording.time)
-        voltages.append(recording.voltage)
+    steps = [
+        stim_factory.step(pre_delay=stim_start, duration=duration, post_delay=post_delay, amplitude=amp)
+        for amp in list_amp
+    ]
+
+    with Pool(len(steps)) as p:
+        recordings = p.starmap(
+            run_stimulus,
+            zip(
+                repeat(cell.template_params),
+                steps,
+                repeat(injecting_section),
+                repeat(injecting_segment),
+                repeat(True),  # cvode
+                repeat(True),  # add_hypamp
+                repeat(recording_section),
+                repeat(recording_segment),
+            )
+        )
 
     steady_states = []
     # compute steady state response
     efel.set_setting('Threshold', threshold_voltage)
-    for voltage, t in zip(voltages, times):
+    for recording in recordings:
         trace = {
-            'T': t,
-            'V': voltage,
+            'T': recording.time,
+            'V': recording.voltage,
             'stim_start': [stim_start],
             'stim_end': [stim_start + duration]
         }
@@ -194,24 +202,30 @@ def compute_plot_fi_curve(cell,
         rheobase = calculate_rheobase(cell=cell, section=injecting_section, segx=injecting_segment)
 
     list_amp = np.linspace(rheobase, max_current, nb_bins)  # [nA]
-    steps = []
-    spikes = []
-    # inject step current and record spike response
     stim_factory = StimulusFactory(dt=0.1)
-    for amp in list_amp:
-        step_stimulus = stim_factory.step(pre_delay=stim_start, duration=duration, post_delay=post_delay, amplitude=amp)
-        recording = run_stimulus(cell.template_params,
-                                 step_stimulus,
-                                 section=injecting_section,
-                                 segment=injecting_segment,
-                                 recording_section=recording_section,
-                                 recording_segment=recording_segment,
-                                 enable_spike_detection=True,
-                                 threshold_spike_detection=threshold_voltage)
-        steps.append(step_stimulus)
-        spikes.append(recording.spike)
-
-    spike_count = [len(spike) for spike in spikes]
+    steps = [
+        stim_factory.step(pre_delay=stim_start, duration=duration, post_delay=post_delay, amplitude=amp)
+        for amp in list_amp
+    ]
+
+    with Pool(len(steps)) as p:
+        recordings = p.starmap(
+            run_stimulus,
+            zip(
+                repeat(cell.template_params),
+                steps,
+                repeat(injecting_section),
+                repeat(injecting_segment),
+                repeat(True),  # cvode
+                repeat(True),  # add_hypamp
+                repeat(recording_section),
+                repeat(recording_segment),
+                repeat(True),  # enable_spike_detection
+                repeat(threshold_voltage),  # threshold_spike_detection
+            )
+        )
+
+    spike_count = [len(recording.spike) for recording in recordings]
 
     plot_fi_curve(list_amp,
                   spike_count,

{bluecellulab-2.6.50 → bluecellulab-2.6.52}/bluecellulab/cell/core.py

@@ -525,6 +525,10 @@ class Cell(InjectableMixin, PlottableMixin):
         nc.record(spike_vec)
         self.recordings[f"spike_detector_{location}_{threshold}"] = spike_vec
 
+    def is_recording_spikes(self, location: str, threshold: float) -> bool:
+        key = f"spike_detector_{location}_{threshold}"
+        return key in self.recordings
+
     def get_recorded_spikes(self, location: str, threshold: float = -30) -> list[float]:
         """Get recorded spikes in the current cell.
 
@@ -756,6 +760,18 @@ class Cell(InjectableMixin, PlottableMixin):
         """Get a vector of AIS voltage."""
         return self.get_recording('self.axonal[1](0.5)._ref_v')
 
+    def add_variable_recording(self, variable: str, section, segx):
+        if variable == "v":
+            self.add_voltage_recording(section, segx)
+        else:
+            raise ValueError(f"Unsupported variable for recording: {variable}")
+
+    def get_variable_recording(self, variable: str, section, segx) -> np.ndarray:
+        if variable == "v":
+            return self.get_voltage_recording(section=section, segx=segx)
+        else:
+            raise ValueError(f"Unsupported variable '{variable}'")
+
     @property
     def n_segments(self) -> int:
         """Get the number of segments in the cell."""

{bluecellulab-2.6.50 → bluecellulab-2.6.52}/bluecellulab/circuit/config/sonata_simulation_config.py

@@ -13,6 +13,8 @@
 # limitations under the License.
 from __future__ import annotations
 from functools import lru_cache
+import json
+import logging
 from pathlib import Path
 from typing import Optional
 
@@ -21,6 +23,8 @@ from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus
 
 from bluepysnap import Simulation as SnapSimulation
 
+logger = logging.getLogger(__name__)
+
 
 class SonataSimulationConfig:
     """Sonata implementation of SimulationConfig protocol."""
@@ -74,9 +78,42 @@ class SonataSimulationConfig:
             result.append(ConnectionOverrides.from_sonata(conn_entry))
         return result
 
+    @lru_cache(maxsize=1)
+    def get_compartment_sets(self) -> dict[str, dict]:
+        filepath = self.impl.config.get("compartment_sets_file")
+        if not filepath:
+            raise ValueError("No 'compartment_sets_file' entry found in SONATA config.")
+        with open(filepath, 'r') as f:
+            return json.load(f)
+
+    @lru_cache(maxsize=1)
+    def get_node_sets(self) -> dict[str, dict]:
+        filepath = self.impl.circuit.config.get("node_sets_file")
+        if not filepath:
+            raise ValueError("No 'node_sets_file' entry found in SONATA config.")
+        with open(filepath, 'r') as f:
+            return json.load(f)
+
+    @lru_cache(maxsize=1)
+    def get_report_entries(self) -> dict[str, dict]:
+        """Returns the 'reports' dictionary from the SONATA simulation config.
+
+        Each key is a report name, and the value is its configuration.
+        """
+        reports = self.impl.config.get("reports", {})
+        if not isinstance(reports, dict):
+            raise ValueError("Invalid format for 'reports' in SONATA config.")
+        return reports
+
     def connection_entries(self) -> list[ConnectionOverrides]:
         return self._connection_entries() + self._connection_overrides
 
+    def report_file_path(self, report_cfg: dict, report_key: str) -> Path:
+        """Resolve the full path for the report output file."""
+        output_dir = Path(self.output_root_path)
+        file_name = report_cfg.get("file_name", f"{report_key}.h5")
+        return output_dir / file_name
+
     @property
     def base_seed(self) -> int:
         return self.impl.run.random_seed
@@ -135,7 +172,13 @@ class SonataSimulationConfig:
 
     @property
     def output_root_path(self) -> str:
-        return self.impl.config["output"]["output_dir"]
+        return self.impl.config.get("output", {}).get("output_dir", "output")
+
+    @property
+    def spikes_file_path(self) -> Path:
+        output_dir = Path(self.output_root_path)
+        spikes_file = self.impl.config.get("output", {}).get("spikes_file", "spikes.h5")
+        return output_dir / spikes_file
 
     @property
     def extracellular_calcium(self) -> Optional[float]:

{bluecellulab-2.6.50 → bluecellulab-2.6.52}/bluecellulab/circuit/iotools.py

@@ -17,7 +17,6 @@ from __future__ import annotations
 from pathlib import Path
 import logging
 
-import bluepy
 import numpy as np
 
 from bluecellulab.circuit.node_id import CellId
@@ -28,6 +27,7 @@ logger = logging.getLogger(__name__)
 def parse_outdat(path: str | Path) -> dict[CellId, np.ndarray]:
     """Parse the replay spiketrains in a out.dat formatted file pointed to by
     path."""
+    import bluepy
     spikes = bluepy.impl.spike_report.SpikeReport.load(path).get()
     # convert Series to DataFrame with 2 columns for `groupby` operation
     spike_df = spikes.to_frame().reset_index()

{bluecellulab-2.6.50 → bluecellulab-2.6.52}/bluecellulab/circuit_simulation.py

@@ -17,10 +17,12 @@ simulations."""
 
 from __future__ import annotations
 from collections.abc import Iterable
+import os
 from pathlib import Path
 from typing import Optional
 import logging
 
+from collections import defaultdict
 import neuron
 import numpy as np
 import pandas as pd
@@ -45,6 +47,7 @@ from bluecellulab.circuit.simulation_access import BluepySimulationAccess, Simul
 from bluecellulab.importer import load_mod_files
 from bluecellulab.rngsettings import RNGSettings
 from bluecellulab.simulation.neuron_globals import NeuronGlobals
+from bluecellulab.simulation.report import configure_all_reports, write_compartment_report, write_sonata_spikes
 from bluecellulab.stimulus.circuit_stimulus_definitions import Noise, OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck, RelativeShotNoise, ShotNoise
 import bluecellulab.stimulus.circuit_stimulus_definitions as circuit_stimulus_definitions
 from bluecellulab.exceptions import BluecellulabError
@@ -301,6 +304,16 @@ class CircuitSimulation:
                 add_linear_stimuli=add_linear_stimuli
             )
 
+        configure_all_reports(
+            cells=self.cells,
+            simulation_config=self.circuit_access.config
+        )
+
+        # add spike recordings
+        for cell in self.cells.values():
+            if not cell.is_recording_spikes("soma", threshold=self.spike_threshold):
+                cell.start_recording_spikes(None, location="soma", threshold=self.spike_threshold)
+
     def _add_stimuli(self, add_noise_stimuli=False,
                      add_hyperpolarizing_stimuli=False,
                      add_relativelinear_stimuli=False,
@@ -458,13 +471,26 @@ class CircuitSimulation:
     @staticmethod
     def merge_pre_spike_trains(*train_dicts) -> dict[CellId, np.ndarray]:
         """Merge presynaptic spike train dicts."""
-        filtered_dicts = [d for d in train_dicts if d not in [None, {}, [], ()]]
+        filtered_dicts = [d for d in train_dicts if isinstance(d, dict) and d]
+
+        if not filtered_dicts:
+            logger.warning("merge_pre_spike_trains: No presynaptic spike trains found.")
+            return {}
 
         all_keys = set().union(*[d.keys() for d in filtered_dicts])
-        return {
-            k: np.sort(np.concatenate([d[k] for d in filtered_dicts if k in d]))
-            for k in all_keys
-        }
+        result = {}
+
+        for k in all_keys:
+            valid_arrays = []
+            for d in filtered_dicts:
+                if k in d:
+                    val = d[k]
+                    if isinstance(val, (np.ndarray, list)) and len(val) > 0:
+                        valid_arrays.append(np.asarray(val))
+            if valid_arrays:
+                result[k] = np.sort(np.concatenate(valid_arrays))
+
+        return result
 
     def _add_connections(
             self,
@@ -646,6 +672,8 @@ class CircuitSimulation:
             forward_skip_value=forward_skip_value,
             show_progress=show_progress)
 
+        self.write_reports()
+
     def get_mainsim_voltage_trace(
             self, cell_id: int | tuple[str, int], t_start=None, t_stop=None, t_step=None
     ) -> np.ndarray:
@@ -779,3 +807,76 @@ class CircuitSimulation:
                                  record_dt=cell_kwargs['record_dt'],
                                  template_format=cell_kwargs['template_format'],
                                  emodel_properties=cell_kwargs['emodel_properties'])
+
+    def write_reports(self):
+        """Write all reports defined in the simulation config."""
+        report_entries = self.circuit_access.config.get_report_entries()
+
+        for report_name, report_cfg in report_entries.items():
+            report_type = report_cfg.get("type", "compartment")
+            section = report_cfg.get("sections")
+
+            if report_type != "compartment":
+                raise NotImplementedError(f"Report type '{report_type}' is not supported.")
+
+            output_path = self.circuit_access.config.report_file_path(report_cfg, report_name)
+            if section == "compartment_set":
+                if report_cfg.get("cells") is not None:
+                    raise ValueError(
+                        "Report config error: 'cells' must not be set when using 'compartment_set' sections."
+                    )
+                compartment_sets = self.circuit_access.config.get_compartment_sets()
+                write_compartment_report(
+                    report_name=report_name,
+                    output_path=output_path,
+                    cells=self.cells,
+                    report_cfg=report_cfg,
+                    source_sets=compartment_sets,
+                    source_type="compartment_set"
+                )
+
+            else:
+                node_sets = self.circuit_access.config.get_node_sets()
+                if report_cfg.get("compartments") not in ("center", "all"):
+                    raise ValueError(
+                        f"Unsupported 'compartments' value '{report_cfg.get('compartments')}' "
+                        "for node-based section recording (must be 'center' or 'all')."
+                    )
+                write_compartment_report(
+                    report_name=report_name,
+                    output_path=output_path,
+                    cells=self.cells,
+                    report_cfg=report_cfg,
+                    source_sets=node_sets,
+                    source_type="node_set"
+                )
+
+        self.write_spike_report()
+
+    def write_spike_report(self):
+        """Collect and write in-memory recorded spike times to a SONATA HDF5
+        file, grouped by population as required by the SONATA specification."""
+        output_path = self.circuit_access.config.spikes_file_path
+
+        if os.path.exists(output_path):
+            os.remove(output_path)
+
+        # Group spikes per population
+        spikes_by_population = defaultdict(dict)
+        for gid, cell in self.cells.items():
+            pop = getattr(gid, 'population_name', None)
+            if pop is None:
+                continue
+            try:
+                cell_spikes = cell.get_recorded_spikes(location="soma", threshold=self.spike_threshold)
+                if cell_spikes is not None:
+                    spikes_by_population[pop][gid.id] = list(cell_spikes)
+            except AttributeError:
+                continue
+
+        # Ensure we at least create empty groups for all known populations
+        all_populations = set(getattr(gid, 'population_name', None) for gid in self.cells.keys())
+
+        for pop in all_populations:
+            spikes = spikes_by_population.get(pop, {})  # May be empty
+            write_sonata_spikes(output_path, spikes, pop)

bluecellulab-2.6.52/bluecellulab/simulation/report.py

@@ -0,0 +1,227 @@
+# Copyright 2025 Open Brain Institute
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Report class of bluecellulab."""
+
+import logging
+from pathlib import Path
+import h5py
+from typing import List
+import numpy as np
+import os
+
+from bluecellulab.tools import resolve_segments, resolve_source_nodes
+from bluecellulab.cell.cell_dict import CellDict
+
+logger = logging.getLogger(__name__)
+
+
+def _configure_recording(cell, report_cfg, source, source_type, report_name):
+    variable = report_cfg.get("variable_name", "v")
+
+    node_id = cell.cell_id
+    compartment_nodes = source.get("compartment_set") if source_type == "compartment_set" else None
+
+    targets = resolve_segments(cell, report_cfg, node_id, compartment_nodes, source_type)
+    for sec, sec_name, seg in targets:
+        try:
+            cell.add_variable_recording(variable=variable, section=sec, segx=seg)
+        except AttributeError:
+            logger.warning(f"Recording for variable '{variable}' is not implemented in Cell.")
+            return
+        except Exception as e:
+            logger.warning(
+                f"Failed to record '{variable}' at {sec_name}({seg}) on GID {node_id} for report '{report_name}': {e}"
+            )
+
+
+def configure_all_reports(cells, simulation_config):
+    report_entries = simulation_config.get_report_entries()
+
+    for report_name, report_cfg in report_entries.items():
+        report_type = report_cfg.get("type", "compartment")
+        section = report_cfg.get("sections", "soma")
+
+        if report_type != "compartment":
+            raise NotImplementedError(f"Report type '{report_type}' is not supported.")
+
+        if section == "compartment_set":
+            source_type = "compartment_set"
+            source_sets = simulation_config.get_compartment_sets()
+            source_name = report_cfg.get("compartments")
+            if not source_name:
+                logger.warning(f"Report '{report_name}' does not specify a node set in 'compartments' for {source_type}.")
+                continue
+        else:
+            source_type = "node_set"
+            source_sets = simulation_config.get_node_sets()
+            source_name = report_cfg.get("cells")
+            if not source_name:
+                logger.warning(f"Report '{report_name}' does not specify a node set in 'cells' for {source_type}.")
+                continue
+
+        source = source_sets.get(source_name)
+        if not source:
+            logger.warning(f"{source_type.title()} '{source_name}' not found for report '{report_name}', skipping recording.")
+            continue
+
+        population = source["population"]
+        node_ids, _ = resolve_source_nodes(source, source_type, cells, population)
+
+        for node_id in node_ids:
+            cell = cells.get((population, node_id))
+            if not cell:
+                continue
+            _configure_recording(cell, report_cfg, source, source_type, report_name)
+
+
+def write_compartment_report(
+    report_name: str,
+    output_path: str,
+    cells: CellDict,
+    report_cfg: dict,
+    source_sets: dict,
+    source_type: str,
+):
+    """Write a SONATA-compatible compartment report to an HDF5 file.
+
+    This function collects time series data (e.g., membrane voltage, ion currents)
+    from a group of cells defined by either a node set or a compartment set, and
+    writes the data to a SONATA-style report file.
+
+    Args:
+        output_path (str): Path to the output HDF5 file.
+        cells (CellDict): Mapping of (population, node_id) to cell objects that
+            provide access to pre-recorded variable traces.
+        report_cfg (dict): Configuration for the report. Must include:
+            - "variable_name": Name of the variable to report (e.g., "v", "ica", "ina").
+            - "start_time", "end_time", "dt": Timing parameters.
+            - "cells" or "compartments": Name of the node or compartment set.
+        source_sets (dict): Dictionary of either node sets or compartment sets.
+        source_type (str): Either "node_set" or "compartment_set".
+
+    Raises:
+        ValueError: If the specified source set is not found.
+
+    Notes:
+        - Currently supports only variables explicitly handled in Cell.get_variable_recording().
+        - Cells without recordings for the requested variable will be skipped.
+    """
+    source_name = report_cfg.get("cells") if source_type == "node_set" else report_cfg.get("compartments")
+    source = source_sets.get(source_name)
+    if not source:
+        logger.warning(f"{source_type.title()} '{source_name}' not found for report '{report_name}', skipping write.")
+        return
+
+    population = source["population"]
+
+    node_ids, compartment_nodes = resolve_source_nodes(source, source_type, cells, population)
+
+    data_matrix: List[np.ndarray] = []
+    recorded_node_ids: List[int] = []
+    index_pointers: List[int] = [0]
+    element_ids: List[int] = []
+
+    for node_id in node_ids:
+        try:
+            cell = cells[(population, node_id)]
+        except KeyError:
+            continue
+        if not cell:
+            continue
+
+        targets = resolve_segments(cell, report_cfg, node_id, compartment_nodes, source_type)
+        for sec, sec_name, seg in targets:
+            try:
+                variable = report_cfg.get("variable_name", "v")
+                trace = cell.get_variable_recording(variable=variable, section=sec, segx=seg)
+                data_matrix.append(trace)
+                recorded_node_ids.append(node_id)
+                element_ids.append(len(element_ids))
+                index_pointers.append(index_pointers[-1] + 1)
+            except Exception as e:
+                logger.warning(f"Failed recording: GID {node_id} sec {sec_name} seg {seg}: {e}")
+
+    if not data_matrix:
+        logger.warning(f"No data recorded for report '{source_name}'. Skipping write.")
+        return
+
+    write_sonata_report_file(
+        output_path, population, data_matrix, recorded_node_ids, index_pointers, element_ids, report_cfg
+    )
+
+
+def write_sonata_report_file(
+    output_path, population, data_matrix, recorded_node_ids, index_pointers, element_ids, report_cfg
+):
+    data_array = np.stack(data_matrix, axis=1)
+    node_ids_arr = np.array(recorded_node_ids, dtype=np.uint64)
+    index_ptr_arr = np.array(index_pointers, dtype=np.uint64)
+    element_ids_arr = np.array(element_ids, dtype=np.uint32)
+    time_array = np.array([
+        report_cfg.get("start_time", 0.0),
+        report_cfg.get("end_time", 0.0),
+        report_cfg.get("dt", 0.1)
+    ], dtype=np.float64)
+
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with h5py.File(output_path, "w") as f:
+        grp = f.require_group(f"/report/{population}")
+        data_ds = grp.create_dataset("data", data=data_array.astype(np.float32))
+
+        variable = report_cfg.get("variable_name", "v")
+        if variable == "v":
+            data_ds.attrs["units"] = "mV"
+
+        mapping = grp.require_group("mapping")
+        mapping.create_dataset("node_ids", data=node_ids_arr)
+        mapping.create_dataset("index_pointers", data=index_ptr_arr)
+        mapping.create_dataset("element_ids", data=element_ids_arr)
+        time_ds = mapping.create_dataset("time", data=time_array)
+        time_ds.attrs["units"] = "ms"
+
+
+def write_sonata_spikes(f_name: str, spikes_dict: dict[int, np.ndarray], population: str):
+    """Write a SONATA spike group to a spike file from {node_id: [t1, t2,
+    ...]}."""
+    all_node_ids: List[int] = []
+    all_timestamps: List[float] = []
+
+    for node_id, times in spikes_dict.items():
+        all_node_ids.extend([node_id] * len(times))
+        all_timestamps.extend(times)
+
+    if not all_timestamps:
+        logger.warning(f"No spikes to write for population '{population}'.")
+
+    # Sort by time for consistency
+    sorted_indices = np.argsort(all_timestamps)
+    node_ids_sorted = np.array(all_node_ids, dtype=np.uint64)[sorted_indices]
+    timestamps_sorted = np.array(all_timestamps, dtype=np.float64)[sorted_indices]
+
+    os.makedirs(os.path.dirname(f_name), exist_ok=True)
+    with h5py.File(f_name, 'a') as f:  # 'a' to allow multiple writes
+        spikes_group = f.require_group("spikes")
+        if population in spikes_group:
+            logger.warning(f"Overwriting existing group for population '{population}' in {f_name}.")
+            del spikes_group[population]
+
+        group = spikes_group.create_group(population)
+        sorting_enum = h5py.enum_dtype({'none': 0, 'by_id': 1, 'by_time': 2}, basetype='u1')
+        group.attrs.create("sorting", 2, dtype=sorting_enum)  # 2 = by_time
+
+        timestamps_ds = group.create_dataset("timestamps", data=timestamps_sorted)
+        group.create_dataset("node_ids", data=node_ids_sorted)
+
+        timestamps_ds.attrs["units"] = "ms"  # SONATA-required