def _add_inner_title(ax, title, loc, size=None, **kwargs): if size is None: size = dict(size=pp.rcParams['legend.fontsize']) at = AnchoredText(title, loc=loc, prop=size, pad=0., borderpad=0.5, frameon=False, **kwargs) at.set_zorder(200) ax.add_artist(at) at.txt._text.set_path_effects([withStroke(foreground="w", linewidth=3)]) return at
def add_inner_title(ax, title, loc, size=None, **kwargs): from matplotlib.offsetbox import AnchoredText from matplotlib.patheffects import withStroke if size is None: size = dict(size=pp.rcParams["legend.fontsize"]) at = AnchoredText(title, loc=loc, prop=size, pad=0.0, borderpad=0.5, frameon=False, **kwargs) at.set_zorder(200) ax.add_artist(at) at.txt._text.set_path_effects([withStroke(foreground="w", linewidth=3)]) return at
def _(self, index, ax, kind='vawt', cm='seismic', ptype='seis'): data = self.data(index) handle = None if kind == 'vawt': wiggles(data.T, wiggleInterval=1, ax=ax) elif kind == 'img': handle = img(data.T, extent=[ self.startInline, self.endInline, self.startCrline, self.endCrline, ], ax=ax, cm=cm, ptype=ptype) ax.invert_yaxis() else: pass ax.get_figure().suptitle("Z slice: {}".format(index.value)) from matplotlib.offsetbox import AnchoredText z_text = AnchoredText(r"$\downarrow$Cross-line", loc=2, prop=dict(size=10), frameon=False, bbox_to_anchor=(0., 0.), bbox_transform=ax.transAxes) ax.add_artist(z_text) inline_text = AnchoredText(r"In-line $\rightarrow$ ", loc=1, prop=dict(size=10), frameon=False, bbox_to_anchor=(1., 0.), bbox_transform=ax.transAxes) ax.add_artist(inline_text) return handle
def add_inner_title(ax, title, loc, size=None, **kwargs): from matplotlib.offsetbox import AnchoredText from matplotlib.patheffects import withStroke if size is None: size = dict(size=plt.rcParams['ytick.labelsize']) at = AnchoredText(title, loc=loc, prop=size, pad=0., borderpad=0.5, frameon=False, **kwargs) ax.add_artist(at) at.txt._text.set_path_effects([withStroke(foreground="w", linewidth=2)]) return at
def plot_seismo_and_best_fit_curve(t: np.ndarray, x: np.ndarray, params: Tuple[float, float, float, float]): amplitude, dampening, phase, frequency = params fig, ax = get_base_plot() ax.plot(t, damped_oscillator(t, *params), label="Best fit curve") ax.plot(t, x, label="Seismogram") ax.legend() ax.set_title(r"Damped oscillation $x(t) = A * exp(-\delta t) * sin(\phi + \omega * t)$") param_string = "\n".join((r"$A = ${amplitude:.2e}".format(amplitude=amplitude), r"$\delta = ${dampening:.2f}".format(dampening=dampening), r"$\phi = ${phase:.2f}".format(phase=phase), r"$\omega = ${frequency:.2f}".format(frequency=frequency))) text = AnchoredText(param_string, loc="lower right") ax.add_artist(text) plt.show()
def add_inner_title(ax, title, loc, size=None, **kwargs): if size is None: size = dict(size=7) # size=plt.rcParams['legend.fontsize'] at = AnchoredText(title, loc=loc, prop=size, pad=0., borderpad=0.25, frameon=False, **kwargs) ax.add_artist(at) at.txt._text.set_path_effects( [withStroke(foreground="w", linewidth=3)]) return at
def add_annotation(self, s, loc='upper left', pad=0.4, borderpad=0., prop=None): if prop is None: prop = {"size": 18, "color": "k"} anchored_text = AnchoredText(s, loc=loc, pad=pad, borderpad=borderpad, frameon=False, prop=prop) self.ax.add_artist(anchored_text)
def add_inner_title(ax, title, loc, **kwargs): from matplotlib.offsetbox import AnchoredText from matplotlib.patheffects import withStroke # prop = dict(path_effects=[withStroke(foreground='w', linewidth=3)], # size=plt.rcParams['legend.fontsize']) prop = dict(size=plt.rcParams['legend.fontsize']) at = AnchoredText(title, loc=loc, prop=prop, pad=0., borderpad=0.5, frameon=False, **kwargs) ax.add_artist(at) return at
def fit_gaussian_peak(x, y, bin_size=1, display_offset=0): init_amplitude = np.sum(y) * bin_size init_mu = np.sum(y * x) / np.sum(y) init_sigma = np.sqrt(np.sum(y * (x - init_mu) ** 2) / np.sum(y)) popt, pcov = curve_fit(gauss, x, y, p0=[init_amplitude, init_mu, init_sigma]) var = popt var_err = np.sqrt(np.diagonal(pcov)) text = write_gaus_info(var, var_err) x_fit = np.linspace(x[0], x[-1], 1000) fig = plt.figure() gs = gridspec.GridSpec(2, 1, height_ratios=[3, 1]) ax0 = fig.add_subplot(gs[0]) ax0.plot(x + display_offset, y, 'b-', label='data') ax0.plot(x_fit + display_offset, gauss(x_fit, *popt), 'g--', label='fit') ax0.plot(x + display_offset, gauss(x, init_amplitude, init_mu, init_sigma), 'r*', label='Initial values') ax0.set_ylabel('count') ax0.legend(loc=2) text_gaus = 'y = A $\\frac{1}{\sigma \sqrt{2 \pi}} e^{-(\\frac{x-\mu}{\sigma})}$' anchored_text = AnchoredText(text, loc=6, frameon=False) anchored_text_gaus = AnchoredText(text_gaus, loc=1, frameon=False) ax0.add_artist(anchored_text) ax0.add_artist(anchored_text_gaus) ax1 = fig.add_subplot(gs[1], sharex=ax0) ax1.plot(x + display_offset, (y - gauss(x, *popt)) / y, marker='o', linestyle='None', color='black') ax1.axhline(0, color='gray', linestyle='dashed') ax1.set_ylabel('Residual') ax1.set_xlabel('Index') print('Peak fitted') return popt, pcov, fig
def plotPermDist(ax, dist, trueVal, pval): with sns.plotting_context('notebook'): sns.set(style="white", palette="muted", font_scale=1.2) sns.despine(left=True) _ = sns.distplot(dist, bins=25, ax=ax) ax.axvline(trueVal, color='r', linewidth=2, alpha=0.8, linestyle='--') ax.add_artist( AnchoredText('si={0:.3f}\np={1:.3f}'.format(trueVal, pval), loc='upper right', frameon=False)) _ = ax.set_xlabel('Spatial Information') _ = ax.set_ylabel('') ax.set_yticks([]) return ax
def visualise_peak(self, frq, y_max, peak_tupel, **kwargs): y_x = kwargs.get('y_x', None) y_y = kwargs.get('y_y', None) y_z = kwargs.get('y_z', None) rr = kwargs.get('rr', None) N = y_max.size #plt.xkcd() #HAHA! COMIC STYLE - XKCD fig, ax = plt.subplots(1) fig.suptitle('Maximum power spectrum with peak.', fontsize="large") # plotting the spectrum if y_y is not None: ax.plot(frq, 2.0 / N * np.abs(y_x[0:N / 2]), 'r', label='Power spectrum X') if y_y is not None: ax.plot(frq, 2.0 / N * np.abs(y_y[0:N / 2]), 'b', label='Power spectrum Y') if y_z is not None: ax.plot(frq, 2.0 / N * np.abs(y_z[0:N / 2]), 'g', label='Power spectrum Z') ax.plot(frq, 2.0 / N * np.abs(y_max[0:N / 2]), 'y', label='Maximum Power spectrum') ax.plot(peak_tupel[0], peak_tupel[1], 'rx', label='Peak') text = 'Peak = %f ; %f' % (peak_tupel[0], peak_tupel[1]) #ax.add_artist(anchored_text) if rr is not None: text += '\n' + 'RR = %f' % rr anchored_text = AnchoredText(text, loc=4, prop=dict(color='Black', size=9)) ax.add_artist(anchored_text) ax.set_xlabel('Frequency in Hz') ax.set_ylabel('Power spectrum density') ax.set_xlim([0.1, 0.6]) plt.legend(loc='best', fontsize=9)
def corr_plot(dataframe, fig_height=None, fig_width=None, **kwargs): """ Plot correlation matrix of a dataframe, and save to local directory. ---------------------------------------- :param dataframe: dataframe to be plot. :param fig_height: height of the figure to be plot, default=None. :param fig_width: width of the figure to be plot, default=None. :return: None """ corr_matrix = dataframe.corr() n = len(corr_matrix) fig, axes = plt.subplots(nrows=n, ncols=n, sharex='col') if fig_height is not None: fig.set_figheight(fig_height) if fig_width is not None: fig.set_figwidth(fig_width) subplot = 1 for col in corr_matrix.columns: for idx in corr_matrix.index: plt.subplot(n, n, subplot) ax = axes[corr_matrix.columns.get_loc(col)][ corr_matrix.index.get_loc(idx)] if col != idx: plt.scatter(dataframe[idx], dataframe[col], **kwargs) fit_X, fit_y = linear_fit(dataframe[idx], dataframe[col]) plt.plot(fit_X, fit_y, color='r') at = AnchoredText( round(corr_matrix[col][idx], 2), prop=dict(size=12), frameon=True, loc='upper left', ) at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2") ax.add_artist(at) else: plt.hist(dataframe[col], bins=10, edgecolor='black') if subplot % n == 1: plt.ylabel(col) else: plt.setp(ax.get_yticklabels(), visible=False) if subplot / n > n - 1: plt.xlabel(idx) else: plt.setp(ax.get_xticklabels(), visible=False) subplot += 1 plt.tight_layout() plt.savefig('corr_plot.png', dpi=300) return None
def add_correlation(data, x, y, method='pearson', signif=2, loc='upper left', fontfamily='Arial', ax=None, **kwargs): """Add correlation to a scatterplot Parameters ---------- data: DataFrame DataFrame with columns x and y, same data used to create the plot x: str x variable to correlate y: str y variable to correlate method: str, optional pearson or spearman signif: int, optional number of significant figures loc: string, optional location of label, passed to matplotlib.offsetbox.AnchoredText size: int, optional text size fontfamily: str, optional text font family ax: Axis object, optional Plot to add correlation to **kwargs Other key word arguments passed to text object Returns ------- matplotlib.axes.Axes """ r = calculate_correlation(data, x, y, method) label = 'r = ' + str(round(r[0], signif)) text = AnchoredText(label, loc=loc, frameon=False, prop=dict(fontfamily=fontfamily, **kwargs)) if ax is None: ax = plt.gca() ax.add_artist(text) return ax
def plot_reg_performance(df, density_bins=80): ''' Display true vs. predicted TBR in a density scatter plot. Requires a data frame with tbr and tbr_pred columns. If density_bins are None, then a regular (non-density-colored) plot is used. ''' xs = df['tbr'].to_numpy() ys = df['tbr_pred'].to_numpy() linreg = Ridge().fit(xs.reshape(-1, 1), ys.reshape(-1, 1)) ys_fit = linreg.predict(xs.reshape(-1, 1)) fig, ax = plt.subplots() if density_bins is None: ax.scatter(xs, ys, s=5, label='Data') else: density_scatter(xs, ys, ax=ax, bins=density_bins, s=5, label='Data') ax.plot(xs, xs, '--', c='k', linewidth=1, dashes=[5, 10], label='Ideal model') ax.plot(xs, ys_fit, '--', c='r', linewidth=1, dashes=[5, 10], label='Trained model') ax.set_xlabel('True TBR') ax.set_ylabel('Predicted TBR') ax.legend(loc='lower right') metric_text = '' # TODO: this is imperfect as there may be other non-input columns in the data frame in_columns = list(df.columns) in_columns.remove('tbr') in_columns.remove('tbr_pred') for init_metric in get_metric_factory().values(): metric = init_metric() if metric_text: metric_text += '\n' metric_value = metric.evaluate( df[in_columns], df['tbr'].to_numpy(), df['tbr_pred'].to_numpy()) metric_text += f'${metric.latex_name}$ = {metric_value:0.06f}' anchored_text = AnchoredText(metric_text, loc=2) ax.add_artist(anchored_text) return fig, ax
def titlebox(ax, text, color, bgcolor=None, size=8, boxsize="10%", pad=0.02, loc=10, **kwargs): """Sets a colored box about the title with the width of the plot""" divider = make_axes_locatable(ax) cax = divider.append_axes("top", size=boxsize, pad=pad) cax.get_xaxis().set_visible(False) cax.get_yaxis().set_visible(False) cax.spines['top'].set_visible(True) cax.spines['right'].set_visible(True) plt.setp(cax.spines.values(), color=color) if bgcolor != None: cax.set_facecolor(bgcolor) else: cax.set_facecolor('white') at = AnchoredText(text, loc=loc, frameon=False, prop=dict(size=size, color=color)) cax.add_artist(at)
def _add_label(self, label: str, value: float): ''' Adds a label and value to the plot's legend Args: label (str): name of the label value (int, float): value of the label ''' string = '{}: '.format(label) + '%.3f' % value if self._labels is None: self._labels = string else: self._labels += '\n' + string text_box = AnchoredText(self._labels, frameon=True, loc=4, pad=0.5) plt.setp(text_box.patch, facecolor='white', edgecolor='w') plt.gca().add_artist(text_box)
def gauss_fit_column(input_file): output_pdf2 = input_file[:-16] + 'fit_columns.pdf' with tb.open_file(input_file + '.h5', 'r+') as in_file_h5: data = np.sum(in_file_h5.root.HistOcc[:], axis=0) data1 = np.sum(in_file_h5.root.HistOcc[:], axis=0) data1 = np.concatenate(data1) y, amplitude, mu, sigma = 100, np.amax(data1), 33., 30. a, b, c, m = 0.1, 0.001, 2, 0.001 # a*x + b*x**2 + m xticks = np.linspace(0, 20, 9, endpoint=True) xtick_data = [1, 10, 20, 30, 40, 50, 60, 70, 80] columns = np.linspace(1, 81, 80, endpoint=False) coeff, _ = curve_fit(f=gauss, xdata=columns, ydata=data1, p0=(y, amplitude, mu, sigma, a, b, m), bounds=(0.001, 1000000)) # # print coeff[-4:] # print coeff[1],coeff[2],coeff[3] # print np.amax(data1) plt.clf() plt.title('Occupancy in x on second plane' ) #('Occupancy per column on second plane') plt.grid() plt.xlabel('mm') #('row') plt.ylabel('#') plt.bar(range(1, 81), data1, label='entries per column') plt.plot(columns, gauss(columns, *coeff), label='fit', color='crimson', linewidth=2.5, alpha=0.8) plt.xticks(xtick_data, xticks) plt.legend() ax = plt.axes() box = AnchoredText('mu = %.1f mm \nsigma = %.2f mm \nA = %.f' % (coeff[2] * 0.25, coeff[3] * 0.25, coeff[1]), loc=2) ax.add_artist(box) plt.savefig(output_pdf2) # print output_pdf2 return coeff[1] * coeff[3] * np.sqrt(2 * np.pi) / np.sum(data1)
def progress(i, y, ax1, ax2, n, test, fig): # if i==1: #style.use('fivethirtyeight') #fig = plt.figure() #ax1 = fig.add_subplot(1,1,1) #plt.ylabel('convergence') #plt.xlabel('iteration') # else: err_range = (np.amax(y) - np.amin(y)) / 2.0 #ax2.cla() ax1.errorbar(i, np.mean(y), yerr=err_range, fmt='o') if i != 0: #Artist.remove(ax1.texts) #fig.text.remove() #print(ax1.get_extents) [Artist.remove(txt) for txt in ax1.texts] [txt.set_visible(False) for txt in ax1.texts] #if i != 0: # textvar = ax1.texts #textvar.remove(True) #ax1.remove(textvar) #ax1.texts.set_visible(False) # [txt.set_visible(False) for txt in ax1.texts] #for txt in ax1.texts: #txt.set_visible(False) text_box = AnchoredText(np.amin(y), frameon=True, loc=1, pad=0.5) plt.setp(text_box.patch, facecolor='white', alpha=1) ax1.add_artist(text_box) #plot_text = ax1.text(3, 9, np.amin(y),bbox=dict(facecolor='white', alpha=1)) #plot_text._bbox_patch._mutation_aspect = 0.1 #plot_text.get_bbox_patch().set_boxstyle("square", pad=1) #ax2.text(n,4,np.amin(y),bbox=dict(facecolor='white', alpha=1)) ax2.plot(range(3), y, c=[0, 0, 0]) #ax2.xaxis.font(12) ax2.tick_params(labelsize='small') #fig.clf() #ax2.draw() #ax2.text() plt.pause(0.5) #time it waits for plot to update
def titlebox(ax, text, color, bgcolor=None, size=8, boxsize=0.1, pad=0.05, **kwargs): """ Sets a colored title box above the plot, spanning the entire plot width. Parameters ---------- ax : matplotlib axis object The axis on which you want to add the titlebox. text: str The title tect bgcolor: str or None The background color of the title box. Default is no color (blank). size: int Size of the text font boxsize: float [0, 1] Fraction of the total plot height to be occupied by the box. Default is 10% (0.1). pad: float The padding space between the title box and the top of the plot. """ boxsize = str(boxsize * 100) + '%' divider = make_axes_locatable(ax) cax = divider.append_axes("top", size=boxsize, pad=pad) cax.get_xaxis().set_visible(False) cax.get_yaxis().set_visible(False) cax.spines["top"].set_visible(False) cax.spines["right"].set_visible(False) cax.spines["bottom"].set_visible(False) cax.spines["left"].set_visible(False) plt.setp(cax.spines.values(), color=color) if bgcolor != None: cax.set_facecolor(bgcolor) else: cax.set_facecolor("white") at = AnchoredText(text, loc=10, frameon=False, prop=dict(size=size, color=color)) cax.add_artist(at)
def _build_plot(self, integr): super()._clean_frame() f = Figure(figsize=(5, 5), dpi=100) a = f.add_subplot() a.plot(integr.start_x, integr.start_y, "b") #a.spines['left'].set_position('zero') #a.spines['bottom'].set_position('zero') #a.spines['top'].set_visible(False) #a.spines['right'].set_visible(False) str_answ = "rectangle = {0}\ntrapezoid = {1}\nsimpson = {2}".format( integr.rectangle(), integr.trapezoid(), integr.simpson()) a.add_artist(AnchoredText(str_answ, loc=2)) canvas = FigureCanvasTkAgg(f) super()._destroy_objects.append(canvas._tkcanvas) canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
def field_count_hist(grp_df, rate_var, vol_var, title, xlab, filedesc): # Annotation Box Stats y = grp_df['YEAR'].mean() total_area = grp_df['Area_acres'].sum() total_vol = grp_df[vol_var].sum() m = total_vol / total_area.round(1) # Bins et_bins = np.linspace(bin_min, bin_max, ((bin_max - bin_min) / bin_size) + 1) # Make Figure font_size = 12 ann_font_size = 10 fig = plt.figure() ax = fig.add_subplot(111) ax.hist(grp_df[rate_var], bins=et_bins, align='mid', edgecolor='black') ax.set_title(title, size=font_size) ax.set_xlabel(xlab, size=font_size) ax.set_ylabel('Field Count', size=font_size) ax.set_xticks(np.arange(0, bin_max + (2 * bin_size), 2 * bin_size)) ax.tick_params(axis='x', labelsize=font_size) ax.tick_params(axis='y', labelsize=font_size) ymin, ymax = plt.ylim() # return the current ylim plt.ylim((ymin, ymax + ymax * 0.3)) # shift ymax for annotation space # Add mean vertical line ax.axvline(m, color='gray', linestyle='dashed', linewidth=1) # Add Annotation Text Box antext = ('Year {:.0f}\n' + 'Mean ET = {:.1f} ft\n' + 'Total Area = {:.1f} acres\n' + 'ET Volume = {:.1f} ac-ft').format(y, m, total_area, total_vol) at = AnchoredText(antext, prop=dict(size=ann_font_size), frameon=True, loc=2) at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2") ax.add_artist(at) # Save Figure file_name = '{:.0f}_{}_Fields'.format(y, filedesc) fig.tight_layout(pad=3) plt.savefig(os.path.join(output_folder, file_name), dpi=300) plt.close(fig) fig.clf() return True
def plotStats(self, ax, lines): """Make the stats box 'plot'. Parameters ---------- ax : `maplotlib.axes` Axes to use. lines : `list` of `str` The data to include in the text box """ text = "\n".join([line for line in lines]) stats_text = AnchoredText(text, loc="center", pad=0.5, prop=dict(size=14, ma="left", backgroundcolor="white", color="black", family='monospace')) ax.add_artist(stats_text) ax.axis('off')
def plot_fitted_curve(d, X,Y,output): fig = plt.figure() ax1 = fig.add_subplot(111) ax1.plot(X, Y, 'ro', markersize=0.5) ax1.plot(X, output[0], '--') ax1.plot(X, output[1]) ax1.set_ylabel(d['abbr']+' '+d['unit']) if output[2]>0.: # moves legend based on direction of trend loc=2 elif output[2]<0.: loc=1 txt = AnchoredText('RMSE='+str(output[3])+' '+d['unit']+'\n$r^2$='+str(output[4])+'%', loc=loc) ax1.add_artist(txt) plt.xticks(np.arange(0, len(X), 12), years) plt.savefig(savepath+d['species']+'_nonlin_regression.png') plt.close() return
def add_stamp(self, text=None, **kwargs): """Add common stamp with text. NOTE add_stamp cannot be used on a subplot that has been de-selected and then re-selected. It will write over existing text. """ if self.stamp != '': stamp = tex_join('\n', self.stamp, text) else: stamp = text if self.loc == 'inside': a_text = AnchoredText(tex_dollars(stamp), loc=2, frameon=False, **kwargs) plt.gca().add_artist(a_text) elif self.loc == 'outside': plt.gca().set_title(tex_dollars(stamp))
def AddAnchored(*args,**kwargs): """ Init definition: AnchoredText(self, s, loc, pad=0.4, borderpad=0.5, prop=None, **kwargs) Docstring: AnchoredOffsetbox with Text Init docstring: *s* : string *loc* : location code *prop* : font property *pad* : pad between the text and the frame as fraction of the font size. *borderpad* : pad between the frame and the axes (or bbox_to_anchor). other keyword parameters of AnchoredOffsetbox are also allowed. """ at = AnchoredText(*args,**kwargs) plt.gca().add_artist(at)
def add_inner_title(title, loc, ax=None, size=None, **kwargs): if ax == None: ax = plt.gca() from matplotlib.offsetbox import AnchoredText from matplotlib.patheffects import withStroke if size is None: size = dict(size=plt.rcParams['legend.fontsize']) at = AnchoredText(title, loc=loc, prop=size, pad=0.7, borderpad=0.01, frameon=False, **kwargs) ax.add_artist(at) at.txt._text.set_path_effects([withStroke(foreground="w", linewidth=3)]) return at
def plot_fitted_curve(d, X, Y, output, times, timestep, savepath=''): if timestep == 'H': t = 'hourly' s = 0.05 l = 0.2 elif timestep == 'M': t = 'monthly' s = 0.5 l = 2 fig = plt.figure() ax1 = fig.add_subplot(111) ax1.plot(times, Y, 'ro', markersize=s) ax1.plot(times, output[0], '--', linewidth=l) ax1.plot(times, output[1], 'k') ''' Uncomment to add linear trendline and print trend z = np.polyfit(X,Y,1) p = np.poly1d(z) ax1.plot(times, p(X), '--', color='k', alpha=0.7) if timestep == 'M': tt = 12 else: tt=8760 print('Linear trend = ', np.round(z[0]*tt,2), d['unit'], '$yr^{-1}$') ''' if 'abbr' in d: ax1.set_ylabel(d['abbr'] + ' (' + d['unit'] + ')') else: ax1.set_ylabel(d['longname'] + ' (' + d['unit'] + ')') if 'yscale' in d: yb, yt = ax1.get_ylim() if yt - yb > 1e4: ax1.set_yscale(d['yscale']) if output[2] > 0.: # moves legend based on direction of trend loc = 2 elif output[2] < 0.: loc = 1 txt = AnchoredText('RMSE=' + str(output[3]) + ' ' + d['unit'] + '\n$r^2$=' + str(output[4]) + '%', loc=loc) ax1.add_artist(txt) plt.savefig(savepath + d['variable'] + '/' + d['variable'] + '_' + t + '_mean.png', dpi=200) plt.close() return
def plot(df: pd.DataFrame, model: MaterialModel, filename: str): dfc = df.copy() dfc = dfc.sort_values(by="strain") cls = model.__class__ dfc_c = dfc.copy() dfc_c['stress'] = np.nan dfc_c['strain'] = dfc_c['strain'] * 4 / 3 dfc['comp_stress'] = dfc.apply(lambda row: model(row['strain'], row['strain_rate'], row['temperature']), axis=1) dfc_c['comp_stress'] = dfc_c.apply(lambda row: model(row['strain'], row['strain_rate'], row['temperature']), axis=1) dfc['stress'] = dfc['stress'] / 1e6 dfc['comp_stress'] = dfc['comp_stress'] / 1e6 dfc_c['stress'] = dfc_c['stress'] / 1e6 dfc_c['comp_stress'] = dfc_c['comp_stress'] / 1e6 grouped = dfc.groupby(['strain_rate', 'temperature']) grouped_c = dfc_c.groupby(['strain_rate', 'temperature']) ncols = 4 nrows = int(np.ceil(grouped.ngroups / ncols)) fig, axes = plt.subplots(nrows=nrows, ncols=ncols, figsize=(24, 18), sharey=False, facecolor='1.0') flattened_axes = axes.flatten() for ax in flattened_axes: ax.set_visible(False) for (key, ax) in zip(grouped.groups.keys(), axes.flatten()): ax.set_visible(True) grouped_c.get_group(key).plot(x='strain', y='comp_stress', c='red', ax=ax, label='Model') grouped.get_group(key).plot(x='strain', y='stress', ax=ax, label='Experiment') ax.set_title(labels[cls]) ax.set_xlabel('True strain') ax.set_ylabel('True stress [MPa]') box_text = 'Strain rate: {}s-1\nTemperature: {}K'.format(*key) text_box = AnchoredText(box_text, frameon=True, loc='lower left', pad=0.1) plt.setp(text_box.patch, facecolor='white', alpha=0.85) ax.add_artist(text_box) ax.legend(loc='lower right', ncol=1, framealpha=0.85, edgecolor='black', fancybox=False) plt.subplots_adjust(wspace=0.3, hspace=0.35) plt.savefig(filename) plt.close(fig)
def plot_graph(series_dict, xlab, threshold): fig, ax = plt.subplots(1, figsize=(16, 9)) j = 0 for country, series in series_dict.items(): x = np.arange(0, series.size) for i in x: if i != max(x): ax.plot( x[i:i + 2], series[i:i + 2], alpha=0.1 + 0.9 * float(i) / (series.size), color=cmap(j), label=country, ) else: ax.plot( x[i:i + 2], series[i:i + 2], alpha=0.1 + 0.9 * float(i) / (series.size), color=cmap(j), label=country, marker="o", markevery=[-1], ) ax.text(x[-1] + 0.5, series[-1], country, color=cmap(j)) j += 1 if j > cmap.N: j = 0 # ax.plot(x, series, label=country, marker="o", markevery=[-1]) # for line in ax.lines: # x, y = line.get_xydata()[-1] # ax.text(x + 0.5, y, line.get_label(), color=line.get_color()) at = AnchoredText( f"Source: https://github.com/CSSEGISandData/COVID-19, {dt.datetime.today()}", prop=dict(size=8), loc=4, ) ax.add_artist(at) ax.set_xlim(0, ax.get_xlim()[1]) ax.set_xlabel(f"Days after {threshold} {xlab}", fontsize=20) ax.set_ylabel(f"Number of {xlab}", fontsize=20) ax.set_yscale("log") plt.tight_layout() return fig, ax
def plot_lines(text, *args, **kwargs): patchopts = kwargs.pop('patchopts', None) sep = kwargs.pop('separator', u'\n') if not isinstance(text, str): linefmt = kwargs.pop('linefmt', u'{}') if isinstance(linefmt, str): fmt = linefmt linefmt = lambda *a: fmt.format(*a) lines = [] lst = [ linefmt(*line) if isinstance(line, (list, tuple)) else linefmt(line) for line in text ] text = sep.join(lst) header, footer = kwargs.pop('header', None), kwargs.pop('footer', None) if header: text = header + sep + text if footer: text = text + sep + footer if kwargs.pop('dump', False): print('Text:\n', text, sep='') # if bbox is None: bbox = dict(facecolor='white', alpha=1) outside = kwargs.pop('outside', None) loc = kwargs.pop('loc', None) if outside: loc = 'upper left' kwargs.setdefault('borderpad', 0.0) if isinstance(loc, str): loc = location_numbers[loc] if not loc: loc = 1 prop = kwargs.pop('prop', {}) ax = plt.gca() if outside: kwargs['bbox_to_anchor'] = outside kwargs['bbox_transform'] = ax.transAxes at = AnchoredText(text, loc, *args, prop=prop, **kwargs) if patchopts: at.patch.set(**patchopts) ax.add_artist(at) return at
def make_map(projection=ccrs.PlateCarree()): """ Generate fig and ax using cartopy input: projection output: fig and ax """ alpha = 0.5 subplot_kw = dict(projection=projection) fig, ax = plt.subplots(figsize=(9, 13), subplot_kw=subplot_kw) gl = ax.gridlines(draw_labels=True) gl.xlabels_top = gl.ylabels_right = False gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER # Put a background image on for nice sea rendering. ax.stock_img() # Create a feature for States/Admin 1 regions at 1:50m from Natural Earth states_provinces = cfeature.NaturalEarthFeature( category='cultural', name='admin_1_states_provinces_lines', scale='50m', facecolor='none') SOURCE = 'Natural Earth' LICENSE = 'public domain' ax.add_feature(cfeature.LAND, zorder=0, alpha=alpha) ax.add_feature(cfeature.COASTLINE, zorder=1, alpha=alpha) ax.add_feature(cfeature.BORDERS, zorder=1, alpha=2 * alpha) ax.add_feature(states_provinces, edgecolor='gray', zorder=1) # Add a text annotation for the license information to the # the bottom right corner. text = AnchoredText(r'$\mathcircled{{c}}$ {}; license: {}' ''.format(SOURCE, LICENSE), loc=4, prop={'size': 9}, frameon=True) ax.add_artist(text) ax.set_xlim(-132, -65) #lon limits ax.set_ylim(20, 55) #lat limits return fig, ax
def main(args): """ execute the code """ prs_true, truebeta = TruePRS(args.outprefix, args.bfile, args.h2, args.ncausal, args.plinkexe, args.causalmean, ) prs_true = liabilities(args.outprefix, args.h2, args.ncausal, prs_true, noenv=args.noenv) if args.GWAS: gwas = PlinkGWAS(args.plinkexe, args.bfile, args.outprefix, args.covs, args.nosex, args.threads, args.maxmem, validate=args.validate) merged = gwas.merge(truebeta, on='SNP') slope, intercept, r2, p_value, std_err = stats.linregress(merged.beta, merged.BETA) ax = merged.plot.scatter(x='beta', y='BETA', s=2, alpha=0.5) ax.add_artist(AnchoredText('$R^{2} = %.3f $' % r2**2, 2)) plt.tight_layout() plt.savefig('%s_truebetavsinferred.png'%(args.outprefix)) plt.close()
def plot_topology(self, circuits, equipments_multipoint, partition_by_station_dict, cities, destdir): (ymin, xmin, ymax, xmax) = equipments_multipoint.buffer(0.2).bounds sidebar_width = (xmax - xmin) * 0.4 sidebar_height = ymax - ymin self.root.info('Plotting Voltages %s' % str((ymin, xmin, ymax, xmax))) ax = plt.axes(projection=ccrs.PlateCarree()) ax.set_extent([xmin, xmax + sidebar_width, ymin, ymax]) for circuit in circuits: plt.plot(circuit.members[0].lon, circuit.members[0].lat, marker='s', markerfacecolor='black', linestyle="None", markersize=1, zorder=10, transform=ccrs.PlateCarree()) plt.plot(circuit.members[-1].lon, circuit.members[-1].lat, marker='s', markerfacecolor='black', linestyle="None", markersize=1, zorder=10, transform=ccrs.PlateCarree()) # ax.annotate(circuit.members[0].id, (circuit.members[0].lon, circuit.members[0].lat)) # ax.annotate(circuit.members[-1].id, (circuit.members[-1].lon, circuit.members[-1].lat)) for line in circuit.members[1:-1]: x, y = line.geom.xy plt.plot(x, y, color=self.color_dict[line.voltage.split(';')[0]], alpha=1, linewidth=self.thickness_dict[line.voltage.split(';')[0]], solid_capstyle='round', zorder=self.zorder_dict[line.voltage.split(';')[0]], transform=ccrs.PlateCarree()) if cities: for city in cities: if xmax > city.lon > xmin and ymax > city.lat > ymin: plt.plot(city.lon, city.lat, marker='s', markerfacecolor='#ff0000', linestyle="None", markersize=log(city.population, 10), zorder=1.5) if city.population >= 200000 and 'DEUTSCHLAND' not in city.name: label = city.name ax.annotate(label, (city.lon, city.lat)) # sidebar ax.add_patch(patches.Rectangle((xmax, ymin), sidebar_width, sidebar_height, facecolor="white", zorder=10)) im = image.imread('../util/logo2.png') ax.imshow(im, aspect='auto', extent=( xmax + sidebar_width / 4, xmax + 3 * sidebar_width / 4, ymax - sidebar_height / 3, ymax - sidebar_height / 2), zorder=11) text = AnchoredText('(c) OpenGridMap', loc=1, prop={'size': 12}, frameon=True, borderpad=0.8) text.set_zorder(11) ax.add_artist(text) plt.plot([], [], marker='s', markerfacecolor='black', linestyle="None", markersize=1, zorder=11, label='station') for voltage in self.color_dict.keys(): label = str(voltage) + 'V' plt.plot([], [], color=self.color_dict[voltage], lw=self.thickness_dict[voltage], zorder=11, label=label) l = plt.legend(numpoints=1, loc=4) l.set_zorder(11) plt.savefig(destdir + '/topology.png', bbox_inches='tight', pad_inches=0, dpi=600) ax.stock_img() plt.savefig(destdir + '/topology_geographical.png', bbox_inches='tight', pad_inches=0, dpi=600) countries = cfeature.NaturalEarthFeature( category='cultural', name='admin_0_countries', scale='10m', facecolor='none') states_provinces = cfeature.NaturalEarthFeature( category='cultural', name='admin_1_states_provinces_shp', scale='10m', facecolor='none') ax.add_feature(states_provinces, edgecolor='#ffffff', linewidth=0.3) ax.add_feature(countries, edgecolor='#333333', linewidth=0.5) kw = dict(resolution='50m', category='cultural', name='populated_places_simple') places_shp = shpreader.natural_earth(**kw) shp = shpreader.Reader(places_shp) for record, place in zip(shp.records(), shp.geometries()): if xmax > place.x > xmin and ymax > place.y > ymin: name = record.attributes['name'].decode('latin-1') plt.plot(place.x, place.y, marker='o', markerfacecolor='#ff0000', linestyle="None", markersize=2, zorder=11) ax.annotate(name, (place.x, place.y), fontsize=4) plt.savefig(destdir + '/topology_administrative.png', bbox_inches='tight', pad_inches=0, dpi=600) # Voronoi partitions if partition_by_station_dict: for station in partition_by_station_dict.keys(): partition_polygon = partition_by_station_dict[station] if hasattr(partition_polygon, 'geoms'): for polygon in partition_polygon: Plotter.plot_polygon(polygon, '#888888', zorder=2) else: Plotter.plot_polygon(partition_polygon, '#888888', zorder=2) plt.plot([], [], color='#888888', lw=2, zorder=5, label='Voronoi partitions') plt.savefig(destdir + '/topology_voronoi.png', bbox_inches='tight', pad_inches=0, dpi=600) plt.clf() plt.close()