Пример #1
0
    c_delay = -17
    TISC_sample_length = 16
    delay_type_flag = 1
    average_subtract_flag = 1
    correlation_mean = np.zeros(63)
    correlation_mean.fill(50)
    filter_flag = 0
    debug = False
    timestep = 1.0 / 2600000000.0
    t = np.linspace(0, timestep * num_samples, num_samples)
    signal_amp = SNR * 2 * noise_sigma

    for i in range(0, 1):
        a_waveform = impulse_gen(num_samples,
                                 a_delay,
                                 upsample,
                                 draw_flag=0,
                                 output_dir='output/')
        empty_list = np.zeros(num_samples)
        difference = np.amax(a_waveform) - np.amin(
            a_waveform)  # Get peak to peak voltage
        a_waveform *= (1 / difference)  # Normalize input
        a_waveform *= signal_amp  # Amplify
        a_imp_dig_wfm = digitize(a_waveform,
                                 num_samples,
                                 num_bits,
                                 digitization_factor=noise_sigma)
        a_waveform = np.add(
            a_waveform, generate_noise(num_samples, noise_sigma, filter_flag))
        b_waveform = np.concatenate(
            [a_waveform[-b_delay:], empty_list[:(-1) * b_delay]])
Пример #2
0
def TISC_sim(SNR,
             threshold,
             b_input_delay,
             c_input_delay,
             num_bits=3,
             noise_sigma=32.0,
             sample_freq=2600000000.0,
             TISC_sample_length=16,
             num_samples=80,
             upsample=10,
             seed=5522684,
             draw_flag=0,
             digitization_factor=32.0,
             output_dir="output/",
             boresight=0,
             baseline=0,
             debug=False):

    # Setup
    save_output_flag = 0
    #if(save_output_flag):
    #outfile = str(output_dir+"/test.root")
    trigger_flag = 0
    #num_bits = 3 # Number of bits available to the digitizer
    #num_samples = num_samples*upsample
    filter_flag = False
    #sample_frequency = 2800000000.0
    def_max_sum = 0.0
    def_as_max_sum = 0.0
    ghi_max_sum = 0.0
    ghi_as_max_sum = 0.0
    timestep = 1.0 / sample_freq

    # Phi sectors have alternating baselines
    if (boresight == 0):
        abc_impulse_amp = 1.000
        def_impulse_amp = 0.835
    elif (boresight == 1):
        abc_impulse_amp = 0.962
        def_impulse_amp = 0.885

    # Fill numpy arrays with zeros
    a_input_noise = np.zeros(num_samples)
    b_input_noise = np.zeros(num_samples)
    c_input_noise = np.zeros(num_samples)
    d_input_noise = np.zeros(num_samples)
    e_input_noise = np.zeros(num_samples)
    f_input_noise = np.zeros(num_samples)

    time = np.zeros(num_samples)
    upsampled_time = np.zeros(num_samples)
    a_input_signal = np.zeros(num_samples)
    b_input_signal = np.zeros(num_samples)
    c_input_signal = np.zeros(num_samples)
    d_input_signal = np.zeros(num_samples)
    e_input_signal = np.zeros(num_samples)
    f_input_signal = np.zeros(num_samples)

    a_input_signal_noise = np.zeros(num_samples)
    b_input_signal_noise = np.zeros(num_samples)
    c_input_signal_noise = np.zeros(num_samples)
    d_input_signal_noise = np.zeros(num_samples)
    e_input_signal_noise = np.zeros(num_samples)
    f_input_signal_noise = np.zeros(num_samples)

    a_dig_waveform = np.zeros(num_samples)
    b_dig_waveform = np.zeros(num_samples)
    c_dig_waveform = np.zeros(num_samples)
    d_dig_waveform = np.zeros(num_samples)
    e_dig_waveform = np.zeros(num_samples)
    f_dig_waveform = np.zeros(num_samples)

    empty_list = np.zeros(num_samples)

    ###################################
    # Generate Thermal Noise
    a_input_noise = generate_noise(num_samples,
                                   noise_sigma,
                                   filter_flag,
                                   seed=seed + 0)
    b_input_noise = generate_noise(num_samples,
                                   noise_sigma,
                                   filter_flag,
                                   seed=seed + 1)
    c_input_noise = generate_noise(num_samples,
                                   noise_sigma,
                                   filter_flag,
                                   seed=seed + 2)

    d_input_noise = generate_noise(num_samples,
                                   noise_sigma,
                                   filter_flag,
                                   seed=seed + 3)
    e_input_noise = generate_noise(num_samples,
                                   noise_sigma,
                                   filter_flag,
                                   seed=seed + 4)
    f_input_noise = generate_noise(num_samples,
                                   noise_sigma,
                                   filter_flag,
                                   seed=seed + 5)
    ###################################

    #####################################
    # Determine RMS of noise and signal amplitude

    #noise_rms = np.sqrt(np.mean((a_input_noise-noise_mean)**2,))

    signal_amp = SNR * 2 * noise_sigma

    #####################################

    a_input_noise = butter_bandpass_filter(a_input_noise)
    b_input_noise = butter_bandpass_filter(b_input_noise)
    c_input_noise = butter_bandpass_filter(c_input_noise)

    d_input_noise = butter_bandpass_filter(d_input_noise)
    e_input_noise = butter_bandpass_filter(e_input_noise)
    f_input_noise = butter_bandpass_filter(f_input_noise)

    #####################################
    # Generate impulse
    if (SNR != 0):
        # Generate Signal and Amplify
        a_input_signal = impulse_gen(num_samples,
                                     upsample,
                                     draw_flag=draw_flag,
                                     output_dir=output_dir)
        difference = np.amax(a_input_signal) - np.amin(
            a_input_signal)  # Get peak to peak voltage
        a_input_signal *= (1 / difference)  # Normalize input
        a_input_signal *= signal_amp  # Amplify
        #b_input_signal = np.concatenate([a_input_signal[:num_samples+b_input_delay],empty_list[:(-1)*b_input_delay]])
        #c_input_signal = np.concatenate([a_input_signal[:num_samples+c_input_delay],empty_list[:(-1)*c_input_delay]])
        b_input_signal = np.concatenate([
            a_input_signal[-b_input_delay:], empty_list[:(-1) * b_input_delay]
        ])
        c_input_signal = np.concatenate([
            a_input_signal[-c_input_delay:], empty_list[:(-1) * c_input_delay]
        ])

        a_input_signal = a_input_signal * abc_impulse_amp
        b_input_signal = b_input_signal * abc_impulse_amp
        c_input_signal = c_input_signal * abc_impulse_amp

        d_input_signal = a_input_signal * def_impulse_amp
        e_input_signal = b_input_signal * def_impulse_amp
        f_input_signal = c_input_signal * def_impulse_amp
        """
      time = np.linspace(0.0,timestep*num_samples,num_samples)
      plt.plot(time,a_input_signal,time,b_input_signal,time,c_input_signal)
      plt.plot(time,d_input_signal,time,e_input_signal,time,f_input_signal)
      plt.plot(time,g_input_signal,time,h_input_signal,time,i_input_signal)
      plt.title("impulse")
      plt.show()  
      """
        # Add the signal to the noise
        a_input_signal_noise = np.add(a_input_noise, a_input_signal)
        b_input_signal_noise = np.add(b_input_noise, b_input_signal)
        c_input_signal_noise = np.add(c_input_noise, c_input_signal)

        d_input_signal_noise = np.add(d_input_noise, d_input_signal)
        e_input_signal_noise = np.add(e_input_noise, e_input_signal)
        f_input_signal_noise = np.add(f_input_noise, f_input_signal)
        """
      time = np.linspace(0.0,timestep*num_samples,num_samples)
      plt.plot(time,a_input_signal_noise,time,b_input_signal_noise,time,c_input_signal_noise)
      plt.plot(time,d_input_signal_noise,time,e_input_signal_noise,time,f_input_signal_noise)
      #plt.plot(time,g_input_signal_noise,time,h_input_signal_noise,time,i_input_signal_noise)
      plt.title("impulse+noise")
      plt.show()
      """
    else:
        a_input_signal_noise = a_input_noise
        b_input_signal_noise = b_input_noise
        c_input_signal_noise = c_input_noise

        d_input_signal_noise = d_input_noise
        e_input_signal_noise = e_input_noise
        f_input_signal_noise = f_input_noise


