MAP

function varargout = subjGUI_MT(varargin)

% Begin initialization code - DO NOT EDIT

gui_Singleton = 1;

gui_State = struct('gui_Name',       mfilename, ...

    'gui_Singleton',  gui_Singleton, ...

    'gui_OpeningFcn', @subjGUI_MT_OpeningFcn, ...

    'gui_OutputFcn',  @subjGUI_MT_OutputFcn, ...

    'gui_LayoutFcn',  [] , ...

    'gui_Callback',   []);

if nargin && isstr(varargin{1})

    gui_State.gui_Callback = str2func(varargin{1});

end

if nargout

    [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});

else

    gui_mainfcn(gui_State, varargin{:});

end

% End initialization code - DO NOT EDIT

% --- Executes just before subjGUI_MT is made visible.

function subjGUI_MT_OpeningFcn(hObject, eventdata, handles, varargin)

% Choose default command line output for subjGUI_MT

handles.output = hObject;

initializeGUI(handles)

guidata(hObject, handles);

function varargout = subjGUI_MT_OutputFcn(hObject, eventdata, handles)

% Get default command line output from handles structure

varargout{1} = handles.output;

% -----------------------------------------------------initializeGUI

function initializeGUI(handles)

global experiment

global subjectGUIHandles expGUIhandles

addpath (['..' filesep 'MAP'], ['..' filesep 'utilities'], ...

    ['..' filesep 'parameterStore'],  ['..' filesep 'wavFileStore'],...

    ['..' filesep 'testPrograms'])

dbstop if error

% subjectGUI size and location         % [left bottom width height]

scrnsize=get(0,'screensize');

set(0, 'units','pixels')

switch experiment.ear

    % use default size unless...

    case {'MAPmodel',  'MAPmodelMultich', 'MAPmodelSingleCh', ...

            'statsModelLogistic','statsModelRareEvent'}

        % 	subjectGUI not needed for modelling so minimize subject GUI

        set(gcf, 'units','pixels')

        y=[0*scrnsize(3) 0.8*scrnsize(4) 0.1*scrnsize(3) 0.2*scrnsize(4)];

        set(gcf,'position',y, 'color',[.871 .961 .996])

    case 'MAPmodelListen',

        % 	subjectGUI is needed for display purposes. Make it large

        set(gcf, 'units','pixels')

        y=[.665*scrnsize(3) 0.02*scrnsize(4) ...

            0.33*scrnsize(3) 0.5*scrnsize(4)]; % alongside

        set(gcf,'position',y, 'color',[.871 .961 .996])

end

switch experiment.ear

    case{'left', 'right','diotic', 'dichoticLeft','dichoticRight'}

        % Look to see if the button box exists and, if so, initialise it

        buttonBoxIntitialize		% harmless if no button box attached

end

% clear display of previous mean values. This is a new measurement series

axes(expGUIhandles.axes4), cla

reset (expGUIhandles.axes4)

% handles needed in non-callback routines below

subjectGUIHandles=handles;

% start immediately

startNewExperiment(handles, expGUIhandles)

% This is the end of the experiment. Exit here and return to ExpGUI.

% ----------------------------------------------------- startNewExperiment

function startNewExperiment(handles, expGUIhandles)

% An experiment consists of a series of 'runs'.

% Resets all relevant variables at the beginning of a new experiment.

global experiment stimulusParameters betweenRuns

% 'start new experiment' button is the only valid action now

experiment.status='waitingForStart';

switch experiment.threshEstMethod

    % add appropriate labels to subject GUI buttons

    case {'2I2AFC++', '2I2AFC+++'}

        set(handles.pushbutton3,'string','')

        set(handles.pushbutton2,'string','2')

        set(handles.pushbutton1,'string','1')

        set(handles.pushbutton0,'string','0')

    case {'MaxLikelihood', 'oneIntervalUpDown'}

        if stimulusParameters.includeCue

            set(handles.pushbutton3,'string','')

            set(handles.pushbutton2,'string','2')

            set(handles.pushbutton1,'string','1')

            set(handles.pushbutton0,'string','0')

        else

            set(handles.pushbutton3,'string','')

            set(handles.pushbutton2,'string','YES')

            set(handles.pushbutton1,'string','NO')

            set(handles.pushbutton0,'string','')

        end

end

switch experiment.paradigm

    case 'discomfort'

        set(handles.pushbutton3,'string','')

        set(handles.pushbutton2,'string','uncomfortable')

        set(handles.pushbutton1,'string','loud')

        set(handles.pushbutton0,'string','comfortable')

        experiment.allowCatchTrials=0;

end

% experiment.subjGUIfontSize is set on expGUI

set(handles.pushbutton3,'FontSize',experiment.subjGUIfontSize)

set(handles.pushbutton2,'FontSize',experiment.subjGUIfontSize)

set(handles.pushbutton1,'FontSize',experiment.subjGUIfontSize)

set(handles.pushbutton0,'FontSize',experiment.subjGUIfontSize)

set(handles.pushbuttoNotSure,'FontSize',experiment.subjGUIfontSize)

set(handles.pushbuttonGO,'FontSize',experiment.subjGUIfontSize)

set(handles.textMSG,'FontSize',experiment.subjGUIfontSize)

set(handles.pushbutton19,'visible','off') % unused button

% start command window summary of progress

