stats = corr_stats.cluster_permutation_test( diff_cons, Behav, cluster_threshold=cluster_threshold, src=fs_src, n_permutations=1000, verbose=True, alpha=0.05, n_jobs=2, seed=10, return_details=True, max_spread=0.01) connection_indices, bundles, bundle_ts, bundle_ps, H0 = stats con_clust = ga_con_diff[connection_indices] # Save some details about the permutation stats to disk write_hdf5('{dir}NEMO_N-P_connect_corr_{c}_{f}-stats.h5'.format(dir=meg_dir, c=cond, f=freq), dict(connection_indices=connection_indices, bundles=bundles, bundle_ts=bundle_ts, bundle_ps=bundle_ps, H0=H0), overwrite=True) # Save the pruned grand average connection object con_clust.save( '{dir}NEMO_N-P_connect_corr_{c}_{f}-pruned-avg-connectivity.h5'.format( dir=meg_dir, c=cond, f=freq))
def _test_raw_reader(reader, test_preloading=True, test_kwargs=True, boundary_decimal=2, test_scaling=True, test_rank=True, **kwargs): """Test reading, writing and slicing of raw classes. Parameters ---------- reader : function Function to test. test_preloading : bool Whether not preloading is implemented for the reader. If True, both cases and memory mapping to file are tested. test_kwargs : dict Test _init_kwargs support. boundary_decimal : int Number of decimals up to which the boundary should match. **kwargs : Arguments for the reader. Note: Do not use preload as kwarg. Use ``test_preloading`` instead. Returns ------- raw : instance of Raw A preloaded Raw object. """ tempdir = _TempDir() rng = np.random.RandomState(0) montage = None if "montage" in kwargs: montage = kwargs['montage'] del kwargs['montage'] if test_preloading: raw = reader(preload=True, **kwargs) rep = repr(raw) assert rep.count('<') == 1 assert rep.count('>') == 1 if montage is not None: raw.set_montage(montage) # don't assume the first is preloaded buffer_fname = op.join(tempdir, 'buffer') picks = rng.permutation(np.arange(len(raw.ch_names) - 1))[:10] picks = np.append(picks, len(raw.ch_names) - 1) # test trigger channel bnd = min(int(round(raw.buffer_size_sec * raw.info['sfreq'])), raw.n_times) slices = [ slice(0, bnd), slice(bnd - 1, bnd), slice(3, bnd), slice(3, 300), slice(None), slice(1, bnd) ] if raw.n_times >= 2 * bnd: # at least two complete blocks slices += [ slice(bnd, 2 * bnd), slice(bnd, bnd + 1), slice(0, bnd + 100) ] other_raws = [ reader(preload=buffer_fname, **kwargs), reader(preload=False, **kwargs) ] for sl_time in slices: data1, times1 = raw[picks, sl_time] for other_raw in other_raws: data2, times2 = other_raw[picks, sl_time] assert_allclose(data1, data2) assert_allclose(times1, times2) # test projection vs cals and data units other_raw = reader(preload=False, **kwargs) other_raw.del_proj() eeg = meg = fnirs = False if 'eeg' in raw: eeg, atol = True, 1e-18 elif 'grad' in raw: meg, atol = 'grad', 1e-24 elif 'mag' in raw: meg, atol = 'mag', 1e-24 else: assert 'fnirs_cw_amplitude' in raw, 'New channel type necessary?' fnirs, atol = 'fnirs_cw_amplitude', 1e-10 picks = pick_types(other_raw.info, meg=meg, eeg=eeg, fnirs=fnirs) col_names = [other_raw.ch_names[pick] for pick in picks] proj = np.ones((1, len(picks))) proj /= proj.shape[1] proj = Projection(data=dict(data=proj, nrow=1, row_names=None, col_names=col_names, ncol=len(picks)), active=False) assert len(other_raw.info['projs']) == 0 other_raw.add_proj(proj) assert len(other_raw.info['projs']) == 1 # Orders of projector application, data loading, and reordering # equivalent: # 1. load->apply->get data_load_apply_get = \ other_raw.copy().load_data().apply_proj().get_data(picks) # 2. apply->get (and don't allow apply->pick) apply = other_raw.copy().apply_proj() data_apply_get = apply.get_data(picks) data_apply_get_0 = apply.get_data(picks[0])[0] with pytest.raises(RuntimeError, match='loaded'): apply.copy().pick(picks[0]).get_data() # 3. apply->load->get data_apply_load_get = apply.copy().load_data().get_data(picks) data_apply_load_get_0, data_apply_load_get_1 = \ apply.copy().load_data().pick(picks[:2]).get_data() # 4. reorder->apply->load->get all_picks = np.arange(len(other_raw.ch_names)) reord = np.concatenate( (picks[1::2], picks[0::2], np.setdiff1d(all_picks, picks))) rev = np.argsort(reord) assert_array_equal(reord[rev], all_picks) assert_array_equal(rev[reord], all_picks) reorder = other_raw.copy().pick(reord) assert reorder.ch_names == [other_raw.ch_names[r] for r in reord] assert reorder.ch_names[0] == other_raw.ch_names[picks[1]] assert_allclose(reorder.get_data([0]), other_raw.get_data(picks[1])) reorder_apply = reorder.copy().apply_proj() assert reorder_apply.ch_names == reorder.ch_names assert reorder_apply.ch_names[0] == apply.ch_names[picks[1]] assert_allclose(reorder_apply.get_data([0]), apply.get_data(picks[1]), atol=1e-18) data_reorder_apply_load_get = \ reorder_apply.load_data().get_data(rev[:len(picks)]) data_reorder_apply_load_get_1 = \ reorder_apply.copy().load_data().pick([0]).get_data()[0] assert reorder_apply.ch_names[0] == apply.ch_names[picks[1]] assert (data_load_apply_get.shape == data_apply_get.shape == data_apply_load_get.shape == data_reorder_apply_load_get.shape) del apply # first check that our data are (probably) in the right units data = data_load_apply_get.copy() data = data - np.mean(data, axis=1, keepdims=True) # can be offsets np.abs(data, out=data) if test_scaling: maxval = atol * 1e16 assert_array_less(data, maxval) minval = atol * 1e6 assert_array_less(minval, np.median(data)) else: atol = 1e-7 * np.median(data) # 1e-7 * MAD # ranks should all be reduced by 1 if test_rank == 'less': cmp = np.less else: cmp = np.equal rank_load_apply_get = np.linalg.matrix_rank(data_load_apply_get) rank_apply_get = np.linalg.matrix_rank(data_apply_get) rank_apply_load_get = np.linalg.matrix_rank(data_apply_load_get) rank_apply_load_get = np.linalg.matrix_rank(data_apply_load_get) assert cmp(rank_load_apply_get, len(col_names) - 1) assert cmp(rank_apply_get, len(col_names) - 1) assert cmp(rank_apply_load_get, len(col_names) - 1) # and they should all match t_kw = dict(atol=atol, err_msg='before != after, likely _mult_cal_one prob') assert_allclose(data_apply_get[0], data_apply_get_0, **t_kw) assert_allclose(data_apply_load_get_1, data_reorder_apply_load_get_1, **t_kw) assert_allclose(data_load_apply_get[0], data_apply_load_get_0, **t_kw) assert_allclose(data_load_apply_get, data_apply_get, **t_kw) assert_allclose(data_load_apply_get, data_apply_load_get, **t_kw) if 'eeg' in raw: other_raw.del_proj() direct = \ other_raw.copy().load_data().set_eeg_reference().get_data() other_raw.set_eeg_reference(projection=True) assert len(other_raw.info['projs']) == 1 this_proj = other_raw.info['projs'][0]['data'] assert this_proj['col_names'] == col_names assert this_proj['data'].shape == proj['data']['data'].shape assert_allclose(this_proj['data'], proj['data']['data']) proj = other_raw.apply_proj().get_data() assert_allclose(proj[picks], data_load_apply_get, atol=1e-10) assert_allclose(proj, direct, atol=1e-10, err_msg=t_kw['err_msg']) else: raw = reader(**kwargs) assert_named_constants(raw.info) full_data = raw._data assert raw.__class__.__name__ in repr(raw) # to test repr assert raw.info.__class__.__name__ in repr(raw.info) assert isinstance(raw.info['dig'], (type(None), list)) data_max = full_data.max() data_min = full_data.min() # these limits could be relaxed if we actually find data with # huge values (in SI units) assert data_max < 1e5 assert data_min > -1e5 if isinstance(raw.info['dig'], list): for di, d in enumerate(raw.info['dig']): assert isinstance(d, DigPoint), (di, d) # gh-5604 meas_date = raw.info['meas_date'] assert meas_date is None or meas_date >= _stamp_to_dt((0, 0)) # test resetting raw if test_kwargs: raw2 = reader(**raw._init_kwargs) assert set(raw.info.keys()) == set(raw2.info.keys()) assert_array_equal(raw.times, raw2.times) # Test saving and reading out_fname = op.join(tempdir, 'test_raw.fif') raw = concatenate_raws([raw]) raw.save(out_fname, tmax=raw.times[-1], overwrite=True, buffer_size_sec=1) # Test saving with not correct extension out_fname_h5 = op.join(tempdir, 'test_raw.h5') with pytest.raises(IOError, match='raw must end with .fif or .fif.gz'): raw.save(out_fname_h5) raw3 = read_raw_fif(out_fname) assert_named_constants(raw3.info) assert set(raw.info.keys()) == set(raw3.info.keys()) assert_allclose(raw3[0:20][0], full_data[0:20], rtol=1e-6, atol=1e-20) # atol is very small but > 0 assert_array_almost_equal(raw.times, raw3.times) assert not math.isnan(raw3.info['highpass']) assert not math.isnan(raw3.info['lowpass']) assert not math.isnan(raw.info['highpass']) assert not math.isnan(raw.info['lowpass']) assert raw3.info['kit_system_id'] == raw.info['kit_system_id'] # Make sure concatenation works first_samp = raw.first_samp last_samp = raw.last_samp concat_raw = concatenate_raws([raw.copy(), raw]) assert concat_raw.n_times == 2 * raw.n_times assert concat_raw.first_samp == first_samp assert concat_raw.last_samp - last_samp + first_samp == last_samp + 1 idx = np.where(concat_raw.annotations.description == 'BAD boundary')[0] expected_bad_boundary_onset = raw._last_time assert_array_almost_equal(concat_raw.annotations.onset[idx], expected_bad_boundary_onset, decimal=boundary_decimal) if raw.info['meas_id'] is not None: for key in ['secs', 'usecs', 'version']: assert raw.info['meas_id'][key] == raw3.info['meas_id'][key] assert_array_equal(raw.info['meas_id']['machid'], raw3.info['meas_id']['machid']) assert isinstance(raw.annotations, Annotations) # Make a "soft" test on units: They have to be valid SI units as in # mne.io.meas_info.valid_units, but we accept any lower/upper case for now. valid_units = _get_valid_units() valid_units_lower = [unit.lower() for unit in valid_units] if raw._orig_units is not None: assert isinstance(raw._orig_units, dict) for ch_name, unit in raw._orig_units.items(): assert unit.lower() in valid_units_lower, ch_name # Test picking with and without preload if test_preloading: preload_kwargs = (dict(preload=True), dict(preload=False)) else: preload_kwargs = (dict(), ) n_ch = len(raw.ch_names) picks = rng.permutation(n_ch) for preload_kwarg in preload_kwargs: these_kwargs = kwargs.copy() these_kwargs.update(preload_kwarg) # don't use the same filename or it could create problems if isinstance(these_kwargs.get('preload', None), str) and \ op.isfile(these_kwargs['preload']): these_kwargs['preload'] += '-1' whole_raw = reader(**these_kwargs) print(whole_raw) # __repr__ assert n_ch >= 2 picks_1 = picks[:n_ch // 2] picks_2 = picks[n_ch // 2:] raw_1 = whole_raw.copy().pick(picks_1) raw_2 = whole_raw.copy().pick(picks_2) data, times = whole_raw[:] data_1, times_1 = raw_1[:] data_2, times_2 = raw_2[:] assert_array_equal(times, times_1) assert_array_equal(data[picks_1], data_1) assert_array_equal( times, times_2, ) assert_array_equal(data[picks_2], data_2) # Make sure that writing info to h5 format # (all fields should be compatible) if check_version('h5py'): fname_h5 = op.join(tempdir, 'info.h5') with _writing_info_hdf5(raw.info): write_hdf5(fname_h5, raw.info) new_info = Info(read_hdf5(fname_h5)) assert object_diff(new_info, raw.info) == '' # Make sure that changing directory does not break anything if test_preloading: these_kwargs = kwargs.copy() key = None for key in ( 'fname', 'input_fname', # artemis123 'vhdr_fname', # BV 'pdf_fname', # BTi 'directory', # CTF 'filename', # nedf ): try: fname = kwargs[key] except KeyError: key = None else: break # len(kwargs) == 0 for the fake arange reader if len(kwargs): assert key is not None, sorted(kwargs.keys()) dirname = op.dirname(fname) these_kwargs[key] = op.basename(fname) these_kwargs['preload'] = False orig_dir = os.getcwd() try: os.chdir(dirname) raw_chdir = reader(**these_kwargs) finally: os.chdir(orig_dir) raw_chdir.load_data() return raw
raw, hp, lp, cov, fwd, defaults.subjects_dir, eps_fname, fslabels, return_generator=True) corr_mats[si, ix] = envelope_correlation(label_ts) # Compute pairwise degree source connectivity amongst labels degrees[si, ix] = mne.connectivity.degree(corr_mats[si, ix]) fout_ = op.join(eps_dir, '%s_%s_fcDs.h5' % (subject, kk)) write_hdf5(fname=fout_, data={ 'corr': corr_mats[si, ix], 'deg': degrees[si, ix] }, overwrite=True) plt.close('all') for ix, (kk, vv) in enumerate(defaults.bands.items()): corr_ = corr_mats[:, ix].mean(0) # Plot group narrow-band corr matrix fig, ax = plt.subplots(figsize=(4, 4)) img = ax.imshow(corr_, cmap='viridis', clim=np.percentile(corr_, [5, 95]), interpolation='nearest', origin='lower') fig.suptitle('%d - %dHz correlation matrix' % (vv[0], vv[1])) fig.colorbar(img, ax=ax) fig.tight_layout()
def run_spatio_temporal_cluster_1samp_test(subjects, cond1, cond2, window_l, window_h, threshold=None, step_down_p=0, n_permutations=1024, n_jobs=1): t0 = time.time() contrasts = list() for subject in subjects: print(f'processing {subject}') # auditory fname_1 = op.join( meg_dir, subject, f'{subject}_audvis-dSPM-{spacing}-inverse-morph-filt-sss-{cond1}-stc' ) # why `crop`: only deal with t > 0 to reduce multiple comparisons # why `T`: transpose to the correct shape stc_1 = mne.read_source_estimate(fname_1).magnitude().crop( window_l, window_h) # visual fname_2 = op.join( meg_dir, subject, f'{subject}_audvis-dSPM-{spacing}-inverse-morph-filt-sss-{cond2}-stc' ) stc_2 = mne.read_source_estimate(fname_2).magnitude().crop( window_l, window_h) stc_diff = stc_1 - stc_2 contrasts.append(stc_diff.data.T) # Get the right shape of difference data contrast_X = np.stack(contrasts, axis=0) # release memory del stc_1, stc_2, stc_diff, contrasts # prepare spatial adjacency fsaverage_src = mne.read_source_spaces( op.join(subjects_dir, 'fsaverage', 'bem', f'fsaverage-{spacing}-src.fif')) adjacency = mne.spatial_src_adjacency(fsaverage_src) # To use the "hat" adjustment method, sigma=1e-3 may be reasonable stat_fun = partial(mne.stats.ttest_1samp_no_p, sigma=1e-3) # Permutation test takes a long time to finish! t_obs, clusters, cluster_pv, H0 = \ mne.stats.spatio_temporal_cluster_1samp_test( contrast_X, adjacency=adjacency, n_jobs=n_jobs, threshold=threshold, stat_fun=stat_fun, verbose=True) # save the result window = f'{int(window_l*1000)}_to_{int(window_h*1000)}' contrast_name = f'{cond1}_vs_{cond2}' cluster_name = op.join(rst_dir, f'{contrast_name}_{window}.h5') write_hdf5(cluster_name, dict(t_obs=t_obs, clusters=clusters, cluster_pv=cluster_pv, H0=H0), title='mnepython', overwrite=True) elaped = time.time() - t0 print(f'Save {cluster_name} after {timedelta(seconds=round(elaped))}')
from joblib import Parallel, delayed subjects = lib.utils.get_subjects(cfg.camcan_meg_raw_path) subjects_dir = cfg.mne_camcan_freesurfer_path mne.utils.set_log_level('warning') def _make_headmodels(subject): # print(subject) # return subject print('running ', subject) error = 'None' try: mne.bem.make_watershed_bem(subject, subjects_dir=subjects_dir, overwrite=True) except Exception as ee: error = str(ee) print(subject, error) outputs = glob.glob( op.join(cfg.mne_camcan_freesurfer_path, subject, 'bem', '*')) return dict(subject=subject, bem_outputs=outputs, error=error) out = Parallel(n_jobs=11)(delayed(_make_headmodels)(subject=subject) for subject in subjects) h5io.write_hdf5('make_head_surfaces_output.h5', out, overwrite=True)
def save_epochs(p, subjects, in_names, in_numbers, analyses, out_names, out_numbers, must_match, decim, run_indices): """Generate epochs from raw data based on events Can only complete after preprocessing is complete. Parameters ---------- p : instance of Parameters Analysis parameters. subjects : list of str Subject names to analyze (e.g., ['Eric_SoP_001', ...]). in_names : list of str Names of input events. in_numbers : list of list of int Event numbers (in scored event files) associated with each name. analyses : list of str Lists of analyses of interest. out_names : list of list of str Event types to make out of old ones. out_numbers : list of list of int Event numbers to convert to (e.g., [[1, 1, 2, 3, 3], ...] would create three event types, where the first two and last two event types from the original list get collapsed over). must_match : list of int Indices from the original in_names that must match in event counts before collapsing. Should eventually be expanded to allow for ratio-based collapsing. decim : int | list of int Amount to decimate. run_indices : array-like | None Run indices to include. """ in_names = np.asanyarray(in_names) old_dict = dict() for n, e in zip(in_names, in_numbers): old_dict[n] = e # let's do some sanity checks if len(in_names) != len(in_numbers): raise RuntimeError('in_names (%d) must have same length as ' 'in_numbers (%d)' % (len(in_names), len(in_numbers))) if np.any(np.array(in_numbers) <= 0): raise ValueError('in_numbers must all be > 0') if len(out_names) != len(out_numbers): raise RuntimeError('out_names must have same length as out_numbers') for name, num in zip(out_names, out_numbers): num = np.array(num) if len(name) != len(np.unique(num[num > 0])): raise RuntimeError('each entry in out_names must have length ' 'equal to the number of unique elements in the ' 'corresponding entry in out_numbers:\n%s\n%s' % (name, np.unique(num[num > 0]))) if len(num) != len(in_names): raise RuntimeError('each entry in out_numbers must have the same ' 'length as in_names') if (np.array(num) == 0).any(): raise ValueError('no element of out_numbers can be zero') ch_namess = list() drop_logs = list() sfreqs = set() for si, subj in enumerate(subjects): if p.disp_files: print(' Loading raw files for subject %s.' % subj) epochs_dir = op.join(p.work_dir, subj, p.epochs_dir) if not op.isdir(epochs_dir): os.mkdir(epochs_dir) evoked_dir = op.join(p.work_dir, subj, p.inverse_dir) if not op.isdir(evoked_dir): os.mkdir(evoked_dir) # read in raw files raw_names = get_raw_fnames(p, subj, 'pca', False, False, run_indices[si]) first_samps = [] last_samps = [] for raw_fname in raw_names: raw = read_raw_fif(raw_fname, preload=False) first_samps.append(raw._first_samps[0]) last_samps.append(raw._last_samps[-1]) raw = [read_raw_fif(fname, preload=False) for fname in raw_names] _fix_raw_eog_cals(raw) # EOG epoch scales might be bad! raw = concatenate_raws(raw) # read in events events = _read_events(p, subj, run_indices[si], raw) new_sfreq = raw.info['sfreq'] / decim[si] if p.disp_files: print(' Epoching data (decim=%s -> sfreq=%0.1f Hz).' % (decim[si], new_sfreq)) if new_sfreq not in sfreqs: if len(sfreqs) > 0: warnings.warn('resulting new sampling frequency %s not equal ' 'to previous values %s' % (new_sfreq, sfreqs)) sfreqs.add(new_sfreq) epochs_fnames, evoked_fnames = get_epochs_evokeds_fnames( p, subj, analyses) mat_file, fif_file = epochs_fnames if p.autoreject_thresholds: assert len(p.autoreject_types) > 0 assert all(a in ('mag', 'grad', 'eeg', 'ecg', 'eog') for a in p.autoreject_types) from autoreject import get_rejection_threshold print(' Computing autoreject thresholds', end='') rtmin = p.reject_tmin if p.reject_tmin is not None else p.tmin rtmax = p.reject_tmax if p.reject_tmax is not None else p.tmax temp_epochs = Epochs(raw, events, event_id=None, tmin=rtmin, tmax=rtmax, baseline=_get_baseline(p), proj=True, reject=None, flat=None, preload=True, decim=decim[si], reject_by_annotation=p.reject_epochs_by_annot) kwargs = dict() if 'verbose' in get_args(get_rejection_threshold): kwargs['verbose'] = False new_dict = get_rejection_threshold(temp_epochs, **kwargs) use_reject = dict() msgs = list() for k in p.autoreject_types: msgs.append('%s=%d %s' % (k, DEFAULTS['scalings'][k] * new_dict[k], DEFAULTS['units'][k])) use_reject[k] = new_dict[k] print(': ' + ', '.join(msgs)) hdf5_file = fif_file.replace('-epo.fif', '-reject.h5') assert hdf5_file.endswith('.h5') write_hdf5(hdf5_file, use_reject, overwrite=True) else: use_reject = _handle_dict(p.reject, subj) # create epochs flat = _handle_dict(p.flat, subj) use_reject, use_flat = _restrict_reject_flat(use_reject, flat, raw) epochs = Epochs(raw, events, event_id=old_dict, tmin=p.tmin, tmax=p.tmax, baseline=_get_baseline(p), reject=use_reject, flat=use_flat, proj=p.epochs_proj, preload=True, decim=decim[si], on_missing=p.on_missing, reject_tmin=p.reject_tmin, reject_tmax=p.reject_tmax, reject_by_annotation=p.reject_epochs_by_annot) del raw if epochs.events.shape[0] < 1: epochs.plot_drop_log() raise ValueError('No valid epochs') drop_logs.append(epochs.drop_log) ch_namess.append(epochs.ch_names) # only kept trials that were not dropped sfreq = epochs.info['sfreq'] # now deal with conditions to save evoked if p.disp_files: print(' Matching trial counts and saving data to disk.') for var, name in ((out_names, 'out_names'), (out_numbers, 'out_numbers'), (must_match, 'must_match'), (evoked_fnames, 'evoked_fnames')): if len(var) != len(analyses): raise ValueError('len(%s) (%s) != len(analyses) (%s)' % (name, len(var), len(analyses))) for analysis, names, numbers, match, fn in zip(analyses, out_names, out_numbers, must_match, evoked_fnames): # do matching numbers = np.asanyarray(numbers) nn = numbers[numbers >= 0] new_numbers = [] for num in numbers: if num > 0 and num not in new_numbers: # Eventually we could relax this requirement, but not # having it in place is likely to cause people pain... if any(num < n for n in new_numbers): raise RuntimeError('each list of new_numbers must be ' ' monotonically increasing') new_numbers.append(num) new_numbers = np.array(new_numbers) in_names_match = in_names[match] # use some variables to allow safe name re-use offset = max(epochs.events[:, 2].max(), new_numbers.max()) + 1 safety_str = '__mnefun_copy__' assert len(new_numbers) == len(names) # checked above if p.match_fun is None: # first, equalize trial counts (this will make a copy) e = epochs[list(in_names[numbers > 0])] if len(in_names_match) > 1: e.equalize_event_counts(in_names_match) # second, collapse relevant types for num, name in zip(new_numbers, names): collapse = [ x for x in in_names[num == numbers] if x in e.event_id ] combine_event_ids(e, collapse, {name + safety_str: num + offset}, copy=False) for num, name in zip(new_numbers, names): e.events[e.events[:, 2] == num + offset, 2] -= offset e.event_id[name] = num del e.event_id[name + safety_str] else: # custom matching e = p.match_fun(epochs.copy(), analysis, nn, in_names_match, names) # now make evoked for each out type evokeds = list() n_standard = 0 kinds = ['standard'] if p.every_other: kinds += ['even', 'odd'] for kind in kinds: for name in names: this_e = e[name] if kind == 'even': this_e = this_e[::2] elif kind == 'odd': this_e = this_e[1::2] else: assert kind == 'standard' if len(this_e) > 0: ave = this_e.average(picks='all') stde = this_e.standard_error(picks='all') if kind != 'standard': ave.comment += ' %s' % (kind, ) stde.comment += ' %s' % (kind, ) evokeds.append(ave) evokeds.append(stde) if kind == 'standard': n_standard += 2 write_evokeds(fn, evokeds) naves = [ str(n) for n in sorted( set([evoked.nave for evoked in evokeds[:n_standard]])) ] naves = ', '.join(naves) if p.disp_files: print(' Analysis "%s": %s epochs / condition' % (analysis, naves)) if p.disp_files: print(' Saving epochs to disk.') if 'mat' in p.epochs_type: spio.savemat(mat_file, dict(epochs=epochs.get_data(), events=epochs.events, sfreq=sfreq, drop_log=epochs.drop_log), do_compression=True, oned_as='column') if 'fif' in p.epochs_type: epochs.save(fif_file, **_get_epo_kwargs()) if p.plot_drop_logs: for subj, drop_log in zip(subjects, drop_logs): plot_drop_log(drop_log, threshold=p.drop_thresh, subject=subj)