def prices_and_profits(pool_backup, fig_name=None, ax_price=None, ax_profit=None): # Create figure and axes if not given in args if ax_price is None or ax_profit is None: fig = plt.figure(figsize=(4, 5), dpi=200) n_rows = 2 n_cols = 1 ax_price = fig.add_subplot(n_rows, n_cols, 1) ax_profit = fig.add_subplot(n_rows, n_cols, 2) prices_over_fov(pool_backup, ax_price) profits_over_fov(pool_backup, ax_profit) if fig_name is not None: # Cut margins plt.tight_layout() # Create directories if not already existing os.makedirs(os.path.dirname(fig_name), exist_ok=True) # Save fig plt.savefig(fig_name) plt.close()
def plot_response(data, plate_name, save_folder = 'Figures/'): """ """ if not os.path.isdir(save_folder): os.makedirs(save_folder) for block in data: # group = group_similar(data[block].keys()) names = data[block].keys() names.sort() # plt.figure(figsize=(16, 4 + len(names)/8), dpi=300) # for i, name in enumerate(names): a, b, c = get_index(group, name) color, pattern = color_shade_pattern(a, b, c, group) mean = data[block][name]['mean'][0] std = data[block][name]['std'][0] plt.barh([i], [mean], height=1.0, color=color, hatch=pattern) plt.errorbar([mean], [i+0.5], xerr=[std], ecolor = [0,0,0], linestyle = '') plt.yticks([i+0.5 for i in xrange(len(names))], names, size = 8) plt.title(plate_name) plt.ylim(0, len(names)) plt.xlabel('change') plt.tight_layout() plt.savefig(save_folder + 'response_' + str(block + 1)) # return None
def plot_bw(ax, x, y, file_name, fig_folder): ax.scatter(x, y, facecolor="black", edgecolor='none', s=25, alpha=0.15) plt.tight_layout() if file_name: plt.savefig("{}/{}_gray.pdf".format(fig_folder, file_name)) plt.show()
def plot_macd(self): fig, ax = subplots(ncols=1, nrows=2, sharex=True) ax[0] = self._plot_m_line(ax[0]) ax[1] = self._plot_macd(ax[1], label='') plt.tight_layout(h_pad=0) for _ax in ax: _ax.legend(loc='best') return fig
def plot_color(fig, ax, x, y, z, file_name, fig_folder): abc = ax.scatter(x, y, c=z, zorder=10, alpha=0.25) fig.colorbar(abc, label="Profits") plt.tight_layout() if file_name: plt.savefig("{}/{}.pdf".format(fig_folder, file_name)) plt.show()
def profit_firmA_against_profit_firmB(file_name, folder=None): if folder is None: folder = "data/figures" os.makedirs(folder, exist_ok=True) bkp = backup.RunBackup.load(file_name=file_name) parameters = bkp.parameters profit_max = parameters.n_positions * parameters.n_prices * parameters.unit_value x = np.arange(parameters.t_max) y = np.zeros((2, parameters.t_max)) for f in range(2): for t in range(parameters.t_max): y[f, t] = np.mean(bkp.profits[:t + 1, f] / profit_max) # y = np.array([np.mean(for_y[i][t]) for t in range(parameters.t_max)]) # y_err = np.array([np.std(for_y[i][t]) for t in range(parameters.t_max)]) fig = plt.Figure() plt.plot(x, y[0], label="Firm A") plt.plot(x, y[1], label="Firm B") # plt.fill_between(x, y - (y_err / 2), y + (y_err / 2), color="C{}".format(i), alpha=.25) plt.legend() plt.xlabel("t") plt.ylabel("Mean profit") plt.text(0.005, 0.005, file_name, transform=fig.transFigure, fontsize='x-small', color='0.5') plt.title("Evolution of profits over time ($r={}$)".format( bkp.field_of_view / 2)) plt.tight_layout() plt.savefig("{}/{}_mean_profit.pdf".format(folder, file_name)) plt.show()
def plot_baseline(data, plate_name, save_folder = r'Figures/'): """ """ colors = ((0.2, 0.2, 0.2), (0.5, 0.5, 0.5), (0.7, 0.7, 0.7), (0.3, 0.3, 0.3)) names = data.keys() names.sort() fig, axs = plt.subplots(figsize=(8,3)) for index, name in enumerate(names): for value in data[name]['original_data']: plot_color = colors[index % len(colors)] if abs(value - data[name]['mean'][0]) > data[name]['std'][0] * 2.0: axs.plot([value], [index], 'ko', markerfacecolor = [1,1,1]) else: axs.plot([value], [index], 'ko', color = plot_color) axs.plot([data[name]['mean'][0] for _ in xrange(2)], [index-0.25, index+0.25], 'k-') axs.plot([data[name]['mean'][0] - data[name]['std'][0] for _ in xrange(2)], [index-0.25, index+0.25], 'k--') axs.plot([data[name]['mean'][0] + data[name]['std'][0] for _ in xrange(2)], [index-0.25, index+0.25], 'k--') plt.yticks([i for i in xrange(len(names))], names, size = 10) plt.title(plate_name) plt.ylim(-0.5,len(names)-0.5) plt.xlabel('Fluorescent intensity') plt.tight_layout() save_filename = save_folder + 'baseline_average' pdf = PdfPages(save_filename.split('.')[0] + '.pdf') pdf.savefig(fig) pdf.close() plt.savefig(save_filename) # return None
def convolve(arrays, melBank, genere, filter_idx): x = [] melBank_time = np.fft.ifft(melBank) #need to transform melBank to time domain for eachClip in arrays: result = np.convolve(eachClip, melBank_time) x.append(result) plotBeforeAfterFilter(eachClip, melBank, melBank_time, result, genere, filter_idx) m = np.asmatrix(np.array(x)) fig, ax = plt.subplots() ax.matshow(m.real) #each element has imaginary part. So just plot real part plt.axis('equal') plt.axis('tight') plt.title(genere) plt.tight_layout() # filename = "./figures/convolution/Convolution_"+"Filter"+str(filter_idx)+genere+".png" # plt.savefig(filename) plt.show()
def plot(results, path=os.path.expanduser("~/Desktop/results.pdf")): x = results[:, 0] y = results[:, 1] fig = plt.figure(figsize=(10, 6)) ax = plt.subplot() ax.scatter(x, y, color='black', alpha=0.25) ax.set_xlabel("$r$") ax.set_ylabel("Diff of profits between $h_0$ and $h_1$") ax.set_title("Does strategic depth impact profits?") add_fitting_curve(ax, x, y) plt.tight_layout() plt.savefig(path) plt.show()
def show_prediction_result(image, label_image, clf): size = (8, 8) plt.figure(figsize=(15, 10)) plt.imshow(image, cmap='gray_r') candidates = [] predictions = [] for region in regionprops(label_image): # skip small images # if region.area < 100: # continue # draw rectangle around segmented coins minr, minc, maxr, maxc = region.bbox # make regions square maxwidth = np.max([maxr - minr, maxc - minc]) minr, maxr = int(0.5 * ((maxr + minr) - maxwidth)) - 3, int(0.5 * ((maxr + minr) + maxwidth)) + 3 minc, maxc = int(0.5 * ((maxc + minc) - maxwidth)) - 3, int(0.5 * ((maxc + minc) + maxwidth)) + 3 rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr, fill=False, edgecolor='red', linewidth=2, alpha=0.2) plt.gca().add_patch(rect) # predict digit candidate = image[minr:maxr, minc:maxc] candidate = np.array(imresize(candidate, size), dtype=float) # invert # candidate = np.max(candidate) - candidate # print im # rescale to 16 in integer candidate = (candidate - np.min(candidate)) if np.max(candidate) == 0: continue candidate /= np.max(candidate) candidate[candidate < 0.2] = 0.0 candidate *= 16 candidate = np.array(candidate, dtype=int) prediction = clf.predict(candidate.reshape(-1)) candidates.append(candidate) predictions.append(prediction) plt.text(minc - 10, minr - 10, "{}".format(prediction), fontsize=50) plt.xticks([], []) plt.yticks([], []) plt.tight_layout() plt.show() return candidates, predictions
def pos_firmA_over_pos_firmB(file_name, folder=None): if folder is None: folder = "data/figures" os.makedirs(folder, exist_ok=True) bkp = backup.RunBackup.load(file_name=file_name) pos = bkp.positions[-1000:] fig = plt.figure() ax = fig.add_subplot(111) ax.scatter(pos[:, 0], pos[:, 1], color="black", alpha=0.05) ax.axvline(0.5, color="white", linewidth=0.5, linestyle="--") ax.axhline(0.5, color="white", linewidth=0.5, linestyle="--") plt.xlim(-1, bkp.parameters.n_positions) plt.ylim(-1, bkp.parameters.n_positions) plt.xticks( range(0, bkp.parameters.n_positions + 1, round(bkp.parameters.n_positions / 5))) plt.yticks( range(0, bkp.parameters.n_positions + 1, round(bkp.parameters.n_positions / 5))) plt.xlabel("Position A") plt.ylabel("Position B") plt.text(0.005, 0.005, file_name, transform=fig.transFigure, fontsize='x-small', color='0.5') plt.title("$r={:.2f}$".format(bkp.field_of_view / 2)) ax.set_aspect(1) plt.tight_layout() plt.savefig("{}/{}_evo_positions.pdf".format(folder, file_name)) plt.show()
def plot_proportions(self): # Container for proportions of agents having this or that in hand according to their type # - rows: type of agent # - columns: type of good fig = plt.figure(figsize=(25, 12)) fig.patch.set_facecolor('white') n_lines = self.n_goods n_columns = 1 x = np.arange(len(self.proportions)) for agent_type in range(self.n_goods): # First subplot ax = plt.subplot(n_lines, n_columns, agent_type + 1) ax.set_title( "Proportion of agents of type {} having good i in hand\n". format(agent_type)) y = [] for i in range(self.n_goods): y.append([]) for proportions_at_t in self.proportions: for good in range(self.n_goods): y[good].append(proportions_at_t[agent_type, good]) ax.set_ylim([-0.02, 1.02]) for good in range(self.n_goods): ax.plot(x, y[good], label="Good {}".format(good), linewidth=2) ax.legend() plt.tight_layout() plt.savefig(filename=self.proportions_figure_name)
def savePdfPage( self ): # Delete any unused subplots if self.subPlots < self.spots: print self.axarr for i in range( self.subPlots, self.spots ): print "Deleting subplot with id: ",i self.fig.delaxes( self.getActiveAx() ) self.subPlots += 1 # Ensure tight layout so everything is visible plt.tight_layout() # Do the save print "Saving pdf page" self.pp.savefig( self.fig, dpi=100 ) # Clear figures plt.cla() # We have to explicitly clear color bars due to the way they are added self.clearColorbars()
def pos_firmA_over_pos_firmB(backup, fig_name): os.makedirs(os.path.dirname(fig_name), exist_ok=True) position_max = backup.parameters.n_positions - 1 pos = backup.positions[-1000:] / position_max fig = plt.figure() ax = fig.add_subplot(111) ax.scatter(pos[:, 0], pos[:, 1], color="black", alpha=0.05, zorder=10) ax.axvline(0.5, color="0.5", linewidth=0.5, linestyle="--", zorder=1) ax.axhline(0.5, color="0.5", linewidth=0.5, linestyle="--", zorder=1) plt.xlim(0, 1) plt.ylim(0, 1) plt.xticks((0, 0.5, 1)) plt.yticks((0, 0.5, 1)) plt.xlabel("Position $a$") plt.ylabel("Position $b$") for tick in ax.get_xticklabels(): tick.set_fontsize("small") for tick in ax.get_yticklabels(): tick.set_fontsize("small") plt.title("$r={:.2f}$".format(backup.parameters.r)) ax.set_aspect(1) # Cut margins plt.tight_layout() # Save fig plt.savefig(fig_name) plt.close()
Fv = [] # For each frequency bin, estimate the stats t_init = time() for t in time_bins: covmats = covest.fit_transform(epochs_data[:, ::1, t:(t+window)]) p_test = PermutationDistance(1000, metric='riemann', mode='pairwise') p, F = p_test.test(covmats, labels, verbose=False) pv.append(p) Fv.append(F[0]) duration = time() - t_init # plot result fig, axes = plt.subplots(1, 1, figsize=[6, 3], sharey=True) sig = 0.05 times = np.array(time_bins)/float(Fs) + tmin axes.plot(times, Fv, lw=2, c='k') plt.xlabel('Time (sec)') plt.ylabel('Score') a = np.where(np.diff(np.array(pv) < sig))[0] a = a.reshape(int(len(a)/2), 2) st = (times[1] - times[0])/2.0 for p in a: axes.axvspan(times[p[0]]-st, times[p[1]]+st, facecolor='g', alpha=0.5) axes.legend(['Score', 'p<%.2f' % sig]) axes.set_title('Pairwise distance - %.1f sec.' % duration) sns.despine() plt.tight_layout() plt.show()
def analyse_profits(pool_backup, file_name="", folder=None): """ Expected running_mode is 'discrete' :param pool_backup: :param file_name: :param folder: :return: """ if folder is None: folder = "data/figures" os.makedirs(folder, exist_ok=True) def f_cond(xx): if xx < 0.25: return 0 elif xx < 0.5: return 1 elif xx < 0.75: return 2 else: return 3 n_pools = 4 labels = [ "0 <= FoV < 0.25", "0.25 <= FoV < 0.50", "0.50 <= FoV < 0.75", "0.75 <= FoV <= 1" ] parameters = pool_backup.parameters backups = pool_backup.backups assert backups[ 0].running_mode == "discrete", "Expected running_mode is 'discrete'" profit_max = parameters.n_positions * parameters.n_prices * parameters.unit_value x = range(parameters.t_max) for_y = [[[] for j in range(parameters.t_max)] for i in range(n_pools)] for i, b in tqdm.tqdm(enumerate(backups), total=len(backups)): cond = f_cond(b.field_of_view) for t in range(parameters.t_max): for_y[cond][t].append(np.mean(b.profits[t, :]) / profit_max) for i in range(n_pools): y = np.array([np.mean(for_y[i][t]) for t in range(parameters.t_max)]) y_err = np.array( [np.std(for_y[i][t]) for t in range(parameters.t_max)]) plt.plot(x, y, label=labels[i]) plt.fill_between(x, y - (y_err / 2), y + (y_err / 2), color="C{}".format(i), alpha=.25) plt.legend() plt.xlabel("t") plt.ylabel("Mean profit") if file_name: plt.title(file_name) plt.tight_layout() if file_name: plt.savefig("{}/{}_mean_profit_{}_cat.pdf".format( folder, file_name, n_pools)) plt.show()
def plot_variable(u, name, direc, cmap=cmaps.parula, scale='lin', numLvls=100, umin=None, umax=None, \ tp=False, \ tpAlpha=1.0, show=False, hide_ax_tick_labels=False, label_axes=True, title='', use_colorbar=True, hide_axis=False, colorbar_loc='right'): """ show -- whether to show the plot on the screen tp -- show triangle cmap -- colors: gist_yarg - grey gnuplot, hsv, gist_ncar jet - typical colors """ mesh = u.function_space().mesh() v = u.compute_vertex_values(mesh) x = mesh.coordinates()[:,0] y = mesh.coordinates()[:,1] t = mesh.cells() if not os.path.isdir( direc ): os.makedirs(direc) full_path = os.path.join(direc, name) if umin != None: vmin = umin else: vmin = v.min() if umax != None: vmax = umax else: vmax = v.max() # countour levels : if scale == 'log': v[v < vmin] = vmin + 1e-12 v[v > vmax] = vmax - 1e-12 from matplotlib.ticker import LogFormatter levels = np.logspace(np.log10(vmin), np.log10(vmax), numLvls) tick_numLvls = min( numLvls, 8 ) tick_levels = np.logspace(np.log10(vmin), np.log10(vmax), tick_numLvls) formatter = LogFormatter(10, labelOnlyBase=False) norm = colors.LogNorm() elif scale == 'lin': v[v < vmin] = vmin + 1e-12 v[v > vmax] = vmax - 1e-12 from matplotlib.ticker import ScalarFormatter levels = np.linspace(vmin, vmax, numLvls) tick_numLvls = min( numLvls, 8 ) tick_levels = np.linspace(vmin, vmax, tick_numLvls) formatter = ScalarFormatter() norm = None elif scale == 'bool': from matplotlib.ticker import ScalarFormatter levels = [0, 1, 2] formatter = ScalarFormatter() norm = None fig = plt.figure(figsize=(5,5)) ax = fig.add_subplot(111) c = ax.tricontourf(x, y, t, v, levels=levels, norm=norm, cmap=plt.get_cmap(cmap)) plt.axis('equal') if tp == True: p = ax.triplot(x, y, t, '-', lw=0.2, alpha=tpAlpha) ax.set_xlim([x.min(), x.max()]) ax.set_ylim([y.min(), y.max()]) if label_axes: ax.set_xlabel(r'$x$') ax.set_ylabel(r'$y$') if hide_ax_tick_labels: ax.set_xticklabels([]) ax.set_yticklabels([]) if hide_axis: plt.axis('off') # include colorbar : if scale != 'bool' and use_colorbar: divider = make_axes_locatable(plt.gca()) cax = divider.append_axes(colorbar_loc, "5%", pad="3%") cbar = plt.colorbar(c, cax=cax, format=formatter, ticks=tick_levels) tit = plt.title(title) if use_colorbar: plt.tight_layout(rect=[.03,.03,0.97,0.97]) else: plt.tight_layout() plt.savefig( full_path + '.eps', dpi=300) if show: plt.show() plt.close(fig)
def mkplots(self): # run to make plots of the resulting posteriors. Modified from marginal_plots.py # from pymultinest. Produces basename+marg.pdf and basename+marge.png files prefix = self.basename parameters = json.load(file(prefix + 'params.json')) n_params = len(parameters) a = pymultinest.Analyzer(n_params=n_params, outputfiles_basename=prefix) s = a.get_stats() p = pymultinest.PlotMarginal(a) try: values = a.get_equal_weighted_posterior() except IOError as e: print 'Unable to open: %s' % e return assert n_params == len(s['marginals']) modes = s['modes'] dim2 = os.environ.get('D', '1' if n_params > 20 else '2') == '2' nbins = 100 if n_params < 3 else 20 if dim2: plt.figure(figsize=(5.1 * n_params, 5 * n_params)) for i in range(n_params): plt.subplot(n_params, n_params, i + 1) plt.xlabel(parameters[i]) m = s['marginals'][i] plt.xlim(m['5sigma']) oldax = plt.gca() x, w, patches = oldax.hist(values[:, i], bins=nbins, edgecolor='grey', color='grey', histtype='stepfilled', alpha=0.2) oldax.set_ylim(0, x.max()) newax = plt.gcf().add_axes(oldax.get_position(), sharex=oldax, frameon=False) p.plot_marginal(i, ls='-', color='blue', linewidth=3) newax.set_ylim(0, 1) ylim = newax.get_ylim() y = ylim[0] + 0.05 * (ylim[1] - ylim[0]) center = m['median'] low1, high1 = m['1sigma'] print center, low1, high1 newax.errorbar(x=center, y=y, xerr=np.transpose( [[center - low1, high1 - center]]), color='blue', linewidth=2, marker='s') oldax.set_yticks([]) #newax.set_yticks([]) newax.set_ylabel("Probability") ylim = oldax.get_ylim() newax.set_xlim(m['5sigma']) oldax.set_xlim(m['5sigma']) #plt.close() for j in range(i): plt.subplot(n_params, n_params, n_params * (j + 1) + i + 1) p.plot_conditional(i, j, bins=20, cmap=plt.cm.gray_r) for m in modes: plt.errorbar(x=m['mean'][i], y=m['mean'][j], xerr=m['sigma'][i], yerr=m['sigma'][j]) ax = plt.gca() if j == i - 1: plt.xlabel(parameters[i]) plt.ylabel(parameters[j]) [l.set_rotation(45) for l in ax.get_xticklabels()] else: ax.set_xticklabels([]) ax.set_yticklabels([]) plt.xlim([ m['mean'][i] - 5 * m['sigma'][i], m['mean'][i] + 5 * m['sigma'][i] ]) plt.ylim([ m['mean'][j] - 5 * m['sigma'][j], m['mean'][j] + 5 * m['sigma'][j] ]) #plt.savefig('cond_%s_%s.pdf' % (params[i], params[j]), bbox_tight=True) #plt.close() plt.tight_layout() plt.savefig(prefix + 'marg.pdf') plt.savefig(prefix + 'marg.png') plt.close() else: from matplotlib.backends.backend_pdf import PdfPages print '1dimensional only. Set the D environment variable D=2 to force' print '2d marginal plots.' pp = PdfPages(prefix + 'marg1d.pdf') for i in range(n_params): plt.figure(figsize=(5, 5)) plt.xlabel(parameters[i]) m = s['marginals'][i] plt.xlim(m['5sigma']) oldax = plt.gca() x, w, patches = oldax.hist(values[:, i], bins=20, edgecolor='grey', color='grey', histtype='stepfilled', alpha=0.2) oldax.set_ylim(0, x.max()) newax = plt.gcf().add_axes(oldax.get_position(), sharex=oldax, frameon=False) p.plot_marginal(i, ls='-', color='blue', linewidth=3) newax.set_ylim(0, 1) ylim = newax.get_ylim() y = ylim[0] + 0.05 * (ylim[1] - ylim[0]) center = m['median'] low1, high1 = m['1sigma'] print center, low1, high1 newax.errorbar(x=center, y=y, xerr=np.transpose( [[center - low1, high1 - center]]), color='blue', linewidth=2, marker='s') oldax.set_yticks([]) newax.set_ylabel("Probability") ylim = oldax.get_ylim() newax.set_xlim(m['5sigma']) oldax.set_xlim(m['5sigma']) plt.savefig(pp, format='pdf', bbox_inches='tight') plt.close() pp.close()
def plot(data): gs = gridspec.GridSpec(2, 2, width_ratios=[1, 1.5]) plt.figure(figsize=(9, 4)) # -------------------------- Nationalities hist ---------------------------------- # ax = plt.subplot(gs[:, 0]) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.spines['left'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.tick_params(length=0) plt.title("Nationality") # data dic_nationality = {} for n in np.unique(data.nationality): dic_nationality[n] = np.sum(data.nationality == n) nationalities = sorted(dic_nationality.items(), key=operator.itemgetter(1)) labels = [i[0].capitalize() for i in nationalities] labels_pos = np.arange(len(labels)) values = [round((i[1] / len(data.age)) * 100, 2) for i in nationalities] # text ax.set_yticks(labels_pos) ax.set_yticklabels(labels) ax.set_xticks([]) for i, v in enumerate(values): ax.text(v + 1, i - 0.05, "{:.2f}%".format(v)) # create ax.barh(labels_pos, values, edgecolor="white", align="center", alpha=0.5) # -------------------------- Gender pie ---------------------------------- # ax = plt.subplot(gs[0, 1]) ax.axis('equal') plt.title("Gender") # get data genders = np.unique(data.gender) labels = [i.capitalize() for i in genders] values = [np.sum(data.gender == i) for i in genders] # create ax.pie(values, labels=labels, explode=(0.01, 0.05), autopct='%1.1f%%', startangle=90, shadow=False) # -------------------------- Age hist ---------------------------------- # ax = plt.subplot(gs[1, 1]) plt.title("Age", y=1.05) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.spines['left'].set_visible(False) ax.tick_params(length=0) # get data n_ages = len(data.age) ages = [ list(i[1]) for i in itertools.groupby(sorted(data.age), lambda x: x // 10) ] decades = [ "{}0-{}9".format(int(i[0] / 10), int(i[0] / 10)) if i[0] >= 20 else "18-19" for i in ages ] decades_pos = np.arange(len(decades)) values = np.array([round((len(i) / n_ages) * 100) for i in ages]) # text ax.set_xticks(decades_pos) ax.set_xticklabels(decades) ax.set_yticks([]) for i, v in enumerate(values): ax.text(i - 0.1, v + 1, "{}%".format(v)) ax.text( 3.5, 20, "Mean: {:.2f} $\pm$ {:.2f} (SD)".format(np.mean(data.age), np.std(data.age))) # create ax.bar(decades_pos, values, edgecolor="white", align="center", alpha=0.5) plt.tight_layout() plt.savefig("fig/demographics.pdf") plt.show()
def distance_over_fov(file_name, pool_backup, fig_folder=None): span_ratio = 0.33 if fig_folder is None: fig_folder = "data/figures" os.makedirs(fig_folder, exist_ok=True) parameters = pool_backup.parameters backups = pool_backup.backups n_simulations = parameters.n_simulations n_positions = parameters.n_positions p_max = parameters.p_max # Compute profit max profit_max = n_positions * p_max # Containers x = np.zeros(n_simulations) y = np.zeros(n_simulations) y_err = np.zeros(n_simulations) z = np.zeros(n_simulations) # How many time steps from the end of the simulation are included in analysis span = int(span_ratio * parameters.t_max) for i, b in enumerate(backups): try: # Save the parameter that affected the customers field of view x[i] = b.field_of_view / 2 except AttributeError: x[i] = b.parameters.r # Compute the mean distance between the two firms data = np.absolute(b.positions[-span:, 0] - b.positions[-span:, 1]) / n_positions spacing = np.mean(data) spacing_std = np.std(data) y[i] = spacing y_err[i] = spacing_std # Get mean profits z[i] = np.mean(b.profits[-span:, :]) / profit_max # Plot this fig = plt.figure(figsize=(10, 6)) ax = plt.subplot() ax.set_xlim(-0.01, 1.01) if max(y) < 0.5: ax.set_ylim(-0.01, 0.51) ax.set_xticks(np.arange(0, 1.1, 0.25)) ax.set_yticks(np.arange(0, 0.51, 0.1)) ax.set_xlabel("$r$") ax.set_ylabel("Mean distance") ax.set_title("Mean distance between firms over $r$") # add comment with file name plt.text(0.005, 0.005, file_name, transform=fig.transFigure, fontsize='x-small', color='0.5') # show random plt.text(0.005, 0.005, file_name, transform=fig.transFigure, fontsize='x-small', color='0.5') abc = ax.scatter(x, y, c=z, zorder=10, alpha=0.25) fig.colorbar(abc, label="Profits") plt.tight_layout() if file_name: plt.savefig("{}/{}.pdf".format(fig_folder, file_name)) plt.show()
def distance(pool_backup, fig_name=None, ax=None): # Shortcuts parameters = pool_backup.parameters backups = pool_backup.backups # Look at the parameters n_simulations = len(parameters["seed"]) n_positions = parameters["n_positions"] t_max = parameters["t_max"] # Containers x = np.zeros(n_simulations) y = np.zeros(n_simulations) z = np.zeros(n_simulations) y_err = np.zeros(n_simulations) # How many time steps from the end of the simulation are included in analysis span_ratio = 0.33 # Take last third span = int(span_ratio * t_max) for i, b in enumerate(backups): x[i] = b.parameters.r # Compute the mean distance between the two firms data = np.absolute( b.positions[-span:, 0] - b.positions[-span:, 1]) / n_positions spacing = np.mean(data) y[i] = spacing # Get std y_err[i] = np.std(data) # Get mean profits z[i] = np.mean(b.profits[-span:, :]) # Plot this if ax is None: fig = plt.figure(figsize=(5, 5), dpi=200) ax = fig.add_subplot() # Enhance aesthetics ax.set_xlim(-0.009, 1.005) ax.set_ylim(-0.009, 1.005) # if max(y) < 0.5: # ax.set_ylim(-0.01, 0.51) ax.set_xticks(np.arange(0, 1.1, 0.25)) ax.set_yticks(np.arange(0, 1.1, 0.25)) ax.set_xlabel("$r$") ax.set_ylabel("Distance") # ax.set_title("Mean distance between firms over $r$") # Display line for indicating 'random' level # seed = 123 # np.random.seed(seed) # random_pos = np.random.random(size=(2, 10 ** 6)) # random_dist = np.mean(np.absolute(random_pos[0] - random_pos[1])) # ax.axhline(random_dist, color='0.5', linewidth=0.5, linestyle="--", zorder=1) # if color: # _color(fig=fig, ax=ax, x=x, y=y, z=z) # else: _bw(ax=ax, x=x, y=y, y_err=y_err) if fig_name: # Cut the margins plt.tight_layout() # Create directories if not already existing os.makedirs(os.path.dirname(fig_name), exist_ok=True) # Save fig plt.savefig(fig_name) plt.close()
def plot(results, parameters, fig_name): # What is common to all subplots fig = plt.figure(figsize=(25, 12)) fig.patch.set_facecolor('white') line_width = 2 n_lines = 3 n_columns = 3 counter = it.count(1) # ----- FOR EACH GENERATION ------ # # FITNESS x = range(len(results["fitness"])) y = results["fitness"] ax = plt.subplot(n_lines, n_columns, next(counter)) ax.set_title("Fitness average\naccording to number of generations\n") ax.plot(x, y, linewidth=line_width) # PROPORTION OF EACH TYPE OF EXCHANGE x_max = len(results["exchanges"]) x = range(x_max) ax = plt.subplot(n_lines, n_columns, next(counter)) ax.set_title( "Proportion of each type of exchange\naccording to number of generations\n" ) type_of_exchanges = sorted([i for i in results["exchanges"][0].keys()]) y = [] for i in range(len(type_of_exchanges)): y.append([]) for i in range(x_max): for exchange_idx in range(len(type_of_exchanges)): y[exchange_idx].append( results["exchanges"][i][type_of_exchanges[exchange_idx]]) ax.set_ylim([-0.02, 1.02]) for exchange_idx in range(len(type_of_exchanges)): ax.plot(x, y[exchange_idx], label="Exchange {}".format(type_of_exchanges[exchange_idx]), linewidth=line_width) ax.legend(fontsize=8) # NUMBER OF EXCHANGES GENERATION x = range(len(results["n_exchanges"])) y = results["n_exchanges"] ax = plt.subplot(n_lines, n_columns, next(counter)) ax.set_title( "Total number of exchanges\naccording to number of generations\n") ax.plot(x, y, linewidth=line_width) # NUMBER OF INTERVENTION OF EACH GOOD x_max = len(results["n_exchanges"]) x = range(x_max) y = [] for i in range(len(results["n_goods_intervention"][0].keys())): y.append([]) for i in range(x_max): for key in results["n_goods_intervention"][0].keys(): y[key].append(results["n_goods_intervention"][i][key]) ax = plt.subplot(n_lines, n_columns, next(counter)) ax.set_title( "Number of interventions of each good\naccording to number of generations\n" ) for key in results["n_goods_intervention"][0].keys(): ax.plot(x, y[key], label="Good {}".format(key), linewidth=line_width) ax.legend(fontsize=8) # DIVERSITY OF PRODUCTION x = range(len(results["production_diversity"])) y = results["production_diversity"] ax = plt.subplot(n_lines, n_columns, next(counter)) ax.set_title("Production diversity\naccording to number of generations\n") ax.plot(x, y, linewidth=line_width) # N PRODUCERS n_goods = len(results["n_producers"][0]) ax = plt.subplot(n_lines, n_columns, next(counter)) ax.set_title("Number of producers for each good \n") for i in range(n_goods): y = [j[i] for j in results["n_producers"]] x = range(len(y)) ax.plot(x, y, linewidth=line_width, label="Good {}".format(i)) ax.legend(fontsize=8) # GLOBAL PRODUCTION n_goods = len(results["production"][0]) ax = plt.subplot(n_lines, n_columns, next(counter)) ax.set_title("Global production for each good \n") for i in range(n_goods): y = [j[i] for j in results["production"]] x = range(len(y)) ax.plot(x, y, linewidth=line_width, label="Good {}".format(i)) ax.legend(fontsize=8) # ------ PARAMETERS ----- # # 5th subplot: PARAMETERS ax = plt.subplot(n_lines, n_columns, next(counter)) ax.set_title("Parameters") ax.axis('off') msg = "" for key in sorted(parameters.keys()): msg += "{}: {}; \n".format(key, parameters[key]) ax.text(0.5, 0.5, msg, ha='center', va='center', size=12) plt.tight_layout() plt.savefig(fig_name) plt.close()
def profits_over_distance(file_name, folder=None, separate_A_and_B=True): if folder is None: folder = "data/figures" os.makedirs(folder, exist_ok=True) pool_backup = backup.PoolBackup.load(file_name=file_name) parameters = pool_backup.parameters backups = pool_backup.backups n_simulations = parameters.n_simulations # Containers x = np.zeros(n_simulations) y = np.zeros((2, n_simulations)) for i, b in enumerate(backups): # Compute the mean distance between the two firms data = np.absolute(b.positions[:, 0] - b.positions[:, 1]) / parameters.n_positions spacing = np.mean(data) x[i] = spacing # Get profits profit_max = parameters.n_positions * parameters.n_prices * parameters.unit_value for f in range(2): y[f, i] = np.mean(b.profits[:, f]) / profit_max # Plot this fig = plt.figure(figsize=(10, 6)) ax = plt.subplot() # ax.set_xlim(-0.01, 1.01) # ax.set_ylim(-0.01, 0.51) ax.set_xticks(np.arange(0, 1.1, 0.25)) ax.set_yticks(np.arange(0, 0.51, 0.1)) add_title_and_labels(ax) add_comment_with_file_name(fig=fig, file_name=file_name) if separate_A_and_B is True: ax.scatter(x, y[0], zorder=10, alpha=0.25, label="Firm A") ax.scatter(x, y[1], zorder=10, alpha=0.25, label="Firm B") add_fitting_curve(ax=ax, x=x, y=y[0]) add_fitting_curve(ax=ax, x=x, y=y[1]) plt.legend() else: ax.scatter(x, np.mean(y, axis=0), zorder=10, alpha=0.25, color="black") plt.tight_layout() if file_name: plt.savefig("{}/{}_profits_over_distance.pdf".format( folder, file_name)) plt.show()
def distance_over_fov(pool_backup, fig_name): # Create directories if not already existing os.makedirs(os.path.dirname(fig_name), exist_ok=True) # Shortcuts parameters = pool_backup.parameters backups = pool_backup.backups # Look at the parameters n_simulations = len(parameters["seed"]) n_positions = parameters["n_positions"] t_max = parameters["t_max"] # Containers x = np.zeros(n_simulations) y = np.zeros(n_simulations) y_err = np.zeros(n_simulations) z = np.zeros(n_simulations) # How many time steps from the end of the simulation are included in analysis span_ratio = 0.33 # Take last third span = int(span_ratio * t_max) for i, b in enumerate(backups): x[i] = b.parameters.r # Compute the mean distance between the two firms data = np.absolute( b.positions[-span:, 0] - b.positions[-span:, 1]) / n_positions spacing = np.mean(data) spacing_std = np.std(data) y[i] = spacing y_err[i] = spacing_std # Get mean profits z[i] = np.mean(b.profits[-span:, :]) # Plot this fig = plt.figure(figsize=(10, 6)) ax = plt.subplot() # Enhance aesthetics ax.set_xlim(-0.01, 1.01) if max(y) < 0.5: ax.set_ylim(-0.01, 0.51) ax.set_xticks(np.arange(0, 1.1, 0.25)) ax.set_yticks(np.arange(0, 0.51, 0.1)) ax.set_xlabel("$r$") ax.set_ylabel("Mean distance") ax.set_title("Mean distance between firms over $r$") # Display line for indicating 'random' level seed = 123 np.random.seed(seed) random_pos = np.random.random(size=(2, 10 ** 6)) random_dist = np.mean(np.absolute(random_pos[0] - random_pos[1])) ax.axhline(random_dist, color='0.5', linewidth=0.5, linestyle="--", zorder=1) # Do the scatter plot scat = ax.scatter(x, y, c=z, zorder=10, alpha=0.25) # Add a color bar fig.colorbar(scat, label="Profits") # Cut the margins plt.tight_layout() # Save fig plt.savefig(fig_name) plt.close()
def main(force): backups = backup.get_data(force) bins = np.arange(0, 3800, 500) bounds = ["{}~{}".format(i, j) for i, j in zip(bins[:-1], bins[1:])] fig = plt.figure(figsize=(12, 8)) axes = fig.add_subplot(211), fig.add_subplot(212) for s, ax in zip((1, 0), axes): scores = {0.25: [], 0.5: []} for b in backups: if b.pvp and b.display_opponent_score is bool(s): for player in (0, 1): sum_profit = np.sum(b.profits[:, player]) scores[b.r].append(sum_profit) if np.max([max(i) for i in scores.values()]) > max(bins): raise Exception("Max bound has been reached") y_upper_bound = 55 ind = np.arange(len(bins) - 1) for r, color in zip((0.25, 0.50), ("C0", "C1")): sc = np.array(scores[r]) print( "Score (r = {:.2f}, s = {}) mean: {:.2f}, std: {:.2f}, min:{}, max: {}" .format(r, s, np.mean(sc), np.std(sc), np.min(sc), np.max(sc))) d = np.digitize(sc, bins=bins) n = len(sc) y = [] for i in ind: y.append(len(sc[d == i]) / n * 100) if np.max(y) > y_upper_bound: raise Exception( "Max bound has been reached ({:.2f} > {})".format( np.max(y), y_upper_bound)) width = 0.35 # the width of the bars ax.bar(ind - width / 2 if r == 0.25 else ind + width / 2, y, width, label='r = {:.2f}'.format(r), alpha=0.5, edgecolor=color) ax.set_xticks(ind) ax.set_xticklabels(bounds, fontsize=8) ax.set_ylim(0, y_upper_bound) ax.set_ylabel("Proportion (%)") ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.tick_params(length=0) ax.set_title('s = {}'.format(s)) plt.tight_layout() plt.legend() plt.savefig("fig/pool_score_distribution.pdf") plt.show()
def mkplots(self): # run to make plots of the resulting posteriors. Modified from marginal_plots.py # from pymultinest. Produces basename+marg.pdf and basename+marge.png files prefix = self.basename parameters = json.load(file(prefix + 'params.json')) n_params = len(parameters) a = pymultinest.Analyzer(n_params = n_params, outputfiles_basename = prefix) s = a.get_stats() p = pymultinest.PlotMarginal(a) try: values = a.get_equal_weighted_posterior() except IOError as e: print 'Unable to open: %s' % e return assert n_params == len(s['marginals']) modes = s['modes'] dim2 = os.environ.get('D', '1' if n_params > 20 else '2') == '2' nbins = 100 if n_params < 3 else 20 if dim2: plt.figure(figsize=(5.1*n_params, 5*n_params)) for i in range(n_params): plt.subplot(n_params, n_params, i + 1) plt.xlabel(parameters[i]) m = s['marginals'][i] plt.xlim(m['5sigma']) oldax = plt.gca() x,w,patches = oldax.hist(values[:,i], bins=nbins, edgecolor='grey', color='grey', histtype='stepfilled', alpha=0.2) oldax.set_ylim(0, x.max()) newax = plt.gcf().add_axes(oldax.get_position(), sharex=oldax, frameon=False) p.plot_marginal(i, ls='-', color='blue', linewidth=3) newax.set_ylim(0, 1) ylim = newax.get_ylim() y = ylim[0] + 0.05*(ylim[1] - ylim[0]) center = m['median'] low1, high1 = m['1sigma'] print center, low1, high1 newax.errorbar(x=center, y=y, xerr=np.transpose([[center - low1, high1 - center]]), color='blue', linewidth=2, marker='s') oldax.set_yticks([]) #newax.set_yticks([]) newax.set_ylabel("Probability") ylim = oldax.get_ylim() newax.set_xlim(m['5sigma']) oldax.set_xlim(m['5sigma']) #plt.close() for j in range(i): plt.subplot(n_params, n_params, n_params * (j + 1) + i + 1) p.plot_conditional(i, j, bins=20, cmap = plt.cm.gray_r) for m in modes: plt.errorbar(x=m['mean'][i], y=m['mean'][j], xerr=m['sigma'][i], yerr=m['sigma'][j]) ax = plt.gca() if j == i-1: plt.xlabel(parameters[i]) plt.ylabel(parameters[j]) [l.set_rotation(45) for l in ax.get_xticklabels()] else: ax.set_xticklabels([]) ax.set_yticklabels([]) plt.xlim([m['mean'][i]-5*m['sigma'][i],m['mean'][i]+5*m['sigma'][i]]) plt.ylim([m['mean'][j]-5*m['sigma'][j],m['mean'][j]+5*m['sigma'][j]]) #plt.savefig('cond_%s_%s.pdf' % (params[i], params[j]), bbox_tight=True) #plt.close() plt.tight_layout() plt.savefig(prefix + 'marg.pdf') plt.savefig(prefix + 'marg.png') plt.close() else: from matplotlib.backends.backend_pdf import PdfPages print '1dimensional only. Set the D environment variable D=2 to force' print '2d marginal plots.' pp = PdfPages(prefix + 'marg1d.pdf') for i in range(n_params): plt.figure(figsize=(5, 5)) plt.xlabel(parameters[i]) m = s['marginals'][i] plt.xlim(m['5sigma']) oldax = plt.gca() x,w,patches = oldax.hist(values[:,i], bins=20, edgecolor='grey', color='grey', histtype='stepfilled', alpha=0.2) oldax.set_ylim(0, x.max()) newax = plt.gcf().add_axes(oldax.get_position(), sharex=oldax, frameon=False) p.plot_marginal(i, ls='-', color='blue', linewidth=3) newax.set_ylim(0, 1) ylim = newax.get_ylim() y = ylim[0] + 0.05*(ylim[1] - ylim[0]) center = m['median'] low1, high1 = m['1sigma'] print center, low1, high1 newax.errorbar(x=center, y=y, xerr=np.transpose([[center - low1, high1 - center]]), color='blue', linewidth=2, marker='s') oldax.set_yticks([]) newax.set_ylabel("Probability") ylim = oldax.get_ylim() newax.set_xlim(m['5sigma']) oldax.set_xlim(m['5sigma']) plt.savefig(pp, format='pdf', bbox_inches='tight') plt.close() pp.close()
def plotIce(di, u, name, direc, u2=None, u2_levels=None, u2_color='k', title='', cmap='gist_yarg', scale='lin', umin=None, umax=None, numLvls=12, levels=None, levels_2=None, tp=False, tpAlpha=0.5, contour_type='filled', params=None, extend='neither', show=True, ext='.png', res=150, cb=True, cb_format='%.1e', zoom_box=False, zoom_box_kwargs=None, plot_pts=None, plot_continent=False, cont_plot_params=None, box_params=None): """ Args: :di: DataInput object with desired projection :u: solution to plot; can be either a function on a 2D mesh, or a string key to matrix variable in <di>.data. :name: title of the plot, latex accepted :direc: directory string location to save image. :cmap: colormap to use - see images directory for sample and name :scale: scale to plot, either 'log', 'lin', or 'bool' :numLvls: number of levels for field values :levels: manual levels, if desired. :tp: boolean determins plotting of triangle overlay :tpAlpha: alpha level of triangles 0.0 (transparent) - 1.0 (opaque) :extends: for the colorbar, extend upper range and may be ["neither", "both", "min", "max"]. default is "neither". for plotting the zoom-box, make <zoom_box> = True and supply dict *zoom_box_kwargs* with parameters :zoom: ammount to zoom :loc: location of box :loc1: loc of first line :loc2: loc of second line :x1: first x-coord :y1: first y-coord :x2: second x-coord :y2: second y-coord :scale_font_color: scale font color :scale_length: scale length in km :scale_loc: 1=top, 2=bottom :plot_grid: plot the triangles :axes_color: color of axes :plot_points: dict of points to plot Returns: A sigle *direc/name.ext* in the source directory. """ # get the original projection coordinates and data : if isinstance(u, str): s = "::: plotting %s's \"%s\" field data directly :::" % (di.name, u) print_text(s, '242') vx, vy = np.meshgrid(di.x, di.y) v = di.data[u] elif isinstance(u, Function) \ or isinstance(u, dolfin.functions.function.Function): s = "::: plotting FEniCS Function \"%s\" :::" % name print_text(s, '242') mesh = u.function_space().mesh() coord = mesh.coordinates() fi = mesh.cells() v = u.compute_vertex_values(mesh) vx = coord[:, 0] vy = coord[:, 1] # get the projection info : if isinstance(di, dict) and 'pyproj_Proj' in di.keys() \ and 'continent' in di.keys(): lon, lat = di['pyproj_Proj'](vx, vy, inverse=True) cont = di['continent'] elif isinstance(di, DataInput): lon, lat = di.proj(vx, vy, inverse=True) cont = di.cont else: s = ">>> plotIce REQUIRES A 'DataFactory' DICTIONARY FOR " + \ "PROJECTION STORED AS KEY 'pyproj_Proj' AND THE CONTINENT TYPE " + \ "STORED AS KEY 'continent' <<<" print_text(s, 'red', 1) sys.exit(1) # Antarctica : if params is None: if cont is 'antarctica': w = 5513335.22665 h = 4602848.6605 fig = plt.figure(figsize=(14, 10)) ax = fig.add_subplot(111) lon_0 = 0 lat_0 = -90 # new projection : m = Basemap(ax=ax, width=w, height=h, resolution='h', projection='stere', lat_ts=-71, lon_0=lon_0, lat_0=lat_0) offset = 0.015 * (m.ymax - m.ymin) # draw lat/lon grid lines every 5 degrees. # labels = [left,right,top,bottom] m.drawmeridians(np.arange(0, 360, 20.0), color='black', labels=[True, False, True, True]) m.drawparallels(np.arange(-90, 90, 5.0), color='black', labels=[True, False, True, True]) m.drawmapscale(-130, -68, 0, -90, 400, yoffset=offset, barstyle='fancy') # Greenland : elif cont is 'greenland': w = 1532453.49654 h = 2644074.78236 fig = plt.figure(figsize=(8, 11.5)) ax = fig.add_subplot(111) lon_0 = -41.5 lat_0 = 71 # new projection : m = Basemap(ax=ax, width=w, height=h, resolution='h', projection='stere', lat_ts=71, lon_0=lon_0, lat_0=lat_0) offset = 0.015 * (m.ymax - m.ymin) # draw lat/lon grid lines every 5 degrees. # labels = [left,right,top,bottom] m.drawmeridians(np.arange(0, 360, 5.0), color='black', labels=[False, False, False, True]) m.drawparallels(np.arange(-90, 90, 5.0), color='black', labels=[True, False, True, False]) m.drawmapscale(-34, 60.5, -41.5, 71, 400, yoffset=offset, barstyle='fancy') elif type(params) is dict: llcrnrlat = params['llcrnrlat'] urcrnrlat = params['urcrnrlat'] llcrnrlon = params['llcrnrlon'] urcrnrlon = params['urcrnrlon'] scale_color = params['scale_color'] scale_length = params['scale_length'] scale_loc = params['scale_loc'] figsize = params['figsize'] lat_interval = params['lat_interval'] lon_interval = params['lon_interval'] plot_grid = params['plot_grid'] plot_scale = params['plot_scale'] axes_color = params['axes_color'] dlon = (urcrnrlon - llcrnrlon) / 2.0 dlat = (urcrnrlat - llcrnrlat) / 2.0 lon_0 = llcrnrlon + dlon lat_0 = llcrnrlat + dlat fig = plt.figure(figsize=figsize) ax = fig.add_subplot(111) # new projection : m = Basemap(ax=ax, llcrnrlat=llcrnrlat, urcrnrlat=urcrnrlat, llcrnrlon=llcrnrlon, urcrnrlon=urcrnrlon, resolution='h', projection='stere', lon_0=lon_0, lat_0=lat_0) offset = 0.015 * (m.ymax - m.ymin) # draw lat/lon grid lines every degree. # labels = [left,right,top,bottom] if plot_grid: m.drawmeridians(np.arange(0, 360, lon_interval), color='black', labels=[False, False, False, True]) m.drawparallels(np.arange(-90, 90, lat_interval), color='black', labels=[True, False, False, False]) if scale_loc == 1: fact = 1.8 elif scale_loc == 2: fact = 0.2 if plot_scale: dx = (m.xmax - m.xmin) / 2.0 dy = (m.ymax - m.ymin) / 2.0 xmid = m.xmin + dx ymid = m.ymin + fact * dy slon, slat = m(xmid, ymid, inverse=True) m.drawmapscale(slon, slat, slon, slat, scale_length, barstyle='fancy', fontcolor=scale_color) for axis in ['top', 'bottom', 'left', 'right']: ax.spines[axis].set_color(axes_color) else: s = ">>> plotIce REQUIRES A 'dict' OF SPECIFIC PARAMETERS FOR 'custom' <<<" print_text(s, 'red', 1) sys.exit(1) # convert to new projection coordinates from lon,lat : x, y = m(lon, lat) m.drawcoastlines(linewidth=0.5, color='black') #m.shadedrelief() #m.bluemarble() #m.etopo() if plot_continent: if cont is 'greenland': llcrnrlat = 57 urcrnrlat = 80.1 llcrnrlon = -57 urcrnrlon = 15 axcont = inset_locator.inset_axes(ax, **cont_plot_params) axcont.xaxis.set_ticks_position('none') axcont.yaxis.set_ticks_position('none') # continent projection : mc = Basemap(ax=axcont, llcrnrlat=llcrnrlat, urcrnrlat=urcrnrlat, llcrnrlon=llcrnrlon, urcrnrlon=urcrnrlon, resolution='c', projection='stere', lon_0=lon_0, lat_0=lat_0) mc.drawcoastlines(linewidth=0.5, color='black') x_c, y_c = mc(lon, lat) v_cont = v.copy() v_cont[:] = 1.0 axcont.tricontourf(x_c, y_c, fi, v_cont, cmap=pl.get_cmap('Reds')) #============================================================================= # plotting : if umin != None and levels is None: vmin = umin elif levels is not None: vmin = levels.min() else: vmin = v.min() if umax != None and levels is None: vmax = umax elif levels is not None: vmax = levels.max() else: vmax = v.max() # set the extended colormap : cmap = pl.get_cmap(cmap) #cmap.set_under(under) #cmap.set_over(over) # countour levels : if scale == 'log': if levels is None: levels = np.logspace(np.log10(vmin), np.log10(vmax), numLvls) v[v < vmin] = vmin + 2e-16 v[v > vmax] = vmax - 2e-16 formatter = LogFormatter(10, labelOnlyBase=False) norm = colors.LogNorm() # countour levels : elif scale == 'sym_log': if levels is None: levels = np.linspace(vmin, vmax, numLvls) v[v < vmin] = vmin + 2e-16 v[v > vmax] = vmax - 2e-16 formatter = LogFormatter(e, labelOnlyBase=False) norm = colors.SymLogNorm(vmin=vmin, vmax=vmax, linscale=0.001, linthresh=0.001) elif scale == 'lin': if levels is None: levels = np.linspace(vmin, vmax, numLvls) norm = colors.BoundaryNorm(levels, cmap.N) elif scale == 'bool': v[v < 0.0] = 0.0 levels = [0, 1, 2] norm = colors.BoundaryNorm(levels, cmap.N) # please do zoom in! if zoom_box: zoom = zoom_box_kwargs['zoom'] loc = zoom_box_kwargs['loc'] loc1 = zoom_box_kwargs['loc1'] loc2 = zoom_box_kwargs['loc2'] llcrnrlat = zoom_box_kwargs['llcrnrlat'] urcrnrlat = zoom_box_kwargs['urcrnrlat'] llcrnrlon = zoom_box_kwargs['llcrnrlon'] urcrnrlon = zoom_box_kwargs['urcrnrlon'] plot_zoom_scale = zoom_box_kwargs['plot_zoom_scale'] scale_font_color = zoom_box_kwargs['scale_font_color'] scale_length = zoom_box_kwargs['scale_length'] scale_loc = zoom_box_kwargs['scale_loc'] plot_grid = zoom_box_kwargs['plot_grid'] axes_color = zoom_box_kwargs['axes_color'] zb_plot_pts = zoom_box_kwargs['plot_points'] x1, y1 = m(llcrnrlon, llcrnrlat) x2, y2 = m(urcrnrlon, urcrnrlat) axins = inset_locator.zoomed_inset_axes(ax, zoom, loc=loc) inset_locator.mark_inset(ax, axins, loc1=loc1, loc2=loc2, fc="none", ec=axes_color) for axis in ['top', 'bottom', 'left', 'right']: axins.spines[axis].set_color(axes_color) #axins.spines[axis].set_linewidth(2) if scale_loc == 1: fact = 1.8 elif scale_loc == 2: fact = 0.2 dx = (x2 - x1) / 2.0 dy = (y2 - y1) / 2.0 xmid = x1 + dx ymid = y1 + fact * dy slon, slat = m(xmid, ymid, inverse=True) # new projection : mn = Basemap(ax=axins, width=w, height=h, resolution='h', projection='stere', lat_ts=lat_0, lon_0=lon_0, lat_0=lat_0) if plot_zoom_scale: mn.drawmapscale(slon, slat, slon, slat, scale_length, yoffset=0.025 * 2.0 * dy, barstyle='fancy', fontcolor=scale_font_color) mn.drawcoastlines(linewidth=0.5, color='black') axins.set_xlim(x1, x2) axins.set_ylim(y1, y2) axins.xaxis.set_ticks_position('none') axins.yaxis.set_ticks_position('none') if isinstance(u, str): #cs = ax.pcolor(x, y, v, cmap=get_cmap(cmap), norm=norm) if contour_type == 'filled': cs = ax.contourf(x, y, v, levels=levels, cmap=cmap, norm=norm, extend=extend) if zoom_box: axins.contourf(x, y, v, levels=levels, cmap=cmap, norm=norm, extend=extend) if contour_type == 'lines': cs = ax.contour(x, y, v, levels=levels, colors='k') for line in cs.collections: if line.get_linestyle() != [(None, None)]: line.set_linestyle([(None, None)]) line.set_color('red') line.set_linewidth(1.5) if levels_2 is not None: cs2 = ax.contour(x, y, v, levels=levels_2, colors='k') for line in cs2.collections: if line.get_linestyle() != [(None, None)]: line.set_linestyle([(None, None)]) line.set_color('#c1000e') line.set_linewidth(0.5) ax.clabel(cs, inline=1, colors='k', fmt='%i') if zoom_box: axins.contour(x, y, v, levels=levels, colors='k') elif isinstance(u, Function) \ or isinstance(u, dolfin.functions.function.Function): #cs = ax.tripcolor(x, y, fi, v, shading='gouraud', # cmap=get_cmap(cmap), norm=norm) if contour_type == 'filled': cs = ax.tricontourf(x, y, fi, v, levels=levels, cmap=cmap, norm=norm, extend=extend) if zoom_box: axins.tricontourf(x, y, fi, v, levels=levels, cmap=cmap, norm=norm, extend=extend) elif contour_type == 'lines': cs = ax.tricontour(x, y, fi, v, linewidths=2.0, levels=levels, colors='k') for line in cs.collections: if line.get_linestyle() != [(None, None)]: line.set_linestyle([(None, None)]) line.set_color('red') line.set_linewidth(1.5) if levels_2 is not None: cs2 = ax.tricontour(x, y, fi, v, levels=levels_2, colors='0.30') for line in cs2.collections: if line.get_linestyle() != [(None, None)]: line.set_linestyle([(None, None)]) line.set_color('#c1000e') line.set_linewidth(0.5) ax.clabel(cs, inline=1, colors='k', fmt='%i') if zoom_box: axins.tricontour(x, y, fi, v, levels=levels, colors='k') axins.clabel(cs, inline=1, colors='k', fmt='%1.2f') if u2 is not None: v2 = u2.compute_vertex_values(mesh) csu2 = ax.tricontour(x, y, fi, v2, linewidths=1.5, levels=u2_levels, colors=u2_color) #for line in csu2.collections: # if line.get_linestyle() != [(None, None)]: # line.set_linestyle([(None, None)]) if plot_pts is not None: lat_a = plot_pts['lat'] lon_a = plot_pts['lon'] sty_a = plot_pts['style'] clr_a = plot_pts['color'] for lat_i, lon_i, sty_i, clr_i in zip(lat_a, lon_a, sty_a, clr_a): x_i, y_i = m(lon_i, lat_i) ax.plot(x_i, y_i, color=clr_i, marker=sty_i) if box_params is not None: x1, y1 = m(box_params['llcrnrlon'], box_params['llcrnrlat']) x2, y2 = m(box_params['urcrnrlon'], box_params['urcrnrlat']) box_x_s = [x1, x2, x2, x1, x1] box_y_s = [y1, y1, y2, y2, y1] ax.plot(box_x_s, box_y_s, '-', lw=1.0, color=box_params['color']) if zoom_box: if zb_plot_pts is not None: lat_a = zb_plot_pts['lat'] lon_a = zb_plot_pts['lon'] sty_a = zb_plot_pts['style'] clr_a = zb_plot_pts['color'] for lat_i, lon_i, sty_i, clr_i in zip(lat_a, lon_a, sty_a, clr_a): x_i, y_i = m(lon_i, lat_i) axins.plot(x_i, y_i, color=clr_i, marker=sty_i) # plot triangles : if tp == True: tp = ax.triplot(x, y, fi, 'k-', lw=0.2, alpha=tpAlpha) if zoom_box and plot_grid: tpaxins = axins.triplot(x, y, fi, 'k-', lw=0.2, alpha=tpAlpha) # include colorbar : if cb and scale != 'bool': divider = make_axes_locatable(ax) #plt.gca()) cax = divider.append_axes("right", "5%", pad="3%") cbar = fig.colorbar( cs, cax=cax, #format=formatter, ticks=levels, format=cb_format) #cbar = plt.colorbar(cs, cax=cax, format=formatter, # ticks=np.around(levels,decimals=1)) # title : tit = plt.title(title) #tit.set_fontsize(40) plt.tight_layout(rect=[.03, .03, 0.97, 0.97]) d = os.path.dirname(direc) if not os.path.exists(d): os.makedirs(d) plt.savefig(direc + name + ext, res=res) if show: plt.show() plt.close(fig) return m
def multiple_subplots(attribute_list, group, dataset, plot_type='hist', row_category_split=0, row_category_split_col='dummy', sav_fig=0, savefname=r'c:\data\temp\ans.png', **kwargs): """ Create multiple subplots within a figure ( currently box, hist) based on the attribute list. May purpose is to ensure y-axis auto scaling for each subplot and does not share y axis. By default, it create n by column (default 3) number of subplot within a single figure. n is based on len(attribute_list)/column. Args: attribute_list (list): (row_category_split = 0)list of column names to plot. Each column name is put under one plot (row_category_split = 1)list of sub category to plot. Each sub cat is put under one plot group ('str'): category option within a plot. Only avaliable for box plot. where the x-axis is group. dataset ('dataframe'): attribute_list items, group and row_category_split_col must be present in the dataset. Kwargs: plot_type(str): hist (histogram) or box (boxplot) option. row_category_split: default 0. Applicable for boxplot. allow sub plot by splitting the plots based on target row (row_category_split_col) sav_fig (bool): default 0, if sav_fg = 1, will save figure beside showing it, will use savefname as the save filename. Additional parameters: column_default (int): default 3. change the layout of the figure. Normally for box plot each plot is based on each column group by "group" (if row_category_split = 0) if row_category_split = 1 """ if kwargs.has_key('column_default'): column_default = float(kwargs['column_default']) else: column_default = 3.0 num_rows = int(math.ceil(len(attribute_list) / column_default)) gs = gridspec.GridSpec(num_rows, int(column_default)) row_index = 0 temp_col = 0 for n in attribute_list: ax = plt.subplot(gs[row_index, temp_col]) if plot_type == 'hist': dataset[n].hist(ax=ax) #may need to add title ax.set_title(n) if plot_type == 'box': if not row_category_split: dataset[[n, group]].boxplot( by=group, sym='k.', vert=True, whis=1.5, ax=ax) #symbol is as a result of seaborn with pylab issue else: dataset[dataset[row_category_split_col] == n].boxplot( by=group, sym='k.', vert=True, whis=1.5, ax=ax) #symbol is as a result of seaborn with pylab issue ax.set_title(n) temp_col = temp_col + 1 if temp_col == 3: row_index = row_index + 1 temp_col = 0 fig = plt.gcf() fig.set_size_inches(18.5, 10.5) plt.tight_layout() if sav_fig: plt.savefig(savefname) plt.show()
def plot_variable(u, name, direc, cmap='gist_yarg', scale='lin', numLvls=12, umin=None, umax=None, tp=False, tpAlpha=0.5, show=True, hide_ax_tick_labels=False, label_axes=True, title='', use_colorbar=True, hide_axis=False, colorbar_loc='right'): """ """ mesh = u.function_space().mesh() v = u.compute_vertex_values(mesh) x = mesh.coordinates()[:, 0] y = mesh.coordinates()[:, 1] t = mesh.cells() d = os.path.dirname(direc) if not os.path.exists(d): os.makedirs(d) if umin != None: vmin = umin else: vmin = v.min() if umax != None: vmax = umax else: vmax = v.max() # countour levels : if scale == 'log': v[v < vmin] = vmin + 1e-12 v[v > vmax] = vmax - 1e-12 from matplotlib.ticker import LogFormatter levels = np.logspace(np.log10(vmin), np.log10(vmax), numLvls) formatter = LogFormatter(10, labelOnlyBase=False) norm = colors.LogNorm() elif scale == 'lin': v[v < vmin] = vmin + 1e-12 v[v > vmax] = vmax - 1e-12 from matplotlib.ticker import ScalarFormatter levels = np.linspace(vmin, vmax, numLvls) formatter = ScalarFormatter() norm = None elif scale == 'bool': from matplotlib.ticker import ScalarFormatter levels = [0, 1, 2] formatter = ScalarFormatter() norm = None fig = plt.figure(figsize=(8, 7)) ax = fig.add_subplot(111) c = ax.tricontourf(x, y, t, v, levels=levels, norm=norm, cmap=pl.get_cmap(cmap)) plt.axis('equal') if tp == True: p = ax.triplot(x, y, t, 'k-', lw=0.25, alpha=tpAlpha) ax.set_xlim([x.min(), x.max()]) ax.set_ylim([y.min(), y.max()]) if label_axes: ax.set_xlabel(r'$x$') ax.set_ylabel(r'$y$') if hide_ax_tick_labels: ax.set_xticklabels([]) ax.set_yticklabels([]) if hide_axis: plt.axis('off') # include colorbar : if scale != 'bool' and use_colorbar: divider = make_axes_locatable(plt.gca()) cax = divider.append_axes(colorbar_loc, "5%", pad="3%") cbar = plt.colorbar(c, cax=cax, format=formatter, ticks=levels) pl.mpl.rcParams['axes.titlesize'] = 'small' tit = plt.title(title) plt.tight_layout() d = os.path.dirname(direc) if not os.path.exists(d): os.makedirs(d) plt.savefig(direc + name + '.pdf') if show: plt.show() plt.close(fig)
def plot_mean_curve(time_data, data, additions, plate_name, save_folder = r'Figures/'): """ """ if not os.path.isdir(save_folder): os.makedirs(save_folder) for block in data: # group = group_similar(data[block].keys()) names = data[block].keys() names.sort() # ----------------- # Plot each group individualy # ----------------- data_per_inch = 5.0 y_len = int(math.sqrt(len(names))) x_len = int(np.ceil(len(names) / float(y_len))) fig, axs = plt.subplots(y_len, x_len, sharex=True, sharey=True, figsize=(x_len*data_per_inch,y_len*data_per_inch), dpi=300) y_min = data[block][names[0]]['original_data'].min() y_max = data[block][names[0]]['original_data'].max() for i, name in enumerate(names): if data[block][name]['original_data'].min() < y_min: y_min = data[block][name]['original_data'].min() if data[block][name]['original_data'].max() > y_max: y_max = data[block][name]['original_data'].max() y_range = y_max - y_min for i, name in enumerate(names): px = i / x_len py = i % x_len if y_len > 1: position = (px, py) else: position = py time = time_data[block][name] mean = np.array(data[block][name]['mean']) std = np.array(data[block][name]['std']) all_curve = data[block][name]['original_data'] axs[position].plot(time, [1.0 for _ in time], 'k-') for curve in all_curve: axs[position].plot(time, curve, color = [0.7 for _ in xrange(3)]) axs[position].plot(time, mean, color = [0.2 for _ in xrange(3)], linewidth = 2.5, label = name) axs[position].plot(time, mean+std, 'k--', color = [0.2 for _ in xrange(3)], linewidth = 2.5) axs[position].plot(time, mean-std, 'k--', color = [0.2 for _ in xrange(3)], linewidth = 2.5) for addition in additions[:block+1]: axs[position].plot([addition[0] for _ in xrange(2)], [0.0,3.0], 'k-') axs[position].text(addition[0], 0.98, addition[1], rotation=270) if i % x_len == 0: axs[position].set_ylabel('Normalized fluorescence', size = 14) if i / x_len == y_len - 1: axs[position].set_xlabel('Time / sec', size = 14) axs[position].set_xlim(0, time[-1]) for j, text in enumerate(name.split(';')): axs[position].text(10, y_max - y_range*j*0.1, text, size = 14) axs[position].set_ylim(y_min-y_range*0.1, y_max+y_range*0.1) # plt.suptitle(plate_name) plt.subplots_adjust(wspace = 0.01, hspace = 0.01) plt.tight_layout() plt.savefig(save_folder + 'block_' + str(block + 1)) # return None
plt.ylabel("$y'$") plt.savefig('plots/tlm_test_singlelines.png') plt.xlim((-0.25, 0.25)) plt.ylim((-0.004, 0.004)) plt.savefig('plots/tlm_test_singlelines_closeup.png') plt.show() # compute mean response over all forecasts tlm = np.mean(np.array(data['tlm']), axis=0) finitdiff = np.mean(np.array(data['finitdiff']), axis=0) plt.figure(figsize=(12, 4)) plt.subplot(121) plt.plot(pert_scales, tlm, label='TLM') plt.plot(pert_scales, finitdiff, label='NN') plt.xlabel('$\sigma$') plt.ylabel("$y'$") plt.legend() sns.despine() plt.subplot(122) plt.plot(pert_scales, tlm, label='TLM') plt.plot(pert_scales, finitdiff, label='NN') plt.xlabel('$\sigma$') plt.ylabel("$y'$") plt.legend() sns.despine() plt.xlim((-0.1, 0.1)) plt.ylim((-0.00005, 0.00005)) plt.tight_layout() plt.savefig('plots/tlm_test.pdf', bbox='tight')
def run(pool_results): # r = pool_results.results[30] # plt.plot(r.indirect_exchanges) # plt.show() # m = MoneyAnalysis.run(r) # print(m) # # for i, r in enumerate(pool_results.results): # # plt.plot(r.indirect_exchanges) # plt.title(i) # plt.show() alphas = [] taus = [] qs = [] gammas = [] y = [] for i, r in enumerate(pool_results.results): # if not r.parameters["x0"] == r.parameters["x1"] == r.parameters["x2"]: # continue alphas.append(r.parameters["alpha"]) taus.append(r.parameters["tau"]) qs.append(r.parameters["q"]) gammas.append(r.parameters["gamma"]) m = MoneyAnalysis.run(r) print(i, m) y.append(m) fig = plt.figure(figsize=(10, 10)) ax = fig.add_subplot(221) ax.scatter(taus, y, c="black", alpha=0.4, s=15) ax.set_ylabel("n monetary states") ax.set_xlabel(r"$\tau$") ax = fig.add_subplot(222) ax.scatter(alphas, y, c="black", alpha=0.4, s=15) ax.set_ylabel("n monetary states") ax.set_xlabel(r"$\alpha$") ax = fig.add_subplot(223) ax.scatter(qs, y, c="black", alpha=0.4, s=15) ax.set_ylabel("n monetary states") ax.set_xlabel(r"$q$") ax = fig.add_subplot(224) ax.scatter(gammas, y, c="black", alpha=0.4, s=15) ax.set_ylabel("n monetary states") ax.set_xlabel(r"$\gamma$") # ax = fig.add_subplot(224) # ax.scatter(x[X.x], y, c="black", alpha=0.4, s=15) # ax.set_ylabel("n monetary states") # ax.set_xlabel(r"n agents") # plt.text(0.005, 0.005, results_pool.file_name, transform=fig.transFigure, fontsize='x-small', color='0.5') plt.tight_layout() # plt.savefig("{}/separate_indirect_exchanges_proportions_{}.pdf" # .format(analysis.parameters.fig_folder, results_pool.file_name)) plt.show()