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)