bluecellulab 2.6.71__tar.gz → 2.6.72__tar.gz

{bluecellulab-2.6.71 → bluecellulab-2.6.72}/PKG-INFO

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

{bluecellulab-2.6.71 → bluecellulab-2.6.72}/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)"
                 )
@@ -911,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-2.6.71 → bluecellulab-2.6.72}/bluecellulab/circuit/config/sonata_simulation_config.py

@@ -130,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

{bluecellulab-2.6.71 → bluecellulab-2.6.72}/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-2.6.72/bluecellulab/reports/utils.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."""
+
+from collections import defaultdict
+import logging
+from typing import Dict, Any, List
+
+from bluecellulab.tools import (
+    resolve_source_nodes,
+)
+
+logger = logging.getLogger(__name__)
+
+SUPPORTED_REPORT_TYPES = {"compartment", "compartment_set"}
+
+
+def configure_all_reports(cells, simulation_config):
+    """Configure recordings for all reports defined in the simulation
+    configuration.
+
+    This iterates through all report entries, resolves source nodes or compartments,
+    and configures the corresponding recordings on each cell.
+
+    Parameters
+    ----------
+    cells : dict
+        Mapping from (population, gid) → Cell object.
+
+    simulation_config : Any
+        Simulation configuration object providing report entries,
+        node sets, and compartment sets.
+    """
+    report_entries = simulation_config.get_report_entries()
+
+    for report_name, report_cfg in report_entries.items():
+        report_type = report_cfg.get("type", "compartment")
+        if report_type == "compartment_set":
+            source_sets = simulation_config.get_compartment_sets()
+            source_name = report_cfg.get("compartment_set")
+            if not source_name:
+                logger.warning(
+                    f"Report '{report_name}' does not specify a node set in 'compartment_set' for {report_type}."
+                )
+                continue
+        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 {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"{report_type} '{source_name}' not found for report '{report_name}', skipping recording."
+            )
+            continue
+
+        population = source["population"]
+        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 or recording_sites is None:
+                continue
+
+            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(
+    cells: Dict[Any, Any],
+    location: str = "soma",
+    threshold: float = -20.0,
+) -> Dict[str, Dict[int, list]]:
+    """Extract spike times from recorded cells, grouped by population.
+
+    Parameters
+    ----------
+    cells : dict
+        Mapping from (population, gid) → Cell object, or similar.
+
+    location : str
+        Recording location passed to Cell.get_recorded_spikes().
+
+    threshold : float
+        Voltage threshold (mV) used for spike detection.
+
+    Returns
+    -------
+    spikes_by_population : dict
+        {population → {gid_int → [spike_times_ms]}}
+    """
+    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 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)
+        # Always assign, even if empty
+        spikes_by_pop[pop][gid] = list(times) if times is not None else []
+
+    return dict(spikes_by_pop)

{bluecellulab-2.6.71 → bluecellulab-2.6.72}/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 = [