def apply_maxfilter(self, st_duration=None, st_correlation=0.98): if not self.raw.info['bads']: warnings.warn("Detecting bad Channel, Please check manually") self.detect_bad_channel() if self.head_pos is None: self.get_headposition() print('Applying maxfilter; This will take time') if self.head_pos is not None: self.raw_sss = maxwell_filter(self.raw, cross_talk=self.ctc_fname, calibration=self.fine_cal_fname, head_pos=self.head_pos, st_duration=st_duration, st_correlation=st_correlation) else: self.raw_sss = maxwell_filter(self.raw, cross_talk=ctc_fname, calibration=fine_cal_fname, st_duration=st_duration, st_correlation=st_correlation) self.maxfilter_applied = True self.raw_sss.save(self.fname_sss, overwrite=True) print('maxfilter done, file saved as {}'.format(self.fname_sss))
def test_sss_proj(): """Test `meg` proj option.""" raw = read_raw_fif(raw_fname) raw.crop(0, 1.0).load_data().pick_types(exclude=()) raw.pick_channels(raw.ch_names[:51]).del_proj() with pytest.raises(ValueError, match='can only be used with Maxfiltered'): compute_proj_raw(raw, meg='combined') raw_sss = maxwell_filter(raw, int_order=5, ext_order=2) sss_rank = 21 # really low due to channel picking assert len(raw_sss.info['projs']) == 0 for meg, n_proj, want_rank in (('separate', 6, sss_rank), ('combined', 3, sss_rank - 3)): proj = compute_proj_raw(raw_sss, n_grad=3, n_mag=3, meg=meg, verbose='error') this_raw = raw_sss.copy().add_proj(proj).apply_proj() assert len(this_raw.info['projs']) == n_proj sss_proj_rank = _compute_rank_int(this_raw) cov = compute_raw_covariance(this_raw, verbose='error') W, ch_names, rank = compute_whitener(cov, this_raw.info, return_rank=True) assert ch_names == this_raw.ch_names assert want_rank == sss_proj_rank == rank # proper reduction if meg == 'combined': assert this_raw.info['projs'][0]['data']['col_names'] == ch_names else: mag_names = ch_names[2::3] assert this_raw.info['projs'][3]['data']['col_names'] == mag_names
def test_sss_proj(): """Test `meg` proj option.""" raw = read_raw_fif(raw_fname) raw.crop(0, 1.0).load_data().pick_types(meg=True, exclude=()) raw.pick_channels(raw.ch_names[:51]).del_proj() raw_sss = maxwell_filter(raw, int_order=5, ext_order=2) sss_rank = 21 # really low due to channel picking assert len(raw_sss.info['projs']) == 0 for meg, n_proj, want_rank in (('separate', 6, sss_rank), ('combined', 3, sss_rank - 3)): proj = compute_proj_raw(raw_sss, n_grad=3, n_mag=3, meg=meg, verbose='error') this_raw = raw_sss.copy().add_proj(proj).apply_proj() assert len(this_raw.info['projs']) == n_proj sss_proj_rank = _compute_rank_int(this_raw) cov = compute_raw_covariance(this_raw, verbose='error') W, ch_names, rank = compute_whitener(cov, this_raw.info, return_rank=True) assert ch_names == this_raw.ch_names assert want_rank == sss_proj_rank == rank # proper reduction if meg == 'combined': assert this_raw.info['projs'][0]['data']['col_names'] == ch_names else: mag_names = ch_names[2::3] assert this_raw.info['projs'][3]['data']['col_names'] == mag_names
def _maxwell_fun(f_name): '''Aux function to run SSS and store shielding calculations''' # Load data, crop, and update magnetometer coil type info raw = mne.io.Raw(op.join(data_dir, f_name), verbose=params['verbose']) erm_error_checks(raw) print ('Time of recording: ' + dt.fromtimestamp(raw.info['meas_date'][0]).strftime('%Y-%m-%d %H:%M:%S') + '\n') raw.crop(tmax=params['erm_len'], copy=False) raw.fix_mag_coil_types() shielding_dict = dict(f_name=f_name) # Store power to get relative change shielding_dict['raw_norm'] = get_power(raw) # Do SSS processing using different calibration files for cal_key, cal_fname in zip(params['cal_keys'], params['cal_fnames']): raw_sss = maxwell_filter(raw, calibration=cal_fname, cross_talk=params['ctc_fname'], st_duration=params['st_duration'], coord_frame=params['coord_frame'], regularize=params['regularize'], verbose=params['verbose']) shielding_dict[cal_key] = comp_shielding(raw, raw_sss) print 'Spatial filtering mean/max:' for cal_key in params['cal_keys']: # Print mean and max shielding factor print (cal_key + '\tMean: {mean} \tMax: {max}'.format( mean=np.mean(shielding_dict[cal_key]), max=np.max(shielding_dict[cal_key]))) return shielding_dict
def process_raw(raw_fname): raw = read_raw_fif(raw_fname, preload=True, allow_maxshield='yes') head_pos = _calculate_chpi_positions(raw=raw) raw = mne.chpi.filter_chpi(raw) raw.fix_mag_coil_types() raw_sss = maxwell_filter(raw, head_pos=head_pos, st_duration=300) raw_sss.save(raw_fname[:-4] + '_sss.fif') return raw, head_pos
def raw_epochs_events(): """Create raw, epochs, and events for tests.""" raw = read_raw_fif(raw_fname).set_eeg_reference(projection=True).crop(0, 3) raw = maxwell_filter(raw, regularize=None) # heavily reduce the rank assert raw.info['bads'] == [] # no bads events = make_fixed_length_events(raw) epochs = Epochs(raw, events, tmin=-0.2, tmax=0, preload=True) return (raw, epochs, events)
def apply_maxfilter_emptyroom(self, st_duration=None): if not self.raw.info['bads']: warnings.warn("Detecting bad Channel, Please check manually") self.detect_bad_channel() self.raw_sss = maxwell_filter(self.raw, coord_frame='meg', regularize=None, cross_talk=self.ctc_fname, calibration=self.fine_cal_fname, origin=(0., 0.013, -0.006)) self.raw_sss.save(self.fname_sss)
def apply_maxfilter(raw_path, bads_path, annot_path, maxfilt_path, is_er): raw = prepare_raw(raw_path, bads_path, annot_path, is_er) coord_frame = "head" if is_er else "meg" raw_sss = maxwell_filter( raw, cross_talk=crosstalk_file, calibration=cal_file, skip_by_annotation=[], coord_frame=coord_frame, ) raw_sss.save(maxfilt_path, overwrite=True)
def test_xdawn_regularization(): """Test Xdawn with regularization.""" # Get data, this time MEG so we can test proper reg/ch type support raw = read_raw_fif(raw_fname, verbose=False, preload=True) events = read_events(event_name) picks = pick_types(raw.info, meg=True, eeg=False, stim=False, ecg=False, eog=False, exclude='bads')[::8] raw.pick_channels([raw.ch_names[pick] for pick in picks]) del picks raw.info.normalize_proj() epochs = Epochs(raw, events, event_id, tmin, tmax, preload=True, baseline=None, verbose=False) # Test with overlapping events. # modify events to simulate one overlap events = epochs.events sel = np.where(events[:, 2] == 2)[0][:2] modified_event = events[sel[0]] modified_event[0] += 1 epochs.events[sel[1]] = modified_event # Fit and check that overlap was found and applied xd = Xdawn(n_components=2, correct_overlap='auto', reg='oas') xd.fit(epochs) assert xd.correct_overlap_ evoked = epochs['cond2'].average() assert np.sum(np.abs(evoked.data - xd.evokeds_['cond2'].data)) # With covariance regularization for reg in [.1, 0.1, 'ledoit_wolf', 'oas']: xd = Xdawn(n_components=2, correct_overlap=False, signal_cov=np.eye(len(epochs.ch_names)), reg=reg) xd.fit(epochs) # With bad shrinkage xd = Xdawn(n_components=2, correct_overlap=False, signal_cov=np.eye(len(epochs.ch_names)), reg=2) with pytest.raises(ValueError, match='shrinkage must be'): xd.fit(epochs) # With rank-deficient input raw = maxwell_filter(raw, int_order=4, ext_order=2) xd = Xdawn(correct_overlap=False, reg=None) # this is a bit wacky because `epochs` has projectors on from the old raw # but it works as a rank-deficient test case with pytest.raises(ValueError, match='Could not compute eigenvalues'): xd.fit(epochs) xd = Xdawn(correct_overlap=False, reg=0.5) xd.fit(epochs) xd = Xdawn(correct_overlap=False, reg='diagonal_fixed') xd.fit(epochs)
def test_xdawn_regularization(): """Test Xdawn with regularization.""" # Get data, this time MEG so we can test proper reg/ch type support raw = read_raw_fif(raw_fname, verbose=False, preload=True) events = read_events(event_name) picks = pick_types(raw.info, meg=True, eeg=False, stim=False, ecg=False, eog=False, exclude='bads')[::8] raw.pick_channels([raw.ch_names[pick] for pick in picks]) del picks raw.info.normalize_proj() epochs = Epochs(raw, events, event_id, tmin, tmax, preload=True, baseline=None, verbose=False) # Test with overlapping events. # modify events to simulate one overlap events = epochs.events sel = np.where(events[:, 2] == 2)[0][:2] modified_event = events[sel[0]] modified_event[0] += 1 epochs.events[sel[1]] = modified_event # Fit and check that overlap was found and applied xd = Xdawn(n_components=2, correct_overlap='auto', reg='oas') xd.fit(epochs) assert_equal(xd.correct_overlap_, True) evoked = epochs['cond2'].average() assert_true(np.sum(np.abs(evoked.data - xd.evokeds_['cond2'].data))) # With covariance regularization for reg in [.1, 0.1, 'ledoit_wolf', 'oas']: xd = Xdawn(n_components=2, correct_overlap=False, signal_cov=np.eye(len(epochs.ch_names)), reg=reg) xd.fit(epochs) # With bad shrinkage xd = Xdawn(n_components=2, correct_overlap=False, signal_cov=np.eye(len(epochs.ch_names)), reg=2) with pytest.raises(ValueError, match='shrinkage must be'): xd.fit(epochs) # With rank-deficient input raw = maxwell_filter(raw, int_order=4, ext_order=2) xd = Xdawn(correct_overlap=False, reg=None) # this is a bit wacky because `epochs` has projectors on from the old raw # but it works as a rank-deficient test case with pytest.raises(ValueError, match='Could not compute eigenvalues'): xd.fit(epochs) xd = Xdawn(correct_overlap=False, reg=0.5) xd.fit(epochs) xd = Xdawn(correct_overlap=False, reg='diagonal_fixed') xd.fit(epochs)
def run_maxfilter(sub_id, raw, cal_fname, ctc_fname, show_figs=False, results_dir=None): """Run maxfilter on one subject""" raw = maxwell_filter(raw, origin='auto', calibration=cal_fname, cross_talk=ctc_fname, st_duration=10) if show_figs or results_dir is not None: fig = raw.plot_psd(show=show_figs) if results_dir is not None: sub_dir = os.path.join(results_dir, sub_id) # Create a dir with the ID name if not os.path.exists(sub_dir): os.mkdir(sub_dir) fig.savefig(os.path.join(sub_dir, f'sss_{sub_id}_psd.png')) return sub_id, raw
raw_stat = mne.io.read_raw_fif(op.join(data_path, 'simulated_stationary_raw.fif')) ############################################################################### # Visualize the "subject" head movements (traces) mne.viz.plot_head_positions(pos, mode='traces') ############################################################################### # Process our simulated raw data (taking into account head movements) # extract our resulting events events = mne.find_events(raw, stim_channel='STI 014') events[:, 2] = 1 raw.plot(events=events) topo_kwargs = dict(times=[0, 0.1, 0.2], ch_type='mag', vmin=-500, vmax=500) # 0. Take average of stationary data (bilateral auditory patterns) evoked_stat = mne.Epochs(raw_stat, events, 1, -0.2, 0.8).average() evoked_stat.plot_topomap(title='Stationary', **topo_kwargs) # 1. Take a naive average (smears activity) evoked = mne.Epochs(raw, events, 1, -0.2, 0.8).average() evoked.plot_topomap(title='Moving: naive average', **topo_kwargs) # 2. Use raw movement compensation (restores pattern) raw_sss = maxwell_filter(raw, head_pos=pos) evoked_raw_mc = mne.Epochs(raw_sss, events, 1, -0.2, 0.8).average() evoked_raw_mc.plot_topomap(title='Moving: movement compensated', **topo_kwargs)
raw.info['bads'] = ['MEG 2443', 'EEG 053', 'MEG 1032', 'MEG 2313'] # set bads ##..........................................................................## ## Ploting Data ## raw.plot_psd(fmax=100) raw.plot(duration=5, n_channels=30) #****************************************************************************# # Preprocessing # #****************************************************************************# ##..........................................................................## ## Maxwell Filter ## # Here we don't use tSSS (set st_duration) because MGH data is very clean raw_sss = maxwell_filter(raw, cross_talk=ctc_fname, calibration=fine_cal_fname) raw.plot_psd(fmax=100) raw_sss.plot_psd(fmax=100) ##..........................................................................## ## Band-pass Filter ## tmin, tmax = 0, 20 # use the first 20s of data # Setup for reading the raw data (save memory by cropping the raw data # before loading it) raw_sss.crop(tmin, tmax).load_data() raw_sss.info['bads'] = ['MEG 2443', 'EEG 053'] # bads + 2 more n_fft = 2048 # the FFT size (n_fft). Ideally a power of 2
def test_low_rank(): """Test low-rank covariance matrix estimation.""" raw = read_raw_fif(raw_fname).set_eeg_reference(projection=True).crop(0, 3) raw = maxwell_filter(raw, regularize=None) # heavily reduce the rank sss_proj_rank = 139 # 80 MEG + 60 EEG - 1 proj n_ch = 366 proj_rank = 365 # one EEG proj events = make_fixed_length_events(raw) methods = ('empirical', 'diagonal_fixed', 'oas') epochs = Epochs(raw, events, tmin=-0.2, tmax=0, preload=True) bounds = { 'None': dict(empirical=(-6000, -5000), diagonal_fixed=(-1500, -500), oas=(-700, -600)), 'full': dict(empirical=(-9000, -8000), diagonal_fixed=(-2000, -1600), oas=(-1600, -1000)), } for rank in ('full', None): covs = compute_covariance( epochs, method=methods, return_estimators=True, verbose='error', rank=rank) for cov in covs: method = cov['method'] these_bounds = bounds[str(rank)][method] this_rank = _cov_rank(cov, epochs.info) if rank is None or method == 'empirical': assert this_rank == sss_proj_rank else: assert this_rank == proj_rank assert these_bounds[0] < cov['loglik'] < these_bounds[1], \ (rank, method) if method == 'empirical': emp_cov = cov # save for later, rank param does not matter # Test equivalence with mne.cov.regularize subspace with pytest.raises(ValueError, match='are dependent.*must equal'): regularize(emp_cov, epochs.info, rank=None, mag=0.1, grad=0.2) assert _cov_rank(emp_cov, epochs.info) == sss_proj_rank reg_cov = regularize(emp_cov, epochs.info, proj=True, rank='full') assert _cov_rank(reg_cov, epochs.info) == proj_rank del reg_cov with catch_logging() as log: reg_r_cov = regularize(emp_cov, epochs.info, proj=True, rank=None, verbose=True) log = log.getvalue() assert 'jointly' in log assert _cov_rank(reg_r_cov, epochs.info) == sss_proj_rank reg_r_only_cov = regularize(emp_cov, epochs.info, proj=False, rank=None) assert _cov_rank(reg_r_only_cov, epochs.info) == sss_proj_rank assert_allclose(reg_r_only_cov['data'], reg_r_cov['data']) del reg_r_only_cov, reg_r_cov # test that rank=306 is same as rank='full' epochs_meg = epochs.copy().pick_types() assert len(epochs_meg.ch_names) == 306 epochs_meg.info.update(bads=[], projs=[]) cov_full = compute_covariance(epochs_meg, method='oas', rank='full', verbose='error') assert _cov_rank(cov_full, epochs_meg.info) == 306 cov_dict = compute_covariance(epochs_meg, method='oas', rank=306, verbose='error') assert _cov_rank(cov_dict, epochs_meg.info) == 306 assert_allclose(cov_full['data'], cov_dict['data']) # Work with just EEG data to simplify projection / rank reduction raw.pick_types(meg=False, eeg=True) n_proj = 2 raw.add_proj(compute_proj_raw(raw, n_eeg=n_proj)) n_ch = len(raw.ch_names) rank = n_ch - n_proj - 1 # plus avg proj assert len(raw.info['projs']) == 3 epochs = Epochs(raw, events, tmin=-0.2, tmax=0, preload=True) assert len(raw.ch_names) == n_ch emp_cov = compute_covariance(epochs, rank='full', verbose='error') assert _cov_rank(emp_cov, epochs.info) == rank reg_cov = regularize(emp_cov, epochs.info, proj=True, rank='full') assert _cov_rank(reg_cov, epochs.info) == rank reg_r_cov = regularize(emp_cov, epochs.info, proj=False, rank=None) assert _cov_rank(reg_r_cov, epochs.info) == rank dia_cov = compute_covariance(epochs, rank=None, method='diagonal_fixed', verbose='error') assert _cov_rank(dia_cov, epochs.info) == rank assert_allclose(dia_cov['data'], reg_cov['data']) # test our deprecation: can simply remove later epochs.pick_channels(epochs.ch_names[:103]) # degenerate with pytest.raises(ValueError, match='can.*only be used with rank="full"'): compute_covariance(epochs, rank=None, method='pca') with pytest.raises(ValueError, match='can.*only be used with rank="full"'): compute_covariance(epochs, rank=None, method='factor_analysis')
picks = mne.pick_types(raw.info, meg=True, exclude='bads') raw.filter(1, 40, **filter_params) events = mne.find_events(raw, stim_channel='STI101', consecutive='increasing', mask=4352, mask_type='not_and', min_duration=0.003, verbose=True) evoked_before = Epochs(raw, events, event_id=event_ids, picks=picks).average() ############################################################################### # Then Maxfiltered and SSS'd data. raw = mne.io.read_raw_fif(raw_fname_in, preload=True, add_eeg_ref=False) raw_sss = mne.io.read_raw_fif(sss_fname_in, preload=True, add_eeg_ref=False) raw.info['bads'] = bads raw_sss.info['bads'] = bads raw = maxwell_filter(raw, calibration=cal, cross_talk=ctc) raw.filter(1, 40, **filter_params) raw_sss.filter(1, 40, **filter_params) evoked_after = Epochs(raw, events, event_id=event_ids, picks=picks).average() evoked_sss = Epochs(raw_sss, events, event_id=event_ids, picks=picks).average() ############################################################################### # Plotting ylim = dict(grad=(-100, 100), mag=(-400, 400)) evoked_before.plot(spatial_colors=True, ylim=ylim, titles={'grad': 'Gradiometers before SSS', 'mag': 'Magnetometers before SSS'}) evoked_after.plot(spatial_colors=True, ylim=ylim, titles={'grad': 'SSS gradiometers',
def test_low_rank(): """Test low-rank covariance matrix estimation.""" raw = read_raw_fif(raw_fname).set_eeg_reference(projection=True).crop(0, 3) raw = maxwell_filter(raw, regularize=None) # heavily reduce the rank sss_proj_rank = 139 # 80 MEG + 60 EEG - 1 proj n_ch = 366 proj_rank = 365 # one EEG proj events = make_fixed_length_events(raw) methods = ('empirical', 'diagonal_fixed', 'oas') epochs = Epochs(raw, events, tmin=-0.2, tmax=0, preload=True) bounds = { 'None': dict(empirical=(-6000, -5000), diagonal_fixed=(-1500, -500), oas=(-700, -600)), 'full': dict(empirical=(-9000, -8000), diagonal_fixed=(-2000, -1600), oas=(-1600, -1000)), } for rank in ('full', None): covs = compute_covariance(epochs, method=methods, return_estimators=True, verbose='error', rank=rank) for cov in covs: method = cov['method'] these_bounds = bounds[str(rank)][method] this_rank = _cov_rank(cov, epochs.info) if rank is None or method == 'empirical': assert this_rank == sss_proj_rank else: assert this_rank == proj_rank assert these_bounds[0] < cov['loglik'] < these_bounds[1], \ (rank, method) if method == 'empirical': emp_cov = cov # save for later, rank param does not matter # Test equivalence with mne.cov.regularize subspace with pytest.raises(ValueError, match='are dependent.*must equal'): regularize(emp_cov, epochs.info, rank=None, mag=0.1, grad=0.2) assert _cov_rank(emp_cov, epochs.info) == sss_proj_rank reg_cov = regularize(emp_cov, epochs.info, proj=True, rank='full') assert _cov_rank(reg_cov, epochs.info) == proj_rank del reg_cov with catch_logging() as log: reg_r_cov = regularize(emp_cov, epochs.info, proj=True, rank=None, verbose=True) log = log.getvalue() assert 'jointly' in log assert _cov_rank(reg_r_cov, epochs.info) == sss_proj_rank reg_r_only_cov = regularize(emp_cov, epochs.info, proj=False, rank=None) assert _cov_rank(reg_r_only_cov, epochs.info) == sss_proj_rank assert_allclose(reg_r_only_cov['data'], reg_r_cov['data']) del reg_r_only_cov, reg_r_cov # test that rank=306 is same as rank='full' epochs_meg = epochs.copy().pick_types() assert len(epochs_meg.ch_names) == 306 epochs_meg.info.update(bads=[], projs=[]) cov_full = compute_covariance(epochs_meg, method='oas', rank='full', verbose='error') assert _cov_rank(cov_full, epochs_meg.info) == 306 cov_dict = compute_covariance(epochs_meg, method='oas', rank=306, verbose='error') assert _cov_rank(cov_dict, epochs_meg.info) == 306 assert_allclose(cov_full['data'], cov_dict['data']) # Work with just EEG data to simplify projection / rank reduction raw.pick_types(meg=False, eeg=True) n_proj = 2 raw.add_proj(compute_proj_raw(raw, n_eeg=n_proj)) n_ch = len(raw.ch_names) rank = n_ch - n_proj - 1 # plus avg proj assert len(raw.info['projs']) == 3 epochs = Epochs(raw, events, tmin=-0.2, tmax=0, preload=True) assert len(raw.ch_names) == n_ch emp_cov = compute_covariance(epochs, rank='full', verbose='error') assert _cov_rank(emp_cov, epochs.info) == rank reg_cov = regularize(emp_cov, epochs.info, proj=True, rank='full') assert _cov_rank(reg_cov, epochs.info) == rank reg_r_cov = regularize(emp_cov, epochs.info, proj=False, rank=None) assert _cov_rank(reg_r_cov, epochs.info) == rank dia_cov = compute_covariance(epochs, rank=None, method='diagonal_fixed', verbose='error') assert _cov_rank(dia_cov, epochs.info) == rank assert_allclose(dia_cov['data'], reg_cov['data']) # test our deprecation: can simply remove later epochs.pick_channels(epochs.ch_names[:103]) # degenerate with pytest.raises(ValueError, match='can.*only be used with rank="full"'): compute_covariance(epochs, rank=None, method='pca') with pytest.raises(ValueError, match='can.*only be used with rank="full"'): compute_covariance(epochs, rank=None, method='factor_analysis')
print('Converting %s to .fif file and applying maxwell filtering' % (result)) result = result.replace('.con', '') result = result.replace('.', '_') result = result.replace(' ', '_') result = result + '_raw_tsss.fif' print('Importing MNE') import mne from mne.preprocessing import maxwell_filter print('Loading data...') # Load Raw raw = mne.io.read_raw_kit(confile, mrk=mrkfile, elp=elpfile, hsp=hspfile, verbose=True) ## Check if any bad channels have been specified if args.bad_chan is not None: raw.info['bads'] = args.bad_chan print('Perorming maxwell_filter (tSSS)') ## Perform tSSS raw_tsss = maxwell_filter(raw, st_duration=60, st_correlation=0.9) print('Saving data') ## Save as .fif file raw_tsss.save(result, buffer_size_sec=1)
def process_one(dipole_no, amp, n_components, crop_idx, crop_len=None): raw_fname = "%sAmp%d_Dip%d_IASoff.fif" % (get_root_dir(), amp, dipole_no) raw = read_raw_fif(raw_fname) raw.load_data() raw.crop(5, None) if crop_len is not None: raw.crop(crop_idx * crop_len, (crop_idx + 1) * crop_len) raw.fix_mag_coil_types() events = find_events(raw, "SYS201") picks = mne.pick_types(raw.info, meg="mag", eeg=False, eog=False, stim=False, exclude="bads") n_bins = 40 freqs = np.linspace(1, 70, n_bins + 1) smica = ICA(n_components, freqs, rng=0).fit( raw, picks=picks, em_it=50000, n_it_lbfgs=200, tol=1e-8, verbose=100, n_it_min=10000, ) ica = ICA_mne(n_components, method="picard").fit(raw.copy().filter(1, 70), picks=picks) jdiag = JDIAG_mne(n_components, freqs, rng=0).fit(raw, picks=picks) tmin, tmax = -0.1, 0.1 event_id = [dipole_no] # pows = np.linalg.norm(smica.A, axis=0) * # np.linalg.norm(smica.powers, axis=0) ** .5 raw_max = raw.copy().filter(1, 40) raw_max = maxwell_filter(raw_max, origin=(0.0, 0.0, 0.0)) epochs = mne.Epochs( raw_max, events, event_id, tmin, tmax, baseline=(None, -0.01), preload=True, picks=picks, ) cov = mne.compute_covariance(epochs, tmax=0) e1 = get_error(epochs, cov) e_2 = get_error_A(smica.A, cov, epochs.info) good = np.argmin(e_2[0]) e2 = [e_2[0][good], e_2[1][good]] e_3 = get_error_A(jdiag.A, cov, epochs.info) good = np.argmin(e_3[0]) e3 = [e_3[0][good], e_3[1][good]] e_4 = get_error_A(ica.get_components(), cov, epochs.info) good = np.argmin(e_4[0]) e4 = [e_4[0][good], e_4[1][good]] crop_str = crop_len if crop_len is not None else 0 np.save( "results/phantom_%d_%d_%d_%d_%d.npy" % (dipole_no, amp, n_components, crop_idx, crop_str), np.array([e1, e2, e3, e4]), ) print(e1, e2, e3, e4) return e1, e2, e3, e4
'/meg16_0097/160512/', #16 '/meg16_0122/160707/', #17 '/meg16_0125/160712/', #18 ] for i in np.arange(0, len(subjects)): meg = subjects[i] # complete path to raw data raw_fname_fruit = main_path + meg + 'block4_fruit.fif' raw_fname_odour = main_path + meg + 'block3_odour.fif' raw_fname_milk = main_path + meg + 'block2_milk.fif' # loading raw data raw_fruit = mne.io.Raw(raw_fname_fruit, preload=True) raw_odour = mne.io.Raw(raw_fname_odour, preload=True) raw_milk = mne.io.Raw(raw_fname_milk , preload=True) # It is critical to mark MEG bad channels in raw.info['bads'] prior to # processing in order to prevent artifact spreading raw_fruit.info['bads'] = [] raw_odour.info['bads'] = [] raw_milk.info['bads'] = [] raw_sss = maxwell_filter(raw_fruit, calibration = calibration, cross_talk=cross_talk , destination = raw_fname_fruit)
# The head positions in the FIF file are all zero for invalid positions # so let's remove them, and then concatenate our times. mask = (head_pos != 0).any(axis=0) head_pos = np.concatenate((t[np.newaxis], head_pos)).T[mask] # In this dataset due to old MaxFilter (2.2.10), data are uniformly # sampled at 1 Hz, so we save some processing time in # maxwell_filter by downsampling. skip = int(round(raw_sss_mf.info['sfreq'])) head_pos = head_pos[::skip] ############################################################################### # Run :func:`mne.preprocessing.maxwell_filter`, and band-pass filter the data. raw_sss_py = maxwell_filter(raw, calibration=cal, cross_talk=ctc, origin=origin, head_pos=head_pos) del raw raw_sss_py.filter(l_freq, 40, **filter_params) raw_sss_mf.filter(l_freq, 40, **filter_params) evoked_sss_py = Epochs(raw_sss_py, events, event_id=event_ids, tmax=tmax).average() evoked_sss_mf = Epochs(raw_sss_mf, events, event_id=event_ids, tmax=tmax).average() ############################################################################### # Plotting
def apply_max_move(self, dest_filename): self.raw_sss = maxwell_filter(self.raw, cross_talk=self.ctc_fname, calibration=self.fine_cal_fname, destination=dest_filename)
print('\n'.join(sys.path)) subjects_dir = '/Users/ktavabi/Data/freesufer' n_jobs = 2 raw_fname = '/Users/ktavabi/Data/genzds/genz_bo_resting_01_raw.fif' raw = mne.io.read_raw_fif(raw_fname, preload=True, allow_maxshield='yes') head_pos = mne.chpi._calculate_chpi_positions(raw=raw) mne.viz.plot_head_positions(head_pos, mode='traces', destination=raw.info['dev_head_t'], info=raw.info, show=True) # Denoise if not op.isfile(raw_fname[:-4] + '_sss.fif'): raw = mne.chpi.filter_chpi(raw) raw.fix_mag_coil_types() raw_sss = maxwell_filter(raw, head_pos=head_pos, st_duration=300) raw_sss.save(raw_fname[:-4] + '_sss.fif') else: raw_sss = mne.io.read_raw_fif(raw_fname[:-4] + '_sss.fif', preload=True) # artifact correction ecg_projs, events = compute_proj_ecg(raw_sss, n_grad=3, n_mag=3, n_eeg=0, average=True) print(ecg_projs) mne.viz.plot_projs_topomap(ecg_projs) eog_projs, events = compute_proj_eog(raw_sss, n_grad=3, n_mag=3,
import mne from mne.preprocessing import maxwell_filter print(__doc__) data_path = mne.datasets.sample.data_path() ############################################################################### # Set parameters raw_fname = data_path + "/MEG/sample/sample_audvis_raw.fif" ctc_fname = data_path + "/SSS/ct_sparse_mgh.fif" fine_cal_fname = data_path + "/SSS/sss_cal_mgh.dat" # Preprocess with Maxwell filtering raw = mne.io.Raw(raw_fname) raw.info["bads"] = ["MEG 2443", "EEG 053", "MEG 1032", "MEG 2313"] # set bads # Here we don't use tSSS (set st_duration) because MGH data is very clean raw_sss = maxwell_filter(raw, cross_talk=ctc_fname, calibration=fine_cal_fname) # Select events to extract epochs from, pick M/EEG channels, and plot evoked tmin, tmax = -0.2, 0.5 event_id = {"Auditory/Left": 1} events = mne.find_events(raw, "STI 014") picks = mne.pick_types(raw.info, meg=True, eeg=False, stim=False, eog=True, include=[], exclude="bads") for r, kind in zip((raw, raw_sss), ("Raw data", "Maxwell filtered data")): epochs = mne.Epochs( r, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=dict(eog=150e-6), preload=False ) evoked = epochs.average() evoked.plot(window_title=kind)
raw_stat = mne.io.read_raw_fif( op.join(data_path, 'simulated_stationary_raw.fif')) ############################################################################### # Visualize the "subject" head movements (traces) mne.viz.plot_head_positions(pos, mode='traces') ############################################################################### # Process our simulated raw data (taking into account head movements) # extract our resulting events events = mne.find_events(raw, stim_channel='STI 014') events[:, 2] = 1 raw.plot(events=events) topo_kwargs = dict(times=[0, 0.1, 0.2], ch_type='mag', vmin=-500, vmax=500) # 0. Take average of stationary data (bilateral auditory patterns) evoked_stat = mne.Epochs(raw_stat, events, 1, -0.2, 0.8).average() evoked_stat.plot_topomap(title='Stationary', **topo_kwargs) # 1. Take a naive average (smears activity) evoked = mne.Epochs(raw, events, 1, -0.2, 0.8).average() evoked.plot_topomap(title='Moving: naive average', **topo_kwargs) # 2. Use raw movement compensation (restores pattern) raw_sss = maxwell_filter(raw, head_pos=pos) evoked_raw_mc = mne.Epochs(raw_sss, events, 1, -0.2, 0.8).average() evoked_raw_mc.plot_topomap(title='Moving: movement compensated', **topo_kwargs)
# Interpolate bad EEG channels raw.info['bads'] = bad_EEG[nip] raw.interpolate_bads() raw.info['bads'] = bad_MEG[nip] ####################################################################### ############################ Maxfilter data ########################### ####################################################################### sss_file_path = data_sss_directory + '/' + nip + '/' + raw_file_path.split( '/')[-1] sss_file_path = '_sss_raw'.join(sss_file_path.split('_raw')) sss_raw = maxwell_filter(raw, calibration=cal_path, cross_talk=ct_path, verbose=False, destination=refrun_path, bad_condition='warning') sss_raw.save(sss_file_path, overwrite=True, verbose=False) report.add_figs_to_section(sss_raw.plot(), captions=raw_file_path, section=nip) ####################################################################### ######################## Close and save report ######################## ####################################################################### # Delete variables del raw, sss_raw # Save report report.save(os.getcwd() + '/1_maxFilter.html',
##..........................................................................## ## Ploting Data ## raw.plot_psd(fmax=100) raw.plot(duration=5, n_channels=30) #****************************************************************************# # Preprocessing # #****************************************************************************# ##..........................................................................## ## Maxwell Filter ## # Here we don't use tSSS (set st_duration) because MGH data is very clean #raw_sss = maxwell_filter(raw, cross_talk=ctc_fname, calibration=fine_cal_fname) raw_sss = maxwell_filter(raw, calibration=None, cross_talk=None) raw_sss.plot_psd(fmax=100) ##..........................................................................## ## Band-pass Filter ## raw_sss.filter(None, 40., fir_design='firwin') raw_sss.plot_psd(fmax=100) raw_sss.filter(1., None, fir_design='firwin') raw_sss.plot_psd(fmax=100) ##..........................................................................## ## Down Sampling ##
# Load data, crop, and update magnetometer coil type info raw = mne.io.Raw(op.join(data_dir, f_name), verbose=params['verbose'], allow_maxshield=False) # Error checks, crop data, and fix coil types coilNoise_error_checks(raw) raw.crop(tmax=params['n_secs'], copy=False) raw.fix_mag_coil_types() shielding_dict = dict(f_name=f_name, freq=freq) # Do SSS processing using different calibration files for cal_key, cal_fname in zip(params['cal_keys'], params['cal_fnames']): raw_sss = maxwell_filter(raw, calibration=cal_fname, cross_talk=params['ctc_fname'], st_duration=params['st_duration'], coord_frame=params['coord_frame'], regularize=params['regularize'], verbose=params['verbose']) shielding_dict[cal_key] = comp_shielding(raw, raw_sss) print 'Spatial filtering mean/max:' for cal_key in params['cal_keys']: # Print mean and max shielding factor print (cal_key + '\tMean: {mean} \tMax: {max}'.format( mean=np.mean(shielding_dict[cal_key]), max=np.max(shielding_dict[cal_key]))) sf_list.append(shielding_dict) ####################################################
# f.write('{},{}\n'.format(meg[1:11],auto_noisy_chs_f + auto_flat_chs_f)) # f.close() # with open('MEG_bad_channels_odour.csv', 'a') as f: # f.write('{},{}\n'.format(meg[1:11],auto_noisy_chs_o + auto_flat_chs_o)) # f.close() # with open('MEG_bad_channels_milk.csv', 'a') as f: # f.write('{},{}\n'.format(meg[1:11],auto_noisy_chs_m + auto_flat_chs_m)) # f.close() # with open('MEG_bad_channels_LD.csv', 'a') as f: # f.write('{},{}\n'.format(meg[1:11],auto_noisy_chs_l + auto_flat_chs_l)) # f.close() # Maxwell filtering data raw_sss_fruit = maxwell_filter(raw_fruit, calibration=calibration, cross_talk=cross_talk, destination=CBU_path + meg + destination_files[i]) raw_sss_odour = maxwell_filter(raw_odour, calibration=calibration, cross_talk=cross_talk, destination=CBU_path + meg + destination_files[i]) raw_sss_milk = maxwell_filter(raw_milk, calibration=calibration, cross_talk=cross_talk, destination=CBU_path + meg + destination_files[i]) raw_sss_LD = maxwell_filter(raw_LD, calibration=calibration, cross_talk=cross_talk,
def test_compute_fine_cal(): """Test computing fine calibration coefficients.""" raw = read_raw_fif(erm_fname) want_cal = read_fine_calibration(cal_mf_fname) got_cal, counts = compute_fine_calibration(raw, cross_talk=ctc, n_imbalance=1, verbose='debug') assert counts == 1 assert set(got_cal.keys()) == set(want_cal.keys()) assert got_cal['ch_names'] == want_cal['ch_names'] # in practice these should never be exactly 1. assert sum([(ic == 1.).any() for ic in want_cal['imb_cals']]) == 0 assert sum([(ic == 1.).any() for ic in got_cal['imb_cals']]) == 0 got_imb = np.array(got_cal['imb_cals'], float) want_imb = np.array(want_cal['imb_cals'], float) assert got_imb.shape == want_imb.shape == (306, 1) got_imb, want_imb = got_imb[:, 0], want_imb[:, 0] orig_locs = np.array([ch['loc'] for ch in raw.info['chs'][:306]]) want_locs = want_cal['locs'] got_locs = got_cal['locs'] assert want_locs.shape == got_locs.shape orig_trans = _loc_to_coil_trans(orig_locs) want_trans = _loc_to_coil_trans(want_locs) got_trans = _loc_to_coil_trans(got_locs) dist = np.linalg.norm(got_trans[:, :3, 3] - want_trans[:, :3, 3], axis=1) assert_allclose(dist, 0., atol=1e-6) dist = np.linalg.norm(got_trans[:, :3, 3] - orig_trans[:, :3, 3], axis=1) assert_allclose(dist, 0., atol=1e-6) orig_quat = rot_to_quat(orig_trans[:, :3, :3]) want_quat = rot_to_quat(want_trans[:, :3, :3]) got_quat = rot_to_quat(got_trans[:, :3, :3]) want_orig_angles = np.rad2deg(_angle_between_quats(want_quat, orig_quat)) got_want_angles = np.rad2deg(_angle_between_quats(got_quat, want_quat)) got_orig_angles = np.rad2deg(_angle_between_quats(got_quat, orig_quat)) for key in ('mag', 'grad'): # imb_cals value p = pick_types(raw.info, meg=key, exclude=()) r2 = np.dot(got_imb[p], want_imb[p]) / (np.linalg.norm(want_imb[p]) * np.linalg.norm(got_imb[p])) assert 0.99 < r2 <= 1.00001, f'{key}: {r2:0.3f}' # rotation angles want_orig_max_angle = want_orig_angles[p].max() got_orig_max_angle = got_orig_angles[p].max() got_want_max_angle = got_want_angles[p].max() if key == 'mag': assert 8 < want_orig_max_angle < 11, want_orig_max_angle assert 1 < got_orig_max_angle < 2, got_orig_max_angle assert 9 < got_want_max_angle < 11, got_want_max_angle else: # Some of these angles are large, but mostly this has to do with # processing a very short (one 10-sec segment), downsampled (90 Hz) # file assert 66 < want_orig_max_angle < 68, want_orig_max_angle assert 67 < got_orig_max_angle < 107, got_orig_max_angle assert 53 < got_want_max_angle < 60, got_want_max_angle kwargs = dict(bad_condition='warning', cross_talk=ctc, coord_frame='meg') raw_sss = maxwell_filter(raw, **kwargs) raw_sss_mf = maxwell_filter(raw, calibration=cal_mf_fname, **kwargs) raw_sss_py = maxwell_filter(raw, calibration=got_cal, **kwargs) _assert_shielding(raw_sss, raw, 26, 27) _assert_shielding(raw_sss_mf, raw, 61, 63) _assert_shielding(raw_sss_py, raw, 61, 63) # redoing with given mag data should yield same result got_cal_redo, _ = compute_fine_calibration(raw, cross_talk=ctc, n_imbalance=1, calibration=got_cal, verbose='debug') assert got_cal['ch_names'] == got_cal_redo['ch_names'] assert_allclose(got_cal['imb_cals'], got_cal_redo['imb_cals'], atol=5e-5) assert_allclose(got_cal['locs'], got_cal_redo['locs'], atol=1e-6) assert sum([(ic == 1.).any() for ic in got_cal['imb_cals']]) == 0 # redoing with 3 imlabance parameters should improve the shielding factor grad_picks = pick_types(raw.info, meg='grad') assert len(grad_picks) == 204 and grad_picks[0] == 0 got_grad_imbs = np.array( [got_cal['imb_cals'][pick] for pick in grad_picks]) assert got_grad_imbs.shape == (204, 1) got_cal_3, _ = compute_fine_calibration(raw, cross_talk=ctc, n_imbalance=3, calibration=got_cal, verbose='debug') got_grad_3_imbs = np.array( [got_cal_3['imb_cals'][pick] for pick in grad_picks]) assert got_grad_3_imbs.shape == (204, 3) corr = np.corrcoef(got_grad_3_imbs[:, 0], got_grad_imbs[:, 0])[0, 1] assert 0.6 < corr < 0.7 raw_sss_py = maxwell_filter(raw, calibration=got_cal_3, **kwargs) _assert_shielding(raw_sss_py, raw, 68, 70)