def plot_extracellular(ax, lfp, ele_pos, num_x, num_y, time_pt): """Plots the extracellular potentials at a given potentials""" lfp *= 1000. lfp_max = np.max(np.abs(lfp[:, time_pt])) levels = np.linspace(-lfp_max, lfp_max, 16) im2 = plt.contourf(ele_pos[:,0].reshape(num_x, num_y), ele_pos[:,1].reshape(num_x, num_y), lfp[:,time_pt].reshape(num_x,num_y), levels=levels, cmap=plt.cm.PRGn) # cb = plt.colorbar(im2, extend='both') # tick_locator = ticker.MaxNLocator(nbins=9, trim=False, prune=None) # #tick_locator.bin_boundaries(-lfp_max, lfp_max) # cb.locator = tick_locator # #cb.ax.yaxis.set_major_locator(ticker.AutoLocator()) # cb.update_ticks() # cb.ax.set_title('$\mu$V') plt.title('Time='+str(time_pt/10.)+' ms') plt.xlabel('X ($\mu$m)') plt.ylabel('Y ($\mu$m)') plt.ylim(ymin=-2150,ymax=550) plt.xlim(xmin=-450,xmax=450) cbaxes = inset_axes(ax, width="50%", # width = 10% of parent_bbox width height="2%", # height : 50% loc=1, borderpad=1.5) cbar = plt.colorbar(cax=cbaxes, ticks=[-lfp_max,0.,lfp_max], orientation='horizontal', format='%.2f') cbar.ax.set_xticklabels([round(-lfp_max,2),str('0 $\mu V$'),round(lfp_max,2)]) return ax
def plot_eigenvalue_gaps( gaps, xlabel=r"$k$", ylabel=r"$\lambda_{k+1}-\lambda_k$", output="eigen_gap.pdf", colors=['b', 'r', 'g', 'c'], legend=[r'$\rho_{1}$', r'$\rho_{0.5}$', r'$\rho_{0.25}$'], marker=['o', '^', 'v']): fig = plt.figure(figsize=(fig_width, fig_height)) ax = fig.add_subplot(111) for i, g in enumerate(gaps): xs = range(1, len(g)+1) ax.plot(xs, g, color=colors[i], linestyle='-', marker=marker[i], linewidth=1.5, markersize=5, label=legend[i], alpha=0.7) ax.set_ylabel(r'$\lambda_{k+1} - \lambda_k$') ax.set_xlabel(r'$k$') ax.set_xlim([1, len(xs)]) ax.legend(loc=2, framealpha=.5, ncol=1) axins = inset_axes(ax, width="60%", height="60%", loc=1, borderpad=0.5) for i, g in enumerate(gaps): axins.plot(xs, g, color=colors[i], linestyle='-', marker=marker[i], linewidth=1.5, markersize=5, alpha=0.7) axins.set_xlim([5,12]) axins.set_ylim([0,0.006]) fig.savefig(output, bbox_inches='tight')
def plot_obs_pred(obs, pred, radius, loglog, ax = None, inset = False, sites = None): """Generic function to generate an observed vs predicted figure with 1:1 line""" if not ax: fig = plt.figure(figsize = (3.5, 3.5)) ax = plt.subplot(111) axis_min = 0.9 * min(list(obs[obs > 0]) + list(pred[pred > 0])) if loglog: axis_max = 3 * max(list(obs)+list(pred)) else: axis_max = 1.1 * max(list(obs)+list(pred)) macroecotools.plot_color_by_pt_dens(np.array(pred), np.array(obs), radius, loglog=loglog, plot_obj = ax) plt.plot([axis_min, axis_max],[axis_min, axis_max], 'k-') plt.xlim(axis_min, axis_max) plt.ylim(axis_min, axis_max) ax.tick_params(axis = 'both', which = 'major', labelsize = 6) if loglog: plt.annotate(r'$R^2$ = %0.2f' %macroecotools.obs_pred_rsquare(np.log10(obs[(obs != 0) * (pred != 0)]), np.log10(pred[(obs != 0) * (pred != 0)])), xy = (0.05, 0.85), xycoords = 'axes fraction', fontsize = 7) else: plt.annotate(r'$R^2$ = %0.2f' %macroecotools.obs_pred_rsquare(obs, pred), xy = (0.05, 0.85), xycoords = 'axes fraction', fontsize = 7) if inset: axins = inset_axes(ax, width="30%", height="30%", loc=4) if loglog: hist_mete_r2(sites[(obs != 0) * (pred != 0)], np.log10(obs[(obs != 0) * (pred != 0)]), np.log10(pred[(obs != 0) * (pred != 0)])) else: hist_mete_r2(sites, obs, pred) plt.setp(axins, xticks=[], yticks=[]) return ax
def plot_elbow_kernel( values, xlabel=r"$k$", #ylabel=r"$\textnormal{Tr}(Y^\top G \, Y)$", ylabel=r"$\log Q_{k+1} - \log Q_{k}$", output="elbow.pdf", colors=['b', 'r', 'g'], legend=[r'$\rho_{1}$', r'$\rho_{0.5}$', r'$\rho_{0.25}$'], marker=['o', '^', 'v']): fig = plt.figure(figsize=(fig_width, fig_height)) ax = fig.add_subplot(111) for i, g in enumerate(values): xs = range(1, len(g)+1) ax.plot(xs, g, color=colors[i], linestyle='-', marker=marker[i], linewidth=1.5, markersize=5, label=legend[i], alpha=0.7) ax.set_xlabel(xlabel) ax.set_ylabel(ylabel) ax.set_xlim([1, 12]) ax.legend(loc=2, framealpha=.5, ncol=1) axins = inset_axes(ax, width="60%", height="60%", loc=1) for i, g in enumerate(values): axins.plot(xs[4:], g[4:], color=colors[i], linestyle='-', marker=marker[i], linewidth=1.5, markersize=5, alpha=0.7) #axins.set_xlim([5,12]) #axins.set_ylim([19.9,20]) #axins.set_xticks([]) #axins.set_yticks([]) fig.savefig(output, bbox_inches='tight')
def draw_latent_factors(ax, A, x, y, w, h, space=1, max_abs_ylim=1, **kwargs): positions = [(x, y), (x, y + h + space), (x, y + 2 * h + 2 * space)] #max_abs_ylim = np.max(np.abs(A)) axes = [] for i, (x_, y_) in enumerate(positions): c = matplotlib.cm.Greys(0.5 + 0.5 * i / 2.) print(i, "latent", c) ia = inset_axes(ax, width="100%", height="100%", bbox_to_anchor=(x_, y_, w, h), bbox_transform=ax.transData, borderpad=0, loc=3) ia.set_xticks([]) ia.set_yticks([]) ia.axhline(0, c="#666666", linestyle=":", lw=0.5, ms=0) ia.plot(A.T[i], c=c, lw=2, ms=0) ia.set_ylabel(r"$\mathbf{{L}}_{0}$".format(i + 1), fontsize=10) ia.set_ylim(-max_abs_ylim, +max_abs_ylim) axes.append(ia) return axes
def plot_potential(ax, lfp, max_val, title): norm = cm.colors.Normalize(vmax=max_val, vmin=-max_val, clip=False) im = plt.imshow(lfp[::-1], aspect='auto', norm=norm, interpolation='nearest', cmap=plt.cm.PRGn) plt.xlim((2750, 4250)) plt.xticks(np.arange(3000, 5000, 1000), np.arange(300, 500, 100)) # plt.ylabel('Electrode depth ($\mu$m)') # plt.xlabel('Time (ms)') plt.title(title, fontweight="bold", fontsize=12) # plt.yticks(np.arange(28)) plt.gca().set_yticks(np.arange(28)) plt.gca().set_yticklabels(np.arange(1, 29)) for label in plt.gca().yaxis.get_ticklabels()[::2]: label.set_visible(False) # plt.xlim(xmin=2500, xmax=4500) # plt.colorbar(extend='both') cbaxes = inset_axes( ax, width="40%", # width = 10% of parent_bbox width height="3%", # height : 50% loc=1, borderpad=1) cbar = plt.colorbar(cax=cbaxes, ticks=[-max_val, 0., max_val], orientation='horizontal', format='%.2f') cbar.ax.set_xticklabels( [round(-max_val, 2), str('0 $\mu V$'), round(max_val, 2)]) return ax, im
def cyclic_colorbar(cmap, ax=None, internal_radius=.4, show_border=True, Nb_segments=100, bckgrnd_color='white', bckgrnd_alpha=.5, bckgrnd_radius=1.6, ticks=math_ticks): if ax == None: print 'toto' ax = inset_axes(gca(), width="25%", height="25%", loc=1) ax.axis('off') theta = linspace(0, 2 * pi, Nb_segments) external_radius = 1 for i in range(len(theta) - 1): segment = [z_tuple(external_radius * exp(1j * theta[i]))] segment += [z_tuple(external_radius * exp(1j * theta[i + 1]))] segment += [z_tuple(internal_radius * exp(1j * theta[i + 1]))] segment += [z_tuple(internal_radius * exp(1j * theta[i]))] segment += [segment[0]] ax.add_collection( PatchCollection([Polygon(segment)], facecolor=cmap(theta[i] / (2 * pi)), edgecolor='none')) if show_border: ax.plot(external_radius * cos(theta), external_radius * sin(theta), **border_style) ax.plot(internal_radius * cos(theta), internal_radius * sin(theta), **border_style) ticks_r = external_radius * array([1, 1 + ticks_length]) ticks_label_r = external_radius * (1 + 3 * ticks_length) for tick in ticks: theta = tick[0] ax.plot(ticks_r * cos(theta), ticks_r * sin(theta), **border_style) ax.text(ticks_label_r * cos(theta), ticks_label_r * sin(theta), tick[1], color=border_style['color'], ha='center', va='center') if bckgrnd_color != None: ax.add_collection( PatchCollection([Circle((0, 0), radius=bckgrnd_radius)], facecolor=bckgrnd_color, alpha=bckgrnd_alpha, zorder=0)) ax.axis('equal') ax.axis('off')
def _plot_legend(pos, colors, axis, bads, outlines='skirt'): """Helper function to plot color/channel legends for butterfly plots with spatial colors""" from mpl_toolkits.axes_grid.inset_locator import inset_axes bbox = axis.get_window_extent() # Determine the correct size. ratio = bbox.width / bbox.height ax = inset_axes(axis, width=str(30 / ratio) + '%', height='30%', loc=2) pos, outlines = _check_outlines(pos, outlines, None) pos_x, pos_y = _prepare_topomap(pos, ax) ax.scatter(pos_x, pos_y, color=colors, s=25, marker='.', zorder=0) for idx in bads: ax.scatter(pos_x[idx], pos_y[idx], s=5, marker='.', color='w', zorder=1) if isinstance(outlines, dict): outlines_ = dict([(k, v) for k, v in outlines.items() if k not in ['patch', 'autoshrink']]) for k, (x, y) in outlines_.items(): if 'mask' in k: continue ax.plot(x, y, color='k', linewidth=1)
def plot_obs_pred_sad(datasets, data_dir='./data/', radius=2): """Multiple obs-predicted plotter""" fig = plt.figure() num_datasets = len(datasets) rows = (3 if num_datasets in (5, 6) else 2) for i, dataset in enumerate(datasets): obs_pred_data = import_obs_pred_data(data_dir + dataset + '_obs_pred.csv') site = ((obs_pred_data["site"])) obs = ((obs_pred_data["obs"])) pred = ((obs_pred_data["pred"])) axis_min = 0.5 * min(obs) axis_max = 2 * max(obs) ax = fig.add_subplot(rows,2,i+1) macroecotools.plot_color_by_pt_dens(pred, obs, radius, loglog=1, plot_obj=plt.subplot(rows,2,i+1)) plt.plot([axis_min, axis_max],[axis_min, axis_max], 'k-') plt.xlim(axis_min, axis_max) plt.ylim(axis_min, axis_max) plt.subplots_adjust(left=0.2, bottom=0.12, right=0.8, top=0.92, wspace=0.29, hspace=0.21) # Create inset for histogram of site level r^2 values axins = inset_axes(ax, width="30%", height="30%", loc=4) hist_mete_r2(site, np.log10(obs), np.log10(pred)) plt.setp(axins, xticks=[], yticks=[]) plt.savefig('obs_pred_plots.png', dpi=400, bbox_inches = 'tight', pad_inches=0)
def plot_sub_boxes(ax, name=None): #Plot subboxes bbox_to_anchor = (-0.02, -0.08, 1, 0.95) if name == 'lstm': bbox_to_anchor = (-0.02, -0.28, 1, 0.95) subaxes = inset_axes(ax, width='50%', height='30%', bbox_to_anchor=bbox_to_anchor, bbox_transform=ax.transAxes, loc='upper right') plts = ax.lines #subaxes.set_ylim(bottom=0.85, top=0.95) for line in plts: x = line.get_xdata() y = line.get_ydata() half = len(x) * 3 // 4 subx = x[half:] suby = y[half:] subaxes.plot(subx, suby, color=line.get_color(), marker=line.get_marker(), markerfacecolor='none', linewidth=1.5) subaxes.set_ylim(bottom=subaxes.get_ylim()[0])
def setup_axes(fig, imx_c, imy_c, h): grid = axes_grid.Grid(fig, "111", nrows_ncols=(4, 3), #ngrids=11, direction='row', axes_pad=0.02, add_all=True, share_all=False, #False, share_x=False, share_y=False, label_mode='L', axes_class=(pywcsgrid2.Axes, {"header":h})) grid.set_aspect(True) # colorbar axes from mpl_toolkits.axes_grid.inset_locator import inset_axes axins = inset_axes(grid[0], width="5%", height="50%", loc=4, ) axins.axis[:].toggle(all=False) axins.axis["left"].toggle(all=True) axins.axis["left"].label.set_size(10) return grid, axins
def plot_eigenvalue_gaps( gaps, xlabel=r"$k$", ylabel=r"$\big|\lambda_{k+1}-\lambda_k\big|$", #ylabel=r"$\lambda_{k}$", output="eigen_gap.pdf", colors=['b', 'r', 'g', 'c'], legend=[r'$\rho_{1}$', r'$\widehat{\rho}_{2}$'], marker=['o', '^', 'v']): fig = plt.figure(figsize=(fig_width, fig_height)) ax = fig.add_subplot(111) for i, g in enumerate(gaps): xs = range(1, len(g)+1) ax.plot(xs, g, color=colors[i], linestyle='-', marker=marker[i], linewidth=1.5, markersize=5, label=legend[i], alpha=0.7) ax.set_ylabel(ylabel) ax.set_xlabel(xlabel) ax.set_xlim([1, len(xs)]) #ax.legend(loc=(0.18,0.6), framealpha=.5, ncol=1) ax.legend(loc=0, framealpha=.5, ncol=1) #with sns.axes_style("whitegrid"): axins = inset_axes(ax, width="50%", height="50%", loc=7, borderpad=1) for i, g in enumerate(gaps): axins.plot(xs[2:10], g[2:10], color=colors[i], linestyle='-', marker=marker[i], linewidth=1.5, markersize=5, alpha=0.7) axins.set_xlim([4,8]) axins.set_xticks([4,5,6,7,8]) #axins.set_yticks([]) #axins.set_ylim([0,0.006]) fig.savefig(output, bbox_inches='tight')
def plot_potential(ax, lfp, max_val, title): norm = cm.colors.Normalize(vmax=max_val, vmin=-max_val, clip=False) im = plt.imshow( lfp[::-1], aspect='auto', norm=norm, interpolation='nearest', cmap=plt.cm.PRGn) # plt.xticks(np.arange(3000, 5000, 1000), np.arange(300, 500, 100)) # plt.ylabel('Electrode depth ($\mu$m)') # plt.xlabel('Time (ms)') plt.title(title, fontweight="bold", fontsize=12) # plt.xlim(xmin=2500, xmax=4500) # plt.colorbar(extend='both') plt.gca().set_yticks(np.arange(28)) plt.gca().set_yticklabels(np.arange(1, 29)) for label in plt.gca().yaxis.get_ticklabels()[::2]: label.set_visible(False) cbaxes = inset_axes(ax, width="40%", # width = 10% of parent_bbox width height="3%", # height : 50% loc=1, borderpad=1) cbar = plt.colorbar( cax=cbaxes, ticks=[-max_val, 0., max_val], orientation='horizontal', format='%.2f') cbar.ax.set_xticklabels( [round(-max_val, 2), str('0 $\mu V$'), round(max_val, 2)]) return ax, im
def plot_gap(infile="experiments_data2/energy_synapse_gap.csv", output="gap.pdf", xlabel="$k$", ylabel1=r"$g_k-\left( g_{k+1} - \sigma_{k+1} \right)$", ylabel2=r"$J_k$"): df = pd.read_csv(infile, dtype=float) fig = plt.figure(figsize=(fig_width, fig_height)) # plot gaps ax = fig.add_subplot(111) xs = range(1,len(df["gap"].values)+1) #ax.errorbar(xs, df["gap"].values, yerr=df["var"].values, color="b", # linestyle='-', marker="o", markersize=5, elinewidth=.5, # capthick=0.5, linewidth=1.5, barsabove=False) ax.plot(xs, df["gap2"].values, color="b", linestyle="-", linewidth=1.5, marker="o", markersize=5) ax.plot(xs, [0]*len(xs), linestyle='--', color='k') ax.set_xlim([1, len(xs)]) ax.set_xlabel(xlabel) ax.set_ylabel(ylabel1) #with sns.axes_style("whitegrid"): axins = inset_axes(ax, width="50%", height="50%", loc=5, borderpad=1) axins.plot(xs[4:10], df["gap2"].values[4:10], color='b', linestyle='-', marker='o', linewidth=1.5, markersize=5, alpha=0.7) axins.set_xticks([5,6,7,8,9]) axins.set_yticks([]) fig.savefig(output, bbox_inches='tight')
def plot_kernel_response(lower_limit, upper_limit, vmag_limit, img, data, stars, outputfile): fig = plt.figure() ax = fig.add_subplot(1, 1, 1) ax.set_yscale('log') # draw visibility limits x = np.linspace(-5 + stars.vmag.min(), stars.vmag.max() + 5, 20) y1 = 10**(x * lower_limit[0] + lower_limit[1]) y2 = 10**(x * upper_limit[0] + upper_limit[1]) ax.plot(x, y1, c='red', label='lower limit') ax.plot(x, y2, c='green', label='upper limit') stars.plot.scatter( x='vmag', y='response', c=stars.visible.values, ax=ax, cmap=plt.cm.RdYlGn, vmin=0, vmax=1, label='Kernel Response', ) ax.set_xlim((-1, float(data['vmaglimit']) + 0.5)) ax.set_ylim(10**(lower_limit[0] * vmag_limit + lower_limit[1] - 1), 10**(-upper_limit[0] + upper_limit[1])) ax.set_ylabel('Kernel Response') ax.set_xlabel('Star Magnitude') ax_in = inset_axes(ax, width='40%', height='40%', loc='lower left') vmin = np.nanpercentile(img, 0.5) vmax = np.nanpercentile(img, 99.5) ax_in.imshow(img, cmap='gray', vmin=vmin, vmax=vmax) stars.plot.scatter( x='x', y='y', c='visible', cmap='RdYlGn', vmin=0, vmax=1, s=3, colorbar=False, ax=ax_in, ) ax_in.get_xaxis().set_visible(False) ax_in.get_yaxis().set_visible(False) leg = ax.legend(loc='lower right') leg.legendHandles[2].set_color('yellow') fig.tight_layout(pad=0) fig.savefig(outputfile, dpi=300) plt.close('all')
def plot_spectrogram(X, param, ax, colorbar = False, title = 'Spectrogram', dB= True, freqscale = 'log', dBMax = None, scaling = 'density', **kwargs): # TODO: correct t axis scala """ plot the spectrogram of a STFT """ sR = param['sR'] # PSD PSD, freq, t_i = stft_PSD(X, param, scaling = scaling, **kwargs) if dB: Z = 10*np.log10(PSD) - 20*np.log10(2e-5) else: Z = PSD # tempo e frequenza per questo plot é ai bordi df, __ = frequency_resolution(param['N'],sR) tR = param['R']/sR t = np.hstack([t_i[0]-tR/2, t_i + tR/2]) freq = np.hstack([ freq[0]-df/2, freq + df/2]) X , Y = np.meshgrid(t , freq) # plotting ax.set_title(title, fontsize = 10) #cmap = brewer2mpl.get_map('RdPu', 'Sequential', 9).mpl_colormap colormap=['#fff7f3','#fde0dd','#fcc5c0','#fa9fb5','#f768a1','#dd3497','#ae017e','#7a0177','#49006a'] cmap=LinearSegmentedColormap.from_list('YeOrRe',colormap) #cmap=LinearSegmentedColormap('RdPu',cmap) if dBMax==None: norm = matplotlib.colors.Normalize(vmin = 0) else: norm = matplotlib.colors.Normalize(vmin = 0, vmax=dBMax) # np.round(np.max(ZdB)-60 ,-1), vmax = np.round(np.max(ZdB)+5,-1), clip = False) spect = ax.pcolormesh(X, Y, np.transpose(Z), norm=norm, cmap = cmap) #legenda if colorbar: axcolorbar = inset_axes(ax, width="2.5%", # width = 10% of parent_bbox width height="100%", # height : 50% loc='upper left', bbox_to_anchor=(1.01, 0., 1, 1), bbox_transform=ax.transAxes, borderpad=0, ) axcolorbar.tick_params(axis='both', which='both', labelsize=8) ax.figure.colorbar(spect, cax = axcolorbar) # if freqscale =='log': ax.set_yscale('log') else: ax.set_yscale('linear') ax.xaxis.set_minor_locator(matplotlib.ticker.AutoMinorLocator()) ax.grid(which= 'both' ,ls="-", linewidth=0.15, color='#aaaaaa', alpha=0.3) ax.set_xlim(t.min(),t.max()) ax.set_ylim(freq.min(),freq.max()) if not colorbar: return(spect)
def draw_latent_scores(ax, scores, tau, x, y, axis_size, max_abs_lim=2.5, space=1, scatter_kwds=None, **kwargs): positions = [(x, y), (x + axis_size + space, y), (x, y + axis_size + space)] axes = [] for i, (x_, y_) in enumerate(positions): ia = inset_axes(ax, width="100%", height="100%", bbox_to_anchor=(x_, y_, axis_size, axis_size), bbox_transform=ax.transData, borderpad=0, loc=3) ia.set_xticks([]) ia.set_yticks([]) axes.append(ia) scatter_kwds = scatter_kwds or dict() scatter_kwds.setdefault("c", tau) scatter_kwds.setdefault("s", 5) axes[0].scatter(scores.T[0], scores.T[1], **scatter_kwds) axes[1].scatter(scores.T[2], scores.T[1], **scatter_kwds) axes[2].scatter(scores.T[0], scores.T[2], **scatter_kwds) label_kwds = dict(fontsize=10) axes[0].set_xlabel(r"$\mathbf{S}_1$", **label_kwds) axes[0].set_ylabel(r"$\mathbf{S}_2$", **label_kwds) axes[1].set_xlabel(r"$\mathbf{S}_3$", **label_kwds) axes[2].set_ylabel(r"$\mathbf{S}_3$", **label_kwds) padding = 0.20 for ax in axes: xlim = ax.get_xlim() ylim = ax.get_ylim() xptp = np.ptp(xlim) * (1 + padding) yptp = np.ptp(ylim) * (1 + padding) ax.set_xlim(np.mean(xlim) - 0.5 * xptp, np.mean(xlim) + 0.5 * xptp) ax.set_ylim(np.mean(ylim) - 0.5 * yptp, np.mean(ylim) + 0.5 * yptp) return axes
def plot_divergence_boxplot_as_inset_axes(divergence, cdf, curr_axes, orig, samplers): box_plot_loc = 4 if cdf else 1 bbox_anchor = (-.02, .12, 1, 1) if cdf else (-.02, -.09, 1, 1) in_axes = ins_loc.inset_axes(curr_axes, width="40%", # width = 40% of parent_bbox height="40%", # height : 40% of parent box loc=box_plot_loc, bbox_to_anchor=bbox_anchor, bbox_transform=curr_axes.transAxes, borderpad=0) plot_divergence_boxplot(samplers, orig, divergence, ax=in_axes, notch=1, grid=False) return in_axes
def plot_basics(data, data_inst, fig, units): from powerlaw import plot_pdf, Fit, pdf annotate_coord = (-.4, .95) ax1 = fig.add_subplot(n_graphs,n_data,data_inst) x, y = pdf(data, linear_bins=True) ind = y>0 y = y[ind] x = x[:-1] x = x[ind] ax1.scatter(x, y, color='r', s=.5) plot_pdf(data[data>0], ax=ax1, color='b', linewidth=2) from pylab import setp setp( ax1.get_xticklabels(), visible=False) if data_inst==1: ax1.annotate("A", annotate_coord, xycoords="axes fraction", fontproperties=panel_label_font) from mpl_toolkits.axes_grid.inset_locator import inset_axes ax1in = inset_axes(ax1, width = "30%", height = "30%", loc=3) ax1in.hist(data, normed=True, color='b') ax1in.set_xticks([]) ax1in.set_yticks([]) ax2 = fig.add_subplot(n_graphs,n_data,n_data+data_inst, sharex=ax1) plot_pdf(data, ax=ax2, color='b', linewidth=2) fit = Fit(data, xmin=1, discrete=True) fit.power_law.plot_pdf(ax=ax2, linestyle=':', color='g') p = fit.power_law.pdf() ax2.set_xlim(ax1.get_xlim()) fit = Fit(data, discrete=True) fit.power_law.plot_pdf(ax=ax2, linestyle='--', color='g') from pylab import setp setp( ax2.get_xticklabels(), visible=False) if data_inst==1: ax2.annotate("B", annotate_coord, xycoords="axes fraction", fontproperties=panel_label_font) ax2.set_ylabel(u"p(X)")# (10^n)") ax3 = fig.add_subplot(n_graphs,n_data,n_data*2+data_inst)#, sharex=ax1)#, sharey=ax2) fit.power_law.plot_pdf(ax=ax3, linestyle='--', color='g') fit.exponential.plot_pdf(ax=ax3, linestyle='--', color='r') fit.plot_pdf(ax=ax3, color='b', linewidth=2) ax3.set_ylim(ax2.get_ylim()) ax3.set_xlim(ax1.get_xlim()) if data_inst==1: ax3.annotate("C", annotate_coord, xycoords="axes fraction", fontproperties=panel_label_font) ax3.set_xlabel(units)
def plotmulticlus(cls, sizex, sizey): ncl = len(cls) fig, ax = plt.subplots(ncl, 2, figsize=[sizex, sizey], squeeze=False) plt.subplots_adjust(hspace=0.3, wspace=0.3) ni = 0 for i in range(ncl): cl = cls[i] # Left column: cluster distribution a0 = ax[i][0] d = pd.DataFrame({'clid': range(1, len(cl) + 1), 'n': map(len, cl)}) a0.scatter(d.iloc[:, 0], d.iloc[:, 1], marker='.', linewidth=0) a0.set_xlabel("Cluster ID") a0.set_ylabel("# Elements") ia0 = inset_axes(a0, width=1.3, height=0.9) ia0.set_xscale("log") ia0.set_yscale("log") ia0.set_xlabel("log Cluster ID") ia0.set_ylabel("log #Elements") ia0.scatter(d.iloc[:, 0], d.iloc[:, 1], marker='.', linewidth=0) # Right column: neighbor distribution a1 = ax[i][1] d2 = pd.DataFrame({ "clsize": d.n.groupby(d.n).unique(), "n": d.n.groupby(d.n).sum() }) a1.scatter(d2.iloc[:, 0], d2.iloc[:, 1], marker='.', linewidth=0) a1.set_xlabel("Cluster Size") a1.set_ylabel("# Elements") ia1 = inset_axes(a1, width=1.3, height=0.9) ia1.set_xscale("log") ia1.set_yscale("log") ia1.set_xlabel("log Cluster Size") ia1.set_ylabel("log # Elements") ia1.scatter(d.iloc[:, 0], d.iloc[:, 1], marker='.', linewidth=0) return
def plot_emp_vs_sim(study_id, data_dir = './out_files/', feas_type = 'partition', ax = None, inset = True, legend = False): """Plot of empirical and simulated mean-variance relationships for a given data set to help visually illustrate our results. Includes scatter plot of empirical data and its fitted line, scatter plot and fitted line for one set of simulated s_ij^2, 95 quantiles of s_ij^2 for each s_i^2 value, and the distribution of b in an inset. Input: study_id - ID of the data set of interest, in the form listed in Appendix A. """ if not ax: fig = plt.figure(figsize = (3.5, 3.5)) ax = plt.subplot(111) var_dat = get_var_sample_file(data_dir + 'taylor_QN_var_predicted_' + feas_type + '_full.txt') var_study = var_dat[var_dat['study'] == study_id] sim_var = [var_study[x][5] for x in xrange(len(var_study))] # take the first simulated sequence b_emp, inter_emp, r, p, std_err = stats.linregress(np.log(var_study['mean']), np.log(var_study['var'])) b_list = [] for k in xrange(len(var_study[0]) - 5): study_k = [var_study[x][k + 5] for x in xrange(len(var_study))] mean_k = [var_study['mean'][p] for p in xrange(len(var_study)) if study_k[p] != 0] study_k = [study_k[p] for p in xrange(len(study_k)) if study_k[p] != 0] b_k, inter, r, p, std_err = stats.linregress(np.log(mean_k), np.log(study_k)) if k == 0: b_0, inter_0 = b_k, inter b_list.append(b_k) ax.set_xscale('log') ax.set_yscale('log') plt.scatter(var_study['mean'], var_study['var'], s = 8, c = 'black', edgecolors='none') emp, = plt.plot(var_study['mean'], np.exp(inter_emp) * var_study['mean'] ** b_emp, '-', c = 'black', linewidth=1.5) if feas_type == 'partition': plot_col = '#228B22' else: plot_col = '#CD69C9' plt.scatter(var_study['mean'], sim_var, s = 8, c = plot_col, edgecolors='none') sim, = plt.plot(var_study['mean'], np.exp(inter_0) * var_study['mean'] ** b_0, '-', linewidth=1.5, c = plot_col) ax.tick_params(axis = 'both', which = 'major', labelsize = 9) ax.set_xlabel('Mean', labelpad = 4, size = 10) ax.set_ylabel('Variance', labelpad = 4, size = 10) if legend: plt.legend([emp, sim], ['Empirical', (feas_type.title()) + 's'], loc = 4, prop = {'size': 8}) if inset: axins = inset_axes(ax, width="30%", height="30%", loc=2) cov_factor = 0.2 xs = np.linspace(0.9 * min(b_list + [b_emp]), 1.1 * max(b_list + [b_emp]), 200) dens_b = comp_dens(b_list, cov_factor) b_dens, = plt.plot(xs, dens_b(xs), c = plot_col, linewidth=1.5) ymax = 1.1 * max(dens_b(xs)) plt.plot((b_emp, b_emp), (0, ymax), 'k-', linewidth = 1.5) plt.tick_params(axis = 'y', which = 'major', left = 'off', right = 'off', labelleft = 'off') plt.tick_params(axis = 'x', which = 'major', top = 'off', bottom = 'off', labelbottom = 'off') return ax
def plotSaturation(title, array, parameters, n, subplot=True, x_reverse=False, diagonal=False, plot_legend=False): fig = plt.figure(n) ax = fig.add_subplot(111) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.xaxis.set_ticks_position('bottom') ax.yaxis.set_ticks_position('left') cm = plt.get_cmap('gist_rainbow') ax.set_color_cycle([cm(1. * i / len(parameters)) for i in range(len(parameters))]) ax.plot(array[:, 0], array[:, 1:], linewidth=2.0) # ax.plot(array, linewidth=2.0) # ax.set_title(title+" VS Sample Number", fontname="Times New Roman") # ax.set_xlabel("Number of H3K4me3 Chip-Seq Sample", fontname="Times New Roman") # ax.set_ylabel(title, fontname="Times New Roman") ax.set_title(title, fontname="Times New Roman") ax.set_xlabel("Cutoff", fontname="Times New Roman") ax.set_ylabel("Coverage", fontname="Times New Roman") if plot_legend: legend = ax.legend(parameters, loc='center right', bbox_to_anchor=(1.3, 0.5)) if subplot: inside_ax = inset_axes(ax, width="35%", # width = 30% of parent_bbox height="35%", # height : 1 inch loc=5) inside_ax.set_color_cycle([cm(1. * i / len(parameters)) for i in range(0, len(parameters))]) if x_reverse: inside_ax.set_xlim(ax.get_xlim()[::-1]) inside_ax.plot(array[20:, 0], array[20:, 1:], linewidth=2.0) inside_ax.tick_params(labelsize=10) if x_reverse: ax.set_xlim(ax.get_xlim()[::-1]) if diagonal: ax.plot(array[:, 0], array[:, 0], linewidth=2.0, color="orange") if plot_legend: fig.savefig("./pictures/"+title, dpi=600, facecolor='w', edgecolor='w', orientation='portrait', bbox_extra_artists=(legend,), bbox_inches='tight') else: fig.savefig("./pictures/" + title, dpi=600, facecolor='w', edgecolor='w', orientation='portrait')
def plot_morp_ele(ax1, src_pos, ele_pos, pot, time_pt): """Plots the morphology midpoints and the electrode positions""" ax = plt.subplot(121, aspect='equal') plt.scatter(src_pos[:, 0], src_pos[:, 1], marker='.', alpha=0.7, color='k', s=0.6) plt.scatter(ele_pos[:, 0], ele_pos[:, 1], marker='x', alpha=0.8, color='r', s=0.9) # for tx in range(len(ele_pos[:,0])): # plt.text(ele_pos[tx, 0], ele_pos[tx, 1], str(tx)) ele_1 = 152 ele_2 = 148 plt.scatter(ele_pos[ele_1, 0], ele_pos[ele_1, 1], marker='s', color='r', s=14.) plt.scatter(ele_pos[ele_2, 0], ele_pos[ele_2, 1], marker='s', color='b', s=14.) plt.xlabel('X ($\mu$m)') plt.ylabel('Y ($\mu$m)') plt.title('Morphology and electrodes') plt.ylim(ymin=-2150, ymax=550) plt.xlim(xmin=-450, xmax=450) cbaxes = inset_axes(ax, width="50%", # width = 10% of parent_bbox width height="17%", # height : 50% loc=4, borderpad=2.2) plt.plot(np.arange(6000), pot[ele_1, :], color='r', linewidth=0.5) plt.plot(np.arange(6000), pot[ele_2, :], color='b', linewidth=0.5) dummy_line = np.arange(-0.5, 0.5, 0.1) plt.plot(np.zeros_like(dummy_line) + time_pt, dummy_line, color='black', linewidth=1) # ax=plt.gca() # ax.arrow(time_pt, -0.1, 0., 0.075, head_width=0.05, # head_length=0.05, width=0.1, # length_includes_head=True, fc='k', ec='k') plt.xlim((2750, 3500)) # 4250)) # plt.xticks(np.arange(3000, 5000, 1000), np.arange(300, 500, 100)) plt.xticks(np.arange(2750, 3750, 250), np.arange(275, 375, 25)) plt.ylim((-0.2, 0.12)) plt.yticks(np.arange(-0.2, 0.1, 0.1), np.arange(-0.2, 0.1, 0.1)) ax = plt.gca() ax.get_yaxis().tick_right() # set_tick_params(direction='in') # inset_plt = plt.plot(cax=cbaxes, # cbar = plt.colorbar(cax=cbaxes, ticks=[-lfp_max,0.,lfp_max], orientation='horizontal', format='%.2f') # cbar.ax.set_xticklabels([round(-lfp_max,2),str('0 $\mu V$'),round(lfp_max,2)]) return ax1
def doDistribution(players): Ytabu = np.load("ipad_tabu_best.npy") YRandom = np.load("humain_random.npy") Yhumain = [i["score"] for i in players] ntabu, binstabu, patches = plt.hist(Ytabu,bins=np.arange(20,80,0.5), cumulative=True, histtype="step",normed=True) nhumain, binshumain, patches = plt.hist(Yhumain,bins=np.arange(20,80,0.5), cumulative=True, histtype="step",normed=True) nrandom, binsrandom, patches = plt.hist(YRandom,bins=np.arange(20,200,1), cumulative=True, histtype="step",normed=True) plt.clf() fig = plt.figure(figsize=(10,5)) plt.hist(Ytabu,bins=5,normed=True, alpha=1.0,facecolor='#FF9600',edgecolor="white",label="Tabou") plt.hist(Yhumain,bins=5,normed=True, alpha=1.0,facecolor='#0074C0',edgecolor="white",label="Humain") plt.hist(YRandom,bins=20,normed=True, alpha=1.0,facecolor='gray',edgecolor="white",label=r"Al\'eatoire") ax = plt.gca() ax.set_xlabel("Distance",fontsize=25) ax.set_ylabel(r"Distribution",fontsize=25) leg =plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=34, mode="expand", borderaxespad=0.,fontsize=20) frame = leg.get_frame() frame.set_facecolor('white') frame.set_edgecolor('none') h=0.2 # ax.set_yticks(np.arange(0.0,1.0+h,h)) from mpl_toolkits.axes_grid.inset_locator import inset_axes inset_axes = inset_axes(ax, width="50%", # width = 30% of parent_bbox height=2.0, # height : 1 inch loc=1) plt.plot(np.arange(20,80-0.5,0.5),ntabu,linewidth=3,color="#FF9600") plt.plot(np.arange(20,80-0.5,0.5),nhumain,linewidth=3,color="#0074C0",alpha=1.0) sigma = np.std(YRandom) mu = np.mean(YRandom) print(norm.cdf(np.mean(Yhumain),mu,sigma)) plt.xlim([30,80]) plt.ylim([-0.001,1.001]) plt.yticks(np.arange(0.0,1.1,0.3)) plt.ylabel("Cumulative",fontsize=20) plt.savefig("../Pres_symposium/figures/distribution_human.pdf",bbox_inches='tight')
def place_inset_ax_in_data_coordinates(ax, bbox): """Return an ax inset in the given ax at the given bbox in data coordinates (bottom, left, width, height)""" bottom, left, width, height = bbox pixels_data_00 = ax.transData.transform([0, 0]) pixels_data_wh = ax.transData.transform([width, height]) iwidth, iheight = (pixels_data_wh - pixels_data_00) / ax.figure.dpi return inset_axes( ax, iwidth, iheight, loc=10, # means "center" bbox_to_anchor=[bottom, left, width, height], bbox_transform=ax.transData)
def _plot_legend(pos, colors, axis, bads, outlines): """Helper function to plot color/channel legends for butterfly plots with spatial colors""" from mpl_toolkits.axes_grid.inset_locator import inset_axes bbox = axis.get_window_extent() # Determine the correct size. ratio = bbox.width / bbox.height ax = inset_axes(axis, width=str(30 / ratio) + '%', height='30%', loc=2) pos_x, pos_y = _prepare_topomap(pos, ax) ax.scatter(pos_x, pos_y, color=colors, s=25, marker='.', zorder=1) for idx in bads: ax.scatter(pos_x[idx], pos_y[idx], s=5, marker='.', color='w', zorder=1) if isinstance(outlines, dict): _draw_outlines(ax, outlines)
def spatial_decay(M, field='E', indices=None): from mpl_toolkits.axes_grid.inset_locator import inset_axes import stephane.vortex.track as track fields, names, vmin, vmax, labels, units = std_fields() j = fields.index(field) Z = np.nanmean(getattr(M, field)[..., indices], axis=2) X, Y = [], [] for i in indices: tup = track.positions(M, i, field=field, indices=indices, step=1, sigma=10.) X.append(tup[1]) Y.append(tup[3]) X0, Y0 = np.nanmean(X), np.nanmean(Y) R, Theta = Smath.cart2pol(M.x - X0, M.y - Y0) R0 = M.param.Diameter Z_flat = np.ndarray.flatten(Z) R_flat = np.ndarray.flatten(R) Theta_flat = np.ndarray.flatten(Theta) phi = np.pi / 2 C = np.mod((Theta_flat + phi + np.pi) / 2 / np.pi, 1) cmap = matplotlib.cm.hot color = [matplotlib.colors.rgb2hex(cmap(c)[:3]) for c in C] fig, ax2 = graphes.set_fig(1, subplot=122) fig.set_size_inches(20, 6) ax2.scatter(R_flat, Z_flat, marker='o', facecolor=color, alpha=0.3, lw=0, cmap=cmap) Rth = np.arange(10 ** 1, 10 ** 2, 1.) # graphes.graphloglog(Rth, 10 ** 5 * (Rth / R0) ** -3.2, label='k--') # graphes.graphloglog(Rth, 5 * 10 ** 4 * (Rth / R0) ** -4.5, label='k--') graphes.set_axis(10 ** 0, 10 ** 2, 10 ** 2, 8 * 10 ** 4) figs = graphes.legende('$R$ (mm)', 'Energy (mm$^2$/s$^{2}$)', 'Spatial decay') fig, ax1 = graphes.set_fig(1, subplot=121) graphes.color_plot(M.x, M.y, Z, fignum=1, vmin=0, vmax=40000, subplot=121) graphes.colorbar(label=names[j] + ' (' + units[j] + ')') figs.update(graphes.legende('X (mm)', 'Y (mm)', 'Time averaged ' + field, cplot=True)) inset_ax = inset_axes(ax2, height="50%", width="50%", loc=3) inset_ax.pcolormesh(M.x / 10 - 10, M.y / 10 - 10, Theta, cmap=cmap) inset_ax.axis('off') return figs
def fig_power(po, pos, sig_loc, start=400, stop=405, Title='', asteriks=[90, 200]): global freq from mpl_toolkits.axes_grid.inset_locator import inset_axes ax1 = py.subplot(gs[pos[2]:pos[3], pos[0]:pos[1]]) set_axis(ax1, -0.1, 1.05, letter=po) labels = ['Olf. bulb', 'Thalamus', 'Visual ctrx'] for i in range(2, -1, -1): sig_loc[i] = notch_filter(sig_loc[i], Fs, np.arange(50, 450, 50)) freq, sp = welch(sig_loc[i], Fs, nperseg=1 * Fs) ax1.plot(freq, sp, lw=2, label=labels[i]) py.legend(loc=2, fontsize=15) ax1.text(asteriks[0], asteriks[1], '*', fontsize=20) ax1.text(160, 440, '?', fontsize=20) py.xlim(0, 260) py.ylim(0, 500) py.ylabel('power ($mv^2$)') ax1.spines['right'].set_visible(False) ax1.spines['top'].set_visible(False) py.xlabel('Frequency (Hz)') if po != 'B3': inset_axes = inset_axes(ax1, width="23%", height=1.0, loc=1) for n in range(3, sig_loc.shape[0]): sig_loc[n] = notch_filter(sig_loc[n], Fs, np.arange(50, 450, 50)) freq, sp = welch(sig_loc[n], Fs, nperseg=10 * Fs) py.plot(freq, sp, lw=0.7, color='green') py.ylim(0, 220) py.xlim(0, 260) py.xticks(fontsize=11) py.yticks(fontsize=11) # py.ylim(.1, 10e4) # py.yscale('log') # py.text(200,100, 'Olf. bulb propofol') py.xlabel('Frequency (Hz)') if po == 'B1': ax1.legend(loc='lower right', bbox_to_anchor=(1.2, 1.1), ncol=3, frameon=True, fontsize=15)
def add_insetimage(ax, height, loc, image): im_ax01 = inset_axes( ax, height=height, # set height width=height, # and width loc=loc, #facecolor='b' ) # center, you can check the different codes in plt.legend? im_ax01.imshow(image) #im_ax01.patch.set_facecolor('red') im_ax01.axis('off') #im_ax01.set_alpha(0.1) #im_ax01.set_facecolor('blue') return ax
def plot_eigenvalue_gaps( gaps, xlabel=r"$k$", ylabel=r"$\big|\lambda_{k+1}-\lambda_k\big|$", #ylabel=r"$\lambda_{k}$", output="eigen_gap.pdf", colors=['b', 'r', 'g', 'c'], legend=[r'$\rho_{1}$', r'$\widehat{\rho}_{2}$'], marker=['o', '^', 'v']): fig = plt.figure(figsize=(fig_width, fig_height)) ax = fig.add_subplot(111) for i, g in enumerate(gaps): xs = range(1, len(g) + 1) ax.plot(xs, g, color=colors[i], linestyle='-', marker=marker[i], linewidth=1.5, markersize=5, label=legend[i], alpha=0.7) ax.set_ylabel(ylabel) ax.set_xlabel(xlabel) ax.set_xlim([1, len(xs)]) #ax.legend(loc=(0.18,0.6), framealpha=.5, ncol=1) ax.legend(loc=0, framealpha=.5, ncol=1) #with sns.axes_style("whitegrid"): axins = inset_axes(ax, width="50%", height="50%", loc=7, borderpad=1) for i, g in enumerate(gaps): axins.plot(xs[2:10], g[2:10], color=colors[i], linestyle='-', marker=marker[i], linewidth=1.5, markersize=5, alpha=0.7) axins.set_xlim([4, 8]) axins.set_xticks([4, 5, 6, 7, 8]) #axins.set_yticks([]) #axins.set_ylim([0,0.006]) fig.savefig(output, bbox_inches='tight')
def plot_divergence_boxplot_as_inset_axes(divergence, cdf, curr_axes, orig, samplers): box_plot_loc = 4 if cdf else 1 bbox_anchor = (-.02, .12, 1, 1) if cdf else (-.02, -.09, 1, 1) in_axes = ins_loc.inset_axes( curr_axes, width="40%", # width = 40% of parent_bbox height="40%", # height : 40% of parent box loc=box_plot_loc, bbox_to_anchor=bbox_anchor, bbox_transform=curr_axes.transAxes, borderpad=0) plot_divergence_boxplot(samplers, orig, divergence, ax=in_axes, notch=1, grid=False) return in_axes
def plot_elbow_kernel( values, xlabel=r"$k$", #ylabel=r"$\textnormal{Tr}(Y^\top G \, Y)$", ylabel=r"$\log Q_{k+1} - \log Q_{k}$", output="elbow.pdf", colors=['b', 'r', 'g'], legend=[r'$\widehat{\rho}_{\sqrt{7}}$', r'$\rho_{1}$'], marker=['o', 's']): fig = plt.figure(figsize=(fig_width, fig_height)) ax = fig.add_subplot(111) for i, g in enumerate(values): xs = range(1, len(g) + 1) ax.plot(xs, g, color=colors[i], linestyle='-', marker=marker[i], linewidth=1.5, markersize=5, label=legend[i], alpha=0.7) ax.set_xlabel(xlabel) ax.set_ylabel(ylabel) ax.set_xlim([1, 12]) ax.legend(loc=2, framealpha=.5, ncol=1) with sns.axes_style("whitegrid"): axins = inset_axes(ax, width="50%", height="50%", loc=1) for i, g in enumerate(values): axins.plot(xs[2:10], g[2:10], color=colors[i], linestyle='-', marker=marker[i], linewidth=1.5, markersize=5, alpha=0.7) #axins.set_xlim([5,12]) #axins.set_ylim([19.9,20]) #axins.set_xticks([]) #axins.set_yticks([]) fig.savefig(output, bbox_inches='tight')
def colorbars(self, cax, pixels=200, orientation='horizontal', vstacked=False): """Draws a 3 colorbar legend into the cax axes object.""" from mpl_toolkits.axes_grid.inset_locator import inset_axes cax.set_yticks([]) cax.set_xticks([]) cax.patch.set_alpha(0) for s in cax.spines.values(): s.set_visible(False) if (orientation == 'vertical') ^ (not vstacked): width, height, locs = '100%', '23%', [9, 10, 8] else: width, height, locs = '25%', '100%', [6, 10, 7] axs = [inset_axes(cax, width, height, loc) for loc in locs] for i, ax in enumerate(axs): if i == 0: fun = lambda a: self.color(a, 0, 0) elif i == 1: fun = lambda b: self.color(0, b, 0) else: fun = lambda c: self.color(0, 0, c) img = np.array( [[fun(d) for d in np.linspace(0, self.maxdiff, pixels)]]) if orientation == 'vertical': img = img.transpose(1, 0, 2) ax.imshow(img, extent=[0, self.maxdiff, 0, self.maxdiff], origin='lower', aspect='auto', interpolation='bicubic') if orientation == 'vertical': ax.set_xticks([]) ax.set_ticks = ax.set_yticks ax.set_ticklabels = ax.set_yticklabels else: ax.set_yticks([]) ax.set_ticks = ax.set_xticks ax.set_ticklabels = ax.set_xticklabels ax.set_ticks([0, self.maxdiff]) ax.set_ticklabels(['same', 'max']) cax.subaxes = axs
def _plot_legend(pos, colors, axis, bads, outlines): """Helper function to plot color/channel legends for butterfly plots with spatial colors""" from mpl_toolkits.axes_grid.inset_locator import inset_axes bbox = axis.get_window_extent() # Determine the correct size. ratio = bbox.width / bbox.height ax = inset_axes(axis, width=str(30 / ratio) + '%', height='30%', loc=2) pos_x, pos_y = _prepare_topomap(pos, ax) ax.scatter(pos_x, pos_y, color=colors, s=25, marker='.', zorder=0) for idx in bads: ax.scatter(pos_x[idx], pos_y[idx], s=5, marker='.', color='w', zorder=1) if isinstance(outlines, dict): outlines_ = dict([(k, v) for k, v in outlines.items() if k not in ['patch', 'autoshrink']]) for k, (x, y) in outlines_.items(): if 'mask' in k: continue ax.plot(x, y, color='k', linewidth=1)
def fig_power(po, pos, sig_loc, start=400, stop = 405, Title = '', asteriks=[0,0]): global freq from mpl_toolkits.axes_grid.inset_locator import inset_axes ax1 = py.subplot(gs[pos[2]:pos[3], pos[0]:pos[1]]) py.title(Title, fontsize=15) set_axis(ax1, -0.1, 1.05, letter= po) labels= ['Olf. bulb', 'Thalamus', 'Visual ctrx'] for i in range(2,-1,-1): sig_loc[i] = notch_filter(sig_loc[i], Fs, np.arange(50, 450, 50)) freq, sp = welch(sig_loc[i], Fs, nperseg = 1*Fs) ax1.plot(freq, sp, lw=4, label=labels[i]) # ax1.text(asteriks[0], asteriks[1] , '*', fontsize=20) py.arrow(asteriks[0], asteriks[1], 0, -12, length_includes_head=True, clip_on = False, head_width=2, head_length=4) # py.ylim(.1, 10e4) py.ylim(0,220) py.xlim(0, 155) py.ylabel('power $mV^2$') ax1.spines['right'].set_visible(False) ax1.spines['top'].set_visible(False) py.xlabel('Frequency (Hz)') if po!='B1': inset_axes = inset_axes(ax1, width="23%", height=1.0, loc=1) for n in range(3,sig_loc.shape[0]): sig_loc[n] = notch_filter(sig_loc[n], Fs, np.arange(50, 450, 50)) freq, sp = welch(sig_loc[n], Fs, nperseg = 1*Fs) py.plot(freq, sp, lw=2, color='green') py.ylim(0,220) py.xlim(0,155) py.xticks(fontsize=11) py.yticks(fontsize=11) # py.ylim(.1, 10e4) # py.yscale('log') # py.text(200,100, 'Olf. bulb propofol') py.xlabel('Frequency (Hz)') if po=='B1': ket = mpatches.Patch(color='green', label='Olf. bulb') kx = mpatches.Patch(color='orange', label='Thalamus LGN') gam = mpatches.Patch(color='blue', label='Visual cortex') ax1.legend(loc='lower right', bbox_to_anchor=(1.2, .7), handles=[ket,kx,gam], ncol=1, frameon = True, fontsize = 15)
def plot_extracellular(ax, lfp, ele_pos, num_x, num_y, time_pt): """Plots the extracellular potentials at a given potentials""" lfp *= 1000. lfp_max = np.max(np.abs(lfp[:, time_pt])) levels = np.linspace(-lfp_max, lfp_max, 16) im2 = plt.contourf(ele_pos[:, 0].reshape(num_x, num_y), ele_pos[:, 1].reshape(num_x, num_y), lfp[:, time_pt].reshape(num_x, num_y), levels=levels, cmap=plt.cm.PRGn) # cb = plt.colorbar(im2, extend='both') # tick_locator = ticker.MaxNLocator(nbins=9, trim=False, prune=None) # #tick_locator.bin_boundaries(-lfp_max, lfp_max) # cb.locator = tick_locator # #cb.ax.yaxis.set_major_locator(ticker.AutoLocator()) # cb.update_ticks() # cb.ax.set_title('$\mu$V') plt.title('Time=' + str(time_pt / 10.) + ' ms') plt.xlabel('X ($\mu$m)') plt.ylabel('Y ($\mu$m)') plt.ylim(ymin=-2150, ymax=550) plt.xlim(xmin=-450, xmax=450) cbaxes = inset_axes( ax, width="50%", # width = 10% of parent_bbox width height="2%", # height : 50% loc=1, borderpad=1.5) cbar = plt.colorbar(cax=cbaxes, ticks=[-lfp_max, 0., lfp_max], orientation='horizontal', format='%.2f') cbar.ax.set_xticklabels( [round(-lfp_max, 2), str('0 $\mu V$'), round(lfp_max, 2)]) return ax
def plot_eigenvalue_gaps( gaps, xlabel=r"$k$", ylabel=r"$\lambda_{k+1}-\lambda_k$", output="eigen_gap.pdf", colors=['b', 'r', 'g', 'c'], legend=[r'$\rho_{1}$', r'$\rho_{0.5}$', r'$\rho_{0.25}$'], marker=['o', '^', 'v']): fig = plt.figure(figsize=(fig_width, fig_height)) ax = fig.add_subplot(111) for i, g in enumerate(gaps): xs = range(1, len(g) + 1) ax.plot(xs, g, color=colors[i], linestyle='-', marker=marker[i], linewidth=1.5, markersize=5, label=legend[i], alpha=0.7) ax.set_ylabel(r'$\lambda_{k+1} - \lambda_k$') ax.set_xlabel(r'$k$') ax.set_xlim([1, len(xs)]) ax.legend(loc=2, framealpha=.5, ncol=1) axins = inset_axes(ax, width="60%", height="60%", loc=1, borderpad=0.5) for i, g in enumerate(gaps): axins.plot(xs, g, color=colors[i], linestyle='-', marker=marker[i], linewidth=1.5, markersize=5, alpha=0.7) axins.set_xlim([5, 12]) axins.set_ylim([0, 0.006]) fig.savefig(output, bbox_inches='tight')
def inset_hist_fig(fig, outer_ax, v, size, loc, ids=None): ''' Inset histogram into the outer_ax at location. Params: fig - figure outer_ax - Main axes v - array of values size - percent of parent fig size [width, height] loc - quadrant location Return: fig - The main figure with inset figure ''' in_axes = inset_axes(outer_ax, width=size[0], height=size[1], loc=loc) #in_axes.patch.set_alpha(0.6) plot_hist(in_axes, v, bins=200, title=r'Distribution', ids=ids) return fig
def add_inset_box(current_event, ax): """Add an inset box to the lightcurve box giving a zoom-in around a selected feature. Based on code by E. Bachelet """ inset_axfig1 = inset_axes(ax, width="25%", height="40%", bbox_to_anchor=(-0.35, -0.2, 1.0, 1.2), borderpad=5, bbox_transform=ax.transAxes) microloutputs.LM_plot_model(current_event.fits[0], inset_axfig1) microloutputs.LM_plot_align_data(current_event.fits[0], inset_axfig1) inset_axfig1.legend_.remove() inset_axfig1.texts[0].set_visible(False) x1, x2, y1, y2 = 2458225.0, 2458250.0, 13.25, 11.0 # specify the limits inset_axfig1.set_xlim(x1, x2) # apply the x-limits inset_axfig1.set_ylim(y1, y2) # apply the y-limits patch, pp1, pp2 = mark_inset(ax, inset_axfig1, loc1=2, loc2=4, fc="none", ec="0.5") pp1.loc1 = 1 pp1.loc2 = 3 pp2.loc1 = 4 pp2.loc2 = 2 inset_axfig1.get_xaxis().get_major_formatter().set_useOffset(False) #inset_axfig1.set_xticks([2457084,2457085.2]) inset_axfig1.tick_params(axis='both', labelsize=10) plt.xticks(rotation=30) plt.grid()
def pl_inset_title_box(ax,title,bwidth="20%",location=1): """ Function that puts title of subplot in a box :ax: Name of matplotlib axis to add inset title text box too :title: 'string to put inside text box' :returns: @todo """ axins = inset_axes(ax, width=bwidth, # width = 30% of parent_bbox height=.30, # height : 1 inch loc=location) plt.setp(axins.get_xticklabels(), visible=False) plt.setp(axins.get_yticklabels(), visible=False) axins.set_xticks([]) axins.set_yticks([]) axins.text(0.5,0.3,title, horizontalalignment='center', transform=axins.transAxes,size=10) return
def plot_csd(ax, lfp, max_val, title, start_t, end_t): norm = cm.colors.Normalize(vmax=max_val, vmin=-max_val, clip=False) im = plt.imshow(lfp[::-1], aspect='auto', norm=norm, interpolation='nearest', cmap=plt.cm.bwr_r) #plt.xlim((2750, 4250)) plt.xticks(np.arange(3000-start_t, 5000-start_t, 1000), np.arange(300, 500, 100)) #plt.ylabel('Electrode depth ($\mu$m)') plt.xlabel('Time (ms)') plt.gca().yaxis.set_major_locator(plt.NullLocator()) plt.title(title)#, fontweight="bold", fontsize=12) #plt.yticks(np.arange(28)) # plt.gca().set_yticks(np.arange(28)) # plt.gca().set_yticklabels(np.arange(1,29)) for label in plt.gca().yaxis.get_ticklabels()[::2]: label.set_visible(False) #plt.xlim(xmin=2500, xmax=4500) #plt.colorbar(extend='both') cbaxes = inset_axes(ax, width="40%", # width = 10% of parent_bbox width height="3%", # height : 50% loc=1, borderpad=1 ) cbar = plt.colorbar(cax=cbaxes, ticks=[-max_val,0.,max_val], orientation='horizontal', format='%.2f') cbar.ax.set_xticklabels(['source',str('0'),'sink']) return ax, im
def plot_gap(infile="experiments_data2/energy_synapse_gap.csv", output="gap.pdf", xlabel="$k$", ylabel1=r"$g_k-\left( g_{k+1} - \sigma_{k+1} \right)$", ylabel2=r"$J_k$"): df = pd.read_csv(infile, dtype=float) fig = plt.figure(figsize=(fig_width, fig_height)) # plot gaps ax = fig.add_subplot(111) xs = range(1, len(df["gap"].values) + 1) #ax.errorbar(xs, df["gap"].values, yerr=df["var"].values, color="b", # linestyle='-', marker="o", markersize=5, elinewidth=.5, # capthick=0.5, linewidth=1.5, barsabove=False) ax.plot(xs, df["gap2"].values, color="b", linestyle="-", linewidth=1.5, marker="o", markersize=5) ax.plot(xs, [0] * len(xs), linestyle='--', color='k') ax.set_xlim([1, len(xs)]) ax.set_xlabel(xlabel) ax.set_ylabel(ylabel1) #with sns.axes_style("whitegrid"): axins = inset_axes(ax, width="50%", height="50%", loc=5, borderpad=1) axins.plot(xs[4:10], df["gap2"].values[4:10], color='b', linestyle='-', marker='o', linewidth=1.5, markersize=5, alpha=0.7) axins.set_xticks([5, 6, 7, 8, 9]) axins.set_yticks([]) fig.savefig(output, bbox_inches='tight')
def plotGraphStats(fileNames): """Import and plot data from c++ program's output""" nDataFig = plt.figure(len(fileNames)+1) nDataAx = nDataFig.add_subplot(111) nData = 0 haveGraphStats = False plotIndividuals = True i = 0 for fileName in fileNames: pathToFile = os.path.realpath(fileName) toPlot = np.genfromtxt(pathToFile, delimiter = ',') if "convergenceData" in fileName: #runs per step rps = 10 nSteps = toPlot.shape[0]/rps fig = plt.figure(); ax = fig.add_subplot(111); for i in range(nSteps): if toPlot[i*rps, 1] == 0.482: toPlot[i*rps:(i+1)*rps, 1] = 0 xData = [sum(toPlot[i*rps:(i+1)*rps, 1])/rps for i in range(nSteps)] yData = [sum(toPlot[i*rps:(i+1)*rps, 0])/rps for i in range(nSteps)] xMax = 1.0*np.max(xData) yMax = 1.0*np.max(yData) xUpLim = xMax yUpLim = 1000000 ax.scatter(xData, yData, c='r', s=36) ax.set_xlabel('Projection interval') ax.set_ylabel('Steps to consensus (log scale)') ax.set_yscale('log') ax.set_ylim((10000, yUpLim)) ax.set_xlim((0, xMax)) insets = [] #copy list to allow modifications fileList = fileNames fileList.remove(fileName) for i in range(nSteps): for f in fileList: #if have graphstats with same projection step, plot in subplot if "graphStats" and str(xData[i]) in f: pathToFile = os.path.realpath(f) toPlotInset = np.genfromtxt(pathToFile, delimiter = ',') insets.append(insetAxes.inset_axes(ax, width="50%", height="50%", loc=3, bbox_to_anchor=(xData[i]/xMax, np.log10(yData[i])/np.log10(yUpLim), 0.4, 0.4), bbox_transform=ax.transAxes)) insets[i].set_xticks([]) insets[i].set_yticks([]) insets[i].plot(toPlotInset[:,1], toPlotInset[:,2]) break plt.show(fig) #don't do individual plotting right now if ("graphstats" in fileName) & (plotIndividuals): haveGraphStats = True paramstr = fileName us = paramstr.find("_") paramstr = paramstr[us+1:] params = {} while us > 0: us = paramstr.find("_") us2 = paramstr.find("_", us+1) params[paramstr[:us]] = float(paramstr[us+1:us2]) if "initDist" in paramstr[:us]: period = paramstr.find(".", us2+1) period2 = paramstr.find(".", period+1) params[paramstr[:us]] = [float(paramstr[us+1:us2]), float(paramstr[us2+1:period2])] us = -1 else: paramstr = paramstr[us2+1:] for key in params: if("initDist" not in key): if(params[key] % 1 == 0): params[key] = int(params[key]) print params alpha = params['alpha'] nData = nData + 1 i = i + 1 scaleUp = 16.0/15.0 scaleDown = 14.0/15.0 #get graph limits l0Low = min(toPlot[:,0])*scaleDown l0Up = max(toPlot[:,0])*scaleUp l1Low = min(toPlot[:,1])*scaleDown l1Up = max(toPlot[:,1])*scaleUp l2Low = min(toPlot[:,2])*scaleDown l2Up = max(toPlot[:,2])*scaleUp nSteps = toPlot.shape[0] f1 = plt.figure(i) ax2 = f1.add_subplot(211, ylabel="Number conflicting edges") ax2.plot(toPlot[:,0],toPlot[:,2], '-', color="#47D147") ax2.set_ylim([l2Low, l2Up]) ax2.set_xlim([0,nSteps]) ax1 = f1.add_subplot(212, sharex=ax2, ylabel="Minority fraction", xlabel="Time") ax1.plot(toPlot[:,0], toPlot[:,1], '-', color="#70AAFF") ax1.set_ylim([l1Low,l1Up]) plt.setp(ax2.get_xticklabels(), visible=False) plt.subplots_adjust(hspace=0) saveFilename = fileName[:-4] + "_fig1" + ".png" plt.savefig(saveFilename, edgecolor='k') nDataAx.plot(toPlot[:,1],toPlot[:,2],'b-', label=r'$\alpha$' + " = " + str(alpha), color=[1-alpha, np.cos(np.pi*alpha/2), alpha]) elif "bifData" in fileName: i = i + 1 fig = plt.figure(i) ax = fig.add_subplot(111) alpha = 0 #filtering by completion of runs: x[2] == 0 toPlot = filter(lambda x: ((x[2] == 0) & (x[3] != 0)), toPlot) toPlot = np.asarray(toPlot) n = toPlot.shape[0] #ids is a 2d list, with the first holding #the different values of alpha, the second #the corresponding initial minority fraction ids = {} colorList = [] nu0 = 0 nAlpha = 0 for i in range(n): alpha = int(100*toPlot[i,0]) u0 = int(100*toPlot[i,3]) uf = toPlot[i,1] if not alpha in ids: ids[alpha] = {} if not u0 in ids[alpha]: ids[alpha][u0] = [] ids[alpha][u0].append(uf) nAlpha = len(ids) if len(ids[alpha]) > nu0: nu0 = len(ids[alpha]) toPlot = np.zeros((nu0,nAlpha,3)) u0s = [] u0f = [] j = 0 for a in ids: u0s = ids[a].keys() u0s.sort() i = 0 for u0 in u0s: ids[a][u0] = np.average(np.asarray(ids[a][u0])) toPlot[i,j,0] = a/100.0 toPlot[i,j,1] = ids[a][u0] i = i + 1 if len(u0s) > len(u0f): u0f = u0s j = j + 1 for i in range(nu0): u0 = u0f[i]/100.0 ax.plot(toPlot[i,:,0], toPlot[i,:,1], 'o', color=[1-2*u0, np.cos(np.pi*u0), 2*u0], label="initial fraction= " + str(u0)) ax.set_xlabel(r'$\alpha$', fontsize=20) ax.set_ylabel("Final minority fraction") colorList.sort() ax.legend(loc=3) ax.set_xlim([0,1]) ax.set_ylim([0,0.5]) saveFilename = fileName[:-4] + ".png" plt.savefig(saveFilename, edgecolor='k') if haveGraphStats: nDataAx.set_title("Number of conflicting edges vs. Minority fraction") nDataAx.legend(loc=2) saveFilename = "nData.png" plt.savefig(saveFilename, edgecolor='k') plt.show() else: plt.close(nDataFig)
all_res.append(data['resistance'][0]) res_error.append(data['error'][0]) titles = ['(a)', '(b)', '(c)', '(d)', '(e)', '(f)', '(g)', '(h)', '(i)'] m_s = 6 x_ticks = [0, 0.04, 0.08, 0.12, 0.16] x_ticks2 = [0, 0.16] res_fig = plt.figure() for i in range(0, len(length)): ax = plt.subplot(3, 3, i + 1) if i == 1: fill_temp = np.delete(fill_factor, 7) res_temp = np.delete(all_res[i], [7, 9, 10]) err_temp = np.delete(res_error[i], [7, 9, 10]) ax.errorbar(fill_temp, res_temp, yerr=err_temp, fmt='o', ms=m_s) ax2 = inset_axes(ax, width="30%", height=1, loc=2) ip = InsetPosition(ax, [0.18, 0.62, 0.4, 0.3]) ax2.errorbar(fill_factor, all_res[i][:len(fill_factor)], yerr=res_error[i][:len(fill_factor)], fmt='o') ax2.set_axes_locator(ip) ax2.xaxis.set_ticks(x_ticks2) ax2.yaxis.set_ticks([0, 15, 30]) ax2.set_xlim(-0.01, 0.17) elif i == 8: fill_temp = np.delete(fill_factor, 4) res_temp = np.delete(all_res[i], 4) err_temp = np.delete(res_error[i], 4) ax.errorbar(fill_temp, res_temp, yerr=err_temp, fmt='o', ms=m_s) ax2 = inset_axes(ax, width="30%", height=1, loc=2)
#legend = mpatches.Circle((0.5, 0.5), 1, facecolor='k', linewidth=3) legends.append(legend) leg = plt.legend(handles=legends, title='Strain (25 bins)', ncol=7, loc='upper center', bbox_to_anchor=(0.5, 1.05)) plt.ylabel(r"Median $K_{sn}$") plt.xlabel("Elevation (50m bins)") leg.get_frame().set_alpha(1) #adding inset histogram new_axes = inset_axes(ax, width="40%", height="40%", bbox_to_anchor=(0.5, 0.5, 1200, 300)) data_2 = getAxisHist("segmented_") new_colour = [] new_colour.append('k') for x in colours: new_colour.append(x) plt.hist(data_2, bins=x_series, stacked=True, color=new_colour[:7]) plt.title("Histogram of Data Points in Elevation Bins") plt.ylabel("Frequency") plt.xlabel("Elevation (50m bins)") leg.get_frame().set_alpha(1) fig.savefig('../elevation_scatter_Strain.png', bbox_inches='tight')
def fig2(n=352899, figname = 'Fig2', data_dir=mydir, \ stratify = True, radius=2, remove = 0, zipfType = 'mle', RGF = False, \ lognormType = 'pln', saveAs = 'eps'): # TAKEN FROM THE mete_sads.py script used for White et al. (2012) # Used for Figure 3 Locey and White (2013) """Multiple obs-predicted plotter""" fig = plt.figure() count = 0 plot_dim = 2 methods = ['geom', 'lognorm', 'mete', 'zipf'] fig.subplots_adjust(bottom= 0.30) for i, method in enumerate(methods): if method == 'zipf': obs_pred_data = importData.import_obs_pred_data(data_dir + 'data/ObsPred/Stratified/'+ method + '_'+ zipfType+'_obs_pred_stratify.txt') INh2 = importData.import_NSR2_data(data_dir + 'data/NSR2/Stratified/' + method + '_mle' + '_NSR2_stratify.txt') elif method == 'lognorm': obs_pred_data = importData.import_obs_pred_data(data_dir + 'data/ObsPred/Stratified/'+ method + '_'+ lognormType+'_obs_pred_stratify.txt') INh2 = importData.import_NSR2_data(data_dir + 'data/NSR2/Stratified/' + method + '_'+ lognormType + '_NSR2_stratify.txt') else: obs_pred_data = importData.import_obs_pred_data(data_dir + 'data/ObsPred/Stratified/'+ method +'_obs_pred_stratify.txt') INh2 = importData.import_NSR2_data(data_dir + 'data/NSR2/Stratified/' + method + '_NSR2_stratify.txt') obs = np.asarray(list(((obs_pred_data["obs"])))) pred = np.asarray(list(((obs_pred_data["pred"])))) site = np.asarray(list(((obs_pred_data["site"])))) obs2 = [] pred2 = [] site2 = [] obs_all = np.asarray(obs) pred_all = np.asarray(pred) site_all = np.asarray(site) if n == 'all' or len(obs) <= n: obs2 = list(obs) pred2 = list(pred) site2 = list(site) else: if len(obs) > n: inds = np.random.choice(range(len(site)), size=n, replace=False) for ind in inds: obs2.append(obs[ind]) pred2.append(pred[ind]) site2.append(site[ind]) obs = np.asarray(obs2) pred = np.asarray(pred2) site = np.asarray(site2) if method == 'zipf': axis_min = 0 axis_max = 2 * max(pred) else: axis_min = 0 axis_max = 2 * max(obs) ax = fig.add_subplot(plot_dim, plot_dim, count+1) if method == 'zipf': NSR2_BS = importData.import_NSR2_data(data_dir + 'data/NSR2/Stratified_Test/'+ method + '_mle_NSR2_stratify.txt') elif method == 'lognorm': NSR2_BS = importData.import_NSR2_data(data_dir + 'data/NSR2/Stratified_Test/'+ method + '_pln_NSR2_stratify.txt') else: NSR2_BS = importData.import_NSR2_data(data_dir + 'data/NSR2/Stratified_Test/'+ method +'_NSR2_stratify.txt') if method == 'geom': ax.set_title("Broken-stick") elif method == 'lognorm': ax.set_title("Lognormal") elif method == 'mete': ax.set_title("Log-series") elif method == 'zipf': ax.set_title("Zipf") print len(pred), len(obs) macroecotools.plot_color_by_pt_dens(pred, obs, radius, loglog=1, plot_obj=plt.subplot(plot_dim,plot_dim,count+1)) plt.plot([axis_min, axis_max],[axis_min, axis_max], 'k-') if method == 'zipf': plt.xlim(0, axis_max) plt.ylim(0, axis_max) else: plt.xlim(0, axis_max) plt.ylim(0, axis_max) r2s = ((INh2["R2"])) r2s = r2s.astype(float) # insert r2 of all data r2_all = np.mean(((NSR2_BS["R2"]))) print method + ' mean = ' + str(r2_all) print method + ' std dev = ' +str(np.std(r2_all)) r2text = r"${}^{{2}}_{{m}} = {:.{p}f} $".format('r',r2_all , p=2) if method == 'geom': plt.text(0.25, 0.90, r2text, fontsize=14, horizontalalignment='center', verticalalignment='center',transform = ax.transAxes) else: plt.text(0.22, 0.90, r2text, fontsize=14, horizontalalignment='center', verticalalignment='center',transform = ax.transAxes) plt.tick_params(axis='both', which='major', labelsize=10) plt.subplots_adjust(wspace=0.0000000001, hspace=0.5) axins = inset_axes(ax, width="30%", height="30%", loc=4) hist_r2 = np.histogram(r2s, range=(0, 1)) xvals = hist_r2[1] + (hist_r2[1][1] - hist_r2[1][0]) xvals = xvals[0:len(xvals)-1] yvals = hist_r2[0] plt.plot(xvals, yvals, 'k-', linewidth=2) plt.axis([0, 1, 0, 1.1 * max(yvals)]) ax.set(adjustable='box-forced', aspect='equal') plt.setp(axins, xticks=[], yticks=[]) count += 1 plt.tight_layout(pad=1.5, w_pad=0.8, h_pad=0.8) fig.text(0.50, 0.03, 'Predicted abundance', ha='center', va='center', fontsize=16) fig.text(0.08, 0.5, 'Observed abundance', ha='center', va='center', rotation='vertical', fontsize=16) fig_name = str(mydir + 'figures/' + figname + '_RGB.' + saveAs) plt.savefig(fig_name, dpi=600, format = saveAs)#, bbox_inches = 'tight')#, pad_inches=0) plt.close()
def figS1(n=35289, figname = 'FigS1', data_dir=mydir, radius=2, zipfType = 'mle', \ saveAs = 'eps', lognormType = 'pln'): methods = ['geom', 'lognorm', 'mete', 'zipf'] datasets = ['95', '97', '99'] fig = plt.figure() count = 0 rows = len(datasets) columns = len(methods) for i, dataset in enumerate(datasets): for j, method in enumerate(methods): print count if method == 'zipf': obs_pred_data = importData.import_obs_pred_data(data_dir + 'data/ObsPred/Stratified/'+ method + '_'+ zipfType+'_obs_pred_stratify.txt') INh2 = importData.import_NSR2_data(data_dir + 'data/NSR2/Stratified/' + method + '_mle' + '_NSR2_stratify.txt') elif method == 'lognorm': obs_pred_data = importData.import_obs_pred_data(data_dir + 'data/ObsPred/Stratified/'+ method + '_'+ lognormType+'_obs_pred_stratify.txt') INh2 = importData.import_NSR2_data(data_dir + 'data/NSR2/Stratified/' + method + '_'+ lognormType + '_NSR2_stratify.txt') else: obs_pred_data = importData.import_obs_pred_data(data_dir + 'data/ObsPred/Stratified/'+ method +'_obs_pred_stratify.txt') INh2 = importData.import_NSR2_data(data_dir + 'data/NSR2/Stratified/' + method + '_NSR2_stratify.txt') obs = np.asarray(list(((obs_pred_data["obs"])))) pred = np.asarray(list(((obs_pred_data["pred"])))) site = np.asarray(list(((obs_pred_data["site"])))) obs2 = [] pred2 = [] site2 = [] obs_all = np.asarray(obs) pred_all = np.asarray(pred) site_all = np.asarray(site) if n == 'all' or len(obs) <= n: obs2 = list(obs) pred2 = list(pred) site2 = list(site) else: if len(obs) > n: inds = np.random.choice(range(len(site)), size=n, replace=False) for ind in inds: obs2.append(obs[ind]) pred2.append(pred[ind]) site2.append(site[ind]) obs = np.asarray(obs2) pred = np.asarray(pred2) site = np.asarray(site2) print "number of points " + str(len(obs)) if method == 'zipf': axis_min = 0 axis_max = 2 * max(pred) else: axis_min = 0 axis_max = 2 * max(obs) ax = fig.add_subplot(rows, columns, count+1) if i == 0 and j == 0: ax.set_title("Broken-stick") elif i == 0 and j == 1: ax.set_title("Lognormal") elif i == 0 and j == 2: ax.set_title("Log-series") elif i == 0 and j == 3: ax.set_title("Zipf") if j == 0: if dataset == '95': ax.set_ylabel("MG-RAST 95%", rotation=90, size=12) elif dataset == '97': ax.set_ylabel("MG-RAST 97%", rotation=90, size=12) elif dataset == '99': ax.set_ylabel("MG-RAST 99%", rotation=90, size=12) macroecotools.plot_color_by_pt_dens(pred, obs, radius, loglog=1, plot_obj=plt.subplot(rows,columns,count+1)) plt.plot([axis_min, axis_max],[axis_min, axis_max], 'k-') if method == 'zipf': plt.xlim(0, axis_max) plt.ylim(0, axis_max) else: plt.xlim(0, axis_max) plt.ylim(0, axis_max) r2s = ((INh2["R2"])) r2s = r2s.astype(float) mean_r2s = np.mean(r2s) std_r2s = np.std(r2s) print method, dataset print "Mean r2 " + str(mean_r2s) print "Standard dev. " + str(std_r2s) if method == 'zipf': getR2 = importData.import_NSR2_data(data_dir + 'data/NSR2/Stratified_Test/SequenceSimilarity/'+ method + '_mle_' +dataset +'_NSR2_stratify.txt') elif method == 'lognorm': getR2 = importData.import_NSR2_data(data_dir + 'data/NSR2/Stratified_Test/SequenceSimilarity/'+ method + '_' + lognormType + '_' +dataset +'_NSR2_stratify.txt') else: getR2 = importData.import_NSR2_data(data_dir + 'data/NSR2/Stratified_Test/SequenceSimilarity/'+ method + '_' +dataset +'_NSR2_stratify.txt') r2_mean = np.mean(((getR2["R2"]))) if method == 'geom': r2text = r"${}^{{2}}_{{m}} = {:.{p}f} $".format('r',r2_mean , p=3) else: r2text = r"${}^{{2}}_{{m}} = {:.{p}f} $".format('r',r2_mean , p=2) if method == 'geom': plt.text(0.28, 0.90, r2text, fontsize=10, horizontalalignment='center', verticalalignment='center',transform = ax.transAxes) else: plt.text(0.25, 0.90, r2text, fontsize=10, horizontalalignment='center', verticalalignment='center',transform = ax.transAxes) plt.tick_params(axis='both', which='major', labelsize=8) plt.subplots_adjust(wspace=0.0000000001, hspace=0.5) axins = inset_axes(ax, width="30%", height="30%", loc=4) hist_r2 = np.histogram(r2s, range=(0, 1)) xvals = hist_r2[1] + (hist_r2[1][1] - hist_r2[1][0]) xvals = xvals[0:len(xvals)-1] yvals = hist_r2[0] plt.plot(xvals, yvals, 'k-', linewidth=2) plt.axis([0, 1, 0, 1.1 * max(yvals)]) ax.set(adjustable='box-forced', aspect='equal') plt.setp(axins, xticks=[], yticks=[]) count += 1 plt.tight_layout(pad=1.5, w_pad=0.8, h_pad=0.8) fig.subplots_adjust(left=0.1) fig.text(0.50, 0.02, 'Predicted abundance', ha='center', va='center', fontsize=14) fig.text(0.03, 0.5, 'Observed abundance', ha='center', va='center', rotation='vertical', fontsize=14) fig_name = str(mydir + 'figures/' + figname + '_RGB.' + saveAs) plt.savefig(fig_name, dpi=600, format = saveAs)#, bbox_inches = 'tight')#, pad_inches=0) plt.close()
def build_composite_band_plot(res, res0): sx = 1 sy = 8 X_min = - sx / 2 X_max = sx / 2 Y_min = -sy / 2 Y_max = sy / 2 fig = plt.figure() gs1 = mpl.gridspec.GridSpec(1,1) gs1.update(left=0.05, right=0.71, bottom=0.05, top=0.71) gs2 = mpl.gridspec.GridSpec(1,1) gs2.update(left=0.79, right=0.95, bottom=0.05, top=0.71) ax1 = plt.subplot(gs1[:,:]) ax2 = plt.subplot(gs2[:,:], sharey=ax1) ax3 = ax2.twiny() plt.setp(ax2.get_yticklabels(), visible=False) # ratio.plot(ax=ax2, lw=3) r = res0.flux_ratio[0.15:0.5] rx = r.values ry = r.index ax2.plot(rx, ry, 'k', lw=3) ax2.set_xticks([0,0.5,1]) ax2.set_xlim(0,1) c3 = cmap7.mpl_colors[0] l = res0.ldos[0.15:0.5] lx = l.values ly = l.index ax3.plot(lx, ly, c=c3, lw=3) ax3.set_xlim(0,1) ax3.set_xticks([0,1]) ax3.set_xlabel("LDOS/"r"$\varepsilon_{hi}$") for obj in ax3.get_xticklabels() + [ax3.spines['top'], ax3.xaxis.label] + ax3.get_xticklines(): obj.set_color(c3) obj.set_zorder(2) ax2.spines['top'].set_visible(False) ax2.set_xticks([0,1]) ax2.set_xlabel("$P_{rad} / P_0$") ax1.set_xlabel("$k_x a / (2 \pi)$") ax1.set_ylabel("$\omega a / (2 \pi c)$") ax1.set_xlim(0,0.5) ax1.set_ylim(0,0.5) ax1.set_aspect('equal') ax1.set_autoscale_on(False) # add an inset image of epsilon a = inset_locator.inset_axes(ax1, height=1.8, width=0.225, loc=8, bbox_to_anchor=(0.9, 0.01), bbox_transform=ax1.transAxes) a.imshow(res.epsilon, extent=(X_min,X_max, Y_min, Y_max), cmap=plt.cm.gray) a.set_aspect("equal") plt.setp(a.xaxis, visible=False) plt.setp(a.yaxis, visible=False) return fig
ax.set(aspect=1, xlim=(-15, 15), ylim=(-20, 5)) axins = zoomed_inset_axes(ax, 2, loc=2) # zoom = 6 im = axins.imshow(Z, extent=extent, interpolation="nearest", origin="lower") plt.xticks(visible=False) plt.yticks(visible=False) # colorbar cax = inset_axes(axins, width="5%", # width = 10% of parent_bbox width height="100%", # height : 50% loc=3, bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=axins.transAxes, borderpad=0, ) colorbar(im, cax=cax) #, ticks=[1,2,3]) plt.draw() plt.show()
def SAD_SSAD(fs): switch = 0 dataset = 'BCI' fig = plt.figure() """ This does this ... figure 3 of Locey and McGilnn 2013""" ax =fig.add_subplot(2,2,1) pattern = 'SAD' RADs = get_obs_pred(dataset, pattern) obsRAD = RADs[0] predRAD = RADs[1] print obs_pred_rsquare(np.log(obsRAD), np.log(predRAD)) N = sum(obsRAD) S = len(obsRAD) DATA = open('/home/kenlocey/combined1/' + str(N) + '-' + str(S) + '.txt','r') RADs = [] for d in DATA: rad = eval(d) RADs.append(rad) DATA.close() x = [] y = [] for rad in RADs: rank = 1 for j in rad: x.append(rank) y.append(np.log(j)) rank += 1 plt.hexbin(x,y,bins='log',gridsize=100,mincnt=1,cmap=cm.Reds) # bins can be 'log' or None plt.tick_params(axis='both', which='major', labelsize=fs-3) ranks = range(1,301+1) plt.scatter(ranks,np.log(obsRAD), color='0.3', marker = '.') plt.text(225, 8, '0.28',fontsize=fs+2) plt.xlabel("Rank in abundance",fontsize=fs) plt.ylabel("ln(abundance)",fontsize=fs) #plt.ylim(-0.1,19.5) plt.xlim(0.01,310) ax =fig.add_subplot(2,2,2) SSADs_freqs = get_SSADs(dataset) SSADs = hist_to_rank(SSADs_freqs) Pvals = [] for i, obsSSAD in enumerate(SSADs): Q = sum(obsSSAD) N = len(obsSSAD) partitions = [] PATH = '/home/kenlocey/combined1/' + str(Q) + '-' + str(N) + '.txt' if path.exists(PATH) and path.isfile(PATH) and access(PATH, R_OK): DATA = open(PATH,'r') DATA.readline() # first line has no abundance info, so skip it for d in DATA: partitions.append(eval(d)) else: continue if len(partitions) == 0: print Q,N,'something is wrong' sys.exit() predSSAD = parts.central_tendency(partitions) print sum(obsSSAD),len(obsSSAD),' ',sum(predSSAD),len(predSSAD), pval = stats.ks_2samp(obsSSAD, predSSAD)[1] Pvals.append(pval) print pval if pval > 0.05 and Q > 1000 and switch == 0: SSADs = [] for part in partitions: ssad = rank_to_PrestonPlot(part) ssad2 = lose_trailing_zeros(ssad) SSADs.append(ssad2) #print SSADs[0] #sys.exit() x = [] y = [] for ssad in SSADs: ab_class = 0 for j in ssad: x.append(ab_class) y.append(j) ab_class += 1 plt.hexbin(x,y,bins=None,gridsize=25,mincnt=1,cmap=cm.Reds) obsSSAD2 = rank_to_PrestonPlot(obsSSAD) obsSSAD3 = lose_trailing_zeros(obsSSAD2) bins = range(0,len(obsSSAD2)) #plt.plot(obsSSAD, color='0.3', lw=2) plt.scatter(bins, obsSSAD3, color='0.3', marker = 'o') #plt.xlim(-0.5,max(bins)) #plt.ylim(-0.5,max(max(predSSAD),max(obsSSAD))+10) plt.xlabel("Abundance class",fontsize=fs) plt.ylabel("frequency",fontsize=fs) plt.tick_params(axis='both', which='major', labelsize=fs-3) switch += 1 if len(Pvals) > 50 and switch == 1: break # Create inset for histogram of site level r^2 values axins = inset_axes(ax, width="30%", height="30%", loc=1) D = get_kdens(Pvals) plt.plot(D[0],D[1],color='0.2',lw=2.0) plt.setp(axins, xticks=[0.0, 0.5, 1.0]) plt.tick_params(axis='both', which='major', labelsize=fs-4) plt.xlim(0.0,1.0) #plt.ylim(0.0, max(D[1])+0.003) plt.subplots_adjust(wspace=0.3) plt.savefig('/home/kenlocey/partitions/SAD-SSAD.png', dpi=400, bbox_inches = 'tight', pad_inches=0.03)
def displacement(ofile,timestep,Natoms,matrix0,Type,Time,frontname,pathtodatabase,systemsize): ''' timestep,system_size,matrix0 contain the initial information about the system. we have to go through sortedfiles to find information about the particles at later timesteps. ''' factor = 10**(-8) # conversionfactor from [A^2/ps] -> [m^2/s] Lx = systemsize[1] -systemsize[0] Ly = systemsize[3] -systemsize[2] Lz = systemsize[5] -systemsize[4] halfsystemsize = 0.5*(Lx+Ly+Lz)/3.0 # half of average system size time = [] for t in Time: time.append(timestep*t/1000.0) # to picoseconds #time.append(t) MSDX = [];MSDY = [];MSDZ = [];MSD = [];D_local = [] dt = (time[1]-time[0]) for T in Time: path = frontname + '.%r.txt' % (T) print path msdx = 0; msdy = 0; msdz = 0; msd = 0 filename = os.path.abspath(os.path.join(pathtodatabase,path)) t, Natoms, system_size, matrix, readstructure, entries, types = readfile(filename) counter = 0 for i in range(Natoms): if (matrix['type'][i] == Type): ID = matrix['id'][i] initial_index = None for j in range(Natoms): k = matrix0['id'][j] if (k == ID): initial_index = j break dx = matrix['x'][i] - matrix0['x'][initial_index] dy = matrix['y'][i] - matrix0['y'][initial_index] dz = matrix['z'][i] - matrix0['z'][initial_index] msdx += (dx)**2 msdy += (dy)**2 msdz += (dz)**2 ######################################## # MINIMUM IMAGE CONVENTION # if (dx < -halfsystemsize): dx = dx + Lx if (dx > halfsystemsize): dx = dx - Lx if (dy < -halfsystemsize): dy = dy + Ly if (dy > halfsystemsize): dy = dy - Ly if (dz < -halfsystemsize): dz = dz + Lz if (dz > halfsystemsize): dz = dz - Lz ######################################## msd += dx**2 + dy**2 + dz**2 counter += 1 D_local.append((msd/(counter*6*T))) MSDX.append(msdx/(6*counter));MSDY.append(msdy/(6*counter));MSDZ.append(msdz/(6*counter));MSD.append(msd/(6*counter)) # ballistic_end = 100ps degree = 1 start = int(round(len(MSD)/5.0)) p = np.polyfit(time[start:],MSD[start:],degree) # last 4/5 of the dataset f = np.polyval(p,time) d_mean_lastpart = p[0]#*10**(-8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s] p1 = np.polyfit(time[0:start],MSD[0:start],degree) f1 = np.polyval(p1,time) d_mean_firstpart = p1[0]#*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s] p2 = np.polyfit(time[0:int(round(start/2.0))],MSD[0:int(round(start/2.0))],degree) f2 = np.polyval(p2,time) d_mean_initpart = p2[0]#*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s] p3 = np.polyfit(time[0:100],MSD[0:100],degree) f3 = np.polyval(p3,time) d_mean_actual = p3[0]#*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s] print "#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#" print " Nvalues in estimate 1 = 100" print " Nvalues in estimate 2 = %g" % (int(round(start/2.0))) print " Nvalues in estimate 3 = %g" % (int(round(start))) print " Nvalues in estimate 4 = %g" % (len(time[start:])) ############################################################################### # plotting #plt.close('all') plt.figure() # Figure 1 Title = 'Mean square displacement' legends = ['$msd_{x}$','$msd_{y}$','$msd_{z}$','$msd$']#['$msd$']# Ylabel = 'mean square displacement $ [A^2] $' Xlabel = 'time $ [ps] $' pltname = 'MSD_bulkwater' linestyles = ['--r','--y','--k','o-b']#['--r'] # plt.hold(True) plt.plot(time,MSDX,linestyles[0]) plt.plot(time,MSDY,linestyles[1]) plt.plot(time,MSDZ,linestyles[2]) plt.plot(time,MSD,linestyles[3],markevery=10) plt.title(Title) plt.xlabel(Xlabel) plt.ylabel(Ylabel) plt.legend(legends,loc='lower right') plt.hold(False) write_to_file(ofile,Title,Xlabel,Ylabel,pltname,legends,linestyles,[time],[MSDX,MSDY,MSDZ,MSD]) from mpl_toolkits.axes_grid.inset_locator import zoomed_inset_axes, inset_axes, mark_inset plt.figure() ax = plt.axes() # Figure 2 Title = 'Mean square displacement' legends = ['MSD','$f_1 %.3f $' % (d_mean_actual),'$f_2 %.3f $' % (d_mean_initpart),'$f_3 %.3f $' % (d_mean_firstpart),'$f_4 %.3f $' % (d_mean_lastpart)] pltname = 'MSD_bulkwater_mean' Xlabel = 'time $ [ps] $' Ylabel = 'mean square displacement $ [A^2] $' linestyles = ['b-','--y','--r','--m','--y'] plt.hold(True) plt.plot(time,MSD,linestyles[0]) plt.plot(time[0:int(round(len(f)/8.0))],f3[0:int(round(len(f)/8.0))],linestyles[1]) # very first part plt.plot(time[0:int(round(len(f)/6.0))],f2[0:int(round(len(f)/6.0))],linestyles[2]) # initpart plt.plot(time[0:int(round(len(f)/5.0))],f1[0:int(round(len(f)/5.0))],linestyles[3]) # firstpart plt.plot(time,f,linestyles[4]) # lastpart plt.hold(False) plt.xlabel(Xlabel) plt.ylabel(Ylabel) plt.legend(legends,loc='lower right') plt.title(Title) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.get_xaxis().tick_bottom() ax.get_yaxis().tick_left() axin = inset_axes(ax, width="30%", height="35%", loc=8) plt.hold(True) axin.plot(time,MSD,linestyles[0]) axin.plot(time,f3,linestyles[1],linewidth=3.0) axin.plot(time,f2,linestyles[2]) #axin.plot(time,f1,linestyles[3]) plt.hold(False) axin.set_xlim(500, 520) ya = 0.0 yb = 4.0 Npoints = 4 points = np.linspace(ya,yb,Npoints) axin.set_ylim(ya, yb) axin.set_xticks([]) axin.set_yticks(points) mark_inset(ax, axin, loc1=3, loc2=4, fc="none", ec="0.5") write_to_file(ofile,Title,Xlabel,Ylabel,pltname,legends,linestyles,[time],[MSD,f]) print "#################################################################" print "# Diffusion estimate f1 : D = %.10f " % (d_mean_actual) print "# Diffusion estimate f2 : D = %.10f " % (d_mean_initpart) print "# Diffusion estimate f3 : D = %.10f " % (d_mean_firstpart) print "# Diffusion estimate f4 : D = %.10f " % (d_mean_lastpart) plt.figure() # Figure 3 Title = 'Time evolution of the local diffusion constant. $ D=(msd/6dt) $' legends = ['$D(t)$']; linestyles = ['-y'] pltname = 'Diffusion_bulkwater' Ylabel = 'displacement $ [ %g m^2/s]$' % factor plt.hold(True) plt.plot(time,D_local,linestyles[0]) plt.hold(False) plt.legend(legends,loc='upper right') plt.title(Title) plt.xlabel(Xlabel) plt.ylabel(Ylabel) write_to_file(ofile,Title,Xlabel,Ylabel,pltname,legends,linestyles,[time],[D_local]) plt.show()
def plot(self, profile, statsResults): if len(statsResults.activeData) <= 0: self.emptyAxis() return axesColour = str(self.preferences['Axes colour'].name()) # *** Get data to plot if self.fieldToPlot == 'p-values': data = statsResults.getColumn('pValues') xLabel = 'p-value' elif self.fieldToPlot == 'p-values (corrected)': data = statsResults.getColumn('pValuesCorrected') xLabel = 'p-value (corrected)' # *** Set size of figure self.fig.clear() self.fig.set_size_inches(self.figWidth, self.figHeight) heightBottomLabels = 0.4 # inches widthSideLabel = 0.5 # inches padding = 0.2 # inches axesHist = self.fig.add_axes([widthSideLabel/self.figWidth,heightBottomLabels/self.figHeight,\ 1.0-(widthSideLabel+padding)/self.figWidth,\ 1.0-(heightBottomLabels+padding)/self.figHeight]) # *** Histogram plot bins = [0.0] binWidth = self.binWidth binEnd = binWidth while binEnd <= 1.0: bins.append(binEnd) binEnd += binWidth n, bins, patch = axesHist.hist(data, bins=bins, log=self.yAxisLogScale,color=(0.5,0.5,0.5)) axesHist.set_xlabel(xLabel) axesHist.set_ylabel('Number of features') # *** Prettify plot for a in axesHist.yaxis.majorTicks: a.tick1On=True a.tick2On=False for a in axesHist.xaxis.majorTicks: a.tick1On=True a.tick2On=False for line in axesHist.yaxis.get_ticklines(): line.set_color(axesColour) for line in axesHist.xaxis.get_ticklines(): line.set_color(axesColour) for loc, spine in axesHist.spines.iteritems(): if loc in ['right','top']: spine.set_color('none') else: spine.set_color(axesColour) # *** Plot inset if self.bShowInset: bins = [0.0] binWidth = self.insetBinWidth binEnd = binWidth while binEnd <= self.xLimit: bins.append(binEnd) binEnd += binWidth widthStr = str(self.insetWidth) + '%' heightStr = str(self.insetHeight) + '%' axins = inset_axes(axesHist, width=widthStr, height=heightStr, loc=1) filteredData = [d for d in data if d <= self.xLimit] if filteredData: n, bins, patch = axins.hist(filteredData, bins=bins, log=self.insetLogScale, color=(0.5,0.5,0.5)) axins.set_xlim(0, self.xLimit) # *** Prettify inset for a in axins.yaxis.majorTicks: a.tick1On=True a.tick2On=False for a in axins.xaxis.majorTicks: a.tick1On=True a.tick2On=False for line in axins.yaxis.get_ticklines(): line.set_color(axesColour) for line in axins.xaxis.get_ticklines(): line.set_color(axesColour) for loc, spine in axins.spines.iteritems(): if loc in ['right','top']: spine.set_color('none') else: spine.set_color(axesColour) self.updateGeometry() self.draw()
fg7.set_xlim([12,37]) fg7.set_ylim([0.45,1.]) fg7.set_yticks([0.5,0.75,1.]) fg7.set_xticks([15,20,25,30,35]) fg7.tick_params(axis='both', which='major', labelsize=30) fg7.set_xlabel(r'Threshold ($x_f$)',fontsize=50) fg7.set_ylabel(r'Proportion Pot./Dep. ($q_f$)',fontsize=50) #fg7.axhline(y=.7, xmin=0, xmax=100, linewidth=10, color = 'b',alpha=0.5, linestyle='dashed') # Make a colorbar for the ContourSet returned by the contourf call. fg7.axvline(x=model_step.mean_patterns, ymin=0, ymax=1, linewidth=10, color = 'g',alpha=0.5, linestyle='dashed') fg7.axvline(x=model_step.median_patterns, ymin=0, ymax=1, linewidth=10, color = 'peru',alpha=0.5, linestyle='dashed') fg7.scatter(themaxcap[2][5:-1],themaxcap[3][5:-1],s=1000*(np.array(themaxcap[1][5:-1])/max(themaxcap[1])),alpha=0.5,color='b') fg7.set_title('(F)',fontsize=50,fontweight="bold",y=1.06) fg7.text(16,0.95,'Potentiation',fontsize=50) fg7.text(28,0.8,'Depresion',fontsize=50) inset_axes = inset_axes(fg7,width=5, height=3,loc=1,bbox_to_anchor=(0.895, 0.265),bbox_transform=fg7.figure.transFigure) inset_axes.plot(themaxcap[0][5:-1],themaxcap[1][5:-1],lw=8,color='maroon',alpha=0.8) inset_axes.set_xlim([0.5,7]) inset_axes.set_ylim([0.4,0.8]) #inset_axes.set_xticks([25.,75,100]) inset_axes.set_yticks([0.4,0.6,0.8]) inset_axes.tick_params(labelsize=30) inset_axes.set_xlabel(r'A',fontsize=30) inset_axes.set_ylabel(r'Larg.Max.Cap.($\alpha_c$)',fontsize=30) #cbar.set_ticklabels([0.08,0.32,0.64]) plt.savefig('fig3.pdf', bbox_inches='tight') print themaxcap[0][5] #plt.show()
def show_coord_topo_zoom(windpark, show = True): """Plot the topology of a given windpark Topographic Map with farms see: http://matplotlib.org/basemap/users/examples.html Basemap Parameters ---------- windpark : Windpark A given windpark to show the topology. """ plt.clf() turbines = windpark.get_turbines() target = windpark.get_target() radius = windpark.get_radius() #pack latitude and longitude in lists rel_input_lat = [] rel_input_lon = [] for row in turbines: rel_input_lat.append(np.float64(row.latitude)) rel_input_lon.append(np.float64(row.longitude)) targetcoord = [0.0, 0.0] targetcoord[0] = np.float64(target.latitude) targetcoord[1] = np.float64(target.longitude) graddiff = (800/111.0) + 0.5 # degree in km... 800km fig = plt.figure(figsize=(11.7,8.3)) plt.title("Location of the farm") #Custom adjust of the subplots plt.subplots_adjust(left=0.05,right=0.95,top=0.90,bottom=0.05,wspace=0.15,hspace=0.05) ax = plt.subplot(111) m = Basemap(projection='lcc', lon_0=targetcoord[1], lat_0=targetcoord[0],\ llcrnrlon = targetcoord[1]-graddiff*2, llcrnrlat = targetcoord[0]-graddiff ,\ urcrnrlon = targetcoord[1]+graddiff, urcrnrlat = targetcoord[0]+graddiff ,\ rsphere=6371200., resolution = None, area_thresh=1000) # Target x_target,y_target = m(targetcoord[1],targetcoord[0]) # Input Farms rel_inputs_lon, rel_inputs_lat = m(rel_input_lon, rel_input_lat) # labels = [left,right,top,bottom] parallels = np.arange(int(targetcoord[0]-7), int(targetcoord[0]+7), 2.) m.drawparallels(parallels,labels=[False,True,True,False]) meridians = np.arange(int(targetcoord[1]-7), int(targetcoord[1]+7), 2.) m.drawmeridians(meridians,labels=[True,False,False,True]) # plot farms in the radius m.plot(x_target, y_target, 'bo') # m.plot(rel_inputs_lon, rel_inputs_lat, 'r*') #m.bluemarble() m.shadedrelief() # we define the inset_axes, with a zoom of 2 and at location 2 (upper left corner) # axins = zoomed_inset_axes(ax, 40, loc=2) axins = inset_axes(ax, width="65%", # width = 30% of parent_bbox height="65%", # height : 1 inch loc=3) # plot farms in the radius m.plot(x_target, y_target, 'bo') m.plot(rel_inputs_lon, rel_inputs_lat, 'r*') #m.bluemarble() m.shadedrelief() #m.etopo() #m.drawcoastlines() graddiff_park = (radius/(111.0*0.7)) # degree in km x,y = m(targetcoord[1]-graddiff_park,targetcoord[0]-graddiff_park) x2,y2 = m(targetcoord[1]+graddiff_park,targetcoord[0]+graddiff_park) axins.set_xlim(x,x2) # and we apply the limits of the zoom plot to the inset axes axins.set_ylim(y,y2) # idem plt.xticks(visible=False) # we hide the ticks plt.yticks(visible=False) mark_inset(ax, axins, loc1=1, loc2=4, fc="none", ec="0.9", linewidth = 3) # we draw the "zoom effect" on the main map (ax), joining cornder 1 & 3 plt.title("Selected Wind Farms") if(show): plt.show()
for i in list_index_alp: fg2.plot(rates,myprobs_pres_fam[i],lw=12,alpha=0.8,label=' ') colormap = plt.cm.Accent plt.gca().set_color_cycle([colormap(i) for i in np.linspace(0, 0.9,len_index_alp)]) for i in list_index_alp: fg2.plot(rates,myprobs_pres_nov[i],lw=12,ls='--',alpha=0.8) fg2.set_xlim([0.01,30]) fg2.set_ylim([0,0.3]) fg2.set_yticks([0,0.1,0.2,0.3]) #fg2.set_xticks([0,0.1,0.2,0.3,0.4,0.5]) fg2.set_xlabel(r'Rate (Hz)',fontsize=45) fg2.set_ylabel(r'Dist. Rates',fontsize=45) fg2.tick_params(labelsize=35) fg2.set_title('(A)',fontsize=50,fontweight="bold",y=1.06) fg2.legend(loc=(0.01,0.47),numpoints=1,prop={'size':12}) inset_axes = inset_axes(fg2,width=5, height=3,loc=1,bbox_to_anchor=(0.345, 0.885),bbox_transform=fg2.figure.transFigure) colormap = plt.cm.Accent plt.gca().set_color_cycle([colormap(i) for i in np.linspace(0, 0.9,len_index_alp)]) for i in list_index_alp: inset_axes.plot(rates,myprobs_pres_fam[i],lw=8,alpha=0.8) colormap = plt.cm.Accent plt.gca().set_color_cycle([colormap(i) for i in np.linspace(0, 0.9,len_index_alp)]) for i in list_index_alp: inset_axes.plot(rates,myprobs_pres_nov[i],lw=8,ls='--',alpha=0.8) inset_axes.set_xlim([25,100]) inset_axes.set_ylim([0,0.02]) inset_axes.set_xticks([25.,75,100]) inset_axes.set_yticks([0.02]) inset_axes.tick_params(labelsize=30) inset_axes.set_xlabel(r'Rate (Hz)',fontsize=30)
# ax1.set_xlabel(r'Rest frame wavelength') ''' ax3 = plt.subplot(gs[1], sharex=ax1) # ax2 = smaller lower axis ax3.plot(wave_rest, chi, 'o', color='k') # plot chi plt.axhline(y=0, color='k') # plot horizontal line at y=0 on chi plot yticks = ax3.yaxis.get_major_ticks() # show ytick labels on lower axis yticks[-1].label1.set_visible(False) # hide uppermost ytick label on lower axis to prevent overlap ax3.set_ylabel(r'$\chi$', fontsize=fs_text) # ax3.set_xlabel(r'Rest frame wavelength', fontsize=fs) # 30 # plt.subplots_adjust(hspace=.0) ''' ax1.legend(numpoints=1, loc='upper left', prop={'size': 20}) # , line2) ... , r'$\chi$'] loc_uvj = 1 inset_axes(ax1, width=8 * 0.32, height=8 * 0.28, loc=loc_uvj) # NOTE: height = 0.875 width (3.5 units vs 4 units) 20%/0.875=0.22857 --> if height 28%, set width to 32% # create inset axis: width (%), height (inches), location # loc=1 (upper right), loc=2 (upper left) --> loc=3 (lower left), loc=4 (lower right); loc=7 (center right) # https://stackoverflow.com/questions/10824156/matplotlib-legend-location-numbers uvj.uvj_plot(-1, 'all', objlist=[str(obj) + '_' + field], title=False, labels=False, lims=True, size=20, show=False, col=['purple']) print('uvj1')
def Make_Z_Plot(grbdict, z_key="grbox_z", Nbins=31, z_cutoff=4.0): """Given any dictionary which has the redshift as one of the keywords, plot a histogram of those redshifts. """ z_list = [] zname_list = [] date_list = [] # 'un'zip all_grbs (is there a better way to do this? just assign rather than a for loop?) for key, value in grbdict.iteritems(): # date_list.append(value['date']) z_list.append(value[z_key]) zname_list.append(key) print "***All***" print " " print z_list print len(z_list) ### Print out the most distant GRB as a function of time zmax = 0.0 rr = [] for key, value in grbdict.iteritems(): if value[z_key] > zmax: rr.append(key) zmax = value[z_key] # print value['date'].year + value['date'].timetuple().tm_yday/365.0, zmax, "# ", key ax = plt.subplot(111) n, bins, patches = plt.hist(plt.log10(z_list), bins=Nbins, facecolor="grey", edgecolor="grey") # Define pre-swift burst index as bursts before 041210 # high_z_i = plt.where(plt.array(date_list) < datetime.date(2004,12,10)) # high_z_list = [z_list[i] for i in list(high_z_i[0])] # print high_z_list # n, bins1, patches = plt.hist(plt.log10(high_z_list),bins=bins,facecolor='black',edgecolor='black',alpha=0.6) if overplot_high_z: high_z_list = [z for z in z_list if z > z_cutoff] n, bins1, patches = plt.hist(plt.log10(high_z_list), bins=bins, facecolor="black", edgecolor="black") ay = ax.twinx() argg = list(plt.ones(len(z_list)).cumsum().repeat(2)) zz = copy.copy(z_list) zz.sort() tmp = list(plt.log10(zz).repeat(2)) tmp.append(1) yy = [0] yy.extend(argg) ay.plot(tmp, yy, aa=True, linewidth=4, color="black") argg = list(plt.ones(len(high_z_list)).cumsum().repeat(2)) zz = copy.copy(high_z_list) zz.sort() tmp = list(plt.log10(zz).repeat(2)) tmp.append(1) yy = [0] yy.extend(argg) ay.plot(tmp, yy, aa=True, linewidth=2, color="grey") ay.set_ylim((0, len(z_list) * 1.05)) ay.set_ylabel("Cumulative Number", fontsize=20) # formatter for bottom x axis def ff(x, pos=None): if x < -1: return "%.2f" % (10 ** x) elif x < 0: return "%.1f" % (10 ** x) elif 10 ** x == 8.5: return "%.1f" % (10 ** x) else: return "%i" % (10 ** x) formatter = FuncFormatter(ff) ax.set_xticks([-2, -1, plt.log10(0.3), 0, plt.log10(2), plt.log10(3), plt.log10(4), plt.log10(6), plt.log10(8.5)]) ax.xaxis.set_major_formatter(formatter) ax.set_xlabel("Redshift ($z$)", fontsize=20) ax.set_ylabel("Number", fontsize=20) ax.set_xlim((plt.log10(0.005), plt.log10(10))) ax2 = ax.twiny() xlim = ax.get_xlim() # ax2.set_xscale("log") ax2.set_xlim((xlim[0], xlim[1])) # Define function for plotting the top X axis; time since big bang in Gyr def rr(x, pos=None): g = cosmocalc.cosmocalc(10.0 ** x, H0=71.0) if g["zage_Gyr"] < 1: return "%.2f" % g["zage_Gyr"] # Return 2 dec place if age < 1; e.g 0.62 else: return "%.1f" % g["zage_Gyr"] # Return 1 dec place if age > 1; e.g. 1.5 ax2.set_xticks([-1.91, -1.3, -0.752, -0.283, 0.102, 0.349, 0.62, plt.log10(8.3)]) formatter1 = FuncFormatter(rr) ax2.xaxis.set_major_formatter(formatter1) ax2.set_xlabel("Time since Big Bang (Gyr)", fontsize=20) # plt.bar(l,a['yy'],width=w,log=False) # ax.set_xscale("log",nonposx='clip') ## Now plot inset plot of GRBs greater than z=z_cutoff axins = inset_axes(ax2, width="30%", height="30%") # width = 30% of parent_bbox # height : 1 inch) locator = axins.get_axes_locator() locator.set_bbox_to_anchor((-0.8, -0.45, 1.35, 1.35), ax.transAxes) locator.borderpad = 0.0 high_z_list = [z for z in z_list if z > z_cutoff] if high_z_list: # if there are any high-z's, plot them n, bins, patches = plt.hist(plt.array(high_z_list), facecolor="black", edgecolor="black") axins.set_xlim(z_cutoff, 8.5) axins.set_xlabel("z") axins.set_ylabel("N") # high_z_i = plt.where(plt.array(date_list) < datetime.date(2004,12,10)) # high_z_list = [z_list[i] for i in list(high_z_i[0]) if z_list[i] > z_cutoff] n, bins, patches = plt.hist(plt.array(high_z_list), bins=bins, facecolor="black", edgecolor="black") high_z_list = [z for z in z_list if z > z_cutoff] if high_z_list: # if there are any high-z's, plot them n, bins, patches = plt.hist(plt.array(high_z_list), facecolor="black", edgecolor="black") axins.set_xlim(z_cutoff, 9.0) # mark_inset(ax, axins, loc1=2, loc2=4, fc="none", ec="0.5") # axins2.set_xlabel("Time since Big Bang [Gyr]",fontsize=20) ylabels = ax.get_yticklabels() plt.setp(ylabels, size=14, name="times", weight="light", color="k") xlabels = ax.get_xticklabels() plt.setp(xlabels, size=14, name="times", weight="light", color="k") xlabels = ax2.get_xticklabels() plt.setp(xlabels, size=14, name="times", weight="light", color="k") xlabels = ay.get_yticklabels() plt.setp(xlabels, size=14, name="times", weight="light", color="k") plt.savefig("z_plot.eps") plt.draw() return z_list