def read_ARA_eventlist(filename): ara_version = 0 event_number = 0 with open(filename, 'r') as fin: lines = fin.readlines() data = "" for i, line in enumerate(lines): if line.startswith("VERSION"): ara_version = float(line.split("=")[1]) elif line.startswith("EVENT_NUM"): event_number = int(line.split("=")[1]) else: data += "{}".format(line) if (ara_version != 0.1): print("file version is {}. version != 0.1 not supported".format( ara_version)) import sys sys.exit(-1) data = np.genfromtxt(BytesIO(data), comments='//', skip_header=3, dtype=[('eventId', int), ('nuflavorint', int), ('nu_nubar', int), ('pnu', float), ('currentint', float), ('posnu_r', float), ('posnu_theta', float), ('posnu_phi', float), ('nnu_theta', float), ('nnu_phi', float), ('elast_y', float)]) # convert angles into NuRadioMC coordinate convention for i in range(len(data)): data[i][3] = 10**(data[i][3] + 18.) * units.eV data[i][4] = data[i][4] * units.m data[i][6] = hp.get_normalized_angle( 0.5 * np.pi - data[i][6] ) # convert theta angle into NuRadioMC coordinate convention data[i][8] = hp.get_normalized_angle( 0.5 * np.pi - data[i][8] ) # convert theta angle into NuRadioMC coordinate convention return data
def get_angles(corsika): """ Converting angles in corsika coordinates to local coordinates """ zenith = np.deg2rad(corsika['inputs'].attrs["THETAP"][0]) azimuth = hp.get_normalized_angle(3 * np.pi / 2. + np.deg2rad(corsika['inputs'].attrs["PHIP"][0])) Bx, Bz = corsika['inputs'].attrs["MAGNET"] B_inclination = np.arctan2(Bz, Bx) B_strength = (Bx ** 2 + Bz ** 2) ** 0.5 * units.micro * units.tesla # in local coordinates north is + 90 deg magnetic_field_vector = B_strength * hp.spherical_to_cartesian(np.pi * 0.5 + B_inclination, 0 + np.pi * 0.5) return zenith, azimuth, magnetic_field_vector
def __draw_2d_correlation_map(self, event, correlation_map): fig4 = plt.figure(figsize=(4, 12)) ax4_1 = fig4.add_subplot(311) d_0, z_0 = np.meshgrid(self.__distances_2d, self.__z_coordinates_2d) ax4_1.pcolor(d_0, z_0, np.max(correlation_map, axis=2).T) ax4_1.grid() theta_0, d_0 = np.meshgrid(self.__azimuths_2d, self.__distances_2d) ax4_2 = fig4.add_subplot(312, projection='polar') ax4_2.pcolor(theta_0, d_0, np.max(correlation_map, axis=1)) ax4_2.grid() ax4_3 = fig4.add_subplot(313) theta_0, z_0 = np.meshgrid(self.__azimuths_2d, self.__z_coordinates_2d) ax4_3.pcolor(theta_0 / units.deg, z_0, np.max(correlation_map, axis=0)) ax4_3.grid() sim_vertex = None for sim_shower in event.get_sim_showers(): sim_vertex = sim_shower.get_parameter(shp.vertex) break if sim_vertex is not None: ax4_1.scatter([np.sqrt(sim_vertex[0]**2 + sim_vertex[1]**2)], [sim_vertex[2]], c='r', alpha=.5, marker='+') ax4_2.scatter([ hp.cartesian_to_spherical(sim_vertex[0], sim_vertex[1], sim_vertex[2])[1] ], [np.sqrt(sim_vertex[0]**2 + sim_vertex[1]**2)], c='r', alpha=.5, marker='+') ax4_3.scatter([ hp.get_normalized_angle( hp.cartesian_to_spherical(sim_vertex[0], sim_vertex[1], sim_vertex[2])[1]) / units.deg ], [(sim_vertex[2])], c='r', alpha=.5, marker='+') ax4_1.set_xlabel('d [m]') ax4_1.set_ylabel('z [m]') ax4_3.set_xlabel(r'$\phi [^\circ]$') ax4_3.set_ylabel('z [m]') fig4.tight_layout() fig4.savefig('{}/{}_{}_2D_correlation_maps.png'.format( self.__debug_folder, event.get_run_number(), event.get_id()))
def get_parallel_channels(self, station_id): """ get a list of parallel antennas Parameters --------- station_id: int the station id Returns list of list of ints """ res = self.__get_channels(station_id) orientations = np.zeros((len(res), 4)) antenna_types = [] channel_ids = [] for iCh, ch in enumerate(res.values()): channel_id = ch['channel_id'] channel_ids.append(channel_id) antenna_types.append(self.get_antenna_type(station_id, channel_id)) orientations[iCh] = self.get_antenna_orientation( station_id, channel_id) orientations[iCh][3] = hp.get_normalized_angle( orientations[iCh][3], interval=np.deg2rad([0, 180])) channel_ids = np.array(channel_ids) antenna_types = np.array(antenna_types) orientations = np.round(np.rad2deg( orientations)) # round to one degree to overcome rounding errors parallel_antennas = [] for antenna_type in np.unique(antenna_types): for u_zen_ori in np.unique(orientations[:, 0]): for u_az_ori in np.unique(orientations[:, 1]): for u_zen_rot in np.unique(orientations[:, 2]): for u_az_rot in np.unique(orientations[:, 3]): mask = (antenna_types == antenna_type) \ & (orientations[:, 0] == u_zen_ori) & (orientations[:, 1] == u_az_ori) \ & (orientations[:, 2] == u_zen_rot) & (orientations[:, 3] == u_az_rot) if np.sum(mask): parallel_antennas.append(channel_ids[mask]) return np.array(parallel_antennas)
def run(self, evt, station, det, channels_to_use=None, cosmic_ray=False): """ Fits the direction using templates Parameters ---------- evt: event station: station det: detector channels_to_use: list (default: [0, 1, 2, 3] antenna to use for fit cosmic_ray: bool type to set correlation template """ if channels_to_use is None: channels_to_use = [0, 1, 2, 3] if (cosmic_ray): type_str = 'cr' xcorrelations = chp.cr_xcorrelations else: type_str = 'nu' xcorrelations = chp.nu_xcorrelations station_id = station.get_id() channels = station.iter_channels(channels_to_use) times = [] positions = [] for iCh, channel in enumerate(channels): channel_id = channel.get_id() times.append( channel[xcorrelations]['{}_ref_xcorr_time'.format(type_str)] + channel.get_trace_start_time()) positions.append(det.get_relative_position(station_id, channel_id)) times = np.array(times) positions = np.array(positions) site = det.get_site(station_id) n_ice = ice.get_refractive_index(-0.01, site) from scipy import optimize as opt def obj_plane(params, positions, t_measured): zenith, azimuth = params if cosmic_ray: if ((zenith < 0) or (zenith > 0.5 * np.pi)): return np.inf else: if ((zenith < 0.5 * np.pi) or (zenith > np.pi)): return np.inf v = hp.spherical_to_cartesian(zenith, azimuth) c = constants.c * units.m / units.s if not cosmic_ray: c = c / n_ice logger.debug("using speed of light = {:.4g}".format(c)) t_expected = -(np.dot(v, positions.T) / c) sigma = 1 * units.ns chi2 = np.sum(((t_expected - t_expected.mean()) - (t_measured - t_measured.mean()))**2 / sigma**2) logger.debug("texp = {texp}, tm = {tmeas}, {chi2}".format( texp=t_expected, tmeas=t_measured, chi2=chi2)) return chi2 method = "Nelder-Mead" options = {'maxiter': 1000, 'disp': False} zenith_start = 135 * units.deg if cosmic_ray: zenith_start = 45 * units.deg starting_chi2 = {} for starting_az in np.array([0, 90, 180, 270]) * units.degree: starting_chi2[starting_az] = obj_plane((zenith_start, starting_az), positions, times) azimuth_start = min(starting_chi2, key=starting_chi2.get) res = opt.minimize(obj_plane, x0=[zenith_start, azimuth_start], args=(positions, times), method=method, options=options) output_str = "reconstucted angles theta = {:.1f}, phi = {:.1f}".format( res.x[0] / units.deg, hp.get_normalized_angle(res.x[1]) / units.deg) if station.has_sim_station(): sim_zen = station.get_sim_station()[stnp.zenith] sim_az = station.get_sim_station()[stnp.azimuth] dOmega = hp.get_angle( hp.spherical_to_cartesian(sim_zen, sim_az), hp.spherical_to_cartesian(res.x[0], res.x[1])) output_str += " MC theta = {:.1f}, phi = {:.1f}, dOmega = {:.2f}".format( sim_zen / units.deg, sim_az / units.deg, dOmega / units.deg) logger.info(output_str) station[stnp.zenith] = res.x[0] station[stnp.azimuth] = hp.get_normalized_angle(res.x[1]) if (cosmic_ray): station[stnp.cr_zenith] = res.x[0] station[stnp.cr_azimuth] = hp.get_normalized_angle(res.x[1]) else: station[stnp.nu_zenith] = res.x[0] station[stnp.nu_azimuth] = hp.get_normalized_angle(res.x[1])
plt.xlabel("r [m]") plt.ylabel("z [m]") plt.grid(True) plt.suptitle("vertex distribution") plt.savefig(os.path.join(plot_folder, 'vertex_distribution.pdf'), bbox_inches="tight") plt.clf() # plot incoming direction # for all events, antennas and ray tracing solutions zeniths, azimuths = hp.cartesian_to_spherical_vectorized( receive_vectors[:, :, :, 0].flatten(), receive_vectors[:, :, :, 1].flatten(), receive_vectors[:, :, :, 2].flatten()) for i in range(len(azimuths)): azimuths[i] = hp.get_normalized_angle(azimuths[i]) weights_matrix = np.outer(weights, np.ones(np.prod( receive_vectors.shape[1:-1]))).flatten() mask = ~np.isnan( azimuths ) # exclude antennas with not ray tracing solution (or with just one ray tracing solution) plt.subplot(1, 2, 1) plt.hist(zeniths[mask] / units.deg, bins=np.arange(0, 181, 10), weights=weights_matrix[mask]) plt.xlabel('zenith [deg]') plt.subplot(1, 2, 2) plt.hist(azimuths[mask] / units.deg, bins=np.arange(0, 361, 45), weights=weights_matrix[mask]) plt.xlabel('azimuth [deg]')
def run(self, evt, station, det, n_index=None, ZenLim=None, AziLim=None, channel_pairs=((0, 2), (1, 3)), use_envelope=False): """ reconstruct signal arrival direction for all events Parameters ---------- evt: Event The event to run the module on station: Station The station to run the module on det: Detector The detector description n_index: float the index of refraction ZenLim: 2-dim array/list of floats (default: [0 * units.deg, 90 * units.deg]) the zenith angle limits for the fit AziLim: 2-dim array/list of floats (default: [0 * units.deg, 360 * units.deg]) the azimuth angle limits for the fit channel_pairs: pair of pair of integers specify the two channel pairs to use, default ((0, 2), (1, 3)) use_envelope: bool (default False) if True, the hilbert envelope of the traces is used """ if ZenLim is None: ZenLim = [0 * units.deg, 90 * units.deg] if AziLim is None: AziLim = [0 * units.deg, 360 * units.deg] use_correlation = True def ll_regular_station(angles, corr_02, corr_13, sampling_rate, positions, trace_start_times): """ Likelihood function for a four antenna ARIANNA station, using correction. Using correlation, has no built in wrap around, pulse needs to be in the middle """ zenith = angles[0] azimuth = angles[1] times = [] for pos in positions: tmp = [geo_utl.get_time_delay_from_direction(zenith, azimuth, pos[0], n=n_index), geo_utl.get_time_delay_from_direction(zenith, azimuth, pos[1], n=n_index)] times.append(tmp) delta_t_02 = times[0][1] - times[0][0] delta_t_13 = times[1][1] - times[1][0] # take different trace start times into account delta_t_02 -= (trace_start_times[0][1] - trace_start_times[0][0]) delta_t_13 -= (trace_start_times[1][1] - trace_start_times[1][0]) delta_t_02 *= sampling_rate delta_t_13 *= sampling_rate pos_02 = int(corr_02.shape[0] / 2 - delta_t_02) pos_13 = int(corr_13.shape[0] / 2 - delta_t_13) # weight_02 = np.sum(corr_02 ** 2) # Normalize crosscorrelation # weight_13 = np.sum(corr_13 ** 2) # # likelihood = -1 * (corr_02[pos_02] ** 2 / weight_02 + corr_13[pos_13] ** 2 / weight_13) # After deliberating a bit, I don't think we should use the square because anti-correlating # pulses would be wrong, given that it is not a continous waveform weight_02 = np.sum(np.abs(corr_02)) # Normalize crosscorrelation weight_13 = np.sum(np.abs(corr_13)) likelihood = -1 * (corr_02[pos_02] / weight_02 + corr_13[pos_13] / weight_13) return likelihood def ll_regular_station_fft(angles, corr_02_fft, corr_13_fft, sampling_rate, positions, trace_start_times): """ Likelihood function for a four antenna ARIANNA station, using FFT convolution Using FFT convolution, has built-in wrap around, but ARIANNA signals are too short for it to be accurate will show problems at zero time delay """ zenith = angles[0] azimuth = angles[1] times = [] for pos in positions: tmp = [geo_utl.get_time_delay_from_direction(zenith, azimuth, pos[0], n=n_index) * sampling_rate, geo_utl.get_time_delay_from_direction(zenith, azimuth, pos[1], n=n_index) * sampling_rate] times.append(tmp) delta_t_02 = (times[0][1] + trace_start_times[0][1] * sampling_rate) - (times[0][0] + trace_start_times[0][0] * sampling_rate) delta_t_13 = (times[1][1] + trace_start_times[1][1] * sampling_rate) - (times[1][0] + trace_start_times[1][0] * sampling_rate) if delta_t_02 < 0: pos_02 = int(delta_t_02 + corr_02_fft.shape[0]) else: pos_02 = int(delta_t_02) if delta_t_13 < 0: pos_13 = int(delta_t_13 + corr_13_fft.shape[0]) else: pos_13 = int(delta_t_13) weight_02 = np.sum(np.abs(corr_02_fft)) # Normalize crosscorrelation weight_13 = np.sum(np.abs(corr_13_fft)) likelihood = -1 * (np.abs(corr_02_fft[pos_02]) ** 2 / weight_02 + np.abs(corr_13[pos_13]) ** 2 / weight_13) return likelihood station_id = station.get_id() positions_pairs = [[det.get_relative_position(station_id, channel_pairs[0][0]), det.get_relative_position(station_id, channel_pairs[0][1])], [det.get_relative_position(station_id, channel_pairs[1][0]), det.get_relative_position(station_id, channel_pairs[1][1])]] sampling_rate = station.get_channel(0).get_sampling_rate() # assume that channels have the same sampling rate trace_start_time_pairs = [[station.get_channel(channel_pairs[0][0]).get_trace_start_time(), station.get_channel(channel_pairs[0][1]).get_trace_start_time()], [station.get_channel(channel_pairs[1][0]).get_trace_start_time(), station.get_channel(channel_pairs[1][1]).get_trace_start_time()]] # determine automatically if one channel has an inverted waveform with respect to the other signs = [1., 1.] for iPair, pair in enumerate(channel_pairs): antenna_type = det.get_antenna_type(station_id, pair[0]) if("LPDA" in antenna_type): otheta, ophi, rot_theta, rot_azimuth = det.get_antenna_orientation(station_id, pair[0]) otheta2, ophi2, rot_theta2, rot_azimuth2 = det.get_antenna_orientation(station_id, pair[1]) if(np.isclose(np.abs(rot_azimuth - rot_azimuth2), 180 * units.deg, atol=1 * units.deg)): signs[iPair] = -1 if use_correlation: # Correlation if not use_envelope: corr_02 = signal.correlate(station.get_channel(channel_pairs[0][0]).get_trace(), signs[0] * station.get_channel(channel_pairs[0][1]).get_trace()) corr_13 = signal.correlate(station.get_channel(channel_pairs[1][0]).get_trace(), signs[1] * station.get_channel(channel_pairs[1][1]).get_trace()) else: corr_02 = signal.correlate(np.abs(signal.hilbert(station.get_channel(channel_pairs[0][0]).get_trace())), np.abs(signal.hilbert(station.get_channel(channel_pairs[0][1]).get_trace()))) corr_13 = signal.correlate(np.abs(signal.hilbert(station.get_channel(channel_pairs[1][0]).get_trace())), np.abs(signal.hilbert(station.get_channel(channel_pairs[1][1]).get_trace()))) else: # FFT convolution corr_02_fft = fftpack.ifft(-1 * fftpack.fft(station.get_channel(channel_pairs[0][0]).get_trace()).conjugate() * fftpack.fft(station.get_channel(channel_pairs[0][1]).get_trace())) corr_13_fft = fftpack.ifft(-1 * fftpack.fft(station.get_channel(channel_pairs[1][0]).get_trace()).conjugate() * fftpack.fft(station.get_channel(channel_pairs[1][1]).get_trace())) if use_correlation: # Using correlation ll = opt.brute( ll_regular_station, ranges=(slice(ZenLim[0], ZenLim[1], 0.01), slice(AziLim[0], AziLim[1], 0.01)), args=(corr_02, corr_13, sampling_rate, positions_pairs, trace_start_time_pairs), full_output=True, finish=opt.fmin) # slow but does the trick else: ll = opt.brute(ll_regular_station_fft, ranges=(slice(ZenLim[0], ZenLim[1], 0.05), slice(AziLim[0], AziLim[1], 0.05)), args=(corr_02_fft, corr_13_fft, sampling_rate, positions_pairs, trace_start_time_pairs), full_output=True, finish=opt.fmin) # slow but does the trick if self.__debug: import peakutils zenith = ll[0][0] azimuth = ll[0][1] times = [] for pos in positions_pairs: tmp = [geo_utl.get_time_delay_from_direction(zenith, azimuth, pos[0], n=n_index), geo_utl.get_time_delay_from_direction(zenith, azimuth, pos[1], n=n_index)] times.append(tmp) delta_t_02 = times[0][1] - times[0][0] delta_t_13 = times[1][1] - times[1][0] # take different trace start times into account delta_t_02 -= (trace_start_time_pairs[0][1] - trace_start_time_pairs[0][0]) delta_t_13 -= (trace_start_time_pairs[1][1] - trace_start_time_pairs[1][0]) delta_t_02 *= sampling_rate delta_t_13 *= sampling_rate toffset = -(np.arange(0, corr_02.shape[0]) - corr_02.shape[0] / 2) / sampling_rate fig, (ax, ax2) = plt.subplots(2, 1, sharex=True) ax.plot(toffset, corr_02) ax.axvline(delta_t_02 / sampling_rate, label='time', c='k') indices = peakutils.indexes(corr_02, thres=0.8, min_dist=5) ax.plot(toffset[indices], corr_02[indices], 'o') imax = np.argmax(corr_02[indices]) self.logger.debug("offset 02= {:.3f}".format(toffset[indices[imax]] - (delta_t_02 / sampling_rate))) ax2.plot(toffset, corr_13) indices = peakutils.indexes(corr_13, thres=0.8, min_dist=5) ax2.plot(toffset[indices], corr_13[indices], 'o') ax2.axvline(delta_t_13 / sampling_rate, label='time', c='k') ax2.set_xlabel("time") ax2.set_ylabel("Correlation Ch 1/ Ch3", fontsize='small') ax.set_ylabel("Correlation Ch 0/ Ch2", fontsize='small') plt.tight_layout() # plt.close("all") station[stnp.zenith] = max(ZenLim[0], min(ZenLim[1], ll[0][0])) station[stnp.azimuth] = ll[0][1] output_str = "reconstucted angles theta = {:.1f}, phi = {:.1f}".format(station[stnp.zenith] / units.deg, station[stnp.azimuth] / units.deg) if station.has_sim_station(): sim_zen = None sim_az = None if(station.get_sim_station().is_cosmic_ray()): sim_zen = station.get_sim_station()[stnp.zenith] sim_az = station.get_sim_station()[stnp.azimuth] elif(station.get_sim_station().is_neutrino()): # in case of a neutrino simulation, each channel has a slightly different arrival direction -> compute the average sim_zen = [] sim_az = [] for efield in station.get_sim_station().get_electric_fields_for_channels(ray_path_type='direct'): sim_zen.append(efield[efp.zenith]) sim_az.append(efield[efp.azimuth]) sim_zen = np.array(sim_zen) sim_az = hp.get_normalized_angle(np.array(sim_az)) ops = "average incident zenith {:.1f} +- {:.1f}".format(np.mean(sim_zen) / units.deg, np.std(sim_zen) / units.deg) ops += " (individual: " for x in sim_zen: ops += "{:.1f}, ".format(x / units.deg) ops += ")" self.logger.debug(ops) ops = "average incident azimuth {:.1f} +- {:.1f}".format(np.mean(sim_az) / units.deg, np.std(sim_az) / units.deg) ops += " (individual: " for x in sim_az: ops += "{:.1f}, ".format(x / units.deg) ops += ")" self.logger.debug(ops) sim_zen = np.mean(np.array(sim_zen)) sim_az = np.mean(np.array(sim_az)) if(sim_zen is not None): dOmega = hp.get_angle(hp.spherical_to_cartesian(sim_zen, sim_az), hp.spherical_to_cartesian(station[stnp.zenith], station[stnp.azimuth])) output_str += " MC theta = {:.2f}, phi = {:.2f}, dOmega = {:.2f}, dZen = {:.1f}, dAz = {:.1f}".format(sim_zen / units.deg, hp.get_normalized_angle(sim_az) / units.deg, dOmega / units.deg, (station[stnp.zenith] - sim_zen) / units.deg, (station[stnp.azimuth] - hp.get_normalized_angle(sim_az)) / units.deg) self.__zenith.append(sim_zen) self.__azimuth.append(sim_az) self.__delta_zenith.append(station[stnp.zenith] - sim_zen) self.__delta_azimuth.append(station[stnp.azimuth] - hp.get_normalized_angle(sim_az)) self.logger.info(output_str) # Still have to add fit quality parameter to output if self.__debug: import peakutils # access simulated efield and high level parameters sim_present = False if(station.has_sim_station()): if(station.get_sim_station().has_parameter(stnp.zenith)): sim_station = station.get_sim_station() azimuth_orig = sim_station[stnp.azimuth] zenith_orig = sim_station[stnp.zenith] sim_present = True self.logger.debug("True CoREAS zenith {0}, azimuth {1}".format(zenith_orig, azimuth_orig)) self.logger.debug("Result of direction fitting: [zenith, azimuth] {}".format(np.rad2deg(ll[0]))) # Show fit space zen = np.arange(ZenLim[0], ZenLim[1], 1 * units.deg) az = np.arange(AziLim[0], AziLim[1], 2 * units.deg) x_plot = np.zeros(zen.shape[0] * az.shape[0]) y_plot = np.zeros(zen.shape[0] * az.shape[0]) z_plot = np.zeros(zen.shape[0] * az.shape[0]) i = 0 for a in az: for z in zen: # Evaluate fit function for grid if use_correlation: z_plot[i] = ll_regular_station([z, a], corr_02, corr_13, sampling_rate, positions_pairs, trace_start_time_pairs) else: z_plot[i] = ll_regular_station_fft([z, a], corr_02_fft, corr_13_fft, sampling_rate, positions_pairs, trace_start_time_pairs) x_plot[i] = a y_plot[i] = z i += 1 fig, ax = plt.subplots(1, 1) ax.scatter(np.rad2deg(x_plot), np.rad2deg(y_plot), c=z_plot, cmap='gnuplot2_r', lw=0) # ax.imshow(z_plot, cmap='gnuplot2_r', extent=(0, 360, 90, 180)) if sim_present: ax.plot(np.rad2deg(hp.get_normalized_angle(azimuth_orig)), np.rad2deg(zenith_orig), marker='d', c='g', label="True") ax.scatter(np.rad2deg(ll[0][1]), np.rad2deg(ll[0][0]), marker='o', c='k', label='Fit') # ax.colorbar(label='Fit parameter') ax.set_ylabel('Zenith [rad]') ax.set_xlabel('Azimuth [rad]') plt.tight_layout() # plot allowed solution separately for each pair of channels toffset = -(np.arange(0, corr_02.shape[0]) - corr_02.shape[0] / 2.) / sampling_rate indices = peakutils.indexes(corr_02, thres=0.8, min_dist=5) t02s = toffset[indices][np.argsort(corr_02[indices])[::-1]] + (trace_start_time_pairs[0][1] - trace_start_time_pairs[0][0]) toffset = -(np.arange(0, corr_13.shape[0]) - corr_13.shape[0] / 2.) / sampling_rate indices = peakutils.indexes(corr_13, thres=0.8, min_dist=5) t13s = toffset[indices][np.argsort(corr_13[indices])[::-1]] + (trace_start_time_pairs[1][1] - trace_start_time_pairs[1][0]) from scipy import constants c = constants.c * units.m / units.s dx = -6 * units.m def get_deltat13(dt, phi): t = -1. * dt * c / (dx * np.cos(phi) * n_index) t[t < 0] = np.nan return np.arcsin(t) def get_deltat02(dt, phi): t = -1 * dt * c / (dx * np.sin(phi) * n_index) t[t < 0] = np.nan return np.arcsin(t) def getDeltaTCone(r, dt): dist = np.linalg.norm(r) t0 = -dist * n_index / c Phic = np.arccos(dt / t0) # cone angle for allowable solutions self.logger.debug('dist = {}, dt = {}, t0 = {}, phic = {}'.format(dist, dt, t0, Phic)) nr = r / dist # normalize p = np.cross([0, 0, 1], nr) # create a perpendicular normal vector to r p = p / np.linalg.norm(p) q = np.cross(nr, p) # nr, p, and q form an orthonormal basis self.logger.debug('nr = {}\np = {}\nq = {}\n'.format(nr, p, q)) ThetaC = np.linspace(0, 2 * np.pi, 1000) Phis = np.zeros(len(ThetaC)) Thetas = np.zeros(len(ThetaC)) for i, thetac in enumerate(ThetaC): # create a set of vectors that point along the cone defined by r and PhiC rc = nr + np.tan(Phic) * (np.sin(thetac) * p + np.cos(thetac) * q) nrc = rc / np.linalg.norm(rc) theta = np.arccos(nrc[2]) phi = np.arctan2(nrc[1], nrc[0]) Phis[i] = phi Thetas[i] = theta return Phis, Thetas # phis = np.deg2rad(np.linspace(0, 360, 10000)) r0_2 = positions_pairs[0][1] - positions_pairs[0][0] # vector pointing from Ch2 to Ch0 r1_3 = positions_pairs[1][1] - positions_pairs[1][0] # vector pointing from Ch3 to Ch1 self.logger.debug('r02 {}\nr13 {}'.format(r0_2, r1_3)) linestyles = ['-', '--', ':', '-.'] for i, t02 in enumerate(t02s): # theta02 = get_deltat02(t02, phis) phi02, theta02 = getDeltaTCone(r0_2, t02) theta02[theta02 < 0] += np.pi phi02[phi02 < 0] += 2 * np.pi jumppos02 = np.where(np.abs(np.diff(phi02)) >= 5.0) for j, pos in enumerate(jumppos02): phi02 = np.insert(phi02, pos + 1 + j, np.nan) theta02 = np.insert(theta02, pos + 1 + j, np.nan) # mask02 = ~np.isnan(theta02) ax.plot(np.rad2deg(phi02), np.rad2deg(theta02), '{}C3'.format(linestyles[i % 4]), label='c 0+2 dt = {}'.format(t02)) for i, t13 in enumerate(t13s): # theta13 = get_deltat13(t13, phis) phi13, theta13 = getDeltaTCone(r1_3, t13) theta13[theta13 < 0] += np.pi phi13[phi13 < 0] += 2 * np.pi jumppos13 = np.where(np.abs(np.diff(phi13)) >= 5.0) for j, pos in enumerate(jumppos13): phi13 = np.insert(phi13, pos + 1 + j, np.nan) theta13 = np.insert(theta13, pos + 1 + j, np.nan) # mask13 = ~np.isnan(theta13) ax.plot(np.rad2deg(phi13), np.rad2deg(theta13), '{}C2'.format(linestyles[i % 4]), label='c 1+3 dt = {}'.format(t13)) ax.legend(fontsize='small') ax.set_ylim(ZenLim[0] / units.deg, ZenLim[1] / units.deg) ax.set_xlim(AziLim[0] / units.deg, AziLim[1] / units.deg)
# if(d > -800): # continue # calcualte expected angles r = ray.ray_tracing(pos_spice + np.array([0, 0, d]), pos_SP1, medium.southpole_simple(), log_level=logging.WARNING) r.find_solutions() if (not r.has_solution()): continue results['depth'].append(d) rvec = r.get_receive_vector(0) zen, az = hp.cartesian_to_spherical(*rvec) az = hp.get_normalized_angle(az) results['exp'].append((zen, az)) print("{} depth = {:.1f}m -> {:.2f} {:.2f} (solution type {})".format( t, d, zen / units.deg, az / units.deg, r.get_solution_type(0))) channelResampler.run(evt, station, det, 50 * units.GHz) channelBandPassFilter.run(evt, station, det, passband=[120 * units.MHz, 300 * units.MHz], filter_type='butterabs', order=10) channelBandPassFilter.run(evt, station, det, passband=[10 * units.MHz, 1000 * units.MHz],
def run(self, evt, station, det, channels_to_use=None, cosmic_ray=False): """ Parameters ---------------- evt: Event The event to run the module on station: Station The station to run the module on det: Detector The detector description channels_to_use: list of int (default: [0, 1, 2, 3]) List with the IDs of channels to use for reconstruction cosmic_ray: Bool (default: False) Flag to mark event as cosmic ray """ if channels_to_use is None: channels_to_use = [0, 1, 2, 3] station_id = station.get_id() times = [] times_error = [] positions = [] for iCh, efield in enumerate(station.get_electric_fields()): if (len(efield.get_channel_ids()) > 1): # FIXME: this can be changed later if each efield has a position and absolute time raise AttributeError( "found efield that is valid for more than one channel. Position can't be determined." ) channel_id = efield.get_channel_ids()[0] if (channel_id not in channels_to_use): continue times.append(efield[efp.signal_time]) if (efield.has_parameter_error(efp.signal_time)): times_error.append( (efield.get_parameter_error(efp.signal_time)**2 + self.__time_uncertainty**2)**0.5) else: times_error.append(self.__time_uncertainty) positions.append(det.get_relative_position(station_id, channel_id)) times = np.array(times) times_error = np.array(times_error) positions = np.array(positions) site = det.get_site(station_id) n_ice = ice.get_refractive_index(-0.01, site) from scipy import optimize as opt def get_expected_times(params, channel_positions): zenith, azimuth = params if cosmic_ray: if ((zenith < 0) or (zenith > 0.5 * np.pi)): return np.ones(len(channel_positions)) * np.inf else: if ((zenith < 0.5 * np.pi) or (zenith > np.pi)): return np.ones(len(channel_positions)) * np.inf v = hp.spherical_to_cartesian(zenith, azimuth) c = constants.c * units.m / units.s if not cosmic_ray: c = c / n_ice logger.debug("using speed of light = {:.4g}".format(c)) t_expected = -(np.dot(v, channel_positions.T) / c) return t_expected def obj_plane(params, pos, t_measured): t_expected = get_expected_times(params, pos) chi_squared = np.sum( ((t_expected - t_expected.mean()) - (t_measured - t_measured.mean()))**2 / times_error**2) logger.debug("texp = {texp}, tm = {tmeas}, {chi2}".format( texp=t_expected, tmeas=t_measured, chi2=chi_squared)) return chi_squared method = "Nelder-Mead" options = {'maxiter': 1000, 'disp': False} zenith_start = 135 * units.deg if cosmic_ray: zenith_start = 45 * units.deg starting_chi2 = {} for starting_az in np.array([0, 90, 180, 270]) * units.degree: starting_chi2[starting_az] = obj_plane((zenith_start, starting_az), positions, times) azimuth_start = min(starting_chi2, key=starting_chi2.get) res = opt.minimize(obj_plane, x0=[zenith_start, azimuth_start], args=(positions, times), method=method, options=options) chi2 = res.fun df = len(channels_to_use) - 3 if (df == 0): chi2ndf = chi2 chi2prob = stats.chi2.sf(chi2, 1) else: chi2ndf = chi2 / df chi2prob = stats.chi2.sf(chi2, df) output_str = "reconstucted angles theta = {:.1f}, phi = {:.1f}, chi2/ndf = {:.2g}/{:d} = {:.2g}, chi2prob = {:.3g}".format( res.x[0] / units.deg, hp.get_normalized_angle(res.x[1]) / units.deg, res.fun, df, chi2ndf, chi2prob) logger.info(output_str) station[stnp.zenith] = res.x[0] station[stnp.azimuth] = hp.get_normalized_angle(res.x[1]) station[stnp.chi2_efield_time_direction_fit] = chi2 station[stnp.ndf_efield_time_direction_fit] = df if (cosmic_ray): station[stnp.cr_zenith] = res.x[0] station[stnp.cr_azimuth] = hp.get_normalized_angle(res.x[1]) if (self.__debug): # calculate residuals t_exp = get_expected_times(res.x, positions) from matplotlib import pyplot as plt fig, ax = plt.subplots(1, 1) ax.errorbar(channels_to_use, ((times - times.mean()) - (t_exp - t_exp.mean())) / units.ns, fmt='o', yerr=times_error / units.ns) ax.set_xlabel("channel id") ax.set_ylabel(r"$t_\mathrm{meas} - t_\mathrm{exp}$ [ns]") pass