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 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 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 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()