def traceDiffPeaks(dm):
"""
desc: |
Determines the peaks where the effect is largest, and smallest, in real
units. This analysis is based on non-baselined pupil size.
arguments:
dm: A DataMatrix.
"""
traceParams = trialParams.copy()
del traceParams['baseline']
x1, y1, err1 = tk.getTraceAvg(dm.select('cueLum == "bright"'), \
**traceParams)
x2, y2, err2 = tk.getTraceAvg(dm.select('cueLum == "dark"'), \
**traceParams)
xGrand, yGrand, errGrand = tk.getTraceAvg(dm, **traceParams)
d = 100. * (y2-y1) / yGrand
iMax = np.where(d == d.max())[0][0]
iMin = np.where(d == d.min())[0][0]
print 'Max effect: %.2f (sample %d)' % (d[iMax], iMax)
print 'Min effect: %.2f (sample %d)' % (d[iMin], iMin)
plt.subplot(211)
plt.plot(y1, color=green[1])
plt.plot(y2, color=blue[1])
plt.plot(yGrand, color=gray[1])
plt.subplot(212)
plt.plot(d, color='black')
plt.axvline(iMax, color='black')
plt.axvline(iMin, color='black')
Plot.save('traceDiffPeaks')
def pupilDiffPlotSubject(dm):
"""
desc:
Creates the overall pupil-size plot for switch-to-bright and
switch-to-dark rounds, separately for each subject.
arguments:
dm:
desc: A DataMatrix.
type: DataMatrix
"""
i = 0
Plot.new(size=Plot.s)
for subject_nr, _dm in dm.walk('subject_nr'):
t = 'pp %s (N=%d)' % (subject_nr, len(_dm))
print(t)
pupilDiffPlot(_dm, label=str(subject_nr))
i += 1
plt.axvline(dm['endInvertTime'].mean(), color='black', linestyle='--')
plt.axvline(dm['endAdaptationTime'].mean(), color='black', linestyle='--')
plt.axhline(0, color='black', linestyle='-')
plt.xlabel('Time since round start (ms)')
plt.ylabel('Mean pupil area')
plt.xlim(0, traceLen)
plt.legend(frameon=False)
Plot.save('pupilDiffPlotSubject', show=show)
def crossExpContour(dm):
"""
desc:
Plots a multipanel contour plot depicting the correlation between
pupil size and fixation saliency for each experiment.
arguments:
dm:
type: DataMatrix
"""
assert(constants.exp == 'exp1')
Plot.new(constants.bigPlot)
plt.subplot(221)
simpleContour(dm, title='Exp. 1')
constants.exp = 'exp2'
dm = helpers.getDataMatrix(cacheId='data.%s' % constants.exp)
dm = helpers.filter(dm, cacheId='filter.%s' % constants.exp)
plt.subplot(222)
simpleContour(dm, title='Exp. 2')
constants.exp = 'exp3'
dm = helpers.getDataMatrix(cacheId='data.%s' % constants.exp)
dm = helpers.filter(dm, cacheId='filter.%s' % constants.exp)
plt.subplot(223)
simpleContour(dm.select('cond == "single"'), title='Exp. 3 single')
plt.subplot(224)
simpleContour(dm.select('cond == "dual"'), title='Exp. 3 dual')
Plot.save('correlationPlot', folder='crossExp', show=constants.show)
def exp1RegressionPlot(dm):
"""
desc:
Creates a demo plot in which fixation saliency is shown as a function
of pupil size.
arguments:
dm:
type: DataMatrix.
"""
Plot.new(size=smallPlot)
lX = []
lY = []
for _dm in dm.group('b__pupilSize'):
lX.append(_dm['_pupilSize'].mean())
lY.append(_dm['salFrom'].mean())
aX = np.array(lX)
aY = np.array(lY)
plt.plot(aX, aY, 'o-', color=exp1Col)
plt.xlabel('Pupil diameter (Z score)')
plt.ylabel('Fixation saliency (arbitrary units)')
plt.xlim(-2, 2)
plt.xticks([-2, -1, 0, 1, 2])
plt.ylim(14, 20)
Plot.save('exp1RegressionPlot', folder='exp1')
def windowPlot(dm, standalone=True, color=blue[1], label=None):
"""
desc:
Creates a graph in which the effect of pupil size on saliency is shown
separately for each temporal displacement. I.e. the effect of pupil size
on trial N on saliency on trial N+1, etc.
arguments:
dm:
type: DataMatrix
keywords:
standalone:
desc: Indicates whether this is a standalone plot, in which case
it will create and save the plot, or not.
type: bool
color:
desc: Plot color.
type: [str, unicode]
label:
desc: Line label.
type: [str, unicode]
"""
if standalone:
Plot.new(widePlot)
dm = dm.intertrialer(["file", "trialId", "saccNr"], "salFrom", _range=windowRange)
xData = []
yData = []
eData = []
for r in windowRange:
if r == 0:
_dv = "salFrom"
elif r < 0:
_dv = "salFrom_m%d" % (-1 * r)
else:
_dv = "salFrom_p%d" % r
print "dv = %s" % _dv
s, t, lo, up = stats.effectSlope(dm, dv=_dv)
print s
xData.append(r)
yData.append(s)
eData.append([lo, up])
xData = np.array(xData)
yData = np.array(yData)
eData = np.array(eData)
plt.fill_between(xData, eData[:, 0], eData[:, 1], color=color, alpha=0.1)
plt.plot(windowRange, yData, "o-", color=color, label=label)
plt.axhline(linestyle="--", color="black")
plt.xlabel("Pupil-size timepoint relative to saliency timepoint")
plt.xticks(windowRange)
plt.xlim(windowRange[0], windowRange[-1])
plt.ylabel("Partial slope")
plt.yticks(slopeTicks[exp])
plt.ylim(slopeLim[exp])
if standalone:
Plot.save("windowPlot", folder=exp, show=show)
def trialPlot(dm, soa, _show=show, err=True, minSmp=200, suffix='', padding=0,
diff=True):
"""
A pupil-trace plot for the full trial epoch.
Arguments:
dm -- A DataMatrix.
soa -- The SOA to select.
Keyword arguments:
_show -- Indicates whether the plot should be shown.
(default=True)
err -- Indicates whether error bars should be drawn.
(default=True)
suffix -- A suffix to identify the trace. (default='')
padding -- A padding time to be added to the traceLen. (default=0)
diff -- Indicates whether the difference trace should be plotted
as well. (default=True)
"""
assert(soa in dm.unique('soa'))
if _show:
Plot.new(size=Plot.ws)
plt.title('SOA: %d ms' % (soa+55))
plt.axhline(1, linestyle='--', color='black')
dm = dm.select('soa == %d' % soa)
# Determine the trace length and create the trace plot
traceLen = soa + 105 + padding
traceParams = trialParams.copy()
traceParams['traceLen'] = traceLen
tracePlot(dm, traceParams=traceParams, err=err, suffix='.%d%s' % (soa, \
suffix), minSmp=minSmp)
# Cue
plt.axvspan(0, cueDur, color=blue[1], alpha=.2)
# Target. Take into account to cue duration in determining the target onset.
targetOnset = soa+55
plt.axvspan(targetOnset, targetOnset+targetDur, color=blue[1], alpha=.2)
plt.xlim(0, 2550)
plt.legend(frameon=False)
plt.xlabel('Time since cue onset (ms)')
plt.ylabel('Pupil size (norm.)')
plt.yticks([1,1.025, 1.05])
plt.xticks(range(0, 2501, 500))
if diff:
plt.ylim(.92, 1.07)
plt.axhline(diffY, linestyle='--', color='black')
plt.twinx()
plt.tick_params(axis="y")
plt.ylim(.92, 1.07)
plt.yticks([.925,.95, .975], [-.025, 0, .025])
else:
plt.ylim(.98, 1.07)
if _show:
Plot.save('trialPlot.%d' % soa, 'trialPlot', show=show)
def splitHalfReliabilityBehav(dm, soa=2445, dv='response_time', n=10000):
"""
Tests the split-half reliability of the behavioral cuing effect at the peak
sample.
Arguments:
dm -- A DataMatrix.
Keyword arguments:
soa -- The SOA. (default=2445)
dv -- The dependent variable to use. (default='correct')
n -- The number of runs. (default=1000)
"""
@cachedArray
def corrArray(dm, soa, dv, n):
import time
lR = []
t0 = time.time()
for i in range(n):
l1 = []
l2 = []
for _dm in dm.group('subject_nr'):
_dm.shuffle()
dm1 = _dm[:len(_dm)/2]
dm2 = _dm[len(_dm)/2:]
ce1 = cuingEffectBehav(dm1, dv=dv)
ce2 = cuingEffectBehav(dm2, dv=dv)
l1.append(ce1)
l2.append(ce2)
s, j, r, p, se = linregress(l1, l2)
print '%d (%d s): r = %.4f, p = %.4f' % (i, time.time()-t0, r, p)
lR.append(r)
return np.array(lR)
assert(soa in dm.unique('soa'))
dm = dm.select('soa == %d' % soa)
Plot.new(size=(3,3))
a = corrArray(dm, soa, dv, n, cacheId='corrArrayBehav.%s' % dv)
a.sort()
ci95up = a[np.ceil(.975 * len(a))]
ci95lo = a[np.floor(.025 * len(a))]
s = 'M = %.2f, P(r > 0) = %.2f, 95%%: %.2f - %.2f' % (a.mean(),
np.mean(a > 0), ci95lo, ci95up)
print s
plt.hist(a, bins=n/10, color=blue[1])
plt.title(s)
plt.axvline(0, color='black')
plt.xlim(-1, 1)
plt.xlabel('Split-half correlation (r)')
plt.ylabel('Frequency (N)')
Plot.save('splitHalfReliability.behav.%s' % dv, folder='corrAnalysis',
show=show)
def respLockPlot(dm, soa, _show=True, err=True, suffix=''):
"""
Generates a response-locked pupil-trace plot.
Arguments:
dm -- A DataMatrix.
soa -- The SOA to analyze.
Keyword arguments:
_show -- Indicates whether the plot should be shown.
(default=True)
err -- Indicates whether error bars should be drawn.
(default=True)
suffix -- A suffix to identify the trace. (default='')
"""
assert(soa in dm.unique('soa'))
if _show:
Plot.new(size=Plot.ws)
plt.title('SOA: %d ms%s' % (soa+55, suffix))
dm = dm.select('soa == %d' % soa)
# Recoding target luminance
print 'Recoding target luminance ...'
dm = dm.addField('targetLum', dtype=str)
for i in dm.range():
if (dm['cueLum'][i] == 'bright' and dm['cueValidity'][i] == 'valid') \
or (dm['cueLum'][i] == 'dark' and dm['cueValidity'][i] == \
'invalid'):
dm['targetLum'][i] = 'bright'
else:
dm['targetLum'][i] = 'dark'
print 'Done'
# Draw lines
plt.axhline(1, linestyle='--', color='black')
plt.axvline(dm['response_time'].mean(), linestyle='--', color='black')
# Determine the trace length and create the trace plot
traceParams = respLockParams.copy()
traceParams['offset'] = soa+55
tracePlot(dm, traceParams=traceParams, err=False, suffix='.respLock.%d%s' \
% (soa, suffix), lumVar='targetLum')
# Target
plt.axvspan(0, targetDur, color=blue[1], alpha=.2)
plt.xlim(0, traceParams['traceLen'])
plt.legend(frameon=False)
plt.xlabel('Time since target onset (ms)')
plt.ylabel('Pupil size (norm.)')
plt.ylim(.95, 1.4)
plt.yticks([1, 1.1, 1.2, 1.3])
plt.xticks(range(0, 1501, 250))
if _show:
Plot.save('respLockPlot.%d%s' % (soa, suffix), 'respLock', show=show)
def pilotgraph(data, name, xlabel):
Plot.new(size=(3,3))
x = -.4
xticks = []
for key, rt, se in data:
xticks.append(key)
plt.bar(x, rt-rt_adjust, color=blue[1])
plt.errorbar(x+.4, rt-rt_adjust, se, color='black', capsize=0)
x += 1
plt.xlim(-.7, x+.2)
plt.xticks(range(len(data)), xticks)
plt.xlabel(xlabel)
plt.ylabel('Response time (s)')
plt.ylim(0, 25)
Plot.save(name, folder='pilot')
def subjectDiffPlot(dm):
"""
Creates a line plot of the pupil effect separately for each subject.
Arguments:
dm -- A DataMatrix.
"""
Plot.new(size=Plot.w)
colors = brightColors * 10
for _dm in dm.group('subject_nr'):
print 'Subject %d' % _dm['subject_nr'][0]
traceDiffPlot(_dm, color=colors.pop())
plt.axhline(0, linestyle='--', color='black')
Plot.save('subjectDiffPlot', 'subject', show=show)
def pupilPlotExample(dm):
"""
desc:
Creates the overall pupil-size plot for switch-to-bright and
switch-to-dark rounds for participant 10.
arguments:
dm:
desc: A DataMatrix.
type: DataMatrix
"""
dm = dm.select('subject_nr == 10')
Plot.new(size=Plot.s)
pupilPlot(dm)
Plot.save('pupilPlotExample', show=show)
def corrPlot(dm, soaBehav, soaPupil, suffix=''):
"""
Plots and analyzes the correlation between the cuing effect in behavior and
pupil size.
Arguments:
dm -- A DataMatrix.
soaBehav -- The SOA to analyze for the behavioral effect.
soaPupil -- The SOA to analyze for the pupil effect.
Keyword arguments:
suffix -- A suffix for the plot filename. (default='')
"""
if stripCorr:
suffix += '.stripCorr'
Plot.new(size=Plot.ws)
plt.title('SOA: %d ms (behavior), %d ms (pupil)' % (soaBehav+55, \
soaPupil+55))
plt.ylim(-.2, 1)
plt.xlabel('Time since cue onset (ms)')
plt.ylabel('Behavior - pupil correlation (r)')
plt.axhline(0, linestyle='--', color='black')
# Cue shading
plt.axvspan(0, cueDur, color=blue[1], alpha=.2)
# Target shading
targetOnset = soaPupil+55
plt.axvspan(targetOnset, targetOnset+targetDur, color=blue[1], alpha=.2)
plt.xlim(0, 2550)
# Accuracy
a = corrTrace(dm, soaBehav, soaPupil, dv='correct', suffix='acc', \
cacheId='corrTrace.correct.%d.%d%s' % (soaBehav, soaPupil, suffix))
tk.markStats(plt.gca(), a[:,1])
plt.plot(a[:,0], label='Accuracy', color=blue[1])
# RTs
a = corrTrace(dm, soaBehav, soaPupil, dv='response_time', suffix='rt', \
cacheId='corrTrace.rt.%d.%d%s' % (soaBehav, soaPupil, suffix))
tk.markStats(plt.gca(), a[:,1])
tk.markStats(plt.gca(), a[:,1], color='red')
plt.plot(a[:,0], label='Response times', color=orange[1])
plt.legend(frameon=False, loc='upper left')
Plot.save('corrAnalysis.%d.%d%s' % (soaBehav, soaPupil, suffix),
'corrAnalysis', show=show)
def subjectPlot(dm):
"""
Generates a separate trial plot for each subject.
Arguments:
dm -- A DataMatrix.
"""
Plot.new(size=Plot.xl)
i = 1
for _dm in dm.group('subject_nr'):
subject_nr = _dm['subject_nr'][0]
N = len(_dm)
plt.subplot(np.ceil(dm.count('subject_nr')/4.), 5, i)
plt.title('%s (%d)' % (subject_nr, N))
trialPlot(_dm, 2445, _show=False, err=False, suffix='.subject%.2d' % \
subject_nr)
i += 1
Plot.save('subjectPlot', 'subject', show=show)
def exp2InstructionPlot(dm):
"""
desc:
Plots the effect of pupil size on saliency for different task
instructions.
arguments:
dm:
type: DataMatrix
"""
assert(exp == 'exp2')
Plot.new(size=smallPlot)
for color, fmt, sceneType in [(fractalCol, 'o-', 'fractal'),
(sceneCol, 's:', 'scene')]:
lSlope = []
if sceneType == 'fractal':
x = -.1
else:
x = .1
lX = []
for inst in ['free', 'search', 'memory']:
lX.append(x)
_dm = dm.select('inst == "%s"' % inst).select(
'sceneType == "%s"' % sceneType)
s, t, lo, up = stats.effectSlope(_dm)
lSlope.append(s)
plt.plot([x, x], [lo, up], '-', color=color)
x += 1
plt.plot(lX, lSlope, fmt, color=color, label=sceneType.capitalize()+'s')
plt.xticks(range(0,3), ['Free', 'Search', 'Memory'])
plt.yticks([0, 2, 4, 6])
plt.ylabel('Partial slope')
plt.xlabel('Task')
plt.xlim(-.5, 2.5)
plt.ylim(slopeLim)
plt.axhline(0, color='black', linestyle='--')
plt.legend(frameon=False, loc='upper left')
Plot.save('instructionPlot', folder=exp, show=show)
def exp3SaccadePlot(dm):
"""
desc:
Creates a saccade plot with the different task conditions as individual
lines.
arguments:
dm:
type: DataMatrix
"""
from analysis import helpers
dmSingle = dm.select('cond == "single"')
dmDual = dm.select('cond == "dual"')
Plot.new(widePlot)
helpers.saccadePlot(dmSingle, standalone=False, color=exp3SingleCol,
label='Single task')
helpers.saccadePlot(dmDual, standalone=False, color=exp3DualCol,
label='Dual task')
plt.legend(frameon=False)
Plot.save('saccadePlot.task', folder=exp, show=show)
def crossExpWindowPlot(dm):
"""
desc:
Creates a window plot with the Exp. 1 and 2 as individual lines.
arguments:
dm:
type: DataMatrix
"""
assert(constants.exp == 'exp1')
Plot.new(constants.widePlot)
helpers.windowPlot(dm, standalone=False, color=constants.exp1Col,
label='Exp. 1')
constants.exp = 'exp2'
dm = helpers.getDataMatrix(cacheId='data.%s' % constants.exp)
dm = helpers.filter(dm, cacheId='filter.%s' % constants.exp)
helpers.windowPlot(dm, standalone=False, color=constants.exp2Col,
label='Exp. 2')
plt.legend(frameon=False)
Plot.save('windowPlot', folder='crossExp', show=constants.show)
def pupilPlotSubject(dm):
"""
desc:
Creates the overall pupil-size plot for switch-to-bright and
switch-to-dark rounds, separately for each subject.
arguments:
dm:
desc: A DataMatrix.
type: DataMatrix
"""
i = 0
Plot.new(Plot.xl)
for subject_nr, _dm in dm.walk('subject_nr'):
t = 'pp %s (N=%d)' % (subject_nr, len(_dm))
print(t)
plt.subplot(2, dm.count('subject_nr')/2, i)
plt.title(t)
pupilPlot(_dm)
i += 1
Plot.save('pupilPlotSubject', show=show)
def corrExample(dm, soaBehav, soaPupil, dv='correct', suffix=''):
"""
Plots an example of the correlation between behavior and pupil size at the
most strongly correlating point.
Arguments:
dm -- A DataMatrix.
soaBehav -- The SOA to analyze for the behavioral effect.
soaPupil -- The SOA to analyze for the pupil effect.
Keyword arguments:
dv -- The dependent variable to use for the behavioral effect.
(default='correct')
suffix -- A filename suffix.
"""
assert(soaPupil in dm.unique('soa'))
assert(soaBehav in dm.unique('soa'))
if stripCorr:
suffix += '.stripCorr'
a = corrTrace(dm, soaBehav, soaPupil, dv='correct', suffix='acc', \
cacheId='corrTrace.correct.%d.%d%s' % (soaBehav, soaPupil, suffix))
bestSample = np.argmax(a[:,0])
dmBehav = dm.select('soa == %d' % soaBehav)
dmPupil = dm.select('soa == %d' % soaPupil)
xData = []
yData = []
print 'pp\tbehav\tpupil'
for subject_nr in dm.unique('subject_nr'):
ceb = cuingEffectBehav(dmBehav.select('subject_nr == %d' \
% subject_nr, verbose=False), dv=dv)
cep = cuingEffectPupil(dmPupil.select('subject_nr == %d' \
% subject_nr, verbose=False), epoch=(bestSample, \
bestSample+winSize))
print '%.2d\t %.4f\t%.4f' % (subject_nr, ceb, cep)
yData.append(100.*ceb)
xData.append(cep)
if stripCorr:
index, xData, yData = stripStd(np.array(xData), np.array(yData))
Plot.new(size=(3,3))
plt.title('SOA: %d ms (behavior), %d ms (pupil)' % (soaBehav+55, \
soaPupil+55))
Plot.regress(xData, yData)
plt.text(0.05, 0.90, 'Sample = %d' % bestSample, ha='left', \
va='top', transform=plt.gca().transAxes)
plt.axhline(0, linestyle='--', color='black')
plt.axvline(0, linestyle='--', color='black')
plt.plot(xData, yData, 'o', color='black')
plt.ylabel('Behav. cuing effect (%)')
plt.xlabel('Pupil cuing effect (norm.)')
Plot.save('corrExample.%d.%d%s' % (soaBehav, soaPupil, suffix),
'corrAnalysis', show=show)
def saccadePlot(dm, standalone=True, color=blue[1], label=None):
"""
desc:
Creates a graph in which the effect of pupil size on saliency is shown
separately for each saccade in a trial.
arguments:
dm:
desc: Data
type:
keywords:
standalone:
desc: Indicates whether this is a standalone plot, in which case
it will create and save the plot, or not.
type: bool
color:
desc: Plot color.
type: [str, unicode]
label:
desc: Line label.
type: [str, unicode]
"""
if standalone:
Plot.new(size=widePlot)
xData = []
yData = []
eData = []
for saccNr in [None] + range(1, maxSacc + 1):
if saccNr == None:
_dm = dm
else:
_dm = dm.select("saccNr == %d" % saccNr)
s, p, lo, up = stats.effectSlope(_dm)
if saccNr == None:
if standalone:
x = -1
elif exp == "exp1":
x = -1.2
else:
x = -0.8
plt.errorbar(x, s, yerr=[[s - lo], [up - s]], capsize=0, fmt="o-", color=color)
else:
xData.append(saccNr)
yData.append(s)
eData.append([lo, up])
xData = np.array(xData)
yData = np.array(yData)
eData = np.array(eData)
plt.fill_between(xData, eData[:, 0], eData[:, 1], color=color, alpha=0.1)
plt.plot(xData, yData, "o-", color=color, label=label)
plt.axhline(0, linestyle="--", color="black")
plt.xlabel("Saccade number")
plt.xlim(-2, maxSacc + 1)
plt.xticks([-1] + range(1, 21), ["Full"] + range(1, 21))
plt.ylabel("Partial slope")
plt.yticks(slopeTicks[exp])
plt.ylim(slopeLim[exp])
if standalone:
Plot.save("saccadePlot", folder=exp, show=show)
def prepFit(dm, suffix=''):
"""
Perform a linear-regression fit on only the first 220 ms.
Arguments:
dm -- DataMatrix
Keyword arguments:
suffix -- A suffix for the output files. (default='')
"""
fig = newFig(size=bigWide)
plt.subplots_adjust(wspace=0, hspace=0)
i = 0
l = [['subjectNr', 'sConst', 'iConst', 'sOnset', 'iOnset', 'sSwap',
'iSwap']]
for dm in [dm] + dm.group('subject_nr'):
print 'Subject %s' % i
row = [i]
# We use a 6 x 2 plot grid
# XX X X X X
# XX X X X X
if i == 0:
# Overall plot
ax = plt.subplot2grid((2,6),(0,0), colspan=2, rowspan=2)
linewidth = 1
title = 'Full data (N=%d)' % len(dm.select('cond != "swap"'))
else:
# Individual plots
ax = plt.subplot2grid((2,6),((i-1)/4, 2+(i-1)%4))
linewidth = 1
title = '%d (N=%d)' % (i, len(dm.select('cond != "swap"')))
plt.text(0.9, 0.1, title, horizontalalignment='right', \
verticalalignment='bottom', transform=ax.transAxes)
if i == 0:
plt.xticks([0, 50, 100, 150, 200])
elif i > 0 and i < 5:
plt.xticks([])
else:
plt.xticks([0, 100])
if i > 0:
plt.yticks([])
else:
plt.yticks([0, -.01, -.02])
plt.ylim(-.025, .01)
plt.axhline(0, color='black', linestyle=':')
for cond in ('constant', 'onset', 'swap'):
_dm = dm.select("cond == '%s'" % cond, verbose=False)
dmWhite = _dm.select('saccCol == "white"', verbose=False)
xAvg, yAvg, errAvg= TraceKit.getTraceAvg(_dm, signal='pupil', \
phase='postSacc', traceLen=postTraceLen, baseline=baseline, \
baselineLock=baselineLock)
xWhite, yWhite, errWhite = TraceKit.getTraceAvg(dmWhite, \
signal='pupil', phase='postSacc', traceLen=postTraceLen, \
baseline=baseline, baselineLock=baselineLock)
yWhite -= yAvg
xWhite = xWhite[:prepWin]
yWhite = yWhite[:prepWin]
if cond == 'constant':
col = constColor
lineStyle = '-'
elif cond == 'onset':
col = onsetColor
lineStyle = '--'
else:
col = swapColor
lineStyle = '-.'
yWhite *= -1
opts = Plot.regress(xWhite, yWhite, lineColor=col, symbolColor=col,
label=cond, annotate=False, symbol=lineStyle, linestyle=':')
s = 1000.*opts[0]
_i = 1000.*opts[1]
print 's = %.4f, i = %.4f' % (s, _i)
if i > 0:
row += [s, _i]
else:
plt.legend(frameon=False, loc='upper right')
if i > 0:
l.append(row)
i += 1
saveFig('linFitPrepWin%s' % suffix, show=False)
dm = DataMatrix(l)
dm.save('output/%s/linFitPrepWin%s.csv' % (exp, suffix))
# Summarize the data and perform ttests on the model parameters
for dv in ['s', 'i']:
print'\nAnalyzing %s' % dv
aConst = dm['%sConst' % dv]
aOnset = dm['%sOnset' % dv]
aSwap = dm['%sSwap' % dv]
print 'Constant: M = %f, SE = %f' % (aConst.mean(), \
aConst.std() / np.sqrt(N))
print 'Onset: M = %f, SE = %f' % (aOnset.mean(), \
aOnset.std() / np.sqrt(N))
print 'Swap: M = %f, SE = %f' % (aSwap.mean(), \
aSwap.std() / np.sqrt(N))
# Standard t-tests
t, p = ttest_rel(aConst, aOnset)
print 'Const vs onset, t = %.4f, p = %.4f' % (t, p)
t, p = ttest_rel(aSwap, aOnset)
print 'Swap vs onset, t = %.4f, p = %.4f' % (t, p)
t, p = ttest_rel(aConst, aSwap)
print 'Const vs swap, t = %.4f, p = %.4f' % (t, p)
def finishTrial(self, trialDict): """ desc: Performs post-trial initialization. arguments: trialDict: desc: Trial information. type: dict l: desc: A whitespace-splitted line of data. type: list """ print 'nFixLost: %(nFixLost)d, maxFixErr = %(maxFixErr).2f' % trialDict trialDict['rt'] = self.endTime - self.startTime trialDict['correct'] = self.correct # Get the correct correct trialDict['endInvertTime'] = np.mean(self.endInvertTime) trialDict['endAdaptationTime'] = np.mean(self.endAdaptationTime) trialDict['endCollectionTime'] = np.mean(self.endCollectionTime) trialDict['endRoundTime'] = np.mean(self.endRoundTime) path = 'likelihood/%s-%.4d.pickle' % (trialDict['file'], trialDict['trialId']) trialDict['__likelihood__'] = path pickle.dump(self.likelihoodTraces, open(path, 'w')) # Determine the mean vector of the fixations fax = np.mean([xy[0] for xy in self.fixList]) fay = np.mean([xy[1] for xy in self.fixList]) fdx = fax - xc fdy = fay - yc fa = np.degrees(np.arctan2(fdy, fdx)) fr = np.sqrt(fdx**2 + fdy**2) # Determine the vector of the target tx = trialDict['targetX'] ty = trialDict['targetY'] tdx = tx - xc tdy = ty - yc ta = np.degrees(np.arctan2(tdy, tdx)) tr = np.sqrt(tdx**2 + tdy**2) # Determine the vector error errA = ta-fa if errA < 0: errA += 360 trialDict['errA'] = errA trialDict['errR'] = fr s = 'Vector: r = %.2f, d(a) = %.2f' % (fr, errA) print s if '--plot' in sys.argv: Plot.new() plt.title(s) plt.xlim(0, 1280) plt.ylim(0, 1024) plt.axvline(xc, linestyle='--', color='black') plt.axhline(yc, linestyle='--', color='black') for x, y in self.fixList: plt.plot(x, y, '.', color=blue[1]) plt.plot(tx, ty, 'o', color=orange[1]) plt.plot([xc, xc+fdx], [yc, yc+fdy], color=blue[1]) plt.plot([xc, xc+tdx], [yc, yc+tdy], color=orange[1]) plotName = '%s-%d' % (trialDict['file'], trialDict['trialId']) Plot.save(plotName)
def lmeBehavior(dm, suffix=''):
"""
Analyzes the behavioral data with mixed effects.
Arguments:
dm -- A DataMatrix.
keywords:
suffix -- A filename suffix.
"""
global R
try:
R
except:
R = RBridge()
i = 1
Plot.new(size=Plot.ws)
for dv in ['correct', 'irt']:
# Also analyze the grouped 945 and 2445 SOAs, which gives more power
# than analyzing them separately.
R.load(dm.select('soa != 45'))
lm = R.lmer('%s ~ cueValidity * soa + (1|subject_nr)' % dv)
lm.save('output/lmeBehavior.longInteract.%s.csv' % dv)
lm._print(title='Long: %s' % dv, sign=10)
lm = R.lmer('%s ~ cueValidity + (1|subject_nr)' % dv)
lm.save('output/lmeBehavior.longNoInteract.%s.csv' % dv)
lm._print(title='Long: %s' % dv, sign=10)
# Loop over SOAs
lSoa = []
lVal = []
lInv = []
for soa in [45, 945, 2445]:
_dm = dm.select('soa == %d' % soa, verbose=False)
R.load(_dm)
lm = R.lmer('%s ~ cueValidity + (1|subject_nr)' % dv)
lm.save('output/lmeBehavior.%s.%s.csv' % (dv, soa))
lm._print(title='%s (%s)' % (dv, soa), sign=10)
mInv = lm['est'][0] # Invalid is reference
mVal = mInv + lm['est'][1] #4Add slope for validity effect
d = lm['est'][1]
m = mInv + .5*d
minD = d - lm['se'][1]
maxD = d + lm['se'][1]
# Determine error bars based on the slope CIs
cInv = [m-minD/2, m-maxD/2]
cVal = [m+minD/2, m+maxD/2]
if dv == 'irt':
mVal = 1./mVal
mInv = 1./mInv
cInv = [1./cInv[0], 1./cInv[1]]
cVal = [1./cVal[0], 1./cVal[1]]
else:
mVal = 100.*mVal
mInv = 100.*mInv
cInv = [100.*cInv[0], 100.*cInv[1]]
cVal = [100.*cVal[0], 100.*cVal[1]]
# We plot the errorbars separately, because it's a bit easier than
# passing them onto `plt.errorbar()`.
plt.plot([soa+55, soa+55], cVal, '-', color=valColor)
plt.plot([soa+55, soa+55], cInv, '-', color=invColor)
lSoa.append(soa+55)
lVal.append(mVal)
lInv.append(mInv)
plt.xlim(-100, 2750)
plt.xticks([100, 1000, 2500])
plt.xlabel('Cue-target interval (ms)')
if dv == 'irt':
plt.ylabel('Respone time (ms)')
plt.ylim(420, 630)
plt.yticks([450, 500, 550, 600])
else:
plt.ylabel('Accuracy (%)')
plt.ylim(80, 95)
plt.yticks([82.5, 85, 87.5, 90, 92.5])
i += 1
nVal = len(dm.select('cueValidity == "valid"', verbose=False))
nInv = len(dm.select('cueValidity == "invalid"', verbose=False))
plt.plot(lSoa, lVal, 'o-', color=valColor, label='Valid (N=%d)' % nVal)
plt.plot(lSoa, lInv, 'o-', color=invColor, label='Invalid (N=%d)' % \
nInv)
plt.legend(frameon=False)
Plot.save('behavior%s' % suffix, 'behavior', show=show)
print('Phase 3:', itr(28.0483, 8., 0.8761))
print('Phase 4 (raw):', itr(51.0775291309, 30., None))
print('Phase 4 (use):', itr(75.2328265173, 30., None))
def itrPhase(phase, N):
a = np.loadtxt('phase%d.csv' % phase, delimiter=',')
abr = np.zeros(a.shape[0])
for i in range(a.shape[0]):
rt = a[i,0]
P = a[i,1]
abr[i] = itr(rt, N, P)
print('Phase 1: Mean ITR: %.2f' % abr.mean())
print(abr)
return abr, abr.mean(), abr.std()
Plot.new(size=Plot.xs)
a, m, sd = itrPhase(1, 2)
print(m)
plt.bar(0, m, width=.5, color=blue[1])
plt.plot([.25] * 10, a, 'o', color=green[2])
a, m, sd = itrPhase(2, 4)
print(m)
plt.bar(1, m, width=.5, color=blue[1])
plt.plot([1.25] * 9, a, 'o', color=green[2])
a, m, sd = itrPhase(3, 8)
print(m)
plt.bar(2, m, width=.5, color=blue[1])
plt.plot([2.25] * 9, a, 'o', color=green[2])
