bmtool 0.7.1.7__tar.gz → 0.7.2.1__tar.gz

{bmtool-0.7.1.7 → bmtool-0.7.2.1}/PKG-INFO

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

{bmtool-0.7.1.7 → bmtool-0.7.2.1}/bmtool/analysis/entrainment.py

@@ -7,13 +7,12 @@ from typing import Dict, List, Optional, Union
 import numba
 import numpy as np
 import pandas as pd
-import scipy.stats as stats
 import xarray as xr
 from numba import cuda
 from scipy import signal
 from tqdm.notebook import tqdm
 
-from .lfp import butter_bandpass_filter, get_lfp_phase, get_lfp_power, wavelet_filter
+from .lfp import butter_bandpass_filter, get_lfp_phase, wavelet_filter
 
 
 def align_spike_times_with_lfp(lfp: xr.DataArray, timestamps: np.ndarray) -> np.ndarray:
@@ -635,85 +634,6 @@ def calculate_entrainment_per_cell(
     return entrainment_dict
 
 
-def calculate_spike_rate_power_correlation(
-    spike_rate: xr.DataArray,
-    lfp_data: np.ndarray,
-    fs: float,
-    pop_names: list,
-    filter_method: str = "wavelet",
-    bandwidth: float = 2.0,
-    lowcut: float = None,
-    highcut: float = None,
-    freq_range: tuple = (10, 100),
-    freq_step: float = 5,
-    type_name: str = "raw",  # 'raw' or 'smoothed'
-):
-    """
-    Calculate correlation between population spike rates (xarray) and LFP power across frequencies.
-
-    Parameters
-    ----------
-    spike_rate : xr.DataArray
-        Population spike rates with dimensions (time, population[, type])
-    lfp_data : np.ndarray
-        LFP data
-    fs : float
-        Sampling frequency
-    pop_names : list
-        List of population names to analyze
-    filter_method : str, optional
-        Filtering method to use, either 'wavelet' or 'butter' (default: 'wavelet')
-    bandwidth : float, optional
-        Bandwidth parameter for wavelet filter when method='wavelet' (default: 2.0)
-    lowcut : float, optional
-        Lower frequency bound (Hz) for butterworth bandpass filter, required if filter_method='butter'
-    highcut : float, optional
-        Upper frequency bound (Hz) for butterworth bandpass filter, required if filter_method='butter'
-    freq_range : tuple, optional
-        Min and max frequency to analyze (default: (10, 100))
-    freq_step : float, optional
-        Step size for frequency analysis (default: 5)
-    type_name : str, optional
-        Which type of spike rate to use if 'type' dimension exists (default: 'raw')
-
-    Returns
-    -------
-    correlation_results : dict
-        Dictionary with correlation results for each population and frequency
-    frequencies : array
-        Array of frequencies analyzed
-    """
-    frequencies = np.arange(freq_range[0], freq_range[1] + 1, freq_step)
-    correlation_results = {pop: {} for pop in pop_names}
-
-    # Calculate power at each frequency band using specified filter
-    power_by_freq = {}
-    for freq in frequencies:
-        power_by_freq[freq] = get_lfp_power(
-            lfp_data, freq, fs, filter_method, lowcut=lowcut, highcut=highcut, bandwidth=bandwidth
-        )
-
-    # For each population, extract the correct spike rate
-    for pop in pop_names:
-        # If 'type' dimension exists, select the type
-        if "type" in spike_rate.dims:
-            pop_rate = spike_rate.sel(population=pop, type=type_name).values
-        else:
-            pop_rate = spike_rate.sel(population=pop).values
-
-        # Calculate correlation with power at each frequency
-        for freq in frequencies:
-            lfp_power = power_by_freq[freq]
-            # Ensure lengths match
-            min_len = min(len(pop_rate), len(lfp_power))
-            if len(pop_rate) != len(lfp_power):
-                print(f"Warning: Length mismatch for {pop} at {freq} Hz, truncating to {min_len}")
-            corr, p_val = stats.spearmanr(pop_rate[:min_len], lfp_power[:min_len])
-            correlation_results[pop][freq] = {"correlation": corr, "p_value": p_val}
-
-    return correlation_results, frequencies
-
-
 def get_spikes_in_cycle(
     spike_df,
     lfp_data,

{bmtool-0.7.1.7 → bmtool-0.7.2.1}/bmtool/analysis/spikes.py

@@ -281,12 +281,13 @@ def get_population_spike_rate(
     node_number = {}
 
     if config is None:
-        print(
-            "Note: Node number is obtained by counting unique node spikes in the network.\nIf the network did not run for a sufficient duration, or not all cells fired,\nthen this count will not include all nodes so the firing rate will not be of the whole population!"
-        )
-        print(
-            "You can provide a config to calculate the correct amount of nodes! for a true population rate."
-        )
+        pass
+        # print(
+        #     "Note: Node number is obtained by counting unique node spikes in the network.\nIf the network did not run for a sufficient duration, or not all cells fired,\nthen this count will not include all nodes so the firing rate will not be of the whole population!"
+        # )
+        # print(
+        #     "You can provide a config to calculate the correct amount of nodes! for a true population rate."
+        # )
 
     if config:
         if not network_name:
@@ -602,3 +603,51 @@ def find_bursting_cells(
         )
 
     return burst_cells
+
+
+def find_highest_firing_cells(
+    df: pd.DataFrame, upper_quantile: float, groupby: str = "pop_name"
+) -> pd.DataFrame:
+    """
+    Identifies and returns spikes from cells with firing rates above a specified upper quantile,
+    grouped by a population label.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame containing spike data with at least the following columns:
+        - 'timestamps': Time of each spike event
+        - 'node_ids': Identifier for each neuron
+        - groupby (e.g., 'pop_name'): Population labels or grouping identifiers for neurons
+
+    upper_quantile : float
+        The upper quantile threshold (between 0 and 1).
+        Cells with firing rates in the top (1 - upper_quantile) fraction are selected.
+        For example, upper_quantile=0.8 selects the top 20% of high-firing cells.
+
+    groupby : str, optional
+        The column name used to group neurons by population. Default is 'pop_name'.
+
+    Returns
+    -------
+    pd.DataFrame
+        A DataFrame containing only the spikes from the high-firing cells across all groupbys.
+    """
+    if upper_quantile == 0:
+        return df
+    df_list = []
+    for pop in df[groupby].unique():
+        pop_df = df[df[groupby] == pop]
+        _, pop_fr = compute_firing_rate_stats(pop_df, groupby=groupby)
+
+        # Identify high firing cells
+        threshold = pop_fr["firing_rate"].quantile(upper_quantile)
+        high_firing_cells = pop_fr[pop_fr["firing_rate"] >= threshold]["node_ids"]
+
+        # Filter spikes for high firing cells
+        pop_spikes = pop_df[pop_df["node_ids"].isin(high_firing_cells)]
+        df_list.append(pop_spikes)
+
+    # Combine all high firing spikes into one DataFrame
+    result_df = pd.concat(df_list, ignore_index=True)
+    return result_df