def runsim(): t0 = time.time() # clock start time pc.set_maxstep( 10) # sets the default max solver step in ms (purposefully large) for elec in lelec: elec.setup() elec.LFPinit() h.finitialize( ) # initialize cells to -65 mV, after all the NetCon delays have been specified if pcID == 0: for tt in range(0, int(h.tstop), printdt): h.cvode.event(tt, prsimtime) # print time callbacks h.fcurrent() h.frecord_init( ) # set state variables if they have been changed since h.finitialize pc.psolve(h.tstop) # actual simulation - run the solver pc.barrier() # these calls aggregate data across procs/nodes pc.allreduce(dp_rec_L2, 1) pc.allreduce( dp_rec_L5, 1) # combine dp_rec on every node, 1=add contributions together for elec in lelec: elec.lfp_final() net.aggregate_currents( ) # aggregate the currents independently on each proc # combine net.current{} variables on each proc pc.allreduce(net.current['L5Pyr_soma'], 1) pc.allreduce(net.current['L2Pyr_soma'], 1) pc.barrier() # write time and calculated dipole to data file only if on the first proc # only execute this statement on one proc savedat(p, pcID, t_vec, dp_rec_L2, dp_rec_L5, net) for elec in lelec: print('end; t_vec.size()', t_vec.size(), 'elec.lfp_t.size()', elec.lfp_t.size()) if pcID == 0: if debug: print("Simulation run time: %4.4f s" % (time.time() - t0)) if debug: print("Simulation directory is: %s" % ddir.dsim) if paramrw.find_param(doutf['file_param'], 'save_spec_data') or usingOngoingInputs( doutf['file_param']): runanalysis(p, doutf['file_param'], doutf['file_dpl_norm'], doutf['file_spec']) # run spectral analysis if paramrw.find_param(doutf['file_param'], 'save_figs'): savefigs(ddir, p, p_exp) # save output figures pc.barrier() # make sure all done in case multiple trials
def exec_show_dpl_max(ddata, opts={}): p = { 'layer': 'L5', 'n_sim': 0, 'n_trial': 0, } args_check(p, opts) expmt_group = ddata.expmt_groups[0] n = p['n_sim'] + p['n_sim']*p['n_trial'] fdpl = ddata.file_match(expmt_group, 'rawdpl')[n] fparam = ddata.file_match(expmt_group, 'param')[n] T = paramrw.find_param(fparam, 'tstop') xlim = (50., T) dpl = dipolefn.Dipole(fdpl) dpl.baseline_renormalize(fparam) dpl.convert_fAm_to_nAm() # add this data to the dict for the string output mapping p['dpl_max'] = dpl.lim(p['layer'], xlim)[1] p['units'] = dpl.units print "The maximal value for the dipole is %(dpl_max)4.3f %(units)s for sim=%(n_sim)i, trial=%(n_trial)i in layer %(layer)s" % (p)
def savedat(p, rank, t_vec, dp_rec_L2, dp_rec_L5, net): global doutf # write time and calculated dipole to data file only if on the first proc # only execute this statement on one proc if rank == 0: # write params to the file paramrw.write(doutf['file_param'], p, net.gid_dict) # write the raw dipole with open(doutf['file_dpl'], 'w') as f: for k in range(int(t_vec.size())): f.write("%03.3f\t" % t_vec.x[k]) f.write("%5.4f\t" % (dp_rec_L2.x[k] + dp_rec_L5.x[k])) f.write("%5.4f\t" % dp_rec_L2.x[k]) f.write("%5.4f\n" % dp_rec_L5.x[k]) # renormalize the dipole and save dpl = Dipole( doutf['file_dpl']) # fix to allow init from data rather than file dpl.baseline_renormalize(doutf['file_param']) dpl.convert_fAm_to_nAm() dconf['dipole_scalefctr'] = dpl.scale( paramrw.find_param(doutf['file_param'], 'dipole_scalefctr')) dpl.smooth( paramrw.find_param(doutf['file_param'], 'dipole_smooth_win') / h.dt) dpl.write(doutf['file_dpl_norm']) # write the somatic current to the file # for now does not write the total but just L2 somatic and L5 somatic with open(doutf['file_current'], 'w') as fc: for t, i_L2, i_L5 in zip(t_vec.x, net.current['L2Pyr_soma'].x, net.current['L5Pyr_soma'].x): fc.write("%03.3f\t" % t) # fc.write("%5.4f\t" % (i_L2 + i_L5)) fc.write("%5.4f\t" % i_L2) fc.write("%5.4f\n" % i_L5) # write output spikes file_spikes_tmp = fio.file_spike_tmp(dproj) spikes_write(net, file_spikes_tmp) # move the spike file to the spike dir if rank == 0: shutil.move(file_spikes_tmp, doutf['file_spikes']) if p['save_vsoma']: save_volt() if p['save_cai']: save_cai() if p['save_ica']: save_ica() for i, elec in enumerate(lelec): elec.lfpout(fn=doutf['file_lfp'].split('.txt')[0] + '_' + str(i) + '.txt', tvec=t_vec)
def baseline_renormalize(self, f_param): # only baseline renormalize if the units are fAm if self.units == 'fAm': N_pyr_x = paramrw.find_param(f_param, 'N_pyr_x') N_pyr_y = paramrw.find_param(f_param, 'N_pyr_y') # N_pyr cells in grid. This is PER LAYER N_pyr = N_pyr_x * N_pyr_y # dipole offset calculation: increasing number of pyr cells (L2 and L5, simultaneously) # with no inputs resulted in an aggregate dipole over the interval [50., 1000.] ms that # eventually plateaus at -48 fAm. The range over this interval is something like 3 fAm # so the resultant correction is here, per dipole # dpl_offset = N_pyr * 50.207 dpl_offset = { # these values will be subtracted 'L2': N_pyr * 0.0443, 'L5': N_pyr * -49.0502 # 'L5': N_pyr * -48.3642, # will be calculated next, this is a placeholder # 'agg': None, } # L2 dipole offset can be roughly baseline shifted over the entire range of t self.dpl['L2'] -= dpl_offset['L2'] # L5 dipole offset should be different for interval [50., 500.] and then it can be offset # slope (m) and intercept (b) params for L5 dipole offset # uncorrected for N_cells # these values were fit over the range [37., 750.) m = 3.4770508e-3 b = -51.231085 # these values were fit over the range [750., 5000] t1 = 750. m1 = 1.01e-4 b1 = -48.412078 # piecewise normalization self.dpl['L5'][self.t <= 37.] -= dpl_offset['L5'] self.dpl['L5'][(self.t > 37.) & (self.t < t1)] -= N_pyr * (m * self.t[ (self.t > 37.) & (self.t < t1)] + b) self.dpl['L5'][ self.t >= t1] -= N_pyr * (m1 * self.t[self.t >= t1] + b1) # recalculate the aggregate dipole based on the baseline normalized ones self.dpl['agg'] = self.dpl['L2'] + self.dpl['L5'] else: print( "Warning, no dipole renormalization done because units were in %s" % (self.units))
def pdipole_grid(ddata): # iterate through expmt_groups for expmt_group in ddata.expmt_groups: fname_short = "%s-%s-dpl.png" % (ddata.sim_prefix, expmt_group) fname = os.path.join(ddata.dsim, expmt_group, fname_short) # simple usage, just checks how many dipole files (total in an expmt) # and then plots dumbly to a grid dpl_list = ddata.file_match(expmt_group, 'rawdpl') param_list = ddata.file_match(expmt_group, 'param') # assume tstop is the same everywhere tstop = paramrw.find_param(param_list[0], 'tstop') # length of the dpl list N_dpl = len(dpl_list) # make a 5-col figure N_cols = 5 # force int arithmetic # this is the BASE number of rows, one might be added! N_rows = int(N_dpl) // int(N_cols) # if the mod is not 0, add a row if (N_dpl % N_cols): N_rows += 1 # print(N_dpl, N_cols, N_rows) f = ac.FigGrid(N_rows, N_cols, tstop) l = [] r = 0 for ax_list in f.ax: l.extend([(r,c) for c in range(len(ax_list))]) r += 1 # automatically truncates the loc list to the size of dpl_list for loc, fdpl, fparam in zip(l, dpl_list, param_list): r = loc[0] c = loc[1] pdipole_ax(f.ax[r][c], fdpl, fparam) f.savepng(fname) f.close()
def exec_welch_max(ddata, opts): p = { 'f_min': 0., } args_check(p, opts) # assume first expmt_group for now expmt_group = ddata.expmt_groups[0] # grab list of dipoles list_dpl = ddata.file_match(expmt_group, 'rawdpl') list_param = ddata.file_match(expmt_group, 'param') # iterate through dipoles for fdpl, fparam in zip(list_dpl, list_param): # grab the dt (needed for the Welch) dt = paramrw.find_param(fparam, 'dt') # grab the dipole dpl = dipolefn.Dipole(fdpl) dpl.baseline_renormalize(fparam) dpl.convert_fAm_to_nAm() # create empty pgram pgram = dict.fromkeys(dpl.dpl) pgram_max = dict.fromkeys(dpl.dpl) # perform stationary Welch, since we're not saving this data yet for key in pgram.keys(): pgram[key] = specfn.Welch(dpl.t, dpl.dpl[key], dt) # create a mask based on f min fmask = (pgram[key].f > p['f_min']) P_cut = pgram[key].P[fmask] f_cut = pgram[key].f[fmask] p_max = np.max(P_cut) f_max = f_cut[P_cut == p_max] # p_max = np.max(pgram[key].P) # f_max = pgram[key].f[pgram[key].P == p_max] # not clear why saving for now pgram_max[key] = (f_max, p_max) print "Max power for %s was %.3e at %4.2f Hz, with f min set to %4.2f" % (key, p_max, f_max, p['f_min'])
def setupaxdipole (self): dinty = self.getInputs() # whether to draw the specgram - should draw if user saved it or have ongoing, poisson, or tonic inputs DrawSpec = False try: DrawSpec = find_param(dfile['outparam'],'save_spec_data') or OngoingInputs or PoissonInputs or TonicInputs except: pass gRow = 0 if dinty['Ongoing'] or dinty['Evoked']: gRow = 2 if DrawSpec: # dipole axis takes fewer rows if also drawing specgram self.axdipole = ax = self.figure.add_subplot(self.G[gRow:5,0]); # dipole else: self.axdipole = ax = self.figure.add_subplot(self.G[gRow:-1,0]); # dipole
def plotsimdat(self): if not updatedat(self.paramf): return # if no data from sim, or data load problem return self.clearaxes() plt.close(self.figure) if len(ddat.keys()) == 0: return dinty = self.getInputs( ) # get dict of input types used (influences which/how plots drawn) # whether to draw the specgram - should draw if user saved it or have ongoing, poisson, or tonic inputs DrawSpec = find_param( dfile['outparam'], 'save_spec_data' ) or dinty['Ongoing'] or dinty['Poisson'] or dinty['Tonic'] try: ds = None xl = (0, find_param(dfile['outparam'], 'tstop')) dt = find_param(dfile['outparam'], 'dt') # get spectrogram if it exists, then adjust axis limits but only if drawing spectrogram if DrawSpec and 'spec' in ddat: if ddat['spec'] is not None: ds = ddat['spec'] # spectrogram xl = (ds['time'][0], ds['time'][-1] ) # use specgram time limits gRow = 0 sampr = 1e3 / dt # dipole sampling rate sidx, eidx = int(sampr * xl[0] / 1e3), int( sampr * xl[1] / 1e3) # use these indices to find dipole min,max if dinty['Ongoing'] or dinty['Evoked'] or dinty['Poisson']: xo = self.plotinputhist(xl, dinty) if xo: gRow = xo[1] if DrawSpec: # dipole axis takes fewer rows if also drawing specgram self.axdipole = ax = self.figure.add_subplot(self.G[gRow:5, 0]) # dipole self.lax.append(ax) else: self.axdipole = ax = self.figure.add_subplot(self.G[gRow:-1, 0]) # dipole self.lax.append(ax) N_trials = self.getNTrials() if debug: print('simdat: N_trials:', N_trials) yl = [ np.amin(ddat['dpl'][sidx:eidx, 1]), np.amax(ddat['dpl'][sidx:eidx, 1]) ] if N_trials > 1 and dconf['drawindivdpl'] and len( ddat['dpltrials'] ) > 0: # plot dipoles from individual trials for dpltrial in ddat['dpltrials']: ax.plot(dpltrial[:, 0], dpltrial[:, 1], color='gray', linewidth=self.gui.linewidth) yl[0] = min(yl[0], dpltrial[sidx:eidx, 1].min()) yl[1] = max(yl[1], dpltrial[sidx:eidx, 1].max()) if dinty['Evoked']: self.drawEVInputTimes(ax, yl, 0.1, (xl[1] - xl[0]) * .02) #15.0) #if dinty['Evoked']: self.drawEVInputTimes(ax,yl,0.1,15.0) if conf.dconf['drawavgdpl'] or N_trials <= 1: # this is the average dipole (across trials) # it's also the ONLY dipole when running a single trial ax.plot(ddat['dpl'][:, 0], ddat['dpl'][:, 1], 'k', linewidth=self.gui.linewidth + 2) scalefctr = getscalefctr(self.paramf) NEstPyr = int(self.getNPyr() * scalefctr) if NEstPyr > 0: ax.set_ylabel(r'Dipole (nAm $\times$ ' + str(scalefctr) + ')\nFrom Estimated ' + str(NEstPyr) + ' Cells', fontsize=dconf['fontsize']) else: ax.set_ylabel(r'Dipole (nAm $\times$ ' + str(scalefctr) + ')\n', fontsize=dconf['fontsize']) ax.set_xlim(xl) ax.set_ylim(yl) if DrawSpec: # if debug: print('ylim is : ', np.amin(ddat['dpl'][sidx:eidx, 1]), np.amax(ddat['dpl'][sidx:eidx, 1])) gRow = 6 self.axspec = ax = self.figure.add_subplot(self.G[gRow:10, 0]) # specgram self.lax.append(ax) cax = ax.imshow(ds['TFR'], extent=(ds['time'][0], ds['time'][-1], ds['freq'][-1], ds['freq'][0]), aspect='auto', origin='upper', cmap=plt.get_cmap('jet')) ax.set_ylabel('Frequency (Hz)', fontsize=dconf['fontsize']) ax.set_xlabel('Time (ms)', fontsize=dconf['fontsize']) ax.set_xlim(xl) ax.set_ylim(ds['freq'][-1], ds['freq'][0]) cbaxes = self.figure.add_axes([0.6, 0.49, 0.3, 0.005]) cb = plt.colorbar( cax, cax=cbaxes, orientation='horizontal') # horizontal to save space for ax in self.lax: if ax: ax.set_xlim(xl) except: print('ERR: in plotsimdat') self.figure.subplots_adjust(left=0.07, right=0.99, bottom=0.08, top=0.99, hspace=0.1, wspace=0.1) # reduce padding
from conf import dconf if dconf['fontsize'] > 0: plt.rcParams['font.size'] = dconf['fontsize'] else: dconf['fontsize'] = 10 tstop = -1 ntrial = 1 scalefctr = 30e3 dplpath = '' paramf = '' for i in range(len(sys.argv)): if sys.argv[i].endswith('.txt'): dplpath = sys.argv[i] elif sys.argv[i].endswith('.param'): paramf = sys.argv[i] scalefctr = paramrw.find_param(paramf, 'dipole_scalefctr') if type(scalefctr) != float and type(scalefctr) != int: scalefctr = 30e3 tstop = paramrw.find_param(paramf, 'tstop') ntrial = paramrw.quickgetprm(paramf, 'N_trials', int) basedir = os.path.join(dconf['datdir'], paramf.split(os.path.sep)[-1].split('.param')[0]) ddat = {} ddat['dpltrials'] = readdpltrials(basedir, ntrial) try: ddat['dpl'] = np.loadtxt(os.path.join(basedir, 'dpl.txt')) except: print('Could not load', dplpath) quit()
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
def plotsimdat (self): # plot the simulation data self.gRow = 0 bottom = 0.0 only_create_axes = False if not os.path.isfile(self.paramf): only_create_axes = True DrawSpec = False xl = (0.0, 1.0) else: # setup the figure axis for drawing the dipole signal dinty = self.getInputs() # try loading data. ignore failures try: updatedat(self.paramf) loaded_dat = True except ValueError: loaded_dat = False pass xl = (0.0, quickgetprm(self.paramf,'tstop',float)) if dinty['Ongoing'] or dinty['Evoked'] or dinty['Poisson']: xo = self.plotinputhist(xl, dinty) if xo: self.gRow = xo[1] # whether to draw the specgram - should draw if user saved it or have ongoing, poisson, or tonic inputs DrawSpec = loaded_dat and \ 'spec' in ddat and \ (find_param(dfile['outparam'],'save_spec_data') or dinty['Ongoing'] or dinty['Poisson'] or dinty['Tonic']) if DrawSpec: # dipole axis takes fewer rows if also drawing specgram self.axdipole = self.figure.add_subplot(self.G[self.gRow:5,0]) # dipole bottom = 0.08 else: self.axdipole = self.figure.add_subplot(self.G[self.gRow:-1,0]) # dipole yl = (-0.001,0.001) self.axdipole.set_ylim(yl) self.axdipole.set_xlim(xl) left = 0.08 w,h=getscreengeom() if w < 2800: left = 0.1 self.figure.subplots_adjust(left=left,right=0.99,bottom=bottom,top=0.99,hspace=0.1,wspace=0.1) # reduce padding if only_create_axes: return try: updatedat(self.paramf) except ValueError: if 'dpl' not in ddat: # failed to load dipole data, nothing more to plot return ds = None xl = (0,ddat['dpl'][-1,0]) dt = ddat['dpl'][1,0] - ddat['dpl'][0,0] # get spectrogram if it exists, then adjust axis limits but only if drawing spectrogram if DrawSpec: if ddat['spec'] is not None: ds = ddat['spec'] # spectrogram xl = (ds['time'][0],ds['time'][-1]) # use specgram time limits else: DrawSpec = False sampr = 1e3/dt # dipole sampling rate sidx, eidx = int(sampr*xl[0]/1e3), int(sampr*xl[1]/1e3) # use these indices to find dipole min,max N_trials = self.getNTrials() if debug: print('simdat: N_trials:',N_trials) yl = [0,0] yl[0] = min(yl[0],np.amin(ddat['dpl'][sidx:eidx,1])) yl[1] = max(yl[1],np.amax(ddat['dpl'][sidx:eidx,1])) if not self.optMode: # skip for optimization for lsim in lsimdat: # plot average dipoles from prior simulations olddpl = lsim[1] if debug: print('olddpl has shape ',olddpl.shape,len(olddpl[:,0]),len(olddpl[:,1])) self.axdipole.plot(olddpl[:,0],olddpl[:,1],'--',color='black',linewidth=self.gui.linewidth) if N_trials>1 and dconf['drawindivdpl'] and len(ddat['dpltrials']) > 0: # plot dipoles from individual trials for dpltrial in ddat['dpltrials']: self.axdipole.plot(dpltrial[:,0],dpltrial[:,1],color='gray',linewidth=self.gui.linewidth) yl[0] = min(yl[0],dpltrial[sidx:eidx,1].min()) yl[1] = max(yl[1],dpltrial[sidx:eidx,1].max()) if conf.dconf['drawavgdpl'] or N_trials <= 1: # this is the average dipole (across trials) # it's also the ONLY dipole when running a single trial self.axdipole.plot(ddat['dpl'][:,0],ddat['dpl'][:,1],'k',linewidth=self.gui.linewidth+1) yl[0] = min(yl[0],ddat['dpl'][sidx:eidx,1].min()) yl[1] = max(yl[1],ddat['dpl'][sidx:eidx,1].max()) else: for idx, opt in enumerate(optdat): optdpl = opt[1] if idx == len(optdat) - 1: # only show the last optimization self.axdipole.plot(optdpl[:,0],optdpl[:,1],'k',color='gray',linewidth=self.gui.linewidth+1) yl[0] = min(yl[0],optdpl[sidx:eidx,1].min()) yl[1] = max(yl[1],optdpl[sidx:eidx,1].max()) if self.hasinitoptdata(): # show initial dipole in dotted black line self.axdipole.plot(initial_ddat['dpl'][:,0],initial_ddat['dpl'][:,1],'--',color='black',linewidth=self.gui.linewidth) yl[0] = min(yl[0],initial_ddat['dpl'][sidx:eidx,1].min()) yl[1] = max(yl[1],initial_ddat['dpl'][sidx:eidx,1].max()) scalefctr = getscalefctr(self.paramf) NEstPyr = int(self.getNPyr() * scalefctr) if NEstPyr > 0: self.axdipole.set_ylabel(r'Dipole (nAm $\times$ '+str(scalefctr)+')\nFrom Estimated '+str(NEstPyr)+' Cells',fontsize=dconf['fontsize']) else: self.axdipole.set_ylabel(r'Dipole (nAm $\times$ '+str(scalefctr)+')\n',fontsize=dconf['fontsize']) self.axdipole.set_xlim(xl); self.axdipole.set_ylim(yl) if DrawSpec: # if debug: print('ylim is : ', np.amin(ddat['dpl'][sidx:eidx,1]),np.amax(ddat['dpl'][sidx:eidx,1])) p_exp = ExpParams(self.paramf, debug=debug) if len(p_exp.expmt_groups) > 0: expmt_group = p_exp.expmt_groups[0] else: expmt_group = None p = p_exp.return_pdict(expmt_group, 0) gRow = 6 self.axspec = self.figure.add_subplot(self.G[gRow:10,0]); # specgram cax = self.axspec.imshow(ds['TFR'],extent=(ds['time'][0],ds['time'][-1],ds['freq'][-1],ds['freq'][0]),aspect='auto',origin='upper',cmap=plt.get_cmap(p['spec_cmap'])) self.axspec.set_ylabel('Frequency (Hz)',fontsize=dconf['fontsize']) self.axspec.set_xlabel('Time (ms)',fontsize=dconf['fontsize']) self.axspec.set_xlim(xl) self.axspec.set_ylim(ds['freq'][-1],ds['freq'][0]) cbaxes = self.figure.add_axes([0.6, 0.49, 0.3, 0.005]) cb = plt.colorbar(cax, cax = cbaxes, orientation='horizontal') # horizontal to save space else: self.axdipole.set_xlabel('Time (ms)',fontsize=dconf['fontsize'])