def setticks(ax, xlog=False, ylog=False, xmajor=5, xminor=1, ymajor=2, yminor=0.5): if not xlog: xmajorLocator = pylab.MultipleLocator(xmajor) xmajorFormatter = pylab.FormatStrFormatter('%d') xminorLocator = pylab.MultipleLocator(xminor) ax.xaxis.set_major_locator(xmajorLocator) #ax.xaxis.set_major_formatter(xmajorFormatter) ax.xaxis.set_minor_locator(xminorLocator) if not ylog: ymajorLocator = pylab.MultipleLocator(ymajor) ymajorFormatter = pylab.FormatStrFormatter('%d') yminorLocator = pylab.MultipleLocator(yminor) ax.yaxis.set_major_locator(ymajorLocator) #ax.yaxis.set_major_formatter(ymajorFormatter) ax.yaxis.set_minor_locator(yminorLocator) ax.get_yaxis().set_tick_params(which='both', direction='out') ax.get_xaxis().set_tick_params(which='both', direction='out') for tick in ax.xaxis.get_ticklines(): tick.set_markersize(3.25) for tick in ax.yaxis.get_ticklines(): tick.set_markersize(3.25) for tick in ax.xaxis.get_ticklines(minor=True): tick.set_markersize(2.75) for tick in ax.yaxis.get_ticklines(minor=True): tick.set_markersize(2.75)
def plot_spectrum(self, p, plot_variable): varlist = [] if plot_variable: if plot_variable not in p.pot_list: raise ArgumentError("variable %s not found" % plot_variable) ##hack for k, t in self.V.items(): if isinstance(k, P): if not isinstance(t, dict): t = dict(value=t) var = t.get('var') if var is None: var = str(k) + 'v' if var == plot_variable: break loga = t.get('a', 0) inv = t.get('inv', 0) for i in range(5): pot = i / 4 lbl = "%s" % pot if inv: pot = 1 - pot if loga: pot = (math.exp(loga * pot) - 1) / (math.exp(loga) - 1) varlist.append((plot_variable, pot, lbl)) else: varlist.append((None, None, p.out_labels)) n = None cut = None def spec(y): s = 20 * np.log10(abs(np.fft.fft(y, n, axis=0)[cut])) return np.where(s > -80, s, np.nan) labels = [] for var, val, lbl in varlist: if var is not None: p.set_variable(var, val) y = self.spectrum_signal(p, magnitude=1e-4) if n is None: n = dk_lib.pow2roundup(len(y)) cut = slice(n * 20 // int(self.FS), n * 10000 // int(self.FS)) w = fftfreq(n, 1.0 / self.FS)[cut] pl.semilogx(w, spec(y), label=plot_variable) pl.xlabel('Frequency') pl.ylabel('Magnitude ') if plot_variable: pl.title(plot_variable) if isinstance(lbl, basestring): labels.append(lbl) else: labels.extend(lbl) ax = pl.gca() ax.grid() ax.yaxis.set_major_formatter(pl.FormatStrFormatter('%d dB')) ax.xaxis.set_major_formatter(pl.FormatStrFormatter('%d Hz')) self.finish_plot(labels, loc='upper left')
def plotTrans(root): """ Plot the fractional change in plate scale and PA over many different starlists that have been aligned. You can either give align results for many different epochs or align results for many different cleaned frames in a single epoch. root - align output """ tab = asciidata.open(root + '.trans') a0 = tab[3].tonumarray() a0e = tab[4].tonumarray() a1 = tab[5].tonumarray() a1e = tab[6].tonumarray() a2 = tab[7].tonumarray() a2e = tab[8].tonumarray() b0 = tab[9].tonumarray() b0e = tab[10].tonumarray() b1 = tab[11].tonumarray() b1e = tab[12].tonumarray() b2 = tab[13].tonumarray() b2e = tab[14].tonumarray() trans = [] for ff in range(len(a0)): tt = objects.Transform() tt.a = [a0[ff], a1[ff], a2[ff]] tt.b = [b0[ff], b1[ff], b2[ff]] tt.aerr = [a0e[ff], a1e[ff], a2e[ff]] tt.berr = [b0e[ff], b1e[ff], b2e[ff]] tt.linearToSpherical(override=False) trans.append(tt) # Read epochs dateTab = asciidata.open(root + '.date') numEpochs = dateTab.ncols years = [dateTab[i][0] for i in range(numEpochs)] p.clf() p.subplot(211) p.plot(scale - 1.0, 'ko') p.ylabel('Fract. Plate Scale Difference') if (years[0] != years[1]): thePlot = p.gca() thePlot.get_xaxis().set_major_locator(p.MultipleLocator(0.1)) thePlot.get_xaxis().set_major_formatter(p.FormatStrFormatter('%8.3f')) p.subplot(212) p.plot(angle, 'ko') p.ylabel('Position Angle') if (years[0] != years[1]): thePlot = p.gca() thePlot.get_xaxis().set_major_locator(p.MultipleLocator(0.1)) thePlot.get_xaxis().set_major_formatter(p.FormatStrFormatter('%8.3f'))
def plot_all(x_outliers, y_outliers, x_model, y_model, data, counter): """Plotting the data. Outliers shown in red. Linear model shown as dotted line. :param x_outliers: list, outlier IDs (str) :param y_outliers: list, outlier IDs (str) :param x_model: array_like, linear model :param y_model: array_like, linear model :param data: np array, the data :param counter: int, counter keeping track of iterations :return: None """ w, h = plt.figaspect(1.5) fig = plt.figure(figsize=(w, h)) ax = fig.add_subplot(211) ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%.1f')) ax.yaxis.set_major_formatter(plt.FormatStrFormatter('%.1f')) smooth_x = np.linspace(min(data["xval"]), max(data["xval"]), 1000) smooth_y = np.linspace(min(data["yval"]), max(data["yval"]), 1000) plt.plot(data["xval"], data["yval"], "ok", markersize=6) plt.plot(smooth_x, x_model(smooth_x), "--k", linewidth=2.5) for outlier in x_outliers: index = np.where(data["name"] == outlier)[0][0] plt.plot(data["xval"][index], data["yval"][index], "or", markersize=6) plt.tick_params(width=2, labelsize=14) plt.axis([0, 1.1 * max(data["xval"]), 0, 1.1 * max(data["yval"])]) plt.xlabel("Independent Variables", fontsize=14) plt.ylabel("Dependent Variables", fontsize=14) ax = fig.add_subplot(212) ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%.1f')) ax.yaxis.set_major_formatter(plt.FormatStrFormatter('%.1f')) plt.plot(data["yval"], data["xval"], "ok", markersize=6) plt.plot(smooth_y, y_model(smooth_y), "--k", linewidth=2.5) for outlier in y_outliers: index = np.where(data["name"] == outlier)[0][0] plt.plot(data["yval"][index], data["xval"][index], "or", markersize=6) plt.tick_params(width=2, labelsize=14) plt.axis([0, 1.1 * max(data["yval"]), 0, 1.1 * max(data["xval"])]) plt.xlabel("Independent Variables", fontsize=14) plt.ylabel("Dependent Variables", fontsize=14) plt.subplots_adjust(left=0.2, hspace=0.5) sns.despine() plt.savefig(os.getcwd() + "/" + "swap_round" + str(counter) + ".png")
def yAxis(): ay = pylab.subplot(111) majLoc = pylab.MultipleLocator(50) majFmat = pylab.FormatStrFormatter( '%d') # or some other format - this puts the numbers on ay.yaxis.set_major_locator(majLoc) ay.yaxis.set_major_formatter(majFmat) minLoc = pylab.MultipleLocator(10) ay.yaxis.set_minor_locator( minLoc) #for the minor ticks, use no labels; default NullFormatter
def xAxis(): ax = pylab.subplot(111) majLoc = pylab.MultipleLocator(0.02) majFmat = pylab.FormatStrFormatter( '%f') # or some other format - this puts the numbers on ax.xaxis.set_major_locator(majLoc) # ax.xaxis.set_major_formatter(majFmat) minLoc = pylab.MultipleLocator(0.01) ax.xaxis.set_minor_locator( minLoc) #for the minor ticks, use no labels; default NullFormatter
def X_axis_label_format(format): """ Define the X-axis label format """ this_axes = py.gca() this_figure = py.gcf() this_image = py.gci() # Set a tick on every integer that is multiple of base in the view interval # which is 1 in this case majorLocator = py.MultipleLocator(1) majorFormatter = py.FormatStrFormatter(format) this_axes.xaxis.set_major_locator(majorLocator) this_axes.xaxis.set_major_formatter(majorFormatter)
def plot_one(outliers, model, data, counter): """Plotting the data under the condition that axes are not swapped. :param outliers: list, outlier IDs (str) :param model: array_like, linear model :param data: np array, the data set :param counter: int, counter keeping track of iterations :return: None """ fig, ax = plt.subplots() ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%.1f')) ax.yaxis.set_major_formatter(plt.FormatStrFormatter('%.1f')) smooth_x = np.linspace(min(data["xval"]), max(data["xval"]), 1000) plt.plot(data["xval"], data["yval"], "ok", markersize=6) plt.plot(smooth_x, model(smooth_x), "--k", linewidth=2.5) for outlier in outliers: index = np.where(data["name"] == outlier)[0][0] plt.plot(data["xval"][index], data["yval"][index], "or", markersize=6) plt.tick_params(width=2, labelsize=14) plt.xlabel("Independent Variables", fontsize=14) plt.ylabel("Dependent Variables", fontsize=14) sns.despine() plt.savefig(os.getcwd() + "/" + "no_swap_round" + str(counter) + ".png") plt.clf()
def __init__(self, nh, nv, brightnessunit, direction_label, direction_reference, spectral_label, spectral_unit, ticksize, title='', separatepanel=True, showaxislabel=False, showtick=False, showticklabel=False, figsize=None, clearpanel=True): self.nh = nh self.nv = nv self.ticksize = ticksize self.brightnessunit = brightnessunit self.numeric_formatter = pl.FormatStrFormatter('%.2f') self.direction_label = direction_label self.direction_reference = direction_reference self.separatepanel = separatepanel self.spectral_label = spectral_label self.spectral_unit = spectral_unit self.showaxislabel = showaxislabel self.showtick = showtick self.showticklabel = showticklabel self.title = title self.figsize = figsize casalog.post('figsize={figsize}'.format(figsize=self.figsize), priority='DEBUG') self.normalization_factor = 1 self._axes_spmap = None # to resize matplotlib window to specified size pl.figure(self.MATPLOTLIB_FIGURE_ID) pl.close() if self.figsize is None: pl.figure(self.MATPLOTLIB_FIGURE_ID) else: pl.figure(self.MATPLOTLIB_FIGURE_ID, figsize=self.figsize) if clearpanel: pl.clf()
def draw_speedup_fig(x, y, fig_title, filename): set_figure_props() ax = pylab.subplot(111) pylab.semilogx(x, y, linestyle=':', marker='v', basex=2) pylab.xticks(x) frm = pylab.FormatStrFormatter("%d") ax.xaxis.set_major_formatter(frm) ax.xaxis.grid(True, which="minor") pylab.xlabel("Query length (bp - log scale)") pylab.ylabel("Speedup") pylab.title(fig_title, fontsize=9) pylab.savefig(filename) pylab.close()
def GraphUtilGaussianFitGraphs(self, name, x, y, error, xLabel, yLabel, whichGraph): """Generic plotting method that plots depending on which graph is being plotted. :param canvas: canvas for widget :param fig: figure for graph :param name: name of tab :param x: x-values :param y: y-values :param error: error values for gaussian fit graphs :param xLabel: x-axis label :param yLabel: y-axis label :param whichGraph: char that represents either gaussian or lattice fit """ mainGraph = qtWidgets.QWidget() fig = plab.Figure((5.0, 4.0), dpi=100) canvas = FigureCanvas(fig) canvas.setParent(mainGraph) axes = fig.add_subplot(111) axes.plot(x, y) print(y) print("Fitted Data") print(name) if whichGraph == 'G': axes.errorbar(x, y, yerr=error, fmt='o') elif whichGraph == 'L': axes.plot(x, y, 'go') axes.yaxis.set_major_formatter(plab.FormatStrFormatter('%.4f')) axes.set_title(name) axes.set_xlabel(xLabel) axes.set_ylabel(yLabel) canvas.draw() tab = qtWidgets.QWidget() tab.setStatusTip(name) vbox = qtWidgets.QVBoxLayout() graphNavigationBar = NavigationToolbar(canvas, mainGraph) vbox.addWidget(graphNavigationBar) vbox.addWidget(canvas) tab.setLayout(vbox) self.myMainWindow.savingCanvasTabs(tab, name, canvas, fig)
def draw_graph(times, output): for sub in times.keys(): x = times[sub].keys() y = [times[sub][i] for i in x] z = zip(x, y) z.sort() x = [tup[0] for tup in z] y = [tup[1] for tup in z] print "%s:" % sub print "--> x = ", x print "--> y = ", y pylab.plot(x, y, label=sub) intFormatter = pylab.FormatStrFormatter('%d') a = pylab.gca() a.xaxis.set_major_formatter(intFormatter) a.yaxis.set_major_formatter(intFormatter) pylab.legend(loc='best') pylab.draw() pylab.xlabel("Revision number") pylab.ylabel("Time (s)") pylab.savefig(output)
sc = ax.pcolormesh(datX, datY, masked_datMesh, cmap='jet') plt.colorbar(sc, label=r'$\log\sqrt{\Delta\nu_x^2+\Delta\nu_y^2}$') #x = fnpData[:,[0]] #y = fnpData[:,[1]] #z = fnpData[:,[4]] #ix = z>-99.0 #plt.scatter(x[ix], y[ix], c=z[ix], cmap='jet', verts=(verts), s=47.0, antialiased=None, edgecolors='none') else: print("Warning: No ADTS footprint data found.") #fig = plt.figure(figsize=(10,10),dpi=125) fig = plt.figure(figsize=(6, 6), dpi=125) plt.subplots_adjust(left=0.15, right=0.95, top=0.9, bottom=0.1) ax = fig.add_subplot(111) ax.yaxis.set_major_formatter(plt.FormatStrFormatter('%.3f')) ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%.3f')) plt.gca().set_autoscale_on(True) plt.xlabel('x (m)') plt.ylabel('y (m)') additionalItemsToPlot(ax) #Plot additional items specified at top of this file #plt.xlim(-0.010,0.010) #plt.ylim(0.0,0.010) plt.title('Raster with Frequency Map Coloring') #plt.show() #plt.savefig('raster.svg')
def plot_points_plus_kde(xlist, labels, markx=False, lines=3, size=9, ax=None): """ Accepts a list of one-dimensional densities and plots each as points on a line with a KDE on top. Parameters: ------------- xlist : list of array-like objects data to produce density plot for labels : list of legend labels; len(labels) should equal len(xlist) markx : bool, optional put tick labels at the min/max values in x? lines : integer, optional line/marker edge thickness size : integer, optional marker size color : string, optional color for points and kde ax : pylab axes object, optional """ if ax is None: ax = pylab.axes(frameon=False) # cycles through colors cw = color_wheel(lines=('-'), symbols=('o')) for i in xrange(0, len(xlist)): # spin the color wheel (c, s, l) = cw.next() # make the point plot ax.plot(xlist[i], zeros(xlist[i].shape), c + s, markersize=size, mew=lines, alpha=0.5) # kde kde = gaussian_kde(xlist[i]) lpoint = min(xlist[i]) - 0.025 * abs(min(xlist[i])) rpoint = max(xlist[i]) + 0.025 * abs(max(xlist[i])) support = linspace(lpoint, rpoint, 512) mPDF = kde(support) ax.plot(support, mPDF, color=c, lw=lines, label=labels[i]) # prtty things up ax.get_yaxis().set_visible(False) ax.set_ylim(bottom=-0.1) if markx: major_formatter = pylab.FormatStrFormatter('%1.2f') ax.get_xaxis().set_major_formatter(major_formatter) ax.get_xaxis().tick_bottom() minx = min([min(x) for x in xlist]) maxx = max([max(x) for x in xlist]) ax.get_xaxis().set_ticks([minx, maxx]) else: ax.get_xaxis().set_ticks([]) # legend ax.legend(loc='best') return ax
def fit_trans_combined(filter): # First lets fit each star in each filter seperately. data = PhotometryData() if (filter == 'H'): m = data.mH m_err = data.mH_err X = data.XH M = data.H M_err = data.H_err c = data.cHKp c_err = data.cHKp_err xpos = data.pxH ypos = data.pyH if (filter == 'Kp'): m = data.mKp m_err = data.mKp_err X = data.XKp M = data.Kp M_err = data.Kp_err c = data.cHKp c_err = data.cHKp_err xpos = data.pxKp ypos = data.pyKp if (filter == 'Lp'): m = data.mLp m_err = data.mLp_err X = data.XLp M = data.Lp M_err = data.Lp_err c = data.cKpLp c_err = data.cKpLp_err xpos = data.pxLp ypos = data.pyLp # Get rid of nan values idx = np.isfinite(m) tmp = np.where(idx == True)[0] print 'Found %d (out of %d) NaN values.' % (len(m) - len(tmp), len(m)) name = data.name[idx] m = m[idx] m_err = m_err[idx] X = X[idx] M = M[idx] M_err = M_err[idx] c = c[idx] c_err = c_err[idx] xpos = xpos[idx] ypos = ypos[idx] p, p_err, res, m_pred = run_fit(m, m_err, X, M, M_err, c, c_err) magFormatter = py.FormatStrFormatter('%.2f') magLocator = py.MultipleLocator(0.02) ########## # Plot Instrumental Magnitude vs. Airmass with Residuals ########## py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) py.grid(True) py.scatter(X, m, c=res, s=30) py.plot(X, m_pred, 'k*', ms=10) cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05) cbar.ax.get_yaxis().get_label().set_text('Residuals') py.legend(('Predicted', 'Observed'), scatterpoints=1, loc='lower right') py.xlabel('Airmass') py.ylabel('Instrumental Magnitude') py.gca().yaxis.set_major_formatter(magFormatter) py.title('All Stars, %s-band' % (filter)) py.savefig('plots/fit_airmass_vs_m_all_%s.png' % (filter)) ########## # Plot Instrumental Magnitude vs. Airmass with Order ########## order = np.arange(len(m)) py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) py.grid(True) py.scatter(X, m, c=order, s=30) py.plot(X, m_pred, 'k*', ms=10) cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05) cbar.ax.get_yaxis().get_label().set_text('Order') py.legend(('Predicted', 'Observed'), loc='lower right') py.xlabel('Airmass') py.ylabel('Instrumental Magnitude') py.gca().yaxis.set_major_formatter(magFormatter) py.title('All Stars, %s-band' % (filter)) py.savefig('plots/fit_airmass_vs_m_order_all_%s.png' % (filter)) ########## # Plot Instrumental Magnitude vs. Order with # Airmass information (colors) and # Position information (symbol sizes). ########## iiTopLeft = np.where((xpos < 400) & (ypos > 600))[0] iiTopRight = np.where((xpos > 600) & (ypos > 600))[0] iiBotRight = np.where((xpos > 600) & (ypos < 400))[0] iiCenter = np.where((xpos > 400) & (xpos < 600) & (ypos > 400) & (ypos < 600))[0] order = np.arange(len(m)) py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) s1 = py.scatter(order[iiCenter], m[iiCenter], c=X[iiCenter], marker='>', s=100, vmin=X.min(), vmax=X.max()) s2 = py.scatter(order[iiTopLeft], m[iiTopLeft], c=X[iiTopLeft], marker='o', s=100, vmin=X.min(), vmax=X.max()) s3 = py.scatter(order[iiTopRight], m[iiTopRight], c=X[iiTopRight], marker='s', s=100, vmin=X.min(), vmax=X.max()) s4 = py.scatter(order[iiBotRight], m[iiBotRight], c=X[iiBotRight], marker='d', s=100, vmin=X.min(), vmax=X.max()) # Legend is backwards for some reason py.legend((s1, s2, s3, s4), ('Center', 'Top Left', 'Top Right', 'Bottom Right'), scatterpoints=1, loc='lower right') py.grid(True) py.xlabel('Order') py.ylabel('Instrumental Magnitude') py.gca().yaxis.set_major_formatter(magFormatter) py.gca().yaxis.set_major_locator(magLocator) cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05) cbar.ax.get_yaxis().get_label().set_text('Airmass') py.title('All Stars, %s-band' % (filter)) py.savefig('plots/fit_order_vs_m_airmass_position_all_%s.png' % (filter)) ########## # Plot Airmass vs. Residuals with Instrumental Magnitude (color) ########## # Give different stars, different symbols fs140 = np.where(name == 'FS140')[0] fs147 = np.where(name == 'FS147')[0] fs148 = np.where(name == 'FS148')[0] py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) s1 = py.scatter(X[fs140], res[fs140], c=m[fs140], s=100, marker='o') s2 = py.scatter(X[fs147], res[fs147], c=m[fs147], s=100, marker='^') s3 = py.scatter(X[fs148], res[fs148], c=m[fs148], s=100, marker='s') py.legend((s1, s2, s3), ('FS140', 'FS147', 'FS148'), scatterpoints=1, loc='lower right') py.grid(True) py.xlabel('Airmass') py.ylabel('Residuals (mag)') cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05, format='%.3f') cbar.ax.get_yaxis().get_label().set_text('Instrumental Magnitude') py.title('All Stars, %s-band' % (filter)) py.savefig('plots/fit_airmass_vs_residuals_m_all_%s.png' % (filter)) ########## # Plot Residuals vs. Color ########## # Give different stars, different symbols py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) s1 = py.scatter(c[fs140], res[fs140], c=X[fs140], s=100, marker='o') s2 = py.scatter(c[fs147], res[fs147], c=X[fs147], s=100, marker='^') s3 = py.scatter(c[fs148], res[fs148], c=X[fs148], s=100, marker='s') py.legend((s1, s2, s3), ('FS140', 'FS147', 'FS148'), scatterpoints=1, loc='lower right') py.grid(True) py.xlabel('Color') py.ylabel('Residuals (mag)') cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05, format='%.3f') cbar.ax.get_yaxis().get_label().set_text('Airmass') py.title('All Stars, %s-band' % (filter)) py.savefig('plots/fit_color_vs_residuals_airmass_all_%s.png' % (filter)) ########## # Plot Residuals vs. Color ########## # Give different stars, different symbols py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) dm = M - m - p[0] s1 = py.scatter(X[fs140], dm[fs140], c=m[fs140], s=100, marker='o') s2 = py.scatter(X[fs147], dm[fs147], c=m[fs147], s=100, marker='^') s3 = py.scatter(X[fs148], dm[fs148], c=m[fs148], s=100, marker='s') py.legend((s1, s2, s3), ('FS140', 'FS147', 'FS148'), scatterpoints=1, loc='lower right') py.grid(True) py.xlabel('Airmass') py.ylabel('M - m - ZP (mag)') cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05, format='%.3f') cbar.ax.get_yaxis().get_label().set_text('Instrumental Magnitude') py.title('All Stars, %s-band' % (filter)) py.savefig('plots/fit_airmass_vs_magdiff_m_all_%s.png' % (filter)) return p
def test_fit_trans(): data = PhotometryData(onlyStar='FS140') p, p_err, res, mH_pred = run_fit(data.mH, data.mH_err, data.XH, data.H, data.H_err, data.cHKp, data.cHKp_err) magFormatter = py.FormatStrFormatter('%.2f') magLocator = py.MultipleLocator(0.02) py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) py.grid(True) py.scatter(data.XH, data.mH, c=res, s=30) py.plot(data.XH, mH_pred, 'k*', ms=10) cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05) cbar.ax.get_yaxis().get_label().set_text('Residuals') py.legend(('Predicted', 'Observed')) py.xlabel('Airmass') py.ylabel('Instrumental Magnitude') py.gca().yaxis.set_major_formatter(magFormatter) py.title('FS140') py.savefig('plots/test_fit_airmass_vs_mH.png') # py.show() py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) py.grid(True) py.scatter(data.mH, res, c=data.XH, s=data.tH * 10.0) py.xlabel('Instrumental Magnitude') py.ylabel('Residuals') py.gca().xaxis.set_major_formatter(magFormatter) py.gca().xaxis.set_major_locator(magLocator) cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05) cbar.ax.get_yaxis().get_label().set_text('Airmass') py.title('FS140') py.savefig('plots/test_fit_mH_vs_residuals_airmass.png') # py.show() py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) py.scatter(data.XH, res, c=data.mH, s=100) py.grid(True) py.xlabel('Airmass') py.ylabel('Residuals (mag)') cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05, format='%.3f') cbar.ax.get_yaxis().get_label().set_text('Instrumental Magnitude') py.title('FS140') py.savefig('plots/test_fit_airmass_vs_residuals_mH.png') # py.show() py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) symSize = (data.XH - data.XH.min()) / (data.XH.max() - data.XH.min()) symSize = symSize * 100.0 + 20.0 py.scatter(data.pxH, data.pyH, c=res, s=symSize) py.grid(True) py.xlabel('X Position') py.ylabel('Y Position') cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05, format='%.3f') cbar.ax.get_yaxis().get_label().set_text('Residuals') py.title('FS140 - Size ~ Airmass') py.savefig('plots/test_position_mH.png') # py.show() iiTopLeft = np.where((data.pxH < 400) & (data.pyH > 600))[0] iiTopRight = np.where((data.pxH > 600) & (data.pyH > 600))[0] iiBotRight = np.where((data.pxH > 600) & (data.pyH < 400))[0] iiCenter = np.where((data.pxH > 400) & (data.pxH < 600) & (data.pyH > 400) & (data.pyH < 600))[0] order = np.arange(len(data.mH)) py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) s1 = py.scatter(order[iiCenter], data.mH[iiCenter], c=data.XH[iiCenter], marker='>', s=100, vmin=data.XH.min(), vmax=data.XH.max()) s2 = py.scatter(order[iiTopLeft], data.mH[iiTopLeft], c=data.XH[iiTopLeft], marker='o', s=100, vmin=data.XH.min(), vmax=data.XH.max()) s3 = py.scatter(order[iiTopRight], data.mH[iiTopRight], c=data.XH[iiTopRight], marker='s', s=100, vmin=data.XH.min(), vmax=data.XH.max()) s4 = py.scatter(order[iiBotRight], data.mH[iiBotRight], c=data.XH[iiBotRight], marker='d', s=100, vmin=data.XH.min(), vmax=data.XH.max()) # Legend is backwards for some reason py.legend((s1, s2, s3, s4), ('Center', 'Top Left', 'Top Right', 'Bottom Right'), scatterpoints=1) py.grid(True) py.xlabel('Order') py.ylabel('Instrumental Magnitude') py.gca().yaxis.set_major_formatter(magFormatter) py.gca().yaxis.set_major_locator(magLocator) cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05) cbar.ax.get_yaxis().get_label().set_text('Airmass') py.title('FS140') py.savefig('plots/test_fit_order_vs_mH_airmass.png') py.show()
def plot_fitparams(file, filter, suffix): transTable = asciidata.open(file) filters = transTable[0].tonumpy() rms = transTable[1].tonumpy() zp = transTable[2].tonumpy() zp_err = transTable[3].tonumpy() k = transTable[4].tonumpy() k_err = transTable[5].tonumpy() data = PhotometryData() name = data.name if (filter == 'H'): m = data.mH m_err = data.mH_err X = data.XH M = data.H M_err = data.H_err c = data.cHKp c_err = data.cHKp_err xpos = data.pxH ypos = data.pyH if (filter == 'Kp'): m = data.mKp m_err = data.mKp_err X = data.XKp M = data.Kp M_err = data.Kp_err c = data.cHKp c_err = data.cHKp_err xpos = data.pxKp ypos = data.pyKp if (filter == 'Lp'): m = data.mLp m_err = data.mLp_err X = data.XLp M = data.Lp M_err = data.Lp_err c = data.cKpLp c_err = data.cKpLp_err xpos = data.pxLp ypos = data.pyLp # Get rid of nan values idx = np.isfinite(m) tmp = np.where(idx == True)[0] print 'Found %d (out of %d) NaN values.' % (len(m) - len(tmp), len(m)) name = name[idx] m = m[idx] m_err = m_err[idx] X = X[idx] M = M[idx] M_err = M_err[idx] c = c[idx] c_err = c_err[idx] xpos = xpos[idx] ypos = ypos[idx] idx = np.where(filters == filter)[0][0] p = np.array([zp[idx], k[idx]]) # Get residuals res, res_err = func_residuals(p, m, m_err, X, M, M_err, c, c_err) # Get the predicted instrumental magnitude m_pred, m_pre_err = func_calc_mag_obs_predicted(p, M, M_err, X, c, c_err) # Print out some statistics print 'Total |Residuals| = ', abs(res).sum() print 'Average |Residuals| = ', abs(res).mean() print 'Stand. Dev. Residuals = ', res.std() # Now we can plot stuff magFormatter = py.FormatStrFormatter('%.2f') magLocator = py.MultipleLocator(0.02) ########## # Plot Instrumental Magnitude vs. Airmass with Residuals ########## py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) py.grid(True) py.scatter(X, m, c=res, s=30) py.plot(X, m_pred, 'k*', ms=10) cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05) cbar.ax.get_yaxis().get_label().set_text('Residuals') py.legend(('Predicted', 'Observed'), scatterpoints=1, loc='lower right') py.xlabel('Airmass') py.ylabel('Instrumental Magnitude') py.gca().yaxis.set_major_formatter(magFormatter) py.title('All Stars, %s-band' % (filter)) py.savefig('plots/fitp_X_vs_m_all_%s_%s.png' % (filter, suffix)) ########## # Plot Instrumental Magnitude vs. Airmass with Order ########## order = np.arange(len(m)) py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) py.grid(True) py.scatter(X, m, c=order, s=30) py.plot(X, m_pred, 'k*', ms=10) cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05) cbar.ax.get_yaxis().get_label().set_text('Order') py.legend(('Predicted', 'Observed'), loc='lower right') py.xlabel('Airmass') py.ylabel('Instrumental Magnitude') py.gca().yaxis.set_major_formatter(magFormatter) py.title('All Stars, %s-band' % (filter)) py.savefig('plots/fitp_X_vs_m_order_all_%s_%s.png' % (filter, suffix)) ########## # Plot Instrumental Magnitude vs. Order with # Airmass information (colors) and # Position information (symbol sizes). ########## iiTopLeft = np.where((xpos < 400) & (ypos > 600))[0] iiTopRight = np.where((xpos > 600) & (ypos > 600))[0] iiBotRight = np.where((xpos > 600) & (ypos < 400))[0] iiCenter = np.where((xpos > 400) & (xpos < 600) & (ypos > 400) & (ypos < 600))[0] order = np.arange(len(m)) py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) s1 = py.scatter(order[iiCenter], m[iiCenter], c=X[iiCenter], marker='>', s=100, vmin=X.min(), vmax=X.max()) s2 = py.scatter(order[iiTopLeft], m[iiTopLeft], c=X[iiTopLeft], marker='o', s=100, vmin=X.min(), vmax=X.max()) s3 = py.scatter(order[iiTopRight], m[iiTopRight], c=X[iiTopRight], marker='s', s=100, vmin=X.min(), vmax=X.max()) s4 = py.scatter(order[iiBotRight], m[iiBotRight], c=X[iiBotRight], marker='d', s=100, vmin=X.min(), vmax=X.max()) # Legend is backwards for some reason py.legend((s1, s2, s3, s4), ('Center', 'Top Left', 'Top Right', 'Bottom Right'), scatterpoints=1, loc='lower right') py.grid(True) py.xlabel('Order') py.ylabel('Instrumental Magnitude') py.gca().yaxis.set_major_formatter(magFormatter) py.gca().yaxis.set_major_locator(magLocator) cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05) cbar.ax.get_yaxis().get_label().set_text('Airmass') py.title('All Stars, %s-band' % (filter)) py.savefig('plots/fitp_order_vs_m_X_pos_all_%s_%s.png' % (filter, suffix)) ########## # Plot Airmass vs. Residuals with Instrumental Magnitude (color) ########## # Give different stars, different symbols fs140 = np.where(name == 'FS140')[0] fs147 = np.where(name == 'FS147')[0] fs148 = np.where(name == 'FS148')[0] py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) s1 = py.scatter(X[fs140], res[fs140], c=m[fs140], s=100, marker='o') s2 = py.scatter(X[fs147], res[fs147], c=m[fs147], s=100, marker='^') s3 = py.scatter(X[fs148], res[fs148], c=m[fs148], s=100, marker='s') py.legend((s1, s2, s3), ('FS140', 'FS147', 'FS148'), scatterpoints=1, loc='lower right') py.grid(True) py.xlabel('Airmass') py.ylabel('Residuals (mag)') cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05, format='%.3f') cbar.ax.get_yaxis().get_label().set_text('Instrumental Magnitude') py.title('All Stars, %s-band' % (filter)) py.savefig('plots/fitp_X_vs_res_m_all_%s_%s.png' % (filter, suffix)) ########## # Plot Residuals vs. Color ########## # Give different stars, different symbols py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) s1 = py.scatter(c[fs140], res[fs140], c=X[fs140], s=100, marker='o') s2 = py.scatter(c[fs147], res[fs147], c=X[fs147], s=100, marker='^') s3 = py.scatter(c[fs148], res[fs148], c=X[fs148], s=100, marker='s') py.legend((s1, s2, s3), ('FS140', 'FS147', 'FS148'), scatterpoints=1, loc='lower right') py.grid(True) py.xlabel('Color') py.ylabel('Residuals (mag)') cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05, format='%.3f') cbar.ax.get_yaxis().get_label().set_text('Airmass') py.title('All Stars, %s-band' % (filter)) py.savefig('plots/fitp_C_vs_res_X_all_%s_%s.png' % (filter, suffix)) ########## # Plot Residuals vs. Color ########## # Give different stars, different symbols py.figure(2, figsize=(8, 6)) py.clf() py.subplots_adjust(left=0.15, right=0.88) dm = M - m - p[0] s1 = py.scatter(X[fs140], dm[fs140], c=m[fs140], s=100, marker='o') s2 = py.scatter(X[fs147], dm[fs147], c=m[fs147], s=100, marker='^') s3 = py.scatter(X[fs148], dm[fs148], c=m[fs148], s=100, marker='s') py.legend((s1, s2, s3), ('FS140', 'FS147', 'FS148'), scatterpoints=1, loc='lower right') py.grid(True) py.xlabel('Airmass') py.ylabel('M - m - ZP (mag)') cbar = py.colorbar(orientation='vertical', pad=0.01, fraction=0.05, format='%.3f') cbar.ax.get_yaxis().get_label().set_text('Instrumental Magnitude') py.title('All Stars, %s-band' % (filter)) py.savefig('plots/fitp_X_vs_magdiff_m_all_%s_%s.png' % (filter, suffix))
if fname == 'pairwise_integrated_inverse_distance': featureContainer.getContainer()[-1].cutoffDistance = 100.0 # Optimization options valid_methods = ['ASLAM-RProp+','ASLAM-RProp-','ASLAM-iRProp-','ASLAM-iRProp+','ASLAM-BFGS', 'Nelder-Mead','Powell','CG','BFGS','Newton-CG','L-BFGS-B','TNC','COBYLA','SLSQP'] options = {'disp': True, 'maxiter': 500, 'xtol': 1e-6, 'ftol': 1e-3, 'gtol': 1e-3} res = {} # Setup plot colors,_,markers = pplot.generateUniqueLinestyles(len(valid_methods), colormap='brg') fig = pl.figure(figsize=(20,12)) fig.canvas.set_window_title('optimizer_comparison') ax = fig.add_subplot(111) ax.grid('on') ax.set_yscale('log') ax.tick_params(axis='y', which='both') ax.yaxis.set_major_formatter(pl.FormatStrFormatter("%.1f")) ax.yaxis.set_minor_formatter(pl.FormatStrFormatter("%.1f")) ax.set_xlabel('number of gradient evaluations') ax.set_ylabel('objective fcn') pl.show(block=False) callback = lambda x: popt.plot_convergence_callback(sceneOpt, lgrad, abscissa_type=ax.get_xlabel(), ordinate_type=ax.get_ylabel()) # Optimize for cnt,method in enumerate(valid_methods): sm.logInfo("Runnig optimization with method {0}".format(method)) lgrad, = ax.plot([],[], color=colors[cnt], marker=markers[cnt], linestyle='-', label='{0}'.format(method)) sceneOpt = popt.SceneOptimizable(scene, featureContainer) res[method] = popt.optimize(sceneOpt, method=method, options=options, callback=callback) ax.legend(loc = 'upper right', numpoints = 1, fancybox = True, framealpha = 0.5)
def plot(self): pylab.close() pylab.plot(self.wave, self.current) pylab.show() self.axes = pylab.gca() self.axes.fmt_xdata = pylab.FormatStrFormatter("%4.2f")
def mixing(flmlname): print("\n********** Calculating the mixing diagnostics\n") # warn user about assumptions print( "Background potential energy calculations makes two assumptions: \n i) domain height = 0.1m \n ii) initial temperature difference is 1.0 degC" ) domainheight = 0.1 rho_zero, T_zero, alpha, g = le_tools.Getconstantsfromflml(flmlname) # get mixing bin bounds and remove lower bound (=-\infty) bounds = le_tools.Getmixingbinboundsfromflml(flmlname)[1:] # find indicies of selected bounds for plotting index_plot = [] for b in [-0.5, -0.25, 0.0, 0.25, 0.5]: index_plot.append( numpy.where(numpy.array([abs(val - b) for val in bounds]) < 1E-6)[0]) time = [] volume_fraction = [] reference_state = [] bpe = [] # get stat files # time_index_end used to ensure don't repeat values stat_files, time_index_end = le_tools.GetstatFiles('./') for i in range(len(stat_files)): stat = stat_parser(stat_files[i]) for j in range(time_index_end[i]): time.append(stat['ElapsedTime']['value'][j]) bins = stat['fluid']['Temperature']['mixing_bins%cv_normalised'][:, j] # rearrange bins so have nobins = nobounds -1 # amounts to including any undershoot or overshoots in lower/upper most bin # for discussion of impacts see H. Hiester, PhD thesis (2011), chapter 4. bins[1] = bins[0] + bins[1] bins[-2] = bins[-2] + bins[-1] bins = bins[1:-1] # sum up bins for plot volume_fraction.append( tuple([ sum(bins[index_plot[k]:index_plot[k + 1]]) for k in range(len(index_plot) - 1) ])) # get reference state using method of Tseng and Ferziger 2001 Abins = sum([ bins[k] * (bounds[k + 1] - bounds[k]) for k in range(len(bins)) ]) pdf = [val / Abins for val in bins] rs = [0] for k in range(len(pdf)): rs.append(rs[-1] + (domainheight * pdf[k] * (bounds[k + 1] - bounds[k]))) reference_state.append(tuple(rs)) # get background potential energy, # noting \rho = \rho_zero(1-\alpha(T-T_zero)) # and reference state is based on temperature # bpe_bckgd = 0.5*(g*rho_zero*(1.0+(alpha*T_zero)))*(domainheight**2) # but don't include this as will look at difference over time bpe.append(-rho_zero * alpha * g * scipy.integrate.trapz( x=reference_state[-1], y=[ bounds[j] * reference_state[-1][j] for j in range(len(reference_state[-1])) ])) volume_fraction = numpy.array(volume_fraction) reference_state = numpy.array(reference_state) bpe_zero = bpe[0] bpe = [val - bpe_zero for val in bpe] # plot fs = 18 pylab.figure(num=2, figsize=(16.5, 11.5)) pylab.suptitle('Mixing', fontsize=fs) # volume fraction pylab.subplot(221) pylab.plot(time, volume_fraction[:, 0], label='$T < -0.25$', color='k') pylab.plot(time, volume_fraction[:, 1], label='$-0.25 < T < 0.0$', color='g') pylab.plot(time, volume_fraction[:, 2], label='$0.0 < T < 0.25$', color='b') pylab.plot(time, volume_fraction[:, 3], label='$0.25 < T$', color='0.5') pylab.axis([0, time[-1], 0, 0.5]) pylab.legend(loc=0) pylab.grid('on') pylab.xlabel('$t$ (s)', fontsize=fs) pylab.ylabel('$V/|\\Omega|$', fontsize=fs) pylab.title('Volume fraction', fontsize=fs) # reference state contours pylab.subplot(222) for i in index_plot: pylab.plot(time, reference_state[:, i], color='k') pylab.text( time[-1] / 100, 1.5E-3, 'From bottom to top contours correspond to values \n $T = -0.5, \, -0.25, \, 0.0, \, 0.25, \, 0.5$ \nwhere the values for $T=-0.5$ and $0.5$ take the values\n$z_* = 0.0$ and $0.1$ respectively', bbox=dict(facecolor='white', edgecolor='black')) pylab.axis([0, time[-1], 0, domainheight]) pylab.grid('on') pylab.xlabel('$t$ (s)', fontsize=fs) pylab.ylabel('$z_*$ (m)', fontsize=fs) pylab.title('Reference state', fontsize=fs) pylab.subplot(223) pylab.plot(bounds, reference_state[-1], color='k') pylab.grid('on') pylab.axis([-0.5, 0.5, 0, domainheight]) pylab.xlabel('$T$ ($^\\circ$C)', fontsize=fs) pylab.ylabel('$z_*$ (m)', fontsize=fs) pylab.title('Reference state at $t=' + str(time[-1]) + '\\,$s', fontsize=fs) pylab.subplot(224) pylab.plot(time, bpe, color='k') pylab.grid('on') pylab.gca().get_xaxis().get_axes().set_xlim(0.0, time[-1]) pylab.xlabel('$t$ (s)', fontsize=fs) pylab.ylabel('$\\Delta E_b$', fontsize=fs - 2) pylab.gca().get_yaxis().set_major_formatter( pylab.FormatStrFormatter('%1.1e')) pylab.title('Background potential energy', fontsize=fs) pylab.savefig('diagnostics/plots/mixing.png') return
def compareDARstar(pwDARfixOn, pwDARfixOff, src, outdir='./'): """ Pass in either the filename to a pickle file containing a Pairwise object or pass in the Pairwise object itself for both a DAR corrected and uncorrected data set. This way we can plot up both and compare them. Also plot the model DAR correction which is the average separation of the pre-DAR + model-DAR values for all frames with strehl > 0.30. """ # Rename variables for brevity if (type(pwDARfixOn) == type('')): pw1 = pickle.load(open(pwDARfixOn)) else: pw1 = pwDARfixOn if (type(pwDARfixOff) == type('')): pw2 = pickle.load(open(pwDARfixOff)) else: pw2 = pwDARfixOff ndx1 = pw1.names.index(src) ndx2 = pw2.names.index(src) idx1 = np.where(pw1.hasData[ndx1] == 1)[0] idx2 = np.where(pw2.hasData[ndx2] == 1)[0] # Calculate predicted change in separation due to DAR for this star parang1 = pw1.parang[idx1] parang2 = pw2.parang[idx2] strehl1 = pw1.strehl[idx1] strehl2 = pw2.strehl[idx2] scale = 0.00996 dzObs1 = pw1.posz[ndx1,idx1] / scale dhObs1 = pw1.posh[ndx1,idx1] / scale dR1 = pw1.dar[ndx1,idx1] / scale dzObs2 = pw2.posz[ndx2,idx2] / scale dhObs2 = pw2.posh[ndx2,idx2] / scale dR2 = pw2.dar[ndx2,idx2] / scale sepObs1 = np.hypot(dzObs1, dhObs1) sepObs2 = np.hypot(dzObs2, dhObs2) sepTrue1 = np.hypot(dzObs1, dhObs1) sepTrue2 = np.hypot(dzObs2 + dR2, dhObs2) # Figure out the highest strehl data sdx = np.where(strehl2 > 0.30)[0] sepTrueAvg = sepTrue2[sdx].mean() py.clf() py.subplots_adjust(left=0.15) # tick formatting yformatter = py.FormatStrFormatter('%5.1f') ax = py.gca() ax.yaxis.set_major_formatter(yformatter) # Plot pre-DAR corrected py.plot(parang2, sepObs2, 'r.') # Plot model DAR corrected rng = py.axis() py.plot([rng[0], rng[1]], [sepTrueAvg, sepTrueAvg], 'k-') # Plot post-DAR corrected py.plot(parang1, sepObs1, 'k.') py.title(src) py.xlabel('Parallactic Angle (deg)') py.ylabel('Distance from %s (pixels)' % (pw1.refSrc)) py.legend(('Pre-DAR', 'Model DAR', 'Post-DAR'), numpoints=3) py.savefig(outdir + 'plots/compare_dar_%s.eps' % src) py.savefig(outdir + 'plots/compare_dar_%s.png' % src)
def get_response(image, model, regions): model = numpy.loadtxt(model) mwave = model[:, 0] mspec = model[:, 1] model = interpolate.splrep(mwave, mspec, k=3, s=0) hdu = pyfits.open(image) if len(hdu) == 4: spec = hdu[1].data.copy() wave = st.wavelength(image, 1) else: spec = hdu[0].data.copy() wave = st.wavelength(image) outmodel = interpolate.splev(wave, model) ratio = outmodel / spec badregions = [] cond = ~numpy.isnan(ratio) cond = cond & (~numpy.isinf(ratio)) for lo, hi in regions: badregions.append([lo, hi]) cond = cond & (~((wave > lo) & (wave < hi))) scurrent = 2. * wave[cond].size**0.5 smod = ratio[cond].mean()**2 spmodel = interpolate.splrep(wave[cond], ratio[cond], k=3, s=scurrent * smod) resp = None while resp != 'q' and resp != 'Q': import pylab current = interpolate.splev(wave, spmodel) pylab.plot(wave, current) pylab.plot(wave, ratio) pylab.gca().fmt_xdata = pylab.FormatStrFormatter('%7.2f') pylab.show() resp = raw_input("Enter command (q, m, s, w, h): ") if resp == 'm': region = raw_input("Enter region to mask (eg, 6530,6580): ").split( ',') while len(region) != 2: region = raw_input( "Please input wavelengths joined by a comma: ").split(',') lo, hi = float(region[0]), float(region[1]) badregions.append([lo, hi]) cond = cond & (~((wave > lo) & (wave < hi))) spmodel = interpolate.splrep(wave[cond], ratio[cond], k=3, s=scurrent * smod) elif resp == 's': scurrent = float( raw_input( "Current smoothing factor is %4.2f, enter new smoothing factor: " % scurrent)) spmodel = interpolate.splrep(wave[cond], ratio[cond], k=3, s=scurrent * smod) elif resp == 'h': print "Use q to quit, m to mask, s to set smoothing scale, w to write model to disk" elif resp == 'w': import cPickle outname = raw_input("Name of file to write to: ") f = open(outname, 'wb') cPickle.dump(spmodel, f) f.close() print "Regions masked:", badregions return spmodel
def main(): "see __doc__" args = sys.argv[1:] fields = [] xtime = True xfmt = None sep = "," title = "" right_label = "" left_label = "" x_label = "" plot_file = "" dims = (8, 6) bkgds = [] x_min_max = [] y_min_max = [] do_legend = True backend = None use_xkcd = False verbose = False opts, args = getopt.getopt(args, "B:F:LT:X:Y:b:d:f:hl:p:r:s:vx:", [ "backend=", "format=", "skip_legend", "title=", "xkcd", "x_range=", "y_range=", "background=", "dimension=", "field=", "help", "left_label=", "plot_file=", "right_label=", "separator=", "verbose=", "x_label", ]) for opt, arg in opts: if opt in ("-B", "--backend"): backend = arg elif opt in ("-f", "--field"): if "'" in arg: quotechar = "'" else: quotechar = '"' plarg = io.StringIO(arg) plarg = next(csv.reader(plarg, quotechar=quotechar)) if len(plarg) == 2: # plot using left y axis by default plarg.append("l") if len(plarg) == 3: # plot using blue by default plarg.append("b") if len(plarg) == 4: # use the Y column name as the default legend name. plarg.append(plarg[1]) if len(plarg) == 5: # plot with '-' line style by default plarg.append("-") if len(plarg) == 6: # no marker by default plarg.append("") try: fields.append([int(x.strip()) for x in plarg[0:2]] + [plarg[2][0].lower()] + [plarg[3].lower()] + plarg[4:]) reader = csv.reader except ValueError: # Assume first two fields name column headers. fields.append(plarg[0:2] + [plarg[2][0].lower()] + [plarg[3].lower()] + plarg[4:]) reader = csv.DictReader elif opt in ("-b", "--background"): bg_spec = arg.split(",") try: bg_spec[0] = int(bg_spec[0]) bg_spec[1] = int(bg_spec[1]) reader = csv.reader except ValueError: bg_spec[0] = bg_spec[0].strip() bg_spec[1] = bg_spec[1].strip() reader = csv.DictReader if ":" in bg_spec[2]: low, high = [float(x) for x in bg_spec[2].split(":")] else: low = high = float(bg_spec[2]) bkgds.append((bg_spec[0], bg_spec[1], low, high, bg_spec[3])) elif opt in ("-F", "--format"): xtime = "%H" in arg or "%M" in arg or "%m" in arg or "%d" in arg xfmt = arg elif opt in ("-d", "--dimension"): dims = tuple([float(v.strip()) for v in re.split("[x,]", arg)]) elif opt in ("-L", "--skip_legend"): do_legend = False elif opt in ("-p", "--plot_file"): plot_file = arg elif opt in ("-l", "--left_label"): left_label = arg elif opt in ("-r", "--right_label"): right_label = arg elif opt in ("-x", "--x_label"): x_label = arg elif opt == "--xkcd": use_xkcd = True elif opt in ("-v", "--verbose"): verbose = True elif opt in ("-Y", "--y_range"): if "," in arg: left, right = arg.split(",") y_min_max = [[float(x) for x in left.split(":")], [float(x) for x in right.split(":")]] else: y_min_max = [[float(x) for x in arg.split(":")]] elif opt in ("-X", "--x_range"): # First try splitting at colon (assuming a pair of floats). If # that produces too many values, try a comma (assuming # timestamps). if len(arg.split(":")) == 2: x_min_max = [[float(x) for x in arg.split(":")]] else: min_dt, max_dt = arg.split(",") x_min = dateutil.parser.parse(min_dt) try: x_max = dateutil.parser.parse(max_dt) except dateutil.parser.ParserError: if max_dt == "today": x_max = datetime.datetime.now() elif max_dt == "yesterday": x_max = datetime.datetime.now() - datetime.timedelta( days=1) else: raise x_min_max = [x_min, x_max] elif opt in ("-s", "--separator"): sep = arg elif opt in ("-T", "--title"): title = arg elif opt in ("-h", "--help"): usage() raise SystemExit if backend is None: if not os.environ.get("DISPLAY"): # Allow non-interactive use (e.g. running with -p from cron) matplotlib.use("Agg") else: matplotlib.use(backend) if verbose: print("Using", matplotlib.get_backend(), file=sys.stderr) if use_xkcd: from matplotlib import pyplot try: pyplot.xkcd() except AttributeError: print("XKCD style not available.", file=sys.stderr) else: if verbose: print("Using XKCD style.", file=sys.stderr) if not fields: fields = [(0, 2, "l", "b", "2", "-", "")] reader = csv.reader min_y = 1e99 max_y = -1e99 if xtime: min_x = datetime.datetime(9999, 12, 31, 23, 59, 59) max_x = datetime.datetime(1970, 1, 1, 0, 0, 0) def parse_x(x_val): try: return dateutil.parser.parse(x_val) except ValueError: print(f"Can't parse {x_val!r} as a timestamp.", file=sys.stderr) raise def fmt_date(tick_val, _=None, xfmt=xfmt): date = matplotlib.dates.num2date(tick_val) if xfmt is None: # Calculate X format dynamically based on the visible # range. left, right = [ matplotlib.dates.num2date(x) for x in pylab.xlim() ] x_delta = right - left if x_delta > int(5 * 365) * ONE_DAY: xfmt = "%Y" elif x_delta > int(2 * 365) * ONE_DAY: xfmt = "%Y-%m" elif x_delta > int(1.5 * 365) * ONE_DAY: xfmt = "%Y-%m-%d" elif x_delta > 2 * ONE_DAY: xfmt = "%m/%d\n%H:%M" elif x_delta < 10 * ONE_MINUTE: xfmt = "%H:%M\n%S.%f" elif x_delta < 2 * ONE_HOUR: xfmt = "%H:%M:%S" else: xfmt = "%H:%M" return date.strftime(xfmt) formatter = matplotlib.ticker.FuncFormatter(fmt_date) else: min_x = 1e99 max_x = -1e99 def parse_x(x_val): return float(x_val) def fmt_float(x_val, _=None): return xfmt % x_val formatter = matplotlib.ticker.FuncFormatter(fmt_float) if reader == csv.DictReader: fieldnames = next(csv.reader(sys.stdin, delimiter=sep)) rdr = reader(sys.stdin, fieldnames=fieldnames, delimiter=sep) else: rdr = reader(sys.stdin, delimiter=sep) raw = list(rdr) left = [] right = [] lt_y_range = [min_y, max_y] rt_y_range = [min_y, max_y] x_range = [min_x, max_x] for (col1, col2, side, color, legend, style, marker) in fields: if "/" in style: style, width = style.split("/", 1) width = float(width) else: width = 1.0 if "/" in marker: marker, m_scale = marker.split("/", 1) m_scale = float(m_scale) else: m_scale = 1.0 if marker == ";": marker = "," data = ([], color, legend, (style, width), (marker, m_scale)) if side == "l": left.append(data) y_range = lt_y_range else: right.append(data) y_range = rt_y_range for values in raw: try: _, _ = (values[col1], values[col2]) except IndexError: # Rows don't need to be completely filled. continue x_val = values[col1] y_val = values[col2] if x_val and y_val: try: x_val = parse_x(x_val) except ValueError as err: print(err, values, file=sys.stderr) raise y_val = float(values[col2]) # If we get inputs with timezone info, convert. This # is likely only to be executed once, as if one # timestamp has tzinfo, all are likely to. if xtime and x_range[0].tzinfo != x_val.tzinfo: zone = x_val.tzinfo x_range = [dt.replace(tzinfo=zone) for dt in x_range] y_range[:] = [min(y_range[0], y_val), max(y_range[1], y_val)] data[0].append((x_val, y_val)) if data[0]: x_range = [ min([x for (x, _y) in data[0]] + [x_range[0]]), max([x for (x, _y) in data[0]] + [x_range[1]]) ] else: print("No data for x range!", file=sys.stderr) if (sum([len(x) for x in left]) == 0 and sum([len(x) for x in right]) == 0): print("No points to plot!", file=sys.stderr) return 1 figure = pylab.figure(figsize=dims) if xtime: figure.autofmt_xdate() left_plot = figure.add_subplot(111) left_plot.set_title(title) left_plot.set_axisbelow(True) left_plot.yaxis.set_major_formatter(pylab.FormatStrFormatter('%g')) left_plot.xaxis.set_major_formatter(formatter) # Use a light, but solid, grid for the X axis and the left Y # axis. No grid for right Y axis. left_plot.xaxis.grid(True, linestyle='solid', which='major', color='lightgrey', alpha=0.5) left_plot.yaxis.grid(True, linestyle='solid', which='major', color='lightgrey', alpha=0.5) lines = [] if left: if left_label: left_plot.set_ylabel(left_label, color=left[0][1]) if x_label: left_plot.set_xlabel(x_label, color=left[0][1]) for data in left: points, color, legend, style, marker = data lines.extend( left_plot.plot([x for x, y in points], [y for x, y in points], color=color, linestyle=style[0], linewidth=style[1], label=legend, marker=marker[0], markersize=marker[1])) for tick_label in left_plot.get_yticklabels(): tick_label.set_color(left[0][1]) extra = 0.02 * (lt_y_range[1] - lt_y_range[0]) lt_y_range = [lt_y_range[0] - extra, lt_y_range[1] + extra] if y_min_max: left_plot.set_ylim(y_min_max[0]) else: left_plot.set_ylim(lt_y_range) if right: right_plot = left_plot.twinx() right_plot.set_axisbelow(True) right_plot.yaxis.set_major_formatter(pylab.FormatStrFormatter('%g')) right_plot.xaxis.set_major_formatter(formatter) if right_label: right_plot.set_ylabel(right_label, color=right[0][1]) if x_label and not left: right_plot.set_xlabel(x_label, color=left[0][1]) for data in right: points, color, legend, style, marker = data lines.extend( right_plot.plot([x for x, y in points], [y for x, y in points], color=color, linestyle=style[0], linewidth=style[1], label=legend, marker=marker[0], markersize=marker[1])) for tick_label in right_plot.get_yticklabels(): tick_label.set_color(right[0][1]) extra = 0.02 * (rt_y_range[1] - rt_y_range[0]) rt_y_range = [rt_y_range[0] - extra, rt_y_range[1] + extra] if len(y_min_max) == 2: right_plot.set_ylim(y_min_max[1]) else: right_plot.set_ylim(rt_y_range) color_bkgd(bkgds, left and left_plot or right_plot, left and lt_y_range or rt_y_range, raw, parse_x) if x_min_max: left_plot.set_xlim(x_min_max[0]) else: extra = (x_range[1] - x_range[0]) * 2 // 100 try: x_range = [x_range[0] - extra, x_range[1] + extra] except OverflowError: print("overflow:", x_range, extra, file=sys.stderr) raise left_plot.set_xlim(x_range) if do_legend: labels = [line.get_label() for line in lines] if right: right_plot.legend(lines, labels, loc='best').set_draggable(True) else: left_plot.legend(lines, labels, loc='best').set_draggable(True) figure.tight_layout() if plot_file: pylab.savefig(plot_file) else: pylab.show() return 0
adts_fnpData[:, 3], c='green', label=r'ADTS along $\pm$x') #pylab.plot(adts_fnpData[-1,2],adts_fnpData[-1,3],'o',c='green') #pylab.plot(cross_adts_fnpData[:,2],cross_adts_fnpData[:,3]) #-------------------------------------------- #Plot horizontal data, then plot vertical data #-------------------------------------------- #fig = pylab.figure(figsize=(10,10),dpi=125) fig = pylab.figure(figsize=(6, 6), dpi=125) pylab.subplots_adjust(left=0.15, right=0.95, top=0.9, bottom=0.1) ax = fig.add_subplot(111) ax.yaxis.set_major_formatter(pylab.FormatStrFormatter('%.2f')) ax.xaxis.set_major_formatter(pylab.FormatStrFormatter('%.2f')) pylab.gca().set_autoscale_on(False) #pylab.xlabel(r'Q$_\mathrm{x}$') #pylab.ylabel(r'Q$_\mathrm{y}$') pylab.xlabel(r'$\mathregular{Q_x}$') pylab.ylabel(r'$\mathregular{Q_y}$') sloppymidQx = fnpData[int(len(fnpData[:, 1]) / 2), 1] sloppymidQy = fnpData[int(len(fnpData[:, 1]) / 2), 2] (Qxmin, Qxmax, Qymin, Qymax) = analytic_tune_plane.make_min_max(sloppymidQx, sloppymidQy) # CANDLE #Qxmin = 24.45
def __init__(self, file): f = pyfits.open(file) self.filename = file """ Test to see if data are in MWA format (ie ext0=meta, ext1=sci, ext2=smooth, ext3=var). If not, set smooth and variance data to science data. """ self.ismwa = True try: self.position = f[0].header['center'] except: self.ismwa = False if self.ismwa: self.pos = self.position self.width = f[0].header['width'] self.rawdata = f[1].data.astype(scipy.float64) self.current = f[2].data.astype(scipy.float64) self.varspec = f[3].data.astype(scipy.float64) f.close() self.wave = wavelength(file, 1) else: self.rawdata = f[0].data.astype(scipy.float64) self.current = f[0].data.astype(scipy.float64) self.varspec = f[0].data.astype(scipy.float64) f.close() self.wave = wavelength(file) self.rawdata = self.rawdata.reshape(self.rawdata.size) self.current = self.current.reshape(self.current.size) self.varspec = self.varspec.reshape(self.varspec.size) """ Trim bad edges. """ tmp = scipy.where((self.rawdata != 0) & ~scipy.isnan(self.rawdata))[0] left = tmp.min() right = tmp.max() + 1 self.current = self.current[left:right] self.varspec = self.varspec[left:right] self.wave = self.wave[left:right] self.rawdata = self.rawdata[left:right] """ Linelist for galaxies. """ self.linelist = [ 2344, 2374, 2383, 2587, 2599.4, 2750.3, 2795., 2802.7, 2852, 3726.03, 3728.82, 3835.38, 3889.05, 3933.66, 3968.47, 4101.74, 4305., 4340.47, 4861.33, 4962., 5007., 5177., 5270., 5328., 5341., 5371.5, 5891.9, 6562.8, 6583.5, 6716.4, 6730.8, 8498., 8542., 8662. ] self.linename = [ 'Fe', '', 'Fe', 'Fe', '', 'FeII', '', 'MgII', 'MgI', "[OII]", "", 'Heta', '', 'CaK', 'CaH', 'H-delta', 'Gband', 'H-gamma', 'H-beta', 'OIII', 'OIII', 'Mgb', 'Fe', 'Fe', '', 'Fe', 'NaII', 'H-alpha', 'N', 'S', '', 'CaT', 'CaT', 'CaT' ] """ Linelist for high-z quasars. """ self.qso = False self.qsolist = [ 1215.24, 1239.4, 1305.53, 1335.52, 1397.61, 1399.8, 1545.86, 1637.85, 1665.85, 1857.4, 1908.27, 2326.0, 2439.5, 2800.32 ] self.qsoname = [ 'Lya', 'Nv', 'Oi', 'Cii', 'SiIV', 'Oiv', 'Civ', 'HeII', 'Oiii', 'AlIII', 'Ciii', 'Cii', 'NeIV', 'MgII' ] self.collect = [] # Stores ID'd lines self.skyid = None self.snid = None self.z = 0. self.axes = None self.redraw() self.axes.fmt_xdata = pylab.FormatStrFormatter("%4.2f")
def linkAnnotationFinders(afs): for i in range(len(afs)): allButSelfAfs = afs[:i] + afs[i + 1:] afs[i].links.extend(allButSelfAfs) #-------------------------------------------- #Plot horizontal data, then plot vertical data #-------------------------------------------- fig = pylab.figure(figsize=(32, 14.22), dpi=75) pylab.subplots_adjust(left=0.05, right=1.00, top=0.9, bottom=0.1) #make Qx-Qy plot ax_QxQy = fig.add_subplot(121) ax_QxQy.yaxis.set_major_formatter(pylab.FormatStrFormatter('%.3f')) Annotes = numpy.chararray(len(Qx), itemsize=8) for i in range(len(Qx)): Annotes[i] = str(i) pylab.scatter(Qx, Qy, marker='o', c=metric, s=10, edgecolors='none', cmap='jet') af1 = AnnoteFinder(Qx, Qy, Annotes, xtol=0.0005, ytol=0.0005, axis=ax_QxQy) pylab.connect('button_press_event', af1) pylab.xlabel('Qx')
def plot(opts): """ Plot data """ print "Generating plots" nbeams = opts.nbeams nchans = opts.nchans f = open(args[0], 'rb') data = f.read() data = np.array(struct.unpack('f' * (len(data) / 4), data), dtype=float) nsamp = len(data) / (nbeams * nchans) data = np.reshape(data, (nsamp, nchans, nbeams)) time = np.arange(0, opts.tsamp * data.shape[0], opts.tsamp) frequency = (np.arange(opts.fch1 * 1e6, opts.fch1 * 1e6 + opts.foff * (data.shape[1]), opts.foff)) * 1e-6 formatter = pylab.FormatStrFormatter('%2.3f') # Process only one beam if opts.beam != -1: fig = plt.figure(figsize=(8, 8)) ax = fig.add_subplot(1, 2, 1) ax.set_title("Beam %d" % opts.beam) ax.imshow(np.log10(data[:, :, opts.beam]), aspect='auto', origin='lower', extent=[frequency[0], frequency[-1], 0, time[-1]]) ax.xaxis.set_major_formatter(formatter) ax.set_xlabel("Channel (kHz)") ax.set_ylabel("Time (s)") ax = fig.add_subplot(2, 2, 2) toplot = np.log10(np.sum(data[:, :, opts.beam], axis=0)) ax.plot(frequency[:len(toplot)], toplot) ax.xaxis.set_major_formatter(formatter) ax.set_xlabel("Channel (MHz)") ax.set_ylabel("Log Power (Arbitrary)") ax.set_xlim((frequency[0], frequency[-1])) ax = fig.add_subplot(2, 2, 4) toplot = np.sum(data[:, :, opts.beam] / nchans, axis=1) ax.plot(time[:len(toplot)], toplot) ax.xaxis.set_major_formatter(pylab.FormatStrFormatter('%2.1f')) ax.set_xlabel("Time (s)") ax.set_ylabel("Power (Arbitrary)") ax.set_xlim((time[0], time[-1])) fig.tight_layout() plt.show() f.close() return # Plot each beam separately fig = plt.figure(figsize=(8, 8)) num_rows = math.ceil(math.sqrt(nbeams)) for i in range(nbeams): ax = fig.add_subplot(num_rows, num_rows, i + 1) ax.set_title("Beam %d" % i) # Show beam if opts.waterfall: ax.imshow(np.log10(data[:, :, i]), aspect='auto', origin='lower', extent=[frequency[0], frequency[-1], 0, time[-1]]) ax.xaxis.set_major_formatter(pylab.FormatStrFormatter('%2.2f')) ax.set_xlabel("Channel (kHz)") ax.set_ylabel("Time (s)") # Plot bandpass if opts.bandpass: ax.plot(frequency, np.log10(np.sum(data[:, :, i], axis=0))) ax.xaxis.set_major_formatter(pylab.FormatStrFormatter('%2.2f')) ax.set_xlabel("Channel (MHz)") ax.set_ylabel("Log Power (Arbitrary)") ax.set_xlim((frequency[0], frequency[-1])) # Plot time series if opts.time: ax.plot(time, np.sum(data[:, :, i] / nchans, axis=1)) ax.xaxis.set_major_formatter(pylab.FormatStrFormatter('%2.1f')) ax.set_xlabel("Time (s)") ax.set_ylabel("Power (Arbitrary)") ax.set_xlim((time[0], time[-1])) fig.tight_layout() plt.show() f.close()