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')