bluecellulab 2.6.60__py3-none-any.whl → 2.6.62__py3-none-any.whl

bluecellulab/circuit/config/definition.py

@@ -68,6 +68,14 @@ class SimulationConfig(Protocol):
     def spike_location(self) -> str:
         raise NotImplementedError
 
+    @property
+    def tstart(self) -> Optional[float]:
+        raise NotImplementedError
+
+    @property
+    def tstop(self) -> Optional[float]:
+        raise NotImplementedError
+
     @property
     def duration(self) -> Optional[float]:
         raise NotImplementedError

bluecellulab/circuit/config/sonata_simulation_config.py

@@ -17,6 +17,7 @@ import json
 import logging
 from pathlib import Path
 from typing import Optional
+import warnings
 
 from bluecellulab.circuit.config.sections import Conditions, ConnectionOverrides
 from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus
@@ -88,11 +89,23 @@ class SonataSimulationConfig:
 
     @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)
+        circuit_filepath = self.impl.circuit.config.get("node_sets_file")
+        base_node_sets = {}
+        if circuit_filepath:
+            with open(circuit_filepath, "r") as f:
+                base_node_sets = json.load(f)
+
+        sim_filepath = self.impl.config.get("node_sets_file")
+        if sim_filepath:
+            with open(sim_filepath, "r") as f:
+                sim_node_sets = json.load(f)
+            # Overwrite/add entries
+            base_node_sets.update(sim_node_sets)
+
+        if not base_node_sets:
+            raise ValueError("No 'node_sets_file' found in simulation or circuit config.")
+
+        return base_node_sets
 
     @lru_cache(maxsize=1)
     def get_report_entries(self) -> dict[str, dict]:
@@ -148,9 +161,21 @@ class SonataSimulationConfig:
         return self.impl.conditions.spike_location.name
 
     @property
-    def duration(self) -> Optional[float]:
+    def tstart(self) -> Optional[float]:
+        return self.impl.config.get("run", {}).get("tstart", 0.0)
+
+    @property
+    def tstop(self) -> float:
         return self.impl.run.tstop
 
+    @property
+    def duration(self) -> Optional[float]:
+        warnings.warn(
+            "`duration` is deprecated. Use `tstop` instead.",
+            DeprecationWarning
+        )
+        return self.tstop
+
     @property
     def dt(self) -> float:
         return self.impl.run.dt

bluecellulab/circuit/simulation_access.py

@@ -172,16 +172,38 @@ class SonataSimulationAccess:
 
 
 def get_synapse_replay_spikes(f_name: str) -> dict:
-    """Read the .h5 file containing the spike replays."""
+    """Read the .h5 file containing the spike replays.
+
+    Args:
+        f_name: Path to SONATA .h5 spike file.
+
+    Returns:
+        Dictionary mapping node_id to np.array of spike times.
+    """
+    all_spikes = []
     with h5py.File(f_name, 'r') as f:
-        # Access the timestamps and node_ids datasets
-        timestamps = f['/spikes/All/timestamps'][:]
-        node_ids = f['/spikes/All/node_ids'][:]
+        if "spikes" not in f:
+            raise ValueError("spike file is missing required 'spikes' group.")
 
-        spikes = pd.DataFrame(data={'t': timestamps, 'node_id': node_ids})
-        spikes = spikes.astype({"node_id": int})
+        for population in f["spikes"]:
+            pop_group = f["spikes"][population]
+            timestamps = pop_group["timestamps"][:]
+            node_ids = pop_group["node_ids"][:]
+
+            pop_spikes = pd.DataFrame({"t": timestamps, "node_id": node_ids})
+            pop_spikes = pop_spikes.astype({"node_id": int})
+            all_spikes.append(pop_spikes)
+
+    if not all_spikes:
+        return {}
+
+    spikes = pd.concat(all_spikes, ignore_index=True)
 
     if (spikes["t"] < 0).any():
         logger.warning("Found negative spike times... Clipping them to 0")
         spikes["t"].clip(lower=0., inplace=True)
-    return spikes.groupby("node_id")["t"].apply(np.array).to_dict()
+
+    # Group spikes by node_id and ensure spike times are sorted in ascending order.
+    # This is critical because NEURON's VecStim requires monotonically increasing times per train.
+    grouped = spikes.groupby("node_id")["t"]
+    return {k: np.sort(np.asarray(v.values)) for k, v in grouped}

