Millisecond Forums

> However, this introduces a blinking effect - i.e., the continuous presentation of the appropriate .jpeg images (through continuous
> presentation of the trial) gives a strobe effect, instead of the continuous display of the images and the dot rotating around the clock. Is it
> possible to fix this?

You'll want to set the respective stimulus elements' /erase attributes to false. If you do need to remove stimuli from the screen at some point(s), you'll want to paint them over with a blank <shape>. See the "How to erase stimuli" topic in the documentation for information on Inquisit's default stimulus erasing behavior.

> I would like .jpegs to still continuously appear for a time (so that the dot rotates a random amount of time between 1000ms - 2500ms)
> after the participant presses the button. I've tried introducing a new trial, but this doesn't seem to work (and undesirably still requires a
> correctresponse, seeing as I am using the /timeout expression to rotate the dot around the clock).

Introducing a new trial is exactly what you should do. The <trial> should not accept any responses -- /validresponse = (0) --  and loop itself a randomly chosen number of times (by /branch-ing back to itself) and once it has been run X times /branch to trial.postlibet.

> The other is that I would ideally like the /correctmessage sound to be delayed by 250ms. I've tried editing the physical sound, but either
> Inquisit plays the sound despite the 250ms gap, or doesn't play the sound at all.

Delaying the the beep conflicts with your other requirement above (keep rotating for a random amount of time), so I'm not sure what to answer here.

Hi Dave,

Many thanks for your response - the /erase = false worked perfectly. On achieving this, appears to be a slight pause when the correct response is made, making the trial pause and thus the clockface/dot remain static for an instant, instead of continued fluid movement from <trial Libet> to <trial Rotate> - is this purely from Inquisit processing, or is there a way to achieve fluidity?

As for the repeated trials to continually rotate the dot, the best I can come up with (as I can't find a repeat trial X number of times expression anywhere) is:

<values>
/currentlistnumber = 0
</values>

<list libetframes>
/items = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24)
/selectionmode = sequence
</list>

<trial Rotate>
/ontrialbegin = [{values.currentlistnumber = list.libetframes.nextvalue}]
/stimulustimes = [1 = libetclock]
/validresponse = (0)
/timeout = 60
/branch = [if (values.currentlistnumber == 1) {trial.postLibet} else {trial.rotate}]
/recorddata = false
</trial>

