def pdipole_exp(ddata, ylim=[]):
""" over ALL trials in ALL conditions in EACH experiment
"""
# sim_prefix
fprefix = ddata.sim_prefix
# create the figure name
fname_exp = '%s_dpl' % (fprefix)
fname_exp_fig = os.path.join(ddata.dsim, fname_exp + '.png')
# create one figure comparing across all
N_expmt_groups = len(ddata.expmt_groups)
f_exp = ac.FigDipoleExp(ddata.expmt_groups)
# empty list for the aggregate dipole data
dpl_exp = []
# go through each expmt
for expmt_group in ddata.expmt_groups:
# create the filename
dexp = ddata.dexpmt_dict[expmt_group]
fname_short = '%s-%s-dpl' % (fprefix, expmt_group)
fname_data = os.path.join(dexp, fname_short + '.txt')
fname_fig = os.path.join(ddata.dfig[expmt_group]['figdpl'], fname_short + '.png')
# grab the list of raw data dipoles and assoc params in this expmt
dpl_list = ddata.file_match(expmt_group, 'rawdpl')
param_list = ddata.file_match(expmt_group, 'param')
for f_dpl, f_param in zip(dpl_list, param_list):
dpl = Dipole(f_dpl)
dpl.baseline_renormalize(f_param)
# x_tmp = np.loadtxt(open(file, 'r'))
# initialize and use x_dpl
if f_dpl is dpl_list[0]:
# assume time vec stays the same throughout
t_vec = dpl.t
x_dpl = dpl.dpl['agg']
else:
# guaranteed to exist after dpl_list[0]
x_dpl += dpl.dpl['agg']
# poor man's mean
x_dpl /= len(dpl_list)
# save this in a list to do comparison figure
# order is same as ddata.expmt_groups
dpl_exp.append(x_dpl)
# write this data to the file
with open(fname_data, 'w') as f:
for t, x in zip(t_vec, x_dpl):
f.write("%03.3f\t%5.4f\n" % (t, x))
# create the plot I guess?
f = ac.FigStd()
f.ax0.plot(t_vec, x_dpl)
if len(ylim):
f.ax0.set_ylim(ylim)
f.savepng(fname_fig)
f.close()
# plot the aggregate data using methods defined in FigDipoleExp()
f_exp.plot(t_vec, dpl_exp)
# attempt at setting titles
for ax, expmt_group in zip(f_exp.ax, ddata.expmt_groups):
ax.set_title(expmt_group)
f_exp.savepng(fname_exp_fig)
f_exp.close()
def pdipole_evoked_aligned(ddata):
""" over ALL trials in ALL conditions in EACH experiment
appears to be iteration over pdipole_exp2()
"""
# grab the original dipole from a specific dir
dproj = fio.return_data_dir()
runtype = 'somethingotherthandebug'
# runtype = 'debug'
if runtype == 'debug':
ddate = '2013-04-08'
dsim = 'mubaseline-04-000'
i_ctrl = 0
else:
ddate = raw_input('Short date directory? ')
dsim = raw_input('Sim name? ')
i_ctrl = ast.literal_eval(raw_input('Sim number: '))
dcheck = os.path.join(dproj, ddate, dsim)
# create a blank ddata structure
ddata_ctrl = fio.SimulationPaths()
dsim = ddata_ctrl.read_sim(dproj, dcheck)
# find the mu_low and mu_high in the expmtgroup names
# this means the group names must be well formed
for expmt_group in ddata_ctrl.expmt_groups:
if 'mu_low' in expmt_group:
mu_low_group = expmt_group
elif 'mu_high' in expmt_group:
mu_high_group = expmt_group
# choose the first [0] from the list of the file matches for mu_low
fdpl_mu_low = ddata_ctrl.file_match(mu_low_group, 'rawdpl')[i_ctrl]
fparam_mu_low = ddata_ctrl.file_match(mu_low_group, 'param')[i_ctrl]
fspk_mu_low = ddata_ctrl.file_match(mu_low_group, 'rawspk')[i_ctrl]
fspec_mu_low = ddata_ctrl.file_match(mu_low_group, 'rawspec')[i_ctrl]
# choose the first [0] from the list of the file matches for mu_high
fdpl_mu_high = ddata_ctrl.file_match(mu_high_group, 'rawdpl')[i_ctrl]
fparam_mu_high = ddata_ctrl.file_match(mu_high_group, 'param')[i_ctrl]
# grab the relevant dipole and renormalize it for mu_low
dpl_mu_low = Dipole(fdpl_mu_low)
dpl_mu_low.baseline_renormalize(fparam_mu_low)
# grab the relevant dipole and renormalize it for mu_high
dpl_mu_high = Dipole(fdpl_mu_high)
dpl_mu_high.baseline_renormalize(fparam_mu_high)
# input feed information
s = spikefn.spikes_from_file(fparam_mu_low, fspk_mu_low)
_, p_ctrl = paramrw.read(fparam_mu_low)
s = spikefn.alpha_feed_verify(s, p_ctrl)
s = spikefn.add_delay_times(s, p_ctrl)
# find tstop, assume same over all. grab the first param file, get the tstop
tstop = paramrw.find_param(fparam_mu_low, 'tstop')
# hard coded bin count for now
n_bins = spikefn.bin_count(150., tstop)
# sim_prefix
fprefix = ddata.sim_prefix
# create the figure name
fname_exp = '%s_dpl_align' % (fprefix)
fname_exp_fig = os.path.join(ddata.dsim, fname_exp + '.png')
# create one figure comparing across all
N_expmt_groups = len(ddata.expmt_groups)
ax_handles = [
'spec',
'input',
'dpl_mu',
'spk',
]
f_exp = ac.FigDipoleExp(ax_handles)
# plot the ctrl dipoles
f_exp.ax['dpl_mu'].plot(dpl_mu_low.t, dpl_mu_low.dpl, color='k')
f_exp.ax['dpl_mu'].hold(True)
f_exp.ax['dpl_mu'].plot(dpl_mu_high.t, dpl_mu_high.dpl)
# function creates an f_exp.ax_twinx list and returns the index of the new feed
f_exp.create_axis_twinx('input')
# input hist information: predicated on the fact that the input histograms
# should be identical for *all* of the inputs represented in this figure
# places 2 histograms on two axes (meant to be one axis flipped)
hists = spikefn.pinput_hist(f_exp.ax['input'], f_exp.ax_twinx['input'], s['alpha_feed_prox'].spike_list, s['alpha_feed_dist'].spike_list, n_bins)
# grab the max counts for both hists
# the [0] item of hist are the counts
max_hist = np.max([np.max(hists[key][0]) for key in hists.keys()])
ymax = 2 * max_hist
# plot the spec here
pc = specfn.pspec_ax(f_exp.ax['spec'], fspec_mu_low)
# deal with the axes here
f_exp.ax['input'].set_ylim((0, ymax))
f_exp.ax_twinx['input'].set_ylim((ymax, 0))
# f_exp.ax[1].set_ylim((0, ymax))
# f_exp.ax[1].set_xlim((50., tstop))
# turn hold on
f_exp.ax[dpl_mu].hold(True)
# empty list for the aggregate dipole data
dpl_exp = []
# go through each expmt
# calculation is extremely redundant
for expmt_group in ddata.expmt_groups:
# a little sloppy, just find the param file
# this param file was for the baseline renormalization and
# assumes it's the same in all for this expmt_group
# also for getting the gid_dict, also assumed to be the same
fparam = ddata.file_match(expmt_group, 'param')[0]
# general check to see if the aggregate dipole data exists
if 'mu_low' in expmt_group or 'mu_high' in expmt_group:
# check to see if these files exist
flist = ddata.find_aggregate_file(expmt_group, 'dpl')
# if no file exists, then find one
if not len(flist):
calc_aggregate_dipole(ddata)
flist = ddata.find_aggregate_file(expmt_group, 'dpl')
# testing the first file
list_spk = ddata.file_match(expmt_group, 'rawspk')
list_s_dict = [spikefn.spikes_from_file(fparam, fspk) for fspk in list_spk]
list_evoked = [s_dict['evprox0'].spike_list[0][0] for s_dict in list_s_dict]
lines_spk = [f_exp.ax['dpl_mu'].axvline(x=x_val, linewidth=0.5, color='r') for x_val in list_evoked]
lines_spk = [f_exp.ax['spk'].axvline(x=x_val, linewidth=0.5, color='r') for x_val in list_evoked]
# handle mu_low and mu_high separately
if 'mu_low' in expmt_group:
dpl_mu_low_ev = Dipole(flist[0])
dpl_mu_low_ev.baseline_renormalize(fparam)
f_exp.ax['spk'].plot(dpl_mu_low_ev.t, dpl_mu_low_ev.dpl, color='k')
# get xlim stuff
t0 = dpl_mu_low_ev.t[0]
T = dpl_mu_low_ev.t[-1]
elif 'mu_high' in expmt_group:
dpl_mu_high_ev = Dipole(flist[0])
dpl_mu_high_ev.baseline_renormalize(fparam)
f_exp.ax['spk'].plot(dpl_mu_high_ev.t, dpl_mu_high_ev.dpl, color='b')
f_exp.ax['input'].set_xlim(50., tstop)
for ax_name in f_exp.ax_handles[2:]:
ax.set_xlim((t0, T))
f_exp.savepng(fname_exp_fig)
f_exp.close()
def pkernel(dfig_dpl, f_dpl, f_spk, f_spec, f_current, f_spec_current, f_param, ax_handles, spec_cmap='jet'):
T = paramrw.find_param(f_param, 'tstop')
xlim = (50., T)
# into the pdipole directory, this will plot dipole, spec, and spikes
# create the axis handle
f = ac.FigDipoleExp(ax_handles)
# create the figure name
fprefix = fio.strip_extprefix(f_dpl) + '-dpl'
fname = os.path.join(dfig_dpl, fprefix + '.png')
# grab the dipole
dpl = dipolefn.Dipole(f_dpl)
dpl.convert_fAm_to_nAm()
# plot the dipole to the agg axes
dpl.plot(f.ax['dpl_agg'], xlim)
dpl.plot(f.ax['dpl_agg_L5'], xlim)
# f.ax['dpl_agg_L5'].hold(True)
# dpl.plot(f.ax['dpl_agg_L5'], xlim, 'L5')
# plot individual dipoles
dpl.plot(f.ax['dpl'], xlim, 'L2')
dpl.plot(f.ax['dpl_L5'], xlim, 'L5')
# f.ysymmetry(f.ax['dpl'])
# print dpl.max('L5', (0., -1)), dpl.max('L5', (50., -1))
# print f.ax['dpl_L5'].get_ylim()
# f.ax['dpl_L5'].set_ylim((-1e5, 1e5))
# f.ysymmetry(f.ax['dpl_L5'])
# plot the current
I_soma = currentfn.SynapticCurrent(f_current)
I_soma.plot_to_axis(f.ax['I_soma'], 'L2')
I_soma.plot_to_axis(f.ax['I_soma_L5'], 'L5')
# plot the dipole-based spec data
pc = specfn.pspec_ax(f.ax['spec_dpl'], f_spec, xlim, 'L2')
f.f.colorbar(pc, ax=f.ax['spec_dpl'])
pc = specfn.pspec_ax(f.ax['spec_dpl_L5'], f_spec, xlim, 'L5')
f.f.colorbar(pc, ax=f.ax['spec_dpl_L5'])
# grab the current spec and plot them
spec_L2, spec_L5 = data_spec_current = specfn.read(f_spec_current, type='current')
pc_L2 = f.ax['spec_I'].imshow(spec_L2['TFR'], aspect='auto', origin='upper',cmap=plt.get_cmap(spec_cmap))
pc_L5 = f.ax['spec_I_L5'].imshow(spec_L5['TFR'], aspect='auto', origin='upper',cmap=plt.get_cmap(spec_cmap))
# plot the current-based spec data
# pci = specfn.pspec_ax(f.ax['spec_I'], f_spec_current, type='current')
f.f.colorbar(pc_L2, ax=f.ax['spec_I'])
f.f.colorbar(pc_L5, ax=f.ax['spec_I_L5'])
# get all spikes
s = spikefn.spikes_from_file(f_param, f_spk)
# these work primarily because of how the keys are done
# in the spike dict s (consequence of spikefn.spikes_from_file())
s_L2 = spikefn.filter_spike_dict(s, 'L2_')
s_L5 = spikefn.filter_spike_dict(s, 'L5_')
# resize xlim based on our 50 ms cutoff thingy
xlim = (50., xlim[1])
# plot the spikes
spikefn.spike_png(f.ax['spk'], s_L2)
spikefn.spike_png(f.ax['spk_L5'], s_L5)
f.ax['dpl'].set_xlim(xlim)
# f.ax['dpl_L5'].set_xlim(xlim)
# f.ax['spec_dpl'].set_xlim(xlim)
f.ax['spk'].set_xlim(xlim)
f.ax['spk_L5'].set_xlim(xlim)
f.savepng(fname)
f.close()
return 0