##########################################
#time = np.linspace(0.0,timestep*num_samples,num_samples)
#plt.plot(time,a_input_noise,time,b_input_noise,time,c_input_noise)
#plt.title("noise")
#plt.show()
##########################################
# Digitized the incoming signal and noise (RITC)
    a_dig_waveform = digitize(a_input_signal_noise, num_samples, num_bits,
                              digitization_factor)
    b_dig_waveform = digitize(b_input_signal_noise, num_samples, num_bits,
                              digitization_factor)
    c_dig_waveform = digitize(c_input_signal_noise, num_samples, num_bits,
                              digitization_factor)

    d_dig_waveform = digitize(d_input_signal_noise, num_samples, num_bits,
                              digitization_factor)
    e_dig_waveform = digitize(e_input_signal_noise, num_samples, num_bits,
                              digitization_factor)
    f_dig_waveform = digitize(f_input_signal_noise, num_samples, num_bits,
                              digitization_factor)

    ##########################################
    """
   time = np.linspace(0.0,timestep*num_samples,num_samples)
   plt.plot(time,a_dig_waveform,time,b_dig_waveform,time,c_dig_waveform)
   plt.plot(time,d_dig_waveform,time,e_dig_waveform,time,f_dig_waveform)
   #plt.plot(time,g_dig_waveform,time,h_dig_waveform,time,i_dig_waveform)
   plt.title("Digitized")
   plt.show()
   """

    ##########################################
    # Run the signal through the GLITC module to get trigger

    trigger_flag, max_total_sum, best_angle, total_sum = sum_correlate(
        num_samples,
        a_dig_waveform,
        b_dig_waveform,
        c_dig_waveform,
        d_dig_waveform,
        e_dig_waveform,
        f_dig_waveform,
        baseline,
        threshold,
        TISC_sample_length,
        debug=debug)
    #print abc_max_sum
    #print def_max_sum
    #print ghi_max_sum

    #########################################

    #dummy = raw_input('Press any key to close')

    return max_total_sum, best_angle
Пример #3
0
def TISC_sim(SNR,threshold,
             b_input_delay,c_input_delay,num_bits=3,
             noise_sigma=32.0,
             sample_freq=2600000000.0,TISC_sample_length=16,
             num_samples=74,upsample=10,cw_flag=0,
             cw_rms=25.0,carrier_frequency=260000000.0,modulation_frequency=1.0,
             seed=5522684,draw_flag=0,digitization_factor=32.0,
             delay_type_flag=1,
             output_dir="output/",average_subtract_flag=0,correlation_mean=np.zeros(44),trial_run_number=1):                         

   #print b_input_delay
   # Setup
   save_output_flag = 0
   #if(save_output_flag):
      #outfile = str(output_dir+"/test.root")
   trigger_flag = 0
   #num_bits = 3 # Number of bits available to the digitizer
   filter_flag = False
   #print SNR

   # Fill numpy arrays with zeros
   a_input_noise = np.zeros(num_samples)
   b_input_noise = np.zeros(num_samples)
   c_input_noise = np.zeros(num_samples)
   a_input_noise_test = np.zeros(num_samples)
   b_input_noise_test = np.zeros(num_samples)
   c_input_noise_test = np.zeros(num_samples)
   a_input_signal = np.zeros(num_samples)
   b_input_signal = np.zeros(num_samples)
   c_input_signal = np.zeros(num_samples)
   a_dig_waveform = np.zeros(num_samples)
   b_dig_waveform = np.zeros(num_samples)
   c_dig_waveform = np.zeros(num_samples)
   cw_noise = np.zeros(num_samples)
   empty_list = np.zeros(num_samples)

###################################
   # Generate Thermal Noise
   a_input_noise = generate_noise(num_samples,noise_sigma,filter_flag)
   b_input_noise = generate_noise(num_samples,noise_sigma,filter_flag)
   c_input_noise = generate_noise(num_samples,noise_sigma,filter_flag)
   #a_input_noise_test = a_input_noise
   #b_input_noise_test = b_input_noise
   #c_input_noise_test = c_input_noise
###################################

   #print a_input_noise[0]
   #print b_input_noise[0]
   #print c_input_noise[0]
#####################################
   # Determine signal amplitude    
   signal_amp = SNR*2*noise_sigma
#####################################

#################################
   #Generate CW & thermal noise
   
   if cw_flag:
      cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,cw_rms,filter_flag)
      a_input_noise = np.add(a_input_noise,cw_noise)
      #cw_noise = generate_cw(num_samples,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      b_input_noise = np.add(b_input_noise,cw_noise)
      #cw_noise = generate_cw(num_samples,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      c_input_noise = np.add(c_input_noise,cw_noise)

#####################################

   # Filter the noise
   a_input_noise = butter_bandpass_filter(a_input_noise)
   b_input_noise = butter_bandpass_filter(b_input_noise)
   c_input_noise = butter_bandpass_filter(c_input_noise)
   #print "Filter Took: " +str(datetime.now()-start_filter)
   #start_signal = datetime.now()
#####################################
   # Generate impulse
   if (SNR != 0):
      # Generate Signal and Amplify
      a_input_signal = impulse_gen(num_samples,upsample,draw_flag=draw_flag,output_dir=output_dir)
      difference=np.amax(a_input_signal)-np.amin(a_input_signal) # Get peak to peak voltage

      a_input_signal *= (1/difference) # Normalize input
      a_input_signal *= signal_amp # Amplify
      b_input_signal = np.concatenate([a_input_signal[:num_samples+b_input_delay],empty_list[:(-1)*b_input_delay]])
      c_input_signal = np.concatenate([a_input_signal[:num_samples+c_input_delay],empty_list[:(-1)*c_input_delay]])

      # Add the signal to the noise
      a_input_signal = np.add(a_input_noise, a_input_signal)
      b_input_signal = np.add(b_input_noise, b_input_signal)
      c_input_signal = np.add(c_input_noise, c_input_signal)
   else:
      a_input_signal = a_input_noise
      b_input_signal = b_input_noise
      c_input_signal = c_input_noise
##########################################
      


##########################################
   # Digitized the incoming signal and noise (RITC)
   a_dig_waveform = digitize(a_input_signal,num_samples,num_bits,digitization_factor)
   b_dig_waveform = digitize(b_input_signal,num_samples,num_bits,digitization_factor)
   c_dig_waveform = digitize(c_input_signal,num_samples,num_bits,digitization_factor)

##########################################
   #print a_dig_waveform

##########################################
   # Run the signal through the GLITC module to get trigger
   if (average_subtract_flag):
      trigger_flag, max_sum, as_max_sum, correlation_mean, test_sum, as_test_sum = sum_correlate(num_samples,a_dig_waveform,b_dig_waveform,c_dig_waveform,
                                                threshold,TISC_sample_length,delay_type_flag=delay_type_flag,
                                                average_subtract_flag=average_subtract_flag,correlation_mean=correlation_mean,trial_run_number=trial_run_number)
   else:
      trigger_flag, max_sum, test_sum = sum_correlate(num_samples,a_dig_waveform,b_dig_waveform,c_dig_waveform,
                                 threshold,TISC_sample_length,delay_type_flag=delay_type_flag,
                                 average_subtract_flag=average_subtract_flag,correlation_mean=correlation_mean)
   """
   if (max_sum>800):
      import matplotlib.pyplot as plt
      #print a_dig_waveform
      #print b_dig_waveform
      #print c_dig_waveform
      #print np.add(np.add(a_dig_waveform,b_dig_waveform),c_dig_waveform)
      #print (np.add(np.add(a_dig_waveform,b_dig_waveform),c_dig_waveform))**2
      #print np.sum((np.add(np.add(a_dig_waveform,b_dig_waveform),c_dig_waveform))**2)
      time = np.linspace(0.0,((num_samples*(10**9))/sample_freq), num_samples)
      plt.figure(1)
      plt.clf()
      plt.plot(time,a_dig_waveform)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("Ch A")
      plt.savefig(output_dir+"/ch_A_large_correlation.png")
      plt.figure(2)
      plt.clf()
      plt.plot(time,b_dig_waveform)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("Ch B")
      plt.savefig(output_dir+"/ch_B_large_correlation.png")
      plt.figure(3)
      plt.clf()
      plt.plot(time,c_dig_waveform)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("Ch C")
      plt.savefig(output_dir+"/ch_C_large_correlation.png")
      plt.figure(4)
      plt.clf()
      plt.plot(time,np.add(np.add(a_dig_waveform,b_dig_waveform),c_dig_waveform))
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("ABC Added")
      plt.savefig(output_dir+"/ABC_large_correlation.png")
      plt.figure(5)
      plt.clf()
      plt.plot(time,(np.add(np.add(a_dig_waveform,b_dig_waveform),c_dig_waveform))**2)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("ABC Square Added")
      plt.savefig(output_dir+"/ABC_square_large_correlation.png")
      plt.figure(6)
      plt.clf()
      plt.plot(time,a_input_noise_test)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("Ch A Thermal Noise")
      plt.savefig(output_dir+"/ch_A_thermal_large_correlation.png")
      plt.figure(7)
      plt.clf()
      plt.plot(time,b_input_noise_test)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("Ch B Thermal Noise")
      plt.savefig(output_dir+"/ch_B_thermal_large_correlation.png")
      plt.figure(8)
      plt.clf()
      plt.plot(time,c_input_noise_test)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("Ch C Thermal Noise")
      plt.savefig(output_dir+"/ch_C_thermal_large_correlation.png")
      plt.figure(9)
      plt.clf()
      plt.plot(time,cw_noise)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("CW Noise")
      plt.savefig(output_dir+"/cw_large_correlation.png")
      plt.show()
      """