bluecellulab/circuit_simulation.py

@@ -17,12 +17,11 @@ 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
+from bluecellulab.reports.utils import configure_all_reports
 import neuron
 import numpy as np
 import pandas as pd
@@ -47,7 +46,6 @@ 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
@@ -638,15 +636,32 @@ class CircuitSimulation:
                        will not be exactly reproduced.
         """
         if t_stop is None:
-            duration = self.circuit_access.config.duration
-            if duration is None:  # type narrowing
+            t_stop = self.circuit_access.config.tstop
+            if t_stop is None:  # type narrowing
                 t_stop = 0.0
-            else:
-                t_stop = duration
         if dt is None:
             dt = self.circuit_access.config.dt
-        if forward_skip_value is None:
-            forward_skip_value = self.circuit_access.config.forward_skip
+
+        config_forward_skip_value = self.circuit_access.config.forward_skip  # legacy
+        config_tstart = self.circuit_access.config.tstart or 0.0             # SONATA
+        # Determine effective skip value and flag
+        if forward_skip_value is not None:
+            # User explicitly provided value → use it
+            effective_skip_value = forward_skip_value
+            effective_skip = forward_skip
+        elif config_forward_skip_value is not None:
+            # Use legacy config if available
+            effective_skip_value = config_forward_skip_value
+            effective_skip = forward_skip
+        elif config_tstart > 0.0:
+            # Use SONATA tstart *only* if no other skip value was provided
+            effective_skip_value = config_tstart
+            effective_skip = True
+        else:
+            # No skip
+            effective_skip_value = None
+            effective_skip = False
+
         if celsius is None:
             celsius = self.circuit_access.config.celsius
         NeuronGlobals.get_instance().temperature = celsius
@@ -664,15 +679,13 @@ class CircuitSimulation:
                            "simulations")
 
         sim.run(
-            t_stop,
+            tstop=t_stop,
             cvode=cvode,
             dt=dt,
-            forward_skip=forward_skip,
-            forward_skip_value=forward_skip_value,
+            forward_skip=effective_skip,
+            forward_skip_value=effective_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:
@@ -713,23 +726,31 @@ class CircuitSimulation:
         first_key = next(iter(self.cells))
         return self.cells[first_key].get_time()
 
-    def get_time_trace(self, t_step=None) -> np.ndarray:
+    def get_time_trace(self, t_start=None, t_stop=None, t_step=None) -> np.ndarray:
         """Get the time vector for the recordings, negative times removed.
 
         Parameters
         -----------
-        t_step: time step (should be a multiple of report time step T;
-        equals T by default)
+        t_start, t_stop: time range of interest.
+        t_step: time step (multiple of report dt; equals dt by default)
 
         Returns:
