OSCR

<i>From concept to proof:</i> developing a neurofeedback-fNIRS protocol to train self-regulation for music performance anxiety in adolescent musicians.

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 · 1,881 lines · 77 KB · no license

  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. """
  4. This experiment was created using PsychoPy3 Experiment Builder (v2024.2.4),
  5. on June 11, 2025, at 16:41
  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. # --- Import packages ---
  15. from psychopy import locale_setup
  16. from psychopy import prefs
  17. from psychopy import plugins
  18. plugins.activatePlugins()
  19. prefs.hardware['audioLib'] = 'ptb'
  20. prefs.hardware['audioLatencyMode'] = '3'
  21. from psychopy import sound, gui, visual, core, data, event, logging, clock, colors, layout, hardware
  22. from psychopy.tools import environmenttools
  23. from psychopy.constants import (NOT_STARTED, STARTED, PLAYING, PAUSED,
  24. STOPPED, FINISHED, PRESSED, RELEASED, FOREVER, priority)
  26. import numpy as np # whole numpy lib is available, prepend 'np.'
  27. from numpy import (sin, cos, tan, log, log10, pi, average,
  28. sqrt, std, deg2rad, rad2deg, linspace, asarray)
  29. from numpy.random import random, randint, normal, shuffle, choice as randchoice
  30. import os # handy system and path functions
  31. import sys # to get file system encoding
  33. import psychopy.iohub as io
  34. from psychopy.hardware import keyboard
  36. # Run 'Before Experiment' code from code
  37. import random
  38. from pylsl import StreamInfo, StreamOutlet # import required classes
  40. situations = {
  41. "Situation1": './BIN/Recordings/Situation1/',
  42. "Situation2": './BIN/Recordings/Situation2/',
  43. "Situation3": './BIN/Recordings/Situation3/',
  44. "Situation4": './BIN/Recordings/Situation4/',
  45. "Situation5": './BIN/Recordings/Situation5/',
  46. "Situation6": './BIN/Recordings/Situation6/',
  47. "Situation7": './BIN/Recordings/Situation7/',
  48. "Situation8": './BIN/Recordings/Situation8/',
  49. "Situation9": './BIN/Recordings/Situation9/',
  50. "Situation10": './BIN/Recordings/Situation10/',
  51. "Situation11": './BIN/Recordings/Situation11/',
  52. "Situation12": './BIN/Recordings/Situation12/',
  53. "Situation13": './BIN/Recordings/Situation13/',
  54. "Situation14": './BIN/Recordings/Situation14/',
  55. "Situation15": './BIN/Recordings/Situation15/',
  56. "Situation16": './BIN/Recordings/Situation16/',
  57. "Situation17": './BIN/Recordings/Situation17/',
  58. "Situation18": './BIN/Recordings/Situation18/',
  59. "Situation19": './BIN/Recordings/Situation19/'
  60. }
  62. iteration = 0
  63. iteration_ctr = 0
  65. ctr_lst = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]
  66. str_lst = [1,2,3,4,5]
  67. # Run 'Before Experiment' code from code_7
  68. import time
  69. # --- Setup global variables (available in all functions) ---
  70. # create a device manager to handle hardware (keyboards, mice, mirophones, speakers, etc.)
  71. deviceManager = hardware.DeviceManager()
  72. # ensure that relative paths start from the same directory as this script
  73. _thisDir = os.path.dirname(os.path.abspath(__file__))
  74. # store info about the experiment session
  75. psychopyVersion = '2024.2.4'
  76. expName = 'Model of training' # from the Builder filename that created this script
  77. # information about this experiment
  78. expInfo = {
  79. 'participant': f"{randint(0, 999999):06.0f}",
  80. 'session': '001',
  81. 'Situation': '',
  82. 'date|hid': data.getDateStr(),
  83. 'expName|hid': expName,
  84. 'psychopyVersion|hid': psychopyVersion,
  85. }
  87. # --- Define some variables which will change depending on pilot mode ---
  88. '''
  89. To run in pilot mode, either use the run/pilot toggle in Builder, Coder and Runner,
  90. or run the experiment with `--pilot` as an argument. To change what pilot
  91. #mode does, check out the 'Pilot mode' tab in preferences.
  92. '''
  93. # work out from system args whether we are running in pilot mode
  94. PILOTING = core.setPilotModeFromArgs()
  95. # start off with values from experiment settings
  96. _fullScr = False
  97. _winSize = [800, 900]
  98. # if in pilot mode, apply overrides according to preferences
  99. if PILOTING:
  100. # force windowed mode
  101. if prefs.piloting['forceWindowed']:
  102. _fullScr = False
  103. # set window size
  104. _winSize = prefs.piloting['forcedWindowSize']
  106. def showExpInfoDlg(expInfo):
  107. """
  108. Show participant info dialog.
  109. Parameters
  110. ==========
  111. expInfo : dict
  112. Information about this experiment.
  114. Returns
  115. ==========
  116. dict
  117. Information about this experiment.
  118. """
  119. # show participant info dialog
  120. dlg = gui.DlgFromDict(
  121. dictionary=expInfo, sortKeys=False, title=expName, alwaysOnTop=True
  122. )
  123. if dlg.OK == False:
  124. core.quit() # user pressed cancel
  125. # return expInfo
  126. return expInfo
  129. def setupData(expInfo, dataDir=None):
  130. """
  131. Make an ExperimentHandler to handle trials and saving.
  133. Parameters
  134. ==========
  135. expInfo : dict
  136. Information about this experiment, created by the `setupExpInfo` function.
  137. dataDir : Path, str or None
  138. Folder to save the data to, leave as None to create a folder in the current directory.
  139. Returns
  140. ==========
  141. psychopy.data.ExperimentHandler
  142. Handler object for this experiment, contains the data to save and information about
  143. where to save it to.
  144. """
  145. # remove dialog-specific syntax from expInfo
  146. for key, val in expInfo.copy().items():
  147. newKey, _ = data.utils.parsePipeSyntax(key)
  148. expInfo[newKey] = expInfo.pop(key)
  150. # data file name stem = absolute path + name; later add .psyexp, .csv, .log, etc
  151. if dataDir is None:
  152. dataDir = _thisDir
  153. filename = u'data/%s_%s_%s' % (expInfo['participant'], expName, expInfo['date'])
  154. # make sure filename is relative to dataDir
  155. if os.path.isabs(filename):
  156. dataDir = os.path.commonprefix([dataDir, filename])
  157. filename = os.path.relpath(filename, dataDir)
  159. # an ExperimentHandler isn't essential but helps with data saving
  160. thisExp = data.ExperimentHandler(
  161. name=expName, version='',
  162. extraInfo=expInfo, runtimeInfo=None,
  163. originPath='C:\\Users\\User\\Desktop\\Musa\\Musa - Protocolo Pedro\\Model of training_lastrun.py',
  164. savePickle=True, saveWideText=True,
  165. dataFileName=dataDir + os.sep + filename, sortColumns='time'
  166. )
  167. thisExp.setPriority('thisRow.t', priority.CRITICAL)
  168. thisExp.setPriority('expName', priority.LOW)
  169. # return experiment handler
  170. return thisExp
  173. def setupLogging(filename):
  174. """
  175. Setup a log file and tell it what level to log at.
  177. Parameters
  178. ==========
  179. filename : str or pathlib.Path
  180. Filename to save log file and data files as, doesn't need an extension.
  182. Returns
  183. ==========
  184. psychopy.logging.LogFile
  185. Text stream to receive inputs from the logging system.
  186. """
  187. # set how much information should be printed to the console / app
  188. if PILOTING:
  189. logging.console.setLevel(
  190. prefs.piloting['pilotConsoleLoggingLevel']
  191. )
  192. else:
  193. logging.console.setLevel('warning')
  194. # save a log file for detail verbose info
  195. logFile = logging.LogFile(filename+'.log')
  196. if PILOTING:
  197. logFile.setLevel(
  198. prefs.piloting['pilotLoggingLevel']
  199. )
  200. else:
  201. logFile.setLevel(
  202. logging.getLevel('info')
  203. )
  205. return logFile
  208. def setupWindow(expInfo=None, win=None):
  209. """
  210. Setup the Window
  212. Parameters
  213. ==========
  214. expInfo : dict
  215. Information about this experiment, created by the `setupExpInfo` function.
  216. win : psychopy.visual.Window
  217. Window to setup - leave as None to create a new window.
  219. Returns
  220. ==========
  221. psychopy.visual.Window
  222. Window in which to run this experiment.
  223. """
  224. if win is None:
  225. # if not given a window to setup, make one
  226. win = visual.Window(
  227. size=_winSize, fullscr=_fullScr, screen=0,
  228. winType='pyglet', allowGUI=True, allowStencil=False,
  229. monitor='testMonitor', color=[0,0,0], colorSpace='rgb',
  230. backgroundImage='', backgroundFit='none',
  231. blendMode='avg', useFBO=True,
  232. units='height',
  233. checkTiming=False # we're going to do this ourselves in a moment
  234. )
  235. else:
  236. # if we have a window, just set the attributes which are safe to set
  237. win.color = [0,0,0]
  238. win.colorSpace = 'rgb'
  239. win.backgroundImage = ''
  240. win.backgroundFit = 'none'
  241. win.units = 'height'
  242. if expInfo is not None:
  243. # get/measure frame rate if not already in expInfo
  244. if win._monitorFrameRate is None:
  245. win._monitorFrameRate = win.getActualFrameRate(infoMsg='Attempting to measure frame rate of screen, please wait...')
  246. expInfo['frameRate'] = win._monitorFrameRate
  247. win.hideMessage()
  248. # show a visual indicator if we're in piloting mode
  249. if PILOTING and prefs.piloting['showPilotingIndicator']:
  250. win.showPilotingIndicator()
  252. return win
  255. def setupDevices(expInfo, thisExp, win):
  256. """
  257. Setup whatever devices are available (mouse, keyboard, speaker, eyetracker, etc.) and add them to
  258. the device manager (deviceManager)
  260. Parameters
  261. ==========
  262. expInfo : dict
  263. Information about this experiment, created by the `setupExpInfo` function.
  264. thisExp : psychopy.data.ExperimentHandler
  265. Handler object for this experiment, contains the data to save and information about
  266. where to save it to.
  267. win : psychopy.visual.Window
  268. Window in which to run this experiment.
  269. Returns
  270. ==========
  271. bool
  272. True if completed successfully.
  273. """
  274. # --- Setup input devices ---
  275. ioConfig = {}
  277. # Setup iohub keyboard
  278. ioConfig['Keyboard'] = dict(use_keymap='psychopy')
  280. # Setup iohub experiment
  281. ioConfig['Experiment'] = dict(filename=thisExp.dataFileName)
  283. # Start ioHub server
  284. ioServer = io.launchHubServer(window=win, **ioConfig)
  286. # store ioServer object in the device manager
  287. deviceManager.ioServer = ioServer
  289. # create a default keyboard (e.g. to check for escape)
  290. if deviceManager.getDevice('defaultKeyboard') is None:
  291. deviceManager.addDevice(
  292. deviceClass='keyboard', deviceName='defaultKeyboard', backend='iohub'
  293. )
  294. if deviceManager.getDevice('key_resp') is None:
  295. # initialise key_resp
  296. key_resp = deviceManager.addDevice(
  297. deviceClass='keyboard',
  298. deviceName='key_resp',
  299. )
  300. # create speaker 'sound_1'
  301. deviceManager.addDevice(
  302. deviceName='sound_1',
  303. deviceClass='psychopy.hardware.speaker.SpeakerDevice',
  304. index=-1
  305. )
  306. # create speaker 'sound_2'
  307. deviceManager.addDevice(
  308. deviceName='sound_2',
  309. deviceClass='psychopy.hardware.speaker.SpeakerDevice',
  310. index=-1
  311. )
  312. # create speaker 'sound_3'
  313. deviceManager.addDevice(
  314. deviceName='sound_3',
  315. deviceClass='psychopy.hardware.speaker.SpeakerDevice',
  316. index=-1
  317. )
  318. # return True if completed successfully
  319. return True
  321. def pauseExperiment(thisExp, win=None, timers=[], playbackComponents=[]):
  322. """
  323. Pause this experiment, preventing the flow from advancing to the next routine until resumed.
  325. Parameters
  326. ==========
  327. thisExp : psychopy.data.ExperimentHandler
  328. Handler object for this experiment, contains the data to save and information about
  329. where to save it to.
  330. win : psychopy.visual.Window
  331. Window for this experiment.
  332. timers : list, tuple
  333. List of timers to reset once pausing is finished.
  334. playbackComponents : list, tuple
  335. List of any components with a `pause` method which need to be paused.
  336. """
  337. # if we are not paused, do nothing
  338. if thisExp.status != PAUSED:
  339. return
  341. # start a timer to figure out how long we're paused for
  342. pauseTimer = core.Clock()
  343. # pause any playback components
  344. for comp in playbackComponents:
  345. comp.pause()
  346. # make sure we have a keyboard
  347. defaultKeyboard = deviceManager.getDevice('defaultKeyboard')
  348. if defaultKeyboard is None:
  349. defaultKeyboard = deviceManager.addKeyboard(
  350. deviceClass='keyboard',
  351. deviceName='defaultKeyboard',
  352. backend='ioHub',
  353. )
  354. # run a while loop while we wait to unpause
  355. while thisExp.status == PAUSED:
  356. # check for quit (typically the Esc key)
  357. if defaultKeyboard.getKeys(keyList=['escape']):
  358. endExperiment(thisExp, win=win)
  359. # sleep 1ms so other threads can execute
  360. clock.time.sleep(0.001)
  361. # if stop was requested while paused, quit
  362. if thisExp.status == FINISHED:
  363. endExperiment(thisExp, win=win)
  364. # resume any playback components
  365. for comp in playbackComponents:
  366. comp.play()
  367. # reset any timers
  368. for timer in timers:
  369. timer.addTime(-pauseTimer.getTime())
  372. def run(expInfo, thisExp, win, globalClock=None, thisSession=None):
  373. """
  374. Run the experiment flow.
  376. Parameters
  377. ==========
  378. expInfo : dict
  379. Information about this experiment, created by the `setupExpInfo` function.
  380. thisExp : psychopy.data.ExperimentHandler
  381. Handler object for this experiment, contains the data to save and information about
  382. where to save it to.
  383. psychopy.visual.Window
  384. Window in which to run this experiment.
  385. globalClock : psychopy.core.clock.Clock or None
  386. Clock to get global time from - supply None to make a new one.
  387. thisSession : psychopy.session.Session or None
  388. Handle of the Session object this experiment is being run from, if any.
  389. """
  390. # mark experiment as started
  391. thisExp.status = STARTED
  392. # make sure window is set to foreground to prevent losing focus
  393. win.winHandle.activate()
  394. # make sure variables created by exec are available globally
  395. exec = environmenttools.setExecEnvironment(globals())
  396. # get device handles from dict of input devices
  397. ioServer = deviceManager.ioServer
  398. # get/create a default keyboard (e.g. to check for escape)
  399. defaultKeyboard = deviceManager.getDevice('defaultKeyboard')
  400. if defaultKeyboard is None:
  401. deviceManager.addDevice(
  402. deviceClass='keyboard', deviceName='defaultKeyboard', backend='ioHub'
  403. )
  404. eyetracker = deviceManager.getDevice('eyetracker')
  405. # make sure we're running in the directory for this experiment
  406. os.chdir(_thisDir)
  407. # get filename from ExperimentHandler for convenience
  408. filename = thisExp.dataFileName
  409. frameTolerance = 0.001 # how close to onset before 'same' frame
  410. endExpNow = False # flag for 'escape' or other condition => quit the exp
  411. # get frame duration from frame rate in expInfo
  412. if 'frameRate' in expInfo and expInfo['frameRate'] is not None:
  413. frameDur = 1.0 / round(expInfo['frameRate'])
  414. else:
  415. frameDur = 1.0 / 60.0 # could not measure, so guess
  417. # Start Code - component code to be run after the window creation
  419. # --- Initialize components for Routine "Prep" ---
  420. # Run 'Begin Experiment' code from code
  421. info = StreamInfo(name='Trigger', type='Markers', channel_count=1, channel_format='int32', source_id='Example')
  422. outlet = StreamOutlet(info)
  424. group = expInfo['Situation']
  425. sess = expInfo['session']
  427. if group == "1":
  428. folder = situations["Situation1"]
  429. elif group == "2":
  430. folder = situations["Situation2"]
  431. elif group == "3":
  432. folder = situations["Situation3"]
  433. elif group == "4":
  434. folder = situations["Situation4"]
  435. elif group == "5":
  436. folder = situations["Situation5"]
  437. elif group == "6":
  438. folder = situations["Situation6"]
  439. elif group == "7":
  440. folder = situations["Situation7"]
  441. elif group == "8":
  442. folder = situations["Situation8"]
  443. elif group == "9":
  444. folder = situations["Situation9"]
  445. elif group == "10":
  446. folder = situations["Situation10"]
  447. elif group == "11":
  448. folder = situations["Situation11"]
  449. elif group == "12":
  450. folder = situations["Situation12"]
  451. elif group == "13":
  452. folder = situations["Situation13"]
  453. elif group == "14":
  454. folder = situations["Situation14"]
  455. elif group == "15":
  456. folder = situations["Situation15"]
  457. elif group == "16":
  458. folder = situations["Situation16"]
  459. elif group == "17":
  460. folder = situations["Situation17"]
  461. elif group == "18":
  462. folder = situations["Situation18"]
  463. elif group == "19":
  464. folder = situations["Situation19"]
  466. random.shuffle(ctr_lst)
  467. random.shuffle(str_lst)
  469. # --- Initialize components for Routine "check_lsl" ---
  470. key_resp = keyboard.Keyboard(deviceName='key_resp')
  471. text_4 = visual.TextStim(win=win, name='text_4',
  472. text='Por favor verifique se a luz verde de trigger está presente no programa aurora antes de avançar.\n\nApós verificar o trigger pode explicar ao participante como procederá a sessão. Explique a tarefa de linha de base:\n\n"Por favor sente-se relaxado e como os olhos fechados durante os próximos 3 minutos, eu aviso quando o tempo chegar ao fim."\n\nApós verificar pode começar o protocolo com a barra de espaços.',
  473. font='Arial',
  474. pos=(0, 0), draggable=False, height=0.05, wrapWidth=None, ori=0.0,
  475. color='white', colorSpace='rgb', opacity=None,
  476. languageStyle='LTR',
  477. depth=-1.0);
  479. # --- Initialize components for Routine "baseline" ---
  480. polygon = visual.ShapeStim(
  481. win=win, name='polygon', vertices='cross',
  482. size=(0.5, 0.5),
  483. ori=0.0, pos=(0, 0), draggable=False, anchor='center',
  484. lineWidth=1.0,
  485. colorSpace='rgb', lineColor='white', fillColor='white',
  486. opacity=None, depth=-1.0, interpolate=True)
  488. # --- Initialize components for Routine "present_situation" ---
  489. sound_1 = sound.Sound(
  490. 'A',
  491. secs=-1,
  492. stereo=True,
  493. hamming=True,
  494. speaker='sound_1', name='sound_1'
  495. )
  496. sound_1.setVolume(1.0)
  497. text = visual.TextStim(win=win, name='text',
  498. text='Explicação de contexto a decorrer\n',
  499. font='Arial',
  500. pos=(0, 0), draggable=False, height=0.05, wrapWidth=None, ori=0.0,
  501. color='white', colorSpace='rgb', opacity=None,
  502. languageStyle='LTR',
  503. depth=-2.0);
  505. # --- Initialize components for Routine "it_setter" ---
  507. # --- Initialize components for Routine "stressor" ---
  508. sound_2 = sound.Sound(
  509. 'A',
  510. secs=-1,
  511. stereo=True,
  512. hamming=True,
  513. speaker='sound_2', name='sound_2'
  514. )
  515. sound_2.setVolume(1.0)
  516. text_2 = visual.TextStim(win=win, name='text_2',
  517. text='A apresentar stressor',
  518. font='Arial',
  519. pos=(0, 0), draggable=False, height=0.05, wrapWidth=None, ori=0.0,
  520. color='white', colorSpace='rgb', opacity=None,
  521. languageStyle='LTR',
  522. depth=-2.0);
  524. # --- Initialize components for Routine "it_ctr" ---
  526. # --- Initialize components for Routine "control" ---
  527. sound_3 = sound.Sound(
  528. 'A',
  529. secs=-1,
  530. stereo=True,
  531. hamming=True,
  532. speaker='sound_3', name='sound_3'
  533. )
  534. sound_3.setVolume(1.0)
  535. text_3 = visual.TextStim(win=win, name='text_3',
  536. text='A apresentar controlo',
  537. font='Arial',
  538. pos=(0, 0), draggable=False, height=0.05, wrapWidth=None, ori=0.0,
  539. color='white', colorSpace='rgb', opacity=None,
  540. languageStyle='LTR',
  541. depth=-2.0);
  543. # --- Initialize components for Routine "ender" ---
  544. text_7 = visual.TextStim(win=win, name='text_7',
  545. text='Sessão finalizada\n',
  546. font='Arial',
  547. pos=(0, 0), draggable=False, height=0.05, wrapWidth=None, ori=0.0,
  548. color='white', colorSpace='rgb', opacity=None,
  549. languageStyle='LTR',
  550. depth=-1.0);
  552. # create some handy timers
  554. # global clock to track the time since experiment started
  555. if globalClock is None:
  556. # create a clock if not given one
  557. globalClock = core.Clock()
  558. if isinstance(globalClock, str):
  559. # if given a string, make a clock accoridng to it
  560. if globalClock == 'float':
  561. # get timestamps as a simple value
  562. globalClock = core.Clock(format='float')
  563. elif globalClock == 'iso':
  564. # get timestamps in ISO format
  565. globalClock = core.Clock(format='%Y-%m-%d_%H:%M:%S.%f%z')
  566. else:
  567. # get timestamps in a custom format
  568. globalClock = core.Clock(format=globalClock)
  569. if ioServer is not None:
  570. ioServer.syncClock(globalClock)
  571. logging.setDefaultClock(globalClock)
  572. # routine timer to track time remaining of each (possibly non-slip) routine
  573. routineTimer = core.Clock()
  574. win.flip() # flip window to reset last flip timer
  575. # store the exact time the global clock started
  576. expInfo['expStart'] = data.getDateStr(
  577. format='%Y-%m-%d %Hh%M.%S.%f %z', fractionalSecondDigits=6
  578. )
  580. # --- Prepare to start Routine "Prep" ---
  581. # create an object to store info about Routine Prep
  582. Prep = data.Routine(
  583. name='Prep',
  584. components=[],
  585. )
  586. Prep.status = NOT_STARTED
  587. continueRoutine = True
  588. # update component parameters for each repeat
  589. # Run 'Begin Routine' code from code
  590. outlet.push_sample(x=[0])
  591. # store start times for Prep
  592. Prep.tStartRefresh = win.getFutureFlipTime(clock=globalClock)
  593. Prep.tStart = globalClock.getTime(format='float')
  594. Prep.status = STARTED
  595. thisExp.addData('Prep.started', Prep.tStart)
  596. Prep.maxDuration = None
  597. # keep track of which components have finished
  598. PrepComponents = Prep.components
  599. for thisComponent in Prep.components:
  600. thisComponent.tStart = None
  601. thisComponent.tStop = None
  602. thisComponent.tStartRefresh = None
  603. thisComponent.tStopRefresh = None
  604. if hasattr(thisComponent, 'status'):
  605. thisComponent.status = NOT_STARTED
  606. # reset timers
  607. t = 0
  608. _timeToFirstFrame = win.getFutureFlipTime(clock="now")
  609. frameN = -1
  611. # --- Run Routine "Prep" ---
  612. Prep.forceEnded = routineForceEnded = not continueRoutine
  613. while continueRoutine:
  614. # get current time
  615. t = routineTimer.getTime()
  616. tThisFlip = win.getFutureFlipTime(clock=routineTimer)
  617. tThisFlipGlobal = win.getFutureFlipTime(clock=None)
  618. frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
  619. # update/draw components on each frame
  621. # check for quit (typically the Esc key)
  622. if defaultKeyboard.getKeys(keyList=["escape"]):
  623. thisExp.status = FINISHED
  624. if thisExp.status == FINISHED or endExpNow:
  625. endExperiment(thisExp, win=win)
  626. return
  627. # pause experiment here if requested
  628. if thisExp.status == PAUSED:
  629. pauseExperiment(
  630. thisExp=thisExp,
  631. win=win,
  632. timers=[routineTimer],
  633. playbackComponents=[]
  634. )
  635. # skip the frame we paused on
  636. continue
  638. # check if all components have finished
  639. if not continueRoutine: # a component has requested a forced-end of Routine
  640. Prep.forceEnded = routineForceEnded = True
  641. break
  642. continueRoutine = False # will revert to True if at least one component still running
  643. for thisComponent in Prep.components:
  644. if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
  645. continueRoutine = True
  646. break # at least one component has not yet finished
  648. # refresh the screen
  649. if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
  650. win.flip()
  652. # --- Ending Routine "Prep" ---
  653. for thisComponent in Prep.components:
  654. if hasattr(thisComponent, "setAutoDraw"):
  655. thisComponent.setAutoDraw(False)
  656. # store stop times for Prep
  657. Prep.tStop = globalClock.getTime(format='float')
  658. Prep.tStopRefresh = tThisFlipGlobal
  659. thisExp.addData('Prep.stopped', Prep.tStop)
  660. thisExp.nextEntry()
  661. # the Routine "Prep" was not non-slip safe, so reset the non-slip timer
  662. routineTimer.reset()
  664. # --- Prepare to start Routine "check_lsl" ---
  665. # create an object to store info about Routine check_lsl
  666. check_lsl = data.Routine(
  667. name='check_lsl',
  668. components=[key_resp, text_4],
  669. )
  670. check_lsl.status = NOT_STARTED
  671. continueRoutine = True
  672. # update component parameters for each repeat
  673. # create starting attributes for key_resp
  674. key_resp.keys = []
  675. key_resp.rt = []
  676. _key_resp_allKeys = []
  677. # store start times for check_lsl
  678. check_lsl.tStartRefresh = win.getFutureFlipTime(clock=globalClock)
  679. check_lsl.tStart = globalClock.getTime(format='float')
  680. check_lsl.status = STARTED
  681. thisExp.addData('check_lsl.started', check_lsl.tStart)
  682. check_lsl.maxDuration = None
  683. # keep track of which components have finished
  684. check_lslComponents = check_lsl.components
  685. for thisComponent in check_lsl.components:
  686. thisComponent.tStart = None
  687. thisComponent.tStop = None
  688. thisComponent.tStartRefresh = None
  689. thisComponent.tStopRefresh = None
  690. if hasattr(thisComponent, 'status'):
  691. thisComponent.status = NOT_STARTED
  692. # reset timers
  693. t = 0
  694. _timeToFirstFrame = win.getFutureFlipTime(clock="now")
  695. frameN = -1
  697. # --- Run Routine "check_lsl" ---
  698. check_lsl.forceEnded = routineForceEnded = not continueRoutine
  699. while continueRoutine:
  700. # get current time
  701. t = routineTimer.getTime()
  702. tThisFlip = win.getFutureFlipTime(clock=routineTimer)
  703. tThisFlipGlobal = win.getFutureFlipTime(clock=None)
  704. frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
  705. # update/draw components on each frame
  707. # *key_resp* updates
  708. waitOnFlip = False
  710. # if key_resp is starting this frame...
  711. if key_resp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
  712. # keep track of start time/frame for later
  713. key_resp.frameNStart = frameN # exact frame index
  714. key_resp.tStart = t # local t and not account for scr refresh
  715. key_resp.tStartRefresh = tThisFlipGlobal # on global time
  716. win.timeOnFlip(key_resp, 'tStartRefresh') # time at next scr refresh
  717. # add timestamp to datafile
  718. thisExp.timestampOnFlip(win, 'key_resp.started')
  719. # update status
  720. key_resp.status = STARTED
  721. # keyboard checking is just starting
  722. waitOnFlip = True
  723. win.callOnFlip(key_resp.clock.reset) # t=0 on next screen flip
  724. win.callOnFlip(key_resp.clearEvents, eventType='keyboard') # clear events on next screen flip
  725. if key_resp.status == STARTED and not waitOnFlip:
  726. theseKeys = key_resp.getKeys(keyList=['space'], ignoreKeys=["escape"], waitRelease=False)
  727. _key_resp_allKeys.extend(theseKeys)
  728. if len(_key_resp_allKeys):
  729. key_resp.keys = _key_resp_allKeys[-1].name # just the last key pressed
  730. key_resp.rt = _key_resp_allKeys[-1].rt
  731. key_resp.duration = _key_resp_allKeys[-1].duration
  732. # a response ends the routine
  733. continueRoutine = False
  735. # *text_4* updates
  737. # if text_4 is starting this frame...
  738. if text_4.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
  739. # keep track of start time/frame for later
  740. text_4.frameNStart = frameN # exact frame index
  741. text_4.tStart = t # local t and not account for scr refresh
  742. text_4.tStartRefresh = tThisFlipGlobal # on global time
  743. win.timeOnFlip(text_4, 'tStartRefresh') # time at next scr refresh
  744. # add timestamp to datafile
  745. thisExp.timestampOnFlip(win, 'text_4.started')
  746. # update status
  747. text_4.status = STARTED
  748. text_4.setAutoDraw(True)
  750. # if text_4 is active this frame...
  751. if text_4.status == STARTED:
  752. # update params
  753. pass
  755. # check for quit (typically the Esc key)
  756. if defaultKeyboard.getKeys(keyList=["escape"]):
  757. thisExp.status = FINISHED
  758. if thisExp.status == FINISHED or endExpNow:
  759. endExperiment(thisExp, win=win)
  760. return
  761. # pause experiment here if requested
  762. if thisExp.status == PAUSED:
  763. pauseExperiment(
  764. thisExp=thisExp,
  765. win=win,
  766. timers=[routineTimer],
  767. playbackComponents=[]
  768. )
  769. # skip the frame we paused on
  770. continue
  772. # check if all components have finished
  773. if not continueRoutine: # a component has requested a forced-end of Routine
  774. check_lsl.forceEnded = routineForceEnded = True
  775. break
  776. continueRoutine = False # will revert to True if at least one component still running
  777. for thisComponent in check_lsl.components:
  778. if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
  779. continueRoutine = True
  780. break # at least one component has not yet finished
  782. # refresh the screen
  783. if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
  784. win.flip()
  786. # --- Ending Routine "check_lsl" ---
  787. for thisComponent in check_lsl.components:
  788. if hasattr(thisComponent, "setAutoDraw"):
  789. thisComponent.setAutoDraw(False)
  790. # store stop times for check_lsl
  791. check_lsl.tStop = globalClock.getTime(format='float')
  792. check_lsl.tStopRefresh = tThisFlipGlobal
  793. thisExp.addData('check_lsl.stopped', check_lsl.tStop)
  794. # check responses
  795. if key_resp.keys in ['', [], None]: # No response was made
  796. key_resp.keys = None
  797. thisExp.addData('key_resp.keys',key_resp.keys)
  798. if key_resp.keys != None: # we had a response
  799. thisExp.addData('key_resp.rt', key_resp.rt)
  800. thisExp.addData('key_resp.duration', key_resp.duration)
  801. thisExp.nextEntry()
  802. # the Routine "check_lsl" was not non-slip safe, so reset the non-slip timer
  803. routineTimer.reset()
  805. # --- Prepare to start Routine "baseline" ---
  806. # create an object to store info about Routine baseline
  807. baseline = data.Routine(
  808. name='baseline',
  809. components=[polygon],
  810. )
  811. baseline.status = NOT_STARTED
  812. continueRoutine = True
  813. # update component parameters for each repeat
  814. # Run 'Begin Routine' code from code_7
  815. outlet.push_sample(x=[1])
  817. start = time.time()
  819. texted = 0
  820. # store start times for baseline
  821. baseline.tStartRefresh = win.getFutureFlipTime(clock=globalClock)
  822. baseline.tStart = globalClock.getTime(format='float')
  823. baseline.status = STARTED
  824. thisExp.addData('baseline.started', baseline.tStart)
  825. baseline.maxDuration = None
  826. # keep track of which components have finished
  827. baselineComponents = baseline.components
  828. for thisComponent in baseline.components:
  829. thisComponent.tStart = None
  830. thisComponent.tStop = None
  831. thisComponent.tStartRefresh = None
  832. thisComponent.tStopRefresh = None
  833. if hasattr(thisComponent, 'status'):
  834. thisComponent.status = NOT_STARTED
  835. # reset timers
  836. t = 0
  837. _timeToFirstFrame = win.getFutureFlipTime(clock="now")
  838. frameN = -1
  840. # --- Run Routine "baseline" ---
  841. baseline.forceEnded = routineForceEnded = not continueRoutine
  842. while continueRoutine and routineTimer.getTime() < 180.0:
  843. # get current time
  844. t = routineTimer.getTime()
  845. tThisFlip = win.getFutureFlipTime(clock=routineTimer)
  846. tThisFlipGlobal = win.getFutureFlipTime(clock=None)
  847. frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
  848. # update/draw components on each frame
  849. # Run 'Each Frame' code from code_7
  850. timer = time.time() - start
  852. texted = f'{timer}'
  854. if timer > 180:
  855. continueRoutine = False
  857. # *polygon* updates
  859. # if polygon is starting this frame...
  860. if polygon.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
  861. # keep track of start time/frame for later
  862. polygon.frameNStart = frameN # exact frame index
  863. polygon.tStart = t # local t and not account for scr refresh
  864. polygon.tStartRefresh = tThisFlipGlobal # on global time
  865. win.timeOnFlip(polygon, 'tStartRefresh') # time at next scr refresh
  866. # add timestamp to datafile
  867. thisExp.timestampOnFlip(win, 'polygon.started')
  868. # update status
  869. polygon.status = STARTED
  870. polygon.setAutoDraw(True)
  872. # if polygon is active this frame...
  873. if polygon.status == STARTED:
  874. # update params
  875. pass
  877. # if polygon is stopping this frame...
  878. if polygon.status == STARTED:
  879. # is it time to stop? (based on global clock, using actual start)
  880. if tThisFlipGlobal > polygon.tStartRefresh + 180-frameTolerance:
  881. # keep track of stop time/frame for later
  882. polygon.tStop = t # not accounting for scr refresh
  883. polygon.tStopRefresh = tThisFlipGlobal # on global time
  884. polygon.frameNStop = frameN # exact frame index
  885. # add timestamp to datafile
  886. thisExp.timestampOnFlip(win, 'polygon.stopped')
  887. # update status
  888. polygon.status = FINISHED
  889. polygon.setAutoDraw(False)
  891. # check for quit (typically the Esc key)
  892. if defaultKeyboard.getKeys(keyList=["escape"]):
  893. thisExp.status = FINISHED
  894. if thisExp.status == FINISHED or endExpNow:
  895. endExperiment(thisExp, win=win)
  896. return
  897. # pause experiment here if requested
  898. if thisExp.status == PAUSED:
  899. pauseExperiment(
  900. thisExp=thisExp,
  901. win=win,
  902. timers=[routineTimer],
  903. playbackComponents=[]
  904. )
  905. # skip the frame we paused on
  906. continue
  908. # check if all components have finished
  909. if not continueRoutine: # a component has requested a forced-end of Routine
  910. baseline.forceEnded = routineForceEnded = True
  911. break
  912. continueRoutine = False # will revert to True if at least one component still running
  913. for thisComponent in baseline.components:
  914. if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
  915. continueRoutine = True
  916. break # at least one component has not yet finished
  918. # refresh the screen
  919. if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
  920. win.flip()
  922. # --- Ending Routine "baseline" ---
  923. for thisComponent in baseline.components:
  924. if hasattr(thisComponent, "setAutoDraw"):
  925. thisComponent.setAutoDraw(False)
  926. # store stop times for baseline
  927. baseline.tStop = globalClock.getTime(format='float')
  928. baseline.tStopRefresh = tThisFlipGlobal
  929. thisExp.addData('baseline.stopped', baseline.tStop)
  930. # Run 'End Routine' code from code_7
  931. outlet.push_sample(x=[2])
  932. # using non-slip timing so subtract the expected duration of this Routine (unless ended on request)
  933. if baseline.maxDurationReached:
  934. routineTimer.addTime(-baseline.maxDuration)
  935. elif baseline.forceEnded:
  936. routineTimer.reset()
  937. else:
  938. routineTimer.addTime(-180.000000)
  939. thisExp.nextEntry()
  941. # --- Prepare to start Routine "present_situation" ---
  942. # create an object to store info about Routine present_situation
  943. present_situation = data.Routine(
  944. name='present_situation',
  945. components=[sound_1, text],
  946. )
  947. present_situation.status = NOT_STARTED
  948. continueRoutine = True
  949. # update component parameters for each repeat
  950. # Run 'Begin Routine' code from code_2
  951. outlet.push_sample(x=[3])
  954. sound_1.setSound(f'{folder}situation.wav', secs=60, hamming=True)
  955. sound_1.setVolume(1.0, log=False)
  956. sound_1.seek(0)
  957. # store start times for present_situation
  958. present_situation.tStartRefresh = win.getFutureFlipTime(clock=globalClock)
  959. present_situation.tStart = globalClock.getTime(format='float')
  960. present_situation.status = STARTED
  961. thisExp.addData('present_situation.started', present_situation.tStart)
  962. present_situation.maxDuration = None
  963. # keep track of which components have finished
  964. present_situationComponents = present_situation.components
  965. for thisComponent in present_situation.components:
  966. thisComponent.tStart = None
  967. thisComponent.tStop = None
  968. thisComponent.tStartRefresh = None
  969. thisComponent.tStopRefresh = None
  970. if hasattr(thisComponent, 'status'):
  971. thisComponent.status = NOT_STARTED
  972. # reset timers
  973. t = 0
  974. _timeToFirstFrame = win.getFutureFlipTime(clock="now")
  975. frameN = -1
  977. # --- Run Routine "present_situation" ---
  978. present_situation.forceEnded = routineForceEnded = not continueRoutine
  979. while continueRoutine and routineTimer.getTime() < 60.0:
  980. # get current time
  981. t = routineTimer.getTime()
  982. tThisFlip = win.getFutureFlipTime(clock=routineTimer)
  983. tThisFlipGlobal = win.getFutureFlipTime(clock=None)
  984. frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
  985. # update/draw components on each frame
  987. # *sound_1* updates
  989. # if sound_1 is starting this frame...
  990. if sound_1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
  991. # keep track of start time/frame for later
  992. sound_1.frameNStart = frameN # exact frame index
  993. sound_1.tStart = t # local t and not account for scr refresh
  994. sound_1.tStartRefresh = tThisFlipGlobal # on global time
  995. # add timestamp to datafile
  996. thisExp.addData('sound_1.started', tThisFlipGlobal)
  997. # update status
  998. sound_1.status = STARTED
  999. sound_1.play(when=win) # sync with win flip
  1001. # if sound_1 is stopping this frame...
  1002. if sound_1.status == STARTED:
  1003. # is it time to stop? (based on global clock, using actual start)
  1004. if tThisFlipGlobal > sound_1.tStartRefresh + 60-frameTolerance or sound_1.isFinished:
  1005. # keep track of stop time/frame for later
  1006. sound_1.tStop = t # not accounting for scr refresh
  1007. sound_1.tStopRefresh = tThisFlipGlobal # on global time
  1008. sound_1.frameNStop = frameN # exact frame index
  1009. # add timestamp to datafile
  1010. thisExp.timestampOnFlip(win, 'sound_1.stopped')
  1011. # update status
  1012. sound_1.status = FINISHED
  1013. sound_1.stop()
  1015. # *text* updates
  1017. # if text is starting this frame...
  1018. if text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
  1019. # keep track of start time/frame for later
  1020. text.frameNStart = frameN # exact frame index
  1021. text.tStart = t # local t and not account for scr refresh
  1022. text.tStartRefresh = tThisFlipGlobal # on global time
  1023. win.timeOnFlip(text, 'tStartRefresh') # time at next scr refresh
  1024. # add timestamp to datafile
  1025. thisExp.timestampOnFlip(win, 'text.started')
  1026. # update status
  1027. text.status = STARTED
  1028. text.setAutoDraw(True)
  1030. # if text is active this frame...
  1031. if text.status == STARTED:
  1032. # update params
  1033. pass
  1035. # if text is stopping this frame...
  1036. if text.status == STARTED:
  1037. # is it time to stop? (based on global clock, using actual start)
  1038. if tThisFlipGlobal > text.tStartRefresh + 60-frameTolerance:
  1039. # keep track of stop time/frame for later
  1040. text.tStop = t # not accounting for scr refresh
  1041. text.tStopRefresh = tThisFlipGlobal # on global time
  1042. text.frameNStop = frameN # exact frame index
  1043. # add timestamp to datafile
  1044. thisExp.timestampOnFlip(win, 'text.stopped')
  1045. # update status
  1046. text.status = FINISHED
  1047. text.setAutoDraw(False)
  1049. # check for quit (typically the Esc key)
  1050. if defaultKeyboard.getKeys(keyList=["escape"]):
  1051. thisExp.status = FINISHED
  1052. if thisExp.status == FINISHED or endExpNow:
  1053. endExperiment(thisExp, win=win)
  1054. return
  1055. # pause experiment here if requested
  1056. if thisExp.status == PAUSED:
  1057. pauseExperiment(
  1058. thisExp=thisExp,
  1059. win=win,
  1060. timers=[routineTimer],
  1061. playbackComponents=[sound_1]
  1062. )
  1063. # skip the frame we paused on
  1064. continue
  1066. # check if all components have finished
  1067. if not continueRoutine: # a component has requested a forced-end of Routine
  1068. present_situation.forceEnded = routineForceEnded = True
  1069. break
  1070. continueRoutine = False # will revert to True if at least one component still running
  1071. for thisComponent in present_situation.components:
  1072. if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
  1073. continueRoutine = True
  1074. break # at least one component has not yet finished
  1076. # refresh the screen
  1077. if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
  1078. win.flip()
  1080. # --- Ending Routine "present_situation" ---
  1081. for thisComponent in present_situation.components:
  1082. if hasattr(thisComponent, "setAutoDraw"):
  1083. thisComponent.setAutoDraw(False)
  1084. # store stop times for present_situation
  1085. present_situation.tStop = globalClock.getTime(format='float')
  1086. present_situation.tStopRefresh = tThisFlipGlobal
  1087. thisExp.addData('present_situation.stopped', present_situation.tStop)
  1088. # Run 'End Routine' code from code_2
  1089. outlet.push_sample(x=[4])
  1090. sound_1.pause() # ensure sound has stopped at end of Routine
  1091. # using non-slip timing so subtract the expected duration of this Routine (unless ended on request)
  1092. if present_situation.maxDurationReached:
  1093. routineTimer.addTime(-present_situation.maxDuration)
  1094. elif present_situation.forceEnded:
  1095. routineTimer.reset()
  1096. else:
  1097. routineTimer.addTime(-60.000000)
  1098. thisExp.nextEntry()
  1100. # set up handler to look after randomisation of conditions etc
  1101. trials = data.TrialHandler2(
  1102. name='trials',
  1103. nReps=5.0,
  1104. method='random',
  1105. extraInfo=expInfo,
  1106. originPath=-1,
  1107. trialList=[None],
  1108. seed=None,
  1109. )
  1110. thisExp.addLoop(trials) # add the loop to the experiment
  1111. thisTrial = trials.trialList[0] # so we can initialise stimuli with some values
  1112. # abbreviate parameter names if possible (e.g. rgb = thisTrial.rgb)
  1113. if thisTrial != None:
  1114. for paramName in thisTrial:
  1115. globals()[paramName] = thisTrial[paramName]
  1116. if thisSession is not None:
  1117. # if running in a Session with a Liaison client, send data up to now
  1118. thisSession.sendExperimentData()
  1120. for thisTrial in trials:
  1121. currentLoop = trials
  1122. thisExp.timestampOnFlip(win, 'thisRow.t', format=globalClock.format)
  1123. if thisSession is not None:
  1124. # if running in a Session with a Liaison client, send data up to now
  1125. thisSession.sendExperimentData()
  1126. # abbreviate parameter names if possible (e.g. rgb = thisTrial.rgb)
  1127. if thisTrial != None:
  1128. for paramName in thisTrial:
  1129. globals()[paramName] = thisTrial[paramName]
  1131. # --- Prepare to start Routine "it_setter" ---
  1132. # create an object to store info about Routine it_setter
  1133. it_setter = data.Routine(
  1134. name='it_setter',
  1135. components=[],
  1136. )
  1137. it_setter.status = NOT_STARTED
  1138. continueRoutine = True
  1139. # update component parameters for each repeat
  1140. # Run 'Begin Routine' code from code_3
  1141. iteration = str_lst.pop(0)
  1143. stressvar = f'stressvar{iteration}'
  1145. # store start times for it_setter
  1146. it_setter.tStartRefresh = win.getFutureFlipTime(clock=globalClock)
  1147. it_setter.tStart = globalClock.getTime(format='float')
  1148. it_setter.status = STARTED
  1149. thisExp.addData('it_setter.started', it_setter.tStart)
  1150. it_setter.maxDuration = None
  1151. # keep track of which components have finished
  1152. it_setterComponents = it_setter.components
  1153. for thisComponent in it_setter.components:
  1154. thisComponent.tStart = None
  1155. thisComponent.tStop = None
  1156. thisComponent.tStartRefresh = None
  1157. thisComponent.tStopRefresh = None
  1158. if hasattr(thisComponent, 'status'):
  1159. thisComponent.status = NOT_STARTED
  1160. # reset timers
  1161. t = 0
  1162. _timeToFirstFrame = win.getFutureFlipTime(clock="now")
  1163. frameN = -1
  1165. # --- Run Routine "it_setter" ---
  1166. # if trial has changed, end Routine now
  1167. if isinstance(trials, data.TrialHandler2) and thisTrial.thisN != trials.thisTrial.thisN:
  1168. continueRoutine = False
  1169. it_setter.forceEnded = routineForceEnded = not continueRoutine
  1170. while continueRoutine:
  1171. # get current time
  1172. t = routineTimer.getTime()
  1173. tThisFlip = win.getFutureFlipTime(clock=routineTimer)
  1174. tThisFlipGlobal = win.getFutureFlipTime(clock=None)
  1175. frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
  1176. # update/draw components on each frame
  1178. # check for quit (typically the Esc key)
  1179. if defaultKeyboard.getKeys(keyList=["escape"]):
  1180. thisExp.status = FINISHED
  1181. if thisExp.status == FINISHED or endExpNow:
  1182. endExperiment(thisExp, win=win)
  1183. return
  1184. # pause experiment here if requested
  1185. if thisExp.status == PAUSED:
  1186. pauseExperiment(
  1187. thisExp=thisExp,
  1188. win=win,
  1189. timers=[routineTimer],
  1190. playbackComponents=[]
  1191. )
  1192. # skip the frame we paused on
  1193. continue
  1195. # check if all components have finished
  1196. if not continueRoutine: # a component has requested a forced-end of Routine
  1197. it_setter.forceEnded = routineForceEnded = True
  1198. break
  1199. continueRoutine = False # will revert to True if at least one component still running
  1200. for thisComponent in it_setter.components:
  1201. if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
  1202. continueRoutine = True
  1203. break # at least one component has not yet finished
  1205. # refresh the screen
  1206. if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
  1207. win.flip()
  1209. # --- Ending Routine "it_setter" ---
  1210. for thisComponent in it_setter.components:
  1211. if hasattr(thisComponent, "setAutoDraw"):
  1212. thisComponent.setAutoDraw(False)
  1213. # store stop times for it_setter
  1214. it_setter.tStop = globalClock.getTime(format='float')
  1215. it_setter.tStopRefresh = tThisFlipGlobal
  1216. thisExp.addData('it_setter.stopped', it_setter.tStop)
  1217. # the Routine "it_setter" was not non-slip safe, so reset the non-slip timer
  1218. routineTimer.reset()
  1220. # --- Prepare to start Routine "stressor" ---
  1221. # create an object to store info about Routine stressor
  1222. stressor = data.Routine(
  1223. name='stressor',
  1224. components=[sound_2, text_2],
  1225. )
  1226. stressor.status = NOT_STARTED
  1227. continueRoutine = True
  1228. # update component parameters for each repeat
  1229. # Run 'Begin Routine' code from code_4
  1230. outlet.push_sample(x=[5])
  1231. sound_2.setSound(f'./BIN/Recordings/Session/Session{sess}/{stressvar}.wav', secs=30, hamming=True)
  1232. sound_2.setVolume(1.0, log=False)
  1233. sound_2.seek(0)
  1234. # store start times for stressor
  1235. stressor.tStartRefresh = win.getFutureFlipTime(clock=globalClock)
  1236. stressor.tStart = globalClock.getTime(format='float')
  1237. stressor.status = STARTED
  1238. thisExp.addData('stressor.started', stressor.tStart)
  1239. stressor.maxDuration = None
  1240. # keep track of which components have finished
  1241. stressorComponents = stressor.components
  1242. for thisComponent in stressor.components:
  1243. thisComponent.tStart = None
  1244. thisComponent.tStop = None
  1245. thisComponent.tStartRefresh = None
  1246. thisComponent.tStopRefresh = None
  1247. if hasattr(thisComponent, 'status'):
  1248. thisComponent.status = NOT_STARTED
  1249. # reset timers
  1250. t = 0
  1251. _timeToFirstFrame = win.getFutureFlipTime(clock="now")
  1252. frameN = -1
  1254. # --- Run Routine "stressor" ---
  1255. # if trial has changed, end Routine now
  1256. if isinstance(trials, data.TrialHandler2) and thisTrial.thisN != trials.thisTrial.thisN:
  1257. continueRoutine = False
  1258. stressor.forceEnded = routineForceEnded = not continueRoutine
  1259. while continueRoutine and routineTimer.getTime() < 30.0:
  1260. # get current time
  1261. t = routineTimer.getTime()
  1262. tThisFlip = win.getFutureFlipTime(clock=routineTimer)
  1263. tThisFlipGlobal = win.getFutureFlipTime(clock=None)
  1264. frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
  1265. # update/draw components on each frame
  1267. # *sound_2* updates
  1269. # if sound_2 is starting this frame...
  1270. if sound_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
  1271. # keep track of start time/frame for later
  1272. sound_2.frameNStart = frameN # exact frame index
  1273. sound_2.tStart = t # local t and not account for scr refresh
  1274. sound_2.tStartRefresh = tThisFlipGlobal # on global time
  1275. # add timestamp to datafile
  1276. thisExp.addData('sound_2.started', tThisFlipGlobal)
  1277. # update status
  1278. sound_2.status = STARTED
  1279. sound_2.play(when=win) # sync with win flip
  1281. # if sound_2 is stopping this frame...
  1282. if sound_2.status == STARTED:
  1283. # is it time to stop? (based on global clock, using actual start)
  1284. if tThisFlipGlobal > sound_2.tStartRefresh + 30-frameTolerance or sound_2.isFinished:
  1285. # keep track of stop time/frame for later
  1286. sound_2.tStop = t # not accounting for scr refresh
  1287. sound_2.tStopRefresh = tThisFlipGlobal # on global time
  1288. sound_2.frameNStop = frameN # exact frame index
  1289. # add timestamp to datafile
  1290. thisExp.timestampOnFlip(win, 'sound_2.stopped')
  1291. # update status
  1292. sound_2.status = FINISHED
  1293. sound_2.stop()
  1295. # *text_2* updates
  1297. # if text_2 is starting this frame...
  1298. if text_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
  1299. # keep track of start time/frame for later
  1300. text_2.frameNStart = frameN # exact frame index
  1301. text_2.tStart = t # local t and not account for scr refresh
  1302. text_2.tStartRefresh = tThisFlipGlobal # on global time
  1303. win.timeOnFlip(text_2, 'tStartRefresh') # time at next scr refresh
  1304. # add timestamp to datafile
  1305. thisExp.timestampOnFlip(win, 'text_2.started')
  1306. # update status
  1307. text_2.status = STARTED
  1308. text_2.setAutoDraw(True)
  1310. # if text_2 is active this frame...
  1311. if text_2.status == STARTED:
  1312. # update params
  1313. pass
  1315. # if text_2 is stopping this frame...
  1316. if text_2.status == STARTED:
  1317. # is it time to stop? (based on global clock, using actual start)
  1318. if tThisFlipGlobal > text_2.tStartRefresh + 30-frameTolerance:
  1319. # keep track of stop time/frame for later
  1320. text_2.tStop = t # not accounting for scr refresh
  1321. text_2.tStopRefresh = tThisFlipGlobal # on global time
  1322. text_2.frameNStop = frameN # exact frame index
  1323. # add timestamp to datafile
  1324. thisExp.timestampOnFlip(win, 'text_2.stopped')
  1325. # update status
  1326. text_2.status = FINISHED
  1327. text_2.setAutoDraw(False)
  1329. # check for quit (typically the Esc key)
  1330. if defaultKeyboard.getKeys(keyList=["escape"]):
  1331. thisExp.status = FINISHED
  1332. if thisExp.status == FINISHED or endExpNow:
  1333. endExperiment(thisExp, win=win)
  1334. return
  1335. # pause experiment here if requested
  1336. if thisExp.status == PAUSED:
  1337. pauseExperiment(
  1338. thisExp=thisExp,
  1339. win=win,
  1340. timers=[routineTimer],
  1341. playbackComponents=[sound_2]
  1342. )
  1343. # skip the frame we paused on
  1344. continue
  1346. # check if all components have finished
  1347. if not continueRoutine: # a component has requested a forced-end of Routine
  1348. stressor.forceEnded = routineForceEnded = True
  1349. break
  1350. continueRoutine = False # will revert to True if at least one component still running
  1351. for thisComponent in stressor.components:
  1352. if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
  1353. continueRoutine = True
  1354. break # at least one component has not yet finished
  1356. # refresh the screen
  1357. if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
  1358. win.flip()
  1360. # --- Ending Routine "stressor" ---
  1361. for thisComponent in stressor.components:
  1362. if hasattr(thisComponent, "setAutoDraw"):
  1363. thisComponent.setAutoDraw(False)
  1364. # store stop times for stressor
  1365. stressor.tStop = globalClock.getTime(format='float')
  1366. stressor.tStopRefresh = tThisFlipGlobal
  1367. thisExp.addData('stressor.stopped', stressor.tStop)
  1368. # Run 'End Routine' code from code_4
  1369. outlet.push_sample(x=[6])
  1370. sound_2.pause() # ensure sound has stopped at end of Routine
  1371. # using non-slip timing so subtract the expected duration of this Routine (unless ended on request)
  1372. if stressor.maxDurationReached:
  1373. routineTimer.addTime(-stressor.maxDuration)
  1374. elif stressor.forceEnded:
  1375. routineTimer.reset()
  1376. else:
  1377. routineTimer.addTime(-30.000000)
  1379. # set up handler to look after randomisation of conditions etc
  1380. trials_2 = data.TrialHandler2(
  1381. name='trials_2',
  1382. nReps=5.0,
  1383. method='random',
  1384. extraInfo=expInfo,
  1385. originPath=-1,
  1386. trialList=[None],
  1387. seed=None,
  1388. )
  1389. thisExp.addLoop(trials_2) # add the loop to the experiment
  1390. thisTrial_2 = trials_2.trialList[0] # so we can initialise stimuli with some values
  1391. # abbreviate parameter names if possible (e.g. rgb = thisTrial_2.rgb)
  1392. if thisTrial_2 != None:
  1393. for paramName in thisTrial_2:
  1394. globals()[paramName] = thisTrial_2[paramName]
  1395. if thisSession is not None:
  1396. # if running in a Session with a Liaison client, send data up to now
  1397. thisSession.sendExperimentData()
  1399. for thisTrial_2 in trials_2:
  1400. currentLoop = trials_2
  1401. thisExp.timestampOnFlip(win, 'thisRow.t', format=globalClock.format)
  1402. if thisSession is not None:
  1403. # if running in a Session with a Liaison client, send data up to now
  1404. thisSession.sendExperimentData()
  1405. # abbreviate parameter names if possible (e.g. rgb = thisTrial_2.rgb)
  1406. if thisTrial_2 != None:
  1407. for paramName in thisTrial_2:
  1408. globals()[paramName] = thisTrial_2[paramName]
  1410. # --- Prepare to start Routine "it_ctr" ---
  1411. # create an object to store info about Routine it_ctr
  1412. it_ctr = data.Routine(
  1413. name='it_ctr',
  1414. components=[],
  1415. )
  1416. it_ctr.status = NOT_STARTED
  1417. continueRoutine = True
  1418. # update component parameters for each repeat
  1419. # Run 'Begin Routine' code from code_6
  1420. iteration_ctr = ctr_lst.pop(0)
  1421. print(iteration_ctr)
  1422. controlvar = f'controlvar{iteration_ctr}'
  1423. # store start times for it_ctr
  1424. it_ctr.tStartRefresh = win.getFutureFlipTime(clock=globalClock)
  1425. it_ctr.tStart = globalClock.getTime(format='float')
  1426. it_ctr.status = STARTED
  1427. thisExp.addData('it_ctr.started', it_ctr.tStart)
  1428. it_ctr.maxDuration = None
  1429. # keep track of which components have finished
  1430. it_ctrComponents = it_ctr.components
  1431. for thisComponent in it_ctr.components:
  1432. thisComponent.tStart = None
  1433. thisComponent.tStop = None
  1434. thisComponent.tStartRefresh = None
  1435. thisComponent.tStopRefresh = None
  1436. if hasattr(thisComponent, 'status'):
  1437. thisComponent.status = NOT_STARTED
  1438. # reset timers
  1439. t = 0
  1440. _timeToFirstFrame = win.getFutureFlipTime(clock="now")
  1441. frameN = -1
  1443. # --- Run Routine "it_ctr" ---
  1444. # if trial has changed, end Routine now
  1445. if isinstance(trials_2, data.TrialHandler2) and thisTrial_2.thisN != trials_2.thisTrial.thisN:
  1446. continueRoutine = False
  1447. it_ctr.forceEnded = routineForceEnded = not continueRoutine
  1448. while continueRoutine:
  1449. # get current time
  1450. t = routineTimer.getTime()
  1451. tThisFlip = win.getFutureFlipTime(clock=routineTimer)
  1452. tThisFlipGlobal = win.getFutureFlipTime(clock=None)
  1453. frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
  1454. # update/draw components on each frame
  1456. # check for quit (typically the Esc key)
  1457. if defaultKeyboard.getKeys(keyList=["escape"]):
  1458. thisExp.status = FINISHED
  1459. if thisExp.status == FINISHED or endExpNow:
  1460. endExperiment(thisExp, win=win)
  1461. return
  1462. # pause experiment here if requested
  1463. if thisExp.status == PAUSED:
  1464. pauseExperiment(
  1465. thisExp=thisExp,
  1466. win=win,
  1467. timers=[routineTimer],
  1468. playbackComponents=[]
  1469. )
  1470. # skip the frame we paused on
  1471. continue
  1473. # check if all components have finished
  1474. if not continueRoutine: # a component has requested a forced-end of Routine
  1475. it_ctr.forceEnded = routineForceEnded = True
  1476. break
  1477. continueRoutine = False # will revert to True if at least one component still running
  1478. for thisComponent in it_ctr.components:
  1479. if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
  1480. continueRoutine = True
  1481. break # at least one component has not yet finished
  1483. # refresh the screen
  1484. if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
  1485. win.flip()
  1487. # --- Ending Routine "it_ctr" ---
  1488. for thisComponent in it_ctr.components:
  1489. if hasattr(thisComponent, "setAutoDraw"):
  1490. thisComponent.setAutoDraw(False)
  1491. # store stop times for it_ctr
  1492. it_ctr.tStop = globalClock.getTime(format='float')
  1493. it_ctr.tStopRefresh = tThisFlipGlobal
  1494. thisExp.addData('it_ctr.stopped', it_ctr.tStop)
  1495. # the Routine "it_ctr" was not non-slip safe, so reset the non-slip timer
  1496. routineTimer.reset()
  1498. # --- Prepare to start Routine "control" ---
  1499. # create an object to store info about Routine control
  1500. control = data.Routine(
  1501. name='control',
  1502. components=[sound_3, text_3],
  1503. )
  1504. control.status = NOT_STARTED
  1505. continueRoutine = True
  1506. # update component parameters for each repeat
  1507. # Run 'Begin Routine' code from code_5
  1508. outlet.push_sample(x=[7])
  1509. sound_3.setSound(f'./BIN/Recordings/Session/Session{sess}/{controlvar}.wav', secs=30, hamming=True)
  1510. sound_3.setVolume(1.0, log=False)
  1511. sound_3.seek(0)
  1512. # store start times for control
  1513. control.tStartRefresh = win.getFutureFlipTime(clock=globalClock)
  1514. control.tStart = globalClock.getTime(format='float')
  1515. control.status = STARTED
  1516. thisExp.addData('control.started', control.tStart)
  1517. control.maxDuration = None
  1518. # keep track of which components have finished
  1519. controlComponents = control.components
  1520. for thisComponent in control.components:
  1521. thisComponent.tStart = None
  1522. thisComponent.tStop = None
  1523. thisComponent.tStartRefresh = None
  1524. thisComponent.tStopRefresh = None
  1525. if hasattr(thisComponent, 'status'):
  1526. thisComponent.status = NOT_STARTED
  1527. # reset timers
  1528. t = 0
  1529. _timeToFirstFrame = win.getFutureFlipTime(clock="now")
  1530. frameN = -1
  1532. # --- Run Routine "control" ---
  1533. # if trial has changed, end Routine now
  1534. if isinstance(trials_2, data.TrialHandler2) and thisTrial_2.thisN != trials_2.thisTrial.thisN:
  1535. continueRoutine = False
  1536. control.forceEnded = routineForceEnded = not continueRoutine
  1537. while continueRoutine and routineTimer.getTime() < 30.0:
  1538. # get current time
  1539. t = routineTimer.getTime()
  1540. tThisFlip = win.getFutureFlipTime(clock=routineTimer)
  1541. tThisFlipGlobal = win.getFutureFlipTime(clock=None)
  1542. frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
  1543. # update/draw components on each frame
  1545. # *sound_3* updates
  1547. # if sound_3 is starting this frame...
  1548. if sound_3.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
  1549. # keep track of start time/frame for later
  1550. sound_3.frameNStart = frameN # exact frame index
  1551. sound_3.tStart = t # local t and not account for scr refresh
  1552. sound_3.tStartRefresh = tThisFlipGlobal # on global time
  1553. # add timestamp to datafile
  1554. thisExp.addData('sound_3.started', tThisFlipGlobal)
  1555. # update status
  1556. sound_3.status = STARTED
  1557. sound_3.play(when=win) # sync with win flip
  1559. # if sound_3 is stopping this frame...
  1560. if sound_3.status == STARTED:
  1561. # is it time to stop? (based on global clock, using actual start)
  1562. if tThisFlipGlobal > sound_3.tStartRefresh + 30-frameTolerance or sound_3.isFinished:
  1563. # keep track of stop time/frame for later
  1564. sound_3.tStop = t # not accounting for scr refresh
  1565. sound_3.tStopRefresh = tThisFlipGlobal # on global time
  1566. sound_3.frameNStop = frameN # exact frame index
  1567. # add timestamp to datafile
  1568. thisExp.timestampOnFlip(win, 'sound_3.stopped')
  1569. # update status
  1570. sound_3.status = FINISHED
  1571. sound_3.stop()
  1573. # *text_3* updates
  1575. # if text_3 is starting this frame...
  1576. if text_3.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
  1577. # keep track of start time/frame for later
  1578. text_3.frameNStart = frameN # exact frame index
  1579. text_3.tStart = t # local t and not account for scr refresh
  1580. text_3.tStartRefresh = tThisFlipGlobal # on global time
  1581. win.timeOnFlip(text_3, 'tStartRefresh') # time at next scr refresh
  1582. # add timestamp to datafile
  1583. thisExp.timestampOnFlip(win, 'text_3.started')
  1584. # update status
  1585. text_3.status = STARTED
  1586. text_3.setAutoDraw(True)
  1588. # if text_3 is active this frame...
  1589. if text_3.status == STARTED:
  1590. # update params
  1591. pass
  1593. # if text_3 is stopping this frame...
  1594. if text_3.status == STARTED:
  1595. # is it time to stop? (based on global clock, using actual start)
  1596. if tThisFlipGlobal > text_3.tStartRefresh + 30-frameTolerance:
  1597. # keep track of stop time/frame for later
  1598. text_3.tStop = t # not accounting for scr refresh
  1599. text_3.tStopRefresh = tThisFlipGlobal # on global time
  1600. text_3.frameNStop = frameN # exact frame index
  1601. # add timestamp to datafile
  1602. thisExp.timestampOnFlip(win, 'text_3.stopped')
  1603. # update status
  1604. text_3.status = FINISHED
  1605. text_3.setAutoDraw(False)
  1607. # check for quit (typically the Esc key)
  1608. if defaultKeyboard.getKeys(keyList=["escape"]):
  1609. thisExp.status = FINISHED
  1610. if thisExp.status == FINISHED or endExpNow:
  1611. endExperiment(thisExp, win=win)
  1612. return
  1613. # pause experiment here if requested
  1614. if thisExp.status == PAUSED:
  1615. pauseExperiment(
  1616. thisExp=thisExp,
  1617. win=win,
  1618. timers=[routineTimer],
  1619. playbackComponents=[sound_3]
  1620. )
  1621. # skip the frame we paused on
  1622. continue
  1624. # check if all components have finished
  1625. if not continueRoutine: # a component has requested a forced-end of Routine
  1626. control.forceEnded = routineForceEnded = True
  1627. break
  1628. continueRoutine = False # will revert to True if at least one component still running
  1629. for thisComponent in control.components:
  1630. if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
  1631. continueRoutine = True
  1632. break # at least one component has not yet finished
  1634. # refresh the screen
  1635. if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
  1636. win.flip()
  1638. # --- Ending Routine "control" ---
  1639. for thisComponent in control.components:
  1640. if hasattr(thisComponent, "setAutoDraw"):
  1641. thisComponent.setAutoDraw(False)
  1642. # store stop times for control
  1643. control.tStop = globalClock.getTime(format='float')
  1644. control.tStopRefresh = tThisFlipGlobal
  1645. thisExp.addData('control.stopped', control.tStop)
  1646. # Run 'End Routine' code from code_5
  1647. outlet.push_sample(x=[8])
  1648. sound_3.pause() # ensure sound has stopped at end of Routine
  1649. # using non-slip timing so subtract the expected duration of this Routine (unless ended on request)
  1650. if control.maxDurationReached:
  1651. routineTimer.addTime(-control.maxDuration)
  1652. elif control.forceEnded:
  1653. routineTimer.reset()
  1654. else:
  1655. routineTimer.addTime(-30.000000)
  1656. thisExp.nextEntry()
  1658. # completed 5.0 repeats of 'trials_2'
  1660. if thisSession is not None:
  1661. # if running in a Session with a Liaison client, send data up to now
  1662. thisSession.sendExperimentData()
  1663. thisExp.nextEntry()
  1665. # completed 5.0 repeats of 'trials'
  1667. if thisSession is not None:
  1668. # if running in a Session with a Liaison client, send data up to now
  1669. thisSession.sendExperimentData()
  1671. # --- Prepare to start Routine "ender" ---
  1672. # create an object to store info about Routine ender
  1673. ender = data.Routine(
  1674. name='ender',
  1675. components=[text_7],
  1676. )
  1677. ender.status = NOT_STARTED
  1678. continueRoutine = True
  1679. # update component parameters for each repeat
  1680. # store start times for ender
  1681. ender.tStartRefresh = win.getFutureFlipTime(clock=globalClock)
  1682. ender.tStart = globalClock.getTime(format='float')
  1683. ender.status = STARTED
  1684. thisExp.addData('ender.started', ender.tStart)
  1685. ender.maxDuration = None
  1686. # keep track of which components have finished
  1687. enderComponents = ender.components
  1688. for thisComponent in ender.components:
  1689. thisComponent.tStart = None
  1690. thisComponent.tStop = None
  1691. thisComponent.tStartRefresh = None
  1692. thisComponent.tStopRefresh = None
  1693. if hasattr(thisComponent, 'status'):
  1694. thisComponent.status = NOT_STARTED
  1695. # reset timers
  1696. t = 0
  1697. _timeToFirstFrame = win.getFutureFlipTime(clock="now")
  1698. frameN = -1
  1700. # --- Run Routine "ender" ---
  1701. ender.forceEnded = routineForceEnded = not continueRoutine
  1702. while continueRoutine and routineTimer.getTime() < 5.0:
  1703. # get current time
  1704. t = routineTimer.getTime()
  1705. tThisFlip = win.getFutureFlipTime(clock=routineTimer)
  1706. tThisFlipGlobal = win.getFutureFlipTime(clock=None)
  1707. frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
  1708. # update/draw components on each frame
  1710. # *text_7* updates
  1712. # if text_7 is starting this frame...
  1713. if text_7.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
  1714. # keep track of start time/frame for later
  1715. text_7.frameNStart = frameN # exact frame index
  1716. text_7.tStart = t # local t and not account for scr refresh
  1717. text_7.tStartRefresh = tThisFlipGlobal # on global time
  1718. win.timeOnFlip(text_7, 'tStartRefresh') # time at next scr refresh
  1719. # add timestamp to datafile
  1720. thisExp.timestampOnFlip(win, 'text_7.started')
  1721. # update status
  1722. text_7.status = STARTED
  1723. text_7.setAutoDraw(True)
  1725. # if text_7 is active this frame...
  1726. if text_7.status == STARTED:
  1727. # update params
  1728. pass
  1730. # if text_7 is stopping this frame...
  1731. if text_7.status == STARTED:
  1732. # is it time to stop? (based on global clock, using actual start)
  1733. if tThisFlipGlobal > text_7.tStartRefresh + 5-frameTolerance:
  1734. # keep track of stop time/frame for later
  1735. text_7.tStop = t # not accounting for scr refresh
  1736. text_7.tStopRefresh = tThisFlipGlobal # on global time
  1737. text_7.frameNStop = frameN # exact frame index
  1738. # add timestamp to datafile
  1739. thisExp.timestampOnFlip(win, 'text_7.stopped')
  1740. # update status
  1741. text_7.status = FINISHED
  1742. text_7.setAutoDraw(False)
  1744. # check for quit (typically the Esc key)
  1745. if defaultKeyboard.getKeys(keyList=["escape"]):
  1746. thisExp.status = FINISHED
  1747. if thisExp.status == FINISHED or endExpNow:
  1748. endExperiment(thisExp, win=win)
  1749. return
  1750. # pause experiment here if requested
  1751. if thisExp.status == PAUSED:
  1752. pauseExperiment(
  1753. thisExp=thisExp,
  1754. win=win,
  1755. timers=[routineTimer],
  1756. playbackComponents=[]
  1757. )
  1758. # skip the frame we paused on
  1759. continue
  1761. # check if all components have finished
  1762. if not continueRoutine: # a component has requested a forced-end of Routine
  1763. ender.forceEnded = routineForceEnded = True
  1764. break
  1765. continueRoutine = False # will revert to True if at least one component still running
  1766. for thisComponent in ender.components:
  1767. if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
  1768. continueRoutine = True
  1769. break # at least one component has not yet finished
  1771. # refresh the screen
  1772. if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
  1773. win.flip()
  1775. # --- Ending Routine "ender" ---
  1776. for thisComponent in ender.components:
  1777. if hasattr(thisComponent, "setAutoDraw"):
  1778. thisComponent.setAutoDraw(False)
  1779. # store stop times for ender
  1780. ender.tStop = globalClock.getTime(format='float')
  1781. ender.tStopRefresh = tThisFlipGlobal
  1782. thisExp.addData('ender.stopped', ender.tStop)
  1783. # Run 'End Routine' code from code_8
  1784. outlet.push_sample(x=[99])
  1785. # using non-slip timing so subtract the expected duration of this Routine (unless ended on request)
  1786. if ender.maxDurationReached:
  1787. routineTimer.addTime(-ender.maxDuration)
  1788. elif ender.forceEnded:
  1789. routineTimer.reset()
  1790. else:
  1791. routineTimer.addTime(-5.000000)
  1792. thisExp.nextEntry()
  1794. # mark experiment as finished
  1795. endExperiment(thisExp, win=win)
  1798. def saveData(thisExp):
  1799. """
  1800. Save data from this experiment
  1802. Parameters
  1803. ==========
  1804. thisExp : psychopy.data.ExperimentHandler
  1805. Handler object for this experiment, contains the data to save and information about
  1806. where to save it to.
  1807. """
  1808. filename = thisExp.dataFileName
  1809. # these shouldn't be strictly necessary (should auto-save)
  1810. thisExp.saveAsWideText(filename + '.csv', delim='auto')
  1811. thisExp.saveAsPickle(filename)
  1814. def endExperiment(thisExp, win=None):
  1815. """
  1816. End this experiment, performing final shut down operations.
  1818. This function does NOT close the window or end the Python process - use `quit` for this.
  1820. Parameters
  1821. ==========
  1822. thisExp : psychopy.data.ExperimentHandler
  1823. Handler object for this experiment, contains the data to save and information about
  1824. where to save it to.
  1825. win : psychopy.visual.Window
  1826. Window for this experiment.
  1827. """
  1828. if win is not None:
  1829. # remove autodraw from all current components
  1830. win.clearAutoDraw()
  1831. # Flip one final time so any remaining win.callOnFlip()
  1832. # and win.timeOnFlip() tasks get executed
  1833. win.flip()
  1834. # return console logger level to WARNING
  1835. logging.console.setLevel(logging.WARNING)
  1836. # mark experiment handler as finished
  1837. thisExp.status = FINISHED
  1838. logging.flush()
  1841. def quit(thisExp, win=None, thisSession=None):
  1842. """
  1843. Fully quit, closing the window and ending the Python process.
  1845. Parameters
  1846. ==========
  1847. win : psychopy.visual.Window
  1848. Window to close.
  1849. thisSession : psychopy.session.Session or None
  1850. Handle of the Session object this experiment is being run from, if any.
  1851. """
  1852. thisExp.abort() # or data files will save again on exit
  1853. # make sure everything is closed down
  1854. if win is not None:
  1855. # Flip one final time so any remaining win.callOnFlip()
  1856. # and win.timeOnFlip() tasks get executed before quitting
  1857. win.flip()
  1858. win.close()
  1859. logging.flush()
  1860. if thisSession is not None:
  1861. thisSession.stop()
  1862. # terminate Python process
  1863. core.quit()
  1866. # if running this experiment as a script...
  1867. if __name__ == '__main__':
  1868. # call all functions in order
  1869. expInfo = showExpInfoDlg(expInfo=expInfo)
  1870. thisExp = setupData(expInfo=expInfo)
  1871. logFile = setupLogging(filename=thisExp.dataFileName)
  1872. win = setupWindow(expInfo=expInfo)
  1873. setupDevices(expInfo=expInfo, thisExp=thisExp, win=win)
  1874. run(
  1875. expInfo=expInfo,
  1876. thisExp=thisExp,
  1877. win=win,
  1878. globalClock='float'
  1879. )
  1880. saveData(thisExp=thisExp)
  1881. quit(thisExp=thisExp, win=win)

Model of training_lastrun.py at commit 0bf72a3, no license · at the source

Overview

Authors: Nery Borges1, Pedro Rodrigues Ribeiro2,3,4, Sofia Serra1, Lurdes Veríssimo3,4, Pedro Dias4,5, Nádia Moura6, Inês Silva4, Isaac Raimundo7, Patrícia Oliveira-Silva2,3,4
ORCID iDs: Lurdes Veríssimo, Pedro Dias, Patrícia Oliveira-Silva
  1. University of Aveiro, Institute of Ethnomusicology – Centre for Studies in Music and Dance (INET-md), Department of Communication and Arts, Aveiro, Portugal
  2. Universidade Católica Portuguesa, Human Neurobehavioral Laboratory (HNL), Porto, Portugal
  3. Universidade Católica Portuguesa, Faculty of Education and Psychology (FEP), Porto, Portugal
  4. Universidade Católica Portuguesa, Research Centre for Human Development (CEDH), Porto, Portugal
  5. University of the Azores, Department of Psychology, Ponta Delgada, Portugal
  6. University of Coimbra, CEIS20 – Centre for Interdisciplinary Studies, Faculty of Arts and Humanities, Coimbra, Portugal
  7. NOVA University of Lisbon, INET-md, Lisbon, Portugal
Institutions: Instituto de Etnomusicologia - Centro de Estudos em Música e Dança; University of Aveiro (Portugal); Universidade Católica Portuguesa (Portugal); Universidade dos Açores (Portugal); Centro de Estudos Interdisciplinares do Século XX (Portugal); University of Coimbra (Portugal); Universidade Nova de Lisboa (Portugal)
Journal: Frontiers in psychology, volume 17, article 1746761
Dates: received 15 November 2025; accepted 10 April 2026; published online 29 April 2026
Type: Methods article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fpsyg.2026.1746761 · PMID 42137087 · PMCID PMC13170606 · OpenAlex W7159650817
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: fNIRS (modality), human (organism), other condition (population), developmental (subfield)
Methods: Spectral & time-frequency, Connectivity, Preprocessing, fMRI & imaging
Keywords: adolescents, gradual exposure, music performance anxiety, neurofeedback-fNIRS, neurophysiological self-regulation
Topic: Diverse Music Education Insights (Music, Arts and Humanities), according to OpenAlex
Citations: cited by 1 paper (Europe PMC); 115 references in the paper

Abstract

Introduction: Music Performance Anxiety (MPA) is a prevalent phenomenon among young musicians, affecting both well-being and artistic performance. Despite its early onset and impact, effective interventions supporting the development of self-regulation of MPA in adolescents remain limited, particularly in relation to neurofeedback-based approaches. In response, this study investigates the feasibility of a Neurofeedback–Functional Near-Infrared Spectroscopy (NFDK-fNIRS) training protocol designed to support this process within a proof-of-concept research framework.

Methods: The protocol alternated MPA induction and regulation within audio-guided sessions conducted in school settings to ensure ecological validity and to integrate top-down control with gradual exposure to performance contexts. The conceptual development and operationalization of the protocol resulted in a theoretical–methodological framework combining gradual exposure, guided imagery, and neurophysiological self-regulation training. This protocol was implemented through standardized auditory scripts and systematic procedures to ensure replicability and experimental coherence. The proof-of-concept implementation was conducted with three female adolescent participants (aged 12–13) across four individual sessions designed to progressively develop physiological self-regulation in response to MPA.

Results: The procedure demonstrated technical feasibility, hemodynamic signal stability, and participants’ gradual adaptation to the training. fNIRS data revealed increased modulation of the dorsolateral prefrontal cortex, consistent with top-down self-regulatory learning mechanisms. Researchers’ reflective journals emphasized practical aspects such as equipment calibration, session duration, and participant engagement.

Discussion: Altogether, the findings indicate that NFDK-fNIRS represents a technically feasible and ecologically applicable approach for training self-regulation of MPA in adolescents, providing a solid foundation for future studies involving larger samples and controlled validation of the protocol.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above.

pedrorribeiro/MUSA-Neurofeedback-training

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 0bf72a3c72014b24d45bba7320965e8a25242660, 13 November 2025
Languages: Python (1)
Size: 520 files, 1 script
Software Heritage: not archived
Found in: the text, “System integration”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (1 file), PsychoPy (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
1 file
At the source: github.com/pedrorribeiro/MUSA-Neurofeedback-training

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;
  • 1 script, 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.

Data availability statement

The raw data supporting the conclusions of this article will be made available by the authors, for research purposes, upon request.

Reproduced under the paper's license (CC BY), from the paper cited above.

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, 30 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 9 authors, 5 keywords, 106 references.

Cite

This paper

Borges, N., Ribeiro, P. R., Serra, S., Veríssimo, L., Dias, P., Moura, N., Silva, I., Raimundo, I., & Oliveira-Silva, P. (2026). &lt;i&gt;From concept to proof:&lt;/i&gt; developing a neurofeedback-fNIRS protocol to train self-regulation for music performance anxiety in adolescent musicians. Frontiers in psychology, 17, 1746761. https://doi.org/10.3389/fpsyg.2026.1746761

BibTeX

@article{borges2026lt,
author = {Borges, Nery and Ribeiro, Pedro Rodrigues and Serra, Sofia and Veríssimo, Lurdes and Dias, Pedro and Moura, Nádia and Silva, Inês and Raimundo, Isaac and Oliveira-Silva, Patrícia},
title = {{\&lt;i\&gt;From concept to proof:\&lt;/i\&gt; developing a neurofeedback-fNIRS protocol to train self-regulation for music performance anxiety in adolescent musicians}},
journal = {Frontiers in psychology},
year = {2026},
month = apr,
volume = {17},
pages = {1746761},
publisher = {Frontiers Media SA},
issn = {1664-1078},
doi = {10.3389/fpsyg.2026.1746761},
url = {https://doi.org/10.3389/fpsyg.2026.1746761},
pmid = {42137087},
pmcid = {PMC13170606}
}

RIS

TY - JOUR
AU - Borges, Nery
AU - Ribeiro, Pedro Rodrigues
AU - Serra, Sofia
AU - Veríssimo, Lurdes
AU - Dias, Pedro
AU - Moura, Nádia
AU - Silva, Inês
AU - Raimundo, Isaac
AU - Oliveira-Silva, Patrícia
TI - &lt;i&gt;From concept to proof:&lt;/i&gt; developing a neurofeedback-fNIRS protocol to train self-regulation for music performance anxiety in adolescent musicians
T2 - Frontiers in psychology
J2 - Front Psychol
PY - 2026
DA - 2026/04/29
VL - 17
SP - 1746761
SN - 1664-1078
PB - Frontiers Media SA
DO - 10.3389/fpsyg.2026.1746761
UR - https://doi.org/10.3389/fpsyg.2026.1746761
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fpsyg.2026.1746761",
"type": "article-journal",
"title": "&lt;i&gt;From concept to proof:&lt;/i&gt; developing a neurofeedback-fNIRS protocol to train self-regulation for music performance anxiety in adolescent musicians",
"container-title": "Frontiers in psychology",
"author": [
{
"family": "Borges",
"given": "Nery"
},
{
"family": "Ribeiro",
"given": "Pedro Rodrigues"
},
{
"family": "Serra",
"given": "Sofia"
},
{
"family": "Veríssimo",
"given": "Lurdes"
},
{
"family": "Dias",
"given": "Pedro"
},
{
"family": "Moura",
"given": "Nádia"
},
{
"family": "Silva",
"given": "Inês"
},
{
"family": "Raimundo",
"given": "Isaac"
},
{
"family": "Oliveira-Silva",
"given": "Patrícia"
}
],
"container-title-short": "Front Psychol",
"volume": "17",
"page": "1746761",
"DOI": "10.3389/fpsyg.2026.1746761",
"PMID": "42137087",
"PMCID": "PMC13170606",
"ISSN": "1664-1078",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fpsyg.2026.1746761",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
29
]
]
}
}

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.1117/1.nph.13.3.035009
Single-subject detection of speech network activation using functional near-infrared spectroscopy.
Journal: Neurophotonics
In common: fNIRS, 3 references
[2] doi:10.1371/journal.pbio.3003666 [code]
Emotion regulation success involves systematic gradient-based reconfigurations of large-scale activation patterns in the human brain.
Journal: PLoS biology
In common: NumPy, 3 references
[3] doi:10.1038/s41598-026-49157-z
Supportive neural mechanisms underlying successful emotion regulation for reappraisal success.
Journal: Scientific reports
In common: 3 references
[4] doi:10.3389/fnhum.2026.1806951 [code]
The theta paradox-delayed reduction of frontal midline theta following downregulation neurofeedback training.
Journal: Frontiers in human neuroscience
In common: 3 references
[5] doi:10.1016/j.dcn.2026.101737 [code]
Being praised and criticized in adolescents and adults: Age-related changes in neural responses to social evaluations.
Journal: Developmental cognitive neuroscience
In common: NumPy, developmental, 2 references
[6] doi:10.1007/s00221-026-07354-2 [code]
Transcutaneous auricular vagus nerve stimulation during a 3-back task: a high-density functional near-infrared spectroscopy study.
Journal: Experimental brain research
In common: fNIRS, 2 references
[7] doi:10.1002/brb3.71581 [code]
Blunted Reward Responsiveness During Social Feedback: Associations with Peer Victimization and Anhedonia in Socially Anxious Adolescents.
Journal: Brain and behavior
In common: PsychoPy, NumPy, developmental, other condition
[8] doi:10.1017/s0033291726104309 [code]
A visual cortex origin of trauma memory intrusions: integrated evidence from TMS and fMRI.
Journal: Psychological medicine
In common: NumPy, other condition, 2 references
[9] doi:10.3389/fpsyt.2026.1757213 [code]
A novel music-based real-time fMRI neurofeedback interface modulates interhemispheric connectivity and enhances mood.
Journal: Frontiers in psychiatry
In common: NumPy, 2 references
[10] doi:10.1038/s41467-026-74331-2 [code]
Trial-by-trial fMRI-neurofeedback dissociates fusiform and occipital contributions to face detection and recognition.
Journal: Nature communications
In common: NumPy, 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.