#########################################


#########################################
   # Output data
   #if(save_output_flag):
      # Now to more ROOT stuff
      #rf_tree.Fill()
      #f.Write()
      #f.Close()

   if draw_flag:
      dummy = raw_input('Press any key to close')
      
   #print "Everything took: " +str(datetime.now()-start_time)
   if (average_subtract_flag):
      return trigger_flag, max_sum, as_max_sum, correlation_mean, test_sum, as_test_sum
   else:
      return trigger_flag, max_sum
def TISC_sim(SNR,threshold,
             b_input_delay,c_input_delay,num_bits=3,
             noise_sigma=32.0,
             sample_freq=2600000000.0,TISC_sample_length=16,
             num_samples=80,upsample=10,cw_flag=0,
             cw_amplitude=20.0,carrier_frequency=260000000.0,modulation_frequency=1.0,
             seed=5522684,draw_flag=0,digitization_factor=32.0,
             delay_type_flag=1,
             output_dir="output/",average_subtract_flag=0,abc_correlation_mean=np.zeros(46),
             def_correlation_mean=np.zeros(44),ghi_correlation_mean=np.zeros(46),trial_run_number=1,boresight=0,baseline=0,six_phi_sector_add=False,window_length=0,window_weight=0.5, debug=False):
   
   # Setup
   save_output_flag = 0
   #if(save_output_flag):
      #outfile = str(output_dir+"/test.root")
   trigger_flag = 0
   #num_bits = 3 # Number of bits available to the digitizer
   #num_samples = num_samples*upsample
   filter_flag = False
   #sample_frequency = 2800000000.0
   def_max_sum = 0.0
   def_as_max_sum = 0.0
   ghi_max_sum = 0.0
   ghi_as_max_sum = 0.0
   timestep = 1.0/sample_freq
   
   
   # Phi sectors have alternating baselines
   if(boresight==0):
      abc_impulse_amp = 1.000
      def_impulse_amp = 0.835
      ghi_impulse_amp = 0.776
      if(baseline==0):
         abc_baseline = 0
         def_baseline = 1
         ghi_baseline = 1
      elif(baseline==1):
         abc_baseline = 1
         def_baseline = 0
         ghi_baseline = 0
   elif(boresight==1):
      abc_impulse_amp = 0.962
      def_impulse_amp = 0.885
      ghi_impulse_amp = 0.650
      if(baseline==0):
         abc_baseline = 1
         def_baseline = 0
         ghi_baseline = 1
      elif(baseline==1):
         abc_baseline = 1
         def_baseline = 0
         ghi_baseline = 0
   
   # Fill numpy arrays with zeros
   a_input_noise = np.zeros(num_samples)
   b_input_noise = np.zeros(num_samples)
   c_input_noise = np.zeros(num_samples)
   d_input_noise = np.zeros(num_samples)
   e_input_noise = np.zeros(num_samples)
   f_input_noise = np.zeros(num_samples)
   g_input_noise = np.zeros(num_samples)
   h_input_noise = np.zeros(num_samples)
   i_input_noise = np.zeros(num_samples)
   time = np.zeros(num_samples)
   upsampled_time = np.zeros(num_samples)
   a_input_signal = np.zeros(num_samples)
   b_input_signal = np.zeros(num_samples)
   c_input_signal = np.zeros(num_samples)
   d_input_signal = np.zeros(num_samples)
   e_input_signal = np.zeros(num_samples)
   f_input_signal = np.zeros(num_samples)
   g_input_signal = np.zeros(num_samples)
   h_input_signal = np.zeros(num_samples)
   i_input_signal = np.zeros(num_samples)
   a_input_signal_noise = np.zeros(num_samples)
   b_input_signal_noise = np.zeros(num_samples)
   c_input_signal_noise = np.zeros(num_samples)
   d_input_signal_noise = np.zeros(num_samples)
   e_input_signal_noise = np.zeros(num_samples)
   f_input_signal_noise = np.zeros(num_samples)
   g_input_signal_noise = np.zeros(num_samples)
   h_input_signal_noise = np.zeros(num_samples)
   i_input_signal_noise = np.zeros(num_samples)
   a_dig_waveform = np.zeros(num_samples)
   b_dig_waveform = np.zeros(num_samples)
   c_dig_waveform = np.zeros(num_samples)
   d_dig_waveform = np.zeros(num_samples)
   e_dig_waveform = np.zeros(num_samples)
   f_dig_waveform = np.zeros(num_samples)
   g_dig_waveform = np.zeros(num_samples)
   h_dig_waveform = np.zeros(num_samples)
   i_dig_waveform = np.zeros(num_samples)
   empty_list = np.zeros(num_samples)


###################################
   # Generate Thermal Noise
   a_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed)
   b_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+1)
   c_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+2)
   d_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+3)
   e_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+4)
   f_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+5)
   g_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+6)
   h_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+7)
   i_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+8)
###################################


#####################################
   # Determine RMS of noise and signal amplitude

   #noise_rms = np.sqrt(np.mean((a_input_noise-noise_mean)**2,))
   
   signal_amp = SNR*2*noise_sigma

#####################################
   
   
#################################
   #Generate CW noise if desired
   if cw_flag:
      cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,cw_amplitude,filter_flag)
      a_input_noise = np.add(a_input_noise,cw_noise)#generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      #a_input_noise += a_input_cw_noise

      # b_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      b_input_noise = np.add(cw_noise,b_input_noise)

      #c_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      c_input_noise = np.add(cw_noise,c_input_noise)
      
      #d_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      d_input_noise = np.add(cw_noise,d_input_noise)

      #e_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      e_input_noise = np.add(cw_noise,e_input_noise)

      #f_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      f_input_noise = np.add(cw_noise,f_input_noise)
      
      #g_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      g_input_noise = np.add(cw_noise,g_input_noise)

      #h_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      h_input_noise = np.add(cw_noise,h_input_noise)

      #i_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      i_input_noise = np.add(cw_noise,i_input_noise)

#####################################
      
   a_input_noise = butter_bandpass_filter(a_input_noise)
   b_input_noise = butter_bandpass_filter(b_input_noise)
   c_input_noise = butter_bandpass_filter(c_input_noise)
   d_input_noise = butter_bandpass_filter(d_input_noise)
   e_input_noise = butter_bandpass_filter(e_input_noise)
   f_input_noise = butter_bandpass_filter(f_input_noise)
   g_input_noise = butter_bandpass_filter(g_input_noise)
   h_input_noise = butter_bandpass_filter(h_input_noise)
   i_input_noise = butter_bandpass_filter(i_input_noise)
 
