bluecellulab 2.6.53__tar.gz → 2.6.55__tar.gz

{bluecellulab-2.6.53 → bluecellulab-2.6.55}/PKG-INFO

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

{bluecellulab-2.6.53 → bluecellulab-2.6.55}/bluecellulab/analysis/analysis.py

@@ -4,11 +4,9 @@ try:
 except ImportError:
     efel = None
 from itertools import islice
-from itertools import repeat
 import logging
 from matplotlib.collections import LineCollection
 import matplotlib.pyplot as plt
-from multiprocessing import Pool
 import neuron
 import numpy as np
 import pathlib
@@ -97,20 +95,15 @@ def compute_plot_iv_curve(cell,
         for amp in list_amp
     ]
 
-    with Pool(len(steps)) as p:
-        recordings = p.starmap(
-            run_stimulus,
-            zip(
-                repeat(cell.template_params),
-                steps,
-                repeat(injecting_section),
-                repeat(injecting_segment),
-                repeat(True),  # cvode
-                repeat(True),  # add_hypamp
-                repeat(recording_section),
-                repeat(recording_segment),
-            )
-        )
+    recordings = []
+    for step in steps:
+        recording = run_stimulus(cell.template_params,
+                                 step,
+                                 section=injecting_section,
+                                 segment=injecting_segment,
+                                 recording_section=recording_section,
+                                 recording_segment=recording_segment)
+        recordings.append(recording)
 
     steady_states = []
     # compute steady state response
@@ -208,24 +201,19 @@ def compute_plot_fi_curve(cell,
         for amp in list_amp
     ]
 
-    with Pool(len(steps)) as p:
-        recordings = p.starmap(
-            run_stimulus,
-            zip(
-                repeat(cell.template_params),
-                steps,
-                repeat(injecting_section),
-                repeat(injecting_segment),
-                repeat(True),  # cvode
-                repeat(True),  # add_hypamp
-                repeat(recording_section),
-                repeat(recording_segment),
-                repeat(True),  # enable_spike_detection
-                repeat(threshold_voltage),  # threshold_spike_detection
-            )
-        )
-
-    spike_count = [len(recording.spike) for recording in recordings]
+    spikes = []
+    for step in steps:
+        recording = run_stimulus(cell.template_params,
+                                 step,
+                                 section=injecting_section,
+                                 segment=injecting_segment,
+                                 recording_section=recording_section,
+                                 recording_segment=recording_segment,
+                                 enable_spike_detection=True,
+                                 threshold_spike_detection=threshold_voltage)
+        spikes.append(recording.spike)
+
+    spike_count = [len(spike) for spike in spikes]
 
     plot_fi_curve(list_amp,
                   spike_count,

{bluecellulab-2.6.53 → bluecellulab-2.6.55}/bluecellulab/circuit/config/sonata_simulation_config.py

@@ -177,7 +177,7 @@ class SonataSimulationConfig:
     @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")
+        spikes_file = self.impl.config.get("output", {}).get("spikes_file", "out.h5")
         return output_dir / spikes_file
 
     @property

{bluecellulab-2.6.53 → bluecellulab-2.6.55}/bluecellulab/circuit_simulation.py

@@ -311,8 +311,8 @@ class CircuitSimulation:
 
         # 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)
+            if not cell.is_recording_spikes(self.spike_location, threshold=self.spike_threshold):
+                cell.start_recording_spikes(None, location=self.spike_location, threshold=self.spike_threshold)
 
     def _add_stimuli(self, add_noise_stimuli=False,
                      add_hyperpolarizing_stimuli=False,
@@ -474,7 +474,6 @@ class CircuitSimulation:
         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])
@@ -832,7 +831,8 @@ class CircuitSimulation:
                     cells=self.cells,
                     report_cfg=report_cfg,
                     source_sets=compartment_sets,
-                    source_type="compartment_set"
+                    source_type="compartment_set",
+                    sim_dt=self.dt,
                 )
 
             else:
@@ -848,7 +848,8 @@ class CircuitSimulation:
                     cells=self.cells,
                     report_cfg=report_cfg,
                     source_sets=node_sets,
-                    source_type="node_set"
+                    source_type="node_set",
+                    sim_dt=self.dt,
                 )
 
         self.write_spike_report()
@@ -868,7 +869,7 @@ class CircuitSimulation:
             if pop is None:
                 continue
             try:
-                cell_spikes = cell.get_recorded_spikes(location="soma", threshold=self.spike_threshold)
+                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:

{bluecellulab-2.6.53 → bluecellulab-2.6.55}/bluecellulab/simulation/report.py

