OSCR

OPM-MEG reveals dynamics of beta bursts underlying attentional processes in sensory cortex

Code ↔ Paper

The paper beside its authors' code: matches between them have not been computed for this paper yet.

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 · 993 lines · 51 KB · no license

  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. """
  4. This experiment was created using PsychoPy3 Experiment Builder (v2021.2.3),
  5. on February 17, 2022, at 16:32
  6. If you publish work using this script the most relevant publication is:
  8. Peirce J, Gray JR, Simpson S, MacAskill M, Höchenberger R, Sogo H, Kastman E, Lindeløv JK. (2019)
  9. PsychoPy2: Experiments in behavior made easy Behav Res 51: 195.
  10. https://doi.org/10.3758/s13428-018-01193-y
  12. """
  14. from __future__ import absolute_import, division
  15. from turtle import left
  17. from psychopy import locale_setup
  18. from psychopy import prefs
  19. from psychopy import sound, gui, visual, core, data, event, logging, clock, colors, parallel
  20. from psychopy.constants import (NOT_STARTED, STARTED, PLAYING, PAUSED,
  21. STOPPED, FINISHED, PRESSED, RELEASED, FOREVER)
  22. import psychopy
  23. import numpy as np # whole numpy lib is available, prepend 'np.'
  24. from numpy import (sin, cos, tan, log, log10, pi, average,
  25. sqrt, std, deg2rad, rad2deg, linspace, asarray)
  26. from numpy.random import random, randint, normal, shuffle, choice as randchoice
  27. import os # handy system and path functions
  28. import sys # to get file system encoding
  30. from psychopy.hardware import keyboard
  34. # Ensure that relative paths start from the same directory as this script
  35. _thisDir = os.path.dirname(os.path.abspath(__file__))
  36. os.chdir(_thisDir)
  38. # Store info about the experiment session
  39. psychopyVersion = '2021.2.3'
  40. expName = 'Braille_Stim_Final' # from the Builder filename that created this script
  41. expInfo = {'participant': '', 'session': '001'}
  42. dlg = gui.DlgFromDict(dictionary=expInfo, sortKeys=False, title=expName)
  43. if dlg.OK == False:
  44. core.quit() # user pressed cancel
  45. expInfo['date'] = data.getDateStr() # add a simple timestamp
  46. expInfo['expName'] = expName
  47. expInfo['psychopyVersion'] = psychopyVersion
  49. # Data file name stem = absolute path + name; later add .psyexp, .csv, .log, etc
  50. filename = _thisDir + os.sep + u'data/%s_%s_%s' % (expInfo['participant'], expName, expInfo['date'])
  52. # An ExperimentHandler isn't essential but helps with data saving
  53. thisExp = data.ExperimentHandler(name=expName, version='',
  54. extraInfo=expInfo, runtimeInfo=None,
  55. originPath='C:\\Users\\physicsuser\\Documents\\MATLAB\\gonzalo\\Braille_paradigm\\Braille_Stim_Final.py',
  56. savePickle=True, saveWideText=True,
  57. dataFileName=filename)
  58. # save a log file for detail verbose info
  59. logFile = logging.LogFile(filename+'.log', level=logging.EXP)
  60. logging.console.setLevel(logging.WARNING) # this outputs to the screen, not a file
  62. endExpNow = False # flag for 'escape' or other condition => quit the exp
  63. frameTolerance = 0.001 # how close to onset before 'same' frame
  65. # Start Code - component code to be run after the window creation
  66. from utils.braille_functions import toBraille, sendStim
  67. # Setup the Window
  68. win = visual.Window(
  69. size=(1024, 768), fullscr=True, screen=0,
  70. winType='pyglet', allowGUI=False, allowStencil=False,
  71. monitor='testMonitor', color=[0,0,0], colorSpace='rgb',
  72. blendMode='avg', useFBO=True,
  73. units='height')
  74. # store frame rate of monitor if we can measure it
  75. expInfo['frameRate'] = win.getActualFrameRate()
  76. if expInfo['frameRate'] != None:
  77. frameDur = 1.0 / round(expInfo['frameRate'])
  78. else:
  79. frameDur = 1.0 / 60.0 # could not measure, so guess
  81. # Setup eyetracking
  82. ioDevice = ioConfig = ioSession = ioServer = eyetracker = None
  84. # create a default keyboard (e.g. to check for escape)
  85. defaultKeyboard = keyboard.Keyboard()
  87. # Initialize components for Routine "trial"
  88. trialClock = core.Clock()
  89. new_trial_text = visual.TextStim(win=win, name='new_trial_text',
  90. text='New trial',
  91. font='Open Sans',
  92. pos=(0, 0), height=0.1, wrapWidth=None, ori=0.0,
  93. color='white', colorSpace='rgb', opacity=None,
  94. languageStyle='LTR',
  95. depth=0.0);
  96. true_pattern = parallel.ParallelPort(address='0xDFF8 ')
  97. cross = visual.ShapeStim(
  98. win=win, name='cross', vertices='cross',
  99. size=(0.1, 0.1),
  100. ori=0.0, pos=(0, 0),
  101. lineWidth=1.0, colorSpace='rgb', lineColor='white', fillColor='white',
  102. opacity=None, depth=-2.0, interpolate=True)
  103. cue_right = visual.ShapeStim(
  104. win=win, name='cue_right', vertices=[(-0.4,0.05),(-0.4,-0.05),(-.2,-0.05),(-.2,-0.1),(0,0),(-.2,0.1),(-.2,0.05)],
  105. size=(0.25, 0.25),
  106. ori=0.0, pos=(0, 0),
  107. lineWidth=1.0, colorSpace='rgb', lineColor='white', fillColor='white',
  108. opacity=None, depth=-3.0, interpolate=True)
  109. cue_left = visual.ShapeStim(
  110. win=win, name='cue_left', vertices=[(0.4,0.05),(0.4,-0.05),(.2,-0.05),(.2,-0.1),(0,0),(.2,0.1),(.2,0.05)],
  111. size=(0.25, 0.25),
  112. ori=0.0, pos=(0, 0),
  113. lineWidth=1.0, colorSpace='rgb', lineColor='white', fillColor='white',
  114. opacity=None, depth=-4.0, interpolate=True)
  115. pattern1 = parallel.ParallelPort(address='0xDFF8 ')
  116. button_resp1 = keyboard.Keyboard()
  117. pattern2 = parallel.ParallelPort(address='0xDFF8 ')
  118. button_resp2 = keyboard.Keyboard()
  119. pattern3 = parallel.ParallelPort(address='0xDFF8 ')
  120. button_resp3 = keyboard.Keyboard()
  121. pattern4 = parallel.ParallelPort(address='0xDFF8 ')
  122. button_resp4 = keyboard.Keyboard()
  123. pattern5 = parallel.ParallelPort(address='0xDFF8 ')
  124. button_resp5 = keyboard.Keyboard()
  125. cross2 = visual.ShapeStim(
  126. win=win, name='cross2', vertices='cross',
  127. size=(0.1, 0.1),
  128. ori=0.0, pos=(0, 0),
  129. lineWidth=1.0, colorSpace='rgb', lineColor='white', fillColor='white',
  130. opacity=None, depth=-15.0, interpolate=True)
  132. # Initialize components for Routine "feedback"
  133. feedbackClock = core.Clock()
  134. feedback_string = visual.TextStim(win=win, name='feedback_string',
  135. text='This is the feedback routine',
  136. font='Open Sans',
  137. pos=(0, 0), height=0.1, wrapWidth=None, ori=0.0,
  138. color='white', colorSpace='rgb', opacity=None,
  139. languageStyle='LTR',
  140. depth=0.0);
  142. # Create some handy timers
  143. globalClock = core.Clock() # to track the time since experiment started
  144. routineTimer = core.CountdownTimer() # to track time remaining of each (non-slip) routine
  146. # set up handler to look after randomisation of conditions etc
  147. Paradigm = data.TrialHandler(nReps=8.0, method='sequential',
  148. extraInfo=expInfo, originPath=-1,
  149. trialList=[None],
  150. seed=None, name='Paradigm')
  151. thisExp.addLoop(Paradigm) # add the loop to the experiment
  152. thisParadigm = Paradigm.trialList[0] # so we can initialise stimuli with some values
  153. # abbreviate parameter names if possible (e.g. rgb = thisParadigm.rgb)
  154. if thisParadigm != None:
  155. for paramName in thisParadigm:
  156. exec('{} = thisParadigm[paramName]'.format(paramName))
  157. # Set up paradigm variables
  158. AttendHand = [] # list of cues
  159. pp = np.array(
  160. [ [1, 1, 0, 0, 1, 1, 0, 0],
  161. [0, 0, 1, 1, 0, 0, 1, 1],
  162. [0, 1, 1, 0, 0, 1, 1, 0],
  163. [1, 1, 1, 1, 0, 0, 0, 0],
  164. [0, 0, 0, 0, 1, 1, 1, 1]
  165. ]
  166. ) # Possible braille patterns
  167. patterns = []
  168. all_down = toBraille(np.zeros([1,8],dtype="int32"),0)
  169. # Define trigger channels
  170. START_trig = 1
  171. SAMPLE_trig = 2
  172. # Pattern triggers
  173. TRUE_trig = 4
  174. FALSEL_trig = 3
  175. FALSER_trig = 5
  177. CUELEFT_trig = 6
  178. CUERIGHT_trig = 7
  179. LEFT_PRESS = 8
  180. RIGHT_PRESS = 16
  181. # Create port object to send the triggers
  182. trigport = parallel.ParallelPort(address='0xDFF8 ')
  183. # Create variables to keep track of presses for the feedback
  184. totalpresses = 0
  185. true_patterns_sent = 0
  186. correctpresses = 0
  187. true_pattern_chosen = []
  188. left_keys = ['b','y']
  189. right_keys = ['r','g']
  191. for thisParadigm in Paradigm:
  192. currentLoop = Paradigm
  193. # abbreviate parameter names if possible (e.g. rgb = thisParadigm.rgb)
  194. if thisParadigm != None:
  195. for paramName in thisParadigm:
  196. exec('{} = thisParadigm[paramName]'.format(paramName))
  198. # set up handler to look after randomisation of conditions etc
  199. first_set = data.TrialHandler(nReps=10.0, method='sequential',
  200. extraInfo=expInfo, originPath=-1,
  201. trialList=[None],
  202. seed=None, name='first_set')
  203. thisExp.addLoop(first_set) # add the loop to the experiment
  204. thisFirst_set = first_set.trialList[0] # so we can initialise stimuli with some values
  205. # Choose random cues for the 10 trials 1 is for left, 2 is for right
  206. Cues = np.append(np.ones([int(first_set.nReps/2),1]), 2*np.ones([int(first_set.nReps/2),1]))
  207. Cues = np.random.permutation(Cues)
  208. AttendHand.append(Cues)
  209. # Choose how many target patterns there will be per trial
  210. g = np.random.gamma(4, 0.3, first_set.nReps)
  211. g = np.round(g)
  212. g[g>5] = 5
  214. # abbreviate parameter names if possible (e.g. rgb = thisFirst_set.rgb)
  215. if thisFirst_set != None:
  216. for paramName in thisFirst_set:
  217. exec('{} = thisFirst_set[paramName]'.format(paramName))
  219. for thisFirst_set in first_set:
  220. # Choose the patterns to send
  221. r = np.random.randint(0,pp.shape[0]) # Choose the true pattern
  222. true_pattern_chosen.append(r)
  223. true_patterns = g[first_set.thisN]
  224. stimuli = np.array([range(0,pp.shape[0])])
  225. np.place(stimuli, stimuli==r, np.random.randint(0,pp.shape[0],pp.shape[0]))
  226. stimuli = np.random.permutation(stimuli)
  227. for i in range(0,int(true_patterns)):
  228. index = np.random.randint(0,pp.shape[0])
  229. stimuli[0,index] = r
  230. patterns.append(stimuli)
  232. currentLoop = first_set
  233. # abbreviate parameter names if possible (e.g. rgb = thisFirst_set.rgb)
  234. if thisFirst_set != None:
  235. for paramName in thisFirst_set:
  236. exec('{} = thisFirst_set[paramName]'.format(paramName))
  238. # ------Prepare to start Routine "trial"-------
  239. continueRoutine = True
  240. routineTimer.add(16.000000)
  241. # update component parameters for each repeat
  242. button_resp1.keys = []
  243. button_resp1.rt = []
  244. _button_resp1_allKeys = []
  245. button_resp2.keys = []
  246. button_resp2.rt = []
  247. _button_resp2_allKeys = []
  248. button_resp3.keys = []
  249. button_resp3.rt = []
  250. _button_resp3_allKeys = []
  251. button_resp4.keys = []
  252. button_resp4.rt = []
  253. _button_resp4_allKeys = []
  254. button_resp5.keys = []
  255. button_resp5.rt = []
  256. _button_resp5_allKeys = []
  257. # keep track of which components have finished
  258. trialComponents = [new_trial_text, true_pattern, cross, cue_right, cue_left, pattern1, button_resp1, pattern2, button_resp2, pattern3, button_resp3, pattern4, button_resp4, pattern5, button_resp5, cross2]
  259. for thisComponent in trialComponents:
  260. thisComponent.tStart = None
  261. thisComponent.tStop = None
  262. thisComponent.tStartRefresh = None
  263. thisComponent.tStopRefresh = None
  264. if hasattr(thisComponent, 'status'):
  265. thisComponent.status = NOT_STARTED
  266. # reset timers
  267. t = 0
  268. _timeToFirstFrame = win.getFutureFlipTime(clock="now")
  269. trialClock.reset(-_timeToFirstFrame) # t0 is time of first possible flip
  270. frameN = -1
  271. # Log which hand
  272. if Cues[first_set.thisN] == 2: # Right hand
  273. logging.data("Right hand cued")
  274. elif Cues[first_set.thisN] == 1:# Left hand
  275. logging.data("Left hand cued")
  276. # -------Run Routine "trial"-------
  277. while continueRoutine and routineTimer.getTime() > 0:
  278. # get current time
  279. t = trialClock.getTime()
  280. tThisFlip = win.getFutureFlipTime(clock=trialClock)
  281. tThisFlipGlobal = win.getFutureFlipTime(clock=None)
  282. frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
  283. # update/draw components on each frame
  285. # *new_trial_text* updates
  286. if new_trial_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
  287. trigport.setData(START_trig)
  288. core.wait(0.1)
  289. trigport.setData(0)
  290. # keep track of start time/frame for later
  291. new_trial_text.frameNStart = frameN # exact frame index
  292. new_trial_text.tStart = t # local t and not account for scr refresh
  293. new_trial_text.tStartRefresh = tThisFlipGlobal # on global time
  294. win.timeOnFlip(new_trial_text, 'tStartRefresh') # time at next scr refresh
  295. new_trial_text.setAutoDraw(True)
  296. if new_trial_text.status == STARTED:
  297. # is it time to stop? (based on local clock)
  298. if tThisFlip > 0.7-frameTolerance:
  299. # keep track of stop time/frame for later
  300. new_trial_text.tStop = t # not accounting for scr refresh
  301. new_trial_text.frameNStop = frameN # exact frame index
  302. win.timeOnFlip(new_trial_text, 'tStopRefresh') # time at next scr refresh
  303. new_trial_text.setAutoDraw(False)
  304. # *true_pattern* updates
  305. if true_pattern.status == NOT_STARTED and t >= 1-frameTolerance:
  306. # keep track of start time/frame for later
  307. true_pattern.frameNStart = frameN # exact frame index
  308. true_pattern.tStart = t # local t and not account for scr refresh
  309. true_pattern.tStartRefresh = tThisFlipGlobal # on global time
  310. win.timeOnFlip(true_pattern, 'tStartRefresh') # time at next scr refresh
  311. true_pattern.status = STARTED
  312. # win.callOnFlip(true_pattern.setData, int(1))
  313. if true_pattern.status == STARTED:
  314. # Send the true pattern
  315. seq = toBraille(pp[r,:],0)
  316. sendStim(seq,pattern1)
  317. trigport.setData(SAMPLE_trig)
  318. # is it time to stop? (based on global clock, using actual start)
  319. if tThisFlipGlobal > true_pattern.tStartRefresh + 0-frameTolerance:
  320. # keep track of stop time/frame for later
  321. true_pattern.tStop = t # not accounting for scr refresh
  322. true_pattern.frameNStop = frameN # exact frame index
  323. win.timeOnFlip(true_pattern, 'tStopRefresh') # time at next scr refresh
  324. true_pattern.status = FINISHED
  325. # win.callOnFlip(true_pattern.setData, int(0))
  327. # *cross* updates
  328. if cross.status == NOT_STARTED and tThisFlip >= 1-frameTolerance:
  329. # keep track of start time/frame for later
  330. cross.frameNStart = frameN # exact frame index
  331. cross.tStart = t # local t and not account for scr refresh
  332. cross.tStartRefresh = tThisFlipGlobal # on global time
  333. win.timeOnFlip(cross, 'tStartRefresh') # time at next scr refresh
  334. cross.setAutoDraw(True)
  335. if cross.status == STARTED:
  336. # is it time to stop? (based on local clock)
  337. if tThisFlip > 3-frameTolerance:
  338. # keep track of stop time/frame for later
  339. cross.tStop = t # not accounting for scr refresh
  340. cross.frameNStop = frameN # exact frame index
  341. win.timeOnFlip(cross, 'tStopRefresh') # time at next scr refresh
  342. cross.setAutoDraw(False)
  343. trigport.setData(0)
  344. sendStim(all_down,pattern1) # Put the pins down after 2 seconds
  346. if Cues[first_set.thisN] == 2: #Right hand hand
  347. # *cue_right* updates
  348. if cue_right.status == NOT_STARTED and tThisFlip >= 4-frameTolerance:
  349. # keep track of start time/frame for later
  350. cue_right.frameNStart = frameN # exact frame index
  351. cue_right.tStart = t # local t and not account for scr refresh
  352. cue_right.tStartRefresh = tThisFlipGlobal # on global time
  353. win.timeOnFlip(cue_right, 'tStartRefresh') # time at next scr refresh
  354. cue_right.setAutoDraw(True)
  355. trigport.setData(CUERIGHT_trig)
  356. if cue_right.status == STARTED:
  357. # is it time to stop? (based on local clock)
  358. if tThisFlip > 6-frameTolerance:
  359. # keep track of stop time/frame for later
  360. cue_right.tStop = t # not accounting for scr refresh
  361. cue_right.frameNStop = frameN # exact frame index
  362. win.timeOnFlip(cue_right, 'tStopRefresh') # time at next scr refresh
  363. cue_right.setAutoDraw(False)
  364. trigport.setData(0)
  365. elif Cues[first_set.thisN] ==1: #Left hand
  366. # *cue_left* updates
  367. if cue_left.status == NOT_STARTED and tThisFlip >= 4-frameTolerance:
  368. # keep track of start time/frame for later
  369. cue_left.frameNStart = frameN # exact frame index
  370. cue_left.tStart = t # local t and not account for scr refresh
  371. cue_left.tStartRefresh = tThisFlipGlobal # on global time
  372. win.timeOnFlip(cue_left, 'tStartRefresh') # time at next scr refresh
  373. cue_left.setAutoDraw(True)
  374. trigport.setData(CUELEFT_trig)
  375. if cue_left.status == STARTED:
  376. # is it time to stop? (based on local clock)
  377. if tThisFlip > 6-frameTolerance:
  378. # keep track of stop time/frame for later
  379. cue_left.tStop = t # not accounting for scr refresh
  380. cue_left.frameNStop = frameN # exact frame index
  381. win.timeOnFlip(cue_left, 'tStopRefresh') # time at next scr refresh
  382. cue_left.setAutoDraw(False)
  383. trigport.setData(0)
  384. # *pattern1* updates
  385. if pattern1.status == NOT_STARTED and t >= 7-frameTolerance:
  386. logging.data("Sending pattern 1")
  387. leftright = np.random.randint(1,3)
  388. logging.data("The trial number is ")
  389. if stimuli[0,0] == r and Cues[first_set.thisN] == leftright:
  390. logging.data("True pattern sent!")
  391. true_patterns_sent += 1
  392. trigport.setData(TRUE_trig)
  393. else:
  394. if leftright == 1:
  395. logging.data("False left")
  396. trigport.setData(FALSEL_trig)
  397. elif leftright == 2:
  398. logging.data("False right")
  399. trigport.setData(FALSER_trig)
  400. core.wait(0.01)
  401. trigport.setData(0)
  402. seq = toBraille(pp[stimuli[0,0],:],leftright)
  403. sendStim(seq,pattern1)
  404. # keep track of start time/frame for later
  405. pattern1.frameNStart = frameN # exact frame index
  406. pattern1.tStart = t # local t and not account for scr refresh
  407. pattern1.tStartRefresh = tThisFlipGlobal # on global time
  408. win.timeOnFlip(pattern1, 'tStartRefresh') # time at next scr refresh
  409. pattern1.status = STARTED
  410. # win.callOnFlip(pattern1.setData, int(1))
  411. if pattern1.status == STARTED:
  412. # is it time to stop? (based on global clock, using actual start)
  413. if tThisFlipGlobal > pattern1.tStartRefresh + 0.1-frameTolerance:
  414. # keep track of stop time/frame for later
  415. pattern1.tStop = t # not accounting for scr refresh
  416. pattern1.frameNStop = frameN # exact frame index
  417. win.timeOnFlip(pattern1, 'tStopRefresh') # time at next scr refresh
  418. pattern1.status = FINISHED
  419. sendStim(all_down,pattern1)
  420. # win.callOnFlip(pattern1.setData, int(0))
  422. # *button_resp1* updates
  423. waitOnFlip = False
  424. if button_resp1.status == NOT_STARTED and tThisFlip >= 7.1-frameTolerance:
  425. # keep track of start time/frame for later
  426. button_resp1.frameNStart = frameN # exact frame index
  427. button_resp1.tStart = t # local t and not account for scr refresh
  428. button_resp1.tStartRefresh = tThisFlipGlobal # on global time
  429. win.timeOnFlip(button_resp1, 'tStartRefresh') # time at next scr refresh
  430. button_resp1.status = STARTED
  431. # keyboard checking is just starting
  432. waitOnFlip = True
  433. win.callOnFlip(button_resp1.clock.reset) # t=0 on next screen flip
  434. win.callOnFlip(button_resp1.clearEvents, eventType='keyboard') # clear events on next screen flip
  435. if button_resp1.status == STARTED:
  436. # is it time to stop? (based on global clock, using actual start)
  437. if tThisFlipGlobal > button_resp1.tStartRefresh + 1-frameTolerance:
  438. # keep track of stop time/frame for later
  439. button_resp1.tStop = t # not accounting for scr refresh
  440. button_resp1.frameNStop = frameN # exact frame index
  441. win.timeOnFlip(button_resp1, 'tStopRefresh') # time at next scr refresh
  442. button_resp1.status = FINISHED
  443. if button_resp1.status == STARTED and not waitOnFlip:
  444. theseKeys = button_resp1.getKeys(keyList=['b', 'g', 'r', 'y'], waitRelease=False)
  445. _button_resp1_allKeys.extend(theseKeys)
  446. if len(_button_resp1_allKeys):
  447. button_resp1.keys = _button_resp1_allKeys[0].name # just the first key pressed
  448. totalpresses += 1
  449. if button_resp1.keys in left_keys:
  450. trigport.setData(LEFT_PRESS)
  451. logging.data("left press")
  452. if stimuli[0,0] == r and leftright == 1:
  453. correctpresses += 1
  454. elif button_resp1.keys in right_keys:
  455. trigport.setData(RIGHT_PRESS)
  456. logging.data("right press")
  457. if stimuli[0,0] == r and leftright == 2:
  458. correctpresses += 1
  459. core.wait(0.015)
  460. trigport.setData(0)
  461. button_resp1.rt = _button_resp1_allKeys[0].rt
  462. _button_resp1_allKeys = [] #Reset the list
  463. # *pattern2* updates
  464. if pattern2.status == NOT_STARTED and t >= 8.1-frameTolerance:
  465. logging.data("Sending pattern 2")
  466. leftright = np.random.randint(1,3)
  467. if stimuli[0,1] == r and Cues[first_set.thisN] == leftright:
  468. logging.data("True pattern sent!")
  469. true_patterns_sent += 1
  470. trigport.setData(TRUE_trig)
  471. else:
  472. if leftright == 1:
  473. logging.data("False left")
  474. trigport.setData(FALSEL_trig)
  475. elif leftright == 2:
  476. logging.data("False right")
  477. trigport.setData(FALSER_trig)
  478. core.wait(0.02)
  479. trigport.setData(0)
  480. seq = toBraille(pp[stimuli[0,1],:],leftright)
  481. sendStim(seq,pattern2)
  482. # keep track of start time/frame for later
  483. pattern2.frameNStart = frameN # exact frame index
  484. pattern2.tStart = t # local t and not account for scr refresh
  485. pattern2.tStartRefresh = tThisFlipGlobal # on global time
  486. win.timeOnFlip(pattern2, 'tStartRefresh') # time at next scr refresh
  487. pattern2.status = STARTED
  488. # win.callOnFlip(pattern2.setData, int(1))
  489. if pattern2.status == STARTED:
  490. # is it time to stop? (based on global clock, using actual start)
  491. if tThisFlipGlobal > pattern2.tStartRefresh + 0.1-frameTolerance:
  492. # keep track of stop time/frame for later
  493. pattern2.tStop = t # not accounting for scr refresh
  494. pattern2.frameNStop = frameN # exact frame index
  495. win.timeOnFlip(pattern2, 'tStopRefresh') # time at next scr refresh
  496. pattern2.status = FINISHED
  497. sendStim(all_down,pattern1)
  498. # win.callOnFlip(pattern2.setData, int(0))
  500. # *button_resp2* updates
  501. waitOnFlip = False
  502. if button_resp2.status == NOT_STARTED and tThisFlip >= 8.2-frameTolerance:
  503. # keep track of start time/frame for later
  504. button_resp2.frameNStart = frameN # exact frame index
  505. button_resp2.tStart = t # local t and not account for scr refresh
  506. button_resp2.tStartRefresh = tThisFlipGlobal # on global time
  507. win.timeOnFlip(button_resp2, 'tStartRefresh') # time at next scr refresh
  508. button_resp2.status = STARTED
  509. # keyboard checking is just starting
  510. waitOnFlip = True
  511. win.callOnFlip(button_resp2.clock.reset) # t=0 on next screen flip
  512. win.callOnFlip(button_resp2.clearEvents, eventType='keyboard') # clear events on next screen flip
  513. if button_resp2.status == STARTED:
  514. # is it time to stop? (based on global clock, using actual start)
  515. if tThisFlipGlobal > button_resp2.tStartRefresh + 1-frameTolerance:
  516. # keep track of stop time/frame for later
  517. button_resp2.tStop = t # not accounting for scr refresh
  518. button_resp2.frameNStop = frameN # exact frame index
  519. win.timeOnFlip(button_resp2, 'tStopRefresh') # time at next scr refresh
  520. button_resp2.status = FINISHED
  521. if button_resp2.status == STARTED and not waitOnFlip:
  522. theseKeys = button_resp2.getKeys(keyList=['b', 'g', 'r', 'y'], waitRelease=False)
  523. _button_resp2_allKeys.extend(theseKeys)
  524. if len(_button_resp2_allKeys):
  525. button_resp2.keys = _button_resp2_allKeys[0].name # just the first key pressed
  526. totalpresses += 1
  527. if button_resp2.keys in left_keys:
  528. trigport.setData(LEFT_PRESS)
  529. logging.data("left press")
  530. if stimuli[0,1] == r and leftright == 1:
  531. correctpresses += 1
  532. elif button_resp2.keys in right_keys:
  533. trigport.setData(RIGHT_PRESS)
  534. logging.data("right press")
  535. if stimuli[0,1] == r and leftright == 2:
  536. correctpresses += 1
  537. core.wait(0.015)
  538. trigport.setData(0)
  539. button_resp2.rt = _button_resp2_allKeys[0].rt
  540. _button_resp2_allKeys = [] # Reset the list
  542. # *pattern3* updates
  543. if pattern3.status == NOT_STARTED and t >= 9.2-frameTolerance:
  544. logging.data("Sending pattern 3")
  545. leftright = np.random.randint(1,3)
  546. if stimuli[0,2] == r and Cues[first_set.thisN] == leftright:
  547. logging.data("True pattern sent!")
  548. true_patterns_sent += 1
  549. trigport.setData(TRUE_trig)
  550. else:
  551. if leftright == 1:
  552. logging.data("False left")
  553. trigport.setData(FALSEL_trig)
  554. elif leftright == 2:
  555. logging.data("False right")
  556. trigport.setData(FALSER_trig)
  557. core.wait(0.02)
  558. trigport.setData(0)
  559. seq = toBraille(pp[stimuli[0,2],:],leftright)
  560. sendStim(seq,pattern3)
  561. # keep track of start time/frame for later
  562. pattern3.frameNStart = frameN # exact frame index
  563. pattern3.tStart = t # local t and not account for scr refresh
  564. pattern3.tStartRefresh = tThisFlipGlobal # on global time
  565. win.timeOnFlip(pattern3, 'tStartRefresh') # time at next scr refresh
  566. pattern3.status = STARTED
  567. # win.callOnFlip(pattern3.setData, int(1))
  568. if pattern3.status == STARTED:
  569. # is it time to stop? (based on global clock, using actual start)
  570. if tThisFlipGlobal > pattern3.tStartRefresh + 0.1-frameTolerance:
  571. # keep track of stop time/frame for later
  572. pattern3.tStop = t # not accounting for scr refresh
  573. pattern3.frameNStop = frameN # exact frame index
  574. win.timeOnFlip(pattern3, 'tStopRefresh') # time at next scr refresh
  575. pattern3.status = FINISHED
  576. sendStim(all_down,pattern1)
  577. # win.callOnFlip(pattern3.setData, int(0))
  579. # *button_resp3* updates
  580. waitOnFlip = False
  581. if button_resp3.status == NOT_STARTED and tThisFlip >= 9.3-frameTolerance:
  582. # keep track of start time/frame for later
  583. button_resp3.frameNStart = frameN # exact frame index
  584. button_resp3.tStart = t # local t and not account for scr refresh
  585. button_resp3.tStartRefresh = tThisFlipGlobal # on global time
  586. win.timeOnFlip(button_resp3, 'tStartRefresh') # time at next scr refresh
  587. button_resp3.status = STARTED
  588. # keyboard checking is just starting
  589. waitOnFlip = True
  590. win.callOnFlip(button_resp3.clock.reset) # t=0 on next screen flip
  591. win.callOnFlip(button_resp3.clearEvents, eventType='keyboard') # clear events on next screen flip
  592. if button_resp3.status == STARTED:
  593. # is it time to stop? (based on global clock, using actual start)
  594. if tThisFlipGlobal > button_resp3.tStartRefresh + 1-frameTolerance:
  595. # keep track of stop time/frame for later
  596. button_resp3.tStop = t # not accounting for scr refresh
  597. button_resp3.frameNStop = frameN # exact frame index
  598. win.timeOnFlip(button_resp3, 'tStopRefresh') # time at next scr refresh
  599. button_resp3.status = FINISHED
  600. if button_resp3.status == STARTED and not waitOnFlip:
  601. theseKeys = button_resp3.getKeys(keyList=['b', 'g', 'r', 'y'], waitRelease=False)
  602. _button_resp3_allKeys.extend(theseKeys)
  603. if len(_button_resp3_allKeys):
  604. button_resp3.keys = _button_resp3_allKeys[0].name # just the first key pressed
  605. totalpresses += 1
  606. if button_resp3.keys in left_keys:
  607. trigport.setData(LEFT_PRESS)
  608. logging.data("left press")
  609. if stimuli[0,2] == r and leftright == 1:
  610. correctpresses += 1
  611. elif button_resp3.keys in right_keys:
  612. trigport.setData(RIGHT_PRESS)
  613. logging.data("right press")
  614. if stimuli[0,2] == r and leftright == 2:
  615. correctpresses += 1
  616. core.wait(0.015)
  617. trigport.setData(0)
  618. button_resp3.rt = _button_resp3_allKeys[0].rt
  619. _button_resp3_allKeys = [] #Reset the list
  620. # *pattern4* updates
  621. if pattern4.status == NOT_STARTED and t >= 10.3-frameTolerance:
  622. logging.data("Sending pattern 4")
  623. leftright = np.random.randint(1,3)
  624. if stimuli[0,3] == r and Cues[first_set.thisN] == leftright:
  625. logging.data("True pattern sent!")
  626. true_patterns_sent += 1
  627. trigport.setData(TRUE_trig)
  628. else:
  629. if leftright == 1:
  630. logging.data("False left")
  631. trigport.setData(FALSEL_trig)
  632. elif leftright == 2:
  633. logging.data("False right")
  634. trigport.setData(FALSER_trig)
  635. core.wait(0.02)
  636. trigport.setData(0)
  637. seq = toBraille(pp[stimuli[0,3],:],leftright)
  638. sendStim(seq,pattern4)
  639. # keep track of start time/frame for later
  640. pattern4.frameNStart = frameN # exact frame index
  641. pattern4.tStart = t # local t and not account for scr refresh
  642. pattern4.tStartRefresh = tThisFlipGlobal # on global time
  643. win.timeOnFlip(pattern4, 'tStartRefresh') # time at next scr refresh
  644. pattern4.status = STARTED
  645. # win.callOnFlip(pattern4.setData, int(1))
  646. if pattern4.status == STARTED:
  647. # is it time to stop? (based on global clock, using actual start)
  648. if tThisFlipGlobal > pattern4.tStartRefresh + 0.1-frameTolerance:
  649. # keep track of stop time/frame for later
  650. pattern4.tStop = t # not accounting for scr refresh
  651. pattern4.frameNStop = frameN # exact frame index
  652. win.timeOnFlip(pattern4, 'tStopRefresh') # time at next scr refresh
  653. pattern4.status = FINISHED
  654. sendStim(all_down,pattern1)
  655. # win.callOnFlip(pattern4.setData, int(0))
  657. # *button_resp4* updates
  658. waitOnFlip = False
  659. if button_resp4.status == NOT_STARTED and tThisFlip >= 10.4-frameTolerance:
  660. # keep track of start time/frame for later
  661. button_resp4.frameNStart = frameN # exact frame index
  662. button_resp4.tStart = t # local t and not account for scr refresh
  663. button_resp4.tStartRefresh = tThisFlipGlobal # on global time
  664. win.timeOnFlip(button_resp4, 'tStartRefresh') # time at next scr refresh
  665. button_resp4.status = STARTED
  666. # keyboard checking is just starting
  667. waitOnFlip = True
  668. win.callOnFlip(button_resp4.clock.reset) # t=0 on next screen flip
  669. win.callOnFlip(button_resp4.clearEvents, eventType='keyboard') # clear events on next screen flip
  670. if button_resp4.status == STARTED:
  671. # is it time to stop? (based on global clock, using actual start)
  672. if tThisFlipGlobal > button_resp4.tStartRefresh + 1-frameTolerance:
  673. # keep track of stop time/frame for later
  674. button_resp4.tStop = t # not accounting for scr refresh
  675. button_resp4.frameNStop = frameN # exact frame index
  676. win.timeOnFlip(button_resp4, 'tStopRefresh') # time at next scr refresh
  677. button_resp4.status = FINISHED
  678. if button_resp4.status == STARTED and not waitOnFlip:
  679. theseKeys = button_resp4.getKeys(keyList=['b', 'g', 'r', 'y'], waitRelease=False)
  680. _button_resp4_allKeys.extend(theseKeys)
  681. if len(_button_resp4_allKeys):
  682. button_resp4.keys = _button_resp4_allKeys[0].name # just the first key pressed
  683. totalpresses += 1
  684. if button_resp4.keys in left_keys:
  685. trigport.setData(LEFT_PRESS)
  686. logging.data("left press")
  687. if stimuli[0,3] == r and leftright == 1:
  688. correctpresses += 1
  689. elif button_resp4.keys in right_keys:
  690. trigport.setData(RIGHT_PRESS)
  691. logging.data("right press")
  692. if stimuli[0,3] == r and leftright == 2:
  693. correctpresses += 1
  694. core.wait(0.015)
  695. trigport.setData(0)
  696. button_resp4.rt = _button_resp4_allKeys[0].rt
  697. _button_resp4_allKeys = [] #Reset the list
  699. # *pattern5* updates
  700. if pattern5.status == NOT_STARTED and t >= 11.4-frameTolerance:
  701. logging.data("Sending pattern 5")
  702. leftright = np.random.randint(1,3)
  703. if stimuli[0,4] == r and Cues[first_set.thisN] == leftright:
  704. logging.data("True pattern sent!")
  705. true_patterns_sent += 1
  706. trigport.setData(TRUE_trig)
  707. else:
  708. if leftright == 1:
  709. logging.data("False left")
  710. trigport.setData(FALSEL_trig)
  711. elif leftright == 2:
  712. logging.data("False right")
  713. trigport.setData(FALSER_trig)
  714. core.wait(0.02)
  715. trigport.setData(0)
  716. seq = toBraille(pp[stimuli[0,4],:],leftright)
  717. sendStim(seq,pattern5)
  718. # keep track of start time/frame for later
  719. pattern5.frameNStart = frameN # exact frame index
  720. pattern5.tStart = t # local t and not account for scr refresh
  721. pattern5.tStartRefresh = tThisFlipGlobal # on global time
  722. win.timeOnFlip(pattern5, 'tStartRefresh') # time at next scr refresh
  723. pattern5.status = STARTED
  724. # win.callOnFlip(pattern5.setData, int(1))
  725. if pattern5.status == STARTED:
  726. # is it time to stop? (based on global clock, using actual start)
  727. if tThisFlipGlobal > pattern5.tStartRefresh + 0.1-frameTolerance:
  728. # keep track of stop time/frame for later
  729. pattern5.tStop = t # not accounting for scr refresh
  730. pattern5.frameNStop = frameN # exact frame index
  731. win.timeOnFlip(pattern5, 'tStopRefresh') # time at next scr refresh
  732. pattern5.status = FINISHED
  733. sendStim(all_down,pattern1)
  734. # win.callOnFlip(pattern5.setData, int(0))
  736. # *button_resp5* updates
  737. waitOnFlip = False
  738. if button_resp5.status == NOT_STARTED and tThisFlip >= 11.5-frameTolerance:
  739. # keep track of start time/frame for later
  740. button_resp5.frameNStart = frameN # exact frame index
  741. button_resp5.tStart = t # local t and not account for scr refresh
  742. button_resp5.tStartRefresh = tThisFlipGlobal # on global time
  743. win.timeOnFlip(button_resp5, 'tStartRefresh') # time at next scr refresh
  744. button_resp5.status = STARTED
  745. # keyboard checking is just starting
  746. waitOnFlip = True
  747. win.callOnFlip(button_resp5.clock.reset) # t=0 on next screen flip
  748. win.callOnFlip(button_resp5.clearEvents, eventType='keyboard') # clear events on next screen flip
  749. if button_resp5.status == STARTED:
  750. # is it time to stop? (based on global clock, using actual start)
  751. if tThisFlipGlobal > button_resp5.tStartRefresh + 1-frameTolerance:
  752. # keep track of sexit()
  753. # op time/frame for later
  754. button_resp5.tStop = t # not accounting for scr refresh
  755. button_resp5.frameNStop = frameN # exact frame index
  756. win.timeOnFlip(button_resp5, 'tStopRefresh') # time at next scr refresh
  757. button_resp5.status = FINISHED
  758. if button_resp5.status == STARTED and not waitOnFlip:
  759. theseKeys = button_resp5.getKeys(keyList=['b', 'g', 'r', 'y'], waitRelease=False)
  760. _button_resp5_allKeys.extend(theseKeys)
  761. if len(_button_resp5_allKeys):
  762. button_resp5.keys = _button_resp5_allKeys[0].name # just the first key pressed
  763. totalpresses += 1
  764. if button_resp5.keys in left_keys:
  765. trigport.setData(LEFT_PRESS)
  766. logging.data("left press")
  767. if stimuli[0,4] == r and leftright == 1:
  768. correctpresses += 1
  769. elif button_resp5.keys in right_keys:
  770. trigport.setData(RIGHT_PRESS)
  771. logging.data("right press")
  772. if stimuli[0,4] == r and leftright == 2:
  773. correctpresses += 1
  774. core.wait(0.015)
  775. trigport.setData(0)
  776. button_resp5.rt = _button_resp5_allKeys[0].rt
  777. _button_resp5_allKeys = [] # Reset list
  781. # *cross2* updates
  782. if cross2.status == NOT_STARTED and tThisFlip >= 6-frameTolerance:
  783. # keep track of start time/frame for later
  784. cross2.frameNStart = frameN # exact frame index
  785. cross2.tStart = t # local t and not account for scr refresh
  786. cross2.tStartRefresh = tThisFlipGlobal # on global time
  787. win.timeOnFlip(cross2, 'tStartRefresh') # time at next scr refresh
  788. cross2.setAutoDraw(True)
  789. if cross2.status == STARTED:
  790. # is it time to stop? (based on local clock)
  791. if tThisFlip > 16-frameTolerance:
  792. # keep track of stop time/frame for later
  793. cross2.tStop = t # not accounting for scr refresh
  794. cross2.frameNStop = frameN # exact frame index
  795. win.timeOnFlip(cross2, 'tStopRefresh') # time at next scr refresh
  796. cross2.setAutoDraw(False)
  798. # check for quit (typically the Esc key)
  799. if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]):
  800. core.quit()
  802. # check if all components have finished
  803. if not continueRoutine: # a component has requested a forced-end of Routine
  804. break
  805. continueRoutine = False # will revert to True if at least one component still running
  806. for thisComponent in trialComponents:
  807. if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
  808. continueRoutine = True
  809. break # at least one component has not yet finished
  811. # refresh the screen
  812. if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
  813. win.flip()
  815. # -------Ending Routine "trial"-------
  816. for thisComponent in trialComponents:
  817. if hasattr(thisComponent, "setAutoDraw"):
  818. thisComponent.setAutoDraw(False)
  819. first_set.addData('new_trial_text.started', new_trial_text.tStartRefresh)
  820. first_set.addData('new_trial_text.stopped', new_trial_text.tStopRefresh)
  821. if true_pattern.status == STARTED:
  822. win.callOnFlip(true_pattern.setData, int(0))
  823. first_set.addData('true_pattern.started', true_pattern.tStart)
  824. first_set.addData('true_pattern.stopped', true_pattern.tStop)
  825. first_set.addData('cross.started', cross.tStartRefresh)
  826. first_set.addData('cross.stopped', cross.tStopRefresh)
  827. first_set.addData('cue_right.started', cue_right.tStartRefresh)
  828. first_set.addData('cue_right.stopped', cue_right.tStopRefresh)
  829. first_set.addData('cue_left.started', cue_left.tStartRefresh)
  830. first_set.addData('cue_left.stopped', cue_left.tStopRefresh)
  831. if pattern1.status == STARTED:
  832. win.callOnFlip(pattern1.setData, int(0))
  833. first_set.addData('pattern1.started', pattern1.tStart)
  834. first_set.addData('pattern1.stopped', pattern1.tStop)
  835. # check responses
  836. if button_resp1.keys in ['', [], None]: # No response was made
  837. button_resp1.keys = None
  838. first_set.addData('button_resp1.keys',button_resp1.keys)
  839. if button_resp1.keys != None: # we had a response
  840. first_set.addData('button_resp1.rt', button_resp1.rt)
  841. first_set.addData('button_resp1.started', button_resp1.tStartRefresh)
  842. first_set.addData('button_resp1.stopped', button_resp1.tStopRefresh)
  843. if pattern2.status == STARTED:
  844. win.callOnFlip(pattern2.setData, int(0))
  845. first_set.addData('pattern2.started', pattern2.tStart)
  846. first_set.addData('pattern2.stopped', pattern2.tStop)
  847. # check responses
  848. if button_resp2.keys in ['', [], None]: # No response was made
  849. button_resp2.keys = None
  850. first_set.addData('button_resp2.keys',button_resp2.keys)
  851. if button_resp2.keys != None: # we had a response
  852. first_set.addData('button_resp2.rt', button_resp2.rt)
  853. first_set.addData('button_resp2.started', button_resp2.tStartRefresh)
  854. first_set.addData('button_resp2.stopped', button_resp2.tStopRefresh)
  855. if pattern3.status == STARTED:
  856. win.callOnFlip(pattern3.setData, int(0))
  857. first_set.addData('pattern3.started', pattern3.tStart)
  858. first_set.addData('pattern3.stopped', pattern3.tStop)
  859. # check responses
  860. if button_resp3.keys in ['', [], None]: # No response was made
  861. button_resp3.keys = None
  862. first_set.addData('button_resp3.keys',button_resp3.keys)
  863. if button_resp3.keys != None: # we had a response
  864. first_set.addData('button_resp3.rt', button_resp3.rt)
  865. first_set.addData('button_resp3.started', button_resp3.tStartRefresh)
  866. first_set.addData('button_resp3.stopped', button_resp3.tStopRefresh)
  867. if pattern4.status == STARTED:
  868. win.callOnFlip(pattern4.setData, int(0))
  869. first_set.addData('pattern4.started', pattern4.tStart)
  870. first_set.addData('pattern4.stopped', pattern4.tStop)
  871. # check responses
  872. if button_resp4.keys in ['', [], None]: # No response was made
  873. button_resp4.keys = None
  874. first_set.addData('button_resp4.keys',button_resp4.keys)
  875. if button_resp4.keys != None: # we had a response
  876. first_set.addData('button_resp4.rt', button_resp4.rt)
  877. first_set.addData('button_resp4.started', button_resp4.tStartRefresh)
  878. first_set.addData('button_resp4.stopped', button_resp4.tStopRefresh)
  879. if pattern5.status == STARTED:
  880. win.callOnFlip(pattern5.setData, int(0))
  881. first_set.addData('pattern5.started', pattern5.tStart)
  882. first_set.addData('pattern5.stopped', pattern5.tStop)
  883. # check responses
  884. if button_resp5.keys in ['', [], None]: # No response was made
  885. button_resp5.keys = None
  886. first_set.addData('button_resp5.keys',button_resp5.keys)
  887. if button_resp5.keys != None: # we had a response
  888. first_set.addData('button_resp5.rt', button_resp5.rt)
  889. first_set.addData('button_resp5.started', button_resp5.tStartRefresh)
  890. first_set.addData('button_resp5.stopped', button_resp5.tStopRefresh)
  891. first_set.addData('cross2.started', cross2.tStartRefresh)
  892. first_set.addData('cross2.stopped', cross2.tStopRefresh)
  893. thisExp.nextEntry()
  895. # completed 10.0 repeats of 'first_set'
  898. # ------Prepare to start Routine "feedback"-------
  899. continueRoutine = True
  900. routineTimer.add(16.000000)
  901. # update component parameters for each repeat
  902. # keep track of which components have finished
  903. feedbackComponents = [feedback_string]
  904. for thisComponent in feedbackComponents:
  905. thisComponent.tStart = None
  906. thisComponent.tStop = None
  907. thisComponent.tStartRefresh = None
  908. thisComponent.tStopRefresh = None
  909. if hasattr(thisComponent, 'status'):
  910. thisComponent.status = NOT_STARTED
  911. # reset timers
  912. t = 0
  913. _timeToFirstFrame = win.getFutureFlipTime(clock="now")
  914. feedbackClock.reset(-_timeToFirstFrame) # t0 is time of first possible flip
  915. frameN = -1
  917. # -------Run Routine "feedback"-------
  918. while continueRoutine and routineTimer.getTime() > 0:
  919. # get current time
  920. t = feedbackClock.getTime()
  921. tThisFlip = win.getFutureFlipTime(clock=feedbackClock)
  922. tThisFlipGlobal = win.getFutureFlipTime(clock=None)
  923. frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
  924. # update/draw components on each frame
  926. # *feedback_string* updates
  927. if feedback_string.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
  928. # keep track of start time/frame for later
  929. feedback_string.frameNStart = frameN # exact frame index
  930. feedback_string.tStart = t # local t and not account for scr refresh
  931. feedback_string.tStartRefresh = tThisFlipGlobal # on global time
  932. feedback_string.text = "Total button presses {} \n You got {} out {} true patterns sent".format(totalpresses, correctpresses, true_patterns_sent)
  933. win.timeOnFlip(feedback_string, 'tStartRefresh') # time at next scr refresh
  934. feedback_string.setAutoDraw(True)
  935. if feedback_string.status == STARTED:
  936. # is it time to stop? (based on global clock, using actual start)
  937. if tThisFlipGlobal > feedback_string.tStartRefresh + 16-frameTolerance:
  938. # keep track of stop time/frame for later
  939. feedback_string.tStop = t # not accounting for scr refresh
  940. feedback_string.frameNStop = frameN # exact frame index
  941. win.timeOnFlip(feedback_string, 'tStopRefresh') # time at next scr refresh
  942. feedback_string.setAutoDraw(False)
  944. # check for quit (typically the Esc key)
  945. if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]):
  946. core.quit()
  948. # check if all components have finished
  949. if not continueRoutine: # a component has requested a forced-end of Routine
  950. break
  951. continueRoutine = False # will revert to True if at least one component still running
  952. for thisComponent in feedbackComponents:
  953. if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
  954. continueRoutine = True
  955. break # at least one component has not yet finished
  957. # refresh the screen
  958. if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
  959. win.flip()
  961. # -------Ending Routine "feedback"-------
  962. for thisComponent in feedbackComponents:
  963. if hasattr(thisComponent, "setAutoDraw"):
  964. thisComponent.setAutoDraw(False)
  965. Paradigm.addData('feedback_string.started', feedback_string.tStartRefresh)
  966. Paradigm.addData('feedback_string.stopped', feedback_string.tStopRefresh)
  967. thisExp.nextEntry()
  968. #Reset counters
  969. totalpresses = 0
  970. true_patterns_sent = 0
  971. correctpresses = 0
  972. # completed 8.0 repeats of 'Paradigm'
  975. # Flip one final time so any remaining win.callOnFlip()
  976. # and win.timeOnFlip() tasks get executed before quitting
  977. win.flip()
  979. # these shouldn't be strictly necessary (should auto-save)
  980. thisExp.saveAsWideText(filename+'.csv', delim='auto')
  981. thisExp.saveAsPickle(filename)
  982. logging.flush()
  983. # Write paradigm data to json file
  984. All_Cues = np.concatenate(AttendHand, axis = 0)
  985. np.savetxt("All_Cues.csv", All_Cues, delimiter=",")
  986. true_pattern_chosen = np.concatenate(true_pattern_chosen)
  987. np.savetxt("true_patterns_chose.csv", true_pattern_chosen, delimiter=",")
  988. All_patterns_sent = np.concatenate(patterns, axis =0)
  989. np.savetxt("All_patterns_sent.csv", All_patterns_sent, delimiter=",")
  990. # make sure everything is closed down
  991. thisExp.abort() # or data files will save again on exit
  992. win.close()
  993. core.quit()