#####################################
   # Generate impulse
   if (SNR != 0):
      # Generate Signal and Amplify
      a_input_signal = impulse_gen(num_samples,upsample,draw_flag=draw_flag,output_dir=output_dir)
      difference=np.amax(a_input_signal)-np.amin(a_input_signal) # Get peak to peak voltage
      a_input_signal *= (1/difference) # Normalize input
      a_input_signal *= signal_amp # Amplify
      #b_input_signal = np.concatenate([a_input_signal[:num_samples+b_input_delay],empty_list[:(-1)*b_input_delay]])
      #c_input_signal = np.concatenate([a_input_signal[:num_samples+c_input_delay],empty_list[:(-1)*c_input_delay]])
      b_input_signal = np.concatenate([a_input_signal[-b_input_delay:],empty_list[:(-1)*b_input_delay]])
      c_input_signal = np.concatenate([a_input_signal[-c_input_delay:],empty_list[:(-1)*c_input_delay]])
      
      
      
      a_input_signal =a_input_signal*abc_impulse_amp
      b_input_signal =b_input_signal*abc_impulse_amp
      c_input_signal =c_input_signal*abc_impulse_amp
      
      d_input_signal =a_input_signal*def_impulse_amp
      e_input_signal =b_input_signal*def_impulse_amp
      f_input_signal =c_input_signal*def_impulse_amp
      
      g_input_signal =a_input_signal*ghi_impulse_amp
      h_input_signal =b_input_signal*ghi_impulse_amp
      i_input_signal =c_input_signal*ghi_impulse_amp
      
      """
      if(boresight==0):
         d_input_signal = a_input_signal*0.776 # Average dB loss at -22.5 degrees
         e_input_signal = b_input_signal*0.776 # from Seavey measurements
         f_input_signal = c_input_signal*0.776
         
         g_input_signal = a_input_signal*0.835 # Average dB loss at +22.5 degrees
         h_input_signal = b_input_signal*0.835 # from Seavey measurements
         i_input_signal = c_input_signal*0.835
      elif(boresight==1):
         # For event between two phi sectors, the two antennas are down by about -0.5dB at
         a_input_signal = a_input_signal*0.885 # Average dB los at +11.25 degrees
         b_input_signal = b_input_signal*0.885 # from Seavey measurements
         c_input_signal = c_input_signal*0.885

         d_input_signal = a_input_signal*0.962 # Average dB loss at -11.25 degrees
         e_input_signal = b_input_signal*0.962 # from Seavey measurements
         f_input_signal = c_input_signal*0.962
         
         g_input_signal = a_input_signal*0.650 # Average dB loss at +-33.75 degrees
         h_input_signal = b_input_signal*0.650 # from Seavey measurements
         i_input_signal = c_input_signal*0.650
      """
      if(debug):
         time = np.linspace(0.0,timestep*num_samples,num_samples)
         plt.plot(time,a_input_signal,time,b_input_signal,time,c_input_signal)
         plt.plot(time,d_input_signal,time,e_input_signal,time,f_input_signal)
         plt.plot(time,g_input_signal,time,h_input_signal,time,i_input_signal)
         plt.title("impulse")
         plt.show()  
      
      # Add the signal to the noise
      a_input_signal_noise = np.add(a_input_noise, a_input_signal)
      b_input_signal_noise = np.add(b_input_noise, b_input_signal)
      c_input_signal_noise = np.add(c_input_noise, c_input_signal)
      d_input_signal_noise = np.add(d_input_noise, d_input_signal)
      e_input_signal_noise = np.add(e_input_noise, e_input_signal)
      f_input_signal_noise = np.add(f_input_noise, f_input_signal)
      g_input_signal_noise = np.add(g_input_noise, g_input_signal)
      h_input_signal_noise = np.add(h_input_noise, h_input_signal)
      i_input_signal_noise = np.add(i_input_noise, i_input_signal)
      
      if(debug):
         time = np.linspace(0.0,timestep*num_samples,num_samples)
         #plt.plot(time,a_input_signal_noise,time,b_input_signal_noise,time,c_input_signal_noise)
         #plt.plot(time,d_input_signal_noise,time,e_input_signal_noise,time,f_input_signal_noise)
         plt.plot(time,g_input_signal_noise,time,h_input_signal_noise,time,i_input_signal_noise)
         plt.title("impulse+noise")
         plt.show()
      
   else:
      a_input_signal_noise = a_input_noise
      b_input_signal_noise = b_input_noise
      c_input_signal_noise = c_input_noise
      d_input_signal_noise = d_input_noise
      e_input_signal_noise = e_input_noise
      f_input_signal_noise = f_input_noise
      g_input_signal_noise = g_input_noise
      h_input_signal_noise = h_input_noise
      i_input_signal_noise = i_input_noise
##########################################
   #time = np.linspace(0.0,timestep*num_samples,num_samples)
   #plt.plot(time,a_input_noise,time,b_input_noise,time,c_input_noise)
   #plt.title("noise")
   #plt.show()
##########################################
   # Digitized the incoming signal and noise (RITC)
   a_dig_waveform = digitize(a_input_signal_noise,num_samples,num_bits,digitization_factor)
   b_dig_waveform = digitize(b_input_signal_noise,num_samples,num_bits,digitization_factor)
   c_dig_waveform = digitize(c_input_signal_noise,num_samples,num_bits,digitization_factor)
   d_dig_waveform = digitize(d_input_signal_noise,num_samples,num_bits,digitization_factor)
   e_dig_waveform = digitize(e_input_signal_noise,num_samples,num_bits,digitization_factor)
   f_dig_waveform = digitize(f_input_signal_noise,num_samples,num_bits,digitization_factor)
   g_dig_waveform = digitize(g_input_signal_noise,num_samples,num_bits,digitization_factor)
   h_dig_waveform = digitize(h_input_signal_noise,num_samples,num_bits,digitization_factor)
   i_dig_waveform = digitize(i_input_signal_noise,num_samples,num_bits,digitization_factor)

##########################################
   
   if(debug):
      time = np.linspace(0.0,timestep*num_samples,num_samples)
      #plt.plot(time,a_dig_waveform,time,b_dig_waveform,time,c_dig_waveform)
      #plt.plot(time,d_dig_waveform,time,e_dig_waveform,time,f_dig_waveform)
      plt.plot(time,g_dig_waveform,time,h_dig_waveform,time,i_dig_waveform)
      plt.title("Digitized")
      plt.show()
   
   
##########################################
   # Run the signal through the GLITC module to get trigger
   if(average_subtract_flag):
      
      abc_trigger_flag, abc_max_sum , abc_as_max_sum, abc_correlation_mean, abc_test_sum, abc_as_test_sum,as_abc_angle,abc_angle,d1,d2 = sum_correlate(num_samples,a_dig_waveform,b_dig_waveform,c_dig_waveform,threshold,abc_baseline,TISC_sample_length,delay_type_flag=delay_type_flag,
                                                average_subtract_flag=average_subtract_flag,correlation_mean=abc_correlation_mean,trial_run_number=trial_run_number)
      def_trigger_flag, def_max_sum , def_as_max_sum, def_correlation_mean, def_test_sum, def_as_test_sum,as_def_angle,def_angle,d1,d2 = sum_correlate(num_samples,d_dig_waveform,e_dig_waveform,f_dig_waveform,threshold,def_baseline,TISC_sample_length,delay_type_flag=delay_type_flag,
                                                average_subtract_flag=average_subtract_flag,correlation_mean=def_correlation_mean,trial_run_number=trial_run_number)
      ghi_trigger_flag, ghi_max_sum , ghi_as_max_sum, ghi_correlation_mean, ghi_test_sum, ghi_as_test_sum,as_ghi_angle,ghi_angle,d1,d2 = sum_correlate(num_samples,g_dig_waveform,h_dig_waveform,i_dig_waveform,threshold,ghi_baseline,TISC_sample_length,delay_type_flag=delay_type_flag,
                                                average_subtract_flag=average_subtract_flag,correlation_mean=ghi_correlation_mean,trial_run_number=trial_run_number)
      #abc_max_sum
      #print len(a_dig_waveform)  
   else:
      abc_trigger_flag, abc_max_sum,abc_angle,d1 = sum_correlate(num_samples,a_dig_waveform,b_dig_waveform,c_dig_waveform,threshold,abc_baseline,TISC_sample_length,delay_type_flag=delay_type_flag,
                                                average_subtract_flag=average_subtract_flag,correlation_mean=abc_correlation_mean,trial_run_number=trial_run_number,window_length=window_length,window_weight=window_weight)
      def_trigger_flag, def_max_sum,def_angle,d1 = sum_correlate(num_samples,d_dig_waveform,e_dig_waveform,f_dig_waveform,threshold,def_baseline,TISC_sample_length,delay_type_flag=delay_type_flag,
                                                average_subtract_flag=average_subtract_flag,correlation_mean=def_correlation_mean,trial_run_number=trial_run_number,window_length=window_length,window_weight=window_weight)
      ghi_trigger_flag, ghi_max_sum,ghi_angle,d1 = sum_correlate(num_samples,g_dig_waveform,h_dig_waveform,i_dig_waveform,threshold,ghi_baseline,TISC_sample_length,delay_type_flag=delay_type_flag,
                                                average_subtract_flag=average_subtract_flag,correlation_mean=ghi_correlation_mean,trial_run_number=trial_run_number,window_length=window_length,window_weight=window_weight)
      #print abc_max_sum
      #print def_max_sum
      #print ghi_max_sum
                                                
   #if(abc_trigger_flag & def_trigger_flag & ghi_trigger_flag):
      #trigger_flag = True
   #else:
      #trigger_flag = False
 

      
   

#########################################

   #dummy = raw_input('Press any key to close')

   if (average_subtract_flag):
      return abc_max_sum,abc_as_max_sum,def_max_sum,def_as_max_sum,ghi_max_sum,ghi_as_max_sum,abc_correlation_mean, def_correlation_mean, ghi_correlation_mean,as_abc_angle,abc_angle,as_def_angle,def_angle,as_ghi_angle,ghi_angle
   else:
      return abc_max_sum,def_max_sum,ghi_max_sum,abc_angle,def_angle,ghi_angle