fprintf(' \n ----------- NEW MEASUREMENTS\n')

disp(['paradigm:   ' experiment.paradigm])

cla(expGUIhandles.axes1)

cla(expGUIhandles.axes2)

cla(expGUIhandles.axes4)

cla(expGUIhandles.axes5)

experiment.stop=0;              % status of 'stop' button

experiment.pleaseRepeat=0;      % status of 'repeat' button

experiment.buttonBoxStatus='not busy';

% date and time and replace ':' with '_'

date=datestr(now);idx=findstr(':',date);date(idx)='_';

experiment.date=date;

timeNow=clock; betweenRuns.timeNow= timeNow;

experiment.timeAtStart=[num2str(timeNow(4)) ':' num2str(timeNow(5))];

experiment.minElapsed=0;

% unpack catch trial rates. The rate declines from the start rate

%  to the base rate using a time constant.

stimulusParameters.catchTrialRate=stimulusParameters.catchTrialRates(1);

stimulusParameters.catchTrialBaseRate=...

    stimulusParameters.catchTrialRates(2);

stimulusParameters.catchTrialTimeConstant=...

    stimulusParameters.catchTrialRates(3);

if stimulusParameters.catchTrialBaseRate==0

    stimulusParameters.catchTrialRate=0;

end

% for human measurements only, identify the start catch trial rate

switch experiment.ear

    case{'left', 'right','diotic', 'dichoticLeft','dichoticRight'}

        fprintf('stimulusParameters.catchTrialRate= %6.3f\n', ...

            stimulusParameters.catchTrialRate)

end

% Reset betweenRuns parameters. this occurs only at experiment start

% withinRuns values are reset in 'startNewRun'

% this approach creates a more readable structure summary printout.

betweenRuns.thresholds=[];

betweenRuns.thresholds_mean=[];

betweenRuns.thresholds_median=[];

betweenRuns.forceThresholds=[];

betweenRuns.observationCount=[];

betweenRuns.catchTrials=[];

betweenRuns.timesOfFirstReversals=[];

betweenRuns.bestThresholdTracks=[];

betweenRuns.levelTracks=[];

betweenRuns.responseTracks=[];

betweenRuns.slopeKTracks=[];

betweenRuns.gainTracks=[];

betweenRuns.VminTracks=[];

betweenRuns.bestGain=[];

betweenRuns.bestVMin=[];

betweenRuns.bestPaMin=[];

betweenRuns.bestLogisticM=[];

betweenRuns.bestLogisticK=[];

betweenRuns.resets=0;

betweenRuns.runNumber=0;

% Up to two parameters can be changed between runs

% Find the variable parameters and randomize them

% e.g. 'variableList1 = stimulusParameters.targetFrequency;'

eval(['variableList1=stimulusParameters.' betweenRuns.variableName1 ';']);

eval(['variableList2=stimulusParameters.' betweenRuns.variableName2 ';']);

nVar1=length(variableList1);

nVar2=length(variableList2);

% Create two sequence vectors to represent the sequence of var1 and var2

% values. 'var1' changes most rapidly.

switch betweenRuns.randomizeSequence

    % {'randomize within blocks', 'fixed sequence',...

    %  'randomize across blocks'}

    case 'fixed sequence'

        var1Sequence=repmat(betweenRuns.variableList1, 1,nVar2);

        var2Sequence=reshape(repmat(betweenRuns.variableList2, ...

            nVar1,1),1,nVar1*nVar2);

    case 'randomize within blocks'

        % the blocks are not randomized

        var1Sequence=betweenRuns.variableList1;

        ranNums=rand(1, length(var1Sequence)); [x idx]=sort(ranNums);

        var1Sequence=var1Sequence(idx);

        betweenRuns.variableList1=variableList1(idx);

        var1Sequence=repmat(var1Sequence, 1,nVar2);

        var2Sequence=reshape(repmat(betweenRuns.variableList2, nVar1,1)...

            ,1,nVar1*nVar2);

    case 'randomize across blocks'

        var1Sequence=repmat(betweenRuns.variableList1, 1,nVar2);

        var2Sequence=reshape(repmat(betweenRuns.variableList2, nVar1,1),...

            1,nVar1*nVar2);

        ranNums=rand(1, nVar1*nVar2);

        [x idx]=sort(ranNums);

        var1Sequence=var1Sequence(idx);

        var2Sequence=var2Sequence(idx);

        % there should be one start value for every combination

        %  of var1/ var2. In principle this allows these values to be

        % programmed. Not currently in use.

        stimulusParameters.WRVstartValues=...

            stimulusParameters.WRVstartValues(idx);

end

betweenRuns.var1Sequence=var1Sequence;

betweenRuns.var2Sequence=var2Sequence;

% caught out vector needs to be linked to the length of the whole sequence

betweenRuns.caughtOut=zeros(1,length(var1Sequence));

disp('planned sequence:')

if min(var1Sequence)>1

    % use decidaml places only if necessary

    disp([betweenRuns.variableName1 ': ' num2str(var1Sequence,'%6.0f')  ])

else

    disp([betweenRuns.variableName1 ': ' num2str(var1Sequence,'%8.3f')  ])

end

if min(var1Sequence)>1

    disp([betweenRuns.variableName2 ': ' num2str(var2Sequence,'%6.0f') ])

else

    disp([betweenRuns.variableName2 ': ' num2str(var2Sequence,'%8.3f') ])