Toolbox_killer.py at commit 10262ac, no license · at the source

Overview

Authors: Gonzalo Reina Rivero1,2, Zoe Tanner1,2, Lukas Rier1, Ryan M Hill1, Vishal Shah3, Molly Rea2, Cody Doyle3, James Osborne3, David Bobela3, Peter G Morris1, Karen J Mullinger1,4, Elena Boto1,2, Niall Holmes1,2, Matthew J Brookes1,2
ORCID iDs: Karen J Mullinger
  1. Sir Peter Mansfield Imaging Centre, School of Physics and Astronomy, University of Nottingham, University Park, Nottingham, NG7 2RD UK
  2. Cerca Magnetics Limited, 2 Castlebridge Office Village, Kirtley Drive, Nottingham, NG7 1LD UK
  3. QuSpin Inc., 331 South 104th Street, Suite 130, Louisville, CO 80027 USA
  4. Centre for Human Brain Health, School of Psychology, University of Birmingham, Birmingham, B15 2TT UK
Institutions: University of Nottingham (United Kingdom); QuSpin (United States) (United States); University of Birmingham (United Kingdom)
Journal: n/a, volume 15, issue 1, article 30471
Dates: received 25 April 2024; accepted 18 June 2025; published online 19 August 2025
Type: Research article · Language: English
License: none stated
Identifiers: DOI 10.1038/s41598-025-08037-8 · PMCID PMC12365038 · OpenAlex W4413316870
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), MEG (modality), human (organism)
Methods: Spectral & time-frequency, Statistics, Preprocessing, fMRI & imaging
Keywords: Beta oscillations, Bursts, Somatosensory, Inhibition, optically pumped magnetometers, Magnetoencephalography, MEG, Attention, Biological physics
MeSH: Attention*, Beta Rhythm*, Magnetoencephalography*, Somatosensory Cortex*, Adult, Electroencephalography, Female, Humans, Male, Young Adult (* major topic)
Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: EPSRC (EP/V047264/1)
Citations: cited by 3 papers (Europe PMC); 81 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.