def TISC_sim(SNR,threshold,
             b_input_delay,c_input_delay,num_bits=3,
             noise_sigma=32.0,
             sample_freq=2600000000.0,TISC_sample_length=16,
             num_samples=80,upsample=10,cw_flag=0,
             cw_amplitude=20.0,carrier_frequency=260000000.0,modulation_frequency=1.0,
             seed=5522684,draw_flag=0,digitization_factor=32.0,
             delay_type_flag=1,
             output_dir="output/",average_subtract_flag=0,abc_correlation_mean=np.zeros(46),
             def_correlation_mean=np.zeros(44),ghi_correlation_mean=np.zeros(46),trial_run_number=1,boresight=0,baseline=0,six_phi_sector_add=False):
   
   # Setup
   save_output_flag = 0
   #if(save_output_flag):
      #outfile = str(output_dir+"/test.root")
   trigger_flag = 0
   #num_bits = 3 # Number of bits available to the digitizer
   #num_samples = num_samples*upsample
   filter_flag = False
   #sample_frequency = 2800000000.0
   def_max_sum = 0.0
   def_as_max_sum = 0.0
   ghi_max_sum = 0.0
   ghi_as_max_sum = 0.0
   timestep = 1.0/sample_freq
   
   
   # Phi sectors have alternating baselines
   if(boresight==0):
      abc_impulse_amp = 1.000
      def_impulse_amp = 0.835
      ghi_impulse_amp = 0.776
      if(baseline==0):
         abc_baseline = 0
         def_baseline = 1
         ghi_baseline = 1
      elif(baseline==1):
         abc_baseline = 1
         def_baseline = 0
         ghi_baseline = 0
   elif(boresight==1):
      abc_impulse_amp = 0.962
      def_impulse_amp = 0.885
      ghi_impulse_amp = 0.650
      if(baseline==0):
         abc_baseline = 1
         def_baseline = 0
         ghi_baseline = 1
      elif(baseline==1):
         abc_baseline = 1
         def_baseline = 0
         ghi_baseline = 0
   
   # Fill numpy arrays with zeros
   a_input_noise = np.zeros(num_samples)
   b_input_noise = np.zeros(num_samples)
   c_input_noise = np.zeros(num_samples)
   d_input_noise = np.zeros(num_samples)
   e_input_noise = np.zeros(num_samples)
   f_input_noise = np.zeros(num_samples)
   g_input_noise = np.zeros(num_samples)
   h_input_noise = np.zeros(num_samples)
   i_input_noise = np.zeros(num_samples)
   time = np.zeros(num_samples)
   upsampled_time = np.zeros(num_samples)
   a_input_signal = np.zeros(num_samples)
   b_input_signal = np.zeros(num_samples)
   c_input_signal = np.zeros(num_samples)
   d_input_signal = np.zeros(num_samples)
   e_input_signal = np.zeros(num_samples)
   f_input_signal = np.zeros(num_samples)
   g_input_signal = np.zeros(num_samples)
   h_input_signal = np.zeros(num_samples)
   i_input_signal = np.zeros(num_samples)
   a_input_signal_noise = np.zeros(num_samples)
   b_input_signal_noise = np.zeros(num_samples)
   c_input_signal_noise = np.zeros(num_samples)
   d_input_signal_noise = np.zeros(num_samples)
   e_input_signal_noise = np.zeros(num_samples)
   f_input_signal_noise = np.zeros(num_samples)
   g_input_signal_noise = np.zeros(num_samples)
   h_input_signal_noise = np.zeros(num_samples)
   i_input_signal_noise = np.zeros(num_samples)
   a_dig_waveform = np.zeros(num_samples)
   b_dig_waveform = np.zeros(num_samples)
   c_dig_waveform = np.zeros(num_samples)
   d_dig_waveform = np.zeros(num_samples)
   e_dig_waveform = np.zeros(num_samples)
   f_dig_waveform = np.zeros(num_samples)
   g_dig_waveform = np.zeros(num_samples)
   h_dig_waveform = np.zeros(num_samples)
   i_dig_waveform = np.zeros(num_samples)
   empty_list = np.zeros(num_samples)


###################################
   # Generate Thermal Noise
   a_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed)
   b_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+1)
   c_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+2)
   d_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+3)
   e_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+4)
   f_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+5)
   g_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+6)
   h_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+7)
   i_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+8)
###################################


#####################################
   # Determine RMS of noise and signal amplitude

   #noise_rms = np.sqrt(np.mean((a_input_noise-noise_mean)**2,))
   
   signal_amp = SNR*2*noise_sigma

#####################################
   
   
#################################
   #Generate CW noise if desired
   if cw_flag:
      cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,cw_amplitude,filter_flag)
      a_input_noise = np.add(a_input_noise,cw_noise)#generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      #a_input_noise += a_input_cw_noise

      # b_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      b_input_noise = np.add(cw_noise,b_input_noise)

      #c_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      c_input_noise = np.add(cw_noise,c_input_noise)
      
      #d_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      d_input_noise = np.add(cw_noise,d_input_noise)

      #e_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      e_input_noise = np.add(cw_noise,e_input_noise)

      #f_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      f_input_noise = np.add(cw_noise,f_input_noise)
      
      #g_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      g_input_noise = np.add(cw_noise,g_input_noise)

      #h_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      h_input_noise = np.add(cw_noise,h_input_noise)

      #i_input_cw_noise = generate_cw(num_samples,upsample,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
      i_input_noise = np.add(cw_noise,i_input_noise)

#####################################
      
   a_input_noise = butter_bandpass_filter(a_input_noise)
   b_input_noise = butter_bandpass_filter(b_input_noise)
   c_input_noise = butter_bandpass_filter(c_input_noise)
   d_input_noise = butter_bandpass_filter(d_input_noise)
   e_input_noise = butter_bandpass_filter(e_input_noise)
   f_input_noise = butter_bandpass_filter(f_input_noise)
   g_input_noise = butter_bandpass_filter(g_input_noise)
   h_input_noise = butter_bandpass_filter(h_input_noise)
   i_input_noise = butter_bandpass_filter(i_input_noise)
 
#####################################
   # Generate impulse
   if (SNR != 0):
      # Generate Signal and Amplify
      a_input_signal = impulse_gen(num_samples,upsample,draw_flag=draw_flag,output_dir=output_dir)
      difference=np.amax(a_input_signal)-np.amin(a_input_signal) # Get peak to peak voltage
      a_input_signal *= (1/difference) # Normalize input
      a_input_signal *= signal_amp # Amplify
      #b_input_signal = np.concatenate([a_input_signal[:num_samples+b_input_delay],empty_list[:(-1)*b_input_delay]])
      #c_input_signal = np.concatenate([a_input_signal[:num_samples+c_input_delay],empty_list[:(-1)*c_input_delay]])
      b_input_signal = np.concatenate([a_input_signal[-b_input_delay:],empty_list[:(-1)*b_input_delay]])
      c_input_signal = np.concatenate([a_input_signal[-c_input_delay:],empty_list[:(-1)*c_input_delay]])
      
      
      
      a_input_signal =a_input_signal*abc_impulse_amp
      b_input_signal =b_input_signal*abc_impulse_amp
      c_input_signal =c_input_signal*abc_impulse_amp
      
      d_input_signal =a_input_signal*def_impulse_amp
      e_input_signal =b_input_signal*def_impulse_amp
      f_input_signal =c_input_signal*def_impulse_amp
      
      g_input_signal =a_input_signal*ghi_impulse_amp
      h_input_signal =b_input_signal*ghi_impulse_amp
      i_input_signal =c_input_signal*ghi_impulse_amp
      
      """
      if(boresight==0):
         d_input_signal = a_input_signal*0.776 # Average dB loss at -22.5 degrees
         e_input_signal = b_input_signal*0.776 # from Seavey measurements
         f_input_signal = c_input_signal*0.776
         
         g_input_signal = a_input_signal*0.835 # Average dB loss at +22.5 degrees
         h_input_signal = b_input_signal*0.835 # from Seavey measurements
         i_input_signal = c_input_signal*0.835
      elif(boresight==1):
         # For event between two phi sectors, the two antennas are down by about -0.5dB at
         a_input_signal = a_input_signal*0.885 # Average dB los at +11.25 degrees
         b_input_signal = b_input_signal*0.885 # from Seavey measurements
         c_input_signal = c_input_signal*0.885

         d_input_signal = a_input_signal*0.962 # Average dB loss at -11.25 degrees
         e_input_signal = b_input_signal*0.962 # from Seavey measurements
         f_input_signal = c_input_signal*0.962
         
         g_input_signal = a_input_signal*0.650 # Average dB loss at +-33.75 degrees
         h_input_signal = b_input_signal*0.650 # from Seavey measurements
         i_input_signal = c_input_signal*0.650
      """
      """
      time = np.linspace(0.0,timestep*num_samples,num_samples)
      plt.plot(time,a_input_signal,time,b_input_signal,time,c_input_signal)
      plt.plot(time,d_input_signal,time,e_input_signal,time,f_input_signal)
      plt.plot(time,g_input_signal,time,h_input_signal,time,i_input_signal)
      plt.title("impulse")
      plt.show()  
      """
      # Add the signal to the noise
      a_input_signal_noise = np.add(a_input_noise, a_input_signal)
      b_input_signal_noise = np.add(b_input_noise, b_input_signal)
      c_input_signal_noise = np.add(c_input_noise, c_input_signal)
      d_input_signal_noise = np.add(d_input_noise, d_input_signal)
      e_input_signal_noise = np.add(e_input_noise, e_input_signal)
      f_input_signal_noise = np.add(f_input_noise, f_input_signal)
      g_input_signal_noise = np.add(g_input_noise, g_input_signal)
      h_input_signal_noise = np.add(h_input_noise, h_input_signal)
      i_input_signal_noise = np.add(i_input_noise, i_input_signal)
      """
      time = np.linspace(0.0,timestep*num_samples,num_samples)
      #plt.plot(time,a_input_signal_noise,time,b_input_signal_noise,time,c_input_signal_noise)
      #plt.plot(time,d_input_signal_noise,time,e_input_signal_noise,time,f_input_signal_noise)
      plt.plot(time,g_input_signal_noise,time,h_input_signal_noise,time,i_input_signal_noise)
      plt.title("impulse+noise")
      plt.show()
      """
   else:
      a_input_signal_noise = a_input_noise
      b_input_signal_noise = b_input_noise
      c_input_signal_noise = c_input_noise
      d_input_signal_noise = d_input_noise
      e_input_signal_noise = e_input_noise
      f_input_signal_noise = f_input_noise
      g_input_signal_noise = g_input_noise
      h_input_signal_noise = h_input_noise
      i_input_signal_noise = i_input_noise