-            One dimentional np.ndarray to represent the times.
+            1D np.ndarray representing time points.
         """
         time = self.get_time()
-        time = time[np.where(time >= 0.0)]
+        time = time[time >= 0.0]
+
+        if t_start is None or t_start < 0:
+            t_start = 0
+        if t_stop is None:
+            t_stop = np.inf
+
+        time = time[(time >= t_start) & (time <= t_stop)]
 
         if t_step is not None:
             ratio = t_step / self.dt
             time = _sample_array(time, ratio)
+
         return time
 
     def get_voltage_trace(
@@ -806,78 +827,3 @@ 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",
-                    sim_dt=self.dt,
-                )
-
-            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",
-                    sim_dt=self.dt,
-                )
-
-        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=self.spike_location, 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/reports/manager.py

@@ -0,0 +1,78 @@
+# 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.
+
+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
+
+
+class ReportManager:
+    """Orchestrates writing all requested SONATA reports."""
+
+    def __init__(self, config, sim_dt: float):
+        self.cfg = config
+        self.dt = sim_dt
+
+    def write_all(
+        self,
+        cells_or_traces: Dict,
+        spikes_by_pop: Optional[Dict[str, Dict[int, list]]] = None,
+    ):
+        """Write all configured reports (compartment and spike) in SONATA
+        format.
+
+        Parameters
+        ----------
+        cells_or_traces : dict
+            A dictionary mapping (population, gid) to either:
+            - Cell objects with recorded data (used in single-process simulations), or
+            - Precomputed trace dictionaries, e.g., {"voltage": ndarray}, typically gathered across ranks in parallel runs.
+
+        spikes_by_pop : dict, optional
+            A precomputed dictionary of spike times by population.
+            If not provided, spike times are extracted from `cells_or_traces`.
+
+        Notes
+        -----
+        In parallel simulations, you must gather all traces and spikes to rank 0 and pass them here.
+        """
+        self._write_voltage_reports(cells_or_traces)
+        self._write_spike_report(spikes_by_pop or extract_spikes_from_cells(cells_or_traces, location=self.cfg.spike_location, threshold=self.cfg.spike_threshold))
+
+    def _write_voltage_reports(self, cells_or_traces):
+        for name, rcfg in self.cfg.get_report_entries().items():
+            if rcfg.get("type") != "compartment":
+                continue
+
+            section = rcfg.get("sections")
+            if section == "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("invalid 'compartments' value")
+                src_sets, src_type = self.cfg.get_node_sets(), "node_set"
+
+            rcfg["_source_sets"] = src_sets
+            rcfg["_source_type"] = src_type
+
+            out_path = self.cfg.report_file_path(rcfg, name)
+            writer = get_writer("compartment")(rcfg, out_path, self.dt)
+            writer.write(cells_or_traces, self.cfg.tstart)
+
+    def _write_spike_report(self, spikes_by_pop):
+        out_path = self.cfg.spikes_file_path
+        writer = get_writer("spikes")({}, out_path, self.dt)
+        writer.write(spikes_by_pop)

bluecellulab/reports/utils.py

@@ -0,0 +1,156 @@
+# 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_segments, 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}"
+            )
+
+
+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")
+        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 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():
+        if isinstance(key, tuple):
+            pop, gid = key
+        else:
+            raise ValueError(f"Cell key {key} is not a (population, gid) tuple.")
+
+        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)
+
+    return dict(spikes_by_pop)

bluecellulab/reports/writers/__init__.py

@@ -0,0 +1,25 @@
+# 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.
+
+from .compartment import CompartmentReportWriter
+from .spikes import SpikeReportWriter
+
+REGISTRY = {
+    "compartment": CompartmentReportWriter,
+    "spikes": SpikeReportWriter,
+}
+
+
+def get_writer(report_type):
+    return REGISTRY[report_type]

bluecellulab/reports/writers/base_writer.py

@@ -0,0 +1,30 @@
+# 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.
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Dict, Any
+
+
+class BaseReportWriter(ABC):
+    """Abstract interface for every report writer."""
+
+    def __init__(self, report_cfg: Dict[str, Any], output_path: Path, sim_dt: float):
+        self.cfg = report_cfg
+        self.output_path = Path(output_path)
+        self.sim_dt = sim_dt
+
+    @abstractmethod
+    def write(self, data: Dict):
+        """Write one report to disk."""

bluecellulab/reports/writers/compartment.py

@@ -0,0 +1,196 @@
+# 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.
+
+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 (
+    resolve_source_nodes,
+    resolve_segments,
+)
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class CompartmentReportWriter(BaseReportWriter):
+    """Writes SONATA compartment (voltage) reports."""
+
+    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")
+
+        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")
+        src = source_sets.get(src_name)
+        if not src:
+            logger.warning(f"{source_type.title()} '{src_name}' not found – skipping '{report_name}'.")
+            return
+
+        population = src["population"]
+        node_ids, comp_nodes = resolve_source_nodes(src, source_type, cells, population)
+
+        data_matrix: List[np.ndarray] = []
+        node_id_list: List[int] = []
+        idx_ptr: List[int] = [0]
+        elem_ids: List[int] = []
+
+        for nid in node_ids:
+            cell = cells.get((population, nid)) or cells.get(f"{population}_{nid}")
+            if cell is None:
+                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)
+                    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}'.")
+            return
+
+        self._write_sonata_report_file(
+            self.output_path,
+            population,
+            data_matrix,
+            node_id_list,
+            idx_ptr,
+            elem_ids,
+            self.cfg,
+            self.sim_dt,
+            tstart
+        )
+
+    def _write_sonata_report_file(
+        self,
+        output_path,
+        population,
+        data_matrix,
+        recorded_node_ids,
+        index_pointers,
+        element_ids,
+        report_cfg,
+        sim_dt,
+        tstart
+    ):
+        """Write a SONATA HDF5 report file containing time series data.
+
+        This function downsamples the data if needed, prepares metadata arrays,
+        and writes the report in SONATA format to the specified HDF5 file.
+
+        Parameters
+        ----------
+        output_path : str or Path
+            Destination path of the report file.
+
+        population : str
+            Name of the population being recorded.
+
+        data_matrix : list of ndarray
+            List of arrays containing recorded time series per element.
+
+        recorded_node_ids : list of int
+            Node IDs corresponding to the recorded traces.
+
+        index_pointers : list of int
+            Index pointers mapping node IDs to data.
+
+        element_ids : list of int
+            Element IDs (e.g., segment IDs) corresponding to each trace.
+
+        report_cfg : dict
+            Report configuration specifying time window and variable name.
+
+        sim_dt : float
+            Simulation timestep (ms).
+
+        tstart : float
+            Simulation start time (ms).
+        """
+        start_time = float(report_cfg.get("start_time", 0.0))
+        end_time = float(report_cfg.get("end_time", 0.0))
+        dt_report = float(report_cfg.get("dt", sim_dt))
+
+        # Clamp dt_report if finer than simuldation dt
+        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."
+            )
+            dt_report = sim_dt
+
+        step = int(round(dt_report / sim_dt))
+        if not np.isclose(step * sim_dt, dt_report, atol=1e-9):
+            raise ValueError(
+                f"dt_report={dt_report} is not an integer multiple of dt_data={sim_dt}"
+            )
+
+        # 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
+
+        # Now slice and downsample
+        data_matrix_downsampled = [
+            trace[start_index:end_index:step] for trace in data_matrix
+        ]
+        data_array = np.stack(data_matrix_downsampled, axis=1).astype(np.float32)
+
+        # Prepare metadata arrays
+        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([start_time, end_time, dt_report], dtype=np.float64)
+
+        # Ensure output directory exists
+        output_path = Path(output_path)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write to HDF5
+        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"

bluecellulab/reports/writers/spikes.py

@@ -0,0 +1,61 @@
+# 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.
+
+from typing import Dict, List
+from bluecellulab.reports.writers.base_writer import BaseReportWriter
+import logging
+import numpy as np
+import h5py
+
+logger = logging.getLogger(__name__)
+
+
+class SpikeReportWriter(BaseReportWriter):
+    """Writes SONATA spike report from pop→gid→times mapping."""
+
+    def write(self, spikes_by_pop: Dict[str, Dict[int, list]]):
+        if self.output_path.exists():
+            self.output_path.unlink()
+
+        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)
+
+            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]
+
+            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}.")
+                    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)
+
+                timestamps_ds.attrs["units"] = "ms"  # SONATA-required

bluecellulab/simulation/report.py

@@ -1,264 +0,0 @@
-# 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,
-    sim_dt: float
-):
-    """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".
-        sim_dt (float): Simulation time step used for the recorded data.
-
-    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, sim_dt
-    )
-
-
-def write_sonata_report_file(
-    output_path,
-    population,
-    data_matrix,
-    recorded_node_ids,
-    index_pointers,
-    element_ids,
-    report_cfg,
-    sim_dt
-):
-    start_time = float(report_cfg.get("start_time", 0.0))
-    end_time = float(report_cfg.get("end_time", 0.0))
-    dt_report = float(report_cfg.get("dt", sim_dt))
-
-    # Clamp dt_report if finer than simuldation dt
-    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."
-        )
-        dt_report = sim_dt
-
-    step = int(round(dt_report / sim_dt))
-    if not np.isclose(step * sim_dt, dt_report, atol=1e-9):
-        raise ValueError(
-            f"dt_report={dt_report} is not an integer multiple of dt_data={sim_dt}"
-        )
-
-    # Downsample the data if needed
-    # Compute start and end indices in the original data
-    start_index = int(round(start_time / sim_dt))
-    end_index = int(round(end_time / sim_dt)) + 1  # inclusive
-
-    # Now slice and downsample
-    data_matrix_downsampled = [
-        trace[start_index:end_index:step] for trace in data_matrix
-    ]
-    data_array = np.stack(data_matrix_downsampled, axis=1).astype(np.float32)
-
-    # Prepare metadata arrays
-    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([start_time, end_time, dt_report], dtype=np.float64)
-
-    # Ensure output directory exists
-    output_path = Path(output_path)
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-
-    # Write to HDF5
-    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/simulation/simulation.py

