May I paste the complete code here? I'm only using the practice trial in this experiment. Thanks
.
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
SINGLE N-BACK TASK ADAPTIVE (1 KEY VERSION)
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
SCRIPT INFO
Author: Katja Borchert, Ph.D. (
katjab@millisecond.com) for Millisecond
Software LLCDate: October, 2011
last updated: 09-26-2014 by K. Borchert for Millisecond Software
Copyright © 09-26-2014 Millisecond Software
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
BACKGROUND INFO
Acknowledgements:
This script implements an adaptive version of the non-adaptive single n-back task version of the N-Back procedure as is described in the
following publication (Experiment1):
Jaeggi, Susanne M.; Studer-Luethi, Barbara; Buschkuehl, Martin; Su, Yi-Fen; Jonides, John; Perrig, Walter J. (2010). The
relationship between n-back performance and matrix reasoning - implications for training and transfer. Intelligence, 38, 625â635.
Millisecond Software thanks Dr. Susanne Jaeggi for kindly providing original instruction materials, stimuli, as well as assistance!
This Inquisit script provides trials and instructions for adaptive single n-back tasks with random shapes (N = 1, N = 2, N = 3, N = 4),
inspired by the non-adaptive version with the same stimuli used and kindly provided by Jaeggi et al (2010
)- used in Experiment 1, as well
as the general procedure described for adaptive n-back testing in Experiment 2.
In this script, participants start out on level N = 1 and can move up to level N = 4. However, instructions
of how to add further levels
of N are also provided.
Single n-back tasks:
In 1-key single n-back tasks, participants are shown a sequence of stimuli (here: a sequence of yellow shapes on a black background) and
asked to indicate whether the
currently presented stimulus fulfills the following criteria:
for N=1 trials:
-
is the shape the same as the one that preceded it? If so (it's a target), and press "A". If not, don't respond.
for N=2 trials:
-
is the shape the same as the one presented two trials before? If so (it's a target), and press "A". If not, don't respond.
for N=3 trials:
-
is the shape the same as the one presented three trials before? If so (it's a target), and press "A". If not, don't respond.
for N=4 trials:
-
is the shape the same as the one presented four trials before? If so (it's a target), and press "A". If not, don't respond.
Specific Procedural Information
(1) Single n-back EXPERIMENT (adaptive) information:
- After instructions, participants receive 10 trials of practice for levels N = 1 to N= 3, with possibility for more
- After practice, participants start on level N = 1, and depending on performance move up or stay on that level
- Adaptive testing is over after 15 blocks
(2) Single n-back BLOCK information:
- Each single n-task block consists of 20+ trials using 8 different shapes.
=> + trials are the N trials that cannot display target
shapes yet (=start trials). Their numbers vary depending on N. The data collected
during these start trials are NOT included in performance counts for Correct Rejections/False Alarms.
=> Of the actual 20 experimental trials, 6 present a target and 14 do not.
- The computer selects randomly
a)
whether it is a target trial or not and
b)
what shape to show if it is not a target trial
-
adaptive blocks:
(a)
based on performance of participants either a higher, lower or the same level N is chosen for the following block (after 15 blocks the session is over)
(b)
adaptive testing starts at level N = 1 in this script
(c)
participants receive performance feedback (% correct) after each block
(3) Single n-back TRIAL information:
- Each trial presents the shape for 500ms and waits another 2500ms before presenting the next shape in the sequence.
- Participants have the entire 3000ms to respond by pressing "A" if they detect a target.
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
INFORMATION FOR CODE-CHANGES (e.g. ADDITIONAL/DIFFERENT LEVELS OF N)
Instructions for changing code for additional
Ns are provided with this script. Please check the following sections for the relevant info:
1. Custom Values
2. Instructions: (a) Instruction Slides (b) Instruction Blocks
3. Trials
4. Blocks: (a) Practice (b) Experimental
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
DEFAULTS
requires Inquisit 4.0.0.0
<
defaults>
/
minimumversion = "4.0.0.0"
/
screencolor = black
</
defaults>
/
canvasaspectratio = (4,3)
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
CUSTOM VALUES
*********************
editable parameters (with default values)
*********************
/
StartN = 1the starting N
!Note: if the starting N changes other changes need to be made,
/
LastN = 4the last N run
/
LastPracticeN = 3last N tested in Practice (default is 3)
/
NumberTestBlocks = 15Number of test blocks run (default is 15)
/
debugmode = 0debugmode = 1:
targetalerts are shown on screen,
debugmode = 0, no
targetalerts are shown (default)
<
values>
/
StartN = 1
/
LastN = 4
/
LastPracticeN = 3
/
NumberTestBlocks = 15
/
debugmode = 0
</
values>
*********************
updated at runtime
*********************
minus1
:contains the
stimulusitemnumber of the stimulus in the trial preceding the current one
minus2
:contains the
stimulusitemnumber of the stimulus shown 2 trials before the current one
minus3
:contains the
stimulusitemnumber of the stimulus shown 3 trials before the current one
minus4
:contains the
stimulusitemnumber of the stimulus shown 4 trials before the current one
stim:contains the current
stimulusitem stimnumber:contains the current
stimulusitemnumberN
:the lag between a target and the stimulus it repeats
currenttarget:contains the
stimulusnumber of the current target
(
a target in N = 0 trials is a stimulus with the same stimulus number as stored in target0)
Hits
:codes the number of correctly
identifiying a target
FalseA:codes the number of times a participant identifies a non-target as a target
Misses
:codes the number of times a participant misses to identify a target
CorrReject:codes the number of times a participant correctly identifies a non-target (and does nothing)
values.TotalHits:the number of total hits across all experimental blocks
values.TotalFA
:the number of total false alarms across all experimental blocks
values.TotalBlocks:the total number of experimental blocks run
values.DV
:dependent variable (DV) in Jaeggi et al (2010): the proportion of (
TotalHits - TotalFA
)/number of total blocks
starttrialcounter:keeps track of how many start trials have been run
repetitioncounter:keeps track of how many times an experimental block has been run
<
values >
/
completed = 0
/minus1 = 0
/minus2 = 0
/minus3 = 0
/minus4 = 0
/N = 0
/
currenttarget = 0
/Hits = 0
/
FalseA = 0
/Misses = 0
/
CorrReject = 0
/
TotalHits = 0
/
TotalFA = 0
/DV = 0
/
TotalBlocks = 0
/
starttrialcounter = 0
/
repetitioncounter = 0
</
values>
**************************ADDITIONAL N-LEVELS*************************************
* if additional N-levels are needed, create and add further "
minusN" values and set them to 0,
Example: N = 5
/minus5 = 0
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
DATA COLLECTION
this implementation suggests to collect the following information:
date:Date of Experiment
time:Time of Day
subject:Subjectnumbervalues.N
:the type of N-back trial
blockcode:the name of the current block
values.TotalBlocks:the total number of experimental blocks run
trialcode:the name of the current trial
stimulusitem:the file of the stimulus shown during a trial
stimulusnumber:the item number of the stimulus shown during a trial
values.currenttarget:the item number of the current target
response:the response of the participant
correct:the correctness of the response
latency:how fast a participant responded within the 3000ms timeframe, if at all
values.Hits
:the number of Hits
values.FalseA:the number of False Alarms
values. Misses
:the number of Misses
values.CorrReject
:the number of Correct Rejections
values.TotalHits:the number of total hits across all experimental blocks
values.TotalFA
:the number of total false alarms across all experimental blocks
values.DV
:the proportion of (
TotalHits - TotalFA
)/number of experimental blocks
**********************
raw data
**********************
<
data>
/
file = "SingleTaskAdaptiveNBack_rawdata
.iqdat"
/
columns = [date, time, subject, values
.N,
blockcode, values
.TotalBlocks,
trialcode,
trialnum,
stimulusitem,
stimulusnumber, values
.currenttarget, response,
correct, latency
values.Hits, values.FalseA, values.Misses, values.CorrReject, values.TotalHits, values.TotalFA, values.DV]
/
separatefiles = true
</
data>
**********************
summary data
**********************
script.startdate:date script was run
script.starttime:time script was started
script.subjectid:subject id number
script.groupid:group id number
script.elapsedtime:time it took to run script (in ms)
/
completed:0 = script was not completed (
script was prematurely aborted); 1 = script was completed (all conditions run)
values.TotalHits:the sum of total hits across all experimental blocks
values.TotalFA
:the number of total false alarms across all experimental blocks
values.DV
:the proportion of (
TotalHits - TotalFA
)/number of experimental blocks
<
summarydata >
/
file = "SingleTaskAdaptiveNBack_summary
.iqdat"
/
columns = [script
.startdate, script
.starttime, script
.subjectid, script
.groupid, script
.elapsedtime, values.completed,
values.N, values.TotalHits, values.TotalFA, values.DV]
</
summarydata>
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
INSTRUCTIONS
*******CODE CHANGES:
If you would like to run different levels of N in practice/experimental trials, change/add the necessary instruction slides
as well as pay attention to the changes necessary under "Instruction Blocks"
***********INSTRUCTION SLIDES*****************************
<
item Nback_startinstructions>
/1 = "SingleNbackInstructions_start.gif"
/2 = "SingleNbackInstructions_N1.gif"
/3 = "SingleNbackInstructions_N2.gif"
/4 = "SingleNbackInstructions_N3.gif"
/5 = -> "SingleNbackInstructions_practice123.gif"
</
item>
NOTE:
*the remaining items/instructions provided
->"SingleNbackInstructions_practice234.gif"
-> "SingleNbackInstructions_N4.gif"
*original slide
<
item practiceend>
/1 = "SingleNbackInstructions_practiceend1234.gif"
</
item>
NOTE:
If higher values of N are run, change this slide
*slides to start experimental trials/end experiment
<
item startendslides>
/1 = "StartExpt.gif"
/2 = "ThankYouSlide.gif"
</
item>
*Instructions for individual experimental N-levels (not original)
<
item expinstructions>
/1 = "SingleNbackInstructionsN1exp.gif"
/2 = "SingleNbackInstructionsN2exp.gif"
/3 = "SingleNbackInstructionsN3exp.gif"
/4 = "SingleNbackInstructionsN4exp.gif"
</
item>
***********INSTRUCTION IMAGE SELECTION******************************************
<
picture SingleNbackinstructions_start>
/
items = Nback_startinstructions
/
select = sequence
/
size = (100%, 100%)
</
picture>
<
picture Practice_end>
/
items =
practiceend/
select = 1
/
size = (100%, 100%)
</
picture>
<
picture StartExp_slide>
/
items =
startendslides/
select = 1
/
size = (100%, 100%)
</
picture>
<
picture EndExp_slide>
/
items =
startendslides/
select = 2
/
size = (100%, 100%)
</
picture>
*instructions for individual experimental trials are selected depending on level of N
<
picture expinstructionslide>
/
items =
expinstructions/
select = values
.N
/
size = (100%, 100%)
</
picture>
<
picture repeatpractice_page>
/
items = ("SingleNbackInstructions_practicerepeat.gif")
/
size = (100%, 100%)
</
picture>
***********INSTRUCTION TRIALS*******************************************
<
trial Nbackinstruct_starttrial>
/
stimulusframes = [1 = SingleNbackinstructions_start]
/
validresponse = (57)
/
recorddata = false
</
trial>
<
trial Practice_endtrial>
/
stimulusframes = [1 = Practice_end]
/
validresponse = (57)
/
recorddata = false
</
trial>
<
trial StartExp_trial>
/
stimulusframes = [1 = StartExp_slide]
/
validresponse = (57)
/
recorddata = false
</
trial>
<
trial expinstructiontrial>
/
stimulusframes = [1 =
expinstructionslide]
/
validresponse = (57)
/
recorddata = false
</
trial>
*only for practice trials:
<
trial practice_expinstructiontrial>
/
stimulusframes = [1 =
expinstructionslide]
/
validresponse = (57)
/
recorddata = false
/
errormessage = false
/
correctmessage = false
</
trial>
<
trial repeatpractice>
/
stimulusframes = [1 = repeatpractice_page]
/
validresponse = (49, 21)
/
recorddata = false
</
trial>
*****stores
TotalHits, TotalFA, and DV into
datafile<
trial EndExp_trial>
/
stimulusframes = [1 = EndExp_slide]
/
validresponse = (57)
/
recorddata = false
</
trial>
*************INSTRUCTION BLOCKS*************************************************************************************
ATTENTION: PRACTICE BLOCKS - code changes
(1) This block sets the beginning N value
for practice trials (here: values
.N = values
.StartN)
(2)
runs original instructions 1-5, for N=1-3, if more/
fewer than three N examples are given adjust /trials = [1-X.....]
<
block Nbackinstruct_start>
/
trials = [1-5 = Nbackinstruct_starttrial]
/
recorddata = false
/
onblockbegin = [values
.N = values
.StartN]
</
block>
<
block RepeatPractice>
/
trials = [1 =
repeatpractice]
/
recorddata = false
/
branch = [
if (trial
.repeatpractice.response == 21) {values
.N = 1; block
.practice_s_ntask} else block
.Practiceblock_end;
]
/
screencolor = (0,0,0)
</
block>
<
block Practiceblock_end>
/
trials = [1 = Practice_endtrial]
/
recorddata = false
</
block>
ATTENTION: EXPERIMENTAL BLOCKS
(1) This block sets the starting value of N (here: values
.N = values
.StartN)
<
block StartExp>
/
trials = [1 = StartExp_trial]
/
recorddata = false
/
onblockbegin = [
values.N = values
.StartN;
values.TotalHits = 0;
values.TotalFA = 0;
values.TotalBlocks = 0;
values.DV = 0
]
</
block>
<
block EndExp>
/
trials = [1 = EndExp_trial]
</
block>
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
SUMMARY PAGES
*A feedback page that could be presented at the end of each experimental block
(NOT included in the NON-ADAPTIVE version, but is included in the ADAPTIVE version)
<
instruct >
/
fontstyle = ("Arial", 2.67%, false, false, false, false, 5, 0)
/
txcolor = (255, 255, 255)
/
screencolor = (0, 0, 0)
/
windowsize = (70%, 60%)
</
instruct>
<
page BlockSummary>
^^ FEEDBACK
^^
^^CORRECT: <% ((values
.Hits + values
.CorrReject) /20) * 100 %>% of the times
</
page>
<
page BlockSummary_practice>
^^ FEEDBACK
^^
^^CORRECT: <% ((values
.Hits + values
.CorrReject) /10) * 100 %>% of the times
</
page>
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
SHAPES
*yellow on black background
*original shapes, kindly provided by Jaeggi et al (2010)
<
item shapes>
/ 1 = "1.gif"
/ 2 = "2.gif"
/ 3 = "3.gif"
/ 4 = "4.gif"
/ 5 = "5.gif"
/ 6 = "6.gif"
/ 7 = "7.gif"
/ 8 = "8.gif"
</
item>
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
STIMULI-SELECTION
****list Variables to select
notargetvalue*list
.notargetvalue selects any of the 8 numbers (item indices) but the one selected for values
.currenttarget<
list notargetvalue>
/
items = (1, 2, 3, 4, 5, 6, 7, 8)
/
not = (values
.currenttarget)
/
select =
replace</
list>
<
list hpos>
/
items = (12%, 22%, 84%, 82%, 20%, 39%, 44%, 78%)
/
selectionrate = always
</
list>
<
list vpos>
/
items = (37%, 51%, 60%, 25%, 41%, 71%, 76%, 70%)
/
selectionmode = list
.hpos.currentindex/
selectionrate = always
</
list>
<
text a>
/
items = ("1")
/
hposition = list
.hpos.nextvalue/
vposition = list
.vpos.nextvalue</
text>
<
text b>
/
items = ("2")
/
hposition = list
.hpos.nextvalue/
vposition = list
.vpos.nextvalue</
text>
<
text c>
/
items = ("3")
/
hposition = list
.hpos.nextvalue/
vposition = list
.vpos.nextvalue</
text>
<
text d>
/
items = ("4")
/
hposition = list
.hpos.nextvalue/
vposition = list
.vpos.nextvalue</
text>
<
text e>
/
items = ("5")
/
hposition = list
.hpos.nextvalue/
vposition = list
.vpos.nextvalue</
text>
<
text f>
/
items = ("6")
/
hposition = list
.hpos.nextvalue/
vposition = list
.vpos.nextvalue</
text>
<
text g>
/
items = ("7")
/
hposition = list
.hpos.nextvalue/
vposition = list
.vpos.nextvalue</
text>
<
text h>
/
items = ("8")
/
hposition = list
.hpos.nextvalue/
vposition = list
.vpos.nextvalue</
text>
***randomly selects one of the shapes
<
picture startshape>
/
items = shapes
/
select =
replace/
size = (40%, 40%)
</
picture>
***selects any
shape but the established target
<
picture nontargetshape>
/
items = shapes
/
select =
notargetvalue/
size = (40%, 40%)
</
picture>
***selects the item with the same item number as the established target
<
picture targetshape>
/
items = shapes
/
select = values
.currenttarget/
size = (40%, 40%)
</
picture>
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
FEEDBACK MESSAGES FOR PRACTICE TRIALS ONLY
<
text ErrorFeedback>
/
items = ("ERROR")
/
fontstyle = ("Arial", 5.00%, true, false, false, false, 5, 0)
/
txcolor = (255, 0, 0)
/
txbgcolor = (0, 0, 0)
/
position = (50%, 70%)
</
text>
<
text CorrectFeedback>
/
items = ("CORRECT")
/
fontstyle = ("Arial", 5.00%, true, false, false, false, 5, 0)
/
txcolor = (0, 255, 0)
/
txbgcolor = (0, 0, 0)
/
position = (50%, 70%)
</
text>
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
ASSISTANT STIMULI
*****acts as an eraser after showing the key stimuli for 500ms, staying on for the remainder of the 3000ms dedicated to each trial
<
shape eraser>
/
shape = rectangle
/
size = (100%, 100%)
/
color = (0, 0, 0)
</
shape>
*****Debug Code:
<
text targetalert>
/
items = ("target")
/
position = (50%, 80%)
/
txcolor = (black)
/
txbgcolor = (black)
/
fontstyle = ("Arial", 3%, true, false, false, false, 5, 1)
</
text>
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
TRIALS
*there are 3 types of trials
1.
start: presented at
beginning of block when
number of trials too small for Target trials; they can present
any of the stimuli (N = 0, start trial presents the target shape)
2.
nontarget:trials that present stimuli that do not repeat the stimulus of n-trials before
3.
target:trials that present Target stimuli
*start trial runs N-times (unless N = 0, then it runs N = 1 time)
<
trial start>
/
stimulustimes = [0 =
startshape; 500 = eraser]
/
validresponse = (
noresponse, 30)
/
correctresponse = (
noresponse)
/
ontrialbegin = [
{
if (values
.N == 1) values
.currenttarget = values
.minus1};
{
if (values
.N == 2) values
.currenttarget = values
.minus2};
{
if (values
.N == 3) values
.currenttarget = values
.minus3};
{
if (values
.N == 4) values
.currenttarget = values
.minus4};
values.starttrialcounter += 1;
]
/
ontrialend = [
{
if (values
.N == 0) values
.currenttarget = picture
.startshape.currentitemnumber};
values.minus4 = values
.minus3;
values.minus3 = values
.minus2;
values.minus2 = values
.minus1;
values.minus1 = picture
.startshape.currentitemnumber]
/
responsetime = 0
/
trialduration = 3000
/
branch = [if (values
.starttrialcounter < values
.N) trial
.start]
</
trial>
<
trial nontarget>
/
stimulustimes = [0 =
nontargetshape; 500 = eraser]
/
validresponse = (
noresponse, 30)
/
correctresponse = (
noresponse)
/
ontrialbegin = [
{
if (values
.N == 1) values
.currenttarget = values
.minus1};
{
if (values
.N == 2) values
.currenttarget = values
.minus2};
{
if (values
.N == 3) values
.currenttarget = values
.minus3};
{
if (values
.N == 4) values
.currenttarget = values
.minus4}
]
/
ontrialend = [
values.minus4 = values
.minus3;
values.minus3 = values
.minus2;
values.minus2 = values
.minus1;
values.minus1 = picture
.nontargetshape.currentitemnumber;
values.CorrReject = values
.CorrReject + trial
.nontarget.correct;
values.FalseA = values
.FalseA + trial
.nontarget.error;
values.TotalFA = values
.TotalFA + trial
.nontarget.error;
values.DV = (values
.TotalHits - values
.TotalFA
)/values
.TotalBlocks;
]
/
responsetime = 0
/
trialduration = 3000
</
trial>
**if target, press the letter "A" (code: 30)
<
trial target>
/
stimulustimes = [0 =
targetshape,
targetalert; 500 = eraser]
/
validresponse = (
noresponse, 30)
/
correctresponse = (30)
/
ontrialbegin = [
{
if (values
.N == 1) values
.currenttarget = values
.minus1};
{
if (values
.N == 2) values
.currenttarget = values
.minus2};
{
if (values
.N == 3) values
.currenttarget = values
.minus3};
{
if (values
.N == 4) values
.currenttarget = values
.minus4};
]
/
ontrialend = [
values.minus4 = values
.minus3;
values.minus3 = values
.minus2;
values.minus2 = values
.minus1;
values.minus1 = picture
.targetshape.currentitemnumber;
values.Hits = values
.Hits+ trial
.target
.correct;
values.Misses = values
.Misses + trial
.target
.error;
values.TotalHits = values
.TotalHits + trial
.target
.correct;
values.DV = (values
.TotalHits - values
.TotalFA
)/values
.TotalBlocks;
]
/
responsetime = 0
/
trialduration = 3000
</
trial>
********************************ADDITIONAL N-LEVELS*****************************************************
For each trial type:
(1)
add {if (values
.N == X) values
.currenttarget = values
.minusX};, e.g. N = 5
/
ontrialbegin = [
.....
{
if (values
.N == 1) values
.currenttarget = values
.minus1};
{
if (values
.N == 2) values
.currenttarget = values
.minus2};
{
if (values
.N == 3) values
.currenttarget = values
.minus3};
{
if (values
.N == 4) values
.currenttarget = values
.minus4};
=>{if (values
.N == 5) values
.currenttarget = values
.minus5};
]
(2)
add values
.minusX = values
.minus
(X-1) e.g. N = 5 - largest N goes on top of the list
/
ontrialend = [
=>values
.minus5 = values
.minus4;
values.minus4 = values
.minus3;
values.minus3 = values
.minus2;
values.minus2 = values
.minus1;
values.minus1 = picture
.targetshape.currentitemnumber;
....
]
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
PRACTICE-BLOCKS-NONADAPTIVE
* Practice Blocks do NOT record data
* Block starts with (a) Instructiontrial (b) N start-trials that cannot present Targets yet (no data collected) (c) 10 practice trials
* 10 practice trials: ratio targets
: nontargets = 3 : 7
<
block practice_s_ntask>
/
onblockbegin = [
values.currenttarget = 0; values.minus1 = 0; values.minus2 = 0; values.minus3 = 0; values.minus4 = 0;
values.TotalBlocks += 1;
values.starttrialcounter = 0;
values.repetitioncounter += 1;
values.Hits = 0; values.FalseA = 0; values.Misses = 0; values.CorrReject = 0;
]
/
trials = [1 = practice_expinstructiontrial; 2 = start; 3 - 12 =
noreplace(nontarget,
nontarget,
nontarget,
nontarget,
nontarget,
nontarget,
nontarget,
target, target, target)]
/ onblockend = [values.TotalHits = 0; values.TotalFA = 0; values.DV = 0]
/
screencolor = (0, 0, 0)
/
recorddata = true
/
postinstructions = (BlockSummary_practice)
/
branch = [if (values
.N == values
.LastPracticeN && values
.repetitioncounter == 1) {values
.TotalBlocks = 0; values
.repetitioncounter = 0; block
.RepeatPractice}]
/
branch = [if (values
.repetitioncounter < 1) block
.practice_s_ntask else
{ values
.N += 1; values
.repetitioncounter = 0; block
.practice_s_ntask}]
</
block>
if trial feedback is desired:
/
errormessage = true
(ErrorFeedback, 500)
/
correctmessage = true
(CorrectFeedback, 500)
************************************** ADDITIONAL N-LEVELS********************************************************
(1)
add values
.minusX = 0
to/
onblockbegin = [
values.currenttarget = 0; values.minus1 = 0; values.minus2 = 0; values.minus3 = 0; values.minus4 = 0;
.....
]
Example: N = 5
/
onblockbegin = [
values.currenttarget = 0; values.minus1 = 0; values.minus2 = 0; values.minus3 = 0; values.minus4 = 0;
values.minus5 = 0;
.....
]
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
EXPERIMENTAL-BLOCKS ADAPTIVE
*********** ADAPTIVE N-BACK EXPERIMENTAL Blocks*****************************
*if a participant makes fewer than 3 errors on a
level then participant moves up a level (see Jaeggi et al (2010))
*if a participant makes more than 5 errors on a
level then participant moves down a level (see Jaeggi et al (2010))
*otherwise participant stays on the same level (see Jaeggi et al (2010))
*Max number of blocks: 15 (see Jaeggi et al (2010), Experiment 2, p
.630),
editable parameter
*Blocks give performance feedback (see Jaeggi et al (2010), Experiment 2, p
.630)
*errors defined in this script: sum of Misses and False Alarms
* Block starts with 1 instruction trial and is followed by N start-trials that cannot present targets yet (not included in performance analyses)
* in remaining 20 trials: ratio
nontargets : targets: 14 : 6 = 7 : 3
<
block s_ntask_adapt>
/
onblockbegin = [
values.currenttarget = 0; values.minus1 = 0; values.minus2 = 0; values.minus3 = 0; values.minus4 = 0;
values.Hits = 0; values.FalseA = 0; values.Misses = 0; values.CorrReject = 0;
values.TotalBlocks += 1; values
.starttrialcounter = 0;
]
/
trials = [1 =
expinstructiontrial; 2 = start; 3 - 22 =
noreplace(nontarget,
nontarget,
nontarget,
nontarget,
nontarget,
nontarget,
nontarget,
target, target, target)]
/
screencolor = (0, 0, 0)
/
postinstructions = (
BlockSummary)
/
branch = [if (values
.TotalBlocks == values
.NumberTestBlocks) block
.EndExp]
/
branch = [if (values
.N < values
.LastN && ((values
.Misses + values
.FalseA) < 3)) {values
.N += 1; block
.s_ntask_adapt}]
/
branch = [if (values
.N > 1 && ((values
.Misses + values
.FalseA) > 5)) {values
.N -= 1; block
.s_ntask_adapt}
else block
.s_ntask_adapt]
</
block>
****************************************ADDITIONAL N-LEVELS/CODE ALTERATIONS********************************************************
(1)
add values
.minusX = 0
to/
onblockbegin = [
values.currenttarget = 0; values.minus1 = 0; values.minus2 = 0; values.minus3 = 0; values.minus4 = 0;
.....
]
Example: N = 5
/
onblockbegin = [
values.currenttarget = 0; values.minus1 = 0; values.minus2 = 0; values.minus3 = 0; values.minus4 = 0;
values.minus5 = 0;
.....
]
************************************************************************************************************************************************************************
************************************************************************************************************************************************************************
EXPERIMENT
*After running the initial instructions, participants work through practice blocks for N = 1 to N = 3
* After practice, participants work through
15 blocks of levels N = 1 to N = 4 (depending on performance)
<
expt>
/
onexptbegin = [if (values.debugmode == 1) text
.targetalert.textcolor = (red)]
/
blocks = [
1 = Nbackinstruct_start;
2 = practice_s_ntask;
]
/
onexptend = [values.completed = 1]
</
expt>
************************************************************************************************************************************************************************
End of Script
************************************************************************************************************************************************************************