def add_extra_dims(linear_model): color_map = cm.ScalarMappable(cmap="hsv") color_array = color_map.to_rgba(linear_model)[:, :-1] new_model = np.zeros((color_array.shape[0], 4)) for x in range(color_array.shape[0]): new_model[x] = np.append(color_array[x], linear_model[x]) return new_model
def plot1D(self, scale=True, meridians=np.arange(5, 12, 2), parallels=np.arange(44, 49, 2), vmin=0., vmax=15, blindzone=False): """ Show alert times for selected events. """ ttPmed = np.median(self.ttP, axis=0) if blindzone: bz2 = ttPmed * ttPmed * self.vs * self.vs - self.dep * self.dep bz2 = np.where(bz2 > 0.0, bz2, 0.0) bz = np.sqrt(bz2) ttPmed = bz cmap = cm.ScalarMappable(norm=Normalize(vmin=vmin, vmax=vmax), cmap=self.cmapname) for lt, ln, delay in zip(self.lat, self.lon, ttPmed): cl = cmap.to_rgba(delay) x, y = self.m(ln, lt) self.m.plot(x, y, ms=8, c=cl, marker='o', picker=5.) self.m.drawmeridians(meridians, labels=[0, 0, 0, 1], color='lightgray', linewidth=0.5, zorder=0) self.m.drawparallels(parallels, labels=[1, 0, 0, 0], color='lightgray', linewidth=0.5, zorder=0) self.m.drawcoastlines(zorder=2) self.m.drawcountries(linewidth=1.0, zorder=2) self.m.drawstates(zorder=2)
def plotHist(data, title, countTools, xlabel="hour", ylabel="count of queries", log=False): if not os.path.exists(title[:title.rfind("/")]): os.makedirs(title[:title.rfind("/")]) fig = plt.figure(1) ax = fig.add_subplot(111) plt.grid(True) plt.title(title) plt.xlabel(xlabel) plt.ylabel(ylabel) axes = plt.axes() axes.xaxis.set_major_locator(ticker.MultipleLocator(1)) if log: axes.set_yscale('log') colormap = cm.nipy_spectral(np.linspace(0, 1, countTools)) color = iter(colormap) minMetricValue = data[0][1]["Y"][0] maxMetricValue = 0 for dataPoint in data: c = next((color)) XY = dataPoint[1] if (XY["Y"][0] < minMetricValue): minMetricValue = XY["Y"][0] if (XY["X"][0] > maxMetricValue): maxMetricValue = XY["Y"][0] try: ax.bar(XY["X"], XY["Y"], align='center', color=c, edgecolor=c) except ValueError: pass scalarMappaple = cm.ScalarMappable(cmap=cm.nipy_spectral, norm=plt.Normalize(vmin=minMetricValue, vmax=maxMetricValue)) scalarMappaple._A = [] plt.colorbar(scalarMappaple) if xlabel is 'hour': plt.xlim(-1, 24) if xlabel is 'day': plt.xlim(0, 32) plt.xticks(fontsize=9) plt.savefig(title + ".png", bbox_inches='tight') plt.close()
def plot_densities_on_map_by_time_point(population_data, time): plt.figure(figsize=(14, 8)) my_map = Basemap(projection='robin', lat_0=57, lon_0=-135, resolution='l', area_thresh=1000.0, llcrnrlon=-136.25, llcrnrlat=56, urcrnrlon=-134.25, urcrnrlat=57.75) my_map.drawcoastlines() my_map.drawcountries() my_map.fillcontinents(color='lightgray', zorder=0) my_map.drawmapboundary() my_map.drawmeridians(np.arange(0, 360, 30)) my_map.drawparallels(np.arange(-90, 90, 30)) time_index = -1 for i in range(0, len(population_data.time_array)): if time == population_data.time_array[ i] * population_data.time_multiplier: time_index = i break lats = [] lons = [] dens = [] for i in range(0, len(population_data.density_array[time_index])): density = population_data.density_array[time_index][i] if density != 0: lats.append(population_data.lat_array[i]) lons.append(population_data.lon_array[i]) dens.append(density) cmap = cm.get_cmap('jet') dens = np.array(dens).astype(float) / 3000 x, y = my_map(lons, lats) rgba = cmap(dens) ax = my_map.scatter(x, y, marker='o', c=rgba, s=3, zorder=1) sm = cm.ScalarMappable(cmap=cmap) sm.set_array([]) sm.set_clim([0, 3000]) plt.colorbar(sm, orientation='horizontal', pad=0.03, aspect=50) plt.savefig("densitites_on_map_" + population_data.name + "_" + str(time) + "Kya.png") map_path = get_map_file_path(population_data.name.lower() + "_densitites_on_map_" + str(time) + ".png") print("Map filepath: " + map_path) plt.savefig(map_path, dpi=500) plt.close()
def make_brain_image(views, brain, orient="horizontal", text="", text_loc=None, text_pan=None, fontsize=160, legend=None, legend_pan=None, cbar=None, vmin=None, vmax=None, cbar_label=""): img_list = [] axis = 1 if orient=="horizontal" else 0 for k,v in views.items(): brain.show_view(**v) scr = brain.screenshot() img_list.append(scr) if text != "": img_txt_list = [] brain.add_text(0, 0.8, text, text_loc, font_size=fontsize, color=(0,0,0)) for k,v in views.items(): brain.show_view(**v) scr = brain.screenshot() img_txt_list.append(scr) img_list[text_pan] = img_txt_list[text_pan] if legend: legend_list = [] brain._renderer.plotter.add_legend(legend, bcolor=(1,1,1)) for k,v in views.items(): brain.show_view(**v) scr = brain.screenshot() legend_list.append(scr) img_list[legend_pan] = legend_list[legend_pan] if orient == "square": # only works for 2x2 h, w, _ = img_list[0].shape img = np.zeros((h*2, w*2, 3), dtype=np.uint8) img[:h, :w, ] = img_list[0] img[:h, w:, ] = img_list[1] img[h:, :w, ] = img_list[2] img[h:, w:, ] = img_list[3] else: img = np.concatenate(img_list, axis=axis) if cbar: norm = Normalize(vmin, vmax) scalmap = cm.ScalarMappable(norm, cbar) if orient == "horizontal": colbar_size = (img_list[-1].shape[0]*4, img_list[-1].shape[1]/6) else: colbar_size = (img_list[-1].shape[0]/6, img_list[-1].shape[1]*4) colbar_size = np.array(colbar_size) / 100 fig, ax = plt.subplots(1,1, figsize=colbar_size) colbar = plt.colorbar(scalmap, cax=ax, orientation=orient) ax.tick_params(labelsize=48) if orient == "horizontal": ax.set_xlabel(cbar_label, fontsize=48) else: ax.set_ylabel(cbar_label, fontsize=48) fig.tight_layout() fig.canvas.draw() mat = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8) mat = mat.reshape(fig.canvas.get_width_height()[::-1] + (3,)) img = np.concatenate((img, mat), axis=abs(axis-1)) return img
def visualize_frustum_ptcloud_with_cam(frustum_ptcloud): ''' :param frustum_ptcloud: np.ndarray, shape (n,4) [x,y,z,s], s is the class activation score \in (0,1) ''' cm = colormap.get_cmap('RdBu') #inferno color_mapper = colormap.ScalarMappable(norm=matplotlib.colors.Normalize( vmin=0, vmax=1, clip=True), cmap=cm) color = color_mapper.to_rgba(frustum_ptcloud[:, 3])[:, :3] * 255 visualize_ptcloud_with_color(frustum_ptcloud[:, 0:3], color)
def plot_optimized_network(network, blocking=True, save_plot=True): _title = 'Optimized network vs. non-optimized' figure(_title) graph = network.network_plot plot_layout = spring_layout(graph) balls = network.get_ball_distribution() print(network.ref_distribution) print(balls) min_val = 0 max_val = max([np_max(network.ref_distribution), np_max(balls)]) cmap = cm.Greys color_vals = cm.ScalarMappable(cmap=cmap, norm=Normalize(vmin=min_val, vmax=max_val)) color_vals._A = [] subplot(2, 1, 1) title('Initial network') colorbar(color_vals) draw_networkx_edges(graph, plot_layout, alpha=.3) draw_networkx_nodes(graph, plot_layout, node_size=100, edgecolors='k', node_color=network.ref_distribution, cmap=cmap, vmin=min_val, vmax=max_val) axis('off') # Disable axis subplot(2, 1, 2) title('Optimized network') colorbar(color_vals) draw_networkx_edges(graph, plot_layout, alpha=.3) draw_networkx_nodes(graph, plot_layout, node_size=100, edgecolors='k', node_color=balls, cmap=cmap, vmin=min_val, vmax=max_val) axis('off') draw() if save_plot: savefig('../results/optimized_network.png') show(block=blocking) # Open matplotlib window
def save_summaries(writer: SummaryWriter, data: Dict, predicted: List, endpoints: Dict = None, losses: Dict = None, metrics: Dict = None, step: int = 0): """Save tensorboard summaries""" subset = [0, 1] with torch.no_grad(): # Save clouds if 'points_src' in data: points_src = data['points_src'][subset, ..., :3] points_ref = data['points_ref'][subset, ..., :3] colors = torch.from_numpy( np.concatenate([np.tile(ORANGE, (*points_src.shape[0:2], 1)), np.tile(BLUE, (*points_ref.shape[0:2], 1))], axis=1)) iters_to_save = [0, len(predicted)-1] if len(predicted) > 1 else [0] # Save point cloud at iter0, iter1 and after last iter concat_cloud_input = torch.cat((points_src, points_ref), dim=1) writer.add_mesh('iter_0', vertices=concat_cloud_input, colors=colors, global_step=step) for i_iter in iters_to_save: src_transformed_first = se3.transform(predicted[i_iter][subset, ...], points_src) concat_cloud_first = torch.cat((src_transformed_first, points_ref), dim=1) writer.add_mesh('iter_{}'.format(i_iter+1), vertices=concat_cloud_first, colors=colors, global_step=step) if endpoints is not None and 'perm_matrices' in endpoints: color_mapper = colormap.ScalarMappable(norm=None, cmap=colormap.get_cmap('coolwarm')) for i_iter in iters_to_save: ref_weights = torch.sum(endpoints['perm_matrices'][i_iter][subset, ...], dim=1) ref_colors = color_mapper.to_rgba(ref_weights.detach().cpu().numpy())[..., :3] writer.add_mesh('ref_weights_{}'.format(i_iter), vertices=points_ref, colors=torch.from_numpy(ref_colors) * 255, global_step=step) if endpoints is not None: if 'perm_matrices' in endpoints: for i_iter in range(len(endpoints['perm_matrices'])): src_weights = torch.sum(endpoints['perm_matrices'][i_iter], dim=2) ref_weights = torch.sum(endpoints['perm_matrices'][i_iter], dim=1) writer.add_histogram('src_weights_{}'.format(i_iter), src_weights, global_step=step) writer.add_histogram('ref_weights_{}'.format(i_iter), ref_weights, global_step=step) # Write losses and metrics if losses is not None: for l in losses: writer.add_scalar('losses/{}'.format(l), losses[l], step) if metrics is not None: for m in metrics: writer.add_scalar('metrics/{}'.format(m), metrics[m], step) writer.flush()
def make_brain_figure(views, brain, cbar=None, vmin=None, vmax=None, cbar_label="", cbar_orient="vertical", hide_cbar=False): img_list = [] for k,v in views.items(): brain.show_view(**v) scr = brain.screenshot() img_list.append(scr) width = 3*scr.shape[0]/100 height = scr.shape[1]/100 cb_ratio = 6 pans = ["A", "B", "C"] if cbar: width += width * 1/cb_ratio mos_str = "" if cbar_orient == "vertical": for pan in pans: for x in range(cb_ratio): mos_str += pan mos_str += "D" elif cbar_orient == "horizontal": for x in range(cb_ratio): for pan in pans: mos_str += pan mos_str += "\n" mos_str += "D"*len(pans) fig, axes = plt.subplot_mosaic(mos_str, figsize=(width, height)) for img_mos, img in zip(pans, img_list): axes[img_mos].imshow(img) axes[img_mos].axis("off") if not hide_cbar: norm = Normalize(vmin, vmax) scalmap = cm.ScalarMappable(norm, cbar) plt.colorbar(scalmap, cax=axes["D"], orientation=cbar_orient) axes["D"].tick_params(labelsize=48) if cbar_orient == "horizontal": axes["D"].set_xlabel(cbar_label, fontsize=48) else: axes["D"].set_ylabel(cbar_label, fontsize=48) else: axes["D"].axis("off") else: fig, axes = plt.subplots(1, 3, figsize=(width, height)) for ax, img in zip(axes, img_list): ax.imshow(img) ax.axis("off") return fig
def plot_network(network, blocking=True, netx_plot=False, size=fig_size, weights=None, file_name=None, plot_edges=False, alph=.05): fig = figure(figsize=size) rcParams.update({ 'font.size': plot_font_size, 'mathtext.default': 'regular' }) ax = fig.gca() ax.axis('off') # Disable axis graph = network if netx_plot else network.network_plot plot_layout = kamada_kawai_layout(graph) cmap = cm.get_cmap('coolwarm') sizes, edge_colors, node_colors = 80, 'k', 'w' if weights is not None: sizes = [50 if weight == 0 else 80 for weight in weights] node_colors = weights min_val, max_val = min(weights), max(weights) if plot_edges: draw_networkx_edges(graph, plot_layout, alpha=alph) draw_networkx_nodes(graph, plot_layout, node_size=sizes, linewidths=.5, edgecolors='k', node_color=node_colors, cmap=cmap) draw() if weights is not None: plt = cm.ScalarMappable(cmap=cmap, norm=Normalize(vmin=0, vmax=1)) plt._A = [] colorbar(plt) if file_name is not None: savefig(file_name, bbox_inches='tight', pad_inches=0) show(block=blocking) # Open matplotlib window
def visualise_signature_distances(self): """ plots distances between, colored with green=identical, red=different. """ dist = self.signature_distances ids = sorted(dist.keys()) xs = [] ys = [] colors = [] colormap = cm.ScalarMappable(cmap='RdYlGn', norm=plt.Normalize(vmin=0, vmax=1)) for x, x_id in enumerate(ids): for y, y_id in enumerate(ids): xs.append(x) ys.append(y) score = 1 - dist[x_id][y_id] colors.append(colormap.to_rgba(score)) plt.scatter(xs, ys, c=colors) plt.title('movie: "%s"' % self.movie.name) plt.show()
def plot_layer_2d(mat): import matplotlib.pyplot as plt from matplotlib.pyplot import cm fig = plt.figure() ax = fig.add_subplot(111) x, y = np.meshgrid(range(mat.shape[1]), range(mat.shape[0])) xs = x.reshape(-1) ys = y.reshape(-1) cols = mat.reshape(-1) - np.min(mat) colors = cm.hsv(cols / max(cols)) colormap = cm.ScalarMappable(cmap=cm.hsv) colormap.set_array(cols) ax.scatter(xs, ys, c=colors) cb = fig.colorbar(colormap) plt.title("subtracted:{}".format(np.min(mat))) plt.show()
def plot_rawdata(r, savefig=None, **kargs): matplotlib.style.use('ggplot') try: dmin = kargs['datemin'] dmax = kargs['datemax'] except KeyError: idx = np.arange(r.d_var.shape[0]) else: try: dt = r.datetime[:].astype('datetime64[ms]') idx = np.where(((dt > np.datetime64(dmin)) & (dt < np.datetime64(dmax))))[0] except tables.NoSuchNodeError: idx = np.arange(r.d_var.shape[0]) counts = r.d_var[idx, :] w = r.ind_var[:] nc = counts.shape[0] cmap = cm.ScalarMappable(norm=Normalize(vmin=0, vmax=nc-1), cmap='RdBu') fig = plt.figure(figsize=(12, 6)) for i in range(nc): c = cmap.to_rgba(i) plt.plot(w, counts[i], color=c, alpha=0.2) plt.xlabel('Wavelength [nm]') plt.ylabel('Intensity') cax, kw = matplotlib.colorbar.make_axes(plt.gca()) norm = Normalize(vmin=0, vmax=nc, clip=False) c = matplotlib.colorbar.ColorbarBase(cax, cmap='RdBu', norm=norm) ticks = np.array([0, int(nc/2.), nc-1]) c.set_ticks(ticks) try: times = r.datetime[idx] labels = np.array([times[0], times[int(nc/2.)], times[nc-1]]) c.set_ticklabels(labels) except tables.NoSuchNodeError: pass if savefig is not None: plt.savefig( savefig, bbox_inches='tight', dpi=300, format='png') return fig
def plot_layer_3d(mat): import matplotlib.pyplot as plt from matplotlib.pyplot import cm from mpl_toolkits.mplot3d import Axes3D fig = plt.figure() ax = fig.add_subplot(111, projection='3d') x, y, z = np.meshgrid(range(mat.shape[1]), range(mat.shape[0]), range(mat.shape[2])) xs = x.reshape(-1) ys = y.reshape(-1) zs = z.reshape(-1) cols = mat.reshape(-1) - np.min(mat) colors = cm.hsv(cols / max(cols)) colormap = cm.ScalarMappable(cmap=cm.hsv) colormap.set_array(cols) ax.scatter(xs, ys, zs, c=colors) cb = fig.colorbar(colormap) plt.title("subtracted:{}".format(np.min(mat))) plt.show()
def __init__(self, cmap, clim): self.colormap = cm.ScalarMappable(cmap=cmap, norm=Normalize(*clim))
def add_rgb_prostate(array): scaler_map = cm.ScalarMappable(cmap="Reds") array = scaler_map.to_rgba(array)[:, : -1] return array
def add_rgb_organs(array): scaler_map = cm.ScalarMappable(cmap="Blues") array = scaler_map.to_rgba(array)[:, : -1] return array
def alert_times_map(self, fns, m=None, fig=None, ax=None, scale=10000., cb=True, disterr=False, interactive=False, eventinfo=None, msscale=1, cmapname='jet'): """ Plot a map of observed alert times. """ cmap = cm.ScalarMappable(norm=Normalize(vmin=6, vmax=25), cmap=cmapname) rp = ReportsParser(dmin=UTCDateTime(2012, 1, 1, 0, 0, 0), dmax=UTCDateTime(2013, 11, 1, 0, 0, 0)) t = EventCA() rp.sfilter = t.point_in_polygon for _f in fns: rp.read_reports(_f) correct = rp.get_correct(mmin=3.5, mmax=10.0) pid = correct[:, 0] ot = correct[:, 2].astype('float') lats = correct[:, 3].astype('float') lons = correct[:, 4].astype('float') mags = correct[:, 6].astype('float') ts1 = correct[:, 7].astype('float') lats1 = correct[:, 9].astype('float') lons1 = correct[:, 10].astype('float') mags1 = correct[:, 12].astype('float') rfns = correct[:, 21] diff = ts1 - ot magdiff = mags - mags1 if m is None and fig is None and ax is None: fig = plt.figure() ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) m = self.background_map(ax) dataX = [] dataY = [] values = [] # load event info cnt = 0 allcnt = 0 for lon, lat, delay, evid, lat1, lon1, dmag, time, mag, rfn in \ zip(lons, lats, diff, pid, lats1, lons1, magdiff, ot, mags, rfns): allcnt += 1 try: if eventinfo is not None and len(eventinfo[evid]) != 4: print "Event %s does not have 4 initial picks." % evid continue except KeyError: print "No event information available for: %s (%s)" % ( evid, UTCDateTime(time)) continue if evid in self.event_excludes: print "Event %s was set to be excluded." % evid continue cnt += 1 ddist, az, baz = gps2DistAzimuth(lat, lon, lat1, lon1) ddist /= 1000. x, y = m(lon, lat) dataX.append(x) dataY.append(y) info = '%s: %.2f %.2f %s' % (UTCDateTime(time), delay, mag, evid) for _st in eventinfo[evid]: info += ' %s' % _st values.append(info) cl = cmap.to_rgba(delay) if disterr: factor = math.sqrt(abs(float(ddist))) sl2 = scale * factor p2 = Wedge((x, y), sl2, 0, 360, facecolor=cl, edgecolor='black', picker=5, lw=1.0) ax.add_patch(p2) else: m.plot(x, y, ms=8 * msscale, c=cl, marker='o', picker=5.) print "Plotted %d out of %d events." % (cnt, allcnt) if interactive: self.popup(fig, dataX, dataY, values) if cb: # Colorbar cax = fig.add_axes([0.87, 0.1, 0.05, 0.8]) cb = ColorbarBase(cax, cmap=cmapname, norm=Normalize(vmin=6., vmax=25.)) cb.set_label('Time since origin time [s]')
_PATH = 'data/' + i + "_" + j + "_" + o + "_" + l + ".txt" #print _PATH f = np.loadtxt(_PATH, delimiter='\t', usecols=[0, 1, 2, 3]) ID = np.loadtxt(_PATH, delimiter='\t', usecols=[7], dtype=str) if ID[0] != "": a = f[3:, :] else: a = f[:, :] fig = plt.figure() ax = fig.add_subplot(111, projection='3d') #ax.scatter(a[:,0],a[:,1],a[:,2]) a[:, 3] = 0 #create color scale color_norm = colors.Normalize(vmin=0, vmax=len(a) - 1) scalar_map = cm.ScalarMappable(norm=color_norm, cmap='hsv') print len(a) for t in range(0, len(a)): #calculate the Euclidian distance(ED) between all markers #if distance is under a upper, create an ID for u in range(0, len(a)): ED = np.sqrt((a[t, 0] - a[u, 0])**2 + (a[t, 1] - a[u, 1])**2 + (a[t, 2] - a[u, 2])**2) if ED <= _BANDWIDTH and a[u, 3] == 0: a[u, 3] = t #set different colors col = scalar_map.to_rgba(a[t, 3]) if (a[t, 3] % 3) != 0 and a[t, 3] != 1: ax.scatter(a[t, 0], a[t, 1],
def plot_samples(self, title, inputs, outputs=None, predictions=None, show=True, filename=None, interactive=False, figsize=(10, 6)): """Plot samples belonging to this dataset. Args: (....): See docstring of method :meth:`data.dataset.Dataset.plot_samples`. """ if inputs.shape[1] != 2: raise ValueError( 'This method is only applicable to 2D input data!') plt.figure(figsize=figsize) plt.title(title, size=20) if interactive: plt.ion() if self.classification: n = self.num_classes colors = np.asarray(misc.get_colorbrewer2_colors(family='Dark2')) if n > len(colors): #warn('Changing to automatic color scheme as we don\'t have ' + # 'as many manual colors as tasks.') colors = cm.rainbow(np.linspace(0, 1, n)) else: norm = Normalize(vmin=self._data['out_data'].min(), vmax=self._data['out_data'].max()) cmap = cm.get_cmap(name='viridis') sm = cm.ScalarMappable(norm=norm, cmap=cmap) sm.set_array(np.asarray([norm.vmin, norm.vmax])) if outputs is not None or predictions is not None: plt.colorbar(sm) if outputs is not None and predictions is None: plt.scatter(inputs[:, 0], inputs[:, 1], #edgecolors='b', label='Targets', facecolor=colors[outputs.squeeze().astype(int)] \ if self.classification else \ cmap(norm(outputs.squeeze())) ) elif predictions is not None and outputs is None: plt.scatter(inputs[:, 0], inputs[:, 1], #edgecolors='r', label='Predictions', facecolor=colors[predictions.squeeze().astype(int)] \ if self.classification else \ cmap(norm(predictions.squeeze())) ) elif predictions is not None and outputs is not None: plt.scatter(inputs[:, 0], inputs[:, 1], label='Targets+Predictions', edgecolors=colors[outputs.squeeze().astype(int)] \ if self.classification else \ cmap(norm(outputs.squeeze())), facecolor=colors[predictions.squeeze().astype(int)] \ if self.classification else \ cmap(norm(predictions.squeeze())) ) else: assert predictions is None and outputs is None plt.scatter(inputs[:, 0], inputs[:, 1], color='k', label='Inputs') #plt.legend() plt.xlabel('x1') plt.ylabel('x2') if filename is not None: plt.savefig(filename, bbox_inches='tight') if show: plt.show()
def statistics(self, fns, fn, stationfn, eventinfo=None, latencies=None, computedelay=False, map=False, interactive=False): """ Compare predicted and observed alert times quantitatively. """ a = np.load(fn) lats_tt = a['lat'][:, :, 0] lons_tt = a['lon'][:, :, 0] times = np.median(a['ttP'], axis=-1) tree = spatial.KDTree(zip(lats_tt.ravel(), lons_tt.ravel())) vals = [] perc_max = 84 perc_min = 16 rp = ReportsParser(dmin=UTCDateTime(2012, 1, 1, 0, 0, 0), dmax=UTCDateTime(2013, 11, 1, 0, 0, 0)) # t = EventCA() t = EventSoCal() rp.sfilter = t.point_in_polygon for _f in fns: rp.read_reports(_f) correct = rp.get_correct(mmin=3.5, mmax=10.0) pid = correct[:, 0] ot = correct[:, 2].astype('float') lats = correct[:, 3].astype('float') lons = correct[:, 4].astype('float') deps = correct[:, 5].astype('float') mags = correct[:, 6].astype('float') ts1 = correct[:, 7].astype('float') lats1 = correct[:, 9].astype('float') lons1 = correct[:, 10].astype('float') mags1 = correct[:, 12].astype('float') rfns = correct[:, 21] diff = ts1 - ot magdiff = mags - mags1 cnt = 0 allcnt = 0 allm = [] dataX = [] dataY = [] popup_values = [] fig = plt.figure() ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) m = self.background_map(ax) cmap = cm.ScalarMappable(norm=Normalize(vmin=0, vmax=2), cmap='RdBu_r') stats_used = [] for lon, lat, dep, delay, evid, lat1, lon1, dmag, time, mag, rfn in \ zip(lons, lats, deps, diff, pid, lats1, lons1, magdiff, ot, mags, rfns): allcnt += 1 try: if eventinfo is not None and len(eventinfo[evid]) != 4: # print "Event %s does not have 4 initial picks." % evid continue except KeyError: print "No event information available for: %s (%s)" % ( evid, UTCDateTime(time)) continue if evid in self.event_excludes: print "Event %s was set to be excluded." % evid continue if computedelay: # Compute the expected alert time for the actual epicenter and # the first stations that detected the event class NetworkInfo: def __init__(self): self.networks = { 'ca': { 'lat': [], 'lon': [], 'chn': [], 'nw': [], 'nm': [], 'lc': [], 'color': 'black', 'label': 'UC Berkeley' } } def get_networks(self): return self.networks # read in SCEDC master station list fh = open(stationfn) scedc_stations = {} for _l in fh.readlines(): if _l.startswith('#'): continue net, sta, chan, loc, lt, ln, elev, ondate, offdate = _l.split( ) ns = '.'.join((net, sta)) if ns not in scedc_stations: scedc_stations[ns] = (float(lt), float(ln)) ni = NetworkInfo() for _st in eventinfo[evid]: ni.networks['ca']['lat'].append(scedc_stations[_st][0]) ni.networks['ca']['lon'].append(scedc_stations[_st][1]) ni.networks['ca']['nm'].append(_st) if _st not in stats_used: stats_used.append(_st) de = DelayEEW() elat, elon, edep, ttP, tstarget = \ de.compute(ni, np.array([float(lon)]), np.array([float(lat)]), np.array([float(dep)]), vp=6.5, vs=3.5, nnst=4, procdelay=True, nmaps=500, resultsfn=None, latencies=latencies) med = np.median(ttP) lb = scoreatpercentile(ttP, perc_min) ub = scoreatpercentile(ttP, perc_max) else: distance, index = tree.query(np.array([[lat, lon]])) irow, icol = divmod(index[0], lats_tt.shape[1]) med = np.median(times[:, irow, icol]) lb = scoreatpercentile(times[:, irow, icol], perc_min) ub = scoreatpercentile(times[:, irow, icol], perc_max) cnt += 1 allm.append(mag) val = (delay - lb) / (ub - lb) print med, lb, ub, delay, val, med - delay vals.append(val) cl = cmap.to_rgba(val) x, y = m(lon, lat) dataX.append(x) dataY.append(y) info = '%s: %.2f %s\n' % (UTCDateTime(time), mag, evid) info += '%.2f %.2f %.2f\n' % (delay, med, val) for _st in eventinfo[evid]: info += ' %s' % _st popup_values.append(info) m.plot(x, y, ms=8, c=cl, marker='o', picker=5.) # plt.figure() # plt.hist(times[ilon, ilat, :], bins=np.arange(0, 30), normed=True, histtype='step') # plt.show() print "Stations used in detections:" print stats_used idx = np.where((np.array(vals) <= 1.0) & (np.array(vals) >= 0)) print "%.1f lie within the %d and %d percentile" % ( (idx[0].size / float(len(vals))) * 100, perc_min, perc_max) # plt.plot(allm, vals, 'bo') if interactive: self.popup(fig, dataX, dataY, popup_values) cax = fig.add_axes([0.87, 0.1, 0.05, 0.8]) cb = ColorbarBase(cax, cmap='RdBu_r', norm=Normalize(vmin=0, vmax=2)) cb.set_label('Alert accuracy') plt.figure() plt.hist(vals, bins=20) plt.show()
# Get start time as beginning of middle day if ifil == 1: refdate = st[1].stats.starttime tstart = datetime(refdate.year, refdate.month, refdate.day, 0, 0, 0) else: tstart = (UTCDateTime(tstart) + 24 * 60 * 60).datetime jdaynum_sac[ifil] = refdate.julday # ensure start time in plot equals 0 dt = st[0].stats.starttime.timestamp fig = plt.figure(figsize=(10, 8)) colorday = np.arange(1, 5) norm = mcolors.Normalize(vmin=colorday.min(), vmax=colorday.max()) cmap = cm.ScalarMappable(norm=norm, cmap=cm.rainbow) cmap.set_array([]) t_zoom = 50 for i in np.arange(0, 3): t = np.linspace(st[i].stats.starttime.timestamp - dt, st[i].stats.endtime.timestamp - dt, st[i].stats.npts) ax1 = fig.add_subplot(4, 1, 1) ax1.plot(t, st[i].data, color=cmap.to_rgba(i + 1)) ax1.set(ylim=(3 * st[i].data.std() + st[i].data.mean(), -3 * st[i].data.std() + st[i].data.mean())) ax1.set(xlim=(0, 3 * 24 * 60 * 60)) ax1.set(title=sta + ' ' + ch + ' ' + str(st[0].stats.starttime) + ' to ' + str(st[2].stats.endtime) + ': total time shift = ' + str(np.round(dt_totalshift_sec / 60 / 60, 3)) +
color=timeColors[timeSlice]) speed_interpolant = LinearNDInterpolator( np.vstack((xCell, yCell)).T, speed[timeSlice, :]) speed_transect = speed_interpolant(np.vstack((xArray, yArray)).T) speed_transect[speed_transect == 0] = np.nan speed_transect[thk_transect == 0.] = np.nan speedAx.plot((distance[-1] - distance) / 1000., speed_transect, color=timeColors[timeSlice]) thickAx.plot((distance[-1] - distance) / 1000., bed_transect, color='black') speedAx.set_xlabel('Distance (km)') speedAx.set_ylabel('Surface\nspeed (m/yr)') speedAx.set_xlim((0, 35)) thickAx.set_ylabel('Elevation\n(m asl)') thickAx.set_xlim((0, 35)) transectFig.subplots_adjust(hspace=0.4) cbar = plt.colorbar(cm.ScalarMappable(cmap='plasma'), ax=transectAx) cbar.set_ticks(np.linspace(0, 1, 6)) cbar.set_label('Year', size='large') years = str(time).lstrip('[').rstrip(']').split() cbar.set_ticklabels(years[0::len(years) // 5]) cbar.ax.tick_params(labelsize=12) plt.show() dataset.close()
def draw_dendrogram(self, ax, pairs, values, labels, lw=20., alpha=0.4, cmap='viridis'): try: from matplotlib import collections as mc from matplotlib.pyplot import Arrow from matplotlib.pyplot import Normalize from matplotlib.pyplot import cm except ImportError: raise ImportError('You must install the matplotlib library to plot the minimum spanning tree.') min_index, max_index = min(pairs), max(pairs) if min_index < 0: raise ValueError('Indices should be non-negative') size = int(len(pairs) / 2 + 1) union_size = size if max_index > union_size - 1: union_size = max_index + 1 union_size += 2 # we will create Union Find as usual uf, sz = np.zeros(2 * union_size, dtype=int), np.ones(union_size) next_label = union_size + 1 # also we need links l, r = np.arange(0, 2*union_size), np.arange(0, 2*union_size) next_label = union_size + 1 for j in range(0, size - 1): a, b = pairs[2 * j], pairs[2 * j + 1] # we will stack first cluster on the left of second aa = a while aa != r[aa]: aa = r[aa] bb = b while bb != l[bb]: bb = l[bb] l[bb] = aa r[aa] = bb # linking aa = a while aa != l[aa]: aa = l[aa] bb = b while bb != r[bb]: bb = r[bb] l[next_label] = aa # marking the borders r[next_label] = bb aa, bb = self.fast_find(uf, a), self.fast_find(uf, b) uf[aa] = uf[bb] = next_label # i = next_label - union_size # a2 = (uf[a] != 0) * (aa - union_size) # b2 = (uf[b] != 0) * (bb - union_size) # na, nb = sz[a2], sz[b2] # sz[i] = na + nb next_label += 1 x_arr = self.arrange_nodes_on_x_axis(uf, union_size, l, r, 200.) norm = len(np.unique(pairs)) sm = cm.ScalarMappable(cmap=cmap, norm=Normalize(0, norm)) sm.set_array(norm) colors = self.get_dendro_colors(labels) heights = {} uf.fill(0) next_label = union_size + 1 for j in range(0, size - 1): v = np.log2(1. + values[j]) # logarithm heights[next_label] = v a, b = pairs[2 * j], pairs[2 * j + 1] # i = next_label - union_size aa, bb = self.fast_find(uf, a), self.fast_find(uf, b) x_arr[next_label] = (x_arr[r[aa]] + x_arr[l[bb]])/2. uf[aa] = uf[bb] = next_label next_label += 1 # a = (uf[a] != 0) * (aa - union_size) # b = (uf[b] != 0) * (bb - union_size) # na, nb = sz[a], sz[b] # sz[i] = na + nb ha, hb = 0, 0 xa, xb = x_arr[aa], x_arr[bb] if aa in heights: ha = heights[aa] if bb in heights: hb = heights[bb] c = 'gray' if labels[a] == labels[b] and labels[a] > 0: c = colors[labels[a]] ax.plot([xa, xa], [ha, v], color=c) ax.plot([xb, xb], [hb, v], color=c) ax.plot([xa, xb], [v, v], color=c) ax.set_xticks([]) for side in ('right', 'top', 'bottom'): ax.spines[side].set_visible(False) ax.set_ylabel('distance') # line_collection.set_array(self._mst[:, 2].T) return ax
def alert_times_map(self, fout=None, m=None, fig=None, ax=None, scale=10000., cb=False, magerr=False, interactive=False, msscale=1, realtime=False, cmapname='jet'): cmap = cm.ScalarMappable(norm=Normalize(vmin=6, vmax=25), cmap=cmapname) if m is None and fig is None and ax is None: fig = plt.figure() ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) m = self.background_map(ax) dataX = [] dataY = [] values = [] for evid in self.del_coord.keys(): lon, lat, delay, magdiff = self.del_coord[evid] x, y = m(lon, lat) dataX.append(x) dataY.append(y) values.append('%s: %.2f' % (evid, delay)) cl = cmap.to_rgba(delay) if magerr: factor = math.sqrt(abs(float(magdiff))) sl2 = scale * factor p2 = Wedge((x, y), sl2, 0, 360, facecolor=cl, edgecolor='black', picker=5, lw=1.0) ax.add_patch(p2) else: m.plot(x, y, ms=8 * msscale, c=cl, marker='s', picker=5.) print "Number of playback events plotted: %d" % len( self.del_coord.keys()) if realtime: for evid in self.del_coord_rt.keys(): lon, lat, delay, magdiff = self.del_coord_rt[evid] x, y = m(lon, lat) dataX.append(x) dataY.append(y) values.append('%s: %.2f' % (evid, delay)) cl = cmap.to_rgba(delay) if magerr: factor = math.sqrt(abs(float(magdiff))) sl2 = scale * factor p2 = Wedge((x, y), sl2, 0, 360, facecolor=cl, edgecolor='black', picker=5, lw=1.0) ax.add_patch(p2) else: m.plot(x, y, ms=8 * msscale, c=cl, marker='o', picker=5.) print "Number of realtime events plotted: %d" % \ len(self.del_coord_rt.keys()) if interactive: try: # add a pop-up window showing the station and its value tooltip = wx.ToolTip(tip='') tooltip.Enable(False) tooltip.SetDelay(0) fig.canvas.SetToolTip(tooltip) def onMotion(event): dir(event.artist) line2d = event.artist x = line2d.get_xdata()[0] y = line2d.get_ydata()[0] found = False for i in xrange(len(dataX)): radius = 5 if abs(x - dataX[i]) < radius and abs( y - dataY[i]) < radius: tip = '%s' % values[i] tooltip.SetTip(tip) tooltip.Enable(True) found = True break if not found: tooltip.Enable(False) fig.canvas.mpl_connect('pick_event', onMotion) except Exception, e: print "Cannot add wx.ToolTip: ", e
def visualize_n_frustums_plus_ptclouds(p_planes_list, frustum_ptcloud): colors = vtk.vtkNamedColors() # set a renderer and a render window renderer = vtk.vtkRenderer() renderer.SetBackground(colors.GetColor3d("Silver")) renderWindow = vtk.vtkRenderWindow() renderWindow.SetSize(600, 600) renderWindow.SetWindowName("Frustum Intersection") renderWindow.AddRenderer(renderer) # an interactor renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetInteractorStyle( vtk.vtkInteractorStyleTrackballCamera()) renderWindowInteractor.SetRenderWindow(renderWindow) # add n frustums for i, p_planes in enumerate(p_planes_list): planesArray = list(p_planes.flatten()) planes = vtk.vtkPlanes() planes.SetFrustumPlanes(planesArray) frustum = vtk.vtkFrustumSource() frustum.ShowLinesOff() frustum.SetPlanes(planes) shrink = vtk.vtkShrinkPolyData() shrink.SetInputConnection(frustum.GetOutputPort()) shrink.SetShrinkFactor(1.) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(shrink.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().EdgeVisibilityOn() actor.GetProperty().SetColor(colors.GetColor3d("Banana")) actor.GetProperty().SetOpacity(.2) renderer.AddActor(actor) # add ptclouds # assin color to ptcloud (n,4) cm = colormap.get_cmap('RdBu') color_mapper = colormap.ScalarMappable(norm=matplotlib.colors.Normalize( vmin=0, vmax=1, clip=True), cmap=cm) color = color_mapper.to_rgba(frustum_ptcloud[:, 3])[:, :3] * 255 ptcloud = np.hstack((frustum_ptcloud[:, 0:3], color)) # Create the geometry of a point (the coordinate) points = vtk.vtkPoints() # Create the topology of the point (a vertex) vertices = vtk.vtkCellArray() # Setup colors Colors = vtk.vtkUnsignedCharArray() Colors.SetNumberOfComponents(3) Colors.SetName("Colors") # Add points for i in range(0, len(ptcloud)): p = ptcloud[i, :3] id = points.InsertNextPoint(p) vertices.InsertNextCell(1) vertices.InsertCellPoint(id) Colors.InsertNextTuple3(ptcloud[i, 3], ptcloud[i, 4], ptcloud[i, 5]) point = vtk.vtkPolyData() # Set the points and vertices we created as the geometry and topology of the polydata point.SetPoints(points) point.SetVerts(vertices) point.GetPointData().SetScalars(Colors) point.Modified() mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(point) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().EdgeVisibilityOn() actor.GetProperty().SetColor(colors.GetColor3d("Tomato")) actor.GetProperty().SetOpacity(.3) renderer.AddActor(actor) transform = vtk.vtkTransform() transform.Translate(0, 0, 0) axes = vtk.vtkAxesActor() # The axes are positioned with a user transform axes.SetAxisLabels(1) axes.SetUserTransform(transform) axes.AxisLabelsOff() axes.SetTotalLength(3.0, 3.0, 3.0) renderer.AddActor(axes) renderer.SetUseDepthPeeling(1) renderer.SetOcclusionRatio(0.1) renderer.SetMaximumNumberOfPeels(100) renderWindow.SetMultiSamples(0) renderWindow.SetAlphaBitPlanes(1) # Position the camera so that we can see the frustum renderer.GetActiveCamera().SetPosition(1, 0, 0) renderer.GetActiveCamera().SetFocalPoint(0, 0, 0) renderer.GetActiveCamera().SetViewUp(0, 1, 0) renderer.GetActiveCamera().Azimuth(30) renderer.GetActiveCamera().Elevation(30) renderer.ResetCamera() # render an image (lights and cameras are created automatically) renderWindow.Render() # begin mouse interaction renderWindowInteractor.Start()
def main(): Figure1 = plt.figure(num=None, figsize=(14, 7)) ax1 = Figure1.add_subplot(1, 1, 1) # subplots #### files einlesen #### T = {} # dictionary wie liste path = '20200120_PMT1_newnewbase_newamp/' for file in os.listdir(path): if not file.endswith('.txt'): continue fn = path + file z1, z2 = file.split('.txt')[0].split('_') z1, z2 = int(z1), int(z2) if not z1 in T.keys( ): # liste von allen ersten 'Zahlen' in dictionary also keys z1, value = z2 wert in keys (1,2,3) T[z1] = {} # leeres Unterdictionary um anzufangen T[z1][z2] = np.genfromtxt(fn) # fuegt z2 in unterdictionary #### colormaps #### cm_sub = np.linspace(1.0, 0.0, len(T)) #len(T)) oder 4 colors = [cm.viridis(x) for x in cm_sub] transmission = [ 0.0001, 0.0003, 0.0005, 0.0007, 0.0012, 0.0014, 0.0016, 0.0019, 0.003, 0.0042, 0.004, 0.0042, 0.008, 0.006, 0.012, 0.016, 0.022, 0.023, 0.029, 0.037, 0.067, 0.072, 0.09, 0.16, 0.23, 0.54 ] rate = [ 1.15, 1.23, 1.37, 1.6, 1.98, 2.02, 2.26, 2.58, 3.43, 4.03, 3.99, 4.73, 7.31, 5.54, 9.58, 12.42, 16.33, 17.18, 21.17, 25.95, 47.47, 55.96, 62.49, 101.39, 127.40 ] print(len(T)) x = [] y = [] clabels = [] V = [0, 1150, 1250, 1350] d_rate = [] int_rate = [] mu1 = [] d_mu1 = [] mu2 = [] d_mu2 = [] sig1 = [] d_sig1 = [] distance = [] d_distance = [] ylabels = [] sig2 = [] d_sig2 = [] mean = [] peakvalley = [] for j, i in enumerate(sorted( T.keys())): #range(1,4): enumerate(sorted(T.keys())): if i in [47, 49, 53, 56, 60]: x.append(T[i][1][:, 0] - 127) else: x.append(T[i][1][:, 0]) y.append(T[i][1][:, 1]) ax1.plot(x[-1], y[-1] / 0.8, color=colors[j]) #[i-1] #, label=V[i]) clabels.append(i) #### Gauss fit for data and noise #### if 0 <= j <= 7: #fuer 2 ->11 m = -6 mask1 = ( x[-1] <= -6. ) # fuer 2 -> 10 # Bereich aendern x_fit1 = x[-1][mask1] y_fit1 = y[-1][mask1] p01 = [1e7, -10, 10] # Startparameter aendern popt1, pcov1 = curve_fit(gauss_function, x_fit1, y_fit1 / 0.8, p0=p01, maxfev=1000000) #print("Mittel:\t" + str(j) + ' ' + str(i) + ' ' + str(popt[1])) mu1.append(popt1[1]) perr1 = np.sqrt(np.diag(pcov1)) d_mu1.append(perr1[1]) sig1.append(popt1[2]) d_sig1.append(perr1[2]) peakvalley.append(np.abs(mu1[-1]) - np.abs(m)) # ax1.plot(x_fit1, gauss_function(x_fit1,*popt1), c='black', zorder=20) # ax1.plot(mu1[-1], gauss_function(mu1[-1], *popt1), marker='o',c='black') int_rate.append(popt1[0] * np.abs(popt1[2]) * np.sqrt(2 * np.pi) * 1e-6) d_rate.append( np.sqrt((np.sqrt(2 * np.pi) * popt1[2] * perr1[0])**2 + (np.sqrt(2 * np.pi) * popt1[0] * perr1[2])**2) * 1e-6) print "Integrierte Rate:\t %d %d %.2f MHz Fehler Rate:\t %.2f MHz" % ( j, i, int_rate[j], d_rate[j]) print "Mittel:\t %d %d %.2f Fehler:\t %.2f MHz" % (j, i, mu1[j], d_mu1[j]) print "Breite:\t %d %d %.2f Fehler:\t %.2f MHz" % (j, i, sig1[j], d_sig1[j]) print "Peak-Valley:\t %d %d %.2f " % (j, i, peakvalley[j]) ylabels.append(round(int_rate[-1], 2)) #### noise gauss fit #### x_plot = np.arange(-15, 10, 0.01) mask2 = (x[-1] <= 10) & (x[-1] >= -5) x_fit2 = x[-1][mask2] y_fit2 = y[-1][mask2] p02 = [1.6e8, 0.0, 1.1] popt2, pcov2 = curve_fit( gauss_function, x_fit2, y_fit2 / 0.8, p0=p02 ) #, bounds= ([1e5, -10, 0.1], [1e9, 5, 10]), maxfev = 1000000) # print("Mittel:\t" + str(j) + ' ' + str(i) + ' ' + str(popt2[1])) mu2.append(popt2[1]) perr2 = np.sqrt(np.diag(pcov2)) d_mu2.append(perr2[1]) sig2.append(popt2[2]) d_sig2.append(perr2[2]) # ax1.plot(x_plot, gauss_function(x_plot, *popt2), c='black', zorder=20) distance.append(mu1[-1] - mu2[-1]) d_distance.append(d_mu1[-1] - d_mu2[-1]) print "Noise Mittel:\t %d %d %.2f Fehler:\t %.2f MHz" % ( j, i, mu2[j], d_mu2[j]) print "Noise Breite:\t %d %d %.2f Fehler:\t %.2f MHz" % ( j, i, sig2[j], d_sig2[j]) if 8 <= j <= 16: # fuer 2 bis 14 # Zahl aendern mask1 = (x[-1] <= -6.) # fuer 2 -10 # Bereich aendern x_fit1 = x[-1][mask1] y_fit1 = y[-1][mask1] p01 = [1e6, -10, 10] # Startparameter aendern popt1, pcov1 = curve_fit(gauss_function, x_fit1, y_fit1 / 0.8, p0=p01, maxfev=1000000) #print(popt, pcov) # print("Mittel:\t" + str(j) + ' ' + str(i) + ' ' + str(popt[1])) mu1.append(popt1[1]) perr1 = np.sqrt(np.diag(pcov1)) d_mu1.append(perr1[1]) sig1.append(popt1[2]) d_sig1.append(perr1[2]) peakvalley.append(np.abs(mu1[-1]) - np.abs(m)) # ax1.plot(x_fit1, gauss_function(x_fit1,*popt1), c='black', zorder=20) # ax1.plot(mu1[-1], gauss_function(mu1[-1], *popt1), marker='o',c='black') #except: #print('Fit failed') #plt.plot(x_fit, gauss_function(x_fit,*p0), c='black') int_rate.append(popt1[0] * np.abs(popt1[2]) * np.sqrt(2 * np.pi) * 1e-6) d_rate.append( np.sqrt((np.sqrt(2 * np.pi) * popt1[2] * perr1[0])**2 + (np.sqrt(2 * np.pi) * popt1[0] * perr1[2])**2) * 1e-6) print "Integrierte Rate:\t %d %d %.2f MHz Fehler Rate:\t %.2f MHz" % ( j, i, int_rate[j], d_rate[j]) print "Mittel:\t %d %d %.2f Fehler:\t %.2f MHz" % (j, i, mu1[j], d_mu1[j]) print "Breite:\t %d %d %.2f Fehler:\t %.2f MHz" % (j, i, sig1[j], d_sig1[j]) print "Peak-Valley:\t %d %d %.2f " % (j, i, peakvalley[j]) ylabels.append(round(int_rate[-1], 2)) #### noise gauss fit #### x_plot = np.arange(-15, 15, 0.01) mask2 = (x[-1] <= 10) & (x[-1] >= -5) x_fit2 = x[-1][mask2] y_fit2 = y[-1][mask2] p02 = [1.6e8, -2, 1.1] popt2, pcov2 = curve_fit( gauss_function, x_fit2, y_fit2 / 0.8, p0=p02 ) #, bounds= ([1e5, -10, 0.1], [1e9, 5, 10]), maxfev = 1000000) #print("Mittel:\t" + str(j) + ' ' + str(i) + ' ' + str(popt[1])) mu2.append(popt2[1]) perr2 = np.sqrt(np.diag(pcov2)) d_mu2.append(perr2[1]) sig2.append(popt2[2]) d_sig2.append(perr2[2]) # ax1.plot(x_plot, gauss_function(x_plot, *popt2), c='black', zorder=20) distance.append(mu1[-1] - mu2[-1]) d_distance.append(d_mu1[-1] - d_mu2[-1]) if 17 <= j <= 18: # Zahl aendern mask1 = (x[-1] <= -10.) #fuer 1 -10 # Bereich aendern x_fit1 = x[-1][mask1] y_fit1 = y[-1][mask1] p01 = [1e6, -20, 10] # Startparameter aendern popt1, pcov1 = curve_fit(gauss_function, x_fit1, y_fit1 / 0.8, p0=p01, maxfev=1000000) #print(popt, pcov) # print("Mittel:\t" + str(j) + ' ' + str(i) + ' ' + str(popt[1])) mu1.append(popt1[1]) perr1 = np.sqrt(np.diag(pcov1)) d_mu1.append(perr1[1]) sig1.append(popt1[2]) d_sig1.append(perr1[2]) peakvalley.append(np.abs(mu1[-1]) - np.abs(m)) # ax1.plot(x_fit1, gauss_function(x_fit1,*popt1), c='black', zorder=20) # ax1.plot(mu1[-1], gauss_function(mu1[-1], *popt1), marker='o',c='black') #except: #print('Fit failed') #plt.plot(x_fit, gauss_function(x_fit,*p0), c='black') int_rate.append(popt1[0] * np.abs(popt1[2]) * np.sqrt(2 * np.pi) * 1e-6) d_rate.append( np.sqrt((np.sqrt(2 * np.pi) * popt1[2] * perr1[0])**2 + (np.sqrt(2 * np.pi) * popt1[0] * perr1[2])**2) * 1e-6) print "Integrierte Rate:\t %d %d %.2f MHz Fehler Rate:\t %.2f MHz" % ( j, i, int_rate[j], d_rate[j]) print "Mittel:\t %d %d %.2f Fehler:\t %.2f MHz" % (j, i, mu1[j], d_mu1[j]) print "Breite:\t %d %d %.2f Fehler:\t %.2f MHz" % (j, i, sig1[j], d_sig1[j]) print "Peak-Valley:\t %d %d %.2f " % (j, i, peakvalley[j]) ylabels.append(round(int_rate[-1], 2)) #### noise gauss fit #### x_plot = np.arange(-15, 15, 0.01) mask2 = (x[-1] <= 10) & (x[-1] >= -7) x_fit2 = x[-1][mask2] y_fit2 = y[-1][mask2] p02 = [1.6e8, -2, 1.1] popt2, pcov2 = curve_fit( gauss_function, x_fit2, y_fit2 / 0.8, p0=p02 ) #, bounds= ([1e5, -10, 0.1], [1e9, 5, 10]), maxfev = 1000000) #print("Mittel:\t" + str(j) + ' ' + str(i) + ' ' + str(popt[1])) mu2.append(popt2[1]) perr2 = np.sqrt(np.diag(pcov2)) d_mu2.append(perr2[1]) sig2.append(popt2[2]) d_sig2.append(perr2[2]) # ax1.plot(x_plot, gauss_function(x_plot, *popt2), c='black', zorder=20) distance.append(mu1[-1] - mu2[-1]) d_distance.append(d_mu1[-1] - d_mu2[-1]) print(len(mu1)) print(len(mu2)) print(len(d_mu2)) print(len(transmission[0:19])) print(len(int_rate)) print(len(d_rate)) print(len(sig1)) print(len(d_sig1)) print(len(sig2)) print(mu1[0]) print(sig2[0]) #### extrapolation trans #### z1 = np.polyfit(transmission[0:19], int_rate, 1) p1 = np.poly1d(z1) #### Colorbar #### norm = mpl.colors.Normalize(vmin=min(clabels), vmax=max(clabels)) #colormap_r = mpl.colors.ListedColormap(col1[::-1]) cmap = cm.ScalarMappable(norm=norm, cmap=cm.viridis_r) cmap.set_array([]) cbar = Figure1.colorbar(cmap, ticks=[3, 9, 15, 20, 26, 32, 37, 42], format='%d') cbar.ax.set_yticklabels([ ylabels[0], ylabels[2], ylabels[5], ylabels[8], ylabels[11], ylabels[14], ylabels[16], ylabels[18] ]) cbar.set_label('Incident rate (MHz)', size=19, labelpad=17) plt.setp(cbar.ax.yaxis.get_ticklabels(), fontsize=20) #### Plotting #### path2 = path + 'PlotsArbeit/' func.custom_plot(ax1, Figure1, path2 + 'Histo_PMT1newbase_1100_log', '', 'Pulse height', 'Count rate (MHz)', xlim=[10, -120], ylim=[1.e0, 1.e9], sciy='log') Figure2 = plt.figure(num=None, figsize=(14, 7)) ax2 = Figure2.add_subplot(1, 1, 1) ax2.errorbar(transmission[0:19], int_rate, yerr=d_rate, c='blue', marker='.', linestyle='') #ax2.plot(transmission[0:19], p1(transmission[0:19])) func.custom_plot( ax2, Figure2, path2 + 'rates_vs_trans', '', 'Transmission', 'Rate (MHz)' ) #, [0,0.03], [0,150]) #[0.0, 0.03], [0.0, 170]) Figure3 = plt.figure(num=None, figsize=(14, 7)) ax3 = Figure3.add_subplot(1, 1, 1) ax3.errorbar(ylabels, mu1, yerr=d_mu1, c='blue', marker='.', linestyle='') ax30 = ax3.twinx() # make a plot with different y-axis using second axis object ax30.set_ylabel("Pulse height (mV)", fontsize=19, labelpad=9) mn30, mx30 = ax3.get_ylim() ax30.set_ylim((mn30 * 200) / 127, (mx30 * 200) / 127) ax30.tick_params(axis='y', labelsize=13) func.custom_plot( ax3, Figure3, path2 + 'photonpeak_vs_rate', '', 'Rate (MHz)', 'Pulse height (ADC)' ) #, [0,150], [-20,-11.5]) #[0.0, 170], [-35, -20]) Figure4 = plt.figure(num=None, figsize=(14, 7)) ax4 = Figure4.add_subplot(1, 1, 1) ax4.errorbar(ylabels, np.abs(sig1), yerr=d_sig1, c='blue', marker='.', linestyle='') ax40 = ax4.twinx() # make a plot with different y-axis using second axis object ax40.set_ylabel("Pulse height (mV)", fontsize=19, labelpad=9) mn40, mx40 = ax4.get_ylim() ax40.set_ylim((mn40 * 200) / 127, (mx40 * 200) / 127) ax40.tick_params(axis='y', labelsize=13) func.custom_plot( ax4, Figure4, path2 + 'Sigma_photonpeak_vs_rate', '', 'Rate (MHz)', 'Pulse height (ADC)') #, [0,150], [4,12]) #[0.0, 150], [6, 20]) Figure5 = plt.figure(num=None, figsize=(14, 7)) ax5 = Figure5.add_subplot(1, 1, 1) ax5.errorbar(ylabels, mu2, yerr=d_mu2, c='blue', marker='.', linestyle='') func.custom_plot( ax5, Figure5, path2 + 'noisepeak_vs_rate', '', 'Rate (MHz)', 'Pulse height (ADC)') #, [0,150], [-5,1]) #[0.0, 170], [-7., 1.]) plt.show()
img = make_brain_image(views, brains[-1], text="C", text_loc="lup", text_pan=0) ax = axes["C"] ax.imshow(img) # visselten param_n = params_n[:, 2] rgba = params_to_rgba(param_n) brains.append( plot_rgba(rgba, labels, parc, figsize=figsize, background=background)) img = make_brain_image(views, brains[-1], text="D", text_loc="lup", text_pan=0) ax = axes["D"] ax.imshow(img) ax = axes["E"] norm = Normalize(vmin, vmax) scalmap = cm.ScalarMappable(norm, cmap) plt.colorbar(scalmap, cax=ax, orientation="horizontal") ax.tick_params(labelsize=fontsize) ax.set_xlabel("DICS power (NAI normalised)", fontsize=fontsize * 0.8) plt.suptitle("Estimated power change from resting state", fontsize=fontsize) plt.savefig("../images/dics_figure.png") # # rainbow # this_rgba = np.zeros((len(labels), 4)) # params = np.abs(aic_comps["sig_params"]) # param_norms = np.linalg.norm(params, axis=1) # for idx in range(len(params)): # if param_norms[idx]: # params[idx,] /= param_norms[idx] # this_rgba[:,:3] = params # param_norms = param_norm(param_norms) # this_rgba[:,3] = param_norms
def add_rgb_dimention(array): scaler_map = cm.ScalarMappable(cmap="Oranges") array = scaler_map.to_rgba(array)[:, :-1] return array
import pandas as pd # %matplotlib inline # %% codecell # Load DataFrame station = 'CC01' path2pkl = "./pkls/" df = pd.read_pickle(path2pkl+station+'_data.pkl') df # %% codecell # loop through channels fig = plt.figure(figsize=(10, 12)) colorday = np.arange(0, 5) norm = mcolors.Normalize(vmin=colorday.min(), vmax=colorday.max()) cmap = cm.ScalarMappable(norm=norm, cmap=cm.Set3) cmap.set_array([]) icount = 0 FS = 13 cmap.to_rgba(4) for ch, data in df.iteritems(): ax1 = fig.add_subplot(3, 1, 1) ax1.plot(data['jdaynum_mseed_ch'], data['nsec_mseed_actual_ch']/60/60, color=cmap.to_rgba(icount), label=ch, linewidth=4-icount/2) # ax1.set_xlabel('Jday', fontsize=FS) ax1.set_ylabel('Mseed file length (hours)', fontsize=FS) ax1.tick_params(labelsize=FS) ax1.grid(True) ax2 = fig.add_subplot(3, 1, 2) ax2.plot(data['jdaynum_mseed_ch'], data['dt_end_gap_sec_ch'], color=cmap.to_rgba(icount), label=ch, linewidth=4-icount/2) # ax2.set_xlabel('Jday', fontsize=FS)