def heatmap(self): [dates,watts] = self.building.data clipMax = scipy.stats.scoreatpercentile(watts,per=95)/1000 clipMin = scipy.stats.scoreatpercentile(watts,per=0)/1000 #watts[watts > clipMax] = clipMax [datesA,wattsA] = self.building.dailyData (m,n) = wattsA.shape fig = Figure(figsize=(10,6),facecolor='white',edgecolor='none') ax = fig.add_subplot(111) #print 'shapes:',m,n #print cm.coolwarm p = ax.imshow(wattsA/1000, interpolation='nearest', aspect='auto', cmap=cm.coolwarm, extent=[0,n*20*2,0,m*2]) p.cmap.set_over('grey') cbar = fig.colorbar(p,ax=ax,shrink=0.8) cbar.set_label('kW') p.set_clim(clipMin, clipMax) ax.set_xticks(range(0,n*40+1,n*40/24*2)) ax.set_xticklabels(['%iam' % x for x in [12]+range(2,12,2)] + ['%ipm' % x for x in [12] + range(2,12,2)] + ['12am']) # rotate lables for l in ax.xaxis.get_majorticklabels(): l.set_rotation(70) ax.set_yticks(range(1,m*2+1,30*2)) ax.format_ydata = mpld.DateFormatter('%m/%d') ax.set_yticklabels([x.strftime('%m/%d/%y') for x in datesA[-1:1:-30,0]]) #fig.autofmt_ydate() ax.tick_params(axis='both', which='major', labelsize=8) ax.set_title('Heat map of %s data for %s' % ('electricity','uploaded data')) ax.set_xlabel('Hour of day') ax.set_ylabel('Date') ax.grid(True) fig.subplots_adjust(top=1.0, left=0.20) return fig
def create_input_graph(self, parent, sizer): """ Creates a graph that plots the input It returns a timer what starts the plotting """ graph_panel = wx.Panel(parent, size=(320,0)) self.input_data_generator = DataGen(self) self.data_input = [] dpi = 160 fig = Figure((2.0, 1.0), dpi=dpi) self.axes_input = fig.add_subplot(111) fig.add_subplot() fig.subplots_adjust(bottom=0.009,left=0.003,right=0.997, top=0.991) self.axes_input.set_axis_bgcolor('black') pylab.setp(self.axes_input.get_xticklabels(), fontsize=4) pylab.setp(self.axes_input.get_yticklabels(), fontsize=4) self.plot_data_input = self.axes_input.plot(self.data_input, linewidth=1, color=(1, 0, 0), )[0] self.axes_input.grid(True, color='gray') self.canvas_input = FigCanvas(graph_panel, -1, fig) vbox = wx.BoxSizer(wx.VERTICAL) vbox.Add(self.canvas_input, 0) graph_panel.SetSizer(vbox) sizer.Add(graph_panel, 0, wx.TOP | wx.BOTTOM, 5) self.axes_input.set_xbound(lower=0, upper=100) self.axes_input.set_ybound(lower=-1.0, upper=1.0) redraw_timer_input = MyThread(self.graph_refresh_time, self.on_redraw_graph, self) #wx.Timer(self) return redraw_timer_input
def prepare_configure_subplots(self): toolfig = Figure(figsize=(6, 3)) canvas = FigureCanvasMac(toolfig) toolfig.subplots_adjust(top=0.9) # Need to keep a reference to the tool. _tool = SubplotTool(self.canvas.figure, toolfig) return canvas
def plotgraph(window): global df2, indexes, f, a, b f = Figure() plot_df = df2.ix[indexes] plot_df = plot_df.set_index('Particulars') if graph == 1: a = f.add_subplot(211) b = f.add_subplot(212) a.clear() b.clear() plot_df1 = plot_df.T plot_df1.plot(ax=a, title='% Change of Particulars in Income Statement as Trends') plot_df1.plot(ax=b, kind='barh', title='% Change of Particulars in Income Statement as Bars') f.subplots_adjust(left=0.2,bottom=0.2,hspace=0.5) elif graph == 2: a = f.add_subplot(111) a.clear() plot_df.plot(ax=a, kind='barh', title='% Change of Particulars in Income Statement as Bars') f.subplots_adjust(left=0.2,bottom=0.2,hspace=0.5) canvas = FigureCanvasTkAgg(f, window) canvas.show() canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True) toolbar = NavigationToolbar2TkAgg(canvas, window) toolbar.update() canvas._tkcanvas.pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True)
def create_output_graph(self, parent, sizer): """ Creates a graph that plots the output """ graph_panel = wx.Panel(parent, size=(320,0)) self.data_output = [] dpi = 160 fig = Figure((2.0, 1.0), dpi=dpi) self.axes_output = fig.add_subplot(111) fig.add_subplot() fig.subplots_adjust(bottom=0.009,left=0.003,right=0.997, top=0.991) self.axes_output.set_axis_bgcolor('black') pylab.setp(self.axes_output.get_xticklabels(), fontsize=4) pylab.setp(self.axes_output.get_yticklabels(), fontsize=4) self.plot_data_output = self.axes_output.plot(self.data_output, linewidth=1, color=(0, 0, 1), )[0] self.axes_output.grid(True, color='gray') self.canvas_output = FigCanvas(graph_panel, -1, fig) vbox = wx.BoxSizer(wx.VERTICAL) vbox.Add(self.canvas_output, 0) graph_panel.SetSizer(vbox) sizer.Add(graph_panel, 0, wx.TOP | wx.BOTTOM, 5) self.axes_output.set_xbound(lower=0, upper=100) self.axes_output.set_ybound(lower=-1.0, upper=1.0)
class PlotPanel (wx.PyPanel): """The PlotPanel has a Figure and a Canvas. OnSize events simply set a flag, and the actual resizing of the figure is triggered by an Idle event.""" def __init__( self, parent, color=None, dpi=None, **kwargs ): from matplotlib.backends.backend_wxagg import (FigureCanvasWxAgg, NavigationToolbar2WxAgg) from matplotlib.figure import Figure # initialize Panel if 'id' not in kwargs.keys(): kwargs['id'] = wx.ID_ANY if 'style' not in kwargs.keys(): kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE wx.Panel.__init__( self, parent, **kwargs ) self.parent = parent # initialize matplotlib stuff self.figure = Figure( None, dpi ) self.canvas = FigureCanvasWxAgg( self, -1, self.figure ) self.ax = self.figure.add_subplot(111) self.figure.subplots_adjust(hspace=0.8) self.toolbar = NavigationToolbar2WxAgg(self.canvas) vSizer = wx.BoxSizer(wx.VERTICAL) vSizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW) vSizer.Add(self.toolbar, 0, wx.EXPAND) self.draw() self.SetAutoLayout(True) self.SetSizer(vSizer) self.Layout() def draw(self): pass # abstract, to be overridden by child classes
def template_plotter(x_axis_label, y_axis_label,x_axes=[],x_ticks=[],title, outfile_name): fig = Figure(linewidth=0.0) fig.set_size_inches(fig_width,fig_length, forward=True) Figure.subplots_adjust(fig, left = fig_left, right = fig_right, bottom = fig_bottom, top = fig_top, hspace = fig_hspace) _subplot = fig.add_subplot(1,1,1) _subplot.boxplot(x_axis,notch=0,sym='+',vert=1, whis=1.5) #_subplot.plot(x,y,color='b', linestyle='--', marker='o' ,label='labels') a =[i for i in range(1,len(x_ticks)+1)] _subplot.set_xticklabels(x_ticks) _subplot.set_xticks(a) labels=_subplot.get_xticklabels() for label in labels: label.set_rotation(30) _subplot.set_ylabel(y_axis_label,fontsize=36) _subplot.set_xlabel(x_axis_label) #_subplot.set_ylim() #_subplot.set_xlim() _subplot.set_title(title) _subplot.legend(loc='upper left',prop=LEGEND_PROP ,bbox_to_anchor=(0.5, -0.05)) canvas = FigureCanvasAgg(fig) if '.eps' in outfile_name: canvas.print_eps(outfile_name, dpi = 110) if '.png' in outfile_name: canvas.print_figure(outfile_name, dpi = 110) outfile_name='EpsilonvsMTU.pdf' if '.pdf' in outfile_name: canvas.print_figure(outfile_name, dpi = 110)
def processOne(fn,done,gpus,telescope,outdir,plotdir,redo=False): print fn info = decodeFilename(fn) print info pklname = ('ds_%s_%s_%s_%s.pkl' % (info['source'],info['mjd'], info['scan'],telescope)) outfn = os.path.join(outdir,'pkls',pklname) if (not redo) and (outfn in done): return fn,None,pklname try: #if True: ds = loadDynSpecFromCycSpecScan(int(info['scan']), int(info['mjd']), gpus=gpus, telescope=telescope) print "loaded dynspec" dynspec.pickle(outfn, ds) print "pickled",outfn fig = Figure(figsize=(10,12)) fig.subplots_adjust(left=0.09,bottom=0.05,top=0.95,right=0.95) ds.plot(fig=fig) plotname = os.path.join(plotdir,pklname + '.png') esc_fname = outfn.replace('_',r'\_') fig.suptitle(('%s @ %s %s' % (info['source'],telescope,esc_fname)),size='medium') canvas = FigureCanvasAgg(fig) canvas.print_figure(plotname) except Exception,e: print fn,e,pklname return fn,e,pklname
def _diffHist(pixels, mean, clippedMedian, sigma, upperKey, lowerKey, plotPath): fig = Figure(figsize=(6, 6)) canvas = FigureCanvas(fig) fig.subplots_adjust(left=0.15, bottom=0.13, wspace=0.25, hspace=0.25, right=0.95) ax = fig.add_subplot(111) nPixels = len(pixels) # Plot histogram nCounts, bins, patches = ax.hist(pixels, bins=int(nPixels / 1000), histtype='stepfilled', fc='0.5', log=True, normed=True) # Plot estimates of the image difference ax.axvline(mean, ls="-", c='k', label="mean") ax.axvline(clippedMedian, ls='--', c='k', label="clipped median") # ax.axvline(fittedMean, ls='--', c='r', label="fitted mean") ax.legend() ax.text(0.05, 0.95, r"Clipped $\Delta= %.2e \pm %.2e$" % (clippedMedian, sigma), ha="left", va="top", transform=ax.transAxes) ax.set_xlabel("Image Difference (counts)") upperKey = upperKey.replace("_", "\_") lowerKey = lowerKey.replace("_", "\_") ax.set_title("%s - %s" % (upperKey, lowerKey)) canvas.print_figure(plotPath)
def plot_vo(tri, colors=None): import matplotlib as mpl from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure fig = Figure(figsize=(4,4)) canvas = FigureCanvas(fig) fig.subplots_adjust(left=0.15, bottom=0.13,wspace=0.25, right=0.95) ax = fig.add_subplot(111, aspect='equal') if colors is None: colors = [(0,1,0,0.2)] #lc = mpl.collections.LineCollection(numpy.array( # [(tri.circumcenters[i], tri.circumcenters[j]) # for i in xrange(len(tri.circumcenters)) # for j in tri.triangle_neighbors[i] if j != -1]), # colors=colors) lines = [(tri.circumcenters[i], tri.circumcenters[j]) for i in xrange(len(tri.circumcenters)) for j in tri.triangle_neighbors[i] if j != -1] lines = numpy.array(lines) lc = mpl.collections.LineCollection(lines, colors=colors) # ax = pl.gca() ax.add_collection(lc) # pl.draw() # pl.savefig("voronoi") ax.plot(tri.x, tri.y, '.k') ax.set_xlim(-50,550) ax.set_ylim(-50,550) canvas.print_figure("voronoi", dpi=300.)
def __init__(self, parent=None, width=5, height=4, dpi=100): fig = Figure(figsize=(width, height), dpi=dpi) self.axes = fig.add_subplot(111) self.axes.hold(False) super(GraphWidget, self).__init__(fig) self.setParent(parent) fig.subplots_adjust(bottom=0.2) FigureCanvas.setSizePolicy(self, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) FigureCanvas.updateGeometry(self) self.below_absolute_value = 0.0 self.below_absolute_enabled = False self.above_absolute_value = 0.0 self.above_absolute_enabled = False self.delayed_plot_timer = QtCore.QTimer() self.delayed_plot_timer.setSingleShot(True) self.delayed_plot_timer.timeout.connect(self.plot) self.readPlotData() self.plot()
def plot_alpha_parameters(pdict, outinfo): from matplotlib.figure import Figure from matplotlib.backends.backend_agg import FigureCanvasAgg as FigCanvas pars = [] parlist, div_idxs = _sort_alpha(pdict) # in some fits we don't include systematics, don't draw anything if not parlist: return xlab, xpos, ypos, yerr = _get_lab_x_y_err(parlist) fig = Figure(figsize=(8, 4)) fig.subplots_adjust(bottom=0.2) canvas = FigCanvas(fig) ax = fig.add_subplot(1,1,1) ax.set_xlim(0, len(xlab)) ax.set_ylim(-2.5, 2.5) ax.errorbar( xpos, ypos, yerr=yerr, **_eb_style) ax.axhline(0, **_hline_style) for hline in div_idxs: ax.axvline(hline, **_hline_style) ax.set_xticks(xpos) ax.set_xticklabels(xlab) ax.tick_params(labelsize=_txt_size) for lab in ax.get_xticklabels(): lab.set_rotation(60 if len(xlab) < 10 else 90) outdir = outinfo['outdir'] fig.tight_layout(pad=0.3, h_pad=0.3, w_pad=0.3) canvas.print_figure( join(outdir, 'alpha' + outinfo['ext']), bboxinches='tight')
def plot_loads_devs(response, start, alldata, allmeans, meandates, maxload, notesets): fig = Figure(figsize=(12,8), dpi=72) rect = fig.patch rect.set_facecolor('white') canvas = FigureCanvas(fig) ax = fig.add_subplot(111) colorlist = ['b', 'g', 'r', 'y', 'c'] plts = [] labels = [] colorlist_count = 0 for dev in alldata.keys(): labels.append(dev) plt = ax.plot(alldata[dev]['dates'], alldata[dev]['loads'], colorlist[colorlist_count] + 'x')[0] plts.append(plt) colorlist_count += 1 ax.plot(meandates, allmeans, 'ks') for i in range(len(meandates)): outstr = "%.03f ug/cm^2\n" % (allmeans[i]) for j in notesets[i]: outstr += j + "\n" ax.text(meandates[i], allmeans[i], outstr) ax.set_ylabel('$ug/cm^2$') ax.set_xlabel('Image Record Time (from EXIF)') ax.set_title("%s" % (str(start))) fig.autofmt_xdate() ax.legend(plts, labels, numpoints=1, loc='lower right') fig.subplots_adjust(left=0.07, bottom=0.10, right=0.91, \ top=0.95, wspace=0.20, hspace=0.00) canvas.print_png(response)
def On_Double(self, event): """Finds best fit with selection and returns a pyplot graph.""" widget = event.widget selection = widget.curselection() choice = widget.get(selection[0]) base_data = pd.read_csv(PATH+choice+'.csv', index_col='Year') base_index = base_data.columns[0] best_fit, r2 = find_best_correlation(data_frame, base_index) fig = Figure(figsize=(6, 4), dpi=100) #Axis of original data set ax1 = fig.add_subplot(111) ax1.plot(data_frame.index, data_frame[base_index], color='r') ax1.set_ylabel(base_index) ax1.annotate(r'$ r ^ 2$ = %s' % r2, xy=(0.05, 0.9),\ xycoords='axes fraction', size='large') #Axis of best fit ax2 = ax1.twinx() ax2.plot(data_frame.index, data_frame[best_fit], color='k') ax2.set_ylabel(best_fit) fig.subplots_adjust(left=0.2, top=0.85, right=0.8, bottom=0.15) canvas = FigureCanvasTkAgg(fig, self) canvas.show() canvas.get_tk_widget().grid(row=1, column=2, ipady=10, ipadx=10)
class MplCanvas(FigureCanvas): def __init__(self, figsize=(8, 6), dpi=80): self.fig = Figure(figsize=figsize, dpi=dpi) self.fig.subplots_adjust(wspace=0, hspace=0, left=0, right=1.0, top=1.0, bottom=0) self.ax = self.fig.add_subplot(111, frameon=False) self.ax.patch.set_visible(False) self.ax.set_axis_off() FigureCanvas.__init__(self, self.fig) FigureCanvas.setSizePolicy(self, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) FigureCanvas.updateGeometry(self) #self.setAlpha(0.0) def saveFig(self, str_io_buf): self.setAlpha(0.0) self.fig.savefig(str_io_buf, transparent=True, frameon=False, format='png') # 140818 Save file to StringIO Buffer not disk file def getFig(self): return self.fig def setAlpha(self, value): self.fig.patch.set_alpha(value) self.ax.patch.set_alpha(value) self.ax.set_axis_off() def set_face_color(self, color): self.fig.set_facecolor(color) # "#000000"
def init_window(self): if self.window: return self.window = Gtk.Window(title="Subplot Configuration Tool") try: self.window.window.set_icon_from_file(window_icon) except Exception: # we presumably already logged a message on the # failure of the main plot, don't keep reporting pass self.vbox = Gtk.Box() self.vbox.set_property("orientation", Gtk.Orientation.VERTICAL) self.window.add(self.vbox) self.vbox.show() self.window.connect('destroy', self.destroy) toolfig = Figure(figsize=(6, 3)) canvas = self.figure.canvas.__class__(toolfig) toolfig.subplots_adjust(top=0.9) SubplotTool(self.figure, toolfig) w = int(toolfig.bbox.width) h = int(toolfig.bbox.height) self.window.set_default_size(w, h) canvas.show() self.vbox.pack_start(canvas, True, True, 0) self.window.show()
class MapPlot(QtGui.QWidget): """ """ def __init__(self, parent, uielement): super(MapPlot, self).__init__() self.parent = parent self.img = None #Set dpi via preference self.fig = Figure(dpi=72) self.ax = self.fig.add_subplot(111) self.fig.subplots_adjust(wspace=0.01, hspace=0.01) self.ax.grid() self.ax.set_xticks([]) self.ax.set_yticks([]) self.canvas = FigureCanvas(self.fig) combo = QtGui.QComboBox(self) [combo.addItem(m) for m in matplotlib.cm.datad] combo.activated[str].connect(self.recolor) ntb = NavigationToolbar(self.canvas, self) ntb.addWidget(combo) uielement.addWidget(self.canvas, 1) # Expanding uielement.addWidget(ntb) def recolor(self, cbar): self.img.set_cmap(cbar) self.canvas.draw()
def bar_plot(d, labels): colors = itertools.cycle(['b', 'g', 'r', 'c', 'm', 'y', 'k']) fig=Figure(figsize=(8, 6), dpi=200) fig.set_facecolor('white') fig.subplots_adjust(bottom=0.30) ax=fig.add_subplot(111) ax.set_title("") ax.set_ylabel('Factor values') #ax.grid(which='major') bottom = None for col in d.columns: if bottom is None: bottom = 0*d[col] ax.bar(range(len(d[col])), d[col], align='center', bottom=bottom, label=labels[col], color=colors.next(), alpha=0.6) bottom += d[col] ax.set_xticks(range(len(d[col]))) ax.set_xlim([-0.5, len(d[col])]) ax.set_xticklabels([unicode(el) for el in d[col].index], size='x-small', rotation='vertical') leg = ax.legend(loc='best', fancybox=True, prop={'size':9}) leg.get_frame().set_alpha(0.5) canvas=FigureCanvas(fig) stream=cStringIO.StringIO() canvas.print_png(stream, bbox_inches='tight') return stream.getvalue()
class Canvas(FigureCanvas): def __init__(self,parent,dpi=100.0): size = parent.size() self.dpi = dpi self.width = size.width() / dpi self.height = size.height() / dpi self.figure = Figure(figsize=(self.width, self.height), dpi=self.dpi, facecolor='w', edgecolor='k', frameon=False) self.figure.subplots_adjust(left=0.05, bottom=0.05, right=0.95, top=0.95, wspace=None, hspace=None) self.axes = self.figure.add_subplot(111) self.axes.axis((-1,1,-1,1)) FigureCanvas.__init__(self, self.figure) self.updateGeometry() self.draw() self.cc = self.copy_from_bbox(self.axes.bbox) self.particle_plot = None self.setParent(parent) self.blit(self.axes.bbox) def on_pre_draw(self): self.restore_region(self.cc) def on_draw(self): raise NotImplementedError def on_post_draw(self): self.blit(self.axes.bbox) def redraw(self): self.on_pre_draw() self.on_draw() self.on_post_draw()
class DevPlot(Plot): def __init__(self,k1={'intel_snb' : ['intel_snb','intel_snb','intel_snb']},k2={'intel_snb':['LOAD_1D_ALL','INSTRUCTIONS_RETIRED','LOAD_OPS_ALL']},processes=1,**kwargs): self.k1 = k1 self.k2 = k2 super(DevPlot,self).__init__(processes=processes,**kwargs) def plot(self,jobid,job_data=None): self.setup(jobid,job_data=job_data) cpu_name = self.ts.pmc_type type_name=self.k1[cpu_name][0] events = self.k2[cpu_name] ts=self.ts n_events = len(events) self.fig = Figure(figsize=(8,n_events*2+3),dpi=110) do_rate = True scale = 1.0 if type_name == 'mem': do_rate = False scale=2.0**10 if type_name == 'cpu': scale=ts.wayness*100.0 for i in range(n_events): self.ax = self.fig.add_subplot(n_events,1,i+1) self.plot_lines(self.ax, [i], 3600., yscale=scale, do_rate = do_rate) self.ax.set_ylabel(events[i],size='small') self.ax.set_xlabel("Time (hr)") self.fig.subplots_adjust(hspace=0.5) #self.fig.tight_layout() self.output('devices')
def __init__(self, ticker): gtk.VBox.__init__(self) startdate = datetime.date(2001, 1, 1) today = enddate = datetime.date.today() date1 = datetime.date(2011, 1, 1) date2 = datetime.date.today() mondays = WeekdayLocator(MONDAY) # major ticks on the mondays alldays = DayLocator() # minor ticks on the days weekFormatter = DateFormatter("%b %d") # Eg, Jan 12 dayFormatter = DateFormatter("%d") # Eg, 12 quotes = quotes_historical_yahoo(ticker, date1, date2) if len(quotes) == 0: raise SystemExit fig = Figure(facecolor="white", figsize=(5, 4), dpi=100) fig.subplots_adjust(bottom=0.2) ax = fig.add_subplot(111) ax.xaxis.set_major_locator(mondays) ax.xaxis.set_minor_locator(alldays) ax.xaxis.set_major_formatter(weekFormatter) candlestick(ax, quotes, width=0.6) ax.xaxis_date() ax.autoscale_view() pylab.setp(pylab.gca().get_xticklabels(), rotation=45, horizontalalignment="right") canvas = FigureCanvas(fig) # a gtk.DrawingArea self.pack_start(canvas) toolbar = NavigationToolbar(canvas, win) self.pack_start(toolbar, False, False)
def save_plotSpectrum(y,Fs,image_name): """ Plots a Single-Sided Amplitude Spectrum of y(t) """ fig = Figure(linewidth=0.0) fig.set_size_inches(fig_width,fig_length, forward=True) Figure.subplots_adjust(fig, left = fig_left, right = fig_right, bottom = fig_bottom, top = fig_top, hspace = fig_hspace) n = len(y) # length of the signal _subplot = fig.add_subplot(2,1,1) print "Fi" _subplot.plot(arange(0,n),y) xlabel('Time') ylabel('Amplitude') _subploti_2=fig.add_subplot(2,1,2) k = arange(n) T = n/Fs frq = k/T # two sides frequency range frq = frq[range(n/2)] # one side frequency range Y = fft(y)/n # fft computing and normalization Y = Y[range(n/2)] _subplot_2.plot(frq,abs(Y),'r') # plotting the spectrum xlabel('Freq (Hz)') ylabel('|Y(freq)|') print "here" canvas = FigureCanvasAgg(fig) if '.eps' in outfile_name: canvas.print_eps(outfile_name, dpi = 110) if '.png' in outfile_name: canvas.print_figure(outfile_name, dpi = 110)
class VOASSNThumb: def __init__(self, data_source): years = mdates.YearLocator(2) # every year months = mdates.MonthLocator() # every month yearsFmt = mdates.DateFormatter('%y') dt_list, ssn_list = data_source.get_plotting_data() self.figure = Figure(figsize=(12,8), dpi=72) self.figure.patch.set_facecolor('white') self.figure.subplots_adjust(bottom=0.2) self.axis = self.figure.add_subplot(111) self.axis.plot_date(dt_list, ssn_list, '-', lw=2) self.axis.axvline(date.today(), color='r') # format the ticks self.axis.xaxis.set_major_locator(years) self.axis.xaxis.set_major_formatter(yearsFmt) self.axis.grid(True) # rotates and right aligns the x labels, and moves the bottom of the # axes up to make room for them # The following line currently breaks voacapgui if the thumbnail is # inserted into a panel # self.figure.autofmt_xdate(rotation=90) self.canvas = FigureCanvasGTK(self.figure) # a gtk.DrawingArea def get_thumb(self): return self.canvas
def run(self, postResults): #create tree with relevant datas source = sortTree(postResults, ['modules', 'controller', 'type']) #create plot fig = Figure() fig.subplots_adjust(wspace=0.5, hspace=0.25) #plot for L1NormAbs axes = fig.add_subplot(111) self.plotVariousController(source, axes,\ xPath=['modules', 'disturbance', 'sigma'],\ yPath=['metrics', 'L1NormAbs'],\ typ='line') self.plotSettings(axes,\ titel=r'Fehlerintegral w(t) und y(t) \"uber Sigma',\ grid=True,\ xlabel=r'$\sigma \, \lbrack m\rbrack$',\ ylabel=r'$E \, \lbrack ms \rbrack$',\ ) #extract controllerNames controllerNames = [x[:-len('Controller')] for x in source.keys()] canvas = FigureCanvas(fig) #write output files fileName = self.name[len('eval_'):]\ + '_Controller_(' + ''.join(controllerNames) + ')' self.writeOutputFiles(fileName, fig) return [{'figure': canvas, 'name': self.name}]
class MplCanvas(FigureCanvas): def __init__(self): self.fig = Figure(facecolor = '#FFFFFF') self.ax = self.fig.add_subplot(111) self.fig.subplots_adjust(left=0.1, bottom=0.1, right=0.9, top=0.9) self.xtitle="x-Axis" self.ytitle="y-Axis" self.PlotTitle = "Some Plot" self.grid_status = True self.xaxis_style = 'linear' self.yaxis_style = 'linear' self.format_labels() self.ax.hold(True) FigureCanvas.__init__(self, self.fig) FigureCanvas.setSizePolicy(self, QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Expanding) FigureCanvas.updateGeometry(self) def format_labels(self): self.ax.set_title(self.PlotTitle) self.ax.title.set_fontsize(10) self.ax.set_xlabel(self.xtitle, fontsize = 9) self.ax.set_ylabel(self.ytitle, fontsize = 9) labels_x = self.ax.get_xticklabels() labels_y = self.ax.get_yticklabels() for xlabel in labels_x: xlabel.set_fontsize(8) xlabel.set_color('b') for ylabel in labels_y: ylabel.set_fontsize(8) ylabel.set_color('b')
class MplCanvas(FigureCanvas): def __init__(self): self.fig = Figure() self.fig.patch.set_facecolor('white') self.ax = self.fig.add_subplot(111) #self.ax.set_frame_on(False) self.ax.axes.get_yaxis().set_visible(False) self.ax.get_xaxis().tick_bottom() self.ax.autoscale(enable = True, axis='y', tight= True) self.ax.autoscale(enable = False, axis='x', tight= True) self.fig.subplots_adjust(0.005,0.2,0.995,1,0,0) self.xdata = 0 #self.ax.spines['right'].set_color('none') #self.ax.spines['top'].set_color('none') #self.ax.spines['left'].set_color('none') FigureCanvas.__init__(self, self.fig) FigureCanvas.setSizePolicy(self, QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Expanding) FigureCanvas.updateGeometry(self) def mousePressEvent(self, event): inv = self.ax.transData.inverted() self.xdata = int(inv.transform((event.x(),event.y()))[0]) self.emit(QtCore.SIGNAL('chartClicked'))
def plotConfusionMatrix(self, confmat): confmat_norm = confmat.astype(float) / confmat.sum(axis=0) fig = Figure(facecolor="white", tight_layout=True) ax = fig.add_subplot(111) ax.matshow(confmat_norm, cmap=cm.Blues) classes = self.parent().model.currentClasses() names = [v.name for v in classes.values()] ax.xaxis.set_major_locator(FixedLocator(range(len(names)))) ax.set_xticklabels(names, rotation=45, size=10) ax.yaxis.set_major_locator(FixedLocator(range(len(names)))) ax.set_yticklabels(names, rotation=45, size=10) ax.set_xlabel("Predictions", fontsize=14) ax.set_ylabel("Annotations", fontsize=14) fig.subplots_adjust(top=0.85) size = _font_size(confmat.shape[0]) for i, items in enumerate(confmat): for j, item in enumerate(items): color = _font_color(confmat_norm[j, i]) ax.text(i, j, str(item), size=size, color=color, va="center", ha="center") self.addFigure("Confusion Matrix", fig)
def matrix_figure(N1=160, N2=32): r=0.4 fsx=20. fsy=fsx*N2/N1 f=Figure(figsize=(fsx,fsy),frameon=False) #f=plt.figure(figsize=(fsx,fsy),frameon=False) ax=f.add_subplot(111,axisbg='k') ax.set_xlim([-2*r,N1-1+2*r]) ax.set_ylim([-2*r,N2-1+2*r]) ax.set_axis_bgcolor('k') ax.set_yticks([]) ax.set_xticks([]) ax.set_frame_on(False) x=np.arange(N1) y=np.arange(N2) xx,yy=np.meshgrid(x,y) cmap = col.ListedColormap([ '#6E6E6E','#FE2E2E', '#64FE2E', '#FF8000']) colors=np.random.randint(0,4,(N1,N2)) patches = [] for x1,y1 in zip(xx.flatten(), yy.flatten()): circle = Circle((x1,y1), r) patches.append(circle) p = PatchCollection(patches, cmap=cmap) p.set_array(colors.flatten()) ax.add_collection(p) f.subplots_adjust(0,0,1,1) return ax, colors
def configure_subplots(self, button): toolfig = Figure(figsize=(6, 3)) canvas = self._get_canvas(toolfig) toolfig.subplots_adjust(top=0.9) tool = SubplotTool(self.canvas.figure, toolfig) w = int(toolfig.bbox.width) h = int(toolfig.bbox.height) window = Gtk.Window() try: window.set_icon_from_file(window_icon) except Exception: # we presumably already logged a message on the # failure of the main plot, don't keep reporting pass window.set_title("Subplot Configuration Tool") window.set_default_size(w, h) vbox = Gtk.Box() vbox.set_property("orientation", Gtk.Orientation.VERTICAL) window.add(vbox) vbox.show() canvas.show() vbox.pack_start(canvas, True, True, 0) window.show()
def __init__(self, matrix, matx, maty, dominio, tipodis, X, Y, tiempos, tiemposobs, superficies, ming, maxg, selected = None, parent = None): fig = Figure(figsize = (1.8 * 4, 2.4 * 4)) self.ax = None self.axt = None fig.subplots_adjust(hspace=.2, wspace=.3, bottom=.07, left=.08, right=.92, top=.94) print "tipos q ",tiempos print "tiempos obs ", tiemposobs self.fig = fig self.matrix = matrix self.dominio=dominio self.tipodis=tipodis self.X=X self.Y=Y self.matx = matx self.maty = maty self.ming=ming self.maxg=maxg self.tiempos = tiempos self.tiemposobs = tiemposobs self.superficies=superficies
class MatplotlibWidget(QtWidgets.QWidget): def __init__(self, parent=None): super(MatplotlibWidget, self).__init__(parent) self.figure = Figure(edgecolor='k') self.figure.subplots_adjust(left=0.05, right=0.95, top=0.85, bottom=0.15) self.figure.set_size_inches(7, 3) self.canvas = FigureCanvasQTAgg(self.figure) self.axes = self.figure.add_subplot(111) self.axes.set_title('Dep/Arr') self.scroll = QtWidgets.QScrollArea(self) sizePolicy = QtWidgets.QSizePolicy( QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.MinimumExpanding) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( self.scroll.sizePolicy().hasHeightForWidth()) self.scroll.setSizePolicy(sizePolicy) self.scroll.setWidget(self.canvas) self.layoutVertical = QtWidgets.QVBoxLayout(self) self.layoutVertical.setSizeConstraint( QtWidgets.QLayout.SetDefaultConstraint) self.layoutVertical.setContentsMargins(0, 0, 0, 0) self.nav = NavigationToolbar(self.canvas, self) self.prop = QtWidgets.QLabel(self) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( self.prop.sizePolicy().hasHeightForWidth()) self.prop.setSizePolicy(sizePolicy) self.layoutVertical.addWidget(self.nav) self.layoutVertical.addWidget(self.prop) self.layoutVertical.addWidget(self.scroll) # self.scroll.resize(self.layoutVertical.geometry().width(), self.layoutVertical.geometry().height()) self.bins = [1] self.binsize = 15 * 60 # min self.max_y = 0 self.plot_off = False self.scroll_resize = False self.show_labels = False self.grid_on = True self.reset_fig() self.first_timestamp = None def reset_fig(self): self.axes.clear() self.axes.set_title('Dep/Arr', loc='center') self.axes.grid(self.grid_on) self.axes.set_xticklabels(['']) self.resize_fig() def resize_fig(self): if not self.plot_off: dpi1 = self.figure.get_dpi() if self.scroll_resize and len(self.bins) >= 5 and len( self.bins) * 50 >= self.scroll.width(): self.figure.set_size_inches( len(self.bins) * 50 / float(dpi1), (self.scroll.height() - 20) / float(dpi1)) self.canvas.resize(self.figure.get_figwidth() * float(dpi1), self.figure.get_figheight() * float(dpi1)) else: self.figure.set_size_inches( (self.scroll.width()) / float(dpi1), (self.scroll.height() - 20) / float(dpi1)) self.canvas.resize(self.figure.get_figwidth() * float(dpi1), self.figure.get_figheight() * float(dpi1)) def update_figure(self, op_list, config_list): if not self.plot_off and op_list: self.reset_fig() dep = [0] arr = [0] labels = [] if not self.first_timestamp: self.first_timestamp = op_list[-1].get_op_timestamp() for op in reversed(op_list): index = int((op.get_op_timestamp() - self.first_timestamp) / self.binsize) # fill in labels and empty values for new bars if index >= len(labels): for m in reversed(range(index - len(labels) + 1)): bin_time = op.get_op_timestamp() - m * self.binsize labels.append( time_string(bin_time - (bin_time % self.binsize))) dep.extend([0] * (index - len(dep) + 1)) arr.extend([0] * (index - len(arr) + 1)) if op.LorT == 'T': dep[index] += 1 elif op.LorT == 'L': arr[index] += 1 N = len(labels) self.bins = np.arange(N) width = 0.8 # plot stacked bars p1 = self.axes.bar(self.bins, arr, width, color='#9CB380') p2 = self.axes.bar(self.bins, dep, width, bottom=arr, color='#5CC8FF') # set legend and labels (not always so they don't overlap) self.axes.legend((p2[0], p1[0]), ('Dep', 'Arr'), loc=0) self.axes.set_xticks(self.bins - 0.5) if len(labels) > 10: i = 0 one_label_per = len(labels) / 15 for m, label in enumerate(labels): if i > 0: labels[m] = '' i += 1 if i > one_label_per: i = 0 self.axes.set_xticklabels(labels, rotation=-40) self.max_y = self.axes.get_ylim()[1] self.axes.set_xlim(-1, N) x_offset = 0.2 # set text for count of each bar if self.show_labels: for m, label in enumerate(labels): if arr[m] != 0: self.axes.text(self.bins[m] - x_offset, arr[m] + self.max_y * 0.01, '{:.0f}'.format(arr[m])) if dep[m] != 0: self.axes.text(self.bins[m] + x_offset / 2, dep[m] + arr[m] + self.max_y * 0.01, '{:.0f}'.format(dep[m])) # config change vertical lines and text for m, config in enumerate(config_list): x = float( (config.from_epoch - self.first_timestamp) / self.binsize) self.axes.plot([x] * 2, [0, 0.9 * self.max_y], 'b--', linewidth=1) self.axes.text(x + x_offset, self.max_y * 0.9, config.config, fontsize=16) # show plot self.canvas.draw()
class DensityPanel(FigureCanvasWxAgg): def __init__(self, parent, **kwargs): self.figure = Figure() FigureCanvasWxAgg.__init__(self, parent, -1, self.figure, **kwargs) self.canvas = self.figure.canvas self.SetMinSize((100, 100)) self.figure.set_facecolor((1, 1, 1)) self.figure.set_edgecolor((1, 1, 1)) self.canvas.SetBackgroundColour('white') self.subplot = self.figure.add_subplot(111) self.gate_helper = GatingHelper(self.subplot, self) self.navtoolbar = None self.point_list = [] self.gridsize = 50 self.cb = None self.x_scale = LINEAR_SCALE self.y_scale = LINEAR_SCALE self.color_scale = None self.x_label = '' self.y_label = '' self.cmap = 'jet' self.canvas.mpl_connect('button_release_event', self.on_release) def setpointslists(self, points): self.subplot.clear() self.point_list = points plot_pts = np.array(points).astype(float) if self.x_scale == LOG_SCALE: plot_pts = plot_pts[(plot_pts[:, 0] > 0)] if self.y_scale == LOG_SCALE: plot_pts = plot_pts[(plot_pts[:, 1] > 0)] hb = self.subplot.hexbin(plot_pts[:, 0], plot_pts[:, 1], gridsize=self.gridsize, xscale=self.x_scale, yscale=self.y_scale, bins=self.color_scale, cmap=matplotlib.cm.get_cmap(self.cmap)) if self.cb: # Remove the existing colorbar and reclaim the space so when we add # a colorbar to the new hexbin subplot, it doesn't get indented. #self.figure.delaxes(self.figure.axes[1]) self.cb.remove() self.figure.subplots_adjust(right=0.90) self.cb = self.figure.colorbar(hb, fraction=0.046, pad=0.04) if self.color_scale == LOG_SCALE: self.cb.set_label('log10(N)') self.subplot.set_xlabel(self.x_label) self.subplot.set_ylabel(self.y_label) xmin = np.nanmin(plot_pts[:, 0]) xmax = np.nanmax(plot_pts[:, 0]) ymin = np.nanmin(plot_pts[:, 1]) ymax = np.nanmax(plot_pts[:, 1]) # Pad all sides if self.x_scale == LOG_SCALE: xmin = xmin / 1.5 xmax = xmax * 1.5 else: xmin = xmin - (xmax - xmin) / 20. xmax = xmax + (xmax - xmin) / 20. if self.y_scale == LOG_SCALE: ymin = ymin / 1.5 ymax = ymax * 1.5 else: ymin = ymin - (ymax - ymin) / 20. ymax = ymax + (ymax - ymin) / 20. self.subplot.axis([xmin, xmax, ymin, ymax]) self.reset_toolbar() def getpointslists(self): return self.point_list def setgridsize(self, gridsize): self.gridsize = gridsize def set_x_scale(self, scale): self.x_scale = scale def set_y_scale(self, scale): self.y_scale = scale def set_color_scale(self, scale): if scale == LINEAR_SCALE: scale = None self.color_scale = scale def set_x_label(self, label): self.x_label = label def set_y_label(self, label): self.y_label = label def set_colormap(self, cmap): self.cmap = cmap self.draw() def get_toolbar(self): if not self.navtoolbar: self.navtoolbar = NavigationToolbar(self.canvas) return self.navtoolbar def reset_toolbar(self): # Cheat since there is no way reset if self.navtoolbar: self.navtoolbar._views.clear() self.navtoolbar._positions.clear() self.navtoolbar.push_current() def set_configpanel(self, configpanel): '''Allow access of the control panel from the plotting panel''' self.configpanel = configpanel def on_release(self, evt): if evt.button == 3: # right click self.show_popup_menu((evt.x, self.canvas.GetSize()[1] - evt.y), None) def show_popup_menu(self, (x, y), data): self.popup_menu_filters = {} popup = wx.Menu() loadimages_table_item = popup.Append( -1, 'Create gated table for CellProfiler LoadImages') selected_gate = self.configpanel.gate_choice.get_gatename_or_none() selected_gates = [] if selected_gate: selected_gates = [selected_gate] self.Bind( wx.EVT_MENU, lambda (e): ui.prompt_user_to_create_loadimages_table( self, selected_gates), loadimages_table_item) show_images_in_gate_item = popup.Append(-1, 'Show images in gate') show_images_in_gate_item.Enable(selected_gate is not None) self.Bind(wx.EVT_MENU, self.show_images_from_gate, show_images_in_gate_item) if p.object_table: show_objects_in_gate_item = popup.Append( -1, 'Show %s in gate (montage)' % (p.object_name[1])) show_objects_in_gate_item.Enable(selected_gate is not None) self.Bind(wx.EVT_MENU, self.show_objects_from_gate, show_objects_in_gate_item) self.PopupMenu(popup, (x, y))
class PCAWindow(wx.Frame): def __init__(self, parent): wx.Frame.__init__(self, parent, id=wx.ID_ANY, title=u"振動モード分析", pos=wx.DefaultPosition, size=wx.Size(1280, 980), style=wx.DEFAULT_FRAME_STYLE | wx.TAB_TRAVERSAL) self.SetSizeHintsSz(wx.DefaultSize, wx.DefaultSize) self.SetForegroundColour( wx.SystemSettings.GetColour(wx.SYS_COLOUR_WINDOW)) self.SetBackgroundColour( wx.SystemSettings.GetColour(wx.SYS_COLOUR_WINDOW)) self.contribution_figure = Figure(figsize=(8, 4.3), dpi=100) self.contribution_canvas = FigureCanvasWxAgg(self, -1, self.contribution_figure) self.contribution_navigationToolbar = NavigationToolbar2Wx( self.contribution_canvas) self.contribution_navigationToolbar.Realize() self.contribution_navigationToolbar.update() self.dammy1_figure = Figure(figsize=(8, 4.3), dpi=100) self.dammy1_canvas = FigureCanvasWxAgg(self, -1, self.dammy1_figure) self.dammy1_navigationToolbar = NavigationToolbar2Wx( self.dammy1_canvas) self.dammy1_navigationToolbar.Realize() self.dammy1_navigationToolbar.update() import configdata self.n_comp = 5 #仮設定(固有値の計算範囲) self.p_comp = 1 #仮設定(表示する固有値モード) self.scale = 1 #仮設定(表示倍率) self.data = configdata.dis.sel(layer=0, features=["dis_x", "dis_y"], stats="mu").values self.pxpy = configdata.pxpys.sel(layer=0, features=["x", "y"]).values self.x = range(1, self.n_comp + 1) from eof_analysis import eof self.d, self.v = eof(self.data, self.n_comp) point = int(self.v.shape[0] / 2) datavx = self.v[:point, self.p_comp - 1] datavy = self.v[point:, self.p_comp - 1] self.contribution_figure.subplots_adjust(left=0.3, right=0.7, bottom=0.1, top=0.8) #self.contribution_axes = self.contribution_figure.add_subplot(111, facecolor='black') self.contribution_axes = self.contribution_figure.add_subplot( 111, facecolor='white') self.contribution_axes.minorticks_on() self.contribution_axes.tick_params(axis='both', which='major', direction='inout', colors="black", labelsize=8, bottom='on', left='on') self.contribution_axes.grid(True) self.contribution_axes.tick_params(axis='both', which='minor', direction='inout', length=5, colors="black") self.contribution_axes.set_title('contribution ratio') #self.colorlist = ["r", "g", "b", "c", "m", "y", "k", "w"] self.colorlist = ["r", "g", "b", "c", "m", "y", "k"] self.contribution_axes.bar(self.x, self.d, color=self.colorlist) frame = 0 cv2img = cv2.imread(configdata.image_filelist[frame]) self.im = cv2.cvtColor(cv2img, cv2.COLOR_BGR2RGB) self.dammy1_figure.subplots_adjust(left=0.1, right=0.995, bottom=0.1, top=0.9) #self.dammy1_axes = self.dammy1_figure.add_subplot(111, facecolor='black') self.dammy1_axes = self.dammy1_figure.add_subplot(111, facecolor='white') self.dammy1_axes.minorticks_on() self.dammy1_axes.tick_params(axis='both', which='major', direction='inout', colors="black", labelsize=8, bottom='on', left='on') self.dammy1_axes.grid(True) self.dammy1_axes.tick_params(axis='both', which='minor', direction='inout', length=5, colors="black") self.dammy1_axes.set_title('dammy1') m = mainWindow.setSt_Dialog2(self) param = int(m.getParam2()) xl = [] st = int(param / 10) for i in range(0, param, st): xl.append(i) self.dammy1_axes.set_xticklabels(xl) self.dammy1_axes.imshow(self.im) self.dammy1_axes.quiver(self.pxpy[:, 0], self.pxpy[:, 1], datavx, datavy, angles='xy', width=0.005, color='red', scale=self.scale) gSizer1 = wx.BoxSizer(wx.VERTICAL) bSizer32 = wx.BoxSizer(wx.VERTICAL) # 左上 bSizer32.Add(self.contribution_canvas, 0, wx.EXPAND) bSizer32.Add(self.contribution_navigationToolbar, 0, wx.EXPAND) gSizer1.Add(bSizer32, 0, wx.EXPAND) bSizer35 = wx.BoxSizer(wx.HORIZONTAL) bSizer34 = wx.BoxSizer(wx.VERTICAL) # 下 bSizer35.Add(bSizer34, 0, wx.EXPAND) bSizer34.Add(self.dammy1_canvas, 0, wx.EXPAND) bSizer34.Add(self.dammy1_navigationToolbar, 0, wx.EXPAND) bSizer36 = wx.BoxSizer(wx.VERTICAL) bSizer35.Add(bSizer36, 0, wx.EXPAND) staticText0 = wx.StaticText(self, wx.ID_ANY, u" \n \n \n \n \n", wx.DefaultPosition, wx.DefaultSize, wx.TE_CENTRE) bSizer36.Add(staticText0, 0, wx.ALIGN_LEFT) array = [] for i in range(self.n_comp): array.append(str(i + 1)) self.combo = wx.ComboBox(self, -1, u' ', choices=array) self.combo.SetSelection(0) self.combo.Bind(wx.EVT_COMBOBOX, self.event_combo) self.textCtrl1 = wx.TextCtrl(self, wx.ID_ANY, u"1", wx.DefaultPosition, wx.DefaultSize, 0) bSizer37 = wx.BoxSizer(wx.HORIZONTAL) bSizer36.Add(bSizer37, 0, wx.ALIGN_LEFT) staticText1 = wx.StaticText(self, wx.ID_ANY, u"次数:", wx.DefaultPosition, wx.DefaultSize, wx.TE_CENTRE) staticText1.SetForegroundColour('#000000') bSizer37.Add(staticText1, 0, wx.ALIGN_CENTER) bSizer37.Add(self.combo, 0, wx.ALIGN_CENTER) bSizer38 = wx.BoxSizer(wx.HORIZONTAL) bSizer36.Add(bSizer38, 0, wx.ALIGN_LEFT) staticText2 = wx.StaticText(self, wx.ID_ANY, u"スケール:", wx.DefaultPosition, wx.DefaultSize, wx.TE_CENTRE) staticText2.SetForegroundColour('#000000') self.button1 = wx.Button(self, wx.ID_ANY, u"更新", wx.DefaultPosition, wx.DefaultSize, 0) self.button1.Bind(wx.EVT_BUTTON, self.event_scale) bSizer38.Add(staticText2, 0, wx.ALIGN_CENTER) bSizer38.Add(self.textCtrl1, 0, wx.ALIGN_CENTER) bSizer38.Add(self.button1, 0, wx.ALIGN_CENTER) gSizer1.Add(bSizer35, 0, wx.EXPAND) self.SetSizer(gSizer1) self.Layout() self.Centre(wx.BOTH) def updateGraph(self): point = int(self.v.shape[0] / 2) datavx = self.v[:point, self.p_comp] datavy = self.v[point:, self.p_comp] self.dammy1_axes.cla() #self.dammy1_axes = self.dammy1_figure.add_subplot(111, facecolor='black') self.dammy1_axes = self.dammy1_figure.add_subplot(111, facecolor='white') self.dammy1_axes.minorticks_on() self.dammy1_axes.tick_params(axis='both', which='major', direction='inout', colors="black", labelsize=8, bottom='on', left='on') self.dammy1_axes.grid(True) self.dammy1_axes.tick_params(axis='both', which='minor', direction='inout', length=5, colors="black") self.dammy1_axes.set_title('dammy1') m = mainWindow.setSt_Dialog2(self) param = int(m.getParam2()) xl = [] st = int(param / 10) for i in range(0, param, st): xl.append(i) self.dammy1_axes.set_xticklabels(xl) self.dammy1_axes.imshow(self.im) self.dammy1_axes.quiver(self.pxpy[:, 0], self.pxpy[:, 1], datavx, datavy, angles='xy', width=0.005, color=self.colorlist[self.p_comp], scale=self.scale) self.dammy1_canvas.draw() def event_combo(self, event): self.p_comp = int(self.combo.GetSelection()) self.updateGraph() def event_scale(self, event): self.scale = float(self.textCtrl1.GetValue()) self.updateGraph() def __del__(self): pass
class WidgetPrimaryNuclides(QWidget, Ui_WidgetPrimaryNuclides): cooling_times = ['1', '1.0e5', '1.0e6', '1.0e7', '1.0e8', '1.0e9', '1.5e9'] param_names = [ 'activity(Bq/kg)', 'total_heat(kW/kg)', 'dose_rate(Sv/h)', 'ingestion_dose(Sv/kg)' ] show_names = [ 'Specific activity(Bq/kg)', 'Heat(kW/kg)', 'Dose rate(Sv/h)', 'Ingestion dose(Sv/kg)' ] colors = [ '#FA8072', '#7FFF00', '#87CEFA', '#8A2BE2', '#A9A9A9', '#E9967A', '#FF1493', '#9932CC', '#CD853F', '#FF7F50', '#2E8B57' ] def __init__(self, parent=None): super(WidgetPrimaryNuclides, self).__init__(parent) self.figure = None self.setupUi(self) self.axes = [None, None, None, None] self.checkButtons = [ self.checkBoxAct, self.checkBoxHeat, self.checkBoxDose, self.checkBoxIng ] for checkButton in self.checkButtons: checkButton.clicked.connect(self.on_click) for time in WidgetPrimaryNuclides.cooling_times: self.comboBoxCoolingTime.addItem(time) self.comboBoxCoolingTime.setCurrentIndex(2) self.initialize_canvas() def initialize_canvas(self): self.figure = Figure(figsize=(8, 6), dpi=100, tight_layout=True) self.figure.set_facecolor('#F5F5F5') self.figure.subplots_adjust(left=0.08, top=0.92, bottom=0.1) self.canvas = FigureCanvas(self.figure) self.verticalLayoutPlot.addWidget(self.canvas) self.toolbar = NavigationToolbar(self.canvas, self) self.verticalLayoutToolbarAndOtherWidgets.addWidget(self.toolbar) def data_to_ui(self, act_data: OneSpectrumActivationData): self.act_data = act_data self.update() self.initialize_figs() def initialize_figs(self): self.update() self.canvas.figure.clf() checked_button_num = 0 for i in range(0, 4): if self.checkButtons[i].isChecked(): checked_button_num += 1 if checked_button_num is 0: return idx = 1 if checked_button_num % 2 is 0: totalnum = checked_button_num * 50 + 20 elif checked_button_num == 3: totalnum = 220 else: totalnum = checked_button_num * 100 + 10 for i in range(0, 4): if self.checkButtons[i].isChecked(): self.axes[i] = self.figure.add_subplot(totalnum + idx) self.draw_axe(i) idx += 1 self.canvas.draw() def draw_axe(self, idx): assert (self.act_data is not None) cooling_time_idx = self.comboBoxCoolingTime.currentIndex() assert (cooling_time_idx < len( self.act_data.all_steps_activation_data)) one_step_data = self.act_data.all_steps_activation_data[ cooling_time_idx] # get primary nuclides for xxx parameter_name = WidgetPrimaryNuclides.param_names[idx] # total_val = 0.0 # one_step_data.parameters[parameter_name] total_val = one_step_data.parameters[parameter_name] if total_val <= 0.0: self.axes[idx].set_title( "Primary nuclides for: " + parameter_name + " is not valid.\nBecause the total value is 0.") self.axes[idx].pie([], labels=[]) return nuclides = [] nuclide_props = [] accumulate_amount = 0.0 primary_limit = self.horizontalSliderPrimaryAmount.value() * 1.0 / 100 # for nuclide in one_step_data.nuclides.keys(): # total_val += one_step_data.nuclides[nuclide].params[parameter_name] for nuclide in sorted(one_step_data.nuclides.keys(), key=lambda a: -one_step_data.nuclides[a].params[ parameter_name]): nuclides.append(nuclide) act_value = one_step_data.nuclides[nuclide].params[parameter_name] prop = act_value / total_val accumulate_amount += prop nuclide_props.append(prop) if accumulate_amount >= primary_limit: break if accumulate_amount > 0.999999: accumulate_amount = 1.0 leftprop = 1 - accumulate_amount if leftprop > 0.0001: nuclide_props.append(leftprop) nuclides.append('Other') self.axes[idx].pie(nuclide_props, labels=nuclides, colors=WidgetPrimaryNuclides.colors, autopct='%1.2f%%', shadow=True, startangle=90) show_name = WidgetPrimaryNuclides.show_names[idx] self.axes[idx].set_title("Primary nuclides for: " + show_name) self.axes[idx].axis('equal') return def on_click(self): self.update() self.initialize_figs() @pyqtSlot(int) def on_comboBoxCoolingTime_currentIndexChanged(self, idx): if self.figure is not None: self.initialize_figs() @pyqtSlot(int) def on_horizontalSliderPrimaryAmount_valueChanged(self, amount): self.labelPrimaryAmount.setText("{0}".format(amount)) if self.figure is not None: self.initialize_figs()
def get_fit_loop_plot(): Ia_model_count = len(info.options_dict["Ia_table"]) cc_model_count = len(info.options_dict["cc_table"]) total_models = Ia_model_count * cc_model_count print("total_models", total_models) new_chi_list = Stats.fit_loop_results["chi_list"].reshape( Ia_model_count, cc_model_count) new_ratio_list = Stats.fit_loop_results["ratio_percent_list"].reshape( Ia_model_count, cc_model_count) new_ratio_error_n_list = Stats.fit_loop_results[ "ratio_percent_error_n_list"].reshape(Ia_model_count, cc_model_count) new_ratio_error_p_list = Stats.fit_loop_results[ "ratio_percent_error_p_list"].reshape(Ia_model_count, cc_model_count) fig = Figure(dpi=200, figsize=(10, 10), facecolor=(1, 1, 1), edgecolor=(0, 0, 0)) ax = [ fig.add_subplot(141), fig.add_subplot(142), fig.add_subplot(143), fig.add_subplot(144) ] fig.subplots_adjust(left=0.15, bottom=0.175, right=0.95, top=0.95, wspace=0.0, hspace=0.0) xlabel = [t.rsplit(".", 1)[0] for t in info.options_dict["cc_table"]] ax[0].set_xticks(range(cc_model_count)) ax[0].set_xticklabels(xlabel, rotation=80, size=5) ylabel = [t.rsplit(".", 1)[0] for t in info.options_dict["Ia_table"]] ax[0].set_yticks(range(Ia_model_count)) ax[0].set_yticklabels(ylabel, size=5) ax[0].imshow(new_chi_list, cmap=matplotlib.cm.get_cmap('winter_r')) for i in range(len(xlabel)): for j in range(len(ylabel)): text = ax[0].text(i, j, "{:.2f}".format(new_chi_list[j, i]), ha="center", va="center", color="black", fontsize=5) ax[0].set_title("Chi") xlabel = [t.rsplit(".", 1)[0] for t in info.options_dict["cc_table"]] ax[1].set_xticks(range(cc_model_count)) ax[1].set_xticklabels(xlabel, rotation=80, size=5) ylabel = ["" for _ in info.options_dict["Ia_table"]] ax[1].set_yticks(range(Ia_model_count)) ax[1].set_yticklabels(ylabel, size=5) ax[1].imshow(new_ratio_list, vmin=0, vmax=1, cmap=matplotlib.cm.get_cmap('autumn_r')) for i in range(len(xlabel)): for j in range(len(ylabel)): text = ax[1].text(i, j, "{:.2f}".format(new_ratio_list[j, i]), ha="center", va="center", color="black", fontsize=5) ax[1].set_title("Ratio") xlabel = [t.rsplit(".", 1)[0] for t in info.options_dict["cc_table"]] ax[2].set_xticks(range(cc_model_count)) ax[2].set_xticklabels(xlabel, rotation=80, size=5) ylabel = ["" for _ in info.options_dict["Ia_table"]] ax[2].set_yticks(range(Ia_model_count)) ax[2].set_yticklabels(ylabel, size=5) ax[2].imshow(new_ratio_list, cmap=matplotlib.cm.get_cmap('summer_r')) for i in range(len(xlabel)): for j in range(len(ylabel)): text = ax[2].text(i, j, "{:.2f}".format(new_ratio_error_n_list[j, i]), ha="center", va="center", color="black", fontsize=5) ax[2].set_title("(-)") xlabel = [t.rsplit(".", 1)[0] for t in info.options_dict["cc_table"]] ax[3].set_xticks(range(cc_model_count)) ax[3].set_xticklabels(xlabel, rotation=80, size=5) ylabel = ["" for _ in info.options_dict["Ia_table"]] ax[3].set_yticks(range(Ia_model_count)) ax[3].set_yticklabels(ylabel, size=5) ax[3].imshow(new_ratio_list, cmap=matplotlib.cm.get_cmap('summer_r')) for i in range(len(xlabel)): for j in range(len(ylabel)): text = ax[3].text(i, j, "{:.2f}".format(new_ratio_error_p_list[j, i]), ha="center", va="center", color="black", fontsize=5) ax[3].set_title("(+)") return fig
class VNA(QMainWindow, Ui_VNA): max_size = 32768 def __init__(self): super(VNA, self).__init__() self.setupUi(self) # IP address validator rx = QRegExp( '^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$' ) self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue)) # state variables self.idle = True self.reading = False # sweep parameters self.sweep_start = 10 self.sweep_stop = 60000 self.sweep_size = 6000 # buffer and offset for the incoming samples self.buffer = bytearray(16 * VNA.max_size) self.offset = 0 self.data = np.frombuffer(self.buffer, np.complex64) self.open = Measurement(self.sweep_start, self.sweep_stop, self.sweep_size) self.short = Measurement(self.sweep_start, self.sweep_stop, self.sweep_size) self.load = Measurement(self.sweep_start, self.sweep_stop, self.sweep_size) self.dut = Measurement(self.sweep_start, self.sweep_stop, self.sweep_size) self.mode = 'dut' # create figure self.figure = Figure() self.figure.set_facecolor('none') self.canvas = FigureCanvas(self.figure) self.plotLayout.addWidget(self.canvas) # create navigation toolbar self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False) # initialize cursor self.cursor = None # remove subplots action actions = self.toolbar.actions() if int(matplotlib.__version__[0]) < 2: self.toolbar.removeAction(actions[7]) else: self.toolbar.removeAction(actions[6]) self.plotLayout.addWidget(self.toolbar) # create TCP socket self.socket = QTcpSocket(self) self.socket.connected.connect(self.connected) self.socket.readyRead.connect(self.read_data) self.socket.error.connect(self.display_error) # connect signals from buttons and boxes self.sweepFrame.setEnabled(False) self.dutSweep.setEnabled(False) self.connectButton.clicked.connect(self.start) self.writeButton.clicked.connect(self.write_cfg) self.readButton.clicked.connect(self.read_cfg) self.openSweep.clicked.connect(self.sweep_open) self.shortSweep.clicked.connect(self.sweep_short) self.loadSweep.clicked.connect(self.sweep_load) self.dutSweep.clicked.connect(self.sweep_dut) self.csvButton.clicked.connect(self.write_csv) self.s1pButton.clicked.connect(self.write_s1p) self.s2pButton.clicked.connect(self.write_s2p) self.startValue.valueChanged.connect(self.set_start) self.stopValue.valueChanged.connect(self.set_stop) self.sizeValue.valueChanged.connect(self.set_size) self.rateValue.addItems([ '50000', '10000', '5000', '1000', '500', '100', '50', '10', '5', '1' ]) self.rateValue.lineEdit().setReadOnly(True) self.rateValue.lineEdit().setAlignment(Qt.AlignRight) for i in range(0, self.rateValue.count()): self.rateValue.setItemData(i, Qt.AlignRight, Qt.TextAlignmentRole) self.rateValue.currentIndexChanged.connect(self.set_rate) self.corrValue.valueChanged.connect(self.set_corr) self.levelValue.valueChanged.connect(self.set_level) self.openPlot.clicked.connect(self.plot_open) self.shortPlot.clicked.connect(self.plot_short) self.loadPlot.clicked.connect(self.plot_load) self.dutPlot.clicked.connect(self.plot_dut) self.smithPlot.clicked.connect(self.plot_smith) self.impPlot.clicked.connect(self.plot_imp) self.rcPlot.clicked.connect(self.plot_rc) self.swrPlot.clicked.connect(self.plot_swr) self.rlPlot.clicked.connect(self.plot_rl) self.gainPlot.clicked.connect(self.plot_gain) # create timer self.startTimer = QTimer(self) self.startTimer.timeout.connect(self.timeout) def start(self): if self.idle: self.connectButton.setEnabled(False) self.socket.connectToHost(self.addrValue.text(), 1001) self.startTimer.start(5000) else: self.stop() def stop(self): self.idle = True self.socket.abort() self.connectButton.setText('Connect') self.connectButton.setEnabled(True) self.sweepFrame.setEnabled(False) self.selectFrame.setEnabled(True) self.dutSweep.setEnabled(False) def timeout(self): self.display_error('timeout') def connected(self): self.startTimer.stop() self.idle = False self.set_start(self.startValue.value()) self.set_stop(self.stopValue.value()) self.set_size(self.sizeValue.value()) self.set_rate(self.rateValue.currentIndex()) self.set_corr(self.corrValue.value()) self.set_level(self.levelValue.value()) self.connectButton.setText('Disconnect') self.connectButton.setEnabled(True) self.sweepFrame.setEnabled(True) self.dutSweep.setEnabled(True) def read_data(self): while (self.socket.bytesAvailable() > 0): if not self.reading: self.socket.readAll() return size = self.socket.bytesAvailable() self.progress.setValue((self.offset + size) / 16) limit = 16 * self.sweep_size if self.offset + size < limit: self.buffer[self.offset:self.offset + size] = self.socket.read(size) self.offset += size else: self.buffer[self.offset:limit] = self.socket.read(limit - self.offset) adc1 = self.data[0::2] adc2 = self.data[1::2] attr = getattr(self, self.mode) size = attr.freq.size attr.data = adc1[0:size].copy() getattr(self, 'plot_%s' % self.mode)() self.reading = False self.sweepFrame.setEnabled(True) self.selectFrame.setEnabled(True) def display_error(self, socketError): self.startTimer.stop() if socketError == 'timeout': QMessageBox.information(self, 'VNA', 'Error: connection timeout.') else: QMessageBox.information(self, 'VNA', 'Error: %s.' % self.socket.errorString()) self.stop() def set_start(self, value): self.sweep_start = value def set_stop(self, value): self.sweep_stop = value def set_size(self, value): self.sweep_size = value def set_rate(self, value): if self.idle: return rate = [1, 5, 10, 50, 100, 500, 1000, 5000, 10000, 50000][value] self.socket.write(struct.pack('<I', 3 << 28 | int(rate))) def set_corr(self, value): if self.idle: return self.socket.write(struct.pack('<I', 4 << 28 | int(value))) def set_level(self, value): if self.idle: return self.socket.write( struct.pack('<I', 5 << 28 | int(32766 * np.power(10.0, value / 20.0)))) self.socket.write(struct.pack('<I', 6 << 28 | int(0))) def sweep(self, mode): if self.idle: return self.sweepFrame.setEnabled(False) self.selectFrame.setEnabled(False) self.mode = mode attr = getattr(self, mode) attr.freq = np.linspace(self.sweep_start, self.sweep_stop, self.sweep_size) * 1000 self.offset = 0 self.reading = True self.socket.write( struct.pack('<I', 0 << 28 | int(self.sweep_start * 1000))) self.socket.write( struct.pack('<I', 1 << 28 | int(self.sweep_stop * 1000))) self.socket.write(struct.pack('<I', 2 << 28 | int(self.sweep_size))) self.socket.write(struct.pack('<I', 7 << 28)) self.progress = QProgressDialog('Sweep status', 'Cancel', 0, self.sweep_size) self.progress.setModal(True) self.progress.setMinimumDuration(1000) self.progress.canceled.connect(self.cancel) def cancel(self): self.offset = 0 self.reading = False self.socket.write(struct.pack('<I', 8 << 28)) self.sweepFrame.setEnabled(True) self.selectFrame.setEnabled(True) def sweep_open(self): self.sweep('open') def sweep_short(self): self.sweep('short') def sweep_load(self): self.sweep('load') def sweep_dut(self): self.sweep('dut') def interp(self, freq, data): real = np.interp(self.dut.freq, freq, data.real) imag = np.interp(self.dut.freq, freq, data.imag) return real + 1j * imag def gain(self): return self.dut.data / self.interp(self.short.freq, self.short.data) def impedance(self): open = self.interp(self.open.freq, self.open.data) short = self.interp(self.short.freq, self.short.data) load = self.interp(self.load.freq, self.load.data) dut = self.dut.data return 50.0 * (open - load) * (dut - short) / ((load - short) * (open - dut)) def gamma(self): z = self.impedance() return (z - 50.0) / (z + 50.0) def plot_gain(self): if self.cursor is not None: self.cursor.hide().disable() matplotlib.rcdefaults() self.figure.clf() self.figure.subplots_adjust(left=0.12, bottom=0.12, right=0.88, top=0.98) axes1 = self.figure.add_subplot(111) axes1.cla() axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix)) axes1.yaxis.set_major_formatter(FuncFormatter(metric_prefix)) axes1.tick_params('y', color='blue', labelcolor='blue') axes1.yaxis.label.set_color('blue') gain = self.gain() axes1.plot(self.dut.freq, 20.0 * np.log10(np.absolute(gain)), color='blue', label='Gain') axes2 = axes1.twinx() axes2.spines['left'].set_color('blue') axes2.spines['right'].set_color('red') axes1.set_xlabel('Hz') axes1.set_ylabel('Gain, dB') axes2.set_ylabel('Phase angle') axes2.tick_params('y', color='red', labelcolor='red') axes2.yaxis.label.set_color('red') axes2.plot(self.dut.freq, np.angle(gain, deg=True), color='red', label='Phase angle') self.cursor = datacursor(axes=self.figure.get_axes(), formatter=LabelFormatter(), display='multiple') self.canvas.draw() def plot_magphase(self, freq, data): if self.cursor is not None: self.cursor.hide().disable() matplotlib.rcdefaults() self.figure.clf() self.figure.subplots_adjust(left=0.12, bottom=0.12, right=0.88, top=0.98) axes1 = self.figure.add_subplot(111) axes1.cla() axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix)) axes1.yaxis.set_major_formatter(FuncFormatter(metric_prefix)) axes1.tick_params('y', color='blue', labelcolor='blue') axes1.yaxis.label.set_color('blue') axes1.plot(freq, np.absolute(data), color='blue', label='Magnitude') axes2 = axes1.twinx() axes2.spines['left'].set_color('blue') axes2.spines['right'].set_color('red') axes1.set_xlabel('Hz') axes1.set_ylabel('Magnitude') axes2.set_ylabel('Phase angle') axes2.tick_params('y', color='red', labelcolor='red') axes2.yaxis.label.set_color('red') axes2.plot(freq, np.angle(data, deg=True), color='red', label='Phase angle') self.cursor = datacursor(axes=self.figure.get_axes(), formatter=LabelFormatter(), display='multiple') self.canvas.draw() def plot_open(self): self.plot_magphase(self.open.freq, self.open.data) def plot_short(self): self.plot_magphase(self.short.freq, self.short.data) def plot_load(self): self.plot_magphase(self.load.freq, self.load.data) def plot_dut(self): self.plot_magphase(self.dut.freq, self.dut.data) def plot_smith_grid(self, axes, color): load = 50.0 ticks = np.array([0.0, 0.2, 0.5, 1.0, 2.0, 5.0]) for tick in ticks * load: axis = np.logspace(-4, np.log10(1.0e3), 200) * load z = tick + 1.0j * axis gamma = (z - load) / (z + load) axes.plot(gamma.real, gamma.imag, color=color, linewidth=0.4, alpha=0.3) axes.plot(gamma.real, -gamma.imag, color=color, linewidth=0.4, alpha=0.3) z = axis + 1.0j * tick gamma = (z - load) / (z + load) axes.plot(gamma.real, gamma.imag, color=color, linewidth=0.4, alpha=0.3) axes.plot(gamma.real, -gamma.imag, color=color, linewidth=0.4, alpha=0.3) if tick == 0.0: axes.text(1.0, 0.0, u'\u221E', color=color, ha='left', va='center', clip_on=True, fontsize=18.0) axes.text(-1.0, 0.0, u'0\u03A9', color=color, ha='left', va='bottom', clip_on=True, fontsize=12.0) continue lab = u'%d\u03A9' % tick x = (tick - load) / (tick + load) axes.text(x, 0.0, lab, color=color, ha='left', va='bottom', clip_on=True, fontsize=12.0) lab = u'j%d\u03A9' % tick z = 1.0j * tick gamma = (z - load) / (z + load) * 1.05 x = gamma.real y = gamma.imag angle = np.angle(gamma) * 180.0 / np.pi - 90.0 axes.text(x, y, lab, color=color, ha='center', va='center', clip_on=True, rotation=angle, fontsize=12.0) lab = u'-j%d\u03A9' % tick axes.text(x, -y, lab, color=color, ha='center', va='center', clip_on=True, rotation=-angle, fontsize=12.0) def plot_smith(self): if self.cursor is not None: self.cursor.hide().disable() matplotlib.rcdefaults() self.figure.clf() self.figure.subplots_adjust(left=0.0, bottom=0.0, right=1.0, top=1.0) axes1 = self.figure.add_subplot(111) self.plot_smith_grid(axes1, 'blue') gamma = self.gamma() plot, = axes1.plot(gamma.real, gamma.imag, color='red') axes1.axis('equal') axes1.set_xlim(-1.12, 1.12) axes1.set_ylim(-1.12, 1.12) axes1.xaxis.set_visible(False) axes1.yaxis.set_visible(False) for loc, spine in axes1.spines.items(): spine.set_visible(False) self.cursor = datacursor(plot, formatter=SmithFormatter(self.dut.freq), display='multiple') self.canvas.draw() def plot_imp(self): self.plot_magphase(self.dut.freq, self.impedance()) def plot_rc(self): self.plot_magphase(self.dut.freq, self.gamma()) def plot_swr(self): if self.cursor is not None: self.cursor.hide().disable() matplotlib.rcdefaults() self.figure.clf() self.figure.subplots_adjust(left=0.12, bottom=0.12, right=0.88, top=0.98) axes1 = self.figure.add_subplot(111) axes1.cla() axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix)) axes1.yaxis.set_major_formatter(FuncFormatter(metric_prefix)) axes1.set_xlabel('Hz') axes1.set_ylabel('SWR') magnitude = np.absolute(self.gamma()) swr = np.maximum( 1.0, np.minimum(100.0, (1.0 + magnitude) / np.maximum(1.0e-20, 1.0 - magnitude))) axes1.plot(self.dut.freq, swr, color='blue', label='SWR') self.cursor = datacursor(axes=self.figure.get_axes(), formatter=LabelFormatter(), display='multiple') self.canvas.draw() def plot_rl(self): if self.cursor is not None: self.cursor.hide().disable() matplotlib.rcdefaults() self.figure.clf() self.figure.subplots_adjust(left=0.12, bottom=0.12, right=0.88, top=0.98) axes1 = self.figure.add_subplot(111) axes1.cla() axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix)) axes1.set_xlabel('Hz') axes1.set_ylabel('Return loss, dB') magnitude = np.absolute(self.gamma()) axes1.plot(self.dut.freq, 20.0 * np.log10(magnitude), color='blue', label='Return loss') self.cursor = datacursor(axes=self.figure.get_axes(), formatter=LabelFormatter(), display='multiple') self.canvas.draw() def write_cfg(self): dialog = QFileDialog(self, 'Write configuration settings', '.', '*.ini') dialog.setDefaultSuffix('ini') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() settings = QSettings(name[0], QSettings.IniFormat) self.write_cfg_settings(settings) def read_cfg(self): dialog = QFileDialog(self, 'Read configuration settings', '.', '*.ini') dialog.setDefaultSuffix('ini') dialog.setAcceptMode(QFileDialog.AcceptOpen) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() settings = QSettings(name[0], QSettings.IniFormat) self.read_cfg_settings(settings) def write_cfg_settings(self, settings): settings.setValue('addr', self.addrValue.text()) settings.setValue('rate', self.rateValue.currentIndex()) settings.setValue('corr', self.corrValue.value()) settings.setValue('open_start', int(self.open.freq[0])) settings.setValue('open_stop', int(self.open.freq[-1])) settings.setValue('open_size', self.open.freq.size) settings.setValue('short_start', int(self.short.freq[0])) settings.setValue('short_stop', int(self.short.freq[-1])) settings.setValue('short_size', self.short.freq.size) settings.setValue('load_start', int(self.load.freq[0])) settings.setValue('load_stop', int(self.load.freq[-1])) settings.setValue('load_size', self.load.freq.size) settings.setValue('dut_start', int(self.dut.freq[0])) settings.setValue('dut_stop', int(self.dut.freq[-1])) settings.setValue('dut_size', self.dut.freq.size) data = self.open.data for i in range(0, self.open.freq.size): settings.setValue('open_real_%d' % i, float(data.real[i])) settings.setValue('open_imag_%d' % i, float(data.imag[i])) data = self.short.data for i in range(0, self.short.freq.size): settings.setValue('short_real_%d' % i, float(data.real[i])) settings.setValue('short_imag_%d' % i, float(data.imag[i])) data = self.load.data for i in range(0, self.load.freq.size): settings.setValue('load_real_%d' % i, float(data.real[i])) settings.setValue('load_imag_%d' % i, float(data.imag[i])) data = self.dut.data for i in range(0, self.dut.freq.size): settings.setValue('dut_real_%d' % i, float(data.real[i])) settings.setValue('dut_imag_%d' % i, float(data.imag[i])) def read_cfg_settings(self, settings): self.addrValue.setText(settings.value('addr', '192.168.1.100')) self.rateValue.setCurrentIndex(settings.value('rate', 0, type=int)) self.corrValue.setValue(settings.value('corr', 0, type=int)) open_start = settings.value('open_start', 10000, type=int) // 1000 open_stop = settings.value('open_stop', 60000000, type=int) // 1000 open_size = settings.value('open_size', 6000, type=int) short_start = settings.value('short_start', 10000, type=int) // 1000 short_stop = settings.value('short_stop', 60000000, type=int) // 1000 short_size = settings.value('short_size', 6000, type=int) load_start = settings.value('load_start', 10000, type=int) // 1000 load_stop = settings.value('load_stop', 60000000, type=int) // 1000 load_size = settings.value('load_size', 6000, type=int) dut_start = settings.value('dut_start', 10000, type=int) // 1000 dut_stop = settings.value('dut_stop', 60000000, type=int) // 1000 dut_size = settings.value('dut_size', 6000, type=int) self.startValue.setValue(dut_start) self.stopValue.setValue(dut_stop) self.sizeValue.setValue(dut_size) self.open = Measurement(open_start, open_stop, open_size) for i in range(0, open_size): real = settings.value('open_real_%d' % i, 0.0, type=float) imag = settings.value('open_imag_%d' % i, 0.0, type=float) self.open.data[i] = real + 1.0j * imag self.short = Measurement(short_start, short_stop, short_size) for i in range(0, short_size): real = settings.value('short_real_%d' % i, 0.0, type=float) imag = settings.value('short_imag_%d' % i, 0.0, type=float) self.short.data[i] = real + 1.0j * imag self.load = Measurement(load_start, load_stop, load_size) for i in range(0, load_size): real = settings.value('load_real_%d' % i, 0.0, type=float) imag = settings.value('load_imag_%d' % i, 0.0, type=float) self.load.data[i] = real + 1.0j * imag self.dut = Measurement(dut_start, dut_stop, dut_size) for i in range(0, dut_size): real = settings.value('dut_real_%d' % i, 0.0, type=float) imag = settings.value('dut_imag_%d' % i, 0.0, type=float) self.dut.data[i] = real + 1.0j * imag def write_csv(self): dialog = QFileDialog(self, 'Write csv file', '.', '*.csv') dialog.setDefaultSuffix('csv') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() fh = open(name[0], 'w') o = self.interp(self.open.freq, self.open.data) s = self.interp(self.short.freq, self.short.data) l = self.interp(self.load.freq, self.load.data) d = self.dut.data f = self.dut.freq fh.write( 'frequency;open.real;open.imag;short.real;short.imag;load.real;load.imag;dut.real;dut.imag\n' ) for i in range(0, f.size): fh.write( '0.0%.8d;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f\n' % (f[i], o.real[i], o.imag[i], s.real[i], s.imag[i], l.real[i], l.imag[i], d.real[i], d.imag[i])) fh.close() def write_s1p(self): dialog = QFileDialog(self, 'Write s1p file', '.', '*.s1p') dialog.setDefaultSuffix('s1p') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() fh = open(name[0], 'w') gamma = self.gamma() freq = self.dut.freq fh.write('# GHz S MA R 50\n') for i in range(0, freq.size): fh.write('0.0%.8d %8.6f %7.2f\n' % (freq[i], np.absolute( gamma[i]), np.angle(gamma[i], deg=True))) fh.close() def write_s2p(self): dialog = QFileDialog(self, 'Write s2p file', '.', '*.s2p') dialog.setDefaultSuffix('s2p') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() fh = open(name[0], 'w') gain = self.gain() gamma = self.gamma() freq = self.dut.freq fh.write('# GHz S MA R 50\n') for i in range(0, freq.size): fh.write( '0.0%.8d %8.6f %7.2f %8.6f %7.2f 0.000000 0.00 0.000000 0.00\n' % (freq[i], np.absolute(gamma[i]), np.angle(gamma[i], deg=True), np.absolute( gain[i]), np.angle(gain[i], deg=True))) fh.close()
draw = False for item in self.menuitems: draw = item.set_hover(event) if draw: self.figure.canvas.draw() break app = QApplication(sys.argv) fig = Figure(figsize=(8, 6)) canvas = FigureCanvas(fig) canvas.resize(640, 480) canvas.show() fig.subplots_adjust(left=0.3) props = ItemProperties(labelcolor='black', bgcolor='yellow', fontsize=15, alpha=0.2) hoverprops = ItemProperties(labelcolor='white', bgcolor='blue', fontsize=15, alpha=0.2) menuitems = [] for label in ('open', 'close', 'save', 'save as', 'quit'): def on_select(item): print('you selected %s' % item.labelstr)
class HorizonFrame(wx.Frame): """ The main frame of the horizon indicator.""" def __init__(self, state, title): self.state = state # Create Frame and Panel(s) wx.Frame.__init__(self, None, title=title) state.frame = self # Initialisation self.initData() self.initUI() self.startTime = time.time() self.nextTime = 0.0 self.fps = 10.0 def initData(self): # Initialise Attitude self.pitch = 0.0 # Degrees self.roll = 0.0 # Degrees self.yaw = 0.0 # Degrees # History Values self.oldRoll = 0.0 # Degrees # Initialise Rate Information self.airspeed = 0.0 # m/s self.relAlt = 0.0 # m relative to home position self.relAltTime = 0.0 # s The time that the relative altitude was recorded self.climbRate = 0.0 # m/s self.altHist = [] # Altitude History self.timeHist = [] # Time History self.altMax = 0.0 # Maximum altitude since startup # Initialise HUD Info self.heading = 0.0 # 0-360 # Initialise Battery Info self.voltage = 0.0 self.current = 0.0 self.batRemain = 0.0 # Initialise Mode and State self.mode = 'UNKNOWN' self.armed = '' self.safetySwitch = '' # Intialise Waypoint Information self.currentWP = 0 self.finalWP = 0 self.wpDist = 0 self.nextWPTime = 0 self.wpBearing = 0 def initUI(self): # Create Event Timer and Bindings self.timer = wx.Timer(self) self.Bind(wx.EVT_TIMER, self.on_timer, self.timer) self.timer.Start(100) self.Bind(wx.EVT_IDLE, self.on_idle) self.Bind(wx.EVT_CHAR_HOOK,self.on_KeyPress) # Create Panel self.panel = wx.Panel(self) self.vertSize = 0.09 self.resized = False # Create Matplotlib Panel self.createPlotPanel() # Fix Axes - vertical is of length 2, horizontal keeps the same lengthscale self.rescaleX() self.calcFontScaling() # Create Horizon Polygons self.createHorizonPolygons() # Center Pointer Marker self.thick = 0.015 self.createCenterPointMarker() # Pitch Markers self.dist10deg = 0.2 # Graph distance per 10 deg self.createPitchMarkers() # Add Roll, Pitch, Yaw Text self.createRPYText() # Add Airspeed, Altitude, Climb Rate Text self.createAARText() # Create Heading Pointer self.createHeadingPointer() # Create North Pointer self.createNorthPointer() # Create Battery Bar self.batWidth = 0.1 self.batHeight = 0.2 self.rOffset = 0.35 self.createBatteryBar() # Create Mode & State Text self.createStateText() # Create Waypoint Text self.createWPText() # Create Waypoint Pointer self.createWPPointer() # Create Altitude History Plot self.createAltHistoryPlot() # Show Frame self.Show(True) self.pending = [] def createPlotPanel(self): '''Creates the figure and axes for the plotting panel.''' self.figure = Figure() self.axes = self.figure.add_subplot(111) self.canvas = FigureCanvas(self,-1,self.figure) self.canvas.SetSize(wx.Size(300,300)) self.axes.axis('off') self.figure.subplots_adjust(left=0,right=1,top=1,bottom=0) self.sizer = wx.BoxSizer(wx.VERTICAL) self.sizer.Add(self.canvas,1,wx.EXPAND,wx.ALL) self.SetSizerAndFit(self.sizer) self.Fit() def rescaleX(self): '''Rescales the horizontal axes to make the lengthscales equal.''' self.ratio = self.figure.get_size_inches()[0]/float(self.figure.get_size_inches()[1]) self.axes.set_xlim(-self.ratio,self.ratio) self.axes.set_ylim(-1,1) def calcFontScaling(self): '''Calculates the current font size and left position for the current window.''' self.ypx = self.figure.get_size_inches()[1]*self.figure.dpi self.xpx = self.figure.get_size_inches()[0]*self.figure.dpi self.fontSize = self.vertSize*(self.ypx/2.0) self.leftPos = self.axes.get_xlim()[0] self.rightPos = self.axes.get_xlim()[1] def checkReszie(self): '''Checks if the window was resized.''' if not self.resized: oldypx = self.ypx oldxpx = self.xpx self.ypx = self.figure.get_size_inches()[1]*self.figure.dpi self.xpx = self.figure.get_size_inches()[0]*self.figure.dpi if (oldypx != self.ypx) or (oldxpx != self.xpx): self.resized = True else: self.resized = False def createHeadingPointer(self): '''Creates the pointer for the current heading.''' self.headingTri = patches.RegularPolygon((0.0,0.80),3,0.05,color='k',zorder=4) self.axes.add_patch(self.headingTri) self.headingText = self.axes.text(0.0,0.675,'0',color='k',size=self.fontSize,horizontalalignment='center',verticalalignment='center',zorder=4) def adjustHeadingPointer(self): '''Adjust the value of the heading pointer.''' self.headingText.set_text(str(self.heading)) self.headingText.set_size(self.fontSize) def createNorthPointer(self): '''Creates the north pointer relative to current heading.''' self.headingNorthTri = patches.RegularPolygon((0.0,0.80),3,0.05,color='k',zorder=4) self.axes.add_patch(self.headingNorthTri) self.headingNorthText = self.axes.text(0.0,0.675,'N',color='k',size=self.fontSize,horizontalalignment='center',verticalalignment='center',zorder=4) def adjustNorthPointer(self): '''Adjust the position and orientation of the north pointer.''' self.headingNorthText.set_size(self.fontSize) headingRotate = mpl.transforms.Affine2D().rotate_deg_around(0.0,0.0,self.heading)+self.axes.transData self.headingNorthText.set_transform(headingRotate) if (self.heading > 90) and (self.heading < 270): headRot = self.heading-180 else: headRot = self.heading self.headingNorthText.set_rotation(headRot) self.headingNorthTri.set_transform(headingRotate) # Adjust if overlapping with heading pointer if (self.heading <= 10.0) or (self.heading >= 350.0): self.headingNorthText.set_text('') else: self.headingNorthText.set_text('N') def toggleWidgets(self,widgets): '''Hides/shows the given widgets.''' for wig in widgets: if wig.get_visible(): wig.set_visible(False) else: wig.set_visible(True) def createRPYText(self): '''Creates the text for roll, pitch and yaw.''' self.rollText = self.axes.text(self.leftPos+(self.vertSize/10.0),-0.97+(2*self.vertSize)-(self.vertSize/10.0),'Roll: %.2f' % self.roll,color='w',size=self.fontSize) self.pitchText = self.axes.text(self.leftPos+(self.vertSize/10.0),-0.97+self.vertSize-(0.5*self.vertSize/10.0),'Pitch: %.2f' % self.pitch,color='w',size=self.fontSize) self.yawText = self.axes.text(self.leftPos+(self.vertSize/10.0),-0.97,'Yaw: %.2f' % self.yaw,color='w',size=self.fontSize) self.rollText.set_path_effects([PathEffects.withStroke(linewidth=1,foreground='k')]) self.pitchText.set_path_effects([PathEffects.withStroke(linewidth=1,foreground='k')]) self.yawText.set_path_effects([PathEffects.withStroke(linewidth=1,foreground='k')]) def updateRPYLocations(self): '''Update the locations of roll, pitch, yaw text.''' # Locations self.rollText.set_position((self.leftPos+(self.vertSize/10.0),-0.97+(2*self.vertSize)-(self.vertSize/10.0))) self.pitchText.set_position((self.leftPos+(self.vertSize/10.0),-0.97+self.vertSize-(0.5*self.vertSize/10.0))) self.yawText.set_position((self.leftPos+(self.vertSize/10.0),-0.97)) # Font Size self.rollText.set_size(self.fontSize) self.pitchText.set_size(self.fontSize) self.yawText.set_size(self.fontSize) def updateRPYText(self): 'Updates the displayed Roll, Pitch, Yaw Text' self.rollText.set_text('Roll: %.2f' % self.roll) self.pitchText.set_text('Pitch: %.2f' % self.pitch) self.yawText.set_text('Yaw: %.2f' % self.yaw) def createCenterPointMarker(self): '''Creates the center pointer in the middle of the screen.''' self.axes.add_patch(patches.Rectangle((-0.75,-self.thick),0.5,2.0*self.thick,facecolor='orange',zorder=3)) self.axes.add_patch(patches.Rectangle((0.25,-self.thick),0.5,2.0*self.thick,facecolor='orange',zorder=3)) self.axes.add_patch(patches.Circle((0,0),radius=self.thick,facecolor='orange',edgecolor='none',zorder=3)) def createHorizonPolygons(self): '''Creates the two polygons to show the sky and ground.''' # Sky Polygon vertsTop = [[-1,0],[-1,1],[1,1],[1,0],[-1,0]] self.topPolygon = Polygon(vertsTop,facecolor='dodgerblue',edgecolor='none') self.axes.add_patch(self.topPolygon) # Ground Polygon vertsBot = [[-1,0],[-1,-1],[1,-1],[1,0],[-1,0]] self.botPolygon = Polygon(vertsBot,facecolor='brown',edgecolor='none') self.axes.add_patch(self.botPolygon) def calcHorizonPoints(self): '''Updates the verticies of the patches for the ground and sky.''' ydiff = math.tan(math.radians(-self.roll))*float(self.ratio) pitchdiff = self.dist10deg*(self.pitch/10.0) # Sky Polygon vertsTop = [(-self.ratio,ydiff-pitchdiff),(-self.ratio,1),(self.ratio,1),(self.ratio,-ydiff-pitchdiff),(-self.ratio,ydiff-pitchdiff)] self.topPolygon.set_xy(vertsTop) # Ground Polygon vertsBot = [(-self.ratio,ydiff-pitchdiff),(-self.ratio,-1),(self.ratio,-1),(self.ratio,-ydiff-pitchdiff),(-self.ratio,ydiff-pitchdiff)] self.botPolygon.set_xy(vertsBot) def createPitchMarkers(self): '''Creates the rectangle patches for the pitch indicators.''' self.pitchPatches = [] # Major Lines (multiple of 10 deg) for i in [-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9]: width = self.calcPitchMarkerWidth(i) currPatch = patches.Rectangle((-width/2.0,self.dist10deg*i-(self.thick/2.0)),width,self.thick,facecolor='w',edgecolor='none') self.axes.add_patch(currPatch) self.pitchPatches.append(currPatch) # Add Label for +-30 deg self.vertSize = 0.09 self.pitchLabelsLeft = [] self.pitchLabelsRight = [] i=0 for j in [-90,-60,-30,30,60,90]: self.pitchLabelsLeft.append(self.axes.text(-0.55,(j/10.0)*self.dist10deg,str(j),color='w',size=self.fontSize,horizontalalignment='center',verticalalignment='center')) self.pitchLabelsLeft[i].set_path_effects([PathEffects.withStroke(linewidth=1,foreground='k')]) self.pitchLabelsRight.append(self.axes.text(0.55,(j/10.0)*self.dist10deg,str(j),color='w',size=self.fontSize,horizontalalignment='center',verticalalignment='center')) self.pitchLabelsRight[i].set_path_effects([PathEffects.withStroke(linewidth=1,foreground='k')]) i += 1 def calcPitchMarkerWidth(self,i): '''Calculates the width of a pitch marker.''' if (i % 3) == 0: if i == 0: width = 1.5 else: width = 0.9 else: width = 0.6 return width def adjustPitchmarkers(self): '''Adjusts the location and orientation of pitch markers.''' pitchdiff = self.dist10deg*(self.pitch/10.0) rollRotate = mpl.transforms.Affine2D().rotate_deg_around(0.0,-pitchdiff,self.roll)+self.axes.transData j=0 for i in [-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9]: width = self.calcPitchMarkerWidth(i) self.pitchPatches[j].set_xy((-width/2.0,self.dist10deg*i-(self.thick/2.0)-pitchdiff)) self.pitchPatches[j].set_transform(rollRotate) j+=1 # Adjust Text Size and rotation i=0 for j in [-9,-6,-3,3,6,9]: self.pitchLabelsLeft[i].set_y(j*self.dist10deg-pitchdiff) self.pitchLabelsRight[i].set_y(j*self.dist10deg-pitchdiff) self.pitchLabelsLeft[i].set_size(self.fontSize) self.pitchLabelsRight[i].set_size(self.fontSize) self.pitchLabelsLeft[i].set_rotation(self.roll) self.pitchLabelsRight[i].set_rotation(self.roll) self.pitchLabelsLeft[i].set_transform(rollRotate) self.pitchLabelsRight[i].set_transform(rollRotate) i += 1 def createAARText(self): '''Creates the text for airspeed, altitude and climb rate.''' self.airspeedText = self.axes.text(self.rightPos-(self.vertSize/10.0),-0.97+(2*self.vertSize)-(self.vertSize/10.0),'AS: %.1f m/s' % self.airspeed,color='w',size=self.fontSize,ha='right') self.altitudeText = self.axes.text(self.rightPos-(self.vertSize/10.0),-0.97+self.vertSize-(0.5*self.vertSize/10.0),'ALT: %.1f m ' % self.relAlt,color='w',size=self.fontSize,ha='right') self.climbRateText = self.axes.text(self.rightPos-(self.vertSize/10.0),-0.97,'CR: %.1f m/s' % self.climbRate,color='w',size=self.fontSize,ha='right') self.airspeedText.set_path_effects([PathEffects.withStroke(linewidth=1,foreground='k')]) self.altitudeText.set_path_effects([PathEffects.withStroke(linewidth=1,foreground='k')]) self.climbRateText.set_path_effects([PathEffects.withStroke(linewidth=1,foreground='k')]) def updateAARLocations(self): '''Update the locations of airspeed, altitude and Climb rate.''' # Locations self.airspeedText.set_position((self.rightPos-(self.vertSize/10.0),-0.97+(2*self.vertSize)-(self.vertSize/10.0))) self.altitudeText.set_position((self.rightPos-(self.vertSize/10.0),-0.97+self.vertSize-(0.5*self.vertSize/10.0))) self.climbRateText.set_position((self.rightPos-(self.vertSize/10.0),-0.97)) # Font Size self.airspeedText.set_size(self.fontSize) self.altitudeText.set_size(self.fontSize) self.climbRateText.set_size(self.fontSize) def updateAARText(self): 'Updates the displayed airspeed, altitude, climb rate Text' self.airspeedText.set_text('AR: %.1f m/s' % self.airspeed) self.altitudeText.set_text('ALT: %.1f m ' % self.relAlt) self.climbRateText.set_text('CR: %.1f m/s' % self.climbRate) def createBatteryBar(self): '''Creates the bar to display current battery percentage.''' self.batOutRec = patches.Rectangle((self.rightPos-(1.3+self.rOffset)*self.batWidth,1.0-(0.1+1.0+(2*0.075))*self.batHeight),self.batWidth*1.3,self.batHeight*1.15,facecolor='darkgrey',edgecolor='none') self.batInRec = patches.Rectangle((self.rightPos-(self.rOffset+1+0.15)*self.batWidth,1.0-(0.1+1+0.075)*self.batHeight),self.batWidth,self.batHeight,facecolor='lawngreen',edgecolor='none') self.batPerText = self.axes.text(self.rightPos - (self.rOffset+0.65)*self.batWidth,1-(0.1+1+(0.075+0.15))*self.batHeight,'%.f' % self.batRemain,color='w',size=self.fontSize,ha='center',va='top') self.batPerText.set_path_effects([PathEffects.withStroke(linewidth=1,foreground='k')]) self.voltsText = self.axes.text(self.rightPos-(self.rOffset+1.3+0.2)*self.batWidth,1-(0.1+0.05+0.075)*self.batHeight,'%.1f V' % self.voltage,color='w',size=self.fontSize,ha='right',va='top') self.ampsText = self.axes.text(self.rightPos-(self.rOffset+1.3+0.2)*self.batWidth,1-self.vertSize-(0.1+0.05+0.1+0.075)*self.batHeight,'%.1f A' % self.current,color='w',size=self.fontSize,ha='right',va='top') self.voltsText.set_path_effects([PathEffects.withStroke(linewidth=1,foreground='k')]) self.ampsText.set_path_effects([PathEffects.withStroke(linewidth=1,foreground='k')]) self.axes.add_patch(self.batOutRec) self.axes.add_patch(self.batInRec) def updateBatteryBar(self): '''Updates the position and values of the battery bar.''' # Bar self.batOutRec.set_xy((self.rightPos-(1.3+self.rOffset)*self.batWidth,1.0-(0.1+1.0+(2*0.075))*self.batHeight)) self.batInRec.set_xy((self.rightPos-(self.rOffset+1+0.15)*self.batWidth,1.0-(0.1+1+0.075)*self.batHeight)) self.batPerText.set_position((self.rightPos - (self.rOffset+0.65)*self.batWidth,1-(0.1+1+(0.075+0.15))*self.batHeight)) self.batPerText.set_fontsize(self.fontSize) self.voltsText.set_text('%.1f V' % self.voltage) self.ampsText.set_text('%.1f A' % self.current) self.voltsText.set_position((self.rightPos-(self.rOffset+1.3+0.2)*self.batWidth,1-(0.1+0.05)*self.batHeight)) self.ampsText.set_position((self.rightPos-(self.rOffset+1.3+0.2)*self.batWidth,1-self.vertSize-(0.1+0.05+0.1)*self.batHeight)) self.voltsText.set_fontsize(self.fontSize) self.ampsText.set_fontsize(self.fontSize) if self.batRemain >= 0: self.batPerText.set_text(int(self.batRemain)) self.batInRec.set_height(self.batRemain*self.batHeight/100.0) if self.batRemain/100.0 > 0.5: self.batInRec.set_facecolor('lawngreen') elif self.batRemain/100.0 <= 0.5 and self.batRemain/100.0 > 0.2: self.batInRec.set_facecolor('yellow') elif self.batRemain/100.0 <= 0.2 and self.batRemain >= 0.0: self.batInRec.set_facecolor('r') elif self.batRemain == -1: self.batInRec.set_height(self.batHeight) self.batInRec.set_facecolor('k') def createStateText(self): '''Creates the mode and arm state text.''' self.modeText = self.axes.text(self.leftPos+(self.vertSize/10.0),0.97,'UNKNOWN',color='grey',size=1.5*self.fontSize,ha='left',va='top') self.modeText.set_path_effects([PathEffects.withStroke(linewidth=self.fontSize/10.0,foreground='black')]) def updateStateText(self): '''Updates the mode and colours red or green depending on arm state.''' self.modeText.set_position((self.leftPos+(self.vertSize/10.0),0.97)) self.modeText.set_text(self.mode) self.modeText.set_size(1.5*self.fontSize) if self.armed: self.modeText.set_color('red') self.modeText.set_path_effects([PathEffects.withStroke(linewidth=self.fontSize/10.0,foreground='yellow')]) elif (self.armed == False): self.modeText.set_color('lightgreen') self.modeText.set_bbox(None) self.modeText.set_path_effects([PathEffects.withStroke(linewidth=1,foreground='black')]) else: # Fall back if unknown self.modeText.set_color('grey') self.modeText.set_bbox(None) self.modeText.set_path_effects([PathEffects.withStroke(linewidth=self.fontSize/10.0,foreground='black')]) def createWPText(self): '''Creates the text for the current and final waypoint, and the distance to the new waypoint.''' self.wpText = self.axes.text(self.leftPos+(1.5*self.vertSize/10.0),0.97-(1.5*self.vertSize)+(0.5*self.vertSize/10.0),'0/0\n(0 m, 0 s)',color='w',size=self.fontSize,ha='left',va='top') self.wpText.set_path_effects([PathEffects.withStroke(linewidth=1,foreground='black')]) def updateWPText(self): '''Updates the current waypoint and distance to it.''' self.wpText.set_position((self.leftPos+(1.5*self.vertSize/10.0),0.97-(1.5*self.vertSize)+(0.5*self.vertSize/10.0))) self.wpText.set_size(self.fontSize) if type(self.nextWPTime) is str: self.wpText.set_text('%.f/%.f\n(%.f m, ~ s)' % (self.currentWP,self.finalWP,self.wpDist)) else: self.wpText.set_text('%.f/%.f\n(%.f m, %.f s)' % (self.currentWP,self.finalWP,self.wpDist,self.nextWPTime)) def createWPPointer(self): '''Creates the waypoint pointer relative to current heading.''' self.headingWPTri = patches.RegularPolygon((0.0,0.55),3,0.05,facecolor='lime',zorder=4,ec='k') self.axes.add_patch(self.headingWPTri) self.headingWPText = self.axes.text(0.0,0.45,'1',color='lime',size=self.fontSize,horizontalalignment='center',verticalalignment='center',zorder=4) self.headingWPText.set_path_effects([PathEffects.withStroke(linewidth=1,foreground='k')]) def adjustWPPointer(self): '''Adjust the position and orientation of the waypoint pointer.''' self.headingWPText.set_size(self.fontSize) headingRotate = mpl.transforms.Affine2D().rotate_deg_around(0.0,0.0,-self.wpBearing+self.heading)+self.axes.transData self.headingWPText.set_transform(headingRotate) angle = self.wpBearing - self.heading if angle < 0: angle += 360 if (angle > 90) and (angle < 270): headRot = angle-180 else: headRot = angle self.headingWPText.set_rotation(-headRot) self.headingWPTri.set_transform(headingRotate) self.headingWPText.set_text('%.f' % (angle)) def createAltHistoryPlot(self): '''Creates the altitude history plot.''' self.altHistRect = patches.Rectangle((self.leftPos+(self.vertSize/10.0),-0.25),0.5,0.5,facecolor='grey',edgecolor='none',alpha=0.4,zorder=4) self.axes.add_patch(self.altHistRect) self.altPlot, = self.axes.plot([self.leftPos+(self.vertSize/10.0),self.leftPos+(self.vertSize/10.0)+0.5],[0.0,0.0],color='k',marker=None,zorder=4) self.altMarker, = self.axes.plot(self.leftPos+(self.vertSize/10.0)+0.5,0.0,marker='o',color='k',zorder=4) self.altText2 = self.axes.text(self.leftPos+(4*self.vertSize/10.0)+0.5,0.0,'%.f m' % self.relAlt,color='k',size=self.fontSize,ha='left',va='center',zorder=4) def updateAltHistory(self): '''Updates the altitude history plot.''' self.altHist.append(self.relAlt) self.timeHist.append(self.relAltTime) # Delete entries older than x seconds histLim = 10 currentTime = time.time() point = 0 for i in range(0,len(self.timeHist)): if (self.timeHist[i] > (currentTime - 10.0)): break # Remove old entries self.altHist = self.altHist[i:] self.timeHist = self.timeHist[i:] # Transform Data x = [] y = [] tmin = min(self.timeHist) tmax = max(self.timeHist) x1 = self.leftPos+(self.vertSize/10.0) y1 = -0.25 altMin = 0 altMax = max(self.altHist) # Keep alt max for whole mission if altMax > self.altMax: self.altMax = altMax else: altMax = self.altMax if tmax != tmin: mx = 0.5/(tmax-tmin) else: mx = 0.0 if altMax != altMin: my = 0.5/(altMax-altMin) else: my = 0.0 for t in self.timeHist: x.append(mx*(t-tmin)+x1) for alt in self.altHist: val = my*(alt-altMin)+y1 # Crop extreme noise if val < -0.25: val = -0.25 elif val > 0.25: val = 0.25 y.append(val) # Display Plot self.altHistRect.set_x(self.leftPos+(self.vertSize/10.0)) self.altPlot.set_data(x,y) self.altMarker.set_data(self.leftPos+(self.vertSize/10.0)+0.5,val) self.altText2.set_position((self.leftPos+(4*self.vertSize/10.0)+0.5,val)) self.altText2.set_size(self.fontSize) self.altText2.set_text('%.f m' % self.relAlt) # =============== Event Bindings =============== # def on_idle(self, event): '''To adjust text and positions on rescaling the window when resized.''' # Check for resize self.checkReszie() if self.resized: # Fix Window Scales self.rescaleX() self.calcFontScaling() # Recalculate Horizon Polygons self.calcHorizonPoints() # Update Roll, Pitch, Yaw Text Locations self.updateRPYLocations() # Update Airpseed, Altitude, Climb Rate Locations self.updateAARLocations() # Update Pitch Markers self.adjustPitchmarkers() # Update Heading and North Pointer self.adjustHeadingPointer() self.adjustNorthPointer() # Update Battery Bar self.updateBatteryBar() # Update Mode and State self.updateStateText() # Update Waypoint Text self.updateWPText() # Adjust Waypoint Pointer self.adjustWPPointer() # Update History Plot self.updateAltHistory() # Update Matplotlib Plot self.canvas.draw() self.canvas.Refresh() self.resized = False time.sleep(0.05) def on_timer(self, event): '''Main Loop.''' state = self.state self.loopStartTime = time.time() if state.close_event.wait(0.001): self.timer.Stop() self.Destroy() return # Check for resizing self.checkReszie() if self.resized: self.on_idle(0) # Get attitude information while state.child_pipe_recv.poll(): objList = state.child_pipe_recv.recv() for obj in objList: self.calcFontScaling() if isinstance(obj,Attitude): self.oldRoll = self.roll self.pitch = obj.pitch*180/math.pi self.roll = obj.roll*180/math.pi self.yaw = obj.yaw*180/math.pi # Update Roll, Pitch, Yaw Text Text self.updateRPYText() # Recalculate Horizon Polygons self.calcHorizonPoints() # Update Pitch Markers self.adjustPitchmarkers() elif isinstance(obj,VFR_HUD): self.heading = obj.heading self.airspeed = obj.airspeed self.climbRate = obj.climbRate # Update Airpseed, Altitude, Climb Rate Locations self.updateAARText() # Update Heading North Pointer self.adjustHeadingPointer() self.adjustNorthPointer() elif isinstance(obj,Global_Position_INT): self.relAlt = obj.relAlt self.relAltTime = obj.curTime # Update Airpseed, Altitude, Climb Rate Locations self.updateAARText() # Update Altitude History self.updateAltHistory() elif isinstance(obj,BatteryInfo): self.voltage = obj.voltage self.current = obj.current self.batRemain = obj.batRemain # Update Battery Bar self.updateBatteryBar() elif isinstance(obj,FlightState): self.mode = obj.mode self.armed = obj.armState # Update Mode and Arm State Text self.updateStateText() elif isinstance(obj,WaypointInfo): self.currentWP = obj.current self.finalWP = obj.final self.wpDist = obj.currentDist self.nextWPTime = obj.nextWPTime if obj.wpBearing < 0.0: self.wpBearing = obj.wpBearing + 360 else: self.wpBearing = obj.wpBearing # Update waypoint text self.updateWPText() # Adjust Waypoint Pointer self.adjustWPPointer() elif isinstance(obj, FPS): # Update fps target self.fps = obj.fps # Quit Drawing if too early if (time.time() > self.nextTime): # Update Matplotlib Plot self.canvas.draw() self.canvas.Refresh() self.Refresh() self.Update() # Calculate next frame time if (self.fps > 0): fpsTime = 1/self.fps self.nextTime = fpsTime + self.loopStartTime else: self.nextTime = time.time() def on_KeyPress(self,event): '''To adjust the distance between pitch markers.''' if event.GetKeyCode() == wx.WXK_UP: self.dist10deg += 0.1 print('Dist per 10 deg: %.1f' % self.dist10deg) elif event.GetKeyCode() == wx.WXK_DOWN: self.dist10deg -= 0.1 if self.dist10deg <= 0: self.dist10deg = 0.1 print('Dist per 10 deg: %.1f' % self.dist10deg) # Toggle Widgets elif event.GetKeyCode() == 49: # 1 widgets = [self.modeText,self.wpText] self.toggleWidgets(widgets) elif event.GetKeyCode() == 50: # 2 widgets = [self.batOutRec,self.batInRec,self.voltsText,self.ampsText,self.batPerText] self.toggleWidgets(widgets) elif event.GetKeyCode() == 51: # 3 widgets = [self.rollText,self.pitchText,self.yawText] self.toggleWidgets(widgets) elif event.GetKeyCode() == 52: # 4 widgets = [self.airspeedText,self.altitudeText,self.climbRateText] self.toggleWidgets(widgets) elif event.GetKeyCode() == 53: # 5 widgets = [self.altHistRect,self.altPlot,self.altMarker,self.altText2] self.toggleWidgets(widgets) elif event.GetKeyCode() == 54: # 6 widgets = [self.headingTri,self.headingText,self.headingNorthTri,self.headingNorthText,self.headingWPTri,self.headingWPText] self.toggleWidgets(widgets) # Update Matplotlib Plot self.canvas.draw() self.canvas.Refresh() self.Refresh() self.Update()
class func(object): def __init__(self, fm, page, setUIPage, setSwitchingEnabled): self.page = page self.setUIPage = setUIPage self.setMainSwitchingEnabled = setSwitchingEnabled self.module = fm.module() self.module_exists = None self.routine_stage = None self.routine_activity = None # many other internal variables self.mode = 'setup' # routine_setup variables self.routine_setup_ready = None self.routine_setup_issues = { 'keithley_no_port': None, 'module_exists_false': None, 'module_ready_false': None, } self.routine_setup_issues_console = { 'keithley_no_port': 'No COM port selected for keithley', 'module_exists_false': 'Selected module with ID {} does not exist', 'module_ready_false': 'Selected module with ID {} not ready for IV curve', } def enforce_mode(mode): if not (type(mode) in [str, list]): raise ValueError def wrapper(function): def wrapped_function(self, *args, **kwargs): if type(mode) is str: valid_mode = self.mode == mode elif type(mode) is list: valid_mode = self.mode in mode else: valid_mode = False if valid_mode: if DEBUG: print( "page {} with mode {} req {} calling function {} with args {} kwargs {}" .format( PAGE_NAME, self.mode, mode, function.__name__, args, kwargs, )) function(self, *args, **kwargs) else: print( "page {} mode is {}, needed {} for function {} with args {} kwargs {}" .format( PAGE_NAME, self.mode, mode, function.__name__, args, kwargs, )) return wrapped_function return wrapper @enforce_mode('setup') def setup(self): self.setupFigures() self.rig() self.mode = 'routine_setup' print("{} setup completed".format(PAGE_NAME)) self.update_info() def setupFigures(self): self.all_fig = Figure() self.all_ax = self.all_fig.add_subplot(111) self.all_fc = FigureCanvas(self.all_fig) self.all_tb = NavigationToolbar(self.all_fc, self.page) self.page.vlAll.addWidget(self.all_tb) self.page.vlAll.addWidget(self.all_fc) self.all_fig.subplots_adjust(left=0.105, right=0.98, top=0.98, bottom=0.145) self.act_fig = Figure() self.act_ax = self.act_fig.add_subplot(111) self.act_fc = FigureCanvas(self.act_fig) self.act_tb = NavigationToolbar(self.act_fc, self.page) self.page.vlActive.addWidget(self.act_tb) self.page.vlActive.addWidget(self.act_fc) self.act_fig.subplots_adjust(left=0.105, right=0.98, top=0.98, bottom=0.145) @enforce_mode('setup') def rig(self): self.page.sbModuleID.valueChanged.connect(self.updateModuleInfo) self.page.pbGoModule.clicked.connect(self.goModule) @enforce_mode('routine_setup') def updateModuleInfo(self, *args, **kwargs): moduleID = self.page.sbModuleID.value() self.module_exists = self.module.load(moduleID) self.updateElements(change='moduleID') @enforce_mode('routine_setup') def update_info(self, ID=None, *args, **kwargs): self.updateModuleInfo() self.updateElements('mode') @enforce_mode(['routine_setup', 'routine_perform']) def updateElements(self, change=None): if change is None: return if change == 'moduleID' or change == 'all': # :TODO: # based on module existence & status # update dict on setup issues # then call function that refreshes pteConsole if self.module_exists: self.page.leModuleExists.setText(MSG_MODULE_EXISTS_TRUE) pcb = -1 if self.module.pcb is None else self.module.pcb self.page.leModuleReady.setText( MSG_MODULE_READY_FALSE if pcb == -1 else MSG_MODULE_READY_TRUE) # :TODO: # When wirebonding and curing status is added: change this to check if the module is bonded, encapsulated, and cured else: self.page.leModuleExists.setText(MSG_MODULE_EXISTS_FALSE) self.page.leModuleReady.clear() if change == 'mode' or change == 'all': self.page.sbModuleID.setEnabled( self.mode == 'routine_setup') # :TODO: and no issues with routine_setup self.page.pbGoModule.setEnabled( self.mode == 'routine_setup' and self.page.sbModuleID.value() >= 0) self.page.pbRefreshComPorts.setEnabled( self.mode == 'routine_setup') self.page.cbKeithleyPort.setEnabled(self.mode == 'routine_setup') self.page.cbKeithleyBaud.setEnabled(self.mode == 'routine_setup') self.page.pbKeithleyQuery.setEnabled(self.mode == 'routine_setup') self.page.pbRoutineStart.setEnabled(self.mode == 'routine_setup') self.page.pbRoutinePause.setEnabled(self.mode == 'routine_perform') self.page.pbRoutineResume.setEnabled( self.mode == 'routine_perform') self.page.pbRoutineDescend.setEnabled( self.mode == 'routine_perform') self.page.pbRoutineEnd.setEnabled(self.mode == 'routine_perform') self.page.pteNotes.setEnabled(self.mode == 'routine_perform') @enforce_mode('routine_setup') def goModule(self, *args, **kwargs): moduleID = self.page.sbModuleID.value() if moduleID >= 0: self.setUIPage(PAGE_ID_MODULE, ID=moduleID) @enforce_mode('routine_setup') def load_kwargs(self, kwargs): ... @enforce_mode('routine_setup') def changed_to(self): self.updateModuleInfo( ) # module info may have changed, so we reload it and propagate consequences.
class SquidGui(QtGui.QMainWindow): defaults = {} defaults.update(SquidAxon.defaults) defaults.update(ClampCircuit.defaults) defaults.update({ 'runtime': 50.0, 'simdt': 0.01, 'plotdt': 0.1, 'vclamp.holdingV': 0.0, 'vclamp.holdingT': 10.0, 'vclamp.prepulseV': 0.0, 'vclamp.prepulseT': 0.0, 'vclamp.clampV': 50.0, 'vclamp.clampT': 20.0, 'iclamp.baseI': 0.0, 'iclamp.firstI': 0.1, 'iclamp.firstT': 40.0, 'iclamp.firstD': 5.0, 'iclamp.secondI': 0.0, 'iclamp.secondT': 0.0, 'iclamp.secondD': 0.0 }) def __init__(self, *args): QtGui.QMainWindow.__init__(self, *args) self.squid_setup = SquidSetup() self._plotdt = SquidGui.defaults['plotdt'] self._plot_dict = defaultdict(list) self.setWindowTitle('Squid Axon simulation') self.setDockNestingEnabled(True) self._createRunControl() self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._runControlDock) self._runControlDock.setFeatures( QtGui.QDockWidget.AllDockWidgetFeatures) self._createChannelControl() self._channelCtrlBox.setWindowTitle('Channel properties') self._channelControlDock.setFeatures( QtGui.QDockWidget.AllDockWidgetFeatures) self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._channelControlDock) self._createElectronicsControl() self._electronicsDock.setFeatures( QtGui.QDockWidget.AllDockWidgetFeatures) self._electronicsDock.setWindowTitle('Electronics') self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._electronicsDock) self._createPlotWidget() self.setCentralWidget(self._plotWidget) self._createStatePlotWidget() self._createHelpMessage() self._helpWindow.setVisible(False) self._statePlotWidget.setWindowFlags(QtCore.Qt.Window) self._statePlotWidget.setWindowTitle('State plot') self._initActions() self._createRunToolBar() self._createPlotToolBar() def getFloatInput(self, widget, name): try: return float(str(widget.text())) except ValueError: QtGui.QMessageBox.critical( self, 'Invalid input', 'Please enter a valid number for {}'.format(name)) raise def _createPlotWidget(self): self._plotWidget = QtGui.QWidget() self._plotFigure = Figure() self._plotCanvas = FigureCanvas(self._plotFigure) self._plotCanvas.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) self._plotCanvas.updateGeometry() self._plotCanvas.setParent(self._plotWidget) self._plotCanvas.mpl_connect('scroll_event', self._onScroll) self._plotFigure.set_canvas(self._plotCanvas) # Vm and command voltage go in the same subplot self._vm_axes = self._plotFigure.add_subplot( 2, 2, 1, title='Membrane potential') self._vm_axes.set_ylim(-20.0, 120.0) # Channel conductances go to the same subplot self._g_axes = self._plotFigure.add_subplot( 2, 2, 2, title='Channel conductance') self._g_axes.set_ylim(0.0, 0.5) # Injection current for Vclamp/Iclamp go to the same subplot self._im_axes = self._plotFigure.add_subplot(2, 2, 3, title='Injection current') self._im_axes.set_ylim(-0.5, 0.5) # Channel currents go to the same subplot self._i_axes = self._plotFigure.add_subplot(2, 2, 4, title='Channel current') self._i_axes.set_ylim(-10, 10) for axis in self._plotFigure.axes: axis.set_autoscale_on(False) layout = QtGui.QVBoxLayout() layout.addWidget(self._plotCanvas) self._plotNavigator = NavigationToolbar(self._plotCanvas, self._plotWidget) layout.addWidget(self._plotNavigator) self._plotWidget.setLayout(layout) def _createStatePlotWidget(self): self._statePlotWidget = QtGui.QWidget() self._statePlotFigure = Figure() self._statePlotCanvas = FigureCanvas(self._statePlotFigure) self._statePlotCanvas.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) self._statePlotCanvas.updateGeometry() self._statePlotCanvas.setParent(self._statePlotWidget) self._statePlotFigure.set_canvas(self._statePlotCanvas) self._statePlotFigure.subplots_adjust(hspace=0.5) self._statePlotAxes = self._statePlotFigure.add_subplot( 2, 1, 1, title='State plot') self._state_plot, = self._statePlotAxes.plot([], [], label='state') self._activationParamAxes = self._statePlotFigure.add_subplot( 2, 1, 2, title='H-H activation parameters vs time') self._activationParamAxes.set_xlabel('Time (ms)') #for axis in self._plotFigure.axes: # axis.autoscale(False) self._stateplot_xvar_label = QtGui.QLabel('Variable on X-axis') self._stateplot_xvar_combo = QtGui.QComboBox() self._stateplot_xvar_combo.addItems(['V', 'm', 'n', 'h']) self._stateplot_xvar_combo.setCurrentIndex(0) self._stateplot_xvar_combo.setEditable(False) self.connect(self._stateplot_xvar_combo, QtCore.SIGNAL('currentIndexChanged(const QString&)'), self._statePlotXSlot) self._stateplot_yvar_label = QtGui.QLabel('Variable on Y-axis') self._stateplot_yvar_combo = QtGui.QComboBox() self._stateplot_yvar_combo.addItems(['V', 'm', 'n', 'h']) self._stateplot_yvar_combo.setCurrentIndex(2) self._stateplot_yvar_combo.setEditable(False) self.connect(self._stateplot_yvar_combo, QtCore.SIGNAL('currentIndexChanged(const QString&)'), self._statePlotYSlot) self._statePlotNavigator = NavigationToolbar(self._statePlotCanvas, self._statePlotWidget) frame = QtGui.QFrame() frame.setFrameStyle(QtGui.QFrame.StyledPanel + QtGui.QFrame.Raised) layout = QtGui.QHBoxLayout() layout.addWidget(self._stateplot_xvar_label) layout.addWidget(self._stateplot_xvar_combo) layout.addWidget(self._stateplot_yvar_label) layout.addWidget(self._stateplot_yvar_combo) frame.setLayout(layout) self._closeStatePlotAction = QtGui.QAction('Close', self) self.connect(self._closeStatePlotAction, QtCore.SIGNAL('triggered()'), self._statePlotWidget.close) self._closeStatePlotButton = QtGui.QToolButton() self._closeStatePlotButton.setDefaultAction(self._closeStatePlotAction) layout = QtGui.QVBoxLayout() layout.addWidget(frame) layout.addWidget(self._statePlotCanvas) layout.addWidget(self._statePlotNavigator) layout.addWidget(self._closeStatePlotButton) self._statePlotWidget.setLayout(layout) # Setting the close event so that when the help window is # closed the ``State plot`` button becomes unchecked self._statePlotWidget.closeEvent = lambda event: self._showStatePlotAction.setChecked( False) def _createRunControl(self): self._runControlBox = QtGui.QGroupBox(self) self._runControlBox.setSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred) self._runTimeLabel = QtGui.QLabel("Run time (ms)", self._runControlBox) self._simTimeStepLabel = QtGui.QLabel("Simulation time step (ms)", self._runControlBox) self._runTimeEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['runtime']), self._runControlBox) set_default_line_edit_size(self._runTimeEdit) self._simTimeStepEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['simdt']), self._runControlBox) set_default_line_edit_size(self._simTimeStepEdit) layout = QtGui.QGridLayout() layout.addWidget(self._runTimeLabel, 0, 0) layout.addWidget(self._runTimeEdit, 0, 1) layout.addWidget(self._simTimeStepLabel, 1, 0) layout.addWidget(self._simTimeStepEdit, 1, 1) layout.setColumnStretch(2, 1.0) layout.setRowStretch(2, 1.0) self._runControlBox.setLayout(layout) self._runControlDock = QtGui.QDockWidget('Simulation', self) self._runControlDock.setWidget(self._runControlBox) def _createChannelControl(self): self._channelControlDock = QtGui.QDockWidget('Channels', self) self._channelCtrlBox = QtGui.QGroupBox(self) self._naConductanceToggle = QtGui.QCheckBox('Block Na+ channel', self._channelCtrlBox) self._naConductanceToggle.setToolTip('<html>%s</html>' % (tooltip_NaChan)) self._kConductanceToggle = QtGui.QCheckBox('Block K+ channel', self._channelCtrlBox) self._kConductanceToggle.setToolTip('<html>%s</html>' % (tooltip_KChan)) self._kOutLabel = QtGui.QLabel('[K+]out (mM)', self._channelCtrlBox) self._kOutEdit = QtGui.QLineEdit( '%g' % (self.squid_setup.squid_axon.K_out), self._channelCtrlBox) self._kOutLabel.setToolTip('<html>%s</html>' % (tooltip_Nernst)) self._kOutEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst)) set_default_line_edit_size(self._kOutEdit) self._naOutLabel = QtGui.QLabel('[Na+]out (mM)', self._channelCtrlBox) self._naOutEdit = QtGui.QLineEdit( '%g' % (self.squid_setup.squid_axon.Na_out), self._channelCtrlBox) self._naOutLabel.setToolTip('<html>%s</html>' % (tooltip_Nernst)) self._naOutEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst)) set_default_line_edit_size(self._naOutEdit) self._kInLabel = QtGui.QLabel('[K+]in (mM)', self._channelCtrlBox) self._kInEdit = QtGui.QLineEdit( '%g' % (self.squid_setup.squid_axon.K_in), self._channelCtrlBox) self._kInEdit.setToolTip(tooltip_Nernst) self._naInLabel = QtGui.QLabel('[Na+]in (mM)', self._channelCtrlBox) self._naInEdit = QtGui.QLineEdit( '%g' % (self.squid_setup.squid_axon.Na_in), self._channelCtrlBox) self._naInEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst)) self._temperatureLabel = QtGui.QLabel('Temperature (C)', self._channelCtrlBox) self._temperatureEdit = QtGui.QLineEdit( '%g' % (self.defaults['temperature'] - CELSIUS_TO_KELVIN), self._channelCtrlBox) self._temperatureEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst)) set_default_line_edit_size(self._temperatureEdit) for child in self._channelCtrlBox.children(): if isinstance(child, QtGui.QLineEdit): set_default_line_edit_size(child) layout = QtGui.QGridLayout(self._channelCtrlBox) layout.addWidget(self._naConductanceToggle, 0, 0) layout.addWidget(self._kConductanceToggle, 1, 0) layout.addWidget(self._naOutLabel, 2, 0) layout.addWidget(self._naOutEdit, 2, 1) layout.addWidget(self._naInLabel, 3, 0) layout.addWidget(self._naInEdit, 3, 1) layout.addWidget(self._kOutLabel, 4, 0) layout.addWidget(self._kOutEdit, 4, 1) layout.addWidget(self._kInLabel, 5, 0) layout.addWidget(self._kInEdit, 5, 1) layout.addWidget(self._temperatureLabel, 6, 0) layout.addWidget(self._temperatureEdit, 6, 1) layout.setRowStretch(7, 1.0) self._channelCtrlBox.setLayout(layout) self._channelControlDock.setWidget(self._channelCtrlBox) return self._channelCtrlBox def __get_stateplot_data(self, name): data = [] if name == 'V': data = self.squid_setup.vm_table.vector elif name == 'm': data = self.squid_setup.m_table.vector elif name == 'h': data = self.squid_setup.h_table.vector elif name == 'n': data = self.squid_setup.n_table.vector else: raise ValueError('Unrecognized selection: %s' % (name)) return numpy.asarray(data) def _statePlotYSlot(self, selectedItem): ydata = self.__get_stateplot_data(str(selectedItem)) self._state_plot.set_ydata(ydata) self._statePlotAxes.set_ylabel(selectedItem) if str(selectedItem) == 'V': self._statePlotAxes.set_ylim(-20, 120) else: self._statePlotAxes.set_ylim(0, 1) self._statePlotCanvas.draw() def _statePlotXSlot(self, selectedItem): xdata = self.__get_stateplot_data(str(selectedItem)) self._state_plot.set_xdata(xdata) self._statePlotAxes.set_xlabel(selectedItem) if str(selectedItem) == 'V': self._statePlotAxes.set_xlim(-20, 120) else: self._statePlotAxes.set_xlim(0, 1) self._statePlotCanvas.draw() def _createElectronicsControl(self): """Creates a tabbed widget of voltage clamp and current clamp controls""" self._electronicsTab = QtGui.QTabWidget(self) self._electronicsTab.addTab(self._getIClampCtrlBox(), 'Current clamp') self._electronicsTab.addTab(self._getVClampCtrlBox(), 'Voltage clamp') self._electronicsDock = QtGui.QDockWidget(self) self._electronicsDock.setWidget(self._electronicsTab) def _getVClampCtrlBox(self): vClampPanel = QtGui.QGroupBox(self) self._vClampCtrlBox = vClampPanel self._holdingVLabel = QtGui.QLabel("Holding Voltage (mV)", vClampPanel) self._holdingVEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['vclamp.holdingV']), vClampPanel) self._holdingTimeLabel = QtGui.QLabel("Holding Time (ms)", vClampPanel) self._holdingTimeEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['vclamp.holdingT']), vClampPanel) self._prePulseVLabel = QtGui.QLabel("Pre-pulse Voltage (mV)", vClampPanel) self._prePulseVEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['vclamp.prepulseV']), vClampPanel) self._prePulseTimeLabel = QtGui.QLabel("Pre-pulse Time (ms)", vClampPanel) self._prePulseTimeEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['vclamp.prepulseT']), vClampPanel) self._clampVLabel = QtGui.QLabel("Clamp Voltage (mV)", vClampPanel) self._clampVEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['vclamp.clampV']), vClampPanel) self._clampTimeLabel = QtGui.QLabel("Clamp Time (ms)", vClampPanel) self._clampTimeEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['vclamp.clampT']), vClampPanel) for child in vClampPanel.children(): if isinstance(child, QtGui.QLineEdit): set_default_line_edit_size(child) layout = QtGui.QGridLayout(vClampPanel) layout.addWidget(self._holdingVLabel, 0, 0) layout.addWidget(self._holdingVEdit, 0, 1) layout.addWidget(self._holdingTimeLabel, 1, 0) layout.addWidget(self._holdingTimeEdit, 1, 1) layout.addWidget(self._prePulseVLabel, 2, 0) layout.addWidget(self._prePulseVEdit, 2, 1) layout.addWidget(self._prePulseTimeLabel, 3, 0) layout.addWidget(self._prePulseTimeEdit, 3, 1) layout.addWidget(self._clampVLabel, 4, 0) layout.addWidget(self._clampVEdit, 4, 1) layout.addWidget(self._clampTimeLabel, 5, 0) layout.addWidget(self._clampTimeEdit, 5, 1) layout.setRowStretch(6, 1.0) vClampPanel.setLayout(layout) return self._vClampCtrlBox def _getIClampCtrlBox(self): iClampPanel = QtGui.QGroupBox(self) self._iClampCtrlBox = iClampPanel self._baseCurrentLabel = QtGui.QLabel("Base Current Level (uA)", iClampPanel) self._baseCurrentEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['iclamp.baseI']), iClampPanel) self._firstPulseLabel = QtGui.QLabel("First Pulse Current (uA)", iClampPanel) self._firstPulseEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['iclamp.firstI']), iClampPanel) self._firstDelayLabel = QtGui.QLabel("First Onset Delay (ms)", iClampPanel) self._firstDelayEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['iclamp.firstD']), iClampPanel) self._firstPulseWidthLabel = QtGui.QLabel("First Pulse Width (ms)", iClampPanel) self._firstPulseWidthEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['iclamp.firstT']), iClampPanel) self._secondPulseLabel = QtGui.QLabel("Second Pulse Current (uA)", iClampPanel) self._secondPulseEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['iclamp.secondI']), iClampPanel) self._secondDelayLabel = QtGui.QLabel("Second Onset Delay (ms)", iClampPanel) self._secondDelayEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['iclamp.secondD']), iClampPanel) self._secondPulseWidthLabel = QtGui.QLabel("Second Pulse Width (ms)", iClampPanel) self._secondPulseWidthEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['iclamp.secondT']), iClampPanel) self._pulseMode = QtGui.QComboBox(iClampPanel) self._pulseMode.addItem("Single Pulse") self._pulseMode.addItem("Pulse Train") for child in iClampPanel.children(): if isinstance(child, QtGui.QLineEdit): set_default_line_edit_size(child) layout = QtGui.QGridLayout(iClampPanel) layout.addWidget(self._baseCurrentLabel, 0, 0) layout.addWidget(self._baseCurrentEdit, 0, 1) layout.addWidget(self._firstPulseLabel, 1, 0) layout.addWidget(self._firstPulseEdit, 1, 1) layout.addWidget(self._firstDelayLabel, 2, 0) layout.addWidget(self._firstDelayEdit, 2, 1) layout.addWidget(self._firstPulseWidthLabel, 3, 0) layout.addWidget(self._firstPulseWidthEdit, 3, 1) layout.addWidget(self._secondPulseLabel, 4, 0) layout.addWidget(self._secondPulseEdit, 4, 1) layout.addWidget(self._secondDelayLabel, 5, 0) layout.addWidget(self._secondDelayEdit, 5, 1) layout.addWidget(self._secondPulseWidthLabel, 6, 0) layout.addWidget(self._secondPulseWidthEdit, 6, 1) layout.addWidget(self._pulseMode, 7, 0, 1, 2) layout.setRowStretch(8, 1.0) # layout.setSizeConstraint(QtGui.QLayout.SetFixedSize) iClampPanel.setLayout(layout) return self._iClampCtrlBox def _overlayPlots(self, overlay): if not overlay: for axis in (self._plotFigure.axes + self._statePlotFigure.axes): title = axis.get_title() axis.clear() axis.set_title(title) suffix = '' else: suffix = '_%d' % (len(self._plot_dict['vm'])) self._vm_axes.set_xlim(0.0, self._runtime) self._g_axes.set_xlim(0.0, self._runtime) self._im_axes.set_xlim(0.0, self._runtime) self._i_axes.set_xlim(0.0, self._runtime) self._vm_plot, = self._vm_axes.plot([], [], label='Vm%s' % (suffix)) self._plot_dict['vm'].append(self._vm_plot) self._command_plot, = self._vm_axes.plot([], [], label='command%s' % (suffix)) self._plot_dict['command'].append(self._command_plot) # Channel conductances go to the same subplot self._gna_plot, = self._g_axes.plot([], [], label='Na%s' % (suffix)) self._plot_dict['gna'].append(self._gna_plot) self._gk_plot, = self._g_axes.plot([], [], label='K%s' % (suffix)) self._plot_dict['gk'].append(self._gk_plot) # Injection current for Vclamp/Iclamp go to the same subplot self._iclamp_plot, = self._im_axes.plot([], [], label='Iclamp%s' % (suffix)) self._vclamp_plot, = self._im_axes.plot([], [], label='Vclamp%s' % (suffix)) self._plot_dict['iclamp'].append(self._iclamp_plot) self._plot_dict['vclamp'].append(self._vclamp_plot) # Channel currents go to the same subplot self._ina_plot, = self._i_axes.plot([], [], label='Na%s' % (suffix)) self._plot_dict['ina'].append(self._ina_plot) self._ik_plot, = self._i_axes.plot([], [], label='K%s' % (suffix)) self._plot_dict['ik'].append(self._ik_plot) # self._i_axes.legend() # State plots self._state_plot, = self._statePlotAxes.plot([], [], label='state%s' % (suffix)) self._plot_dict['state'].append(self._state_plot) self._m_plot, = self._activationParamAxes.plot([], [], label='m%s' % (suffix)) self._h_plot, = self._activationParamAxes.plot([], [], label='h%s' % (suffix)) self._n_plot, = self._activationParamAxes.plot([], [], label='n%s' % (suffix)) self._plot_dict['m'].append(self._m_plot) self._plot_dict['h'].append(self._h_plot) self._plot_dict['n'].append(self._n_plot) if self._showLegendAction.isChecked(): for axis in (self._plotFigure.axes + self._statePlotFigure.axes): axis.legend() def _updateAllPlots(self): self._updatePlots() self._updateStatePlot() def _updatePlots(self): if len(self.squid_setup.vm_table.vector) <= 0: return vm = numpy.asarray(self.squid_setup.vm_table.vector) cmd = numpy.asarray(self.squid_setup.cmd_table.vector) ik = numpy.asarray(self.squid_setup.ik_table.vector) ina = numpy.asarray(self.squid_setup.ina_table.vector) iclamp = numpy.asarray(self.squid_setup.iclamp_table.vector) vclamp = numpy.asarray(self.squid_setup.vclamp_table.vector) gk = numpy.asarray(self.squid_setup.gk_table.vector) gna = numpy.asarray(self.squid_setup.gna_table.vector) time_series = numpy.linspace(0, self._plotdt * len(vm), len(vm)) self._vm_plot.set_data(time_series, vm) time_series = numpy.linspace(0, self._plotdt * len(cmd), len(cmd)) self._command_plot.set_data(time_series, cmd) time_series = numpy.linspace(0, self._plotdt * len(ik), len(ik)) self._ik_plot.set_data(time_series, ik) time_series = numpy.linspace(0, self._plotdt * len(ina), len(ina)) self._ina_plot.set_data(time_series, ina) time_series = numpy.linspace(0, self._plotdt * len(iclamp), len(iclamp)) self._iclamp_plot.set_data(time_series, iclamp) time_series = numpy.linspace(0, self._plotdt * len(vclamp), len(vclamp)) self._vclamp_plot.set_data(time_series, vclamp) time_series = numpy.linspace(0, self._plotdt * len(gk), len(gk)) self._gk_plot.set_data(time_series, gk) time_series = numpy.linspace(0, self._plotdt * len(gna), len(gna)) self._gna_plot.set_data(time_series, gna) # self._vm_axes.margins(y=0.1) # self._g_axes.margin(y=0.1) # self._im_axes.margins(y=0.1) # self._i_axes.margins(y=0.1) if self._autoscaleAction.isChecked(): for axis in self._plotFigure.axes: axis.relim() axis.margins(0.1, 0.1) axis.autoscale_view(tight=True) else: self._vm_axes.set_ylim(-20.0, 120.0) self._g_axes.set_ylim(0.0, 0.5) self._im_axes.set_ylim(-0.5, 0.5) self._i_axes.set_ylim(-10, 10) self._vm_axes.set_xlim(0.0, time_series[-1]) self._g_axes.set_xlim(0.0, time_series[-1]) self._im_axes.set_xlim(0.0, time_series[-1]) self._i_axes.set_xlim(0.0, time_series[-1]) self._plotCanvas.draw() def _updateStatePlot(self): if len(self.squid_setup.vm_table.vector) <= 0: return sx = str(self._stateplot_xvar_combo.currentText()) sy = str(self._stateplot_yvar_combo.currentText()) xdata = self.__get_stateplot_data(sx) ydata = self.__get_stateplot_data(sy) minlen = min(len(xdata), len(ydata)) self._state_plot.set_data(xdata[:minlen], ydata[:minlen]) self._statePlotAxes.set_xlabel(sx) self._statePlotAxes.set_ylabel(sy) if sx == 'V': self._statePlotAxes.set_xlim(-20, 120) else: self._statePlotAxes.set_xlim(0, 1) if sy == 'V': self._statePlotAxes.set_ylim(-20, 120) else: self._statePlotAxes.set_ylim(0, 1) self._activationParamAxes.set_xlim(0, self._runtime) m = self.__get_stateplot_data('m') n = self.__get_stateplot_data('n') h = self.__get_stateplot_data('h') time_series = numpy.linspace(0, self._plotdt * len(m), len(m)) self._m_plot.set_data(time_series, m) time_series = numpy.linspace(0, self._plotdt * len(h), len(h)) self._h_plot.set_data(time_series, h) time_series = numpy.linspace(0, self._plotdt * len(n), len(n)) self._n_plot.set_data(time_series, n) if self._autoscaleAction.isChecked(): for axis in self._statePlotFigure.axes: axis.relim() axis.set_autoscale_on(True) axis.autoscale_view(True) self._statePlotCanvas.draw() def _runSlot(self): if moose.isRunning(): print 'Stopping simulation in progress ...' moose.stop() self._runtime = self.getFloatInput(self._runTimeEdit, self._runTimeLabel.text()) self._overlayPlots(self._overlayAction.isChecked()) self._simdt = self.getFloatInput(self._simTimeStepEdit, self._simTimeStepLabel.text()) clampMode = None singlePulse = True if self._electronicsTab.currentWidget() == self._vClampCtrlBox: clampMode = 'vclamp' baseLevel = self.getFloatInput(self._holdingVEdit, self._holdingVLabel.text()) firstDelay = self.getFloatInput(self._holdingTimeEdit, self._holdingTimeLabel.text()) firstWidth = self.getFloatInput(self._prePulseTimeEdit, self._prePulseTimeLabel.text()) firstLevel = self.getFloatInput(self._prePulseVEdit, self._prePulseVLabel.text()) secondDelay = firstWidth secondWidth = self.getFloatInput(self._clampTimeEdit, self._clampTimeLabel.text()) secondLevel = self.getFloatInput(self._clampVEdit, self._clampVLabel.text()) if not self._autoscaleAction.isChecked(): self._im_axes.set_ylim(-10.0, 10.0) else: clampMode = 'iclamp' baseLevel = self.getFloatInput(self._baseCurrentEdit, self._baseCurrentLabel.text()) firstDelay = self.getFloatInput(self._firstDelayEdit, self._firstDelayLabel.text()) firstWidth = self.getFloatInput(self._firstPulseWidthEdit, self._firstPulseWidthLabel.text()) firstLevel = self.getFloatInput(self._firstPulseEdit, self._firstPulseLabel.text()) secondDelay = self.getFloatInput(self._secondDelayEdit, self._secondDelayLabel.text()) secondLevel = self.getFloatInput(self._secondPulseEdit, self._secondPulseLabel.text()) secondWidth = self.getFloatInput( self._secondPulseWidthEdit, self._secondPulseWidthLabel.text()) singlePulse = (self._pulseMode.currentIndex() == 0) if not self._autoscaleAction.isChecked(): self._im_axes.set_ylim(-0.4, 0.4) self.squid_setup.clamp_ckt.configure_pulses(baseLevel=baseLevel, firstDelay=firstDelay, firstWidth=firstWidth, firstLevel=firstLevel, secondDelay=secondDelay, secondWidth=secondWidth, secondLevel=secondLevel, singlePulse=singlePulse) if self._kConductanceToggle.isChecked(): self.squid_setup.squid_axon.specific_gK = 0.0 else: self.squid_setup.squid_axon.specific_gK = SquidAxon.defaults[ 'specific_gK'] if self._naConductanceToggle.isChecked(): self.squid_setup.squid_axon.specific_gNa = 0.0 else: self.squid_setup.squid_axon.specific_gNa = SquidAxon.defaults[ 'specific_gNa'] self.squid_setup.squid_axon.celsius = self.getFloatInput( self._temperatureEdit, self._temperatureLabel.text()) self.squid_setup.squid_axon.K_out = self.getFloatInput( self._kOutEdit, self._kOutLabel.text()) self.squid_setup.squid_axon.Na_out = self.getFloatInput( self._naOutEdit, self._naOutLabel.text()) self.squid_setup.squid_axon.K_in = self.getFloatInput( self._kInEdit, self._kInLabel.text()) self.squid_setup.squid_axon.Na_in = self.getFloatInput( self._naInEdit, self._naInLabel.text()) self.squid_setup.squid_axon.updateEk() self.squid_setup.schedule(self._simdt, self._plotdt, clampMode) # The following line is for use with Qthread self.squid_setup.run(self._runtime) self._updateAllPlots() def _toggleDocking(self, on): self._channelControlDock.setFloating(on) self._electronicsDock.setFloating(on) self._runControlDock.setFloating(on) def _restoreDocks(self): self._channelControlDock.setVisible(True) self._electronicsDock.setVisible(True) self._runControlDock.setVisible(True) def _initActions(self): self._runAction = QtGui.QAction(self.tr('Run'), self) self._runAction.setShortcut(self.tr('F5')) self._runAction.setToolTip('Run simulation (F5)') self.connect(self._runAction, QtCore.SIGNAL('triggered()'), self._runSlot) self._resetToDefaultsAction = QtGui.QAction( self.tr('Restore defaults'), self) self._resetToDefaultsAction.setToolTip( 'Reset all settings to their default values') self.connect(self._resetToDefaultsAction, QtCore.SIGNAL('triggered()'), self._useDefaults) self._showLegendAction = QtGui.QAction(self.tr('Display legend'), self) self._showLegendAction.setCheckable(True) self.connect(self._showLegendAction, QtCore.SIGNAL('toggled(bool)'), self._showLegend) self._showStatePlotAction = QtGui.QAction(self.tr('State plot'), self) self._showStatePlotAction.setCheckable(True) self._showStatePlotAction.setChecked(False) self.connect(self._showStatePlotAction, QtCore.SIGNAL('toggled(bool)'), self._statePlotWidget.setVisible) self._autoscaleAction = QtGui.QAction(self.tr('Auto-scale plots'), self) self._autoscaleAction.setCheckable(True) self._autoscaleAction.setChecked(False) self.connect(self._autoscaleAction, QtCore.SIGNAL('toggled(bool)'), self._autoscale) self._overlayAction = QtGui.QAction('Overlay plots', self) self._overlayAction.setCheckable(True) self._overlayAction.setChecked(False) self._dockAction = QtGui.QAction('Undock all', self) self._dockAction.setCheckable(True) self._dockAction.setChecked(False) self.connect(self._dockAction, QtCore.SIGNAL('toggled(bool)'), self._toggleDocking) self._restoreDocksAction = QtGui.QAction('Show all', self) self.connect(self._restoreDocksAction, QtCore.SIGNAL('triggered()'), self._restoreDocks) self._quitAction = QtGui.QAction(self.tr('&Quit'), self) self._quitAction.setShortcut(self.tr('Ctrl+Q')) self.connect(self._quitAction, QtCore.SIGNAL('triggered()'), QtGui.qApp.closeAllWindows) def _createRunToolBar(self): self._simToolBar = self.addToolBar(self.tr('Simulation control')) self._simToolBar.addAction(self._quitAction) self._simToolBar.addAction(self._runAction) self._simToolBar.addAction(self._resetToDefaultsAction) self._simToolBar.addAction(self._dockAction) self._simToolBar.addAction(self._restoreDocksAction) def _createPlotToolBar(self): self._plotToolBar = self.addToolBar(self.tr('Plotting control')) self._plotToolBar.addAction(self._showLegendAction) self._plotToolBar.addAction(self._autoscaleAction) self._plotToolBar.addAction(self._overlayAction) self._plotToolBar.addAction(self._showStatePlotAction) self._plotToolBar.addAction(self._helpAction) self._plotToolBar.addAction(self._helpBiophysicsAction) def _showLegend(self, on): if on: for axis in (self._plotFigure.axes + self._statePlotFigure.axes): axis.legend().set_visible(True) else: for axis in (self._plotFigure.axes + self._statePlotFigure.axes): axis.legend().set_visible(False) self._plotCanvas.draw() self._statePlotCanvas.draw() def _autoscale(self, on): if on: for axis in (self._plotFigure.axes + self._statePlotFigure.axes): axis.relim() axis.set_autoscale_on(True) axis.autoscale_view(True) else: for axis in self._plotFigure.axes: axis.set_autoscale_on(False) self._vm_axes.set_ylim(-20.0, 120.0) self._g_axes.set_ylim(0.0, 0.5) self._im_axes.set_ylim(-0.5, 0.5) self._i_axes.set_ylim(-10, 10) self._plotCanvas.draw() self._statePlotCanvas.draw() def _useDefaults(self): self._runTimeEdit.setText('%g' % (self.defaults['runtime'])) self._simTimeStepEdit.setText('%g' % (self.defaults['simdt'])) self._overlayAction.setChecked(False) self._naConductanceToggle.setChecked(False) self._kConductanceToggle.setChecked(False) self._kOutEdit.setText('%g' % (SquidGui.defaults['K_out'])) self._naOutEdit.setText('%g' % (SquidGui.defaults['Na_out'])) self._kInEdit.setText('%g' % (SquidGui.defaults['K_in'])) self._naInEdit.setText('%g' % (SquidGui.defaults['Na_in'])) self._temperatureEdit.setText( '%g' % (SquidGui.defaults['temperature'] - CELSIUS_TO_KELVIN)) self._holdingVEdit.setText('%g' % (SquidGui.defaults['vclamp.holdingV'])) self._holdingTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.holdingT'])) self._prePulseVEdit.setText('%g' % (SquidGui.defaults['vclamp.prepulseV'])) self._prePulseTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.prepulseT'])) self._clampVEdit.setText('%g' % (SquidGui.defaults['vclamp.clampV'])) self._clampTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.clampT'])) self._baseCurrentEdit.setText('%g' % (SquidGui.defaults['iclamp.baseI'])) self._firstPulseEdit.setText('%g' % (SquidGui.defaults['iclamp.firstI'])) self._firstDelayEdit.setText('%g' % (SquidGui.defaults['iclamp.firstD'])) self._firstPulseWidthEdit.setText('%g' % (SquidGui.defaults['iclamp.firstT'])) self._secondPulseEdit.setText('%g' % (SquidGui.defaults['iclamp.secondI'])) self._secondDelayEdit.setText('%g' % (SquidGui.defaults['iclamp.secondD'])) self._secondPulseWidthEdit.setText( '%g' % (SquidGui.defaults['iclamp.secondT'])) self._pulseMode.setCurrentIndex(0) def _onScroll(self, event): if event.inaxes is None: return axes = event.inaxes zoom = 0.0 if event.button == 'up': zoom = -1.0 elif event.button == 'down': zoom = 1.0 if zoom != 0.0: self._plotNavigator.push_current() axes.get_xaxis().zoom(zoom) axes.get_yaxis().zoom(zoom) self._plotCanvas.draw() def closeEvent(self, event): QtGui.qApp.closeAllWindows() def _showBioPhysicsHelp(self): self._createHelpMessage() self._helpMessageText.setText( '<html><p>%s</p><p>%s</p><p>%s</p><p>%s</p><p>%s</p></html>' % (tooltip_Nernst, tooltip_Erest, tooltip_KChan, tooltip_NaChan, tooltip_Im)) self._helpWindow.setVisible(True) def _showRunningHelp(self): self._createHelpMessage() self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL)) self._helpWindow.setVisible(True) def _createHelpMessage(self): if hasattr(self, '_helpWindow'): return self._helpWindow = QtGui.QWidget() self._helpWindow.setWindowFlags(QtCore.Qt.Window) layout = QtGui.QVBoxLayout() self._helpWindow.setLayout(layout) self._helpMessageArea = QtGui.QScrollArea() self._helpMessageText = QtGui.QTextBrowser() self._helpMessageText.setOpenExternalLinks(True) self._helpMessageArea.setWidget(self._helpMessageText) layout.addWidget(self._helpMessageText) self._squidGuiPath = os.path.dirname(os.path.abspath(__file__)) self._helpBaseURL = os.path.join(self._squidGuiPath, 'help.html') self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL)) self._helpMessageText.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) self._helpMessageArea.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) self._helpMessageText.setMinimumSize(800, 600) self._closeHelpAction = QtGui.QAction('Close', self) self.connect(self._closeHelpAction, QtCore.SIGNAL('triggered()'), self._helpWindow.close) # Setting the close event so that the ``Help`` button is # unchecked when the help window is closed self._helpWindow.closeEvent = lambda event: self._helpAction.setChecked( False) self._helpTOCAction = QtGui.QAction('Help running demo', self) self.connect(self._helpTOCAction, QtCore.SIGNAL('triggered()'), self._jumpToHelpTOC) # This panel is for putting two buttons using horizontal # layout panel = QtGui.QFrame() panel.setFrameStyle(QtGui.QFrame.StyledPanel + QtGui.QFrame.Raised) layout.addWidget(panel) layout = QtGui.QHBoxLayout() panel.setLayout(layout) self._helpAction = QtGui.QAction('Help running', self) self.connect(self._helpAction, QtCore.SIGNAL('triggered()'), self._showRunningHelp) self._helpBiophysicsAction = QtGui.QAction('Help biophysics', self) self.connect(self._helpBiophysicsAction, QtCore.SIGNAL('triggered()'), self._showBioPhysicsHelp) self._helpTOCButton = QtGui.QToolButton() self._helpTOCButton.setDefaultAction(self._helpTOCAction) self._helpBiophysicsButton = QtGui.QToolButton() self._helpBiophysicsButton.setDefaultAction(self._helpBiophysicsAction) layout.addWidget(self._helpTOCButton) layout.addWidget(self._helpBiophysicsButton) self._closeHelpButton = QtGui.QToolButton() self._closeHelpButton.setDefaultAction(self._closeHelpAction) layout.addWidget(self._closeHelpButton) def _jumpToHelpTOC(self): self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
class OHLCWidget(Canvas): def __init__(self, parent=None): from matplotlib import rcParams rcParams['font.size'] = 6 self.figure = Figure(facecolor='w', edgecolor='w') self.figure.subplots_adjust(left=0.1, right=0.9, wspace=0.6) Canvas.__init__(self, self.figure) self.setParent(parent) self.figure.canvas.mpl_connect('motion_notify_event', self.onmove) Canvas.setSizePolicy(self, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) Canvas.updateGeometry(self) def sizeHint(self): w, h = self.get_width_height() return QtCore.QSize(w, h) def minimumSizeHint(self): return QtCore.QSize(10, 10) def onmove(self, event): if event.xdata == None or event.inaxes == self.info_axes: return #print(event.x, event.xdata, event.inaxes) ind = int(round(event.xdata)) self.info(ind) def info(self, ind): print("call info", ind) if ind >= len(self.rows) or ind < 0: return '' row = self.rows[ind] if row == None: return print(row) #today = datetime.datetime(1899,12,30)+datetime.timedelta(days=float(row[0])) y, m, d = row[0].split('-') today = datetime.datetime(int(y), int(m), int(d)) open = float(row[1]) high = float(row[2]) low = float(row[3]) close = float(row[4]) volume = int(float(row[5])) print(today, open, high, low, close, volume) self.info_axes.clear() self.info_axes.text(0.1, 0.95, 'Date') self.info_axes.text(0.15, 0.93, today.strftime("%Y%m%d"), color='b') self.info_axes.text(0.1, 0.90, 'Open') self.info_axes.text(0.15, 0.88, open, color='b') self.info_axes.text(0.1, 0.85, 'High') self.info_axes.text(0.15, 0.83, high, color='b') self.info_axes.text(0.1, 0.80, 'Low') self.info_axes.text(0.15, 0.78, low, color='b') self.info_axes.text(0.1, 0.75, 'Close') self.info_axes.text(0.15, 0.73, close, color='b') self.info_axes.text(0.1, 0.70, 'Volume') self.info_axes.text(0.15, 0.68, volume, color='b') self.info_axes.set_xticklabels([]) self.info_axes.set_yticklabels([]) self.figure.canvas.draw() def query(self, sql, parameters=None): self.figure.clear() self.vol_axes = self.figure.add_axes([0.06, 0.01, 0.87, 0.24], axisbg='#cccccc', autoscale_on=True) self.ohlc_axes = self.figure.add_axes([0.06, 0.25, 0.87, 0.74], axisbg='#cccccc', autoscale_on=True) self.info_axes = self.figure.add_axes([0.93, 0.01, 0.06, 0.98], axisbg='#cccccc', autoscale_on=True) # select data from sqlite3 db deone_db = r'data/DEONE.db' con = sqlite3.connect(deone_db) con.text_factory = str cur = con.cursor() #t = u'深发展A'.encode('utf-8') #cur.execute(u'select * from StockHist where 股票名称=?'.encode('utf-8'), (t,)) #cur.execute('select * from StockHist') cur.execute(sql, parameters) dates = [] ind = 0 self.rows = [] for ind in xrange(100): row = cur.fetchone() if row == None: break #print(row) self.rows += [row] #today = datetime.datetime(1899,12,30)+datetime.timedelta(days=float(row[0])) y, m, d = row[0].split('-') today = datetime.datetime(int(y), int(m), int(d)) dates += [today] open = float(row[1]) high = float(row[2]) low = float(row[3]) close = float(row[4]) volume = int(float(row[5])) #print(ind, today, open, high, low, close, volume) if close > open: col = "r" elif close < open: col = "g" else: col = "w" self.ohlc_axes.hlines(open, ind - 0.3, ind + 0.3, colors='w') self.ohlc_axes.bar(ind, close - open, 0.6, open, color=col, align='center') self.ohlc_axes.vlines(ind, low, high, color=col) self.vol_axes.bar(ind, volume, 0.6, color=col, align='center') con.close() formatter = MyFormatter(dates) self.ohlc_axes.xaxis.set_major_formatter(formatter) self.vol_axes.xaxis.set_major_formatter(formatter) self.ohlc_axes.set_xlim(-0.5, ind + 1.5) self.ohlc_axes.grid(True) self.vol_axes.set_xlim(-0.5, ind + 1.5) self.vol_axes.grid(True) self.vol_axes.set_xticklabels([]) self.info_axes.set_xticklabels([]) self.info_axes.set_yticklabels([]) self.figure.autofmt_xdate() self.info(ind - 1)
class SolverWidget(QtGui.QWidget): """ Widget used to run and monitor the Ember solver """ def __init__(self, conf, *args, **kwargs): QtGui.QWidget.__init__(self) self.conf = conf self.setLayout(QtGui.QVBoxLayout()) # Buttons self.startButton = QtGui.QPushButton('Start') self.stopButton = QtGui.QPushButton('Stop') self.resetButton = QtGui.QPushButton('Reset') self.buttons = QtGui.QWidget() self.buttons.setLayout(QtGui.QHBoxLayout()) self.buttons.layout().addWidget(self.startButton) self.buttons.layout().addWidget(self.stopButton) self.buttons.layout().addWidget(self.resetButton) self.layout().addWidget(self.buttons) self.startButton.pressed.connect(self.run) self.stopButton.pressed.connect(self.stop) self.resetButton.pressed.connect(self.reset) # Progress Bar self.progressBar = QtGui.QProgressBar() self.layout().addWidget(self.progressBar) self.progressBar.setRange(0, 1000) self.progressBar.setValue(0) # Graphs self.graphContainer = QtGui.QWidget() self.graphContainer.setLayout(QtGui.QHBoxLayout()) self.layout().addWidget(self.graphContainer) self.fig = Figure(figsize=(600,400), dpi=72) self.fig.subplots_adjust(0.09, 0.08, 0.93, 0.96, wspace=0.3) self.ax1 = self.fig.add_subplot(1,2,1) self.ax1.set_xlabel('time [ms]') self.ax1.set_ylabel('Consumption Speed, $S_c$ [cm/s]') self.Sc_timeseries = self.ax1.plot([0],[0], lw=2)[0] self.ax2a = self.fig.add_subplot(1,2,2) self.ax2b = self.ax2a.twinx() self.ax2a.set_xlabel('flame coordinate [mm]') self.ax2a.set_ylabel('Temperature [K]') self.ax2b.set_ylabel('Heat Release Rate [MW/m$^3$]') self.T_profile = self.ax2a.plot([0],[0], 'b', lw=2)[0] self.hrr_profile = self.ax2b.plot([0],[0], 'r', lw=2)[0] self.canvas = FigureCanvas(self.fig) self.graphContainer.layout().addWidget(self.canvas) bgcolor = self.palette().color(QtGui.QPalette.Window) self.fig.set_facecolor((bgcolor.redF(), bgcolor.greenF(), bgcolor.blueF())) #self.fig.patch.set_alpha(0.1) # internals self.solver = None self.solverThread = None self.updateTimer = QtCore.QTimer() self.updateTimer.setInterval(0.5) self.updateTimer.timeout.connect(self.updateStatus) self.running = False self.updateButtons() def run(self): if self.solverThread is not None and self.solverThread.is_alive(): return if self.solver is None: self.conf.validate() self.solver = _ember.FlameSolver(self.conf) self.solver.initialize() self.solverThread = SolverThread(solver=self.solver, conf=self.conf) self.solverThread.start() self.updateTimer.start() self.running = True self.updateButtons() def stop(self): if self.solverThread: self.solverThread.stop() self.updateTimer.stop() self.running = False self.startButton.setText('Resume') self.updateButtons() def reset(self): self.progressBar.setValue(0) self.T_profile.set_data([0], [0]) self.hrr_profile.set_data([0], [0]) self.Sc_timeseries.set_data([0], [0]) self.canvas.draw() self.solver = None self.startButton.setText('Start') self.updateButtons() def updateButtons(self): running = self.running and self.solverThread is not None and self.solverThread.is_alive() self.startButton.setEnabled(not running) self.stopButton.setEnabled(running) self.resetButton.setEnabled(self.solver is not None and not running) def updateStatus(self): if not self.solver: return if not self.solverThread.is_alive(): self.running = False self.updateTimer.stop() self.updateButtons() if self.solver.progress > 0: self.progressBar.setValue(1000 * self.solver.progress) with self.solver.lock: t = np.array(self.solver.timeseriesWriter.t) Sc = np.array(self.solver.timeseriesWriter.Sc) self.T_profile.set_data(self.solver.x * 1000, self.solver.T) self.hrr_profile.set_data(self.solver.x * 1000, self.solver.qDot / 1e6) self.Sc_timeseries.set_data(1000 * t, Sc * 100) for ax in (self.ax1, self.ax2a, self.ax2b): ax.relim() ax.autoscale_view(False, True, True) self.canvas.draw()
class Plot(): ''' A container for holding variables and methods needed for animating the interactive plot, is a child of a PlotPage object ''' def __init__(self, parent, seconds, scale, num): self.parent = parent self.scale = scale self.scale['command'] = self.updatePos self.scale_pos = 0 self.num = num # Which number servo, for plot title self.length = 0 self.click = False # Node follows mouse only when clicked self.point_index = None # Track which node has been selected # For keeping values within range of servo degrees self.upper_limit = 179 self.lower_limit = 0 self.limit_range = lambda n: max(min(self.upper_limit, n), self. lower_limit) # Initial Graph ----- self.fig = Figure(figsize=(10, 5), dpi=100) self.fig.subplots_adjust(bottom=0.18) self.ax = self.fig.add_subplot(111) self.xs = [i for i in range(self.length)] self.ys = [self.lower_limit for i in self.xs] self.setPlot() self.drawPlot() def updatePos(self, *args): '''Read the scale to move plot viewing area, args are a tuple of scale value automatically passed in''' self.scale_pos = self.scale.get() self.update() def setPlot(self): '''Elements of the plot which do not need to be redrawn every update ''' self.ax.set_ylim([-10, 190]) self.ax.set_yticks(range(0, 190, 20)) self.ax.grid(alpha=.5) self.ax.set_xlabel('Seconds') self.ax.set_ylabel('Degree of Motion', fontname='BPG Courier GPL&GNU', fontsize=14) def clearPlotLines(self): '''Remove plotted lines so they can be redrawn''' self.line.remove() self.nodes.remove() self.upper.remove() self.lower.remove() def drawPlot(self): '''Draw the actual plot''' self.ax.set_title(label=self.parent.name, fontsize=18, y=1.03) x_window = 20 # Num of ticks in 'viewport' pos = round(self.scale_pos * 2) # scale_pos is in seconds, pos is in ticks pos = max(pos, 0) # Confine y-values to within upper and lower limits self.ys = [self.limit_range(node) for node in self.ys] # Only 'x_window' of plot is viewable self.ax.set_xlim([pos - .5, pos + x_window + .5]) self.ax.set_xticks([i for i in range(pos, pos + x_window + 1)]) self.ax.set_xticklabels([i / 2 for i in self.ax.get_xticks()]) for tick in self.ax.get_xticklabels(): tick.set_rotation(45) #~ # Plot upper and lower limits self.upper, = self.ax.plot(self.xs, [self.upper_limit for i in self.xs], 'k--', alpha=.6, linewidth=1) self.lower, = self.ax.plot(self.xs, [self.lower_limit for i in self.xs], 'k--', alpha=.6, linewidth=1) # Line self.line, = self.ax.plot(self.xs, self.ys, color='orange', markersize=10) # Clickable nodes self.nodes, = self.ax.plot(self.xs, self.ys, 'k.', markersize=10, picker=5.0) def onPress(self, event): '''Which node has been clicked''' point = event.artist index = event.ind self.point_index = int(index[0]) if not event.mouseevent.dblclick: self.click = True else: # If node is double-clicked open popup to change value sleep(.1) # Short delay to end all events on mainloop ValuePopup(self, self.point_index) def onMotion(self, event): if self.click and event.inaxes: # Point follows mouse on y-axis self.ys[self.point_index] = self.limit_range(event.ydata) # Round to nearest whole degree self.ys[self.point_index] = int(round(self.ys[self.point_index])) self.update() def onRelease(self, event): if self.point_index is not None: self.click = False self.point_index = None def update(self): '''Re-draw plot after moving a point''' self.clearPlotLines() self.drawPlot() self.fig.canvas.draw()
class GraphStyleDialog(wx.Dialog): def __init__(self, *args, **kwds): kwds["style"] = wx.DEFAULT_FRAME_STYLE wx.Dialog.__init__(self, *args, **kwds) self.list_modes = wx.ListBox(self, -1, choices=[]) self.sizer_list_modes_staticbox = wx.StaticBox( self, -1, _("List of graph style modes")) self.sizer_preview_staticbox = wx.StaticBox(self, -1, _("Preview")) self.label_bg_color = wx.StaticText(self, -1, _("Background color") + ": ") self.button_bg_color = wx.ColourPickerCtrl(self, -1, '#FFFFFF') self.label_grid_color = wx.StaticText(self, -1, _("Grid color") + ": ") self.button_grid_color = wx.ColourPickerCtrl(self, -1, '#666666') self.label_line_color = wx.StaticText(self, -1, _("Line color") + ": ") self.button_line_color = wx.ColourPickerCtrl(self, -1, '#0000FF') self.label_line_style = wx.StaticText(self, -1, _("Line style") + ": ") self.combo_line_style = wx.ComboBox( self, -1, choices=[_("Solid"), _("Dashed"), _("Dashdot"), _("Dotted")], style=wx.CB_DROPDOWN | wx.CB_READONLY) self.label_line_width = wx.StaticText(self, -1, _("Line width") + ": ") self.spin_line_width = wx.SpinCtrl(self, -1, "", min=1, max=10) self.sizer_customize_staticbox = wx.StaticBox(self, -1, _("Customize")) self.button_apply_style = wx.Button(self, -1, _("Apply graph style")) self.first_time = True self.is_customized = False self.dpi = 70 self.fig = Figure((3.0, 3.0), dpi=self.dpi) self.fig.subplots_adjust( left=0.05, right=0.945, top=0.95, bottom=0.06) # Adjust the chart to occupy as much space the canvas self.axes = self.fig.add_subplot(111) self.plot_data = self.axes.plot([])[0] example_data_x = numpy.linspace(0, 10) example_data_y = numpy.power(2, example_data_x) / 10 self.plot_data.set_xdata(example_data_x) self.plot_data.set_ydata(example_data_y) self.axes.set_xbound(lower=5, upper=10) self.axes.set_ybound(lower=1, upper=90) self.canvas = FigCanvas(self, -1, self.fig) self.__insert_style_modes() self.__set_properties() self.__do_layout() self.Bind(wx.EVT_LISTBOX, self.on_select_mode, self.list_modes) self.Bind(wx.EVT_LISTBOX_DCLICK, self.on_dclick_list_modes, self.list_modes) self.Bind(wx.EVT_COLOURPICKER_CHANGED, self.on_change_bg_color, self.button_bg_color) self.Bind(wx.EVT_COLOURPICKER_CHANGED, self.on_change_grid_color, self.button_grid_color) self.Bind(wx.EVT_COLOURPICKER_CHANGED, self.on_change_line_color, self.button_line_color) self.Bind(wx.EVT_COMBOBOX, self.on_change_line_style, self.combo_line_style) self.Bind(wx.EVT_SPINCTRL, self.on_change_line_width, self.spin_line_width) self.Bind(wx.EVT_BUTTON, self.on_apply_style, self.button_apply_style) def __set_properties(self): self.SetTitle(_("Graph style configuration")) self.SetSize((700, 530)) self.list_modes.SetSelection(0) self.combo_line_style.SetSelection(0) self.button_apply_style.SetMinSize((230, 37)) self.__set_colors('#FFFFFF', '#666666', '#0000FF', 0, 1) def __do_layout(self): separator = wx.BoxSizer(wx.VERTICAL) sizer_div = wx.BoxSizer(wx.HORIZONTAL) sizer_subdiv = wx.BoxSizer(wx.VERTICAL) self.sizer_customize_staticbox.Lower() sizer_customize = wx.StaticBoxSizer(self.sizer_customize_staticbox, wx.HORIZONTAL) grid_sizer_customize = wx.FlexGridSizer(5, 2, 5, 0) self.sizer_preview_staticbox.Lower() sizer_preview = wx.StaticBoxSizer(self.sizer_preview_staticbox, wx.HORIZONTAL) self.sizer_list_modes_staticbox.Lower() sizer_list_modes = wx.StaticBoxSizer(self.sizer_list_modes_staticbox, wx.HORIZONTAL) sizer_list_modes.Add(self.list_modes, 1, wx.ALL | wx.EXPAND, 5) sizer_div.Add(sizer_list_modes, 3, wx.ALL | wx.EXPAND, 5) sizer_preview.Add(self.canvas, 1, wx.EXPAND, 0) sizer_subdiv.Add(sizer_preview, 1, wx.ALL | wx.EXPAND, 5) grid_sizer_customize.Add(self.label_bg_color, 0, wx.ALIGN_CENTER_VERTICAL, 0) grid_sizer_customize.Add(self.button_bg_color, 0, wx.EXPAND, 0) grid_sizer_customize.Add(self.label_grid_color, 0, wx.ALIGN_CENTER_VERTICAL, 0) grid_sizer_customize.Add(self.button_grid_color, 0, wx.EXPAND, 0) grid_sizer_customize.Add(self.label_line_color, 0, wx.ALIGN_CENTER_VERTICAL, 0) grid_sizer_customize.Add(self.button_line_color, 0, wx.EXPAND, 0) grid_sizer_customize.Add(self.label_line_style, 0, wx.ALIGN_CENTER_VERTICAL, 0) grid_sizer_customize.Add(self.combo_line_style, 0, wx.EXPAND, 0) grid_sizer_customize.Add(self.label_line_width, 0, wx.ALIGN_CENTER_VERTICAL, 0) grid_sizer_customize.Add(self.spin_line_width, 0, wx.EXPAND, 0) grid_sizer_customize.AddGrowableCol(1) sizer_customize.Add(grid_sizer_customize, 1, wx.ALL | wx.EXPAND, 5) sizer_subdiv.Add(sizer_customize, 0, wx.ALL | wx.EXPAND, 5) sizer_div.Add(sizer_subdiv, 4, wx.EXPAND, 0) separator.Add(sizer_div, 1, wx.EXPAND, 0) separator.Add(self.button_apply_style, 0, wx.RIGHT | wx.BOTTOM | wx.ALIGN_RIGHT, 5) self.SetSizer(separator) self.Layout() def __insert_style_modes(self): # Format for adding new graphics style modes: # self.list_modes.Append(<Mode name>, ModeStyle(<bg color>, <grid color>, <line color>, <num line style>, <num line width>)) self.list_modes.Append( _("Default"), ModeStyle('#FFFFFF', '#666666', '#0000FF', 0, 1)) self.list_modes.Append( "Contrast", ModeStyle('#000000', '#FFFFFF', '#FFFFFF', 0, 1)) self.list_modes.Append( "Simple", ModeStyle('#FFFFFF', '#000000', '#000000', 0, 1)) self.list_modes.Append( "Hacker", ModeStyle('#000000', '#00FF00', '#00FF00', 0, 1)) self.list_modes.Append( "Aqua", ModeStyle('#0E2581', '#FFFFFF', '#00EDF6', 0, 1)) self.list_modes.Append( "Inferno", ModeStyle('#6B0000', '#FFFFFF', '#FF0000', 0, 1)) self.list_modes.Append( "Tropical", ModeStyle('#00B829', '#006207', '#FFFF00', 1, 2)) self.list_modes.Append( "Desert", ModeStyle('#A94000', '#FFC800', '#FFB612', 0, 1)) self.list_modes.Append( "Night", ModeStyle('#000000', '#FFFF00', '#FFFF00', 3, 2)) def __get_name_line_style(self, n): name = None if n == 0: name = "solid" elif n == 1: name = "dashed" elif n == 2: name = "dashdot" elif n == 3: name = "dotted" return name def __set_colors(self, bg_color, grid_color, line_color, line_style, line_width): self.button_bg_color.SetColour(bg_color) self.button_grid_color.SetColour(grid_color) self.button_line_color.SetColour(line_color) self.combo_line_style.SetSelection(line_style) self.spin_line_width.SetValue(line_width) self.axes.set_axis_bgcolor(bg_color) self.axes.grid(True, color=grid_color) self.plot_data.set_color(line_color) self.plot_data.set_linestyle(self.__get_name_line_style(line_style)) self.plot_data.set_linewidth(line_width) self.canvas.draw() def on_dclick_list_modes(self, event): style_conf = self.list_modes.GetClientData( self.list_modes.GetSelection()) self.__set_colors(style_conf.bg_color, style_conf.grid_color, style_conf.line_color, style_conf.line_style, style_conf.line_width) self.EndModal(0) def on_select_mode(self, event): if self.first_time and self.is_customized: self.list_modes.SetSelection(wx.NOT_FOUND) self.first_time = False else: style_conf = self.list_modes.GetClientData( self.list_modes.GetSelection()) self.__set_colors(style_conf.bg_color, style_conf.grid_color, style_conf.line_color, style_conf.line_style, style_conf.line_width) def on_change_bg_color(self, event): new_bg_color = GetColorString(self.button_bg_color.GetColour()) self.axes.set_axis_bgcolor(new_bg_color) self.canvas.draw() self.list_modes.SetSelection(wx.NOT_FOUND) def on_change_grid_color(self, event): new_grid_color = GetColorString(self.button_grid_color.GetColour()) self.axes.grid(True, color=new_grid_color) self.canvas.draw() self.list_modes.SetSelection(wx.NOT_FOUND) def on_change_line_color(self, event): new_line_color = GetColorString(self.button_line_color.GetColour()) self.plot_data.set_color(new_line_color) self.canvas.draw() self.list_modes.SetSelection(wx.NOT_FOUND) def on_change_line_style(self, event): new_line_style = self.combo_line_style.GetSelection() self.plot_data.set_linestyle( self.__get_name_line_style(new_line_style)) self.canvas.draw() self.list_modes.SetSelection(wx.NOT_FOUND) def on_change_line_width(self, event): new_line_width = self.spin_line_width.GetValue() self.plot_data.set_linewidth(new_line_width) self.canvas.draw() self.list_modes.SetSelection(wx.NOT_FOUND) def on_apply_style(self, event): self.EndModal(0) def GetModeName(self): name_mode = None if self.list_modes.GetSelection() == wx.NOT_FOUND: name_mode = _("Customized") elif self.list_modes.GetSelection() == 0: name_mode = self.list_modes.GetString( self.list_modes.GetSelection()) else: name_mode = _("{0} mode").format( self.list_modes.GetString(self.list_modes.GetSelection())) return name_mode def GetBgColor(self): return GetColorString(self.button_bg_color.GetColour()) def GetGridColor(self): return GetColorString(self.button_grid_color.GetColour()) def GetLineColor(self): return GetColorString(self.button_line_color.GetColour()) def GetLineStyle(self): return self.__get_name_line_style(self.combo_line_style.GetSelection()) def GetLineWidth(self): return self.spin_line_width.GetValue() def GetModeNumber(self): return self.list_modes.GetSelection() def GetLineStyleNumber(self): return self.combo_line_style.GetSelection() def SetModeNumber(self, nr_mode): self.list_modes.SetSelection(nr_mode) # It is neccesary to work on OSX systems style_conf = self.list_modes.GetClientData(nr_mode) self.__set_colors(style_conf.bg_color, style_conf.grid_color, style_conf.line_color, style_conf.line_style, style_conf.line_width) def SetCustomizedMode(self, bg_color, grid_color, line_color, line_style, line_width): self.is_customized = True self.__set_colors(bg_color, grid_color, line_color, line_style, line_width) self.list_modes.SetSelection(wx.NOT_FOUND)
weightlist[0][0] * -1 + weightlist[0][1] * test1_x1[item_te1] + weightlist[0][2] * test1_x2[item_te1])) t_test1_x2.append(sigmoid( weightlist[1][0] * -1 + weightlist[1][1] * test1_x1[item_te1] + weightlist[1][2] * test1_x2[item_te1])) for item_te2 in range(len(test2_x1)): t_test2_x1.append(sigmoid( weightlist[0][0] * -1 + weightlist[0][1] * test2_x1[item_te2] + weightlist[0][2] * test2_x2[item_te2])) t_test2_x2.append(sigmoid( weightlist[1][0] * -1 + weightlist[1][1] * test2_x1[item_te2] + weightlist[1][2] * test2_x2[item_te2])) display_output_weight = tk.Label( window, width=35, height=2, text=weightlist[-1], fg='black', anchor='w', wraplength=250) display_output_weight.place(x=30, y=200) # draw f = Figure(figsize=(3, 6), dpi=150) f.subplots_adjust(left=0.25, right=0.95, top=0.90, bottom=0.1) f_plot = f.add_subplot(211) f_plot2 = f.add_subplot(212) f_plot.tick_params(labelsize=8) f_plot2.tick_params(labelsize=8) canvas = FigureCanvasTkAgg(f, window) canvas.get_tk_widget().place(x=300, y=0) # original f_plot.clear() legend_train1 = f_plot.scatter( train1_x1, train1_x2, c='r', marker='o', s=8) legend_train2 = f_plot.scatter( train2_x1, train2_x2, c='r', marker='x', s=8) if case == 1: if test_y[0] == 0:
class graph_panel(wx.Panel): def __init__(self, *args, **kwargs): wx.Panel.__init__(self, *args, **kwargs) self.previous_patterns = [] self.history_size = 100 self.hi_contrast = False self.build() def build(self): self.fig = Figure(dpi=110) #self.fig.set_facecolor('#d4d0c8') self.fig.set_facecolor('#888888') self.canvas = FigCanvas(self, -1, self.fig) self.Bind(wx.EVT_SIZE, self.sizeHandler) self.SetMinSize((400, 200)) self.clear() self.draw() def sizeHandler(self, *args, **kwargs): ''' makes sure that the canvas is properly resized ''' self.canvas.SetSize(self.GetSize()) ######################## def set_hi_contrast(self, event): ''' set the contrast ''' self.hi_contrast = event.IsChecked() def clear(self): ''' called when the pattern changes ''' self.need_data = True self.singles_curves = [] self.coincidence_curves = [] def add_counts(self, data): ''' add a set of counts ''' new_singles = filter(lambda x: len(x[1]) == 1, data) new_coincidences = filter(lambda x: len(x[1]) > 1, data) if self.need_data: self.singles_curves = [ curve(q[0], self.history_size) for q in new_singles ] self.coincidence_curves = [ curve(q[0], self.history_size) for q in new_coincidences ] self.need_data = False for i in range(len(self.singles_curves)): self.singles_curves[i].add_point(new_singles[i][2]) for i in range(len(self.coincidence_curves)): self.coincidence_curves[i].add_point(new_coincidences[i][2]) self.draw() def draw_curve_set(self, curves, subplot_index): ax = self.fig.add_subplot(subplot_index) ax.set_axis_bgcolor('#000000') for c in curves: c.draw(ax, self.hi_contrast) ax.set_xlim(0, self.history_size) yfm = ax.yaxis.get_major_formatter() yfm.set_powerlimits([0, 1]) def draw(self): ''' draw all of the curves etc ''' self.fig.clf() self.draw_curve_set(self.singles_curves, 211) self.draw_curve_set(self.coincidence_curves, 212) self.fig.subplots_adjust(left=.05, right=.98, top=.97, bottom=.05) self.canvas.draw()
class Graph_viewer: def __init__(self, graph, actions=['nothing'], callback=None): """ weights : dictionary mapping name to weight kmers will be colored in rank order of weight """ self.graph = graph self.callback = callback self.window = gtk.Window() self.window.connect('destroy', lambda x: gtk.main_quit()) self.window.set_default_size(800, 600) self.window.set_title('Graph viewer') vbox = gtk.VBox() self.window.add(vbox) self.figure = Figure(figsize=(8, 6), dpi=50) self.axes = self.figure.add_subplot(111) colors = numpy.empty((len(graph.names), 3)) sizes = numpy.empty(len(graph.names)) sizes[:] = 2.0 #if weights is None: # #self.axes.plot(graph.positions[:,0], graph.positions[:,1], ',') # # colors[:,:] = [[0.0,0.0,0.0]] # #else: #names = weights.keys() #values = weights.values() ##names.sort(key=lambda x: weights[x]) #idents = numpy.array([ graph.name_to_ident[name] for name in names ]) #x = numpy.array(values, dtype='float64') x = numpy.array(graph.weights, dtype='float64') x = numpy.log(x) x -= numpy.minimum.reduce(x) x /= numpy.average(x) * 2.0 #x /= numpy.sum(x*x)*2.0/numpy.sum(x) xx = numpy.minimum(x, 1.0) #x = numpy.arange(len(graph.names)) / float(len(graph.names)) colors[:, 0] = 0.5 - xx * 0.5 colors[:, 1] = 0.75 - xx * 0.5 colors[:, 2] = 1.0 - xx * 0.5 sizes[:] = numpy.maximum(x, 1.0)**2 #*2.0 #n = 20 #for i in xrange(n): # start = i*len(names)//n # end = (i+1)*len(names)//n # if start == end: continue # # x = (1.0-float(i)/(n-1)) # position_block = graph.positions[idents[start:end]] # self.axes.scatter(position_block[:,0], # position_block[:,1], # linewidths=0, # marker='s', # s=10.0, # c=(0.0,x,x*0.5+0.5), # zorder=i) dots = Dots(graph.positions[:, 1], graph.positions[:, 0], colors, sizes) self.axes.add_artist(dots) #if len(graph.links) < 1000: # for i, (other, other_sign, other_travel) in enumerate(graph.links): # for j in other: # if j > i: # self.axes.plot([graph.positions[i,0],graph.positions[j,0]], # [graph.positions[i,1],graph.positions[j,1]], # 'k-') self.axes.axis('scaled') self.axes.set_xlim(0.0, numpy.maximum.reduce(graph.positions[:, 0]) * 1.1) self.axes.set_ylim(0.0, numpy.maximum.reduce(graph.positions[:, 1]) * 1.1) self.figure.subplots_adjust(top=0.99, bottom=0.05, right=0.99, left=0.05) #pylab.connect('button_press_event', self._on_click) self.annotation_pylab = [] self.clear_annotation() self.canvas = FigureCanvas(self.figure) # a gtk.DrawingArea self.canvas.mpl_connect('button_press_event', self._on_down) self.canvas.mpl_connect('button_release_event', self._on_up) vbox.pack_start(self.canvas) hbox = gtk.HBox() vbox.pack_start(hbox, False, False, 10) label = gtk.Label('Middle click:') hbox.pack_start(label, False, False, 5) self.radios = {} last = None for action in actions: radio = gtk.RadioButton(group=last, label=action) last = radio self.radios[action] = radio hbox.pack_start(radio, False, False, 5) label = gtk.Label('Right click: clear') hbox.pack_end(label, False, False, 5) self.radios[actions[0]].set_active(True) toolbar = NavigationToolbar(self.canvas, self.window) vbox.pack_start(toolbar, False, False) def run(self): self.window.show_all() gtk.main() def clear_annotation(self): self.annotation = {} def label(self, name, label): ident = self.graph.name_to_ident[name] self.axes.text(self.graph.positions[ident, 0], self.graph.positions[ident, 1], label, horizontalalignment='center', verticalalignment='bottom', zorder=100000) def arrow(self, names, label): positions = [ self.graph.positions[self.graph.name_to_ident[name]] for name in names if self.graph.has(name) ] if not positions: return #Error? max_positions = max(4, (len(positions) + 29) // 30) #20 if len(positions) > max_positions: positions = [ positions[i * (len(positions) - 1) // (max_positions - 1)] for i in xrange(max_positions) ] arrow = Arrow(positions, label, True) #names = [ name for name in names if self.graph.has(name) ] # #if len(names) < 2: return #Error? # #ident1 = self.graph.name_to_ident[names[0]] #ident2 = self.graph.name_to_ident[names[-1]] # #arrow = Arrow(self.graph.positions[ident1], # self.graph.positions[ident2], # label, # True) self.axes.add_artist(arrow) def annotate(self, name, mass, r, g, b): r *= mass g *= mass b *= mass old_mass, old_r, old_g, old_b = self.annotation.get( name, (0.0, 0.0, 0.0, 0.0)) self.annotation[name] = (old_mass + mass, old_r + r, old_g + g, old_b + b) def refresh_annotation(self): while self.annotation_pylab: item = self.annotation_pylab.pop(-1) item.remove() xs = [] ys = [] colors = [] sizes = [] for name in self.annotation: mass, r, g, b = self.annotation[name] if not mass: continue ident = self.graph.name_to_ident[name] xs.append(self.graph.positions[ident, 0]) ys.append(self.graph.positions[ident, 1]) colors.append((r / mass, g / mass, b / mass)) sizes.append(mass) if xs: #thing = self.axes.scatter( # xs, # ys, # s=sizes, # c=colors, # linewidths=0, # marker='s', # zorder=10000) thing = Dots(numpy.array(ys), numpy.array(xs), numpy.array(colors), numpy.array(sizes), zorder=2) self.axes.add_artist(thing) self.annotation_pylab.append(thing) self.canvas.draw() def name_from_position(self, x, y): xoff = self.graph.positions[:, 0] - x yoff = self.graph.positions[:, 1] - y dist2 = xoff * xoff + yoff * yoff best = numpy.argmin(dist2) return self.graph.names[best] def _on_down(self, event): self.down_name = self.name_from_position(event.xdata, event.ydata) def _on_up(self, event): if event.inaxes and event.button == 3: self.clear_annotation() self.refresh_annotation() elif event.inaxes and event.button == 2: name = self.name_from_position(event.xdata, event.ydata) if self.callback: action = None for item in self.radios: if self.radios[item].get_active(): action = item self.callback(self, action, self.down_name, name) self.refresh_annotation() del self.down_name
class MasterPlot(Plot): k1={'amd64' : ['amd64_core','amd64_core','amd64_sock','lnet','lnet', 'ib_sw','ib_sw','cpu'], 'intel_pmc3' : ['intel_pmc3', 'intel_pmc3', 'intel_pmc3', 'intel_pmc3', 'lnet', 'lnet', 'ib_ext','ib_ext','cpu','mem','mem','mem'], 'intel_nhm' : ['intel_nhm', 'intel_nhm', 'intel_nhm', 'intel_nhm', 'lnet', 'lnet', 'ib_ext','ib_ext','cpu','mem','mem','mem'], 'intel_wtm' : ['intel_wtm', 'intel_wtm', 'intel_wtm', 'intel_wtm', 'lnet', 'lnet', 'ib_ext','ib_ext','cpu','mem','mem','mem'], 'intel_snb' : ['intel_snb_imc', 'intel_snb_imc', 'intel_snb', 'lnet', 'lnet', 'ib_sw','ib_sw','cpu', 'intel_snb', 'intel_snb', 'intel_snb', 'mem', 'mem','mem'], 'intel_hsw' : ['intel_hsw_imc', 'intel_hsw_imc', 'intel_hsw', 'lnet', 'lnet', 'ib_sw','ib_sw','cpu', 'intel_hsw', 'intel_hsw', 'intel_hsw', 'mem', 'mem','mem'], 'intel_ivb' : ['intel_ivb_imc', 'intel_ivb_imc', 'intel_ivb', 'lnet', 'lnet', 'ib_sw','ib_sw','cpu', 'intel_ivb', 'intel_ivb', 'intel_ivb', 'mem', 'mem','mem'], } k2={'amd64': ['SSE_FLOPS','DCSF','DRAM','rx_bytes','tx_bytes', 'rx_bytes','tx_bytes','user'], 'intel_pmc3' : ['MEM_UNCORE_RETIRED_REMOTE_DRAM', 'MEM_UNCORE_RETIRED_LOCAL_DRAM', 'FP_COMP_OPS_EXE_SSE_PACKED', 'FP_COMP_OPS_EXE_SSE_SCALAR', 'rx_bytes','tx_bytes', 'port_recv_data','port_xmit_data','user', 'MemUsed', 'FilePages','Slab'], 'intel_nhm' : ['MEM_UNCORE_RETIRED_REMOTE_DRAM', 'MEM_UNCORE_RETIRED_LOCAL_DRAM', 'FP_COMP_OPS_EXE_SSE_PACKED', 'FP_COMP_OPS_EXE_SSE_SCALAR', 'rx_bytes','tx_bytes', 'port_recv_data','port_xmit_data','user', 'MemUsed', 'FilePages','Slab'], 'intel_wtm' : ['MEM_UNCORE_RETIRED_REMOTE_DRAM', 'MEM_UNCORE_RETIRED_LOCAL_DRAM', 'FP_COMP_OPS_EXE_SSE_PACKED', 'FP_COMP_OPS_EXE_SSE_SCALAR', 'rx_bytes','tx_bytes', 'port_recv_data','port_xmit_data','user', 'MemUsed', 'FilePages','Slab'], 'intel_snb' : ['CAS_READS', 'CAS_WRITES', 'LOAD_L1D_ALL', 'rx_bytes','tx_bytes', 'rx_bytes','tx_bytes','user', 'SSE_DOUBLE_SCALAR', 'SSE_DOUBLE_PACKED', 'SIMD_DOUBLE_256', 'MemUsed', 'FilePages','Slab'], 'intel_hsw' : ['CAS_READS', 'CAS_WRITES', 'LOAD_L1D_ALL', 'rx_bytes','tx_bytes', 'rx_bytes','tx_bytes','user', 'SSE_DOUBLE_SCALAR', 'SSE_DOUBLE_PACKED', 'SIMD_DOUBLE_256', 'MemUsed', 'FilePages','Slab'], 'intel_ivb' : ['CAS_READS', 'CAS_WRITES', 'LOAD_L1D_ALL', 'rx_bytes','tx_bytes', 'rx_bytes','tx_bytes','user', 'SSE_DOUBLE_SCALAR', 'SSE_DOUBLE_PACKED', 'SIMD_DOUBLE_256', 'MemUsed', 'FilePages','Slab'], } fname='master' def plot(self,jobid,job_data=None): if not self.setup(jobid,job_data=job_data): return if self.wide: self.fig = Figure(figsize=(15.5,12),dpi=110) self.ax=self.fig.add_subplot(6,2,2) cols = 2 shift = 2 else: self.fig = Figure(figsize=(8,12),dpi=110) self.ax=self.fig.add_subplot(6,1,1) cols = 1 shift = 1 if self.mode == 'hist': plot=self.plot_thist elif self.mode == 'percentile': plot=self.plot_mmm else: plot=self.plot_lines k1_tmp=self.k1[self.ts.pmc_type] k2_tmp=self.k2[self.ts.pmc_type] processor_schema = self.ts.j.schemas[self.ts.pmc_type] # Plot key 1 for flops plot_ctr = 0 try: if 'SSE_D_ALL' in processor_schema and 'SIMD_D_256' in processor_schema: idx0 = k2_tmp.index('SSE_D_ALL') idx1 = None idx2 = k2_tmp.index('SIMD_D_256') elif 'SSE_DOUBLE_SCALAR' in processor_schema and 'SSE_DOUBLE_PACKED' in processor_schema and 'SIMD_DOUBLE_256' in processor_schema: idx0 = k2_tmp.index('SSE_DOUBLE_SCALAR') idx1 = k2_tmp.index('SSE_DOUBLE_PACKED') idx2 = k2_tmp.index('SIMD_DOUBLE_256') elif 'FP_COMP_OPS_EXE_SSE_PACKED' in processor_schema and 'FP_COMP_OPS_EXE_SSE_SCALAR' in processor_schema: idx0 = k2_tmp.index('FP_COMP_OPS_EXE_SSE_SCALAR') idx1 = k2_tmp.index('FP_COMP_OPS_EXE_SSE_PACKED') idx2 = None else: print("FLOP stats not available for JOBID",self.ts.j.id) raise plot_ctr += 1 ax = self.fig.add_subplot(6,cols,plot_ctr*shift) for host_name in self.ts.j.hosts.keys(): flops = self.ts.assemble([idx0],host_name,0) if idx1: flops += 2*self.ts.assemble([idx1],host_name,0) if idx2: flops += 4*self.ts.assemble([idx2],host_name,0) flops = numpy.diff(flops)/numpy.diff(self.ts.t)/1.0e9 ax.step(self.ts.t/3600., numpy.append(flops, [flops[-1]]), where="post") ax.set_ylabel('Dbl GFLOPS') ax.set_xlim([0.,self.ts.t[-1]/3600.]) tspl_utils.adjust_yaxis_range(ax,0.1) except: print sys.exc_info()[0] print("FLOP plot not available for JOBID",self.ts.j.id) # Plot key 2 try: if 'CAS_READS' in k2_tmp and 'CAS_WRITES' in k2_tmp: idx0=k2_tmp.index('CAS_READS') idx1=k2_tmp.index('CAS_WRITES') elif 'MEM_UNCORE_RETIRED_REMOTE_DRAM' in k2_tmp and 'MEM_UNCORE_RETIRED_LOCAL_DRAM' in k2_tmp: idx0=k2_tmp.index('MEM_UNCORE_RETIRED_REMOTE_DRAM') idx1=k2_tmp.index('MEM_UNCORE_RETIRED_LOCAL_DRAM') else: print(self.ts.pmc_type + ' missing Memory Bandwidth data' + ' for jobid ' + self.ts.j.id ) raise plot_ctr += 1 plot(self.fig.add_subplot(6,cols,plot_ctr*shift), [idx0,idx1], 3600., 1.0/64.0*1024.*1024.*1024., ylabel='Total Mem BW GB/s') except: print(self.ts.pmc_type + ' missing Memory Bandwidth plot' + ' for jobid ' + self.ts.j.id ) #Plot key 3 idx0=k2_tmp.index('MemUsed') idx1=k2_tmp.index('FilePages') idx2=k2_tmp.index('Slab') plot_ctr += 1 plot(self.fig.add_subplot(6,cols,plot_ctr*shift), [idx0,-idx1,-idx2], 3600.,2.**30.0, ylabel='Memory Usage GB',do_rate=False) # Plot lnet sum rate idx0=k1_tmp.index('lnet') idx1=idx0 + k1_tmp[idx0+1:].index('lnet') + 1 plot_ctr += 1 plot(self.fig.add_subplot(6,cols,plot_ctr*shift), [idx0,idx1], 3600., 1024.**2, ylabel='Total lnet MB/s') # Plot remaining IB sum rate if 'ib_ext' in self.ts.j.hosts.values()[0].stats: try: idx2=k1_tmp.index('ib_sw') idx3=idx2 + k1_tmp[idx2+1:].index('ib_sw') + 1 except: idx2=k1_tmp.index('ib_ext') idx3=idx2 + k1_tmp[idx2+1:].index('ib_ext') + 1 try: plot_ctr += 1 plot(self.fig.add_subplot(6,cols,plot_ctr*shift),[idx2,idx3,-idx0,-idx1],3600.,2.**20, ylabel='Total (ib-lnet) MB/s') except: pass #Plot CPU user time idx0 = [k2_tmp.index('user')] plot_ctr += 1 wayness = len(self.ts.j.hosts.values()[0].stats['cpu'].keys()) plot(self.fig.add_subplot(6,cols,plot_ctr*shift),idx0,3600.,wayness, xlabel='Time (hr)', ylabel='cpu usage %') self.fig.subplots_adjust(hspace=0.35) self.output('master')
class MyFigureCanvas(FigureCanvas): """ Main class of generating figs in GUI using matplot.backend_qt5agg Contains: drawing functions plot_acc_response_ plot_launch_ plot_max_acc_ plot_pedal_map_ plot_raw_data plot_radar_map_ """ def __init__(self, parent=None, width=10, height=10, dpi=100, plot_type='3d', **kwargs): self.fig = Figure(figsize=(width, height), dpi=100) super(MyFigureCanvas, self).__init__(self.fig) self.kwargs = kwargs # self.data = data # self.parameter1 = para1 # FigureCanvas.__init__(self, fig) # 初始化父类 堆栈溢出问题! # self.setParent(parent) if plot_type == '2d': self.axes = self.fig.add_axes([0.1, 0.1, 0.8, 0.8]) elif plot_type == '3d': self.fig.subplots_adjust(left=0.08, top=0.92, right=0.95, bottom=0.1) self.axes = self.fig.add_subplot(111, projection='3d') elif plot_type == '2d-poly': self.axes = self.fig.add_subplot(111, polar=True) elif plot_type == '2d-multi': pass elif plot_type == '3d-subplot': pass elif plot_type == '2d-subplot': pass def plot_acc_response(self, data, ped_avg): # 目前做不到先画图,后统一输出,只能在主线程里面同步画 for i in range(0, len(data[1])): self.axes.plot(data[1][i], data[0][i], data[2][i], label=int(round(ped_avg[i] / 5) * 5)) self.axes.legend(bbox_to_anchor=(1.02, 1), loc=1, borderaxespad=0) self.axes.set_xlabel('Velocity (kph)', fontsize=12) self.axes.set_ylabel('Pedal (%)', fontsize=12) self.axes.set_zlabel('Acc (g) ', fontsize=12) def plot_launch(self, data): for i in range(0, len(data[2])): self.axes.plot(data[2][i], data[1][i], label=int(round(np.mean(data[0][i]) / 5) * 5)) self.axes.legend() self.axes.grid(True, linestyle="--", color="k", linewidth="0.4") self.axes.set_xlabel('Time (s)', fontsize=12) self.axes.set_ylabel('Acc (g)', fontsize=12) self.axes.set_title('Launch', fontsize=12) def plot_max_acc(self, data): # self.axes.plot(data[0], data[1], color='green', linestyle='dashed', marker='o', markerfacecolor='blue', # markersize=8) self.axes.plot(data[0], data[1], linestyle='dashed', marker='o', markersize=8) self.axes.grid(True, linestyle="--", color="k", linewidth="0.4") self.axes.legend() self.axes.set_xlabel('Pedal (%)', fontsize=12) self.axes.set_ylabel('Acc (g)', fontsize=12) self.axes.set_title('Acc-Pedal', fontsize=12) def plot_pedal_map(self, data): pedalmap = self.axes.scatter(data[1], data[2], c=data[0], marker='o', linewidths=0.1, s=6, cmap=cm.get_cmap('RdYlBu_r')) self.axes.grid(True, linestyle="--", color="k", linewidth="0.4") self.axes.set_xlabel('Engine Speed (rpm)', fontsize=12) self.axes.set_ylabel('Torque (Nm)', fontsize=12) self.axes.set_title('PedalMap', fontsize=12) def plot_shift_map(self, data): str_label = [ '1->2', '2->3', '3->4', '4->5', '5->6', '6->7', '7->8', '8->9', '9->10' ] for i in range(1, int(max(data[0])) + 1): # 选择当前Gear, color=colour[i] self.axes.plot(data[2][np.where(data[0] == i)], data[1][np.where(data[0] == i)], marker='o', linestyle='-', linewidth=3, markerfacecolor='blue', markersize=4, label=str_label[i - 1]) self.axes.legend() self.axes.grid(True, linestyle="--", color="k", linewidth="0.4") self.axes.set_xlabel('Vehicle Speed (km/h)', fontsize=12) self.axes.set_ylabel('Pedal (%)', fontsize=12) self.axes.set_title('ShiftMap', fontsize=12) def plot_systemgain_curve(self, vehspd_sg, acc_sg): speedIndex = np.arange(10, 170, 10) speedIndex = speedIndex.tolist() acc_banana = np.zeros((5, len(speedIndex))) acc_banana[0, :] = [ 0.0144, 0.0126, 0.0111, 0.0097, 0.0084, 0.0073, 0.0064, 0.0056, 0.0048, 0.0042, 0.0037, 0.0032, 0.0028, 0.0024, 0.0021, 0.0018 ] acc_banana[1, :] = [ 0.0172, 0.0152, 0.0134, 0.0119, 0.0104, 0.0092, 0.0081, 0.0071, 0.0063, 0.0055, 0.0049, 0.0043, 0.0038, 0.0034, 0.0030, 0.0026 ] acc_banana[2, :] = [ 0.0200, 0.0178, 0.0158, 0.0141, 0.0125, 0.0111, 0.0098, 0.0087, 0.0078, 0.0069, 0.0062, 0.0055, 0.0049, 0.0043, 0.0038, 0.0033 ] acc_banana[3, :] = [ 0.0228, 0.0204, 0.0182, 0.0163, 0.0145, 0.0129, 0.0115, 0.0103, 0.0092, 0.0082, 0.0074, 0.0066, 0.0059, 0.0053, 0.0047, 0.0042 ] acc_banana[4, :] = [ 0.0256, 0.0230, 0.0206, 0.0185, 0.0166, 0.0149, 0.0133, 0.0119, 0.0107, 0.0096, 0.0086, 0.0077, 0.0069, 0.0062, 0.0055, 0.0049 ] # self.axes.plot(vehspd_sg, acc_sg, color='green', linestyle='-') self.axes.plot(vehspd_sg, acc_sg, linestyle='-') self.axes.plot(speedIndex, acc_banana[0, :], color='blue', linestyle='--') self.axes.plot(speedIndex, acc_banana[1, :], color='red', linestyle='--') self.axes.plot(speedIndex, acc_banana[2, :], color='black', linestyle='--') self.axes.plot(speedIndex, acc_banana[3, :], color='blue', linestyle='--') self.axes.plot(speedIndex, acc_banana[4, :], color='red', linestyle='--') self.axes.plot([speedIndex[0]] * 5, acc_banana[:, 0], color='blue', linestyle='-') self.axes.set_xlabel('velocity(km/h)') self.axes.set_ylabel('acc(g/mm)') self.axes.set_xlim(0, 120) self.axes.set_ylim(0, 0.03) self.axes.grid(True, linestyle="-", color="grey", linewidth="0.4") def plot_constant_speed(self, vehspd_cs, pedal_cs): # self.axes.plot(vehspd_cs, pedal_cs, color='green', linestyle='dashed', marker='o', markerfacecolor='blue', # markersize=8) self.axes.plot(vehspd_cs, pedal_cs, linestyle='dashed', marker='o', markersize=8) self.axes.grid(True, linestyle="--", color="k", linewidth="0.4") self.axes.legend() self.axes.set_xlabel('velocity (kph)', fontsize=12) self.axes.set_ylabel('pedal (%)', fontsize=12) self.axes.set_title('Constant Speed', fontsize=12) def plot_acc_response_(self): ''' :return: ''' self.xdata = self.kwargs['data'][1] self.ydata = self.kwargs['data'][0] self.zdata = self.kwargs['data'][2] self.pedal_avg = self.kwargs['pedal_avg'] for i in range(0, len(self.xdata)): self.axes.plot(self.xdata[i], self.ydata[i], self.zdata[i], label=int(round(self.pedal_avg[i] / 5) * 5)) self.axes.legend(bbox_to_anchor=(1.02, 1), loc=1, borderaxespad=0) self.axes.set_xlabel('Vehicle Speed (km/h)', fontsize=12) self.axes.set_ylabel('Pedal(%)', fontsize=12) self.axes.set_zlabel('Acc (g)', fontsize=12) self.axes.set_title('Acc-3D Map', fontsize=12) def plot_launch_(self): self.xdata = self.kwargs['data'][2] self.ydata = self.kwargs['data'][1] self.pedal = self.kwargs['data'][0] for i in range(0, len(self.xdata)): self.axes.plot(self.xdata[i], self.ydata[i], label=int(round(np.mean(self.pedal[i]) / 5) * 5)) self.axes.legend() self.axes.grid(True, linestyle="--", color="k", linewidth="0.4") self.axes.set_xlabel('Time (s)', fontsize=12) self.axes.set_ylabel('Acc (g)', fontsize=12) self.axes.set_title('Launch', fontsize=12) def plot_max_acc_(self): self.xdata = self.kwargs['xdata'] self.ydata = self.kwargs['ydata'] self.axes.plot(self.xdata, self.ydata, color='green', linestyle='dashed', marker='o', markerfacecolor='blue', markersize=8) self.axes.grid(True, linestyle="--", color="k", linewidth="0.4") self.axes.legend() self.axes.set_xlabel('Pedal (%)', fontsize=12) self.axes.set_ylabel('Acc (g)', fontsize=12) self.axes.set_title('Acc-Pedal', fontsize=12) def plot_pedal_map_(self): self.xdata = self.kwargs['data'][1] self.ydata = self.kwargs['data'][2] self.zdata = self.kwargs['data'][0] self.axes.scatter(self.xdata, self.ydata, c=self.zdata, marker='o', linewidths=0.1, s=6, cmap=cm.get_cmap('RdYlBu_r')) self.axes.grid(True, linestyle="--", color="k", linewidth="0.4") self.axes.set_xlabel('Engine Speed (rpm)', fontsize=12) self.axes.set_ylabel('Torque (Nm)', fontsize=12) self.axes.set_title('PedalMap', fontsize=12) def plot_raw_data(self, time, df, **kwargs): pos = [0.02, 0.1, 0.8, 0.8] colors = ['r', 'b', 'g', 'y', 'orchid', 'orange', 'navy'] font_size = 10 for i in range(df.shape[1]): if i == 0: self.axes = self.fig.add_axes( pos, axisbg='w', label=str(df.columns[i])) # 设置初始的图层底色为白色 self.axes.tick_params(axis='x', colors='black', labelsize=10) self.axes.set_xlabel('time (s)', fontsize=12) else: self.axes = self.fig.add_axes( pos, axisbg='none', label=str(df.columns[i])) # 设置随后的图层底色为透明 self.axes.spines['right'].set_position( ('outward', 60 * i)) # 图的右侧边框向外移动 self.axes.spines['right'].set_color(colors[i]) self.axes.spines['right'].set_linewidth(2) self.axes.plot(time, df.iloc[:, i], linewidth=1, color=colors[i]) self.axes.yaxis.set_ticks_position('right') self.axes.tick_params(axis='y', colors=colors[i]) self.axes.set_ylabel(str(df.columns[i]), fontsize=font_size, color=colors[i]) self.axes.yaxis.set_label_position('right') def plot_radar_map_(self): self.theta = self.kwargs['theta'] self.data = self.kwargs['data'] self.legends = self.kwargs['legends'] # plt.thetagrids(theta*(180/np.pi), labels=labels, fontproperties=myfont) self.axes.set_ylim(0, 100) colour_Bar = [ 'blue', 'red', 'c', 'royalblue', 'lightcoral', 'yellow', 'lightgreen', 'brown', 'teal', 'orange', 'coral', 'gold', 'lime', 'olive' ] if self.data.size <= 7: # 一条数据绘制 # 画雷达图,并填充雷达图内部区域 self.axes.plot(self.theta, self.data, "o-", color='blue', linewidth=2) self.axes.fill(self.theta, self.data, color="blue", alpha=0.25) self.axes.set_rgrids(np.arange(20, 100, 20), labels=np.arange(20, 100, 20), angle=0) self.axes.set_thetagrids(self.theta * (180 / np.pi), labels=np.array( ["A", "B", "C", "D", "E", "F"])) self.axes.set_title("Rating") else: for i in range(self.data.size // 7): self.axes.plot(self.theta, self.data[i], 'o-', color=colour_Bar[i], linewidth=2) self.axes.fill(self.theta, self.data[i], color=colour_Bar[i], alpha=0.25) self.axes.set_rgrids(np.arange(20, 100, 20), labels=np.arange(20, 100, 20), angle=0) self.axes.set_thetagrids(self.theta * (180 / np.pi), labels=np.array( ["A", "B", "C", "D", "E", "F"])) self.axes.set_title("Rating Comparison") self.axes.legend(self.legends) def plot_original_fig_sb(self, original_data): self.axes = self.fig.add_axes([0.1, 0.1, 0.8, 0.8]) time_data = original_data.time_data sr_x_data = original_data.sr_x_data sr_y_data = original_data.sr_y_data sr_z_data = original_data.sr_z_data self.axes.plot(time_data, sr_x_data, color='black') self.axes.plot(time_data, sr_y_data, color='red') self.axes.plot(time_data, sr_z_data, color='blue') exam_x = np.where(sr_x_data > 10) exam_y = np.where(sr_y_data > 10) exam_z = np.where(sr_z_data > 10) if exam_x[0].shape[0] > 0: for nn in exam_x: self.axes.plot(time_data[nn], sr_x_data[nn], color='red', marker='x', markersize=12) sr_x_data[nn] = 0 if exam_y[0].shape[0] > 0: for nn in exam_y: self.axes.plot(time_data[nn], sr_y_data[nn], color='red', marker='x', markersize=12) if exam_z[0].shape[0] > 0: for nn in exam_z: self.axes.plot(time_data[nn], sr_z_data[nn], color='red', marker='x', markersize=12) self.axes.set_xlabel('Time (s)', fontsize=10) self.axes.set_ylabel('Acc (g)', fontsize=10) self.axes.set_title('Speed bump 20kph', fontsize=12) def plot_filter_fig_sb(self, filter_data): time_data = filter_data.time_data sr_x_filter = filter_data.sr_x_data sr_y_filter = filter_data.sr_y_data sr_z_filter = filter_data.sr_z_data self.axes.plot(time_data, sr_x_filter, color='black') self.axes.plot(time_data, sr_y_filter, color='red') self.axes.plot(time_data, sr_z_filter, color='blue') self.axes.set_xlabel('Time (s)', fontsize=10) self.axes.set_ylabel('Acc (g)', fontsize=10) self.axes.set_title('Speed bump 20kph', fontsize=14) def plot_result_keyonff(self, key_on_off_fig, original_data): # 作图,把计算得到的特征点标注在图中 index_st = key_on_off_fig.index_st index_snd = key_on_off_fig.index_snd index_crank_st = key_on_off_fig.index_crank_st index_crank_snd = key_on_off_fig.index_crank_snd index_flare = key_on_off_fig.index_flare spd_flare = key_on_off_fig.spd_flare time_data = original_data.time_data spd_data = original_data.spd_data self.axes.set_title('Result of key on and off', fontsize=14) self.axes.set_xlabel('time', fontsize=12) self.axes.set_ylabel('eng_spd', fontsize=12) self.axes.plot(time_data, spd_data, color='blue', linewidth=2) offset_x = 1 offset_y = 2 for NN in range(len(index_st)): self.axes.plot(time_data[index_st[NN]], spd_data[index_st[NN]], color='red', marker='.', markersize=18, linewidth=2) self.axes.text(time_data[index_st[NN]] + offset_x, spd_data[index_st[NN]] + offset_y, 'start') self.axes.plot(time_data[index_snd[NN]], spd_data[index_snd[NN]], color='red', marker='^', markersize=10, linewidth=2) self.axes.text(time_data[index_snd[NN]] + offset_x, spd_data[index_snd[NN]] + offset_y, 'end') self.axes.plot(time_data[index_crank_st[NN]], spd_data[index_crank_st[NN]], color='b', marker='.', markersize=18, linewidth=2) self.axes.text(time_data[index_crank_st[NN]] + offset_x, spd_data[index_crank_st[NN]] + offset_y, 'crank_start') self.axes.plot(time_data[index_crank_snd[NN]], spd_data[index_crank_snd[NN]], color='b', marker='^', markersize=10, linewidth=2) self.axes.text(time_data[index_crank_snd[NN]] + offset_x, spd_data[index_crank_snd[NN]] + offset_y, 'crank_end') self.axes.plot(time_data[index_flare[NN]], spd_flare[NN], color='black', marker='.', markersize=18, linewidth=2) self.axes.text(time_data[index_flare[NN]] + offset_x, spd_data[index_flare[NN]] + offset_y, 'flare') def reset_i(self): self.i = 0 def plot_acc_response_subplot(self, history_data): pic_num = len(history_data) for m in range(pic_num): self.axes = self.fig.add_subplot(1, pic_num, m + 1, projection='3d') data = history_data[m].sysGain_class.accresponce.data ped_avg = history_data[m].sysGain_class.accresponce.pedal_avg for i in range(0, len(data[1])): self.axes.plot(data[1][i], data[0][i], data[2][i], label=int(round(ped_avg[i] / 5) * 5)) self.axes.legend(bbox_to_anchor=(1.02, 1), loc=1, borderaxespad=0) self.axes.set_xlabel('Velocity (kph)', fontsize=12) self.axes.set_ylabel('Pedal (%)', fontsize=12) self.axes.set_zlabel('Acc (g) ', fontsize=12) def plot_launch_subplot(self, history_data): pic_num = len(history_data) for m in range(pic_num): self.axes = self.fig.add_subplot(1, pic_num, m + 1) data = history_data[m].sysGain_class.launch.data for i in range(0, len(data[2])): self.axes.plot(data[2][i], data[1][i], label=int(round(np.mean(data[0][i]) / 5) * 5)) self.axes.legend() self.axes.grid(True, linestyle="--", color="k", linewidth="0.4") self.axes.set_xlabel('Time (s)', fontsize=12) self.axes.set_ylabel('Acc (g)', fontsize=12) self.axes.set_title('Launch', fontsize=12) def plot_shift_map_subplot(self, history_data): pic_num = len(history_data) for m in range(pic_num): self.axes = self.fig.add_subplot(1, pic_num, m + 1) data = history_data[m].sysGain_class.shiftmap.data str_label = [ '1->2', '2->3', '3->4', '4->5', '5->6', '6->7', '7->8', '8->9', '9->10' ] for i in range(1, int(max(data[0])) + 1): # 选择当前Gear, color=colour[i] self.axes.plot(data[2][np.where(data[0] == i)], data[1][np.where(data[0] == i)], marker='o', linestyle='-', linewidth=3, markerfacecolor='blue', markersize=4, label=str_label[i - 1]) self.axes.legend() self.axes.grid(True, linestyle="--", color="k", linewidth="0.4") self.axes.set_xlabel('Vehicle Speed (km/h)', fontsize=12) self.axes.set_ylabel('Pedal (%)', fontsize=12) self.axes.set_title('ShiftMap', fontsize=12) def plot_pedal_map_subplot(self, history_data): pic_num = len(history_data) for m in range(pic_num): self.axes = self.fig.add_subplot(1, pic_num, m + 1) data = history_data[m].sysGain_class.pedalmap.data pedalmap = self.axes.scatter(data[1], data[2], c=data[0], marker='o', linewidths=0.1, s=6, cmap=cm.get_cmap('RdYlBu_r')) self.axes.grid(True, linestyle="--", color="k", linewidth="0.4") self.axes.set_xlabel('Engine Speed (rpm)', fontsize=12) self.axes.set_ylabel('Torque (Nm)', fontsize=12) self.axes.set_title('PedalMap', fontsize=12)
class Qt5MplCanvas(FigureCanvas): """ A customized Qt widget for matplotlib figure. It can be used to replace GraphicsView of QtGui """ def __init__(self, parent, width=4.5, height=4): """ Initialization """ # from mpl_toolkits.axes_grid1 import host_subplot # import mpl_toolkits.axisartist as AA # import matplotlib.pyplot as plt # Instantiating matplotlib Figure self.fig = Figure(figsize=(width, height)) self.fig.patch.set_facecolor('white') # self.fig.patch.set_facecolor('gray') self.axes = self.fig.add_subplot(111) # return: matplotlib.axes.AxesSubplot self.fig.subplots_adjust(left=0.0) self.fig.subplots_adjust(right=1.0) self.fig.subplots_adjust(top=1.0) self.fig.subplots_adjust(bottom=0.0) self.axes.axis('off') # Initialize parent class and set parent FigureCanvas.__init__(self, self.fig) self.setParent(parent) # Set size policy to be able to expanding and resizable with frame FigureCanvas.setSizePolicy(self, QtWidgets.QSizePolicy.Expanding,QtWidgets.QSizePolicy.Expanding) FigureCanvas.updateGeometry(self) # Variables to manage all lines/subplot self._lineDict = {} self._lineIndex = 0 # legend and color bar self._colorBar = None self._isLegendOn = False self._legendFontSize = 8 def _update_canvas(self, img, ROIS=[]): """ Add an image by file """ # import scipy.ndimage as ndimage #import matplotlib.image as mpimg self.clear_canvas() # set aspect to auto mode self.axes.set_aspect('auto') im = img[:,:,0] # im = ndimage.gaussian_filter(im, sigma=(8, 8), order=0) # lum_img = img[:,:,0] # FUTURE : refactor for image size, interpolation and origin self.axes.imshow( np.fliplr( im[:,:].T ) ) for rois in ROIS: x1,y1, x2,y2 = rois self.axes.plot([x1,x2],[y1,y1], 'k') self.axes.plot([x1,x1],[y1,y2], 'k') self.axes.plot([x1,x2],[y2,y2], 'k') self.axes.plot([x2,x2],[y1,y2], 'k') self.axes.axis('off') self.draw() def addImage(self, img): """ Add an image by file """ #import matplotlib.image as mpimg self.clear_canvas() # set aspect to auto mode self.axes.set_aspect('auto') #img = matplotlib.image.imread( imagefilename ) self.axes.imshow( img ) # lum_img = img[:,:,0] # FUTURE : refactor for image size, interpolation and origin self.axes.axis('off') self.draw() def difference(self, SimPat, img): """ Add an image by file """ #import matplotlib.image as mpimg self.clear_canvas() # set aspect to auto mode self.axes.set_aspect('auto') # img = matplotlib.image.imread( imagefilename ) self.axes.imshow( np.fliplr( SimPat[:,:,0].T ) - img ) # lum_img = img[:,:,0] # FUTURE : refactor for image size, interpolation and origin self.axes.set_xticks([]) self.axes.set_yticks([]) self.draw() def clear_canvas(self): """ Clear data including lines and image from canvas """ # clear image self.axes.cla() # END-OF-CLASS (MplGraphicsView)
class GraphFrame(wx.Frame): """ The main frame of the application """ title = 'Demo: dynamic matplotlib graph' T = [] def __init__(self): wx.Frame.__init__(self, None, -1, self.title) self.showSPO2 = 0 self.showPulse = 0 self.paused = False self.plotData = [0] self.data_lock = threading.Lock() self.create_main_panel() self.flag = "" self.redraw_timer = wx.Timer(self) self.Bind(wx.EVT_TIMER, self.on_redraw_timer, self.redraw_timer) self.redraw_timer.Start(fs) self.Bind(wx.EVT_CLOSE, self.OnClose) self.on_timer = wx.Timer(self) self.Bind(wx.EVT_TIMER, functools.partial(self.Send, msg='mode:On'), self.on_timer) self.off_timer = wx.Timer(self) self.Bind(wx.EVT_TIMER, functools.partial(self.Send, msg='mode:Off'), self.off_timer) self.check_timer = wx.Timer(self) self.Bind(wx.EVT_TIMER, self.check_file, self.check_timer) self.disconnect_timer = wx.Timer(self) self.T = [] # self.T.append(self.on_timer) # self.T.append(self.off_timer) # self.T.append(self.disconnect_timer) def OnClose(self, event): global en_flag print "closing" en_flag = False self.Destroy() def create_main_panel(self): self.panel = wx.Panel(self) self.init_plot() self.canvas = FigCanvas(self.panel, -1, self.fig) self.comport_control = ComportPanel(self.panel,-1) self.comport_control.disconnect_button.Disable() self.hbox2 = wx.BoxSizer(wx.HORIZONTAL) self.hbox2.Add(self.comport_control, border=5, flag=wx.ALL) self.vbox = wx.BoxSizer(wx.HORIZONTAL) self.vbox.Add(self.hbox2, 0, flag=wx.ALIGN_CENTER | wx.TOP) self.vbox.Add(self.canvas, 1, flag=wx.LEFT | wx.TOP | wx.GROW) self.panel.SetSizer(self.vbox) self.vbox.Fit(self) def init_plot(self): self.dpi = 100 self.fig = Figure((3.0, 3.0), dpi=self.dpi) self.axes = self.fig.add_subplot(111) self.fig.subplots_adjust(left=0.03, right=0.995, bottom = 0.03, top = 0.95) self.axes.set_axis_bgcolor('black') self.axes.set_title('MiniPSG', size=12) self.axes.get_yaxis().set_visible(True) self.axes.yaxis.set_ticks([ ]) pylab.setp(self.axes.get_xticklabels(), fontsize=8) pylab.setp(self.axes.get_yticklabels(), fontsize=8) # plot the data as a line series, and save the reference # to the plotted line series # self.plot_data = [] self.plot_data.extend( self.axes.plot( np.arange(len(self.plotData)), self.plotData[:], 'r', linewidth=1, ) ) def draw_plot(self): """ Redraws the plot """ show_len = 30 * fs if self.data_lock.acquire(): ymin = 0 ymax = 300 xmax = len(self.plotData) if len(self.plotData) > show_len else show_len xmin = xmax - show_len xmax = xmax/float(fs) xmin = xmin/float(fs) self.axes.set_xbound(lower=xmin, upper=xmax) self.axes.set_ybound(lower=ymin, upper=ymax) self.axes.grid(True, color='gray') pylab.setp(self.axes.get_xticklabels(), visible=True) if len(self.plotData) < show_len: self.plot_data[0].set_xdata(np.arange(0,len(self.plotData),1.0)/float(fs)) self.plot_data[0].set_ydata(np.array(self.plotData)) else: self.plot_data[0].set_xdata(np.arange(len(self.plotData)-show_len,len(self.plotData),1.0)/float(fs)) self.plot_data[0].set_ydata(np.array(self.plotData[-show_len:])) self.data_lock.release() self.canvas.draw() def on_redraw_timer(self, event): # if paused do not add data, but still redraw the plot # (to respond to scale modifications, grid change, etc.) # self.draw_plot() def on_exit(self, event): self.Destroy() def connect(self, event): global en_flag en_flag = True self.plotData = [] if (self.check_timer.IsRunning()): self.check_timer.Stop() if self.comport_control.file_textctrl.GetValue()=="": filename = "./rawData/test.txt" else: filename = "./rawData/"+self.comport_control.file_textctrl.GetValue()+".txt" dataThread = SerialThread(self.plotData, self.data_lock, filename) self.comport_control.connect_button.Disable() self.comport_control.disconnect_button.Enable() dataThread.start() self.Bind(wx.EVT_TIMER, functools.partial(self.auto_disconnect, e=event), self.disconnect_timer) self.schedule() def schedule(self): self.on_timer.Start(5000) self.off_timer.Start(25000) self.disconnect_timer.Start(30000) def check_file(self, event): if(os.path.exists('result.txt')): f = open('result.txt', 'r') r = f.read().splitlines() result = 'result:' + r[0] self.SendTo(result) self.check_timer.Stop() f.close() os.remove('result.txt') def auto_disconnect(self, event, e): self.disconnect(e) def Send(self, event, msg): self.SendTo(msg) def disconnect(self, event): global en_flag en_flag = False print(self.disconnect_timer.IsRunning()) self.disconnect_timer.Stop() if(self.on_timer.IsRunning()): self.on_timer.Stop() if(self.off_timer.IsRunning()): self.off_timer.Stop() print("stop record",time.ctime()) self.check_timer.Start(500) self.comport_control.connect_button.Enable() self.comport_control.disconnect_button.Disable() filename = "./rawData/"+self.comport_control.file_textctrl.GetValue()+".txt" copyfile(filename, "./testing.txt") print "disconnect!" def SendTo(self, message): # Create a TCP/IP socket sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Connect the socket to the port where the server is listening #server_address = ('localhost', 10000) server_address = (sys.argv[1], 10000) print ('\n########################') print("send", time.ctime()) print >>sys.stderr, 'connecting to %s port %s' % server_address sock.connect(server_address) try: # Send data #message = 'This is the message. It will be repeated.' print ('------------------------') print >>sys.stderr, 'send: "%s"' % message sock.sendall(message) # # Look for the response # amount_received = 0 # amount_expected = len(message) # # while amount_received < amount_expected: # data = sock.recv(16) # amount_received += len(data) # print >>sys.stderr, 'received "%s"' % data finally: #print >>sys.stderr, 'closing socket' if(message == 'mode:On'): print(self.on_timer.IsRunning()) self.on_timer.Stop() elif(message == 'mode:Off'): print(self.off_timer.IsRunning()) self.off_timer.Stop() print ('########################') sock.close() def devSelect(self, event): global chan index = event.GetSelection() chan = devChoice[index] print chan
class appGui: def __init__(self): gladefile = "paViewerGUI.glade" self.windowname = "MainWindow" self.wTree = gtk.glade.XML(gladefile, self.windowname) dic = { "on_MainWindow_destroy": gtk.main_quit, "on_ButtonQuit_clicked": gtk.main_quit, "on_ButtonOpen_clicked": self.Open, "on_ButtonPlane_clicked": self.ChangePlane, "on_change_Current": self.ChangeCurrent, "on_ButtonSave_clicked": self.SaveFigure } self.wTree.signal_autoconnect(dic) self.window = self.wTree.get_widget(self.windowname) self.XmaxIndicator = self.wTree.get_widget("LabelXMax") self.YmaxIndicator = self.wTree.get_widget("LabelYMax") self.ZmaxIndicator = self.wTree.get_widget("LabelZMax") self.XScaler = self.wTree.get_widget("ScaleX") self.YScaler = self.wTree.get_widget("ScaleY") self.ZScaler = self.wTree.get_widget("ScaleZ") self.XText = self.wTree.get_widget("EntryX") self.YText = self.wTree.get_widget("EntryY") self.ZText = self.wTree.get_widget("EntryZ") self.PlaneSwitcher = self.wTree.get_widget("ButtonPlane") self.PlaneIndicator = self.wTree.get_widget("LabelPlane") self.window.show() self.OpenFileName = os.getcwd() self.plane = "xy" self.lock = 0 self.draw_lock = 0 self.pa = None self.TitleOfPlots = [] self.ax = [] self.figure = Figure(figsize=(6, 6), dpi=72) self.figure.subplots_adjust(left=0.05, right=1.0, bottom=0.07, top=0.95, wspace=0.2, hspace=0.1) self.canvas = FigureCanvasGTKAgg(self.figure) # a gtk.DrawingArea self.canvas.show() self.view = self.wTree.get_widget("ViewFrame") self.view.add(self.canvas) def DirectOpen(self, filename): self.OpenFileName = filename self.pa = PA.PA(file=self.OpenFileName) self.currentX = self.pa.nx() / 2 self.currentY = self.pa.ny() / 2 self.currentZ = self.pa.nz() / 2 self.XmaxIndicator.set_text(str(self.pa.nx())) self.YmaxIndicator.set_text(str(self.pa.ny())) self.ZmaxIndicator.set_text(str(self.pa.nz())) self.XScaler.set_range(0.0, self.pa.nx()) self.XScaler.set_value(self.currentX) self.YScaler.set_range(0.0, self.pa.ny()) self.YScaler.set_value(self.currentY) self.ZScaler.set_range(0.0, self.pa.nz()) self.ZScaler.set_value(self.currentZ) self.XText.set_text(str(self.currentX)) self.YText.set_text(str(self.currentY)) self.ZText.set_text(str(self.currentZ)) self.DrawPicture(self.window) def Open(self, widget): # A SIMPLE FILE CHOOSE DIALOG dialog = gtk.FileChooserDialog("Please select your PA File...", self.window, gtk.FILE_CHOOSER_ACTION_OPEN, None, None) dialog.add_button("Cancel", gtk.RESPONSE_CANCEL) dialog.add_button("Select", gtk.RESPONSE_OK) if self.OpenFileName != os.getcwd(): dialog.set_current_folder(os.path.split(self.OpenFileName)[0]) else: dialog.set_current_folder(os.getcwd()) result = dialog.run() if result == gtk.RESPONSE_OK: self.OpenFileName = dialog.get_filename() dialog.destroy() else: dialog.destroy() return 0 # SO EVERYTHING GOOD, LETS OPEN THE FILE self.pa = PA.PA(file=self.OpenFileName) self.currentX = self.pa.nx() / 2 self.currentY = self.pa.ny() / 2 self.currentZ = self.pa.nz() / 2 self.XmaxIndicator.set_text(str(self.pa.nx())) self.YmaxIndicator.set_text(str(self.pa.ny())) self.ZmaxIndicator.set_text(str(self.pa.nz())) self.XScaler.set_range(0.0, self.pa.nx()) self.XScaler.set_value(self.currentX) self.YScaler.set_range(0.0, self.pa.ny()) self.YScaler.set_value(self.currentY) self.ZScaler.set_range(0.0, self.pa.nz()) self.ZScaler.set_value(self.currentZ) self.XText.set_text(str(self.currentX)) self.YText.set_text(str(self.currentY)) self.ZText.set_text(str(self.currentZ)) self.DrawPicture(self.window) def DrawPicture_thread(self, widget): drawFigureThreat().start() def DrawPicture(self, widget): # Nothing open if self.pa == None: return 0 self.wTree.get_widget("View").set_text(self.OpenFileName) # CHECK WHO WANTS TO BE PLOTTED? self.TitleOfPlots = [] if self.wTree.get_widget("CheckRaw").get_active() == True: self.TitleOfPlots.append("Raw") if self.wTree.get_widget("CheckGeo").get_active() == True: self.TitleOfPlots.append("Geometry") if self.wTree.get_widget("CheckPot").get_active() == True: self.TitleOfPlots.append("Potential") # CLEAR FIGURE IS IMPORTANT! self.figure.clear() self.ax = [] i = 0 while i < len(self.TitleOfPlots): num = 100 + 10 * len(self.TitleOfPlots) + 1 + i self.ax.append(self.figure.add_subplot(num)) if self.plane == "xy": self.ax[i].set_xlabel('Y') self.ax[i].set_ylabel('X') elif self.plane == "xz": self.ax[i].set_xlabel('Z') self.ax[i].set_ylabel('X') elif self.plane == "yz": self.ax[i].set_xlabel('Z') self.ax[i].set_ylabel('Y') self.ax[i].set_title(self.TitleOfPlots[i]) i = i + 1 data_raw = [] data_geo = [] data_pot = [] if self.plane == "xy": i = 0 while i < self.pa.nx(): j = 0 data_raw.append([]) data_geo.append([]) data_pot.append([]) while j < self.pa.ny(): data_pot[i].append(self.pa.potential(i, j, self.currentZ)) data_geo[i].append(self.pa.electrode(i, j, self.currentZ)) data_raw[i].append(self.pa.raw(i, j, self.currentZ)) j = j + 1 i = i + 1 elif self.plane == "xz": i = 0 while i < self.pa.nx(): j = 0 data_raw.append([]) data_geo.append([]) data_pot.append([]) while j < self.pa.nz(): data_pot[i].append(self.pa.potential(i, self.currentY, j)) data_geo[i].append(self.pa.electrode(i, self.currentY, j)) data_raw[i].append(self.pa.raw(i, self.currentY, j)) j = j + 1 i = i + 1 elif self.plane == "yz": i = 0 while i < self.pa.ny(): j = 0 data_raw.append([]) data_geo.append([]) data_pot.append([]) while j < self.pa.nz(): data_pot[i].append(self.pa.potential(self.currentX, i, j)) data_geo[i].append(self.pa.electrode(self.currentX, i, j)) data_raw[i].append(self.pa.raw(self.currentX, i, j)) j = j + 1 i = i + 1 i = 0 while i < len(self.TitleOfPlots): if self.TitleOfPlots[i] == "Raw": self.ax[i].imshow(data_raw) self.figure.colorbar(self.ax[i].imshow(data_raw), ax=self.ax[i], shrink=(1.1 - len(self.TitleOfPlots) / 10.0), pad=0.01) elif self.TitleOfPlots[i] == "Geometry": self.ax[i].imshow(data_geo) self.figure.colorbar(self.ax[i].imshow(data_geo), ax=self.ax[i], shrink=(1.1 - len(self.TitleOfPlots) / 10.0), pad=0.01) elif self.TitleOfPlots[i] == "Potential": self.ax[i].imshow(data_pot) self.figure.colorbar(self.ax[i].imshow(data_pot), ax=self.ax[i], shrink=(1.1 - len(self.TitleOfPlots) / 10.0), pad=0.01) i = i + 1 self.canvas.draw() def ChangePlane(self, widget): if self.plane == "xy": self.plane = "xz" self.PlaneIndicator.set_text("XZ") elif self.plane == "xz": self.plane = "yz" self.PlaneIndicator.set_text("YZ") elif self.plane == "yz": self.plane = "xy" self.PlaneIndicator.set_text("XY") self.DrawPicture(self.window) def ChangeCurrent(self, widget): if self.lock == 1: return 0 self.lock = 1 if widget.get_name() == "ScaleX": self.currentX = int(self.XScaler.get_value()) elif widget.get_name() == "ScaleY": self.currentY = int(self.YScaler.get_value()) elif widget.get_name() == "ScaleZ": self.currentZ = int(self.ZScaler.get_value()) # elif widget.get_name() == "CheckRaw" or widget.get_name() == "CheckGeo" or widget.get_name() == "CheckPot": else: self.currentX = int(float(self.XText.get_text())) self.currentY = int(float(self.YText.get_text())) self.currentZ = int(float(self.ZText.get_text())) self.XText.set_text(str(self.currentX)) self.YText.set_text(str(self.currentY)) self.ZText.set_text(str(self.currentZ)) self.XScaler.set_value(self.currentX) self.YScaler.set_value(self.currentY) self.ZScaler.set_value(self.currentZ) self.DrawPicture(self.window) self.lock = 0 def SaveFigure(self, widget): # A SIMPLE FILE CHOOSE DIALOG dialog = gtk.FileChooserDialog("Please select your PA File...", self.window, gtk.FILE_CHOOSER_ACTION_SAVE, None, None) dialog.add_button("Cancel", gtk.RESPONSE_CANCEL) dialog.add_button("Select", gtk.RESPONSE_OK) result = dialog.run() if result == gtk.RESPONSE_OK: FileName = dialog.get_filename() dialog.destroy() else: dialog.destroy() return 0 self.figure.savefig((FileName + ".pdf"))
class DoubleMyMplCanvas(FigureCanvas): def __init__(self, parent=None, width = 6, height = 5, dpi = 100, sharex = None, sharey = None): self.fig = Figure(figsize = (width, height), dpi=dpi, facecolor = '#FFFFFF') self.ax = self.fig.add_subplot(211, sharex = sharex, sharey = sharey) self.ax2 = self.fig.add_subplot(212, sharex = sharex, sharey = sharey) self.axList = [self.ax, self.ax2] self.fig.subplots_adjust(left=0.1, bottom=0.1, right=0.9, top=0.9) self.plotTitle = '' self.xtitle="X"#"Drift Time (ms)" self.ytitle="Y"#"Intensity" self.ax.set_xlabel(self.xtitle, fontsize = 9) self.ax.set_ylabel(self.ytitle, fontsize = 9) self.grid_status = True self.xaxis_style = 'linear' self.yaxis_style = 'linear' self.format_labels() self.ax.hold(True) FigureCanvas.__init__(self, self.fig) FigureCanvas.setSizePolicy(self, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) FigureCanvas.updateGeometry(self) def format_labels(self, xItalic = False): for ax in self.axList: ax.set_title(self.plotTitle) ax.title.set_fontsize(10) xLabel = self.xtitle#self.ax.get_xlabel() yLabel = self.ytitle#self.ax.get_ylabel() if xItalic: ax.set_xlabel(xLabel, fontsize = 9, fontstyle = 'italic') else: ax.set_xlabel(xLabel, fontsize = 9) ax.set_ylabel(yLabel, fontsize = 9) labels_x = ax.get_xticklabels() labels_y = ax.get_yticklabels() for xlabel in labels_x: xlabel.set_fontsize(8) for ylabel in labels_y: ylabel.set_fontsize(8) ylabel.set_color('b') if ax.get_legend() != None: self.ax.legend(borderaxespad = 0.03, axespad=0.25) texts = ax.get_legend().get_texts() for text in texts: text.set_fontsize(8) def sizeHint(self): w, h = self.get_width_height() return QtCore.QSize(w, h) def minimumSizeHint(self): return QtCore.QSize(10, 10) def sizeHint(self): w, h = self.get_width_height() return QtCore.QSize(w, h) def minimumSizeHint(self): return QtCore.QSize(10, 10)
class Mplot(FCanvas): def __init__(self, parent, B=[]): self.parent = parent self.deph = parent.deph.value() self.w = parent.Width.value() - 200 self.h = parent.Height.value() self.a = float(parent.a.text()) self.c = float(parent.c.text()) self.b = round( float((self.c - self.a) / 2 * self.h / self.w) + float(parent.d.text()), 6) self.d = round( -float((self.c - self.a) / 2 * self.h / self.w) + float(parent.d.text()), 6) self.D = [self.a, self.b] self.B = B self.colorMap = parent.CMap.currentText() self.const = complex(float(self.parent.const_re.text()), float(self.parent.const_im.text())) ### self.fig = Figure(figsize=(self.w, self.h), dpi=1) FCanvas.__init__(self, self.fig) self.setParent(parent) FCanvas.setSizePolicy(self, QSizePolicy.Expanding, QSizePolicy.Expanding) FCanvas.updateGeometry(self) self.plot() def plot(self): if len(self.B) == 0: global c c = self.const exec( '''global F, G F = lambda z,w:''' + self.parent.func.text() + ''' G = lambda z,w:''' + self.parent.func2.text(), globals(), locals()) A1 = np.linspace(self.a, self.c, self.w) A2 = np.linspace(self.d, self.b, self.h) A = np.array([[complex(i, e) for i in A1] for e in A2]) self.B = np.array([[0 for i in range(self.w)] for e in range(self.h)]) for i in range(len(A)): for e in range(len(A[i])): N = A[i][e] M = A[i][e] #self.const for j in range(self.deph): N, M = F(N, M), G(N, M) if abs(N) > 5: break self.B[i][e] = j #abs(N) self.fig.subplots_adjust(left=0, right=1.0, top=1.0, bottom=0) ax = self.fig.add_subplot(111) ax.axis('scaled') ax.axis([0, self.w, 0, self.h]) ax.xaxis.set_major_formatter(plt.NullFormatter()) ax.yaxis.set_major_formatter(plt.NullFormatter()) ax.imshow(self.B, cmap=self.colorMap) self.show() def mousePressEvent(self, event): if self.parent.i: self.a = round( (self.c - self.a) * event.pos().x() / self.w + self.a, 6) self.b = round( (self.d - self.b) * event.pos().y() / self.h + self.b, 6) def mouseReleaseEvent(self, event): if self.parent.i: self.c = round( (self.c - self.D[0]) * event.pos().x() / self.w + self.D[0], 6) self.d = round( (self.d - self.D[1]) * event.pos().y() / self.h + self.D[1], 6) self.parent.find(self.a, self.b, self.c, self.d) self.parent.i = False
class simpleapp_tk(tkinter.Tk): def __init__(self, parent): tkinter.Tk.__init__(self, parent) self.parent = parent if USE_EMULATION: self.inst = keithley_2450_fake() else: self.inst = keithley_2450() self.data = data() col = self.winfo_rgb(self.cget('bg')) self.bgcolor = (float(col[0]) / 65536, float(col[1]) / 65536, float(col[2]) / 65536) self.waitingOnImport = 0 self.selectWindow = None self.ConnectToDB() self.initialize() def initialize(self): self.grid() #cretae menu bar self.menubar = tkinter.Menu(self) filemenu = tkinter.Menu(self.menubar, tearoff=0) filemenu.add_command(label="Open", command=self.OnMenuOpen) filemenu.add_command(label="Save", command=self.OnMenuSave) filemenu.add_separator() filemenu.add_command(label="Print", command=self.OnMenuPrint) filemenu.add_separator() filemenu.add_command(label="Quit", command=self.OnMenuQuit) self.menubar.add_cascade(label="File", menu=filemenu) self.config(menu=self.menubar) # create the entry boxes FrameEntry = tkinter.Frame(self) FrameScan = tkinter.Frame(FrameEntry) FrameDevice = tkinter.Frame(FrameEntry) self.CreateScanLabel(FrameScan) self.CreateDeviceLabel(FrameDevice) self.entryVariableV0.set(self.inst.parV0) self.entryVariableV1.set(self.inst.parV1) self.entryVariableST.set(self.inst.parST) self.entryVariableDT.set(self.inst.parDT) self.entryVariableUS.set(self.data.userName) self.entryVariableSI.set(self.data.sipmID) self.entryVariableTE.set(self.data.temperature) self.UpdateDate() FrameDevice.grid(column=0, row=0, padx=10, pady=20, sticky='EW') FrameScan.grid(column=0, row=1, padx=10, pady=20, sticky='EW') #create the plotter FramePlot = tkinter.Frame(self) self.CreatePlotter(FramePlot) # create the buttons FrameButton = tkinter.Frame(self) self.CreateButtons(FrameButton) # create the logger FrameLogger = tkinter.Frame(self) self.CreateLogger(FrameLogger) #create frame import FrameImport = tkinter.Frame(self) self.CreateImportList(FrameImport) #place frames, try to make it look nice fillLabel = tkinter.Label(self, text=" ", height=2) fillLabel2 = tkinter.Label(self, text=" ", width=20) FrameEntry.grid(column=0, row=0, padx=10, pady=10, sticky='EW') FramePlot.grid(column=1, row=0, sticky='EW', padx=10, pady=10, rowspan=2) fillLabel.grid(column=0, row=1) FrameButton.grid(column=0, row=2, sticky='EW', padx=10, pady=10, columnspan=2) FrameLogger.grid(column=0, row=3, sticky='EW', padx=10, pady=5, columnspan=2) fillLabel2.grid(column=3, row=0) FrameImport.grid(column=4, row=0, sticky='EW', padx=10, pady=5, rowspan=4) self.grid_columnconfigure(0, weight=1) self.resizable(False, False) self.update() self.geometry(self.geometry()) #--------------------------------------------------------------------------------- def OnMenuOpen(self): filename = None if USING_PYTHON_3: filename = tkinter.filedialog.askopenfilename( initialdir=os.getcwd(), title="Select file", filetypes=(("text files", "*.txt"), ("all files", "*.*"))) else: filename = tkFileDialog.askopenfilename( initialdir=os.getcwd(), title="Select file", filetypes=(("text files", "*.txt"), ("all files", "*.*"))) if (self.data.read(filename, self.inst) == 0): self.EmitLogText("Error: Could not read " + filename) return self.entryVariableV0.set(self.inst.parV0) self.entryVariableV1.set(self.inst.parV1) self.entryVariableST.set(self.inst.parST) self.entryVariableDT.set(self.inst.parDT) self.entryVariableSI.set(self.data.sipmID) self.entryVariableUS.set(self.data.userName) self.entryVariableTE.set(self.data.temperature) self.entryVariableDA.set(self.data.date) self.data.hasData = 1 self.RefreshPlot() self.EmitLogText("Loaded content of " + filename) def OnMenuSave(self): self.RefreshParams() self.RefreshPlot() if (self.ValidateSaveData() == 0): return filename = None if USING_PYTHON_3: filename = tkinter.filedialog.asksaveasfilename( initialdir=os.getcwd(), title="Select file", filetypes=(("text files", "*.txt"), ("all files", "*.*"))) else: filename = tkFileDialog.asksaveasfilename( initialdir=os.getcwd(), title="Select file", filetypes=(("text files", "*.txt"), ("all files", "*.*"))) result = self.data.write(filename, self.inst) if (result == 0): self.EmitLogText("Error: Problem saving file " + filename + ". Try again") self.EmitLogText("Saved into file " + filename) def OnMenuPrint(self): filename = None if USING_PYTHON_3: filename = tkinter.filedialog.asksaveasfilename( initialdir=os.getcwd(), title="Select file", filetypes=(("pdf files", "*.pdf"), ("all files", "*.*"))) else: filename = tkFileDialog.asksaveasfilename( initialdir=os.getcwd(), title="Select file", filetypes=(("pdf files", "*.pdf"), ("all files", "*.*"))) self.figure.savefig(filename) self.EmitLogText("Printed plot into file " + filename) def OnMenuQuit(self): global app self.inst.disconnect() app.destroy() #--------------------------------------------------------------------------------- def CreateDeviceLabel(self, frame): label0 = tkinter.Label(frame, text="Device", font="bold", height=2) self.entryVariableTE = tkinter.StringVar() self.entryVariableUS = tkinter.StringVar() self.entryVariableSI = tkinter.StringVar() self.entryVariableDA = tkinter.StringVar() self.labelUS = tkinter.Label(frame, text="User name") self.labelSI = tkinter.Label(frame, text="Device ID") self.labelTE = tkinter.Label(frame, text="Temperature [C]") self.labelDA = tkinter.Label(frame, text="Date") self.entryUS = tkinter.Entry(frame, width=10, textvariable=self.entryVariableUS) self.entrySI = tkinter.Entry(frame, width=10, textvariable=self.entryVariableSI) self.entryTE = tkinter.Entry(frame, width=10, textvariable=self.entryVariableTE) self.entryDA = tkinter.Label(frame, textvariable=self.entryVariableDA) label0.grid( column=0, row=0, sticky='W', columnspan=2, ) self.FinalizeEntryLabel(self.labelUS, self.entryUS, 1, self.OnValidateUS) self.FinalizeEntryLabel(self.labelSI, self.entrySI, 2, self.OnValidateSI) self.FinalizeEntryLabel(self.labelTE, self.entryTE, 3, self.OnValidateTE) self.labelDA.grid(column=0, row=4, sticky='E', padx=5) self.entryDA.grid(column=1, row=4, sticky='EW', padx=5) def CreateScanLabel(self, frame): label0 = tkinter.Label(frame, text="Scan parameters", font="bold", height=2) self.entryVariableV0 = tkinter.StringVar() self.entryVariableV1 = tkinter.StringVar() self.entryVariableST = tkinter.StringVar() self.entryVariableDT = tkinter.StringVar() self.entryVariableTE = tkinter.StringVar() self.labelV0 = tkinter.Label(frame, text="V0 [V]") self.labelV1 = tkinter.Label(frame, text="V1 [V]") self.labelST = tkinter.Label(frame, text="# Step") self.labelDT = tkinter.Label(frame, text="dT [s]") self.entryV0 = tkinter.Entry(frame, width=10, textvariable=self.entryVariableV0) self.entryV1 = tkinter.Entry(frame, width=10, textvariable=self.entryVariableV1) self.entryST = tkinter.Entry(frame, width=10, textvariable=self.entryVariableST) self.entryDT = tkinter.Entry(frame, width=10, textvariable=self.entryVariableDT) label0.grid(column=0, row=0, sticky='W', columnspan=2) self.FinalizeEntryLabel(self.labelV0, self.entryV0, 1, self.OnValidateV0) self.FinalizeEntryLabel(self.labelV1, self.entryV1, 2, self.OnValidateV1) self.FinalizeEntryLabel(self.labelST, self.entryST, 3, self.OnValidateST) self.FinalizeEntryLabel(self.labelDT, self.entryDT, 4, self.OnValidateDT) def FinalizeEntryLabel(self, label, entry, irow, cmd): label.grid(column=0, row=irow, sticky='E', padx=5) entry.grid(column=1, row=irow, sticky='EW', padx=5) entry.bind("<Return>", cmd) def OnValidateV0(self, event): #self.inst.parV0 = self.ValidateParInt(self.entryVariableV0, self.inst.parV0, 0, min(self.inst.Vmax,self.inst.parV1), "V0") self.inst.parV0 = self.ValidateParFloat( self.entryVariableV0, self.inst.parV0, 0, min(self.inst.Vmax, self.inst.parV1), "V0") def OnValidateV1(self, event): #self.inst.parV1 = self.ValidateParInt(self.entryVariableV1, self.inst.parV1, max(0,self.inst.parV0), self.inst.Vmax, "V1") self.inst.parV1 = self.ValidateParFloat(self.entryVariableV1, self.inst.parV1, max(0, self.inst.parV0), self.inst.Vmax, "V1") def OnValidateST(self, event): self.inst.parST = self.ValidateParInt(self.entryVariableST, self.inst.parST, 1, self.inst.STmax, "STEP") def OnValidateDT(self, event): self.inst.parDT = self.ValidateParFloat(self.entryVariableDT, self.inst.parDT, self.inst.DTmin, self.inst.DTmax, "DT") def OnValidateUS(self, event): self.data.userName = self.entryVariableUS.get() self.EmitLogText("set user name to " + self.data.userName) def OnValidateSI(self, event): self.data.sipmID = self.entryVariableSI.get() self.EmitLogText("set device ID to " + self.data.sipmID) def OnValidateTE(self, event): self.data.temperature = self.ValidateParFloat(self.entryVariableTE, self.data.temperature, -100.0, 100.0, "Temperature") #--------------------------------------------------------------------------------- def CreatePlotter(self, frame): self.figure = Figure(figsize=(5, 5), dpi=100, facecolor=self.bgcolor) self.figure.subplots_adjust(left=0.2) self.figure.subplots_adjust(bottom=0.2) self.plotter = self.figure.add_subplot(111) self.plotter.plot(self.data.I, self.data.V) self.plotter.set_xlabel("V [V]") self.plotter.set_ylabel("I [A]") self.figure.suptitle("I-V curve for " + self.data.sipmID, fontsize=14, fontweight='bold') self.canvasFig = FigureCanvasTkAgg(self.figure, master=frame) self.canvasFig.show() self.canvasFig.get_tk_widget().grid(column=0, row=2) #--------------------------------------------------------------------------------- def CreateButtons(self, frame): self.buttonConnect = tkinter.Button(frame, text=u"Connect", font='bold', command=self.OnButtonConnect) self.buttonDisconnect = tkinter.Button(frame, state="disabled", text=u"Disconnect", font='bold', command=self.OnButtonDisconnect) self.buttonMeasure = tkinter.Button(frame, state="disabled", text=u"Measure", font='bold', command=self.OnButtonMeasure) self.buttonConnect.grid(column=0, row=0, padx=10) self.buttonDisconnect.grid(column=1, row=0, padx=10) self.buttonMeasure.grid(column=2, row=0, padx=10) def OnButtonConnect(self): if (self.inst.connect() == 1): self.label.configure(bg="green") self.labelVariable.set("Connected to " + self.inst.name) self.buttonConnect.configure(state="disabled") self.buttonDisconnect.configure(state="active") self.buttonMeasure.configure(state="active") self.EmitLogText(self.inst.logMessage) def OnButtonDisconnect(self): self.inst.disconnect() self.label.configure(bg="red") self.labelVariable.set("Disconnected") self.buttonConnect.configure(state="active") self.buttonDisconnect.configure(state="disabled") self.buttonMeasure.configure(state="disabled") self.buttonImport.configure(state="disabled") def OnButtonMeasure(self): if (self.inst.checkConnection() == 1): self.RefreshParams() self.inst.measureIV(self.data) self.data.hasData = 1 self.buttonExport.configure(state="active") self.RefreshPlot() self.UpdateDate() else: self.OnButtonDisconnect() self.EmitLogText(self.inst.logMessage) #--------------------------------------------------------------------------------- def CreateImportList(self, frame): label0 = tkinter.Label(frame, text="Measurements", font="bold", height=2) label0.grid(column=0, row=0, sticky='W') self.scroller2 = tkinter.Scrollbar(frame) self.scroller2.grid(column=2, row=1, sticky='ns') self.listImport = tkinter.Listbox(frame, height=25, width=50, yscrollcommand=self.scroller2.set) self.scroller.config(command=self.listImport.yview) self.listImport.grid(column=0, row=1, sticky='EW') FrameButton = tkinter.Frame(frame) self.entryVariableFilterSI = tkinter.StringVar() self.entryVariableFilterUS = tkinter.StringVar() self.labelFSI = tkinter.Label(FrameButton, text="Sipm ID filter: ") self.labelFUS = tkinter.Label(FrameButton, text="User filter: ") self.entryFSI = tkinter.Entry(FrameButton, width=10, textvariable=self.entryVariableFilterSI) self.entryFUS = tkinter.Entry(FrameButton, width=10, textvariable=self.entryVariableFilterUS) self.buttonExport = tkinter.Button(FrameButton, state="disabled", text=u"Export", font='bold', command=self.OnButtonExport) self.buttonImport = tkinter.Button(FrameButton, state="disabled", text=u"Import", font='bold', command=self.OnButtonImport) self.buttonFilter = tkinter.Button(FrameButton, state="disabled", text=u"Filter", font='bold', command=self.OnButtonFilter) self.labelFSI.grid(column=0, row=1, padx=10, pady=20, sticky='EW') self.entryFSI.grid(column=1, row=1, padx=10, pady=20, sticky='EW') self.labelFUS.grid(column=0, row=2, padx=10, sticky='EW') self.entryFUS.grid(column=1, row=2, padx=10, sticky='EW') self.buttonImport.grid(column=0, row=0, padx=10, sticky='EW') self.buttonExport.grid(column=1, row=0, padx=10, sticky='EW') self.buttonFilter.grid(column=2, row=0, padx=10, sticky='EW') FrameButton.grid(column=0, row=2, pady=20, sticky='EW') self.listImport.bind("<Return>", self.HandleListboxReturnKey) self.GenerateImportList() def OnButtonExport(self): self.RefreshParams() self.RefreshPlot() valid = self.ValidateSaveData() if valid == 0: self.EmitLogText("ERROR: Cannot export data (Missing data)") return if self.connectedToDB == 0: self.EmitLogText( "ERROR: Cannot export data (Not connected to database)") return self.EmitLogText('Exporting data to DB') self.WriteEntry() def OnButtonImport(self): if self.waitingOnImport != 0: self.EmitLogText("ERROR: Already waiting for import selection") return 0 if self.connectedToDB != 1: self.EmitLogText( "ERROR: Cannot import data (Not connected to database)") return 0 if (self.listImport.curselection()): self.ImportSingleEntry( self.listImport.get(self.listImport.curselection())) def OnButtonFilter(self): importSipmID = self.entryVariableFilterSI.get() importUser = self.entryVariableFilterUS.get() self.GenerateImportList(importSipmID, importUser) def HandleListboxReturnKey(self, event): if (self.buttonImport.cget("state") == "active"): self.buttonImport.invoke() def GenerateImportList(self, importSipmID="", importUser=""): self.listImport.delete(0, tkinter.END) try: session = self.Session() if (importSipmID == "" and importUser == ""): importList = session.query(Entry).all() if (importSipmID != "" and importUser != ""): importList = session.query(Entry).filter_by( sipmid=importSipmID, username=importUser) if (importSipmID == "" and importUser != ""): importList = session.query(Entry).filter_by( username=importUser) if (importSipmID != "" and importUser == ""): importList = session.query(Entry).filter_by( sipmid=importSipmID) entryNum = 1 for curEntry in importList: self.listImport.insert( entryNum, curEntry.date + " | " + curEntry.sipmid + " | " + curEntry.username) entryNum += 1 self.buttonImport.configure(state="disabled") if (entryNum > 1): self.listImport.select_set(0) self.buttonImport.configure(state="active") self.buttonFilter.configure(state="active") except: session.rollback() self.EmitLogText("ERROR: Communication problem with SQL database") raise finally: session.close() def ImportSingleEntry(self, selectionString): importDate = selectionString.split("|")[0].strip() importSipmID = selectionString.split("|")[1].strip() if self.connectedToDB != 1: self.EmitLogText( "ERROR: Cannot import data (Not connected to database)") return 0 try: session = self.Session() our_entry = session.query(Entry).filter_by( sipmid=importSipmID, date=importDate).first() if our_entry == None: self.EmitLogText("ERROR: Cannot import data (Entry not found)") return 0 self.data.userName = our_entry.username self.data.sipmID = our_entry.sipmid self.data.temperature = our_entry.temperature self.data.date = our_entry.date self.inst.parV0 = our_entry.v0 self.inst.parV1 = our_entry.v1 self.inst.parST = our_entry.steps self.inst.parDT = our_entry.deltat self.data.V = our_entry.varray self.data.I = our_entry.iarray self.entryVariableV0.set(self.inst.parV0) self.entryVariableV1.set(self.inst.parV1) self.entryVariableST.set(self.inst.parST) self.entryVariableDT.set(self.inst.parDT) self.entryVariableSI.set(self.data.sipmID) self.entryVariableUS.set(self.data.userName) self.entryVariableTE.set(self.data.temperature) self.entryVariableDA.set(self.data.date) self.data.hasData = 1 self.RefreshPlot() self.EmitLogText('Successfully imported device \"' + self.data.sipmID + '\" from DB') except: session.rollback() self.EmitLogText("ERROR: Communication problem with SQL database") raise finally: session.close() return def WriteEntry(self): try: session = self.Session() query_entry = session.query(Entry).filter_by( sipmid=self.data.sipmID, date=self.data.date).first() if query_entry != None: self.EmitLogText("Replacing existing entry...") session.delete(query_entry) session.commit() new_entry = Entry(username=str(self.data.userName), sipmid=str(self.data.sipmID), temperature=float(self.data.temperature), date=str(self.data.date), v0=float(self.inst.parV0), v1=float(self.inst.parV1), steps=int(self.inst.parST), deltat=float(self.inst.parDT), varray=self.data.V, iarray=self.data.I) session.add(new_entry) session.commit() our_entry = session.query(Entry).filter_by( sipmid=self.data.sipmID).first() if our_entry == None: self.EmitLogText("ERROR: Could not export to DB") return 0 self.EmitLogText("New Entry: " + our_entry.__repr__()) entries = session.query(Entry).all() self.EmitLogText("Number of entries in DB: " + str(len(entries))) self.GenerateImportList() except: session.rollback() self.EmitLogText("ERROR: Could not export to DB") raise finally: session.close() return 1 #--------------------------------------------------------------------------------- def CreateLogger(self, frame): self.labelVariable = tkinter.StringVar() self.labelColor = tkinter.StringVar() self.labelColor.set("red") self.labelVariable.set(u"Not connected") self.label = tkinter.Label(frame, textvariable=self.labelVariable, anchor="w", fg="white", bg=self.labelColor.get()) self.label.grid(column=0, row=0, sticky='EW', pady=5) self.scroller = tkinter.Scrollbar(frame) self.scroller.grid(column=2, row=1, sticky='ns') self.logtext = tkinter.Text(frame, height=5, yscrollcommand=self.scroller.set) self.scroller.config(command=self.logtext.yview) self.logtext.insert(tkinter.INSERT, "Good day\n") self.logtext.configure(state="disabled") self.logtext.grid(column=0, row=1, sticky='EW') #--------------------------------------------------------------------------------- def ConnectToDB(self): self.engine = None self.Session = None self.connectedToDB = 0 try: if CONNECT_TO_REAL_DB: pw = DB_PASSWORD self.engine = create_engine( 'mysql+mysqldb://root:' + pw + '@localhost/' + DB_NAME + '?unix_socket=//opt/local/var/run/mysql56/mysqld.sock', echo=ECHO_SQL_COMMANDS) else: self.engine = create_engine('sqlite:///:memory:', echo=ECHO_SQL_COMMANDS) Base.metadata.create_all(self.engine) self.Session = sessionmaker(bind=self.engine) self.connectedToDB = 1 print("Connected to DB") return 1 except: return 0 def UpdateDate(self): now = datetime.datetime.now() self.data.date = "%s-%s-%s %s:%s:%s" % ( now.year, now.month, now.day, now.hour, now.minute, now.second) self.entryVariableDA.set(self.data.date) def RefreshParams(self): self.inst.parV0 = float(self.entryVariableV0.get()) self.inst.parV1 = float(self.entryVariableV1.get()) self.inst.parST = int(self.entryVariableST.get()) self.inst.parDT = float(self.entryVariableDT.get()) self.data.sipmID = self.entryVariableSI.get() self.data.userName = self.entryVariableUS.get() self.data.temperature = float(self.entryVariableTE.get()) def RefreshPlot(self): self.plotter.clear() self.finterp = interp1d(self.data.V, self.data.I, kind='cubic') xnew = np.linspace(self.data.V[0], self.data.V[-1], num=max(self.inst.parST, 100), endpoint=True) self.plotter.plot(self.data.V, self.data.I, 'o', xnew, self.finterp(xnew), '-') #self.plotter.plot(self.data.V,self.data.I) self.plotter.set_xlabel("V [V]") self.plotter.set_ylabel("I [A]") self.figure.suptitle("I-V curve for " + self.data.sipmID, fontsize=14, fontweight='bold') self.canvasFig.draw() def EmitLogText(self, text): self.logtext.config(state='normal') self.logtext.insert(tkinter.END, text + "\n") self.logtext.see(tkinter.END) self.logtext.config(state='disabled') def ValidateParInt(self, entryVar, oldPar, bound0, bound1, parName): try: par = int(entryVar.get()) if (par < bound0 or par > bound1): raise ValueError self.EmitLogText("set " + parName + " to " + str(par)) return par except ValueError: self.EmitLogText("Error: " + parName + " must be in the range " + str(bound0) + "....." + str(bound1)) entryVar.set(oldPar) return oldPar def ValidateParFloat(self, entryVar, oldPar, bound0, bound1, parName): try: par = float(entryVar.get()) if (par < bound0 or par > bound1): raise ValueError self.EmitLogText("set " + parName + " to " + str(par)) return par except ValueError: self.EmitLogText("Error: " + parName + " must be in the range " + str(bound0) + ".." + str(bound1)) entryVar.set(oldPar) return oldPar def ValidateSaveData(self): if (self.data.userName == ""): self.EmitLogText( "Error: Username missing, so we know who to blame later...") return 0 if (self.data.sipmID == ""): self.EmitLogText("Error: device ID missing") return 0 if (self.data.hasData == 0): self.EmitLogText("Error: No measurement available") return 0 return 1
class Advanced2dCanvas(FigureCanvasQTAgg): def __init__(self, parent=None, width=6, height=6, dpi=100): self.fig = Figure(figsize=(width, height), dpi=dpi) self.fig.subplots_adjust(left=0.1, bottom=0.1, right=0.9, top=0.9) super().__init__(self.fig) self.fig.canvas.setFocusPolicy(Qt.ClickFocus) self.fig.canvas.setFocus() def _imshow(self, imgs, scale=0, normalization=0, name=''): self.fig.clf() ax_num = len(imgs) # set a primary image img = imgs[-1] #self.ax.cla() if scale == 0: # Linear.. nothing happened #scaled2d = self.flux2d.copy() scaled2d = img.copy() elif scale == 1: # log transformation.. scaled = log(1+ img)/log(1+img_max) #if self.flux2d.min() < 0: # scaled2d = np.log(-self.flux2d.min() + self.flux2d) / np.log(-self.flux2d.min() + self.flux2d.max()) if img.min() < 0: scaled2d = np.log(-img.min() + img) / np.log(-img.min() + img.max()) else: #scaled2d = np.log(1 + self.flux2d) / np.log(1 + self.flux2d.max()) scaled2d = np.log(1 + img) / np.log(1 + img.max()) elif scale == 2: # square root transformation.. # pixel values > 0 ==> regular sqrt; pixel values <0 ==> 1.absolute value 2.sqrt 3.add minus sign #scaled2d = copy.deepcopy(self.flux2d) scaled2d = copy.deepcopy(img) scaled2d[scaled2d >= 0] = np.sqrt(scaled2d[scaled2d >= 0]) scaled2d[scaled2d < 0] = -np.sqrt(-scaled2d[scaled2d < 0]) elif scale == 3: #scaled2d = self.flux2d**2 scaled2d = img**2 # normalization next # send scaling limits back to toolbar if type(normalization) is int: #print(scaled2d) if normalization == 0: pass #self.send_scale_limits.emit([scaled2d.min(), scaled2d.max()]) elif normalization == 1: # minmax 100% range scaled2d = (scaled2d - scaled2d.min()) / (scaled2d.max() - scaled2d.min()) elif normalization < 10: # this magic num from n_combobox in toolbar if normalization == 2: # 99.5% low, up = np.percentile(scaled2d, [0.25, 99.75]) elif normalization == 3: # 99% low, up = np.percentile(scaled2d, [0.5, 99.5]) elif normalization == 4: # 98% low, up = np.percentile(scaled2d, [1., 99.]) elif normalization == 5: # 97% low, up = np.percentile(scaled2d, [1.5, 98.5]) elif normalization == 6: # 96% low, up = np.percentile(scaled2d, [2., 98.]) elif normalization == 7: # 95% low, up = np.percentile(scaled2d, [2.5, 97.5]) elif normalization == 8: # 92.5% low, up = np.percentile(scaled2d, [3.75, 96.25]) elif normalization == 9: # 90% low, up = np.percentile(scaled2d, [5., 95.]) scaled2d = (scaled2d - low) / (up - low) elif normalization == 10: # Z-score scaled2d = (scaled2d - scaled2d.mean()) / scaled2d.std() elif type(normalization) == list: tmp = (scaled2d - scaled2d.min()) / (scaled2d.max() - scaled2d.min()) scaled2d = tmp * (normalization[1] - normalization[0]) + normalization[0] if 'STAMP' not in name: self.ax = self.fig.add_subplot(ax_num, 1, 1) # flux self.ax.imshow(imgs[0], origin='lower', vmin=imgs[0].min(), vmax=imgs[0].max()) self.ax.set_title(name[0] + ' of Current Object') self.ax.tick_params(labelbottom=False) ax_add = [self.ax] for i in range(1, ax_num): ax_add.append( self.fig.add_subplot(ax_num, 1, i + 1, sharex=self.ax)) if i + 1 == ax_num: if scale == 1: cax = ax_add[-1].imshow(img, origin='lower', vmin=scaled2d.min(), vmax=scaled2d.max() * 0.01) else: cax = ax_add[-1].imshow(img, origin='lower', vmin=scaled2d.min(), vmax=scaled2d.max()) ax_cb = self.fig.colorbar(cax, ax=ax_add[-1], location='bottom') ax_add[-1].tick_params(labelbottom=True) else: ax_add[-1].imshow(imgs[i], origin='lower', vmin=imgs[i].min(), vmax=imgs[i].max()) ax_add[-1].tick_params(labelbottom=False) ax_add[-1].set_title(name[i] + ' of Current Object') ax_add[-1].set_aspect('auto') else: if len(imgs) > 1: wcs = imgs[0] self.ax = self.fig.add_subplot(1, 1, 1, projection=wcs) self.ax.set_xlabel('RA') self.ax.set_ylabel('DEC') else: self.ax = self.fig.add_subplot(1, 1, 1) self.ax.imshow(img, origin='lower', vmin=scaled2d.min(), vmax=scaled2d.max()) if len(name) > 1: self.ax.set_title(name + ' of Current Object') ax_xlim = self.ax.get_xlim() self.ax.set_aspect('auto') #self.ax2d.set_xlim(xlim_spec1d) #self.fig.tight_layout() self.draw() return [scaled2d.min(), scaled2d.max()]
def __init__(self,parent): Tk.Frame.__init__(self,parent) fig = Figure(figsize=(7, 7), dpi=100) fig.subplots_adjust(left=0.01, bottom=0.01, right=0.99, top=0.99) self.mainplot = fig.add_subplot(111,aspect=1) self.mainplot.set_xticks([]) self.mainplot.set_yticks([]) self.vsfreq_curves=[] self.curves=[] self.dots=[] PlotSmith(self.mainplot) parent.bind('<Up>',self.test) self.settings={'centerfreq':2.0e9, 'lowerfreq':1.5e9, 'upperfreq':2.5e9, 'stepsize':0.1e9, 'SmithImpedance':50.0, 'InputImpedance':50, 'LoadImpedance':50} #Menu menu=Tk.Menu(self.master) self.master.config(menu=menu) File=Tk.Menu(menu) menu.add_cascade(label="File",menu=File) menu.add_cascade(label="Plotting",menu=File) menu.add_cascade(label="Settings",menu=File) menu.add_cascade(label="Help",menu=File) #SLIDER FRAME Slider_Frame=Tk.Frame(root) Slider_Frame.grid(row=0,column=0,sticky=Tk.S) slider_canvas=Tk.Canvas(Slider_Frame) slider=SliderFrame(slider_canvas,self.callback) #COMPONENT CONTROL BUTTON FRAMES (i.e. delete, edit) CmpCntrl = Tk.Frame() CmpCntrl.grid(row=1,column=0,padx=5,pady=10,sticky=Tk.S) button_del=Tk.Button(CmpCntrl,width=10,text="Delete",command=self.delete_element) button_del.grid(row=2,column=0,padx=5,pady=1) button_edit=Tk.Button(CmpCntrl,width=10,text="Edit",command=self.edit_element) button_edit.grid(row=2,column=1,padx=5,pady=10) ser_c_icon=Tk.PhotoImage(file="./icons/button_Cse.gif") #button_ser_c=Tk.Button(CmpCntrl,image=ser_c_icon,command=self.add_series_c)#command=self.add_series_c,image=series_c_photo button_ser_c=Tk.Button(CmpCntrl,width=10,text="Series C",command=self.add_series_c)#command=self.add_series_c,image=series_c_photo button_ser_c.grid(row=0,column=0) button2=Tk.Button(CmpCntrl,width=10,text="Shunt C", command=self.add_shunt_c) button2.grid(row=0,column=1) button3=Tk.Button(CmpCntrl,width=10,text="Series L", command=self.add_series_l) button3.grid(row=1,column=0) button4=Tk.Button(CmpCntrl,width=10,text="Shunt L", command=self.add_shunt_l) button4.grid(row=1,column=1) CmpCntrl.config(background="white") #PLOT FRAME PlotFrame = Tk.Frame() PlotFrame.grid(row=1,column=1) self.pltcanvas = FigureCanvasTkAgg(fig, master=PlotFrame) self.pltcanvas.get_tk_widget().grid(row=1,column=1) self.net=network() L1=ind(0.80e-9) C1=cap(6.3e-12,shunt=1) L2=ind(2.0e-9) C2=cap(1.6e-12,shunt=1) L3=ind(5e-9,shunt=1) self.net.element_array.append(C2) self.net.element_array.append(L2) self.net.element_array.append(C1) self.net.element_array.append(L1) self.net.element_array.append(L3) #TEST CASE -- matching 50.0 Ohms to ~5.0 Ohms at 2 GHz #SCHEMATIC FRAME self.im_size=100 SchemFrame = Tk.Frame(root) SchemFrame.grid(row=2,column=0,columnspan=6,sticky=Tk.N+Tk.S+Tk.W+Tk.E) self.Schem = SchematicFrame(SchemFrame,self.net,self.draw_plot,slider) #Pass re-draw function to schematic ######## #Schem.grid(row=0,column=0) #Draw #self.center_freq=2.0e9 self.draw_plot()
avg_dz_m, n_gl=con['n_gl']) fig_height = 3.5 # in. fig_width = 5 # in. fig = Figure(figsize=(fig_width, fig_height)) canvas = FigureCanvas(fig) ax = fig.add_subplot(111) ax.set_title('Varied Erosion History', fontsize=12) ax.invert_xaxis() ax.invert_yaxis() var_line, = ax.plot(t * 1e-6, z_targ, 'r') ax.set_xlabel('Time Before Present (Myr)', fontsize=10) ax.set_ylabel('Depth (m)', fontsize=10) ax.grid(linestyle='-', color='0.75') fig.subplots_adjust(bottom=0.13) ax.set_xlim(left=2) ax.set_ylim(bottom=75) canvas.print_figure('var_hist.png', dpi=500) ax.set_title('Steady Erosion History', fontsize=12) const_line, = ax.plot(t * 1e-6, z_const, 'b') ax.lines.remove(var_line) canvas.print_figure('const_hist.png', dpi=500) fig_height = 5 # in. fig_width = 3.5 # in. # interpolate a production function max_possible_depth = con['n_gl'] * con['max_dz'] + con['bottom_depth'] p = production.interpolate_P_tot(max_possible_depth, npts=con['n_prod_interp_pts'], alt=con['alt'],
class App(tk.Frame): def __init__(self, parent,file_path): tk.Frame.__init__(self, parent) parent.deiconify() self.events_flag = False self.baseline_flag = False self.overlay_flag = False self.file_path = file_path ##### Trace plotting widgets ##### self.trace_frame = tk.LabelFrame(parent,text='Current Trace') self.trace_fig = Figure(figsize=(7,5), dpi=100) self.trace_canvas = FigureCanvasTkAgg(self.trace_fig, master=self.trace_frame) self.trace_toolbar_frame = tk.Frame(self.trace_frame) self.trace_toolbar = NavigationToolbar2Tk(self.trace_canvas, self.trace_toolbar_frame) self.trace_toolbar.update() self.trace_frame.grid(row=0,column=0,columnspan=6,sticky=tk.N+tk.S) self.trace_toolbar_frame.grid(row=1,column=0,columnspan=6) self.trace_canvas.get_tk_widget().grid(row=0,column=0,columnspan=6) ##### PSD plotting widgets ##### self.psd_frame = tk.LabelFrame(parent,text='Power Spectrum') self.psd_fig = Figure(figsize=(7,5), dpi=100) self.psd_canvas = FigureCanvasTkAgg(self.psd_fig, master=self.psd_frame) self.psd_toolbar_frame = tk.Frame(self.psd_frame) self.psd_toolbar = NavigationToolbar2Tk(self.psd_canvas, self.psd_toolbar_frame) self.psd_toolbar.update() self.psd_frame.grid(row=0,column=6,columnspan=6,sticky=tk.N+tk.S) self.psd_toolbar_frame.grid(row=1,column=6,columnspan=6) self.psd_canvas.get_tk_widget().grid(row=0,column=6,columnspan=6) ##### Control widgets ##### self.control_frame = tk.LabelFrame(parent, text='Controls') self.control_frame.grid(row=2,column=0,columnspan=6,sticky=tk.N+tk.S+tk.E+tk.W) self.start_entry = tk.Entry(self.control_frame) self.start_entry.insert(0,'0') self.start_label = tk.Label(self.control_frame, text='Start Time (s)') self.start_label.grid(row=0,column=0,sticky=tk.E+tk.W) self.start_entry.grid(row=0,column=1,sticky=tk.E+tk.W) self.end_entry = tk.Entry(self.control_frame) self.end_entry.insert(0,'10') self.end_label = tk.Label(self.control_frame, text='End Time (s)') self.end_label.grid(row=0,column=2,sticky=tk.E+tk.W) self.end_entry.grid(row=0,column=3,sticky=tk.E+tk.W) self.psd_length_entry = tk.Entry(self.control_frame) self.psd_length_label = tk.Label(self.control_frame, text='PSD Length (s)') self.psd_length_label.grid(row=0,column=4,sticky=tk.E+tk.W) self.psd_length_entry.grid(row=0,column=5,sticky=tk.E+tk.W) self.cutoff_entry = tk.Entry(self.control_frame) self.cutoff_entry.insert(0,'900000') self.cutoff_label = tk.Label(self.control_frame, text='Cutoff (Hz)') self.cutoff_label.grid(row=1,column=0,sticky=tk.E+tk.W) self.cutoff_entry.grid(row=1,column=1,sticky=tk.E+tk.W) self.order_entry = tk.Entry(self.control_frame) self.order_entry.insert(0,'8') self.order_label = tk.Label(self.control_frame, text='Filter Order') self.order_label.grid(row=1,column=2,sticky=tk.E+tk.W) self.order_entry.grid(row=1,column=3,sticky=tk.E+tk.W) self.downsample_entry = tk.Entry(self.control_frame) self.downsample_label = tk.Label(self.control_frame, text='Downsample') self.downsample_label.grid(row=1,column=4,sticky=tk.E+tk.W) self.downsample_entry.grid(row=1,column=5,sticky=tk.E+tk.W) self.plot_trace = tk.Button(self.control_frame, text='Update Trace', command=self.update_trace) self.plot_trace.grid(row=2,column=0,columnspan=2,sticky=tk.E+tk.W) self.normalize = tk.IntVar() self.normalize.set(0) self.normalize_check = tk.Checkbutton(self.control_frame, text='Normalize', variable = self.normalize) self.normalize_check.grid(row=2,column=2,sticky=tk.E+tk.W) self.plot_psd = tk.Button(self.control_frame, text='Update PSD', command=self.update_psd) self.plot_psd.grid(row=2,column=3,sticky=tk.E+tk.W) self.update_data = tk.Button(self.control_frame, text='Update Data', command=self.update_data) self.update_data.grid(row=2,column=4,columnspan=1,sticky=tk.E+tk.W) self.overlay_cusum = tk.Button(self.control_frame, text='Overlay CUSUM', command=self.overlay_cusum) self.overlay_cusum.grid(row=2,column=5,columnspan=1,sticky=tk.E+tk.W) ##### Feedback Widgets ##### self.feedback_frame = tk.LabelFrame(parent, text='Status') self.feedback_frame.grid(row=2,column=6,columnspan=6,sticky=tk.N+tk.S+tk.E+tk.W) self.wildcard = tk.StringVar() self.wildcard_label = tk.Label(self.feedback_frame, textvariable=self.wildcard) self.wildcard_label.grid(row=0,column=0,columnspan=6,sticky=tk.E+tk.W) self.export_psd = tk.Button(self.feedback_frame, text='Export PSD',command=self.export_psd) self.export_psd.grid(row=1,column=0,columnspan=6,sticky=tk.E+tk.W) self.export_trace = tk.Button(self.feedback_frame, text='Export Trace',command=self.export_trace) self.export_trace.grid(row=2,column=0,columnspan=6,sticky=tk.E+tk.W) self.get_filenames(self.file_path) self.load_memmaps() self.initialize_samplerate() ##### utility functions ##### def overlay_cusum(self): analysis_dir = tkinter.filedialog.askdirectory(initialdir='G:/NPN/Filter Scaling/K435PC/500bp',title='Choose analysis directory') baseline_path = analysis_dir + '/baseline.csv' ratefile_path = analysis_dir + '/rate.csv' config_path = analysis_dir + '/summary.txt' self.events_flag = True self.baseline_flag = True self.overlay_flag = True try: self.ratefile = pd.read_csv(ratefile_path,encoding='utf-8') except IOError: self.overlay_flag = False self.wildcard.set('rate.csv not found in given directory') try: self.baseline_file = pd.read_csv(baseline_path,encoding='utf-8') except IOError: self.overlay_flag = False self.wildcard.set('baseline.csv not found in given directory') with open(config_path,'r') as config: for line in config: if 'threshold' in line and 'intra' not in line: line = re.split('=|\n',line) self.threshold = float(line[1]) if 'hysteresis' in line and 'intra' not in line: line = re.split('=|\n',line) self.hysteresis = float(line[1]) if 'cutoff' in line: line = re.split('=|\n',line) self.config_cutoff = int(line[1]) if 'poles' in line: line = re.split('=|\n',line) self.config_order = int(line[1]) def export_psd(self): try: data_path = tkinter.filedialog.asksaveasfilename(defaultextension='.csv',initialdir='G:/PSDs for Sam') np.savetxt(data_path,np.c_[self.f, self.Pxx, self.rms],delimiter=',') except AttributeError: self.wildcard.set('Plot the PSD first') def export_trace(self): try: data_path = tkinter.filedialog.asksaveasfilename(defaultextension='.csv',initialdir='G:/Analysis/Pores/NPN/PSDs') np.savetxt(data_path,self.plot_data,delimiter=',') except AttributeError: self.wildcard.set('Plot the trace first') def get_file_index(self, samplenum): i = 0 try: while self.file_start_index[i+1] < samplenum: i += 1 except IndexError: i = len(self.file_start_index) return i def load_mapped_data(self): if self.start_entry.get()!='': self.start_time = float(self.start_entry.get()) start_index = int((float(self.start_entry.get())*self.samplerate)) else: self.start_time = 0 start_index = 0 start_f = self.get_file_index(start_index) if self.end_entry.get()!='': self.end_time = float(self.end_entry.get()) end_index = int((float(self.end_entry.get())*self.samplerate)) if end_index > self.total_samples: end_index = self.total_samples else: end_index = start_index + len(self.maps[start_f]) end_f = self.get_file_index(end_index) if start_f == end_f: filesize = len(self.maps[start_f]) tempdata = self.maps[start_f][start_index - self.file_start_index[start_f]:end_index - self.file_start_index[start_f]] settings = self.settings[start_f] data = self.scale_raw_data(tempdata,settings) else: filesize = len(self.maps[start_f]) tempdata = self.maps[start_f][start_index - self.file_start_index[start_f]:] settings = self.settings[start_f] data = self.scale_raw_data(tempdata,settings) for i in range(start_f+1,end_f): tempdata = self.maps[i] settings = self.settings[i] data = np.concatenate((data,self.scale_raw_data(tempdata,settings))) tempdata = self.maps[end_f] settings = self.settings[end_f] filesize = len(self.maps[end_f]) data = np.concatenate((data, self.scale_raw_data(self.maps[end_f][:end_index - self.file_start_index[end_f]],settings))) self.data = data def scale_raw_data(self,tempdata,settings): samplerate = np.floor(np.squeeze(settings['ADCSAMPLERATE'])) TIAgain = np.squeeze(settings['SETUP_TIAgain']) preADCgain = np.squeeze(settings['SETUP_preADCgain']) currentoffset = np.squeeze(settings['SETUP_pAoffset']) voltageoffset = np.squeeze(settings['SETUP_mVoffset']) ADCvref = np.squeeze(settings['SETUP_ADCVREF']) ADCbits = np.squeeze(settings['SETUP_ADCBITS']) if samplerate != self.samplerate: self.wildcard.set('One of your files does not match the global sampling rate!') closedloop_gain = TIAgain*preADCgain bitmask = (2**16 - 1) - (2**(16-ADCbits) - 1) tempdata = tempdata.astype(np.uint16) & bitmask tempdata = ADCvref - (2*ADCvref) * tempdata.astype(float)/ float(2**16) tempdata = -tempdata/float(closedloop_gain) + float(currentoffset) return tempdata * 1e12 def load_memmaps(self): columntypes = np.dtype([('current', np.uint16)]) self.maps = [np.memmap(str(f), dtype=columntypes, mode='r')['current'] for f in self.sorted_files] self.settings = [sio.loadmat(f.replace('.log','.mat')) for f in self.sorted_files] total = 0 self.file_start_index = [0] for m in self.maps: total += len(m) self.file_start_index.append(total) self.total_samples = total self.file_start_index = np.array(self.file_start_index,dtype=np.int64) def get_filenames(self, initialfile): pattern = initialfile[:-19] + '*.log' files = glob.glob(pattern) timelist = [os.path.basename(fname)[-19:-4] for fname in files] etimestamps = [time.mktime(time.strptime(stamp,"%Y%m%d_%H%M%S")) for stamp in timelist] self.sorted_files = [fname for (estamp, fname) in sorted(zip(etimestamps, files), key=lambda pair: pair[0])] self.wildcard.set('Found {0} files matching {1}'.format(len(self.sorted_files),pattern)) def integrate_noise(self, f, Pxx): df = f[1]-f[0] return np.sqrt(np.cumsum(Pxx * df)) def filter_data(self): cutoff = float(self.cutoff_entry.get()) order = int(self.order_entry.get()) Wn = 2.0 * cutoff/float(self.samplerate) b, a = bessel(order,Wn,'low') padding = 1000 padded = np.pad(self.data, pad_width=padding, mode='median') self.filtered_data = filtfilt(b, a, padded, padtype=None)[padding:-padding] def downsample_data(self): self.downsampled_data = self.filtered_data[::int(self.samplerate / self.downsample_entry.get())] def initialize_samplerate(self): settings = self.settings[0] self.samplerate = np.floor(np.squeeze(settings['ADCSAMPLERATE'])) ##### Plot Updating functions ##### def update_trace(self): self.load_mapped_data() self.filtered_data = self.data self.plot_data = self.filtered_data plot_samplerate = self.samplerate if self.cutoff_entry.get()!='' and self.order_entry!='': self.filter_data() self.plot_data = self.filtered_data if self.downsample_entry.get()!='': self.downsample_data() self.plot_data = self.downsampled_data plot_samplerate = float(self.downsample_entry.get()) self.trace_fig.clf() a = self.trace_fig.add_subplot(111) if self.events_flag and self.overlay_flag == True: db = self.ratefile start_time = self.start_time end_time = self.end_time good_start = np.atleast_1d(np.squeeze(sqldf('SELECT start_time_s from db WHERE start_time_s >= {0} AND start_time_s < {1} AND type IN (0,1)'.format(start_time,end_time),locals()).values)*1e6) bad_start = np.atleast_1d(np.squeeze(sqldf('SELECT start_time_s from db WHERE start_time_s >= {0} AND start_time_s < {1} AND type>1'.format(start_time,end_time),locals()).values)*1e6) good_end = np.atleast_1d(np.squeeze(sqldf('SELECT end_time_s from db WHERE end_time_s >= {0} AND end_time_s < {1} AND type IN (0,1)'.format(start_time,end_time),locals()).values)*1e6) bad_end = np.atleast_1d(np.squeeze(sqldf('SELECT end_time_s from db WHERE end_time_s >= {0} AND end_time_s < {1} AND type>1'.format(start_time,end_time),locals()).values)*1e6) if len(good_start) > 0 and len(good_end) > 0: if good_start[0] > good_end[0]: good_start = good_start[1:] if len(bad_start) > 0 and len(bad_end) > 0: if bad_start[0] > bad_end[0]: bad_start = bad_start[1:] for gs, ge in zip(np.atleast_1d(good_start),np.atleast_1d(good_end)): a.axvspan(gs,ge,color='g',alpha=0.3) for bs, be in zip(np.atleast_1d(bad_start),np.atleast_1d(bad_end)): a.axvspan(bs,be,color='r',alpha=0.3) time = np.linspace(1.0/plot_samplerate,len(self.plot_data)/float(plot_samplerate),len(self.plot_data))+self.start_time a.set_xlabel(r'Time ($\mu s$)') a.set_ylabel('Current (pA)') self.trace_fig.subplots_adjust(bottom=0.14,left=0.21) a.plot(time*1e6,self.plot_data,'.',markersize=1) if self.baseline_flag: if self.config_cutoff != int(self.cutoff_entry.get()) or self.config_order != int(self.order_entry.get()): self.wildcard.set('Filter settings in config file do not match plotting filter settings, overlay will be inaccurate') db = self.baseline_file start_time = self.start_time end_time = self.end_time times = np.squeeze(sqldf('SELECT time_s from db',locals()).values) times = np.sort(times) start_block = times[0] for time in times: if time <= start_time and time >= start_block: start_block = time baseline_db = sqldf('SELECT * from db WHERE time_s >= {0} and time_s < {1}'.format(start_block,end_time),locals()) times = baseline_db['time_s'].values means = baseline_db['baseline_pA'].values stdevs = baseline_db['stdev_pA'].values numblocks = len(means) for i in range(numblocks): if i == 0: xmin = start_time else: xmin = times[i] if i+1 == numblocks: xmax = end_time else: xmax = times[i+1] sign = np.sign(means[i]) a.plot((xmin*1e6,xmax*1e6), (means[i]-sign*(self.threshold - self.hysteresis)*stdevs[i],means[i]-sign*(self.threshold - self.hysteresis)*stdevs[i]), '--',color='y') a.plot((xmin*1e6,xmax*1e6), (means[i]-sign*self.threshold*stdevs[i],means[i]-sign*self.threshold*stdevs[i]), '--',color='y') a.plot((xmin*1e6,xmax*1e6), (means[i],means[i]), '--', color='black') self.trace_canvas.draw() def update_psd(self): self.load_mapped_data() self.filtered_data = self.data self.plot_data = self.filtered_data plot_samplerate = self.samplerate bandwidth = 1.0e6 if self.cutoff_entry.get()!='' and self.order_entry!='': self.filter_data() self.plot_data = self.filtered_data maxf = 2*float(self.cutoff_entry.get()) bandwidth = maxf/2.0 else: maxf = 2e6 if (self.psd_length_entry.get()!=''): length = 2**np.ceil(np.log2(float(self.psd_length_entry.get())*plot_samplerate)) if (length > len(self.filtered_data)): length = len(self.filtered_data) else: length = np.minimum(2**20,len(self.filtered_data)) end_index = int(np.floor(len(self.filtered_data)/length)*length) current = np.average(self.filtered_data[:end_index]) f, Pxx = welch(self.filtered_data, plot_samplerate,nperseg=length) self.rms = self.integrate_noise(f, Pxx) if self.normalize.get(): Pxx /= current**2 Pxx *= bandwidth self.rms /= np.absolute(current) self.f = f self.Pxx = Pxx minf = 1 BW_index = np.searchsorted(f, maxf/2) logPxx = np.log10(Pxx[1:BW_index]) minP = 10**np.floor(np.amin(logPxx)) maxP = 10**np.ceil(np.amax(logPxx)) df = f[1]-f[0] fitmax = 10000 freqstop = len(f[f<=100]) N = len(f[f<fitmax]) fnorm = self.f[1:N] if self.normalize.get(): Pxx_norm = self.Pxx[1:N] else: Pxx_norm = self.Pxx[1:N]*bandwidth/current**2 #popt, pcov = curve_fit(self.fitfunc, fnorm, np.log10(Pxx_norm), p0=[1.0,1,1000.0, 0.0001], sigma=np.sqrt(np.arange(1,N)+np.sqrt(3)/3), maxfev=100000) #f0 = popt[0] #alpha = popt[1] #fstar = popt[2] #offset = popt[3] #L_simple = self.old_L(Pxx_norm[:freqstop], df, bandwidth) #L_adj = self.corrected_L(fnorm[:freqstop], Pxx_norm[:freqstop], f0, alpha, fstar, offset, df, bandwidth) self.psd_fig.clf() a = self.psd_fig.add_subplot(111) a.set_xlabel('Frequency (Hz)') a.set_ylabel(r'Spectral Power ($\mathrm{pA}^2/\mathrm{Hz}$)') a.set_xlim(minf, maxf) a.set_ylim(minP, maxP) self.psd_fig.subplots_adjust(bottom=0.14,left=0.21) a.loglog(f[1:],Pxx[1:],'b-') #if self.normalize.get(): # a.loglog(fnorm, 10**self.fitfunc(f[1:N], f0, alpha, fstar, offset),'g') #else: # a.loglog(fnorm, 10**self.fitfunc(f[1:N], f0, alpha, fstar, offset)*current**2/bandwidth,'g') for tick in a.get_yticklabels(): tick.set_color('b') a2 = a.twinx() a2.semilogx(f, self.rms, 'r-') a2.set_ylabel('RMS Noise (pA)') a2.set_xlim(minf, maxf) for tick in a2.get_yticklabels(): tick.set_color('r') a2.format_coord = make_format(a2, a) self.psd_canvas.draw() #psd1hz = 10**self.fitfunc(1.0, f0, alpha, fstar, offset)*current**2/bandwidth # self.wildcard.set('RMS = {:0.2f} pA\tL[old] = {:.3g}\tL[adjusted] = {:.3g}\tPSD@1Hz = {:.3g} pA\u00b2/Hz'.format(np.std(self.filtered_data), L_simple, L_adj,psd1hz)) def fitfunc(self, f, f0, alpha, fstar, offset): return np.log10((f0/f)**alpha + alpha*(f0/fstar)**(1+alpha)*(f/f0) + offset) def corrected_L(self, f, Pxx, f0, alpha, fstar, offset, df, B): integrand = Pxx - alpha*(f0/fstar)**(1+alpha)*(f/f0) - offset return np.sqrt(np.sum(integrand)*df/B) def old_L(self, Pxx, df, B): return np.sqrt(np.sum(Pxx)*df/B) def update_data(self): self.get_filenames(self.file_path) self.load_memmaps() self.initialize_samplerate()
class graph_panel(wx.Panel): def __init__(self, *args, **kwargs): wx.Panel.__init__(self, *args, **kwargs) self.previous_patterns = [] self.history_size = 100 self.hi_contrast = False self.big_numbers = False self.need_data = True self.build() def build(self): ''' build the whole thing ''' self.fig = Figure(dpi=110) self.fig.set_facecolor('#000000') self.canvas = FigCanvas(self, -1, self.fig) self.Bind(wx.EVT_SIZE, self.sizeHandler) self.SetMinSize((400, 200)) self.buildgraph() def add_axes(self, subplot_index): ''' add a new set of axes ''' ax = self.fig.add_subplot(subplot_index) ax.set_axis_bgcolor('#000000') ax.set_xlim(0, self.history_size) #ax.set_yscale('log', nonposx='clip') #ax.set_ylim(ymin=0) yfm = ax.yaxis.get_major_formatter() yfm.set_powerlimits([0, 1]) ax.spines['top'].set_color('white') ax.spines['bottom'].set_color('white') ax.spines['left'].set_color('white') ax.spines['right'].set_color('white') ax.tick_params(axis='x', colors='white') ax.tick_params(axis='y', colors='white') ax.yaxis.get_offset_text().set_color('white') return ax def add_big_text(self, ax): ''' add big text ''' text = ax.text(0.01, 0.95, '', transform=ax.transAxes, color='#ffffff', va='top', fontsize=45) return text def buildgraph(self): ''' build the graph bits ''' self.fig.clf() self.axes1 = self.add_axes(211) self.axes2 = self.add_axes(212) self.fig.subplots_adjust(left=.08, right=.97, top=.96, bottom=.08) def sizeHandler(self, *args, **kwargs): ''' makes sure that the canvas is properly resized ''' self.canvas.SetSize(self.GetSize()) def set_hi_contrast(self, event): ''' set the contrast ''' self.hi_contrast = event.IsChecked() for c in self.all_curves: if self.hi_contrast: c.plot_curve.set_lw(1) c.plot_curve.set_color('white') else: c.plot_curve.set_lw(1) c.plot_curve.set_color(c.color) def set_big_numbers(self, event): ''' set the contrast ''' self.big_numbers = event.IsChecked() def clear(self): ''' called when the pattern changes ''' if self.need_data == False: self.buildgraph() self.need_data = True self.singles_curves = [] def add_counts(self, data): ''' add a set of counts ''' new_singles = filter(lambda x: len(x[1]) == 1, data) new_coincidences = filter(lambda x: len(x[1]) > 1, data) if self.need_data: self.singles_curves = [ curve(q[0], q[1], self.axes1, self.history_size) for q in new_singles ] self.coincidence_curves = [ curve(q[0], q[1], self.axes2, self.history_size) for q in new_coincidences ] self.all_curves = self.singles_curves + self.coincidence_curves self.need_data = False for i in range(len(self.singles_curves)): self.singles_curves[i].add_point(new_singles[i][2]) for i in range(len(self.coincidence_curves)): self.coincidence_curves[i].add_point(new_coincidences[i][2]) self.draw() def get_big_number_text(self, curve_group): ''' update the big number text ''' text = '' for c in curve_group: s = format(int(c.ydata[-1]), ',d') s = '%s: %s\n' % (c.label, s) text += s return text def rescale_axes(self): ''' rescale all the axes ''' self.axes1.relim() self.axes1.autoscale_view(True, True, True) self.axes2.relim() self.axes2.autoscale_view(True, True, True) def draw(self): ''' draw all of the curves etc ''' for c in self.all_curves: c.update() self.rescale_axes() self.canvas.draw()