def praster(f_param, tstop, file_spk, dfig):
# ddipole is dipole data
s_dict = spikefn.spikes_from_file(f_param, file_spk)
s_dict_L2 = {}
s_dict_L5 = {}
s_dict_L2_extgauss = {}
s_dict_L2_extpois = {}
s_dict_L5_extgauss = {}
s_dict_L5_extpois = {}
# clean out s_dict destructively
for key in s_dict.keys():
# do this first to remove all extgauss feeds
if 'extgauss' in key:
if 'L2_' in key:
s_dict_L2_extgauss[key] = s_dict.pop(key)
elif 'L5_' in key:
s_dict_L5_extgauss[key] = s_dict.pop(key)
elif 'extpois' in key:
# s_dict_extpois[key] = s_dict.pop(key)
if 'L2_' in key:
s_dict_L2_extpois[key] = s_dict.pop(key)
elif 'L5_' in key:
s_dict_L5_extpois[key] = s_dict.pop(key)
# L2 next
elif 'L2_' in key:
s_dict_L2[key] = s_dict.pop(key)
elif 'L5_' in key:
s_dict_L5[key] = s_dict.pop(key)
# split to find file prefix
file_prefix = file_spk.split('/')[-1].split('.')[0]
# create standard fig and axes
f = FigRaster(tstop)
spikefn.spike_png(f.ax['L2'], s_dict_L2)
spikefn.spike_png(f.ax['L5'], s_dict_L5)
spikefn.spike_png(f.ax['L2_extpois'], s_dict_L2_extpois)
spikefn.spike_png(f.ax['L2_extgauss'], s_dict_L2_extgauss)
spikefn.spike_png(f.ax['L5_extpois'], s_dict_L5_extpois)
spikefn.spike_png(f.ax['L5_extgauss'], s_dict_L5_extgauss)
# testfig.ax0.plot(t_vec, dp_total)
fig_name = os.path.join(dfig, file_prefix + '.png')
plt.savefig(fig_name, dpi=300)
f.close()
def pfreqpwr_with_hist(file_name, freqpwr_result, f_spk, gid_dict, p_dict,
key_types):
f = ac.FigFreqpwrWithHist()
f.ax['hist'].hold(True)
xmin = 50.
xmax = p_dict['tstop']
f.ax['freqpwr'].plot(freqpwr_result['freq'], freqpwr_result['avgpwr'])
# grab alpha feed data. spikes_from_file() from spikefn.py
s_dict = spikefn.spikes_from_file(gid_dict, f_spk)
# check for existance of alpha feed keys in s_dict.
s_dict = spikefn.alpha_feed_verify(s_dict, p_dict)
# Account for possible delays
s_dict = spikefn.add_delay_times(s_dict, p_dict)
# set number of bins (150 bins/1000ms)
bins = 150. * (xmax - xmin) / 1000.
hist_data = []
# Proximal feed
hist_data.extend(f.ax['hist'].hist(s_dict['alpha_feed_prox'].spike_list,
bins,
range=[xmin, xmax],
color='red',
label='Proximal feed')[0])
# Distal feed
hist_data.extend(f.ax['hist'].hist(s_dict['alpha_feed_dist'].spike_list,
bins,
range=[xmin, xmax],
color='green',
label='Distal feed')[0])
# set hist axis props
f.set_hist_props(hist_data)
# axis labels
f.ax['freqpwr'].set_xlabel('freq (Hz)')
f.ax['freqpwr'].set_ylabel('power')
f.ax['hist'].set_xlabel('time (ms)')
f.ax['hist'].set_ylabel('# spikes')
# create title
title_str = ac.create_title(p_dict, key_types)
f.f.suptitle(title_str)
# title_str = [key + ': %2.1f' % p_dict[key] for key in key_types['dynamic_keys']]
f.savepng(file_name)
f.close()
def exec_spike_rates(ddata, opts):
# opts should be:
# opts_default = {
# expmt_group: 'something',
# celltype: 'L5_pyramidal',
# }
expmt_group = opts['expmt_group']
celltype = opts['celltype']
list_f_spk = ddata.file_match(expmt_group, 'rawspk')
list_f_param = ddata.file_match(expmt_group, 'param')
# note! this is NOT ignoring first 50 ms
for fspk, fparam in zip(list_f_spk, list_f_param):
s_all = spikefn.spikes_from_file(fparam, fspk)
_, p_dict = paramrw.read(fparam)
T = p_dict['tstop']
# check if the celltype is in s_all
if celltype in s_all.keys():
s = s_all[celltype].spike_list
n_cells = len(s)
# grab all the sp_counts
sp_counts = np.array([len(spikes_cell) for spikes_cell in s])
# calc mean and stdev
sp_count_mean = np.mean(sp_counts)
sp_count_stdev = np.std(sp_counts)
# calc rate in Hz, assume T in ms
sp_rates = sp_counts * 1000. / T
sp_rate_mean = np.mean(sp_rates)
sp_rate_stdev = np.std(sp_rates)
# direct
sp_rate = sp_count_mean * 1000. / T
print "Sim No. %i, Trial %i, celltype is %s:" % (p_dict['Sim_No'], p_dict['Trial'], celltype)
print " spike count mean is: %4.3f" % sp_count_mean
print " spike count stdev is: %4.3f" % sp_count_stdev
print " spike rate over %4.3f ms is %4.3f Hz +/- %4.3f" % (T, sp_rate_mean, sp_rate_stdev)
print " spike rate over %4.3f ms is %4.3f Hz" % (T, sp_rate)
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 pdipole_evoked(dfig, f_dpl, f_spk, f_param, ylim=[]):
""" for each individual simulation/trial
"""
gid_dict, p_dict = paramrw.read(f_param)
# get the spike dict from the files
s_dict = spikefn.spikes_from_file(f_param, f_spk)
s = s_dict.keys()
s.sort()
# create an empty dict 'spk_unique'
spk_unique = dict.fromkeys([key for key in s_dict.keys() if key.startswith(('evprox', 'evdist'))])
for key in spk_unique:
spk_unique[key] = s_dict[key].unique_all(0)
# draw vertical lines for each item in this
# x_dipole is dipole data
# x_dipole = np.loadtxt(open(f_dpl, 'r'))
dpl = Dipole(f_dpl)
# split to find file prefix
file_prefix = f_dpl.split('/')[-1].split('.')[0]
# # set xmin value
# xmin = xlim[0] / p_dict['dt']
# # set xmax value
# if xlim[1] == 'tstop':
# xmax = p_dict['tstop'] / p_dict['dt']
# else:
# xmax = xlim[1] / p_dict['dt']
# these are the vectors for now, but this is going to change
t_vec = dpl.t
dp_total = dpl.dpl['agg']
f = ac.FigStd()
# hold on
f.ax0.hold(True)
f.ax0.plot(t_vec, dp_total)
lines_spk = dict.fromkeys(spk_unique)
print(spk_unique)
# plot the lines
for key in spk_unique:
print(key, spk_unique[key])
x_val = spk_unique[key][0]
lines_spk[key] = plt.axvline(x=x_val, linewidth=0.5, color='r')
# title_txt = [key + ': {:.2e}' % p_dict[key] for key in key_types['dynamic_keys']]
title_txt = 'test'
f.ax0.set_title(title_txt)
if ylim:
f.ax0.set_ylim(ylim)
fig_name = os.path.join(dfig, file_prefix+'.png')
plt.savefig(fig_name, dpi=300)
f.close()
def calc_avgdpl_stimevoked(ddata):
for expmt_group in ddata.expmt_groups:
# create the filename
dexp = ddata.dexpmt_dict[expmt_group]
fname_short = '%s-%s-dpl' % (ddata.sim_prefix, expmt_group)
fname_data = os.path.join(dexp, fname_short + '.txt')
# grab the list of raw data dipoles and assoc params in this expmt
fdpl_list = ddata.file_match(expmt_group, 'rawdpl')
param_list = ddata.file_match(expmt_group, 'param')
spk_list = ddata.file_match(expmt_group, 'rawspk')
# actual list of Dipole() objects
dpl_list = [Dipole(fdpl) for fdpl in fdpl_list]
t_truncated = []
# iterate through the lists, grab the spike time, phase align the signals,
# cut them to length, and then mean the dipoles
for dpl, f_spk, f_param in zip(dpl_list, spk_list, param_list):
_, p = paramrw.read(f_param)
# grab the corresponding relevant starting spike time
s = spikefn.spikes_from_file(f_param, f_spk)
s = spikefn.alpha_feed_verify(s, p)
s = spikefn.add_delay_times(s, p)
# t_evoked is the same for all of the cells in these simulations
t_evoked = s['evprox0'].spike_list[0][0]
# attempt to give a 50 ms buffer
if t_evoked > 50.:
t0 = t_evoked - 50.
else:
t0 = t_evoked
# truncate the dipole related vectors
dpl.t = dpl.t[dpl.t > t0]
dpl.dpl['agg'] = dpl.dpl['agg'][dpl.t > t0]
t_truncated.append(dpl.t[0])
# find the t0_max value to compare on other dipoles
t_truncated -= np.max(t_truncated)
for dpl, t_adj in zip(dpl_list, t_truncated):
# negative numbers mean that this vector needs to be shortened by that many ms
T_new = dpl.t[-1] + t_adj
dpl.dpl['agg'] = dpl.dpl['agg'][dpl.t < T_new]
dpl.t = dpl.t[dpl.t < T_new]
if dpl is dpl_list[0]:
dpl_total = dpl.dpl['agg']
else:
dpl_total += dpl.dpl['agg']
dpl_mean = dpl_total / len(dpl_list)
t_dpl = dpl_list[0].t
# write this data to the file
with open(fname_data, 'w') as f:
for t, x in zip(t_dpl, dpl_mean):
f.write("%03.3f\t%5.4f\n" % (t, x))
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
def aggregate_with_hist(f, ax, f_spec, f_dpl, f_spk, f_param):
# load param dict
_, p_dict = paramrw.read(f_param)
# load spec data from file
spec = specfn.Spec(f_spec)
# data_spec = np.load(f_spec)
# timevec = data_spec['time']
# freqvec = data_spec['freq']
# TFR = data_spec['TFR']
xmin = timevec[0]
xmax = p_dict['tstop']
x = (xmin, xmax)
pc = spec.plot_TFR(ax['spec'], layer='agg', xlim=x)
# pc = ax['spec'].imshow(TFR, extent=[timevec[0], timevec[-1], freqvec[-1], freqvec[0]], aspect='auto', origin='upper')
f.f.colorbar(pc,
ax=ax['spec'],
norm=plt.colors.Normalize(vmin=0, vmax=90000),
cmap=plt.get_cmap('jet'))
# grab the dipole data
dpl = dipolefn.Dipole(f_dpl)
dpl.plot(ax['dipole'], x, layer='agg')
# data_dipole = np.loadtxt(open(f_dpl, 'r'))
# t_dpl = data_dipole[xmin/p_dict['dt']:, 0]
# dp_total = data_dipole[xmin/p_dict['dt']:, 1]
# ax['dipole'].plot(t_dpl, dp_total)
# grab alpha feed data. spikes_from_file() from spikefn.py
s_dict = spikefn.spikes_from_file(f_param, f_spk)
# check for existance of alpha feed keys in s_dict.
s_dict = spikefn.alpha_feed_verify(s_dict, p_dict)
# Account for possible delays
s_dict = spikefn.add_delay_times(s_dict, p_dict)
# set number of bins (150 bins/1000ms)
bins = 150. * (xmax - xmin) / 1000.
hist = {}
# Proximal feed
hist['feed_prox'] = ax['feed_prox'].hist(
s_dict['alpha_feed_prox'].spike_list,
bins,
range=[xmin, xmax],
color='red',
label='Proximal feed')
# Distal feed
hist['feed_dist'] = ax['feed_dist'].hist(
s_dict['alpha_feed_dist'].spike_list,
bins,
range=[xmin, xmax],
color='green',
label='Distal feed')
# for now, set the xlim for the other one, force it!
ax['dipole'].set_xlim(x)
ax['spec'].set_xlim(x)
ax['feed_prox'].set_xlim(x)
ax['feed_dist'].set_xlim(x)
# set hist axis props
f.set_hist_props(ax, hist)
# axis labels
ax['spec'].set_xlabel('Time (ms)')
ax['spec'].set_ylabel('Frequency (Hz)')
# Add legend to histogram
for key in ax.keys():
if 'feed' in key:
ax[key].legend()
def ppsth_grid(simpaths):
# get filename lists in dictionaries of experiments
dict_exp_param = simpaths.exp_files_of_type('param')
dict_exp_spk = simpaths.exp_files_of_type('rawspk')
# recreate the ExpParams object used in the simulation
p_exp = paramrw.ExpParams(simpaths.fparam[0])
# need number of lambda vals (cols) and number of sigma vals (rows)
try:
N_rows = len(p_exp.p_all['L2Pyr_Gauss_A_weight'])
except TypeError:
N_rows = 1
try:
N_cols = len(p_exp.p_all['L2Basket_Pois_lamtha'])
except TypeError:
N_cols = 1
tstop = p_exp.p_all['tstop']
print N_rows, N_cols, tstop
# ugly but slightly less ugly than the index arithmetic i had planned. muahaha
f = ac.FigGrid(N_rows, N_cols, tstop)
# create coordinates for axes
# this is backward-looking for a reason!
axes_coords = [
(j, i) for i, j in it.product(np.arange(N_cols), np.arange(N_rows))
]
if len(simpaths.expnames) != len(axes_coords):
print "um ... see ppsth.py"
# assumes a match between expnames and the keys of the previous dicts
for expname, axis_coord in zip(simpaths.expnames, axes_coords):
# get the tstop
exp_param_list = dict_exp_param[expname]
exp_spk_list = dict_exp_spk[expname]
gid_dict, p = paramrw.read(exp_param_list[0])
tstop = p['tstop']
lamtha = p['L2Basket_Pois_lamtha']
sigma = p['L2Pyr_Gauss_A_weight']
# these are total spike dicts for the experiments
s_L2Pyr_list = []
# s_L5Pyr_list = []
# iterate through params and spikes for a given experiment
for fparam, fspk in zip(dict_exp_param[expname],
dict_exp_spk[expname]):
# get gid dict
gid_dict, p = paramrw.read(fparam)
# get spike dict
s_dict = spikefn.spikes_from_file(gid_dict, fspk)
# add a new entry to list for each different file assoc with an experiment
s_L2Pyr_list.append(
np.array(
list(
it.chain.from_iterable(
s_dict['L2_pyramidal'].spike_list))))
# s_L5Pyr_list.append(np.array(list(it.chain.from_iterable(s_dict['L5_pyramidal'].spike_list))))
# now aggregate over all spikes
s_L2Pyr = np.array(list(it.chain.from_iterable(s_L2Pyr_list)))
# s_L5Pyr = np.array(list(it.chain.from_iterable(s_L5Pyr_list)))
# optimize bins, currently unused for comparison reasons!
N_trials = len(fparam)
bin_L2 = 250
# bin_L5 = 120
# bin_L2 = spikefn.hist_bin_opt(s_L2Pyr, N_trials)
# bin_L5 = spikefn.hist_bin_opt(s_L5Pyr, N_trials)
r = axis_coord[0]
c = axis_coord[1]
# create standard fig and axes
f.ax[r][c].hist(s_L2Pyr, bin_L2, facecolor='g', alpha=0.75)
if r == 0:
f.ax[r][c].set_title(r'$\lambda_i$ = %d' % lamtha)
if c == 0:
f.ax[r][c].set_ylabel(r'$A_{gauss}$ = %.3e' % sigma)
# f.ax[r][c].set_ylabel(r'$\sigma_{gauss}$ = %d' % sigma)
# normalize these axes
y_L2 = f.ax[r][c].get_ylim()
# y_L2 = f.ax['L2_psth'].get_ylim()
print expname, lamtha, sigma, r, c, y_L2[1]
f.ax[r][c].set_ylim((0, 250.))
# f.ax['L2_psth'].set_ylim((0, 450.))
# f.ax['L5_psth'].set_ylim((0, 450.))
# spikefn.spike_png(f.ax['L2'], s_dict_L2)
# spikefn.spike_png(f.ax['L5'], s_dict_L5)
# spikefn.spike_png(f.ax['L2_extpois'], s_dict_L2_extpois)
# spikefn.spike_png(f.ax['L2_extgauss'], s_dict_L2_extgauss)
# spikefn.spike_png(f.ax['L5_extpois'], s_dict_L5_extpois)
# spikefn.spike_png(f.ax['L5_extgauss'], s_dict_L5_extgauss)
# testfig.ax0.plot(t_vec, dp_total)
fig_name = os.path.join(simpaths.dsim, 'aggregate.eps')
plt.savefig(fig_name)
f.close()
# run the compression
fio.epscompress(simpaths.dsim, '.eps', 1)
def ppsth(simpaths):
# get filename lists in dictionaries of experiments
dict_exp_param = simpaths.exp_files_of_type('param')
dict_exp_spk = simpaths.exp_files_of_type('rawspk')
# assumes a match between expnames and the keys of the previous dicts
for expname in simpaths.expnames:
# get the tstop
exp_param_list = dict_exp_param[expname]
exp_spk_list = dict_exp_spk[expname]
gid_dict, p = paramrw.read(exp_param_list[0])
# gid_dict, p = paramrw.read(dict_exp_param[expname][0])
tstop = p['tstop']
# get representative spikes
s_dict = spikefn.spikes_from_file(gid_dict, exp_spk_list[0])
s_dict_L2 = {}
s_dict_L5 = {}
s_dict_L2_extgauss = {}
s_dict_L2_extpois = {}
s_dict_L5_extgauss = {}
s_dict_L5_extpois = {}
# clean out s_dict destructively
# borrowed from praster
for key in s_dict.keys():
# do this first to remove all extgauss feeds
if 'extgauss' in key:
if 'L2_' in key:
s_dict_L2_extgauss[key] = s_dict.pop(key)
elif 'L5_' in key:
s_dict_L5_extgauss[key] = s_dict.pop(key)
elif 'extpois' in key:
# s_dict_extpois[key] = s_dict.pop(key)
if 'L2_' in key:
s_dict_L2_extpois[key] = s_dict.pop(key)
elif 'L5_' in key:
s_dict_L5_extpois[key] = s_dict.pop(key)
# L2 next
elif 'L2_' in key:
s_dict_L2[key] = s_dict.pop(key)
elif 'L5_' in key:
s_dict_L5[key] = s_dict.pop(key)
# these are total spike dicts for the experiments
s_L2Pyr_list = []
s_L5Pyr_list = []
# iterate through params and spikes for a given experiment
for fparam, fspk in zip(dict_exp_param[expname],
dict_exp_spk[expname]):
# get gid dict
gid_dict, p = paramrw.read(fparam)
# get spike dict
s_dict = spikefn.spikes_from_file(gid_dict, fspk)
# add a new entry to list for each different file assoc with an experiment
s_L2Pyr_list.append(
np.array(
list(
it.chain.from_iterable(
s_dict['L2_pyramidal'].spike_list))))
s_L5Pyr_list.append(
np.array(
list(
it.chain.from_iterable(
s_dict['L5_pyramidal'].spike_list))))
# now aggregate over all spikes
s_L2Pyr = np.array(list(it.chain.from_iterable(s_L2Pyr_list)))
s_L5Pyr = np.array(list(it.chain.from_iterable(s_L5Pyr_list)))
# optimize bins, currently unused for comparison reasons!
N_trials = len(fparam)
# bin_L2 = 120
# bin_L5 = 120
bin_L2 = spikefn.hist_bin_opt(s_L2Pyr, N_trials)
bin_L5 = spikefn.hist_bin_opt(s_L5Pyr, N_trials)
# create standard fig and axes
f = ac.FigPSTH(400.)
f.ax['L2_psth'].hist(s_L2Pyr, bin_L2, facecolor='g', alpha=0.75)
f.ax['L5_psth'].hist(s_L5Pyr, bin_L5, facecolor='g', alpha=0.75)
# normalize these axes
y_L2 = f.ax['L2_psth'].get_ylim()
y_L5 = f.ax['L5_psth'].get_ylim()
print y_L2, y_L5
# f.ax['L2_psth'].set_ylim((0, 450.))
# f.ax['L5_psth'].set_ylim((0, 450.))
spikefn.spike_png(f.ax['L2'], s_dict_L2)
spikefn.spike_png(f.ax['L5'], s_dict_L5)
spikefn.spike_png(f.ax['L2_extpois'], s_dict_L2_extpois)
spikefn.spike_png(f.ax['L2_extgauss'], s_dict_L2_extgauss)
spikefn.spike_png(f.ax['L5_extpois'], s_dict_L5_extpois)
spikefn.spike_png(f.ax['L5_extgauss'], s_dict_L5_extgauss)
# # testfig.ax0.plot(t_vec, dp_total)
fig_name = os.path.join(simpaths.dsim, expname + '.eps')
plt.savefig(fig_name)
f.close()
# run the compression
fio.epscompress(simpaths.dsim, '.eps', 1)
