bmtool 0.6.9.23__tar.gz → 0.6.9.25__tar.gz

{bmtool-0.6.9.23 → bmtool-0.6.9.25}/PKG-INFO

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

bmtool-0.6.9.25/bmtool/analysis/entrainment.py

@@ -0,0 +1,429 @@
+"""
+Module for entrainment analysis
+"""
+
+import numpy as np
+from scipy import signal
+import numba
+from numba import cuda
+import pandas as pd
+import xarray as xr
+from .lfp import wavelet_filter,butter_bandpass_filter
+from typing import Dict, List
+from tqdm.notebook import tqdm
+
+
+def calculate_signal_signal_plv(x1: np.ndarray, x2: np.ndarray, fs: float, freq_of_interest: float = None, 
+                  method: str = 'wavelet', lowcut: float = None, highcut: float = None, 
+                  bandwidth: float = 2.0) -> np.ndarray:
+    """
+    Calculate Phase Locking Value (PLV) between two signals using wavelet or Hilbert method.
+    
+    Parameters:
+    - x1, x2: Input signals (1D arrays, same length)
+    - fs: Sampling frequency
+    - freq_of_interest: Desired frequency for wavelet PLV calculation
+    - method: 'wavelet' or 'hilbert' to choose the PLV calculation method
+    - lowcut, highcut: Cutoff frequencies for the Hilbert method
+    - bandwidth: Bandwidth parameter for the wavelet
+    
+    Returns:
+    - plv: Phase Locking Value (1D array)
+    """
+    if len(x1) != len(x2):
+        raise ValueError("Input signals must have the same length.")
+    
+    if method == 'wavelet':
+        if freq_of_interest is None:
+            raise ValueError("freq_of_interest must be provided for the wavelet method.")
+        
+        # Apply CWT to both signals
+        theta1 = wavelet_filter(x=x1, freq=freq_of_interest, fs=fs, bandwidth=bandwidth)
+        theta2 = wavelet_filter(x=x2, freq=freq_of_interest, fs=fs, bandwidth=bandwidth)
+    
+    elif method == 'hilbert':
+        if lowcut is None or highcut is None:
+            print("Lowcut and or highcut were not definded, signal will not be filter and just take hilbert transform for plv calc")
+        
+        if lowcut and highcut:
+            # Bandpass filter and get the analytic signal using the Hilbert transform
+            x1 = butter_bandpass_filter(x1, lowcut, highcut, fs)
+            x2 = butter_bandpass_filter(x2, lowcut, highcut, fs)
+        
+        # Get phase using the Hilbert transform
+        theta1 = signal.hilbert(x1)
+        theta2 = signal.hilbert(x2)
+    
+    else:
+        raise ValueError("Invalid method. Choose 'wavelet' or 'hilbert'.")
+    
+    # Calculate phase difference
+    phase_diff = np.angle(theta1) - np.angle(theta2)
+    
+    # Calculate PLV from standard equation from Measuring phase synchrony in brain signals(1999)
+    plv = np.abs(np.mean(np.exp(1j * phase_diff), axis=-1))
+    
+    return plv
+
+
+def calculate_spike_lfp_plv(spike_times: np.ndarray = None, lfp_signal: np.ndarray = None, spike_fs : float = None,
+                   lfp_fs: float = None, method: str = 'hilbert', freq_of_interest: float = None,
+                   lowcut: float = None, highcut: float = None,
+                   bandwidth: float = 2.0) -> tuple:
+    """
+    Calculate spike-lfp phase locking value Based on https://www.sciencedirect.com/science/article/pii/S1053811910000959
+    
+    Parameters:
+    - spike_times: Array of spike times 
+    - lfp_signal: Local field potential time series
+    - spike_fs: Sampling frequency in Hz of the spike times only needed if spikes times and lfp has different fs
+    - lfp_fs : Sampling frequency in Hz of the LFP
+    - method: 'wavelet' or 'hilbert' to choose the phase extraction method
+    - freq_of_interest: Desired frequency for wavelet phase extraction
+    - lowcut, highcut: Cutoff frequencies for bandpass filtering (Hilbert method)
+    - bandwidth: Bandwidth parameter for the wavelet
+    
+    Returns:
+    - ppc1: Phase-Phase Coupling value
+    - spike_phases: Phases at spike times
+    """
+    
+    if spike_fs == None:
+        spike_fs = lfp_fs
+    # Convert spike times to sample indices
+    spike_times_seconds = spike_times / spike_fs
+
+    # Then convert from seconds to samples at the new sampling rate
+    spike_indices = np.round(spike_times_seconds * lfp_fs).astype(int)
+    
+    # Filter indices to ensure they're within bounds of the LFP signal
+    valid_indices = [idx for idx in spike_indices if 0 <= idx < len(lfp_signal)]
+    if len(valid_indices) <= 1:
+        return 0, np.array([])
+    
+    # Extract phase using the specified method
+    if method == 'wavelet':
+        if freq_of_interest is None:
+            raise ValueError("freq_of_interest must be provided for the wavelet method.")
+        
+        # Apply CWT to extract phase at the frequency of interest
+        lfp_complex = wavelet_filter(x=lfp_signal, freq=freq_of_interest, fs=lfp_fs, bandwidth=bandwidth)
+        instantaneous_phase = np.angle(lfp_complex)
+        
+    elif method == 'hilbert':
+        if lowcut is None or highcut is None:
+            print("Lowcut and/or highcut were not defined, signal will not be filtered and will just take Hilbert transform for PPC1 calculation")
+            filtered_lfp = lfp_signal
+        else:
+            # Bandpass filter the signal
+            filtered_lfp = butter_bandpass_filter(lfp_signal, lowcut, highcut, lfp_fs)
+        
+        # Get phase using the Hilbert transform
+        analytic_signal = signal.hilbert(filtered_lfp)
+        instantaneous_phase = np.angle(analytic_signal)
+        
+    else:
+        raise ValueError("Invalid method. Choose 'wavelet' or 'hilbert'.")
+    
+    # Get phases at spike times
+    spike_phases = instantaneous_phase[valid_indices]
+    
+    # Calculate PPC1
+    n = len(spike_phases)
+    
+    # Convert phases to unit vectors in the complex plane
+    unit_vectors = np.exp(1j * spike_phases)
+    
+    # Calculate the resultant vector
+    resultant_vector = np.sum(unit_vectors)
+    
+    # Plv is the squared length of the resultant vector divided by n²
+    plv = (np.abs(resultant_vector) ** 2) / (n ** 2)
+    
+    return plv
+
+
+@numba.njit(parallel=True, fastmath=True)
+def _ppc_parallel_numba(spike_phases):
+    """Numba-optimized parallel PPC calculation"""
+    n = len(spike_phases)
+    sum_cos = 0.0
+    for i in numba.prange(n):
+        phase_i = spike_phases[i]
+        for j in range(i + 1, n):
+            sum_cos += np.cos(phase_i - spike_phases[j])
+    return (2 / (n * (n - 1))) * sum_cos
+
+
+@cuda.jit(fastmath=True)
+def _ppc_cuda_kernel(spike_phases, out):
+    i = cuda.grid(1)
+    if i < len(spike_phases):
+        local_sum = 0.0
+        for j in range(i+1, len(spike_phases)):
+            local_sum += np.cos(spike_phases[i] - spike_phases[j])
+        out[i] = local_sum
+
+
+def _ppc_gpu(spike_phases):
+    """GPU-accelerated implementation"""
+    d_phases = cuda.to_device(spike_phases)
+    d_out = cuda.device_array(len(spike_phases), dtype=np.float64)
+    
+    threads = 256
+    blocks = (len(spike_phases) + threads - 1) // threads
+    
+    _ppc_cuda_kernel[blocks, threads](d_phases, d_out)
+    total = d_out.copy_to_host().sum()
+    return (2/(len(spike_phases)*(len(spike_phases)-1))) * total
+
+
+def calculate_ppc(spike_times: np.ndarray = None, lfp_signal: np.ndarray = None, spike_fs: float = None,
+                  lfp_fs: float = None, method: str = 'hilbert', freq_of_interest: float = None,
+                  lowcut: float = None, highcut: float = None,
+                  bandwidth: float = 2.0,ppc_method: str = 'numpy') -> tuple:
+    """
+    Calculate Pairwise Phase Consistency (PPC) between spike times and LFP signal.
+    Based on https://www.sciencedirect.com/science/article/pii/S1053811910000959
+    
+    Parameters:
+    - spike_times: Array of spike times 
+    - lfp_signal: Local field potential time series
+    - spike_fs: Sampling frequency in Hz of the spike times only needed if spikes times and lfp has different fs
+    - lfp_fs: Sampling frequency in Hz of the LFP
+    - method: 'wavelet' or 'hilbert' to choose the phase extraction method
+    - freq_of_interest: Desired frequency for wavelet phase extraction
+    - lowcut, highcut: Cutoff frequencies for bandpass filtering (Hilbert method)
+    - bandwidth: Bandwidth parameter for the wavelet
+    - ppc_method: which algo to use for PPC calculate can be numpy, numba or gpu
+    
+    Returns:
+    - ppc: Pairwise Phase Consistency value
+    """
+    if spike_fs is None:
+        spike_fs = lfp_fs
+    # Convert spike times to sample indices
+    spike_times_seconds = spike_times / spike_fs
+
+    # Then convert from seconds to samples at the new sampling rate
+    spike_indices = np.round(spike_times_seconds * lfp_fs).astype(int)
+    
+    # Filter indices to ensure they're within bounds of the LFP signal
+    valid_indices = [idx for idx in spike_indices if 0 <= idx < len(lfp_signal)]
+    if len(valid_indices) <= 1:
+        return 0, np.array([])
+    
+    # Extract phase using the specified method
+    if method == 'wavelet':
+        if freq_of_interest is None:
+            raise ValueError("freq_of_interest must be provided for the wavelet method.")
+        
+        # Apply CWT to extract phase at the frequency of interest
+        lfp_complex = wavelet_filter(x=lfp_signal, freq=freq_of_interest, fs=lfp_fs, bandwidth=bandwidth)
+        instantaneous_phase = np.angle(lfp_complex)
+        
+    elif method == 'hilbert':
+        if lowcut is None or highcut is None:
+            print("Lowcut and/or highcut were not defined, signal will not be filtered and will just take Hilbert transform for PPC calculation")
+            filtered_lfp = lfp_signal
+        else:
+            # Bandpass filter the signal
+            filtered_lfp = butter_bandpass_filter(lfp_signal, lowcut, highcut, lfp_fs)
+        
+        # Get phase using the Hilbert transform
+        analytic_signal = signal.hilbert(filtered_lfp)
+        instantaneous_phase = np.angle(analytic_signal)
+        
+    else:
+        raise ValueError("Invalid method. Choose 'wavelet' or 'hilbert'.")
+    
+    # Get phases at spike times
+    spike_phases = instantaneous_phase[valid_indices]
+    
+    n_spikes = len(spike_phases)
+
+    # Calculate PPC (Pairwise Phase Consistency)
+    if n_spikes <= 1:
+        return 0, spike_phases
+    
+    # Explicit calculation of pairwise phase consistency
+    sum_cos_diff = 0.0
+    
+    # # Σᵢ Σⱼ₍ᵢ₊₁₎ f(θᵢ, θⱼ)
+    # for i in range(n_spikes - 1):  # For each spike i
+    #     for j in range(i + 1, n_spikes):  # For each spike j > i
+    #         # Calculate the phase difference between spikes i and j
+    #         phase_diff = spike_phases[i] - spike_phases[j]
+            
+    #         #f(θᵢ, θⱼ) = cos(θᵢ)cos(θⱼ) + sin(θᵢ)sin(θⱼ) can become #f(θᵢ, θⱼ) = cos(θᵢ - θⱼ)
+    #         cos_diff = np.cos(phase_diff)
+            
+    #         # Add to the sum
+    #         sum_cos_diff += cos_diff
+    
+    # # Calculate PPC according to the equation
+    # # PPC = (2 / (N(N-1))) * Σᵢ Σⱼ₍ᵢ₊₁₎ f(θᵢ, θⱼ)
+    # ppc = ((2 / (n_spikes * (n_spikes - 1))) * sum_cos_diff)
+    
+    # same as above (i think) but with vectorized computation and memory fixes so it wont take forever to run.
+    if ppc_method == 'numpy':
+        i, j = np.triu_indices(n_spikes, k=1)
+        phase_diff = spike_phases[i] - spike_phases[j]
+        sum_cos_diff = np.sum(np.cos(phase_diff))
+        ppc = ((2 / (n_spikes * (n_spikes - 1))) * sum_cos_diff)
+    elif ppc_method == 'numba':
+        ppc = _ppc_parallel_numba(spike_phases)
+    elif ppc_method == 'gpu':
+        ppc = _ppc_gpu(spike_phases)
+    else:
+        raise ExceptionType("Please use a supported ppc method currently that is numpy, numba or gpu")
+    return ppc
+
+    
+def calculate_ppc2(spike_times: np.ndarray = None, lfp_signal: np.ndarray = None, spike_fs: float = None,
+                  lfp_fs: float = None, method: str = 'hilbert', freq_of_interest: float = None,
+                  lowcut: float = None, highcut: float = None,
+                  bandwidth: float = 2.0) -> tuple:
+    """
+    # -----------------------------------------------------------------------------
+    # PPC2 Calculation (Vinck et al., 2010) 
+    # -----------------------------------------------------------------------------
+    # Equation(Original):
+    #   PPC = (2 / (n * (n - 1))) * sum(cos(φ_i - φ_j) for all i < j)
+    # Optimized Formula (Algebraically Equivalent):
+    #   PPC = (|sum(e^(i*φ_j))|^2 - n) / (n * (n - 1))
+    # -----------------------------------------------------------------------------
+        
+    Parameters:
+    - spike_times: Array of spike times 
+    - lfp_signal: Local field potential time series
+    - spike_fs: Sampling frequency in Hz of the spike times only needed if spikes times and lfp has different fs
+    - lfp_fs: Sampling frequency in Hz of the LFP
+    - method: 'wavelet' or 'hilbert' to choose the phase extraction method
+    - freq_of_interest: Desired frequency for wavelet phase extraction
+    - lowcut, highcut: Cutoff frequencies for bandpass filtering (Hilbert method)
+    - bandwidth: Bandwidth parameter for the wavelet
+    
+    Returns:
+    - ppc2: Pairwise Phase Consistency 2 value
+    """
+    
+    if spike_fs is None:
+        spike_fs = lfp_fs
+    # Convert spike times to sample indices
+    spike_times_seconds = spike_times / spike_fs
+
+    # Then convert from seconds to samples at the new sampling rate
+    spike_indices = np.round(spike_times_seconds * lfp_fs).astype(int)
+    
+    # Filter indices to ensure they're within bounds of the LFP signal
+    valid_indices = [idx for idx in spike_indices if 0 <= idx < len(lfp_signal)]
+    if len(valid_indices) <= 1:
+        return 0, np.array([])
+    
+    # Extract phase using the specified method
+    if method == 'wavelet':
+        if freq_of_interest is None:
+            raise ValueError("freq_of_interest must be provided for the wavelet method.")
+        
+        # Apply CWT to extract phase at the frequency of interest
+        lfp_complex = wavelet_filter(x=lfp_signal, freq=freq_of_interest, fs=lfp_fs, bandwidth=bandwidth)
+        instantaneous_phase = np.angle(lfp_complex)
+        
+    elif method == 'hilbert':
+        if lowcut is None or highcut is None:
+            print("Lowcut and/or highcut were not defined, signal will not be filtered and will just take Hilbert transform for PPC2 calculation")
+            filtered_lfp = lfp_signal
+        else:
+            # Bandpass filter the signal
+            filtered_lfp = butter_bandpass_filter(lfp_signal, lowcut, highcut, lfp_fs)
+        
+        # Get phase using the Hilbert transform
+        analytic_signal = signal.hilbert(filtered_lfp)
+        instantaneous_phase = np.angle(analytic_signal)
+        
+    else:
+        raise ValueError("Invalid method. Choose 'wavelet' or 'hilbert'.")
+    
+    # Get phases at spike times
+    spike_phases = instantaneous_phase[valid_indices]
+    
+    # Calculate PPC2 according to Vinck et al. (2010), Equation 6
+    n = len(spike_phases)
+    
+    if n <= 1:
+        return 0, spike_phases
+    
+    # Convert phases to unit vectors in the complex plane
+    unit_vectors = np.exp(1j * spike_phases)
+    
+    # Calculate the resultant vector
+    resultant_vector = np.sum(unit_vectors)
+    
+    # PPC2 = (|∑(e^(i*φ_j))|² - n) / (n * (n - 1))
+    ppc2 = (np.abs(resultant_vector)**2 - n) / (n * (n - 1))
+    
+    return ppc2
+
+
+def calculate_ppc_per_cell(spike_df: pd.DataFrame, lfp_signal: np.ndarray,
+                            spike_fs: float, lfp_fs:float,
+                            pop_names: List[str],freqs: List[float]) -> Dict[str, Dict[int, Dict[float, float]]]:
+    """
+    Calculate pairwise phase consistency (PPC) per neuron (cell) for specified frequencies across different populations.
+
+    This function computes the PPC for each neuron within the specified populations based on their spike times
+    and a single-channel local field potential (LFP) signal.
+
+    Args:
+        spike_df (pd.DataFrame): Spike dataframe use bmtool.analysis.load_spikes_to_df
+        lfp (xr.DataArray): xarray DataArray representing the LFP use bmtool.analysis.ecp_to_lfp
+        spike_fs (float): sampling rate of spikes BMTK default is 1000
+        lfp_fs (float): sampling rate of lfp 
+        pop_names (List[str]): List of population names (as strings) to compute PPC for. pop_names should be in spike_df
+        freqs (List[float]): List of frequencies (in Hz) at which to calculate PPC.
+
+    Returns:
+        Dict[str, Dict[int, Dict[float, float]]]: Nested dictionary where the structure is:
+            {
+                population_name: {
+                    node_id: {
+                        frequency: PPC value
+                    }
+                }
+            }
+            PPC values are floats representing the pairwise phase consistency at each frequency.
+    """
+    ppc_dict = {}
+    for pop in pop_names:
+        skip_count = 0
+        pop_spikes = spike_df[spike_df['pop_name'] == pop]
+        nodes = pop_spikes['node_ids'].unique()
+        ppc_dict[pop] = {}
+        print(f'Processing {pop} population')
+        for node in tqdm(nodes):
+            node_spikes = pop_spikes[pop_spikes['node_ids'] == node]
+            
+            # Skip nodes with less than or equal to 1 spike
+            if len(node_spikes) <= 1:
+                skip_count += 1
+                continue
+
+            ppc_dict[pop][node] = {}
+            for freq in freqs:
+                ppc = calculate_ppc2(
+                    node_spikes['timestamps'].values,
+                    lfp_signal,
+                    spike_fs=spike_fs,
+                    lfp_fs=lfp_fs,
+                    freq_of_interest=freq,
+                    method='wavelet'
+                )
+                ppc_dict[pop][node][freq] = ppc
+
+        print(f'Calculated PPC for {pop} population with {len(nodes)-skip_count} valid cells, skipped {skip_count} cells for lack of spikes')
+
+    return ppc_dict
+
+
+