@@ -92,6 +92,7 @@ def write_compartment_report(
     report_cfg: dict,
     source_sets: dict,
     source_type: str,
+    sim_dt: float
 ):
     """Write a SONATA-compatible compartment report to an HDF5 file.
 
@@ -109,6 +110,7 @@ def write_compartment_report(
             - "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.
@@ -157,25 +159,60 @@ def write_compartment_report(
         return
 
     write_sonata_report_file(
-        output_path, population, data_matrix, recorded_node_ids, index_pointers, element_ids, report_cfg
+        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
+    output_path,
+    population,
+    data_matrix,
+    recorded_node_ids,
+    index_pointers,
+    element_ids,
+    report_cfg,
+    sim_dt
 ):
-    data_array = np.stack(data_matrix, axis=1)
+    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([
-        report_cfg.get("start_time", 0.0),
-        report_cfg.get("end_time", 0.0),
-        report_cfg.get("dt", 0.1)
-    ], dtype=np.float64)
+    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))

{bluecellulab-2.6.53 → bluecellulab-2.6.55}/bluecellulab/validation/validation.py

@@ -438,68 +438,38 @@ def run_validations(
     )
 
     logger.debug("Running validations...")
-    from bluecellulab.utils import NestedPool
-    with NestedPool(processes=8) as pool:
-        # Validation 1: Spiking Test
-        spiking_test_result_future = pool.apply_async(
-            spiking_test,
-            (cell.template_params, rheobase, out_dir, spike_threshold_voltage)
-        )
-
-        # Validation 2: Depolarization Block Test
-        depolarization_block_result_future = pool.apply_async(
-            depolarization_block_test,
-            (cell.template_params, rheobase, out_dir)
-        )
+    # Validation 1: Spiking Test
+    spiking_test_result = spiking_test(
+        cell.template_params, rheobase, out_dir, spike_threshold_voltage
+    )
 
-        # Validation 3: Backpropagating AP Test
-        bpap_result_future = pool.apply_async(
-            bpap_test,
-            (cell.template_params, rheobase, out_dir)
-        )
+    # Validation 2: Depolarization Block Test
+    depolarization_block_result = depolarization_block_test(
+        cell.template_params, rheobase, out_dir
+    )
 
-        # Validation 4: Postsynaptic Potential Test
-        # We have to wait for ProbAMPANMDA_EMS to be present in entitycore to implement this test
+    # Validation 3: Backpropagating AP Test
+    bpap_result = bpap_test(cell.template_params, rheobase, out_dir)
 
-        # Validation 5: AIS Spiking Test
-        ais_spiking_test_result_future = pool.apply_async(
-            ais_spiking_test,
-            (cell.template_params, rheobase, out_dir, spike_threshold_voltage)
-        )
+    # Validation 4: Postsynaptic Potential Test
+    # We have to wait for ProbAMPANMDA_EMS to be present in entitycore to implement this test
 
-        # Validation 6: Hyperpolarization Test
-        hyperpolarization_result_future = pool.apply_async(
-            hyperpolarization_test,
-            (cell.template_params, rheobase, out_dir)
-        )
+    # Validation 5: AIS Spiking Test
+    ais_spiking_test_result = ais_spiking_test(
+        cell.template_params, rheobase, out_dir, spike_threshold_voltage
+    )
 
-        # Validation 7: Rin Test
-        rin_result_future = pool.apply_async(
-            rin_test,
-            (rin,)
-        )
+    # Validation 6: Hyperpolarization Test
+    hyperpolarization_result = hyperpolarization_test(cell.template_params, rheobase, out_dir)
 
-        # # Validation 8: IV Test
-        iv_test_result_future = pool.apply_async(
-            iv_test,
-            (cell.template_params, rheobase, out_dir, spike_threshold_voltage)
-        )
+    # Validation 7: Rin Test
+    rin_result = rin_test(rin)
 
-        # # Validation 9: FI Test
-        fi_test_result_future = pool.apply_async(
-            fi_test,
-            (cell.template_params, rheobase, out_dir, spike_threshold_voltage)
-        )
+    # Validation 8: IV Test
+    iv_test_result = iv_test(cell.template_params, rheobase, out_dir, spike_threshold_voltage)
 
-        # Wait for all validations to complete
-        spiking_test_result = spiking_test_result_future.get()
-        depolarization_block_result = depolarization_block_result_future.get()
-        bpap_result = bpap_result_future.get()
-        ais_spiking_test_result = ais_spiking_test_result_future.get()
-        hyperpolarization_result = hyperpolarization_result_future.get()
-        rin_result = rin_result_future.get()
-        iv_test_result = iv_test_result_future.get()
-        fi_test_result = fi_test_result_future.get()
+    # Validation 9: FI Test
+    fi_test_result = fi_test(cell.template_params, rheobase, out_dir, spike_threshold_voltage)
 
     return {
         "memodel_properties": {

{bluecellulab-2.6.53 → bluecellulab-2.6.55}/bluecellulab.egg-info/PKG-INFO

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