end

fprintf('\nvariable1 \t  variable2\t  \n')

fprintf('%s \t  %s\t  Threshold  \n',betweenRuns.variableName1,...

    betweenRuns.variableName2)

% Light up 'GO' on subjGUI and advise.

set(handles.editdigitInput,'visible','off')

switch experiment.ear

    case {'statsModelLogistic', 'statsModelRareEvent',...

            'MAPmodel',  'MAPmodelMultiCh','MAPmodelSingleCh'}

        % no changes required if model used

    otherwise

        set(handles.pushbuttonGO,'backgroundcolor','y')

        set(handles.pushbuttonGO,'visible','on')

        set(handles.frame1,'visible','off')

        set(handles.textMSG,'backgroundcolor', 'w')

        msg=[{'Ready to start new Experiment'}, {' '}, {'Please, click on the GO button'}];

        set(handles.textMSG,'string', msg)

        set(handles.pushbuttoNotSure,'visible','off')

        set(handles.pushbuttonWrongButton,'visible','off')

        set(handles.pushbutton3,'visible','off')

        set(handles.pushbutton2,'visible','off')

        set(handles.pushbutton1,'visible','off')

        set(handles.pushbutton0,'visible','off')

        pause(.1) % to allow display to be drawn

end

% Selecting the 'GO' button is the only valid operation action now

experiment.status='waitingForGO'; 	% i.e. waiting for new run

% control is now either manual, model (MAP) or randomization

switch experiment.ear

    case {'MAPmodel','MAPmodelMultiCh','MAPmodelSingleCh','MAPmodelListen'}                                     % MAP model is now the subject

        stimulusParameters.calibrationdB=0;             % Pascals required!

        MAPmodelRunsGUI(handles)

        % model is now the subject

    case  {'statsModelLogistic', 'statsModelRareEvent'}

        % no catch trials for the statistical model

        stimulusParameters.catchTrialBaseRate=0;

        stimulusParameters.catchTrialRate=0;

        statsModelRunsGUI(handles)

    otherwise

        %manual operation; wait for user to click on 'GO'

end

% Experiment complete (after MAP or randomization)

% return to  'initializeGUI' and then back to expGUI

% Manual control finds its own way home. Program control assumed when

% the user hits the GO button

% -----------------------------------------------------------------   startNewRun

function startNewRun(handles)

% There are many ways to arrive here.

%  Under manual control this is achieved by hitting the GO button

%   either via the button box or a mouse click

%  MAP and randomization methods call this too

global experiment stimulusParameters betweenRuns withinRuns expGUIhandles

global LevittControl rareEvent errormsg

figure(handles.figure1) % guarantee subject GUI visibility

% ignore call if program is not ready

if ~strcmp(experiment.status,'waitingForGO'), return, end

set(handles.pushbuttonGO,'visible','off')

% append message to expGUI message box to alert experimenter that the user

% is active

addToMsg('Starting new trial',0)

cla(expGUIhandles.axes1),  title(''); % stimulus

cla(expGUIhandles.axes2),  title(''); % WRV track

drawnow

betweenRuns.runNumber=betweenRuns.runNumber + 1;

withinRuns.trialNumber=1;

withinRuns.variableValue=...

    stimulusParameters.WRVstartValues(betweenRuns.runNumber);

% add random jitter to start level

if ~experiment.singleShot

    % SS or single shot allows the user to precisely set the WRV

    withinRuns.variableValue=withinRuns.variableValue +...

        (rand-0.5)*stimulusParameters.jitterStartdB;

end

withinRuns.peaks=[];

withinRuns.troughs=[];

withinRuns.levelList=[];

withinRuns.meanEstTrack=[];

withinRuns.bestSlopeK=[];

withinRuns.bestGain=[];

withinRuns.bestVMin=[];

withinRuns.forceThreshold=NaN;

withinRuns.responseList=[];

withinRuns.caughtOut=0;

withinRuns.wrongButton=0;

withinRuns.catchTrialCount=0;

withinRuns.thresholdEstimateTrack=[];

withinRuns.beginningOfPhase2=0;

withinRuns.nowInPhase2=0;

withinRuns.thisIsRepeatTrial=0;

rareEvent.Euclid=NaN;

rareEvent.bestGain=NaN;

rareEvent.bestVMin=NaN;

rareEvent.thresholddB=0;

rareEvent.bestPaMindB=NaN;

rareEvent.predictionLevels=[];

rareEvent.predictionsRE=[];

LevittControl.sequence=[];

% on-screen count of number of runs still to complete

trialsToGo=length(betweenRuns.var1Sequence)-betweenRuns.runNumber;

set(handles.toGoCounter,'string', trialsToGo);

switch experiment.threshEstMethod

    case {'2I2AFC++', '2I2AFC+++'}

        % For 2I2AFC the buttons need to be on the screen ab initio

        Levitt2      % inititalize Levitt2 procedure

end

switch experiment.ear

    case{'left', 'right','diotic', 'dichoticLeft','dichoticRight'}

        % allow subject time to recover from 'go' press

        pause(experiment.clickToStimulusPause)

end

errormsg=nextStimulus(handles);				% get the show on the road

% terminate if there is any kind of problem

if ~isempty(errormsg)

    % e.g. limits exceeded, clipping

    disp(errormsg)

    runCompleted(handles)

    return

