def proc_subject(filelist):
"""Given an infile of raw pupil data, saves out:
1. Session level data with dilation data summarized for each trial
2. Dataframe of average peristumulus timecourse for each condition
3. Plot of average peristumulus timecourse for each condition
4. Percent of samples with blinks """
for fname in filelist:
print('Processing {}'.format(fname))
if (os.path.splitext(fname)[-1] == ".gazedata") | (os.path.splitext(fname)[-1] == ".csv"):
df = pd.read_csv(fname, sep="\t")
elif os.path.splitext(fname)[-1] == ".xlsx":
df = pd.read_excel(fname)
else:
raise IOError('Could not open {}'.format(fname))
subid = pupil_utils.get_subid(df['Subject'], fname)
timepoint = pupil_utils.get_timepoint(df['Session'], fname)
df = df[df.CurrentObject.str.contains("Recall", na=False)]
df = pupil_utils.deblink(df)
dfresamp = clean_trials(df)
dfresamp = dfresamp[dfresamp.index<=dfresamp.index[0] + pd.offsets.Second(30)]
dfresamp1s = dfresamp.resample('1S', closed='right', label='right').mean()
dfresamp1s.index = dfresamp1s.index.round('S')
dfresamp1s = dfresamp1s.dropna(how='all')
pupildf = dfresamp1s.reset_index().rename(columns={
'index':'Timestamp',
'DiameterPupilLRFilt':'Diameter',
'BlinksLR':'BlinkPct'})
pupilcols = ['Subject', 'Timestamp', 'Dilation',
'Baseline', 'Diameter', 'BlinkPct']
pupildf = pupildf[pupilcols].sort_values(by='Timestamp')
# Keep only first 30s of trial
pupildf = pupildf.loc[pupildf.Timestamp<=pupildf.Timestamp[0] + pd.offsets.Second(30)]
# Set subject ID and session as (as type string)
pupildf['Subject'] = subid
pupildf['Session'] = timepoint
pupil_outname = pupil_utils.get_proc_outfile(fname, '_ProcessedPupil.csv')
pupil_outname = pupil_outname.replace("HVLT_Recall-Recognition","HVLT_Recall")
pupil_outname = pupil_outname.replace("-Delay","-Recall")
pupildf.to_csv(pupil_outname, index=False)
print('Writing processed data to {0}'.format(pupil_outname))
plot_trials(pupildf, fname)
#### Create data for 10 second blocks
dfresamp10s = dfresamp.resample('10s', closed='right', label='right').mean()
pupilcols = ['Subject', 'Timestamp', 'Dilation', 'Baseline',
'DiameterPupilLRFilt', 'BlinksLR']
pupildf10s = dfresamp10s.reset_index()[pupilcols].sort_values(by='Timestamp')
pupildf10s = pupildf10s[pupilcols].rename(columns={'DiameterPupilLRFilt':'Diameter',
'BlinksLR':'BlinkPct'})
# Set subject ID as (as type string)
pupildf10s['Subject'] = subid
pupildf10s['Session'] = timepoint
pupildf10s['Timestamp'] = pd.to_datetime(pupildf10s.Timestamp).dt.strftime('%H:%M:%S')
pupil10s_outname = pupil_utils.get_proc_outfile(fname, '_ProcessedPupil_Tertiles.csv')
pupil10s_outname = pupil10s_outname.replace("HVLT_Recall-Recognition","HVLT_Recall")
pupil10s_outname = pupil10s_outname.replace("-Delay","-Recall")
'Writing tertile data to {0}'.format(pupil10s_outname)
pupildf10s.to_csv(pupil10s_outname, index=False)
def proc_subject(filelist):
"""Given an infile of raw pupil data, saves out:
1. Session level data with dilation data summarized for each trial
2. Dataframe of average peristumulus timecourse for each condition
3. Plot of average peristumulus timecourse for each condition
4. Percent of samples with blinks """
for fname in filelist:
print('Processing {}'.format(fname))
if (os.path.splitext(fname)[-1] == ".gazedata") | (os.path.splitext(fname)[-1] == ".csv"):
df = pd.read_csv(fname, sep="\t")
elif os.path.splitext(fname)[-1] == ".xlsx":
df = pd.read_excel(fname, parse_dates=False)
else:
raise IOError('Could not open {}'.format(fname))
subid = pupil_utils.get_subid(df['Subject'], fname)
timepoint = pupil_utils.get_timepoint(df['Session'], fname)
trialevents = get_trial_events(df)
dfresamp = clean_trials(df, trialevents)
dfresamp = dfresamp.reset_index(drop=False).set_index(['Condition','Trial'])
dfresamp['Timestamp'] = dfresamp.groupby(level='Trial')['Timestamp'].transform(lambda x: x - x.iat[0])
dfresamp['Timestamp'] = pd.to_datetime(dfresamp.Timestamp.values.astype(np.int64))
### Create data resampled to 1 second
dfresamp1s = dfresamp.groupby(level=['Condition','Trial']).apply(lambda x: x.resample('1s', on='Timestamp', closed='right', label='right').mean())
pupilcols = ['Subject', 'Session', 'Trial', 'Condition', 'Timestamp',
'Dilation', 'Baseline', 'DiameterPupilLRFilt', 'BlinksLR']
pupildf = dfresamp1s.reset_index()[pupilcols].sort_values(by=['Trial','Timestamp'])
pupildf = pupildf[pupilcols].rename(columns={'DiameterPupilLRFilt':'Diameter',
'BlinksLR':'BlinkPct'})
# Set subject ID and session as (as type string)
pupildf['Subject'] = subid
pupildf['Session'] = timepoint
pupildf['Timestamp'] = pd.to_datetime(pupildf.Timestamp).dt.strftime('%H:%M:%S')
pupil_outname = pupil_utils.get_proc_outfile(fname, '_ProcessedPupil.csv')
print('Writing processed data to {0}'.format(pupil_outname))
pupildf.to_csv(pupil_outname, index=False)
plot_trials(pupildf, fname)
#### Create data for 15 second blocks
dfresamp15s = dfresamp.groupby(level=['Condition','Trial']).apply(lambda x: x.resample('15s', on='Timestamp', closed='right', label='right').mean())
pupilcols = ['Subject', 'Session', 'Trial', 'Condition', 'Timestamp',
'Dilation', 'Baseline', 'DiameterPupilLRFilt', 'BlinksLR']
pupildf15s = dfresamp15s.reset_index()[pupilcols].sort_values(by=['Trial','Timestamp'])
pupildf15s = pupildf15s[pupilcols].rename(columns={'DiameterPupilLRFilt':'Diameter',
'BlinksLR':'BlinkPct'})
# Set subject ID as (as type string)
pupildf15s['Subject'] = subid
pupildf15s['Session'] = timepoint
pupildf15s['Timestamp'] = pd.to_datetime(pupildf15s.Timestamp).dt.strftime('%H:%M:%S')
pupil15s_outname = pupil_utils.get_proc_outfile(fname, '_ProcessedPupil_Quartiles.csv')
'Writing quartile data to {0}'.format(pupil15s_outname)
pupildf15s.to_csv(pupil15s_outname, index=False)
def plot_trials(pupildf, fname):
sns.set_style("ticks")
p = sns.lineplot(data=pupildf, x="Timestamp", y="Dilation")
plt.tight_layout()
plot_outname = pupil_utils.get_proc_outfile(fname, "_PupilPlot.png")
plot_outname = plot_outname.replace("-Delay", "-Recall")
p.figure.savefig(plot_outname)
plt.close()
def rename_gaze_file(fname, subid, session):
procdir = os.path.dirname(pupil_utils.get_proc_outfile(fname, ''))
new_fname = ''.join([
'Oddball-',
str(subid), '-Session',
str(session), '_recoded.gazedata'
])
newfile = os.path.join(procdir, new_fname)
return newfile
def plot_trials(pupildf, fname):
pupildf['Time'] = pd.to_datetime(pupildf.Timestamp).dt.second
palette = sns.cubehelix_palette(len(pupildf.Load.unique()))
p = sns.lineplot(data=pupildf, x="Time",y="Dilation", hue="Load", palette=palette, legend="brief", ci=None)
plt.xticks(rotation=45)
plt.ylim(-.2, .5)
plt.tight_layout()
plot_outname = pupil_utils.get_proc_outfile(fname, "_PupilPlot.png")
p.figure.savefig(plot_outname)
plt.close()
def plot_trials(pupildf, fname):
sns.set_style("ticks")
palette = sns.color_palette("deep", n_colors=len(pupildf.Trial.unique()))
p = sns.lineplot(data=pupildf, x="Timestamp",y="Dilation", hue="Trial", palette=palette, legend="brief")
plt.xticks(rotation=45)
plt.ylim(-1.0, 1.0)
plt.tight_layout()
plt.legend(loc='best')
plot_outname = pupil_utils.get_proc_outfile(fname, "_PupilPlot.png")
p.figure.savefig(plot_outname)
plt.close()
def proc_subject(filelist):
"""
Given an infile of raw pupil data, saves out:
1) Session level data with dilation data summarized for each trial
2) Dataframe of average peristumulus timecourse for each condition
3) Plot of average peristumulus timecourse for each condition
4) Percent of samples with blinks
"""
for fname in filelist:
print('Processing {}'.format(fname))
if (os.path.splitext(fname)[-1]
== ".gazedata") | (os.path.splitext(fname)[-1] == ".csv"):
df = pd.read_csv(fname, sep="\t")
elif os.path.splitext(fname)[-1] == ".xlsx":
df = pd.read_excel(fname)
else:
raise IOError('Could not open {}'.format(fname))
subid = pupil_utils.get_subid(df['Subject'], fname)
timepoint = pupil_utils.get_timepoint(df['Session'], fname)
# Keep only samples after last sample of Recall
df = df[df[df.CurrentObject == "Recall"].index[-1] + 1:]
df = pupil_utils.deblink(df)
dfresamp = clean_trials(df)
alltrialsdf = proc_all_trials(dfresamp)
# Remove trials with >50% blinks
alltrialsdf = alltrialsdf[alltrialsdf.BlinkPct < .50]
plot_trials(alltrialsdf, fname)
pupildf = alltrialsdf.groupby(['Condition', 'Timestamp'])[[
'Baseline', 'DiameterPupilLRFilt', 'Dilation', 'BlinksLR',
'Duration'
]].mean()
pupildf['ntrials'] = alltrialsdf.groupby(['Condition',
'Timestamp']).size()
pupildf = pupildf.reset_index()
pupildf['Subject'] = subid
pupildf['Session'] = timepoint
pupildf = pupildf.rename(columns={
'DiameterPupilLRFilt': 'Diameter',
'BlinksLR': 'BlinkPct'
})
# Reorder columns
cols = [
'Subject', 'Session', 'Baseline', 'Timestamp', 'Diameter',
'Dilation', 'BlinkPct', 'Duration', 'Condition', 'ntrials'
]
pupildf = pupildf[cols]
pupil_outname = pupil_utils.get_proc_outfile(fname,
'_ProcessedPupil.csv')
pupil_outname = pupil_outname.replace("HVLT_Recall-Recognition",
"HVLT_Recognition")
pupil_outname = pupil_outname.replace("-Delay", "-Recognition")
pupildf.to_csv(pupil_outname, index=False)
print('Writing processed data to {0}'.format(pupil_outname))
def save_total_blink_pct(dfresamp, infile):
"""Calculate and save out percent of trials with blinks in session"""
outfile = pupil_utils.get_proc_outfile(infile, '_BlinkPct.json')
blink_dict = {}
blink_dict['TotalBlinkPct'] = float(dfresamp.BlinksLR.mean())
blink_dict['Subject'] = str(dfresamp.loc[dfresamp.index[0], 'Subject'])
blink_dict['Session'] = int(dfresamp.loc[dfresamp.index[0], 'Session'])
blink_json = json.dumps(blink_dict)
with open(outfile, 'w') as f:
f.write(blink_json)
def proc_subject(filelist):
"""
Given an infile of raw pupil data, saves out:
1) Session level data with dilation data summarized for each trial
2) Dataframe of average peristumulus timecourse for each condition
3) Plot of average peristumulus timecourse for each condition
4) Percent of samples with blinks
"""
for fname in filelist:
print('Processing {}'.format(fname))
if (os.path.splitext(fname)[-1]
== ".gazedata") | (os.path.splitext(fname)[-1] == ".csv"):
df = pd.read_csv(fname, sep="\t")
elif os.path.splitext(fname)[-1] == ".xlsx":
df = pd.read_excel(fname)
else:
raise IOError('Could not open {}'.format(fname))
subid = pupil_utils.get_subid(df['Subject'], fname)
timepoint = pupil_utils.get_timepoint(df['Session'], fname)
# Keep only samples after last sample of Recall
df = df[df[df.CurrentObject == "Recall"].index[-1] + 1:]
df = pupil_utils.deblink(df)
dfresamp = pupil_utils.resamp_filt_data(df,
filt_type='low',
string_cols=['CurrentObject'])
# Resampling fills forward fills Current Object when missing. This
# results in values of "Response" at beginning of trials. Reaplce these
# by backfilling from first occurrence of "Fixation" in every trial.
for i in dfresamp.TrialId.unique():
trialstartidx = (dfresamp.TrialId == i).idxmax()
fixstartidx = (
dfresamp.loc[dfresamp.TrialId == i,
"CurrentObject"] == "Fixation").idxmax()
dfresamp.loc[trialstartidx:fixstartidx,
"CurrentObject"] = "Fixation"
dfresamp = clean_trials(df)
pupildf = proc_all_trials(dfresamp)
pupildf['Subject'] = subid
pupildf['Session'] = timepoint
pupildf = pupildf.rename(columns={
'DiameterPupilLRFilt': 'Diameter',
'BlinksLR': 'BlinkPct'
})
# Reorder columns
cols = [
'Subject', 'Session', 'TrialId', 'Baseline', 'Diameter',
'Dilation', 'BlinkPct', 'Duration', 'Condition'
]
pupildf = pupildf[cols]
pupil_outname = pupil_utils.get_proc_outfile(fname,
'_ProcessedPupil.csv')
pupil_outname = pupil_outname.replace("-Delay", "-Recognition")
pupildf.to_csv(pupil_outname, index=False)
print('Writing processed data to {0}'.format(pupil_outname))
def plot_pstc(allconddf, infile, trial_start=0.):
"""Plot peri-stimulus timecourse across all trials and split by condition"""
outfile = pupil_utils.get_proc_outfile(infile, '_PSTCplot.png')
p = sns.lineplot(data=allconddf,
x="Timepoint",
y="Dilation",
hue="Condition",
legend="brief")
plt.axvline(trial_start, color='k', linestyle='--')
p.figure.savefig(outfile)
plt.close()
def plot_trials(df, fname):
sns.set_style("ticks")
p = sns.lineplot(data=df, x="Timestamp", y="Dilation", hue="Condition")
plt.ylim(-.2, .5)
p.axvline(x=2.5, color='black', linestyle='--')
plt.tight_layout()
plot_outname = pupil_utils.get_proc_outfile(fname, "_PSTCPlot.png")
plot_outname = plot_outname.replace("HVLT_Recall-Recognition",
"HVLT_Recognition")
plot_outname = plot_outname.replace("-Delay", "-Recognition")
p.figure.savefig(plot_outname)
plt.close()
def plot_trials(pupildf, fname):
palette = sns.color_palette('muted',
n_colors=len(pupildf['Trial'].unique()))
p = sns.lineplot(data=pupildf,
x="Timestamp",
y="Dilation",
hue="Trial",
palette=palette,
legend="brief")
plt.xticks(rotation=45)
plt.tight_layout()
plot_outname = pupil_utils.get_proc_outfile(fname, "_PupilPlot.png")
p.figure.savefig(plot_outname)
plt.close()
def proc_subject(filelist):
"""Given an infile of raw pupil data, saves out:
1. Session level data with dilation data summarized for each trial
2. Dataframe of average peristumulus timecourse for each condition
3. Plot of average peristumulus timecourse for each condition
4. Percent of samples with blinks """
for fname in filelist:
print('Processing {}'.format(fname))
if (os.path.splitext(fname)[-1]
== ".gazedata") | (os.path.splitext(fname)[-1] == ".csv"):
df = pd.read_csv(fname, sep="\t")
elif os.path.splitext(fname)[-1] == ".xlsx":
df = pd.read_excel(fname)
else:
raise IOError('Could not open {}'.format(fname))
subid = pupil_utils.get_subid(df['Subject'], fname)
timepoint = pupil_utils.get_timepoint(df['Session'], fname)
trialevents = get_trial_events(df)
dfresamp = clean_trials(trialevents)
dfresamp = dfresamp.reset_index(level='Timestamp').set_index(
['Load', 'Trial'])
# # Save out dfresamp for cleaned pupil at 30Hz for individuals trials
# pupil_outname = pupil_utils.get_proc_outfile(fname, '_ProcessedPupil30Hz.csv')
# pupildf.to_csv(pupil_outname, index=True)
# Take average of each second
dfresamp1s = dfresamp.groupby(
level=['Load', 'Trial']).apply(lambda x: x.resample(
'1s', on='Timestamp', closed='right', label='right').mean()
).reset_index()
# Select and rename columns of interest
pupilcols = [
'Subject', 'Trial', 'Load', 'Timestamp', 'Dilation', 'Baseline',
'DiameterPupilLRFilt', 'BlinksLR'
]
dfresamp1s = dfresamp1s[pupilcols].rename(columns={
'DiameterPupilLRFilt': 'Diameter',
'BlinksLR': 'BlinkPct'
})
# Save out individual trial data for Wang Lab
intermed_outname = pupil_utils.get_proc_outfile(
fname, '_AllTrials.csv')
intermed_outname = intermed_outname.replace('Processed Pupil Data',
'Wang Lab')
if not os.path.exists(os.path.dirname(intermed_outname)):
os.makedirs(os.path.dirname(intermed_outname))
dfresamp1s['Timestamp'] = dfresamp1s.Timestamp.dt.strftime('%H:%M:%S')
dfresamp1s.to_csv(intermed_outname, index=False)
def proc_subject(filelist):
"""Given an infile of raw pupil data, saves out:
1. Session level data with dilation data summarized for each trial
2. Dataframe of average peristumulus timecourse for each condition
3. Plot of average peristumulus timecourse for each condition
4. Percent of samples with blinks """
for fname in filelist:
print('Processing {}'.format(fname))
if (os.path.splitext(fname)[-1] == ".gazedata") | (os.path.splitext(fname)[-1] == ".csv"):
df = pd.read_csv(fname, sep="\t")
elif os.path.splitext(fname)[-1] == ".xlsx":
df = pd.read_excel(fname)
else:
raise IOError('Could not open {}'.format(fname))
subid = pupil_utils.get_subid(df['Subject'], fname)
timepoint = pupil_utils.get_timepoint(df['Session'], fname)
trialevents = get_trial_events(df)
dfresamp = clean_trials(trialevents)
dfresamp = dfresamp.reset_index(level='Timestamp').set_index(['Load','Trial'])
# # Save out dfresamp for cleaned pupil at 30Hz for individuals trials
# pupil_outname = pupil_utils.get_proc_outfile(fname, '_ProcessedPupil30Hz.csv')
# pupildf.to_csv(pupil_outname, index=True)
# Take average of each second
dfresamp1s = dfresamp.groupby(level=['Load','Trial']).apply(lambda x: x.resample('1s', on='Timestamp', closed='right', label='right').mean()).reset_index()
# Select and rename columns of interest
pupilcols = ['Subject', 'Trial', 'Load', 'Timestamp', 'Dilation',
'Baseline', 'DiameterPupilLRFilt', 'BlinksLR']
dfresamp1s = dfresamp1s[pupilcols].rename(columns={'DiameterPupilLRFilt':'Diameter',
'BlinksLR':'BlinkPct'})
# Set samples with >50% blinks to missing
dfresamp1s.loc[dfresamp1s.BlinkPct>.5, ['Dilation','Baseline','Diameter','BlinkPct']] = np.nan
# Drop missing samples and average of trials within load
pupildf = dfresamp1s.groupby(['Load','Timestamp']).mean()
# Set subject ID and session as (as type string)
pupildf['Subject'] = subid
pupildf['Session'] = timepoint
# Add number of non-missing trials that contributed to each sample average
pupildf['ntrials'] = dfresamp1s.dropna(subset=['Dilation']).groupby(['Load','Timestamp']).size()
pupildf = pupildf.reset_index()
pupildf['Timestamp'] = pupildf.Timestamp.dt.strftime('%H:%M:%S')
pupildf = pupildf[['Subject','Session','Load','Timestamp','Baseline','Diameter','Dilation','BlinkPct','ntrials']]
pupil_outname = pupil_utils.get_proc_outfile(fname, '_ProcessedPupil.csv')
print('Writing processed data to {0}'.format(pupil_outname))
# Save out data and plots
pupildf.to_csv(pupil_outname, index=False)
plot_trials(pupildf, fname)
def proc_subject(filelist):
"""Given an infile of raw pupil data, saves out:
1. Session level data with dilation data summarized for each trial
2. Dataframe of average peristumulus timecourse for each condition
3. Plot of average peristumulus timecourse for each condition
4. Percent of samples with blinks """
for fname in filelist:
print('Processing {}'.format(fname))
if (os.path.splitext(fname)[-1]
== ".gazedata") | (os.path.splitext(fname)[-1] == ".csv"):
df = pd.read_csv(fname, sep="\t")
elif os.path.splitext(fname)[-1] == ".xlsx":
df = pd.read_excel(fname)
else:
raise IOError('Could not open {}'.format(fname))
subid = pupil_utils.get_subid(df['Subject'], fname)
timepoint = pupil_utils.get_timepoint(df['Session'], fname)
trialevents = get_trial_events(df)
dfresamp = clean_trials(trialevents)
pupildf = dfresamp.groupby(['Trial',
'CurrentObject']).mean().reset_index()
pupildf['Word'] = pupildf.CurrentObject.str.replace('PlayWord',
'').astype('int')
pupilcols = [
'Subject', 'Session', 'Trial', 'Word', 'Dilation', 'Baseline',
'DiameterPupilLRFilt', 'BlinksLR'
]
pupildf = pupildf[pupilcols]
pupildf = pupildf.sort_values(by=['Trial', 'Word'])
# Set subject ID and session as (as type string)
pupildf['Subject'] = subid
pupildf['Session'] = timepoint
pupildf = pupildf[pupilcols].rename(columns={
'DiameterPupilLRFilt': 'Diameter',
'BlinksLR': 'BlinkPct'
})
pupil_outname = pupil_utils.get_proc_outfile(fname,
'_ProcessedPupil.csv')
pupildf.to_csv(pupil_outname, index=False)
print('Writing processed data to {0}'.format(pupil_outname))
plot_trials(pupildf, fname)
def plot_event(signal_filt,
con_ts,
incon_ts,
neut_ts,
kernel,
infile,
plot_kernel=True):
"""Plot peri-stimulus timecourse of each event type as well as the
canonical pupil response function"""
outfile = pupil_utils.get_proc_outfile(infile, '_PSTCplot.png')
plt.ioff()
all_events = con_ts.data + (incon_ts.data * 2) + (neut_ts.data * 3)
all_events_ts = ts.TimeSeries(all_events, sampling_rate=30., time_unit='s')
all_era = nta.EventRelatedAnalyzer(signal_filt,
all_events_ts,
len_et=90,
correct_baseline=False)
fig, ax = plt.subplots()
viz.plot_tseries(all_era.eta, yerror=all_era.ets, fig=fig)
if plot_kernel:
ax.plot((all_era.eta.time * (10**-12)), kernel)
ax.legend(['Congruent', 'Incongruent', 'Neutral'])
fig.savefig(outfile)
plt.close(fig)
def proc_subject(filelist):
"""Given an infile of raw pupil data, saves out:
1. Session level data with dilation data summarized for each trial
2. Dataframe of average peristumulus timecourse for each condition
3. Plot of average peristumulus timecourse for each condition
4. Percent of samples with blinks """
tpre = 0.250
tpost = 2.5
samp_rate = 30.
for pupil_fname in filelist:
print('Processing {}'.format(pupil_fname))
if (os.path.splitext(pupil_fname)[-1] == ".gazedata") | (
os.path.splitext(pupil_fname)[-1] == ".csv"):
df = pd.read_csv(pupil_fname, sep="\t")
elif os.path.splitext(pupil_fname)[-1] == ".xlsx":
df = pd.read_excel(pupil_fname, parse_dates=False)
else:
raise IOError('Could not open {}'.format(pupil_fname))
subid = pupil_utils.get_subid(df['Subject'], pupil_fname)
timepoint = pupil_utils.get_timepoint(df['Session'], pupil_fname)
df = pupil_utils.deblink(df)
df.CurrentObject.replace('StimulusRecord', 'Stimulus', inplace=True)
dfresamp = pupil_utils.resamp_filt_data(
df, filt_type='band', string_cols=['TrialId', 'CurrentObject'])
dfresamp = dfresamp.drop(columns='TrialId_x').rename(
columns={'TrialId_y': 'TrialId'})
eprime_fname = get_eprime_fname(pupil_fname)
eprime = pd.read_csv(eprime_fname,
sep='\t',
encoding='utf-16',
skiprows=0)
if not np.array_equal(eprime.columns[:3],
['ExperimentName', 'Subject', 'Session']):
eprime = pd.read_csv(eprime_fname,
sep='\t',
encoding='utf-16',
skiprows=1)
eprime = eprime.rename(columns={"Congruency": "Condition"})
pupil_utils.plot_qc(dfresamp, pupil_fname)
sessdf = get_sessdf(dfresamp, eprime)
sessdf['BlinkPct'] = get_blink_pct(dfresamp, pupil_fname)
dfresamp['zDiameterPupilLRFilt'] = pupil_utils.zscore(
dfresamp['DiameterPupilLRFilt'])
condf, incondf, neutraldf = proc_all_trials(
sessdf, dfresamp['zDiameterPupilLRFilt'], tpre, tpost, samp_rate)
condf_long = reshape_df(condf)
incondf_long = reshape_df(incondf)
neutraldf_long = reshape_df(neutraldf)
glm_results = ts_glm(dfresamp.zDiameterPupilLRFilt,
sessdf.loc[sessdf.Condition == 'C', 'Timestamp'],
sessdf.loc[sessdf.Condition == 'I', 'Timestamp'],
sessdf.loc[sessdf.Condition == 'N',
'Timestamp'], dfresamp.BlinksLR)
# Set subject ID and session as (as type string)
glm_results['Subject'] = subid
glm_results['Session'] = timepoint
save_glm_results(glm_results, pupil_fname)
allconddf = condf_long.append(incondf_long).reset_index(drop=True)
allconddf = allconddf.append(neutraldf_long).reset_index(drop=True)
# Set subject ID and session as (as type string)
allconddf['Subject'] = subid
allconddf['Session'] = timepoint
allconddf = allconddf[allconddf.Timepoint < 3.0]
plot_pstc(allconddf, pupil_fname)
save_pstc(allconddf, pupil_fname)
sessdf['Subject'] = subid
sessdf['Session'] = timepoint
sessout = pupil_utils.get_proc_outfile(pupil_fname, '_SessionData.csv')
sessdf.to_csv(sessout, index=False)
def save_pstc(allconddf, infile):
"""Save out peristimulus timecourse plots"""
outfile = pupil_utils.get_proc_outfile(infile, '_PSTCdata.csv')
pstcdf = allconddf.groupby(['Subject', 'Condition',
'Timepoint']).mean().reset_index()
pstcdf.to_csv(outfile, index=False)
def save_glm_results(glm_results, infile):
"""Calculate and save out percent of trials with blinks in session"""
glm_json = json.dumps(glm_results)
outfile = pupil_utils.get_proc_outfile(infile, '_GLMresults.json')
with open(outfile, 'w') as f:
f.write(glm_json)