GonReina/Braille_paradigm

License: none: the authors keep all their rights
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 10262acb01aed8488beee5491662ca23c4090514, 28 March 2023
Languages: Python (5)
Size: 14 files, 5 scripts
Software Heritage: not archived
Found in: the text, “Tactile attention paradigm”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PsychoPy (4 files), NumPy (3 files)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
6 files
At the source: github.com/GonReina/Braille_paradigm.git

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;
  • 5 scripts, each with its path and the digest of its content;
  • no match between paragraphs and code yet;
  • 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 says that the data are available on request
  • it says that the code is available on request

Read it in the paper: doi.org/10.1038/s41598-025-08037-8.

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, 14 authors, 9 keywords, 10 MeSH terms, 1 funder, 72 references.

Cite

This paper

Rivero, G. R., Tanner, Z., Rier, L., Hill, R. M., Shah, V., Rea, M., Doyle, C., Osborne, J., Bobela, D., Morris, P. G., Mullinger, K. J., Boto, E., Holmes, N., & Brookes, M. J. (2025). OPM-MEG reveals dynamics of beta bursts underlying attentional processes in sensory cortex. Scientific Reports, 15(1), 30471. https://doi.org/10.1038/s41598-025-08037-8

BibTeX

@article{rivero2025opm,
author = {Rivero, Gonzalo Reina and Tanner, Zoe and Rier, Lukas and Hill, Ryan M and Shah, Vishal and Rea, Molly and Doyle, Cody and Osborne, James and Bobela, David and Morris, Peter G and Mullinger, Karen J and Boto, Elena and Holmes, Niall and Brookes, Matthew J},
title = {{OPM-MEG reveals dynamics of beta bursts underlying attentional processes in sensory cortex}},
journal = {Scientific Reports},
year = {2025},
volume = {15},
number = {1},
pages = {30471},
publisher = {Nature Publishing Group},
issn = {2045-2322},
doi = {10.1038/s41598-025-08037-8},
url = {https://doi.org/10.1038/s41598-025-08037-8},
pmcid = {PMC12365038}
}

RIS

TY - JOUR
AU - Rivero, Gonzalo Reina
AU - Tanner, Zoe
AU - Rier, Lukas
AU - Hill, Ryan M
AU - Shah, Vishal
AU - Rea, Molly
AU - Doyle, Cody
AU - Osborne, James
AU - Bobela, David
AU - Morris, Peter G
AU - Mullinger, Karen J
AU - Boto, Elena
AU - Holmes, Niall
AU - Brookes, Matthew J
TI - OPM-MEG reveals dynamics of beta bursts underlying attentional processes in sensory cortex
T2 - Scientific Reports
J2 - Sci Rep
PY - 2025
DA - 2025
VL - 15
IS - 1
SP - 30471
SN - 2045-2322
PB - Nature Publishing Group
DO - 10.1038/s41598-025-08037-8
UR - https://doi.org/10.1038/s41598-025-08037-8
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41598-025-08037-8",
"type": "article-journal",
"title": "OPM-MEG reveals dynamics of beta bursts underlying attentional processes in sensory cortex",
"container-title": "Scientific Reports",
"author": [
{
"family": "Rivero",
"given": "Gonzalo Reina"
},
{
"family": "Tanner",
"given": "Zoe"
},
{
"family": "Rier",
"given": "Lukas"
},
{
"family": "Hill",
"given": "Ryan M"
},
{
"family": "Shah",
"given": "Vishal"
},
{
"family": "Rea",
"given": "Molly"
},
{
"family": "Doyle",
"given": "Cody"
},
{
"family": "Osborne",
"given": "James"
},
{
"family": "Bobela",
"given": "David"
},
{
"family": "Morris",
"given": "Peter G"
},
{
"family": "Mullinger",
"given": "Karen J"
},
{
"family": "Boto",
"given": "Elena"
},
{
"family": "Holmes",
"given": "Niall"
},
{
"family": "Brookes",
"given": "Matthew J"
}
],
"container-title-short": "Sci Rep",
"volume": "15",
"issue": "1",
"page": "30471",
"DOI": "10.1038/s41598-025-08037-8",
"PMCID": "PMC12365038",
"ISSN": "2045-2322",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41598-025-08037-8",
"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: NumPy, MEG, 14 references
[2] doi:10.1162/imag.a.1218 [code]
Reliability and signal comparison of OPM-MEG, fMRI & iEEG in a repeated movie viewing paradigm.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MEG, 12 references
[3] doi:10.3390/s26103131 [code]
Neuromagnetism "On the Cheap": Evaluating a Combined Cylindrical Shield and Partial-Coverage OPM-MEG System for Detecting Sensorimotor Responses in Humans.
Journal: Sensors (Basel, Switzerland)
In common: NumPy, MEG, 8 references
[4] doi:10.64898/2026.03.06.710026 [code]
Distinct beta burst motifs exhibit opposing error relationships during motor adaptation
Journal: bioRxiv (preprint)
In common: NumPy, 9 references
[5] doi:10.1007/s10548-025-01150-x
Movement Related Beta-Band Modulation with OPM-MEG: A Pilot Study
Journal: n/a
In common: MEG, 8 references
[6] doi:10.1016/j.isci.2025.113806 [code]
Beta-band frequency shifts signal decisions in human prefrontal cortex
Journal: n/a
In common: 9 references
[7] doi:10.1016/j.neuroimage.2026.121930
Quantifying cerebellar signal detectability in MEG and EEG in epilepsy using anatomically informed source modeling.
Journal: NeuroImage
In common: MEG, EEG, 7 references
[8] doi:10.1162/imag.a.1226 [code]
A neuroscientist's guide to neural burst detection.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: NumPy, 8 references
[9] doi:10.1111/psyp.70345 [code]
sBOSC: A Method for Source-Level Identification of Neural Oscillations in Electromagnetic Brain Signals.
Journal: Psychophysiology
In common: MEG, EEG, 8 references
[10] doi:10.1038/s41467-026-73553-8 [code]
Universal rhythmic architecture uncovers two modes of neural dynamics.
Journal: Nature communications
In common: NumPy, EEG, 7 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.