def plt_2_trajectories(data, labels, xyt, savepath, usemeans=True, mid=0, plttype='scatter', **kwargs): plt.figure(figsize=(30, 10)) vals = {} assert len(data) == len(labels) ylims = kwargs.pop('ylims', (0, 1)) if usemeans: means = [np.mean(line) for line in data] else: means = [mid] * len(data) vals['up'] = [ np.array([x for x in line if x >= means[i]]) for i, line in enumerate(data) ] vals['down'] = [ np.array([x for x in line if x < means[i]]) for i, line in enumerate(data) ] cols = {'up': 'green', 'down': 'red'} plt.plot(range(len(labels)), means, lw=4, c=cm.Oranges(0.8)) plt.axhline(y=mid, c=cm.Greys(0.8), alpha=0.7) for x in range(0, len(means), 12): plt.axvline(x=x, c=cm.Greys(0.8), alpha=0.7, lw=1.5) if 'scatter' in plttype: for k, v in vals.items(): ys = [y for line in v for y in line] xs = [xval for xval, line in enumerate(v) for y in line] plt.scatter(xs, ys, alpha=0.25, c=cols[k], label=k) if 'mean' in plttype: for k, v in vals.items(): ys = [np.mean(line) for line in v] xs = range(len(v)) plt.plot(xs, ys, alpha=0.8, lw=2, c=cols[k], label=k) if 'box' in plttype: for k, v in vals.items(): plt.boxplot(v, positions=range(len(data)), boxprops={'c': cols[k]}) plt.legend() plt.xlabel(xyt[0], fontsize=20) plt.xticks(ticks=range(len(v)), labels=labels, rotation=45, fontsize=10, ha='center') plt.ylabel(xyt[1], fontsize=20) plt.title(xyt[2], fontsize=24) plt.ylim(*ylims) plt.savefig(savepath + '.png', bbox_inches='tight') plt.close('all')
def __init__( self, df, var1, var2, classvar, nn_range=range(1, 101), granularity=50., buffer_denom=15., figsize=(20, 20), dotsize=70, point_colors=cm.Greys( [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), #point_colors=sns.xkcd_palette(['windows blue', 'amber']), mesh_colors=cm.jet([0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])): #mesh_colors=['#8FCCFF', '#FFED79']): self.df = df self.var1 = var1 self.var2 = var2 self.classvar = classvar self.nn_range = nn_range self.granularity = granularity self.buffer_denom = buffer_denom self.figsize = figsize self.dotsize = dotsize self.point_colors = point_colors self.mesh_colors = mesh_colors
def __init__(self, values=None, limits=None, zero_point=0): normal_map = cm.viridis(np.linspace(0, 1, 256)) zero_map = cm.Greys(np.linspace(0, 0.01, 256)) all_colors = np.vstack((zero_map, normal_map)) self.cmap = colors.LinearSegmentedColormap.from_list( "special_zero", all_colors) self.zero_point = zero_point if values is not None: self.vmin = np.min(values) self.vmax = np.max(values) elif limits: self.vmin, self.vmax = limits else: raise ValueError( "colormap_special_zero needs either `values` or `limits`") if self.vmin == 0: self.vmin = -self.vmax * 0.05 if zero_point == 0: zero_point = min(0.01 * self.vmax, 0.1) if zero_point <= self.vmin: # white colormap isn't needed self.norm = None self.cmap = cm.viridis else: self.norm = colors.DivergingNorm(vmin=self.vmin, vcenter=zero_point, vmax=self.vmax)
def plot_points(xarray, yarray): # Make array of colors colors = cm.Greys(np.linspace(0, 1, len(xarray))) # Plot graph for i in range(len(xarray)): plt.scatter(xarray[i], yarray[i], c=colors[i], s=100) plt.show()
def draw_vapor(init, end): for f in td_files[init:end]: print(f) ##### retrieve variables ##### dt = netCDF4.Dataset(f) t = int(np.array(dt['Time'])) qc = dt['qc'][0, :len(z), y_prof, xslice] #qv = dt['qv'][0, :len(z), y_prof, :] qr = dt['qr'][0, :len(z), y_prof, xslice] ##### draw qv ##### #qv = np.ma.masked_array(qv, qv<1e-10) #contourf(x, z, qv, levels=50, vmin=0., vmax=0.02, cmap='Blues') #colorbar(extend='max') ##### draw qc ##### colors = cm.Greys( np.hstack([np.array([0.] * 5), np.linspace(0.5, 0.75, 95)])) cmap = LinearSegmentedColormap.from_list('name', colors) #cmap.set_bad('white') qc = np.ma.masked_array(qc, qc < 0.0) contourf(x, z, qc, cmap=cmap, vmin=0, vmax=0.001, levels=100) colorbar() ##### draw qr ##### cmap = nclcmap('BrownBlue12') colors = cm.Blues(np.linspace(0.5, 1)) cmap = LinearSegmentedColormap.from_list('name', colors) qr = np.ma.masked_array(qr, qr <= 1e-6) #5e-6) contourf(x, z, qr, cmap=cmap, vmin=0., vmax=0.01, alpha=.5, levels=20) ##### figure setting ##### title('Vapor Distribution @ t = ' + str(t) + ' min') xlabel('X (m)') ylabel('Z (m)') savefig('vapor' + f[-9:-3] + '.png', dpi=300) clf()
def time_of_emergence(self, start_time, times=np.arange(10, 76), noisestart=None, plot=True, solver=None, uncertainty="lines", **kwargs): if noisestart is None: noisestart = cmip5.start_time(self.obs) if not hasattr(self, "P"): self.model_projections() nmod, nyears = self.get_forced(solver=solver).shape self.TOE = MV.zeros((nmod, len(times))) for i in range(len(times)): L = times[i] modslopes, noiseterm = self.sn_at_time(start_time, L, noisestart=noisestart) sns = modslopes / np.std(noiseterm) self.TOE[:, i] = sns self.TOE.setAxis(0, self.get_forced(solver=solver).getAxis(0)) if plot: endyears = start_time.year + times if uncertainty == "lines": for ind_model in self.TOE.asma(): plt.plot(endyears, ind_model, alpha=.3, color=cm.Greys(.5), lw=1) elif uncertainty == "bounds": plt.plot(endyears, np.ma.min(self.TOE.asma(), axis=0), linestyle="--", **kwargs) plt.plot(endyears, np.ma.max(self.TOE.asma(), axis=0), linestyle="--", **kwargs) else: plt.fill_between(endyears, np.ma.min(self.TOE.asma(), axis=0), np.ma.max(self.TOE.asma(), axis=0), alpha=.2, **kwargs) plt.plot(endyears, np.ma.average(self.TOE.asma(), axis=0), label=self.name + " model mean signal", **kwargs) #plt.fill_between(endyears,np.ma.min(self.TOE.asma(),axis=0),np.ma.max(self.TOE.asma(),axis=0),alpha=.3,**kwargs) #plt.axhline(stats.norm.interval(.9)[-1],c="r",lw=3) plt.xlabel("Trend end year") plt.ylabel("Signal-to-noise ratio")
def make_shadow_cmap() -> colors.ListedColormap: shadow_colors = cm.Greys(np.arange(cm.Greys.N)) mid_idx = int(cm.Greys.N * 0.8) shadow_colors[:mid_idx, 3] = 0.0 # avoid shadows at low values shadow_colors[mid_idx:, 3] = np.linspace(0.0, 1.0, num=(cm.Greys.N - mid_idx), endpoint=True) # logger.debug("shadow colors: %s" % shadow_colors[:, 3]) return colors.ListedColormap(shadow_colors)
def get_colors(color_c=3, color_step=100): cmap_colors = np.vstack(( cm.Oranges(np.linspace(0.4, 1, color_step)), cm.Reds(np.linspace(0.4, 1, color_step)), cm.Greys(np.linspace(0.4, 1, color_step)), cm.Purples(np.linspace(0.4, 1, color_step)), cm.Blues(np.linspace(0.4, 1, color_step)), cm.Greens(np.linspace(0.4, 1, color_step)), cm.pink(np.linspace(0.4, 1, color_step)), cm.copper(np.linspace(0.4, 1, color_step)), )) return cmap_colors[np.arange(color_c * color_step) % (color_step * 8)]
def plot_color(df_tmp, plot_col, item, **kwargs): ''' This plotter will make the polygons if you input colors into the plot. The input is a dataframe. A minimum of the input numbers, a maximum, the column name that is going to be plotted, and a list of items that is missing. (Usually these items are colors that are not in the dataframe when they are expected to be. ''' missing = [] df_tmp.reset_index(inplace=True) color = df_tmp[plot_col][0] # The edgecolor of the polygon. if 'edgecolor' in kwargs: edgecolor = kwargs['edgecolor'] else: edgecolor = 'black' # Check if the color is defined and adjust color if it is not. if not isinstance(color, str): if np.isnan(color): missing.append(item) color = cm.Greys(0.3) # Define the polygon and add it to the plot. if df_tmp['type'].ix[0] == 'MultiPolygon': i = 0 for j in range(len(df_tmp)): if (df_tmp['X'].ix[j] == df_tmp['X'].ix[i]) and ( df_tmp['Y'].ix[j] == df_tmp['Y'].ix[i]) and (j > i): df_tmp2 = df_tmp.ix[range(i, j + 1)] i = j + 1 # Plot the polygons. poly = plt.Polygon(df_tmp2[['X', 'Y']], facecolor=color, edgecolor=edgecolor, zorder=0) poly.set_linewidth(0.1) if 'linewidth' in kwargs: poly.set_linewidth(kwargs['linewidth']) plt.gca().add_patch(poly) elif df_tmp['type'].ix[0] == 'Polygon': # Plot the polygons. poly = plt.Polygon(df_tmp[['X', 'Y']], facecolor=color, edgecolor=edgecolor, zorder=0) poly.set_linewidth(0.1) if 'linewidth' in kwargs: poly.set_linewidth(kwargs['linewidth']) plt.gca().add_patch(poly) return missing
def plot_roc_auc_profile(dm_df, dmz, accs, num_solvers, title=None, plot_legend=False): colors = [ cm.Set1(0) if x.find('gpc') != -1 else (cm.Set1(1) if x.find('xgb') != -1 else (cm.Set1(2) if x.find('logit') != -1 else cm.Greys(0.5))) for x in dm_df.columns ] linestyles = [ '--' if x.find('stacking') != -1 else ('-.' if x.find('oncatenation') != -1 else ('-' if x.find('major_vote') != -1 else ':')) for x in dm_df.columns ] plt.figure(figsize=(5, 5)) for cnt_solver in range(num_solvers): if dm_df.columns[cnt_solver].find('ss_mf_gpc') == -1 and dm_df.columns[ cnt_solver].find('hetmogp') == -1: plt.plot(accs, dmz[cnt_solver], label=dm_df.columns[cnt_solver], color=colors[cnt_solver], linestyle=linestyles[cnt_solver]) if 'ss_mf_gpc:multi-fidelity' in dm_df.columns: cnt_solver = dm_df.columns.tolist().index('ss_mf_gpc:multi-fidelity') plt.plot(accs, dmz[cnt_solver], label=dm_df.columns[cnt_solver], color='k') if 'hetmogp:multi-fidelity' in dm_df.columns: cnt_solver = dm_df.columns.tolist().index('hetmogp:multi-fidelity') plt.plot(accs, dmz[cnt_solver], label=dm_df.columns[cnt_solver], color='orange') if 'GPMA' in dm_df.columns: cnt_solver = dm_df.columns.tolist().index('GPMA') plt.plot(accs, dmz[cnt_solver], label=dm_df.columns[cnt_solver], color='magenta') plt.xlim([0.4, 1]) if plot_legend: plt.legend(loc=2, bbox_to_anchor=(1, 1)) if title is not None: plt.title(title)
def plot_scatter(s2pl, scatter=None, top=None, annotate=False, title=None): """ Plot a series of scatter points. Args: s2points: series of points. """ num_series = len(list(s2pl.keys())) colors = cm.rainbow(np.linspace(0, 1, num_series)) marker = itertools.cycle( ('o', 'v', '^', '<', '>', 'D', 's', '*', 'x', '+', 'H')) for series, points, c in zip( list(s2pl.keys())[:top], list(s2pl.values())[:top], colors): x = [point.perf for point in points] y = [point.risk for point in points] designs = [point.design for point in points] legend = '(' + str(series[0])[:3] + ',' + str(series[1])[:3] + ')' plt.plot(x, y, color=cm.Greys(series[0] + series[1]), marker=next(marker), alpha=.5, label=legend) if annotate: for i in range(len(designs)): plt.annotate(designs[i], (x[i], y[i]), fontsize=8) plt.annotate(series, (x[i], y[i] + .01), fontsize=8) if scatter: for series, points, c in zip( list(scatter.keys())[:top], list(scatter.values())[:top], colors): x = [point.perf for point in points] y = [point.risk for point in points] designs = [point.design for point in points] legend = '(' + str(series[0])[:3] + ',' + str( series[1])[:3] + ')' plt.scatter(x, y, color='black', marker='o', alpha=.5) plt.xlabel('Normalized Performance', fontsize=20) plt.ylabel('Normalized Risk', fontsize=20) #plt.xlim([0.8, 1.2]) #plt.ylim([0, 1.1]) plt.legend(loc='upper right', fancybox=True, shadow=True, fontsize=12) if title: plt.savefig(title + '.png') else: plt.show() plt.clf()
def map_val_colors(img, v_min=0.0, v_max=1.0, cmap='hot'): fun = { 'hot': lambda t: cm.afmhot(colors.Normalize(vmin=v_min, vmax=v_max)(t), bytes=True), 'jet': lambda t: cm.jet(colors.Normalize(vmin=v_min, vmax=v_max)(t), bytes=True), 'Greys': lambda t: cm.Greys(colors.Normalize(vmin=v_min, vmax=v_max)(t), bytes=True), 'Blues': lambda t: cm.Blues(colors.Normalize(vmin=v_min, vmax=v_max)(t), bytes=True), } return fun[cmap](img)
def plot_PC1s(pcs, evs, mean, faxes=None, title=False, ylabel=None): if pcs.ndim > 3: pcs = pcs.reshape(-1, 3, 40) mean = mean.reshape(-1, 40) evs = evs.reshape(-1, 3) freqs = bands.chang_lab['cfs'] if faxes is None: faxes = plt.subplots(1, 2, figsize=(2.5, 12)) f, (ax0, ax1) = faxes ratios = evs[:, 1:] / evs[:, [0]] beta_weights = np.zeros(pcs.shape[0]) beta_weights = (pcs[:, 0, 14:20]).sum(axis=-1) beta_weights -= beta_weights.min() beta_weights /= beta_weights.max() for ii, pc in enumerate(pcs): ax0.plot(freqs, pcs[ii, 0], c=cm.Greys(beta_weights[ii]), alpha=1.) ax0.plot(freqs, np.median(pcs[:, 0], axis=0), c='r') ax0.axhline(0, 0, 1, c='blue', ls='--') ax1.errorbar([0, 1], ratios.mean(axis=0), yerr=ratios.std(axis=0), c='k', ls='none', marker='.') ax1.axhline(1, 0, 1, linestyle='--', c='gray') pc0s = pcs[:, 0] / np.linalg.norm(pcs[:, 0], axis=1, keepdims=True) if mean is not None: mean = mean / np.linalg.norm(mean, axis=1, keepdims=True) ips = abs(np.sum(pc0s * mean, axis=1)) ax1.errorbar(2, ips.mean(), yerr=ips.std(), c='k', marker='.') #ax0.set_xscale('log') if mean is None: ax1.set_xticks([0, 1]) ax1.set_xticklabels([r'$\frac{e_2}{e_1}$', r'$\frac{e_3}{e_1}$']) ax1.set_xlim(-1, 2) else: ax1.set_xticks([0, 1, 2]) ax1.set_xticklabels( [r'$\frac{e_2}{e_1}$', r'$\frac{e_3}{e_1}$', r'$|\mu\cdot PC1|$']) ax1.set_xlim(-1, 3) ax1.set_ylim(0, 1.1) ax1.set_yticks([0, 1]) if ylabel is not None: ax0.set_ylabel(ylabel) return
def gray_to_cm_pil(gray_np, log=False, fftshift=False, cmap='viridis'): if log: gray_np = 20 * np.log(np.abs(gray_np)) if fftshift: gray_np = np.fft.fftshift(gray_np) gray_np_norm = (gray_np - gray_np.min()) / (gray_np.max() - gray_np.min()) # img_pil = Image.fromarray(np.uint8(cm.gist_earth(gray_np_norm) * 255)) if cmap == 'viridis': img_cmap = cm.viridis(gray_np_norm) elif cmap.lower() in ['greys', 'grey', 'gray']: img_cmap = cm.Greys(1 - gray_np_norm) img_pil = Image.fromarray(np.uint8(img_cmap * 255)) return img_pil
def __init__(self,data_pred,data_gt,colors,img,types,gif_name = "test.gif", plot_ = False, save = True): self.img = img self.xs_pred = data_pred[:,:,0] self.ys_pred = data_pred[:,:,1] self.xs_gt = data_gt[:,:,0] self.ys_gt = data_gt[:,:,1] self.types = types self.nb_agents = self.xs_pred.shape[0] self.margin = 1 self.nb_frames = self.xs_pred.shape[1] self.gif_name = gif_name self.plot_ = plot_ self.save = save self.fps = 1 self.colors = colors self.lin_size = 100 lin = np.linspace(0.6, 0.8, self.lin_size) self.color_dict = { "bicycle":cm.Blues(lin), "pedestrian":cm.Reds(lin), "car":cm.Greens(lin), "skate":cm.Greys(lin), "cart":cm.Purples(lin), "bus":cm.Oranges(lin) } self.colors = [self.color_dict[type_][np.random.randint(self.lin_size)] for type_ in self.types] self.history = 4 self.get_plots()
def projection_figure(D,fortalk=False): start = cdtime.comptime(1975,8,1) trends = cmip5.get_linear_trends(D.ALL.obs(time=(start,'2005-12-31'))) if fortalk: plt.figure() else: plt.subplot(211) m=b.landplot(trends,vmin=-2,vmax=2) m.drawcoastlines(color="gray") plt.colorbar(orientation='horizontal',label="Trend (PDSI/decade)") plt.title("(a): 1975-2005 GDA trends") if fortalk: plt.figure() else: plt.subplot(212) Plotting.Plotting.time_plot(D.ALL.projection(time=('1100-1-1','1850-12-31')),color=cm.Greens(.9),lw=3,label="pre-industrial noise") Plotting.Plotting.time_plot(D.ALL.projection(time=('1851-1-1','1974-12-31')),c=cm.Greys(.5),lw=3) Plotting.Plotting.time_plot(D.ALL.projection(time=('1975-1-1','2005-12-31')),c=cm.Blues(.8),label="Target period",lw=3) plt.xlabel("Year") plt.ylabel("Projection") plt.title("(b): GDA projection on fingerprint") plt.xlim(1400,2010) plt.legend()
def get_cmaps_biasCNN(): """ Create color maps """ nsteps = 8 colors_all_1 = np.moveaxis( np.expand_dims(cm.Greys(np.linspace(0, 1, nsteps)), axis=2), [0, 1, 2], [0, 2, 1]) colors_all_2 = np.moveaxis( np.expand_dims(cm.GnBu(np.linspace(0, 1, nsteps)), axis=2), [0, 1, 2], [0, 2, 1]) colors_all_3 = np.moveaxis( np.expand_dims(cm.YlGn(np.linspace(0, 1, nsteps)), axis=2), [0, 1, 2], [0, 2, 1]) colors_all_4 = np.moveaxis( np.expand_dims(cm.OrRd(np.linspace(0, 1, nsteps)), axis=2), [0, 1, 2], [0, 2, 1]) colors_all = np.concatenate((colors_all_1[np.arange(2, nsteps, 1), :, :], colors_all_2[np.arange(2, nsteps, 1), :, :], colors_all_3[np.arange(2, nsteps, 1), :, :], colors_all_4[np.arange(2, nsteps, 1), :, :], colors_all_2[np.arange(2, nsteps, 1), :, :]), axis=1) int_inds = [3, 3, 3, 3] colors_main = np.asarray( [colors_all[int_inds[ii], ii, :] for ii in range(np.size(int_inds))]) colors_main = np.concatenate((colors_main, colors_all[5, 1:2, :]), axis=0) # plot the color map #plt.figure();plt.imshow(np.expand_dims(colors_main,axis=0)) colors_sf = np.moveaxis( np.expand_dims(cm.GnBu(np.linspace(0, 1, 8)), axis=2), [0, 1, 2], [0, 2, 1]) colors_sf = colors_sf[np.arange(2, 8, 1), :, :] return colors_main, colors_sf
rspace = np.linspace(rmin, rmax, 100) # choose energies based on the behavior of the determinant (see cpts_..._RGM.nb) wfktJ0 = [[psiL(rr, 1, lit_wrels, np.real(litcoeff)) for rr in rspace] for litcoeff in litcoeffs00] f = plt.figure(figsize=(10, 6)) f.suptitle( r'$\Psi_{LIT}^{0^-}\;\;\;\;\sigma_i=%2.1f$ MeV $\;\;\;\;\sigma_r\in[%2.1f,%2.1f]$ MeV (dark$\to$light)' % (sI, float(sR[0]), float(sR[-1])), fontsize=14) ax1 = f.add_subplot(111) colormap = cm.Greys(np.linspace(0, 1, len(wfktJ0)))[::-1] ax1.set_xlabel(r'$r$ [fm]', fontsize=12) ax1.set_ylabel(r'$\psi_{0^-}(r)$ [MeV$^{-3/2}$]', fontsize=12) [ ax1.plot(rspace, wfktJ0[wfkt], label='$\sigma_r=%4.2f, n=%d$' % (float(sR[wfkt]), nw), c=colormap[wfkt]) for wfkt in range(len(wfktJ0)) ] line, = ax1.plot(rspace, wfktJ0[0], 'r-') energysel = [1, 4, 23, 45, 76, 90]
def plot_spike_shapes(shape_dict, f_handle, meta, info, my_name): """ Plots spike shapes superimposed, together with the appropriate mean :f_handle: list of figure and axes handles :param shape_dict: dictionary with spike shape for all selected repros and stimuli :return: figure handle, maybe """ color_spread = np.linspace(0.8, 0.4, len(shape_dict)) cmapGrey = [cm.Greys(x) for x in color_spread] counter = 0 for k, v in shape_dict.items(): # for spike in range(shape_dict[k].shape[0]): # peak_voltage = np.max(shape_dict[k][spike,:]) # f_handle[1].plot(shape_dict[k][spike,:]-peak_voltage, color=cmapGrey[counter]) avg_spike = np.mean(shape_dict[k], 0) med_spike = np.median(shape_dict[k], 0) peak_avg_voltage = np.max(avg_spike) peak_med_voltage = np.max(med_spike) q25spike = np.percentile(shape_dict[k], 5, 0) q75spike = np.percentile(shape_dict[k], 95, 0) std_spike = np.std(shape_dict[k], 0) # f_handle[1].fill_between(range(0,med_spike.shape[0]), med_spike-peak_med_voltage-q25spike, med_spike-peak_med_voltage + q75spike, color=cmapGrey[counter], alpha=0.2) # f_handle[1].plot(med_spike-peak_med_voltage, color=cmapGrey[counter]) f_handle[1].fill_between(range(0, avg_spike.shape[0]), avg_spike - peak_med_voltage - std_spike, med_spike - peak_med_voltage + std_spike, color=cmapGrey[counter], alpha=0.1) f_handle[1].plot(avg_spike - peak_avg_voltage, color=cmapGrey[counter]) if "SyncPulse" in meta[k][0]["Status"].keys(): f_handle[1].text(35, -5 - counter * 5, "".join([ r'$g_{Vgate}$', ' = ', meta[k][0]["Status"]["gvgate"].split('.')[0], ' ns' ]), fontsize=10, color=cmapGrey[counter]) f_handle[1].text( 60, -5 - counter * 5, "".join([ r'$\tau_{Vgate}$', ' = ', meta[k][0]["Status"]["vgatetau"].split('.')[0], ' ms' ]), fontsize=10, color=cmapGrey[counter]) counter += 1 f_handle[1].set_title(".".join([ "_".join([info["Cell"]["Location"], expfolder, "spike_shape", my_name]), 'pdf' ])) f_handle[1].set_ylim(-40, 0) f_handle[1].set_xlabel("time [ms]") f_handle[1].set_ylabel("relative voltage [mV]") f_handle[1].set_xticklabels(['-1', '0', '1', '2', '3', '4']) f_handle[0].savefig(ppjoin( '../overviewSpikeShape/', ".".join([ "_".join( [info["Cell"]["Location"], expfolder, "spike_shape", my_name]), 'pdf' ])), transparent=True)
fig = plt.figure() ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree()) # ax.scatter(lon1, lat1, color='black', s=5, label="No rotation") ax.scatter(lon2, lat2, color='red', s=5, label="Earth's Rotation") plt.legend() ax.stock_img() ax.gridlines() ax.coastlines() plt.title("Effect of Earth's rotation on the Ground Track") """ Several periods """ per = 3 orbit_0 = orbital_elements(h=1000, e=0.0, i=60, raan=0, omega=0) theta0 = np.linspace(0, 2 * np.pi * per, per * N_points) lon0, lat0 = compute_track(orbit_1, theta0, periods=per, rotation=True) colors = cm.Greys(np.linspace(0, 1, len(theta0))) fig = plt.figure() ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree()) ax.scatter(lon0, lat0, color=colors, s=5) ax.stock_img() ax.gridlines() ax.coastlines() plt.title("%d Periods" % (per)) """ Effect of Inclination """ i2, i3 = 45, 60 orbit_2 = orbital_elements(h=600, e=0.0, i=i2, raan=0, omega=0) orbit_3 = orbital_elements(h=600, e=0.0, i=i3, raan=0, omega=0) lon2, lat2 = compute_track(orbit_2, theta, rotation=True) lon3, lat3 = compute_track(orbit_3, theta, rotation=True)
def wht_noise(path_to_folder, subfolder, info): """ Main engine, opens the spike files. :param path_to_folder: folder with recordings :param subfolder: folder containing the experiment/cell :param info: experimental data from info.dat :return fnames: list of figure names to be used in the html build """ # define sample rate FS = 20000 # define the Gauss kernel width (= 1SD) sigma = 0.001 # seconds, from Berman & Maler 1998 # define the input data filename = ppjoin(path_to_folder, subfolder, "stimulus-whitenoise-spikes.dat") # get the file, extract the three data subunits relacs_file = load(filename) # extract RePro indices try: ReProIx = relacs_file.fields[('ReProIndex',)] except: return None # convert set objet into a list ReProIx = list(ReProIx) ReProIx.sort() # define empty list containing figure names fnames = [] for ix in ReProIx: # if relacs file is empty or too short due to aborted RePro presentation # "try:" provides normal termination of the loop instead of error try: metas, _, datas = relacs_file.select({"ReProIndex": ix}) except: return None print("ReProIx", ix, "Iterations", len(metas)) # determine figure handles fig = figure_handles() # FFT is defined as something + 1, due to mlab reasoning nFFT = 2048 FFT = (nFFT/2)+1 # prepare empty variables coh = np.zeros([len(metas), FFT], ) coh_short = np.zeros([len(metas), FFT], ) P_csd = np.zeros([len(metas), FFT], dtype=complex) P_csd_short = np.zeros([len(metas), FFT], dtype=complex) P_psd = np.zeros([len(metas), FFT]) P_psd_short = np.zeros([len(metas), FFT]) H = np.zeros([len(metas), FFT],)# dtype=complex) H_short = np.zeros([len(metas), FFT],)# dtype=complex) MI = np.zeros([len(metas), FFT], ) MI_short = np.zeros([len(metas), FFT], ) # number of stimulus iterations for i in range(0, len(metas)): color_spread = np.linspace(0.35,0.8, len(metas)) cmap = [ cm.Greys(x) for x in color_spread ] # extract meta infos wnFname = metas[i]["envelope"] wnDur = float(metas[i]["Settings"]["Waveform"]["duration"].split("m")[0]) # duration in miliseconds # conversions spikes = np.array(datas[i]) # conversions wnDur /= 1000 # conversion to miliseconds spikes /= 1000 print(spikes.shape) convolved_Train, _ = train_convolve(spikes, sigma, FS, wnDur) print(sum(convolved_Train)/FS) wNoise = process_wn(path_to_folder, wnFname, len(convolved_Train)) # compute coherence, mutual information, transfer and the power spectra and cross-spectra density freq, coh[i,:], coh_short[i,:], H[i,:], H_short[i,:], MI[i,:], MI_short[i,:], \ P_csd[i,:], P_csd_short[i,:], P_psd[i,:], P_psd_short[i,:] \ = cohere_transfere_MI (convolved_Train, wNoise, nFFT, FS) # plot coherence, mutual information etc.... plot_the_lot(fig, freq, coh, coh_short, MI, MI_short, H, H_short, metas, cmap, np.array(datas)) avgCoh, avgCoh_short, avgH, avgH_short, mut_inf, mut_inf_short = compute_avgs(coh, coh_short, H, H_short, MI, MI_short) plot_the_lot(fig, freq, avgCoh, avgCoh_short, mut_inf, mut_inf_short, avgH, avgH_short, metas, cmap = [cm.Reds(0.6)],raster='empty', annotation=True) fig[2].text(0.05, 0.95, " ".join(['Species:', info["Subject"]["Species"]]), transform=fig[1].transAxes, fontsize=10) fig[2].text(0.05, 0.90, " ".join(['ELL Segment:', info["Cell"]["Location"]]), transform=fig[1].transAxes, fontsize=10) # define file name filename = "".join([str(metas[i]["ReProIndex"]), '_', 'whitenoise']) fnames.append(filename) fig[0].savefig(ppjoin(path_to_folder, subfolder, ".".join([filename, 'png'])), transparent=True) fig[0].savefig(ppjoin(path_to_folder, subfolder, ".".join([filename, 'svg'])), transparent=True) plt.close() return fnames
def noise_transfer(tests, wd, expfolder): """" Plots the transfer and coherence curve into the graphic file (*.png, *.svg) Requires: :param tests: dictionary containing experimental conditions as keys and ReProIx as values :param wd: location of the experimental folder :param expfolder: name of the experimental folder Outputs: graphic files containing coherence, MI and transfer """ # define sample rate FS = 20000 # define the Gauss kernel width (= 1SD) sigma = 0.001 # seconds, from Berman & Maler 1998 # define the input data filename = ppjoin(wd, expfolder, "stimulus-whitenoise-spikes.dat") # read in some experimental data (_, _, filenames) = next(walk(ppjoin(wd, expfolder))) if "info.dat" in filenames: exp_info = dict(read_info(wd, expfolder)[0]) print(exp_info) else: exp_info = {"Cell": {"Location": "UNLABELED"}} # load data relacs_file = load(filename) # four panel figure FHandles = figure_handles() # define colors color_spread = np.linspace(0.5, 0.9, len(tests)) cmap = [cm.Greys(x) for x in color_spread] # cmap = [ cm.viridis(x) for x in color_spread ] # color counter col_count = 0 # FFT is defined as something + 1, due to mlab reasoning nFFT = 1024 FFT = (nFFT / 2) + 1 # define spike dict for the raster plot spike_dict = OrderedDict() for k, v in tests.items(): # get RePro indexes of the same experimental condition ReProIx = tests[k] # define empty variables, containing traces of the same experiments, different RePros coh_repro = np.zeros([len(ReProIx), FFT]) coh_repro_short = np.zeros([len(ReProIx), FFT]) H_repro = np.zeros([len(ReProIx), FFT]) H_repro_short = np.zeros([len(ReProIx), FFT]) MI_repro = np.zeros([len(ReProIx), FFT]) MI_repro_short = np.zeros([len(ReProIx), FFT]) spike_list = [] # define/reset counter counter = 0 # iteration of same experimental condition for ix in ReProIx: try: metas, _, datas = relacs_file.select({"ReProIndex": ix}) except: return None # define empty variables coh = np.zeros([len(metas), FFT]) coh_short = np.zeros([len(metas), FFT]) P_csd = np.zeros([len(metas), FFT], dtype=complex) P_csd_short = np.zeros([len(metas), FFT], dtype=complex) P_psd = np.zeros([len(metas), FFT]) P_psd_short = np.zeros([len(metas), FFT]) H = np.zeros([len(metas), FFT]) H_short = np.zeros([len(metas), FFT]) MI = np.zeros([len(metas), FFT]) MI_short = np.zeros([len(metas), FFT]) meta_repros = [] # number of stimulus iterations for i in range(0, len(metas)): # extract meta infos wnFname = metas[i]["envelope"] wnDur = float( metas[i]["Settings"]["Waveform"]["duration"].split( "m")[0]) # duration in miliseconds # spikes spikes = np.array(datas[i]) # conversions wnDur /= 1000 # conversion to miliseconds spikes /= 1000 print(spikes.shape) convolved_Train, _ = train_convolve(spikes, sigma, FS, wnDur) print(sum(convolved_Train) / FS) wNoise = process_wn(wd, wnFname, len(convolved_Train)) # compute coherence, mutual information, transfer and the power spectra and cross-spectra density freq, coh[i,:], coh_short[i,:], H[i,:], H_short[i,:], MI[i,:], MI_short[i,:], \ P_csd[i,:], P_csd_short[i,:], P_psd[i,:], P_psd_short[i,:] \ = cohere_transfere_MI (convolved_Train, wNoise, nFFT, FS) # compute averages over iterations of the *same* repro coh_repro[counter,:], coh_repro_short[counter,:], \ H_repro[counter,:], H_repro_short[counter,:], \ MI_repro[counter,:], MI_repro_short[counter,:] = compute_avgs(coh, coh_short, H, H_short, MI, MI_short) # store one of the metas meta_repros.append(metas[0]) # store all the spikes from the same type of experiment spike_list.append(datas) counter = counter + 1 # plot the lot plot_the_lot(FHandles, freq, coh_repro, coh_repro_short, MI_repro, MI_repro_short, H_repro, H_repro_short, metas, cmap=[cmap[col_count]], raster='empty', annotation=False, comparison=True) # compute the average of the different repro presentations (with same test conditions) avgCoh, avgCoh_short, avgH, avgH_short, avgMI, avgMI_short = compute_avgs( coh_repro, coh_repro_short, H_repro, H_repro_short, MI_repro, MI_repro_short) # plot the lot plot_the_lot(FHandles, freq, avgCoh, avgCoh_short, avgMI, avgMI_short, avgH, avgH_short, meta_repros, cmap=[cmap[col_count]], raster='empty', annotation=False, comparison=True) # provide gVgate values FHandles[1].text(0.5, 0.8 - 0.05 * col_count, " ".join([ r'$g_{Vgate}$', ' = ', meta_repros[0]["Status"]["gvgate"].split(".")[0], 'nS' ]), color=cmap[col_count], transform=FHandles[1].transAxes, fontsize=10) FHandles[5].text( 0.5, 0.8 - 0.05 * col_count, " ".join([ r'$\tau_{Vgate}$', ' = ', meta_repros[0]["Status"]["vgatetau"].split(".")[0], 'ms' ]), color=cmap[col_count], transform=FHandles[5].transAxes, fontsize=10) # update spike dictionary spike_dict[k] = spike_list # update the color counter col_count += 1 # write FFT value FHandles[1].text(0.05, 0.90, " ".join(['FFT = ', str(nFFT)]), color='k', transform=FHandles[1].transAxes, fontsize=10) # plot raster plot spike_iter_count = 0 for i, k in enumerate(spike_dict): for j in range(len(spike_dict[k])): for gnj in range(len(spike_dict[k][j])): FHandles[7].plot(spike_dict[k][j][gnj], np.zeros(len(spike_dict[k][j][gnj])) + spike_iter_count, '|', color=cmap[i], ms=12) spike_iter_count += 1 FHandles[7].set_title( ppjoin(".".join([ exp_info["Cell"]["Location"], ':', expfolder, "dyn_noise_transfer", '_'.join([k for k, v in tests.items()]), '_'.join([ str(x) for sublist in [v for k, v in tests.items()] for x in sublist ]), "fft", str(nFFT) ]))) # Save figures FHandles[0].savefig(ppjoin(".".join([ expfolder, "coherence_transfer", '.'.join([k for k, v in tests.items()]), '.'.join([ str(x) for sublist in [v for k, v in tests.items()] for x in sublist ]), "fft", str(nFFT), 'svg' ])), transparent=True) FHandles[0].savefig(ppjoin(".".join([ expfolder, "coherence_transfer", '.'.join([k for k, v in tests.items()]), ".".join([ str(x) for sublist in [v for k, v in tests.items()] for x in sublist ]), "fft", str(nFFT), 'png' ])), transparent=True) # save figures into dedicated folder if necessary FHandles[0].savefig(ppjoin( '../overviewTransfer/', ".".join([ "_".join([ exp_info["Cell"]["Location"], expfolder, "coherence_transfer", "".join([k for k, v in tests.items()]), "_".join([ str(x) for sublist in [v for k, v in tests.items()] for x in sublist ]), "fft", str(nFFT) ]), 'pdf' ])), transparent=True)
def plot_final_policy_combined(exp_groups, des_mps, des_speed, min_speed, ax=None, fs=20., save_path=None): dt = 0.5 if ax is None: f, ax = plt.subplots(1, 1, figsize=(5, 3.5)) else: f = ax.get_figure() exp_groups.insert(0, [{ 'folder': os.path.join(EXP_FOLDER, 'random'), 'label': 'Random policy', 'color': cm.Greys(1.0) }]) for exp_group_num, exp_group in enumerate(exp_groups): distance_travelled = [] for exp in exp_group: samples_folder = os.path.join(exp['folder'], 'prediction/final_policy/') samples_fnames = [ os.path.join(samples_folder, fname) for fname in os.listdir(samples_folder) if fname[-4:] == '.npz' ] assert (len(samples_fnames) == 1) samples_fname = samples_fnames[0] samples = Sample.load(samples_fname) for sample in samples: distance = dt * (des_mps / des_speed) * (sample.get_U()[:, 1] - min_speed).sum() distance_travelled.append(distance) width = 0.8 / len(exp_groups) ax.bar([exp_group_num * width], [np.mean(distance_travelled)], yerr=[np.std(distance_travelled)], width=width * 0.8, error_kw=dict(lw=4, capsize=5, capthick=2), color=exp_group[0]['color'], ecolor=cm.Greys(0.5), label=exp_group[0]['label']) # for exp_group in exp_groups: # ax.plot([], [], lw=5., label=exp_group[0]['label'], color=exp_group[0]['color']) lgd = ax.legend(loc='upper center', fontsize=fs * 0.8, bbox_to_anchor=(1.35, 0.7)) ax.set_xlim((-0.05, width * len(exp_groups))) ax.set_ylim((-0.3, ax.get_ylim()[1])) ax.set_ylabel(r'Distance travelled (m)', fontsize=fs) for tick in ax.xaxis.get_major_ticks() + ax.xaxis.get_minor_ticks(): tick.label1.set_visible(False) for tick in ax.yaxis.get_major_ticks(): tick.label.set_fontsize(fs) if save_path is not None: f.savefig(save_path, bbox_extra_artists=(lgd, ), bbox_inches='tight')
def plot_final_policy(exp_groups, des_mps, des_speed, min_speed, ax=None, fs=20., save_path=None): dt = 0.5 if ax is None: f, ax = plt.subplots(1, 1, figsize=(10, 3.5)) else: f = ax.get_figure() exp_groups.insert(0, [{ 'folder': os.path.join(EXP_FOLDER, 'random'), 'label': 'Random policy', 'color': cm.Greys(0.5) }]) for exp_num, exp in enumerate(flatten_list(exp_groups)): samples_folder = os.path.join(exp['folder'], 'prediction/final_policy/') samples_fnames = [ os.path.join(samples_folder, fname) for fname in os.listdir(samples_folder) if fname[-4:] == '.npz' ] assert (len(samples_fnames) == 1) samples_fname = samples_fnames[0] samples = Sample.load(samples_fname) distance_travelled = [] for sample in samples: distance = dt * (des_mps / des_speed) * (sample.get_U()[:, 1] - min_speed).sum() distance_travelled.append(distance) # ax.plot(range(len(distance_travelled)), distance_travelled, # linestyle='', # marker=exp['marker'], # color=exp['color'], # mew=exp['mew']) ax.bar(np.arange(len(distance_travelled)) + 0.15 * exp_num + 0.1, distance_travelled, width=0.15, color=exp['color']) for exp_group in exp_groups: ax.plot([], [], lw=5., label=exp_group[0]['label'], color=exp_group[0]['color']) lgd = ax.legend(loc='upper right', fontsize=fs * 0.8) ax.set_xlabel(r'Starting position', fontsize=fs) ax.set_ylabel(r'Distance travelled (m)', fontsize=fs) N = len(distance_travelled) ax.set_xticks(np.arange(N) + 0.5) ax.set_xticklabels([str(x) for x in range(N)]) # Hide major tick labels and customize minor tick labels ax.xaxis.set_minor_formatter(ticker.NullFormatter()) ax.xaxis.set_major_locator(ticker.FixedLocator(np.arange(N) + 0.5)) ax.xaxis.set_major_formatter( ticker.FixedFormatter([r'{0}'.format(str(x)) for x in range(N)])) for tick in ax.xaxis.get_major_ticks() + ax.yaxis.get_major_ticks(): tick.label.set_fontsize(fs) if save_path is not None: f.savefig(save_path, bbox_extra_artists=(lgd, ), bbox_inches='tight')
def plot_boxplot_speeds(exp_groups, des_mps, des_speed, min_speed, ax=None, is_legend=True, start_itr=0, save_path=None, ylim=None, fs=20.): end_itr = min([len(exp['U']) for exp in flatten_list(exp_groups)]) itrs_offset = np.linspace(0.35, 0.65, len(exp_groups)) if ax is None: f, ax = plt.subplots(1, 1, figsize=(1.5 * (end_itr - start_itr), 5)) else: f = ax.get_figure() T = 0 for exp_group in exp_groups: for exp in exp_group: for U_itr in exp['U']: for U in U_itr: T = max(T, len(U)) for exp_group_num, exp_group in enumerate(exp_groups): xvels_itrs = [] for itr in xrange(start_itr, end_itr): xvels = [] for exp in exp_group: xvels += flatten_list([ list((des_mps / des_speed) * (U[:, 1] - min_speed)) + [0] * (T - len(U)) for U in exp['U'][itr] ]) xvels_itrs.append(xvels) color = exp_group[0]['color'] ax.errorbar([itr + itrs_offset[exp_group_num]], [np.mean(xvels)], [[np.mean(xvels) - np.min(xvels)], [np.max(xvels) - np.mean(xvels)]], fmt='.k', ecolor='gray', lw=1.5, capsize=5., capthick=2.) ax.errorbar(itr + itrs_offset[exp_group_num], np.mean(xvels), np.std(xvels), marker='o', color=color, ecolor=color, mec=color, lw=3.) des_xvel_handle = ax.plot((start_itr, end_itr), (des_mps, des_mps), color='k', ls=':', lw=2.)[0] ax.set_xlim((start_itr, end_itr)) ax.set_ylim((0, des_mps * 1.1)) if ylim is not None: ax.set_ylim(ylim) # background color for itr in xrange(start_itr, end_itr): ax.axvspan(itr, itr + 1, facecolor=cm.Greys(0.05 + (itr % 2) * 0.1), edgecolor='none') ax.set_xticks(np.arange(start_itr, end_itr) + 0.5) ax.set_xticklabels([str(x) for x in range(start_itr, end_itr)]) # Hide major tick labels and customize minor tick labels ax.xaxis.set_major_formatter(ticker.NullFormatter()) ax.xaxis.set_minor_locator( ticker.FixedLocator(np.arange(start_itr, end_itr) + 0.5)) ax.xaxis.set_minor_formatter( ticker.FixedFormatter( [r'{0}'.format(str(x)) for x in range(start_itr, end_itr)])) ax.set_xlabel('Iteration', fontsize=fs) ax.set_ylabel('Speed (m/s)', fontsize=fs) for tick in ax.xaxis.get_minor_ticks() + ax.yaxis.get_major_ticks(): tick.label.set_fontsize(fs) if is_legend: # Create legend extra = Rectangle((0, 0), 1, 1, fc="w", fill=False, edgecolor='none', linewidth=0) legend_handles = [] legend_labels = [] legend_handles.append(des_xvel_handle) legend_labels.append('') legend_handles.append(extra) legend_labels.append('Desired speed') for exp_group in exp_groups: legend_handles.append( Rectangle((0, 0), 1, 1, color=exp_group[0]['color'], fill=True, linewidth=1)) legend_labels.append('') legend_handles.append(extra) legend_labels.append(exp_group[0]['label']) lgd = f.legend(legend_handles, legend_labels, loc='upper center', bbox_to_anchor=(0.45, 1.15), ncol=len(legend_handles), handletextpad=-2, handlelength=3., fontsize=fs) if save_path is not None: f.tight_layout() f.savefig(save_path, bbox_extra_artists=(lgd, ), bbox_inches='tight')
def plot_num_successful(exp_groups, ax=None, fs=20., save_path=None, is_legend=False): if ax is None: f, ax = plt.subplots(1, 1, figsize=(4, 4)) else: f = ax.get_figure() end_itr = min([len(exp['U']) for exp in flatten_list(exp_groups)]) reps = len(exp_groups[0][0]['U'][0]) T = 10 for itr in xrange(0, end_itr): ax.axvspan(itr, itr + 1, facecolor=cm.Greys(0.05 + (itr % 2) * 0.1), edgecolor='none') for exp_group_num, exp_group in enumerate(exp_groups): frac_successful_itrs_group = [] for exp in exp_group: num_successful_itrs = np.array([0.] * end_itr) for itr in xrange(end_itr): for rep in xrange(reps): if exp['stop_rollout'][itr][rep] or len( exp['U'][itr][rep]) == T: num_successful_itrs[itr] += 1. frac_successful_itrs = num_successful_itrs / (reps) frac_successful_itrs_group.append(frac_successful_itrs) frac_successful_itrs_group = 100 * np.array(frac_successful_itrs_group) width = 0.8 / len(exp_groups) ax.bar(np.arange(end_itr) + exp_group_num * width + width / 4., frac_successful_itrs_group.mean(axis=0), yerr=frac_successful_itrs_group.std(axis=0), width=width * 0.8, error_kw=dict(lw=2, capsize=3, capthick=1), color=exp_group[0]['color'], ecolor=cm.Greys(0.5), label=exp_group[0]['label']) ax.set_xlabel(r'Iteration', fontsize=fs) ax.set_ylabel(r'\begin{center}Successful\\rollouts (\%)\end{center}', fontsize=fs) ax.set_ylim((0, 100)) N = end_itr ax.set_xticks(np.arange(N) + 0.5) ax.set_xticklabels([str(x) for x in range(N)]) # Hide major tick labels and customize minor tick labels ax.xaxis.set_minor_formatter(ticker.NullFormatter()) ax.xaxis.set_major_locator(ticker.FixedLocator(np.arange(N) + 0.5)) ax.xaxis.set_major_formatter( ticker.FixedFormatter([r'{0}'.format(str(x)) for x in range(N)])) for tick in ax.xaxis.get_major_ticks() + ax.yaxis.get_major_ticks(): tick.label.set_fontsize(fs) if is_legend: leg = ax.legend(loc='upper left', ncol=2, bbox_to_anchor=(-0.5, 1.5), fontsize=fs) else: leg = None if save_path is not None: f.tight_layout() f.savefig(save_path, bbox_extra_artists=(leg, ), bbox_inches='tight', dpi=200)
# The following histogram shows I vs position. This is a representation of the average value of the number of photons emitted between any two consecutive integral positions along hte tubelight and thus a representation of the average intensity. # In[50]: if p!=0: plt.figure(1,figsize=size) plt.title("Intensity (average) of the tubelight vs position", fontsize=18) plt.xlabel("Position", fontsize=18) plt.ylabel("Intensity/ Number of photons emitted",fontsize=18) plt.grid(True) ret=plt.hist(I,np.arange(0,n+1,1),color="white") vals=ret[0] vals=1-(vals/max(vals)) norm = colors.Normalize(vals.min(), vals.max()) for thisfrac, thispatch in zip(vals, ret[2]): color = cm.Greys(norm(thisfrac)) thispatch.set_facecolor(color) plt.show() plt.close() # We plot the phase space of the electrons and also make a table of the centers of the bins and the intensity (number of photons) values. # In[53]: plt.figure(2,figsize=size) plt.xlabel("X",fontsize=18) plt.title("Electron phase space",fontsize=18) plt.ylabel("V",fontsize=18) plt.grid(True)
pres_41_45['President'].value_counts() pres_41_45.groupby('President', sort=False).median().round(1) import matplotlib.pyplot as plt from matplotlib import cm fig, ax = plt.subplots(figsize=(16, 6)) styles = ['-.', '-', ':', '-', ':'] colors = [.9, .3, .7, .3, .9] groups = pres_41_45.groupby('President', sort=False) for style, color, (pres, df) in zip(styles, colors, groups): df.plot('End Date', 'Approving', ax=ax, label=pres, style=style, color=cm.Greys(color), title='Presidential Approval Rating') days_func = lambda x: x - x.iloc[0] pres_41_45['Days in Office']=pres_41_45.groupby('President')['End Date']\ .transform(days_func) pres_41_45.head() pres_41_45.groupby('President').head(3) pres_41_45.dtypes pres_41_45['Days in Office'] = pres_41_45['Days in Office'].dt.days pres_41_45['Days in Office'].head() pres_pivot = pres_41_45.pivot(index='Days in Office', columns='President', values='Approving') pres_pivot.head() plot_kwargs = dict(figsize=(16, 6),
ax.scatter(lon_rot, lat_rot, color='red', s=5, label="Earth's Rotation") plt.legend() ax.stock_img() ax.gridlines() ax.coastlines() plt.title("Effect of Earth's rotation on the Ground Track") plt.show() # ================================================================================== # # Several orbital periods # # ================================================================================== # per = 3 leo_per = orbital_elements(h=1000, e=0.0, i=45, raan=0, omega=0) lon_per, lat_per = compute_track(leo, periods=per, rotation=True) colors = cm.Greys(np.linspace(0, 1, N_points * per)) fig = plt.figure() ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree()) ax.scatter(lon_per, lat_per, color=colors, s=5) ax.stock_img() ax.gridlines() ax.coastlines() plt.title("%d Periods" % (per)) # ================================================================================== # # Effect of Inclination # # ================================================================================== # i1, i2 = 45, 60 inc1 = orbital_elements(h=600, e=0.0, i=i1, raan=0, omega=0)
import numpy as np from matplotlib import cm r = np.linspace(0, 1, 257)[:256] cmapInferno = np.array(cm.inferno(r) * 255, dtype=np.uint8) r = np.linspace(0, 1, 101) cmapGreys = np.array(cm.Greys(r) * 255, dtype=np.uint8) print("#pragma once\n\nunsigned int CM_GREYS[101] {") for r, g, b, a in cmapGreys: print(" " + str((r << 24) | (g << 16) | (b << 8) | a) + ",") print("};") # print("\n\nunsigned int CM_INFERNO[256] {") # for r, g, b, a in cmapInferno: # print(" " + str((r << 24) | (g << 16) | (b << 8) | a) + ",") # print("};") # print("logic [255:0][31:0] CM_INFERNO = {") # for r, g, b, a in cmapInferno[::-1]: # print(" {32'h" + hex((r << 24) | (g << 16) | (b << 8) | a)[2:] + "},") # print("};\n")