+x

 

SanneBos - 5/17/2021

For an online experiment I created a modified Stroop task. I put my script in the attachment 
For this experiment I have three categories per block with items (word lists), and each word should appear once in red and once in blue. The order of the trials should be random per word category and per word color. 

Now I want to put some constraints on the randomized order, as my script currently randomly picks a blue or red item from one of the three lists in that block.

The order must be random, with the following constraints?:
- The items should appear in a random order
- No more than 3 trials with the same color in a row.
- Each item (word) should appear exactly once in red, once in blue (currently controlled with two separate lists and assigning a color to that itemset.)
- Within a block, a word should never appear in red and blue immediately after one another. There should be at least 2-3 trials in between two similar words.

How can I implement this in Inquisit?
Thanks in advance!

+x

 

Dave - 5/17/2021

+x

 

SanneBos - 5/17/2021

For an online experiment I created a modified Stroop task. I put my script in the attachment 
For this experiment I have three categories per block with items (word lists), and each word should appear once in red and once in blue. The order of the trials should be random per word category and per word color. 

Now I want to put some constraints on the randomized order, as my script currently randomly picks a blue or red item from one of the three lists in that block.

The order must be random, with the following constraints?:
- The items should appear in a random order
- No more than 3 trials with the same color in a row.
- Each item (word) should appear exactly once in red, once in blue (currently controlled with two separate lists and assigning a color to that itemset.)
- Within a block, a word should never appear in red and blue immediately after one another. There should be at least 2-3 trials in between two similar words.

How can I implement this in Inquisit?
Thanks in advance!

Please refer to the relevant parts exactly as they are named in the script. What are the categories (name the elements)? What are the relevant word lists (name the elements)? Same with " Each item (word) should appear exactly once in red, once in blue (currently controlled with two separate lists and assigning a color to that itemset.)" -- Please name the elements you are referring to. With respect to "There should be at least 2-3 trials in between two similar words" -- what do you understand to be "similar words"?

Explain how you set up the script and why you did so.

+x

 

SanneBos - 5/17/2021

+x

 

Dave - 5/17/2021

+x

 

SanneBos - 5/17/2021

For an online experiment I created a modified Stroop task. I put my script in the attachment 
For this experiment I have three categories per block with items (word lists), and each word should appear once in red and once in blue. The order of the trials should be random per word category and per word color. 

Now I want to put some constraints on the randomized order, as my script currently randomly picks a blue or red item from one of the three lists in that block.

The order must be random, with the following constraints?:
- The items should appear in a random order
- No more than 3 trials with the same color in a row.
- Each item (word) should appear exactly once in red, once in blue (currently controlled with two separate lists and assigning a color to that itemset.)
- Within a block, a word should never appear in red and blue immediately after one another. There should be at least 2-3 trials in between two similar words.

How can I implement this in Inquisit?
Thanks in advance!

Please refer to the relevant parts exactly as they are named in the script. What are the categories (name the elements)? What are the relevant word lists (name the elements)? Same with " Each item (word) should appear exactly once in red, once in blue (currently controlled with two separate lists and assigning a color to that itemset.)" -- Please name the elements you are referring to. With respect to "There should be at least 2-3 trials in between two similar words" -- what do you understand to be "similar words"?

Explain how you set up the script and why you did so.

Thanks for your quick reply, Dave.

The experiment consists of mulitple blocks, I will explain it for one of the blocks. The other ones have similar set ups. 
For example the block ADHDStroop:
- the script contains three word lists, each in a different category: item.ADHDwordslist has 20 items in category 1; item.noADHDwordslist has 20 items in category 2; item.afleidingADHDwordslist has 8 items in category 3.
- from each itemlist, a text element generates that list with either textcolor blue or red:
<text ADHDwordblue> 
    / items = ADHDwordslist
    / select = noreplace
    / txcolor = blue
</text>
This results with the following trials: ADHDwordblue (category 1 in blue), noADHDwordblue (category 2 in blue), afleidingADHDwordblue (category 3 in blue), ADHDwordred (category 1 in red), noADHDwordred (category 2 in red), afleidingADHDwordred (category 3 in red).