end

% return route is variable (see intro to this function)

% -----------------------------------------------------buttonBox_callback

function buttonBox_callback(obj, info)

% deals with a button press on the button box.

global experiment

global serobj

global subjectGUIHandles

% do not accept callback if one is already in process

if strcmp(experiment.buttonBoxStatus,'busy')

    disp(' ignored button press')

    return % to quiescent state

end

experiment.buttonBoxStatus='busy';

% identify the code of the button pressed

buttonPressedNo = fscanf(serobj,'%c',1);

% This is the map from the button to the Cedrus codes

switch experiment.buttonBoxType

    case 'horizontal'

        pbGo='7'; 		pb0='1';

        pb1='2';		pb2='3';

        pbRepeat='4';	pbWrong='6';	pbBlank='5';

    case 'square'

        pbGo='7';		pb0='1';

        pb1='3';		pb2='4';

        pbRepeat='8';	pbWrong='6';	pbBlank='5';

end

% decide what to do

switch experiment.status

    case {'presentingStimulus', 'waitingForStart', 'trialcompleted', ...

            'endOfExperiment'}

        disp(' ignored button press')

    case 'waitingForGO'

        % i.e. waiting for new run

        if strcmp(buttonPressedNo,pbGo)			% only GO button  accepted

            startNewRun(subjectGUIHandles)

        else

            disp(' ignored button press')

        end

    case 'waitingForResponse'

        % response to stimuli

        switch buttonPressedNo

            case pb0						% button 0 (top left)

                switch experiment.threshEstMethod

                    case {'2I2AFC++', '2I2AFC+++'}

                        disp(' ignored button press')

                    otherwise

                        set(subjectGUIHandles.pushbutton0,...

                            'backgroundcolor','r')

                        pause(.1)

                        set(subjectGUIHandles.pushbutton0,...

                            'backgroundcolor',get(0,...

                            'defaultUicontrolBackgroundColor'))

                        userSelects0or1(subjectGUIHandles)

                end

            case pb1						% button 1 (bottom left)

                switch experiment.threshEstMethod

                    case {'2I2AFC++', '2I2AFC+++'}

                        userSelects0or1(subjectGUIHandles)

                    otherwise

                        set(subjectGUIHandles.pushbutton1,...

                            'backgroundcolor','r')

                        pause(.1)

                        set(subjectGUIHandles.pushbutton1,...

                            'backgroundcolor',get(0,...

                            'defaultUicontrolBackgroundColor'))

                        userSelects0or1(subjectGUIHandles)

                end

            case pb2						% button 2 (bottom right)

                switch experiment.threshEstMethod

                    case {'2I2AFC++', '2I2AFC+++'}

                        userSelects2 (subjectGUIHandles)

                    otherwise

                        set(subjectGUIHandles.pushbutton2,...

                            'backgroundcolor','r')

                        pause(.1)

                        set(subjectGUIHandles.pushbutton2,...

                            'backgroundcolor',get(0,...

                            'defaultUicontrolBackgroundColor'))

                        userSelects2 (subjectGUIHandles)

                end

            case pbRepeat                   % extreme right button

                switch experiment.threshEstMethod

                    case {'2I2AFC++', '2I2AFC+++'}

                        disp(' ignored button press')

                    otherwise

                        set(subjectGUIHandles.pushbuttoNotSure,...

                            'backgroundcolor','r')

                        pause(.1)

                        set(subjectGUIHandles.pushbuttoNotSure,...

                            'backgroundcolor',get(0,...

                            'defaultUicontrolBackgroundColor'))

                        userSelectsPleaseRepeat (subjectGUIHandles)

                end

            case {pbWrong, pbBlank}

                disp(' ignored button press')

            otherwise						% unrecognised button

                disp('ignored button press')

        end									% end (button press number)

    otherwise

        disp('ignored button press')

end											% experiment status

% button box remains 'busy' until after the stimulus has been presented

experiment.buttonBoxStatus='not busy';

% -------------------------------------------------- pushbuttonGO_Callback

function pushbuttonGO_Callback(hObject, eventdata, handles)

% This is a mouse click path

% GO function is also called directly from button box

%  and from MAP model and stats model

set(handles.pushbuttonGO,'visible','off')

startNewRun(handles)

% ---------------------------------------------------pushbutton0_Callback

function pushbutton0_Callback(hObject, eventdata, handles)

global experiment

% This is a mouse click path

% ignore 0 button if 2I2AFC used

if findstr(experiment.threshEstMethod,'2I2AFC')

    return  % to quiescent state

end

% userDoesNotHearTarget(handles)		% only possible interpretation

userDecides(handles, false)

% -------------------------------------------------- pushbutton1_Callback

function pushbutton1_Callback(hObject, eventdata, handles)

userSelects0or1(handles)				% also called from buttonBox

% ---------------------------------------------------pushbutton2_Callback

function pushbutton2_Callback(hObject, eventdata, handles)

userSelects2(handles)					% also called from buttonBox

% --------------------------------------------- pushbuttoNotSure_Callback

function pushbuttoNotSure_Callback(hObject, eventdata, handles)

userSelectsPleaseRepeat(handles)		% also called from buttonBox

% -------------------------------------------------- pushbutton3_Callback

function pushbutton3_Callback(hObject, eventdata, handles)

% ------------------------------------------------- pushbutton19_Callback

