def load_data(band):
dfs = []
data = []
for subj in cfg.subjects:
tfr_path = bp.tfr_av.fpath(subject=subj, acquisition=band)
tfr = read_tfrs(tfr_path)[0]["confidence < 100 and confidence > 0"]
df = tfr.metadata.copy()
data.append(tfr.pick_types(meg="grad").data[:, :, 0, :])
df["subject"] = subj
dfs.append(df)
return dfs, data
def read_tfrs_from_path(tfrs_path: str, pattern: str) -> List[AverageTFR]:
"""
Reads TFR files from path with a given pattern to look for within the file name. I.e.
used for separating conditions (e.g. H, L).
Parameters
----------
tfrs_path
pattern
Returns
-------
"""
files = sorted([
f for f in os.listdir(tfrs_path)
if pattern.lower() in f.lower() and not f.startswith(".")
])
tfrs = [read_tfrs(os.path.join(tfrs_path, f))[0] for f in files]
return tfrs
'CS-1',
'CS-2',
'CS+',
'CS-E',
]
anova_data = []
data = dict()
gavg = dict()
for cond in conditions:
pdat = []
data[cond] = []
for p in part:
data[cond].append(
read_tfrs(
opj('/data/derivatives', p, 'eeg',
p + '_task-fearcond_' + cond + '_avg-tfr.h5'))[0])
data[cond][-1].apply_baseline(mode='logratio', baseline=(-0.2, 0))
data[cond][-1].crop(tmin=0, tmax=1)
pdat.append(np.float32(data[cond][-1].data))
anova_data.append(np.stack(pdat))
gavg[cond] = mne.grand_average(data[cond])
anova_data = np.stack(anova_data)
# # Take difference of interest for each part
diff_data = np.empty((2, ) + anova_data.shape[1:])
for s in range(anova_data.shape[1]):
"epochs",
"All_%d-sss_%s-epo.fif" % (params.lp_cut, subject),
)
epochs = read_epochs(ep_fname)
epochs = epochs["tone"]
epochs.pick_types(meg="grad")
epochs.crop(-0.2, 1.3).apply_baseline()
epochs.resample(200.0, npad="auto")
epochs.drop_bad()
evoked = epochs.average()
if np.isnan(evoked.data).any():
xs.append(subject.split("_")[1])
continue
evokeds.append(evoked)
if op.isfile(out):
tfrs.append(read_tfrs(out))
else:
print("computing TFRAverage data for %s: " % subject)
tfr = tfr_stockwell(epochs,
fmin=fmin,
fmax=fmax,
n_jobs=12,
return_itc=True)
write_tfrs(out, tfr, overwrite=write)
# %%
# partition around 4mos
out = features["id"].isin(xs)
features = features[~out]
ix = np.where(features["age"].values == 120)[0][0]
aix = np.argpartition(features["age"].values, ix)
# Despine
plt.rc("axes.spines", top=False, right=False)
plt.rcParams['font.family'] = 'Arial Narrow'
###############################
# Load data
##############################
betas = np.load(opj(outpath, 'ols_2ndlevel_allbetas.npy'))
pvals = np.load(opj(outpath, 'ols_2ndlevel_tfr_pvals.npy'))
tvals = np.load(opj(outpath, 'ols_2ndlevel_tfr_tvals.npy'))
# Mock info
epo = read_tfrs(
opj('/data/derivatives', part[0], 'eeg',
part[0] + '_task-fearcond_epochs-tfr.h5'))[0]
epo.apply_baseline(mode='logratio', baseline=(-0.2, 0))
# epo.crop(tmin=0, tmax=1)
regvarsnames = ['Expectation', 'Irr. uncertainty', 'Est. uncertainty']
# ###########################################################################
# Make plot
###############################################################################
chans_to_plot = ['Pz', 'POz', 'CPz', 'Cz', 'Fz']
for idx, regvar in enumerate(regvarsnames):
def load_patient_tfr(deriv_path, subject, band, task=None, verbose=True):
from mne.time_frequency import read_tfrs, AverageTFR
if task is not None:
search_str = f"*sub-{subject}_*task-{task}*.h5"
else:
search_str = f"*sub-{subject}_*.h5"
deriv_files = [f.as_posix() for f in Path(deriv_path).rglob(search_str)]
if band == "delta":
fmin, fmax = 0.5, 5
elif band == "theta":
fmin, fmax = 5, 10
elif band == "alpha":
fmin, fmax = 10, 16
elif band == "beta":
fmin, fmax = 16, 30
elif band == "gamma":
fmin, fmax = 30, 90
elif band == "highgamma":
fmin, fmax = 90, 300
else:
raise ValueError("kwarg 'band' can only be prespecified set of values")
# print(deriv_files)
patient_tfrs = []
for deriv_fpath in deriv_files:
# print(f"Loading {deriv_fpath}")
avg_tfr = read_tfrs(deriv_fpath)[0]
# print(avg_tfr.freqs)
# only obtain the Band TFR for that subject
freq_inds = np.where((avg_tfr.freqs >= fmin) & (avg_tfr.freqs < fmax))[0]
# print(freq_inds)
band_data = np.mean(avg_tfr.data[:, freq_inds, :], axis=1, keepdims=True)
band_tfr = AverageTFR(
avg_tfr.info,
data=band_data,
freqs=[fmin],
nave=1,
times=avg_tfr.times,
verbose=0,
)
json_fpath = deriv_fpath.replace(".h5", ".json")
with open(json_fpath, "r") as fin:
sidecar_json = json.load(fin)
# obtain the event IDs for the markers of interest
sz_onset_id = sidecar_json.get("sz_onset_event_id", None)
sz_offset_id = sidecar_json.get("sz_offset_event_id")
clin_onset_id = sidecar_json.get("clin_onset_event_id")
# events array
events = sidecar_json["events"]
# obtain onset/offset event markers
sz_onset_win = _get_onset_event_id(events, sz_onset_id)
sz_offset_win = _get_onset_event_id(events, sz_offset_id)
clin_onset_win = _get_onset_event_id(events, clin_onset_id)
# set those windows
sidecar_json["sz_onset_win"] = sz_onset_win
sidecar_json["sz_offset_win"] = sz_offset_win
sidecar_json["clin_onset_win"] = clin_onset_win
sidecar_json["freq_band"] = (fmin, fmax)
# create a Result object
band_tfr = Result(
Normalize.compute_fragilitymetric(band_data.squeeze(), invert=True),
info=avg_tfr.info,
metadata=sidecar_json,
)
# band_tfr.metadata.save(json_fpath)
if np.isnan(band_data).any():
print(f"Skipping {deriv_fpath} due to nans")
continue
if sz_onset_win is None:
print(f"Skipping {deriv_fpath}")
continue
patient_tfrs.append(band_tfr)
return patient_tfrs
from mne.time_frequency import read_tfrs
from config import subjects, bp_epochs, bp_tfr, bp_tfr_av
band = "alphabeta"
for subj in subjects:
print(subj)
tfr_path = bp_tfr_av.fpath(subject=subj, acquisition=band)
tfr = read_tfrs(tfr_path)[0]["confidence < 100 and confidence > 0"]
# tfr = read_tfrs(tfr_path)[0]
df = tfr.metadata.copy()
df["subject"] = subj
"""Compute power time course in target frequency bins"""
from argparse import ArgumentParser
import numpy as np
from mne.time_frequency import read_tfrs
from metacog import bp
from metacog.config_parser import cfg
parser = ArgumentParser(__doc__)
parser.add_argument("subject", help="subject id")
subj = parser.parse_args().subject
tfr_path = bp.tfr.fpath(subject=subj)
tfr = read_tfrs(tfr_path)[0]
fr = tfr.freqs
for band in cfg.target_bands:
fr_inds = np.logical_and(fr >= cfg.target_bands[band][0],
fr <= cfg.target_bands[band][1])
data = tfr.data[:, :, fr_inds, :].mean(axis=2, keepdims=True)
tfr_band = tfr.copy()
tfr_band.data = data
tfr_band.freqs = [cfg.target_bands[band][0]]
tfr_av_path = bp.tfr_av.fpath(subject=subj, acquisition=band)
tfr_av_path.parent.mkdir(exist_ok=True, parents=True)
tfr_band.save(tfr_av_path, overwrite=True)