in each trial (for example trial.ADHDwordblue) the response, reaction time, accuracy and other stuff is saved to the dataset.

Now, say we throw the words of category 1, 2 and 3 on a big pile. I would like to randomly present words from that big pile to the participant. Each word should be presented once in blue, once in red. 
Then, the result would be that I have reaction times per category, so I can compare this. (If it is easier to put it in the script in one big pile of words, I could separate the categories in post analysis.)

As each word should be presented twice (once red, once blue) it is currently possible that in consecutive trials, the word "chaotic" would present in red, and the next trial the same word "chaotic" presents in blue. I do not want that. Therefore, I want at least 2-3 trials in between the two times that that word is presented.

How do you think I could fix this?
Thanks a lot, I hope you can help me.

+x

 

Dave - 5/17/2021

+x

 

SanneBos - 5/17/2021

+x

 

Dave - 5/17/2021

+x

 

SanneBos - 5/17/2021

For an online experiment I created a modified Stroop task. I put my script in the attachment 
For this experiment I have three categories per block with items (word lists), and each word should appear once in red and once in blue. The order of the trials should be random per word category and per word color. 

Now I want to put some constraints on the randomized order, as my script currently randomly picks a blue or red item from one of the three lists in that block.

The order must be random, with the following constraints?:
- The items should appear in a random order
- No more than 3 trials with the same color in a row.
- Each item (word) should appear exactly once in red, once in blue (currently controlled with two separate lists and assigning a color to that itemset.)
- Within a block, a word should never appear in red and blue immediately after one another. There should be at least 2-3 trials in between two similar words.

How can I implement this in Inquisit?
Thanks in advance!

Please refer to the relevant parts exactly as they are named in the script. What are the categories (name the elements)? What are the relevant word lists (name the elements)? Same with " Each item (word) should appear exactly once in red, once in blue (currently controlled with two separate lists and assigning a color to that itemset.)" -- Please name the elements you are referring to. With respect to "There should be at least 2-3 trials in between two similar words" -- what do you understand to be "similar words"?

Explain how you set up the script and why you did so.

Thanks for your quick reply, Dave.

The experiment consists of mulitple blocks, I will explain it for one of the blocks. The other ones have similar set ups. 
For example the block ADHDStroop:
- the script contains three word lists, each in a different category: item.ADHDwordslist has 20 items in category 1; item.noADHDwordslist has 20 items in category 2; item.afleidingADHDwordslist has 8 items in category 3.
- from each itemlist, a text element generates that list with either textcolor blue or red:
<text ADHDwordblue> 
    / items = ADHDwordslist
    / select = noreplace
    / txcolor = blue
</text>
This results with the following trials: ADHDwordblue (category 1 in blue), noADHDwordblue (category 2 in blue), afleidingADHDwordblue (category 3 in blue), ADHDwordred (category 1 in red), noADHDwordred (category 2 in red), afleidingADHDwordred (category 3 in red).

in each trial (for example trial.ADHDwordblue) the response, reaction time, accuracy and other stuff is saved to the dataset.

Now, say we throw the words of category 1, 2 and 3 on a big pile. I would like to randomly present words from that big pile to the participant. Each word should be presented once in blue, once in red. 
Then, the result would be that I have reaction times per category, so I can compare this. (If it is easier to put it in the script in one big pile of words, I could separate the categories in post analysis.)

As each word should be presented twice (once red, once blue) it is currently possible that in consecutive trials, the word "chaotic" would present in red, and the next trial the same word "chaotic" presents in blue. I do not want that. Therefore, I want at least 2-3 trials in between the two times that that word is presented.

How do you think I could fix this?
Thanks a lot, I hope you can help me.

Well, first off, your block does not sample trials in the correct proportions at all. You have 20 items in category 1, 20 in category 2, and only 8 in category 3. You want each item presented twice (once blue, once red), so 96 trials total. But that's not what your block does. Your block samples from the six trial elements in equal proportions per

<block ADHDStroop>
    / preinstructions = (expronde1)        // Show HTML with reminder-instructions
    / trials = [
        1 = getready;
        2-97 = noreplace(ADHDwordblue, noADHDwordblue, afleidingADHDwordblue, ADHDwordred, noADHDwordred, afleidingADHDwordred);
    ]
    / showmousecursor = false