##########################################
   #time = np.linspace(0.0,timestep*num_samples,num_samples)
   #plt.plot(time,a_input_noise,time,b_input_noise,time,c_input_noise)
   #plt.title("noise")
   #plt.show()
##########################################
   # Digitized the incoming signal and noise (RITC)
   a_dig_waveform = digitize(a_input_signal_noise,num_samples,num_bits,digitization_factor)
   b_dig_waveform = digitize(b_input_signal_noise,num_samples,num_bits,digitization_factor)
   c_dig_waveform = digitize(c_input_signal_noise,num_samples,num_bits,digitization_factor)
   d_dig_waveform = digitize(d_input_signal_noise,num_samples,num_bits,digitization_factor)
   e_dig_waveform = digitize(e_input_signal_noise,num_samples,num_bits,digitization_factor)
   f_dig_waveform = digitize(f_input_signal_noise,num_samples,num_bits,digitization_factor)
   g_dig_waveform = digitize(g_input_signal_noise,num_samples,num_bits,digitization_factor)
   h_dig_waveform = digitize(h_input_signal_noise,num_samples,num_bits,digitization_factor)
   i_dig_waveform = digitize(i_input_signal_noise,num_samples,num_bits,digitization_factor)

##########################################
   """
   time = np.linspace(0.0,timestep*num_samples,num_samples)
   #plt.plot(time,a_dig_waveform,time,b_dig_waveform,time,c_dig_waveform)
   #plt.plot(time,d_dig_waveform,time,e_dig_waveform,time,f_dig_waveform)
   plt.plot(time,g_dig_waveform,time,h_dig_waveform,time,i_dig_waveform)
   plt.title("Digitized")
   plt.show()
   """
   
##########################################
   # Run the signal through the GLITC module to get trigger
   if(average_subtract_flag):
      
      abc_trigger_flag, abc_max_sum , abc_as_max_sum, abc_correlation_mean, abc_test_sum, abc_as_test_sum,as_abc_angle,abc_angle,d1,d2 = sum_correlate(num_samples,a_dig_waveform,b_dig_waveform,c_dig_waveform,threshold,abc_baseline,TISC_sample_length,delay_type_flag=delay_type_flag,
                                                average_subtract_flag=average_subtract_flag,correlation_mean=abc_correlation_mean,trial_run_number=trial_run_number)
      def_trigger_flag, def_max_sum , def_as_max_sum, def_correlation_mean, def_test_sum, def_as_test_sum,as_def_angle,def_angle,d1,d2 = sum_correlate(num_samples,d_dig_waveform,e_dig_waveform,f_dig_waveform,threshold,def_baseline,TISC_sample_length,delay_type_flag=delay_type_flag,
                                                average_subtract_flag=average_subtract_flag,correlation_mean=def_correlation_mean,trial_run_number=trial_run_number)
      ghi_trigger_flag, ghi_max_sum , ghi_as_max_sum, ghi_correlation_mean, ghi_test_sum, ghi_as_test_sum,as_ghi_angle,ghi_angle,d1,d2 = sum_correlate(num_samples,g_dig_waveform,h_dig_waveform,i_dig_waveform,threshold,ghi_baseline,TISC_sample_length,delay_type_flag=delay_type_flag,
                                                average_subtract_flag=average_subtract_flag,correlation_mean=ghi_correlation_mean,trial_run_number=trial_run_number)
      #abc_max_sum
      #print len(a_dig_waveform)  
   else:
      abc_trigger_flag, abc_max_sum,abc_andle,d1 = sum_correlate(num_samples,a_dig_waveform,b_dig_waveform,c_dig_waveform,threshold,abc_baseline,TISC_sample_length,delay_type_flag=delay_type_flag,
                                                average_subtract_flag=average_subtract_flag,correlation_mean=abc_correlation_mean,trial_run_number=trial_run_number)
      def_trigger_flag, def_max_sum,def_angle,d1 = sum_correlate(num_samples,d_dig_waveform,e_dig_waveform,f_dig_waveform,threshold,def_baseline,TISC_sample_length,delay_type_flag=delay_type_flag,
                                                average_subtract_flag=average_subtract_flag,correlation_mean=def_correlation_mean,trial_run_number=trial_run_number)
      ghi_trigger_flag, ghi_max_sum,ghi_angle,d1 = sum_correlate(num_samples,g_dig_waveform,h_dig_waveform,i_dig_waveform,threshold,ghi_baseline,TISC_sample_length,delay_type_flag=delay_type_flag,
                                                average_subtract_flag=average_subtract_flag,correlation_mean=ghi_correlation_mean,trial_run_number=trial_run_number)
      #print abc_max_sum
      #print def_max_sum
      #print ghi_max_sum
                                                
   #if(abc_trigger_flag & def_trigger_flag & ghi_trigger_flag):
      #trigger_flag = True
   #else:
      #trigger_flag = False
 

      
   

#########################################

   #dummy = raw_input('Press any key to close')

   if (average_subtract_flag):
      return abc_max_sum,abc_as_max_sum,def_max_sum,def_as_max_sum,ghi_max_sum,ghi_as_max_sum,abc_correlation_mean, def_correlation_mean, ghi_correlation_mean,as_abc_angle,abc_angle,as_def_angle,def_angle,as_ghi_angle,ghi_angle
   else:
      return abc_max_sum,def_max_sum,ghi_max_sum,abc_angle,def_angle,ghi_angle
def TISC_sim(SNR,threshold,
             b_input_delay,c_input_delay,num_bits=3,
             noise_sigma=32.0,
             sample_freq=2600000000.0,TISC_sample_length=16,
             num_samples=80,upsample=10,
             seed=5522684,draw_flag=0,digitization_factor=32.0,
             output_dir="output/",boresight=0,baseline=0,debug=False):
   
   # Setup
   save_output_flag = 0
   #if(save_output_flag):
      #outfile = str(output_dir+"/test.root")
   trigger_flag = 0
   #num_bits = 3 # Number of bits available to the digitizer
   #num_samples = num_samples*upsample
   filter_flag = False
   #sample_frequency = 2800000000.0
   def_max_sum = 0.0
   def_as_max_sum = 0.0
   ghi_max_sum = 0.0
   ghi_as_max_sum = 0.0
   timestep = 1.0/sample_freq
   
   
   
   # Phi sectors have alternating baselines
   if(boresight==0):
      abc_impulse_amp = 1.000
      def_impulse_amp = 0.835
   elif(boresight==1):
      abc_impulse_amp = 0.962
      def_impulse_amp = 0.885
   
   # Fill numpy arrays with zeros
   a_input_noise = np.zeros(num_samples)
   b_input_noise = np.zeros(num_samples)
   c_input_noise = np.zeros(num_samples)
   d_input_noise = np.zeros(num_samples)
   e_input_noise = np.zeros(num_samples)
   f_input_noise = np.zeros(num_samples)

   time = np.zeros(num_samples)
   upsampled_time = np.zeros(num_samples)
   a_input_signal = np.zeros(num_samples)
   b_input_signal = np.zeros(num_samples)
   c_input_signal = np.zeros(num_samples)
   d_input_signal = np.zeros(num_samples)
   e_input_signal = np.zeros(num_samples)
   f_input_signal = np.zeros(num_samples)

   a_input_signal_noise = np.zeros(num_samples)
   b_input_signal_noise = np.zeros(num_samples)
   c_input_signal_noise = np.zeros(num_samples)
   d_input_signal_noise = np.zeros(num_samples)
   e_input_signal_noise = np.zeros(num_samples)
   f_input_signal_noise = np.zeros(num_samples)

   a_dig_waveform = np.zeros(num_samples)
   b_dig_waveform = np.zeros(num_samples)
   c_dig_waveform = np.zeros(num_samples)
   d_dig_waveform = np.zeros(num_samples)
   e_dig_waveform = np.zeros(num_samples)
   f_dig_waveform = np.zeros(num_samples)
   
   empty_list = np.zeros(num_samples)


