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 calculate_polarization_vector(launch_vector, shower_axis): """ calculates the polarization vector in spherical coordinates (eR, eTheta, ePhi) """ polarization_direction = np.cross(launch_vector, np.cross(shower_axis, launch_vector)) polarization_direction /= np.linalg.norm(polarization_direction) cs = cstrans.cstrafo(*hp.cartesian_to_spherical(*launch_vector)) return cs.transform_from_ground_to_onsky(polarization_direction)
def find_receiving_zenith(self, station, ray_type, channel_id): solution_types = {1: 'direct', 2: 'refracted', 3: 'reflected'} nu_vertex_2D = station.get_parameter(stnp.vertex_2D_fit) nu_vertex = [nu_vertex_2D[0], 0, nu_vertex_2D[1]] ray_tracer = NuRadioMC.SignalProp.analyticraytracing.ray_tracing( nu_vertex, self.__detector.get_relative_position(station.get_id(), channel_id) + self.__detector.get_absolute_position(station.get_id()), NuRadioMC.utilities.medium.get_ice_model('greenland_simple') ) ray_tracer.find_solutions() for i_solution, solution in enumerate(ray_tracer.get_results()): if solution_types[ray_tracer.get_solution_type(i_solution)] == ray_type: receive_vector = ray_tracer.get_receive_vector(i_solution) receive_zenith = hp.cartesian_to_spherical(receive_vector[0], receive_vector[1], receive_vector[2])[0] travel_time = ray_tracer.get_travel_time(i_solution) return receive_zenith, travel_time return None, None
def dump(filename): print(f"!!!!!!!!!!!! dumping relevant file content of {filename}:!!!!!!!!!!!!!!!") fin = h5py.File(filename, 'r') stations = [] for key in fin.keys(): if(key.startswith("station_")): stations.append(key) event_group_ids = np.array(fin['event_group_ids']) for iE, evt_gid in enumerate(event_group_ids): t = "index, " for key in keys_event: t += f"{key}, " print(t) t = f"{iE} " for key in keys_event: t += f"{fin[key][iE]} " print(t) t = "stationid, channelid, rayid, " for key in station_keys: t += f"{key}, " for key in station_keys_3dim: t += f"{key}, " t += f" zen, az" print(t) for station in stations: if not 'ray_tracing_C0' in station: print(f'{station} has not entries') continue nCh, nR = np.array(fin[station]['ray_tracing_C0'][iE]).shape for iCh in range(nCh): for iR in range(nR): t = f"\t{station} {iCh} {iR}: " for key in station_keys: t += f"{fin[station][key][iE][iCh][iR]:.9g} " for key in station_keys_3dim: t += "(" for iD in range(3): t += f"{fin[station][key][iE][iCh][iR][iD]:.5g}," t += ") " zen, az = hp.cartesian_to_spherical(*np.array(fin[station]["receive_vectors"][iE][iCh][iR])) t += f" {zen/units.deg:.2f} {az/units.deg:.2f}" print(t)
def run_nu_kernel(self, frame): # we'll need an array of frequencies at which we'll calculate attens etc # declare it here so we don't wast time declaring it over and over again ff = np.fft.rfftfreq(self._n_samples, self._dt) # get the list of particles from the *thinned* mctree if 'I3MCTreeThin' not in frame: icetray.logging.log_fatal('Frame does not contain the thinned tree I3MCTreeThin \nPlease tray.AddModule(TreeThinner) first!') mctree = frame.Get('I3MCTreeThin') primary = mctree.primaries[0] num_particles = len(mctree) if num_particles == 1: icetray.logging.log_info("There are no children of the primary") # load the list of antennas antgeomap = self.antgeomap # for every particle, we create a map between the particle ID and the I3RadioMCSummary particle_radio_mc_map = icetradio.I3ParticleRadioMCSummaryMap() # now, we loop over every particle, and every antenna, and do ray tracing for particle in mctree: # skip the primary if particle == primary: continue # time of the vertex in nanoseconds vertex_time = particle.time # get the source (vertex) position, and move it into surface oriented coordinates source = particle.pos source = util_geo.convert_i3_to_global(source) # for this particle, we need a map between the particle id and the signal iceantenna_radio_mc_map = icetradio.I3IceAntennaRadioMCSummaryMap() # where it's GOING # in I3Position format (not simple numpy array) # so that we are uniform between shower_axis and launch_vector shower_axis = dataclasses.I3Position(particle.dir.x, particle.dir.y, particle.dir.z) deposited_energy = particle.energy / icetray.I3Units.eV # in eV! shower_type = particle.type em_or_had = util_phys.pick_em_or_had(shower_type) if em_or_had is 'UDEF': icetray.logging.log_warn("A particle ({}) has an undefined type. Skipping it.".format(shower_type)) continue n_index = self.ice.get_index_of_refraction(source) for iceantkey, g in antgeomap: # need a radio mc summary object radio_mc_summary = icetradio.I3RadioMCSummary() # get the target (antenna) position, and move it into surface oriented coordinates target = g.position target = util_geo.convert_i3_to_global(target) # do ray tracing record, attens = signal_prop.do_ray_tracing( propagator=self.propagator, ice_model=self.ice, attenuation_model=self._att_model, source=source, target=target, ff=ff, sampling_rate=self._sampling_rate ) # store the ray trace record radio_mc_summary.ray_trace_record = record # now, do signals for iS in range(record.numSolutions): # the time this field arrives at the antenna is the sum # of the time of the vertex and the propagation time # this is a value in ns, so we have to convert to seconds # when we pass it to the signal generator arrival_time = vertex_time + record.solutions[iS].travelTime signal = signal_gen.generate_signal( deposited_energy=deposited_energy, shower_axis=shower_axis, em_or_had=em_or_had, launch_vector=record.solutions[iS].launchVector, distance=record.solutions[iS].pathLength, arrival_time=arrival_time / icetray.I3Units.s, n_index=n_index, attenuation_values=attens[iS], dt=self._dt, n_samples=self._n_samples, model=self._askaryan_model, seed=self._seed, ) # convert the arrival information into a theta and phi for the signal local_recieve_vector = util_dataclasses.i3pos_to_np(record.solutions[iS].receiveVector) theta, phi = hp.cartesian_to_spherical(*local_recieve_vector) signal.arrival_theta = theta * icetray.I3Units.rad signal.arrival_phi = phi * icetray.I3Units.rad # finish filling out the signal container signal.sol_num = record.solutions[iS].solutionNumber signal.sol_type = record.solutions[iS].solutionType # append the signal radio_mc_summary.signals.append(signal) # now, put this radio mc summary into the map for this vertex iceantenna_radio_mc_map[iceantkey] = radio_mc_summary # now, for this particle, we store the map of radio truths particle_radio_mc_map[particle.id] = iceantenna_radio_mc_map # now, this gets stored in the frame if(len(particle_radio_mc_map)>0): # only store the frame if one of the daughter particles actually contributed frame.Put("ParticleRadioMCSummaryMap",particle_radio_mc_map)
for i in range(flav.size): if (flav[i]): receive_vectors = np.append(receive_vectors, [rvtemp[i]], axis=0) weightstemp = np.append(weightstemp, weights[i]) # print("--------------------------") # print(rvtemp[0]) # print("----------") # print(receive_vectors[0]) # print("--------------------------") receive_vectors = np.delete(receive_vectors, 0, axis=0) # receive_vectors = np.array(station['receive_vectors'])[triggered] # for all events, antennas and ray tracing solutions zeniths, azimuths = hp.cartesian_to_spherical(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(weightstemp, 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) fig, axs = php.get_histograms([zeniths[mask] / units.deg, azimuths[mask] / units.deg], bins=[np.arange(0, 181, 5), np.arange(0, 361, 45)], xlabels=['zenith [deg]', 'azimuth [deg]'], weights=weights_matrix[mask], stats=False) # axs[0].xaxis.set_ticks(np.arange(0, 181, 45)) majorLocator = MultipleLocator(45) majorFormatter = FormatStrFormatter('%d') minorLocator = MultipleLocator(5)
ax.plot(x1[0], x1[2], 'ko') for i, x in enumerate([x2, x3, x4, x5]): print('finding solutions for ', x) r = ray.ray_tracing(x1,x,ice) r.find_solutions() if(r.has_solution()): for iS in range(r.get_number_of_solutions()): ray_tracing_C0[i, iS] = r.get_results()[iS]['C0'] ray_tracing_solution_type[i, iS] = r.get_solution_type(iS) print(" Solution %d, Type %d: "%(iS,ray_tracing_solution_type[i, iS])) R = r.get_path_length(iS) # calculate path length T = r.get_travel_time(iS) # calculate travel time print(" Ray Distance %.3f and Travel Time %.3f"%(R/units.m,T/units.ns)) receive_vector = r.get_receive_vector(iS) receive_vectors[i, iS] = receive_vector zenith, azimuth = hp.cartesian_to_spherical(*receive_vector) print(" Receiving Zenith %.3f and Azimuth %.3f "%(zenith/units.deg, azimuth/units.deg)) #to readout the actual trace, we have to flatten to 2D dX = x - x1 dPhi = -np.arctan2(dX[1],dX[0]) c,s = np.cos(dPhi), np.sin(dPhi) R = np.array(((c,-s,0),(s,c,0),(0,0,1))) X1r = x1 X2r = np.dot(R, x-x1) + x1 x1_2d = np.array([X1r[0],X1r[2]]) x2_2d = np.array([X2r[0],X2r[2]]) r_2d = ray.ray_tracing_2D(ice) yy,zz = r_2d.get_path(x1_2d,x2_2d,ray_tracing_C0[i, iS]) ax.plot(yy, zz, '{}'.format(php.get_color_linestyle(i)), label='{} C0 = {:.4f}'.format(ray_tracing_solution_type[i,iS], ray_tracing_C0[i,iS])) ax.plot(x2_2d[0], x2_2d[1], '{}{}-'.format('d',php.get_color(i)))
continue # 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,
def __draw_search_zones(self, event, slope, offset, line_fit_d, line_fit_z, min_z_offset, max_z_offset, i_max_d, i_max_z, corr_mask_d, corr_mask_z, z_fit, i_max_theta, theta_corr_mask, median_theta): fig5 = plt.figure(figsize=(8, 8)) ax5_1_1 = fig5.add_subplot(221) ax5_1_1.grid() ax5_1_2 = fig5.add_subplot(222) ax5_1_2.grid() ax5_1_1.fill_between( self.__distances_2d, self.__distances_2d * slope + offset + 1.1 * max_z_offset, self.__distances_2d * slope + offset - 1.1 * min_z_offset, color='k', alpha=.2) ax5_1_1.scatter(self.__distances_2d[corr_mask_d], self.__z_coordinates_2d[i_max_d][corr_mask_d]) ax5_1_1.scatter(self.__distances_2d[~corr_mask_d], self.__z_coordinates_2d[i_max_d][~corr_mask_d], c='k', alpha=.5) ax5_1_1.plot(self.__distances_2d, self.__distances_2d * slope + offset, color='k', linestyle=':') ax5_1_1.fill_between( self.__distances_2d, self.__distances_2d * slope + offset + 1.1 * max_z_offset, self.__distances_2d * slope + offset - 1.1 * min_z_offset, color='k', alpha=.2) ax5_1_1.plot(self.__distances_2d, self.__distances_2d * line_fit_d[0] + line_fit_d[1], color='r', linestyle=':') ax5_1_1.fill_between(self.__distances_2d, self.__distances_2d * line_fit_d[0] + line_fit_d[1] + 1.1 * max_z_offset, self.__distances_2d * line_fit_d[0] + line_fit_d[1] - 1.1 * min_z_offset, color='r', alpha=.2) ax5_1_2.scatter(self.__distances_2d[i_max_z][corr_mask_z], self.__z_coordinates_2d[corr_mask_z]) ax5_1_2.scatter(self.__distances_2d[i_max_z][~corr_mask_z], self.__z_coordinates_2d[~corr_mask_z], c='k', alpha=.5) ax5_1_2.plot(self.__distances_2d, self.__distances_2d * slope + offset, color='k', linestyle=':') ax5_1_2.plot(self.__distances_2d, self.__distances_2d * line_fit_z[0] + line_fit_z[1], color='r', linestyle=':') ax5_1_2.fill_between(self.__distances_2d, self.__distances_2d * line_fit_z[0] + line_fit_z[1] + 1.1 * max_z_offset, self.__distances_2d * line_fit_z[0] + line_fit_z[1] - 1.1 * min_z_offset, color='r', alpha=.2) ax5_1_2.plot(self.__distances_2d, self.__distances_2d * slope + offset, color='k', linestyle=':') ax5_1_2.fill_between( self.__distances_2d, self.__distances_2d * slope + offset + 1.1 * max_z_offset, self.__distances_2d * slope + offset - 1.1 * min_z_offset, color='k', alpha=.2) if z_fit: ax5_2 = fig5.add_subplot(2, 2, (3, 4)) ax5_2.grid() else: ax5_2 = fig5.add_subplot(2, 2, (3, 4), projection='polar') if z_fit: ax5_2.scatter(self.__azimuths_2d[i_max_theta][theta_corr_mask], np.abs(self.__z_coordinates_2d)[theta_corr_mask]) ax5_2.scatter(self.__azimuths_2d[i_max_theta][~theta_corr_mask], np.abs(self.__z_coordinates_2d)[~theta_corr_mask], c='k', alpha=.5) ax5_2.plot([median_theta, median_theta], [ np.abs(self.__z_coordinates_2d[0]), np.abs(self.__z_coordinates_2d[-1]) ], color='k', linestyle=':') else: ax5_2.scatter(self.__azimuths_2d[i_max_theta][theta_corr_mask], self.__distances_2d[theta_corr_mask]) ax5_2.scatter(self.__azimuths_2d[i_max_theta][~theta_corr_mask], self.__distances_2d[~theta_corr_mask], c='k', alpha=.5) ax5_2.plot([median_theta, median_theta], [self.__distances_2d[0], self.__distances_2d[-1]], color='k', linestyle=':') 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: ax5_1_1.axhline(sim_vertex[2], color='r', linestyle='--', alpha=.5) ax5_1_1.axvline(np.sqrt(sim_vertex[0]**2 + sim_vertex[1]**2), color='r', linestyle='--', alpha=.5) ax5_1_2.axhline(sim_vertex[2], color='r', linestyle='--', alpha=.5) ax5_1_2.axvline(np.sqrt(sim_vertex[0]**2 + sim_vertex[1]**2), color='r', linestyle='--', alpha=.5) ax5_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='+') ax5_1_1.set_xlabel('d [m]') ax5_1_2.set_xlabel('d [m]') ax5_1_1.set_ylabel('z [m]') ax5_1_2.set_ylabel('z [m]') if z_fit: ax5_2.set_xlabel(r'$\phi [^\circ]$') ax5_2.set_ylabel('|z| [m]') fig5.tight_layout() fig5.savefig('{}/{}_{}_search_zones.png'.format( self.__debug_folder, event.get_run_number(), event.get_id()))