def handler(self, subject, params):
"""
"""
# check that selected epochs have similar times structure
time_arrays = []
for name in params['conditions']:
epochs = subject.epochs.get(name)
if epochs:
time_arrays.append(epochs.content.times)
assert_arrays_same(time_arrays)
evokeds = {}
for name in params['conditions']:
epochs = subject.epochs.get(name)
if not epochs:
raise KeyError('No epoch collection called ' + str(name))
mne_epochs = epochs.content
@threaded
def average():
return mne_epochs.average()
mne_evoked = average(do_meanwhile=self.window.update_ui)
evokeds[name] = mne_evoked
evoked_directory = subject.evoked_directory
evoked = Evoked(params['name'],
evoked_directory,
params,
content=evokeds)
evoked.save_content()
subject.add(evoked, 'evoked')
def save_tse(experiment, data, window):
""" Computes TSE and saves averages or channels
to csv from selected item from all subjects
"""
try:
selected_name = data['outputs']['tfr'][0]
except IndexError as exc:
return
time_arrays = []
freq_arrays = []
for subject in experiment.subjects.values():
tfr = subject.tfr.get(selected_name)
if not tfr:
continue
time_arrays.append(tfr.times)
freq_arrays.append(tfr.freqs)
assert_arrays_same(time_arrays)
assert_arrays_same(freq_arrays, 'Freqs do no match')
def handler(output, condition, blmode, blstart, blend, tmin, tmax, fmin,
fmax):
try:
if output == 'all_channels':
save_tse_all_channels(experiment, selected_name, blmode,
blstart, blend, tmin, tmax, fmin, fmax)
else:
save_tse_channel_averages(experiment, selected_name, blmode,
blstart, blend, tmin, tmax, fmin,
fmax)
except Exception as exc:
exc_messagebox(window, exc)
dialog = TFROutputOptions(window, experiment, selected_name, handler)
dialog.show()
def group_average_evoked(experiment, evoked_name, groups, new_name):
"""
"""
keys = []
time_arrays = []
for group_key, group_subjects in groups.items():
for subject_name in group_subjects:
try:
subject = experiment.subjects.get(subject_name)
evoked = subject.evoked.get(evoked_name)
mne_evokeds = evoked.content
for mne_evoked in mne_evokeds.values():
time_arrays.append(mne_evoked.times)
except Exception as exc:
continue
assert_arrays_same(time_arrays)
grand_evokeds = {}
for group_key, group_subjects in groups.items():
for subject in experiment.subjects.values():
if subject.name not in group_subjects:
continue
evoked = subject.evoked.get(evoked_name)
if not evoked:
continue
for evoked_item_key, evoked_item in evoked.content.items():
grand_key = (group_key, evoked_item_key)
if grand_key not in grand_evokeds:
grand_evokeds[grand_key] = []
grand_evokeds[grand_key].append(evoked_item)
grand_averages = {}
new_keys = []
for key, grand_evoked in grand_evokeds.items():
new_key = str(key[1]) + '_' + str(key[0])
if len(grand_evoked) == 1:
grand_averages[new_key] = grand_evoked[0].copy()
else:
grand_averages[new_key] = mne.grand_average(grand_evoked)
new_keys.append(new_key)
grand_averages[new_key].comment = new_key
subject = experiment.active_subject
evoked_directory = subject.evoked_directory
params = {'conditions': new_keys, 'groups': groups}
grand_average_evoked = Evoked(new_name,
evoked_directory,
params,
content=grand_averages)
grand_average_evoked.save_content()
subject.add(grand_average_evoked, 'evoked')
def run(self):
try:
selected_name = self.data['outputs']['tfr'][0]
except IndexError as exc:
return
time_arrays = []
freq_arrays = []
for subject in self.experiment.subjects.values():
tfr = subject.tfr.get(selected_name)
if not tfr:
continue
time_arrays.append(tfr.times)
freq_arrays.append(tfr.freqs)
assert_arrays_same(time_arrays)
assert_arrays_same(freq_arrays, 'Freqs do no match')
def option_handler(params):
params['channel_groups'] = self.experiment.channel_groups
params['name'] = selected_name
try:
self.handler(self.experiment.active_subject, params)
except Exception as exc:
exc_messagebox(self.window, exc)
dialog = TFROutputOptions(self.window,
self.experiment,
selected_name,
handler=option_handler)
dialog.show()
def run(self):
try:
selected_name = self.data['outputs']['spectrum'][0]
except IndexError as exc:
return
# validate freqs
freq_arrays = []
for subject in self.experiment.subjects.values():
spectrum = subject.spectrum.get(selected_name)
if not spectrum:
continue
freq_arrays.append(spectrum.freqs)
assert_arrays_same(freq_arrays, 'Freqs do not match')
def option_handler(selected_option):
params = {
'name': selected_name,
'output_option': selected_option,
'channel_groups': self.experiment.channel_groups
}
try:
self.handler(self.experiment.active_subject, params)
except Exception as exc:
exc_messagebox(self.window, exc)
dialog = OutputOptions(self.window, handler=option_handler)
dialog.show()
def save(experiment, data, window):
""" Saves averages or channels to csv from selected item from all subjects
"""
try:
selected_name = data['outputs']['evoked'][0]
except IndexError as exc:
return
# validate times
time_arrays = []
for subject in experiment.subjects.values():
evoked = subject.evoked.get(selected_name)
if not evoked:
continue
for mne_evoked in evoked.content.values():
time_arrays.append(mne_evoked.times)
assert_arrays_same(time_arrays)
def handler(selected_option):
try:
if selected_option == 'channel_averages':
save_channel_averages(experiment, selected_name)
else:
save_all_channels(experiment, selected_name)
except Exception as exc:
exc_messagebox(window, exc)
dialog = OutputOptions(window, handler=handler)
dialog.show()
def run(self):
try:
selected_name = self.data['outputs']['evoked'][0]
except IndexError as exc:
return
# validate times
time_arrays = []
for subject in self.experiment.subjects.values():
evoked = subject.evoked.get(selected_name)
if not evoked:
continue
for mne_evoked in evoked.content.values():
time_arrays.append(mne_evoked.times)
assert_arrays_same(time_arrays, 'Times do not match')
def option_handler(selected_option):
params = {
'name': selected_name,
'output_option': selected_option,
'channel_groups': self.experiment.channel_groups
}
try:
self.handler(self.experiment.active_subject, params)
except Exception as exc:
exc_messagebox(self.window, exc)
dialog = OutputOptions(self.window, handler=option_handler)
dialog.show()
def save(experiment, data, window):
""" Saves all channels or averages to csv from selected item from all
subjects
"""
try:
selected_name = data['outputs']['spectrum'][0]
except IndexError as exc:
return
# validate freqs
freq_arrays = []
for subject in experiment.subjects.values():
spectrum = subject.spectrum.get(selected_name)
if not spectrum:
continue
freq_arrays.append(spectrum.freqs)
assert_arrays_same(freq_arrays, 'Freqs do not match')
def handler(selected_option):
try:
if selected_option == 'channel_averages':
save_channel_averages(experiment, selected_name)
else:
save_all_channels(experiment, selected_name)
except Exception as exc:
exc_messagebox(window, exc)
dialog = OutputOptions(window, handler=handler)
dialog.show()
def create_tfr(subject, tfr_name, epochs_names,
freqs, decim, n_cycles, subtract_evoked):
""" Handles tfr item creation.
"""
time_arrays = []
for name in epochs_names:
collection = subject.epochs.get(name)
if collection:
time_arrays.append(collection.content.times)
assert_arrays_same(time_arrays)
tfrs = {}
for epoch_name in epochs_names:
epochs = subject.epochs[epoch_name].content
if subtract_evoked:
epochs = epochs.copy().subtract_evoked()
tfr = mne.time_frequency.tfr.tfr_morlet(epochs,
freqs=freqs,
n_cycles=n_cycles,
decim=decim,
average=True,
return_itc=False)
tfrs[epoch_name] = tfr
# convert list-like to list
if hasattr(n_cycles, '__len__'):
n_cycles = list(n_cycles)
params = {
'decim': decim,
'n_cycles': n_cycles,
'evoked_subtracted': subtract_evoked,
'conditions': epochs_names
}
meggie_tfr = TFR(tfr_name, subject.tfr_directory, params, tfrs)
meggie_tfr.save_content()
subject.add(meggie_tfr, "tfr")
def create_evoked(self, subject, selected_epochs):
time_arrays = []
for name in selected_epochs:
epochs = subject.epochs.get(name)
if epochs:
time_arrays.append(epochs.content.times)
assert_arrays_same(time_arrays)
evokeds = {}
for name in selected_epochs:
try:
epochs = subject.epochs[name]
except KeyError:
raise KeyError('No epoch collection called ' + str(name))
mne_epochs = epochs.content
@threaded
def average():
return mne_epochs.average()
mne_evoked = average(do_meanwhile=self.parent.update_ui)
mne_evoked.comment = name
evokeds[name] = mne_evoked
evoked_name = validate_name(self.ui.lineEditName.text())
params = {'conditions': selected_epochs}
evoked_directory = subject.evoked_directory
evoked = Evoked(evoked_name, evoked_directory, params, content=evokeds)
evoked.save_content()
subject.add(evoked, 'evoked')
def group_average_tfr(experiment, tfr_name, groups, new_name):
""" Computes a group average item."""
# check data cohesion
keys = []
freq_arrays = []
time_arrays = []
for group_key, group_subjects in groups.items():
for subject_name in group_subjects:
try:
subject = experiment.subjects.get(subject_name)
tfr = subject.tfr.get(tfr_name)
keys.append(tuple(sorted(tfr.content.keys())))
freq_arrays.append(tuple(tfr.freqs))
time_arrays.append(tuple(tfr.times))
except Exception as exc:
continue
assert_arrays_same(keys, 'Conditions do no match')
assert_arrays_same(freq_arrays, 'Freqs do not match')
assert_arrays_same(time_arrays)
# handle channel differences
ch_names = []
for group_key, group_subjects in groups.items():
for subject_name in group_subjects:
try:
subject = experiment.subjects.get(subject_name)
tfr = subject.tfr.get(tfr_name)
ch_names.append(tuple(clean_names(tfr.ch_names)))
except Exception as exc:
continue
if len(set(ch_names)) != 1:
logging.getLogger('ui_logger').info(
"TFR's contain different sets of channels. Identifying common ones.."
)
common_ch_names = list(set.intersection(*map(set, ch_names)))
logging.getLogger('ui_logger').info(
str(len(common_ch_names)) + ' common channels found.')
else:
common_ch_names = ch_names[0]
grand_tfrs = {}
for group_key, group_subjects in groups.items():
for subject in experiment.subjects.values():
if subject.name not in group_subjects:
continue
meggie_tfr = subject.tfr.get(tfr_name)
if not meggie_tfr:
continue
for tfr_item_key, tfr_item in meggie_tfr.content.items():
grand_key = (group_key, tfr_item_key)
# get common channels in "subject specific space"
subject_ch_names = tfr_item.info['ch_names']
for ch_idx, ch_name in enumerate(
clean_names(subject_ch_names)):
drop_names = []
if ch_name not in common_ch_names:
drop_names.append(subject_ch_names[ch_idx])
tfr_item = tfr_item.copy().drop_channels(drop_names)
# sanity check
if len(tfr_item.info['ch_names']) != len(common_ch_names):
raise Exception('Something wrong with the channels')
if grand_key in grand_tfrs:
grand_tfrs[grand_key].append(tfr_item)
else:
grand_tfrs[grand_key] = [tfr_item]
grand_averages = {}
for key, grand_tfr in grand_tfrs.items():
new_key = str(key[1]) + '_group_' + str(key[0])
if len(grand_tfr) == 1:
grand_averages[new_key] = grand_tfr[0].copy()
else:
grand_averages[new_key] = mne.grand_average(grand_tfr)
active_subject = experiment.active_subject
meggie_tfr = active_subject.tfr.get(tfr_name)
params = {
'decim': meggie_tfr.decim,
'n_cycles': meggie_tfr.n_cycles,
'evoked_subtracted': meggie_tfr.evoked_subtracted,
'conditions': list(grand_averages.keys()),
'groups': groups
}
meggie_tfr = TFR(new_name, active_subject.tfr_directory, params,
grand_averages)
meggie_tfr.save_content()
active_subject.add(meggie_tfr, "tfr")
def group_average_spectrum(experiment, spectrum_name, groups, new_name):
""" Computes a group average spectrum item.
"""
# check data cohesion
keys = []
freq_arrays = []
for group_key, group_subjects in groups.items():
for subject_name in group_subjects:
try:
subject = experiment.subjects.get(subject_name)
spectrum = subject.spectrum.get(spectrum_name)
keys.append(tuple(sorted(spectrum.content.keys())))
freq_arrays.append(tuple(spectrum.freqs))
except Exception as exc:
continue
assert_arrays_same(keys, 'Conditions do not match')
assert_arrays_same(freq_arrays, 'Freqs do not match')
# handle channel differences
ch_names = []
for group_key, group_subjects in groups.items():
for subject_name in group_subjects:
try:
subject = experiment.subjects.get(subject_name)
spectrum = subject.spectrum.get(spectrum_name)
ch_names.append(tuple(clean_names(spectrum.ch_names)))
except Exception as exc:
continue
if len(set(ch_names)) != 1:
logging.getLogger('ui_logger').info(
"PSD's contain different sets of channels. Identifying common ones..")
common_ch_names = list(set.intersection(*map(set, ch_names)))
logging.getLogger('ui_logger').info(
str(len(common_ch_names)) + ' common channels found.')
else:
common_ch_names = ch_names[0]
grand_psds = {}
for group_key, group_subjects in groups.items():
for subject in experiment.subjects.values():
if subject.name not in group_subjects:
continue
spectrum = subject.spectrum.get(spectrum_name)
if not spectrum:
continue
subject_ch_names = clean_names(spectrum.ch_names)
for spectrum_item_key, spectrum_item in spectrum.content.items():
grand_key = (group_key, spectrum_item_key)
# get common channels in "subject specific space"
idxs = [subject_ch_names.index(ch_name) for ch_name
in common_ch_names]
spectrum_item = spectrum_item[idxs]
if grand_key not in grand_psds:
grand_psds[grand_key] = []
grand_psds[grand_key].append(spectrum_item)
grand_averages = {}
for key, grand_psd in grand_psds.items():
new_key = str(key[1]) + '_group_' + str(key[0])
if len(grand_psd) == 1:
grand_averages[new_key] = grand_psd[0].copy()
else:
grand_averages[new_key] = np.mean(grand_psd, axis=0)
subject = experiment.active_subject
try:
spectrum = subject.spectrum.get(spectrum_name)
except Exception as exc:
raise Exception('Active subject should be included in the groups')
spectrum_directory = subject.spectrum_directory
info = spectrum.info
common_idxs = [ch_idx for ch_idx, ch_name in enumerate(clean_names(info['ch_names']))
if ch_name in common_ch_names]
info = mne.pick_info(info, sel=common_idxs)
freqs = spectrum.freqs
data = grand_averages
params = deepcopy(spectrum.params)
# individual intervals not relevant in the group item
params.pop('intervals', None)
params['groups'] = groups
params['conditions'] = [elem for elem in grand_averages.keys()]
spectrum = Spectrum(new_name, subject.spectrum_directory,
params, data, freqs, info)
spectrum.save_content()
subject.add(spectrum, 'spectrum')
