def __init__(self, ylims=None, num_twiny_axes=2, num_twinx_axes=1): # Geometry self.ylims = ylims self.fig = plt.figure(figsize=(6, 8)) self.gridspecs = gridspec.GridSpec( len(ylims) if ylims else 1, 1, height_ratios=list(reversed([ylim[1] - ylim[0] for ylim in ylims]))) self.axes = list(self.create_axes()) self.twiny_axes = [[ax.twiny() for ax in self.axes] for i in range(num_twiny_axes)] self.twinx_axes = [[ax.twinx() for ax in self.axes] for i in range(num_twinx_axes)] for axes in [self.axes] + self.twinx_axes: for ax, ylim in zip(axes, list(reversed(ylims))): ax.set_ylim(*ylim) # for twinx_axes in self.twinx_axes: # for ax, ylim in zip(twinx_axes, list(reversed(ylims))): # ax.set_ylim(*ylim) # Axes #for ax in self.axes[:-1] + self.twin_axes[:-1]: for ax in self.axes[:-1] + [ ax for twiny_axes in self.twiny_axes for ax in twiny_axes[:-1] ]: #ax.spines['bottom'].set_visible(False) ax.spines['bottom'].set_linewidth(.5) #ax.spines['bottom'].set_alpha(.5) ax.spines['bottom'].set_linestyle('dotted') ax.tick_params(labelbottom=False, bottom=False, which='major') ax.tick_params(labelbottom=False, bottom=False, which='minor') for ax in self.axes[1:] + [ ax for twiny_axes in self.twiny_axes for ax in twiny_axes[1:] ]: #ax.spines['top'].set_visible(False) ax.spines['top'].set_linewidth(.5) #ax.spines['top'].set_alpha(.5) ax.spines['top'].set_linestyle('dotted') ax.tick_params(labeltop=False, top=False, which='major') ax.tick_params(labeltop=False, top=False, which='minor') for ax in self.axes + [ ax for twiny_axes in self.twiny_axes for ax in twiny_axes ]: #for ax in self.axes + self.twin_axes: ax.tick_params(direction='in', which='major') ax.tick_params(direction='in', which='minor') ax.yaxis.set_major_locator(ticker.MultipleLocator(.1)) ax.yaxis.set_minor_locator(ticker.AutoMinorLocator()) ax.set_axisbelow(True) for ax in self.axes: ax.xaxis.set_major_locator(ticker.MultipleLocator(1)) ax.xaxis.set_minor_locator(ticker.AutoMinorLocator()) ax.grid(ls='-', which='major', lw=1, c='k', alpha=.2) ax.grid(ls='-', which='minor', lw=.5, c='k', alpha=.1) self.create_diag(.008, .015)
def plot(data, unit="wn", figname="specden.svg"): if unit == "eV": x = data[:, 1] xlabel = 'E / eV' xmaj = ticker.MultipleLocator(0.05) elif unit == "wn": x = data[:, 0] xlabel = r'$\tilde{\nu}$ / cm$^{-1}$' xmaj = ticker.MultipleLocator(500) specden = data[:, -1] # Set up a plot fig = plt.figure() gs = gridspec.GridSpec(1, 1) gs.update(wspace=0.1, hspace=0.1) ax = plt.subplot(gs[0]) ax.plot(x, specden) # Plot options ax.set_xlabel(xlabel) ax.set_ylabel(r'$J(\omega)$ / cm$^{-1}$') ax.set_xlim(x.min(), x.max() + 1) ax.set_ylim(0) xminloc = ticker.AutoMinorLocator(5) yminloc = ticker.AutoMinorLocator(5) ax.xaxis.set_major_locator(xmaj) ax.xaxis.set_minor_locator(xminloc) ax.yaxis.set_minor_locator(yminloc) # ax.yaxis.set_label_coords(-0.1, 0.5) ax.xaxis.set_ticks_position('both') ax.yaxis.set_ticks_position('both') ax.tick_params(axis='both', which='major', direction='in', pad=10, length=5) ax.tick_params(axis='both', which='minor', direction='in', pad=10, length=2) # ax.relim() # ax.autoscale_view(True,True,True) # ax.set_aspect(0.65/ax.get_data_ratio()) rcParams.update({'font.size': 18}) # plt.gcf().subplots_adjust(bottom=0.15) plt.savefig(figname, dpi=600) plt.close() # plt.show() return
def plot_one_psd(ax, X_pwr, f_ax, title_str, p_range, f_range): """ Plots ONLY ONE PSD """ X_plot = 10 * np.log10(X_pwr + np.finfo(float).eps) plt.plot(f_ax, X_plot) # Major and Minor ticks ax = plt.gca() ax.xaxis.set_major_locator(ticker.AutoLocator()) ax.xaxis.set_minor_locator(ticker.AutoMinorLocator()) ax.yaxis.set_major_locator(ticker.AutoLocator()) ax.yaxis.set_minor_locator(ticker.AutoMinorLocator()) plt.xlabel('Modulation frequency (Hz)') plt.ylabel('Conventional frequency (Hz)') if f_range is not None: xlim = f_range else: xlim = f_ax if p_range is not None: ylim = p_range else: ylim = X_plot # set the limits of the plot to the limits of the data plt.axis([xlim.min(), xlim.max(), ylim.min(), ylim.max()]) plt.title(title_str) plt.draw()
def roc(data): ''' This function generates a standard rate of climb plot. Input data must have columns following the standard naming convention of the helicopter class. ie. A dataframe output from the Helicopter.forward_flight method can be directly supplied. ''' fig, ax = plt.subplots(figsize=(15,9)) # Add the data and color it ax.plot(data.Airspeed, data.ROC, color='orange', label='Rate of Climb', marker='o', markersize='4') ax.legend() # Axis labels ax.set_xlabel('Airspeed, $V$ [kts]', fontsize=12) ax.set_ylabel('Rate of Climb, $ROC$ [ft/min]', fontsize=12) ax.set_title('Forward Flight Rate of Climb\n', fontsize=18) ax.xaxis.set_minor_locator(ticker.AutoMinorLocator()) ax.yaxis.set_minor_locator(ticker.AutoMinorLocator()) ax.tick_params(axis='both', which='both', direction='in') # Set the grid lines ax.grid(b=True, which='major', linestyle=':') ax.grid(b=True, which='minor', linestyle=':', alpha=0.3) return fig, ax
def plot_box_plot(df, save_dir): df.columns = df.columns.swaplevel(0, 1) columns = df.columns.levels[0] print 'columns', columns for c in columns: plt.figure(figsize=(7, 5)) dd = df[c].copy() dd.columns = [mapping_dict_cols[a] for a in dd.columns] model_names = dd.columns avg = dd['P-NET'].median() sns.set_style("whitegrid") order = list(dd.median().sort_values().index) dd = dd.melt() ax = sns.boxplot(x="variable", y="value", data=dd, whis=np.inf, order=order, palette=my_pal) ax.axhline(avg, ls='--') plt.ylim([0.4, 1.05]) ax.set_ylabel(mapping_dict[c], fontdict=dict(family='Arial', weight='bold', fontsize=14)) ax.set_xlabel('') plt.tight_layout() plt.setp(ax.get_xticklabels(), rotation=30, horizontalalignment='right', fontsize=14) ax.get_xaxis().set_minor_locator(ticker.AutoMinorLocator()) ax.get_yaxis().set_minor_locator(ticker.AutoMinorLocator()) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.spines['left'].set_visible(False) plt.gcf().subplots_adjust(bottom=0.3, left=0.2) plt.savefig(join(save_dir, c + '_boxplot'), dpi=100)
def nclize_axis(ax, minor_per_major=3): """ Utility function to make plots look like NCL plots """ import matplotlib.ticker as tic ax.tick_params(labelsize="small") ax.minorticks_on() ax.xaxis.set_minor_locator(tic.AutoMinorLocator(n=minor_per_major)) ax.yaxis.set_minor_locator(tic.AutoMinorLocator(n=minor_per_major)) # length and width are in points and may need to change depending on figure size etc. ax.tick_params( "both", length=8, width=1.5, which="major", bottom=True, top=True, left=True, right=True, ) ax.tick_params( "both", length=5, width=0.75, which="minor", bottom=True, top=True, left=True, right=True, )
def plotalgos(self): """plots aglos""" figure(figsize=self.figsize) for i, algo in enumerate(self.algolist): d = self.moving_average_pct(self.algos, algo) plt.plot(self.blocklist, d, '-', color=self.colorlist[i], label=algo, linewidth=self.lw) plt.hold('on') plt.grid('on') ax = plt.gca() ax.get_xaxis().set_minor_locator(ticker.AutoMinorLocator()) ax.get_yaxis().set_minor_locator(ticker.AutoMinorLocator()) ax.set_xlim([self.blocklist[0], self.blocklist[-1]]) ax.grid(b=True, which='major', color='#a0a0a0', linestyle='-', linewidth=1.0) ax.grid(b=True, which='minor', color='#dcdcdc', linestyle='-', linewidth=0.5) ax.get_xaxis().get_major_formatter().set_scientific(False) ax.get_xaxis().get_major_formatter().set_useOffset(False) ax.set_xlabel('Block Number') ax.set_ylabel('% of Blocks') ax.set_title('Block % for Mining Algorithms') legend(self.algolist, loc=0, prop={'size': 8}) savefig(self.plotpath + 'algohist.png', bbox_inches='tight')
def plot_species(ax, windows, abbrev): ax.xaxis.set_minor_locator(ticker.AutoMinorLocator(2)) ax.yaxis.set_minor_locator(ticker.AutoMinorLocator(2)) ax.grid(True, which='both') ax.plot( windows['window_order'], -np.log10(windows['pvalue']), linewidth='0.75', color='black', ) hotspots = windows.loc[windows['signif'] & windows['top_window']] ax.scatter( hotspots['window_order'], -np.log10(hotspots['pvalue']), s=4, color='red', ) ax.set_ylabel("-log10(P)") title = ax.twinx() title.set_ylabel(sp.species_abbrev, bbox={ 'linestyle': "-", 'linewidth': 1, 'edgecolor': 'black', 'facecolor': 'lightgrey' }) title.set_yticks([]) pass
def animate(i, st, download, upload, time, ax1, ax2): # Add x and y to lists time.append(dt.datetime.now().strftime("%d/%m/%y %H:%M:%S")) download.append(st.download() / 1e6) upload.append(st.upload() / 1e6) # Draw x and y lists ax1.clear() ax1.plot(time, download) ax2.clear() ax2.plot(time, upload) # Format plot ax1.set_xticks([]) ax1.yaxis.set_major_locator(ticker.AutoLocator()) ax1.yaxis.set_minor_locator(ticker.AutoMinorLocator()) ax2.xaxis.set_major_locator(ticker.AutoLocator()) ax2.xaxis.set_minor_locator(ticker.AutoMinorLocator()) ax2.yaxis.set_major_locator(ticker.AutoLocator()) ax2.yaxis.set_minor_locator(ticker.AutoMinorLocator()) plt.xticks(rotation=45, ha='right') plt.subplots_adjust(bottom=0.30) ax1.set_title("Download Speed") ax2.set_title("Upload Speed") ax1.set_ylabel("Speed (Mb/s") ax2.set_ylabel("Speed (Mb/s") ax2.set_xlabel("Time") plt.tight_layout()
def global_plot(dic=dataBase, name=False, overlap=False): if name is not False: plt.title(list(dic.keys())) fig, ax = plt.subplots(1, 1, figsize=(16, 16), dpi=180) if overlap is True: for linea in dic.keys(): grafo, z = dic[linea], solapamiento[linea] colormap = plt.cm.jet # plt.cm.hsv normalize = matplotlib.colors.Normalize(vmin=1, vmax=22) lc = LineCollection(zip(grafo[:-1], grafo[1:]), array=z, cmap=colormap, norm=normalize) ax.add_collection(lc) ax.margins(0.5, 0.1) ax.xaxis.set_major_locator(mticker.MultipleLocator(5)) ax.yaxis.set_major_locator(mticker.MultipleLocator(5)) ax.xaxis.set_minor_locator(mticker.AutoMinorLocator(5)) ax.yaxis.set_minor_locator(mticker.AutoMinorLocator(5)) ax.grid(which='major', color='#CCCCCC', linestyle='--') ax.grid(which='minor', color='#CCCCCC', linestyle=':') # plt.grid() plt.colorbar(lc, ticks=mticker.MultipleLocator(5), aspect=50) plt.xlim([-5, 32]), plt.ylim([32, 72]) else: for linea in dic.keys(): x, y = [k[0] for k in grafo], [k[1] for k in grafo] plt.plot(x, y, '-', linewidth=2, color="b") plt.grid()
def subplots(nrows=1, ncols=1, figsize = (4, 3), sharex=True, \ sharey=True, **kwargs): if nrows == 1 and ncols == 1: fig, ax = plt.subplots(figsize=figsize, constrained_layout=True, **kwargs) ax.xaxis.set_minor_locator(ticker.AutoMinorLocator(2)) ax.yaxis.set_minor_locator(ticker.AutoMinorLocator(2)) ax.tick_params(direction='in', length=6) return fig, ax elif (nrows > 1 and ncols == 1) or (ncols > 1 and nrows == 1): fig, axs = plt.subplots(nrows=nrows, ncols=ncols, sharex=sharex, \ sharey=sharey, **kwargs) for ax in axs: ax.xaxis.set_minor_locator(ticker.AutoMinorLocator(2)) ax.yaxis.set_minor_locator(ticker.AutoMinorLocator(2)) ax.tick_params(direction='in', length=6, labelsize=20) return fig, axs else: fig, ax = plt.subplots(nrows=nrows, ncols=ncols, \ sharex=True, sharey=True) return fig, ax
def plot_params(ax, axis_label=None, plt_title=None, label_size=15, axis_fsize=15, title_fsize=20, scale='linear'): # Tick-Parameters ax.xaxis.set_minor_locator(ticker.AutoMinorLocator()) ax.yaxis.set_minor_locator(ticker.AutoMinorLocator()) ax.tick_params(which='both', width=1, labelsize=label_size) ax.tick_params(which='major', length=6) ax.tick_params(which='minor', length=3, color='0.8') # Grid plt.grid(lw=1, ls='-', c="0.7", which='major') plt.grid(lw=1, ls='-', c="0.9", which='minor') # Plot Title plt.title(plt_title, {'fontsize': title_fsize}) # Yaxis sacle plt.yscale(scale) plt.minorticks_on() # Plot Axes Labels xl = plt.xlabel(axis_label[0], fontsize=axis_fsize) yl = plt.ylabel(axis_label[1], fontsize=axis_fsize)
def update_ticks_and_axes(ax, plt, baseFontSize, yAxisFormatString, allowNegativeY, xAxisGridStyle, yAxisGridStyle): if not allowNegativeY: # Assure that the Y axis minimum is not negative ymin, ymax = plt.ylim() if ymin < 0: plt.ylim(bottom=0) # plt.xticks(fontsize=baseFontSize-2) # plt.yticks(fontsize=baseFontSize-2) ax.yaxis.set_major_formatter(mtick.FormatStrFormatter(yAxisFormatString)) ax.yaxis.set_minor_locator(mtick.AutoMinorLocator()) # Optionally define the distance between tick labels # ax.xaxis.set_major_locator(mtick.MultipleLocator(5000)) ax.xaxis.set_major_formatter( mtick.FuncFormatter(lambda x, p: format(int(x), ','))) ax.xaxis.set_minor_locator(mtick.AutoMinorLocator()) xAxisGridlines = len(xAxisGridStyle) > 0 yAxisGridlines = len(yAxisGridStyle) > 0 if xAxisGridlines or yAxisGridlines: ax.grid(True) ax.xaxis.grid(xAxisGridlines, which='major', linestyle=xAxisGridStyle) ax.xaxis.grid(False, which='minor') ax.yaxis.grid(yAxisGridlines, which='major', linestyle=yAxisGridStyle) ax.yaxis.grid(False, which='minor')
def plot_schedulability_rates_simplegen(): """Plot schedulability rates in a graph, using the results from eval_simplegen().""" modes = [ # name, color, linestyle, marker ('dSMC', 'blue', 'dashed', 'o'), ('dAMC', 'red', 'dashed', 'd'), ('EDF-VD', 'green', 'dashed', 's'), ('pSMC', 'orange', 'dashed', '^'), ('pAMC-BB', 'magenta', 'dashed', 'D'), ('pAMC-BB+', 'purple', 'dashed', 'v') ] task_sets_list = pickle.load( open(task_sets_path + 'task_sets_simplegen', 'rb')) rates = {} fig = plt.figure(figsize=(12, 6), dpi=300) fig.suptitle('Evaluation: SimpleGen (n=%d)' % len(task_sets_list[0])) ax1 = fig.add_subplot(111) for name, color, linestyle, marker in modes: rates[name] = pickle.load(open(eval_simplegen_path + name, 'rb')) ax1.plot(utils, rates[name], label=name, color=color, linestyle=linestyle, marker=marker) ax1.set_xlabel('LO mode utilization') ax1.set_ylabel('Percentage of task sets schedulable') ax1.set_xlim(0.1, 2.1) ax1.set_xticks([k * 0.5 for k in range(5)]) ax1.set_yticks([k * 20 for k in range(6)]) ax1.xaxis.set_minor_locator(ticker.AutoMinorLocator(5)) ax1.yaxis.set_minor_locator(ticker.AutoMinorLocator(1)) ax1.minorticks_on() ax1.grid(which='both', linestyle='dashed') # Plot average system util: avg_utils = [] for i, _ in enumerate(utils): avg_utils.append( np.average([task_set.u_avg for task_set in task_sets_list[i]])) ax2 = ax1.twinx() ax2.plot(utils, avg_utils, label='Avg Sys Util (right scale)', color='black', linestyle='dashed', marker=None) ylim = ax1.get_ylim() ax2.set_ylim(ylim[0] / 100, ylim[1] / 100) ax2.set_ylabel('U(Avg)') plt.axvline(1.0, color='black', linewidth=0.8) lines1, labels1 = ax1.get_legend_handles_labels() lines2, labels2 = ax2.get_legend_handles_labels() plt.xlim(0.1, 2.1) plt.legend(lines1 + lines2, labels1 + labels2, loc='center left') plt.savefig('./figures/schedulability_rates_simplegen.png')
def mozenaPlot(data): ''' create the plot from Mark Mozena's thesis with given data Sersic vs Reff vs Axis Ratio ''' condition = np.ones_like(data["red"], bool) condition &= data["cam"] != 0 condition &= data["cam"] != 1 condition &= (data["red"] > 1.4) & (data["red"] < 2.6) condition &= (data["mass"] > 10**8.5) & (data["mass"] < 10**11) s = 0.5 ser = data["ser"][condition] rad = data["rad"][condition] ba = data["ba"][condition] serlim = [0, 5.5] serticks = [1, 2, 3, 4, 5] serVSrad = plt.subplot(221) serVSrad.plot(rad, ser, "bs", ms=s) serVSrad.set_xscale("log") serVSrad.set_ylabel("Sersic (n)", labelpad=15) serVSrad.set_ylim(serlim) serVSrad.set_yticks(serticks) serVSrad.yaxis.set_minor_locator(ticker.AutoMinorLocator(n=2)) plt.setp(serVSrad.get_xticklabels(), visible=False) baVSrad = plt.subplot(223, sharex=serVSrad) baVSrad.plot(rad, ba, "bs", ms=s) baVSrad.set_xlabel("$R_{eff}$ (kpc)") baVSrad.set_xscale("log") baVSrad.set_xlim(0.5, 12) baVSrad.set_xticks([1.0, 3.0, 10.0]) baVSrad.xaxis.set_major_formatter(ticker.LogFormatter(labelOnlyBase=False)) baVSrad.set_ylabel("Axis Ratio (q)") baVSser = plt.subplot(224, sharey=baVSrad) baVSser.plot(ser, ba, "bs", ms=s) baVSser.set_xlim(serlim) baVSser.set_xticks(serticks) baVSser.xaxis.set_minor_locator(ticker.AutoMinorLocator(n=2)) baVSser.set_xlabel("Sersic (n)") baVSser.set_ylim(0, 1.05) baVSser.set_yticks([0.2, 0.4, 0.6, 0.8, 1.0]) baVSser.yaxis.set_minor_locator(ticker.AutoMinorLocator(n=2)) plt.setp(baVSser.get_yticklabels(), visible=False) # remove extra space between subplots plt.tight_layout(w_pad=0, h_pad=0) # these are matplotlib.patch.Patch properties props = dict(boxstyle='round', facecolor='wheat', alpha=0.5) # place a text box in upper left in axes coords textstr = "Simulations\nFour Random Cameras\n$z = 1.4 - 2.6$" textstr += "\n$log(M_{\odot}) = 8.5 - 11.0$\n$N = %d$" % len(ser) plt.figtext(0.6, 0.9, textstr, fontsize=16, verticalalignment='top') #, bbox=props) return
def plot2DTrial(X, Y, C, ax=plt.gca(), xlabel=None, ylabel=None, colorBar=False, clBarLabel="", vmin=None, vmax=None, title="", clbarNTicks=2, xticks=True, yticks=True, cmap=None, cbar_kw={}, sliceAnn=None, axis_setting='scaled', **kw): '''A low level function to plot a 2D trial-average data into a plot.''' kw['rasterized'] = kw.get('rasterized', True) cbar_kw['label'] = cbar_kw.get('label', '') cbar_kw['shrink'] = cbar_kw.get('shrink', 0.8) cbar_kw['pad'] = cbar_kw.get('pad', 0.05) cbar_kw['ticks'] = cbar_kw.get('ticks', ti.MultipleLocator(5)) cbar_kw['rasterized'] = cbar_kw.get('rasterized', True) if xlabel is None: xlabel = xlabelText if ylabel is None: ylabel = ylabelText dx = X[0, 1] - X[0, 0] dy = Y[1, 0] - Y[0, 1] globalAxesSettings(ax) ax.minorticks_on() mappable = ax.imshow(C, vmin=vmin, vmax=vmax, cmap=cmap, extent=(X[0, 0] - dx / 2., X[0, -1] + dx / 2., Y[0, 0] - dy / 2., Y[-1, 0] + dy / 2.), interpolation='none', origin='lower', **kw) cax = createColorbar(ax, mappable=mappable, **cbar_kw) if colorBar == False: cax.set_visible(False) if xlabel != "": ax.set_xlabel(xlabel, va='top') ax.xaxis.set_label_coords(0.5, -0.125) if ylabel != "": ax.set_ylabel(ylabel, ha='center') ax.yaxis.set_label_coords(-0.125, 0.5) ax.xaxis.set_ticks([X[0, 0], X[0, -1]]) ax.yaxis.set_ticks([Y[0, 0], Y[-1, 0]]) ax.xaxis.set_minor_locator(ti.AutoMinorLocator(6)) ax.yaxis.set_minor_locator(ti.AutoMinorLocator(6)) ax.axis(axis_setting) if not xticks: ax.xaxis.set_ticklabels([]) if not yticks: ax.yaxis.set_ticklabels([]) # slice annotations if sliceAnn is not None: for args in sliceAnn: args.update(ax=ax, X=X, Y=Y) plotSliceAnnotation(**args) return C, ax, cax
def _heatmap(features,clen,step,Plot,**kwargs): reg=kwargs.get('reg',None) if reg: lo=reg[0] hi=reg[1] else: lo=0 hi=clen ranges=_heat(features,lo,hi,step) import numpy as np x=np.array(_arrpoints(lo,hi,step)) y=np.array([value for value in ranges.values()]) maxy=max([value for value in ranges.values()]) medy=__roundup((maxy/2),1) if Plot.num_ax==4: ax_heat=Plot.ax3 ax_curve=Plot.ax4 elif Plot.num_ax==3: ax_heat=Plot.ax2 ax_curve=Plot.ax3 extent = [x[0]-(x[1]-x[0])/2., x[-1]+(x[1]-x[0])/2.,0,1] ax_heat.xaxis.set_minor_locator(ticker.AutoMinorLocator()) _heatmap=ax_heat.imshow(y[np.newaxis,:], cmap="plasma", aspect="auto", extent=extent) ax_heat.set_yticks([]) ax_heat.set_xlim(extent[0], extent[1]) axins = inset_axes(ax_heat, width="1%", # width = 5% of parent_bbox width height="100%", # height : 50% loc='center left', bbox_to_anchor=(-0.011, 0, 1, 1), bbox_transform=ax_heat.transAxes, borderpad=0, ) cbar = ax_heat.figure.colorbar(_heatmap, cax=axins, orientation='vertical', fraction=.25, ticks=[0,maxy]) cbar.ax.yaxis.set_ticks_position('left') cbar.ax.yaxis.set_tick_params(labelsize=9) ax_curve.plot(x,y) ax_curve.set_xlim(extent[0], extent[1]) ax_curve.xaxis.set_minor_locator(ticker.AutoMinorLocator()) ax_curve.set_yticks([0,medy,maxy]) ax_curve.yaxis.set_tick_params(labelsize=9) ax_curve.set_ylabel(f'Variant count per\n{step} bp', fontsize='small', labelpad=-0.4, va='bottom')
def __init__(self, parent=None, id: int = None, types: List[CurveType] = [], params: Dict = FIGURE_CONF) -> None: # Canvas Attributes self.fig, _ = plt.subplots(constrained_layout=True) super(MyCanvasItem, self).__init__(self.fig) self.id = id self.parameter = params.copy() self.parameter["Title"] = f"%s | %s" % (types[0].value, types[1].value) self.wg_canvas = parent self.ax_types = types self.ax_main = self.fig.axes[0] self.ax_sub = self.fig.axes[0].twinx() self.ax_sub.set_zorder(1) self.ax_main.set_zorder(2) self.ax_main.patch.set_visible(False) self.grid_status = [True, False] self.update_axis_info() self.apply_style() self.draggable_lines = [Draggable_lines( self, self.ax_main), Draggable_lines(self, self.ax_sub)] self.draggable_lines[0].set_visible(False) self.draggable_lines[1].set_visible(False) # Interation functions with canvas self.setAcceptDrops(True) # self.fig.canvas.mpl_connect('pick_event', self.handle_pick) self.fig.canvas.mpl_connect( 'button_press_event', self.handleDoubleClicked) self.fig.canvas.mpl_connect('button_press_event', self.handle_click) # Default Setting self.ax_main.format_coord = lambda x, y: "" self.ax_main.set_ylim(auto=False) self.ax_main.grid(linewidth='0.75', linestyle='-', color='black') self.ax_main.grid(which='minor', linewidth='0.5', linestyle=':', color='#808080') self.ax_main.yaxis.set_minor_locator(ticker.AutoMinorLocator(5)) self.ax_sub.set_visible(False) self.ax_sub.set_ylim(auto=False) self.ax_sub.grid(linewidth='0.75', color='#1f77b4', linestyle='dashed', dashes=(20, 10)) self.ax_sub.grid(which='minor', linewidth='0.5', color='#8fbbd9', linestyle='--', dashes=(10, 5)) self.ax_sub.yaxis.set_minor_locator(ticker.AutoMinorLocator(5)) self.set_grid_status() self.fig.set_constrained_layout_pads(w_pad=10/72., h_pad=10/72., hspace=0.5, wspace=0.5)
def spectrum(spec, color_ions=True, annotate_ions=True, ax=None): if ax is None: ax = plt.gca() max_intensity = spec.intensity.max() for mz, intensity, annotation in zip(spec.mz, spec.intensity, spec.annotation): ion_type = annotation.ion_type if annotation is not None else None color = colors.get(ion_type) if color_ions else colors.get(None) zorder = zorders.get(ion_type) ax.plot([mz, mz], [0, intensity / max_intensity], color=color, zorder=zorder) if annotate_ions and annotation is not None: ax.text(mz + 5, intensity / max_intensity + 0.02, str(annotation), color=color, zorder=5, rotation=90, rotation_mode='anchor') min_mz = max(0, math.floor(spec.mz[0] / 100 - 1) * 100) max_mz = math.ceil(spec.mz[-1] / 100 + 1) * 100 ax.set_xlim(min_mz, max_mz) ax.yaxis.set_major_formatter(mticker.PercentFormatter(xmax=1.)) ax.set_ylim(0, 1.15 if annotate_ions else 1.05) ax.xaxis.set_minor_locator(mticker.AutoLocator()) ax.yaxis.set_minor_locator(mticker.AutoLocator()) ax.xaxis.set_minor_locator(mticker.AutoMinorLocator()) ax.yaxis.set_minor_locator(mticker.AutoMinorLocator()) ax.grid(b=True, which='major', color='#9E9E9E', linestyle='--', linewidth=1.0) ax.grid(b=True, which='minor', color='#9E9E9E', linestyle='--', linewidth=0.5) ax.set_axisbelow(True) ax.tick_params(axis='both', which='both', labelsize='small') ax.set_xlabel('m/z') ax.set_ylabel('Intensity') return ax
def adjust(axis, title="", loc=0, minor=[True, False, False, False], xlim=[], ylim=[], xlabel="Time (s)", ylabel="", xVisible=True, yVisible=True, seperator=True): """ Adjust axis properties """ axis.set_title(title) if isinstance(loc, int): axis.legend(loc=loc) if minor[0]: # X ticks minorlocator axis.xaxis.set_minor_locator(ticker.AutoMinorLocator()) if minor[1]: # X minor axis axis.grid(which='minor', axis='x', color='tab:gray', linestyle=':') if minor[2]: # Y ticks minorlocator axis.yaxis.set_minor_locator(ticker.AutoMinorLocator()) if minor[3]: # Y minor axis axis.grid(which='minor', axis='y', color='tab:gray', linestyle=':') if minor != [False, False, False, False]: axis.grid(which='major') if xlim != []: if len(xlim) == 2: axis.set_xlim(xlim[0], xlim[1]) if len(xlim) == 3: axis.set_xlim(xlim[0], xlim[1]) axis.set_xticks(numpy.arange(xlim[0], xlim[1] + xlim[2], xlim[2])) if ylim != []: if len(ylim) == 2: axis.set_ylim(ylim[0], ylim[1]) if len(ylim) == 3: axis.set_ylim(ylim[0], ylim[1]) axis.set_yticks(numpy.arange(ylim[0], ylim[1] + ylim[2], ylim[2])) axis.set_xlabel(xlabel) axis.set_ylabel(ylabel) if not xVisible: plt.setp(axis.get_xticklabels(), visible=False) if not yVisible: plt.setp(axis.get_yticklabels(), visible=False) # use " " as thousand seperator if seperator: axis.yaxis.set_major_formatter( ticker.FuncFormatter( lambda x, pos: format(int(x), ",").replace(",", " ")))
def Histogram(self, y, title=' ', xLabel=' ', yLabel=' ', dump=False, **kwargs): """ Histogram plot Inputs: - bins = list of bin edges - y = 1D array Options: - title = plot title, string - xLabel = title of the x-axis, string - yLabel = title of the y-axis, string - dump = boolean, dump profile data in csv file - kwargs = keyword options associated with pandas.DataFrame.to_csv, such as: sep, header, na_rep, index,...etc Check doc. of "to_csv" for complete list of options """ ## the histogram of the data #fig = plt.figure(figsize=(18,10)) self._def_fig() self._ax = self._fig.add_subplot(111) density, bins = np.histogram(y, bins=50, normed=True, density=True) unity_density = density / density.sum() widths = bins[:-1] - bins[1:] # To plot correct percentages in the y axis self._ax.bar(bins[1:], unity_density, width=widths) formatter = ticker.FuncFormatter(lambda v, pos: str(v * 100)) self._ax.yaxis.set_major_formatter(formatter) self._ax.get_xaxis().set_minor_locator(ticker.AutoMinorLocator()) self._ax.get_yaxis().set_minor_locator(ticker.AutoMinorLocator()) self._ax.grid(b=True, which='major', color='w', linewidth=1.5) self._ax.grid(b=True, which='minor', color='w', linewidth=0.5) plt.ylabel(yLabel) plt.xlabel(xLabel) self._fig.show() if dump: self._dump_profile_data_as_csv(bins[1:], unity_density, title=title, xLabel=xLabel, yLabel=yLabel, **kwargs)
def _setspineslabels(self): self.ax1.spines['top'].set_visible(False) #equivalent to ax1.set_frame_on(False) self.ax1.spines['right'].set_visible(False) self.ax1.spines['left'].set_visible(False) self.ax1.xaxis.set_minor_locator(ticker.AutoMinorLocator()) self.ax1.axes.get_yaxis().set_visible(False) if self.ax2: self.ax2.spines['top'].set_visible(False) #equivalent to ax1.set_frame_on(False) self.ax2.spines['right'].set_visible(False) self.ax2.spines['left'].set_visible(False) self.ax2.xaxis.set_minor_locator(ticker.AutoMinorLocator()) self.ax2.axes.get_yaxis().set_visible(False)
def graph_std(climate, cities, w_length=1): """ Plot the std for a given city across the years. Args: climate: a climate object. city: a str or list of str of cities names in capital letters. w_length: compute the moving average of temperatures with specified window length of years. Retunrs: A seaborn lineplot of (14x6) inches of std temperatures vs years. """ years = climate.get_years() # Filtering the data frame by cities, months, days temps = climate.filter_by(cities=cities) # std value of the period temperatures remaining constant every year. y = np.array( [temps[temps.index.year == year].values.min() for year in years]) z = np.array( [temps[temps.index.year == year].values.max() for year in years]) # Computing the moving average and seting up the data frame. y = main.moving_average(y, w_length) z = main.moving_average(z, w_length) w = z - y df = pd.DataFrame({'YEAR': years, 'MIN': y, 'MAX': z, 'Delta': w}) # Minimal and Maximal temperatures after all the averages temp_min, temp_max = -30, 52 fig, ax = plt.subplots(figsize=(14, 6)) ax = sns.lineplot(x='YEAR', y='MIN', data=df, linewidth=4) ax = sns.lineplot(x='YEAR', y='MAX', data=df, linewidth=4) ax.fill_between(x='YEAR', y1=temp_min, y2=temp_max, data=df, alpha=0.25) ax.xaxis.set_major_locator(ticker.MultipleLocator(5)) ax.yaxis.set_major_locator(ticker.MultipleLocator(10)) ax.xaxis.set_minor_locator(ticker.AutoMinorLocator(5)) ax.yaxis.set_minor_locator(ticker.AutoMinorLocator(5)) ax.grid(which='major', color='#CCCCCC', linestyle='--') ax.grid(which='minor', color='#CCCCCC', linestyle=':') ax.set_xlim(min(df.YEAR), max(df.YEAR)) ax.set_ylim(temp_min, temp_max) ax.set_xlabel(None) ax.set_ylabel('Temperature (ºC)') # ax.set_title(title, size=20) ax.grid(axis='x', c='gray', ls='--')
def plotConnHistogram(val, **kw): ''' Plot a histogram of connection weights with some predetermined formatting. Parameters ---------- val : numpy array A 1D array of connetions. **kw Keyword arguments to the hist function. See code for some additional keyword arguments. ''' # keyword arguments kw['bins'] = kw.get('bins', 20) #kw['edgecolor'] = kw.get('edgecolor', 'none') ax = kw.pop('ax', plt.gca()) xlabel = kw.pop('xlabel', 'g (nS)') ylabel = kw.pop('ylabel', 'Count') title = kw.pop('title', '') locators = kw.pop('locators', {}) ylabelPos = kw.pop('ylabelPos', -0.2) globalAxesSettings(ax) n, _, _ = ax.hist(val, **kw) print(np.max(n)) ax.set_xlabel(xlabel) ax.text(ylabelPos, 0.5, ylabel, rotation=90, transform=ax.transAxes, va='center', ha='right') ax.set_title(title) # tick formatting x_major = locators.get('x_major', ti.MaxNLocator(3)) x_minor = locators.get('x_minor', ti.AutoMinorLocator(2)) y_major = locators.get('y_major', ti.LinearLocator(2)) y_minor = locators.get('y_minor', ti.AutoMinorLocator(4)) ax.xaxis.set_major_locator(x_major) ax.yaxis.set_major_locator(y_major) ax.xaxis.set_minor_locator(x_minor) ax.yaxis.set_minor_locator(y_minor) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) return ax
def plot_1d_sweep(data, ax, xlabel, ylabel, xticks=True, yticks=True, axis_setting='scaled', title='', **kwargs): '''Plot a 1D parameter Sweep. Parameters ---------- data : AggregateData Data to plot. The first (Y/rows) dimension will be ignored. ax : mpl.Axes Matplotlib axes. xlabel, ylabel : str X/Y label strings xticks, yticks : bool Whether to plot ticks and number on the X/Y axes. kwargs : dict Keyword arguments that will be passed on to the plot function. ''' plot_data, X, _ = data.getTrialData() X = X.flatten() logger_1d.info('min(data): %f', np.min(plot_data.flatten())) logger_1d.info('max(data): %f', np.max(plot_data.flatten())) globalAxesSettings(ax) ax.minorticks_on() if xlabel != "": ax.set_xlabel(xlabel, va='top') ax.xaxis.set_label_coords(0.5, -0.125) if ylabel != "": ax.set_ylabel(ylabel, ha='center') ax.yaxis.set_label_coords(-0.125, 0.5) ax.plot(X.flatten(), plot_data[0, :, :], 'o', color='g', markersize=5, markeredgecolor='white', **kwargs) if xlabel != "": ax.set_xlabel(xlabel, va='top') ax.xaxis.set_label_coords(0.5, -0.125) if ylabel != "": ax.set_ylabel(ylabel, ha='center') ax.yaxis.set_label_coords(-0.157, 0.5) ax.xaxis.set_ticks([X[0], X[-1]]) ax.xaxis.set_minor_locator(ti.AutoMinorLocator(6)) ax.yaxis.set_minor_locator(ti.AutoMinorLocator(6)) ax.axis(axis_setting) if not xticks: ax.xaxis.set_ticklabels([]) if not yticks: ax.yaxis.set_ticklabels([])
def drawConcurrentUsersPlot(axes, nb_users_list, stat_list, only_average=False): min_array = numpy.array([stat.minimum for stat in stat_list]) mean_array = numpy.array([stat.mean for stat in stat_list]) max_array = numpy.array([stat.maximum for stat in stat_list]) yerr_list = [stat.standard_deviation for stat in stat_list] yerr_lower = numpy.minimum(mean_array - min_array, yerr_list) yerr_upper = numpy.minimum(max_array - mean_array, yerr_list) axes.errorbar(nb_users_list, mean_array, yerr=[yerr_lower, yerr_upper], color='r', ecolor='b', label='Mean', elinewidth=2, fmt='D-', capsize=10.0) if not only_average: axes.plot(nb_users_list, min_array, 'yo-', label='Minimum') axes.plot(nb_users_list, max_array, 'gs-', label='Maximum') axes.set_xticks(nb_users_list) return (ticker.FixedLocator(nb_users_list), None, ticker.MaxNLocator(nbins=20), ticker.AutoMinorLocator())
def render_plot(file_path: str): # xaxis configuration: Major ticks every month, minor ticks every week (+ these can overlap). plt.gca().xaxis.set_remove_overlapping_locs(False) plt.gca().xaxis.set_major_locator(dates.MonthLocator()) plt.gca().xaxis.set_major_formatter(dates.DateFormatter('%Y-%m')) plt.gca().xaxis.set_minor_locator(dates.WeekdayLocator(byweekday=0)) # xaxis configuration: Customize tick labels alignment for a subjectively more readable result. for tick in plt.gca().get_xticklabels(): tick.set_ha('left') # yaxis configuration: Major ticks every hour, minor ticks every 10 minutes. plt.gca().yaxis.set_major_locator(ticker.MultipleLocator(1)) plt.gca().yaxis.set_minor_locator(ticker.AutoMinorLocator(6)) # yaxis configuration: Start at 0 to avoid displaying negative time. plt.ylim(bottom=0) # Grid configuration. plt.grid(b=True, which='major', linestyle='--') plt.grid(b=True, which='minor', linestyle=':', alpha=GRID_ALPHA) # Legend configuration. legend_elements = [] for k, v in SLEEP_TIME_TYPES.items(): legend_elements.append( lines.Line2D([0], [0], color=v['color'], label=v['label'])) plt.legend(handles=legend_elements) plt.xlabel('Date') plt.ylabel('Sleep time (h)') plt.savefig(file_path)
def plot(self, file): """ Plot energy convergence curve """ plt.figure() plt.plot([*self.__best_gener, self.generation], [*self.__best_curve, self.best_fit], color="#222222", label="Energy", lw=0.5) sciargs = {"style": "sci", "scilimits": (0, 0), "useMathText": True} ax = plt.gca() gargs = {"axis": "y", "ls": ":"} # Add minor locators ax.yaxis.set_minor_locator(tck.AutoMinorLocator()) # Add grids plt.grid(True, which="minor", lw=0.1, color="#CCCCCC", **gargs) plt.grid(True, which="major", lw=0.5, color="#AAAAAA", **gargs) # Use scientific notiation on x-axis plt.ticklabel_format(axis="x", **sciargs) # Use scientific notiation on y-axis plt.ticklabel_format(axis="y", **sciargs) plt.xlabel("Generation") plt.ylabel("Fitness") plt.legend() plt.savefig(file, dpi=300, transparent=True) plt.close()
def plot_rpr_curve(sor, params, compare=False, rp=[], save=False): # Defining Matplotlib Figure f = plt.figure(num=None, figsize=(9, 12)) sor_range = np.arange(sor.min() - 2, sor.max() + 2) rpr = get_rpr(sor_range, params) # Sub plot ax = f.add_subplot(111) if compare: # Plotting actual data plt.scatter(sor, rp, s=50, marker='o', label='Actual data') # Plotting calculated data plt.scatter(sor, get_rpr(sor, params), s=70, marker='x', label='Value calculated by equation') plt.plot(sor_range, rpr, c='g') # Semi-Log Plot plt.yscale("log") # Setting Plot Tick-values plt.yticks([0.01, 0.001, 0.01, 0.1, 1, 10, 100]) plt.xticks(np.arange(sor.min() // 10 * 10, 101, 10)) # Tick-Parameters ax.xaxis.set_minor_locator(ticker.AutoMinorLocator()) ax.tick_params(which='both', width=1, labelsize=14) ax.tick_params(which='major', length=6) ax.tick_params(which='minor', length=3, color='0.8') # Plot Title if compare: plt.title("Permeability Ratio Data\n (Actual vs Calculated)", {'fontsize': 20}) else: plt.title("Permeability Ratio Data", {'fontsize': 20}) # Plot Axes Labels axis_label = ["Oil Saturation (So) in persent(%)", "Kg/Ko"] xl = plt.xlabel(axis_label[0], fontsize=16) yl = plt.ylabel(axis_label[1], fontsize=16) if compare: # Legend Location plt.legend(loc="best") # Grid plt.grid(lw=1, ls='-', c="0.7", which='major') plt.grid(lw=1, ls='-', c="0.9", which='minor') #saving plot if save: plt.savefig("KoKgRatioVsSaturtion_curve.png") # Showing Final Plot plt.show()
def plot_box_plot(df, axis): df.columns = df.columns.swaplevel(0, 1) metrics = df.columns.levels[0] print 'metrics', metrics for i, c in enumerate(metrics): dd = df[c].copy() dd.columns = [mapping_dict_cols[a] for a in dd.columns] avg = dd['P-NET'].median() sns.set_style("whitegrid") order = list(dd.median().sort_values().index) dd = dd.melt() # ax = sns.boxplot(ax=axis[i], x="variable", y="value", data=dd, whis=np.inf, order=order, palette=my_pal, linewidth=1) flierprops = dict(marker='o', markersize=1, alpha=0.7) ax = sns.boxplot(ax=axis[i], x="variable", y="value", data=dd, whis=1.5, order=order, palette=my_pal, linewidth=1, flierprops=flierprops) ax.axhline(avg, ls='--', linewidth=1) ax.set_ylim([0.4, 1.05]) ax.set_ylabel(mapping_dict[c], fontproperties) ax.set_xlabel('') ax.set_xticklabels(ax.get_xticklabels(), rotation=30, horizontalalignment='right', fontsize=fontsize) ax.get_xaxis().set_minor_locator(ticker.AutoMinorLocator()) ax.tick_params(axis='both', which='major', labelsize=fontsize) ax.minorticks_off() ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.spines['left'].set_visible(False)