This obviously means the clock will rotate afterwards until the given value, however I am unable to work out how to randomly generate this (or if there's a better solution).

>Delaying the the beep conflicts with your other requirement above (keep rotating for a random amount of time), so I'm not sure what to answer here

It is purely for the participants to estimate how long it took for the noise to appear after their action - the aim is to have a few different lengths of delay, with different types of noises, the time estimation bar afterwards is for them to measure how long it took for the sound to appear. If there is no way to achieve this, I will likely have to rethink how to present the trials in a way to produce the illusion of a dot rotating around the clock. Thank you anyway though!

Thanks,
Josh

> [...] appears to be a slight pause when the correct response is made, making the trial pause and thus the clockface/dot remain static for an
> instant [...]

If your definition of <trial libet> is still the same as it was in your initial post, the pause is due to you displaying a correctmessage for 250ms.

<trial Libet>
/ontrialbegin = [{values.currentlistnumber = list.libetframes.nextvalue}]
/stimulustimes = [1 = libetclock]
/correctresponse = (" ")
/correctmessage = true(beep, 250)
...
</trial>

Only after that will Inquisit move on to the next trial (e.g. <trial rotate>). It's what you instructed the script to do.

Regarding the rotation: At the start of each "round", i.e. in <trial preLibet>, generate a random number (using round(rand()) or by sampling from a <list> of random values) from the desired range and store it in a global variable (a <values> entry). The random number in that variable represents *the number of times* you want to run <trial rotate> after a response has been given in <trial libet>. You count the number of times <trial rotate> is run and /branch to <trial postLibet> once the count is equal to the random value.

<trial preLibet>
/ ontrialbegin = [values.keep_rotating_for_n_trials = round(rand(20,50)); values.rotationcount = 0; ]
...
/branch = [trial.Libet]
/recorddata = false
</trial>

<trial Rotate>
/ ontrialbegin = [values.rotationcount += 1]
...
/branch = [if (values.rotationcount >= values.keep_rotating_for_n_trials) {trial.postLibet} else {trial.rotate}]
/recorddata = false
</trial>

Regarding the delay: The display of the response message with (varying) delay should not be handled by <trial libet> then, but by some other, separate / dedicated <trial> element, e.g. <trial rotate>. You can 'inject' the <sound> stimulus into the <trial>'s stimulusframes by using the insertstimulusframe() function. As with the continued rotation detailed above, pick the instance of <trial rotate> in which the "beep" should occur. The do

<trial Rotate>
/ ontrialbegin = [values.rotationcount += 1]
/ ontrialbegin = [if (values.rotationcount == values.beep_in_instance) {trial.rotate.insertstimulusframe(sound.beep, 1);}; ]
/ ontrialend = [trial.rotate.resetstimulusframes(); ]
...
/branch = [if (values.rotationcount >= values.keep_rotating_for_n_trials) {trial.postLibet} else {trial.rotate}]
/recorddata = false
</trial>

Hi Dave,

That's great - It runs nice and smoothly now, except for one issue, which is that the sound doesn't play at all, now. I've tried recreating the physical sound file and replacing it to no avail. The study runs, and I receive no error message, but the sound still does not play. 

Here's an updated script:
<trial preLibet>
/ontrialbegin = [{values.currentlistnumber = list.libetframes.nextvalue}]
/ontrialbegin = [values.keep_rotating_for_n_trials = round(rand(20,50)); values.rotationcount = 0;]
/stimulustimes = [1 = cross; 500 = libetclock]
/correctresponse = (" ")
/pretrialpause = 500
/timeout = 600
/branch = [trial.Libet]
/recorddata = false
</trial>

<trial Libet>
/ontrialbegin = [{values.currentlistnumber = list.libetframes.nextvalue}]
/stimulustimes = [1 = libetclock]
/correctresponse = (57)
/correctmessage = true(beep, 1)
/timeout = 60
/branch = [if (trial.Libet.response == 57) {trial.rotate} else {trial.Libet}]
/recorddata = false
/ontrialend = [values.sound = 3]
/ontrialend = [values.onset = list.libetframes.currentvalue]
</trial>

<trial Rotate>
/ontrialbegin = [{values.currentlistnumber = list.libetframes.nextvalue}]
/ontrialbegin = [values.rotationcount += 1]
/ontrialbegin = [if (values.rotationcount == values.beep) {trial.rotate.insertstimulusframe(sound.beep, 250)}]
/stimulustimes = [1 = libetclock]
/validresponse = (0)
/timeout = 60
/ontrialend = [trial.rotate.resetstimulusframes(100)]
/branch = [if (values.rotationcount >= values.keep_rotating_for_n_trials) {trial.postLibet} else {trial.rotate}]
/recorddata = false
</trial>

<trial postLibet>
/stimulustimes = [1 = cross]
/timeout = 500
/branch = [surveypage.tep]
/recorddata = false
</trial>

Where I have put 250 is the amount of time I'd like to delay the sound for - I apologise if that's an inappropriate place.
Thank you for your help, it is greatly appreciated.
Josh

<trial Rotate>
/ontrialbegin = [{values.currentlistnumber = list.libetframes.nextvalue}]
/ontrialbegin = [values.rotationcount += 1]
/ontrialbegin = [if (values.rotationcount == values.beep) {trial.rotate.insertstimulusframe(sound.beep, 250)}]
/stimulustimes = [1 = libetclock]
/validresponse = (0)
/timeout = 60
/ontrialend = [trial.rotate.resetstimulusframes(100)]
/branch = [if (values.rotationcount >= values.keep_rotating_for_n_trials) {trial.postLibet} else {trial.rotate}]
/recorddata = false
</trial>

means you insert the sound *in the trial's 250th frame*, which does not make sense. The trial does not even last that long (it times out after just 60ms). You'll want to insert the stimulus in the 1st frame just like in the example code in my previous reply. And you need to make sure that values.beep makes sense. I.e., it should represent the *instance* of <trial rotate> that corresponds (most closely) to the desired delay. With a single instance of <trial rotate> lasting 60ms and the desired delay being ~250 ms, you'd want the beep inserted in the 5th instance of <trial rotate>, i.e., values.beep should be set to 5.

Hi Dave,

Thanks for your help - I've worked through a lot of the issues, and everything has turned out nicely thanks to you.

However, there is one glaring problem - when the sound is played in the following trial, the rotating dot pauses in place whilst the sound is played. I assume this is because the .jpeg of whatever clock-face + dot is bound to the sound stimulus. What the task requires is that the dot still to continue rotating whilst the sound is being played, as the participant is going to be asked to judge the time the sound occurred (which will be quite easy if the .jpeg pauses and thus the dot is, to the participant's perspective, stationary). Is there a solution to this, or will it require a complete overhaul of the code to produce this effect? I've attached the updated script below for your reference.

Many thanks again,
Josh

> However, there is one glaring problem - when the sound is played in the following trial, the rotating dot pauses in place whilst the sound
> is played. I assume this is because the .jpeg of whatever clock-face + dot is bound to the sound stimulus.

Yes and no. The clock-face is not bound to the sound stimulus; both are bound to the *trial*. You are essentially working in 60ms intervals (duration of a single instance of the relevant <trial>). Thus your options are:

- Make sure the sound you play is substantially shorter than 60ms, so that it "fits" within a single instance of the <trial>.
- You've also forced the <trial> to play the sound to completion by setting /playthrough = true in the respective <sound> elements, i.e., the <trial> that plays the sound will not terminate and cut off the sound after 60ms before moving on to the next <trial>.
- If making the sounds sufficiently short is not an option, you need to set up and run yet another <trial> element, one that lasts longer than 60ms (how long depends on the actual length of your sounds; I have no way of knowing what it is) and displays *more* than a single clock-face via its /stimulustimes.

To illustrate, here's a quick example implementing the gist of the latter option:

<block myblock>
/ onblockbegin = [systembeep.frequency = 440; systembeep.duration = 300; ]
/ trials = [1-10=start]
</block>

<values>
/ c1item = 1
/ c2item = 1
/ c3item = 1
/ c4item = 1
/ c5item = 1
/ c6item = 1
/ delay = 4
/ keeprotatingfor = 0
/ rotatecount = 0
</values>

<trial start>
/ ontrialbegin = [list.clocksteps.reset(); values.rotatecount = 0; values.keeprotatingfor = round(rand(20,50)); ]
/ stimulusframes = [1=fixation]
/ trialduration = 600
/ branch = [trial.libet]
</trial>

<trial libet>
/ ontrialbegin = [values.c1item = list.clocksteps.nextindex; ]
/ stimulusframes = [1=clock1]
/ trialduration = 60
/ validresponse = (57, -57, 0)
/ branch = [if (trial.libet.response != 0) trial.rotate else trial.libet]
</trial>

<trial rotate>
/ ontrialbegin = [values.c1item = list.clocksteps.nextindex; values.rotatecount += 1; ]
/ stimulusframes = [1=clock1]
/ validresponse = (0)
/ trialduration = 60
/ branch = [if (values.rotatecount == values.delay) trial.audio]
/ branch = [if (values.rotatecount < values.keeprotatingfor) trial.rotate else trial.end]
</trial>

<trial audio>
/ ontrialbegin = [values.c1item = list.clocksteps.nextindex; values.c2item = list.clocksteps.nextindex;
    values.c3item = list.clocksteps.nextindex; values.c4item = list.clocksteps.nextindex;
    values.c5item = list.clocksteps.nextindex; values.c5item = list.clocksteps.nextindex; ]
/ ontrialend = [values.rotatecount += 6]
/ stimulustimes = [0=systembeep, clock1; 60=clock2; 120=clock3; 180=clock4; 240=clock5; 300=clock6]
/ validresponse = (0)
/ trialduration = 360
/ branch = [if (values.rotatecount < values.keeprotatingfor) trial.rotate else trial.end]
</trial>

<trial end>
/ stimulusframes = [1=end]
/ validresponse = (57)
</trial>

<list clocksteps>
/ poolsize = 24
/ selectionmode = sequence
/ selectionrate = always
</list>

<text clock1>
/ items = clockfaceitems
/ select = values.c1item
/ erase = false
</text>

<text clock2>
/ items = clockfaceitems
/ select = values.c2item
/ erase = false
</text>

<text clock3>
/ items = clockfaceitems
/ select = values.c3item
/ erase = false
</text>

<text clock4>
/ items = clockfaceitems
/ select = values.c4item
/ erase = false
</text>

<text clock5>
/ items = clockfaceitems
/ select = values.c5item
/ erase = false
</text>

<text clock6>
/ items = clockfaceitems
/ select = values.c6item
/ erase = false
</text>

<item clockfaceitems>
/ 1 = "01.jpg"
/ 2 = "02.jpg"
/ 3 = "03.jpg"
/ 4 = "04.jpg"
/ 5 = "05.jpg"
/ 6 = "06.jpg"
/ 7 = "07.jpg"
/ 8 = "08.jpg"
/ 9 = "09.jpg"
/ 10 = "10.jpg"
/ 11 = "11.jpg"
/ 12 = "12.jpg"
/ 13 = "13.jpg"
/ 14 = "14.jpg"
/ 15 = "15.jpg"
/ 16 = "16.jpg"
/ 17 = "17.jpg"
/ 18 = "18.jpg"
/ 19 = "19.jpg"
/ 20 = "20.jpg"
/ 21 = "21.jpg"
/ 22 = "22.jpg"
/ 23 = "23.jpg"
/ 24 = "24.jpg"
</item>

<text fixation>
/ items = ("+")
/ erase = false
</text>

<text end>
/ items = ("End of round.")
</text>

Hi Dave,

Thanks for your help! I had a bit of trouble implementing your example into my script (I need these specific sounds as the length that they are) - It runs without errors, but the clock face (i.e. trial) still pauses whilst the sound is played, and don't carry on afterwards, and the text name appears in front of the clock (although this is probably because they are text items in your example). I apologise if I made some glaring errors in my translation. I have acquired the correct stimuli, so I've added those in, which are positive and negative sounds. I've pasted the script below with just the positive sounds to share what I managed to do (or not do, as is the case):

<values>
/completed = 0
/intervalestimation = 0
/currentlistnumber = 0
</values>

<values>
/onset = 0
</values>

<values>
/sound = 0
</values>

<values>
/keep_rotating_for_n_trials = 0
/rotationcount = 0
/beep = 5
</values>

<list targetduration>
/items = (100, 200, 300, 400, 500, 600, 700, 800, 900)
/replace = false
</list>

<list targetdurationh>
/items = (100, 400, 700)
/poolsize = 42
/replace = false
</list>

<list targetdurations>
/items = (100, 400, 700)
/poolsize = 42
/replace = false
</list>

<list libetframes>
/items = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24)
/selectionmode = sequence
/poolsize = 24
</list>

*******************************************************************************************************************
*******************************************************************************************************************
STIMULI
*******************************************************************************************************************
*******************************************************************************************************************

**********
Clock
**********

<item libetclock>
/1 = "Libet_clock1.jpg"
/2 = "Libet_clock2.jpg"
/3 = "Libet_clock3.jpg"
/4 = "Libet_clock4.jpg"
/5 = "Libet_clock5.jpg"
/6 = "Libet_clock6.jpg"
/7 = "Libet_clock7.jpg"
/8 = "Libet_clock8.jpg"
/9 = "Libet_clock9.jpg"
/10 = "Libet_clock10.jpg"
/11 = "Libet_clock11.jpg"
/12 = "Libet_clock12.jpg"
/13 = "Libet_clock13.jpg"
/14 = "Libet_clock14.jpg"
/15 = "Libet_clock15.jpg"
/16 = "Libet_clock16.jpg"
/17 = "Libet_clock17.jpg"
/18 = "Libet_clock18.jpg"
/19 = "Libet_clock19.jpg"
/20 = "Libet_clock20.jpg"
/21 = "Libet_clock21.jpg"
/22 = "Libet_clock22.jpg"
/23 = "Libet_clock23.jpg"
/24 = "Libet_clock24.jpg"
</item>

<picture libetclock>
/items = libetclock
/position = (50, 50)
/select = list.libetframes.currentvalue
/erase = false
</picture>

**********
Sounds
**********

<item possounds>
/1 = "FemCheer.wav"
/2 = "FemLaugh.wav"
/3 = "MaleCheer.wav"
/4 = "MaleLaugh.wav"
</item>

<sound possounds>
/items = possounds
/playthrough = true
</sound>

**********
Extra stimuli:
**********

<text cross>
/items = ("+")
/color = (0,0,0)
</text>

*******************************************************************************************************************
*******************************************************************************************************************
TRIALS
*******************************************************************************************************************
*******************************************************************************************************************
<values>
/c1item = 1
/c2item = 1
/c3item = 1
/c4item = 1
/c5item = 1
/delay = 4
</values>

<text clock1>
/ items = libetclock
/ select = values.c1item
/ erase = false
</text>

<text clock2>
/ items = libetclock
/ select = values.c2item
/ erase = false
</text>

<text clock3>
/ items = libetclock
/ select = values.c3item
/ erase = false
</text>

<text clock4>
/ items = libetclock
/ select = values.c4item
/ erase = false
</text>

<text clock5>
/ items = libetclock
/ select = values.c5item
/ erase = false
</text>

*********
Libet trials - Positive sounds
*********
<trial positive>
/ontrialbegin = [{values.currentlistnumber = list.libetframes.nextvalue}]
/ontrialbegin = [values.keep_rotating_for_n_trials = round(rand(20,50)); values.rotationcount = 0]
/stimulustimes = [1 = cross; 500 = libetclock]
/correctresponse = (" ")
/pretrialpause = 500
/trialduration = 600
/branch = [trial.LibetP]
/recorddata = false
</trial>

<trial LibetP>
/ontrialbegin = [{values.currentlistnumber = list.libetframes.nextvalue}]
/ontrialbegin = [values.c1item = list.libetframes.nextindex]
/stimulustimes = [1 = libetclock]
/correctresponse = (57)
/trialduration = 50
/branch = [if (trial.LibetP.response == 57) {trial.rotateP} else {trial.LibetP}]
/recorddata = false
/ontrialend = [values.sound = sound.possounds.currentitem]
/ontrialend = [values.onset = list.libetframes.currentvalue]
</trial>

<trial RotateP>
/ontrialbegin = [{values.currentlistnumber = list.libetframes.nextvalue}]
/ontrialbegin = [values.rotationcount += 1; values.c1item = list.libetframes.nextindex]
/stimulustimes = [1 = libetclock]
/validresponse = (0)
/trialduration = 50
/ontrialend = [trial.rotateP.resetstimulusframes(0)]
/branch = [if (values.rotationcount >= values.keep_rotating_for_n_trials) {trial.AudioP} else {trial.rotateP}]
/recorddata = false
</trial>

<trial AudioP>
/ ontrialbegin = [values.c1item = list.libetframes.nextindex; values.c2item = list.libetframes.nextindex; values.c3item = list.libetframes.nextindex; values.c4item = list.libetframes.nextindex; values.c5item = list.libetframes.nextindex; values.c5item = list.libetframes.nextindex; ]
/ ontrialend = [values.rotationcount += 6]
/ stimulustimes = [0 = possounds, clock1; 50 = clock2; 100 = clock3; 150 = clock4; 200 = clock5]
/ validresponse = (0)
/ trialduration = 250
/ branch = [if (values.rotationcount < values.keep_rotating_for_n_trials) trial.rotateP else trial.postlibetP]
</trial>

<trial postLibetP>
/stimulustimes = [1 = cross]
/trialduration = 500
/branch = [surveypage.tep]
/recorddata = false
</trial>

Many thanks in advance,
Josh