bmtool 0.7.1.4__py3-none-any.whl → 0.7.1.6__py3-none-any.whl

bmtool/analysis/entrainment.py

@@ -714,7 +714,17 @@ def calculate_spike_rate_power_correlation(
     return correlation_results, frequencies
 
 
-def get_spikes_in_cycle(spike_df, lfp_data, spike_fs=1000, lfp_fs=400, band=(30, 80)):
+def get_spikes_in_cycle(
+    spike_df,
+    lfp_data,
+    spike_fs=1000,
+    lfp_fs=400,
+    filter_method="butter",
+    lowcut=None,
+    highcut=None,
+    bandwidth=2.0,
+    freq_of_interest=None,
+):
     """
     Analyze spike timing relative to oscillation phases.
 
@@ -733,12 +743,15 @@ def get_spikes_in_cycle(spike_df, lfp_data, spike_fs=1000, lfp_fs=400, band=(30,
     phase_data : dict
         Dictionary containing phase values for each spike and neuron population
     """
-    filtered_lfp = butter_bandpass_filter(lfp_data, band[0], band[1], lfp_fs)
-
-    # Calculate phase using Hilbert transform
-    analytic_signal = signal.hilbert(filtered_lfp)
-    phase = np.angle(analytic_signal)
-    amplitude = np.abs(analytic_signal)
+    phase = get_lfp_phase(
+        lfp_data=lfp_data,
+        fs=lfp_fs,
+        filter_method=filter_method,
+        lowcut=lowcut,
+        highcut=highcut,
+        bandwidth=bandwidth,
+        freq_of_interest=freq_of_interest,
+    )
 
     # Get unique neuron populations
     neuron_pops = spike_df["pop_name"].unique()
@@ -763,4 +776,4 @@ def get_spikes_in_cycle(spike_df, lfp_data, spike_fs=1000, lfp_fs=400, band=(30,
             valid_samples = spike_indices[valid_indices]
             phase_data[pop] = phase[valid_samples]
 
-    return phase_data, filtered_lfp, phase, amplitude
+    return phase_data

bmtool/analysis/spikes.py

@@ -3,11 +3,12 @@ Module for processing BMTK spikes output.
 """
 
 import os
-from typing import Dict, List, Optional, Tuple, Union
+from typing import List, Optional, Tuple, Union
 
 import h5py
 import numpy as np
 import pandas as pd
+import xarray as xr
 from scipy.stats import mannwhitneyu
 
 from bmtool.util.util import load_nodes_from_config
@@ -213,9 +214,11 @@ def get_population_spike_rate(
     save: bool = False,
     save_path: Optional[str] = None,
     normalize: bool = False,
-) -> Dict[str, np.ndarray]:
+    smooth_window: int = 50,  # Window size for smoothing (in time bins)
+    smooth_method: str = "gaussian",  # Smoothing method: 'gaussian', 'boxcar', or 'exponential'
+) -> xr.DataArray:
     """
-    Calculate the population spike rate for each population in the given spike data, with an option to normalize.
+    Calculate the population spike rate for each population in the given spike data.
 
     Parameters
     ----------
@@ -239,23 +242,41 @@ def get_population_spike_rate(
         Directory path where the file should be saved if `save` is True (default: None)
     normalize : bool, optional
         Whether to normalize the spike rates for each population to a range of [0, 1] (default: False)
+    smooth_window : int, optional
+        Window size for smoothing in number of time bins (default: 50)
+    smooth_method : str, optional
+        Smoothing method to use: 'gaussian', 'boxcar', or 'exponential' (default: 'gaussian')
 
     Returns
     -------
-    Dict[str, np.ndarray]
-        A dictionary where keys are population names, and values are arrays representing the spike rate over time for each population.
-        If `normalize` is True, each population's spike rate is scaled to [0, 1].
+    xr.DataArray
+        An xarray DataArray containing the spike rates with dimensions of time, population, and type.
+        The 'type' dimension includes 'raw' and 'smoothed' values.
+        The DataArray includes sampling frequency (fs) as an attribute.
+        If normalize is True, each population's spike rate is scaled to [0, 1].
 
     Raises
     ------
     ValueError
         If `save` is True but `save_path` is not provided.
+        If an invalid smooth_method is specified.
 
     Notes
     -----
-    - If `config` is None, the function assumes all cells in each population have fired at least once; otherwise, the node count may be inaccurate.
-    - If normalization is enabled, each population's spike rate is scaled using Min-Max normalization based on its own minimum and maximum values.
+    - If `config` is None, the function assumes all cells in each population have fired at least once;
+      otherwise, the node count may be inaccurate.
+    - If normalization is enabled, each population's spike rate is scaled using Min-Max normalization.
+    - Smoothing is applied using scipy.ndimage's filters based on the specified method.
     """
+    import numpy as np
+    from scipy import ndimage
+
+    # Validate smoothing method
+    if smooth_method not in ["gaussian", "boxcar", "exponential"]:
+        raise ValueError(
+            f"Invalid smooth_method: {smooth_method}. Choose from 'gaussian', 'boxcar', or 'exponential'."
+        )
+
     pop_spikes = {}
     node_number = {}
 
@@ -271,7 +292,13 @@ def get_population_spike_rate(
                 "Grabbing first network; specify a network name to ensure correct node population is selected."
             )
 
-    for pop_name in spike_data["pop_name"].unique():
+    # Get t_stop if not provided
+    if t_stop is None:
+        t_stop = spike_data["timestamps"].max()
+
+    # Get population names and prepare data
+    populations = spike_data["pop_name"].unique()
+    for pop_name in populations:
         ps = spike_data[spike_data["pop_name"] == pop_name]
 
         if config:
@@ -282,12 +309,10 @@ def get_population_spike_rate(
                 nodes = list(nodes.values())[0] if nodes else {}
             nodes = nodes[nodes["pop_name"] == pop_name]
             node_number[pop_name] = nodes.index.nunique()
+
         else:
             node_number[pop_name] = ps["node_ids"].nunique()
 
-        if t_stop is None:
-            t_stop = spike_data["timestamps"].max()
-
         filtered_spikes = spike_data[
             (spike_data["pop_name"] == pop_name)
             & (spike_data["timestamps"] > t_start)
@@ -295,29 +320,153 @@ def get_population_spike_rate(
         ]
         pop_spikes[pop_name] = filtered_spikes
 
-    time = np.array([t_start, t_stop, 1000 / fs])
-    pop_rspk = {p: _pop_spike_rate(spk["timestamps"], time) for p, spk in pop_spikes.items()}
-    spike_rate = {p: fs / node_number[p] * pop_rspk[p] for p in pop_rspk}
+    # Calculate time points
+    time = np.arange(t_start, t_stop, 1000 / fs)  # Convert sampling frequency to time steps
+
+    # Calculate spike rates for each population
+    spike_rates = []
+    for p in populations:
+        raw_rate = _pop_spike_rate(pop_spikes[p]["timestamps"], (t_start, t_stop, 1000 / fs))
+        rate = fs / node_number[p] * raw_rate
+        spike_rates.append(rate)
+
+    spike_rates_array = np.array(spike_rates).T  # Transpose to have time as first dimension
+
+    # Calculate smoothed version for each population
+    smoothed_rates = []
+
+    for i in range(spike_rates_array.shape[1]):
+        pop_rate = spike_rates_array[:, i]
+
+        if smooth_method == "gaussian":
+            # Gaussian smoothing (sigma is approximately window/6 for a Gaussian filter)
+            sigma = smooth_window / 6
+            smoothed_pop_rate = ndimage.gaussian_filter1d(pop_rate, sigma=sigma)
+        elif smooth_method == "boxcar":
+            # Boxcar/uniform smoothing
+            kernel = np.ones(smooth_window) / smooth_window
+            smoothed_pop_rate = ndimage.convolve1d(pop_rate, kernel, mode="nearest")
+        elif smooth_method == "exponential":
+            # Exponential smoothing
+            alpha = 2 / (smooth_window + 1)  # Equivalent to window size in exponential smoothing
+            smoothed_pop_rate = np.zeros_like(pop_rate)
+            smoothed_pop_rate[0] = pop_rate[0]
+            for t in range(1, len(pop_rate)):
+                smoothed_pop_rate[t] = alpha * pop_rate[t] + (1 - alpha) * smoothed_pop_rate[t - 1]
+
+        smoothed_rates.append(smoothed_pop_rate)
+
+    smoothed_rates_array = np.array(smoothed_rates).T  # Transpose to have time as first dimension
+
+    # Stack raw and smoothed data
+    combined_data = np.stack([spike_rates_array, smoothed_rates_array], axis=2)
+
+    # Create DataArray with the additional 'type' dimension
+    spike_rate_array = xr.DataArray(
+        combined_data,
+        coords={"time": time, "population": populations, "type": ["raw", "smoothed"]},
+        dims=["time", "population", "type"],
+        attrs={
+            "fs": fs,
+            "normalized": False,
+            "smooth_method": smooth_method,
+            "smooth_window": smooth_window,
+        },
+    )
 
-    # Normalize each spike rate series if normalize=True
+    # Normalize if requested
     if normalize:
-        spike_rate = {p: (sr - sr.min()) / (sr.max() - sr.min()) for p, sr in spike_rate.items()}
-
+        # Apply normalization for each population and each type (raw/smoothed)
+        for pop_idx in range(len(populations)):
+            for type_idx, type_name in enumerate(["raw", "smoothed"]):
+                pop_data = spike_rate_array.sel(population=populations[pop_idx], type=type_name)
+                min_val = pop_data.min(dim="time")
+                max_val = pop_data.max(dim="time")
+
+                # Handle case where min == max (constant signal)
+                if max_val != min_val:
+                    spike_rate_array.loc[:, populations[pop_idx], type_name] = (
+                        pop_data - min_val
+                    ) / (max_val - min_val)
+
+        spike_rate_array.attrs["normalized"] = True
+
+    # Save if requested
     if save:
         if save_path is None:
             raise ValueError("save_path must be provided if save is True.")
 
         os.makedirs(save_path, exist_ok=True)
-
         save_file = os.path.join(save_path, "spike_rate.h5")
-        with h5py.File(save_file, "w") as f:
-            f.create_dataset("time", data=time)
-            grp = f.create_group("populations")
-            for p, rspk in spike_rate.items():
-                pop_grp = grp.create_group(p)
-                pop_grp.create_dataset("data", data=rspk)
+        spike_rate_array.to_netcdf(save_file)
 
-    return spike_rate
+    return spike_rate_array
+
+
+def average_spike_rate_over_windows(
+    spike_rate: xr.DataArray, windows: List[Tuple[float, float]]
+) -> xr.DataArray:
+    """
+    Calculate the average spike rate over multiple time windows.
+
+    Parameters
+    ----------
+    spike_rate : xr.DataArray
+        The spike rate data array with dimensions (time, population, type)
+        where 'type' can be 'raw' or 'smoothed'
+    windows : List[Tuple[float, float]]
+        List of (start, end) times in milliseconds defining the windows to average over
+
+    Returns
+    -------
+    xr.DataArray
+        Averaged spike rate with time normalized to start at 0,
+        preserving all original dimensions (time, population, type)
+    """
+    # Check if the DataArray has a 'type' dimension (compatible with new format)
+    has_type_dim = "type" in spike_rate.dims
+
+    # Initialize list to store data from each window
+    window_data = []
+
+    # Get data for each window
+    for start, end in windows:
+        # Select data points within the window
+        window = spike_rate.sel(time=slice(start, end))
+
+        # Normalize time to start at 0 for this window
+        window = window.assign_coords(time=window.time - start)
+        window_data.append(window)
+
+    # Align and average windows
+    # First window determines the time coordinates
+    aligned_data = xr.concat(window_data, dim="window")
+    averaged_data = aligned_data.mean(dim="window")
+
+    # Create new DataArray with the averaged data
+    if has_type_dim:
+        # Create result with time, population, and type dimensions
+        result = xr.DataArray(
+            averaged_data.values,
+            coords={
+                "time": averaged_data.time.values,
+                "population": averaged_data.population,
+                "type": averaged_data.type,
+            },
+            dims=["time", "population", "type"],
+        )
+    else:
+        # Handle older format without 'type' dimension (for backward compatibility)
+        result = xr.DataArray(
+            averaged_data.values,
+            coords={"time": averaged_data.time.values, "population": averaged_data.population},
+            dims=["time", "population"],
+        )
+
+    # Preserve attributes
+    result.attrs = spike_rate.attrs
+
+    return result
 
 
 def compare_firing_over_times(
@@ -401,7 +550,7 @@ def compare_firing_over_times(
 
 
 def find_bursting_cells(
-    df: pd.DataFrame, burst_threshold: float = 10, rename_bursting_cells: bool = False
+    df: pd.DataFrame, isi_threshold: float = 10, burst_count_threshold: int = 1
 ) -> pd.DataFrame:
     """
     Finds bursting cells in a population based on a time difference threshold.
@@ -410,10 +559,10 @@ def find_bursting_cells(
     ----------
     df : pd.DataFrame
         DataFrame containing spike data with columns for timestamps, node_ids, and pop_name
-    burst_threshold : float, optional
+    isi_threshold : float, optional
         Time difference threshold in milliseconds to identify bursts
-    rename_bursting_cells : bool, optional
-        If True, returns a DataFrame with bursting cells renamed in their pop_name column
+    burst_count_threshold : int, optional
+        Number of bursts required to identify a bursting cell
 
     Returns
     -------
@@ -425,10 +574,11 @@ def find_bursting_cells(
     diff_df["time_diff"] = df.groupby("node_ids")["timestamps"].diff()
 
     # Create a column indicating whether each time difference is a burst
-    diff_df["is_burst_instance"] = diff_df["time_diff"] < burst_threshold
+    diff_df["is_burst_instance"] = diff_df["time_diff"] < isi_threshold
 
     # Group by node_ids and check if any row has a burst instance
-    burst_summary = diff_df.groupby("node_ids")["is_burst_instance"].any()
+    # check if there are enough bursts
+    burst_summary = diff_df.groupby("node_ids")["is_burst_instance"].sum() >= burst_count_threshold
 
     # Convert to a DataFrame with reset index
     burst_cells = burst_summary.reset_index(name="is_burst")
@@ -442,14 +592,11 @@ def find_bursting_cells(
     )
 
     # Add "_bursters" suffix only to those cells
-    if rename_bursting_cells:
-        burst_cells.loc[burst_mask, "pop_name"] = (
-            burst_cells.loc[burst_mask, "pop_name"] + "_bursters"
-        )
+    burst_cells.loc[burst_mask, "pop_name"] = burst_cells.loc[burst_mask, "pop_name"] + "_bursters"
 
-    for pop in burst_cells["pop_name"].unique():
+    for pop in sorted(burst_cells["pop_name"].unique()):
         print(
-            f"Number of bursters in {pop}: {burst_cells[burst_cells['pop_name'] == pop]['node_ids'].nunique()}"
+            f"Number of cells in {pop}: {burst_cells[burst_cells['pop_name'] == pop]['node_ids'].nunique()}"
         )
 
     return burst_cells

bmtool/bmplot/spikes.py

@@ -1,3 +1,5 @@
+"""Plotting functions for neural spikes and firing rates."""
+
 from typing import Dict, List, Optional, Union
 
 import matplotlib.pyplot as plt

{bmtool-0.7.1.4.dist-info → bmtool-0.7.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmtool
-Version: 0.7.1.4
+Version: 0.7.1.6
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.7.1.4.dist-info → bmtool-0.7.1.6.dist-info}/RECORD

@@ -8,16 +8,16 @@ bmtool/plot_commands.py,sha256=Dxm_RaT4CtHnfsltTtUopJ4KVbfhxtktEB_b7bFEXII,12716
 bmtool/singlecell.py,sha256=I2yolbAnNC8qpnRkNdnDCLidNW7CktmBuRrcowMZJ3A,45041
 bmtool/synapses.py,sha256=wlRY7IixefPzafqG6k2sPIK4s6PLG9Kct-oCaVR29wA,64269
 bmtool/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bmtool/analysis/entrainment.py,sha256=uG2TWbeYJEg_VQB6pKEWlrVBzQ6M4h6FSAZR4GMKp-E,28178
+bmtool/analysis/entrainment.py,sha256=PM4Do8Cl248Y2kIXLRFLPmUB_mH38Yhl8CUDDcunGq0,28241
 bmtool/analysis/lfp.py,sha256=S2JvxkjcK3-EH93wCrhqNSFY6cX7fOq74pz64ibHKrc,26556
 bmtool/analysis/netcon_reports.py,sha256=VnPZNKPaQA7oh1q9cIatsqQudm4cOtzNtbGPXoiDCD0,2909
-bmtool/analysis/spikes.py,sha256=kIcTRRMr6ofxCwnE9lrlnvlez4z07IKX0mUr4jy9jP8,17120
+bmtool/analysis/spikes.py,sha256=iJfoVKl2k1X9s6C3PYz-18zlfahuRM_35wN5H9xDCIg,22715
 bmtool/bmplot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/bmplot/connections.py,sha256=P1JBG4xCbLVq4sfQuUE6c3dO949qajrjdQcrazdmDS4,53861
 bmtool/bmplot/entrainment.py,sha256=VSlZvcSeXLr5OxGvmWcGU4s7JS7vOL38lq1XC69O_AE,6926
 bmtool/bmplot/lfp.py,sha256=SNpbWGOUnYEgnkeBw5S--aPN5mIGD22Gw2Pwus0_lvY,2034
 bmtool/bmplot/netcon_reports.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bmtool/bmplot/spikes.py,sha256=Lg8V3ynYCqk-QJvq-BOInjZMHYHrxHgXjtDOX67df-A,11148
+bmtool/bmplot/spikes.py,sha256=RJOOtmgWhTvyVi1CghoKTtxvt7MF9cJCrJVm5hV5wA4,11210
 bmtool/debug/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/debug/commands.py,sha256=VV00f6q5gzZI503vUPeG40ABLLen0bw_k4-EX-H5WZE,580
 bmtool/debug/debug.py,sha256=9yUFvA4_Bl-x9s29quIEG3pY-S8hNJF3RKBfRBHCl28,208
@@ -26,9 +26,9 @@ bmtool/util/commands.py,sha256=Nn-R-4e9g8ZhSPZvTkr38xeKRPfEMANB9Lugppj82UI,68564
 bmtool/util/util.py,sha256=owce5BEusZO_8T5x05N2_B583G26vWAy7QX29V0Pj0Y,62818
 bmtool/util/neuron/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/util/neuron/celltuner.py,sha256=lokRLUM1rsdSYBYrNbLBBo39j14mm8TBNVNRnSlhHCk,94868
-bmtool-0.7.1.4.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
-bmtool-0.7.1.4.dist-info/METADATA,sha256=6lhzffBCmubbgsbW4WJyoZ4PdOo3Qoe1SjcOMaSgZwY,3577
-bmtool-0.7.1.4.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-bmtool-0.7.1.4.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
-bmtool-0.7.1.4.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
-bmtool-0.7.1.4.dist-info/RECORD,,
+bmtool-0.7.1.6.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
+bmtool-0.7.1.6.dist-info/METADATA,sha256=_jtey-F9b0kjpQ2CELf9SxupFMMv1c-RtgmthDweFJw,3577
+bmtool-0.7.1.6.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+bmtool-0.7.1.6.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
+bmtool-0.7.1.6.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
+bmtool-0.7.1.6.dist-info/RECORD,,

{bmtool-0.7.1.4.dist-info → bmtool-0.7.1.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any