###################################
   # Generate Thermal Noise
   a_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+0)
   b_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+1)
   c_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+2)
   
   d_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+3)
   e_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+4)
   f_input_noise = generate_noise(num_samples,noise_sigma,filter_flag,seed=seed+5)
###################################


#####################################
   # Determine RMS of noise and signal amplitude

   #noise_rms = np.sqrt(np.mean((a_input_noise-noise_mean)**2,))
   
   signal_amp = SNR*2*noise_sigma

#####################################
      
   a_input_noise = butter_bandpass_filter(a_input_noise)
   b_input_noise = butter_bandpass_filter(b_input_noise)
   c_input_noise = butter_bandpass_filter(c_input_noise)
   
   d_input_noise = butter_bandpass_filter(d_input_noise)
   e_input_noise = butter_bandpass_filter(e_input_noise)
   f_input_noise = butter_bandpass_filter(f_input_noise)

 
#####################################
   # Generate impulse
   if (SNR != 0):
      # Generate Signal and Amplify
      a_input_signal = impulse_gen(num_samples,upsample,draw_flag=draw_flag,output_dir=output_dir)
      difference=np.amax(a_input_signal)-np.amin(a_input_signal) # Get peak to peak voltage
      a_input_signal *= (1/difference) # Normalize input
      a_input_signal *= signal_amp # Amplify
      #b_input_signal = np.concatenate([a_input_signal[:num_samples+b_input_delay],empty_list[:(-1)*b_input_delay]])
      #c_input_signal = np.concatenate([a_input_signal[:num_samples+c_input_delay],empty_list[:(-1)*c_input_delay]])
      b_input_signal = np.concatenate([a_input_signal[-b_input_delay:],empty_list[:(-1)*b_input_delay]])
      c_input_signal = np.concatenate([a_input_signal[-c_input_delay:],empty_list[:(-1)*c_input_delay]])
      
      
      
      a_input_signal =a_input_signal*abc_impulse_amp
      b_input_signal =b_input_signal*abc_impulse_amp
      c_input_signal =c_input_signal*abc_impulse_amp
      
      d_input_signal =a_input_signal*def_impulse_amp
      e_input_signal =b_input_signal*def_impulse_amp
      f_input_signal =c_input_signal*def_impulse_amp
      
      """
      time = np.linspace(0.0,timestep*num_samples,num_samples)
      plt.plot(time,a_input_signal,time,b_input_signal,time,c_input_signal)
      plt.plot(time,d_input_signal,time,e_input_signal,time,f_input_signal)
      plt.plot(time,g_input_signal,time,h_input_signal,time,i_input_signal)
      plt.title("impulse")
      plt.show()  
      """
      # Add the signal to the noise
      a_input_signal_noise = np.add(a_input_noise, a_input_signal)
      b_input_signal_noise = np.add(b_input_noise, b_input_signal)
      c_input_signal_noise = np.add(c_input_noise, c_input_signal)
      
      d_input_signal_noise = np.add(d_input_noise, d_input_signal)
      e_input_signal_noise = np.add(e_input_noise, e_input_signal)
      f_input_signal_noise = np.add(f_input_noise, f_input_signal)

      """
      time = np.linspace(0.0,timestep*num_samples,num_samples)
      plt.plot(time,a_input_signal_noise,time,b_input_signal_noise,time,c_input_signal_noise)
      plt.plot(time,d_input_signal_noise,time,e_input_signal_noise,time,f_input_signal_noise)
      #plt.plot(time,g_input_signal_noise,time,h_input_signal_noise,time,i_input_signal_noise)
      plt.title("impulse+noise")
      plt.show()
      """
   else:
      a_input_signal_noise = a_input_noise
      b_input_signal_noise = b_input_noise
      c_input_signal_noise = c_input_noise
      
      d_input_signal_noise = d_input_noise
      e_input_signal_noise = e_input_noise
      f_input_signal_noise = f_input_noise

##########################################
   #time = np.linspace(0.0,timestep*num_samples,num_samples)
   #plt.plot(time,a_input_noise,time,b_input_noise,time,c_input_noise)
   #plt.title("noise")
   #plt.show()
##########################################
   # Digitized the incoming signal and noise (RITC)
   a_dig_waveform = digitize(a_input_signal_noise,num_samples,num_bits,digitization_factor)
   b_dig_waveform = digitize(b_input_signal_noise,num_samples,num_bits,digitization_factor)
   c_dig_waveform = digitize(c_input_signal_noise,num_samples,num_bits,digitization_factor)
   
   d_dig_waveform = digitize(d_input_signal_noise,num_samples,num_bits,digitization_factor)
   e_dig_waveform = digitize(e_input_signal_noise,num_samples,num_bits,digitization_factor)
   f_dig_waveform = digitize(f_input_signal_noise,num_samples,num_bits,digitization_factor)


##########################################
   """
   time = np.linspace(0.0,timestep*num_samples,num_samples)
   plt.plot(time,a_dig_waveform,time,b_dig_waveform,time,c_dig_waveform)
   plt.plot(time,d_dig_waveform,time,e_dig_waveform,time,f_dig_waveform)
   #plt.plot(time,g_dig_waveform,time,h_dig_waveform,time,i_dig_waveform)
   plt.title("Digitized")
   plt.show()
   """
   
##########################################
   # Run the signal through the GLITC module to get trigger

   trigger_flag, max_total_sum,best_angle,total_sum = sum_correlate(num_samples,a_dig_waveform,b_dig_waveform,c_dig_waveform,d_dig_waveform,e_dig_waveform,f_dig_waveform,baseline,threshold,TISC_sample_length,debug=debug)
   #print abc_max_sum
   #print def_max_sum
   #print ghi_max_sum
                                             

 

      
   

#########################################

   #dummy = raw_input('Press any key to close')


   return max_total_sum,best_angle
Пример #7
0
def TISC_sim(SNR,
             threshold,
             b_input_delay,
             c_input_delay,
             num_bits=3,
             noise_sigma=32.0,
             sample_freq=2600000000.0,
             TISC_sample_length=16,
             num_samples=74,
             upsample=10,
             cw_flag=0,
             cw_rms=25.0,
             carrier_frequency=260000000.0,
             modulation_frequency=1.0,
             seed=5522684,
             draw_flag=0,
             digitization_factor=32.0,
             delay_type_flag=1,
             output_dir="output/",
             average_subtract_flag=0,
             correlation_mean=np.zeros(44),
             trial_run_number=1):

    #print b_input_delay
    # Setup
    save_output_flag = 0
    #if(save_output_flag):
    #outfile = str(output_dir+"/test.root")
    trigger_flag = 0
    #num_bits = 3 # Number of bits available to the digitizer
    filter_flag = False
    #print SNR

    # Fill numpy arrays with zeros
    a_input_noise = np.zeros(num_samples)
    b_input_noise = np.zeros(num_samples)
    c_input_noise = np.zeros(num_samples)
    a_input_noise_test = np.zeros(num_samples)
    b_input_noise_test = np.zeros(num_samples)
    c_input_noise_test = np.zeros(num_samples)
    a_input_signal = np.zeros(num_samples)
    b_input_signal = np.zeros(num_samples)
    c_input_signal = np.zeros(num_samples)
    a_dig_waveform = np.zeros(num_samples)
    b_dig_waveform = np.zeros(num_samples)
    c_dig_waveform = np.zeros(num_samples)
    cw_noise = np.zeros(num_samples)
    empty_list = np.zeros(num_samples)

    ###################################
    # Generate Thermal Noise
    a_input_noise = generate_noise(num_samples, noise_sigma, filter_flag)
    b_input_noise = generate_noise(num_samples, noise_sigma, filter_flag)
    c_input_noise = generate_noise(num_samples, noise_sigma, filter_flag)
    #a_input_noise_test = a_input_noise
    #b_input_noise_test = b_input_noise
    #c_input_noise_test = c_input_noise
    ###################################

    #print a_input_noise[0]
    #print b_input_noise[0]
    #print c_input_noise[0]
    #####################################
    # Determine signal amplitude
    signal_amp = SNR * 2 * noise_sigma
    #####################################

    #################################
    #Generate CW & thermal noise

    if cw_flag:
        cw_noise = generate_cw(num_samples, upsample, sample_freq,
                               carrier_frequency, modulation_frequency, cw_rms,
                               filter_flag)
        a_input_noise = np.add(a_input_noise, cw_noise)
        #cw_noise = generate_cw(num_samples,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
        b_input_noise = np.add(b_input_noise, cw_noise)
        #cw_noise = generate_cw(num_samples,sample_freq,carrier_frequency,modulation_frequency,peak_amplitude,filter_flag)
        c_input_noise = np.add(c_input_noise, cw_noise)

#####################################

