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