function pushbutton19_Callback(hObject, eventdata, handles)

% should be invisible (ignore)

% --------------------------------------- pushbuttonWrongButton_Callback

function pushbuttonWrongButton_Callback(hObject, eventdata, handles)

userSelectsWrongButton(handles)

% --------------------------------------- editdigitInput_Callback

function editdigitInput_Callback(hObject, eventdata, handles)

userSelects0or1(handles)				% after digit string input

% ----------------------------------------------------- userSelects0or1

function userSelects0or1(handles)

global experiment withinRuns

switch experiment.threshEstMethod

    case {'2I2AFC++', '2I2AFC+++'}

        switch withinRuns.stimulusOrder

            case 'targetFirst';

                %                 userHearsTarget(handles)

                userDecides(handles, true)

            otherwise

                %                 userDoesNotHearTarget(handles)

                userDecides(handles, false)

        end

    otherwise

        % single interval

        % 0 or 1 are treated as equivalent (i.e. target is not heard)

        userDecides(handles, false)

end

% return to pushButton1 callback

% ----------------------------------------------------- userSelects2

function userSelects2(handles)

global experiment withinRuns

switch experiment.threshEstMethod

    case {'2I2AFC++', '2I2AFC+++'}

        switch withinRuns.stimulusOrder

            case 'targetSecond';

                %                 userDoesNotHearTarget(handles)

                userDecides(handles, true)

            otherwise

                %                 userHearsTarget(handles)

                userDecides(handles, false)

        end

    otherwise

        % single interval (2 targets heard)

        userDecides(handles, true)

end

% return to pushButton2 callback

% ----------------------------------------------------- ---- userDecides

function userDecides(handles, saidYes)

global experiment stimulusParameters betweenRuns withinRuns

global rareEvent logistic psy levelsBinVector errormsg

if experiment.singleShot

    return  % not clear why this should be here

end

% ignore click if not 'waitingForResponse'

if ~strcmp(experiment.status,'waitingForResponse')

    disp('ignored click')

    return % to userSelects

end

% speech reception threshold

if strcmp(stimulusParameters.targetType,'digitStrings')

    % read triple digits from userGUI

    digitsInput=get(handles.editdigitInput,'string');

    % must be three digits

    if ~(length(digitsInput)==3)

        addToMsg(['error message: Wrong no of digits'], 0, 1)

        set(handles.textMSG,'string', 'Wrong no of digits', ...

            'BackgroundColor','r', 'ForegroundColor', 'w')

        set(handles.editdigitInput,'string','')

        return

    end

    % obtain correct answer from file name

    x=stimulusParameters.digitString;

    idx=find(x=='O'); x(idx)='0'; % replace 'oh' with zero

    disp([x '   ' digitsInput])

    if x==digitsInput

        saidYes=1;  % i.e. correct response

    else

        saidYes=0;  % i.e  wrong response

    end

    set(handles.editdigitInput,'string','')

    set(handles.editdigitInput,'visible','off')

    pause(0.1)

end

% no button presses accepted while processing

experiment.status='processingResponse';

% catch trials. Restart trial if caught

if withinRuns.catchTrial

    if saidYes

        disp('catch trial - caught out')

        withinRuns.caughtOut=withinRuns.caughtOut+1;

        % special: estimate caught out rate by allowing the trial

        %  to continue after catch

        if stimulusParameters.catchTrialBaseRate==0.5

            %  To use this facility, set the catchTrialRate and the

            %   catchTrialBaseRate both to 0.5

            %    update false positive rate

            betweenRuns.caughtOut(betweenRuns.runNumber)=...

                withinRuns.caughtOut;

            plotProgressThisTrial(handles)

            nextStimulus(handles);

            return

        end

        % Punishment: caught out restarts the trial

        set(handles.frame1,'backgroundColor','r')

        set(handles.pushbuttonGO, ...

            'visible','on', 'backgroundcolor','y') % and go again

        msg=[{'Start again: catch trial error'}, {' '},...

            {'Please,click on the GO button'}];

        set(handles.textMSG,'string',msg)

        [y,fs]=wavread('ding.wav');

        if ispc

            wavplay(y/100,fs)

        else

            sound(y/100,fs)

        end

        % raise catch trial rate temporarily.

        %  this is normally reduced on each new trial (see GO)

        stimulusParameters.catchTrialRate=...

            stimulusParameters.catchTrialRate+0.1;

        if stimulusParameters.catchTrialRate>0.5

            stimulusParameters.catchTrialRate=0.5;

        end

        fprintf('stimulusParameters.catchTrialRate= %6.3f\n', ...

            stimulusParameters.catchTrialRate)

        betweenRuns.caughtOut(betweenRuns.runNumber)=...

            1+betweenRuns.caughtOut(betweenRuns.runNumber);

        betweenRuns.runNumber=betweenRuns.runNumber-1;

        experiment.status='waitingForGO';

        return % unwind and wait for button press

    else % (said No)

        % user claims not to have heard target.

        % This is good as it was not present.

        % So, repeat the stimulus (possibly with target)

        %  and behave as if the last trial did not occur

        errormsg=nextStimulus(handles);

        % terminate if there is any kind of problem

        if ~isempty(errormsg)

            % e.g. limits exceeded, clipping

            disp(['Error nextStimulus: ' errormsg])

            runCompleted(handles)

            return

        end

        return      % no further action - next trial

    end

