def determine_detector_timing_offsets(d, s, events): """Determine the offsets between the station detectors. ADL: Currently assumes detector 1 is a good reference. But this is not always the best choice. Perhaps it should be determined using more data (more than one day) to be more accurate. """ bins = arange(-100 + 1.25, 100, 2.5) col = (cl for cl in COLORS) graph = Plot() for i, j in itertools.combinations(range(1, 5), 2): ti = events.col('t%d' % i) tj = events.col('t%d' % j) dt = (ti - tj).compress((ti >= 0) & (tj >= 0)) y, bins = histogram(dt, bins=bins) graph.histogram(y, bins, linestyle='color=%s' % col.next()) x = (bins[:-1] + bins[1:]) / 2 try: popt, pcov = curve_fit(gauss, x, y, p0=(len(dt), 0., 10.)) print '%d-%d: %f (%f)' % (i, j, popt[1], popt[2]) except (IndexError, RuntimeError): print '%d-%d: failed' % (i, j) graph.set_title('Time difference, station %d' % (s)) graph.set_label('%s' % d.replace('_', ' ')) graph.set_xlimits(-100, 100) graph.set_ylimits(min=0) graph.set_xlabel('$\Delta t$') graph.set_ylabel('Counts') graph.save_as_pdf('%s_%d' % (d, s))
def plot_fit(x, data, slope, intercept, pair): plot = Plot() plot.scatter(x, log(c)) plot.plot(x, x * slope + intercept, mark=None) plot.set_ylimits(min=0) plot.set_label(r'%.1e \si{\hertz}' % rate) plot.save_as_pdf('intervals/intervals_%d_%d_r' % pair)
def plot_traces(): with tables.open_file(DATA, 'r') as data: for i, pre, coin, post in TIME_WINDOWS: test_node = data.get_node('/t%d' % i) events = test_node.events.read() events.sort(order='ext_timestamp') blobs = test_node.blobs for e_idx in [0, 1]: t_idx = events[e_idx]['traces'][1] extts = events[e_idx]['ext_timestamp'] try: trace = zlib.decompress(blobs[t_idx]).split(',') except zlib.error: trace = zlib.decompress(blobs[t_idx][1:-1]).split(',') if trace[-1] == '': del trace[-1] trace = [int(x) for x in trace] plot = Plot() plot.plot(range(len(trace)), trace, mark=None) plot.set_label('%d' % extts) microsec_to_sample = 400 plot.draw_vertical_line(pre * microsec_to_sample, linestyle='thick,red,semitransparent') plot.draw_vertical_line((pre + coin) * microsec_to_sample, linestyle='thick,blue,semitransparent') plot.set_ylabel('Signal strength [ADCcounts]') plot.set_xlabel('Sample [2.5ns]') plot.set_ylimits(min=150, max=1500) plot.set_xlimits(min=0, max=len(trace)) plot.save_as_pdf('trace_%d_%d' % (i, e_idx))
def plot_and_fit_offsets(x, y, popt, d, id): plot = Plot() plot_data_and_fit(x, y, popt, plot) plot.set_label('$\mu$: %.2f, $\sigma$: %.2f' % (popt[1], popt[2])) plot.set_ylabel('Occurrence') plot.set_xlabel('$\Delta t$ [ns]') plot.set_ylimits(min=0) plot.save_as_pdf('api_detector_offset_distribution_%s_' % id + d.strftime('%Y%m%d'))
def plot_distributions(distances, name=''): bins = arange(0, 10.001, 0.2) plot = Plot() plot.histogram(*histogram(distances, bins)) plot.set_ylimits(min=0) plot.set_xlimits(min=0, max=10) plot.set_ylabel('Counts') plot.set_xlabel(r'Distance to center mass location [\si{\meter}]') plot.set_label('67\%% within %.1fm' % percentile(distances, 67)) plot.save_as_pdf('gps_distance_cm' + name)
def plot_compared(): popt, perr = fit_curve(senstech_m_ph, senstech_e_ph) fit = FIT % (popt[0], P1, popt[1]) plot = Plot(width=r'.67\linewidth', height=r'.67\linewidth') plot.set_label(fit, location='upper left') plot.scatter(senstech_e_ph, senstech_m_ph, mark='*') plot.scatter(nikhef_e_ph, nikhef_m_ph, mark='o') inputs = linspace(min(senstech_m_ph), max(senstech_m_ph), 500) plot.plot(ice_cube_pmt_p1(inputs, *popt), inputs, mark=None) plot.plot([0, 6], [0, 6], mark=None, linestyle='gray') plot.set_xlimits(0, 6) plot.set_ylimits(0, 6) plot.set_axis_equal() plot.set_xlabel(r'Sum individual LED pulseheights [\si{\volt}]') plot.set_ylabel(r'Multiple-LED pulseheight [\si{\volt}]') plot.save_as_pdf('plots/linearity_compared')
def plot_distribution(): for e in arange(14, 18, 1): for core_distance in [1, 5, 10, 50, 100, 500, 1000]: path = ('/Users/arne/Datastore/first_particle/first_{e}_{r}.npy'. format(e=e, r=core_distance)) times = load(path) counts, bins = histogram(times, bins=20) plot = Plot() plot.histogram(counts, bins) plot.set_xlabel('arrival time [ns]') plot.set_ylabel('Counts') plot.set_ylimits(min=0) plot.set_xlimits(bins[0], bins[-1]) plot.set_label('E=$10^{{{e}}}$eV, r={r}m'.format(e=e, r=core_distance)) plot.save_as_pdf('plots/first_particle_{e}_{r}_new'.format( e=e, r=core_distance))
def plot_reconstruction_accuracy(data, d): station_path = '/cluster_simulations/station_%d' cluster = cluster_501_510() coincidences = data.root.coincidences.coincidences recs501 = data.root.hisparc.cluster_amsterdam.station_501.reconstructions recs510 = data.root.hisparc.cluster_amsterdam.station_510.reconstructions graph = Plot() ids = set(recs501.col('id')).intersection(recs510.col('id')) filtered_501 = [(row['zenith'], row['azimuth']) for row in recs501 if row['id'] in ids] filtered_510 = [(row['zenith'], row['azimuth']) for row in recs510 if row['id'] in ids] zen501, azi501 = zip(*filtered_501) zen510, azi510 = zip(*filtered_510) zen501 = array(zen501) azi501 = array(azi501) zen510 = array(zen510) azi510 = array(azi510) da = angle_between(zen501, azi501, zen510, azi510) n, bins = histogram(da, bins=arange(0, pi, .1)) graph.histogram(n, bins) failed = coincidences.nrows - len(ids) graph.set_ylimits(min=0) graph.set_xlimits(min=0, max=pi) graph.set_ylabel('Count') graph.set_xlabel('Angle between 501 and 510 [rad]') graph.set_title('Coincidences between 501 and 510') graph.set_label('Failed to reconstruct %d events' % failed) graph.save_as_pdf('coincidences_%s' % d) graph_recs = PolarPlot() azimuth = degrees(recs501.col('azimuth')) zenith = degrees(recs501.col('zenith')) graph_recs.scatter(azimuth[:5000], zenith[:5000], mark='*', markstyle='mark size=.2pt') graph_recs.set_ylimits(min=0, max=90) graph_recs.set_ylabel('Zenith [degrees]') graph_recs.set_xlabel('Azimuth [degrees]') graph_recs.set_title('Reconstructions by 501') graph_recs.save_as_pdf('reconstructions_%s' % d)
def plot_delta_histogram(ids, **kwargs): """ Plot a histogram of the deltas """ if type(ids) is int: ids = [ids] # Bin width bin_size = 1 # 2.5*n # Begin Figure plot = Plot() for id in ids: ext_timestamps, deltas = get(id) low = floor(min(deltas)) high = ceil(max(deltas)) bins = np.arange(low - .5 * bin_size, high + bin_size, bin_size) n, bins = np.histogram(deltas, bins) bin_centers = (bins[:-1] + bins[1:]) / 2 popt, pcov = curve_fit(gauss, bin_centers, n, p0=[.15, np.mean(deltas), np.std(deltas)]) plot.histogram(n, bins) plot.plot(bin_centers, gauss(bin_centers, *popt), mark=None, linestyle='gray') if kwargs.keys(): plot.set_title('Tijdtest ' + kwargs[kwargs.keys()[0]]) plot.set_label(r'$\mu={1:.1f}$, $\sigma={2:.1f}$'.format(*popt)) plot.set_xlabel(r'Time difference [ns]') plot.set_ylabel(r'Counts') plot.set_xlimits(low, high) plot.set_ylimits(min=0.) # Save Figure if len(ids) == 1: name = 'delta_histogram/tt_delta_hist_%03d' % ids[0] elif kwargs.keys(): name = 'delta_histogram/tt_delta_hist_' + kwargs[kwargs.keys()[0]] plot.save_as_pdf(PLOT_PATH + name) print 'tt_analyse: Plotted histogram'
def main(): # Draw random numbers from the normal distribution np.random.seed(1) N = np.random.normal(size=2000) # define bin edges edge = 5 bin_width = .1 bins = np.arange(-edge, edge + .5 * bin_width, bin_width) # build histogram and x, y values at the center of the bins n, bins = np.histogram(N, bins=bins) x = (bins[:-1] + bins[1:]) / 2 y = n # fit normal distribution pdf to data f = lambda x, N, mu, sigma: N * scipy.stats.norm.pdf(x, mu, sigma) popt, pcov = scipy.optimize.curve_fit(f, x, y) print("Parameters from fit (N, mu, sigma):", popt) # make graph graph = Plot() # graph histogram graph.histogram(n, bins) # graph model with fit parameters x = np.linspace(-edge, edge, 100) graph.plot(x, f(x, *popt), mark=None) # set labels and limits graph.set_xlabel("value") graph.set_ylabel("count") graph.set_label("Fit to data") graph.set_xlimits(-6, 6) # save graph to file graph.save('histogram-fit')
def plot_offset_distribution(ids, **kwargs): """Offset distribution""" # Begin Figure plot = Plot() offsets = [ np.average([x for x in get(id)[1] if abs(x) < 100]) for id in ids ] bins = np.arange(-70, 70, 2) n, bins = np.histogram(offsets, bins) plot.histogram(n, bins) bin_centers = (bins[:-1] + bins[1:]) / 2 popt, pcov = curve_fit(gauss, bin_centers, n, p0=[1., np.mean(offsets), np.std(offsets)]) plot.plot(bin_centers, gauss(bin_centers, *popt), mark=None, linestyle='gray') if kwargs.keys(): plot.set_title('Tijdtest offset distribution ' + kwargs[kwargs.keys()[0]]) plot.set_label(r'$\mu={1:.1f}$, $\sigma={2:.1f}$'.format(*popt)) plot.set_xlabel(r'Offset [\si{\nano\second}]') plot.set_ylabel(r'Counts') plot.set_ylimits(min=0) # Save Figure name = 'box/tt_offset_distribution' if kwargs.keys(): name += kwargs[kwargs.keys()[0]] plot.save_as_pdf(PLOT_PATH + name) print 'tt_analyse: Plotted offsets'
def plot_histogram(data, timestamps, station_numbers): """Make a 2D histogram plot of the number of events over time per station :param data: list of lists, with the number of events. :param station_numbers: list of station numbers in the data list. """ plot = Plot(width=r'\linewidth', height=r'1.3\linewidth') plot.histogram2d(data.T[::7][1:], timestamps[::7] / 1e9, np.arange(len(station_numbers) + 1), type='reverse_bw', bitmap=True) plot.set_label( gps_to_datetime(timestamps[-1]).date().isoformat(), 'upper left') plot.set_xlimits(min=YEARS_TICKS[0] / 1e9, max=timestamps[-1] / 1e9) plot.set_xticks(YEARS_TICKS / 1e9) plot.set_xtick_labels(YEARS_LABELS) plot.set_yticks(np.arange(0.5, len(station_numbers) + 0.5)) plot.set_ytick_labels(['%d' % s for s in sorted(station_numbers)], style=r'font=\sffamily\tiny') plot.set_axis_options('ytick pos=right') plot.save_as_pdf('eventtime_histogram_network_hour')
def plot_distribution(): distances = CORE_DISTANCES for e in ENERGIES: first_t = [] first_t_std = [] median_t = [] median_t_std = [] for core_distance in distances: first_path = ( '/Users/arne/Datastore/first_particle/first_{e}_{r}.npy'. format(e=e, r=core_distance)) median_path = ( '/Users/arne/Datastore/first_particle/median_{e}_{r}.npy'. format(e=e, r=core_distance)) first_times = load(first_path) first_t.append(mean(first_times)) first_t_std.append(std(first_times)) median_times = load(median_path) median_t.append(mean(median_times)) median_t_std.append(std(median_times)) plot = Plot('semilogx') plot.plot(distances, first_t, yerr=first_t_std, markstyle='mark size=1pt', linestyle=None) plot.plot(distances, median_t, yerr=median_t_std, markstyle='mark size=1pt,gray', linestyle=None) plot.set_xlabel('Core distance [m]') plot.set_ylabel('Time after first [ns]') plot.set_ylimits(min=-10) plot.set_xlimits(0, 1e3) plot.set_label('E=$10^{{{e}}}$eV'.format(e=e), location='upper left') plot.save_as_pdf('plots/first_particle_{e}'.format(e=e))
def plot_traces(event, station): s = Station(station) plot = Plot() traces = s.event_trace(event['timestamp'], event['nanoseconds'], raw=True) for j, trace in enumerate(traces): t = arange(0, (2.5 * len(traces[0])), 2.5) plot.plot(t, trace, mark=None, linestyle=COLORS[j]) n_peaks = event['n_peaks'] plot.set_title('%d - %d' % (station, event['ext_timestamp'])) plot.set_label('%d ' * 4 % tuple(n_peak for n_peak in n_peaks)) plot.set_xlabel('t [\si{n\second}]') plot.set_ylabel('Signal strength') plot.set_xlimits(min=0, max=2.5 * len(traces[0])) plot.set_ylimits(min=150, max=500) # max=2 ** 12 plot.draw_horizontal_line(253, linestyle='gray') plot.draw_horizontal_line(323, linestyle='gray') plot.draw_horizontal_line(event['baseline'][0] + 20, linestyle='thin,gray') plot.draw_horizontal_line(event['baseline'][1] + 20, linestyle='thin,red!40!black') plot.draw_horizontal_line(event['baseline'][2] + 20, linestyle='thin,green!40!black') plot.draw_horizontal_line(event['baseline'][3] + 20, linestyle='thin,blue!40!black') plot.save_as_pdf('traces_%d_%d' % (station, event['ext_timestamp']))
def plot_reconstruction_accuracy(): combinations = ['~d1 | ~d2 | ~d3 | ~d4', 'd1 & d2 & d3 & d4'] station_path = '/cluster_simulations/station_%d' with tables.open_file(RESULT_PATH, 'r') as data: cluster = data.root.coincidences._v_attrs.cluster coincidences = data.root.coincidences.coincidences c_recs = data.root.coincidences.reconstructions graph = Plot() da = angle_between(c_recs.col('zenith'), c_recs.col('azimuth'), c_recs.col('reference_zenith'), c_recs.col('reference_azimuth')) ids = c_recs.col('id') N = coincidences.read_coordinates(ids, field='N') for k, filter in enumerate([N == 3, N > 3]): n, bins = histogram(da.compress(filter), bins=arange(0, pi, .1)) graph.histogram(n, bins, linestyle=GRAYS[k % len(GRAYS)]) failed = len(coincidences.get_where_list('N >= 3')) - c_recs.nrows graph.set_ylimits(min=0) graph.set_xlimits(min=0, max=pi) graph.set_ylabel('Count') graph.set_xlabel('Angle between input and reconstruction [rad]') graph.set_title('Coincidences') graph.set_label('Failed to reconstruct %d events' % failed) graph.save_as_pdf('coincidences_alt') for station in cluster.stations: station_group = data.get_node(station_path % station.number) recs = station_group.reconstructions rows = coincidences.get_where_list('s%d == True' % station.number) reference_azimuth = coincidences.read_coordinates(rows, field='azimuth') reference_zenith = coincidences.read_coordinates(rows, field='zenith') graph = Plot() for k, combo in enumerate(combinations): selected_reconstructions = recs.read_where(combo) filtered_azimuth = array([ reference_azimuth[i] for i in selected_reconstructions['id'] ]) filtered_zenith = array([ reference_zenith[i] for i in selected_reconstructions['id'] ]) azimuth = selected_reconstructions['azimuth'] zenith = selected_reconstructions['zenith'] da = angle_between(zenith, azimuth, filtered_zenith, filtered_azimuth) n, bins = histogram(da, bins=arange(0, pi, .1)) graph.histogram(n, bins, linestyle=GRAYS[k % len(GRAYS)]) failed = station_group.events.nrows - recs.nrows graph.set_ylimits(min=0) graph.set_xlimits(min=0, max=pi) graph.set_ylabel('Count') graph.set_xlabel('Angle between input and reconstruction [rad]') graph.set_title('Station: %d' % station.number) graph.set_label('Failed to reconstruct %d events' % failed) graph.save_as_pdf('s_%d' % station.number)
def analyse_reconstructions(path): seed = os.path.basename(os.path.dirname(path)) cq = CoincidenceQuery(path) c_ids = cq.coincidences.get_where_list('N >= 3') if not len(cq.reconstructions) or not len(c_ids): cq.finish() return c_recs = cq.reconstructions.read_coordinates(c_ids) # Angles zen_out = c_recs['zenith'] azi_out = c_recs['azimuth'] zen_in = c_recs['reference_zenith'] azi_in = c_recs['reference_azimuth'] # Cores x_out = c_recs['x'] y_out = c_recs['y'] x_in = c_recs['reference_x'] y_in = c_recs['reference_y'] # Size size_out = c_recs['size'] energy_out = c_recs['energy'] size_in = c_recs['reference_size'] energy_in = c_recs['reference_energy'] energy = np.log10(energy_in[0]) zenith = np.degrees(zen_in[0]) label = r'$E=10^{%d}$eV, $\theta={%.1f}^{\circ}$' % (energy, zenith) # Azimuth bins = np.linspace(-np.pi, np.pi, 21) acounts_out, bins = np.histogram(azi_out, bins) acounts_in, bins = np.histogram(azi_in, bins) plota = Plot() plota.histogram(acounts_out, bins) plota.histogram(acounts_in, bins, linestyle='red') plota.set_xlabel(r'$\phi$ [\si{\radian}]') plota.set_xlimits(-np.pi, np.pi) plota.set_ylabel(r'Counts') plota.set_ylimits(min=0) plota.save_as_pdf('plots/azimuth_in_out_%s' % seed) # Zenith bins = np.linspace(0, np.pi / 2, 21) zcounts_out, bins = np.histogram(zen_out, bins) zcounts_in, bins = np.histogram(zen_in, bins) plotz = Plot() plotz.histogram(zcounts_out, bins) plotz.histogram(zcounts_in, bins, linestyle='red') plotz.set_xlabel(r'$\theta$ [\si{\radian}]') plotz.set_xlimits(0, np.pi / 2) plotz.set_ylabel(r'Counts') plotz.set_ylimits(min=0) plotz.save_as_pdf('plots/zenith_in_out_%s' % seed) # Angle between angle_distances = angle_between(zen_out, azi_out, zen_in, azi_in) if len(np.isfinite(angle_distances)): bins = np.linspace(0, np.pi / 2, 91) counts, bins = np.histogram(angle_distances, bins=bins) plotd = Plot() plotd.histogram(counts, np.degrees(bins)) sigma = np.percentile(angle_distances[np.isfinite(angle_distances)], 67) plotd.set_label(label + r', 67\%% within \SI{%.1f}{\degree}' % np.degrees(sigma)) plotd.set_xlabel(r'Angle between reconstructions [\si{\degree}]') plotd.set_ylabel('Counts') plotd.set_xlimits(np.degrees(bins[0]), np.degrees(bins[-1])) plotd.set_ylimits(min=0) plotd.save_as_pdf('plots/angle_between_in_out_%s' % seed) # Distance beween filter = size_out != 1e6 core_distances = np.sqrt( (x_out.compress(filter) - x_in.compress(filter))**2 + (y_out.compress(filter) - y_in.compress(filter))**2) if len(np.isfinite(core_distances)): bins = np.linspace(0, 1000, 100) counts, bins = np.histogram(core_distances, bins=bins) plotc = Plot() plotc.histogram(counts, bins) sigma = np.percentile(core_distances[np.isfinite(core_distances)], 67) # energy = np.log10(energy_in[0]) zenith = np.degrees(zen_in[0]) # plotc.set_label(r'$E=10^{%d}$eV, $\theta={%.1f}^{\circ}$, 67\%% ' 'within \SI{%.1f}{\meter}' % (energy, zenith, sigma)) plotc.set_xlabel(r'Distance between cores [\si{\meter}]') plotc.set_ylabel('Counts') plotc.set_xlimits(bins[0], bins[-1]) plotc.set_ylimits(min=0) plotc.save_as_pdf('plots/core_distance_between_in_out_%s' % seed) # Core positions filter = size_out != 1e6 plotc = Plot() for x0, x1, y0, y1 in zip(x_out, x_in, y_out, y_in): plotc.plot([x0, x1], [y0, y1]) plotc.set_xlabel(r'x [\si{\meter}]') plotc.set_ylabel(r'y [\si{\meter}]') plotc.set_xlimits(bins[0], bins[-1]) plotc.set_ylimits(min=0) plotc.save_as_pdf('plots/core_positions_in_out_%s' % seed) # Shower size relative_size = size_out.compress(filter) / size_in.compress(filter) counts, bins = np.histogram(relative_size, bins=np.logspace(-2, 2, 21)) plots = Plot('semilogx') plots.histogram(counts, bins) plots.set_xlabel('Relative size') plots.set_ylabel('Counts') plots.set_xlimits(bins[0], bins[-1]) plots.set_ylimits(min=0) plots.save_as_pdf('plots/size_in_out_%s' % seed) # Cleanup cq.finish()
def determine_station_timing_offsets(d, data): # First determine detector offsets for each station offsets = {} for s in [501, 510]: station_group = data.get_node('/hisparc/cluster_amsterdam/station_%d' % s) offsets[s] = determine_detector_timing_offsets2(station_group.events) ref_station = 501 ref_d_off = offsets[ref_station] station = 510 cq = CoincidenceQuery(data, '/coincidences') dt = [] d_off = offsets[station] stations = [ref_station, station] coincidences = cq.all(stations) c_events = cq.events_from_stations(coincidences, stations) for events in c_events: # Filter for possibility of same station twice in coincidence if len(events) is not 2: continue if events[0][0] == ref_station: ref_event = events[0][1] event = events[1][1] else: ref_event = events[1][1] event = events[0][1] try: ref_t = min([ref_event['t%d' % (i + 1)] - ref_d_off[i] for i in range(4) if ref_event['t%d' % (i + 1)] not in ERR]) t = min([event['t%d' % (i + 1)] - d_off[i] for i in range(4) if event['t%d' % (i + 1)] not in ERR]) except ValueError: continue if (ref_event['t_trigger'] in ERR or event['t_trigger'] in ERR): continue dt.append((int(event['ext_timestamp']) - int(ref_event['ext_timestamp'])) - (event['t_trigger'] - ref_event['t_trigger']) + (t - ref_t)) bins = linspace(-150, 150, 200) y, bins = histogram(dt, bins=bins) x = (bins[:-1] + bins[1:]) / 2 try: popt, pcov = curve_fit(gauss, x, y, p0=(len(dt), 0., 50)) station_offset = popt[1] except RuntimeError: station_offset = 0. offsets[station] = [detector_offset + station_offset for detector_offset in offsets[station]] print 'Station 501 - 510: %f (%f)' % (popt[1], popt[2]) graph = Plot() graph.histogram(y, bins) graph.set_title('Time difference, between station 501-510') graph.set_label('%s' % d.replace('_', ' ')) graph.set_xlimits(-150, 150) graph.set_ylimits(min=0) graph.set_xlabel('$\Delta t$') graph.set_ylabel('Counts') graph.save_as_pdf('%s' % d)
popt, pcov = curve_fit(gauss, x, y, p0=(len(offsets), 0., 2.5)) return x, y, popt def plot_fit(x, y, popt, graph): graph.plot(x - BIN_WIDTH / 2, y, mark=None, use_steps=True) fit_x = arange(min(x), max(x), 0.1) graph.plot(fit_x, gauss(fit_x, *popt), mark=None, linestyle='gray') if __name__ == '__main__': dates = [(2013, 3, 19), (2013, 10, 28), (2014, 1, 1), (2014, 1, 2), (2014, 1, 3), (2014, 1, 4), (2014, 1, 10), (2014, 1, 20), (2014, 1, 30)] files = [date(y, m, d) for y, m, d in dates] for f in files: path = DATA_PATH + f.strftime('%Y/%-m/%Y_%-m_%-d.h5') with tables.open_file(path, 'r') as data: offsets = determine_offsets(data) graph = Plot() x, y, popt = fit_offsets(offsets) plot_fit(x, y, popt, graph) graph.set_label('$\mu$: %.2f, $\sigma$: %.2f' % (popt[1], popt[2])) graph.set_ylabel('Occurrence') graph.set_xlabel('$\Delta t$ [ns]') graph.set_ylimits(min=0) graph.save_as_pdf('detector_offset_distribution_' + f.strftime('%Y%m%d'))
def plot_angles(data): """Make azimuth and zenith plots to compare the results""" rec = data.root.reconstructions zenhis = rec.col('reconstructed_theta') zenkas = rec.col('reference_theta') azihis = rec.col('reconstructed_phi') azikas = rec.col('reference_phi') min_n = rec.col('min_n134') high_zenith = (zenhis > .2) & (zenkas > .2) for minn in [0, 1, 2, 4]: filter = (min_n > minn) azicounts, x, y = np.histogram2d(azihis.compress(high_zenith & filter), azikas.compress(high_zenith & filter), bins=np.linspace(-pi, pi, 73)) plota = Plot() plota.histogram2d(azicounts, degrees(x), degrees(y), type='reverse_bw', bitmap=True) # plota.set_title('Reconstructed azimuths for events in coincidence (zenith gt .2 rad)') plota.set_xlabel(r'$\phi_\textrm{HiSPARC}$ [\si{\degree}]') plota.set_ylabel(r'$\phi_\textrm{KASCADE}$ [\si{\degree}]') plota.set_xticks([-180, -90, 0, 90, 180]) plota.set_yticks([-180, -90, 0, 90, 180]) plota.save_as_pdf('azimuth_his_kas_minn%d' % minn) zencounts, x, y = np.histogram2d(zenhis.compress(filter), zenkas.compress(filter), bins=np.linspace(0, pi / 3., 41)) plotz = Plot() plotz.histogram2d(zencounts, degrees(x), degrees(y), type='reverse_bw', bitmap=True) # plotz.set_title('Reconstructed zeniths for station events in coincidence') plotz.set_xlabel(r'$\theta_\textrm{HiSPARC}$ [\si{\degree}]') plotz.set_ylabel(r'$\theta_\textrm{KASCADE}$ [\si{\degree}]') plotz.set_xticks([0, 15, 30, 45, 60]) plotz.set_yticks([0, 15, 30, 45, 60]) plotz.save_as_pdf('zenith_his_kas_minn%d' % minn) distances = angle_between(zenhis.compress(filter), azihis.compress(filter), zenkas.compress(filter), azikas.compress(filter)) counts, bins = np.histogram(distances, bins=linspace(0, pi, 100)) plotd = Plot() plotd.histogram(counts, degrees(bins)) sigma = degrees(scoreatpercentile(distances, 67)) plotd.set_title(r'$N_\textrm{MIP} \geq %d$' % minn) plotd.set_label(r'67\%% within \SI{%.1f}{\degree}' % sigma) # plotd.set_title('Distance between reconstructed angles for station events') plotd.set_xlabel('Angle between reconstructions [\si{\degree}]') plotd.set_ylabel('Counts') plotd.set_xlimits(min=0, max=90) plotd.set_ylimits(min=0) plotd.save_as_pdf('angle_between_his_kas_minn%d' % minn)
def analyse_reconstructions(data): cq = CoincidenceQuery(data) c_ids = data.root.coincidences.coincidences.read_where('s501', field='id') c_recs = cq.reconstructions.read_coordinates(c_ids) s_recs = data.root.hisparc.cluster_amsterdam.station_501.reconstructions zenc = c_recs['zenith'] azic = c_recs['azimuth'] zens = s_recs.col('zenith') azis = s_recs.col('azimuth') high_zenith = (zenc > .2) & (zens > .2) for minn in [1, 2, 4, 8, 16]: filter = (s_recs.col('min_n') > minn) length = len(azis.compress(high_zenith & filter)) shifts501 = np.random.normal(0, .06, length) azicounts, x, y = np.histogram2d(azis.compress(high_zenith & filter) + shifts501, azic.compress(high_zenith & filter), bins=np.linspace(-np.pi, np.pi, 73)) plota = Plot() plota.histogram2d(azicounts, np.degrees(x), np.degrees(y), type='reverse_bw', bitmap=True) # plota.set_title('Reconstructed azimuths for events in coincidence (zenith gt .2 rad)') plota.set_xlabel(r'$\phi_{501}$ [\si{\degree}]') plota.set_ylabel(r'$\phi_{Science Park}$ [\si{\degree}]') plota.set_xticks([-180, -90, 0, 90, 180]) plota.set_yticks([-180, -90, 0, 90, 180]) plota.save_as_pdf('azimuth_501_spa_minn%d' % minn) length = sum(filter) shifts501 = np.random.normal(0, .04, length) zencounts, x, y = np.histogram2d(zens.compress(filter) + shifts501, zenc.compress(filter), bins=np.linspace(0, np.pi / 3., 41)) plotz = Plot() plotz.histogram2d(zencounts, np.degrees(x), np.degrees(y), type='reverse_bw', bitmap=True) # plotz.set_title('Reconstructed zeniths for station events in coincidence') plotz.set_xlabel(r'$\theta_{501}$ [\si{\degree}]') plotz.set_ylabel(r'$\theta_{Science Park}$ [\si{\degree}]') plotz.set_xticks([0, 15, 30, 45, 60]) plotz.set_yticks([0, 15, 30, 45, 60]) plotz.save_as_pdf('zenith_501_spa_minn%d' % minn) distances = angle_between(zens.compress(filter), azis.compress(filter), zenc.compress(filter), azic.compress(filter)) counts, bins = np.histogram(distances, bins=np.linspace(0, np.pi, 91)) plotd = Plot() plotd.histogram(counts, np.degrees(bins)) sigma = np.degrees(np.percentile(distances[np.isfinite(distances)], 67)) plotd.set_label(r'67\%% within \SI{%.1f}{\degree}' % sigma) # plotd.set_title('Distance between reconstructed angles for station and cluster') plotd.set_xlabel('Angle between reconstructions [\si{\degree}]') plotd.set_ylabel('Counts') plotd.set_xlimits(min=0, max=90) plotd.set_ylimits(min=0) plotd.save_as_pdf('angle_between_501_spa_minn%d' % minn)
def plot_angles(data): """Make azimuth and zenith plots to compare the results""" rec501 = data.get_node('/hisparc/cluster_amsterdam/station_501', 'reconstructions') rec510 = data.get_node('/hisparc/cluster_amsterdam/station_510', 'reconstructions') zen501 = rec501.col('zenith') zen510 = rec510.col('zenith') azi501 = rec501.col('azimuth') azi510 = rec510.col('azimuth') minn501 = rec501.col('min_n') minn510 = rec510.col('min_n') sigmas = [] blas = [] minns = [0, 1, 2, 4, 8, 16, 24] high_zenith = (zen501 > .2) & (zen510 > .2) for minn in minns: filter = (minn501 > minn) & (minn510 > minn) length = len(azi501.compress(high_zenith & filter)) shifts501 = np.random.normal(0, .06, length) shifts510 = np.random.normal(0, .06, length) azicounts, x, y = np.histogram2d( azi501.compress(high_zenith & filter) + shifts501, azi510.compress(high_zenith & filter) + shifts510, bins=np.linspace(-pi, pi, 73)) plota = Plot() plota.histogram2d(azicounts, degrees(x), degrees(y), type='reverse_bw', bitmap=True) # plota.set_title('Reconstructed azimuths for events in coincidence (zenith gt .2 rad)') plota.set_xlabel(r'$\phi_{501}$ [\si{\degree}]') plota.set_ylabel(r'$\phi_{510}$ [\si{\degree}]') plota.set_xticks([-180, -90, 0, 90, 180]) plota.set_yticks([-180, -90, 0, 90, 180]) plota.save_as_pdf('azimuth_501_510_minn%d' % minn) length = len(zen501.compress(filter)) shifts501 = np.random.normal(0, .04, length) shifts510 = np.random.normal(0, .04, length) zencounts, x, y = np.histogram2d(zen501.compress(filter) + shifts501, zen510.compress(filter) + shifts510, bins=np.linspace(0, pi / 3., 41)) plotz = Plot() plotz.histogram2d(zencounts, degrees(x), degrees(y), type='reverse_bw', bitmap=True) # plotz.set_title('Reconstructed zeniths for station events in coincidence') plotz.set_xlabel(r'$\theta_{501}$ [\si{\degree}]') plotz.set_ylabel(r'$\theta_{510}$ [\si{\degree}]') plotz.set_xticks([0, 15, 30, 45, 60]) plotz.set_yticks([0, 15, 30, 45, 60]) plotz.save_as_pdf('zenith_501_510_minn%d' % minn) distances = angle_between(zen501.compress(filter), azi501.compress(filter), zen510.compress(filter), azi510.compress(filter)) counts, bins = np.histogram(distances, bins=linspace(0, pi, 100)) plotd = Plot() plotd.histogram(counts, degrees(bins)) sigma = degrees(percentile(distances[isfinite(distances)], 68)) sigmas.append(sigma) bla = degrees(percentile(distances[isfinite(distances)], 95)) blas.append(bla) plotd.set_label(r'67\%% within \SI{%.1f}{\degree}' % sigma) # plotd.set_title('Distance between reconstructed angles for station events') plotd.set_xlabel(r'Angle between reconstructions [\si{\degree}]') plotd.set_ylabel('Counts') plotd.set_xlimits(min=0, max=90) plotd.set_ylimits(min=0) plotd.save_as_pdf('angle_between_501_510_minn%d' % minn) plot = Plot() plot.plot(minns, sigmas, mark='*') plot.plot(minns, blas) plot.set_ylimits(min=0, max=40) plot.set_xlabel('Minimum number of particles in each station') plot.set_ylabel(r'Angle between reconstructions [\si{\degree}]') plot.save_as_pdf('angle_between_501_510_v_minn')
def plot_thickness(seed): plot = Plot('semilogx') plot2 = Plot('loglog') data_path = os.path.join(LOCAL_STORE, seed, 'corsika.h5') with tables.open_file(data_path) as data: particles = data.get_node('/groundparticles') header = data.get_node_attr('/', 'event_header') end = data.get_node_attr('/', 'event_end') time_first_interaction = (header.first_interaction_altitude - header.observation_heights[0]) / .2998 core_distances = logspace(0, 4, 31) min_t = [] lower_t = [] low_t = [] median_t = [] high_t = [] higher_t = [] max_t = [] distances = [] density = [] xerr = [] yerr = [] for r_inner, r_outer in zip(core_distances[:-1], core_distances[1:]): t = particles.read_where('(r >= %f) & (r <= %f) & ' '(particle_id >= 2) & (particle_id <= 6)' % (r_inner, r_outer), field='t') if len(t) < 1: continue area = area_between(r_outer, r_inner) density.append(len(t) / area) distances.append((r_outer + r_inner) / 2) # distances.append(10**((log10(r_outer) + log10(r_inner)) / 2)) yerr.append(sqrt(len(t)) / area) xerr.append((r_outer - r_inner) / 2) percentiles_t = percentile(t, [0, 50]) ref_t, med_t = percentiles_t - time_first_interaction min_t.append(ref_t) # lower_t.append(lsig2_t) # low_t.append(lsig1_t) median_t.append(med_t) # high_t.append(hsig1_t) # higher_t.append(hsig2_t) # max_t.append(m_t) energy = log10(header.energy) shower_size = log10(end.n_electrons_levels + end.n_muons_levels) plot.set_label('E=$10^{%.1f}$eV, size=$10^{%.1f}$' % (energy, shower_size), location='upper left') plot.plot(distances, median_t, mark=None) plot.plot(distances, min_t, linestyle='dashed', mark=None) plot.draw_horizontal_line(1500) plot.set_xlimits(min=.5, max=1e4) plot.set_xlabel(r'core distance [m]') plot.set_ylabel(r'time after first [ns]') plot.set_ylimits(min=-10, max=1000) plot.save_as_pdf('plots/%.1f_%.1f_%s_front.pdf' % (energy, shower_size, seed)) plot2.set_xlimits(min=.5, max=1e5) plot2.set_xlabel(r'core distance') plot2.set_ylabel(r'particle density') plot2.plot(distances, density, xerr=xerr, yerr=yerr, mark=None, markstyle='transparent', linestyle=None) plot2.draw_horizontal_line(2.46) # plot2.draw_horizontal_line(0.6813) plot2.save_as_pdf('plots/%.1f_%.1f_%s_dens.pdf' % (energy, shower_size, seed))