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

bmtool/analysis/entrainment.py

@@ -712,3 +712,55 @@ def calculate_spike_rate_power_correlation(
             correlation_results[pop][freq] = {"correlation": corr, "p_value": p_val}
 
     return correlation_results, frequencies
+
+
+def get_spikes_in_cycle(spike_df, lfp_data, spike_fs=1000, lfp_fs=400, band=(30, 80)):
+    """
+    Analyze spike timing relative to oscillation phases.
+
+    Parameters:
+    -----------
+    spike_df : pd.DataFrame
+    lfp_data : np.array
+        Raw LFP signal
+    fs : float
+        Sampling frequency of LFP in Hz
+    gamma_band : tuple
+        Lower and upper bounds of gamma frequency band in Hz
+
+    Returns:
+    --------
+    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)
+
+    # Get unique neuron populations
+    neuron_pops = spike_df["pop_name"].unique()
+
+    # Get the phase at each spike time for each neuron population
+    phase_data = {}
+
+    for pop in neuron_pops:
+        # Get spike times for this population
+        pop_spikes = spike_df[spike_df["pop_name"] == pop]["timestamps"].values
+
+        # Convert spike times to sample indices
+        spike_times_seconds = pop_spikes / spike_fs
+
+        # Then convert from seconds to samples at the new sampling rate
+        spike_indices = np.round(spike_times_seconds * lfp_fs).astype(int)
+
+        # Ensure spike times are within LFP data range
+        valid_indices = (spike_indices >= 0) & (spike_indices < len(phase))
+
+        if np.any(valid_indices):
+            valid_samples = spike_indices[valid_indices]
+            phase_data[pop] = phase[valid_samples]
+
+    return phase_data, filtered_lfp, phase, amplitude

bmtool/analysis/spikes.py

@@ -398,3 +398,58 @@ def compare_firing_over_times(
         print(f"    p-value: {p_val}")
         print(f"    Significant difference (p<0.05): {'Yes' if p_val < 0.05 else 'No'}")
     return
+
+
+def find_bursting_cells(
+    df: pd.DataFrame, burst_threshold: float = 10, rename_bursting_cells: bool = False
+) -> pd.DataFrame:
+    """
+    Finds bursting cells in a population based on a time difference threshold.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame containing spike data with columns for timestamps, node_ids, and pop_name
+    burst_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
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame with bursting cells renamed in their pop_name column
+    """
+    # Create a new DataFrame with the time differences
+    diff_df = df.copy()
+    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
+
+    # Group by node_ids and check if any row has a burst instance
+    burst_summary = diff_df.groupby("node_ids")["is_burst_instance"].any()
+
+    # Convert to a DataFrame with reset index
+    burst_cells = burst_summary.reset_index(name="is_burst")
+
+    # merge with original df to get timestamps
+    burst_cells = pd.merge(burst_cells, df, on="node_ids")
+
+    # Create a mask for burst cells that don't already have "_bursters" in their name
+    burst_mask = burst_cells["is_burst"] & ~burst_cells["pop_name"].str.contains(
+        "_bursters", na=False
+    )
+
+    # 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"
+        )
+
+    for pop in burst_cells["pop_name"].unique():
+        print(
+            f"Number of bursters in {pop}: {burst_cells[burst_cells['pop_name'] == pop]['node_ids'].nunique()}"
+        )
+
+    return burst_cells

bmtool/bmplot/entrainment.py

@@ -1,5 +1,8 @@
 import matplotlib.pyplot as plt
+import numpy as np
 import seaborn as sns
+from matplotlib.gridspec import GridSpec
+from scipy import stats
 
 
 def plot_spike_power_correlation(correlation_results, frequencies, pop_names):
@@ -48,3 +51,152 @@ def plot_spike_power_correlation(correlation_results, frequencies, pop_names):
     plt.tight_layout()
 
     plt.show()
+
+
+def plot_cycle_with_spike_histograms(phase_data, bins=36, pop_name=None):
+    """
+    Plot an idealized gamma cycle with spike histograms for different neuron populations.
+
+    Parameters:
+    -----------
+    phase_data : dict
+        Dictionary containing phase values for each spike and neuron population
+    fs : float
+        Sampling frequency of LFP in Hz
+    bins : int
+        Number of bins for the phase histogram (default 36 gives 10-degree bins)
+    pop_name : list
+        List of population names to be plotted
+    """
+    sns.set_style("whitegrid")
+    # Create a figure with subplots
+    fig = plt.figure(figsize=(12, 8))
+    gs = GridSpec(len(pop_name) + 1, 1, height_ratios=[1.5] + [1] * len(pop_name))
+
+    # Top subplot: Idealized gamma cycle
+    ax_gamma = fig.add_subplot(gs[0])
+
+    # Create an idealized gamma cycle
+    x = np.linspace(-np.pi, np.pi, 1000)
+    y = np.sin(x)
+
+    ax_gamma.plot(x, y, "b-", linewidth=2)
+    ax_gamma.set_title("Cycle with Neuron Population Spike Distributions", fontsize=14)
+    ax_gamma.set_ylabel("Amplitude", fontsize=12)
+    ax_gamma.set_xlim(-np.pi, np.pi)
+    ax_gamma.set_xticks(np.linspace(-np.pi, np.pi, 9))
+    ax_gamma.set_xticklabels(["-180°", "-135°", "-90°", "-45°", "0°", "45°", "90°", "135°", "180°"])
+    ax_gamma.grid(True)
+    ax_gamma.axhline(y=0, color="k", linestyle="-", alpha=0.3)
+    ax_gamma.axvline(x=0, color="k", linestyle="--", alpha=0.3)
+
+    # Generate a color map for the different populations
+    colors = plt.cm.tab10(np.linspace(0, 1, len(pop_name)))
+
+    # Add histograms for each neuron population
+    for i, pop_name in enumerate(pop_name):
+        ax_hist = fig.add_subplot(gs[i + 1], sharex=ax_gamma)
+
+        # Compute histogram
+        hist, bin_edges = np.histogram(phase_data[pop_name], bins=bins, range=(-np.pi, np.pi))
+        bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+
+        # Normalize histogram
+        if np.sum(hist) > 0:
+            hist = hist / np.sum(hist) * 100  # Convert to percentage
+
+        # Plot histogram
+        ax_hist.bar(bin_centers, hist, width=2 * np.pi / bins, alpha=0.7, color=colors[i])
+        ax_hist.set_ylabel(f"{pop_name}\nSpikes (%)", fontsize=10)
+
+        # Add grid to align with gamma cycle
+        ax_hist.grid(True, alpha=0.3)
+        ax_hist.set_ylim(0, max(hist) * 1.2)  # Add some headroom
+
+    # Set x-label for the last subplot
+    ax_hist.set_xlabel("Phase (degrees)", fontsize=12)
+
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_ppc_by_population(ppc_dict, pop_names, freqs, figsize=(15, 8), title=None):
+    """
+    Plot PPC for all node populations on one graph with mean and standard error.
+
+    Parameters:
+    -----------
+    ppc_dict : dict
+        Dictionary containing PPC data organized by population, node, and frequency
+    pop_names : list
+        List of population names to plot data for
+    freqs : list
+        List of frequencies to plot
+    figsize : tuple
+        Figure size for the plot
+    """
+    # Set up the visualization style
+    sns.set_style("whitegrid")
+    plt.figure(figsize=figsize)
+
+    # Calculate the width of each group of bars
+    n_groups = len(freqs)
+    n_populations = len(pop_names)
+    group_width = 0.8
+    bar_width = group_width / n_populations
+
+    # Color palette for different populations
+    pop_colors = sns.color_palette(n_colors=n_populations)
+
+    # For tracking x-axis positions and labels
+    x_centers = np.arange(n_groups)
+    tick_labels = [str(freq) for freq in freqs]
+
+    # Process and plot data for each population
+    for i, pop in enumerate(pop_names):
+        # Store mean and SE for each frequency in this population
+        means = []
+        errors = []
+        valid_freqs_idx = []
+
+        # Collect and process data for all frequencies in this population
+        for freq_idx, freq in enumerate(freqs):
+            freq_values = []
+
+            # Collect values across all nodes for this frequency
+            for node in ppc_dict[pop]:
+                try:
+                    ppc_value = ppc_dict[pop][node][freq]
+                    freq_values.append(ppc_value)
+                except KeyError:
+                    continue
+
+            # If we have data for this frequency
+            if freq_values:
+                mean_val = np.mean(freq_values)
+                se_val = stats.sem(freq_values)
+                means.append(mean_val)
+                errors.append(se_val)
+                valid_freqs_idx.append(freq_idx)
+
+        # Calculate x positions for this population's bars
+        # Each population's bars are offset within their frequency group
+        x_positions = x_centers[valid_freqs_idx] + (i - n_populations / 2 + 0.5) * bar_width
+
+        # Plot bars with error bars
+        plt.bar(
+            x_positions, means, width=bar_width * 0.9, color=pop_colors[i], alpha=0.7, label=pop
+        )
+        plt.errorbar(x_positions, means, yerr=errors, fmt="none", ecolor="black", capsize=4)
+
+    # Set up the plot labels and legend
+    plt.xlabel("Frequency")
+    plt.ylabel("PPC Value")
+    if title:
+        plt.title(title)
+    plt.xticks(x_centers, tick_labels)
+    plt.legend(title="Population")
+
+    # Adjust layout and save
+    plt.tight_layout()
+    plt.show()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmtool
-Version: 0.7.1.2
+Version: 0.7.1.4
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 
@@ -38,7 +38,6 @@ Requires-Dist: PyWavelets
 Requires-Dist: numba
 Provides-Extra: dev
 Requires-Dist: ruff>=0.1.0; extra == "dev"
-Requires-Dist: pyright>=1.1.0; extra == "dev"
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Dynamic: author

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

@@ -8,13 +8,13 @@ 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=sjfSxPs1Y0dnEtX9a3IIMEeQ09L6WbhO3KMt-O8SN64,26480
+bmtool/analysis/entrainment.py,sha256=uG2TWbeYJEg_VQB6pKEWlrVBzQ6M4h6FSAZR4GMKp-E,28178
 bmtool/analysis/lfp.py,sha256=S2JvxkjcK3-EH93wCrhqNSFY6cX7fOq74pz64ibHKrc,26556
 bmtool/analysis/netcon_reports.py,sha256=VnPZNKPaQA7oh1q9cIatsqQudm4cOtzNtbGPXoiDCD0,2909
-bmtool/analysis/spikes.py,sha256=ScP4EeX2QuEd_FXyj3W0WWgZKvZwwneuWuKFe3xwaCY,15115
+bmtool/analysis/spikes.py,sha256=kIcTRRMr6ofxCwnE9lrlnvlez4z07IKX0mUr4jy9jP8,17120
 bmtool/bmplot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/bmplot/connections.py,sha256=P1JBG4xCbLVq4sfQuUE6c3dO949qajrjdQcrazdmDS4,53861
-bmtool/bmplot/entrainment.py,sha256=TC2qJV0Z6YiK5X7bEpiEyf7nZiWU__466Uhq0kbrhIY,1611
+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
@@ -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.2.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
-bmtool-0.7.1.2.dist-info/METADATA,sha256=LO1VUW641H9cxsHp1vi809dqrJoZGc4GfJaKqTbOZGc,3623
-bmtool-0.7.1.2.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-bmtool-0.7.1.2.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
-bmtool-0.7.1.2.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
-bmtool-0.7.1.2.dist-info/RECORD,,
+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,,