bluecellulab 2.6.51__py3-none-any.whl → 2.6.53__py3-none-any.whl

bluecellulab/analysis/analysis.py

@@ -248,7 +248,7 @@ class BPAP:
         self.cell = cell
         self.dt = 0.025
         self.stim_start = 1000
-        self.stim_duration = 3
+        self.stim_duration = 5
         self.basal_cmap = sns.color_palette("crest", as_cmap=True)
         self.apical_cmap = sns.color_palette("YlOrBr_r", as_cmap=True)
 
@@ -301,7 +301,11 @@ class BPAP:
             for rec in recs.values()
         ]
         features_results = efel.get_feature_values(traces, [efel_feature_name])
-        amps = [feat_res[efel_feature_name][0] for feat_res in features_results]
+        amps = [
+            feat_res[efel_feature_name][0]
+            for feat_res in features_results
+            if feat_res[efel_feature_name] is not None
+        ]
 
         return amps
 
@@ -320,7 +324,7 @@ class BPAP:
 
     def get_amplitudes_and_distances(self):
         soma_rec, dend_rec, apic_rec = self.get_recordings()
-        soma_amp = self.amplitudes({"soma": soma_rec})[0]
+        soma_amp = self.amplitudes({"soma": soma_rec})
         dend_amps = None
         dend_dist = None
         apic_amps = None
@@ -334,20 +338,21 @@ class BPAP:
 
         return soma_amp, dend_amps, dend_dist, apic_amps, apic_dist
 
-    def fit(self, soma_amp, dend_amps, dend_dist, apic_amps, apic_dist):
+    @staticmethod
+    def fit(soma_amp, dend_amps, dend_dist, apic_amps, apic_dist):
         """Fit the amplitudes vs distances to an exponential decay function."""
         from scipy.optimize import curve_fit
 
         popt_dend = None
         if dend_amps and dend_dist:
             dist = [0] + dend_dist  # add soma distance
-            amps = [soma_amp] + dend_amps  # add soma amplitude
+            amps = soma_amp + dend_amps  # add soma amplitude
             popt_dend, _ = curve_fit(exp_decay, dist, amps)
 
         popt_apic = None
         if apic_amps and apic_dist:
             dist = [0] + apic_dist  # add soma distance
-            amps = [soma_amp] + apic_amps  # add soma amplitude
+            amps = soma_amp + apic_amps  # add soma amplitude
             popt_apic, _ = curve_fit(exp_decay, dist, amps)
 
         return popt_dend, popt_apic
@@ -357,10 +362,18 @@ class BPAP:
         validated = True
         notes = ""
         popt_dend, popt_apic = self.fit(soma_amp, dend_amps, dend_dist, apic_amps, apic_dist)
+        logging.warning(popt_dend)
+        if dend_amps is not None:
+            plt.cla()
+            plt.plot([0], soma_amp, '.')
+            plt.plot(dend_dist, dend_amps, '.')
+            x = np.linspace(0, max(dend_dist), 100)
+            plt.plot(x, exp_decay(x, *popt_dend), color='darkgreen', linestyle='--', label='Basal Dendritic Fit')
+            plt.savefig("bad_dendritic_fit.png")
         if popt_dend is None:
             logger.debug("No dendritic recordings found.")
             notes += "No dendritic recordings found.\n"
-        elif popt_dend[1] <= 0:
+        elif popt_dend[1] <= 0 or popt_dend[0] <= 0:
             logger.debug("Dendritic fit is not decaying.")
             validated = False
             notes += "Dendritic fit is not decaying.\n"
@@ -369,7 +382,7 @@ class BPAP:
         if popt_apic is None:
             logger.debug("No apical recordings found.")
             notes += "No apical recordings found.\n"
-        elif popt_apic[1] <= 0:
+        elif popt_apic[1] <= 0 or popt_apic[0] <= 0:
             logger.debug("Apical fit is not decaying.")
             validated = False
             notes += "Apical fit is not decaying.\n"
@@ -395,7 +408,7 @@ class BPAP:
 
         outpath = pathlib.Path(output_dir) / output_fname
         fig, ax1 = plt.subplots(figsize=(10, 6))
