def butter_bandpass_filter(data, lowcut=180000000.0, highcut=1200000000.0, fs=2600000000.0, order=8):
from noise import generate_noise
b, a = butter_bandpass(lowcut, highcut, fs, order=order)
y = generate_noise(len(a),noise_sigma=32.0,filter_flag=0)
x = np.linspace(0.0,(1.0/fs)*len(data),len(b))
zi = lfiltic(b,a,y,x)
y,zf = lfilter(b,a,data,zi=zi)
return y
def butter_bandpass_filter(data,
lowcut=180000000.0,
highcut=1200000000.0,
fs=2600000000.0,
order=8):
from noise import generate_noise
b, a = butter_bandpass(lowcut, highcut, fs, order=order)
y = generate_noise(len(a), noise_sigma=32.0, filter_flag=0)
x = np.linspace(0.0, (1.0 / fs) * len(data), len(b))
zi = lfiltic(b, a, y, x)
y, zf = lfilter(b, a, data, zi=zi)
return y
def generateData(args,mode):
if mode=="train":
batchnum=args.num_block
elif mode=="test":
batchnum=args.num_test_block
X_train=np.random.randint(0,2,(batchnum,args.block_len, args.code_rate_k))
noise_shape = (batchnum,args.block_len, args.code_rate_k)
this_sigma,this_snr=getnoisesigma(args.train_channel_low,args.train_channel_high)
# print("batch_idx=",batch_idx,"noise sigma=",this_sigma,"this_snr=",this_snr)
fwd_noise = generate_noise(noise_shape, args, this_sigma)
codes=X_train
received_codes=codes + fwd_noise
inputdata=received_codes
return (inputdata,fwd_noise)
def test(args,model,turbo,use_cuda=False,verbose=True):
device = torch.device("cuda" if use_cuda else "cpu")
model.eval()
ber_res=[]
snr_interval=(args.snr_test_end-args.snr_test_start)*1.0/(args.snr_points-1)
snrs=[snr_interval*item+args.snr_test_start for item in range(args.snr_points)]
print("SNRS:",snrs)
sigmas=snrs
for sigma,this_snr in zip(sigmas,snrs):
num_test_batch=int(args.num_block/(args.batch_size))
test_ber=0.0
train_ber=0.0
for batch_idx in range(num_test_batch):
X_test = torch.randint(0, 2, (args.batch_size, args.block_len, args.code_rate_k), dtype=torch.float)
noise_shape = (args.batch_size, args.block_len, args.code_rate_n)
fwd_noise = generate_noise(noise_shape, args, sigma)
X_test, fwd_noise= X_test.to(device), fwd_noise.to(device)
num_block=X_test.shape[0]
x_code=[]
for idx in range(num_block):
np_inputs=np.array(X_test[idx,:,0].type(torch.IntTensor).detach())
[sys,par1,par2]=turbo.encoder(np_inputs)
xx = np.array([sys, par1, par2]).T
decodebits=turbo.decoder(xx,this_snr)
x_code.append(xx)
# train_ber+=calber(np_inputs,decodebits[:,0])
codes=torch.from_numpy(np.array(x_code)).type(torch.FloatTensor)
codes=2.0*codes-1.0
received_codes=codes + fwd_noise
noisemap=sigma*torch.ones(args.batch_size, args.block_len, 1)
inputdata=torch.cat((noisemap,received_codes),2)
output=model(inputdata)
np_outputs=np.array(output.type(torch.IntTensor).detach())
np_outputs=np_outputs>0
x_code=np.array(x_code)
test_ber=test_ber+np.sum(np.bitwise_xor(np_outputs,x_code),axis=(0,1,2))
# output=received_codes
# for idx in range(num_block):
# np_inputs=np.array(output[idx,:,:].type(torch.IntTensor).detach())
# decodebits=turbo.decoder(np_inputs,this_snr)
# y_true=np.array(X_test[idx,:,0].type(torch.IntTensor).detach())
# test_ber+=calber(y_true,decodebits[:,0])
test_ber/=(num_test_batch*args.batch_size*args.block_len* args.code_rate_n)
train_ber/=(num_test_batch*args.batch_size*args.block_len* args.code_rate_k)
print("snr=",this_snr,"trainber=",train_ber,"testber=",test_ber)
ber_res.append(test_ber)
print("BERS:",ber_res)
def validate(args,model,epoch,optimizer,criterion,turbo,use_cuda=False,verbose=True):
device = torch.device("cuda" if use_cuda else "cpu")
model.eval()
test_loss= 0.0
test_ber=0.0
with torch.no_grad():
num_test_batch = int(args.num_block/args.batch_size * args.test_ratio)
for batch_idx in range(num_test_batch):
channel=1
X_test = torch.randint(0, 2, (args.batch_size, channel,args.block_len, args.code_rate_k), dtype=torch.float)
noise_shape = (args.batch_size, channel,args.block_len, args.code_rate_k)
this_sigma,this_snr=getnoisesigma(args.train_channel_low,args.train_channel_high)
# print("batch_idx=",batch_idx,"noise sigma=",this_sigma,"this_snr=k",this_snr)
fwd_noise = generate_noise(noise_shape, args, this_sigma)
X_test, fwd_noise= X_test.to(device), fwd_noise.to(device)
optimizer.zero_grad()
# num_block=X_test.shape[0]
# x_code=[]
# for idx in range(num_block):
# np_inputs=np.array(X_test[idx,:,0].type(torch.IntTensor).detach())
# [sys,par1,par2]=turbo.encoder(np_inputs)
# xx = np.array([sys, par1, par2]).T
# x_code.append(xx)
# codes=torch.from_numpy(np.array(x_code)).type(torch.FloatTensor)
codes=X_test
# codes=2.0*codes-1.0
received_codes=codes + fwd_noise
noisemap=this_sigma*torch.ones(args.batch_size, args.block_len, 1)
# inputdata=torch.cat((noisemap,received_codes),2)
inputdata=received_codes
output=model(inputdata)
test_loss += F.mse_loss(output, fwd_noise)
denoisesig=received_codes-output
denoisesig=torch.clamp(denoisesig,0,1)
np_outputs=denoisesig.data.numpy()
np_outputs=np.round(np_outputs)
# x_code=np.array(x_code)
x_code=np.array(codes.type(torch.IntTensor).detach())
test_ber=test_ber+np.sum(np.logical_xor(np_outputs,x_code),axis=(0,1,2,3))
test_loss /= num_test_batch
test_ber/=(num_test_batch*args.batch_size*args.block_len* args.code_rate_k)
if verbose:
print('====> Test set MSE loss', float(test_loss),"===>Test set BER ",float(test_ber))
def trainer(args,model,epoch,optimizer,criterion,turbo,use_cuda=False,verbose=True):
device = torch.device("cuda" if use_cuda else "cpu")
model.train()
start_time = time.time()
train_loss = 0.0
for batch_idx in range(int(args.num_block/args.batch_size)):
optimizer.zero_grad()
model.zero_grad()
block_len = args.block_len
channel=1
X_train = torch.randint(0, 2, (args.batch_size, channel,block_len, args.code_rate_k), dtype=torch.float)
noise_shape = (args.batch_size, channel,args.block_len, args.code_rate_k)
this_sigma,this_snr=getnoisesigma(args.train_channel_low,args.train_channel_high)
# print("batch_idx=",batch_idx,"noise sigma=",this_sigma,"this_snr=",this_snr)
fwd_noise = generate_noise(noise_shape, args, this_sigma)
X_train, fwd_noise = X_train.to(device), fwd_noise.to(device)
num_block=X_train.shape[0]
# x_code=[]
# for idx in range(num_block):
# np_inputs=np.array(X_train[idx,:,0].type(torch.IntTensor).detach())
# [sys,par1,par2]=turbo.encoder(np_inputs)
# xx = np.array([sys, par1, par2]).T
# x_code.append(xx)
# codes=torch.from_numpy(np.array(x_code)).type(torch.FloatTensor)
codes=X_train
# codes=2.0*codes-1.0
received_codes=codes + fwd_noise
noisemap=this_sigma*torch.ones(args.batch_size, args.block_len, 1)
# inputdata=torch.cat((noisemap,received_codes),2)
inputdata=received_codes
output=model(inputdata)
loss = criterion(output, fwd_noise)
loss.backward()
train_loss += loss.item()
optimizer.step()
# for name,parms in model.named_parameters():
# print("--->name:",name,"--->grad_requirs:",parms.requires_grad,"--->grad_value:",parms.grad)
end_time = time.time()
train_loss = train_loss /(args.num_block/args.batch_size)
if verbose:
print('====> Epoch: {} Average loss: {:.8f}'.format(epoch, train_loss),' running time', str(end_time - start_time))
return train_loss
def __init__(self, seismic=None):
self.g = -9.81 # gravity constant
self.m0 = 10.0 # mass of cart
self.m1 = 0.5 # mass of pole 1
self.m2 = 0.5 # mass of pole 2
self.L1 = 1 # length of pole 1
self.L2 = 1 # length of pole 2
self.l1 = self.L1 / 2 # distance from pivot point to center of mass
self.l2 = self.L2 / 2 # distance from pivot point to center of mass
self.I1 = self.m1 * (
self.L1
^ 2) / 12 # moment of inertia of pole 1 w.r.t its center of mass
self.I2 = self.m2 * (
self.L2
^ 2) / 12 # moment of inertia of pole 2 w.r.t its center of mass
self.tau = 0.02 # seconds between state updates
self.counter = 0
self.seismic = seismic
self.friction = 0.98
if seismic is None:
self.seismic = noise.generate_noise(fs=4000, amplify=100)
# self.seismic = noise.generate_noise()
# Angle at which to fail the episode
#self.theta_threshold_radians = 12 * 2 * math.pi / 360
# # (never fail the episode based on the angle)
self.theta_threshold_radians = 100000 * 2 * math.pi / 360
self.x_threshold = 2.4
self.x2_threshold = 1
# Angle limit set to 2 * theta_threshold_radians so failing observation is still within bounds
high = np.array([
self.x_threshold * 2,
np.finfo(np.float32).max, self.theta_threshold_radians * 2,
np.finfo(np.float32).max
])
self.action_space = spaces.Discrete(3)
self.observation_space = spaces.Box(-high, high, dtype=np.float32)
self.viewer = None
# Just need to initialize the relevant attributes
self.configure()
'noisy_labels': [],
'loss_history': [],
'labeled_idxs': [],
'lr': []
}
"""
################################# Prepare Data ###############################
"""
print('==> Preparing data..')
trainset, valset, testset, num_classes =\
datasets.__dict__[args.dataset](args.final_run, args.val_size)
args.num_classes = num_classes
analysis_dict['clean_labels'].append(deepcopy(trainset.targets)) # num : 45000
trainset, clean_idxs_train, noisy_idxs_train = generate_noise(
args.dataset, trainset, args.noise_type, args.noise_ratio)
analysis_dict['noisy_labels'].append(deepcopy(trainset.targets)) # num : 45000
if args.noisy_validation:
valset, clean_idxs_val, noisy_idxs_val = generate_noise(
args.dataset, valset, args.noise_type, args.noise_ratio)
transform_test = deepcopy(testset.transform)
filtered_trainset = deepcopy(trainset)
trainset.transform = transform_test
filtered_trainloader = DataLoader(filtered_trainset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
trainloader = DataLoader(trainset,
import numpy as np
from noise import generate_noise
import matplotlib.pyplot as plt
debug=True
num_samples = 128
num_bits = 3
noise_sigma = 32.0
digitization_factor = 32.0
sample_frequency = 2600000000.0
sample_noise = np.zeros(num_samples)
dig_waveform = np.zeros(num_samples)
sine_waveform = np.zeros(num_samples)
sample_noise = generate_noise(num_samples,noise_sigma=noise_sigma,filter_flag=1)
for i in range(0,int(num_samples)):
sine_waveform[i] = 3.0*noise_sigma*np.sin(2*np.pi*50000000.0*(float(i)/sample_frequency))
sample = sine_waveform + sample_noise
#sample = sample_noise
dig_waveform = digitize(sample,num_samples,num_bits,digitization_factor,debug=debug)
t = np.linspace(0,(1/2800000000.0)*num_samples*(10**9),num_samples)
plt.figure()
plt.clf()
plt.plot(t,dig_waveform,label="Digitized Noise")
plt.title("Digitized Noise")
plt.xlabel("Time [ns]")
from noise import generate_noise
import matplotlib.pyplot as plt
debug = True
num_samples = 128
num_bits = 3
noise_sigma = 32.0
digitization_factor = 32.0
sample_frequency = 2600000000.0
sample_noise = np.zeros(num_samples)
dig_waveform = np.zeros(num_samples)
sine_waveform = np.zeros(num_samples)
sample_noise = generate_noise(num_samples,
noise_sigma=noise_sigma,
filter_flag=1)
for i in range(0, int(num_samples)):
sine_waveform[i] = 3.0 * noise_sigma * np.sin(
2 * np.pi * 50000000.0 * (float(i) / sample_frequency))
sample = sine_waveform + sample_noise
#sample = sample_noise
dig_waveform = digitize(sample,
num_samples,
num_bits,
digitization_factor,
debug=debug)
t = np.linspace(0, (1 / 2800000000.0) * num_samples * (10**9), num_samples)
from noise import generate_noise
from mask import generate_mask
from PIL import Image
import numpy as np
from sys import argv
WIDTH = 512
HEIGHT = 512
MAX_BYTE_VAL = 255
if __name__ == '__main__':
count = 6
if len(argv) > 1:
count = int(argv[1])
data = generate_noise(WIDTH, HEIGHT, octaveCount=count)
mask = generate_mask(WIDTH, HEIGHT)
data *= mask
img = Image.fromarray(np.uint8(data * MAX_BYTE_VAL))
img.save('out.png')
import numpy as np
import gym
from keras.models import Sequential
from keras.layers import Dense, Activation, Flatten
from keras.optimizers import Adam
from rl.agents.dqn import DQNAgent
from rl.policy import BoltzmannQPolicy
from rl.memory import SequentialMemory
import noise
ENV_NAME = 'ligo_environment:two-stage-v1'
seismic = noise.generate_noise()
# Get the environment and extract the number of actions.
env = gym.make(ENV_NAME, seismic=seismic)
np.random.seed(123)
env.seed(123)
nb_actions = env.action_space.n
# Next, we build a very simple model.
model = Sequential()
# model.add(Flatten(input_shape=(6, 1) + env.observation_space.shape))
model.add(Flatten(input_shape=(1,6,1)))
model.add(Dense(16))
model.add(Activation('relu'))
model.add(Dense(16))
model.add(Activation('relu'))
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))
f_waveform = np.add(c_waveform, generate_noise(num_samples, noise_sigma, filter_flag))
# a_waveform[40]=3.5
# a_waveform[41]=-3.5
a_dig_waveform = digitize(a_waveform, num_samples, num_bits, digitization_factor=noise_sigma)
b_dig_waveform = digitize(b_waveform, num_samples, num_bits, digitization_factor=noise_sigma)
impulse_sample *= (1/difference) # Normalize input
impulse_sample *= signal_amp # Amplify
plt.figure(1,figsize=(16,8))
plt.clf()
plt.plot(time,impulse_sample[0:sample_length])
plt.xlabel("Time [ns]")
plt.ylabel("Amplitude [mV]")
plt.title("Impulse Simulation")
if (save_plot_flag):
plt.savefig("plots/impulse_sample.png")
b_impulse_sample = np.roll(impulse_sample,-15)
c_impulse_sample = np.roll(impulse_sample,-17)
#print b_impulse_sample
#print c_impulse_sample
noise_sample = generate_noise(sample_length=sample_length,noise_sigma=noise_sigma,filter_flag=0)
b_noise_sample = generate_noise(sample_length=sample_length,noise_sigma=noise_sigma,filter_flag=0)
c_noise_sample = generate_noise(sample_length=sample_length,noise_sigma=noise_sigma,filter_flag=0)
plt.figure(3,figsize=(16,8))
plt.clf()
plt.plot(time,noise_sample)
plt.xlabel("Time [ns]")
plt.ylabel("Voltage [mV]")
plt.title("Band Limited Noise Sample")
if (save_plot_flag):
plt.savefig("plots/noise_sample.png")
plt.figure(4,figsize=(16,8))
plt.clf()
test_noise = generate_noise(sample_length=sample_length*1000,noise_sigma=noise_sigma,filter_flag=False)
plt.hist(test_noise,bins=100,normed=True,label="N = 80,000")
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=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_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))
#a_waveform[40]=3.5
#a_waveform[41]=-3.5
a_dig_waveform = digitize(a_waveform,
num_samples,
num_bits,
digitization_factor=noise_sigma)
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
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
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