{bmtool-0.6.9.23 → bmtool-0.6.9.25}/bmtool/analysis/lfp.py

@@ -11,8 +11,6 @@ import matplotlib.pyplot as plt
 from scipy import signal 
 import pywt
 from bmtool.bmplot import is_notebook
-import numba
-from numba import cuda
 import pandas as pd
 
 
@@ -295,360 +293,6 @@ def butter_bandpass_filter(data: np.ndarray, lowcut: float, highcut: float, fs:
     return x_a
 
 
-def calculate_signal_signal_plv(x1: np.ndarray, x2: np.ndarray, fs: float, freq_of_interest: float = None, 
-                  method: str = 'wavelet', lowcut: float = None, highcut: float = None, 
-                  bandwidth: float = 2.0) -> np.ndarray:
-    """
-    Calculate Phase Locking Value (PLV) between two signals using wavelet or Hilbert method.
-    
-    Parameters:
-    - x1, x2: Input signals (1D arrays, same length)
-    - fs: Sampling frequency
-    - freq_of_interest: Desired frequency for wavelet PLV calculation
-    - method: 'wavelet' or 'hilbert' to choose the PLV calculation method
-    - lowcut, highcut: Cutoff frequencies for the Hilbert method
-    - bandwidth: Bandwidth parameter for the wavelet
-    
-    Returns:
-    - plv: Phase Locking Value (1D array)
-    """
-    if len(x1) != len(x2):
-        raise ValueError("Input signals must have the same length.")
-    
-    if method == 'wavelet':
-        if freq_of_interest is None:
-            raise ValueError("freq_of_interest must be provided for the wavelet method.")
-        
-        # Apply CWT to both signals
-        theta1 = wavelet_filter(x=x1, freq=freq_of_interest, fs=fs, bandwidth=bandwidth)
-        theta2 = wavelet_filter(x=x2, freq=freq_of_interest, fs=fs, bandwidth=bandwidth)
-    
-    elif method == 'hilbert':
-        if lowcut is None or highcut is None:
-            print("Lowcut and or highcut were not definded, signal will not be filter and just take hilbert transform for plv calc")
-        
-        if lowcut and highcut:
-            # Bandpass filter and get the analytic signal using the Hilbert transform
-            x1 = butter_bandpass_filter(x1, lowcut, highcut, fs)
-            x2 = butter_bandpass_filter(x2, lowcut, highcut, fs)
-        
-        # Get phase using the Hilbert transform
-        theta1 = signal.hilbert(x1)
-        theta2 = signal.hilbert(x2)
-    
-    else:
-        raise ValueError("Invalid method. Choose 'wavelet' or 'hilbert'.")
-    
-    # Calculate phase difference
-    phase_diff = np.angle(theta1) - np.angle(theta2)
-    
-    # Calculate PLV from standard equation from Measuring phase synchrony in brain signals(1999)
-    plv = np.abs(np.mean(np.exp(1j * phase_diff), axis=-1))
-    
-    return plv
-
-
-def calculate_spike_lfp_plv(spike_times: np.ndarray = None, lfp_signal: np.ndarray = None, spike_fs : float = None,
-                   lfp_fs: float = None, method: str = 'hilbert', freq_of_interest: float = None,
-                   lowcut: float = None, highcut: float = None,
-                   bandwidth: float = 2.0) -> tuple:
-    """
-    Calculate spike-lfp phase locking value Based on https://www.sciencedirect.com/science/article/pii/S1053811910000959
-    
-    Parameters:
-    - spike_times: Array of spike times 
-    - lfp_signal: Local field potential time series
-    - spike_fs: Sampling frequency in Hz of the spike times only needed if spikes times and lfp has different fs
-    - lfp_fs : Sampling frequency in Hz of the LFP
-    - method: 'wavelet' or 'hilbert' to choose the phase extraction method
-    - freq_of_interest: Desired frequency for wavelet phase extraction
-    - lowcut, highcut: Cutoff frequencies for bandpass filtering (Hilbert method)
-    - bandwidth: Bandwidth parameter for the wavelet
-    
-    Returns:
-    - ppc1: Phase-Phase Coupling value
-    - spike_phases: Phases at spike times
-    """
-    
-    if spike_fs == None:
-        spike_fs = lfp_fs
-    # Convert spike times to sample indices
-    spike_times_seconds = spike_times / spike_fs
-
-    # Then convert from seconds to samples at the new sampling rate
-    spike_indices = np.round(spike_times_seconds * lfp_fs).astype(int)
-    
-    # Filter indices to ensure they're within bounds of the LFP signal
-    valid_indices = [idx for idx in spike_indices if 0 <= idx < len(lfp_signal)]
-    if len(valid_indices) <= 1:
-        return 0, np.array([])
-    
-    # Extract phase using the specified method
-    if method == 'wavelet':
-        if freq_of_interest is None:
-            raise ValueError("freq_of_interest must be provided for the wavelet method.")
-        
-        # Apply CWT to extract phase at the frequency of interest
-        lfp_complex = wavelet_filter(x=lfp_signal, freq=freq_of_interest, fs=lfp_fs, bandwidth=bandwidth)
-        instantaneous_phase = np.angle(lfp_complex)
-        
-    elif method == 'hilbert':
-        if lowcut is None or highcut is None:
-            print("Lowcut and/or highcut were not defined, signal will not be filtered and will just take Hilbert transform for PPC1 calculation")
-            filtered_lfp = lfp_signal
-        else:
-            # Bandpass filter the signal
-            filtered_lfp = butter_bandpass_filter(lfp_signal, lowcut, highcut, lfp_fs)
-        
-        # Get phase using the Hilbert transform
-        analytic_signal = signal.hilbert(filtered_lfp)
-        instantaneous_phase = np.angle(analytic_signal)
-        
-    else:
-        raise ValueError("Invalid method. Choose 'wavelet' or 'hilbert'.")
-    
-    # Get phases at spike times
-    spike_phases = instantaneous_phase[valid_indices]
-    
-    # Calculate PPC1
-    n = len(spike_phases)
-    
-    # Convert phases to unit vectors in the complex plane
-    unit_vectors = np.exp(1j * spike_phases)
-    
-    # Calculate the resultant vector
-    resultant_vector = np.sum(unit_vectors)
-    
-    # Plv is the squared length of the resultant vector divided by n²
-    plv = (np.abs(resultant_vector) ** 2) / (n ** 2)
-    
-    return plv
-
-
-@numba.njit(parallel=True, fastmath=True)
-def _ppc_parallel_numba(spike_phases):
-    """Numba-optimized parallel PPC calculation"""
-    n = len(spike_phases)
-    sum_cos = 0.0
-    for i in numba.prange(n):
-        phase_i = spike_phases[i]
-        for j in range(i + 1, n):
-            sum_cos += np.cos(phase_i - spike_phases[j])
-    return (2 / (n * (n - 1))) * sum_cos
-
-
-@cuda.jit(fastmath=True)
-def _ppc_cuda_kernel(spike_phases, out):
-    i = cuda.grid(1)
-    if i < len(spike_phases):
-        local_sum = 0.0
-        for j in range(i+1, len(spike_phases)):
-            local_sum += np.cos(spike_phases[i] - spike_phases[j])
-        out[i] = local_sum
-
-
-def _ppc_gpu(spike_phases):
-    """GPU-accelerated implementation"""
-    d_phases = cuda.to_device(spike_phases)
-    d_out = cuda.device_array(len(spike_phases), dtype=np.float64)
-    
-    threads = 256
-    blocks = (len(spike_phases) + threads - 1) // threads
-    
-    _ppc_cuda_kernel[blocks, threads](d_phases, d_out)
-    total = d_out.copy_to_host().sum()
-    return (2/(len(spike_phases)*(len(spike_phases)-1))) * total
-
-
-def calculate_ppc(spike_times: np.ndarray = None, lfp_signal: np.ndarray = None, spike_fs: float = None,
-                  lfp_fs: float = None, method: str = 'hilbert', freq_of_interest: float = None,
-                  lowcut: float = None, highcut: float = None,
-                  bandwidth: float = 2.0,ppc_method: str = 'numpy') -> tuple:
-    """
-    Calculate Pairwise Phase Consistency (PPC) between spike times and LFP signal.
-    Based on https://www.sciencedirect.com/science/article/pii/S1053811910000959
-    
-    Parameters:
-    - spike_times: Array of spike times 
-    - lfp_signal: Local field potential time series
-    - spike_fs: Sampling frequency in Hz of the spike times only needed if spikes times and lfp has different fs
-    - lfp_fs: Sampling frequency in Hz of the LFP
-    - method: 'wavelet' or 'hilbert' to choose the phase extraction method
-    - freq_of_interest: Desired frequency for wavelet phase extraction
-    - lowcut, highcut: Cutoff frequencies for bandpass filtering (Hilbert method)
-    - bandwidth: Bandwidth parameter for the wavelet
-    - ppc_method: which algo to use for PPC calculate can be numpy, numba or gpu
-    
-    Returns:
-    - ppc: Pairwise Phase Consistency value
-    """
-    if spike_fs is None:
-        spike_fs = lfp_fs
-    # Convert spike times to sample indices
-    spike_times_seconds = spike_times / spike_fs
-
-    # Then convert from seconds to samples at the new sampling rate
-    spike_indices = np.round(spike_times_seconds * lfp_fs).astype(int)
-    
-    # Filter indices to ensure they're within bounds of the LFP signal
-    valid_indices = [idx for idx in spike_indices if 0 <= idx < len(lfp_signal)]
-    if len(valid_indices) <= 1:
-        return 0, np.array([])
-    
-    # Extract phase using the specified method
-    if method == 'wavelet':
-        if freq_of_interest is None:
-            raise ValueError("freq_of_interest must be provided for the wavelet method.")
-        
-        # Apply CWT to extract phase at the frequency of interest
-        lfp_complex = wavelet_filter(x=lfp_signal, freq=freq_of_interest, fs=lfp_fs, bandwidth=bandwidth)
-        instantaneous_phase = np.angle(lfp_complex)
-        
-    elif method == 'hilbert':
-        if lowcut is None or highcut is None:
-            print("Lowcut and/or highcut were not defined, signal will not be filtered and will just take Hilbert transform for PPC calculation")
-            filtered_lfp = lfp_signal
-        else:
-            # Bandpass filter the signal
-            filtered_lfp = butter_bandpass_filter(lfp_signal, lowcut, highcut, lfp_fs)
-        
-        # Get phase using the Hilbert transform
-        analytic_signal = signal.hilbert(filtered_lfp)
-        instantaneous_phase = np.angle(analytic_signal)
-        
-    else:
-        raise ValueError("Invalid method. Choose 'wavelet' or 'hilbert'.")
-    
-    # Get phases at spike times
-    spike_phases = instantaneous_phase[valid_indices]
-    
-    n_spikes = len(spike_phases)
-
-    # Calculate PPC (Pairwise Phase Consistency)
-    if n_spikes <= 1:
-        return 0, spike_phases
-    
-    # Explicit calculation of pairwise phase consistency
-    sum_cos_diff = 0.0
-    
-    # # Σᵢ Σⱼ₍ᵢ₊₁₎ f(θᵢ, θⱼ)
-    # for i in range(n_spikes - 1):  # For each spike i
-    #     for j in range(i + 1, n_spikes):  # For each spike j > i
-    #         # Calculate the phase difference between spikes i and j
-    #         phase_diff = spike_phases[i] - spike_phases[j]
-            
-    #         #f(θᵢ, θⱼ) = cos(θᵢ)cos(θⱼ) + sin(θᵢ)sin(θⱼ) can become #f(θᵢ, θⱼ) = cos(θᵢ - θⱼ)
-    #         cos_diff = np.cos(phase_diff)
-            
-    #         # Add to the sum
-    #         sum_cos_diff += cos_diff
-    
-    # # Calculate PPC according to the equation
-    # # PPC = (2 / (N(N-1))) * Σᵢ Σⱼ₍ᵢ₊₁₎ f(θᵢ, θⱼ)
-    # ppc = ((2 / (n_spikes * (n_spikes - 1))) * sum_cos_diff)
-    
-    # same as above (i think) but with vectorized computation and memory fixes so it wont take forever to run.
-    if ppc_method == 'numpy':
-        i, j = np.triu_indices(n_spikes, k=1)
-        phase_diff = spike_phases[i] - spike_phases[j]
-        sum_cos_diff = np.sum(np.cos(phase_diff))
-        ppc = ((2 / (n_spikes * (n_spikes - 1))) * sum_cos_diff)
-    elif ppc_method == 'numba':
-        ppc = _ppc_parallel_numba(spike_phases)
-    elif ppc_method == 'gpu':
-        ppc = _ppc_gpu(spike_phases)
-    else:
-        raise ExceptionType("Please use a supported ppc method currently that is numpy, numba or gpu")
-    return ppc
-
-    
-def calculate_ppc2(spike_times: np.ndarray = None, lfp_signal: np.ndarray = None, spike_fs: float = None,
-                  lfp_fs: float = None, method: str = 'hilbert', freq_of_interest: float = None,
-                  lowcut: float = None, highcut: float = None,
-                  bandwidth: float = 2.0) -> tuple:
-    """
-    # -----------------------------------------------------------------------------
-    # PPC2 Calculation (Vinck et al., 2010) 
-    # -----------------------------------------------------------------------------
-    # Equation(Original):
-    #   PPC = (2 / (n * (n - 1))) * sum(cos(φ_i - φ_j) for all i < j)
-    # Optimized Formula (Algebraically Equivalent):
-    #   PPC = (|sum(e^(i*φ_j))|^2 - n) / (n * (n - 1))
-    # -----------------------------------------------------------------------------
-        
-    Parameters:
-    - spike_times: Array of spike times 
-    - lfp_signal: Local field potential time series
-    - spike_fs: Sampling frequency in Hz of the spike times only needed if spikes times and lfp has different fs
-    - lfp_fs: Sampling frequency in Hz of the LFP
-    - method: 'wavelet' or 'hilbert' to choose the phase extraction method
-    - freq_of_interest: Desired frequency for wavelet phase extraction
-    - lowcut, highcut: Cutoff frequencies for bandpass filtering (Hilbert method)
-    - bandwidth: Bandwidth parameter for the wavelet
-    
-    Returns:
-    - ppc2: Pairwise Phase Consistency 2 value
-    - spike_phases: Phases at spike times
-    """
-    
-    if spike_fs is None:
-        spike_fs = lfp_fs
-    # Convert spike times to sample indices
-    spike_times_seconds = spike_times / spike_fs
-
-    # Then convert from seconds to samples at the new sampling rate
-    spike_indices = np.round(spike_times_seconds * lfp_fs).astype(int)
-    
-    # Filter indices to ensure they're within bounds of the LFP signal
-    valid_indices = [idx for idx in spike_indices if 0 <= idx < len(lfp_signal)]
-    if len(valid_indices) <= 1:
-        return 0, np.array([])
-    
-    # Extract phase using the specified method
-    if method == 'wavelet':
-        if freq_of_interest is None:
-            raise ValueError("freq_of_interest must be provided for the wavelet method.")
-        
-        # Apply CWT to extract phase at the frequency of interest
-        lfp_complex = wavelet_filter(x=lfp_signal, freq=freq_of_interest, fs=lfp_fs, bandwidth=bandwidth)
-        instantaneous_phase = np.angle(lfp_complex)
-        
-    elif method == 'hilbert':
-        if lowcut is None or highcut is None:
-            print("Lowcut and/or highcut were not defined, signal will not be filtered and will just take Hilbert transform for PPC2 calculation")
-            filtered_lfp = lfp_signal
-        else:
-            # Bandpass filter the signal
-            filtered_lfp = butter_bandpass_filter(lfp_signal, lowcut, highcut, lfp_fs)
-        
-        # Get phase using the Hilbert transform
-        analytic_signal = signal.hilbert(filtered_lfp)
-        instantaneous_phase = np.angle(analytic_signal)
-        
-    else:
-        raise ValueError("Invalid method. Choose 'wavelet' or 'hilbert'.")
-    
-    # Get phases at spike times
-    spike_phases = instantaneous_phase[valid_indices]
-    
-    # Calculate PPC2 according to Vinck et al. (2010), Equation 6
-    n = len(spike_phases)
-    
-    if n <= 1:
-        return 0, spike_phases
-    
-    # Convert phases to unit vectors in the complex plane
-    unit_vectors = np.exp(1j * spike_phases)
-    
-    # Calculate the resultant vector
-    resultant_vector = np.sum(unit_vectors)
-    
-    # PPC2 = (|∑(e^(i*φ_j))|² - n) / (n * (n - 1))
-    ppc2 = (np.abs(resultant_vector)**2 - n) / (n * (n - 1))
-    
-    return ppc2
-
-
 # windowing functions 
 def windowed_xarray(da, windows, dim='time',
                     new_coord_name='cycle', new_coord=None):

{bmtool-0.6.9.23 → bmtool-0.6.9.25}/bmtool/analysis/spikes.py

@@ -7,6 +7,7 @@ import pandas as pd
 from bmtool.util.util import load_nodes_from_config
 from typing import Dict, Optional,Tuple, Union, List
 import numpy as np
+from scipy.stats import mannwhitneyu
 import os
 
 
@@ -252,3 +253,55 @@ def get_population_spike_rate(spikes: pd.DataFrame, fs: float = 400.0, t_start:
 
     return spike_rate
 
+
+def compare_firing_over_times(spike_df,group_by, time_window_1, time_window_2):
+    """
+    Compares the firing rates of a population during two different time windows
+    time_window_1 and time_window_2 should be a list of [start, stop] in milliseconds
+    Returns firing rates and results of a Mann-Whitney U test (non-parametric)
+    """
+    # Filter spikes for the population of interest
+    for pop_name in spike_df[group_by].unique():
+        print(f"Population: {pop_name}")
+        pop_spikes = spike_df[spike_df[group_by] == pop_name]
+        
+        # Filter by time windows
+        pop_spikes_1 = pop_spikes[(pop_spikes['timestamps'] >= time_window_1[0]) & (pop_spikes['timestamps'] <= time_window_1[1])]
+        pop_spikes_2 = pop_spikes[(pop_spikes['timestamps'] >= time_window_2[0]) & (pop_spikes['timestamps'] <= time_window_2[1])]
+        
+        # Get unique neuron IDs
+        unique_neurons = pop_spikes['node_ids'].unique()
+        
+        # Calculate firing rates per neuron for each time window in Hz
+        neuron_rates_1 = []
+        neuron_rates_2 = []
+        
+        for neuron in unique_neurons:
+            # Count spikes for this neuron in each window
+            n_spikes_1 = len(pop_spikes_1[pop_spikes_1['node_ids'] == neuron])
+            n_spikes_2 = len(pop_spikes_2[pop_spikes_2['node_ids'] == neuron])
+            
+            # Calculate firing rate in Hz (convert ms to seconds by dividing by 1000)
+            rate_1 = n_spikes_1 / ((time_window_1[1] - time_window_1[0]) / 1000)
+            rate_2 = n_spikes_2 / ((time_window_2[1] - time_window_2[0]) / 1000)
+            
+            neuron_rates_1.append(rate_1)
+            neuron_rates_2.append(rate_2)
+        
+        # Calculate average firing rates
+        avg_firing_rate_1 = np.mean(neuron_rates_1) if neuron_rates_1 else 0
+        avg_firing_rate_2 = np.mean(neuron_rates_2) if neuron_rates_2 else 0
+        
+        # Perform Mann-Whitney U test
+        # Handle the case when one or both arrays are empty
+        if len(neuron_rates_1) > 0 and len(neuron_rates_2) > 0:
+            u_stat, p_val = mannwhitneyu(neuron_rates_1, neuron_rates_2, alternative='two-sided')
+        else:
+            u_stat, p_val = np.nan, np.nan
+
+        print(f"    Average firing rate in window 1: {avg_firing_rate_1:.2f} Hz")
+        print(f"    Average firing rate in window 2: {avg_firing_rate_2:.2f} Hz")
+        print(f"    U-statistic: {u_stat:.2f}")
+        print(f"    p-value: {p_val}")
+        print(f"    Significant difference (p<0.05): {'Yes' if p_val < 0.05 else 'No'}")
+    return

{bmtool-0.6.9.23 → bmtool-0.6.9.25}/bmtool/bmplot.py

@@ -23,8 +23,9 @@ import sys
 import re
 from typing import Optional, Dict, Union, List
 
-from .util.util import CellVarsFile,load_nodes_from_config #, missing_units
+from .util.util import CellVarsFile,load_nodes_from_config,load_templates_from_config #, missing_units
 from bmtk.analyzer.utils import listify
+from neuron import h
 
 use_description = """
 
@@ -682,6 +683,155 @@ def edge_histogram_matrix(config=None,sources = None,targets=None,sids=None,tids
     fig.text(0.04, 0.5, 'Source', va='center', rotation='vertical')
     plt.draw()
 
+def distance_delay_plot(simulation_config: str,source: str,target: str,
+    group_by: str,sid: str,tid: str) -> None:
+    """
+    Plots the relationship between the distance and delay of connections between nodes in a neural network simulation.
+
+    This function loads the node and edge data from a simulation configuration file, filters nodes by population or group,
+    identifies connections (edges) between source and target node populations, calculates the Euclidean distance between
+    connected nodes, and plots the delay as a function of distance.
+
+    Args:
+        simulation_config (str): Path to the simulation config file
+        source (str): The name of the source population in the edge data.
+        target (str): The name of the target population in the edge data.
+        group_by (str): Column name to group nodes by (e.g., population name).
+        sid (str): Identifier for the source group (e.g., 'PN').
+        tid (str): Identifier for the target group (e.g., 'PN').
+
+    Returns:
+        None: The function creates and displays a scatter plot of distance vs delay.
+    """
+    nodes, edges = util.load_nodes_edges_from_config(simulation_config)
+    nodes = nodes[target]
+    #node id is index of nodes df
+    node_id_source = nodes[nodes[group_by] == sid].index
+    node_id_target = nodes[nodes[group_by] == tid].index
+
+    edges = edges[f'{source}_to_{target}']
+    edges = edges[edges['source_node_id'].isin(node_id_source) & edges['target_node_id'].isin(node_id_target)]
+
+    stuff_to_plot = []
+    for index, row in edges.iterrows():
+        try:
+            source_node = row['source_node_id']
+            target_node = row['target_node_id']
+            
+            source_pos = nodes.loc[[source_node], ['pos_x', 'pos_y', 'pos_z']]
+            target_pos = nodes.loc[[target_node], ['pos_x', 'pos_y', 'pos_z']]
+            
+            distance = np.linalg.norm(source_pos.values - target_pos.values)
+
+            delay = row['delay']  # This line may raise KeyError
+            stuff_to_plot.append([distance, delay])
+
+        except KeyError as e:
+            print(f"KeyError: Missing key {e} in either edge properties or node positions.")
+        except IndexError as e:
+            print(f"IndexError: Node ID {source_node} or {target_node} not found in nodes.")
+        except Exception as e:
+            print(f"Unexpected error at edge index {index}: {e}")
+
+    plt.scatter([x[0] for x in stuff_to_plot], [x[1] for x in stuff_to_plot])
+    plt.xlabel('Distance')
+    plt.ylabel('Delay')
+    plt.title(f'Distance vs Delay for edge between {sid} and {tid}')
+    plt.show()
+
+def plot_synapse_location_histograms(config, target_model, source=None, target=None):
+    """
+    generates a histogram of the positions of the synapses on a cell broken down by section
+    config: a BMTK config
+    target_model: the name of the model_template used when building the BMTK node
+    source: The source BMTK network 
+    target: The target BMTK network
+    """
+    # Load mechanisms and template
+
+    util.load_templates_from_config(config)
+
+    # Load node and edge data
+    nodes, edges = util.load_nodes_edges_from_config(config)
+    nodes = nodes[source]
+    edges = edges[f'{source}_to_{target}']
+
+    # Map target_node_id to model_template
+    edges['target_model_template'] = edges['target_node_id'].map(nodes['model_template'])
+
+    # Map source_node_id to pop_name
+    edges['source_pop_name'] = edges['source_node_id'].map(nodes['pop_name'])
+
+    edges = edges[edges['target_model_template'] == target_model]
+
+    # Create the cell model from target model
+    cell = getattr(h, target_model.split(':')[1])()
+ 
+    # Create a mapping from section index to section name
+    section_id_to_name = {}
+    for idx, sec in enumerate(cell.all):
+        section_id_to_name[idx] = sec.name()
+
+    # Add a new column with section names based on afferent_section_id
+    edges['afferent_section_name'] = edges['afferent_section_id'].map(section_id_to_name)
+
+    # Get unique sections and source populations
+    unique_pops = edges['source_pop_name'].unique()
+
+    # Filter to only include sections with data
+    section_counts = edges['afferent_section_name'].value_counts()
+    sections_with_data = section_counts[section_counts > 0].index.tolist()
+
+
+    # Create a figure with subplots for each section
+    plt.figure(figsize=(8,12))
+
+    # Color map for source populations
+    color_map = plt.cm.tab10(np.linspace(0, 1, len(unique_pops)))
+    pop_colors = {pop: color for pop, color in zip(unique_pops, color_map)}
+
+    # Create a histogram for each section
+    for i, section in enumerate(sections_with_data):
+        ax = plt.subplot(len(sections_with_data), 1, i+1)
+        
+        # Get data for this section
+        section_data = edges[edges['afferent_section_name'] == section]
+        
+        # Group by source population
+        for pop_name, pop_group in section_data.groupby('source_pop_name'):
+            if len(pop_group) > 0:
+                ax.hist(pop_group['afferent_section_pos'], bins=15, alpha=0.7, 
+                    label=pop_name, color=pop_colors[pop_name])
+        
+        # Set title and labels
+        ax.set_title(f"{section}", fontsize=10)
+        ax.set_xlabel('Section Position', fontsize=8)
+        ax.set_ylabel('Frequency', fontsize=8)
+        ax.tick_params(labelsize=7)
+        ax.grid(True, alpha=0.3)
+        
+        # Only add legend to the first plot
+        if i == 0:
+            ax.legend(fontsize=8)
+
+    plt.tight_layout()
+    plt.suptitle('Connection Distribution by Cell Section and Source Population', fontsize=16, y=1.02)
+    if is_notebook:
+        plt.show()
+    else:
+        pass
+
+    # Create a summary table
+    print("Summary of connections by section and source population:")
+    pivot_table = edges.pivot_table(
+        values='afferent_section_id', 
+        index='afferent_section_name',
+        columns='source_pop_name',
+        aggfunc='count',
+        fill_value=0
+    )
+    print(pivot_table)
+
 def plot_connection_info(text, num, source_labels, target_labels, title, syn_info='0', save_file=None, return_dict=None):
     """
     Function to plot connection information as a heatmap, including handling missing source and target values.

{bmtool-0.6.9.23 → bmtool-0.6.9.25}/bmtool/synapses.py

@@ -647,7 +647,7 @@ class SynapseTuner:
         # Widgets setup (Sliders)
         freqs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 35, 50, 100, 200]
         delays = [125, 250, 500, 1000, 2000, 4000]
-        durations = [300, 500, 1000, 2000, 5000, 10000]
+        durations = [100, 300, 500, 1000, 2000, 5000, 10000]
         freq0 = 50
         delay0 = 250
         duration0 = 300

{bmtool-0.6.9.23 → bmtool-0.6.9.25}/bmtool/util/util.py

@@ -6,6 +6,8 @@ import numpy as np
 from numpy import genfromtxt
 import h5py
 import pandas as pd
+import neuron
+from neuron import h
 
 #from bmtk.utils.io.cell_vars import CellVarsFile
 #from bmtk.analyzer.cell_vars import _get_cell_report
@@ -392,6 +394,32 @@ def load_edges_from_paths(edge_paths):#network_dir='network'):
     
     return edges_dict
 
+def load_mechanisms_from_config(config=None):
+    """
+    loads neuron mechanisms from BMTK config
+    """
+    if config is None:
+        config = 'simulation_config.json'
+    config = load_config(config)
+    return neuron.load_mechanisms(config['components']['mechanisms_dir'])
+
+def load_templates_from_config(config=None):
+    if config is None:
+        config = 'simulation_config.json'
+    config = load_config(config)
+    load_mechanisms_from_config(config)
+    return load_templates_from_paths(config['components']['templates_dir'])
+
+def load_templates_from_paths(template_paths):
+    # load all the files in the templates dir
+    for item in os.listdir(template_paths):
+        item_path = os.path.join(template_paths, item)
+        if os.path.isfile(item_path):
+            print(f"loading {item_path}")
+            h.load_file(item_path)
+
+    
+
 def cell_positions_by_id(config=None, nodes=None, populations=[], popids=[], prepend_pop=True):
     """
     Returns a dictionary of arrays of arrays {"population_popid":[[1,2,3],[1,2,4]],...

{bmtool-0.6.9.23 → bmtool-0.6.9.25}/bmtool.egg-info/PKG-INFO

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

{bmtool-0.6.9.23 → bmtool-0.6.9.25}/bmtool.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ bmtool.egg-info/entry_points.txt
 bmtool.egg-info/requires.txt
 bmtool.egg-info/top_level.txt
 bmtool/analysis/__init__.py
+bmtool/analysis/entrainment.py
 bmtool/analysis/lfp.py
 bmtool/analysis/netcon_reports.py
 bmtool/analysis/spikes.py

{bmtool-0.6.9.23 → bmtool-0.6.9.25}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name="bmtool",
-    version='0.6.9.23',
+    version='0.6.9.25',
     author="Neural Engineering Laboratory at the University of Missouri",
     author_email="gregglickert@mail.missouri.edu",
     description="BMTool",