OSCR

The Mismatch Negativity Compared: EEG, SQUID‐MEG, and Novel 4 Helium‐OPMs

Code ↔ Paper

12 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 12 matches
  1. [1] § Materials and Methods › Data Analysis ↔ Fig_S2-3a.py, lines 475–524 · score 0.58 · spatiotemporal cluster, cluster forming, permutation, threshold, window, sensors
  2. [2] § Materials and Methods › Data Analysis ↔ B2_SQUID_IndividualStats.py, lines 37–122 · score 0.58 · cluster permutation, cluster forming, matrix, threshold, odd, epochs
  3. [3] § Materials and Methods › Data Preprocessing ↔ A1_SQUID-SQUIDEEG_preproc.py, lines 309–318 · score 0.57 · eye movement artifacts, regress, EOG, Preprocessing, epoched, SQUID
  4. [4] § Materials and Methods › Data Preprocessing ↔ A3_OPM-EEG_preproc.py, lines 250–257 · score 0.57 · eye movement artifacts, regress, EOG, Preprocessing, epoched, OPM
  5. [5] § Materials and Methods › Data Analysis ↔ REV_EEG-SNR.py, lines 101–147 · score 0.55 · MLC51, MLF46, MRF41, MLC25, selection, LC11
  6. [6] § Materials and Methods › Data Analysis ↔ Fig4.py, lines 100–147 · score 0.54 · MLC51, MLF46, MRF41, MLC25, selection, LC11
  7. [7] § Materials and Methods › Data Preprocessing ↔ A1_SQUID-SQUIDEEG_preproc.py, lines 57–125 · score 0.52 · SDs, breaks, segments, spikes, omitted, amplitude
  8. [8] § Materials and Methods › Data Preprocessing ↔ A2_OPM_preproc.py, lines 69–108 · score 0.52 · SDs, breaks, segments, spikes, omitted, amplitude
  9. [9] § Materials and Methods › Data Preprocessing ↔ A2_OPM_preproc.py, lines 225–255 · score 0.51 · linear regression, rolling, channel, filtered, Preprocessing, OPM
  10. [10] § Results › Significant MMN for SQUID‐MEG, EEG, and OPM‐MEG ↔ B3_OPM_IndividualStats.py, lines 39–96 · score 0.51 · 118–196 ms, left cluster, 118 ms, OPM, SQUID
  11. [11] § Results › Significant MMN for SQUID‐MEG, EEG, and OPM‐MEG ↔ Fig2_OPM.py, lines 65–81 · score 0.50 · 118–196 ms, left cluster, 118 ms, OPM, SQUID
  12. [12] § Materials and Methods › Data Analysis ↔ REV_EEG-SNR.py, lines 101–147 · score 0.50 · selection bias, SNR, baseline, peak, sub, 250 ms

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 431 lines · 17 KB · no license · 2 matches

  1. #Preamble
  2. import os.path as op
  3. from os import listdir
  4. import mne
  5. import numpy as np
  6. import autoreject as ar
  7. import matplotlib.pyplot as plt
  8. plt.ion()
  10. #Task parameters
  11. tmin,tmax =-0.2, 0.41 #time before and after trigger. Tones are spaced 610ms apart
  12. bl_min,bl_max=-0.2,0 #baseline start and end (None for either first or last sample)
  13. highpass,lowpass = 2,45 #bandpass frequencies
  14. highpass_final,lowpass_final=2,20 #after preproc, but before epoching, apply more stingent filter
  15. line_freq=[50,100,150] #notch filter frequency(/ies)
  16. final_samp_rate=1000 #Output sampling rate
  17. use_previous_rejection=1 #load rejection parameters from previous dataset, for consistency when reanalysing with different parameters
  18. use_autoreject=1
  20. #define file name
  21. data_path = '/sps/cermep/opm/NEW_MEG/HV'
  23. #Get datasets
  24. dirs = [int(d) for d in listdir(data_path) if op.isdir(op.join(data_path, d)) and d.isnumeric()]
  25. dirs.sort()
  27. #Let user select subject
  28. print('Available Subjects: ')
  29. sub_list=[]
  30. for d in range(len(dirs)):
  31. ds_files=[d for d in listdir(op.join(data_path, str(dirs[d]).zfill(2))) if '.ds' in d and 'MEG' in d and 'MMN' in d]
  32. if len(ds_files)>0:
  33. print(str(dirs[d]).zfill(2))
  34. sub_list.append(str(dirs[d]).zfill(2))
  36. input_given=False
  37. while not input_given:
  38. inp = input('Select Subject: ') #Ask for user input
  39. if inp.isdecimal() and np.any(np.isin(dirs,int(inp))):
  40. print('Subject '+inp+' selected')
  41. subject=inp.zfill(2)
  42. input_given=True
  43. else:
  44. print('Incorrect input, please try again')
  46. print('Retreiving sessions..')
  47. print('Loading data')
  48. ds_files=[d for d in listdir(op.join(data_path, subject)) if '.ds' in d and 'MEG' in d and 'MMN' in d]
  49. ds_files.sort()
  51. ses_nr=[int(d[-5:-3]) for d in ds_files]
  52. ses_nr=np.sort(ses_nr)
  53. runs=[]
  54. for s in range(len(ses_nr)):
  55. runs.append(ds_files[0][:-5] +str(ses_nr[s]).zfill(2) +'.ds')
  57. #AUDIO triggers:
  58. # '1' - normal audio
  59. # '2' - oddball
  60. #rename for EEG
  61. rename = {
  62. 'EEG001-2800': 'Fp1',
  63. 'EEG002-2800': 'Fp2',
  64. 'EEG003-2800': 'AFz',
  65. 'EEG004-2800': 'F1',
  66. 'EEG005-2800': 'F2',
  67. 'EEG006-2800': 'FC5',
  68. 'EEG007-2800': 'FCz',
  69. 'EEG008-2800': 'FC6',
  70. 'EEG009-2800': 'C1',
  71. 'EEG010-2800': 'C2',
  72. 'EEG011-2800': 'TP9',
  73. 'EEG012-2800': 'TP10',
  74. 'EEG013-2800': 'P7',
  75. 'EEG014-2800': 'P8',
  76. }
  78. st_1020=mne.channels.make_standard_montage('standard_1020')
  80. all_raw=[]
  81. for i_run in runs:
  82. print('Loading ' +i_run)
  83. file_name=op.join(data_path, subject, i_run)
  85. raw = mne.io.read_raw_ctf(file_name, preload=True)
  87. raw.rename_channels(rename)
  88. raw.set_montage(st_1020, match_alias=rename,on_missing='ignore')
  90. if len(raw.ch_names) > 100: #ignore EEG only datasets (OPMEEG)
  92. #apply third order gradient compensation (if not already done)
  93. raw.apply_gradient_compensation(3)
  95. if subject=='02':
  96. raw.resample(1200)
  98. #define event IDs
  99. events, event_dict=mne.events_from_annotations(raw)
  101. #mark breaks in the data
  102. break_annots = mne.preprocessing.annotate_break(
  103. raw=raw,
  104. events=events,
  105. min_break_duration=9, # consider segments of at least 5 s duration
  106. t_start_after_previous=4, # buffer time after last event, carefull of edge effects
  107. t_stop_before_next=4 # stop annotation 4 s before beginning of next one
  108. )
  109. raw.set_annotations(raw.annotations + break_annots) #Mark breaks in raw data
  111. #Remove spikes from data
  112. #Reject by amplitude, use standard deviation of the raw data
  113. raw_tmp=raw.copy().pick_types(meg=True,eeg=False,ref_meg=False).resample(500).filter(l_freq=highpass, h_freq=lowpass)
  114. dat=raw_tmp.get_data(picks='meg',reject_by_annotation='omit')
  115. p2p=((np.abs(np.diff(dat,axis=1))))
  116. n_sds=15 #how many SD to set as threshold
  117. spike_annots, spike_bads = mne.preprocessing.annotate_amplitude(
  118. raw_tmp,
  119. peak=np.median(p2p)+np.std(p2p)*n_sds
  120. )
  121. raw.set_annotations(raw.annotations + spike_annots) #add these annotations to the raw data
  123. all_raw.append(raw) #add annotated raw session to the whole
  125. raw=mne.concatenate_raws(all_raw, on_mismatch='warn')
  127. #get events from concatenated RAW
  128. events, event_dict=mne.events_from_annotations(raw)
  130. #Recode events such that standard sounds preceding an oddbal are coded differently.
  131. events[:,2][np.where(events[:,2]==2)[0]-1]=6
  132. event_dict['std_preOdd'] = 6
  134. #save event structure for trial order reconstruction
  135. print('Saving events')
  136. ev_file=op.join(data_path,'group','MMN',subject+'_SQUID_eve.fif')
  137. mne.write_events(ev_file, events,overwrite=True)
  139. #select true standard tone event
  140. event_ids=np.unique(events[:,2])
  141. event_count=[np.sum(events[:,2]==d) for d in event_ids]
  142. std_id=event_ids[np.array(event_count).argsort()][-1:][0]
  143. std_code=[s for s in event_dict.keys() if event_dict[s]==std_id]
  145. #Split data in MEG and EEG data
  146. raw_meg=raw.copy().pick_types(meg=True,eeg=False,ref_meg=True)
  147. raw_eeg=raw.copy().pick_types(meg=False,eeg=True,ref_meg=True)
  148. if subject=='04':
  149. picks_eog=['EEG064-2800']
  150. else:
  151. picks_eog=['EEG063-2800','EEG064-2800']
  153. raw_eog=raw.copy().pick_channels(picks_eog)
  154. picks_eeg=[c for c in raw_eeg.ch_names if c not in picks_eog]
  155. raw_eeg=raw_eeg.pick_channels(picks_eeg) #remove eog from EEG
  157. #filter raw data
  158. raw_eog_filt=raw_eog.copy().notch_filter(freqs=line_freq).filter(l_freq=highpass, h_freq=lowpass)
  159. raw_meg_filt=raw_meg.copy().notch_filter(freqs=line_freq).filter(l_freq=highpass, h_freq=lowpass)
  160. raw_eeg_filt=raw_eeg.copy().notch_filter(freqs=line_freq).filter(l_freq=highpass, h_freq=lowpass)
  162. if subject=='09':
  163. print('WARNING: Check raw data for residual bad sections!')
  165. #Create downsampled datasets for ICA
  166. raw_meg_ICA=raw_meg_filt.copy().resample(500)
  167. raw_eeg_ICA=raw_eeg_filt.copy().resample(500)
  169. #ICA
  170. ica_meg = mne.preprocessing.ICA(n_components=30,method='fastica',random_state=42)
  171. ica_meg.fit(raw_meg_ICA)
  172. if not use_previous_rejection:
  173. ica_meg.plot_sources(raw_meg_ICA)
  174. ica_meg.plot_components()
  176. #BAD MEG ICA components
  177. ICA_meg_reject = {
  178. '01' : [0,1,13.25],
  179. '02' : [7,10,16,23,29],
  180. '04' : [6,14,24],
  181. '06' : [0,7,11],
  182. '07' : [6,11,22],
  183. '08' : [1,6,9,10],
  184. '09' : [4,6,23,28], #depends on manual marking of bad areas!
  185. '10' : [1,4,24],
  186. '14' : [0,2,4,28],
  187. '15' : [2,7,9,10],
  188. '16' : [3,5,15],
  189. '17' : [0,2,3,16],
  190. '18' : [0,5,8],
  191. '19' : [0,4,13],
  192. '21' : [0,1,5,12,25],
  193. '22' : [0,16,20],
  194. '24' : [0,4,6,28]
  195. }
  197. if use_previous_rejection:
  198. raw_meg_clean=ica_meg.apply(raw_meg_filt,exclude=ICA_meg_reject[subject])
  199. else:
  200. raw_meg_clean=ica_meg.apply(raw_meg_filt)
  202. #inspect EEG for bad channels
  203. if not use_previous_rejection:
  204. raw_eeg_ICA.plot()
  206. #MARK bad channel(s) in browser
  207. bad_channels = {
  208. '01' : [15],
  209. '02' : [15],
  210. '04' : [15,62],
  211. '06' : [15],
  212. '07' : [15],
  213. '08' : [2,15],
  214. '09' : [15],
  215. '10' : [15],
  216. '14' : [15],
  217. '15' : [15],
  218. '16' : [15],
  219. '17' : [15],
  220. '18' : [15],
  221. '19' : [15],
  222. '21' : [15],
  223. '22' : [15],
  224. '24' : [15]
  225. }
  227. bads = [rename['EEG0' +str(d).zfill(2)+ '-2800'] for d in bad_channels[subject] if d<15]+['EEG0' +str(d).zfill(2)+ '-2800' for d in bad_channels[subject] if d>14]
  229. raw_eeg_ICA.info['bads']=bads
  230. raw_eeg_filt.info['bads']=bads
  232. ica_eeg = mne.preprocessing.ICA(method='fastica',random_state=42)
  233. ica_eeg.fit(raw_eeg_ICA)
  235. if not use_previous_rejection:
  236. ica_eeg.plot_sources(raw_eeg_ICA)
  237. ica_eeg.plot_components()
  239. raw_ep=raw_eeg_filt.copy()
  240. event_id={'1' : event_dict['1'], '2' : event_dict['2']} #Trigger
  241. tmp_epochs=mne.Epochs(raw_ep,events,event_id=event_id,tmin=tmin,tmax=tmax,preload=True)
  242. tmp_epochs.resample(500)
  243. ica_eeg.plot_sources(tmp_epochs)
  245. #Mark BAD EEG ICA components
  246. ICA_eeg_reject = {
  247. '01' : [0,1,3,11],
  248. '02' : [0,6,7],
  249. '04' : [0],
  250. '06' : [0,2,5,10,11,13],
  251. '07' : [0,1],
  252. '08' : [0,1,7],
  253. '09' : [0,1,3,4],
  254. '10' : [1,2,9],
  255. '14' : [0,1,3,7,11],
  256. '15' : [0,1,6],
  257. '16' : [1],
  258. '17' : [0,1,9],
  259. '18' : [0,1,2,3,4],
  260. '19' : [0,7,8],
  261. '21' : [0,1,3],
  262. '22' : [0,7,12],
  263. '24' : [0,1,5]
  264. }
  266. if use_previous_rejection:
  267. raw_eeg_clean=ica_eeg.apply(raw_eeg_filt,exclude=ICA_eeg_reject[subject])
  268. else:
  269. raw_eeg_clean=ica_eeg.apply(raw_eeg_filt)
  271. #add EOG back in
  272. raw_meg_clean.add_channels([raw_eog_filt])
  273. raw_eeg_clean.add_channels([raw_eog_filt])
  275. #Bandpass filter
  276. print('Wide Bandpass filter')
  277. raw_meg_filt=raw_meg_clean.filter(l_freq=None, h_freq=lowpass_final) # bandpass
  278. raw_eeg_filt=raw_eeg_clean.filter(l_freq=None, h_freq=lowpass_final) # bandpass
  280. ## EPOCH
  281. #get events
  282. print('Creating epoch')
  283. event_id_std={std_code[0] : event_dict[std_code[0]]} #Standard tone (exl pre-odd)
  284. event_id_odd={'2' : event_dict['2']} #Trigger
  285. event_id_stdPreOdd={'std_preOdd' : event_dict['std_preOdd']} #Trigger
  286. event_id_all={std_code[0] : event_dict[std_code[0]],'2' : event_dict['2'], 'std_preOdd' : event_dict['std_preOdd']} #Trigger
  288. #Cut epochs
  289. meg_epochs_odd=mne.Epochs(raw_meg_clean,events,event_id=event_id_odd,tmin=tmin,tmax=tmax,preload=True)
  290. meg_epochs_std=mne.Epochs(raw_meg_clean,events,event_id=event_id_std,tmin=tmin,tmax=tmax,preload=True)
  291. meg_epochs_stdPreOdd=mne.Epochs(raw_meg_clean,events,event_id=event_id_stdPreOdd,tmin=tmin,tmax=tmax,preload=True)
  292. meg_epochs_all=mne.Epochs(raw_meg_clean,events,event_id=event_id_all,tmin=tmin,tmax=tmax,preload=True)
  293. eeg_epochs_odd=mne.Epochs(raw_eeg_clean,events,event_id=event_id_odd,tmin=tmin,tmax=tmax,preload=True)
  294. eeg_epochs_std=mne.Epochs(raw_eeg_clean,events,event_id=event_id_std,tmin=tmin,tmax=tmax,preload=True)
  295. eeg_epochs_stdPreOdd=mne.Epochs(raw_eeg_clean,events,event_id=event_id_stdPreOdd,tmin=tmin,tmax=tmax,preload=True)
  296. eeg_epochs_all=mne.Epochs(raw_eeg_clean,events,event_id=event_id_all,tmin=tmin,tmax=tmax,preload=True)
  298. #now resample to output sampling rate
  299. print('Resampling.')
  300. meg_epochs_odd.resample(final_samp_rate)
  301. meg_epochs_std.resample(final_samp_rate)
  302. meg_epochs_stdPreOdd.resample(final_samp_rate)
  303. meg_epochs_all.resample(final_samp_rate)
  304. eeg_epochs_odd.resample(final_samp_rate)
  305. eeg_epochs_std.resample(final_samp_rate)
  306. eeg_epochs_stdPreOdd.resample(final_samp_rate)
  307. eeg_epochs_all.resample(final_samp_rate)
  309. #Correct eye movement artifacts using regression
  310. print('Correcting for eye movements')
  311. meg_epochsTMP=meg_epochs_all.subtract_evoked() #create epochs for regression estimation
  312. eeg_epochsTMP=eeg_epochs_all.subtract_evoked()
  313. if subject=='04':
  314. picks_eog=['EEG064-2800']
  315. else:
  316. picks_eog=['EEG063-2800','EEG064-2800']
  317. meg_epochsTMP.set_eeg_reference(ref_channels=[])
  318. eeg_epochsTMP.set_eeg_reference('average')
  320. #fit model
  321. meg_model_EOG = mne.preprocessing.EOGRegression(picks='meg',picks_artifact=picks_eog).fit(meg_epochsTMP)
  322. eeg_model_EOG = mne.preprocessing.EOGRegression(picks='eeg',picks_artifact=picks_eog).fit(eeg_epochsTMP)
  324. #apply model
  325. meg_epochs_odd.set_eeg_reference(ref_channels=[])
  326. meg_epochs_std.set_eeg_reference(ref_channels=[])
  327. meg_epochs_stdPreOdd.set_eeg_reference(ref_channels=[])
  328. meg_epochs_all.set_eeg_reference(ref_channels=[])
  329. meg_epochs_odd=meg_model_EOG.apply(meg_epochs_odd)
  330. meg_epochs_std=meg_model_EOG.apply(meg_epochs_std)
  331. meg_epochs_stdPreOdd=meg_model_EOG.apply(meg_epochs_stdPreOdd)
  332. meg_epochs_all=meg_model_EOG.apply(meg_epochs_all)
  334. eeg_epochs_odd.set_eeg_reference('average')
  335. eeg_epochs_std.set_eeg_reference('average')
  336. eeg_epochs_stdPreOdd.set_eeg_reference('average')
  337. eeg_epochs_all.set_eeg_reference('average')
  338. eeg_epochs_odd=eeg_model_EOG.apply(eeg_epochs_odd)
  339. eeg_epochs_std=eeg_model_EOG.apply(eeg_epochs_std)
  340. eeg_epochs_stdPreOdd=eeg_model_EOG.apply(eeg_epochs_stdPreOdd)
  341. eeg_epochs_all=eeg_model_EOG.apply(eeg_epochs_all)
  343. #drop eog
  344. print('Removing EOG from data')
  345. meg_epochs_odd=meg_epochs_odd.pick_types(meg=True,eeg=False,ref_meg=True)
  346. meg_epochs_std=meg_epochs_std.pick_types(meg=True,eeg=False,ref_meg=True)
  347. meg_epochs_stdPreOdd=meg_epochs_stdPreOdd.pick_types(meg=True,eeg=False,ref_meg=True)
  348. meg_epochs_all=meg_epochs_all.pick_types(meg=True,eeg=False,ref_meg=True)
  349. eeg_epochs_odd=eeg_epochs_odd.pick_channels(picks_eeg)
  350. eeg_epochs_std=eeg_epochs_std.pick_channels(picks_eeg)
  351. eeg_epochs_stdPreOdd=eeg_epochs_stdPreOdd.pick_channels(picks_eeg)
  352. eeg_epochs_all=eeg_epochs_all.pick_channels(picks_eeg)
  354. #baselining
  355. print('Baselining')
  356. meg_epochs_odd.apply_baseline(baseline=(bl_min,bl_max))
  357. meg_epochs_std.apply_baseline(baseline=(bl_min,bl_max))
  358. meg_epochs_stdPreOdd.apply_baseline(baseline=(bl_min,bl_max))
  359. meg_epochs_all.apply_baseline(baseline=(bl_min,bl_max))
  360. eeg_epochs_odd.apply_baseline(baseline=(bl_min,bl_max))
  361. eeg_epochs_std.apply_baseline(baseline=(bl_min,bl_max))
  362. eeg_epochs_stdPreOdd.apply_baseline(baseline=(bl_min,bl_max))
  363. eeg_epochs_all.apply_baseline(baseline=(bl_min,bl_max))
  366. #Autoreject
  367. #MEG
  368. if use_autoreject:
  369. print('MEG - Using autoreject to discard artifactual epochs')
  370. rejectTHRES = ar.get_rejection_threshold(meg_epochs_all, decim=2,random_state=42,ch_types='mag') #get AR threshold
  371. print('MEG Threshold: ' +str(rejectTHRES['mag']))
  373. drop_odd=meg_epochs_odd.copy().drop_bad(reject=rejectTHRES,verbose='WARNING') #check resulting rejection
  374. print('MEG - Odd condition portion of data kept: ' +str(len(drop_odd)/np.shape(meg_epochs_odd)[0]*100)+ '%')
  375. meg_epochs_odd=meg_epochs_odd.drop_bad(reject=rejectTHRES,verbose='WARNING') #check resulting rejection
  377. drop_std=meg_epochs_std.copy().drop_bad(reject=rejectTHRES,verbose='WARNING') #check resulting rejection
  378. print('MEG - Std condition portion of data kept: ' +str(len(drop_std)/np.shape(meg_epochs_std)[0]*100)+ '%')
  379. meg_epochs_std=meg_epochs_std.drop_bad(reject=rejectTHRES,verbose='WARNING') #check resulting rejection
  381. drop_stdPreOdd=meg_epochs_stdPreOdd.copy().drop_bad(reject=rejectTHRES,verbose='WARNING') #check resulting rejection
  382. print('MEG - Std preceding Odd condition portion of data kept: ' +str(len(drop_stdPreOdd)/np.shape(meg_epochs_stdPreOdd)[0]*100)+ '%')
  383. meg_epochs_stdPreOdd=meg_epochs_stdPreOdd.drop_bad(reject=rejectTHRES,verbose='WARNING') #check resulting rejection
  385. print('EEG: Using autoreject to discard artifactual epochs')
  386. rejectTHRES = ar.get_rejection_threshold(eeg_epochs_all, decim=2,random_state=42,ch_types='eeg') #get AR threshold
  387. print('Threshold: ' +str(rejectTHRES['eeg']))
  389. drop_odd=eeg_epochs_odd.copy().drop_bad(reject=rejectTHRES,verbose='WARNING') #check resulting rejection
  390. print('EEG Odd - Portion of data kept: ' +str(len(drop_odd)/np.shape(eeg_epochs_odd)[0]*100)+ '%')
  391. eeg_epochs_odd=eeg_epochs_odd.drop_bad(reject=rejectTHRES,verbose='WARNING') #check resulting rejection
  393. drop_std=eeg_epochs_std.copy().drop_bad(reject=rejectTHRES,verbose='WARNING') #check resulting rejection
  394. print('EEG Std - Portion of data kept: ' +str(len(drop_std)/np.shape(eeg_epochs_std)[0]*100)+ '%')
  395. eeg_epochs_std=eeg_epochs_std.drop_bad(reject=rejectTHRES,verbose='WARNING') #check resulting rejection
  397. drop_stdPreOdd=eeg_epochs_stdPreOdd.copy().drop_bad(reject=rejectTHRES,verbose='WARNING') #check resulting rejection
  398. print('EEG Std preceding Odd - Portion of data kept: ' +str(len(drop_stdPreOdd)/np.shape(eeg_epochs_stdPreOdd)[0]*100)+ '%')
  399. eeg_epochs_stdPreOdd=eeg_epochs_stdPreOdd.drop_bad(reject=rejectTHRES,verbose='WARNING') #check resulting rejection
  402. #save
  403. print('Saving epochs..')
  404. meg_epochs_odd.save(op.join(data_path,'group','MMN','epochs',subject+'_SQUID_odd-epo.fif'),overwrite=True)
  405. meg_epochs_std.save(op.join(data_path,'group','MMN','epochs',subject+'_SQUID_std-epo.fif'),overwrite=True)
  406. meg_epochs_stdPreOdd.save(op.join(data_path,'group','MMN','epochs',subject+'_SQUID_stdPreOdd-epo.fif'),overwrite=True)
  407. eeg_epochs_odd.save(op.join(data_path,'group','MMN','epochs',subject+'_SQUIDEEG_odd-epo.fif'),overwrite=True)
  408. eeg_epochs_std.save(op.join(data_path,'group','MMN','epochs',subject+'_SQUIDEEG_std-epo.fif'),overwrite=True)
  409. eeg_epochs_stdPreOdd.save(op.join(data_path,'group','MMN','epochs',subject+'_SQUIDEEG_stdPreOdd-epo.fif'),overwrite=True)
  410. print('Done.')
  412. #Create evoked
  413. meg_evoked_odd=meg_epochs_odd.average()
  414. meg_evoked_std=meg_epochs_std.average()
  415. meg_evoked_stdPreOdd=meg_epochs_stdPreOdd.average()
  416. eeg_evoked_odd=eeg_epochs_odd.average()
  417. eeg_evoked_std=eeg_epochs_std.average()
  418. eeg_evoked_stdPreOdd=eeg_epochs_stdPreOdd.average()
  421. #save
  422. print('Saving evoked..')
  423. meg_evoked_odd.save(op.join(data_path,'group','MMN','evoked',subject+'_SQUID_odd-ave.fif'),overwrite=True)
  424. meg_evoked_std.save(op.join(data_path,'group','MMN','evoked',subject+'_SQUID_std-ave.fif'),overwrite=True)
  425. meg_evoked_stdPreOdd.save(op.join(data_path,'group','MMN','evoked',subject+'_SQUID_stdPreOdd-ave.fif'),overwrite=True)
  426. eeg_evoked_odd.save(op.join(data_path,'group','MMN','evoked',subject+'_SQUIDEEG_odd-ave.fif'),overwrite=True)
  427. eeg_evoked_std.save(op.join(data_path,'group','MMN','evoked',subject+'_SQUIDEEG_std-ave.fif'),overwrite=True)
  428. eeg_evoked_stdPreOdd.save(op.join(data_path,'group','MMN','evoked',subject+'_SQUIDEEG_stdPreOdd-ave.fif'),overwrite=True)
  429. print('Done.')
  431. print('Finished subject ' +subject)