-        ax1.scatter([0], [soma_amp], marker="^", color='black', label='Soma')
+        ax1.scatter([0], soma_amp, marker="^", color='black', label='Soma')
         if dend_amps and dend_dist:
             ax1.scatter(
                 dend_dist,

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/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/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/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/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

bluecellulab/tools.py

@@ -394,14 +394,14 @@ def check_empty_topology() -> bool:
 
 
 def calculate_max_thresh_current(cell: Cell,
-                                 threshold_voltage: float = -30.0,
+                                 threshold_voltage: float = -20.0,
                                  section: str = "soma[0]",
                                  segx: float = 0.5) -> float:
     """Calculate the upper bound threshold current.
 
     Args:
         cell (bluecellulab.cell.Cell): The initialized cell model.
-        threshold_voltage (float, optional): Voltage threshold for spike detection. Default is -30.0 mV.
+        threshold_voltage (float, optional): Voltage threshold for spike detection. Default is -20.0 mV.
         section (str, optional): The section where current is injected.
         segx (float, optional): Fractional location within the section for current injection.
 
@@ -508,19 +508,85 @@ def validate_section_and_segment(cell: Cell, section_name: str, segment_position
 
 
 def get_section(cell: Cell, section_name: str) -> NeuronSection:
-    """Retrieve a NEURON section from the cell by its name.
+    """Return a single, fully specified NEURON section (e.g., 'soma[0]',
+    'dend[3]').
 
-    Args:
-        cell (Cell): The cell object containing the sections.
-        section_name (str): The name of the section to retrieve.
+    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}]")
 
-    Returns:
-        NeuronSection: The NEURON section corresponding to the provided name.
+
+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: If the section with the specified name does not exist.
+        ValueError or TypeError if no valid sections are found.
     """
+    # Try to interpret as fully qualified section name
     try:
-        return cell.sections[section_name]
-    except KeyError:
-        raise ValueError(f"Section '{section_name}' not found in the cell.")
+        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":
+        compartment_nodes = source.get("compartment_set", [])
+        node_ids = [entry[0] for entry in compartment_nodes]
+    else:  # node_set
+        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
+    return node_ids, compartment_nodes

{bluecellulab-2.6.51.dist-info → bluecellulab-2.6.53.dist-info}/METADATA

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

{bluecellulab-2.6.51.dist-info → bluecellulab-2.6.53.dist-info}/RECORD

@@ -1,5 +1,5 @@
 bluecellulab/__init__.py,sha256=1d_CKIJLIpon7o13h3lBnV_-33obZEPwa9KDTjlFPD8,880
-bluecellulab/circuit_simulation.py,sha256=dXaYblCWWMX2I7HhlL0chTyelePj-6Io2NNdGK5oB-o,35020
+bluecellulab/circuit_simulation.py,sha256=zF72yNZnnGUN40Vp66VFvr2Rz4tVuD3iWtvao23GoHQ,39270
 bluecellulab/connection.py,sha256=-xT0mU7ppeHI_qjCKj17TtxXVVcUDgBsaMKt9ODmcEU,4640
 bluecellulab/dendrogram.py,sha256=FjS6RZ6xcp5zJoY5d5qv_edqPM13tL2-UANgbZuDBjY,6427
 bluecellulab/exceptions.py,sha256=1lKD92VIyD8cUggAI1SLxeKzj_09Ik_TlHCzPLCvDHg,2379
@@ -10,18 +10,18 @@ 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=hF1HJcera0oggetsfN5PNTRYCpFS0sQiZlVxw4jRd1g,17968
+bluecellulab/tools.py,sha256=Cc-Pv_7ban1EA9aqj8mfnjq-187llqj5WVzuQdesqhc,20395
 bluecellulab/type_aliases.py,sha256=DvgjERv2Ztdw_sW63JrZTQGpJ0x5uMTFB5hcBHDb0WA,441
 bluecellulab/utils.py,sha256=0NhwlzyLnSi8kziSfDsQf7pokO4qDkMJVAO33kSX4O0,2227
 bluecellulab/verbosity.py,sha256=T0IgX7DrRo19faxrT4Xzb27gqxzoILQ8FzYKxvUeaPM,1342
 bluecellulab/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bluecellulab/analysis/analysis.py,sha256=53g6SW_9ZbG3fbhuXJqurAPRR4VG1jsZYK6efq-EwfA,21229
+bluecellulab/analysis/analysis.py,sha256=OCx6_7jX1yPRAGNhOyu4y6HRuCbKJFG-NLDAqLl2qFQ,21758
 bluecellulab/analysis/inject_sequence.py,sha256=uU6Q6y0ErMDDEgdsTZBXCJ4LgwkATY7G8Fa6mmjpL98,12523
 bluecellulab/analysis/plotting.py,sha256=PqRoaZz33ULMw8A9YnZXXrxcUd84M_dwlYMTFhG7YT4,3999
 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=BualY0WOtC0arKmvKzQ3sQ0fhc2jrtd6wqSd9M-e25E,33797
+bluecellulab/cell/core.py,sha256=2dRx5ueElOJthhmnrijbBb9rH9xlJRp_hyZ73YHLGas,34478
 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
@@ -36,7 +36,7 @@ bluecellulab/cell/ballstick/emodel.hoc,sha256=7WcuepK-wB9bASRvNdCwO9Woc9-SpBCFqB
 bluecellulab/cell/ballstick/morphology.asc,sha256=EO0VIRilJAwpiDP2hIevwusfvYptNYhvsu1f5GgbSQo,190
 bluecellulab/circuit/__init__.py,sha256=Khpa13nzNvDlDS2JduyoFTukEduEkWCc5ML_JwGpmZs,361
 bluecellulab/circuit/format.py,sha256=90gWOXg6HK0R9a4WFSnnRH8XezxmzOGk5dRpJHbvbbU,1674
-bluecellulab/circuit/iotools.py,sha256=h3nlPp1b30VVjkxg6hIfZibdXODxpFXXD1guR2fa0rg,1585
+bluecellulab/circuit/iotools.py,sha256=Q65xYDaiensMtrulC3OLsS2_hcWr_Kje0nXFrAizMMo,1589
 bluecellulab/circuit/node_id.py,sha256=FdoFAGq0_sCyQySOuNI0chdbVr3L8R0w2Y1em5MyIDA,1265
 bluecellulab/circuit/simulation_access.py,sha256=keME58gzLVAPEg2nnWD_bwEm9V2Kjeqyfoj_55GPMCM,7061
 bluecellulab/circuit/synapse_properties.py,sha256=TvUMiXZAAeYo1zKkus3z1EUvrE9QCIQ3Ze-jSnPSJWY,6374
@@ -49,7 +49,7 @@ 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=I1jd4KUX21mw03FEv1aYNsT0UFbDANY3YEPwwKXqe4k,2774
 bluecellulab/circuit/config/sections.py,sha256=QRnU44-OFvHxcF1LX4bAEP9dk3I6UKsuPNBbWkdfmRE,7151
-bluecellulab/circuit/config/sonata_simulation_config.py,sha256=7yEvuourzN2nRjzsA5CcDF8pcjEyjSJHitp3OH-ijgk,4829
+bluecellulab/circuit/config/sonata_simulation_config.py,sha256=Rg1qEyGIh5s6kusE-9Z1r3LwZ4bxtF7aYr0-UeTOD6k,6536
 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
@@ -58,6 +58,7 @@ bluecellulab/hoc/fileUtils.hoc,sha256=LSM7BgyjYVqo2DGSOKvg4W8IIusbsL45JVYK0vgwit
 bluecellulab/simulation/__init__.py,sha256=P2ebt0SFw-08J3ihN-LeRn95HeF79tzA-Q0ReLm32dM,214
 bluecellulab/simulation/neuron_globals.py,sha256=iBjhg0-1YMP5LsVdtUDt24PEypkCL6mlyzEBZqoS8xo,4508
 bluecellulab/simulation/parallel.py,sha256=oQ_oV2EKr8gP4yF2Dq8q9MiblDyi89_wBgLzQkLV_U0,1514
+bluecellulab/simulation/report.py,sha256=KA8Swdxy-52AIQFMUNHq4suIZhLxesOL32ZudeM-QBg,9298
 bluecellulab/simulation/simulation.py,sha256=VhftOMYU1Rfrphvud6f0U4kvbUivSviQ5TlVljuTb88,6486
 bluecellulab/stimulus/__init__.py,sha256=DgIgVaSyR-URf3JZzvO6j-tjCerzvktuK-ep8pjMRPQ,37
 bluecellulab/stimulus/circuit_stimulus_definitions.py,sha256=dTpwfRxH4c4yJDYyKrO6X-2Nqdy-QT3GxGQjfsRhNVY,17158
@@ -67,9 +68,9 @@ bluecellulab/synapse/__init__.py,sha256=RW8XoAMXOvK7OG1nHl_q8jSEKLj9ZN4oWf2nY9HA
 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=EN9HMty70VPwnEPhWUmN5F-MGWbMN3uU0DmNnjL0ucw,18209
-bluecellulab-2.6.51.dist-info/licenses/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
-bluecellulab-2.6.51.dist-info/licenses/LICENSE,sha256=dAMAR2Sud4Nead1wGFleKiwTZfkTNZbzmuGfcTKb3kg,11335
-bluecellulab-2.6.51.dist-info/METADATA,sha256=uWxsjFCkKomqMrGyVsZuhcUdDHi32Swj5sASJ4faKJE,8259
-bluecellulab-2.6.51.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bluecellulab-2.6.51.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
-bluecellulab-2.6.51.dist-info/RECORD,,
+bluecellulab-2.6.53.dist-info/licenses/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
+bluecellulab-2.6.53.dist-info/licenses/LICENSE,sha256=dAMAR2Sud4Nead1wGFleKiwTZfkTNZbzmuGfcTKb3kg,11335
+bluecellulab-2.6.53.dist-info/METADATA,sha256=7O-2OmI89TVrP7DYO10sMKqBwCDz53pvdPnuDqQ965o,8259
+bluecellulab-2.6.53.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bluecellulab-2.6.53.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
+bluecellulab-2.6.53.dist-info/RECORD,,