def feature_label(self, data): f = data[0] s = data[1] base_x = 0.88 base_y = 0.74 for i in range(0, len(data[0])): pl.figtext(base_y, base_x-0.05*i, '{} -> {}'.format(f[i], s[i]))
def main(args): if len(args) != 3: print "Usage: python plots.py <results file> <start time> <end time>" sys.exit() fh = open(args[0], "r") l = fh.readline().split() N = int(l[0]) T = int(l[1]) step = int(l[2]) mean_c = float(l[3]) ts = int(args[1]) / step td = int(args[2]) / step + step x = range(0, T + step, step) cl = [] for line in fh.readlines(): c = float(line) cl.append(c) fh.close() # Time evolution of the fraction of cooperators. pylab.figure(1, figsize = (7, 4.5), dpi = 500) pylab.xlabel(r"$t$") pylab.ylabel(r"$x$") pylab.plot(x[ts:td], cl[ts:td], "#000000", alpha = 0.6, linewidth = 2.0) pylab.figtext(0.82, 0.85, r"$x_\infty = %4.3f$" %(mean_c), ha = 'center', va = 'center', bbox = dict(facecolor = 'white', edgecolor = 'black')) pylab.xlim(int(args[1]), int(args[2])) pylab.ylim(0, 1) ax = pylab.gca() ax.xaxis.major.formatter.set_powerlimits((0,0)) pylab.savefig("plot.pdf", format = "pdf") pylab.close(1)
def add_label(self, feature_result, min_feature_label): base_x = 0.88 base_y = 0.74 for i in range(0, len(feature_result)): x1 = feature_result[i] x2 = min_feature_label[i] pl.figtext(base_y, base_x-0.05*i, '{} -> [{}]'.format(x1, x2))
def plotData(): marr = fetchData() textsize = 18 yticks([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], xt, size=textsize) ylabel("Periode [s]", size=textsize) xticks([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], yt, size=textsize) xlabel("Ausstattung [%]", size=textsize) title( "Abweichung der Geschwindigkeit zwischen FCD und des simulierten Verkehrs", size=textsize) # title("Relative Anzahl erfasster Kanten", size=textsize) figtext(0.7865, 0.92, '[%]', size=textsize) # levels=arange(mmin-mmin*.1, mmax+mmax*.1, (mmax-mmin)/10.)) contourf(marr, 50) # set fontsize and ticks for the colorbar: if showVal == EDGENO: cb = colorbar(ticks=[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]) else: # cb = colorbar(ticks=range(17)) cb = colorbar() for t in cb.ax.get_yticklabels(): # set colorbar fontsize of each tick t.set_fontsize(textsize) show()
def myplot_setlabel(xlabel=None,ylabel=None,title=None, label=None, xy=(0,0), ax=None, labsize=15,rightticks=False): import matplotlib as mpl mpl.rcParams['font.size'] = labsize+0. # mpl.rcParams['font.family'] = 'serif'# New Roman' mpl.rcParams['font.serif'] = 'Bitstream Vera Serif' mpl.rcParams['axes.labelsize'] = labsize+1. print labsize+1 mpl.rcParams['xtick.labelsize'] = labsize+0. mpl.rcParams['ytick.labelsize'] = labsize+0. if label: print "######################## LABELS HERE##########################" if xy==(0,0): xy=(0.3,0.90) if not ax: print "WARNING: no axix, cannot place label" pl.figtext(xy[0],xy[1],label, fontsize=labsize) else: pl.text(xy[0],xy[1],label, transform=ax.transAxes, fontsize=labsize) if rightticks: ax.yaxis.tick_right() pl.xlabel(xlabel, fontsize=labsize+1) pl.ylabel(ylabel, fontsize=labsize+1) if title: pl.title(title)
def display_settings(self): from pylab import figtext assert self.search search = self.search figtext(.01,.99,search.str_graph_fixed(), va='top',fontsize='medium') figtext(.35, .99, search.str_graph_used(), va='top',fontsize='medium')
def buildAtmos(self, secz, xlim=[300, 1100], doPlot=False): """Generate the total atmospheric transmission profile at this airmass, using the coefficients C.""" # Burke paper says atmosphere put together as # Trans_total (alt/az/time) = Tgray * (e^-Z*tau_aerosol(alt/az/t)) * # * (1 - C_mol * BP(t)/BPo * A_mol(Z)) -- line 2 # * (1 - sqrt(C_mol * BP(t)/BPo) * A_mol(Z)) -- 3 # * (1 - C_O3 * A_O3(A) ) # * (1 - C_H2O(alt/az/time) * A_H2O(Z)) # Tau_aerosol = trans['aerosol'] ... but replace with power law (because here all 1's) # typical power law index is about tau ~ lambda^-1 # A_mol = trans['O2'] # secz = secz of this observation # wavelen / atmo_templates == building blocks of atmosphere, with seczlist / atmo_ind keys # C = coeffsdictionary = to, t1, t2, alpha0 (for aerosol), C_mol, BP, C_O3, C_H2O values if (abs(secz - self.secz) > interplimit): print "Generating interpolated atmospheric absorption profiles for this airmass %f" %(secz) self.interpolateSecz(secz) BP0 = 782 # mb # set aerosol appropriately with these coefficients self.atmo_abs['aerosol'] = 1.0 - numpy.exp(-secz * (self.C['t0'] + self.C['t1']*0.0 + self.C['t2']*0.0) * (self.wavelen/675.0)**self.C['alpha']) # set total transmission, with appropriate coefficients self.trans_total = numpy.ones(len(self.wavelen), dtype='float') self.trans_total = self.trans_total * (1.0 - self.C['mol'] * self.C['BP']/BP0 * self.atmo_abs['rayleigh']) \ * ( 1 - numpy.sqrt(self.C['mol'] * self.C['BP']/BP0) * self.atmo_abs['O2']) \ * ( 1 - self.C['O3'] * self.atmo_abs['O3']) \ * ( 1 - self.C['H2O'] * self.atmo_abs['H2O']) \ * ( 1 - self.atmo_abs['aerosol']) # now we can plot the atmosphere if doPlot: pylab.figure() pylab.subplot(212) colorindex = 0 for comp in self.atmo_ind: pylab.plot(self.wavelen, self.atmo_abs[comp], colors[colorindex], label='%s' %(comp)) colorindex = self._next_color(colorindex) leg =pylab.legend(loc=(0.88, 0.3), fancybox=True, numpoints=1, shadow=True) ltext = leg.get_texts() pylab.setp(ltext, fontsize='small') coefflabel = "" for comp in ('mol', 't0', 'alpha', 'O3', 'H2O'): coefflabel = coefflabel + "C[%s]:%.2f " %(comp, self.C[comp]) if (comp=='alpha') | (comp=='mol'): coefflabel = coefflabel + "\n" pylab.figtext(0.2, 0.35, coefflabel, fontsize='small') pylab.xlim(xlim[0], xlim[1]) pylab.ylim(0, 1.0) pylab.xlabel("Wavelength (nm)") pylab.subplot(211) pylab.plot(self.wavelen, self.atmo_trans[self.seczToString(1.2)]['comb'], 'r-', label='Standard X=1.2 (no aerosols)') pylab.plot(self.wavelen, self.trans_total, 'k-', label='Observed') leg = pylab.legend(loc=(0.12, 0.05), fancybox=True, numpoints=1, shadow=True) ltext = leg.get_texts() pylab.setp(ltext, fontsize='small') pylab.xlim(xlim[0], xlim[1]) pylab.ylim(0, 1.0) pylab.title("Example Atmosphere at X=%.2f" %(secz)) return
def do_panel(condition, refcondition, figtitle, cursor, band='r'): cmd = "select a.BT, f.flag, a.r_bulge, a.n_bulge, a.ba_bulge, a.ba_disk, c.z from CAST as c, Flags_catalog as f, {band}_band_serexp as a, gz2_flags as z where a.galcount = c.galcount and a.galcount = f.galcount and a.galcount = z.galcount and f.band='{band}' and f.model='serexp' and f.ftype ='u' and {condition};" #a.r_bulge, BT, flags, r_bulge, n_bulge,ba_bulge,ba_disk, zspec =cursor.get_data(cmd.format(condition=condition, band=band)) ref_BT,ref_flag, ref_rb, ref_nb, ref_ba,ref_badisk, ref_zspec = cursor.get_data(cmd.format(condition=refcondition, band=band)) BT = np.array(BT) flags = np.array(flags, dtype=int) r_bulge = np.array(r_bulge) n_bulge= np.array(n_bulge) ba_bulge= np.array(ba_bulge) ba_disk= np.array(ba_disk) zspec = np.array(zspec) ref_BT = np.array(ref_BT) ref_flag = np.array(ref_flag, dtype=int) ref_rb = np.array(ref_rb) ref_nb= np.array(ref_nb) ref_ba= np.array(ref_ba) ref_badisk= np.array(ref_badisk) ref_zspec = np.array(ref_zspec) panel_plot(BT, flags, r_bulge, n_bulge,ba_bulge,ba_disk, ref_BT,ref_flag, ref_rb, ref_nb, ref_ba,ref_badisk, zspec, ref_zspec) pl.figtext(0.5, 0.95, figtitle) print figtitle+' ',BT.size, ' objects' pl.savefig('bar_params_serexp_%s.eps' %band) #pl.savefig('bar_z_serexp.eps') return
def showImage(self, xlim=None, ylim=None, clims=None, cmap=None, copy=False, stats=True): if copy: # useful if you're going to apply a hanning filter or something later, but # want to keep an imge of the original image = numpy.copy(self.image) else: image = self.image pylab.figure() pylab.title('Image') if xlim == None: x0 = 0 x1 = self.nx else: x0 = xlim[0] x1 = xlim[1] if ylim == None: y0 = 0 y1 = self.ny else: y0 = ylim[0] y1 = ylim[1] if clims == None: pylab.imshow(image, origin='lower', cmap=cmap) else: pylab.imshow(image, origin='lower', vmin=clims[0], vmax=clims[1], cmap=cmap) pylab.xlabel('X') pylab.ylabel('Y') cb = pylab.colorbar() clims = cb.get_clim() pylab.xlim(x0, x1) pylab.ylim(y0, y1) if stats: statstxt = 'Mean/Stdev/Min/Max:\n %.2f/%.2f/%.2f/%.2f' %(numpy.mean(image), numpy.std(image), image.min(), image.max()) pylab.figtext(0.75, 0.03, statstxt) return clims
def test_varying_inclination(self): #""" Test that the waveform is consistent for changes in inclination #""" sigmas = [] incs = numpy.arange(0, 21, 1.0) * lal.PI / 10.0 for inc in incs: # WARNING: This does not properly handle the case of SpinTaylor* # where the spin orientation is not relative to the inclination hp, hc = get_waveform(self.p, inclination=inc) s = sigma(hp, low_frequency_cutoff=self.p.f_lower) sigmas.append(s) f = pylab.figure() pylab.axes([.1, .2, 0.8, 0.70]) pylab.plot(incs, sigmas) pylab.title("Vary %s inclination, $\\tilde{h}$+" % self.p.approximant) pylab.xlabel("Inclination (radians)") pylab.ylabel("sigma (flat PSD)") info = self.version_txt pylab.figtext(0.05, 0.05, info) if self.save_plots: pname = self.plot_dir + "/%s-vary-inclination.png" % self.p.approximant pylab.savefig(pname) if self.show_plots: pylab.show() else: pylab.close(f) self.assertAlmostEqual(sigmas[-1], sigmas[0], places=7) self.assertAlmostEqual(max(sigmas), sigmas[0], places=7) self.assertTrue(sigmas[0] > sigmas[5])
def regressionANN(mypathforResults,predicted,observed,regress,variable_to_fill, Site_ID,units,list_out,index_str): for index, item in enumerate(list_out): fig=pl.figure(4, figsize=(16, 12), dpi=80, facecolor='w', edgecolor='k') ANN_label=str(item+"_NN") graphtext1=str('slope ' + str("{0:.2f}".format(regress[index][0])) +'\n' + 'intercept ' + str("{0:.2f}".format(regress[index][1])) +'\n' + 'r-value ' + str("{0:.2f}".format(regress[index][2])) +'\n' + 'p-value ' + str("{0:.2f}".format(regress[index][3])) +'\n' + 'slope SE ' + str("{0:.2f}".format(regress[index][4])) +'\n' + 'estim. SE ' + str("{0:.2f}".format(regress[index][5])) ) pl.figtext(0.7,0.6,graphtext1, bbox=dict()) pl.plot(observed[:,index], predicted[:,index], 'o', label='targets vs. outputs') slope = regress[index][0]; intercept = regress[index][1] x = np.linspace(min(observed[:,index]),max(observed[:,index])) y = slope * x + intercept pl.plot(x, y, linewidth = 2, label = 'regression line') pl.legend() pl.title('Tower vs ANN for '+item+' at ' +Site_ID+ ' index '+index_str) pl.xlabel('Tower ' + '('+units+')') pl.ylabel('ANN ' + '('+units+')') pl.legend(shadow=True, fancybox=True,loc='best') pl.savefig(mypathforResults+'/'+'Tower vs ANN for '+item+' at ' +Site_ID+ ' index '+index_str) #pl.show() pl.close(4) time.sleep(2)
def OnCalcShift(self, event): if (len(self.PSFLocs) > 0): import pylab x,y,z = self.PSFLocs[0] z_ = numpy.arange(self.image.data.shape[2])*self.image.mdh['voxelsize.z']*1.e3 z_ -= z_.mean() pylab.figure() p_0 = 1.0*self.image.data[x,y,:,0].squeeze() p_0 -= p_0.min() p_0 /= p_0.max() #print (p_0*z_).sum()/p_0.sum() p0b = numpy.maximum(p_0 - 0.5, 0) z0 = (p0b*z_).sum()/p0b.sum() p_1 = 1.0*self.image.data[x,y,:,1].squeeze() p_1 -= p_1.min() p_1 /= p_1.max() p1b = numpy.maximum(p_1 - 0.5, 0) z1 = (p1b*z_).sum()/p1b.sum() dz = z1 - z0 print(('z0: %f, z1: %f, dz: %f' % (z0,z1,dz))) pylab.plot(z_, p_0) pylab.plot(z_, p_1) pylab.vlines(z0, 0, 1) pylab.vlines(z1, 0, 1) pylab.figtext(.7,.7, 'dz = %3.2f' % dz)
def gen_hrf(self): m_A, q_Z, mu_k, m_H, sigma_k, width, height, hrf0 = self.analy.Vbjde() fgs = self.ConditionalNRLHist(m_A, q_Z) MMin = -1.0 # Y.min() MMax = 1.0 # Y.max() pas = (MMax - MMin) / 100 xx = arange(MMin, MMax, pas) nf = 1 g0 = self.gaussian(xx, mu_k[0][0], sigma_k[0][0]) g1 = self.gaussian(xx, mu_k[0][1], sigma_k[0][1]) print (g0, g1) fgs.insert(0, figure((self.nf + 1) * 123)) title("Fonction de reponse", fontsize='xx-large') figtext(0.2, 0.04, 'bande = ' + str(self.bande)+ ' beta =' + str(self.beta) + ' sigma = ' + str(self.sigmaH) + ' pl = ' + str(self.pl) + ' dt = ' + str(self.dt) + ' thrf = ' + str(self.Thrf), #'mu_k = '+ str(self.mu_k) + #'sigma_k = '+ str(self.sigma_k), fontsize='x-large') plot(m_H) if self.shower == 1: show() return fgs
def dovis(self): """ Do runtime visualization. """ pylab.clf() phi = self.cc_data.get_var("phi") myg = self.cc_data.grid pylab.imshow(numpy.transpose(phi[myg.ilo:myg.ihi+1, myg.jlo:myg.jhi+1]), interpolation="nearest", origin="lower", extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax]) pylab.xlabel("x") pylab.ylabel("y") pylab.title("phi") pylab.colorbar() pylab.figtext(0.05,0.0125, "t = %10.5f" % self.cc_data.t) pylab.draw()
def plot_Rnl(self,filename=None): """ Plot radial wave functions with matplotlib. filename: output file name + extension (extension used in matplotlib) """ if pl==None: raise AssertionError('pylab could not be imported') rmax = data[self.symbol]['R_cov']/0.529177*3 ri = np.where( self.rgrid<rmax )[0][-1] states=len(self.list_states()) p = np.ceil(np.sqrt(states)) #p**2>=states subplots fig=pl.figure() i=1 # as a function of grid points for n,l,nl in self.list_states(): ax=pl.subplot(2*p,p,i) pl.plot(self.Rnlg[nl]) pl.yticks([],[]) pl.xticks(size=5) # annotate c = 'k' if nl in self.valence: c='r' pl.text(0.5,0.4,r'$R_{%s}(r)$' %nl,transform=ax.transAxes,size=15,color=c) if ax.is_first_col(): pl.ylabel(r'$R_{nl}(r)$',size=8) i+=1 # as a function of radius i = p**2+1 for n,l,nl in self.list_states(): ax=pl.subplot(2*p,p,i) pl.plot(self.rgrid[:ri],self.Rnlg[nl][:ri]) pl.yticks([],[]) pl.xticks(size=5) if ax.is_last_row(): pl.xlabel('r (Bohr)',size=8) c = 'k' if nl in self.valence: c='r' pl.text(0.5,0.4,r'$R_{%s}(r)$' %nl,transform=ax.transAxes,size=15,color=c) if ax.is_first_col(): pl.ylabel(r'$R_{nl}(r)$',size=8) i+=1 file = '%s_KSAllElectron.pdf' %self.symbol #pl.rc('figure.subplot',wspace=0.0,hspace=0.0) fig.subplots_adjust(hspace=0.2,wspace=0.1) s='' if self.confinement!=None: s='(confined)' pl.figtext(0.4,0.95,r'$R_{nl}(r)$ for %s-%s %s' %(self.symbol,self.symbol,s)) if filename is not None: file = filename pl.savefig(file)
def putText( self, text ): """ Puts some text into an otherwise empty plot. @param text: text to put in the empty plot """ newText = '' for i in range( int(len(text)/60.0)+1): newText+=text[60*i:60*i+60]+'\n' figtext(0.15,0.15, newText)
def test_varying_orbital_phase(self): #"""Check that the waveform is consistent under phase changes #""" if self.p.approximant in td_approximants(): sample_attr = 'sample_times' else: sample_attr = 'sample_frequencies' f = pylab.figure() pylab.axes([.1, .2, 0.8, 0.70]) hp_ref, hc_ref = get_waveform(self.p, coa_phase=0) pylab.plot(getattr(hp_ref, sample_attr), hp_ref.real(), label="phiref") hp, hc = get_waveform(self.p, coa_phase=lal.PI/4) m, i = match(hp_ref, hp) self.assertAlmostEqual(1, m, places=2) o = overlap(hp_ref, hp) pylab.plot(getattr(hp, sample_attr), hp.real(), label="$phiref \pi/4$") hp, hc = get_waveform(self.p, coa_phase=lal.PI/2) m, i = match(hp_ref, hp) o = overlap(hp_ref, hp) self.assertAlmostEqual(1, m, places=7) self.assertAlmostEqual(-1, o, places=7) pylab.plot(getattr(hp, sample_attr), hp.real(), label="$phiref \pi/2$") hp, hc = get_waveform(self.p, coa_phase=lal.PI) m, i = match(hp_ref, hp) o = overlap(hp_ref, hp) self.assertAlmostEqual(1, m, places=7) self.assertAlmostEqual(1, o, places=7) pylab.plot(getattr(hp, sample_attr), hp.real(), label="$phiref \pi$") pylab.xlim(min(getattr(hp, sample_attr)), max(getattr(hp, sample_attr))) pylab.title("Vary %s oribital phiref, h+" % self.p.approximant) if self.p.approximant in td_approximants(): pylab.xlabel("Time to coalescence (s)") else: pylab.xlabel("GW Frequency (Hz)") pylab.ylabel("GW Strain (real part)") pylab.legend(loc="upper left") info = self.version_txt pylab.figtext(0.05, 0.05, info) if self.save_plots: pname = self.plot_dir + "/%s-vary-phase.png" % self.p.approximant pylab.savefig(pname) if self.show_plots: pylab.show() else: pylab.close(f)
def get_GB_cls_metrics(data_fh,info): """ Get the metrics of Gradient Boost classification models :param data_classi_fh: path to file containing Classification training data """ from pylab import figtext try: dpkl=read_pkl(data_fh) except: return False if not 'gs_cv' in dpkl.keys(): return False dXy=dpkl['dXy_final'] ycol=dpkl['ycol'] gs_cv=dpkl['gs_cv'] feat_imp = dpkl['feat_imp'] Xcols=[c for c in dXy.columns.tolist() if c!=ycol] est=gs_cv.best_estimator_ X=dXy.loc[:,Xcols].as_matrix() y=dXy.loc[:,ycol].as_matrix() #partial dep plot_type='partial_dep' plot_fh='%s/data_ml/%s.%s.pdf' % (info.prj_dh,plot_type,basename(data_fh)) if not exists(plot_fh): feats_indi=[s for s in dpkl['feat_imp'].head(6).index.tolist() if not ((') ' in s) and (' (' in s))] features=[Xcols.index(f) for f in feats_indi] feature_names=linebreaker(Xcols) from sklearn.ensemble.partial_dependence import plot_partial_dependence fig, axs = plot_partial_dependence(est, X, features,#[[features[1],features[2]]], feature_names=feature_names, n_jobs=int(info.cores), grid_resolution=50, n_cols=2, line_kw={'color':'r'}, figsize=[7,9]) figtext(0.9,-0.2,'AUC = %.2f' % gs_cv.best_score_,ha='right',color='b') saveplot(plot_fh,form='pdf',tight_layout=False) #relimp plot_type='featimps' plot_fh='%s/data_ml/%s.%s.pdf' % (info.prj_dh,plot_type,basename(data_fh)) if not exists(plot_fh): featst=10 fig=plt.figure(figsize=(3,featst*0.75)) # fig = plt.figure(figsize=(8,featst*0.25))#figsize=(11,5)) ax=plt.subplot(111) feat_imp=feat_imp.sort_values(by='Feature importance',ascending=True) feat_imp.index=linebreaker(feat_imp.index, break_pt=30) feat_imp.tail(featst).plot(kind='barh',ax=ax, color='red') ax.set_xlabel('Feature Importance') ax.legend([]) figtext(0.9,-0.2,'AUC = %.2f' % gs_cv.best_score_,ha='right',color='b') saveplot(plot_fh,form='pdf',tight_layout=False)
def anneal_w_graphics(n=11, depth=10): """ Make an animation of the BDST chain walking on an nxn grid and play it """ ni = 5 nj = 100 nk = 5 beta = mc.Uninformative('beta', value=1.) G = nx.grid_graph([n, n]) G.orig_pos = dict([[v, v] for v in G.nodes_iter()]) G.pos = dict([[v, v] for v in G.nodes_iter()]) root = (5,5) bdst = BDST(G, root, depth, beta) mod_mc = mc.MCMC([beta, bdst]) mod_mc.use_step_method(STMetropolis, bdst) mod_mc.use_step_method(mc.NoStepper, beta) for i in range(ni): beta.value = i*5 for j in range(nj): mod_mc.sample(1) T = bdst.value for k in range(nk): if random.random() < .95: delta_pos = nx.spring_layout(T, pos=G.pos, fixed=[root], iterations=1) else: delta_pos = G.orig_pos eps=.01 my_avg = lambda x, y: (x[0]*(1.-eps) + y[0]*eps, x[1]*(1.-eps)+y[1]*eps) for v in G.pos: G.pos[v] = my_avg(G.pos[v], delta_pos[v]) views.plot_graph_and_tree(G, T, time=1.*k/nk) str = '' str += ' beta: %.1f\n' % beta.value str += ' cur depth: %d (target: %d)\n' % (T.depth, depth) sm = mod_mc.step_method_dict[bdst][0] str += ' accepted: %d of %d\n' % (sm.accepted, sm.accepted + sm.rejected) pl.figtext(0, 0, str) pl.figtext(1, 0, 'healthyalgorithms.wordpress.com \n', ha='right') pl.axis([-1, n, -1, n]) pl.axis('off') pl.subplots_adjust(0, 0, 1, 1) pl.savefig('bdst%06d.png' % (i*nj*nk + j*nk + k)) print 'accepted:', mod_mc.step_method_dict[bdst][0].accepted import subprocess subprocess.call('mencoder mf://bdst*.png -mf w=800:h=600 -ovc x264 -of avi -o bdst_G_%d_d_%d.avi' % (n, depth), shell=True) subprocess.call('mplayer -loop 0 bdst_G_%d_d_%d.avi' % (n, depth), shell=True) subprocess.call('rm bdst*.png') return bdst.value
def showdp(fsz=16): """Utility function to set default parameters for DOS plots.""" pl.xlabel("E-E$_\mathrm{f}$ (eV)", size=fsz) pl.figtext(0.03, 0.45, "LDOS", rotation="vertical", size=fsz) loc, lab = pl.xticks() lab.set_size = fsz loc, lab = pl.yticks() lab.set_size = fsz pl.legend() pl.subplots_adjust(hspace=0.0) pl.show()
def plot_peak_offsets(offsets, filebase, doshow=False): """Plots the results of the peak offsets calculated.""" from pylab import figure, clf, xlim, ylim, savefig, plot, text, show, figtext, subplot, title #@type inst Instrument inst = instrument.inst numperpage = 6 # Initialize some stats rms = 0 rms_wl = 0 #@type po PeakOffset for po in offsets: #Square of the error distance error = (po.measured[0]- po.predicted[0])**2 + (po.measured[1]- po.predicted[1])**2 rms += error error = (po.wavelength_measured - po.wavelength_predicted)**2 rms_wl += error # Now do the root-mean rms = (rms/ len(offsets))**0.5 rms_wl = (rms_wl/ len(offsets))**0.5 print "Peak offsets RMS error is ", rms print "Peak offsets RMS wavelength error is ", rms_wl #@type det FlatDetector for (det_num, det) in enumerate(inst.detectors): if det_num % numperpage == 0: figure(det_num/numperpage, figsize=[8, 10]) clf() figtext(0.5, 0.95, "Offset (black line) from predicted peak positions (red dot); wavelength in angstroms", horizontalalignment='center', verticalalignment='top') ax = subplot(3, 2, det_num % numperpage+1) #Set the axes font sizes for xlabel_i in ax.get_xticklabels() + ax.get_yticklabels() : xlabel_i.set_fontsize(10) #@type po PeakOffset for po in offsets: if po.det_num == det_num: x = [po.measured[0], po.predicted[0]] y = [po.measured[1], po.predicted[1]] plot(po.predicted[0], po.predicted[1], 'r.') plot(x, y, '-k') text(po.predicted[0], po.predicted[1], ' %.1f' % po.wavelength_measured, size=5, verticalalignment='center') xlim( -det.width/2, det.width/2) ylim( -det.height/2, det.height/2) #axis('equal') title('Detector %s' % det.name) #-- Save to files -- for i in xrange((len(inst.detectors) + numperpage-1) / numperpage): figure(i) savefig( filebase + "_%d.pdf" % i, papertype="letter") #-- combine -- os.system("pdftk %s_*.pdf cat output %s.pdf" % (filebase, filebase)) if doshow: show()
def gen_plots(): """ Create plots and save them in plot.pdf file, and print the mean fraction of cooperators over the last 10 percent of the generations to STDOUT. """ # Open and load the stuff from the results file. fh = open("results.pkl", "r") params = pickle.load(fh) population = pickle.load(fh) fh.close() # generations axis ticks. x = [i * params["report_freq"] \ for i in range(0, params["generations"] / \ params["report_freq"] + 1)] y1 = [] fixation_time_in_ticks = len(population[0].get_trait_list()) - 1 fixation_time = fixation_time_in_ticks * params["report_freq"] fixated_to_c = False for t in range(0, params["generations"] / params["report_freq"] + 1): freq_c = 0 if t <= fixation_time_in_ticks: for p in population: if p.get_trait_list()[t] == Player.C: freq_c += 1 if freq_c == params["population"]: fixated_to_c = True else: if fixated_to_c: freq_c = params["population"] freq_c = 1.0 * freq_c / params["population"] y1.append(freq_c) last = int(params["generations"] * 0.1) i = (params["generations"] / params["report_freq"]) - \ (last / params["report_freq"]) l = y1[i:] avg_c = sum(l) / len(l) # Plot 1 (generations versus frequency of C players). pylab.figure(1, figsize = (7, 4.5), dpi = 500) pylab.xlabel(r"$t$") pylab.ylabel(r"$x$") pylab.plot(x, y1, "#000000", alpha = 0.6, linewidth = 2.0) pylab.figtext(0.82, 0.85, r"$x_\infty = %4.3f$" %(avg_c), ha = 'center', va = 'center', bbox = dict(facecolor = 'white', edgecolor = 'black')) pylab.ylim(0.0, 1.0) ax = pylab.gca() ax.xaxis.major.formatter.set_powerlimits((0,0)) pylab.savefig("plot.pdf", format = "pdf") pylab.close(1)
def display_fail(self, message): #? If there is a way to stretch this an inch as well, it would # help with text overlap. not sure if it is possible without # making a subplot, and corresponding strange boxes from pylab import savefig, close, axes, figtext axes([0,0,.01,.01]) figtext(.5, .5, message, ha='center',va='center',size='x-large') self.display_settings() savefig(self.image_dst + ".png") close() return False
def savefig(filename, *args, **kwargs): if ScriptFlags.MREORG_SAVEFIGADDINFO: F = pylab.gcf() x,y = F.get_size_inches() txt = 'Size: x=%2.2f y=%2.2f (inches)' % (x,y) txt += '\n' + filename.split('/')[-1] pylab.figtext(0.0, 0.5, txt, backgroundcolor='white') if ScriptFlags.MREORG_AUTOMAKEDIRS: mreorg.ensure_directory_exists(filename) return orig_mplsavefig(filename, *args, **kwargs)
def psfSizeCCD(ccd=None,filter='r',seeing=0,theta=0., zenith = 0., x=0., y=0.,z=0.): res = genImgV(Nstar=1, ccd = ccd,seeing=seeing,theta=theta,zenith=zenith,x=x,y=y,z=z) imgV = res[0] size = np.sqrt(len(imgV[0][2:])) img = imgV[0][2:].reshape(size,size) xcen = res[1][0]['xcen'] ycen = res[1][0]['ycen'] height, x, y, width_x, width_y = fitgaussian(img) disImgCCD(imgV,ccd) pl.figtext(0.2,0.85,'CCD: '+ccd[0], color='r') pl.figtext(0.2,0.8,'Filter: '+filter, color='r') return width_x, width_y
def dovis(self): """ Do runtime visualization """ pylab.clf() pylab.rc("font", size=10) u = self.cc_data.get_var("x-velocity") v = self.cc_data.get_var("y-velocity") myg = self.cc_data.grid vort = myg.scratch_array() divU = myg.scratch_array() vort[myg.ilo:myg.ihi+1,myg.jlo:myg.jhi+1] = \ 0.5*(v[myg.ilo+1:myg.ihi+2,myg.jlo:myg.jhi+1] - v[myg.ilo-1:myg.ihi,myg.jlo:myg.jhi+1])/myg.dx - \ 0.5*(u[myg.ilo:myg.ihi+1,myg.jlo+1:myg.jhi+2] - u[myg.ilo:myg.ihi+1,myg.jlo-1:myg.jhi])/myg.dy divU[myg.ilo:myg.ihi+1,myg.jlo:myg.jhi+1] = \ 0.5*(u[myg.ilo+1:myg.ihi+2,myg.jlo:myg.jhi+1] - u[myg.ilo-1:myg.ihi,myg.jlo:myg.jhi+1])/myg.dx + \ 0.5*(v[myg.ilo:myg.ihi+1,myg.jlo+1:myg.jhi+2] - v[myg.ilo:myg.ihi+1,myg.jlo-1:myg.jhi])/myg.dy fig, axes = pylab.subplots(nrows=2, ncols=2, num=1) pylab.subplots_adjust(hspace=0.25) fields = [u, v, vort, divU] field_names = ["u", "v", r"$\nabla \times U$", r"$\nabla \cdot U$"] for n in range(4): ax = axes.flat[n] f = fields[n] img = ax.imshow(np.transpose(f[myg.ilo:myg.ihi+1, myg.jlo:myg.jhi+1]), interpolation="nearest", origin="lower", extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax]) ax.set_xlabel("x") ax.set_ylabel("y") ax.set_title(field_names[n]) pylab.colorbar(img, ax=ax) pylab.figtext(0.05,0.0125, "t = %10.5f" % self.cc_data.t) pylab.draw()
def plot(cluster, filename="plot.png", func=lambda a: a.id, plot_title='', cmap='Paired', filter=lambda a: True, draw_legend=False, radius='2.25', sym=None): ac = rc.load(cluster) clusters = rc.load_clusters(cluster) p = get_population() pops = [0 for i in range(30000)] cluster_pops = [] cluster_pop_max = [] for clust in range(len(clusters)): cluster_pops.append(pops[:]) cluster_pop_max.append([0,0,-1,0]) for clust,agents in enumerate(clusters): for agent in agents: a = Agent(agent) for i in range(a.birth, a.death): cluster_pops[clust][i] += 1 if cluster_pop_max[clust][2] == -1: cluster_pop_max[clust][2] = i if i > cluster_pop_max[clust][3]: cluster_pop_max[clust][3] = i if cluster_pops[clust][i] > cluster_pop_max[clust][0]: cluster_pop_max[clust][0] = cluster_pops[clust][i] cluster_pop_max[clust][1] = i lines=[] for i,clust in enumerate(cluster_pops): lines.append(pylab.plot(range(30000),clust, label=("%d: k=%d" % (i, len(clusters[i]))), color=pylab.cm.Paired(float(i)/len(clusters)))) if draw_legend: pylab.figlegend(lines, ["%d: k=%d" % (i, len(clust)) for i,clust in enumerate(clusters)], 'center right', ncol=((len(clusters)/35)+1), prop=dict(size=6)) else: print "should not draw!!!" title = r"Cluster Population ($\epsilon$ = %s, %d clusters)" % (radius, len(clusters)) pylab.title(title, weight='black') pylab.xlabel("Time", weight='bold') pylab.ylabel("Population Size", weight='bold') if sym is not None: pylab.figtext(0,.954, '(%s)' % sym, size=6, weight='black') pylab.savefig(filename, dpi=300) print 'cluster, totalPop, start, peak, stop, maxPop' for clust,agents in enumerate(clusters): print clust, len(agents), cluster_pop_max[clust][2], cluster_pop_max[clust][1], cluster_pop_max[clust][3]+1, cluster_pop_max[clust][0]
def main(fileNames, ylog, remote, plotStyle): if ylog: pylab.subplot(111, xscale='log', yscale='log') else: pylab.subplot(111, xscale='log') for fileName in fileNames: with open(fileName, 'r') as f: size = numpy.array(json.loads(f.readline())[1:]) benchmark = map(json.loads, f.readlines()) for test in benchmark: if not remote and test['label'].endswith('R-to-C'): continue rawData = test.pop('data') data = [d for d in rawData if -1.0 not in d] length = len(data) if length != len(rawData): print('Invalid measurement encountered in ' '{0}.'.format(test['label'])) data = numpy.array(data) if length > 1: mean = numpy.mean(data, 0)[1:] var = numpy.var(data, 0)[1:] minVal = numpy.min(data, 0)[1:] maxVal = numpy.max(data, 0)[1:] elif length == 1: mean = numpy.array(data[0][1:]) var = None else: print('No valid measurements for {0}.'.format(test['label'])) continue if plotStyle == 'minmax': pylab.errorbar(size, mean, numpy.array([minVal, maxVal]), **test) elif plotStyle == 'variance': pylab.errorbar(size, mean, var, **test) else: pylab.errorbar(size, mean, **test) if 'paper.data' in fileNames: pylab.figtext(0.8, 0.8, 'green: paper measurements', ha='right') pylab.xlabel('number of characters') pylab.ylabel('time [ms]') pylab.legend(loc='upper left') pylab.show()
def plot_F_and_pi(F, pi, causes, title=""): N, T, J = F.shape pl.figure(figsize=(0.5 * T, 1.0 * J)) left = 2.0 / (T + 5.0) right = 1 - 0.05 / T bottom = 2.0 / (T + 5.0) top = 1 - 0.05 / T xmax = F.max() dj = (top - bottom) / J dt = (right - left) / T ax = {} for jj, j in enumerate(sorted(range(J), key=lambda j: pi[:, :, j].mean())): for t in range(T): pl.axes([left + t * dt, bottom + jj * dj, dt, dj]) pl.plot(pl.randn(N), F[:, t, j], "b.", alpha=0.5, zorder=-100) pl.plot(0.5 * pl.randn(N), pi[:N, t, j], "g.", alpha=0.5, zorder=100) # pi[:,t,j].sort() # below = pi[:, t, j].mean() - pi[:,t,j][.025*N] # above = pi[:,t,j][.975*N] - pi[:, t, j].mean() # pl.errorbar([0], pi[:, t, j].mean(), [[below], [above]], # fmt='gs', ms=10, mew=1, mec='white', linewidth=3, capsize=10, # zorder=100) pl.text( -2.75, xmax * 0.9, "%.0f\n%.0f\n%.0f" % ( 100 * F[:, t, j].mean(), 100 * pi[:, t, j].mean(), 100 * pi[:, t, j].mean() - 100 * F[:, t, j].mean(), ), va="top", ha="left", ) pl.xticks([]) pl.yticks([0.25, 0.5, 0.75]) if jj == 0: pl.xlabel("%d\n%.0f" % (t + 1980, 100 * F[:, t, :].sum() / N)) if t > 0: pl.yticks([]) else: pl.ylabel(causes[j]) pl.axis([-3, 3, 0, xmax]) if title: pl.figtext(0.01, 0.99, title, va="top", ha="left")
def do3DSimulation(): fig = plt.figure() ax = fig.gca(projection='3d') mCoeff1List = np.linspace(0,1,12) mCoeff2List = np.linspace(0,1,12) #mCoeffList = [1] err1List = [] err2List = [] #print mCoeffList X, Y = np.meshgrid(mCoeff1List, mCoeff2List) z1s = np.array([calculateError3Comps(x,y) for x,y in zip(np.ravel(X), np.ravel(Y))]) z2s = np.array([calculateRMSError3Comps(x,y) for x,y in zip(np.ravel(X), np.ravel(Y))]) #R = np.sqrt(X**2 + Y**2) #Z = np.sin(R) Z1 = z1s.reshape(X.shape) Z2 = z2s.reshape(X.shape) #surf = ax.plot_surface(X, Y, Z1) #surf = ax.plot_surface(X, Y, Z2) #surf = ax.plot_surface(X, Y, Z1, rstride=1, cstride=1, cmap=cm.afmhot,linewidth=0, antialiased=False) surf = ax.plot_surface(X, Y, Z1, rstride=1, cstride=1, cmap=cm.afmhot) ax.set_zlim(0, 1.8) ax.view_init(elev=25,azim=-25) ax.zaxis.set_major_locator(LinearLocator(10)) ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f')) ax.set_xticks([0,0.2,0.8,1.0]) ax.set_yticks([0,0.2,0.8,1.0]) ax.set_zticks([0,0.5,1.0,1.8]) #ax.set_xticks([0,0.2,0.4,0.6,0.8,1.0]) #fig.colorbar(surf, shrink=0.5, aspect=5) for tick in ax.xaxis.get_major_ticks(): tick.label.set_fontsize(15) for tick in ax.yaxis.get_major_ticks(): tick.label.set_fontsize(15) for tick in ax.zaxis.get_major_ticks(): tick.label.set_fontsize(15) ax.grid(color='black',linestyle='-', linewidth=1) ax.set_xlabel("$m_{f_{1}f_{2}}$",fontsize=28) ax.set_ylabel("$m_{f_{1}f_{3}}$",fontsize=28) ax.set_zlabel("Overall error",fontsize=24) plt.figtext(0.25, 0.8, "$|E_{f_{1}}| = |E_{f_{2}}| = |E_{f_{3}}| = 1.0$",fontsize=24) #plt.title("Variation of overall error with MIC between 3 error components",fontsize=24) plt.savefig("simu3d.eps",format="eps",dpi=800,bbox_inches="tight") plt.show()
color = '#114568' xsize = 800 figpat = '../doc/source/images/sonat-{xsize}-{bgcolor}{shadow}.svg' aspect = 1 / 4.5 xisize = 1. * xsize / dpi yisize = xisize * aspect sonat_size = 145. * xisize / 8. o_size = 50 * xisize / 8. figfiles = [] P.figure(figsize=(xisize, yisize), dpi=dpi) kw = dict(ha='center', va='center', color=color, weight='bold') ts = P.figtext(.5, .41, 'SONAT', size=sonat_size, **kw) to = P.figtext(.302, .49, 'O', size=o_size, **kw) shadow = '' bgcolor = 'transp' figfiles.append(figpat.format(**locals())) checkdir(figfiles[-1], asfile=True) P.savefig(figfiles[-1], transparent=True) bgcolor = 'white' figfiles.append(figpat.format(**locals())) P.savefig(figfiles[-1]) bgcolor = 'blue' figfiles.append(figpat.format(**locals())) P.savefig(figfiles[-1], facecolor="#2882B9")
print("Shape") print(data_new.shape) pylab.figure() pylab.title('PC2 VS PC1') pylab.xlabel('PC1') pylab.ylabel('PC2') graph_dir = '~/deep_learning_microbiome/analysis/kmers_rel_abundance' pylab.scatter(data_new[:, 0],data_new[:, 1]) pylab.gca().set_position((.1, .4, .8, .6)) pylab.figtext(0.02, .24, 'This graph shows the relative abundance data plotted with 2-component PCA') pylab.savefig(os.path.expanduser(graph_dir + '/pca_two_components' + '.pdf'), bbox_inches='tight') pylab.figure() pylab.title('Explained Variance vs Number of Components') pylab.xlabel('Components') pylab.ylabel('Total Variance') nComponents = 10 fileInfo = '_totalnumcomponents-{}'.format(nComponents) total_variance = 0 for i in range(1, nComponents): pca = PCA(n_components=i)
def buildADS1115Graph(password, myGraphSampleCount, graphNumber): print('buildADS1115Graph%d - The time is: %s' % (graphNumber, datetime.now())) # open database con1 = mdb.connect('localhost', 'root', password, 'DataLogger' ) # now we have to get the data, stuff it in the graph mycursor = con1.cursor() print myGraphSampleCount query = '(SELECT timestamp, deviceid, channel0_voltage, channel0_raw, channel1_voltage, channel1_raw, channel2_voltage, channel2_raw, channel3_voltage, channel3_raw, id FROM '+ADS1115tableName+' ORDER BY id DESC LIMIT '+ str(myGraphSampleCount) + ') ORDER BY id ASC' print "query=", query try: mycursor.execute(query) result = mycursor.fetchall() except: e=sys.exc_info()[0] print "Error: %s" % e print result[0] t = [] # time u = [] # channel 1 - Current averageCurrent = 0.0 currentCount = 0 for record in result: t.append(record[0]) # adjust according to graphNumber if (graphNumber == 0): addValue = record[graphNumber*2+3] if (graphNumber == 1): # O2 Sensor sensorVoltage = record[graphNumber*2+2]*(5.0/6.144) AMP = 121 K_O2 = 7.43 sensorVoltage = sensorVoltage/AMP*10000.0 Value_O2 = sensorVoltage/K_O2 addValue = Value_O2 - 1.05 if (graphNumber == 2): addValue = record[graphNumber*2+2] if (graphNumber == 3): addValue = record[graphNumber*2+2] u.append(addValue) averageCurrent = averageCurrent+addValue currentCount=currentCount+1 averageCurrent = averageCurrent/currentCount print ("count of t=",len(t)) #x1 = [datetime.strptime(d, '%Y-%m-%d %H:%M:%S',) for d in t] x1 = [d for d in t] fds = dates.date2num(x1) # converted # matplotlib date format object hfmt = dates.DateFormatter('%H:%M:%S') #hfmt = dates.DateFormatter('%m/%d-%H') fig = pyplot.figure() fig.set_facecolor('white') ax = fig.add_subplot(111,facecolor = 'white') ax.vlines(fds, -200.0, 1000.0,colors='w') #ax.xaxis.set_major_locator(dates.MinuteLocator(interval=1)) ax.xaxis.set_major_formatter(hfmt) if (graphNumber == 0): ax.set_ylim(bottom = 0.0) pyplot.xticks(rotation='45') pyplot.subplots_adjust(bottom=.3) pylab.plot(fds, u, color='r',label="Air Quality Sensor",linestyle="-",marker=".") if (graphNumber == 1): ax.set_ylim(bottom = 0.0) pyplot.xticks(rotation='45') pyplot.subplots_adjust(bottom=.3) pylab.plot(fds, u, color='r',label="Oxygen (O2) Sensor ",linestyle="-",marker=".") if (graphNumber == 2): ax.set_ylim(bottom = 0.0) pyplot.xticks(rotation='45') pyplot.subplots_adjust(bottom=.3) pylab.plot(fds, u, color='r',label="Light Sensor",linestyle="-",marker=".") if (graphNumber == 3): ax.set_ylim(bottom = -200.0) pyplot.xticks(rotation='45') pyplot.subplots_adjust(bottom=.3) pylab.plot(fds, u, color='r',label="Voltage Divider ",linestyle="-",marker=".") pylab.xlabel("Seconds") pylab.legend(loc='lower center') if (graphNumber == 0): pylab.axis([min(fds), max(fds), 0, max(u)+1000]) pylab.ylabel("Raw Data") if (graphNumber == 1): pylab.axis([min(fds), max(fds), 0, max(u)+2]) pylab.ylabel("Percent (%)") if (graphNumber == 2): pylab.axis([min(fds), max(fds), 0, max(u)+2]) pylab.ylabel("Voltage (V)") if (graphNumber == 3): pylab.axis([min(fds), max(fds), 0, max(u)+2]) pylab.ylabel("Voltage Divider (V)") if (graphNumber == 0): pylab.figtext(.5, .05, ("Average Air Quality %6.2f\n%s") %(averageCurrent, datetime.now()),fontsize=18,ha='center') if (graphNumber == 1): pylab.figtext(.5, .05, ("Average O2 %6.2f %%\n%s") %(averageCurrent, datetime.now()),fontsize=18,ha='center') if (graphNumber == 2): pylab.figtext(.5, .05, ("Average Light Sensor %6.2f V\n%s") %(averageCurrent, datetime.now()),fontsize=18,ha='center') if (graphNumber == 3): pylab.figtext(.5, .05, ("Average Voltage Divider %6.2f V\n%s") %(averageCurrent, datetime.now()),fontsize=18,ha='center') pylab.grid(True) pyplot.show() pyplot.savefig("/var/www/html/ADS1115DataLoggerGraph"+str(graphNumber)+".png", facecolor=fig.get_facecolor()) mycursor.close() con1.close() fig.clf() pyplot.close() pylab.close() gc.collect() print "------ADS1115Graph"+str(graphNumber)+" finished now"
ecart.append(abs(predic_score - score_spkshow[spk_test])) val.append(round(np.mean(ecart), 3)) if round(np.mean(ecart), 3) < lower_ecart[0]: lower_ecart = [round(np.mean(ecart), 3), round(predic_score, 2)] print 'spkshow lower ecart', lower_ecart fig1 = plt.figure() fig1.suptitle('ecart/prediction baseline spkshow', fontsize=14, fontweight='bold') plt.ylabel('ecart') plt.xlabel('prediction') plt.plot(np.arange(0, 1.01, 0.05), val) plt.ylim([0, 1]) plt.figtext( .01, .01, "plus petit ecart : " + str(lower_ecart[0]) + " pour prediction=" + str(lower_ecart[1])) fig1.savefig('spkshow_base_line') plt.show() score_spkseg = {} lower_ecart = [1.0, 0.0] for line in open(l_spkseg_file): l = line[:-1].split(' ') score_spkseg.setdefault(l[0] + '#' + l[3], {}) score_spkseg[l[0] + '#' + l[3]][l[1] + ' ' + l[2]] = [] for line in open(score_file_spkseg['f']): l = line[:-1].split(' ') spk = l[0] + '#' + l[3] seg = str(float(l[1])) + ' ' + str(float(l[2]))
def TemperatureHumidityGraph(source, days, delay): print("TemperatureHumidityGraph source:%s days:%s" % (source, days)) print("sleeping seconds:", delay) time.sleep(delay) print("TemperatureHumidityGraph running now") # blink GPIO LED when it's run GPIO.setup(18, GPIO.OUT) GPIO.output(18, True) time.sleep(0.2) GPIO.output(18, False) # now we have get the data, stuff it in the graph try: print("trying database") db = mdb.connect('localhost', 'root', DATABASEPASSWORD, 'WeatherPi') cursor = db.cursor() query = "SELECT TimeStamp, bmp180Temperature, outsideTemperature, outsideHumidity, insideHumidity FROM WeatherData where now() - interval %i hour < TimeStamp" % ( days * 24) print "query=", query cursor.execute(query) result = cursor.fetchall() t = [] u = [] v = [] x = [] z = [] fig = pyplot.figure() for record in result: t.append(record[0]) u.append(record[1]) v.append(record[2]) x.append(record[3]) z.append(record[4]) print("count of t=", len(t)) if (len(t) == 0): return #dts = map(datetime.datetime.fromtimestamp, s) #fds = dates.date2num(dts) # converted # matplotlib date format object hfmt = dates.DateFormatter('%m/%d-%H') ax = fig.add_subplot(111) ax.xaxis.set_major_locator(dates.HourLocator(interval=6)) ax.xaxis.set_major_formatter(hfmt) pylab.xticks(rotation='vertical') pyplot.subplots_adjust(bottom=.3) pylab.plot(t, v, color='g', label="Outside Temp (C)", linestyle="-", marker=".") pylab.plot(t, u, color='r', label="Inside Temp (C)", linestyle="-", marker=".") pylab.xlabel("Hours") pylab.ylabel("degrees C") pylab.legend(loc='upper left') pylab.axis([min(t), max(t), 0, 40]) ax2 = pylab.twinx() pylab.ylabel("% ") pylab.plot(t, x, color='y', label="Outside Hum %", linestyle="-", marker=".") pylab.plot(t, z, color='b', label="Inside Hum %", linestyle="-", marker=".") pylab.axis([min(t), max(t), 0, 100]) pylab.legend(loc='lower left') pylab.figtext(.5, .05, ("Environmental Statistics Last %i Days" % days), fontsize=18, ha='center') #pylab.grid(True) pyplot.setp(ax.xaxis.get_majorticklabels(), rotation=70) ax.xaxis.set_major_formatter(dates.DateFormatter('%m/%d-%H')) pyplot.show() pyplot.savefig( "/home/pi/WeatherPiRasPiConnectServer/static/TemperatureHumidityGraph.png" ) except mdb.Error, e: print "Error %d: %s" % (e.args[0], e.args[1])
pl.hist(whk1124a, bins=20, alpha=0.5) pl.xlabel('Whiker Length [adaptive moments]') pl.vlines(0.2, 0, 10, color='r', lw=2) pl.title('11/24/2012') pl.grid() pl.subplot(3, 3, 9) pl.hist(whk1202a, bins=20, alpha=0.5) pl.xlabel('Whiker Length [adaptive moments]') pl.vlines(0.2, 0, 10, color='r', lw=2) pl.ylim(0, 10) pl.title('12/02/2012') pl.grid() pl.figtext(0.35, 0.95, 'Distribution of Mean Whisker Length', color='b', fontsize=18) pl.savefig('whisker_robust_mean_summary.png') #----median fwhm distribution ---- pl.figure(figsize=(15, 15)) pl.subplot(3, 3, 1) pl.hist(fwhm1123w, bins=20, alpha=0.5) pl.xlabel('Whiker Length [weighed moments]') pl.vlines(0.9, 0, 10, color='r', lw=2) pl.ylim(0, 10) pl.xlim(0.6, 2.0) pl.title('11/23/2012') pl.grid()
def aspcap_residue_plot(self, test_predictions, test_labels, test_pred_error=None, test_labels_err=None): """ NAME: aspcap_residue_plot PURPOSE: plot aspcap residue INPUT: test_predictions (ndarray): Test result from neural network test_labels (ndarray): Gound truth for tests result test_pred_error (ndarray): (Optional) 1-sigma error for tests result from Baysian neural network. test_labels_err (ndarray): (Optional) Gound truth for tests result OUTPUT: None, just plots to be saved HISTORY: 2018-Jan-28 - Written - Henry Leung (University of Toronto) """ import pylab as plt import numpy as np import seaborn as sns print("Start plotting residues") resid = test_predictions - test_labels # Some plotting variables for asthetics plt.rcParams['axes.facecolor'] = 'white' sns.set_style("ticks") plt.rcParams['axes.grid'] = True plt.rcParams['grid.color'] = 'gray' plt.rcParams['grid.alpha'] = '0.4' x_lab = 'ASPCAP' y_lab = 'astroNN' fullname = self.targetname aspcap_residue_path = os.path.join(self.fullfilepath, 'ASPCAP_residue') if not os.path.exists(aspcap_residue_path): os.makedirs(aspcap_residue_path) mad_labels = np.zeros(test_labels.shape[1]) for i in range(test_labels.shape[1]): not9999_index = np.where(test_labels[:, i] != MAGIC_NUMBER) mad_labels[i] = mad((test_labels[:, i])[not9999_index], axis=0) if test_pred_error is None: # To deal with prediction from non-Bayesian Neural Network test_pred_error = np.zeros(test_predictions.shape) for i in range(self._labels_shape): plt.figure(figsize=(15, 11), dpi=200) plt.axhline(0, ls='--', c='k', lw=2) not9999 = np.where(test_labels[:, i] != -9999.)[0] plt.errorbar((test_labels[:, i])[not9999], (resid[:, i])[not9999], yerr=(test_pred_error[:, i])[not9999], markersize=2, fmt='o', ecolor='g', capthick=2, elinewidth=0.5) plt.xlabel('ASPCAP ' + target_name_conversion(fullname[i]), fontsize=25) plt.ylabel('$\Delta$ ' + target_name_conversion(fullname[i]) + '\n(' + y_lab + ' - ' + x_lab + ')', fontsize=25) plt.tick_params(labelsize=20, width=1, length=10) if self._labels_shape == 1: plt.xlim([ np.min((test_labels[:])[not9999]), np.max((test_labels[:])[not9999]) ]) else: plt.xlim([ np.min((test_labels[:, i])[not9999]), np.max((test_labels[:, i])[not9999]) ]) ranges = (np.max((test_labels[:, i])[not9999]) - np.min( (test_labels[:, i])[not9999])) / 2 plt.ylim([-ranges, ranges]) bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=2) bias = np.median((resid[:, i])[not9999], axis=0) scatter = mad((resid[:, i])[not9999], axis=0) plt.figtext(0.6, 0.75, '$\widetilde{m}$=' + '{0:.3f}'.format(bias) + ' $\widetilde{s}$=' + '{0:.3f}'.format(scatter / float(mad_labels[i])) + ' s=' + '{0:.3f}'.format(scatter), size=25, bbox=bbox_props) plt.tight_layout() plt.savefig(aspcap_residue_path + f'/{fullname[i]}_test.png') plt.close('all') plt.clf() if test_labels_err is not None: for i in range(self._labels_shape): plt.figure(figsize=(15, 11), dpi=200) plt.axhline(0, ls='--', c='k', lw=2) not9999 = np.where(test_labels[:, i] != -9999.)[0] plt.scatter((test_labels_err[:, i])[not9999], (resid[:, i])[not9999], s=0.7) plt.xlabel('ASPCAP Error of ' + target_name_conversion(fullname[i]), fontsize=25) plt.ylabel('$\Delta$ ' + target_name_conversion(fullname[i]) + '\n(' + y_lab + ' - ' + x_lab + ')', fontsize=25) plt.tick_params(labelsize=20, width=1, length=10) if self._labels_shape == 1: plt.xlim([ np.percentile((test_labels_err[:])[not9999], 5), np.percentile((test_labels_err[:])[not9999], 95) ]) else: plt.xlim([ np.min((test_labels_err[:, i])[not9999]), np.percentile((test_labels_err[:, i])[not9999], 90) ]) ranges = (np.percentile( (resid[:, i])[not9999], 5) - np.percentile( (resid[:, i])[not9999], 95)) plt.ylim([-ranges, ranges]) plt.tight_layout() plt.savefig(aspcap_residue_path + f'/{fullname[i]}_test_err.png') plt.close('all') plt.clf() print("Finished plotting residues")
def myplot(path='.',output=-1,sink=False,center=[0.5,0.5,0.5],los='x',size=[0.5,0.5], \ minimum=None,maximum=None,typlot='rho',record=False,igrp=-1,plot_velocity=False,slice=False): filerep = path if (record): savedir = os.path.join(filerep, "results") if not os.path.exists(savedir): os.makedirs(savedir) #mu,alpha,lmax = parseDirSink(directory) #savedir = checkDir(savedir, "mu" + mu) #savedir = checkDir(savedir, "lmax" + lmax) # if output=-1, take last output if output == -1: outputname = np.sort(glob.glob(os.path.join(filerep, "output_?????")))[-1] output = int(outputname.split('_')[-1]) # Define the file ro = pm.RamsesOutput(filerep, output) if igrp != -1 and (igrp > ro.info["ngrp"] or igrp < 0): print(bold + 'PROBLEM:' + reset + ' igrp=' + str(igrp) + ' but simulation with ngrp=' + str(ro.info["ngrp"])) sys.exit(1) # Define the output data structure (to use with pymses5) ro.define_amr_scalar_field("hydro", "rho", 0) ro.define_amr_vector_field("hydro", "vel", [1, 2, 3]) ro.define_amr_vector_field("hydro", "Bl", [4, 5, 6]) ro.define_amr_vector_field("hydro", "Br", [7, 8, 9]) ro.define_amr_scalar_field("hydro", "P", 10) ro.define_amr_multivalued_field("hydro", "Er", 11, ro.info["ngrp"]) ro.define_amr_vector_field( "hydro", "J", [11 + ro.info["ngrp"], 12 + ro.info["ngrp"], 13 + ro.info["ngrp"]]) ro.define_amr_scalar_field("hydro", "eint", 14 + ro.info["ngrp"]) if ro.info["eos"]: ro.define_amr_scalar_field("hydro", "T", 15 + ro.info["ngrp"]) ro.define_amr_vector_field("grav", "g", [0, 1, 2]) time = ro.info["time"] * ro.info["unit_time"].express(ct.kyr) if (sink): # Read sink particles sink_filename = os.path.join( filerep, 'output_%05d' % output + '/sink_%05d' % output + '.csv') print("Reading sinks : " + reset + sink_filename) sinkp = np.loadtxt(sink_filename, dtype={ 'names': ('Id', 'mass', 'x', 'y', 'z', 'vx', 'vy', 'vz', 'rot_period', 'lx', 'ly', 'lz', 'acc_rate', 'acc_lum', 'age', 'int_lum', 'Teff'), 'formats': ('i', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f') }, delimiter=',') sinkp = np.atleast_1d(sinkp) # to work even if only 1 sink nsink = sinkp.size # Define the accretion radius if ("ncell_racc" in ro.info): ncell_racc = ro.info['ncell_racc'] else: ncell_racc = 4 dxmin = 0.5**ro.info['levelmax'] * ro.info["unit_length"].express( ct.au) r_acc = dxmin * ncell_racc #area = np.pi*r_acc**2 xc, yc, zc = sinkp['x'] / ro.info['boxlen'], sinkp['y'] / ro.info[ 'boxlen'], sinkp['z'] / ro.info['boxlen'] else: nsink = 0 if nsink == 0: nsink = 1 # Center xc, yc, zc = np.atleast_1d(center[0]), np.atleast_1d( center[1]), np.atleast_1d(center[2]) cmap = pl.cm.get_cmap('seismic', 100) if typlot == 'rho': cmap = pl.cm.get_cmap('jet', 100) elif typlot == 'Tr': cmap = pl.cm.get_cmap('hot', 100) elif typlot == 'B': cmap = pl.cm.get_cmap('PuOr', 100) elif typlot == 'beta_plasma': cmap = pl.cm.get_cmap('seismic', 100) else: cmap = pl.cm.get_cmap('jet', 100) # Width of the region to plot xr, yr = size[0], size[1] xbl = (-xr / 2. * ro.info["unit_length"]).express(ct.au) xbr = (+xr / 2. * ro.info["unit_length"]).express(ct.au) ybl = (-yr / 2. * ro.info["unit_length"]).express(ct.au) ybr = (+yr / 2. * ro.info["unit_length"]).express(ct.au) extent = [xbl, xbr, ybl, ybr] # Define camera if los == 'x': upvec = "z" vx = 1 vy = 2 labelx = 'Y (AU)' labely = 'Z (AU)' plane = 'yz' elif los == 'y': upvec = "x" vx = 2 vy = 0 labelx = 'Z (AU)' labely = 'X (AU)' plane = 'zx' elif los == 'z': upvec = "y" vx = 0 vy = 1 labelx = 'X (AU)' labely = 'Y (AU)' plane = 'xy' def plot_func(dset): if typlot == 'rho': return dset['rho'] * ro.info["unit_density"].express( ct.g / ct.cm**3) if typlot == 'eint': return dset['eint'] * (ro.info["unit_density"] * ro.info["unit_velocity"]**2).express( ct.erg / ct.cm**3) if typlot == 'T': if ro.info["eos"]: return dset['T'] else: return dset['P'] / dset['rho'] * ro.info[ "unit_temperature"].express(ct.K) * ro.info["mu_gas"] if typlot == 'B': B = 1./4*( (dset['Bl'][:,0]+dset['Br'][:,0])**2 \ +(dset['Bl'][:,1]+dset['Br'][:,1])**2 \ +(dset['Bl'][:,2]+dset['Br'][:,2])**2) return B # To use with pymses5 if typlot == 'Er' or typlot == 'Tr': if igrp == -1: Er = np.sum(dset['Er'], axis=-1) * ( ro.info["unit_density"] * ro.info["unit_velocity"]**2).express(ct.erg / ct.cm**3) else: Er = dset['Er'][:, igrp - 1] * ( ro.info["unit_density"] * ro.info["unit_velocity"]**2).express(ct.erg / ct.cm**3) if typlot == 'Er': return Er else: return (Er / ct.a_R.express(ct.erg / ct.cm**3 / ct.K**4))**0.25 if typlot == 'entropy': return dset['P'] / dset['rho']**ro.hydro_info["gamma"] if typlot == 'Pth_Pdyn': return dset['P'] / (0.5 * dset['rho'] * np.sum(dset['vel']**2, axis=-1)) if typlot == 'beta_plasma': B = 1./4.*( (dset['Bl'][:,0]+dset['Br'][:,0])**2 \ +(dset['Bl'][:,1]+dset['Br'][:,1])**2 \ +(dset['Bl'][:,2]+dset['Br'][:,2])**2) if igrp == -1: Er = np.sum( dset['Er'], axis=-1 ) #*(ro.info["unit_density"]*ro.info["unit_velocity"]**2).express(ct.erg/ct.cm**3) else: Er = dset[ 'Er'][:, igrp - 1] #*(ro.info["unit_density"]*ro.info["unit_velocity"]**2).express(ct.erg/ct.cm**3) return dset['P'] / (B) #/dset['rho']) else: print(bold + 'Problem in typlot') sys.exit() # Fields to be read fields_to_read = [] if (not ro.info["eos"] and typlot == 'T') or typlot == 'entropy': fields_to_read = ["rho", "P"] elif typlot == 'Tr': fields_to_read = ["Er"] elif typlot == 'Pth_Pdyn': fields_to_read = ["P", "rho", "vel"] elif typlot == 'B': fields_to_read = ["Bl", "Br"] elif typlot == 'beta_plasma': fields_to_read = ["Bl", "Br", "rho", "P", "Er"] else: fields_to_read = [typlot] if (plot_velocity): fields_to_read.append("vel") if not slice: fields_to_read.append("rho") fields_to_read = list(set(fields_to_read)) #to remove duplicates if slice: source = ro.amr_source(fields_to_read) varplot_op = ScalarOperator(plot_func) else: rt = raytracing.RayTracer(ro, fields_to_read) if typlot == 'rho': func = lambda dset: plot_func(dset) * ro.info["unit_length" ].express(ct.cm) varplot_op = ScalarOperator(func) else: up_func = lambda dset: (dset["rho"] * ro.info["unit_density"]. express(ct.g / ct.cm**3) * plot_func(dset)) down_func = lambda dset: (dset["rho"] * ro.info["unit_density"]. express(ct.g / ct.cm**3)) varplot_op = FractionOperator(up_func, down_func) for i in range(nsink): fig = pl.figure() ax = pl.subplot(111) pl.xlabel(labelx) pl.ylabel(labely) cam = Camera(center=[xc[i], yc[i], zc[i]],line_of_sight_axis=los,region_size=[xr, yr] \ , up_vector=upvec,map_max_size=512, log_sensitive=True) if slice: mapx = SliceMap(source, cam, varplot_op, z=0.) else: # WARNING! surf_qty=True to get an integral over dz and not dSdz # so that if typlot=='rho', get surface density map # and if not, get a density-weighted map (and not a mass-weighted map) mapx = rt.process(varplot_op, cam, surf_qty=True) if typlot == 'Pth_Pdyn': imx = pl.imshow(mapx.transpose(), extent = extent, origin='lower' \ , vmin = minimum, vmax = maximum,cmap=cmap) #imx = pl.contourf(mapx.transpose(), extent = extent, origin='lower' \ # , vmin = minimum, vmax = maximum) cbar = pl.colorbar() cbar.set_label(typlot) else: imx = pl.imshow(np.log10(mapx.transpose()), extent = extent, origin='lower' \ , vmin = minimum, vmax = maximum,cmap=cmap) #imx = pl.contourf(np.log10(mapx.transpose()), extent = extent, origin='lower' \ # , vmin = minimum, vmax = maximum) cbar = pl.colorbar() # cmap = pl.cm.get_cmap('jet',100) if typlot == 'rho': cbar.set_label(r'$\mathrm{log(}\rho)$', fontsize=15) elif typlot == 'Tr': cbar.set_label(r'$\mathrm{log(T_r)}$', fontsize=15) elif typlot == 'Pth_Pdyn': cbar.set_label('Pth/Pdyn') elif typlot == 'B': cbar.set_label('log(|B|)') elif typlot == 'beta_plasma': cbar.set_label(r'$\mathrm{log(}\beta)$', fontsize=15) else: cbar.set_label('Log(' + typlot + ')') if (sink): for isink in range(nsink): # Plot sinks position mass = sinkp[isink]["mass"] col = cmap(int(mass * 100)) xp = (sinkp[isink]['x'] / ro.info['boxlen'] - xc[i]) * ro.info["unit_length"].express(ct.au) yp = (sinkp[isink]['y'] / ro.info['boxlen'] - yc[i]) * ro.info["unit_length"].express(ct.au) zp = (sinkp[isink]['z'] / ro.info['boxlen'] - zc[i]) * ro.info["unit_length"].express(ct.au) if los == 'x': ax.add_patch( pl.Circle((yp, zp), radius=r_acc, fc='white', alpha=0.65)) ax.add_patch( pl.Circle((yp, zp), radius=(r_acc / ncell_racc), fc=col, ec=col)) #pl.plot(yp,zp,'k+',mew=2,ms=10) elif los == 'y': ax.add_patch( pl.Circle((zp, xp), radius=r_acc, fc='white', alpha=0.65)) ax.add_patch( pl.Circle((zp, xp), radius=(r_acc / ncell_racc), fc=col, ec=col)) #pl.plot(zp,xp,'k+',mew=2,ms=10) elif los == 'z': ax.add_patch( pl.Circle((xp, yp), radius=r_acc, fc='white', alpha=0.65)) ax.add_patch( pl.Circle((xp, yp), radius=(r_acc / ncell_racc), fc=col, ec=col)) #pl.plot(xp,yp,'k+',mew=2,ms=10) # Plot velocity field if (slice and plot_velocity): p = cam.get_slice_points(0.0) nx, ny = cam.get_map_size() dset = pm.analysis.sample_points(source, p) vel = dset["vel"] * ro.info["unit_velocity"].express(ct.km / ct.s) rs = 32 x = np.linspace(xbl, xbr, nx) y = np.linspace(ybl, ybr, ny) u, v = np.zeros((nx, ny)), np.zeros((nx, ny)) mask = np.zeros((nx, ny)) for ii in range(nx): for jj in range(ny): if (ii % rs == 0 and jj % rs == 0): u[ii, jj] = vel[:, vx].reshape(nx, ny)[ii, jj] v[ii, jj] = vel[:, vy].reshape(nx, ny)[ii, jj] else: u[ii, jj] = 'Inf' v[ii, jj] = 'Inf' mask[ii, jj] = 1 u2 = u[::rs, ::rs] v2 = v[::rs, ::rs] x2 = x[::rs] y2 = y[::rs] vel_mean = np.mean(np.sqrt(u2**2 + v2**2)) vel_max = np.max(np.sqrt(u2**2 + v2**2)) #pl.quiver(x,y,u.transpose(),v.transpose(),scale=20*nx) #Q=pl.quiver(x,y,u.transpose(),v.transpose(),scale=100,pivot='mid') #u_masked=np.ma.masked_array(u,mask=mask) #v_masked=np.ma.masked_array(v,mask=mask) #vel_mean=np.mean(np.sqrt(u_masked**2+v_masked**2)) Q = pl.quiver(x2, y2, u2.transpose(), v2.transpose(), scale=100, pivot='mid') #pl.quiverkey(Q,0.7,0.92,vel_mean,r'%.2f km/s'%vel_mean,coordinates='figure') pl.quiverkey(Q, 0.7, 0.92, vel_max, r'%.2f km/s' % vel_max, coordinates='figure') pl.axis(extent) del (u, v, x, y, u2, v2, x2, y2) if (sink): # Print the mass of the sinks mass = 0 for j in range(nsink): mass = mass + sinkp["mass"][j] pl.figtext(0.01, 00.01, "$\mathrm{M}_*=$" + "%4.1f " % mass + "$M_\odot$", fontsize=15) pl.suptitle("%.3f kyr" % time) if (record): for format in ("png", "eps", "pdf"): if slice: namefig = os.path.join( savedir, "slice_" + typlot + "_" + plane + "_eps" + "_%.3f" % size[0] + "_out" + "_%05d" % output + "_isink_%05d." % sinkp['Id'][i] + format) else: namefig = os.path.join( savedir, "proj_" + typlot + "_" + plane + "_eps" + "_%.3f" % size[0] + "_out" + "_%05d" % output + "_isink_%05d." % sinkp['Id'][i] + format) print(bold + "Save figure: " + reset + namefig) pl.savefig(namefig) pl.close() else: pl.ion() pl.show() if (sink): # Print the mass of the sinks for i in range(nsink): mass = sinkp["mass"][i] print(bold + "Mass(" + str(i) + "): " + reset + "%.2e Msun" % mass)
P.xlabel(r'$S_{\rm area}$ $[{\rm deg}^2]$', labelpad=10., fontdict={'fontsize':'xx-large'}) P.ylabel('$\sigma(w_0)$', labelpad=15., fontdict={'fontsize':'xx-large'}) # Set tick locations P.gca().xaxis.set_minor_locator(matplotlib.ticker.MultipleLocator(1000)) #P.yscale('log') # Legend leg = P.legend(prop={'size':18}, loc='upper right', frameon=True, ncol=1) leg.get_frame().set_edgecolor('w') leg.get_frame().set_alpha(0.8) P.ylim((0., YMAX)) print enames print exptnames # Experiment names t1 = P.figtext(0.25, 0.88, enames[1], transform=P.gca().transAxes, fontsize=18, color=colours[1]) t2 = P.figtext(0.25, 0.82, enames[0], transform=P.gca().transAxes, fontsize=18, color=colours[0]) t1.set_bbox(dict(color='w', alpha=0.7)) t2.set_bbox(dict(color='w', alpha=0.7)) # Set size P.tight_layout() #P.gcf().set_size_inches(8.4, 7.8) #P.gcf().set_size_inches(9.5, 6.8) P.savefig(fname, transparent=True) P.show()
def CreateFrames(path, runName, runExt, t0, t1, plane, configFile): assert ((plane == 'xzplane') | (plane == 'xyplane')) planeSelect = {'xzplane': 'xzplane', 'xyplane': 'xyplane'}[plane] # Make sure the output directory exisits if not make it dirname = os.path.join(path, 'figs', plane) if not os.path.exists(dirname): os.makedirs(dirname) print(('Rendering ' + planeSelect + 'plane, storing frames at ' + dirname)) #Now check to make sure the files are correct data = pyLTR.Models.LFM(path, runName, ext=runExt) modelVars = data.getVarNames() timeRange = data.getTimeRange() if len(timeRange) == 0: raise Exception(( 'No data files found. Are you pointing to the correct run directory?' )) index0 = 0 if t0: for i, t in enumerate(timeRange): if t0 >= t: index0 = i index1 = len(timeRange) - 1 if t1: for i, t in enumerate(timeRange): if t1 >= t: index1 = i print( ('Extracting LFM MAG quantities for time series over %d time steps.' % (index1 - index0))) # Output a status bar displaying how far along the computation is. progress = pyLTR.StatusBar(0, index1 - index0) progress.start() # Deal with the plot options if (configFile == None): vxOpts = {'min': -800., 'max': 800., 'colormap': 'RdBu_r'} vyOpts = {'min': -100., 'max': 100., 'colormap': 'RdBu_r'} vzOpts = {'min': -100., 'max': 100., 'colormap': 'RdBu_r'} bxOpts = {'min': -10., 'max': 10.} byOpts = {'min': -10., 'max': 10.} bzOpts = {'min': -10., 'max': 10.} rhoOpts = {'min': 0, 'max': 50} optsObject = { 'vx': vxOpts, 'vy': vyOpts, 'vz': vzOpts, 'bx': bxOpts, 'by': byOpts, 'bz': bzOpts, 'rho': rhoOpts } configFilename = os.path.join(dirname, 'MHDPlanes.config') print(("Writing plot config file at " + configFilename)) f = open(configFilename, 'w') f.write(pyLTR.yaml.safe_dump(optsObject, default_flow_style=False)) f.close() else: f = open(configFile, 'r') optsDict = pyLTR.yaml.safe_load(f.read()) f.close() if ('vx' in optsDict): vxOpts = optsDict['vx'] else: vxOpts = {'min': -800., 'max': 800., 'colormap': 'RdBu_r'} if ('vy' in optsDict): vyOpts = optsDict['vy'] else: vyOpts = {'min': -100., 'max': 100., 'colormap': 'RdBu_r'} if ('vz' in optsDict): vzOpts = optsDict['vz'] else: vzOpts = {'min': -100., 'max': 100., 'colormap': 'RdBu_r'} if ('bx' in optsDict): bxOpts = optsDict['bx'] else: bxOpts = {'min': -10., 'max': 10.} if ('by' in optsDict): byOpts = optsDict['by'] else: byOpts = {'min': -10., 'max': 10.} if ('bz' in optsDict): bzOpts = optsDict['bz'] else: bzOpts = {'min': -10., 'max': 10.} if ('rho' in optsDict): bzOpts = optsDict['rho'] else: rhoOpts = {'min': 0., 'max': 50.} vals = data.getEqSlice('X_grid', timeRange[0]) / 6.38e8 xeq = {'data': vals, 'name': r'$X$', 'units': r'$R_E$'} vals = data.getEqSlice('Y_grid', timeRange[0]) / 6.38e8 yeq = {'data': vals, 'name': r'$X$', 'units': r'$R_E$'} vals = data.getEqSlice('Z_grid', timeRange[0]) / 6.38e8 zeq = {'data': vals, 'name': r'$X$', 'units': r'$R_E$'} vals = data.getMerSlice('X_grid', timeRange[0]) / 6.38e8 xmer = {'data': vals, 'name': r'$X$', 'units': r'$R_E$'} vals = data.getMerSlice('Y_grid', timeRange[0]) / 6.38e8 ymer = {'data': vals, 'name': r'$X$', 'units': r'$R_E$'} vals = data.getMerSlice('Z_grid', timeRange[0]) / 6.38e8 zmer = {'data': vals, 'name': r'$X$', 'units': r'$R_E$'} for i, time in enumerate(timeRange[index0:index1]): try: #first read the data vals = data.getEqSlice('vx_', time) / 1000.0 vx = {'data': vals, 'name': r'$V_X$', 'units': r'km/s'} vals = data.getEqSlice('vy_', time) / 1000.0 vy = {'data': vals, 'name': r'$V_Y$', 'units': r'km/s'} vals = data.getEqSlice('vz_', time) / 1000.0 vz = {'data': vals, 'name': r'$V_Z$', 'units': r'km/s'} vals = data.getEqSlice('bx_', time) bx = {'data': vals, 'name': r'$B_X$', 'units': r'nT'} vals = data.getEqSlice('by_', time) by = {'data': vals, 'name': r'$B_Y$', 'units': r'nT'} vals = -1.0 * data.getEqSlice('bz_', time) bz = {'data': vals, 'name': r'$B_Z$', 'units': r'S'} # Now onto the plot tt = time.timetuple() p.figure(figsize=(16, 12)) p.figtext(0.5, 0.92, 'LFM ' + '\n%4d-%02d-%02d %02d:%02d:%02d' % (tt.tm_year, tt.tm_mon, tt.tm_mday, tt.tm_hour, tt.tm_min, tt.tm_sec), fontsize=14, multialignment='center') ax = p.subplot(231) x = xeq['data'] y = yeq['data'] pyLTR.Graphics.CutPlane.CutPlaneDict(x, y, vx, vxOpts, userAxes=ax) ax = p.subplot(234) pyLTR.Graphics.CutPlane.CutPlaneDict(x, y, vy, vyOpts, userAxes=ax) ax = p.subplot(232) pyLTR.Graphics.CutPlane.CutPlaneDict(x, y, vz, vzOpts, userAxes=ax) ax = p.subplot(235) pyLTR.Graphics.CutPlane.CutPlaneDict(x, y, bx, bxOpts, userAxes=ax) ax = p.subplot(233) pyLTR.Graphics.CutPlane.CutPlaneDict(x, y, by, byOpts, userAxes=ax) ax = p.subplot(236) pyLTR.Graphics.CutPlane.CutPlaneDict(x, y, bz, bzOpts, userAxes=ax) savefigName = os.path.join(path, 'figs', plane, 'frame_%05d.png' % i) p.savefig(savefigName, dpi=100) p.close() progress.increment() except KeyboardInterrupt: # Exit when the user hits CTRL+C. progress.stop() progress.join() print('Exiting.') import sys sys.exit(0) except: # Cleanup progress bar if something bad happened. progress.stop() progress.join() raise progress.stop() progress.join() return os.path.join(path, 'figs', plane)
print "Sensors names : %s" % significant_sensors_names ############################################################################### # View location of significantly active sensors import pylab as pl # load sensor layout from mne.layouts import read_layout layout = read_layout('Vectorview-grad') # Extract mask and indices of active sensors in layout idx_of_sensors = [layout.names.index(name) for name in significant_sensors_names if name in layout.names] mask_significant_sensors = np.zeros(len(layout.pos), dtype=np.bool) mask_significant_sensors[idx_of_sensors] = True mask_non_significant_sensors = mask_significant_sensors == False # plot it pl.figure(facecolor='k') pl.axis('off') pl.axis('tight') pl.scatter(layout.pos[mask_significant_sensors, 0], layout.pos[mask_significant_sensors, 1], s=50, c='r') pl.scatter(layout.pos[mask_non_significant_sensors, 0], layout.pos[mask_non_significant_sensors, 1], c='w') title = 'MNE sample data (Left auditory between 40 and 60 ms)' pl.figtext(0.03, 0.93, title, color='w', fontsize=18) pl.show() pl.show()
def visualize_single_step(mod, i, alpha=0., description_str=''): """ Show how a random walk in a two dimensional space has progressed up to step i""" X = mod.X.trace() pl.clf() sq_size = .3 # show 2d trace pl.axes([.05, .05, sq_size, sq_size]) pl.plot(X[:i, 0], X[:i, 1], 'b.-', alpha=.1) Y = alpha * X[i, :] + (1 - alpha) * X[i - 1, :] pl.plot([Y[0], Y[0]], [Y[1], 2.], 'k-', alpha=.5) pl.plot([Y[0], 2], [Y[1], Y[1]], 'k-', alpha=.5) pl.plot(Y[0], Y[1], 'go') if hasattr(mod, 'shape'): pl.fill(mod.shape[:, 0], mod.shape[:, 1], color='b', alpha=.2) if hasattr(mod, 'plot_distribution'): mod.plot_distribution() pl.axis([-1.1, 1.1, -1.1, 1.1]) pl.xticks([]) pl.yticks([]) # show 1d marginals ## X[0] is horizontal position pl.axes([.05, .05 + sq_size, sq_size, 1. - .1 - sq_size]) pl.plot(X[:(i + 1), 0], i + 1 - pl.arange(i + 1), 'k-') pl.axis([-1.1, 1.1, 0, 1000]) pl.xticks([]) pl.yticks([]) pl.text(-1, .1, '$X_0$') ## X[1] is vertical position pl.axes([.05 + sq_size, .05, 1. - .1 - sq_size, sq_size]) pl.plot(i + 1 - pl.arange(i + 1), X[:(i + 1), 1], 'k-') pl.axis([0, 1000, -1.1, 1.1]) pl.xticks([]) pl.yticks([]) pl.text(10, -1., '$X_1$') ## show X[i, j] acorr N, D = X.shape if i > 250: for j in range(D): pl.axes([ 1 - .1 - 1.5 * sq_size * (1 - j * D**-1.), 1. - .1 - 1.5 * sq_size * D**-1, 1.5 * sq_size * D**-1., 1.5 * sq_size * D**-1. ]) pl.acorr(X[(i / 2.):i:10, j], detrend=pl.mlab.detrend_mean) pl.xlabel('$X_%d$' % j) if j == 0: pl.ylabel('autocorr') pl.xticks([]) pl.yticks([]) pl.axis([-10, 10, -.1, 1]) ## show X[1] acorr ## textual information str = '' str += 't = %d\n' % i str += 'acceptance rate = %.2f\n\n' % ( 1. - pl.mean(pl.diff(X[(i / 2.):i, 0]) == 0.)) str += 'mean(X) = %s' % pretty_array(X[(i / 2.):i, :].mean(0)) if hasattr(mod, 'true_mean'): str += ' / true mean = %s\n' % pretty_array(mod.true_mean) else: str += '\n' if i > 10: iqr = pl.sort(X[(i / 2.):i, :], axis=0)[[.25 * (i / 2.), .75 * (i / 2.)], :].T for j in range(D): str += 'IQR(X[%d]) = (%.2f, %.2f)' % (j, iqr[j, 0], iqr[j, 1]) if hasattr(mod, 'true_iqr'): str += ' / true IQR = %s\n' % mod.true_iqr[j] else: str += '\n' pl.figtext(.05 + .01 + sq_size, .05 + .01 + sq_size, str, va='bottom', ha='left') pl.figtext(sq_size + .5 * (1. - sq_size), .96, description_str, va='top', ha='center', size=32) pl.figtext(.95, .05, 'healthyalgorithms.wordpress.com', ha='right')
def apogee_model_eval(h5name=None, folder_name=None, check_cannon=None, test_noisy=None): """ NAME: apogee_model_eval PURPOSE: To test the model and generate plots INPUT: h5name = Name of the h5 data set folder_name = the folder name contains the model check_cannon = check cannon result or not test_noist = whether test noisy training data or not (both adding noise and transolational shift) OUTPUT: target and normalized data HISTORY: 2017-Oct-14 Henry Leung """ # prevent Tensorflow taking up all the GPU memory config = tf.ConfigProto() config.gpu_options.allow_growth = True set_session(tf.Session(config=config)) h5name_check(h5name) if test_noisy is None: test_noisy = False h5test = h5name + '_test.h5' traindata = h5name + '_train.h5' currentdir = os.getcwd() fullfolderpath = currentdir + '/' + folder_name print(fullfolderpath) mean_and_std = np.load(fullfolderpath + '/meanstd.npy') spec_meanstd = np.load(fullfolderpath + '/spectra_meanstd.npy') target = np.load(fullfolderpath + '/targetname.npy') modelname = '/model_{}.h5'.format(folder_name[-11:]) model = load_model(os.path.normpath(fullfolderpath + modelname)) mean_labels = mean_and_std[0] std_labels = mean_and_std[1] num_labels = mean_and_std.shape[1] # ensure the file will be cleaned up with h5py.File(h5test) as F: i = 0 index_not9999 = [] for tg in target: temp = np.array(F['{}'.format(tg)]) temp_index = np.where(temp != -9999) if i == 0: index_not9999 = temp_index i += 1 else: index_not9999 = reduce(np.intersect1d, (index_not9999, temp_index)) test_spectra = np.array(F['spectra']) test_spectra = test_spectra[index_not9999] test_spectra -= spec_meanstd[0] test_spectra /= spec_meanstd[1] i = 0 test_labels = np.array((test_spectra.shape[1])) for tg in target: # load data temp = np.array(F['{}'.format(tg)]) temp = temp[index_not9999] if i == 0: test_labels = temp[:] if len(target) == 1: test_labels = test_labels.reshape((len(test_labels), 1)) i += 1 else: test_labels = np.column_stack((test_labels, temp[:])) apogee_index = np.array(F['index'])[index_not9999] print('Test set contains ' + str(len(test_spectra)) + ' stars') time1 = time.time() test_predictions = batch_predictions(model, test_spectra, 500, num_labels, std_labels, mean_labels) print("{0:.2f}".format(time.time() - time1) + ' seconds to make ' + str(len(test_spectra)) + ' predictions') resid = test_predictions - test_labels bias = np.median(resid, axis=0) scatter = mad_std(resid, axis=0) # Some plotting variables for asthetics plt.rcParams['axes.facecolor'] = 'white' sns.set_style("ticks") plt.rcParams['axes.grid'] = True plt.rcParams['grid.color'] = 'gray' plt.rcParams['grid.alpha'] = '0.4' x_lab = 'ASPCAP' y_lab = 'astroNN' for i in range(num_labels): plt.figure(figsize=(15, 11), dpi=200) plt.axhline(0, ls='--', c='k', lw=2) plt.scatter(test_labels[:, i], resid[:, i], s=3) fullname = target_name_conversion(target[i]) plt.xlabel('ASPCAP ' + fullname, fontsize=25) plt.ylabel('$\Delta$ ' + fullname + '\n(' + y_lab + ' - ' + x_lab + ')', fontsize=25) plt.tick_params(labelsize=20, width=1, length=10) if num_labels == 1: plt.xlim([np.min(test_labels[:]), np.max(test_labels[:])]) else: plt.xlim([np.min(test_labels[:, i]), np.max(test_labels[:, i])]) ranges = (np.max(test_labels[:, i]) - np.min(test_labels[:, i])) / 2 plt.ylim([-ranges, ranges]) bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=2) plt.figtext(0.6, 0.75, '$\widetilde{m}$=' + '{0:.3f}'.format(bias[i]) + ' $\widetilde{s}$=' + '{0:.3f}'.format(scatter[i] / std_labels[i]) + ' s=' + '{0:.3f}'.format(scatter[i]), size=25, bbox=bbox_props) plt.tight_layout() plt.savefig(fullfolderpath + '/{}_test.png'.format(target[i])) plt.close('all') plt.clf() if traindata is not None: with h5py.File(traindata) as F: index_not9999 = [] for counter, tg in enumerate(target): temp = np.array(F['{}'.format(tg)]) temp_index = np.where(temp != -9999) if counter == 0: index_not9999 = temp_index else: index_not9999 = reduce(np.intersect1d, (index_not9999, temp_index)) train_spectra = np.array(F['spectra']) train_spectra = train_spectra[index_not9999] sigma = 0.08**2 train_spectra_noisy = train_spectra + np.random.poisson( sigma, train_spectra.shape) train_spectra -= spec_meanstd[0] train_spectra /= spec_meanstd[1] train_spectra_noisy -= spec_meanstd[0] train_spectra_noisy /= spec_meanstd[1] random_num_color = np.array([]) for index in range(train_spectra_noisy.shape[0]): # make sure no 0 pixel shift while True: random_temp = np.random.randint(-7, 7) if random_temp != 0: break random_num_color = np.append(random_num_color, random_temp) train_spectra_noisy[index] = np.roll( train_spectra_noisy[index], random_temp) train_labels = np.array((train_spectra.shape[1])) for counter, tg in enumerate(target): # load data temp = np.array(F['{}'.format(tg)]) temp = temp[index_not9999] if counter == 0: train_labels = temp[:] if len(target) == 1: train_labels = train_labels.reshape( (len(train_labels), 1)) else: train_labels = np.column_stack((train_labels, temp[:])) if test_noisy is True: train_noisy_predictions = batch_predictions( model, train_spectra_noisy, 500, num_labels, std_labels, mean_labels) train_predictions = batch_predictions(model, train_spectra, 500, num_labels, std_labels, mean_labels) resid_noisy = train_noisy_predictions - train_labels resid_train = train_predictions - train_labels bias_train = np.median(resid_train, axis=0) scatter_train = mad_std(resid_train, axis=0) bias_noisy = np.median(resid_noisy, axis=0) scatter_noisy = mad_std(resid_noisy, axis=0) # Some plotting variables for aesthetics plt.rcParams['axes.facecolor'] = 'white' sns.set_style("ticks") plt.rcParams['axes.grid'] = True plt.rcParams['grid.color'] = 'gray' plt.rcParams['grid.alpha'] = '0.4' x_lab = 'ASPCAP' y_lab = 'astroNN' trainplot_noisy_fullpath = os.path.join(fullfolderpath, 'Noisy_TrainData_Plots/') trainplot_noisy_2_fullpath = os.path.join( fullfolderpath, 'Noisy_TrainData_Plots_02/') trainplot_fullpath = os.path.join(fullfolderpath, 'TrainData_Plots/') # check folder existence if not os.path.exists(trainplot_fullpath): os.makedirs(trainplot_fullpath) if not os.path.exists(trainplot_noisy_fullpath): os.makedirs(trainplot_noisy_fullpath) if not os.path.exists(trainplot_noisy_2_fullpath): os.makedirs(trainplot_noisy_2_fullpath) for i in range(num_labels): plt.figure(figsize=(15, 11), dpi=200) plt.axhline(0, ls='--', c='k', lw=2) plt.scatter(train_labels[:, i], resid_train[:, i], s=3) fullname = target_name_conversion(target[i]) plt.xlabel('ASPCAP ' + fullname, fontsize=25) plt.ylabel('$\Delta$ ' + fullname + '\n(' + y_lab + ' - ' + x_lab + ')', fontsize=25) plt.tick_params(labelsize=20, width=1, length=10) if num_labels == 1: plt.xlim( [np.min(train_labels[:]), np.max(train_labels[:])]) else: plt.xlim([ np.min(train_labels[:, i]), np.max(train_labels[:, i]) ]) ranges = (np.max(train_labels[:, i]) - np.min(train_labels[:, i])) / 2 plt.ylim([-ranges, ranges]) bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=2) plt.figtext( 0.6, 0.75, '$\widetilde{m}$=' + '{0:.3f}'.format(bias_train[i]) + ' $\widetilde{s}$=' + '{0:.3f}'.format(scatter_train[i] / std_labels[i]) + ' s=' + '{0:.3f}'.format(scatter_train[i]), size=25, bbox=bbox_props) plt.tight_layout() plt.savefig(trainplot_fullpath + '{}_train_data.png'.format(target[i])) plt.close('all') plt.clf() plt.figure(figsize=(15, 11), dpi=200) plt.axhline(0, ls='--', c='k', lw=2) plt.scatter(train_labels[:, i], resid_noisy[:, i], c=random_num_color, s=3, cmap='gray') fullname = target_name_conversion(target[i]) plt.xlabel('ASPCAP ' + fullname, fontsize=25) plt.ylabel('$\Delta$ ' + fullname + '\n(' + y_lab + ' - ' + x_lab + ')', fontsize=25) plt.tick_params(labelsize=20, width=1, length=10) if num_labels == 1: plt.xlim( [np.min(train_labels[:]), np.max(train_labels[:])]) else: plt.xlim([ np.min(train_labels[:, i]), np.max(train_labels[:, i]) ]) ranges = (np.max(train_labels[:, i]) - np.min(train_labels[:, i])) / 2 plt.ylim([-ranges, ranges]) bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=2) plt.figtext( 0.5, 0.85, '$\widetilde{m}$=' + '{0:.3f}'.format(bias_noisy[i]) + ' $\widetilde{s}$=' + '{0:.3f}'.format(scatter_noisy[i] / std_labels[i]) + ' s=' + '{0:.3f}'.format(scatter_noisy[i]), size=25, bbox=bbox_props) cbar = plt.colorbar() cbar.ax.tick_params(labelsize=25, width=1, length=10) plt.tight_layout() plt.savefig(trainplot_noisy_fullpath + '{}_noisytrain_data.png'.format(target[i])) plt.close('all') plt.clf() if check_cannon is True: astroNN.apogee.cannon.cannon_plot(apogee_index, std_labels, target, folder_name=folder_name, aspcap_answer=test_labels) return None
inf_high.append(msims[scen].results['new_infections'].high[wd]) epsx = 0.003 llpad = 0.01 lockdown1 = [sim.day('2020-03-23'), sim.day('2020-05-31')] lockdown2 = [sim.day('2020-11-05'), sim.day('2020-12-03')] lockdown3 = [sim.day('2021-01-04'), sim.day('2021-02-08')] for nc in range(ncols): pl.figtext(xgapl + (dx + xgapm) * nc + epsx, ygapb + dy * nrows + ygapm * (nrows - 1) + llpad, labels[nc], fontsize=36, fontweight='bold', bbox={ 'edgecolor': 'none', 'facecolor': 'white', 'alpha': 0.5, 'pad': 4 }) for pn in range(nplots): ax[pn] = pl.axes([ xgapl + (dx + xgapm) * (pn % ncols), ygapb + (ygapm + dy) * (pn // ncols), dx, dy ]) print([ xgapl + (dx + xgapm) * (pn % ncols), ygapb + (ygapm + dy) * (pn // ncols) ])
def CreateFrames(path, runName, runExt, t0, t1, hemisphere, configFile): assert ((hemisphere == 'north') | (hemisphere == 'south')) hemiSelect = {'north': 'north', 'south': 'south'}[hemisphere] # Make sure the output directory exisits if not make it dirname = os.path.join(path, 'figs', hemisphere) if not os.path.exists(dirname): os.makedirs(dirname) print(('Rendering ' + hemiSelect + 'ern hemisphere, storing frames at ' + dirname)) #Now check to make sure the files are correct data = pyLTR.Models.LFMION(path, runName, runExt) modelVars = data.getVarNames() for v in [ 'x_interp', 'y_interp', 'potnorth', 'potsouth', 'curnorth', 'cursouth', 'SigmaP_north', 'SigmaP_south', 'SigmaH_north', 'SigmaH_south', 'avE_north', 'avE_south', 'fluxnorth', 'fluxsouth' ]: assert (v in modelVars) timeRange = data.getTimeRange() if len(timeRange) == 0: raise Exception(( 'No data files found. Are you pointing to the correct run directory?' )) index0 = 0 if t0: for i, t in enumerate(timeRange): if t0 >= t: index0 = i index1 = len(timeRange) - 1 if t1: for i, t in enumerate(timeRange): if t1 >= t: index1 = i print( ('Extracting LFM ION quantities for time series over %d time steps.' % (index1 - index0))) # Output a status bar displaying how far along the computation is. progress = pyLTR.StatusBar(0, index1 - index0) progress.start() # Pre-compute r and theta x = data.read('x_interp', timeRange[index0]) y = data.read('y_interp', timeRange[index0]) theta = n.arctan2(y, x) theta[theta < 0] = theta[theta < 0] + 2 * n.pi # plotting routines now rotate local noon to point up #theta=theta+n.pi/2 # to put noon up r = n.sqrt(x**2 + y**2) # plotting routines now expect longitude and colatitude, in radians, stored in dictionaries longitude = {'data': theta, 'name': r'\phi', 'units': r'rad'} colatitude = {'data': n.arcsin(r), 'name': r'\theta', 'units': r'rad'} # Deal with the plot options if (configFile == None): potOpts = {'min': -100., 'max': 100., 'colormap': 'RdBu_r'} facOpts = {'min': -1., 'max': 1., 'colormap': 'RdBu_r'} pedOpts = {'min': 1., 'max': 20.} halOpts = {'min': 1., 'max': 20.} engOpts = {'min': 0., 'max': 20.} flxOpts = {'min': 0., 'max': 1.0e9, 'format_str': '%.1e'} optsObject = { 'pot': potOpts, 'fac': facOpts, 'ped': pedOpts, 'hall': halOpts, 'energy': engOpts, 'flux': flxOpts } configFilename = os.path.join(dirname, 'IonSum.config') print(("Writing plot config file at " + configFilename)) f = open(configFilename, 'w') f.write(pyLTR.yaml.safe_dump(optsObject, default_flow_style=False)) f.close() else: f = open(configFile, 'r') optsDict = pyLTR.yaml.safe_load(f.read()) f.close() if ('pot' in optsDict): potOpts = optsDict['pot'] else: potOpts = {'min': -100., 'max': 100., 'colormap': 'RdBu_r'} if ('fac' in optsDict): facOpts = optsDict['fac'] else: facOpts = {'min': -1., 'max': 1., 'colormap': 'RdBu_r'} if ('ped' in optsDict): pedOpts = optsDict['ped'] else: pedOpts = {'min': 1., 'max': 8.} if ('hall' in optsDict): halOpts = optsDict['hall'] else: halOpts = {'min': 1., 'max': 8.} if ('energy' in optsDict): engOpts = optsDict['energy'] else: engOpts = {'min': 0., 'max': 20.} if ('flux' in optsDict): flxOpts = optsDict['flux'] else: flxOpts = {'min': 0., 'max': 1.0e9, 'format_str': '%.1e'} for i, time in enumerate(timeRange[index0:index1]): try: #first read the data vals = data.read('pot' + hemiSelect, time) / 1000.0 psi = {'data': vals, 'name': r'$\Phi$', 'units': r'kV'} vals = data.read('cur' + hemiSelect, time) * 1.0e6 fac = { 'data': vals, 'name': r'$J_{||}$', 'units': r'$\mu\mathrm{A/m^2}$' } vals = data.read('avE_' + hemiSelect, time) eng = {'data': vals, 'name': r'Energy', 'units': r'keV'} vals = data.read('flux' + hemiSelect, time) flx = { 'data': vals, 'name': r'Flux', 'units': r'$\mathrm{1/cm^2s}$' } vals = data.read('SigmaP_' + hemiSelect, time) ped = {'data': vals, 'name': r'$\Sigma_{P}$', 'units': r'S'} vals = -1.0 * data.read('SigmaH_' + hemiSelect, time) hal = {'data': vals, 'name': r'$\Sigma_{H}$', 'units': r'S'} # Now onto the plot tt = time.timetuple() p.figure(figsize=(16, 12)) p.figtext( 0.5, 0.92, 'LFM ION ' + hemiSelect + '\n%4d-%02d-%02d %02d:%02d:%02d' % (tt.tm_year, tt.tm_mon, tt.tm_mday, tt.tm_hour, tt.tm_min, tt.tm_sec), fontsize=14, multialignment='center') ax = p.subplot(231, polar=True) pyLTR.Graphics.PolarPlot.BasicPlotDict(longitude, colatitude, psi, potOpts, userAxes=ax, useMesh=True) ax = p.subplot(234, polar=True) pyLTR.Graphics.PolarPlot.BasicPlotDict(longitude, colatitude, fac, facOpts, userAxes=ax, useMesh=True) ax = p.subplot(232, polar=True) pyLTR.Graphics.PolarPlot.BasicPlotDict(longitude, colatitude, ped, pedOpts, userAxes=ax, useMesh=True) ax = p.subplot(235, polar=True) pyLTR.Graphics.PolarPlot.BasicPlotDict(longitude, colatitude, hal, halOpts, userAxes=ax, useMesh=True) ax = p.subplot(233, polar=True) pyLTR.Graphics.PolarPlot.BasicPlotDict(longitude, colatitude, eng, engOpts, userAxes=ax, useMesh=True) ax = p.subplot(236, polar=True) pyLTR.Graphics.PolarPlot.BasicPlotDict(longitude, colatitude, flx, flxOpts, userAxes=ax, useMesh=True) savefigName = os.path.join(path, 'figs', hemisphere, 'frame_summary_%05d.png' % i) p.savefig(savefigName, dpi=100) p.close() progress.increment() except KeyboardInterrupt: # Exit when the user hits CTRL+C. progress.stop() progress.join() print('Exiting.') import sys sys.exit(0) except: # Cleanup progress bar if something bad happened. progress.stop() progress.join() raise progress.stop() progress.join() return os.path.join(path, 'figs', hemisphere)
def plot_calibration(sims, date, do_save=0): sim = sims[0] # For having a sim to refer to # Draw plots fig1_path = f'calibration_{date}_fig1.png' fig2_path = f'calibration_{date}_fig2.png' fig_args = sc.mergedicts({'figsize': (16, 14)}) axis_args = sc.mergedicts({'left': 0.10, 'bottom': 0.05, 'right': 0.95, 'top': 0.93, 'wspace': 0.25, 'hspace': 0.40}) # Handle input arguments -- merge user input with defaults low_q = 0.1 high_q = 0.9 # Figure 1: Calibration pl.figure(**fig_args) pl.subplots_adjust(**axis_args) pl.figtext(0.42, 0.95, 'Model calibration', fontsize=30) #%% Figure 1, panel 1 ax = pl.subplot(4,1,1) format_ax(ax, sim) plotter('new_tests', sims, ax, calib=True, label='Number of tests per day', ylabel='Tests') plotter('new_diagnoses', sims, ax, calib=True, label='Number of diagnoses per day', ylabel='Tests') #%% Figure 1, panel 2 ax = pl.subplot(4,1,2) format_ax(ax, sim) plotter('cum_diagnoses', sims, ax, calib=True, label='Cumulative diagnoses', ylabel='People') #%% Figure 1, panel 3 ax = pl.subplot(4,1,3) format_ax(ax, sim) plotter('cum_deaths', sims, ax, calib=True, label='Cumulative deaths', ylabel='Deaths') #%% Figure 1, panels 4A and 4B agehists = [] for s,sim in enumerate(sims): agehist = sim['analyzers'][0] if s == 0: age_data = agehist.data agehists.append(agehist.hists[-1]) x = age_data['age'].values pos = age_data['cum_diagnoses'].values death = age_data['cum_deaths'].values # From the model mposlist = [] mdeathlist = [] for hists in agehists: mposlist.append(hists['diagnosed']) mdeathlist.append(hists['dead']) mposarr = np.array(mposlist) mdeatharr = np.array(mdeathlist) mpbest = pl.median(mposarr, axis=0) mplow = pl.quantile(mposarr, q=low_q, axis=0) mphigh = pl.quantile(mposarr, q=high_q, axis=0) mdbest = pl.median(mdeatharr, axis=0) mdlow = pl.quantile(mdeatharr, q=low_q, axis=0) mdhigh = pl.quantile(mdeatharr, q=high_q, axis=0) # Plotting w = 4 off = 2 bins = x.tolist() + [100] ax = pl.subplot(4,2,7) c1 = [0.3,0.3,0.6] c2 = [0.6,0.7,0.9] xx = x+w-off pl.bar(x-off,pos, width=w, label='Data', facecolor=c1) pl.bar(xx, mpbest, width=w, label='Model', facecolor=c2) for i,ix in enumerate(xx): pl.plot([ix,ix], [mplow[i], mphigh[i]], c='k') ax.set_xticks(bins[:-1]) pl.title('Diagnosed cases by age') pl.xlabel('Age') pl.ylabel('Cases') pl.legend() ax = pl.subplot(4,2,8) c1 = [0.5,0.0,0.0] c2 = [0.9,0.4,0.3] pl.bar(x-off,death, width=w, label='Data', facecolor=c1) pl.bar(x+w-off, mdbest, width=w, label='Model', facecolor=c2) for i,ix in enumerate(xx): pl.plot([ix,ix], [mdlow[i], mdhigh[i]], c='k') ax.set_xticks(bins[:-1]) pl.title('Deaths by age') pl.xlabel('Age') pl.ylabel('Deaths') pl.legend() # Tidy up if do_save: cv.savefig(fig1_path) # Figure 2: Projections pl.figure(**fig_args) pl.subplots_adjust(**axis_args) pl.figtext(0.42, 0.95, 'Model estimates', fontsize=30) #%% Figure 2, panel 1 ax = pl.subplot(4,1,1) format_ax(ax, sim) plotter('cum_infections', sims, ax,calib=True, label='Cumulative infections', ylabel='People') plotter('cum_recoveries', sims, ax,calib=True, label='Cumulative recoveries', ylabel='People') #%% Figure 2, panel 2 ax = pl.subplot(4,1,2) format_ax(ax, sim) plotter('n_infectious', sims, ax,calib=True, label='Number of active infections', ylabel='People') plot_intervs(sim, labels=True) #%% Figure 2, panel 3 ax = pl.subplot(4,1,3) format_ax(ax, sim) plotter('new_infections', sims, ax,calib=True, label='Infections per day', ylabel='People') plotter('new_recoveries', sims, ax,calib=True, label='Recoveries per day', ylabel='People') plot_intervs(sim) #%% Figure 2, panels 4 ax = pl.subplot(4,1,4) format_ax(ax, sim) plotter('r_eff', sims, ax, calib=True, label='Effective reproductive number', ylabel=r'$R_{eff}$') ylims = [0,4] pl.ylim(ylims) xlims = pl.xlim() pl.plot(xlims, [1, 1], 'k') plot_intervs(sim) # Tidy up if do_save: cv.savefig(fig2_path) return
def buildWXLINKGraphSolarPower(password, myGraphSampleCount): print('buildWXLINKGraphSolarPower - The time is: %s' % datetime.now(timezone('US/Pacific'))) # open database con1 = mdb.connect('localhost', 'root', password, 'DataLogger') # now we have to get the data, stuff it in the graph mycursor = con1.cursor() print myGraphSampleCount query = '(SELECT timestamp, deviceid, Outdoor_Temperature, OutDoor_Humidity, Battery_Voltage, Battery_Current, Solar_Panel_Voltage, Solar_Panel_Current, Load_Current, id FROM ' + WXLINKtableName + ' ORDER BY id DESC LIMIT ' + str( myGraphSampleCount) + ') ORDER BY id ASC' print "query=", query try: mycursor.execute(query) result = mycursor.fetchall() except: e = sys.exc_info()[0] print "Error: %s" % e t = [] # time u = [] # Battery_Voltage v = [] # Battery_Current x = [] # Solar_Panel_Voltage y = [] # Solar_Panel_Current z = [] # Load_Current sp = [] # Solar Power bp = [] # Battery Power lp = [] # Load Power averagePowerIn = 0.0 averagePowerOut = 0.0 currentCount = 0 for record in result: t.append(record[0]) u.append(record[4]) v.append(record[5]) x.append(record[6]) y.append(record[7]) z.append(record[8]) sp.append(record[6] * record[7]) bp.append(record[4] * record[5]) lp.append(5.0 * record[8]) # assume 5V nominal output print("count of t=", len(t)) lastSampleTime = t[-1] fds = dates.date2num(t) # converted # matplotlib date format object hfmt = dates.DateFormatter('%H:%M:%S') #hfmt = dates.DateFormatter('%m/%d-%H') fig = pyplot.figure() fig.set_facecolor('white') ax = fig.add_subplot(111, axisbg='white') ax.vlines(fds, -200.0, 1000.0, colors='w') ax2 = fig.add_subplot(111, axisbg='white') ax.xaxis.set_major_formatter(hfmt) pyplot.xticks(rotation='45') pyplot.subplots_adjust(bottom=.3) pylab.plot(t, sp, color='green', label="Solar Power (mW) ", linestyle="-", marker=".") pylab.plot(t, bp, color='red', label="Battery Power (mW) ", linestyle="-", marker=".") pylab.plot(t, lp, color='black', label="Load Power (mW) ", linestyle="-", marker=".") pylab.xlabel("Time") pylab.ylabel("milli Watts (mW)") pylab.legend(loc='upper left', fontsize='x-small') fullpower = [] fullpower.extend(sp) fullpower.extend(bp) fullpower.extend(lp) pylab.axis([min(t), max(t), min(fullpower) - 100, max(fullpower) + 100]) pylab.figtext(.5, .01, ("System Power Performance WXLink\n%s\nLast Sample: %s") % (datetime.now(timezone('US/Pacific')), lastSampleTime), fontsize=18, ha='center') pylab.grid(True) pyplot.show() pyplot.savefig("/var/www/html/WXLINKDataLoggerGraphPower.png", facecolor=fig.get_facecolor()) mycursor.close() con1.close() fig.clf() pyplot.close() pylab.close() gc.collect() print "------WXLINKGraphPower finished now"
def plot(self, filename=None): """ Plot the Slater-Koster table with matplotlib. parameters: =========== filename: for graphics file """ try: import pylab as pl except: raise AssertionError('pylab could not be imported') fig = pl.figure() fig.subplots_adjust(hspace=0.0001, wspace=0.0001) mx = max(1, self.tables[0].max()) if self.nel == 2: mx = max(mx, self.tables[1].max()) for i in range(10): name = integrals[i] ax = pl.subplot(5, 2, i + 1) for p, (e1, e2) in enumerate(self.pairs): s1, s2 = e1.get_symbol(), e2.get_symbol() if p == 0: s = '-' lw = 1 alpha = 1.0 else: s = '--' lw = 4 alpha = 0.2 if np.all(abs(self.tables[p][:, i]) < 1E-10): ax.text(0.03, 0.02 + p * 0.15, 'No %s integrals for <%s|%s>' % (name, s1, s2), transform=ax.transAxes, size=10) if not ax.is_last_row(): pl.xticks([], []) if not ax.is_first_col(): pl.yticks([], []) else: pl.plot(self.Rgrid, self.tables[p][:, i], c='r', ls=s, lw=lw, alpha=alpha) pl.plot(self.Rgrid, self.tables[p][:, i + 10], c='b', ls=s, lw=lw, alpha=alpha) pl.axhline(0, c='k', ls='--') pl.title(name, position=(0.9, 0.8)) if ax.is_last_row(): pl.xlabel('r (Bohr)') else: pl.xticks([], []) if not ax.is_first_col(): pl.yticks([], []) pl.ylim(-mx, mx) pl.xlim(0) pl.figtext(0.3, 0.95, 'H', color='r', size=20) pl.figtext(0.34, 0.95, 'S', color='b', size=20) pl.figtext(0.38, 0.95, ' Slater-Koster tables', size=20) e1, e2 = self.ela.get_symbol(), self.elb.get_symbol() pl.figtext(0.3, 0.92, '(thin solid: <%s|%s>, wide dashed: <%s|%s>)' % (e1, e2, e2, e1), size=10) file = '%s_%s_slako.pdf' % (e1, e2) if filename != None: file = filename pl.savefig(file)
def PowerVoltageGraph(source,days,delay): print("PowerVoltageGraph source:%s days:%s delay:%i" % (source,days,delay)) print("sleeping :",delay) time.sleep(delay) print("PowerVoltageGraph running now") # blink GPIO LED when it's run GPIO.setup(18, GPIO.OUT) GPIO.output(18, True) time.sleep(0.2) GPIO.output(18, False) # now we have get the data, stuff it in the graph try: print("trying database") db = mdb.connect('localhost', 'root', config.MySQL_Password, 'ProjectCuracao2'); cursor = db.cursor() query = "SELECT TimeStamp, solarVoltage, batteryVoltage, loadVoltage FROM PowerSystem where now() - interval %i hour < TimeStamp" % (days*24) cursor.execute(query) result = cursor.fetchall() t = [] s = [] u = [] v = [] #x = [] for record in result: t.append(record[0]) s.append(record[1]) u.append(record[2]) v.append(record[3]) #x.append(record[4]) fig = pyplot.figure() print ("count of t=",len(t)) #print (t) if (len(t) == 0): return #dts = map(datetime.datetime.fromtimestamp, t) #print dts #fds = dates.date2num(t) # converted # matplotlib date format object hfmt = dates.DateFormatter('%m/%d-%H') fig = pyplot.figure() fig.set_facecolor('white') ax = fig.add_subplot(111,axisbg = 'white') #ax.vlines(fds, -200.0, 1000.0,colors='w') ax.xaxis.set_major_locator(dates.HourLocator(interval=6)) ax.xaxis.set_major_formatter(hfmt) ax.set_ylim(bottom = -200.0) pyplot.xticks(rotation='vertical') pyplot.subplots_adjust(bottom=.3) pylab.plot(t, s, color='b',label="Solar",linestyle="-",marker=".") pylab.plot(t, u, color='r',label="Battery",linestyle="-",marker=".") pylab.plot(t, v, color='g',label="Load",linestyle="-",marker=".") #pylab.plot(t, x, color='m',label="Power Eff",linestyle="-",marker=".") pylab.xlabel("Hours") pylab.ylabel("Voltage V") pylab.legend(loc='upper left') if (max(u) > max(s)): myMax = max(u)+ 100.0 else: myMax = max(s) pylab.axis([min(t), max(t), min(u), myMax]) pylab.figtext(.5, .05, ("ProjectCuracao2 Power Voltage Last %i Days" % days),fontsize=18,ha='center') pyplot.setp( ax.xaxis.get_majorticklabels(), rotation=70) pylab.grid(True) pyplot.show() try: pyplot.savefig("/home/pi/RasPiConnectServer/static/PowerVoltageGraph.png",facecolor=fig.get_facecolor()) except: pyplot.savefig("/home/pi/SDL_Pi_ProjectCuracao2/static/PowerVoltageGraph.png",facecolor=fig.get_facecolor()) except mdb.Error, e: print "Error %d: %s" % (e.args[0],e.args[1])
data_normalized_projected3 = pca3.inverse_transform(data_normalized_pca3) data_normalized_projected4 = pca4.inverse_transform(data_normalized_pca4) loss3 = ((data_normalized3 - data_normalized_projected3)**2).mean() loss4 = ((data_normalized4 - data_normalized_projected4)**2).mean() # print(str(i) + ": 3mer, " + str(loss3)) # print(str(i) + ": 5mer, " + str(loss5)) pylab.scatter(i, loss3, color = 'b') pylab.scatter(i, loss4, color = 'g') #Figure text axes = pylab.gca() axes.set_ylim([0,0.00000018]) pylab.gca().set_position((.1, .4, .8, .6)) pylab.figtext(0.02, .24, 'This graph plots the mean squared loss with increasing number of PCA components.') pylab.figtext(0.02, .2, 'Maximum number of components: {}'.format(no_components)) pylab.figtext(0.02, .16, '314 hmp files evaluated for each kmer size') #####2 component data_normalized3 = normalize(data3, axis = 1, norm = 'l1') data_normalized4 = normalize(data4, axis = 1, norm = 'l1') pca3 = PCA(n_components=2) pca3.fit(data_normalized3) PCA(copy=True, iterated_power = 'auto', n_components=2, random_state=None, svd_solver = 'auto', tol=0.0, whiten = False) data_new3 = pca3.transform(data_normalized3) pca4 = PCA(n_components=2)
def plot_uvj_vs_icd(): galaxies = pickle.load(open('galaxies.pickle', 'rb')) galaxies = filter(lambda galaxy: galaxy.ICD_IH != None, galaxies) galaxies = filter(lambda galaxy: galaxy.sersic != None and \ galaxy.ston_I > 10, galaxies) #Upper and Lower limit arrow verts arrowup_verts = [[0., 0.], [-1., -1], [0., 0.], [0., -2.], [0., 0.], [1, -1]] #arrowdown_verts = [[0.,0.], [-1., 1], [0.,0.], # [0.,2.], [0.,0.], [1, 1]] F = pyl.figure(1, figsize=(8, 3)) grid = AxesGrid(F, 111, nrows_ncols=(1, 4), axes_pad=0.1, add_all=True, aspect=False, share_all=False) ax1 = grid[0] ax2 = grid[1] ax3 = grid[2] ax4 = grid[3] for galaxy in galaxies: if galaxy.sersic < 1.: if galaxy.ICD_IH * 100 < 50: col1 = ax1.scatter(galaxy.Mass, galaxy.ICD_IH * 100., s=25, c='0.8', edgecolor='0.8') else: col1 = ax1.scatter(galaxy.Mass, 50, marker=None, s=100, verts=arrowup_verts) if 1. < galaxy.sersic < 2.: if galaxy.ICD_IH * 100 < 50: col2 = ax2.scatter(galaxy.Mass, galaxy.ICD_IH * 100., s=25, c='0.8', edgecolor='0.8') else: col2 = ax2.scatter(galaxy.Mass, 50, marker=None, s=100, verts=arrowup_verts) if 2. < galaxy.sersic < 3.: if galaxy.ICD_IH * 100 < 50: col3 = ax3.scatter(galaxy.Mass, galaxy.ICD_IH * 100., s=25, c='0.8', edgecolor='0.8') else: col3 = ax3.scatter(galaxy.Mass, 50, marker=None, s=100, verts=arrowup_verts) if 3. < galaxy.sersic: if galaxy.ICD_IH * 100 < 50: col4 = ax4.scatter(galaxy.Mass, galaxy.ICD_IH * 100., s=25, c='0.8', edgecolor='0.8') else: col4 = ax4.scatter(galaxy.Mass, 50, marker=None, s=100, verts=arrowup_verts) # Add the box and whiskers galaxies1 = filter(lambda galaxy: galaxy.ston_I > 10. and \ galaxy.sersic < 1, galaxies) galaxies1 = pyl.asarray(galaxies1) galaxies2 = filter(lambda galaxy: galaxy.ston_I > 10. and \ 1 < galaxy.sersic < 2, galaxies) galaxies2 = pyl.asarray(galaxies2) galaxies3 = filter(lambda galaxy: galaxy.ston_I > 10. and \ 2 < galaxy.sersic < 3, galaxies) galaxies3 = pyl.asarray(galaxies3) galaxies4 = filter(lambda galaxy: galaxy.ston_I > 10. and \ 3 < galaxy.sersic, galaxies) galaxies4 = pyl.asarray(galaxies4) x1 = [galaxy.Mass for galaxy in galaxies1] x2 = [galaxy.Mass for galaxy in galaxies2] x3 = [galaxy.Mass for galaxy in galaxies3] x4 = [galaxy.Mass for galaxy in galaxies4] grid1 = [] grid2 = [] grid3 = [] grid4 = [] from boxplot_percentile_width import percentile_box_plot as pbp bins_x = pyl.array([8.5, 9., 9.5, 10., 11]) for i in range(bins_x.size - 1): xmin = bins_x[i] xmax = bins_x[i + 1] cond = [cond1 and cond2 for cond1, cond2 in zip(x1 >= xmin, x1 < xmax)] grid1.append(galaxies1.compress(cond)) icd1 = [] for i in range(len(grid1)): icd1.append([galaxy.ICD_IH * 100 for galaxy in grid1[i]]) width = pyl.diff(bins_x) index = pyl.delete(bins_x, -1) + 0.25 index[-1] = index[-1] + 0.25 bp1 = pbp(ax1, icd1, indexer=list(index), width=width) bins_x = pyl.array([8.5, 9., 9.5, 10., 10.5, 11.5]) for i in range(bins_x.size - 1): xmin = bins_x[i] xmax = bins_x[i + 1] cond = [cond1 and cond2 for cond1, cond2 in zip(x2 >= xmin, x2 < xmax)] grid2.append(galaxies2.compress(cond)) icd2 = [] for i in range(len(grid2)): icd2.append([galaxy.ICD_IH * 100 for galaxy in grid2[i]]) width = pyl.diff(bins_x) index = pyl.delete(bins_x, -1) + 0.25 index[-1] = index[-1] + 0.25 bp2 = pbp(ax2, icd2, indexer=list(index), width=width) bins_x = pyl.array([8.5, 9.5, 10., 11.]) for i in range(bins_x.size - 1): xmin = bins_x[i] xmax = bins_x[i + 1] cond = [cond1 and cond2 for cond1, cond2 in zip(x3 >= xmin, x3 < xmax)] grid3.append(galaxies3.compress(cond)) icd3 = [] for i in range(len(grid3)): icd3.append([galaxy.ICD_IH * 100 for galaxy in grid3[i]]) width = pyl.diff(bins_x) index = pyl.delete(bins_x, -1) + 0.25 index[-1] = index[-1] + 0.25 index[0] = index[0] + 0.25 bp3 = pbp(ax3, icd3, indexer=list(index), width=width) bins_x = pyl.array([8.5, 9., 9.5, 10., 10.5, 11., 12.]) for i in range(bins_x.size - 1): xmin = bins_x[i] xmax = bins_x[i + 1] cond = [cond1 and cond2 for cond1, cond2 in zip(x4 >= xmin, x4 < xmax)] grid4.append(galaxies4.compress(cond)) icd4 = [] for i in range(len(grid4)): icd4.append([galaxy.ICD_IH * 100 for galaxy in grid4[i]]) width = pyl.diff(bins_x) index = pyl.delete(bins_x, -1) + 0.25 index[-1] = index[-1] + 0.25 print 'ajsdf' bp4 = pbp(ax4, icd4, indexer=list(index), width=width) ax1.set_xticks([8, 9, 10, 11]) ax2.set_xticks([8, 9, 10, 11, 12]) ax3.set_xticks([8, 9, 10, 11]) ax4.set_xticks([8, 9, 10, 11, 12]) ax1.set_ylim(0, 50) ax2.set_ylim(0, 50) ax3.set_ylim(0, 50) ax4.set_ylim(0, 50) ax1.set_xlim(8, 12.5) ax2.set_xlim(8, 12.5) ax3.set_xlim(8, 12.5) ax4.set_xlim(8, 12.5) ax1.set_ylabel(r'$\xi[i_{775},H_{160}]$ (%)') ax1.set_title('n < 1') ax2.set_title('1 < n < 2') ax3.set_title('2 < n < 3') ax4.set_title('3 < n') pyl.figtext(.5, .05, r'Log Mass $(M_{\odot})$', fontsize=18, horizontalalignment='center') ax1.axhline(0, lw=2, zorder=0) ax2.axhline(0, lw=2, zorder=0) ax3.axhline(0, lw=2, zorder=0) ax4.axhline(0, lw=2, zorder=0) import matplotlib.font_manager line1 = pyl.Line2D([], [], marker='o', mfc='0.8', mec='0.8', markersize=8, linewidth=0) line2 = pyl.Line2D([], [], marker='s', mec='#348ABD', mfc='None', markersize=10, linewidth=0, markeredgewidth=2) line3 = pyl.Line2D([], [], color='#A60628', linewidth=2) prop = matplotlib.font_manager.FontProperties(size='small') ax3.legend((line1, line2, line3), ('Data', 'Quartiles', 'Medians'), loc='upper center', prop=prop, ncol=1) pyl.tight_layout() pyl.subplots_adjust(bottom=0.21, left=0.11) pyl.show()
for i,tmp in enumerate(xs): pl.subplot(520+3+i*2) pl.plot(tmp, label="分段%s" % (i+1)) pl.gca().set_yticklabels([]) pl.gca().set_xticklabels([]) pl.legend() pl.subplot(520+3+i*2+1) tmp = np.convolve(tmp, h) result.append(tmp) pl.plot(tmp, label="分段卷积%s" % (i+1)) pl.gca().set_yticklabels([]) pl.gca().set_xticklabels([]) pl.axvspan(i*100,i*100+200,alpha=0.3,facecolor="g") pl.legend() pl.subplot(529) pl.plot(np.convolve(x,h), label="原始信号卷积") pl.gca().set_yticklabels([]) pl.gca().set_xticklabels([]) pl.legend() pl.subplot(5,2,10) pl.plot(np.sum(result, axis=0), label="分段卷积和") pl.gca().set_yticklabels([]) pl.gca().set_xticklabels([]) pl.legend() pl.subplots_adjust(hspace=0.05, wspace=0.03, top=0.95, bottom=0.01,left=0.03,right=0.97) pl.figtext(0.5, 0.965, "分段卷积演示", ha='center', color='black', weight='bold', size='large') pl.show()
def RMIrichness(ra=None, dec=None, photoz=None, cat=None, plot=True, err=True, rw=True, bcg=True): fra = cat.field('ra') fdec = cat.field('dec') imag = cat.field('imag') rmi = cat.field('model_mag')[:, 2] - cat.field('model_mag')[:, 3] rmierr = np.sqrt( cat.field('model_magerr')[:, 2]**2 + cat.field('model_magerr')[:, 3]**2) depth = 12 h = es.htm.HTM(depth) srad = np.rad2deg(1. / Da(0, photoz)) m1, m2, d12 = h.match(ra, dec, fra, fdec, srad, maxmatch=50000) r12 = np.deg2rad(d12) * Da(0, photoz) cimag = imag[m2[0]] crmi = rmi[m2[0]] if bcg is True: indices = (imag[m2] <= limi0_2(photoz)) * (imag[m2] > cimag) else: indices = (imag[m2] <= limi0_2(photoz)) ntot = len(m2[indices]) if ntot <= 10: return 'not enough galaxy brighter than 0.2 L*' alpha = np.array([0.5, 0.5]) mu = np.array([ sts.scoreatpercentile(rmi[m2[indices]], per=70), sts.scoreatpercentile(rmi[m2[indices]], per=40) ]) sigma = np.array([0.04, 0.3]) if err is True: if rw is False: aic2 = gmm.aic_ecgmm(rmi[m2[indices]], rmierr[m2[indices]], alpha, mu, sigma) aic1 = gmm.wstat(rmi[m2[indices]], rmierr[m2[indices]])[3] else: aic2, alpha, mu, sigma = rwgmm.aic2EM(rmi[m2[indices]], rmierr[m2[indices]], r12[indices], alpha, mu, sigma) aic1 = rwgmm.aic1EM(rmi[m2[indices]], rmierr[m2[indices]], r12[indices])[0] else: aic2 = gmm.aic_ecgmm(rmi[m2[indices]], aalpha=alpha, mmu=mu, ssigma=sigma) aic1 = gmm.wstat(rmi[m2[indices]])[3] srt = np.argsort(sigma) alpha = alpha[srt] mu = mu[srt] sigma = sigma[srt] z = rmiz(mu[0]) if plot == True: pl.figure(figsize=(12, 6)) pl.subplot(1, 2, 1) hh = pl.hist(rmi[m2[indices]], bins=50, normed=True, facecolor='green', alpha=0.3, range=[-1, 3]) pl.vlines(crmi, 0, hh[0].max() + 0.5, color='red', lw=2, linestyle='dashed') pl.grid() x = np.arange(-1, 3, 0.01) t = gmm.ecgmmplot(x, alpha, mu, sigma) richness = ntot * alpha[0] pl.xlabel('r - i') pl.figtext(0.61, 0.85, 'Relative Weights: ' + str(np.round(alpha, 4))) pl.figtext(0.61, 0.8, 'Mean Colors: ' + str(np.round(mu, 4))) pl.figtext(0.61, 0.75, 'Mean Color Widths: ' + str(np.round(sigma, 4))) pl.figtext(0.61, 0.68, 'Richness: ' + str(np.round(richness, 2))) pl.figtext(0.61, 0.61, r'$AIC_1$: ' + str(aic1)) pl.figtext(0.61, 0.54, r'$AIC_2$: ' + str(aic2)) pl.figtext(0.61, 0.47, 'Test Photoz: ' + str(photoz)) pl.figtext(0.61, 0.4, 'Ridgeline Photoz: ' + str(round(z, 3))) pl.figtext(0.61, 0.33, 'R200: ' + str(round(0.09 * richness**0.798, 2)) + ' Mpc') pl.figtext( 0.61, 0.25, 'M200: ' + str(round(8.8 * (richness / 19.)**1.7, 2)) + 'x10^13 Solar Mass') pl.title('Total # of galaxies: ' + str(ntot)) return richness, aic1, aic2, crmi, alpha, mu, sigma, z
def gaia_model_eval(h5name=None, folder_name=None): """ NAME: apogee_model_eval PURPOSE: To test the model and generate plots INPUT: h5name = Name of the h5 data set folder_name = the folder name contains the model OUTPUT: target and normalized data HISTORY: 2017-Oct-14 Henry Leung """ # prevent Tensorflow taking up all the GPU memory config = tf.ConfigProto() config.gpu_options.allow_growth = True set_session(tf.Session(config=config)) h5name_check(h5name) h5test = h5name + '_test.h5' traindata = h5name + '_train.h5' currentdir = os.getcwd() fullfolderpath = currentdir + '/' + folder_name print(fullfolderpath) mean_and_std = np.load(fullfolderpath + '/meanstd.npy') spec_meanstd = np.load(fullfolderpath + '/spectra_meanstd.npy') modelname = '/model_{}.h5'.format(folder_name[-11:]) model = load_model(os.path.normpath(fullfolderpath + modelname)) mean_labels = mean_and_std[0] std_labels = mean_and_std[1] # ensure the file will be cleaned up with h5py.File(h5test) as F: test_spectra = np.array(F['spectra']) test_spectra -= spec_meanstd[0] test_spectra /= spec_meanstd[1] absmag = np.array(F['absmag']) print('Test set contains ' + str(len(test_spectra)) + ' stars') time1 = time.time() test_predictions = batch_predictions(model, test_spectra, 500, 1, std_labels, mean_labels) print("{0:.2f}".format(time.time() - time1) + ' seconds to make ' + str(len(test_spectra)) + ' predictions') resid = test_predictions.flatten() - absmag bias = np.median(resid) scatter = mad_std(resid) # Some plotting variables for asthetics plt.rcParams['axes.facecolor'] = 'white' sns.set_style("ticks") plt.rcParams['axes.grid'] = True plt.rcParams['grid.color'] = 'gray' plt.rcParams['grid.alpha'] = '0.4' x_lab = 'Gaia' y_lab = 'astroNN' plt.figure(figsize=(15, 11), dpi=200) plt.axhline(0, ls='--', c='k', lw=2) plt.scatter(absmag, resid, s=3) plt.xlabel('Gaia Abs Mag', fontsize=25) plt.ylabel('$\Delta$ Abs Mag' + '\n(' + y_lab + ' - ' + x_lab + ')', fontsize=25) plt.tick_params(labelsize=20, width=1, length=10) plt.xlim([np.min(absmag), np.max(absmag)]) ranges = (np.max(absmag) - np.min(absmag)) / 2 plt.ylim([-ranges, ranges]) bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=2) plt.figtext(0.6, 0.75, '$\widetilde{m}$=' + '{0:.3f}'.format(float(bias)) + ' $\widetilde{s}$=' + '{0:.3f}'.format(float(scatter / std_labels)) + ' s=' + '{0:.3f}'.format(float(scatter)), size=25, bbox=bbox_props) plt.tight_layout() plt.savefig(fullfolderpath + '/absmag_test.png') plt.close('all') plt.clf() if traindata is not None: with h5py.File(traindata) as F: train_spectra = np.array(F['spectra']) train_spectra -= spec_meanstd[0] train_spectra /= spec_meanstd[1] absmag = np.array(F['absmag']) time1 = time.time() test_predictions = batch_predictions(model, train_spectra, 500, 1, std_labels, mean_labels) print("{0:.2f}".format(time.time() - time1) + ' seconds to make ' + str(len(train_spectra)) + ' predictions') resid = test_predictions.flatten() - absmag bias = np.median(resid) scatter = mad_std(resid) # Some plotting variables for asthetics plt.rcParams['axes.facecolor'] = 'white' sns.set_style("ticks") plt.rcParams['axes.grid'] = True plt.rcParams['grid.color'] = 'gray' plt.rcParams['grid.alpha'] = '0.4' x_lab = 'Gaia' y_lab = 'astroNN' plt.figure(figsize=(15, 11), dpi=200) plt.axhline(0, ls='--', c='k', lw=2) plt.scatter(absmag, resid, s=3) plt.xlabel('Gaia Abs Mag', fontsize=25) plt.ylabel('$\Delta$ Abs Mag' + '\n(' + y_lab + ' - ' + x_lab + ')', fontsize=25) plt.tick_params(labelsize=20, width=1, length=10) plt.xlim([np.min(absmag), np.max(absmag)]) ranges = (np.max(absmag) - np.min(absmag)) / 2 plt.ylim([-ranges, ranges]) bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=2) plt.figtext(0.6, 0.75, '$\widetilde{m}$=' + '{0:.3f}'.format(float(bias)) + ' $\widetilde{s}$=' + '{0:.3f}'.format(float(scatter / std_labels)) + ' s=' + '{0:.3f}'.format(float(scatter)), size=25, bbox=bbox_props) plt.tight_layout() plt.savefig(fullfolderpath + '/absmag_train.png') plt.close('all') plt.clf() return None
def multilabels(self, xtext, ytext, title=None): plt.subplots_adjust(bottom=0.2) plt.figtext(0.5, 0.07, xtext, ha='center') plt.figtext(0.05, 0.5, ytext, rotation='vertical', va='center') if title is not None: plt.suptitle(title)
def fitDecay(colourFilter, metadata, channame='', i=0): #get frames in which events occured and convert into seconds t = colourFilter['t'].astype('f') * metadata.getEntry('Camera.CycleTime') n, bins = np.histogram(t, 100) b1 = bins[:-1] Nm = n.max() res = FitModel(e2mod, [Nm * 2, 15, -3, Nm * 3, n[1] / 1], n[1:], b1[1:], Nm) #mse = (res[2]['fvec']**2).mean() #ch2 = chi2(res, n[1:]) #print ch2 ch2, mse = chi2_mse(e2mod, n[1:], res, b1[1:], Nm) PL.AddRecord('/Photophysics/Decay/e2mod', munge_res(e2mod, res, mse=mse, ch2=ch2)) res2 = FitModelPoisson(emod, [Nm * 2, 15, -3, Nm * 3, n[1] / 2], n[1:], b1[1:], Nm) #[0] ch2, mse = chi2_mse(hmod, n[1:], res2, b1[1:], Nm) PL.AddRecord('/Photophysics/Decay/emod', munge_res(emod, res2, mse=mse, ch2=ch2)) res3 = FitModelPoisson(hmod, [Nm * 2, 15, -3, Nm * 3, n[1] / 2], n[1:], b1[1:], Nm) #[0] ch2, mse = chi2_mse(hmod, n[1:], res3, b1[1:], Nm) PL.AddRecord('/Photophysics/Decay/hmod', munge_res(hmod, res3, mse=mse, ch2=ch2)) r4 = FitModelPoisson(e2mod, [Nm * 2, 15, -3, Nm * 3, n[1] / 2], n[1:], b1[1:], Nm) ch2, mse = chi2_mse(e2mod, n[1:], r4, b1[1:], Nm) PL.AddRecord('/Photophysics/Decay/e2mod_p', munge_res(e2mod, r4, mse=mse, ch2=ch2)) if USE_GUI: pylab.bar(b1 / 60, n, width=(b1[1] - b1[0]) / 60, alpha=0.4, fc=colours[i]) pylab.plot(b1 / 60, e2mod(res[0], b1, Nm), colours[i], lw=3) pylab.plot(b1 / 60, emod(res2[0], b1, Nm), colours[i], lw=2, ls='--') pylab.plot(b1 / 60, hmod(res3[0], b1, Nm), colours[i], lw=2, ls=':') pylab.plot(b1 / 60, e2mod(r4[0], b1, Nm), colours[i], lw=1) pylab.ylim(0, 1.2 * n.max()) pylab.ylabel('Events') pylab.xlabel('Acquisition Time [mins]') pylab.title('Event Rate') b = 0.5 * (1 + erf(res[0][2])) * Nm pylab.figtext(.4, .8 - .05 * i, channame + '\t$\\tau = %3.2fs,\\;b = %3.2f$' % (res[0][1], b / res[0][0]), size=18, color=colours[i]) return 0
'_bias-', bias ) + '{}{}'.format('_numEpochs-', numEpochs) + '{}{}'.format( '_batch-', batchSize ) + '_encActFunc-' + encoded_activation + '_decActFunc-' + decoded_activation + '_lossFunc-' + loss + '_backend-' + backend # how does the loss change as the fraction of data in the test vs training change? pylab.figure() for hs in allHistories: pylab.plot(hs.history['val_loss']) pylab.title('model loss by epochs and number of training samples') pylab.ylabel('test loss') pylab.xlabel('epoch') pylab.legend(['300', '600', '900', '1200', '1500'], loc='upper left') pylab.gca().set_position((.1, .6, .8, .6)) pylab.figtext( 0.02, .4, 'This graph shows how loss changes with number of epochs for different splits between training and test data.' ) pylab.figtext(0.02, .32, 'Backend: ' + backend) pylab.figtext(0.02, .28, 'Loss function: ' + loss) pylab.figtext(0.02, .24, 'Number of encoding dimensions: {}'.format(encoding_dim)) pylab.figtext(0.02, .2, 'Use bias: {}'.format(bias)) pylab.figtext(0.02, .16, 'Number of epochs of training: {}'.format(numEpochs)) pylab.figtext(0.02, .12, 'Batch size used during training: {}'.format(batchSize)) pylab.figtext(0.02, .08, 'Activation function used for encoding: ' + encoded_activation) pylab.figtext(0.02, .04, 'Activation function used for decoding: ' + decoded_activation) pylab.savefig( os.path.expanduser(graph_dir + '/epoch_vs_loss_varied_training_samples' +
def fitFluorBrightnessT(colourFilter, metadata, channame='', i=0, rng=None): #nPh = (colourFilter['A']*2*math.pi*(colourFilter['sig']/(1e3*metadata.getEntry('voxelsize.x')))**2) #nPh = nPh*metadata.getEntry('Camera.ElectronsPerCount')/metadata.getEntry('Camera.TrueEMGain') #from mpl_toolkits.mplot3d import Axes3D nPh = getPhotonNums(colourFilter, metadata) t = (colourFilter['t'].astype('f') - metadata['Protocol.DataStartsAt'] ) * metadata.getEntry('Camera.CycleTime') NEvents = len(t) if rng is None: rng = nPh.mean() * 3 Nco = nPh.min() n, xbins, ybins = np.histogram2d( nPh, t, [np.linspace(0, rng, 50), np.linspace(0, t.max(), 20)]) bins = xbins[:-1] xb = xbins[:-1][:, None] * np.ones([1, ybins.size - 1]) yb = ybins[:-1][None, :] * np.ones([xbins.size - 1, 1]) res0 = FitModel( fITmod2, [n.max() * 3, 1, np.median(nPh), 20, 1e2, 1e2, 100], n, xb, yb, Nco) print((res0[0])) PL.AddRecord('/Photophysics/FluorBrightness/fITmod2', munge_res(fITmod2, res0)) A, Ndet, lamb, tauI, a, Acrit, bg = res0[0] #Ndet = Ndet**2 #NDetM = NDetM**2 #Acrit = Acrit**2 #a = (1+erf(a))/2 Ndet = np.sqrt(Ndet**2 + 1) - 1 #+ve bg = np.sqrt(bg**2 + 1) - 1 Acrit = np.sqrt(Acrit**2 + 1) - 1 a = (1 + erf(a)) / 2 # [0,1] #bg = sqrt(bg**2 + 1) - 1 #k = sqrt(k**2 + 1) - 1 NDetM = bg rr = fITmod2(res0[0], xb, yb, Nco) if USE_GUI: pylab.figure() pylab.subplot(131) pylab.imshow(n, interpolation='nearest') pylab.colorbar() pylab.subplot(132) pylab.imshow(rr, interpolation='nearest') pylab.colorbar() pylab.subplot(133) pylab.imshow(n - rr, interpolation='nearest') pylab.colorbar() pylab.title(channame) pylab.figure() t_ = np.linspace(t[0], t[-1], 100) #sc = (lamb/(ybins[1] - ybins[0])) #sc = len(ybins) sc = 1. / (1 - np.exp(-(ybins[1] - ybins[0]) / lamb)) print(('sc = ', sc)) y1 = sc * A / ((t_ / tauI)**a + 1) pylab.plot(t_, y1) pylab.plot(t_, sc * (Ndet / ((t_ / tauI)**a + 1) + NDetM)) pylab.bar(ybins[:-1], n.sum(0), width=ybins[1] - ybins[0], alpha=0.5) pylab.plot(ybins[:-1], rr.sum(0), lw=2) pylab.title(channame) pylab.xlabel('Time [s]') pylab.figtext( .2, .7, '$A = %3.0f\\;N_{det} = %3.2f\\;\\lambda = %3.0f\\;\\tau = %3.0f$\n$\\alpha = %3.3f\\;A_{crit} = %3.2f\\;N_{det_0} = %3.2f$' % (A, Ndet, lamb, tauI, a, Acrit, NDetM), size=18) return [channame, lamb, NEvents]
def dmmProcessData(data, mRange): # Display graph if we received data with plot if len(data) == 361: # Scope screen has 320 i.e. 40pix/div points on x axis x = numpy.linspace(0, 8 * timebase[data[13]][0], 320) # Scope screen has 128 (-64:64) i.e. 16pix/div points on y axis [x/myInt for x in myList] const = float(1) / 64 * mRange[0] * 4 point = data[12] if data[12] < 127 else -(255 - data[12]) offset = float(point) * const offsety = [0 for point in data[40:360]] iy = [ point if point < 127 else -(255 - point) for point in data[40:360] ] y = [(float(point) * const) for point in iy] # Trigger time -76:76 (-160:160) trigx = numpy.linspace(-64 * const - offset, 64 * const - offset, 128) tpointx = data[14] if data[14] < 127 else -(255 - data[14]) tpointx = (4 * timebase[data[13]][0]) + (tpointx * 8 * timebase[data[13]][0] / 160) trigxx = [tpointx for point in trigx] # Trigger level -60:60 (-64:64) tpointy = data[16] if data[16] < 127 else -(255 - data[16]) tpointy = float(tpointy) * const - offset trigy = [tpointy for point in data[40:360]] if options.cont_cap: logging.info( 'MeasuredData %s TotalTime: %d %s TotalRange: %d .. %d %s TrigTime: %.2f %s TrigValue: %.2f %s BaseOffset: %.2f %s Min: %.2f %s Max: %.2f %s', y, 8 * timebase[data[13]][0], timebase[data[13]][1], -mRange[0] * 4 - offset, mRange[0] * 4 - offset, mRange[1], tpointx, timebase[data[13]][1], tpointy, mRange[1], offset, mRange[1], min(y[1:]), mRange[1], max(y[1:]), mRange[1]) else: logging.info( 'TotalTime: %d %s TotalRange: %d .. %d %s TrigTime: %.2f %s TrigValue: %.2f %s BaseOffset: %.2f %s Min: %.2f %s Max: %.2f %s', 8 * timebase[data[13]][0], timebase[data[13]][1], -mRange[0] * 4 - offset, mRange[0] * 4 - offset, mRange[1], tpointx, timebase[data[13]][1], tpointy, mRange[1], offset, mRange[1], min(y[1:]), mRange[1], max(y[1:]), mRange[1]) # http://matplotlib.org/users/pyplot_tutorial.html pylab.figure(1, figsize=(6, 6)) # Plot the complete image pylab.plot(x, y, x, trigy, 'r--', trigxx, trigx, 'r--', x, offsety, 'g--') # Scope screen shows 8 timebase segments pylab.axis([ 0, 8 * timebase[data[13]][0], -mRange[0] * 4 - offset, mRange[0] * 4 - offset ]) pylab.xlabel(timebase[data[13]][1]) pylab.ylabel(mRange[1]) pylab.grid(True) fig = pylab.gcf() fig.canvas.set_window_title('Scopemeter UT81B') if data[17] == 2: TrigMode = 'SHOT' elif data[17] == 1: TrigMode = 'NORM' else: TrigMode = 'AUTO' TrigEdge = 'Rising' if data[15] == 0 else 'Falling' TrigText = 'Slope: ' + TrigEdge + ' Mode: ' + TrigMode pylab.figtext( 0.13, 0.91, mRange[2] + ' ' + str(mRange[0]) + mRange[1] + ' ' + str(timebase[data[13]][0]) + timebase[data[13]][1] + ' ' + TrigText) pylab.show() elif len(data) == 41: time.sleep(timeout) else: logging.info('Malformed data')
def main(): """ NAME core_depthplot.py DESCRIPTION plots various measurements versus core_depth or age. plots data flagged as 'FS-SS-C' as discrete samples. SYNTAX core_depthplot.py [command line optins] OPTIONS -h prints help message and quits -f FILE: specify input magic_measurments format file from magi -fsum FILE: specify input LIMS database (IODP) core summary csv file -fwig FILE: specify input depth,wiggle to plot, in magic format with sample_core_depth key for depth -fsa FILE: specify input er_samples format file from magic for depth -fa FILE: specify input er_ages format file from magic for age NB: must have either -fsa OR -fa (not both) -fsp FILE sym size: specify input zeq_specimen format file from magic, sym and size NB: PCAs will have specified color, while fisher means will be white with specified color as the edgecolor -fres FILE specify input pmag_results file from magic, sym and size -LP [AF,T,ARM,IRM, X] step [in mT,C,mT,mT, mass/vol] to plot -S do not plot blanket treatment data (if this is set, you don't need the -LP) -sym SYM SIZE, symbol, size for continuous points (e.g., ro 5, bs 10, g^ 10 for red dot, blue square, green triangle), default is blue dot at 5 pt -D do not plot declination -M do not plot magnetization -log plot magnetization on a log scale -L do not connect dots with a line -I do not plot inclination -d min max [in m] depth range to plot -n normalize by weight in er_specimen table -Iex: plot the expected inc at lat - only available for results with lat info in file -ts TS amin amax: plot the GPTS for the time interval between amin and amax (numbers in Ma) TS: [ck95, gts04, gts12] -ds [mbsf,mcd] specify depth scale, mbsf default -fmt [svg, eps, pdf, png] specify output format for plot (default: svg) -sav save plot silently DEFAULTS: Measurements file: magic_measurements.txt Samples file: er_samples.txt NRM step Summary file: none """ meas_file = 'magic_measurements.txt' intlist = [ 'measurement_magnitude', 'measurement_magn_moment', 'measurement_magn_volume', 'measurement_magn_mass' ] samp_file = 'er_samples.txt' depth_scale = 'sample_core_depth' wt_file = '' verbose = pmagplotlib.verbose width = 10 sym, size = 'bo', 5 Ssym, Ssize = 'cs', 5 method, fmt = "LT-NO", '.svg' step = 0 pcol = 3 pel = 3 pltD, pltI, pltM, pltL, pltS = 1, 1, 1, 1, 1 logit = 0 maxInt = -1000 minInt = 1e10 maxSuc = -1000 minSuc = 10000 plotexp, pTS = 0, 0 dir_path = "." sum_file = "" suc_file = "" age_file = "" spc_file = "" res_file = "" ngr_file = "" wig_file = "" title, location = "", "" if '-WD' in sys.argv: ind = sys.argv.index('-WD') dir_path = sys.argv[ind + 1] norm = 0 if '-h' in sys.argv: print main.__doc__ sys.exit() if '-L' in sys.argv: pltL = 0 if '-S' in sys.argv: pltS = 0 # don't plot the bulk measurements at all if '-D' in sys.argv: pltD = 0 pcol -= 1 pel -= 1 width -= 2 if '-I' in sys.argv: pltI = 0 pcol -= 1 pel -= 1 width -= 2 if '-M' in sys.argv: pltM = 0 pcol -= 1 pel -= 1 width -= 2 if '-log' in sys.argv: logit = 1 if '-ds' in sys.argv and 'mcd' in sys.argv: depth_scale = 'sample_composite_depth' if '-sym' in sys.argv: ind = sys.argv.index('-sym') sym = sys.argv[ind + 1] size = float(sys.argv[ind + 2]) if '-f' in sys.argv: ind = sys.argv.index('-f') meas_file = sys.argv[ind + 1] if '-fsa' in sys.argv: ind = sys.argv.index('-fsa') samp_file = sys.argv[ind + 1] if '-fa' in sys.argv: print main.__doc__ print 'only -fsa OR -fa - not both' sys.exit() elif '-fa' in sys.argv: ind = sys.argv.index('-fa') age_file = sys.argv[ind + 1] if '-fsp' in sys.argv: ind = sys.argv.index('-fsp') spc_file = dir_path + '/' + sys.argv[ind + 1] spc_sym = sys.argv[ind + 2] spc_size = float(sys.argv[ind + 3]) if '-fres' in sys.argv: ind = sys.argv.index('-fres') res_file = dir_path + '/' + sys.argv[ind + 1] res_sym = sys.argv[ind + 2] res_size = float(sys.argv[ind + 3]) if '-fwig' in sys.argv: ind = sys.argv.index('-fwig') wig_file = dir_path + '/' + sys.argv[ind + 1] pcol += 1 width += 2 if '-fsum' in sys.argv: ind = sys.argv.index('-fsum') sum_file = dir_path + '/' + sys.argv[ind + 1] if '-fmt' in sys.argv: ind = sys.argv.index('-fmt') fmt = '.' + sys.argv[ind + 1] if '-sav' in sys.argv: plots = 1 verbose = 0 if '-LP' in sys.argv: ind = sys.argv.index('-LP') meth = sys.argv[ind + 1] if meth == "AF": step = round(float(sys.argv[ind + 2]) * 1e-3, 6) method = 'LT-AF-Z' elif meth == 'T': step = round(float(sys.argv[ind + 2]) + 273, 6) method = 'LT-T-Z' elif meth == 'ARM': method = 'LT-AF-I' step = round(float(sys.argv[ind + 2]) * 1e-3, 6) elif meth == 'IRM': method = 'LT-IRM' step = round(float(sys.argv[ind + 2]) * 1e-3, 6) elif meth == 'X': method = 'LP-X' pcol += 1 if sys.argv[ind + 2] == 'mass': suc_key = 'measurement_chi_mass' elif sys.argv[ind + 2] == 'vol': suc_key = 'measurement_chi_volume' else: print 'error in susceptibility units' sys.exit() else: print 'method not supported' sys.exit() if '-n' in sys.argv: ind = sys.argv.index('-n') wt_file = dir_path + '/' + sys.argv[ind + 1] norm = 1 dmin, dmax = -1, -1 if '-d' in sys.argv: ind = sys.argv.index('-d') dmin = float(sys.argv[ind + 1]) dmax = float(sys.argv[ind + 2]) if '-ts' in sys.argv: ind = sys.argv.index('-ts') ts = sys.argv[ind + 1] amin = float(sys.argv[ind + 2]) amax = float(sys.argv[ind + 3]) pTS = 1 pcol += 1 width += 2 # # # get data read in meas_file = dir_path + '/' + meas_file if age_file == "": samp_file = dir_path + '/' + samp_file Samps, file_type = pmag.magic_read(samp_file) else: depth_scale = 'age' age_file = dir_path + '/' + age_file Samps, file_type = pmag.magic_read(age_file) age_unit = "" if spc_file != "": Specs, file_type = pmag.magic_read(spc_file) if res_file != "": Results, file_type = pmag.magic_read(res_file) if norm == 1: ErSpecs, file_type = pmag.magic_read(wt_file) print len(ErSpecs), ' specimens read in from ', wt_file Cores = [] core_depth_key = "Top depth cored CSF (m)" if sum_file != "": input = open(sum_file, 'rU').readlines() if "Core Summary" in input[0]: headline = 1 else: headline = 0 keys = input[headline].replace('\n', '').split(',') if "Core Top (m)" in keys: core_depth_key = "Core Top (m)" if "Core Label" in keys: core_label_key = "Core Label" if "Core label" in keys: core_label_key = "Core label" for line in input[2:]: if 'TOTALS' not in line: CoreRec = {} for k in range(len(keys)): CoreRec[keys[k]] = line.split(',')[k] Cores.append(CoreRec) if len(Cores) == 0: print 'no Core depth information available: import core summary file' sum_file = "" Data = [] if depth_scale == 'sample_core_depth': ylab = "Depth (mbsf)" elif depth_scale == 'age': ylab = "Age" else: ylab = "Depth (mcd)" # collect the data for plotting declination Depths, Decs, Incs, Ints = [], [], [], [] SDepths, SDecs, SIncs, SInts = [], [], [], [] SSucs = [] samples = [] methods, steps, m2 = [], [], [] if pltS: # plot the bulk measurement data Meas, file_type = pmag.magic_read(meas_file) meas_key = 'measurement_magn_moment' print len(Meas), ' measurements read in from ', meas_file for m in intlist: # find the intensity key with data meas_data = pmag.get_dictitem( Meas, m, '', 'F') # get all non-blank data for this specimen if len(meas_data) > 0: meas_key = m break m1 = pmag.get_dictitem(Meas, 'magic_method_codes', method, 'has') # fish out the desired method code if method == 'LT-T-Z': m2 = pmag.get_dictitem(m1, 'treatment_temp', str(step), 'eval') # fish out the desired step elif 'LT-AF' in method: m2 = pmag.get_dictitem(m1, 'treatment_ac_field', str(step), 'eval') elif 'LT-IRM' in method: m2 = pmag.get_dictitem(m1, 'treatment_dc_field', str(step), 'eval') elif 'LT-X' in method: m2 = pmag.get_dictitem(m1, suc_key, '', 'F') if len(m2) > 0: for rec in m2: # fish out depths and weights D = pmag.get_dictitem(Samps, 'er_sample_name', rec['er_sample_name'], 'T') if not D: # if using an age_file, you may need to sort by site D = pmag.get_dictitem(Samps, 'er_site_name', rec['er_site_name'], 'T') depth = pmag.get_dictitem(D, depth_scale, '', 'F') if len(depth) > 0: if ylab == 'Age': ylab = ylab + ' (' + depth[0][ 'age_unit'] + ')' # get units of ages - assume they are all the same! rec['core_depth'] = float(depth[0][depth_scale]) rec['magic_method_codes'] = rec[ 'magic_method_codes'] + ':' + depth[0][ 'magic_method_codes'] if norm == 1: specrecs = pmag.get_dictitem(ErSpecs, 'er_specimen_name', rec['er_specimen_name'], 'T') specwts = pmag.get_dictitem(specrecs, 'specimen_weight', "", 'F') if len(specwts) > 0: rec['specimen_weight'] = specwts[0][ 'specimen_weight'] Data.append( rec ) # fish out data with core_depth and (if needed) weights else: Data.append( rec ) # fish out data with core_depth and (if needed) weights if title == "": pieces = rec['er_sample_name'].split('-') location = rec['er_location_name'] title = location SData = pmag.sort_diclist(Data, 'core_depth') for rec in SData: # fish out bulk measurement data from desired depths if dmax == -1 or float(rec['core_depth']) < dmax and float( rec['core_depth']) > dmin: Depths.append((rec['core_depth'])) if method == "LP-X": SSucs.append(float(rec[suc_key])) else: if pltD == 1: Decs.append(float(rec['measurement_dec'])) if pltI == 1: Incs.append(float(rec['measurement_inc'])) if norm == 0 and pltM == 1: Ints.append(float(rec[meas_key])) if norm == 1 and pltM == 1: Ints.append( float(rec[meas_key]) / float(rec['specimen_weight'])) if len(SSucs) > 0: maxSuc = max(SSucs) minSuc = min(SSucs) if len(Ints) > 1: maxInt = max(Ints) minInt = min(Ints) if len(Depths) == 0: print 'no bulk measurement data matched your request' SpecDepths, SpecDecs, SpecIncs = [], [], [] FDepths, FDecs, FIncs = [], [], [] if spc_file != "": # add depths to spec data print 'spec file found' BFLs = pmag.get_dictitem( Specs, 'magic_method_codes', 'DE-BFL', 'has') # get all the discrete data with best fit lines for spec in BFLs: if location == "": location = spec['er_location_name'] samp = pmag.get_dictitem(Samps, 'er_sample_name', spec['er_sample_name'], 'T') if len(samp) > 0 and depth_scale in samp[0].keys( ) and samp[0][depth_scale] != "": if ylab == 'Age': ylab = ylab + ' (' + samp[0][ 'age_unit'] + ')' # get units of ages - assume they are all the same! if dmax == -1 or float(samp[0][depth_scale]) < dmax and float( samp[0][depth_scale]) > dmin: # filter for depth SpecDepths.append(float( samp[0][depth_scale])) # fish out data with core_depth SpecDecs.append(float( spec['specimen_dec'])) # fish out data with core_depth SpecIncs.append(float( spec['specimen_inc'])) # fish out data with core_depth else: print 'no core_depth found for: ', spec['er_specimen_name'] FMs = pmag.get_dictitem( Specs, 'magic_method_codes', 'DE-FM', 'has') # get all the discrete data with best fit lines for spec in FMs: if location == "": location = spec['er_location_name'] samp = pmag.get_dictitem(Samps, 'er_sample_name', spec['er_sample_name'], 'T') if len(samp) > 0 and depth_scale in samp[0].keys( ) and samp[0][depth_scale] != "": if ylab == 'Age': ylab = ylab + ' (' + samp[0][ 'age_unit'] + ')' # get units of ages - assume they are all the same! if dmax == -1 or float(samp[0][depth_scale]) < dmax and float( samp[0][depth_scale]) > dmin: # filter for depth FDepths.append(float( samp[0][depth_scale])) # fish out data with core_depth FDecs.append(float( spec['specimen_dec'])) # fish out data with core_depth FIncs.append(float( spec['specimen_inc'])) # fish out data with core_depth else: print 'no core_depth found for: ', spec['er_specimen_name'] ResDepths, ResDecs, ResIncs = [], [], [] if 'age' in depth_scale: # set y-key res_scale = 'average_age' else: res_scale = 'average_height' if res_file != "": #creates lists of Result Data for res in Results: meths = res['magic_method_codes'].split(":") if 'DE-FM' in meths: if dmax == -1 or float(res[res_scale]) < dmax and float( res[res_scale]) > dmin: # filter for depth ResDepths.append(float( res[res_scale])) # fish out data with core_depth ResDecs.append(float( res['average_dec'])) # fish out data with core_depth ResIncs.append(float( res['average_inc'])) # fish out data with core_depth Susc, Sus_depths = [], [] if dmin == -1: if len(Depths) > 0: dmin, dmax = Depths[0], Depths[-1] if len(FDepths) > 0: dmin, dmax = Depths[0], Depths[-1] if pltS == 1 and len(SDepths) > 0: if SDepths[0] < dmin: dmin = SDepths[0] if SDepths[-1] > dmax: dmax = SDepths[-1] if len(SpecDepths) > 0: if min(SpecDepths) < dmin: dmin = min(SpecDepths) if max(SpecDepths) > dmax: dmax = max(SpecDepths) if len(ResDepths) > 0: if min(ResDepths) < dmin: dmin = min(ResDepths) if max(ResDepths) > dmax: dmax = max(ResDepths) if suc_file != "": sucdat = open(suc_file, 'rU').readlines() keys = sucdat[0].replace('\n', '').split(',') # splits on underscores for line in sucdat[1:]: SucRec = {} for k in range(len(keys)): SucRec[keys[k]] = line.split(',')[k] if float(SucRec['Top Depth (m)']) < dmax and float( SucRec['Top Depth (m)'] ) > dmin and SucRec['Magnetic Susceptibility (80 mm)'] != "": Susc.append(float(SucRec['Magnetic Susceptibility (80 mm)'])) if Susc[-1] > maxSuc: maxSuc = Susc[-1] if Susc[-1] < minSuc: minSuc = Susc[-1] Sus_depths.append(float(SucRec['Top Depth (m)'])) WIG, WIG_depths = [], [] if wig_file != "": wigdat, file_type = pmag.magic_read(wig_file) swigdat = pmag.sort_diclist(wigdat, depth_scale) keys = wigdat[0].keys() for key in keys: if key != depth_scale: plt_key = key break for wig in swigdat: if float(wig[depth_scale]) < dmax and float( wig[depth_scale]) > dmin: WIG.append(float(wig[plt_key])) WIG_depths.append(float(wig[depth_scale])) tint = 4.5 plt = 1 if len(Decs) > 0 and len(Depths) > 0 or ( len(SpecDecs) > 0 and len(SpecDepths) > 0 ) or (len(ResDecs) > 0 and len(ResDepths) > 0) or (len(SDecs) > 0 and len(SDepths) > 0) or ( len(SInts) > 0 and len(SDepths) > 0) or (len(SIncs) > 0 and len(SDepths) > 0): pylab.figure(1, figsize=(width, 8)) version_num = pmag.get_version() pylab.figtext(.02, .01, version_num) if pltD == 1: ax = pylab.subplot(1, pcol, plt) if pltL == 1: pylab.plot(Decs, Depths, 'k') if len(Decs) > 0: pylab.plot(Decs, Depths, sym, markersize=size) if len(Decs) == 0 and pltL == 1 and len(SDecs) > 0: pylab.plot(SDecs, SDepths, 'k') if len(SDecs) > 0: pylab.plot(SDecs, SDepths, Ssym, markersize=Ssize) if spc_file != "": pylab.plot(SpecDecs, SpecDepths, spc_sym, markersize=spc_size) if spc_file != "" and len(FDepths) > 0: pylab.scatter(FDecs, FDepths, marker=spc_sym[-1], edgecolor=spc_sym[0], facecolor='white', s=spc_size**2) if res_file != "": pylab.plot(ResDecs, ResDepths, res_sym, markersize=res_size) if sum_file != "": for core in Cores: depth = float(core[core_depth_key]) if depth > dmin and depth < dmax: pylab.plot([0, 360.], [depth, depth], 'b--') if pel == plt: pylab.text(360, depth + tint, core[core_label_key]) if pel == plt: pylab.axis([0, 400, dmax, dmin]) else: pylab.axis([0, 360., dmax, dmin]) pylab.xlabel('Declination') pylab.ylabel(ylab) plt += 1 pmagplotlib.delticks(ax) # dec xticks are too crowded otherwise if pltI == 1: pylab.subplot(1, pcol, plt) if pltL == 1: pylab.plot(Incs, Depths, 'k') if len(Incs) > 0: pylab.plot(Incs, Depths, sym, markersize=size) if len(Incs) == 0 and pltL == 1 and len(SIncs) > 0: pylab.plot(SIncs, SDepths, 'k') if len(SIncs) > 0: pylab.plot(SIncs, SDepths, Ssym, markersize=Ssize) if spc_file != "" and len(SpecDepths) > 0: pylab.plot(SpecIncs, SpecDepths, spc_sym, markersize=spc_size) if spc_file != "" and len(FDepths) > 0: pylab.scatter(FIncs, FDepths, marker=spc_sym[-1], edgecolor=spc_sym[0], facecolor='white', s=spc_size**2) if res_file != "": pylab.plot(ResIncs, ResDepths, res_sym, markersize=res_size) if sum_file != "": for core in Cores: depth = float(core[core_depth_key]) if depth > dmin and depth < dmax: if pel == plt: pylab.text(90, depth + tint, core[core_label_key]) pylab.plot([-90, 90], [depth, depth], 'b--') pylab.plot([0, 0], [dmax, dmin], 'k-') if pel == plt: pylab.axis([-90, 110, dmax, dmin]) else: pylab.axis([-90, 90, dmax, dmin]) pylab.xlabel('Inclination') pylab.ylabel('') plt += 1 if pltM == 1 and len(Ints) > 0 or len(SInts) > 0: pylab.subplot(1, pcol, plt) for pow in range(-10, 10): if maxInt * 10**pow > 1: break if logit == 0: for k in range(len(Ints)): Ints[k] = Ints[k] * 10**pow for k in range(len(SInts)): SInts[k] = SInts[k] * 10**pow if pltL == 1 and len(Ints) > 0: pylab.plot(Ints, Depths, 'k') if len(Ints) > 0: pylab.plot(Ints, Depths, sym, markersize=size) if len(Ints) == 0 and pltL == 1 and len(SInts) > 0: pylab.plot(SInts, SDepths, 'k-') if len(SInts) > 0: pylab.plot(SInts, SDepths, Ssym, markersize=Ssize) if sum_file != "": for core in Cores: depth = float(core[core_depth_key]) pylab.plot([0, maxInt * 10**pow + .1], [depth, depth], 'b--') if depth > dmin and depth < dmax: pylab.text(maxInt * 10**pow - .2 * maxInt * 10**pow, depth + tint, core[core_label_key]) pylab.axis([0, maxInt * 10**pow + .1, dmax, dmin]) if norm == 0: pylab.xlabel('%s %i %s' % ('Intensity (10^-', pow, ' Am^2)')) else: pylab.xlabel('%s %i %s' % ('Intensity (10^-', pow, ' Am^2/kg)')) else: if pltL == 1: pylab.semilogx(Ints, Depths, 'k') if len(Ints) > 0: pylab.semilogx(Ints, Depths, sym, markersize=size) if len(Ints) == 0 and pltL == 1 and len(SInts) > 0: pylab.semilogx(SInts, SDepths, 'k') if len(Ints) == 0 and pltL == 1 and len(SInts) > 0: pylab.semilogx(SInts, SDepths, 'k') if len(SInts) > 0: pylab.semilogx(SInts, SDepths, Ssym, markersize=Ssize) if sum_file != "": for core in Cores: depth = float(core[core_depth_key]) pylab.semilogx([minInt, maxInt], [depth, depth], 'b--') if depth > dmin and depth < dmax: pylab.text(maxInt - .2 * maxInt, depth + tint, core[core_label_key]) pylab.axis([0, maxInt, dmax, dmin]) if norm == 0: pylab.xlabel('Intensity (Am^2)') else: pylab.xlabel('Intensity (Am^2/kg)') plt += 1 if suc_file != "" or len(SSucs) > 0: pylab.subplot(1, pcol, plt) if len(Susc) > 0: if pltL == 1: pylab.plot(Susc, Sus_depths, 'k') if logit == 0: pylab.plot(Susc, Sus_depths, sym, markersize=size) if logit == 1: pylab.semilogx(Susc, Sus_depths, sym, markersize=size) if len(SSucs) > 0: if logit == 0: pylab.plot(SSucs, SDepths, sym, markersize=size) if logit == 1: pylab.semilogx(SSucs, SDepths, sym, markersize=size) if sum_file != "": for core in Cores: depth = float(core[core_depth_key]) if logit == 0: pylab.plot([minSuc, maxSuc], [depth, depth], 'b--') if logit == 1: pylab.semilogx([minSuc, maxSuc], [depth, depth], 'b--') pylab.axis([minSuc, maxSuc, dmax, dmin]) pylab.xlabel('Susceptibility') plt += 1 if wig_file != "": pylab.subplot(1, pcol, plt) pylab.plot(WIG, WIG_depths, 'k') if sum_file != "": for core in Cores: depth = float(core[core_depth_key]) pylab.plot([WIG[0], WIG[-1]], [depth, depth], 'b--') pylab.axis([min(WIG), max(WIG), dmax, dmin]) pylab.xlabel(plt_key) plt += 1 if pTS == 1: ax1 = pylab.subplot(1, pcol, plt) ax1.axis([-.25, 1.5, amax, amin]) plt += 1 TS, Chrons = pmag.get_TS(ts) X, Y, Y2 = [0, 1], [], [] cnt = 0 if amin < TS[1]: # in the Brunhes Y = [amin, amin] # minimum age Y1 = [TS[1], TS[1]] # age of the B/M boundary ax1.fill_between(X, Y, Y1, facecolor='black') # color in Brunhes, black for d in TS[1:]: pol = cnt % 2 cnt += 1 if d <= amax and d >= amin: ind = TS.index(d) Y = [TS[ind], TS[ind]] Y1 = [TS[ind + 1], TS[ind + 1]] if pol: ax1.fill_between( X, Y, Y1, facecolor='black') # fill in every other time ax1.plot([0, 1, 1, 0, 0], [amin, amin, amax, amax, amin], 'k-') ax2 = ax1.twinx() pylab.ylabel("Age (Ma): " + ts) for k in range(len(Chrons) - 1): c = Chrons[k] cnext = Chrons[k + 1] d = cnext[1] - (cnext[1] - c[1]) / 3. if d >= amin and d < amax: ax2.plot([1, 1.5], [c[1], c[1]], 'k-') # make the Chron boundary tick ax2.text(1.05, d, c[0]) # ax2.axis([-.25, 1.5, amax, amin]) figname = location + '_m:_' + method + '_core-depthplot' + fmt pylab.title(location) if verbose: pylab.draw() ans = raw_input("S[a]ve plot? ") if ans == 'a': pylab.savefig(figname) print 'Plot saved as ', figname elif plots: pylab.savefig(figname) print 'Plot saved as ', figname sys.exit()