end     % of catch trial

% Real target: analyse the response, make tracks and define next stim.

% Define response and update response list

if saidYes

    % target was heard, so response=1;

    withinRuns.responseList=[withinRuns.responseList 1];	% 'heard it!'

else

    % target was not hear heard, so response=0;

    withinRuns.responseList=[withinRuns.responseList 0];

end

withinRuns.levelList=[withinRuns.levelList withinRuns.variableValue];

trialNumber=length(withinRuns.responseList);

% keep track of peaks and troughs;

% identify direction of change during initial period

if saidYes

    % default step size before first reversal

    WRVinitialStep=-stimulusParameters.WRVinitialStep;

    WRVsmallStep=-stimulusParameters.WRVsmallStep;

    % if the previous direction was 'less difficult', this must be a peak

    if strcmp(withinRuns.direction,'less difficult') ...

            && length(withinRuns.levelList)>1

        withinRuns.peaks=[withinRuns.peaks withinRuns.variableValue];

    end

    withinRuns.direction='more difficult';

else

    % said 'no'

    % default step size before first reversal

    WRVinitialStep=stimulusParameters.WRVinitialStep;

    WRVsmallStep=stimulusParameters.WRVsmallStep;

    % if the previous direction was 'up', this must be a peak

    if strcmp(withinRuns.direction,'more difficult') ...

            && length(withinRuns.levelList)>1

        withinRuns.troughs=[withinRuns.troughs withinRuns.variableValue];

    end

    withinRuns.direction='less difficult';

end

% phase 2 is all the levels after and incuding the first reversal

%  plus the level before that

% Look for the end of phase 1

if ~withinRuns.nowInPhase2 && length(withinRuns.peaks)+ ...

        length(withinRuns.troughs)>0

    % define phase 2

    withinRuns.beginningOfPhase2=trialNumber-1;

    withinRuns.nowInPhase2=1;

    WRVsmallStep=WRVinitialStep/2;

end

if withinRuns.nowInPhase2

    % keep a record of all levels and responses in phase 2 only

    withinRuns.levelsPhaseTwo=...

        withinRuns.levelList(withinRuns.beginningOfPhase2:end);

    withinRuns.responsesPhaseTwo=...

        withinRuns.responseList(withinRuns.beginningOfPhase2:end);

else

    withinRuns.levelsPhaseTwo=[];

end

% get (or substitute) threshold estimate

switch experiment.threshEstMethod

    case {'2I2AFC++', '2I2AFC+++'}

        % for plotting psychometric function only

        if withinRuns.beginningOfPhase2>0

            [psy, levelsBinVector, logistic, rareEvent]= ...

                bestFitPsychometicFunctions...

                (withinRuns.levelsPhaseTwo,  withinRuns.responsesPhaseTwo);

        end

        if ~isempty(withinRuns.peaks) && ~isempty(withinRuns.troughs)

            thresholdEstimate= ...

                mean([mean(withinRuns.peaks) mean(withinRuns.troughs)]);

        else

            thresholdEstimate=NaN;

        end

    otherwise

        % single interval methods

        try

            % using the s trial after the first reversal

            [psy, levelsBinVector, logistic, rareEvent]= ...

                bestFitPsychometicFunctions(withinRuns.levelsPhaseTwo,...

                withinRuns.responsesPhaseTwo);

        catch

            logistic.bestThreshold=NaN;

        end

end

if withinRuns.nowInPhase2

    % save tracks of threshold estimates for plotting andprinting

    switch experiment.functionEstMethod

        case {'logisticLS', 'logisticML'}

            if withinRuns.nowInPhase2

                withinRuns.meanEstTrack=...

                    [withinRuns.meanEstTrack ...

                    mean(withinRuns.levelsPhaseTwo)];

                withinRuns.thresholdEstimateTrack=...

                    [withinRuns.thresholdEstimateTrack ...

                    logistic.bestThreshold];

            end

        case 'rareEvent'

            withinRuns.meanEstTrack=...

                [withinRuns.meanEstTrack rareEvent.thresholddB];

            withinRuns.thresholdEstimateTrack=...

                [withinRuns.thresholdEstimateTrack logistic.bestThreshold];

        case 'peaksAndTroughs'

            withinRuns.meanEstTrack=...

                [withinRuns.meanEstTrack thresholdEstimate];

            withinRuns.thresholdEstimateTrack=...

                [withinRuns.thresholdEstimateTrack thresholdEstimate];

    end

end

% special discomfort condition

% run is completed when subject hits '2' button

switch experiment.paradigm

    case 'discomfort'

        if saidYes

            runCompleted(handles)

            return

        end

end

% choose the next level for the stimulus

