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

bmtool/analysis/entrainment.py

@@ -2,7 +2,7 @@
 Module for entrainment analysis
 """
 
-from typing import Dict, List
+from typing import Dict, List, Optional, Union
 
 import numba
 import numpy as np
@@ -41,7 +41,7 @@ def align_spike_times_with_lfp(lfp: xr.DataArray, timestamps: np.ndarray) -> np.
         (timestamps >= lfp.time.values[0]) & (timestamps <= lfp.time.values[-1])
     ].copy()
     # set the time axis of the spikes to match the lfp
-    timestamps = timestamps - lfp.time.values[0]
+    # timestamps = timestamps - lfp.time.values[0]
     return timestamps
 
 
@@ -127,33 +127,33 @@ def calculate_signal_signal_plv(
     return plv
 
 
-def calculate_spike_lfp_plv(
-    spike_times: np.ndarray = None,
-    lfp_data=None,
-    spike_fs: float = None,
-    lfp_fs: float = None,
-    filter_method: str = "butter",
-    freq_of_interest: float = None,
-    lowcut: float = None,
-    highcut: float = None,
+def _get_spike_phases(
+    spike_times: np.ndarray,
+    lfp_data: Union[np.ndarray, xr.DataArray],
+    spike_fs: float,
+    lfp_fs: float,
+    filter_method: str = "wavelet",
+    freq_of_interest: Optional[float] = None,
+    lowcut: Optional[float] = None,
+    highcut: Optional[float] = None,
     bandwidth: float = 2.0,
-    filtered_lfp_phase: np.ndarray = None,
-) -> float:
+    filtered_lfp_phase: Optional[Union[np.ndarray, xr.DataArray]] = None,
+) -> np.ndarray:
     """
-    Calculate spike-lfp unbiased phase locking value
+    Helper function to get spike phases from LFP data.
 
     Parameters
     ----------
     spike_times : np.ndarray
         Array of spike times
-    lfp_data : np.ndarray
+    lfp_data : Union[np.ndarray, xr.DataArray]
         Local field potential time series data. Not required if filtered_lfp_phase is provided.
-    spike_fs : float, optional
-        Sampling frequency in Hz of the spike times, only needed if spike times and LFP have different sampling rates
+    spike_fs : float
+        Sampling frequency in Hz of the spike times
     lfp_fs : float
         Sampling frequency in Hz of the LFP data
     filter_method : str, optional
-        Method to use for filtering, either 'wavelet' or 'butter' (default: 'butter')
+        Method to use for filtering, either 'wavelet' or 'butter' (default: 'wavelet')
     freq_of_interest : float, optional
         Desired frequency for wavelet phase extraction, required if filter_method='wavelet'
     lowcut : float, optional
