bluecellulab 2.6.51__tar.gz → 2.6.52__tar.gz

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

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

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

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

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

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

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

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

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

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

bluecellulab-2.6.52/bluecellulab/simulation/report.py

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

{bluecellulab-2.6.51 → bluecellulab-2.6.52}/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 → bluecellulab-2.6.52}/bluecellulab.egg-info/PKG-INFO

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

{bluecellulab-2.6.51 → bluecellulab-2.6.52}/bluecellulab.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ bluecellulab/hoc/fileUtils.hoc
 bluecellulab/simulation/__init__.py
 bluecellulab/simulation/neuron_globals.py
 bluecellulab/simulation/parallel.py
+bluecellulab/simulation/report.py
 bluecellulab/simulation/simulation.py
 bluecellulab/stimulus/__init__.py
 bluecellulab/stimulus/circuit_stimulus_definitions.py