</block>

resulting in 96/6 = 16 instances of each trial, so:
16 x ADHDwordblue
16 x ADHDwordred
16 x noADHDwordblue
16 x noADHDwordred
16 x afleidingADHDwordblue
16 x afleidingADHDwordred

and this is before we even get to discussing any options for constraints.

> - No more than 3 trials with the same color in a row.

is relatively easy to implement using a list with a /maxrunsize constraint for trial color selection if you can live with potential constraint violations towards the end of a sequence (with on-the-fly random sampling, you will run into situations where the only trials left in the list are trials that violate the constraint). Simple example:

// "blue" trials
<trial a_blue>
/ ontrialbegin = [
    values.trialnumber += 1;
]
/ trialduration = 0
</trial>

<trial b_blue>
/ ontrialbegin = [
    values.trialnumber += 1;
]
/ trialduration = 0
</trial>

<trial c_blue>
/ ontrialbegin = [
    values.trialnumber += 1;
]
/ trialduration = 0
</trial>

// "red" trials
<trial a_red>
/ ontrialbegin = [
    values.trialnumber += 1;
]
/ trialduration = 0
</trial>

<trial b_red>
/ ontrialbegin = [
    values.trialnumber += 1;
]
/ trialduration = 0
</trial>

<trial c_red>
/ ontrialbegin = [
    values.trialnumber += 1;
]
/ trialduration = 0
</trial>

// list of "blue" trials
<list bluetriallist>
/ items = (trial.a_blue, trial.b_blue, trial.c_blue)
/ itemprobabilities = [.416; .416; .168]
/ poolsize = 48
/ selectionmode = random
/ replace = false
</list>

// list of "red" trials
<list redtriallist>
/ items = (trial.a_red, trial.b_red, trial.c_red)
/ itemprobabilities = [.416; .416; .168]
/ poolsize = 48
/ selectionmode = random
/ replace = false
</list>

<list trialcolor>
/ items = ("blue","red")
/ poolsize = 96
/ maxrunsize = 3
/ selectionmode = random
/ replace = false
</list>

<values>
/ trialcolor = 1
/ trialnumber = 0
</values>

<trial trialselector>
/ ontrialbegin = [
    values.trialcolor = list.trialcolor.nextvalue;
]
/ recorddata = false
/ branch = [
    if (values.trialcolor == "blue") {
        list.bluetriallist.nextvalue;
    } else if (values.trialcolor == "red") {
        list.redtriallist.nextvalue;
    };
]
/ trialduration = 0
</trial>

<block exampleblock>
/ trials = [1-96 = trialselector]
</block>

<data>
/ columns = (date time subject group session blocknum blockcode values.trialnumber trialcode values.trialcolor stimulusitem response latency correct)
</data>

> - Within a block, a word should never appear in red and blue immediately after one another. There should be at least 2-3 trials in between two similar words.

is not easily done at all. If you shun the work, you should drop that constraint. Otherwise, you will have to code a sequence generator, in which case the best advice I can give you is to study the one included with the AAT script https://www.millisecond.com/download/library/aat/

+x

 

SanneBos - 5/18/2021

Hi Dave,

Based on your comment on the difficulties with my constraints I hard coded the sequences. That fixed my issues, and the experiment works almost completely now.

Now, some other part of my script fails...

I use the code below to run one of five different hard-coded sequences (Further specified within block.ADHD1, and different per block)

<expt>
    / blocks = [
        1 =list.blockSelectorADHD; ]
</expt>

<list blockSelectorADHD>
    / items = (block.ADHD1, block.ADHD2, block.ADHD3, block.ADHD4, block.ADHD5)
    / selectionmode = random
</list>

This works for most of my code.
However, in the end of my experiment I also have a random sequence of 5 rounds of blocks that shoud be followed by a specific surveypage;
For example: surveypage 1, block1 - - surveypage 2, block2 - - surveypage 5, block5 - - surveypage 4, block4 - - surveypage 3, block3