@@ -88,7 +88,7 @@ class Simulation:
 
     def run(
             self,
-            maxtime: float,
+            tstop: float,
             cvode=True,
             cvode_minstep=None,
             cvode_maxstep=None,
@@ -107,10 +107,10 @@ class Simulation:
             show_progress = bluecellulab.VERBOSE_LEVEL > 1
 
         if show_progress:
-            self.progress_dt = maxtime / 100
+            self.progress_dt = tstop / 100
             self.init_progress_callback()
 
-        neuron.h.tstop = maxtime
+        neuron.h.tstop = tstop
 
         cvode_old_status = neuron.h.cvode_active()
         if cvode:
@@ -138,10 +138,9 @@ class Simulation:
         # initialized heavily influence the random number generator
         # e.g. finitialize() + step() != run()
 
-        logger.debug(f'Running a simulation until {maxtime} ms ...')
-
         self.init_callbacks()
 
+        logger.debug(f'Running a simulation until {tstop} ms ...')
         neuron.h.stdinit()
 
         if forward_skip:
@@ -152,7 +151,7 @@ class Simulation:
                 for _ in range(0, 10):
                     neuron.h.fadvance()
                 neuron.h.dt = save_dt
-                neuron.h.t = 0.0
+                neuron.h.t = forward_skip_value
 
         if self.pc is not None:
             for cell in self.cells:

bluecellulab/stimulus/circuit_stimulus_definitions.py

@@ -243,7 +243,7 @@ class Stimulus:
                 delay=stimulus_entry["delay"],
                 duration=stimulus_entry["duration"],
                 amp_start=stimulus_entry["amp_start"],
-                amp_end=stimulus_entry["amp_end"],
+                amp_end=stimulus_entry.get("amp_end", stimulus_entry["amp_start"]),
             )
         elif pattern == Pattern.RELATIVE_LINEAR:
             return RelativeLinear(
@@ -251,7 +251,7 @@ class Stimulus:
                 delay=stimulus_entry["delay"],
                 duration=stimulus_entry["duration"],
                 percent_start=stimulus_entry["percent_start"],
-                percent_end=stimulus_entry["percent_end"],
+                percent_end=stimulus_entry.get("percent_end", stimulus_entry["percent_start"]),
             )
         elif pattern == Pattern.SYNAPSE_REPLAY:
             return SynapseReplay(
@@ -285,7 +285,7 @@ class Stimulus:
                 decay_time=stimulus_entry["decay_time"],
                 mean_percent=stimulus_entry["mean_percent"],
                 sd_percent=stimulus_entry["sd_percent"],
-                relative_skew=stimulus_entry.get("RelativeSkew", 0.5),
+                relative_skew=stimulus_entry.get("relative_skew", 0.5),
                 seed=stimulus_entry.get("random_seed", None),
                 mode=ClampMode(stimulus_entry.get("input_type", "current_clamp").lower()),
                 reversal=stimulus_entry.get("reversal", 0.0)

{bluecellulab-2.6.60.dist-info → bluecellulab-2.6.62.dist-info}/METADATA

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

{bluecellulab-2.6.60.dist-info → bluecellulab-2.6.62.dist-info}/RECORD

@@ -1,5 +1,5 @@
 bluecellulab/__init__.py,sha256=1d_CKIJLIpon7o13h3lBnV_-33obZEPwa9KDTjlFPD8,880
-bluecellulab/circuit_simulation.py,sha256=N_kMjWykpt_UouvwCp-7g0o0NMd_1jB4IHxWplEvEME,39294
+bluecellulab/circuit_simulation.py,sha256=CryoBSUGc9z6nIAyNzCsyppeSlc_URJX6hZoZPgQI2Q,36807
 bluecellulab/connection.py,sha256=-xT0mU7ppeHI_qjCKj17TtxXVVcUDgBsaMKt9ODmcEU,4640
 bluecellulab/dendrogram.py,sha256=FjS6RZ6xcp5zJoY5d5qv_edqPM13tL2-UANgbZuDBjY,6427
 bluecellulab/exceptions.py,sha256=1lKD92VIyD8cUggAI1SLxeKzj_09Ik_TlHCzPLCvDHg,2379
@@ -38,7 +38,7 @@ bluecellulab/circuit/__init__.py,sha256=Khpa13nzNvDlDS2JduyoFTukEduEkWCc5ML_JwGp
 bluecellulab/circuit/format.py,sha256=90gWOXg6HK0R9a4WFSnnRH8XezxmzOGk5dRpJHbvbbU,1674
 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/simulation_access.py,sha256=8LX5nbKw_Hu7AR3pGLdTFGwehvhaj-r8Mh1q3dVoiVg,7745
 bluecellulab/circuit/synapse_properties.py,sha256=TvUMiXZAAeYo1zKkus3z1EUvrE9QCIQ3Ze-jSnPSJWY,6374
 bluecellulab/circuit/validate.py,sha256=wntnr7oIDyasqD1nM-kqz1NpfWDxBGhx0Ep3e5hHXIw,3593
 bluecellulab/circuit/circuit_access/__init__.py,sha256=sgp6m5kP-pq60V1IFGUiSUR1OW01zdxXNNUJmPA8anI,201
@@ -47,30 +47,37 @@ bluecellulab/circuit/circuit_access/definition.py,sha256=_sUU0DkesGOFW82kS1G9vki
 bluecellulab/circuit/circuit_access/sonata_circuit_access.py,sha256=tADHxVZw4VgZAz2z4NKMUwc0rd_EO40EZggw5fDhnF4,10411
 bluecellulab/circuit/config/__init__.py,sha256=aaoJXRKBJzpxxREo9NxKc-_CCPmVeuR1mcViRXcLrC4,215
 bluecellulab/circuit/config/bluepy_simulation_config.py,sha256=V3eqOzskX7VrMDpl-nMQVEhDg8QWgRmRduyJBii5sgI,6974
-bluecellulab/circuit/config/definition.py,sha256=I1jd4KUX21mw03FEv1aYNsT0UFbDANY3YEPwwKXqe4k,2774
+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=eRI5x1AEg0NetTsuUZhWiHNhW8zIPYul-QqX_clHQLg,6533
+bluecellulab/circuit/config/sonata_simulation_config.py,sha256=J1DFqNxIJKAxD1KU_oJV9tigMdpT_Not0Q8SF5q2EeQ,7271
 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/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/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=i_VjwIkDnHHAUk4Tx2F5LhaeBVBctcOzchK_8nG6NFw,10474
-bluecellulab/simulation/simulation.py,sha256=VhftOMYU1Rfrphvud6f0U4kvbUivSviQ5TlVljuTb88,6486
+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=dTpwfRxH4c4yJDYyKrO6X-2Nqdy-QT3GxGQjfsRhNVY,17158
+bluecellulab/stimulus/circuit_stimulus_definitions.py,sha256=h_SqjJ-L3yNxiEO8I6Cy7i-lhfZXjrdCc92dl8bjOog,17229
 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=vLaOAyCO1qwwQ5Ud9X9NDX3iSsh_2S5tUA9xRmoDHiA,18465
-bluecellulab-2.6.60.dist-info/licenses/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
-bluecellulab-2.6.60.dist-info/licenses/LICENSE,sha256=dAMAR2Sud4Nead1wGFleKiwTZfkTNZbzmuGfcTKb3kg,11335
-bluecellulab-2.6.60.dist-info/METADATA,sha256=kLm4ryHnVcbAotV6m-03Mp3ZCxRQrPtA5j2Ot0YvE6Y,8259
-bluecellulab-2.6.60.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bluecellulab-2.6.60.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
-bluecellulab-2.6.60.dist-info/RECORD,,
+bluecellulab-2.6.62.dist-info/licenses/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
+bluecellulab-2.6.62.dist-info/licenses/LICENSE,sha256=dAMAR2Sud4Nead1wGFleKiwTZfkTNZbzmuGfcTKb3kg,11335
+bluecellulab-2.6.62.dist-info/METADATA,sha256=08Q8N5dafN3_qazVN4W0H7Lbg8unaGFAywz-HBFh8FU,8259
+bluecellulab-2.6.62.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bluecellulab-2.6.62.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
+bluecellulab-2.6.62.dist-info/RECORD,,