bluecellulab 2.6.70__py3-none-any.whl → 2.6.72__py3-none-any.whl

bluecellulab/cell/core.py

@@ -19,7 +19,7 @@ import logging
 
 from pathlib import Path
 import queue
-from typing import Optional
+from typing import List, Optional, Tuple
 from typing_extensions import deprecated
 
 import neuron
@@ -793,13 +793,13 @@ class Cell(InjectableMixin, PlottableMixin):
             mech, var = variable.split(".", 1)
             mobj = getattr(seg, mech, None)
             if mobj is None or not hasattr(mobj, f"_ref_{var}"):
-                raise ValueError(
+                raise AttributeError(
                     f"'{variable}' not recordable at {section.name()}({segx}). "
                     f"Mechanisms here: {list(section.psection()['density_mechs'].keys())}"
                 )
         else:
             if not hasattr(seg, f"_ref_{variable}"):
-                raise ValueError(
+                raise AttributeError(
                     f"'{variable}' not recordable at {section.name()}({segx}). "
                     f"(Top-level vars are typically v/ina/ik/ica)"
                 )
@@ -840,7 +840,18 @@ class Cell(InjectableMixin, PlottableMixin):
         connected to that cell."""
         if self.sonata_proxy is None:
             raise BluecellulabError("Cell: add_synapse_replay requires a sonata proxy.")
-        synapse_spikes: dict = get_synapse_replay_spikes(stimulus.spike_file)
+
+        file_path = Path(stimulus.spike_file).expanduser()
+        if not file_path.is_absolute():
+            config_dir = stimulus.config_dir
+            if config_dir is not None:
+                file_path = Path(config_dir) / file_path
+
+        file_path = file_path.resolve()
+
+        if not file_path.exists():
+            raise FileNotFoundError(f"Spike file not found: {str(file_path)}")
+        synapse_spikes: dict = get_synapse_replay_spikes(str(file_path))
         for synapse_id, synapse in self.synapses.items():
             source_population = synapse.syn_description["source_population_name"]
             pre_gid = CellId(
@@ -900,6 +911,150 @@ class Cell(InjectableMixin, PlottableMixin):
     def __del__(self):
         self.delete()
 
+    def get_section(self, section_name: str) -> NeuronSection:
+        """Return a single, fully specified NEURON section (e.g., 'soma[0]',
+        'dend[3]').
+
+        Raises:
+            ValueError or TypeError if the section is not found or invalid.
+        """
+        if section_name in self.sections:
+            section = self.sections[section_name]
+            if hasattr(section, "nseg"):
+                return section
+            raise TypeError(f"'{section_name}' exists but is not a NEURON section.")
+
+        available = ", ".join(self.sections.keys())
+        raise ValueError(f"Section '{section_name}' not found. Available: [{available}]")
+
+    def get_sections(self, section_name: str) -> List[NeuronSection]:
+        """Return a list of NEURON sections.
+
+        If the section name is a fully specified one (e.g., 'dend[3]'), return it as a list of one.
+        If the section name is a base name (e.g., 'dend'), return all matching sections like 'dend[0]', 'dend[1]', etc.
+
+        Raises:
+            ValueError if no valid sections are found.
+        """
+        # Try to interpret as fully qualified section name
+        try:
+            return [self.get_section(section_name)]
+        except ValueError:
+            pass  # Not a precise match; try prefix match
+
+        # Fallback to prefix-based match (e.g., 'dend' → 'dend[0]', 'dend[1]', ...)
+        matched = [
+            section for name, section in self.sections.items()
+            if name.startswith(f"{section_name}[")
+        ]
+        if matched:
+            return matched
+
+        available = ", ".join(self.sections.keys())
+        raise ValueError(f"Section '{section_name}' not found. Available: [{available}]")
+
+    def get_section_by_id(self, section_id: int) -> NeuronSection:
+        """Return NEURON section by global section index (LibSONATA
+        ordering)."""
+        if not self.psections:
+            self._init_psections()
+
+        try:
+            return self.psections[int(section_id)].hsection
+        except KeyError:
+            raise IndexError(f"Section ID {section_id} is out of range for cell {self.cell_id.id}")
+
+    def resolve_segments_from_compartment_set(self, node_id, compartment_nodes) -> List[Tuple[NeuronSection, str, float]]:
+        """Resolve segments for a cell using a predefined compartment node
+        list.
+
+        Supports both LibSONATA format ([node_id, section_id, seg]) and
+        name-based format ([node_id, section_name, seg]).
+        """
+        result = []
+        for n_id, sec_ref, seg in compartment_nodes:
+            if n_id != node_id:
+                continue
+
+            if isinstance(sec_ref, str):
+                # Name-based: e.g., "dend[5]"
+                section = self.get_section(sec_ref)
+                sec_name = section.name().split(".")[-1]
+            elif isinstance(sec_ref, int):
+                # ID-based: resolve by section index
+                try:
+                    section = self.get_section_by_id(sec_ref)
+                    sec_name = section.name().split(".")[-1]
+                except AttributeError:
+                    raise ValueError(f"Cell object does not support section lookup by index: {sec_ref}")
+            else:
+                raise TypeError(f"Unsupported section reference type: {type(sec_ref)}")
+
+            result.append((section, sec_name, seg))
+        return result
+
+    def resolve_segments_from_config(self, report_cfg) -> List[Tuple[NeuronSection, str, float]]:
+        """Resolve segments from NEURON sections based on config."""
+        compartment = report_cfg.get("compartments", "center")
+        if compartment not in {"center", "all"}:
+            raise ValueError(
+                f"Unsupported 'compartments' value '{compartment}' — must be 'center' or 'all'."
+            )
+
+        section_name = report_cfg.get("sections", "soma")
+        sections = self.get_sections(section_name)
+
+        targets = []
+        for sec in sections:
+            sec_name = sec.name().split(".")[-1]
+            if compartment == "center":
+                targets.append((sec, sec_name, 0.5))
+            elif compartment == "all":
+                for seg in sec:
+                    targets.append((sec, sec_name, seg.x))
+        return targets
+
+    def configure_recording(self, recording_sites, variable_name, report_name):
+        """Configure recording of a variable on a single cell.
+
+        This function sets up the recording of the specified variable (e.g., membrane voltage)
+        in the target cell, for each resolved segment.
+
+        Parameters
+        ----------
+        cell : Any
+            The cell object on which to configure recordings.
+
+        recording_sites : list of tuples
+            List of tuples (section, section_name, segment) where:
+            - section is the section object in the cell.
+            - section_name is the name of the section.
+            - segment is the Neuron segment index (0-1).
+
+        variable_name : str
+            The name of the variable to record (e.g., "v" for membrane voltage).
+
+        report_name : str
+            The name of the report (used in logging).
+        """
+        node_id = self.cell_id.id
+
+        for sec, sec_name, seg in recording_sites:
+            try:
+                self.add_variable_recording(variable=variable_name, section=sec, segx=seg)
+                logger.info(
+                    f"Recording '{variable_name}' at {sec_name}({seg}) on GID {node_id} for report '{report_name}'"
+                )
+            except AttributeError:
+                logger.warning(
+                    f"Recording for variable '{variable_name}' is not implemented in Cell."
+                )
+                return
+            except Exception as e:
+                logger.warning(
+                    f"Failed to record '{variable_name}' at {sec_name}({seg}) on GID {node_id} for report '{report_name}': {e}"
+                )
+
     def add_currents_recordings(
         self,
         section,

bluecellulab/circuit/config/sonata_simulation_config.py

@@ -55,8 +55,9 @@ class SonataSimulationConfig:
         inputs = self.impl.config.get("inputs")
         if inputs is None:
             return result
+        config_dir = self._get_config_dir()
         for value in inputs.values():
-            stimulus = Stimulus.from_sonata(value)
+            stimulus = Stimulus.from_sonata(value, config_dir=config_dir)
             if stimulus:
                 result.append(stimulus)
         return result
@@ -84,7 +85,11 @@ class SonataSimulationConfig:
         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:
+        config_dir = self._get_config_dir()
+        full_path = Path(filepath)
+        if config_dir is not None and not full_path.is_absolute():
+            full_path = Path(config_dir) / filepath
+        with open(full_path, 'r') as f:
             return json.load(f)
 
     @lru_cache(maxsize=1)
@@ -125,6 +130,8 @@ class SonataSimulationConfig:
         """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")
+        if not file_name.endswith(".h5"):
+            file_name += ".h5"
         return output_dir / file_name
 
     @property
@@ -214,3 +221,12 @@ class SonataSimulationConfig:
         connection_override: ConnectionOverrides
     ) -> None:
         self._connection_overrides.append(connection_override)
+
+    def _get_config_dir(self):
+        # Prefer config_path, fallback to _simulation_config_path
+        config_path = getattr(self.impl, "config_path", None)
+        if config_path is None:
+            sim_config_path = getattr(self.impl, "_simulation_config_path", None)
+            if sim_config_path is not None:
+                config_path = Path(sim_config_path)
+        return str(config_path.parent) if config_path is not None else None

bluecellulab/reports/manager.py

@@ -14,7 +14,11 @@
 
 from typing import Optional, Dict
 from bluecellulab.reports.writers import get_writer
-from bluecellulab.reports.utils import extract_spikes_from_cells  # helper you already have / write
+from bluecellulab.reports.utils import SUPPORTED_REPORT_TYPES, extract_spikes_from_cells  # helper you already have / write
+
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 class ReportManager:
@@ -52,21 +56,30 @@ class ReportManager:
 
     def _write_voltage_reports(self, cells_or_traces):
         for name, rcfg in self.cfg.get_report_entries().items():
-            if rcfg.get("type") != "compartment":
+            if rcfg.get("type") not in SUPPORTED_REPORT_TYPES:
                 continue
 
-            section = rcfg.get("sections")
-            if section == "compartment_set":
+            report_type = rcfg.get("type")
+            if report_type == "compartment_set":
                 if rcfg.get("cells") is not None:
-                    raise ValueError("'cells' may not be set with 'compartment_set'")
-                src_sets, src_type = self.cfg.get_compartment_sets(), "compartment_set"
-            else:
-                if rcfg.get("compartments") not in ("center", "all"):
+                    raise ValueError("'cells' may not be set when using 'compartment_set' report type.")
+                if rcfg.get("sections") is not None:
+                    raise ValueError("'sections' may not be set when using 'compartment_set' report type.")
+                if rcfg.get("compartments") is not None:
+                    raise ValueError("'compartments' may not be set when using 'compartment_set' report type.")
+                src_sets = self.cfg.get_compartment_sets()
+            elif report_type == "compartment":
+                compartments = rcfg.get("compartments") or "center"
+                if compartments not in ("center", "all"):
                     raise ValueError("invalid 'compartments' value")
-                src_sets, src_type = self.cfg.get_node_sets(), "node_set"
+                if rcfg.get("cells") is None:
+                    raise ValueError("'cells' must be specified when using compartment reports")
+                src_sets = self.cfg.get_node_sets()
+            else:
+                logger.error(f"Unsupported report type '{report_type}' in configuration for report '{name}'")
 
             rcfg["_source_sets"] = src_sets
-            rcfg["_source_type"] = src_type
+            rcfg["name"] = name
 
             out_path = self.cfg.report_file_path(rcfg, name)
             writer = get_writer("compartment")(rcfg, out_path, self.dt)

bluecellulab/reports/utils.py

@@ -17,50 +17,13 @@ from collections import defaultdict
 import logging
 from typing import Dict, Any, List
 
-from bluecellulab.tools import resolve_segments, resolve_source_nodes
+from bluecellulab.tools import (
+    resolve_source_nodes,
+)
 
 logger = logging.getLogger(__name__)
 
-
-def _configure_recording(cell, report_cfg, source, source_type, report_name):
-    """Configure recording of a variable on a single cell.
-
-    This function sets up the recording of the specified variable (e.g., membrane voltage)
-    in the target cell, for each resolved segment.
-
-    Parameters
-    ----------
-    cell : Any
-        The cell object on which to configure recordings.
-
-    report_cfg : dict
-        The configuration dictionary for this report.
-
-    source : dict
-        The source definition specifying nodes or compartments.
-
-    source_type : str
-        Either "node_set" or "compartment_set".
-
-    report_name : str
-        The name of the report (used in logging).
-    """
-    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}"
-            )
+SUPPORTED_REPORT_TYPES = {"compartment", "compartment_set"}
 
 
 def configure_all_reports(cells, simulation_config):