@@ -167,12 +167,9 @@ def calculate_spike_lfp_plv(
 
     Returns
     -------
-    float
-        Phase Locking Value (unbiased)
+    np.ndarray
+        Array of 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
 
@@ -180,10 +177,21 @@ def calculate_spike_lfp_plv(
     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 = align_spike_times_with_lfp(lfp=lfp_data, timestamps=spike_indices)
+    if isinstance(lfp_data, xr.DataArray):
+        if filtered_lfp_phase is not None:
+            valid_indices = align_spike_times_with_lfp(
+                lfp=filtered_lfp_phase, timestamps=spike_indices
+            )
+        else:
+            valid_indices = align_spike_times_with_lfp(lfp=lfp_data, timestamps=spike_indices)
+    elif isinstance(lfp_data, np.ndarray):
+        if filtered_lfp_phase is not None:
+            valid_indices = [idx for idx in spike_indices if 0 <= idx < len(filtered_lfp_phase)]
+        else:
+            valid_indices = [idx for idx in spike_indices if 0 <= idx < len(lfp_data)]
 
     if len(valid_indices) <= 1:
-        return 0
+        return np.array([])
 
     # Get instantaneous phase
     if filtered_lfp_phase is None:
@@ -200,7 +208,73 @@ def calculate_spike_lfp_plv(
         instantaneous_phase = filtered_lfp_phase
 
     # Get phases at spike times
-    spike_phases = instantaneous_phase.sel(time=valid_indices).values
+    if isinstance(instantaneous_phase, xr.DataArray):
+        spike_phases = instantaneous_phase.sel(time=valid_indices, method="nearest").values
+    else:
+        spike_phases = instantaneous_phase[valid_indices]
+
+    return spike_phases
+
+
+def calculate_spike_lfp_plv(
+    spike_times: np.ndarray = None,
+    lfp_data=None,
+    spike_fs: float = None,
+    lfp_fs: float = None,
+    filter_method: str = "butter",
+    freq_of_interest: float = None,
+    lowcut: float = None,
+    highcut: float = None,
+    bandwidth: float = 2.0,
+    filtered_lfp_phase: np.ndarray = None,
+) -> float:
+    """
+    Calculate spike-lfp unbiased phase locking value
+
+    Parameters
+    ----------
+    spike_times : np.ndarray
+        Array of spike times
+    lfp_data : np.ndarray
+        Local field potential time series data. Not required if filtered_lfp_phase is provided.
+    spike_fs : float, optional
+        Sampling frequency in Hz of the spike times, only needed if spike times and LFP have different sampling rates
+    lfp_fs : float
+        Sampling frequency in Hz of the LFP data
+    filter_method : str, optional
+        Method to use for filtering, either 'wavelet' or 'butter' (default: 'butter')
+    freq_of_interest : float, optional
+        Desired frequency for wavelet phase extraction, required if filter_method='wavelet'
+    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'
+    bandwidth : float, optional
+        Bandwidth parameter for wavelet filter when method='wavelet' (default: 2.0)
+    filtered_lfp_phase : np.ndarray, optional
+        Pre-computed instantaneous phase of the filtered LFP. If provided, the function will skip the filtering step.
+
+    Returns
+    -------
+    float
+        Phase Locking Value (unbiased)
+    """
+
+    spike_phases = _get_spike_phases(
+        spike_times=spike_times,
+        lfp_data=lfp_data,
+        spike_fs=spike_fs,
+        lfp_fs=lfp_fs,
+        filter_method=filter_method,
+        freq_of_interest=freq_of_interest,
+        lowcut=lowcut,
+        highcut=highcut,
+        bandwidth=bandwidth,
+        filtered_lfp_phase=filtered_lfp_phase,
+    )
+
+    if len(spike_phases) <= 1:
+        return 0
 
     # Number of spikes
     N = len(spike_phases)
@@ -302,46 +376,26 @@ def calculate_ppc(
     float
         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
-    if filtered_lfp_phase is not None:
-        valid_indices = align_spike_times_with_lfp(lfp=filtered_lfp_phase, timestamps=spike_indices)
-    else:
-        valid_indices = align_spike_times_with_lfp(lfp=lfp_data, timestamps=spike_indices)
-
-    if len(valid_indices) <= 1:
+    spike_phases = _get_spike_phases(
+        spike_times=spike_times,
+        lfp_data=lfp_data,
+        spike_fs=spike_fs,
+        lfp_fs=lfp_fs,
+        filter_method=filter_method,
+        freq_of_interest=freq_of_interest,
+        lowcut=lowcut,
+        highcut=highcut,
+        bandwidth=bandwidth,
+        filtered_lfp_phase=filtered_lfp_phase,
+    )
+
+    if len(spike_phases) <= 1:
         return 0
 
-    # Get instantaneous phase
-    if filtered_lfp_phase is None:
-        instantaneous_phase = get_lfp_phase(
-            lfp_data=lfp_data,
-            filter_method=filter_method,
-            freq_of_interest=freq_of_interest,
-            lowcut=lowcut,
-            highcut=highcut,
-            bandwidth=bandwidth,
-            fs=lfp_fs,
-        )
-    else:
-        instantaneous_phase = filtered_lfp_phase
-
-    # Get phases at spike times
-    spike_phases = instantaneous_phase.sel(time=valid_indices).values
-
     n_spikes = len(spike_phases)
 
     # Calculate PPC (Pairwise Phase Consistency)
-    if n_spikes <= 1:
-        return 0
-
     # Explicit calculation of pairwise phase consistency
     # Vectorized computation for efficiency
     if ppc_method == "numpy":
@@ -409,45 +463,25 @@ def calculate_ppc2(
         Pairwise Phase Consistency 2 (PPC2) 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
-    if filtered_lfp_phase is not None:
-        valid_indices = align_spike_times_with_lfp(lfp=filtered_lfp_phase, timestamps=spike_indices)
-    else:
-        valid_indices = align_spike_times_with_lfp(lfp=lfp_data, timestamps=spike_indices)
-
-    if len(valid_indices) <= 1:
+    spike_phases = _get_spike_phases(
+        spike_times=spike_times,
+        lfp_data=lfp_data,
+        spike_fs=spike_fs,
+        lfp_fs=lfp_fs,
+        filter_method=filter_method,
+        freq_of_interest=freq_of_interest,
+        lowcut=lowcut,
+        highcut=highcut,
+        bandwidth=bandwidth,
+        filtered_lfp_phase=filtered_lfp_phase,
+    )
+
+    if len(spike_phases) <= 1:
         return 0
 
-    # Get instantaneous phase
-    if filtered_lfp_phase is None:
-        instantaneous_phase = get_lfp_phase(
-            lfp_data=lfp_data,
-            filter_method=filter_method,
-            freq_of_interest=freq_of_interest,
-            lowcut=lowcut,
-            highcut=highcut,
-            bandwidth=bandwidth,
-            fs=lfp_fs,
-        )
-    else:
-        instantaneous_phase = filtered_lfp_phase
-
-    # Get phases at spike times
-    spike_phases = instantaneous_phase.sel(time=valid_indices).values
     # Calculate PPC2 according to Vinck et al. (2010), Equation 6
     n = len(spike_phases)
 
-    if n <= 1:
-        return 0
-
     # Convert phases to unit vectors in the complex plane
     unit_vectors = np.exp(1j * spike_phases)
 
@@ -539,7 +573,7 @@ def calculate_entrainment_per_cell(
     for pop in pop_names:
         skip_count = 0
         pop_spikes = spike_df[spike_df["pop_name"] == pop]
-        nodes = pop_spikes["node_ids"].unique()
+        nodes = sorted(pop_spikes["node_ids"].unique())  # sort so all nodes are processed in order
         entrainment_dict[pop] = {}
         print(f"Processing {pop} population")
         for node in tqdm(nodes):

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

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

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

@@ -8,7 +8,7 @@ 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=UVYhakyFGmH56UZ2jlshOH86rIKc9hSI-U2-kK2yp7o,25190
+bmtool/analysis/entrainment.py,sha256=sjfSxPs1Y0dnEtX9a3IIMEeQ09L6WbhO3KMt-O8SN64,26480
 bmtool/analysis/lfp.py,sha256=S2JvxkjcK3-EH93wCrhqNSFY6cX7fOq74pz64ibHKrc,26556
 bmtool/analysis/netcon_reports.py,sha256=VnPZNKPaQA7oh1q9cIatsqQudm4cOtzNtbGPXoiDCD0,2909
 bmtool/analysis/spikes.py,sha256=ScP4EeX2QuEd_FXyj3W0WWgZKvZwwneuWuKFe3xwaCY,15115
@@ -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.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
-bmtool-0.7.1.dist-info/METADATA,sha256=qVCMtNEx1YXI0KlMV3hLlhTSdEbbv5xrj2V1ZFWY0ho,3621
-bmtool-0.7.1.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-bmtool-0.7.1.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
-bmtool-0.7.1.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
-bmtool-0.7.1.dist-info/RECORD,,
+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,,