def test_filterfit(self):
"""Test filtering test computing PAC."""
data = np.random.rand(2, 1024)
p = Pac(idpac=(4, 0, 0))
p.filterfit(1024, data, n_jobs=1)
p.idpac = (1, 1, 1)
p.filterfit(1024, data, data, n_jobs=1, n_perm=2)
p.dcomplex = 'wavelet'
p.filter(1024, data, n_jobs=1)
def test_kargs():
"""Test filtering test computing PAC."""
data = np.random.rand(2, 1024)
p = Pac(idpac=(1, 2, 4))
karg1 = p.filterfit(1024, data, data, njobs=1)
karg2 = p.filterfit(1024, data, data, njobs=1, get_pval=True)
karg3 = p.filterfit(1024, data, data, njobs=1, get_surro=True)
karg4 = p.filterfit(1024,
data,
data,
njobs=1,
get_surro=True,
get_pval=True)
assert len(karg1) == 1
assert len(karg2) == 2
assert len(karg3) == 2
assert len(karg4) == 3
def set_data(self,
data,
sf=1.,
f_pha=[(2, 4), (5, 7), (8, 13)],
f_amp=[(40, 60), (60, 100)],
idpac=(4, 0, 0),
n_window=None,
clim=None,
cmap=None,
vmin=None,
under=None,
vmax=None,
over=None,
**kwargs):
"""Compute pacmap and set data to the ImageObj."""
# ======================= CHECKING =======================
is_tensorpac_installed(raise_error=True)
from tensorpac import Pac
data = np.squeeze(data)
assert isinstance(data, np.ndarray) and data.ndim == 1
assert isinstance(sf, (int, float))
time = np.arange(len(data))
# Switch between several plotting capabilities :
_pha = len(f_pha) == 2 and all(
[isinstance(k, (int, float)) for k in f_pha])
_amp = len(f_amp) == 2 and all(
[isinstance(k, (int, float)) for k in f_amp])
if _pha or _amp:
assert isinstance(n_window, int)
sections = time.copy()[::n_window][1::]
time = np.array(np.array_split(time, sections)[0:-1]).mean(1).T
time /= sf
data = np.array(np.array_split(data, sections)[0:-1]).T
# Define the pac object and compute pac :
p = Pac(idpac=idpac, fpha=f_pha, famp=f_amp, **kwargs)
pac = np.squeeze(p.filterfit(sf, data, njobs=1, axis=0))
pac[np.isnan(pac)] = 0.
assert pac.ndim == 2
# Get x-axis and y-axis :
if _pha:
xaxis, yaxis = time, p.yvec
elif _amp:
xaxis, yaxis = time, p.xvec
else:
xaxis, yaxis = p.xvec, p.yvec
# Update color arguments :
self._update_cbar_args(cmap, clim, vmin, vmax, under, over)
# Set data to the image object :
ImageObj.set_data(self,
pac,
xaxis=xaxis,
yaxis=yaxis,
**self.to_kwargs())
def compute_pt_tp(n_jobs, n_perm, title=''):
"""Compute Pactools and Tensorpac."""
cpt, meth_comp, soft = [], [], []
for meth in ['MVL', 'MI', 'PLV']:
# ---------------------------------------------------------------------
# get the method name
meth_pt = METH['PACTOOLS'][meth]
meth_tp = METH['TENSORPAC'][meth]
if n_perm > 0:
idpac = (meth_tp, 2, 4)
else:
idpac = (meth_tp, 0, 0)
# ---------------------------------------------------------------------
# PACTOOLS
pt_start = tst()
estimator = Comodulogram(fs=sf,
low_fq_range=f_pha_pt,
low_fq_width=f_pha_pt_width,
high_fq_range=f_amp_pt,
high_fq_width=f_amp_pt_width,
method=meth_pt,
progress_bar=False,
n_jobs=n_jobs,
n_surrogates=n_perm)
estimator.fit(data)
pt_end = tst()
# ---------------------------------------------------------------------
# TENSORPAC
tp_start = tst()
p_obj = Pac(idpac=idpac,
f_pha=f_pha_tp,
f_amp=f_amp_tp,
verbose='error')
pac = p_obj.filterfit(sf, data, n_jobs=n_jobs, n_perm=n_perm).mean(-1)
tp_end = tst()
# ---------------------------------------------------------------------
# shape shape checking
assert estimator.comod_.shape == pac.T.shape
# saving the results
cpt += [pt_end - pt_start, tp_end - tp_start]
meth_comp += [meth] * 2
soft += ['Pactools', 'Tensorpac']
# -------------------------------------------------------------------------
df = pd.DataFrame({
"Computing time": cpt,
"PAC method": meth_comp,
"Software": soft
})
sns.barplot(x="PAC method", y="Computing time", hue="Software", data=df)
plt.title(title, fontsize=14, fontweight='bold')
def set_data(self, data, sf=1., f_pha=[(2, 4), (5, 7), (8, 13)],
f_amp=[(40, 60), (60, 100)], idpac=(4, 0, 0), n_window=None,
clim=None, cmap=None, vmin=None, under=None, vmax=None,
over=None, **kwargs):
"""Compute pacmap and set data to the ImageObj."""
# ======================= CHECKING =======================
is_tensorpac_installed(raise_error=True)
from tensorpac import Pac
data = np.squeeze(data)
assert isinstance(data, np.ndarray) and data.ndim == 1
assert isinstance(sf, (int, float))
time = np.arange(len(data))
# Switch between several plotting capabilities :
_pha = len(f_pha) == 2 and all([isinstance(k, (int,
float)) for k in f_pha])
_amp = len(f_amp) == 2 and all([isinstance(k, (int,
float)) for k in f_amp])
if _pha or _amp:
assert isinstance(n_window, int)
sections = time.copy()[::n_window][1::]
time = np.array(np.array_split(time, sections)[0:-1]).mean(1).T
time /= sf
data = np.array(np.array_split(data, sections)[0:-1]).T
# Define the pac object and compute pac :
p = Pac(idpac=idpac, fpha=f_pha, famp=f_amp, **kwargs)
pac = np.squeeze(p.filterfit(sf, data, njobs=1, axis=0))
pac[np.isnan(pac)] = 0.
assert pac.ndim == 2
# Get x-axis and y-axis :
if _pha:
xaxis, yaxis = time, p.yvec
elif _amp:
xaxis, yaxis = time, p.xvec
else:
xaxis, yaxis = p.xvec, p.yvec
# Update color arguments :
self._update_cbar_args(cmap, clim, vmin, vmax, under, over)
# Set data to the image object :
ImageObj.set_data(self, pac, xaxis=xaxis, yaxis=yaxis,
**self.to_kwargs())
n=str(noise))
info.append(inf)
# Generate coupling :
data[i, k, ...], time = pac_signals_wavelet(fpha=fpha,
famp=famp,
noise=noise,
npts=n_pts,
ntrials=n_trials,
sf=sf)
# ----------------- Compute PAC -----------------
# Define the PAC object :
p = Pac(idpac=(4, 0, 0),
fpha=(1, 15, 1, .3),
famp=(25, 130, 5, 1),
dcomplex='wavelet',
width=12)
# Compute PAC along the time axis and take the mean across trials :
pac = p.filterfit(sf, data, axis=3).mean(-1)
# ----------------- Visualization -----------------
q = 1
plt.figure(figsize=(20, 19))
for i in range(n_subject):
for k in range(n_elec):
plt.subplot(n_subject, n_elec, q)
p.comodulogram(pac[:, :, i, k], title=info[q - 1], interp=(.2, .2))
q += 1
p.show()
# Compute true PAC estimation and surrogates distribution
###############################################################################
# Now, we compute the PAC using multiple phases and amplitudes such as the
# distribution of surrogates. In this example, we used the method proposed by
# Bahramisharif et al. 2013 :cite:`bahramisharif2013propagating` and also
# recommended by Aru et al. 2015 :cite:`aru2015untangling`. This method
# consists in swapping two time blocks of amplitudes cut at a random time
# point. Then, we used the method :class:`tensorpac.Pac.infer_pvalues` in order
# to get the corrected p-values across all possible (phase, amplitude)
# frequency pairs.
# define the Pac object
p = Pac(idpac=(2, 2, 0), f_pha=(2, 15, 2, .2), f_amp=(60, 120, 5, 1))
# compute true pac and surrogates
n_perm = 200 # number of permutations
xpac = p.filterfit(sf, data, n_perm=n_perm, n_jobs=-1,
random_state=0).squeeze()
# get the corrected p-values
pval = p.infer_pvalues(p=0.05)
# get the mean pac values where it's detected as significant
xpac_smean = xpac[pval < .05].mean()
# if you want to see how the surrogates looks like, you can have to access
# using :class:`tensorpac.Pac.surrogates`
surro = p.surrogates.squeeze()
print(f"Surrogates shape (n_perm, n_amp, n_pha) : {surro.shape}")
# get the maximum of the surrogates across (phase, amplitude) pairs
surro_max = surro.max(axis=(1, 2))
plt.figure(figsize=(16, 5))
plt.subplot(131)
p.comodulogram(xpac,
import numpy as np
import matplotlib.pyplot as plt
from tensorpac import Pac, pac_signals_wavelet
plt.style.use('seaborn-poster')
# First, we generate a dataset of signals artificially coupled between 10hz
# and 100hz. By default, this dataset is organized as (n_epochs, n_times) where
# n_times is the number of time points.
n_epochs = 1 # number of datasets
sf = 512. # sampling frequency
data, time = pac_signals_wavelet(f_pha=6,
f_amp=90,
noise=.8,
n_epochs=n_epochs,
n_times=4000,
sf=sf)
# First, let's use the MVL, without any further correction by surrogates :
p = Pac(idpac=(1, 2, 0), f_pha=(2, 15, 2, .2), f_amp=(60, 120, 10, 1))
xpac = p.filterfit(sf, data, n_perm=200, p=.05)
pval = p.pvalues
p.comodulogram(xpac.mean(-1),
title=str(p),
cmap='Spectral_r',
vmin=0.,
pvalues=pval,
levels=.05)
p.show()
from tensorpac.signals import pac_signals_tort
# Dataset of signals artificially coupled between 10hz and 100hz :
n_epochs = 20
n_times = 4000
sf = 512. # sampling frequency
# Create artificially coupled signals using Tort method :
data, time = pac_signals_tort(f_pha=10,
f_amp=100,
noise=2,
n_epochs=n_epochs,
dpha=10,
damp=10,
sf=sf,
n_times=n_times)
# Define a PAC object :
p = Pac(idpac=(6, 0, 0), f_pha=(2, 20, 1, 1), f_amp=(60, 150, 5, 5))
# Filter the data and extract PAC :
xpac = p.filterfit(sf, data)
# Plot your Phase-Amplitude Coupling :
p.comodulogram(xpac.mean(-1),
title='Contour plot with 5 regions',
cmap='Spectral_r',
plotas='contour',
ncontours=5)
p.show()
noise=3,
n_epochs=n_epochs,
dpha=20,
damp=5,
chi=.3,
n_times=3000)
# Define the model of PAC to use :
p = Pac(idpac=(4, 0, 0),
f_pha=(2, 30, 1, 1),
f_amp=(60, 150, 5, 5),
dcomplex='wavelet',
width=12)
# Now, compute PAC by taking the phase of the first dataset and the amplitude
# of the second
xpac12 = p.filterfit(1024, d1, d2)
# Invert by taking the phase of the second dataset and the amplitude of the
# first one :
xpac21 = p.filterfit(1024, d2, d1)
# Plot signals and PAC :
plt.figure(figsize=(18, 12))
plt.subplot(2, 2, 1)
plt.plot(time, d1.mean(0), color='k')
plt.xlabel('Time')
plt.ylabel('Amplitude [uV]')
plt.title('Mean across trials of the first dataset')
plt.axis('tight')
plt.subplot(2, 2, 2)
plt.plot(time, d2.mean(0), color='k')
"""
from tensorpac import Pac, pac_trivec, pac_signals_tort
sf = 256.
data, time = pac_signals_tort(fpha=[5, 7],
famp=[60, 80],
noise=2,
ntrials=5,
npts=3000,
sf=sf,
dpha=10)
trif, tridx = pac_trivec(fstart=30, fend=140, fwidth=3)
p = Pac(idpac=(1, 0, 0), fpha=[5, 7], famp=trif)
pac = p.filterfit(sf, data, axis=1)
p.triplot(pac.mean(-1),
trif,
tridx,
cmap='Spectral_r',
rmaxis=True,
title=r'Optimal $[Fmin; Fmax]hz$ band for amplitude')
# In this example, we generated a coupling with a phase between [5, 7]hz and an
# amplitude between [60, 80]hz. To interpret the figure, the best starting
# frequency is around 50hz and the best ending frequency is around 90hz. In
# conclusion, the optimal amplitude bandwidth for this [5, 7]hz phase is
# [50, 90]hz.
# plt.savefig('triplot.png', dpi=600, bbox_inches='tight')
n_epochs = 50
n_times = 3000
n_perm = 20
###############################################################################
data, time = pac_signals_wavelet(sf=sf,
f_pha=10,
f_amp=100,
noise=3.,
n_epochs=n_epochs,
n_times=n_times)
p = Pac(idpac=(1, 2, 3), f_pha=cfg["phres"], f_amp=cfg["ahres"])
# p = Pac(idpac=(1, 2, 3), f_pha=(1, 30, 1, 1), f_amp=(60, 160, 5, 5))
# p = Pac(idpac=(1, 2, 3), f_pha='lres', f_amp='lres')
xpac = p.filterfit(sf, data, n_perm=n_perm, p=.05, n_jobs=-1)
pacn = p.pac.mean(-1)
pac = xpac.mean(-1)
surro = p.surrogates.mean(0).max(-1) # mean(perm).max(epochs)
plt.figure(figsize=(22, 6))
plt.subplot(1, 3, 1)
p.comodulogram(pacn,
cblabel="",
title="Uncorrected PAC",
cmap=cfg["cmap"],
vmin=0)
ax = plt.gca()
ax.text(*tuple(cfg["nb_pos"]), 'A', transform=ax.transAxes, **cfg["nb_cfg"])
###############################################################################
sf = 1024
n_epochs = 50
n_times = 3000
n_perm = 20
###############################################################################
data, time = pac_signals_wavelet(sf=sf,
f_pha=10,
f_amp=100,
noise=3.,
n_epochs=n_epochs,
n_times=n_times)
p = Pac(idpac=(1, 2, 3), f_pha='hres', f_amp='hres')
xpac = p.filterfit(sf, data, n_perm=n_perm, p=.05, n_jobs=-1, random_state=0)
pacn = p.pac.mean(-1)
pac = xpac.mean(-1)
surro = p.surrogates.mean(0).max(-1) # mean(perm).max(epochs)
kw_plt = dict(fz_labels=20, fz_title=22, fz_cblabel=20)
plt.figure(figsize=(20, 6))
plt.subplot(1, 3, 1)
p.comodulogram(pacn,
cblabel="",
title="Uncorrected PAC",
cmap=cfg["cmap"],
vmin=0,
# and 100hz. By default, this dataset is organized as (ntrials, npts) where
# npts is the number of time points.
n = 10 # number of datasets
data, time = pac_signals_wavelet(fpha=10,
famp=100,
noise=1.,
ntrials=n,
npts=4000)
# First, let's use the MVL, without any further correction by surrogates :
p = Pac(idpac=(5, 3, 3),
fpha=(4, 18, 1, .3),
famp=(60, 150, 5, 2),
dcomplex='wavelet',
width=7)
xpac, pval = p.filterfit(1024, data, axis=1, nperm=110, get_pval=True)
# Now, we plot the result by taking the mean across the dataset dimension.
plt.figure(figsize=(20, 15))
plt.subplot(3, 3, 1)
p.comodulogram(xpac.mean(-1), title='Default plotting')
plt.subplot(3, 3, 2)
p.comodulogram(xpac.mean(-1),
title='Peaking between [5, 20]',
vmin=5,
vmax=20,
cmap='gnuplot2_r')
plt.subplot(3, 3, 3)
# Ideally, the p-values should be corrected across trials because taking the
# and 100hz. By default, this dataset is organized as (ntrials, npts) where
# npts is the number of time points.
n = 10 # number of datasets
npts = 4000 # number of time points
data, time = pac_signals_tort(fpha=10,
famp=100,
noise=3.,
ntrials=n,
npts=npts,
dpha=10,
damp=5,
chi=.8)
# First, let's use the MVL, without any further correction by surrogates :
p = Pac(idpac=(1, 0, 0), fpha=(2, 30, 1, .5), famp=(60, 150, 10, 1))
xpac = p.filterfit(1024, data, axis=1)
t1 = p.method + '\n' + p.surro + '\n' + p.norm
# Now, we still use the MVL method, but in addition we shuffle amplitude time
# series and then, subtract then divide by the mean of surrogates :
p.idpac = (1, 1, 1)
xpac_corr = p.filterfit(1024, data, data, axis=1, nperm=10)
t2 = p.method + '\n' + p.surro + '\n' + p.norm
# Now, we plot the result by taking the mean across the dataset dimension.
plt.figure(figsize=(20, 7))
plt.subplot(1, 2, 1)
p.comodulogram(xpac.mean(-1), title=t1)
plt.subplot(1, 2, 2)
p.comodulogram(xpac_corr.mean(-1), title=t2)
plt.show()
n_epochs=n_epochs,
n_times=n_times)
# create a second random dataset without any coupling
x_2 = np.random.rand(n_epochs, n_times)
###############################################################################
# Compute the single trial PAC on both datasets
###############################################################################
# once the datasets created, we can now extract the PAC, computed across
# time-points for each trials and across several phase and amplitude
# frequencies
# create the pac object. Use the Gaussian-Copula PAC
p = Pac(idpac=(6, 0, 0), f_pha='hres', f_amp='hres', dcomplex='wavelet')
# compute pac for both dataset
pac_1 = p.filterfit(sf, x_1, n_jobs=-1)
pac_2 = p.filterfit(sf, x_2, n_jobs=-1)
###############################################################################
# Correct for multiple-comparisons using a cluster-based approach
###############################################################################
# Then, we perform the cluster-based correction for multiple comparisons
# between the PAC coming from the two conditions. To this end we use the
# Python package MNE-Python and in particular, the function
# :func:`mne.stats.permutation_cluster_test`
# mne requires that the first is represented by the number of trials (n_epochs)
# Therefore, we transpose the output PACs of both conditions
pac_r1 = np.transpose(pac_1, (2, 0, 1))
pac_r2 = np.transpose(pac_2, (2, 0, 1))
###############################################################################
# Compute true PAC estimation and surrogates distribution
###############################################################################
# Now, we compute the PAC using multiple phases and amplitudes such as the
# distribution of surrogates. In this example, we used the method proposed by
# Tort et al. 2010 :cite:`tort2010measuring`. This method consists in swapping
# phase and amplitude trials. Then, we used the method
# :class:`tensorpac.Pac.infer_pvalues` in order to get the corrected p-values
# across all possible (phase, amplitude) frequency pairs.
# define the Pac object
p = Pac(idpac=(1, 1, 0), f_pha='mres', f_amp='mres')
# compute true pac and surrogates
n_perm = 200 # number of permutations
xpac = p.filterfit(sf, data, n_perm=n_perm, n_jobs=-1).squeeze()
plt.figure(figsize=(16, 5))
for n_mcp, mcp in enumerate(['maxstat', 'fdr', 'bonferroni']):
# get the corrected p-values
pval = p.infer_pvalues(p=0.05, mcp=mcp)
# set to gray non significant p-values and in color significant values
pac_ns = xpac.copy()
pac_ns[pval <= .05] = np.nan
pac_s = xpac.copy()
pac_s[pval > .05] = np.nan
plt.subplot(1, 3, n_mcp + 1)
p.comodulogram(pac_ns, cmap='gray', colorbar=False, vmin=np.nanmin(pac_ns),
vmax=np.nanmax(pac_ns))
p.comodulogram(pac_s, title=f'MCP={mcp}', cmap='viridis',
f_amp=100,
noise=1.,
n_epochs=n_epochs,
n_times=n_times)
# First, let's use the MVL, without any further correction by surrogates :
p = Pac(idpac=(4, 0, 0),
f_pha=(5, 14, 2, .3),
f_amp=(80, 120, 2, 1),
verbose=False)
plt.figure(figsize=(18, 9))
# Define several cycle options for the fir1 (eegfilt like) filter :
print('Filtering with fir1 filter')
for i, k in enumerate([(1, 3), (2, 4), (3, 6)]):
p.cycle = k
xpac = p.filterfit(1024, data, n_jobs=1)
plt.subplot(2, 3, i + 1)
p.comodulogram(xpac.mean(-1), title='Fir1 - cycle ' + str(k))
# Define several wavelet width :
p.dcomplex = 'wavelet'
print('Filtering with wavelets')
for i, k in enumerate([7, 9, 12]):
p.width = k
xpac = p.filterfit(1024, data)
plt.subplot(2, 3, i + 4)
p.comodulogram(xpac.mean(-1), title='Wavelet - width ' + str(k))
plt.show()
coupling.
"""
import numpy as np
import matplotlib.pyplot as plt
from tensorpac.utils import pac_signals_tort
from tensorpac import Pac
data, time = pac_signals_tort(fpha=[5, 7],
famp=[60, 80],
chi=0.5,
ntrials=10,
noise=3.,
npts=2000)
p = Pac(idpac=(3, 1, 1),
fpha=(1, 15, 1, .2),
famp=(40, 100, 5, 2),
dcomplex='wavelet',
width=6)
pac = np.squeeze(p.filterfit(1024, data, axis=1, nperm=10))
plt.figure(figsize=(12, 9))
p.comodulogram(pac.mean(-1),
title=str(p),
plotas='contour',
ncontours=10,
cmap='plasma',
vmin=0)
plt.show()
noise=3,
ntrials=n,
dpha=20,
damp=5,
chi=.3,
npts=3000)
# Define the model of PAC to use :
p = Pac(idpac=(4, 0, 0),
fpha=(2, 30, 1, 1),
famp=(60, 150, 5, 5),
dcomplex='wavelet',
width=12)
# Now, compute PAC by taking the phase of the first dataset and the amplitude
# of the second
xpac12 = p.filterfit(1024, d1, d2, axis=1)
# Invert by taking the phase of the second dataset and the amplitude of the
# first one :
xpac21 = p.filterfit(1024, d2, d1, axis=1)
# Plot signals and PAC :
plt.figure(figsize=(18, 12))
plt.subplot(2, 2, 1)
plt.plot(time, d1.mean(0), color='k')
plt.xlabel('Time')
plt.ylabel('Amplitude [uV]')
plt.title('Mean across trials of the first dataset')
plt.axis('tight')
plt.subplot(2, 2, 2)
plt.plot(time, d2.mean(0), color='k')
f_pha, f_amp = 5, 120
n_epochs = 5
n_times = 1000
###############################################################################
# generate the random dataset
sig_t, time = pac_signals_tort(f_pha=f_pha, f_amp=f_amp, n_epochs=n_epochs,
noise=2, n_times=n_times, sf=sf)
sig_w, time = pac_signals_wavelet(sf=sf, f_pha=f_pha, f_amp=f_amp, noise=.5,
n_epochs=n_epochs, n_times=n_times)
# compute pac
p = Pac(idpac=(6, 0, 0), f_pha=cfg["phres"], f_amp=cfg["ahres"],
dcomplex='wavelet', width=12)
xpac_t = p.filterfit(sf, sig_t, n_jobs=1).mean(-1)
xpac_w = p.filterfit(sf, sig_w, n_jobs=1).mean(-1)
plt.figure(figsize=(17, 14))
# ----------------------------------------- Tort et al. 2010
plt.subplot(221)
plt.plot(time, sig_t[0, :], color='black', lw=.8)
plt.ylabel("Amplitude (V)")
plt.title("pac_signals_tort (Tort et al. 2010)")
plt.autoscale(axis='both', tight=True)
plt.tick_params(axis='x', which='both', labelbottom=False)
ax = plt.gca()
ax.text(*tuple(cfg["nb_pos"]), 'A', transform=ax.transAxes, **cfg["nb_cfg"])
plt.subplot(222)
noise=1.,
n_epochs=n_epochs,
n_times=n_times)
# First, let's use the MVL, without any further correction by surrogates :
p = Pac(idpac=(4, 0, 0),
f_pha=(5, 14, 2, .3),
f_amp=(80, 120, 2, 1),
verbose=False)
plt.figure(figsize=(18, 9))
# Define several cycle options for the fir1 (eegfilt like) filter :
p.filt = 'fir1'
print('Filtering with fir1 filter')
for i, k in enumerate([(1, 3), (2, 4), (3, 6)]):
p.cycle = k
xpac = p.filterfit(1024, data)
plt.subplot(2, 3, i + 1)
p.comodulogram(xpac.mean(-1), title='Fir1 - cycle ' + str(k))
# Define several wavelet width :
p.dcomplex = 'wavelet'
print('Filtering with wavelets')
for i, k in enumerate([7, 9, 12]):
p.width = k
xpac = p.filterfit(1024, data)
plt.subplot(2, 3, i + 4)
p.comodulogram(xpac.mean(-1), title='Wavelet - width ' + str(k))
plt.show()
npts = 2000 # number of time points
data, time = pac_signals_wavelet(fpha=10,
famp=100,
noise=1.,
ntrials=n,
npts=npts)
# First, let's use the MVL, without any further correction by surrogates :
p = Pac(idpac=(1, 0, 0), fpha=(5, 14, 2, .3), famp=(80, 120, 2, 1))
plt.figure(figsize=(18, 9))
# Define several cycle options for the fir1 (eegfilt like) filter :
p.filt = 'fir1'
print('Filtering with fir1 filter')
for i, k in enumerate([(1, 3), (3, 6), (6, 12)]):
p.cycle = k
xpac = p.filterfit(1024, data, axis=1)
plt.subplot(2, 3, i + 1)
p.comodulogram(xpac.mean(-1), title='Fir1 - cycle ' + str(k))
# Define several wavelet width :
p.dcomplex = 'wavelet'
print('Filtering with wavelets')
for i, k in enumerate([7, 12, 24]):
p.width = k
xpac = p.filterfit(1024, data, axis=1)
plt.subplot(2, 3, i + 4)
p.comodulogram(xpac.mean(-1), title='Wavelet - width ' + str(k))
plt.show()