In my old version of the experiment I used:     
<expt>
    / blocks = [
          1-5 = noreplace(survey1, survey2, survey3, survey4, survey5); ]
</expt>

With the survey's branching to that specific block.

However, the two techniques don't mix, as I am not allowed to branch in my survey to a list.blockSelector...

Do you know a way to work around this?
It would be ideal if I could branch to a list, but that doesn't work...

+x

 

SanneBos - 5/18/2021

+x

 

SanneBos - 5/18/2021

Hi Dave,

Based on your comment on the difficulties with my constraints I hard coded the sequences. That fixed my issues, and the experiment works almost completely now.

Now, some other part of my script fails...

I use the code below to run one of five different hard-coded sequences (Further specified within block.ADHD1, and different per block)

<expt>
    / blocks = [
        1 =list.blockSelectorADHD; ]
</expt>

<list blockSelectorADHD>
    / items = (block.ADHD1, block.ADHD2, block.ADHD3, block.ADHD4, block.ADHD5)
    / selectionmode = random
</list>

This works for most of my code.
However, in the end of my experiment I also have a random sequence of 5 rounds of blocks that shoud be followed by a specific surveypage;
For example: surveypage 1, block1 - - surveypage 2, block2 - - surveypage 5, block5 - - surveypage 4, block4 - - surveypage 3, block3

In my old version of the experiment I used:     
<expt>
    / blocks = [
          1-5 = noreplace(survey1, survey2, survey3, survey4, survey5); ]
</expt>

With the survey's branching to that specific block.

However, the two techniques don't mix, as I am not allowed to branch in my survey to a list.blockSelector...

Do you know a way to work around this?
It would be ideal if I could branch to a list, but that doesn't work...

Small addition: what makes it difficult is that there is a preinstruction html page before each block... So the order is surveypage - preinstruction - other trials... That's where I'm stuck currently.

+x

 

Dave - 5/18/2021

+x

 

SanneBos - 5/18/2021

+x

 

SanneBos - 5/18/2021

Hi Dave,

Based on your comment on the difficulties with my constraints I hard coded the sequences. That fixed my issues, and the experiment works almost completely now.

Now, some other part of my script fails...

I use the code below to run one of five different hard-coded sequences (Further specified within block.ADHD1, and different per block)

<expt>
    / blocks = [
        1 =list.blockSelectorADHD; ]
</expt>

<list blockSelectorADHD>
    / items = (block.ADHD1, block.ADHD2, block.ADHD3, block.ADHD4, block.ADHD5)
    / selectionmode = random
</list>

This works for most of my code.
However, in the end of my experiment I also have a random sequence of 5 rounds of blocks that shoud be followed by a specific surveypage;
For example: surveypage 1, block1 - - surveypage 2, block2 - - surveypage 5, block5 - - surveypage 4, block4 - - surveypage 3, block3

In my old version of the experiment I used:     
<expt>
    / blocks = [
          1-5 = noreplace(survey1, survey2, survey3, survey4, survey5); ]
</expt>

With the survey's branching to that specific block.

However, the two techniques don't mix, as I am not allowed to branch in my survey to a list.blockSelector...

Do you know a way to work around this?
It would be ideal if I could branch to a list, but that doesn't work...

Small addition: what makes it difficult is that there is a preinstruction html page before each block... So the order is surveypage - preinstruction - other trials... That's where I'm stuck currently.

> However, the two techniques don't mix, as I am not allowed to branch in my survey to a list.blockSelector...

This is not true, why do you believe that to be the case?

+x

 

SanneBos - 5/18/2021

+x

 

Dave - 5/18/2021

+x

 

SanneBos - 5/18/2021

+x

 

SanneBos - 5/18/2021

Hi Dave,

Based on your comment on the difficulties with my constraints I hard coded the sequences. That fixed my issues, and the experiment works almost completely now.

Now, some other part of my script fails...

I use the code below to run one of five different hard-coded sequences (Further specified within block.ADHD1, and different per block)

<expt>
    / blocks = [
        1 =list.blockSelectorADHD; ]
</expt>

<list blockSelectorADHD>
    / items = (block.ADHD1, block.ADHD2, block.ADHD3, block.ADHD4, block.ADHD5)
    / selectionmode = random