switch experiment.threshEstMethod

    case {'2I2AFC++', '2I2AFC+++'}

        if saidYes

            [WRVinitialStep, msg]=Levitt2('hit', withinRuns.variableValue);

        else

            [WRVinitialStep, msg]=Levitt2('miss',withinRuns.variableValue);

        end

        % empty message means continue as normal

        if ~isempty(msg)

            runCompleted(handles)

            return

        end

        newWRVvalue=withinRuns.variableValue-WRVinitialStep;

    case {'MaxLikelihood', 'oneIntervalUpDown'}

        % run completed by virtue of number of trials

        % or restart because listener is in trouble

        if length(withinRuns.levelsPhaseTwo)== experiment.maxTrials

            % Use bonomial test to decide if there is an imbalance in the

            % number of 'yes'es and 'no's

            yesCount=sum(withinRuns.responseList);

            noCount=length(withinRuns.responseList)-yesCount;

            z=abs(yesCount-noCount)/(yesCount+noCount)^0.5;

            if z>1.96

                betweenRuns.resets=betweenRuns.resets+1;

                disp([ 'reset / z= ' num2str( z)  ...

                    '   Nresets= ' num2str( betweenRuns.resets) ] )

                withinRuns.peaks=[];

                withinRuns.troughs=[];

                withinRuns.levelList=withinRuns.levelList(end);

                withinRuns.meanEstTrack=withinRuns.meanEstTrack(end);

                withinRuns.forceThreshold=NaN;

                withinRuns.responseList=withinRuns.responseList(end);

                withinRuns.beginningOfPhase2=0;

                withinRuns.nowInPhase2=0;

                withinRuns.thresholdEstimateTrack=...

                    withinRuns.thresholdEstimateTrack(end);

            else

                runCompleted(handles)

                return

            end

        end

        % set new value for WRV

        if withinRuns.nowInPhase2

            % phase 2

            currentMeanEst=withinRuns.thresholdEstimateTrack(end);

            switch experiment.threshEstMethod

                case 'MaxLikelihood'

                    newWRVvalue=currentMeanEst;

                case {'oneIntervalUpDown'}

                    newWRVvalue=withinRuns.variableValue+WRVsmallStep;

            end

        else

            % phase 1

            if withinRuns.variableValue+2*WRVinitialStep>...

                    stimulusParameters.WRVlimits(2)

                % use smaller steps when close to maximum

                WRVinitialStep=WRVinitialStep/2;

            end

            newWRVvalue=withinRuns.variableValue+WRVinitialStep;

        end

    otherwise

        error(  'assessment method not recognised')

end

switch experiment.paradigm

    % prevent unrealistic gap durations 'gapDetection' tasks.

    % Note that the gap begins when the ramp ends not when stimulus ends

    case 'gapDetection'

        if newWRVvalue<-2*stimulusParameters.rampDuration

            newWRVvalue=-2*stimulusParameters.rampDuration;

            addToMsg('gap duration fixed at - 2 * ramp!',1, 1)

        end

end

withinRuns.variableValue=newWRVvalue;

withinRuns.trialNumber=withinRuns.trialNumber+1;

% Trial continues

plotProgressThisTrial(handles)

% next stimulus and so the cycle continues

errormsg=nextStimulus(handles);

% after the stimulus is presented, control returns here and the system

% waits for user action.

% terminate if there is any kind of problem

if ~isempty(errormsg)

    % e.g. limits exceeded, clipping

    disp(['Error nextStimulus: ' errormsg])

    runCompleted(handles)

    return

end

% ------------------------------------------------ userSelectsPleaseRepeat

function userSelectsPleaseRepeat(handles)

global experiment withinRuns

% ignore click if not 'waitingForResponse'

if ~strcmp(experiment.status,'waitingForResponse')

    disp('ignored click')

    return

end

% Take no action other than to make a

%  tally of repeat requests

experiment.pleaseRepeat=experiment.pleaseRepeat+1;

withinRuns.thisIsRepeatTrial=1;

nextStimulus(handles);

% ------------------------------------------------ userSelectsWrongButton

function userSelectsWrongButton(handles)

global withinRuns experiment

% restart is the simplest solution for a 'wrong button' request

withinRuns.wrongButton=withinRuns.wrongButton+1;

set(handles.pushbuttonGO, 'visible','on', 'backgroundcolor','y')

msg=[{'Start again: wrong button pressed'}, {' '},...

    {'Please,click on the GO button'}];

set(handles.textMSG,'string',msg)

experiment.status='waitingForGO';

% ------------------------------------------------- plotProgressThisTrial

function plotProgressThisTrial(handles)

% updates GUI: used for all responses

global experiment stimulusParameters betweenRuns withinRuns expGUIhandles

global  psy levelsBinVector binFrequencies rareEvent logistic statsModel

% plot the levelTrack and the threshold track

% Panel 2

% plot the levelList

axes(expGUIhandles.axes2); cla

plot( withinRuns.levelList,'o','markerFaceColor','k'), hold on

% plot the best threshold estimate tracks

if length(withinRuns.meanEstTrack)>=1

    % The length of the levelList is 2 greater than number of thresholds

    ptr=withinRuns.beginningOfPhase2+1;

    plot(ptr: ptr+length(withinRuns.meanEstTrack)-1, ...

        withinRuns.meanEstTrack, 'r')

    plot( ptr: ptr+length(withinRuns.thresholdEstimateTrack)-1, ...

        withinRuns.thresholdEstimateTrack, 'g')

    hold off

    estThresh=withinRuns.thresholdEstimateTrack(end);

    switch experiment.threshEstMethod

        % add appropriate labels to subject GUI buttons

        case {'2I2AFC++', '2I2AFC+++'}

            title([stimulusParameters.WRVname ' = ' ...

                num2str(withinRuns.variableValue, '%5.1f')])

        otherwise

            title([stimulusParameters.WRVname ' = ' ...

                num2str(withinRuns.variableValue, '%5.1f') ...

                ';    TH= ' num2str(estThresh, '%5.1f') ' dB'])

    end

