def _detector_simulation(self):
calculateAmplitudePerRaySolution.run(self._evt, self._station, self._det)
# save the amplitudes to output hdf5 file
# save amplitudes per ray tracing solution to hdf5 data output
if('max_amp_ray_solution' not in self._mout):
self._mout['max_amp_ray_solution'] = np.zeros((self._n_events, self._n_antennas, 2)) * np.nan
# for sim_channel in self._station.get_sim_station().iter_channels():
for sim_channel in self._station.iter_channels():
for iCh2, sim_channel2 in enumerate(sim_channel):
channel_id = sim_channel2.get_id()
self._mout['max_amp_ray_solution'][self._iE, channel_id, iCh2] = sim_channel2.get_parameter(
chp.maximum_amplitude_envelope)
self._increase_signal(0, 8**0.5)
self._increase_signal(1, 8**0.5)
self._increase_signal(2, 8**0.5)
# start detector simulation
# efieldToVoltageConverterPerChannel.run(self._evt, self._station, self._det) # convolve efield with antenna pattern
efieldToVoltageConverter.run(self._evt, self._station, self._det) # convolve efield with antenna pattern
if(bool(self._cfg['signal']['zerosignal'])):
self._increase_signal(None, 0)
if bool(self._cfg['noise']):
Vrms = self._Vrms / self._bandwidth * 2 * units.GHz # normalize noise level to the bandwidth its generated for
channelGenericNoiseAdder.run(self._evt, self._station, self._det, amplitude=Vrms, min_freq=0 * units.MHz,
max_freq=2 * units.GHz, type='rayleigh')
channelBandPassFilter.run(self._evt, self._station, self._det, filter_type='NTU+cheb')
triggerSimulator.run(self._evt, self._station, self._det,
threshold=4.24 * self._Vrms,
triggered_channels=[0, 1, 2, 3, 4, 5], # run trigger on all channels
number_concidences=3,
trigger_name='simple_threshold') # the name of the trigger
def _detector_simulation(self):
# start detector simulation
efieldToVoltageConverter.run(self._evt, self._station, self._det) # convolve efield with antenna pattern
# downsample trace to internal simulation sampling rate (the efieldToVoltageConverter upsamples the trace to
# 20 GHz by default to achive a good time resolution when the two signals from the two signal paths are added)
channelResampler.run(self._evt, self._station, self._det, sampling_rate=1. / self._dt)
if self._is_simulate_noise():
max_freq = 0.5 / self._dt
norm = self._get_noise_normalization(self._station.get_id()) # assuming the same noise level for all stations
Vrms = self._Vrms / (norm / (max_freq)) ** 0.5 # normalize noise level to the bandwidth its generated for
channelGenericNoiseAdder.run(self._evt, self._station, self._det, amplitude=Vrms, min_freq=0 * units.MHz,
max_freq=max_freq, type='rayleigh')
# bandpass filter trace, the upper bound is higher then the sampling rate which makes it just a highpass filter
channelBandPassFilter.run(self._evt, self._station, self._det, passband=[80 * units.MHz, 500 * units.MHz],
filter_type='butter', order=10)
triggerSimulator.run(self._evt, self._station, self._det,
threshold=1 * self._Vrms,
triggered_channels=[0, 1, 2, 3],
number_concidences=1,
trigger_name='pre_trigger_1sigma')
# downsample trace back to detector sampling rate
channelResampler.run(self._evt, self._station, self._det, sampling_rate=self._sampling_rate_detector)
def _detector_simulation(self):
# start detector simulation
if (bool(self._cfg['signal']['zerosignal'])):
self._increase_signal(None, 0)
efieldToVoltageConverter.run(
self._evt, self._station,
self._det) # convolve efield with antenna pattern
# downsample trace to internal simulation sampling rate (the efieldToVoltageConverter upsamples the trace to
# 20 GHz by default to achive a good time resolution when the two signals from the two signal paths are added)
channelResampler.run(self._evt,
self._station,
self._det,
sampling_rate=1. / self._dt)
if bool(self._cfg['noise']):
Vrms = self._Vrms / (
self._bandwidth / (2.5 * units.GHz)
)**0.5 # normalize noise level to the bandwidth its generated for
channelGenericNoiseAdder.run(self._evt,
self._station,
self._det,
amplitude=Vrms,
min_freq=0 * units.MHz,
max_freq=2.5 * units.GHz,
type='rayleigh')
# bandpass filter trace, the upper bound is higher then the sampling rate which makes it just a highpass filter
channelBandPassFilter.run(self._evt,
self._station,
self._det,
passband=[80 * units.MHz, 1000 * units.GHz],
filter_type='butter',
order=2)
channelBandPassFilter.run(self._evt,
self._station,
self._det,
passband=[0, 500 * units.MHz],
filter_type='butter',
order=10)
# first run a simple threshold trigger
simpleThreshold.run(
self._evt,
self._station,
self._det,
threshold=3 * self._Vrms,
triggered_channels=None, # run trigger on all channels
number_concidences=1,
trigger_name='simple_threshold') # the name of the trigger
"""
channelResampler = NuRadioReco.modules.channelResampler.channelResampler()
channelResampler.begin()
eventWriter = NuRadioReco.modules.io.eventWriter.eventWriter()
output_filename = "MC_example_station_{}.nur".format(station_id)
eventWriter.begin(output_filename)
# Loop over all events in file as initialized in readCoRREAS and perform analysis
for iE, evt in enumerate(readCoREAS.run(detector=det)):
logger.info("processing event {:d} with id {:d}".format(iE, evt.get_id()))
station = evt.get_station(station_id)
station.set_station_time(astropy.time.Time('2019-01-01T00:00:00'))
det.update(station.get_station_time())
if simulationSelector.run(evt, station.get_sim_station(), det):
efieldToVoltageConverter.run(evt, station, det)
hardwareResponseIncorporator.run(evt, station, det, sim_to_data=True)
channelGenericNoiseAdder.run(evt,
station,
det,
type="rayleigh",
amplitude=20 * units.mV)
triggerSimulator.run(evt,
station,
det,
number_concidences=2,
threshold=100 * units.mV)
'If set, the run number and event id will be set to an increasing value.')
args = parser.parse_args()
# initialize modules
det = detector.GenericDetector(json_filename=args.detectordescription,
default_station=102,
default_channel=0)
readCoREASShower = NuRadioReco.modules.io.coreas.readCoREASShower.readCoREASShower(
)
readCoREASShower.begin(args.inputfilename,
det,
set_ascending_run_and_event_number=args.set_run_number)
efieldToVoltageConverter = NuRadioReco.modules.efieldToVoltageConverter.efieldToVoltageConverter(
)
efieldToVoltageConverter.begin()
eventTypeIdentifier = NuRadioReco.modules.eventTypeIdentifier.eventTypeIdentifier(
)
eventWriter = NuRadioReco.modules.io.eventWriter.eventWriter()
eventWriter.begin(args.output_filename)
for event, gen_det in readCoREASShower.run():
print('Event {} {}'.format(event.get_run_number(), event.get_id()))
for station in event.get_stations():
eventTypeIdentifier.run(event, station, 'forced', 'cosmic_ray')
efieldToVoltageConverter.run(event, station, gen_det)
eventWriter.run(event, gen_det)
nevents = eventWriter.end()
print("Finished processing, {} events".format(nevents))
def _detector_simulation_part2(self):
# start detector simulation
efieldToVoltageConverter.run(
self._evt, self._station,
self._det) # convolve efield with antenna pattern
# downsample trace to 1.5 Gs/s
new_sampling_rate = 1.5 * units.GHz
channelResampler.run(self._evt,
self._station,
self._det,
sampling_rate=new_sampling_rate)
cut_times = get_window_around_maximum(self._station)
# Bool for checking the noise triggering rate
check_only_noise = False
if check_only_noise:
for channel in self._station.iter_channels():
trace = channel.get_trace() * 0
channel.set_trace(trace, sampling_rate=new_sampling_rate)
if self._is_simulate_noise():
max_freq = 0.5 / self._dt
norm = self._get_noise_normalization(self._station.get_id(
)) # assuming the same noise level for all stations
channelGenericNoiseAdder.run(self._evt,
self._station,
self._det,
amplitude=self._Vrms,
min_freq=0 * units.MHz,
max_freq=max_freq,
type='rayleigh',
bandwidth=norm)
# bandpass filter trace, the upper bound is higher then the sampling rate which makes it just a highpass filter
channelBandPassFilter.run(self._evt,
self._station,
self._det,
passband=[130 * units.MHz, 1000 * units.GHz],
filter_type='butter',
order=6)
channelBandPassFilter.run(self._evt,
self._station,
self._det,
passband=[0, 750 * units.MHz],
filter_type='butter',
order=10)
# run the phased trigger
triggerSimulator.run(
self._evt,
self._station,
self._det,
threshold=2.5 *
self._Vrms, # see phased trigger module for explanation
triggered_channels=None, # run trigger on all channels
secondary_channels=[0, 1, 3, 4, 6, 7], # secondary channels
trigger_name=
'primary_and_secondary_phasing', # the name of the trigger
coupled=True,
cut_times=cut_times)
def _detector_simulation_part2(self):
# Start detector simulation
# Convolve efield with antenna pattern
efieldToVoltageConverter.run(self._evt, self._station, self._det)
# Downsample trace back to detector sampling rate
channelResampler.run(self._evt,
self._station,
self._det,
sampling_rate=new_sampling_rate)
# Filter signals
channelBandPassFilter.run(
self._evt,
self._station,
self._det,
passband=[0.0 * units.MHz, 240.0 * units.MHz],
filter_type='cheby1',
order=9,
rp=.1)
channelBandPassFilter.run(
self._evt,
self._station,
self._det,
passband=[80.0 * units.MHz, 230.0 * units.MHz],
filter_type='cheby1',
order=4,
rp=.1)
filtered_signal_traces = {}
for channel in self._station.iter_channels():
trace = np.array(channel.get_trace())
filtered_signal_traces[channel.get_id()] = trace
# Since there are often two traces within the same thing, gotta be careful
Vpps = np.zeros(self._station.get_number_of_channels())
for iChan, channel in enumerate(self._station.iter_channels()):
trace = np.array(channel.get_trace())
Vpps[iChan] = np.max(trace) - np.min(trace)
factor = 1.0 / (np.mean(Vpps) / 2.0)
mult_factors = factor * SNRs
has_triggered = True
while (has_triggered
): # search for noise traces that don't set off a trigger
# loop over all channels (i.e. antennas) of the station
for channel in self._station.iter_channels():
trace = np.zeros(
len(filtered_signal_traces[channel.get_id()][:]))
channel.set_trace(trace, sampling_rate=new_sampling_rate)
# Adding noise AFTER the SNR calculation
channelGenericNoiseAdder.run(self._evt,
self._station,
self._det,
amplitude=1.0 / Vrms_ratio,
min_freq=min_freq,
max_freq=max_freq,
type='rayleigh')
# bandpass filter trace, the upper bound is higher then the sampling rate which makes it just a highpass filter
channelBandPassFilter.run(
self._evt,
self._station,
self._det,
passband=[0 * units.MHz, 240.0 * units.MHz],
filter_type='cheby1',
order=9,
rp=.1)
channelBandPassFilter.run(
self._evt,
self._station,
self._det,
passband=[80.0 * units.MHz, 230.0 * units.MHz],
filter_type='cheby1',
order=4,
rp=.1)
if (phase):
has_triggered = triggerSimulator.run(
self._evt,
self._station,
self._det,
Vrms=1.0,
threshold=threshold,
triggered_channels=channels,
phasing_angles=phasing_angles,
ref_index=1.75,
trigger_name='primary_phasing',
trigger_adc=
False, # Don't have a seperate ADC for the trigger
clock_offset=np.random.uniform(0.0, 2.0),
adc_output='voltage', # output in volts
trigger_filter=None,
upsampling_factor=upsampling_factor,
window=window,
step=step)
else:
original_traces_ = self._station.get_channel(4).get_trace()
squared_mean, num_frames = triggerSimulator.power_sum(
coh_sum=original_traces_,
window=window,
step=step,
adc_output='voltage')
squared_mean_threshold = np.power(threshold, 2.0)
has_triggered = (True
in (squared_mean > squared_mean_threshold))
if (has_triggered):
print('Trigger on noise... ')
filtered_noise_traces = {}
for channel in self._station.iter_channels():
filtered_noise_traces[channel.get_id()] = channel.get_trace()
for factor, iSNR in zip(mult_factors, range(len(mult_factors))):
for channel in self._station.iter_channels():
trace = copy.deepcopy(
filtered_signal_traces[channel.get_id()][:]) * factor
noise = filtered_noise_traces[channel.get_id()]
channel.set_trace(trace + noise,
sampling_rate=new_sampling_rate)
if (phase):
has_triggered = triggerSimulator.run(
self._evt,
self._station,
self._det,
Vrms=1.0,
threshold=threshold,
triggered_channels=channels,
phasing_angles=phasing_angles,
ref_index=1.75,
trigger_name='primary_phasing',
trigger_adc=False,
clock_offset=np.random.uniform(0.0, 2.0),
adc_output='voltage',
trigger_filter=None,
upsampling_factor=upsampling_factor,
window=window,
step=step)
else:
original_traces_ = self._station.get_channel(4).get_trace()
squared_mean, num_frames = triggerSimulator.power_sum(
coh_sum=original_traces_,
window=window,
step=step,
adc_output='voltage')
squared_mean_threshold = np.power(threshold, 2.0)
has_triggered = (True
in (squared_mean > squared_mean_threshold))
if (has_triggered):
print('Trigger for SNR', SNRs[iSNR])
SNRtriggered[iSNR] += 1
count_events()
print(count_events.events)
print(SNRtriggered)
if (count_events.events % 10 == 0):
# plt.show()
# Save every ten triggers
output = {
'total_events': count_events.events,
'SNRs': list(SNRs),
'triggered': list(SNRtriggered)
}
outputfile = args.outputSNR
with open(outputfile, 'w+') as fout:
json.dump(output, fout, sort_keys=True, indent=4)
def _detector_simulation(self):
# start detector simulation
if (bool(self._cfg['signal']['zerosignal'])):
self._increase_signal(None, 0)
efieldToVoltageConverter.run(
self._evt, self._station,
self._det) # convolve efield with antenna pattern
# downsample trace to internal simulation sampling rate (the efieldToVoltageConverter upsamples the trace to
# 20 GHz by default to achive a good time resolution when the two signals from the two signal paths are added)
channelResampler.run(self._evt,
self._station,
self._det,
sampling_rate=1. / self._dt)
if bool(self._cfg['noise']):
Vrms = self._Vrms / (
self._bandwidth / (2.5 * units.GHz)
)**0.5 # normalize noise level to the bandwidth its generated for
channelGenericNoiseAdder.run(self._evt,
self._station,
self._det,
amplitude=Vrms,
min_freq=0 * units.MHz,
max_freq=2.5 * units.GHz,
type='rayleigh')
# bandpass filter trace, the upper bound is higher then the sampling rate which makes it just a highpass filter
channelBandPassFilter.run(self._evt,
self._station,
self._det,
passband=[80 * units.MHz, 1000 * units.GHz],
filter_type='butter',
order=2)
channelBandPassFilter.run(self._evt,
self._station,
self._det,
passband=[0, 500 * units.MHz],
filter_type='butter',
order=10)
# first run a simple threshold trigger
simpleThreshold.run(
self._evt,
self._station,
self._det,
threshold=3 * self._Vrms,
triggered_channels=None, # run trigger on all channels
number_concidences=1,
trigger_name='simple_threshold') # the name of the trigger
# run a high/low trigger on the 4 downward pointing LPDAs
highLowThreshold.run(
self._evt,
self._station,
self._det,
threshold_high=4 * self._Vrms,
threshold_low=-4 * self._Vrms,
triggered_channels=[0, 1, 2, 3], # select the LPDA channels
number_concidences=2, # 2/4 majority logic
trigger_name='LPDA_2of4_4.1sigma',
set_not_triggered=(
not self._station.has_triggered("simple_threshold"))
) # calculate more time consuming ARIANNA trigger only if station passes simple trigger
# run a high/low trigger on the 4 surface dipoles
highLowThreshold.run(
self._evt,
self._station,
self._det,
threshold_high=3 * self._Vrms,
threshold_low=-3 * self._Vrms,
triggered_channels=[4, 5, 6, 7], # select the bicone channels
number_concidences=4, # 4/4 majority logic
trigger_name='surface_dipoles_4of4_3sigma',
set_not_triggered=(
not self._station.has_triggered("simple_threshold"))
) # calculate more time consuming ARIANNA trigger only if station passes simple trigger
# downsample trace back to detector sampling rate
channelResampler.run(self._evt,
self._station,
self._det,
sampling_rate=self._sampling_rate_detector)