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
"""
def _detector_simulation_trigger(self, evt, station, det):
original_traces = {}
for channel in station.iter_channels():
trace = np.array(channel.get_trace())
original_traces[channel.get_id()] = trace
# channel 8 is a noiseless channel at 100m depth
simpleThreshold.run(
evt,
station,
det,
threshold=3 * self._Vrms_per_channel[station.get_id()][8],
triggered_channels=[8], # run trigger on all channels
number_concidences=1,
trigger_name=f'dipole_3.0sigma')
simpleThreshold.run(
evt,
station,
det,
threshold=2.5 * self._Vrms_per_channel[station.get_id()][8],
triggered_channels=[8], # run trigger on all channels
number_concidences=1,
trigger_name=f'dipole_2.5sigma')
simpleThreshold.run(
evt,
station,
det,
threshold=2.0 * self._Vrms_per_channel[station.get_id()][8],
triggered_channels=[8], # run trigger on all channels
number_concidences=1,
trigger_name=f'dipole_2.0sigma')
simpleThreshold.run(
evt,
station,
det,
threshold=1.5 * self._Vrms_per_channel[station.get_id()][8],
triggered_channels=[8], # run trigger on all channels
number_concidences=1,
trigger_name=f'dipole_1.5sigma')
simpleThreshold.run(
evt,
station,
det,
threshold=1.0 * self._Vrms_per_channel[station.get_id()][8],
triggered_channels=[8], # run trigger on all channels
number_concidences=1,
trigger_name=f'dipole_1.0sigma')
# Trigger windows
Vrms = self._Vrms_per_channel[station.get_id()][4]
resample = self._cfg[
'sampling_rate'] * units.GHz # Old name, just the MC clock frequency
# x2 for upsampling
window_4ant = int(16 * units.ns * self._sampling_rate_detector * 2.0)
step_4ant = int(8 * units.ns * self._sampling_rate_detector * 2.0)
# x4 for upsampling
window_8ant = int(16 * units.ns * self._sampling_rate_detector * 4.0)
step_8ant = int(8 * units.ns * self._sampling_rate_detector * 4.0)
# Seperately add noise, filter it, then add filtered signal back in
filtered_signal_traces = {}
for channel in station.iter_channels():
trace = np.array(channel.get_trace())
filtered_signal_traces[channel.get_id()] = trace
channel.set_trace(np.zeros(len(trace)), sampling_rate=resample)
channelGenericNoiseAdder.run(evt,
station,
det,
amplitude=Vrms / 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(evt,
station,
det,
passband=[0 * units.MHz, 235.0 * units.MHz],
filter_type='cheby1',
order=9,
rp=.1)
channelBandPassFilter.run(
evt,
station,
det,
passband=[87.0 * units.MHz, 225.0 * units.MHz],
filter_type='cheby1',
order=4,
rp=.1)
for channel in station.iter_channels():
trace = copy.deepcopy(filtered_signal_traces[channel.get_id()][:])
noise = channel.get_trace()
channel.set_trace(trace + noise, sampling_rate=resample)
# run the 4 phased trigger
phasedArrayTrigger.run(
evt,
station,
det,
Vrms=Vrms,
threshold=1.95 * np.power(Vrms, 2.0) *
window_8ant, # see phased trigger module for explanation
triggered_channels=range(0, 8),
phasing_angles=phasing_angles_8ant,
ref_index=1.75,
trigger_name=f'PA_8channel_100Hz', # the name of the trigger
trigger_adc=False, # Don't have a seperate ADC for the trigger
adc_output=f'voltage', # output in volts
trigger_filter=None,
upsampling_factor=4,
window=window_8ant,
step=step_8ant)
# run the 4 phased trigger
phasedArrayTrigger.run(
evt,
station,
det,
Vrms=Vrms,
threshold=1.89 * np.power(Vrms, 2.0) * window_4ant,
triggered_channels=range(2, 6),
phasing_angles=phasing_angles_4ant,
ref_index=1.75,
trigger_name=f'PA_4channel_100Hz', # the name of the trigger
trigger_adc=False, # Don't have a seperate ADC for the trigger
adc_output=f'voltage', # output in volts
trigger_filter=None,
upsampling_factor=2,
window=window_4ant,
step=step_4ant)
for channel in station.iter_channels():
channel.set_trace(original_traces[channel.get_id()], resample)
# downsample trace back to detector sampling rate
resample = self._sampling_rate_detector
channelResampler.run(evt, station, det, sampling_rate=resample)
# channel 8 is a noiseless channel at 100m depth
simpleThreshold.run(
evt,
station,
det,
threshold=3 * self._Vrms_per_channel[station.get_id()][8],
triggered_channels=[8], # run trigger on all channels
number_concidences=1,
trigger_name=f'dipole_3.0sigma_500MHz')
simpleThreshold.run(
evt,
station,
det,
threshold=2.5 * self._Vrms_per_channel[station.get_id()][8],
triggered_channels=[8], # run trigger on all channels
number_concidences=1,
trigger_name=f'dipole_2.5sigma_500Mhz')
simpleThreshold.run(
evt,
station,
det,
threshold=2.0 * self._Vrms_per_channel[station.get_id()][8],
triggered_channels=[8], # run trigger on all channels
number_concidences=1,
trigger_name=f'dipole_2.0sigma_500Mhz')
simpleThreshold.run(
evt,
station,
det,
threshold=1.5 * self._Vrms_per_channel[station.get_id()][8],
triggered_channels=[8], # run trigger on all channels
number_concidences=1,
trigger_name=f'dipole_1.5sigma_500Mhz')
simpleThreshold.run(
evt,
station,
det,
threshold=1.0 * self._Vrms_per_channel[station.get_id()][8],
triggered_channels=[8], # run trigger on all channels
number_concidences=1,
trigger_name=f'dipole_1.0sigma_500Mhz')
filtered_signal_traces = {}
for channel in station.iter_channels():
trace = np.array(channel.get_trace())
filtered_signal_traces[channel.get_id()] = trace
channel.set_trace(np.zeros(len(trace)), sampling_rate=resample)
channelGenericNoiseAdder.run(evt,
station,
det,
amplitude=Vrms / Vrms_ratio,
min_freq=min_freq,
max_freq=max_freq,
type='rayleigh')
channelBandPassFilter.run(evt,
station,
det,
passband=[0 * units.MHz, 235.0 * units.MHz],
filter_type='cheby1',
order=9,
rp=.1)
channelBandPassFilter.run(
evt,
station,
det,
passband=[87.0 * units.MHz, 225.0 * units.MHz],
filter_type='cheby1',
order=4,
rp=.1)
for channel in station.iter_channels():
trace = copy.deepcopy(filtered_signal_traces[channel.get_id()][:])
noise = channel.get_trace()
channel.set_trace(trace + noise, sampling_rate=resample)
phasedArrayTrigger.run(
evt,
station,
det,
Vrms=Vrms,
threshold=1.95 * np.power(Vrms, 2.0) *
window_8ant, # see phased trigger module for explanation
triggered_channels=range(0, 8),
phasing_angles=phasing_angles_8ant,
ref_index=1.75,
trigger_name=f'PA_8channel_100Hz_500MHz', # the name of the trigger
trigger_adc=False, # Don't have a seperate ADC for the trigger
adc_output=f'voltage', # output in volts
trigger_filter=None,
upsampling_factor=4,
window=window_8ant,
step=step_8ant)
# run the 4 phased trigger
phasedArrayTrigger.run(
evt,
station,
det,
Vrms=Vrms,
threshold=1.89 * np.power(Vrms, 2.0) * window_4ant,
triggered_channels=range(2, 6),
phasing_angles=phasing_angles_4ant,
ref_index=1.75,
trigger_name=f'PA_4channel_100Hz_500MHz', # the name of the trigger
trigger_adc=False, # Don't have a seperate ADC for the trigger
adc_output=f'voltage', # output in volts
trigger_filter=None,
upsampling_factor=2,
window=window_4ant,
step=step_4ant)
channel_pairs=channel_pairs)
voltageToEfieldConverter.run(evt,
station,
det,
use_channels=used_channels_efield)
electricFieldSignalReconstructor.run(evt, station, det)
voltageToAnalyticEfieldConverter.run(
evt,
station,
det,
use_channels=used_channels_efield,
bandpass=[80 * units.MHz, 500 * units.MHz],
use_MC_direction=False)
channelResampler.run(evt,
station,
det,
sampling_rate=1 * units.GHz)
electricFieldResampler.run(evt,
station,
det,
sampling_rate=1 * units.GHz)
eventWriter.run(evt, det)
nevents = eventWriter.end()
print("Finished processing, {} events".format(nevents))
def _detector_simulation(self):
# start detector simulation
efieldToVoltageConverterPerChannel.run(
self._evt, self._station,
self._det) # convolve efield with antenna pattern
# downsample trace back to detector sampling rate
channelResampler.run(self._evt,
self._station,
self._det,
sampling_rate=1. / self._dt)
# 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.MHz],
filter_type='butter10')
triggerSimulator.run(
self._evt,
self._station,
self._det,
threshold=3 * self._Vrms,
# triggered_channels=None,
triggered_channels=[0, 1, 2, 3, 4, 5, 6, 7],
# triggered_channels=[0, 1, 2, 3],
number_concidences=1,
trigger_name='simple_threshold')
triggerSimulatorARIANNA.run(
self._evt,
self._station,
self._det,
threshold_high=3 * self._Vrms,
threshold_low=-3 * self._Vrms,
triggered_channels=[0, 1, 2, 3, 4, 5, 6, 7],
number_concidences=3,
cut_trace=False,
trigger_name='high_low_3of8',
set_not_triggered=(
not self._station.has_triggered("simple_threshold"))
) # calculate more time consuming ARIANNA trigger only if station passes simple trigger
triggerSimulatorARIANNA.run(
self._evt,
self._station,
self._det,
threshold_high=3 * self._Vrms,
threshold_low=-3 * self._Vrms,
triggered_channels=[0, 1, 2, 3, 4, 5, 6, 7],
number_concidences=2,
cut_trace=False,
trigger_name='high_low_2of8',
set_not_triggered=(
not self._station.has_triggered("simple_threshold"))
) # calculate more time consuming ARIANNA trigger only if station passes simple trigger
triggerSimulatorARIANNA.run(
self._evt,
self._station,
self._det,
threshold_high=3 * self._Vrms,
threshold_low=-3 * self._Vrms,
triggered_channels=[0, 1, 2, 3, 12, 13, 14, 15],
number_concidences=3,
cut_trace=False,
trigger_name='high_low_2of8_LPDAs',
set_not_triggered=(
not self._station.has_triggered("simple_threshold"))
) # calculate more time consuming ARIANNA trigger only if station passes simple trigger
triggerSimulatorARIANNA.run(
self._evt,
self._station,
self._det,
threshold_high=3 * self._Vrms,
threshold_low=-3 * self._Vrms,
triggered_channels=[0, 1, 2, 3],
number_concidences=2,
cut_trace=False,
trigger_name='high_low_2of4_LPDA',
set_not_triggered=(
not self._station.has_triggered("simple_threshold"))
) # calculate more time consuming ARIANNA trigger only if station passes simple trigger
triggerSimulatorARIANNA.run(
self._evt,
self._station,
self._det,
threshold_high=3 * self._Vrms,
threshold_low=-3 * self._Vrms,
triggered_channels=[4, 5, 6, 7],
number_concidences=4,
cut_trace=False,
trigger_name='high_low_4of4_dipoles',
set_not_triggered=(
not self._station.has_triggered("simple_threshold"))
) # calculate more time consuming ARIANNA trigger only if station passes simple trigger
triggerSimulatorARIANNA.run(self._evt,
self._station,
self._det,
threshold_high=3 * self._Vrms,
threshold_low=-3 * self._Vrms,
triggered_channels=[8, 9, 10, 11],
number_concidences=2,
cut_trace=False,
trigger_name='high_low_2of4_deep_dipoles')
triggerSimulatorARIANNA.run(
self._evt,
self._station,
self._det,
threshold_high=3 * self._Vrms,
threshold_low=-3 * self._Vrms,
triggered_channels=[0, 1, 2, 3, 4, 5, 6, 7],
number_concidences=6,
cut_trace=False,
trigger_name='high_low_6of8_3sigma',
set_not_triggered=(
not self._station.has_triggered("simple_threshold"))
) # calculate more time consuming ARIANNA trigger only if station passes simple trigger
triggerSimulatorARIANNA.run(
self._evt,
self._station,
self._det,
threshold_high=4 * self._Vrms,
threshold_low=-4 * self._Vrms,
triggered_channels=[0, 1, 2, 3],
number_concidences=2,
cut_trace=False,
trigger_name='high_low_2of4_LPDA_4sigma',
set_not_triggered=(
not self._station.has_triggered("simple_threshold"))
) # calculate more time consuming ARIANNA trigger only if station passes simple trigger
triggerSimulatorARIANNA.run(
self._evt,
self._station,
self._det,
threshold_high=3.3 * self._Vrms,
threshold_low=-3.3 * self._Vrms,
triggered_channels=[0, 1, 2, 3],
number_concidences=4,
cut_trace=False,
trigger_name='high_low_4of4_LPDA_3.3sigma',
set_not_triggered=(
not self._station.has_triggered("simple_threshold"))
) # calculate more time consuming ARIANNA trigger only if station passes simple trigger
triggerSimulatorARIANNA.run(
self._evt,
self._station,
self._det,
threshold_high=3.3 * self._Vrms,
threshold_low=-3.3 * self._Vrms,
triggered_channels=[4, 5, 6, 7],
number_concidences=4,
cut_trace=False,
trigger_name='high_low_4of4_3.3sigma',
set_not_triggered=(
not self._station.has_triggered("simple_threshold"))
) # calculate more time consuming ARIANNA trigger only if station passes simple trigger
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],
filter_type='rectangular')
hardwareResponseIncorporator.run(evt, station, det)
channelSignalReconstructor.run(evt, station, det)
# channelTimeWindow.run(evt, station, det, window_function='hanning', around_pulse=True, window_width=20*units.ns,
# window_rise_time=20*units.ns)
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)
station_ARA,
det,
amplitude=20 * units.mV,
min_freq=50 * units.MHz,
max_freq=1000 * units.MHz,
type='perfect_white')
channelGenericNoiseAdder.run(event_ARIANNA,
station_ARIANNA,
det,
amplitude=20 * units.mV,
min_freq=50 * units.MHz,
max_freq=1000 * units.MHz,
type='perfect_white')
channelResampler.run(event_ARA,
station_ARA,
det,
sampling_rate=1 * units.GHz)
channelResampler.run(event_ARIANNA,
station_ARIANNA,
det,
sampling_rate=1 * units.GHz)
channelSignalReconstructor.run(event_ARIANNA, station_ARIANNA, det)
channelSignalReconstructor.run(event_ARA, station_ARA, det)
channelLengthAdjuster.run(event_ARIANNA, station_ARIANNA, det)
channelLengthAdjuster.run(event_ARA, station_ARA, det)
triggerSimulator_ARA.run(event_ARA,
station_ARA,
det,
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)