end

xlim([0 experiment.maxTrials+withinRuns.beginningOfPhase2]);

ylim(stimulusParameters.WRVlimits)

ylabel ('dB SPL')

grid on

% Panel 4: Summary of threshold estimates (not used here)

% Estimates from previous runs are set in 'runCompleted'

% It is only necessary to change title showing runs/trials remaining

axes(expGUIhandles.axes4)

runsToGo=length(betweenRuns.var1Sequence)-betweenRuns.runNumber;

if withinRuns.beginningOfPhase2>0

    trialsToGo= experiment.singleIntervalMaxTrials(1) ...

        + withinRuns.beginningOfPhase2- withinRuns.trialNumber;

    title(['trials remaining = ' num2str(trialsToGo) ...

        ':    runs to go= ' num2str(runsToGo)])

end

% plot psychometric function   - panel 5

axes(expGUIhandles.axes5), cla

plot(withinRuns.levelList, withinRuns.responseList,'b.'), hold on

ylim([0 1])

title('')

switch experiment.threshEstMethod

    case {'MaxLikelihood', 'oneIntervalUpDown'}

        if withinRuns.beginningOfPhase2>0

            % display only when in phase 2.

            withinRuns.levelsPhaseTwo=...

                withinRuns.levelList(withinRuns.beginningOfPhase2:end);

            withinRuns.responsesPhaseTwo=...

                withinRuns.responseList(withinRuns.beginningOfPhase2:end);

            % organise data as psychometric function

            [psy, levelsBinVector, binFrequencies]= ...

                psychometricFunction(withinRuns.levelsPhaseTwo,...

                withinRuns.responsesPhaseTwo, experiment.psyBinWidth);

            % Plot the function

            %   point by point with circles of appropiate weighted size

            hold on,

            for i=1:length(psy)

                plot(levelsBinVector(i), psy(i), 'ro', ...

                    'markersize', 50*binFrequencies(i)/sum(binFrequencies))

            end

            % save info for later

            betweenRuns.psychometicFunction{betweenRuns.runNumber}=...

                [levelsBinVector; psy];

            % fitPsychometric functions is  computed in 'userDecides'

            % plot(rareEvent.predictionLevels, rareEvent.predictionsRE,'k')

            plot(logistic.predictionLevels, logistic.predictionsLOG, 'r')

            plot(rareEvent.predictionLevels, rareEvent.predictionsRE, 'k')

            if ~isnan(logistic.bestThreshold )

                xlim([ 0 100 ])

                title(['k= ' num2str(logistic.bestK, '%6.2f') ' g= '...

                    num2str(rareEvent.bestGain,'%6.3f') '  A=' ...

                    num2str(rareEvent.bestVMin,'%8.1f')])

            else

                title(' ')

            end

            switch experiment.ear

                %plot green line for statsModel a priori model

                case 'statsModelLogistic'

                    % plot proTem logistic (green) used by stats model

                    p= 1./(1+exp(-statsModel.logisticSlope...

                        *(levelsBinVector-logistic.bestThreshold)));

                    if experiment.psyFunSlope<0, p=1-p;end

                    titleText=[ ',  statsModel: logistic'];

                    hold on,    plot(levelsBinVector, p,'g')

                case  'statsModelRareEvent'

                    pressure=28*10.^(levelsBinVector/20);

                    p=1-exp(-stimulusParameters.targetDuration...

                        *(statsModel.rareEvenGain...

                        * pressure-statsModel.rareEventVmin));

                    p(p<0)=0;

                    if experiment.psyFunSlope<0, p=1-p;end

                    hold on,    plot(levelsBinVector, p,'g')

            end %(estMethod)

        end

    otherwise           % 2A2IFC

        message3= ...

            ([ 'peaks='  num2str(withinRuns.peaks) ...

            'troughs='  num2str(withinRuns.troughs)]);

        ylimRM([-0.1 1.1])	% 0=no / 1=yes

        set(gca,'ytick',[0 1], 'yTickLabel', {'no';'yes'})

        ylabel('psychometric function'), xlabel('target level')

        if length(levelsBinVector)>1

            xlim([ min(levelsBinVector) max(levelsBinVector)])

            xlim([ 0 100])

        end

end

% command window summary

% Accumulate things to say in the message window

message1= (['responses:      ' num2str(withinRuns.responseList,'%9.0f')]);

switch experiment.paradigm

    % more decimal places needed on GUI

    case { 'gapDetection', 'frequencyDiscrimination', 'forwardMaskingD'}

        message2= ([stimulusParameters.WRVname  ...

            ':       ' num2str(withinRuns.levelList,'%7.3f')]);

        message3= (['Thresh (logistic mean):   ' ...

            num2str(withinRuns.thresholdEstimateTrack,'%7.3f')]);

    otherwise

        message2= ([stimulusParameters.WRVname ':      ' ...

            num2str(withinRuns.levelList,'%7.1f')]);

        message3= (['Thresh (logistic mean):   ' ...

            num2str(withinRuns.thresholdEstimateTrack,'%7.1f')]);

end

addToMsg(str2mat(message1, message2, message3), 0)

% -----------------------------------------------------runCompleted

function runCompleted(handles)

% Used at the end of each run

global experiment stimulusParameters betweenRuns withinRuns

global rareEvent expGUIhandles