@@ -83,39 +46,132 @@ def configure_all_reports(cells, simulation_config):
 
     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"
+        if report_type == "compartment_set":
             source_sets = simulation_config.get_compartment_sets()
-            source_name = report_cfg.get("compartments")
+            source_name = report_cfg.get("compartment_set")
             if not source_name:
-                logger.warning(f"Report '{report_name}' does not specify a node set in 'compartments' for {source_type}.")
+                logger.warning(
+                    f"Report '{report_name}' does not specify a node set in 'compartment_set' for {report_type}."
+                )
                 continue
-        else:
-            source_type = "node_set"
+        elif report_type == "compartment":
             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}.")
+                logger.warning(
+                    f"Report '{report_name}' does not specify a node set in 'cells' for {report_type}."
+                )
                 continue
+        else:
+            raise NotImplementedError(
+                f"Report type '{report_type}' is not supported. "
+                f"Supported types: {SUPPORTED_REPORT_TYPES}"
+            )
 
         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.")
+            logger.warning(
+                f"{report_type} '{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:
+        node_ids, compartment_nodes = resolve_source_nodes(
+            source, report_type, cells, population
+        )
+        recording_sites_per_cell = build_recording_sites(
+            cells, node_ids, population, report_type, report_cfg, compartment_nodes
+        )
+        variable_name = report_cfg.get("variable_name", "v")
+
+        for node_id, recording_sites in recording_sites_per_cell.items():
             cell = cells.get((population, node_id))
-            if not cell:
+            if not cell or recording_sites is None:
                 continue
-            _configure_recording(cell, report_cfg, source, source_type, report_name)
+
+            cell.configure_recording(recording_sites, variable_name, report_name)
+
+
+def build_recording_sites(
+    cells_or_traces, node_ids, population, report_type, report_cfg, compartment_nodes
+):
+    """Build per-cell recording sites based on source type and report
+    configuration.
+
+    This function resolves the segments (section, name, seg.x) where variables
+    should be recorded for each cell, based on either a node set (standard
+    compartment reports) or a compartment set (predefined segment list).
+
+    Parameters
+    ----------
+    cells_or_traces : dict
+        Either a mapping from (population, node_id) to Cell objects (live sim),
+        or from gid_key strings to trace dicts (gathered traces on rank 0).
+
+    node_ids : list of int
+        List of node IDs for which recordings should be configured.
+
+    population : str
+        Name of the population to which the cells belong.
+
+    report_type : str
+        The report type, either 'compartment_set' or 'compartment'.
+
+    report_cfg : dict
+        Configuration dictionary specifying report parameters
+
+    compartment_nodes : list or None
+        Optional list of [node_id, section_name, seg_x] defining segment locations
+        for each cell (used if report_type == 'compartment_set').
+
+    Returns
+    -------
+    dict
+        Mapping from node ID to list of recording site tuples:
+        (section_object, section_name, seg_x).
+    """
+    targets_per_cell = {}
+
+    for node_id in node_ids:
+        # Handle both (pop, id) and "pop_id" keys
+        key = (population, node_id)
+        cell_or_trace = cells_or_traces.get(key) or cells_or_traces.get(f"{population}_{node_id}")
+        if not cell_or_trace:
+            continue
+
+        if isinstance(cell_or_trace, dict):  # Trace dict, not Cell
+            if report_type == "compartment_set":
+                # Find all entries matching node_id
+                targets = [
+                    (None, section_name, segx)
+                    for nid, section_name, segx in compartment_nodes
+                    if nid == node_id
+                ]
+            elif report_type == "compartment":
+                section_name = report_cfg.get("sections", "soma")
+                segx = 0.5 if report_cfg.get("compartments", "center") == "center" else 0.0
+                targets = [(None, f"{section_name}[0]", segx)]
+            else:
+                raise NotImplementedError(
+                    f"Unsupported report type '{report_type}' in trace-based output."
+                )
+        else:
+            # Cell object
+            if report_type == "compartment_set":
+                targets = cell_or_trace.resolve_segments_from_compartment_set(
+                    node_id, compartment_nodes
+                )
+            elif report_type == "compartment":
+                targets = cell_or_trace.resolve_segments_from_config(report_cfg)
+            else:
+                raise NotImplementedError(
+                    f"Report type '{report_type}' is not supported. "
+                    f"Supported types: {SUPPORTED_REPORT_TYPES}"
+                )
+
+        targets_per_cell[node_id] = targets
+
+    return targets_per_cell
 
 
 def extract_spikes_from_cells(
@@ -144,13 +200,28 @@ def extract_spikes_from_cells(
     spikes_by_pop: defaultdict[str, Dict[int, List[float]]] = defaultdict(dict)
 
     for key, cell in cells.items():
+        # Resolve the key to (population, gid)
         if isinstance(key, tuple):
             pop, gid = key
+        elif isinstance(key, str):
+            try:
+                pop, gid_str = key.rsplit("_", 1)
+                gid = int(gid_str)
+            except Exception:
+                raise ValueError(
+                    f"Cell key '{key}' could not be parsed as 'population_gid'"
+                )
         else:
-            raise ValueError(f"Cell key {key} is not a (population, gid) tuple.")
+            raise ValueError(f"Cell key '{key}' is not a recognized format.")
+
+        if not hasattr(cell, "get_recorded_spikes"):
+            raise TypeError(
+                f"Cannot extract spikes: cell entry {key} is not a Cell object (got {type(cell)}). "
+                "If you have precomputed traces, pass them as `spikes_by_pop`."
+            )
 
         times = cell.get_recorded_spikes(location=location, threshold=threshold)
-        if times is not None and len(times) > 0:
-            spikes_by_pop[pop][gid] = list(times)
+        # Always assign, even if empty
+        spikes_by_pop[pop][gid] = list(times) if times is not None else []
 
     return dict(spikes_by_pop)

bluecellulab/reports/writers/compartment.py

@@ -16,10 +16,11 @@ from pathlib import Path
 import numpy as np
 import h5py
 from typing import Dict, List
+
 from .base_writer import BaseReportWriter
 from bluecellulab.reports.utils import (
+    build_recording_sites,
     resolve_source_nodes,
-    resolve_segments,
 )
 import logging
 
@@ -31,52 +32,67 @@ class CompartmentReportWriter(BaseReportWriter):
 
     def write(self, cells: Dict, tstart=0):
         report_name = self.cfg.get("name", "unnamed")
-        # section     = self.cfg.get("sections")
         variable = self.cfg.get("variable_name", "v")
+        report_type = self.cfg.get("type", "compartment")
 
+        # Resolve source set
         source_sets = self.cfg["_source_sets"]
-        source_type = self.cfg["_source_type"]
-        src_name = self.cfg.get("cells") if source_type == "node_set" else self.cfg.get("compartments")
+        if report_type == "compartment":
+            src_name = self.cfg.get("cells")
+        elif report_type == "compartment_set":
+            src_name = self.cfg.get("compartment_set")
+        else:
+            raise NotImplementedError(
+                f"Unsupported report type '{report_type}' in configuration for report '{report_name}'"
+            )
+
         src = source_sets.get(src_name)
         if not src:
-            logger.warning(f"{source_type.title()} '{src_name}' not found – skipping '{report_name}'.")
+            logger.warning(f"{report_type} '{src_name}' not found – skipping '{report_name}'.")
             return
 
         population = src["population"]
-        node_ids, comp_nodes = resolve_source_nodes(src, source_type, cells, population)
+        node_ids, comp_nodes = resolve_source_nodes(src, report_type, cells, population)
+        recording_sites_per_cell = build_recording_sites(
+            cells, node_ids, population, report_type, self.cfg, comp_nodes
+        )
+
+        # Detect trace mode
+        sample_cell = next(iter(cells.values()))
+        is_trace_mode = isinstance(sample_cell, dict)
 
         data_matrix: List[np.ndarray] = []
         node_id_list: List[int] = []
         idx_ptr: List[int] = [0]
         elem_ids: List[int] = []
 
-        for nid in node_ids:
+        for nid in sorted(recording_sites_per_cell):
+            recording_sites = recording_sites_per_cell[nid]
             cell = cells.get((population, nid)) or cells.get(f"{population}_{nid}")
             if cell is None:
+                logger.warning(f"Cell or trace for ({population}, {nid}) not found – skipping.")
                 continue
 
-            if isinstance(cell, dict):
-                # No section/segment structure to resolve for traces
-                trace = np.asarray(cell["voltage"], dtype=np.float32)
-                data_matrix.append(trace)
-                node_id_list.append(nid)
-                elem_ids.append(len(elem_ids))
-                idx_ptr.append(idx_ptr[-1] + 1)
-                continue
-
-            targets = resolve_segments(cell, self.cfg, nid, comp_nodes, source_type)
-            for sec, sec_name, seg in targets:
-                try:
-                    if hasattr(cell, "get_variable_recording"):
-                        trace = cell.get_variable_recording(variable=variable, section=sec, segx=seg)
-                    else:
-                        trace = np.asarray(cell["voltage"], dtype=np.float32)
-                    data_matrix.append(trace)
+            if is_trace_mode:
+                voltage = np.asarray(cell["voltage"], dtype=np.float32)
+                for sec, sec_name, seg in recording_sites:
+                    data_matrix.append(voltage)
                     node_id_list.append(nid)
                     elem_ids.append(len(elem_ids))
                     idx_ptr.append(idx_ptr[-1] + 1)
-                except Exception as e:
-                    logger.warning(f"Failed recording {nid}:{sec_name}@{seg}: {e}")
+            else:
+                for sec, sec_name, seg in recording_sites:
+                    try:
+                        if hasattr(cell, "get_variable_recording"):
+                            trace = cell.get_variable_recording(variable=variable, section=sec, segx=seg)
+                        else:
+                            trace = np.asarray(cell["voltage"], dtype=np.float32)
+                        data_matrix.append(trace)
+                        node_id_list.append(nid)
+                        elem_ids.append(len(elem_ids))
+                        idx_ptr.append(idx_ptr[-1] + 1)
+                    except Exception as e:
+                        logger.warning(f"Failed recording {nid}:{sec_name}@{seg}: {e}")
 
         if not data_matrix:
             logger.warning(f"No data for report '{report_name}'.")
@@ -148,7 +164,8 @@ class CompartmentReportWriter(BaseReportWriter):
         if dt_report < sim_dt:
             logger.warning(
                 f"Requested report dt={dt_report} ms is finer than simulation dt={sim_dt} ms. "
-                f"Clamping report dt to {sim_dt} ms."
+                f"Clamping report dt to {sim_dt} ms. "
+                f"To achieve finer temporal resolution, reduce the simulation dt in your config."
             )
             dt_report = sim_dt
 
@@ -161,7 +178,7 @@ class CompartmentReportWriter(BaseReportWriter):
         # Downsample the data if needed
         # Compute start and end indices in the original data
         start_index = int(round((start_time - tstart) / sim_dt))
-        end_index = int(round((end_time - tstart) / sim_dt)) + 1  # inclusive
+        end_index = int(round((end_time - tstart) / sim_dt))
 
         # Now slice and downsample
         data_matrix_downsampled = [

bluecellulab/reports/writers/spikes.py

@@ -25,37 +25,62 @@ class SpikeReportWriter(BaseReportWriter):
     """Writes SONATA spike report from pop→gid→times mapping."""
 
     def write(self, spikes_by_pop: Dict[str, Dict[int, list]]):
+        """Write SONATA spike report with per-population groups.
+
+        Creates empty datasets for populations without spikes.
+        """
+
+        # Remove any existing file
         if self.output_path.exists():
             self.output_path.unlink()
 
+        # Make sure parent directory exists
         self.output_path.parent.mkdir(parents=True, exist_ok=True)
 
-        for pop, gid_map in spikes_by_pop.items():
-            all_node_ids: List[int] = []
-            all_timestamps: List[float] = []
-            for node_id, times in gid_map.items():
-                all_node_ids.extend([node_id] * len(times))
-                all_timestamps.extend(times)
+        # Always create the file and /spikes group
+        with h5py.File(self.output_path, "w") as f:
+            spikes_group = f.create_group("spikes")
+
+            for pop, gid_map in spikes_by_pop.items():
+                all_node_ids: List[int] = []
+                all_timestamps: List[float] = []
+
+                for node_id, times in gid_map.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 '{pop}'.")
+                if not all_timestamps:
+                    logger.warning(f"No spikes to write for population '{pop}'.")
 
-            # 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]
+                # Sort by time for consistency (will be empty arrays if no spikes)
+                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
+                ]
 
-            with h5py.File(self.output_path, 'a') as f:
-                spikes_group = f.require_group("spikes")
                 if pop in spikes_group:
-                    logger.warning(f"Overwriting existing group for population '{pop}' in {self.output_path}.")
+                    logger.warning(
+                        f"Overwriting existing group for population '{pop}' in {self.output_path}."
+                    )
                     del spikes_group[pop]
 
                 group = spikes_group.create_group(pop)
-                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)
 
+                # SONATA requires the 'sorting' attribute
+                sorting_enum = h5py.enum_dtype(
+                    {"none": 0, "by_id": 1, "by_time": 2}, basetype="u1"
+                )
+                if timestamps_sorted.size > 0:
+                    group.attrs.create("sorting", 2, dtype=sorting_enum)  # 2 = by_time
+                else:
+                    group.attrs.create("sorting", 0, dtype=sorting_enum)  # 0 = none
+
+                # Always create datasets (even empty)
+                timestamps_ds = group.create_dataset(
+                    "timestamps", data=timestamps_sorted
+                )
                 timestamps_ds.attrs["units"] = "ms"  # SONATA-required
+                group.create_dataset("node_ids", data=node_ids_sorted)

bluecellulab/stimulus/circuit_stimulus_definitions.py

@@ -19,7 +19,6 @@ Run-time validates the data via Pydantic.
 from __future__ import annotations
 
 from enum import Enum
-from pathlib import Path
 from typing import Optional
 import warnings
 
@@ -212,7 +211,7 @@ class Stimulus:
             raise ValueError(f"Unknown pattern {pattern}")
 
     @classmethod
-    def from_sonata(cls, stimulus_entry: dict) -> Optional[Stimulus]:
+    def from_sonata(cls, stimulus_entry: dict, config_dir: Optional[str] = None) -> Optional[Stimulus]:
         pattern = Pattern.from_sonata(stimulus_entry["module"])
         if pattern == Pattern.NOISE:
             return Noise(
@@ -259,6 +258,7 @@ class Stimulus:
                 delay=stimulus_entry["delay"],
                 duration=stimulus_entry["duration"],
                 spike_file=stimulus_entry["spike_file"],
+                config_dir=config_dir,
             )
         elif pattern == Pattern.SHOT_NOISE:
             return ShotNoise(
@@ -361,13 +361,7 @@ class RelativeLinear(Stimulus):
 @dataclass(frozen=True, config=dict(extra="forbid"))
 class SynapseReplay(Stimulus):
     spike_file: str
-
-    @field_validator("spike_file")
-    @classmethod
-    def spike_file_exists(cls, v):
-        if not Path(v).exists():
-            raise ValueError(f"spike_file {v} does not exist")
-        return v
+    config_dir: Optional[str] = None
 
 
 @dataclass(frozen=True, config=dict(extra="forbid"))

bluecellulab/tools.py

@@ -29,7 +29,6 @@ from bluecellulab.exceptions import UnsteadyCellError
 from bluecellulab.simulation.neuron_globals import set_neuron_globals
 from bluecellulab.simulation.parallel import IsolatedProcess
 from bluecellulab.utils import CaptureOutput
-from bluecellulab.type_aliases import NeuronSection
 
 
 logger = logging.getLogger(__name__)
@@ -119,7 +118,7 @@ def calculate_SS_voltage_subprocess(
         emodel_properties=emodel_properties,
     )
 
-    sec = get_section(cell, section)
+    sec = cell.get_section(section)
     neuron_section = sec
     cell.add_voltage_recording(cell.sections[section], segx)
     cell.add_ramp(500, 5000, step_level, step_level, section=neuron_section, segx=segx)
@@ -313,7 +312,7 @@ def detect_spike_step_subprocess(
         template_format=template_format,
         emodel_properties=emodel_properties)
 
-    sec = get_section(cell, section)
+    sec = cell.get_section(section)
     cell.add_voltage_recording(cell.sections[section], segx)
 
     neuron_section = sec
@@ -517,88 +516,19 @@ def validate_section_and_segment(cell: Cell, section_name: str, segment_position
         raise ValueError(f"Segment position must be between 0.0 and 1.0, got {segment_position}.")
 
 
-def get_section(cell: Cell, section_name: str) -> NeuronSection:
-    """Return a single, fully specified NEURON section (e.g., 'soma[0]',
-    'dend[3]').
-
-    Raises:
-        ValueError or TypeError if the section is not found or invalid.
-    """
-    if section_name in cell.sections:
-        section = cell.sections[section_name]
-        if hasattr(section, "nseg"):
-            return section
-        raise TypeError(f"'{section_name}' exists but is not a NEURON section.")
-
-    available = ", ".join(cell.sections.keys())
-    raise ValueError(f"Section '{section_name}' not found. Available: [{available}]")
-
-
-def get_sections(cell, section_name: str):
-    """Return a list of NEURON sections.
-
-    If the section name is a fully specified one (e.g., 'dend[3]'), return it as a list of one.
-    If the section name is a base name (e.g., 'dend'), return all matching sections like 'dend[0]', 'dend[1]', etc.
-
-    Raises:
-        ValueError or TypeError if no valid sections are found.
-    """
-    # Try to interpret as fully qualified section name
-    try:
-        return [get_section(cell, section_name)]
-    except ValueError:
-        pass  # Not a precise match; try prefix match
-
-    # Fallback to prefix-based match (e.g., 'dend' → 'dend[0]', 'dend[1]', ...)
-    matched = [
-        section for name, section in cell.sections.items()
-        if name.startswith(f"{section_name}[")
-    ]
-    if matched:
-        return matched
-
-    available = ", ".join(cell.sections.keys())
-    raise ValueError(f"Section '{section_name}' not found. Available: [{available}]")
-
-
-def resolve_segments(cell, report_cfg, node_id, compartment_nodes, source_type):
-    """Determine which segments to record from one or more NEURON sections."""
-    section_name = report_cfg.get("sections", "soma")
-    compartment = report_cfg.get("compartments", "center")
-
-    if source_type == "compartment_set":
-        return [
-            (get_section(cell, sec), sec, seg)
-            for _, sec, seg in compartment_nodes if _ == node_id
-        ]
-
-    sections = get_sections(cell, section_name)
-    targets = []
-
-    for sec in sections:
-        sec_name = sec.name().split(".")[-1]
-        if compartment == "center":
-            targets.append((sec, sec_name, 0.5))
-        elif compartment == "all":
-            for seg in sec:
-                targets.append((sec, sec_name, seg.x))
-        else:
-            raise ValueError(
-                f"Unsupported 'compartments' value '{compartment}' — must be 'center' or 'all'."
-            )
-
-    return targets
-
-
-def resolve_source_nodes(source, source_type, cells, population):
-    if source_type == "compartment_set":
+def resolve_source_nodes(source, report_type, cells, population):
+    if report_type == "compartment_set":
         compartment_nodes = source.get("compartment_set", [])
         node_ids = [entry[0] for entry in compartment_nodes]
-    else:  # node_set
+    elif report_type == "compartment":
         node_ids = source.get("node_id")
         if node_ids is None:
             node_ids = [node_id for (pop, node_id) in cells.keys() if pop == population]
         compartment_nodes = None
+    else:
+        raise NotImplementedError(
+            f"Unsupported source type '{report_type}' in configuration for report."
+        )
     return node_ids, compartment_nodes
 
 

{bluecellulab-2.6.70.dist-info → bluecellulab-2.6.72.dist-info}/METADATA

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

{bluecellulab-2.6.70.dist-info → bluecellulab-2.6.72.dist-info}/RECORD

@@ -10,7 +10,7 @@ bluecellulab/plotwindow.py,sha256=ePU-EegZ1Sqk0SoYYiQ6k24ZO4s3Hgfpx10uePiJ5xM,27
 bluecellulab/psection.py,sha256=FSOwRNuOTyB469BM-jPEf9l1J59FamXmzrQgBI6cnP4,6174
 bluecellulab/psegment.py,sha256=PTgoGLqM4oFIdF_8QHFQCU59j-8TQmtq6PakiGUQhIo,3138
 bluecellulab/rngsettings.py,sha256=2Ykb4Ylk3XTs58x1UIxjg8XJqjSpnCgKRZ8avXCDpxk,4237
-bluecellulab/tools.py,sha256=ePal9-y6AnIgSdRzqqL8fH57M96VXUWPEGvJ7mpz4Ps,21926
+bluecellulab/tools.py,sha256=OamYjgBBBiUiXlf4zCDOjI-SuA6o9Ck8UsKsAi_8gEg,19483
 bluecellulab/type_aliases.py,sha256=DvgjERv2Ztdw_sW63JrZTQGpJ0x5uMTFB5hcBHDb0WA,441
 bluecellulab/utils.py,sha256=0NhwlzyLnSi8kziSfDsQf7pokO4qDkMJVAO33kSX4O0,2227
 bluecellulab/verbosity.py,sha256=T0IgX7DrRo19faxrT4Xzb27gqxzoILQ8FzYKxvUeaPM,1342
@@ -21,7 +21,7 @@ bluecellulab/analysis/plotting.py,sha256=PqRoaZz33ULMw8A9YnZXXrxcUd84M_dwlYMTFhG
 bluecellulab/analysis/utils.py,sha256=eMirP557D11BuedgSqjripDxOq1haIldNbnYNetV1bg,121
 bluecellulab/cell/__init__.py,sha256=Sbc0QOsJ8E7tSwf3q7fsXuE_SevBN6ZmoCVyyU5zfII,208
 bluecellulab/cell/cell_dict.py,sha256=VE7pi-NsMVRSmo-PSdbiLYmolDOu0Gc6JxFBkuQpFdk,1346
-bluecellulab/cell/core.py,sha256=PKus_O8iREcU5-SDBjM7XbRUwromPz-K9imGo2Q11-4,37875
+bluecellulab/cell/core.py,sha256=ndfDwcYfINe-T9hniH-XL9TKPCa6c2sNa-HuCfDVKZE,44213
 bluecellulab/cell/injector.py,sha256=GB0pmyZMOHNV-lzd_t4cLoDE87S58IMbe7-qU1zBWvE,19033
 bluecellulab/cell/plotting.py,sha256=t2qDUabFtsBb-nJMkDh5UfsgW-wvQ2wfDwAVZ8-hWPo,4032
 bluecellulab/cell/random.py,sha256=pemekc11geRBKD8Ghb82tvKOZLfFWkUz1IKLc_NWg-A,1773
@@ -50,35 +50,35 @@ bluecellulab/circuit/config/__init__.py,sha256=aaoJXRKBJzpxxREo9NxKc-_CCPmVeuR1m
 bluecellulab/circuit/config/bluepy_simulation_config.py,sha256=V3eqOzskX7VrMDpl-nMQVEhDg8QWgRmRduyJBii5sgI,6974
 bluecellulab/circuit/config/definition.py,sha256=cotKRDHOjzZKNgNSrZ29voU-66W8jaGt5yuge1hyv18,2953
 bluecellulab/circuit/config/sections.py,sha256=QRnU44-OFvHxcF1LX4bAEP9dk3I6UKsuPNBbWkdfmRE,7151
-bluecellulab/circuit/config/sonata_simulation_config.py,sha256=J1DFqNxIJKAxD1KU_oJV9tigMdpT_Not0Q8SF5q2EeQ,7271
+bluecellulab/circuit/config/sonata_simulation_config.py,sha256=M3dD9B69VK01lRaR84PiAj8th-x8hrAE80IpGDLqvi8,8056
 bluecellulab/hoc/Cell.hoc,sha256=z77qRQG_-afj-RLX0xN6V-K6Duq3bR7vmlDrGWPdh4E,16435
 bluecellulab/hoc/RNGSettings.hoc,sha256=okJBdqlPXET8BrpG1Q31GdaxHfpe3CE0L5P7MAhfQTE,1227
 bluecellulab/hoc/TDistFunc.hoc,sha256=WKX-anvL83xGuGPH9g1oIORB17UM4Pi3-iIXzKO-pUQ,2663
 bluecellulab/hoc/TStim.hoc,sha256=noBJbM_ZqF6T6MEgBeowNzz21I9QeYZ5brGgUvCSm4k,8473
 bluecellulab/hoc/fileUtils.hoc,sha256=LSM7BgyjYVqo2DGSOKvg4W8IIusbsL45JVYK0vgwitU,2539
 bluecellulab/reports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bluecellulab/reports/manager.py,sha256=hy54B7AXa46bgjKJ_Ar65_GYIu9C8Zg2fgxIlxSweRE,3284
-bluecellulab/reports/utils.py,sha256=yZPtO0HXs6HPDVOZQbeXlPajnSOqE2Qmx8VufQFJFT0,5557
+bluecellulab/reports/manager.py,sha256=bKtqxOnZcta4HwrlWN51ysfMmvcbISksUpOKF0pJFV0,4021
+bluecellulab/reports/utils.py,sha256=wnYFo1xKbBRu1KZTIea83Wvakoo_SQ94QiqOD26cEe0,8271
 bluecellulab/reports/writers/__init__.py,sha256=Q8Y2GC83jseH5QY9IlEQsvaUQIH-BzgqhVjGRWD5j90,826
 bluecellulab/reports/writers/base_writer.py,sha256=P5ramFD2oFIroEBCH1pAscbkfcBIVYFIBg4pVpSP2IU,1042
-bluecellulab/reports/writers/compartment.py,sha256=EwFc2NwqhGEwGShEFOIrpYWRgH4b7qZCwsPvpUxeboU,7212
-bluecellulab/reports/writers/spikes.py,sha256=ycMuoT6f-UbAbC47X9gkG44OQYeAGBQMB2RdJAq3Ykg,2558
+bluecellulab/reports/writers/compartment.py,sha256=vtBRBNHm6NRnX09RZCszC9MKpiZqqVovlhwsfitzaRU,7960
+bluecellulab/reports/writers/spikes.py,sha256=FJm74SKeMb0h_oNucwWoNrh8xLObzinQTOHH0v1xKeU,3375
 bluecellulab/simulation/__init__.py,sha256=P2ebt0SFw-08J3ihN-LeRn95HeF79tzA-Q0ReLm32dM,214
 bluecellulab/simulation/neuron_globals.py,sha256=wvh6HfVYXoUsAcy17wqI_4SOqBCovRGEEaW9ANDgiIQ,4943
 bluecellulab/simulation/parallel.py,sha256=oQ_oV2EKr8gP4yF2Dq8q9MiblDyi89_wBgLzQkLV_U0,1514
 bluecellulab/simulation/report.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bluecellulab/simulation/simulation.py,sha256=OfrzeHvLmOV2ptYcGie_fVGrtkDfizLpE6ZyQWVxnIE,6492
 bluecellulab/stimulus/__init__.py,sha256=DgIgVaSyR-URf3JZzvO6j-tjCerzvktuK-ep8pjMRPQ,37
-bluecellulab/stimulus/circuit_stimulus_definitions.py,sha256=h_SqjJ-L3yNxiEO8I6Cy7i-lhfZXjrdCc92dl8bjOog,17229
+bluecellulab/stimulus/circuit_stimulus_definitions.py,sha256=Xdd4j3oiGHNsuGEjI-KLy0EQd-Qd7C9JvOSLJwIr7pE,17113
 bluecellulab/stimulus/factory.py,sha256=4fvVFFjOGHSqBidLe_W1zQozfMEeePXWO6yYCs30-SM,30780
 bluecellulab/stimulus/stimulus.py,sha256=a_hKJUtZmIgjiFjbJf6RzUPokELqn0IHCgIWGw5XLm8,30322
 bluecellulab/synapse/__init__.py,sha256=RW8XoAMXOvK7OG1nHl_q8jSEKLj9ZN4oWf2nY9HAwuk,192
 bluecellulab/synapse/synapse_factory.py,sha256=NHwRMYMrnRVm_sHmyKTJ1bdoNmWZNU4UPOGu7FCi-PE,6987
 bluecellulab/synapse/synapse_types.py,sha256=zs_yBvGTH4QrbQF3nEViidyq1WM_ZcTSFdjUxB3khW0,16871
 bluecellulab/validation/validation.py,sha256=D35LE_131CtIzeeePAPz1OFzncGjAcvF02lSIvGvL2E,21331
-bluecellulab-2.6.70.dist-info/licenses/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
-bluecellulab-2.6.70.dist-info/licenses/LICENSE,sha256=dAMAR2Sud4Nead1wGFleKiwTZfkTNZbzmuGfcTKb3kg,11335
-bluecellulab-2.6.70.dist-info/METADATA,sha256=Ug2P_2tjK0W4lmb2m9KkPUTeZscj3XBPBPfcpoIJz68,8359
-bluecellulab-2.6.70.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bluecellulab-2.6.70.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
-bluecellulab-2.6.70.dist-info/RECORD,,
+bluecellulab-2.6.72.dist-info/licenses/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
+bluecellulab-2.6.72.dist-info/licenses/LICENSE,sha256=dAMAR2Sud4Nead1wGFleKiwTZfkTNZbzmuGfcTKb3kg,11335
+bluecellulab-2.6.72.dist-info/METADATA,sha256=wlI-kK0juc84JZFmdgzQLXarBPJ8gWpc2riGNVHZsg8,8359
+bluecellulab-2.6.72.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bluecellulab-2.6.72.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
+bluecellulab-2.6.72.dist-info/RECORD,,