A1_SQUID-SQUIDEEG_preproc.py at commit 5e93aed, no license · at the source

Overview

Authors: Tjerk P Gutteling1,2, Jérémie Mattout2, Sébastien Daligault1, Julien Jung3, Etienne Labyt4, Denis Schwartz1,2, Françoise Lecaignard2
ORCID iDs: Tjerk P Gutteling, Julien Jung, Françoise Lecaignard
  1. CERMEP‐Imagerie du Vivant, MEG Departement, Lyon, France
  2. CNRS, INSERM, Centre de Recherche en Neurosciences de Lyon CRNL U1028, UMR5292, COPHY, Université Claude Bernard Lyon 1, Bron, France
  3. CNRS, INSERM, Centre de Recherche en Neurosciences de Lyon CRNL U1028, UMR5292, EDUWELL, Université Claude Bernard Lyon 1, Bron, France
  4. MAG4Health, Grenoble, France
Institutions: Lyon 1 Université (France); Centre National de la Recherche Scientifique (France); Inserm (France); Centre de Recherche en Neurosciences de Lyon (France); Centre d'Exploration et de Recherche Médicale par Emission de Positons (France); Calcul, Cognition et Neurophysiologie (France)
Journal: n/a, volume 46, issue 14, article e70368
Dates: received 14 March 2025; accepted 17 September 2025; published online 27 September 2025; in print October 2025
Type: Other · Language: English
License: none stated
Identifiers: DOI 10.1002/hbm.70368 · PMCID PMC12476031 · OpenAlex W4414565259
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), MEG (modality), human (organism), cognitive (subfield)
Methods: Spectral & time-frequency, Connectivity, Statistics, Smoothing, state filtering, decompositions, Preprocessing, Evoked potentials, Physiology & signal measures
Keywords: auditory, EEG, MEG, MMN, OPM
MeSH: Auditory Perception*, Brain*, Electroencephalography*, Evoked Potentials, Auditory*, Magnetoencephalography*, Magnetometry*, Acoustic Stimulation, Adult, Female, Humans, Male, Young Adult (* major topic)
Topic: Neuroscience and Music Perception (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Région Auvergne-Rhône-Alpes; France Life Imaging (ANR-11-INBS-0006); Labex Cortex (ANR-11-LABX-0042)
Citations: cited by 4 papers (Europe PMC); 65 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (none stated) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

Its files are read in the Code ↔ Paper reader above, with 12 matches between paragraphs and lines of code.

tgutteling/OPM_MMN

License: none: the authors keep all their rights
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 5e93aeda27c2708aca8653052b2c08eb1943976e, 21 October 2025
Languages: Python (16)
Size: 17 files, 16 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Matplotlib (16 files), MNE-Python (16 files), NumPy (16 files), SciPy (7 files), seaborn (4 files), autoreject (3 files), scikit-learn (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
17 files
At the source: github.com/tgutteling/OPM_MMN

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 16 scripts, each with its path and the digest of its content;
  • 12 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Code and data availability statement

The paper has a code and data availability statement. Its license (none stated) does not allow reproducing it here; in short, from what the harvester recognized in it:

  • it points to the authors' code: tgutteling/OPM_MMN
  • it says that the data are available on request

Read it in the paper: doi.org/10.1002/hbm.70368.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 7 authors, 5 keywords, 12 MeSH terms, 3 funders, 65 references.

Cite

This paper

Gutteling, T. P., Mattout, J., Daligault, S., Jung, J., Labyt, E., Schwartz, D., & Lecaignard, F. (2025). The Mismatch Negativity Compared: EEG, SQUID‐MEG, and Novel 4 Helium‐OPMs. Human Brain Mapping, 46(14), e70368. https://doi.org/10.1002/hbm.70368

BibTeX

@article{gutteling2025mismatch,
author = {Gutteling, Tjerk P and Mattout, Jérémie and Daligault, Sébastien and Jung, Julien and Labyt, Etienne and Schwartz, Denis and Lecaignard, Françoise},
title = {{The Mismatch Negativity Compared: EEG, SQUID‐MEG, and Novel 4 Helium‐OPMs}},
journal = {Human Brain Mapping},
year = {2025},
volume = {46},
number = {14},
pages = {e70368},
publisher = {Wiley},
issn = {1065-9471},
doi = {10.1002/hbm.70368},
url = {https://doi.org/10.1002/hbm.70368},
pmcid = {PMC12476031}
}

RIS

TY - JOUR
AU - Gutteling, Tjerk P
AU - Mattout, Jérémie
AU - Daligault, Sébastien
AU - Jung, Julien
AU - Labyt, Etienne
AU - Schwartz, Denis
AU - Lecaignard, Françoise
TI - The Mismatch Negativity Compared: EEG, SQUID‐MEG, and Novel 4 Helium‐OPMs
T2 - Human Brain Mapping
J2 - Hum Brain Mapp
PY - 2025
DA - 2025
VL - 46
IS - 14
SP - e70368
SN - 1065-9471
PB - Wiley
DO - 10.1002/hbm.70368
UR - https://doi.org/10.1002/hbm.70368
LA - en
ER -

CSL-JSON

{
"id": "10.1002/hbm.70368",
"type": "article-journal",
"title": "The Mismatch Negativity Compared: EEG, SQUID‐MEG, and Novel 4 Helium‐OPMs",
"container-title": "Human Brain Mapping",
"author": [
{
"family": "Gutteling",
"given": "Tjerk P"
},
{
"family": "Mattout",
"given": "Jérémie"
},
{
"family": "Daligault",
"given": "Sébastien"
},
{
"family": "Jung",
"given": "Julien"
},
{
"family": "Labyt",
"given": "Etienne"
},
{
"family": "Schwartz",
"given": "Denis"
},
{
"family": "Lecaignard",
"given": "Françoise"
}
],
"container-title-short": "Hum Brain Mapp",
"volume": "46",
"issue": "14",
"page": "e70368",
"DOI": "10.1002/hbm.70368",
"PMCID": "PMC12476031",
"ISSN": "1065-9471",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/hbm.70368",
"language": "en",
"issued": {
"date-parts": [
[
2025
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1162/imag.a.1040 [code]
Novel 4 He-OPMs support waveform-specific beta burst analysis comparable to SQUID-MEG
Journal: n/a
In common: autoreject, MNE-Python, scikit-learn, 3 other tools, MEG, 14 references, author Tjerk P Gutteling
[2] doi:10.1038/s41598-026-41129-7 [code]
Non-linear relationships between auditory mismatch responses and the inharmonicity of complex sounds.
Journal: Scientific reports
In common: autoreject, MNE-Python, seaborn, 3 other tools, EEG, cognitive, 5 references
[3] doi:10.1162/imag.a.1269 [code]
From early to contemporary normative modeling: Mapping individual differences in neurophysiological signals.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: autoreject, MNE-Python, seaborn, 4 other tools, MEG, EEG, 2 references
[4] doi:10.1093/nc/niag029 [code]
A data-driven approach to identifying and evaluating connectivity-based neural correlates of conscious visual perception.
Journal: Neuroscience of consciousness
In common: autoreject, MNE-Python, seaborn, 4 other tools, MEG, cognitive, 2 references
[5] doi:10.7554/elife.108023 [code]
Challenges in replay detection by TDLM in post-encoding resting state.
Journal: eLife
In common: autoreject, MNE-Python, seaborn, 4 other tools, MEG, 2 references
[6] doi:10.1162/imag.a.1321 [code]
Phase similarity between similar objects indicates representational merging across retrieval training but not sleep.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: autoreject, MNE-Python, seaborn, 4 other tools, EEG, cognitive, 2 references
[7] doi:10.1109/tmi.2026.3687982 [code]
Spatial-Jitter Model for Magnetoencephalography Sensor Arrays.
Journal: IEEE transactions on medical imaging
In common: MNE-Python, SciPy, Matplotlib, 1 other tool, MEG, 4 references
[8] doi:10.1038/s41597-025-05174-7 [code]
A large-scale MEG and EEG dataset for object recognition in naturalistic scenes
Journal: n/a
In common: MNE-Python, seaborn, scikit-learn, 3 other tools, MEG, EEG, 3 references
[9] doi:10.1038/s41598-026-58505-y [code]
Remoteness sensitive theta network dynamics during early autobiographical memory access.
Journal: Scientific reports
In common: autoreject, MNE-Python, seaborn, 3 other tools, EEG, cognitive, 2 references
[10] doi:10.1371/journal.pcbi.1014302 [code]
Trial-level sequence modeling reveals hidden dynamics of dual-task interference.
Journal: PLoS computational biology
In common: autoreject, MNE-Python, seaborn, 4 other tools, EEG, 2 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.