</list>

This works for most of my code.
However, in the end of my experiment I also have a random sequence of 5 rounds of blocks that shoud be followed by a specific surveypage;
For example: surveypage 1, block1 - - surveypage 2, block2 - - surveypage 5, block5 - - surveypage 4, block4 - - surveypage 3, block3

In my old version of the experiment I used:     
<expt>
    / blocks = [
          1-5 = noreplace(survey1, survey2, survey3, survey4, survey5); ]
</expt>

With the survey's branching to that specific block.

However, the two techniques don't mix, as I am not allowed to branch in my survey to a list.blockSelector...

Do you know a way to work around this?
It would be ideal if I could branch to a list, but that doesn't work...

Small addition: what makes it difficult is that there is a preinstruction html page before each block... So the order is surveypage - preinstruction - other trials... That's where I'm stuck currently.

> However, the two techniques don't mix, as I am not allowed to branch in my survey to a list.blockSelector...

This is not true, why do you believe that to be the case?

When I run my script, I get the error:
The element 'blockSelectorRelaties' returned by branch expression 'blockSelectorRelaties' is the wrong type.

And the blocks don't run, only the surveys work.

+x

 

Dave - 5/18/2021

+x

 

SanneBos - 5/18/2021

+x

 

Dave - 5/18/2021

+x

 

SanneBos - 5/18/2021

+x

 

SanneBos - 5/18/2021

Hi Dave,

Based on your comment on the difficulties with my constraints I hard coded the sequences. That fixed my issues, and the experiment works almost completely now.

Now, some other part of my script fails...

I use the code below to run one of five different hard-coded sequences (Further specified within block.ADHD1, and different per block)

<expt>
    / blocks = [
        1 =list.blockSelectorADHD; ]
</expt>

<list blockSelectorADHD>
    / items = (block.ADHD1, block.ADHD2, block.ADHD3, block.ADHD4, block.ADHD5)
    / selectionmode = random
</list>

This works for most of my code.
However, in the end of my experiment I also have a random sequence of 5 rounds of blocks that shoud be followed by a specific surveypage;
For example: surveypage 1, block1 - - surveypage 2, block2 - - surveypage 5, block5 - - surveypage 4, block4 - - surveypage 3, block3

In my old version of the experiment I used:     
<expt>
    / blocks = [
          1-5 = noreplace(survey1, survey2, survey3, survey4, survey5); ]
</expt>

With the survey's branching to that specific block.

However, the two techniques don't mix, as I am not allowed to branch in my survey to a list.blockSelector...

Do you know a way to work around this?
It would be ideal if I could branch to a list, but that doesn't work...

Small addition: what makes it difficult is that there is a preinstruction html page before each block... So the order is surveypage - preinstruction - other trials... That's where I'm stuck currently.

> However, the two techniques don't mix, as I am not allowed to branch in my survey to a list.blockSelector...

This is not true, why do you believe that to be the case?

When I run my script, I get the error:
The element 'blockSelectorRelaties' returned by branch expression 'blockSelectorRelaties' is the wrong type.

And the blocks don't run, only the surveys work.

To /branch to a block object contained in a list, you ought to do

<block StroopInstructionsDL_werk>
  / preinstructions = (expronde3A)
  / branch = [list.blockSelectorWerk.nextvalue]
</block>

<block StroopInstructionsDL_sociaal>
  / preinstructions = (expronde3A)
  / branch = [list.blockSelectorSociaal.nextvalue]
</block>

<block StroopInstructionsDL_relaties>
  / preinstructions = (expronde3A)
  / branch = [list.blockSelectorRelaties.nextvalue]
</block>

<block StroopInstructionsDL_hobby>
  / preinstructions = (expronde3A)
  / branch = [list.blockSelectorHobby.nextvalue]
</block>

<block StroopInstructionsDL_zelf>
  / preinstructions = (expronde3A)
  / branch = [list.blockSelectorZelf.nextvalue]
</block>

nextvalue is what actually causes an item from the list (here: a block object) to be sampled. list.blockselector in /branch returns nothing in and of itself in /branch, i.e. not a block object.