# Source code for brainbox.lfp

```
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 13 14:57:53 2020
Functions to analyse LFP signals
@author: Guido Meijer
"""
from scipy.signal import welch, csd, filtfilt, butter
import numpy as np
[docs]def butter_filter(signal, highpass_freq=None, lowpass_freq=None, order=4, fs=2500):
# The filter type is determined according to the values of cut-off frequencies
Fn = fs / 2.
if lowpass_freq and highpass_freq:
if highpass_freq < lowpass_freq:
Wn = (highpass_freq / Fn, lowpass_freq / Fn)
btype = 'bandpass'
else:
Wn = (lowpass_freq / Fn, highpass_freq / Fn)
btype = 'bandstop'
elif lowpass_freq:
Wn = lowpass_freq / Fn
btype = 'lowpass'
elif highpass_freq:
Wn = highpass_freq / Fn
btype = 'highpass'
else:
raise ValueError("Either highpass_freq or lowpass_freq must be given")
# Filter signal
b, a = butter(order, Wn, btype=btype, output='ba')
filtered_data = filtfilt(b=b, a=a, x=signal, axis=1)
return filtered_data
[docs]def power_spectrum(signal, fs=2500, segment_length=0.5, segment_overlap=0.5, scaling='density'):
"""
Calculate the power spectrum of an LFP signal
Parameters
----------
signal : 2D array
LFP signal from different channels in V with dimensions (channels X samples)
fs : int
Sampling frequency
segment_length : float
Length of the segments for which the spectral density is calcualted in seconds
segment_overlap : float
Fraction of overlap between the segments represented as a float number between 0 (no
overlap) and 1 (complete overlap)
Returns
----------
freqs : 1D array
Frequencies for which the spectral density is calculated
psd : 2D array
Power spectrum in V^2 with dimensions (channels X frequencies)
"""
# Transform segment from seconds to samples
segment_samples = int(fs * segment_length)
overlap_samples = int(segment_overlap * segment_samples)
# Calculate power spectrum
freqs, psd = welch(signal, fs=fs, nperseg=segment_samples, noverlap=overlap_samples,
scaling=scaling)
return freqs, psd
[docs]def coherence(signal_a, signal_b, fs=2500, segment_length=1, segment_overlap=0.5):
"""
Calculate the coherence between two LFP signals
Parameters
----------
signal_a : 1D array
LFP signal from different channels with dimensions (channels X samples)
fs : int
Sampling frequency
segment_length : float
Length of the segments for which the spectral density is calcualted in seconds
segment_overlap : float
Fraction of overlap between the segments represented as a float number between 0 (no
overlap) and 1 (complete overlap)
Returns
----------
freqs : 1D array
Frequencies for which the coherence is calculated
coherence : 1D array
Coherence takes a value between 0 and 1, with 0 or 1 representing no or perfect coherence,
respectively
phase_lag : 1D array
Estimate of phase lag in radian between the input time series for each frequency
"""
# Transform segment from seconds to samples
segment_samples = int(fs * segment_length)
overlap_samples = int(segment_overlap * segment_samples)
# Calculate coherence
freqs, Pxx = welch(signal_a, fs=fs, nperseg=segment_samples, noverlap=overlap_samples)
_, Pyy = welch(signal_b, fs=fs, nperseg=segment_samples, noverlap=overlap_samples)
_, Pxy = csd(signal_a, signal_b, fs=fs, nperseg=segment_samples, noverlap=overlap_samples)
coherence = np.abs(Pxy) ** 2 / (Pxx * Pyy)
phase_lag = np.angle(Pxy)
return freqs, coherence, phase_lag
```