# Filter the noise
    a_input_noise = butter_bandpass_filter(a_input_noise)
    b_input_noise = butter_bandpass_filter(b_input_noise)
    c_input_noise = butter_bandpass_filter(c_input_noise)
    #print "Filter Took: " +str(datetime.now()-start_filter)
    #start_signal = datetime.now()
    #####################################
    # Generate impulse
    if (SNR != 0):
        # Generate Signal and Amplify
        a_input_signal = impulse_gen(num_samples,
                                     upsample,
                                     draw_flag=draw_flag,
                                     output_dir=output_dir)
        difference = np.amax(a_input_signal) - np.amin(
            a_input_signal)  # Get peak to peak voltage

        a_input_signal *= (1 / difference)  # Normalize input
        a_input_signal *= signal_amp  # Amplify
        b_input_signal = np.concatenate([
            a_input_signal[:num_samples + b_input_delay],
            empty_list[:(-1) * b_input_delay]
        ])
        c_input_signal = np.concatenate([
            a_input_signal[:num_samples + c_input_delay],
            empty_list[:(-1) * c_input_delay]
        ])

        # Add the signal to the noise
        a_input_signal = np.add(a_input_noise, a_input_signal)
        b_input_signal = np.add(b_input_noise, b_input_signal)
        c_input_signal = np.add(c_input_noise, c_input_signal)
    else:
        a_input_signal = a_input_noise
        b_input_signal = b_input_noise
        c_input_signal = c_input_noise


##########################################

##########################################
# Digitized the incoming signal and noise (RITC)
    a_dig_waveform = digitize(a_input_signal, num_samples, num_bits,
                              digitization_factor)
    b_dig_waveform = digitize(b_input_signal, num_samples, num_bits,
                              digitization_factor)
    c_dig_waveform = digitize(c_input_signal, num_samples, num_bits,
                              digitization_factor)

    ##########################################
    #print a_dig_waveform

    ##########################################
    # Run the signal through the GLITC module to get trigger
    if (average_subtract_flag):
        trigger_flag, max_sum, as_max_sum, correlation_mean, test_sum, as_test_sum = sum_correlate(
            num_samples,
            a_dig_waveform,
            b_dig_waveform,
            c_dig_waveform,
            threshold,
            TISC_sample_length,
            delay_type_flag=delay_type_flag,
            average_subtract_flag=average_subtract_flag,
            correlation_mean=correlation_mean,
            trial_run_number=trial_run_number)
    else:
        trigger_flag, max_sum, test_sum = sum_correlate(
            num_samples,
            a_dig_waveform,
            b_dig_waveform,
            c_dig_waveform,
            threshold,
            TISC_sample_length,
            delay_type_flag=delay_type_flag,
            average_subtract_flag=average_subtract_flag,
            correlation_mean=correlation_mean)
    """
   if (max_sum>800):
      import matplotlib.pyplot as plt
      #print a_dig_waveform
      #print b_dig_waveform
      #print c_dig_waveform
      #print np.add(np.add(a_dig_waveform,b_dig_waveform),c_dig_waveform)
      #print (np.add(np.add(a_dig_waveform,b_dig_waveform),c_dig_waveform))**2
      #print np.sum((np.add(np.add(a_dig_waveform,b_dig_waveform),c_dig_waveform))**2)
      time = np.linspace(0.0,((num_samples*(10**9))/sample_freq), num_samples)
      plt.figure(1)
      plt.clf()
      plt.plot(time,a_dig_waveform)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("Ch A")
      plt.savefig(output_dir+"/ch_A_large_correlation.png")
      plt.figure(2)
      plt.clf()
      plt.plot(time,b_dig_waveform)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("Ch B")
      plt.savefig(output_dir+"/ch_B_large_correlation.png")
      plt.figure(3)
      plt.clf()
      plt.plot(time,c_dig_waveform)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("Ch C")
      plt.savefig(output_dir+"/ch_C_large_correlation.png")
      plt.figure(4)
      plt.clf()
      plt.plot(time,np.add(np.add(a_dig_waveform,b_dig_waveform),c_dig_waveform))
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("ABC Added")
      plt.savefig(output_dir+"/ABC_large_correlation.png")
      plt.figure(5)
      plt.clf()
      plt.plot(time,(np.add(np.add(a_dig_waveform,b_dig_waveform),c_dig_waveform))**2)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("ABC Square Added")
      plt.savefig(output_dir+"/ABC_square_large_correlation.png")
      plt.figure(6)
      plt.clf()
      plt.plot(time,a_input_noise_test)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("Ch A Thermal Noise")
      plt.savefig(output_dir+"/ch_A_thermal_large_correlation.png")
      plt.figure(7)
      plt.clf()
      plt.plot(time,b_input_noise_test)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("Ch B Thermal Noise")
      plt.savefig(output_dir+"/ch_B_thermal_large_correlation.png")
      plt.figure(8)
      plt.clf()
      plt.plot(time,c_input_noise_test)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("Ch C Thermal Noise")
      plt.savefig(output_dir+"/ch_C_thermal_large_correlation.png")
      plt.figure(9)
      plt.clf()
      plt.plot(time,cw_noise)
      plt.xlabel("Time [ns]")
      plt.ylabel("Amplitude [unitless]")
      plt.title("CW Noise")
      plt.savefig(output_dir+"/cw_large_correlation.png")
      plt.show()
      """
    #########################################

    #########################################
    # Output data
    #if(save_output_flag):
    # Now to more ROOT stuff
    #rf_tree.Fill()
    #f.Write()
    #f.Close()

    if draw_flag:
        dummy = raw_input('Press any key to close')

    #print "Everything took: " +str(datetime.now()-start_time)
    if (average_subtract_flag):
        return trigger_flag, max_sum, as_max_sum, correlation_mean, test_sum, as_test_sum
    else:
        return trigger_flag, max_sum
    a_delay = 0
    b_delay = -15
    c_delay = -17
    TISC_sample_length = 16
    delay_type_flag = 1
    average_subtract_flag = 1
    correlation_mean = np.zeros(63)
    correlation_mean.fill(50)
    filter_flag = 0
    debug = False
    timestep = 1.0 / 2600000000.0
    t = np.linspace(0, timestep * num_samples, num_samples)
    signal_amp = SNR * 2 * noise_sigma

    for i in range(0, 1):
        a_waveform = impulse_gen(num_samples, a_delay, upsample, draw_flag=0, output_dir="output/")
        empty_list = np.zeros(num_samples)
        difference = np.amax(a_waveform) - np.amin(a_waveform)  # Get peak to peak voltage
        a_waveform *= 1 / difference  # Normalize input
        a_waveform *= signal_amp  # Amplify
        a_imp_dig_wfm = digitize(a_waveform, num_samples, num_bits, digitization_factor=noise_sigma)
        a_waveform = np.add(a_waveform, generate_noise(num_samples, noise_sigma, filter_flag))
        b_waveform = np.concatenate([a_waveform[-b_delay:], empty_list[: (-1) * b_delay]])
        c_waveform = np.concatenate([a_waveform[-c_delay:], empty_list[: (-1) * c_delay]])
        b_waveform = np.add(b_waveform, generate_noise(num_samples, noise_sigma, filter_flag))
        c_waveform = np.add(c_waveform, generate_noise(num_samples, noise_sigma, filter_flag))

        d_waveform = np.add(a_waveform, generate_noise(num_samples, noise_sigma, filter_flag))
        e_waveform = np.concatenate([d_waveform[-b_delay:], empty_list[: (-1) * b_delay]])
        f_waveform = np.concatenate([d_waveform[-c_delay:], empty_list[: (-1) * c_delay]])
        e_waveform = np.add(b_waveform, generate_noise(num_samples, noise_sigma, filter_flag))
Пример #9
0
	upsample_length = upsample*sample_length

	impulse_sample = np.zeros(sample_length)
	impulse_upsample = np.zeros(upsample_length)
	impulse_downsample = np.zeros(sample_length)
	#impulse_upsample_fit_poly = np.zeros(poly_index)
	impulse_upsample_fit = np.zeros(upsample_length)
	impulse_noise_sample = np.zeros(sample_length)
	digitized_sample = np.zeros(sample_length)
	noise_sample = np.zeros(sample_length)
	cw_sample = np.zeros(sample_length)
	#noise_cw_sample = np.zeros(sample_length)

	time = np.linspace(0.0,((sample_length*(10**9))/sample_frequency), sample_length)
	impulse_sample = impulse_gen(sample_length,impulse_position,upsample,sample_frequency,draw_flag=draw_flag,output_dir=output_dir)
	
	
	"""
	upsample_time = np.linspace(0.0,((upsample_length*(10**9))/(sample_frequency*upsample)), upsample_length)
	plt.figure(2,figsize=(16,8))
	plt.clf()
	plt.plot(upsample_time,impulse_upsample[0:upsample_length])
	plt.xlabel("Time [ns]")
	plt.ylabel("Amplitude [unitless]")
	plt.title("Upsampled Impulse Simulation")
	if (save_plot_flag):
		plt.savefig("plots/upsample_impulse_sample.png")
	"""
	signal_amp = (2*SNR*noise_sigma)
	difference=np.amax(impulse_sample)-np.amin(impulse_sample) # Get peak to peak voltage