def fitter_timing(datadate,samplerate_name,shaping):
if samplerate_name == 'INVALID':
return("Failed")
t_fitter,v_fitter,_ = rw('G:/data/watchman/'+datadate+'_watchman_spe/d2/d2_average.txt',1)
uspl = us(t_fitter,v_fitter)
filedir = 'G:/data/watchman/'+str(datadate)+'_watchman_spe/studies/phase/'+samplerate_name+'/'
Nloops = len(os.listdir(filedir + 'phase=0/phase_'+shaping))
for i in range(Nloops):
print(i)
filename_exact = 'G:/data/watchman/'+str(datadate)+'_watchman_spe/d3/d3_raw_gained/D3--waveforms--%05d.txt' % i
t,v,_ = rw(filename_exact,5)
v = -1*v
ET = t[0:400]
EV = v[0:400]
chi2_min = -1
x_min = -1
y_min = -1
shift_min = -1
shifts = np.arange(0,80/20000000000,1e-11)
for shift in shifts:
pre_OV = uspl(ET + shift)
A = np.array([[np.sum(np.square(pre_OV)),np.sum(pre_OV),np.sum(np.multiply(pre_OV,EV))],[np.sum(pre_OV),len(EV),np.sum(EV)]])
A[0] = A[0]/A[0][0]
A[1] = np.subtract(A[1],A[1][0]*A[0])
A[1] = A[1]/A[1][1]
A[0] = np.subtract(A[0],A[0][1]*A[1])
x = A[0][2]
y = A[1][2]
OV = x*pre_OV + y
chi2 = chi_squared(OV,EV)
if chi2_min < 0:
shift_min = shift
chi2_min = chi2
x_min = x
y_min = y
elif chi2 < chi2_min:
shift_min = shift
chi2_min = chi2
x_min = x
y_min = y
v_fit = x_min*uspl(t_fitter + shift_min) + y_min
t_cross = timing_extraction(t_fitter,v_fit)
if t_cross <= -0.5e-10 or chi2_min >= 7.95e-5 or t_cross >= 0.5e-10:
fig,ax = plt.subplots()
ax.plot(t,v)
ax.plot(t_fitter,v_fit)
ax.axvline(0,color = 'Black')
ax.axvline(t_cross,color = 'Red')
ax.set_title(str(t_cross) + ', ' + str(chi2_min) + ', ' + str(i))
plt.get_current_fig_manager().window.showMaximized()
plt.show(block = False)
plt.pause(0.1)
fig.savefig('G:/data/watchman/20190724_watchman_spe/studies/phase/Histograms/'+samplerate_name+'/Doubles/%05d.png' % i,dpi = 500)
print("Was double!")
plt.close()
return("Passed")
def p3(noise, datadate, numhead, fsps, new_fsps, gain_noise, gain_factor_2,
gain_factor_4, gain_factor_8, start_index, steps, scale_array):
#establishing directory names
if new_fsps == 1000000000:
sample_rate = '1 Gsps'
elif new_fsps == 500000000:
sample_rate = '500 Msps'
elif new_fsps == 250000000:
sample_rate = '250 Msps'
else:
sample_rate = 'trash'
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d2/d2_average.txt'
writedir = 'G:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/averages/phase=' + str(
start_index) + '/phase_raw_gained_analyzed/'
#creating directories if they don't exist
if not os.path.exists(writedir):
os.makedirs(writedir)
t, v, header = rw(filename, numhead)
Nloops = len(scale_array) #establishing how many files to cycle through
for i in range(Nloops):
scale_height = scale_array[i] / np.max(v)
v_scaled = v * scale_height
print('%s/%s, File: %05d' %
(start_index + 1, steps,
i)) #printing number of file currently being processed
#establishing read and write names
writename = writedir + 'Phase--waveforms--%05d.txt' % i
#downsampling waveform values
(t_down, v_down) = downsampling(t - start_index * 1 / 20000000000,
v_scaled, fsps, new_fsps, start_index)
#digitizing waveform values
v_digit = digitize(v_down, noise)
#saving downsampled and digitized waveforms
write_waveform(t_down, v_digit, writename, header)
def determine(datadate, numhead):
Nloops = len(
os.listdir('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_50centered'))
writename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_histograms/charge.txt'
if not os.path.exists('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_histograms/histogram_images'):
os.makedirs('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_histograms/histogram_images')
#determining charge
for i in range(Nloops):
print(i)
area = 0
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_50centered/D1--waveforms--%05d.txt' % i
(t, y, _) = rw(filename, numhead)
#determining area under curve
for i in range(len(y) - 1):
area += ((t[i + 1] - t[i]) * y[i])
charge = str(
-1 * area / 50
) #area under curve/resistance gives charge, made positive for graphical reasons
wh(charge, writename)
#create histogram from saved file
(histo_mean, histo_std) = gh(writename)
rh(writename, "Coulombs", "Histogram of Charges", "Charge", datadate,
histo_mean, histo_std)
def determine(datadate,numhead,directory):
Nloops = len(os.listdir('G:/data/watchman/'+datadate+'_watchman_spe/d2/d2_'+directory))
if directory == 'raw':
Nloops -= 1
writename = 'G:/data/watchman/'+datadate+'_watchman_spe/d2/d2_histograms/10_90_rise_time_'+directory+'.txt'
if not os.path.exists('G:/data/watchman/'+datadate+'_watchman_spe/d2/d2_histograms/histogram_images/'):
os.makedirs('G:/data/watchman/'+datadate+'_watchman_spe/d2/d2_histograms/histogram_images/')
#determine rise times
for i in range(Nloops):
print(i)
filename = 'G:/data/watchman/'+datadate+'_watchman_spe/d2/d2_'+directory+'/D2--waveforms--%05d.txt' % i
(t,y,_) = rw(filename,numhead)
y_norm = y/min(y)
check10 = y_norm <= .1 #determining where 10% and 90% are located
check90 = y_norm >= .9
index10 = np.asarray([k for k, x in enumerate(check10) if x])
index90 = np.asarray([k for k, x in enumerate(check90) if x])
index_90 = int(index90[0] + 0.5)
index10_removed = index10[np.where(index10 < index_90)] #removing all values after 90% rise index
index_10 = int(index10_removed[len(index10_removed)-1] + 0.5) #turning last 10% rise index into int
rise_time = str(t[index_90] - t[index_10]) #rise time is time at 90% - time at 10%
wh(rise_time,writename) #writing value to histogram txt file
#create histogram from saved file
(histo_mean,histo_std) = gh(writename)
rh(writename,"Seconds","Histogram of 10-90 Rise Times","10_90_Rise_"+directory,datadate,histo_mean,histo_std)
def disparity_investigation(samplerate_name,shaping,datadate,n_box,n_delay,n_att,numhead):
phase_time = 1/20000000000 #sets timing between phases (initial sample rate of oscilloscope)
filedir = 'G:/data/watchman/'+str(datadate)+'_watchman_spe/studies/phase/'+samplerate_name+'/phase=0/phase_'+shaping+'/'
Nloops = len(os.listdir(filedir))
filedir = 'G:/data/watchman/'+str(datadate)+'_watchman_spe/studies/phase/' + samplerate_name + '/array_data/'
median_array = np.loadtxt(filedir+'median_array.csv', delimiter=',')
correction_median_array = np.loadtxt(filedir+'correction_median_array.csv', delimiter=',')
for i in range(29,40):
corrected_difference_list = [] #initializing lists (use python lists rather than np arrays when appending, faster)
for j in range(Nloops):
print(j) #printing value to show progress
#establishing directory and file names
filedir = 'G:/data/watchman/'+str(datadate)+'_watchman_spe/studies/phase/'+samplerate_name+'/phase='+str(i)+'/phase_'+shaping+'/'
filename = filedir + 'Phase--waveforms--%05d.txt' % j
#reading in waveform values and running CFD
(t,v,_) = rw(filename,numhead)
t_avg,v_avg = boxcar_wf(t,v,n_box)
v_delay = delay_wf(v_avg,n_delay)
v_att = attenuate_wf(v_avg,n_att)
v_sum = sum_wf(v_att,v_delay)
t_cross,_,_ = zc_locator(t_avg,v_sum)
t_cross = t_cross - median_array[0] #removing linear displacement
corrected_difference_list.append(-1*i*phase_time - (t_cross + correction_median_array[i])) #gathering timing difference
corrected_difference_list = np.asarray(corrected_difference_list) #turning to numpy array for better calculation
#calculating full mean and standard deviations
set_mean = np.mean(corrected_difference_list)
set_std = np.std(corrected_difference_list)
set_mean = '%.5g' % set_mean
set_std = '%.5g' % set_std
histo_mean,histo_std = gauss_histogram(corrected_difference_list) #gathering starting means/stds for fit
corrected_difference_list = corrected_difference_list[(corrected_difference_list >= histo_mean - 4*histo_std) & (corrected_difference_list <= histo_mean + 4*histo_std)] #cutting off outliers
histo_data, bins_data = np.histogram(corrected_difference_list, bins = 200)
binwidth = (bins_data[1] - bins_data[0]) #determining bin width
#determining bin centers
binscenters = np.array([0.5 * (bins_data[i] + bins_data[i+1]) for i in range(len(bins_data)-1)])
b_guess = (len(corrected_difference_list) * binwidth) #using area approximation to guess at B value
popt, _ = cf(fit_function,xdata = binscenters,ydata = histo_data, p0 = [b_guess,histo_mean,histo_std], maxfev = 10000)
gauss_mean = '%s' % float('%.5g' % popt[1])
gauss_std = '%s' % float('%.5g' % popt[2])
#establishing 5 significant figure versions of the mean and std from curve fit
x_values = np.linspace(popt[1] - 1.5*popt[2], popt[1] + 1.5*popt[2], 100000) #creating 100,000 x values to map curvefit gaussian to
fig,ax = plt.subplots()
ax.bar(binscenters, histo_data, width=binwidth) #plotting histogram
ax.plot(x_values, fit_function(x_values, *popt), color='darkorange') #plotting curve fit
ax.set_xlabel('True Timing - Recovered Timing')
ax.set_ylabel('Count')
ax.set_title('Corrected Timings for Phase=%d' %i +'\nGaussian Fit Values:\nMean = '+gauss_mean+' seconds, '+set_mean+'seconds\nStandard Deviation = '+gauss_std+' seconds, '+set_std+'seconds', fontdict={'fontsize': 14})
plt.get_current_fig_manager().window.showMaximized()
plt.show(block = False)
plt.pause(1)
filedir = 'G:/data/watchman/20190724_watchman_spe/studies/disparity/'
filename = 'Phase_%d.png' % i
savename = filedir + filename
fig.savefig(savename,dpi = 500)
plt.close()
def determine(datadate, numhead):
Nloops = len(
os.listdir(
'G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_50centered')) #determining size of directory
writename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_histograms/10_90_fall_time.txt' #setting file name to write to
if not os.path.exists('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_histograms/histogram_images'
): #creating write directory if nonexistant
os.makedirs('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_histograms/histogram_images')
#determine fall times
for i in range(Nloops):
print(i)
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_50centered/D1--waveforms--%05d.txt' % i #setting file name to read from
(t, y, _) = rw(filename, numhead) #taking in waveform values
y_norm = y / min(y) #normalizing voltage values
check10 = y_norm <= .1 #determining where 10% and 90% falling are located
check90 = y_norm >= .9
index10 = np.asarray([k for k, x in enumerate(check10) if x])
index90 = np.asarray([k for k, x in enumerate(check90) if x])
index_90 = int(index90[len(index90) - 1] + 0.5)
index10_removed = index10[np.where(
index10 > index_90)] #removing all values before 90% fall index
index_10 = int(index10_removed[0] +
0.5) #turning first 10% fall index into int
fall_time = str(t[index_10] -
t[index_90]) #fall time is time at 10% - time at 90%
wh(fall_time, writename) #writing value to histogram txt file
#create histogram from saved file
(histo_mean, histo_std) = gh(writename)
rh(writename, "Seconds", "Histogram of 10-90 Fall Times", "10_90_Fall",
datadate, histo_mean, histo_std)
def determine_average_shape(datadate, numhead):
Nloops = len(
os.listdir('G:/data/watchman/' + datadate +
'_watchman_spe/d2/d2_normalized'))
writename = 'G:/data/watchman/' + datadate + '_watchman_spe/d2/d2_histograms/average_shape.txt'
if not os.path.exists('G:/data/watchman/' + datadate +
'_watchman_spe/d2/d2_histograms/histogram_images'):
os.makedirs('G:/data/watchman/' + datadate +
'_watchman_spe/d2/d2_histograms/histogram_images')
for i in range(Nloops):
print(i)
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d2/d2_normalized/D2--waveforms--%05d.txt' % i
(t, y, _) = rw(filename, numhead)
#starting array if this is first file
if i == 0:
ysum = y
#adding additional normalized files to the array index-wise
else:
ysum = np.add(ysum, y)
yfinal = np.divide(
ysum, Nloops) #diving array index-wise by number of files added
header_name = "Average Waveform Shape\n"
write_waveform(t, yfinal, writename,
header_name) #writing array to waveform file
return (t, yfinal)
def determine(datadate, numhead):
Nloops = len(
os.listdir(
'G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_50centered')) #determining size of directory
writename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_histograms/20_80_rise_time.txt' #setting file name to write to
if not os.path.exists('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_histograms/histogram_images'
): #creating write directory if nonexistant
os.makedirs('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_histograms/histogram_images')
#determine rise times
for i in range(Nloops):
print(i)
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_50centered/D1--waveforms--%05d.txt' % i #setting file name to read from
(t, y, _) = rw(filename, numhead) #taking in waveform values
y_norm = y / min(y) #normalizing voltage values
check20 = y_norm <= .2 #determining where 20% and 80% rising are located
check80 = y_norm >= .8
index20 = np.asarray([k for k, x in enumerate(check20) if x])
index80 = np.asarray([k for k, x in enumerate(check80) if x])
index_80 = int(index80[0] + 0.5)
index20_removed = index20[np.where(
index20 < index_80)] #removing all values after 80% rise index
index_20 = int(index20_removed[len(index20_removed) - 1] +
0.5) #turning last 20% rise index into int
rise_time = str(t[index_80] -
t[index_20]) #rise time is time at 80% - time at 10%
wh(rise_time, writename) #writing value to histogram txt file
#create histogram from saved file
(histo_mean, histo_std) = gh(writename)
rh(writename, "Seconds", "Histogram of 20-80 Rise Times", "20_80_Rise",
datadate, histo_mean, histo_std)
def determine(datadate, numhead):
Nloops = len(
os.listdir('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_50centered'))
writename10 = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_histograms/10_jitter.txt'
writename20 = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_histograms/20_jitter.txt'
writename80 = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_histograms/80_jitter.txt'
writename90 = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_histograms/90_jitter.txt'
if not os.path.exists('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_histograms/histogram_images'):
os.makedirs('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_histograms/histogram_images')
#peak amplitude acquisition
for i in range(Nloops):
print(i)
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_50centered/D1--waveforms--%05d.txt' % i
(t, y, _) = rw(filename, numhead)
y_norm = y / min(y)
check10 = y_norm <= .1 #determining where 10% and 90% are located
check90 = y_norm >= .9
index10 = np.asarray([k for k, x in enumerate(check10) if x])
index90 = np.asarray([k for k, x in enumerate(check90) if x])
index_90 = int(index90[0] + 0.5) #turning 90% rising point into int
index10_removed = index10[np.where(
index10 < index_90)] #removing all 10% points after 90% index
index_10 = int(index10_removed[len(index10_removed) - 1] +
0.5) #turning last 10% index before 90% index into int
check20 = y_norm <= .2 #determining where 20% and 80% rising are located
check80 = y_norm >= .8
index20 = np.asarray([k for k, x in enumerate(check20) if x])
index80 = np.asarray([k for k, x in enumerate(check80) if x])
index_80 = int(index80[0] + 0.5) #turning 80% rising point into int
index20_removed = index20[np.where(
index20 < index_80)] #removing all 20% points after 80% index
index_20 = int(index20_removed[len(index20_removed) - 1] +
0.5) #turning last 20% index before 90% index into int
#gathering times at rising 10,20,80,90% points
t10 = str(t[index_10])
t20 = str(t[index_20])
t80 = str(t[index_80])
t90 = str(t[index_90])
#writing values to respective histogram files
wh(t10, writename10)
wh(t20, writename20)
wh(t80, writename80)
wh(t90, writename90)
#create histograms from saved files
(histo_mean10, histo_std10) = gh(writename10)
(histo_mean20, histo_std20) = gh(writename20)
(histo_mean80, histo_std80) = gh(writename80)
(histo_mean90, histo_std90) = gh(writename90)
rh(writename10, "Seconds", "Histogram of 10% Jitter", "10_Jitter",
datadate, histo_mean10, histo_std10)
rh(writename20, "Seconds", "Histogram of 20% Jitter", "20_Jitter",
datadate, histo_mean20, histo_std20)
rh(writename80, "Seconds", "Histogram of 80% Jitter", "80_Jitter",
datadate, histo_mean80, histo_std80)
rh(writename90, "Seconds", "Histogram of 90% Jitter", "90_Jitter",
datadate, histo_mean90, histo_std90)
def p3_average_cycling(datadate, numhead, fsps, new_fsps, noise):
filedir = 'G:/Data/watchman/' + datadate + '_watchman_spe/d2/'
writedir1 = 'G:/Data/watchman/' + datadate + '_watchman_spe/d3/d3_averages/raw/'
writedir2 = 'G:/Data/watchman/' + datadate + '_watchman_spe/d3/d3_averages/rise_doubled/'
writedir4 = 'G:/Data/watchman/' + datadate + '_watchman_spe/d3/d3_averages/rise_quadrupled/'
writedir8 = 'G:/Data/watchman/' + datadate + '_watchman_spe/d3/d3_averages/rise_octupled/'
if not os.path.exists(writedir1):
os.makedirs(writedir1)
if not os.path.exists(writedir2):
os.makedirs(writedir2)
if not os.path.exists(writedir4):
os.makedirs(writedir4)
if not os.path.exists(writedir8):
os.makedirs(writedir8)
filename1 = filedir + 'd2_average.txt'
filename2 = filedir + 'd2_average_doubled.txt'
filename4 = filedir + 'd2_average_quadrupled.txt'
filename8 = filedir + 'd2_average_octupled.txt'
(t, v, header) = rw(filename1, numhead)
(t2, v2, header2) = rw(filename2, numhead)
(t4, v4, header4) = rw(filename4, numhead)
(t8, v8, header8) = rw(filename8, numhead)
(v, v2, v4, v8) = gain(v, v2, v4, v8)
Nloops = 10000
for i in range(Nloops):
print(i)
writename1 = writedir1 + 'D3--waveforms--%05d.txt' % i
writename2 = writedir2 + 'D3--waveforms--%05d.txt' % i
writename4 = writedir4 + 'D3--waveforms--%05d.txt' % i
writename8 = writedir8 + 'D3--waveforms--%05d.txt' % i
#downsampling waveform values
(t_down_1, v_down_1) = downsampling(t, v, fsps, new_fsps)
(t_down_2, v_down_2) = downsampling(t2, v2, fsps, new_fsps)
(t_down_4, v_down_4) = downsampling(t4, v4, fsps, new_fsps)
(t_down_8, v_down_8) = downsampling(t8, v8, fsps, new_fsps)
#digitizing waveform values
v_digit_1 = digitize(v_down_1, noise)
v_digit_2 = digitize(v_down_2, noise)
v_digit_4 = digitize(v_down_4, noise)
v_digit_8 = digitize(v_down_8, noise)
#saving downsampled and digitized waveforms
write_waveform(t_down_1, v_digit_1, writename1, header)
write_waveform(t_down_2, v_digit_2, writename2, header2)
write_waveform(t_down_4, v_digit_4, writename4, header4)
write_waveform(t_down_8, v_digit_8, writename8, header8)
def waveform_sort(filenum, datadate, numhead):
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/C2--waveforms--%05d.txt' % filenum
(_, v, _) = rw(filename, numhead)
v_sorted = np.flip(np.sort(v, kind="mergesort"))
v_differences = voltage_diff(v_sorted)
min_v_diff = min(v_differences)
max_v_diff = max(v_differences)
plt.hist(v_differences,
bins=np.arange(min_v_diff, max_v_diff + 1.3729999999e-8,
1.3729999999e-8),
log=True)
plt.show()
def p3(new_fsps, datadate, numhead, scale, phase_array, n_box, n_delay, n_att,
num_phases):
#establishing directory names
if new_fsps == 1000000000:
sample_rate = '1 Gsps'
elif new_fsps == 500000000:
sample_rate = '500 Msps'
elif new_fsps == 250000000:
sample_rate = '250 Msps'
else:
sample_rate = 'trash'
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d2/d2_average.txt'
t, v, _ = rw(filename, numhead)
uspl = us(t, v)
t_cross_array = []
for i in range(len(phase_array)):
print('ndel=' + str(n_delay) + ', natt=' + str(n_att) + ', ' + str(i))
start_value = t[0] + i / (new_fsps * num_phases)
end_value = t[-1]
t_array = np.arange(start_value, end_value, 1 / new_fsps)
v_array = -1 * uspl(t_array)
t_array = t_array - i / (new_fsps * num_phases)
scale_height = scale / np.max(v_array)
v_scaled = v_array * scale_height
v_digit = digitize(v_scaled, 0)
t_avg, v_avg = boxcar_wf(t_array, v_digit, n_box)
v_delay = delay_wf(v_avg, n_delay)
v_att = attenuate_wf(v_avg, n_att)
v_sum = sum_wf(v_att, v_delay)
t_cross, _, _ = zc_locator(t_avg, v_sum)
t_cross_array.append(t_cross)
t_cross_array = t_cross_array - t_cross_array[0]
t_cross_array = np.flip(np.asarray(t_cross_array))
true_timing_array = np.flip(np.zeros(num_phases) - phase_array)
fig, ax = plt.subplots()
ax.plot(true_timing_array, t_cross_array)
ax.set_title('Recovered Timing vs. True Timing')
ax.set_xlabel('True Timing (Seconds)')
ax.set_ylabel('Recovered Timing (Seconds)')
plt.get_current_fig_manager().window.showMaximized()
plt.show(block=False)
savedir = 'G:/data/watchman/' + str(
datadate
) + '_watchman_spe/studies/phase/' + sample_rate + '/Histograms/averages_splined/'
if not os.path.exists(savedir):
os.makedirs(savedir)
filename = 'ndelay=' + str(n_delay) + '_natt=' + str(
n_att) + '_Phases=%d.png' % num_phases
savename = savedir + filename
fig.savefig(savename, dpi=500)
plt.close()
def d2normalization(datadate, numhead):
Nloops = len(
os.listdir('G:/data/watchman/' + datadate + '_watchman_spe/d2/d2_raw'))
if not os.path.exists('G:/data/watchman/' + datadate +
'_watchman_spe/d2/d2_normalized/'):
os.makedirs('G:/data/watchman/' + datadate +
'_watchman_spe/d2/d2_normalized/')
for i in range(Nloops):
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d2/d2_raw/D2--waveforms--%05d.txt' % i
writename = 'G:/data/watchman/' + datadate + '_watchman_spe/d2/d2_normalized/D2--waveforms--%05d.txt' % i
(t, y, header) = rw(filename, numhead)
y_norm = y / min(y) #normalizing y to peak = 1
write_waveform(t, y_norm, writename, header)
def three_stage_compare(datadate, numhead, filenum, shaping):
plt.rcParams.update({'font.size': 16})
readname1 = 'G:/Data/watchman/' + datadate + '_watchman_spe/d1/d1_final_spes/D1--waveforms--%05d.txt' % filenum
readname2 = 'G:/Data/watchman/' + datadate + '_watchman_spe/d2/d2_' + shaping + '_gained/D2--waveforms--%05d.txt' % filenum
readname3 = 'G:/Data/watchman/' + datadate + '_watchman_spe/d3/d3_' + shaping + '_gained_analyzed/D3--waveforms--%05d.txt' % filenum
(t1, v1, _) = rw(readname1, numhead)
(t2, v2, _) = rw(readname2, numhead)
(t3, v3, _) = rw(readname3, numhead)
v1 = v1 / min(v1)
v2 = v2 / min(v2)
v3 = v3 / min(v3)
plt.rcParams.update({'font.size': 14})
p1, = plt.plot(t1, v1, color='orange', label='Waveform After P1')
p2, = plt.plot(t2, v2, color='green', label='Waveform After P2')
p3, = plt.plot(t3, v3, color='blue', label='Waveform After P3')
plt.scatter(t3, v3, color='blue')
plt.xlabel('Time (s)')
plt.title(
'250 Msps, Risetime Octupled During P2\nSample SPE Waveform After Each Stage:\nWaveform %05d'
% filenum)
plt.legend(handles=[p1, p2, p3])
plt.get_current_fig_manager().window.showMaximized()
plt.show()
def establish_templates(new_fsps, datadate, numhead, scale_array, phase_array,
noise, fsps, steps, scale_mean):
#establishing directory names
if new_fsps == 1000000000:
sample_rate = '1 Gsps'
elif new_fsps == 500000000:
sample_rate = '500 Msps'
elif new_fsps == 250000000:
sample_rate = '250 Msps'
else:
sample_rate = 'trash'
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d2/d2_average.txt'
t, v, header = rw(filename, numhead)
uspl = us(t, v)
for i in range(len(phase_array)):
print(i)
writedir_noise = 'G:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/file_template/phase=' + str(
i) + '/phase_raw_gained_analyzed_noised/'
writedir_peaked = 'G:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/file_template/phase=' + str(
i) + '/phase_raw_gained_analyzed_peaked/'
#creating directories if they don't exist
if not os.path.exists(writedir_noise):
os.makedirs(writedir_noise)
if not os.path.exists(writedir_peaked):
os.makedirs(writedir_peaked)
start_value = t[i]
end_value = t[-1]
t_array = np.arange(start_value, end_value, 1 / new_fsps)
v_array = uspl(t_array)
Nloops = len(
scale_array) #establishing how many files to cycle through
for j in range(Nloops):
scale_height_noise = scale_mean / np.max(v_array)
scale_height_peaked = scale_array[j] / np.max(v_array)
v_scaled_noise = v_array * scale_height_noise
v_scaled_peaked = v_array * scale_height_peaked
print('%s/%s, File: %05d' %
(i + 1, steps,
j)) #printing number of file currently being processed
#establishing read and write names
writename_noise = writedir_noise + 'Phase--waveforms--%05d.txt' % j
writename_peaked = writedir_peaked + 'Phase--waveforms--%05d.txt' % j
#digitizing waveform values
v_digit_noise = digitize(v_scaled_noise, noise)
v_digit_peaked = digitize(v_scaled_peaked, noise)
#saving downsampled and digitized waveforms
ww(t_array - i / fsps, v_digit_noise, writename_noise, header)
ww(t_array - i / fsps, v_digit_peaked, writename_peaked, header)
return ()
def determine(datadate,numhead):
Nloops = len(os.listdir('G:/data/watchman/'+datadate+'_watchman_spe/d2/d2_raw')) - 1
writename = 'G:/data/watchman/'+datadate+'_watchman_spe/d2/d2_histograms/raw_peak_amplitude.txt'
if not os.path.exists('G:/data/watchman/'+datadate+'_watchman_spe/d2/d2_histograms/histogram_images'):
os.makedirs('G:/data/watchman/'+datadate+'_watchman_spe/d2/d2_histograms/histogram_images')
#peak amplitude acquisition
for i in range(Nloops):
print(i)
filename = 'G:/data/watchman/'+datadate+'_watchman_spe/d2/d2_raw/D2--waveforms--%05d.txt' % i
(_,y,_) = rw(filename,numhead)
index_min = np.where(y == min(y)) #determining index of peak
value = str((-1*y[index_min])[0]) #flipping peak to positive
wh(value,writename) #writing value to histogram txt file
#create histogram from saved file
(histo_mean,histo_std) = gh(writename)
rh(writename,"Volts","Histogram of Peak Amplitudes","Peak_Amplitude",datadate,histo_mean,histo_std)
def d1normalization(datadate, numhead):
Nloops = len(
os.listdir(
'G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_50centered')) #establishing size of directory
if not os.path.exists('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_normalized/'
): #creating write directory if nonexistant
os.makedirs('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_normalized/')
for i in range(Nloops):
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_50centered/D1--waveforms--%05d.txt' % i #setting file name for reading
writename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_normalized/D1--waveforms--%05d.txt' % i #setting file name for writing
(t, y, header) = rw(filename,
numhead) #gathering waveform data into array
y_norm = y / min(y) #normalizing y to peak = 1
write_waveform(t, y_norm, writename,
header) #writing normalized waveform
def center_check(Nloops, numhead, datadate):
center_list = [] #initializing list
for i in range(Nloops):
print(i)
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_baseline_shifted/D1--waveforms--%05d.txt' % i
(_, y, _) = rw(filename, numhead) #reading in waveform y values
y_norm = y / min(y[370:1370]) #normalizing to make calculations easier
check = y_norm >= 0.5 #50% crossing criteria
index = [k for k, x in enumerate(check)
if x] #code to enumerate index values
index_50 = int(index[0]) #making into integer
center_list = center_list.append(
index_50) #appending index location to list of index locations
center_list = np.asarray(center_list) #converting list to numpy array
center_list_sorted = np.sort(center_list) #sort center_list array
max_index = int(round(center_list_sorted[(len(center_list_sorted) -
1)])) #determine maximum index
min_index = int(round(center_list_sorted[0])) #determine minimum index
center_index = int(
round(np.mean(center_list))
) #establishing mean index location, rounding it, and converting to integer
return (max_index, min_index, center_index, center_list)
def baselineshift(datadate, numhead):
Nloops = len(
os.listdir(
'G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_renamed')) #establish size of directory
if not os.path.exists('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_baseline_shifted/'
): #create write directory if nonexistant
os.makedirs('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_baseline_shifted/')
for i in range(Nloops):
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_renamed/D1--waveforms--%05d.txt' % i #establish file name to read
writename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_baseline_shifted/D1--waveforms--%05d.txt' % i #establish file name to write
(t, y, header) = rw(filename,
numhead) #collect waveform data into array
baseline = np.mean(
y[0:200]
) #determining average value at beginning to establish baseline
if abs(baseline) >= 0.0005: #used to check baselines that are too big
print(str(baseline) + ', ' + str(i))
y_new = (y - baseline) #reducing y to factor out baseline
write_waveform(t, y_new, writename, header) #writing waveforms
def waveform_viewer(datadate, subfolder_name, numhead):
NLoops = len(
os.listdir('G:/data/watchman/' + datadate + '_watchman_spe/d1/' +
subfolder_name)) #determine number of files in directory
files = sorted(
os.listdir('G:/data/watchman/' + datadate + '_watchman_spe/d1/' +
subfolder_name)) #create list of file names in directory
plt.rcParams.update({'font.size': 14})
for i in range(NLoops): #cycle through number of files
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/' + subfolder_name + '/' + files[
i] #open first file in list
(x, y, _) = rw(filename, numhead) #get data from file, ignore header
y_line = min(y) * .5
print(filename) #print name of file
plt.plot(x, y) #plot data from file
plt.axvline(x=0, color='red')
plt.axhline(y=y_line, color='purple')
plt.xlabel('Time (s)')
plt.ylabel('Volts')
plt.title('Sample SPE Waveform After P1:\nWaveform %05d' %
i) #title plot with name of file
plt.get_current_fig_manager().window.showMaximized() #maximizes plot
plt.show() #show plot, with pause in code
def d1shift50(datadate, numhead):
Nloops = len(
os.listdir('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_baseline_shifted')
) #establishing size of direcory
(max_index, min_index, center_index, center_list) = center_check(
Nloops, numhead,
datadate) #checking for average location of 50% rise point
#printing calculated indices
print(min_index)
print(center_index)
print(max_index)
if not os.path.exists('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_50centered/'
): #creating write directory if nonexistant
os.makedirs('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_50centered/')
for i in range(Nloops):
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_baseline_shifted/D1--waveforms--%05d.txt' % i #setting file name for reading
writename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_50centered/D1--waveforms--%05d.txt' % i #setting file name for writing
(t, y, header) = rw(filename, numhead) #reading in waveform values
index_50 = int(center_list[i] + 0.5) #converting to int
t_50 = t[
index_50] #converting index of 50% rising point to value at that point
t_new = (t - t_50) #shifting t_50 to t=0s
#rolling so 50 rising point is at center index
t_intermediate = np.roll(t_new, center_index - index_50)
y_intermediate = np.roll(y, center_index - index_50)
first_cutoff = (center_index - min_index
) #determining latest first index
last_cutoff = (len(y) - max_index + center_index
) #determining earliest last index
#slicing off 'problem indices'
t_50centered = t_intermediate[first_cutoff:last_cutoff]
y_50centered = y_intermediate[first_cutoff:last_cutoff]
write_waveform(t_50centered, y_50centered, writename,
header) #writing final waveform
def determine(datadate, numhead):
Nloops = len(
os.listdir('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_50centered'))
writename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_histograms/FWHM.txt'
if not os.path.exists('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_histograms/histogram_images'):
os.makedirs('G:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_histograms/histogram_images')
#determine rise times
for i in range(Nloops):
print(i)
filename = 'G:/data/watchman/' + datadate + '_watchman_spe/d1/d1_50centered/D1--waveforms--%05d.txt' % i
(t, y, _) = rw(filename, numhead)
y_norm = y / min(y)
check = y_norm <= .5 #determining where values under 50% are
check_peak = y_norm == 1 #determining where peak is
index_peak = np.asarray([k for k, x in enumerate(check_peak) if x])
peak_index = int(index_peak[0] + 0.5) #turning peak index into int
index = np.asarray([k for k, x in enumerate(check) if x])
index_low = index[np.where(
index < peak_index)] #removing all values after peak
index_high = index[np.where(
index > peak_index)] #removing all values before peak
index_first = int(index_low[len(index_low) - 1] +
0.5) #turning last 50% point before peak into int
index_last = int(index_high[0] +
0.5) #turning first 50% point after peak into int
FWHM = str(
t[index_last] -
t[index_first]) #FWHM is time at falling 50% - time at rising 50%
wh(FWHM, writename) #writing to histogram txt file
#create histogram from saved file
(histo_mean, histo_std) = gh(writename)
rh(writename, "Seconds", "Histogram of Full Width Half Maximums", "FWHM",
datadate, histo_mean, histo_std)
#check location of 50% point on rising edge
import numpy as np
from readwaveform import read_waveform as rw
import os
Nloops = len(os.listdir('G:/data/watchman/20190724_watchman_spe/d1/d1_baseline_shifted')) #establish size of directory
for i in range(Nloops):
filename = 'G:/data/watchman/20190724_watchman_spe/d1/d1_baseline_shifted/D1--waveforms--%05d.txt' % i #open specific file
(_,y,_) = rw(filename,5) #read in y values from the file
y_norm = y/min(y[370:1370]) #normalizing to make calculations easier
check = y_norm >= 0.5 #50% crossing criteria
index = [k for k, x in enumerate(check) if x] #code to enumerate index values
index50 = int(index[0] + 0.5) #converting first index to an integer
if index50 < 370:
print(str(index50)+', '+str(filename))
def p3(noise_filter, noise, datadate, numhead, fsps, new_fsps, gain_noise,
gain_factor_2, gain_factor_4, gain_factor_8, start_index, steps):
#establishing directory names
if new_fsps == 1000000000:
sample_rate = '1 Gsps'
elif new_fsps == 500000000:
sample_rate = '500 Msps'
elif new_fsps == 250000000:
sample_rate = '250 Msps'
else:
sample_rate = 'trash'
if noise_filter == 0 and gain_noise == 0:
filedir1 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_raw'
filedir2 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_rise_doubled'
filedir4 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_rise_quadrupled'
filedir8 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_rise_octupled'
writedir1 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_raw'
writedir2 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_rise_doubled'
writedir4 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_rise_quadrupled'
writedir8 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_rise_octupled'
elif gain_noise == 0:
filedir1 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_raw_noise=' + str(
noise) + 'V'
filedir2 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_rise_doubled_noise=' + str(
noise) + 'V'
filedir4 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_rise_quadrupled_noise=' + str(
noise) + 'V'
filedir8 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_rise_octupled_noise=' + str(
noise) + 'V'
writedir1 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_raw_noise=' + str(noise_filter) + 'V'
writedir2 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_rise_doubled_noise=' + str(
noise_filter) + 'V'
writedir4 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_rise_quadrupled_noise=' + str(
noise_filter) + 'V'
writedir8 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_rise_octupled_noise=' + str(
noise_filter) + 'V'
elif noise_filter == 0:
filedir1 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_raw_gain_noise=' + str(
gain_noise) + 'V'
filedir2 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_rise_doubled_gain_noise=' + str(
gain_noise) + 'V'
filedir4 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_rise_quadrupled_gain_noise=' + str(
gain_noise) + 'V'
filedir8 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_rise_octupled_gain_noise=' + str(
gain_noise) + 'V'
writedir1 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_raw_gain_noise=' + str(gain_noise) + 'V'
writedir2 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_rise_doubled_gain_noise=' + str(
gain_noise) + 'V'
writedir4 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_rise_quadrupled_gain_noise=' + str(
gain_noise) + 'V'
writedir8 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_rise_octupled_gain_noise=' + str(
gain_noise) + 'V'
else:
filedir1 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_raw_gain_noise=' + str(
gain_noise) + 'V_noise=' + str(noise) + 'V'
filedir2 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_rise_doubled_gain_noise=' + str(
gain_noise) + 'V_noise=' + str(noise) + 'V'
filedir4 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_rise_quadrupled_gain_noise=' + str(
gain_noise) + 'V_noise=' + str(noise) + 'V'
filedir8 = 'g:/data/watchman/' + datadate + '_watchman_spe/d2/d2_rise_octupled_gain_noise=' + str(
gain_noise) + 'V_noise=' + str(noise) + 'V'
writedir1 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_raw_gain_noise=' + str(
gain_noise) + 'V_noise=' + str(noise_filter) + 'V'
writedir2 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_rise_doubled_gain_noise=' + str(
gain_noise) + 'V_noise=' + str(noise_filter) + 'V'
writedir4 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_rise_quadrupled_gain_noise=' + str(
gain_noise) + 'V_noise=' + str(noise_filter) + 'V'
writedir8 = 'g:/data/watchman/' + datadate + '_watchman_spe/studies/phase/' + sample_rate + '/phase=' + str(
start_index) + '/phase_rise_octupled_gain_noise=' + str(
gain_noise) + 'V_noise=' + str(noise_filter) + 'V'
if gain_factor_2 != 1 or gain_factor_4 != 1 or gain_factor_8:
filedir1 = filedir1 + '_gained/'
filedir2 = filedir2 + '_gained/'
filedir4 = filedir4 + '_gained/'
filedir8 = filedir8 + '_gained/'
writedir1 = writedir1 + '_gained_analyzed/'
writedir2 = writedir2 + '_gained_analyzed/'
writedir4 = writedir4 + '_gained_analyzed/'
writedir8 = writedir8 + '_gained_analyzed/'
else:
filedir1 = filedir1 + '/'
filedir2 = filedir2 + '/'
filedir4 = filedir4 + '/'
filedir8 = filedir8 + '/'
writedir1 = writedir1 + '_analyzed/'
writedir2 = writedir2 + '_analyzed/'
writedir4 = writedir4 + '_analyzed/'
writedir8 = writedir8 + '_analyzed/'
#creating directories if they don't exist
if not os.path.exists(writedir1):
os.makedirs(writedir1)
if not os.path.exists(writedir2):
os.makedirs(writedir2)
if not os.path.exists(writedir4):
os.makedirs(writedir4)
if not os.path.exists(writedir8):
os.makedirs(writedir8)
Nloops = len(
os.listdir(filedir2)) #establishing how many files to cycle through
for i in range(Nloops):
print('%s/%s, File: %05d' %
(start_index + 1, steps,
i)) #printing number of file currently being processed
#establishing read and write names
filename1 = filedir1 + 'D2--waveforms--%05d.txt' % i
filename2 = filedir2 + 'D2--waveforms--%05d.txt' % i
filename4 = filedir4 + 'D2--waveforms--%05d.txt' % i
filename8 = filedir8 + 'D2--waveforms--%05d.txt' % i
writename1 = writedir1 + 'Phase--waveforms--%05d.txt' % i
writename2 = writedir2 + 'Phase--waveforms--%05d.txt' % i
writename4 = writedir4 + 'Phase--waveforms--%05d.txt' % i
writename8 = writedir8 + 'Phase--waveforms--%05d.txt' % i
#reading in waveform values
(t1, v1, header1) = rw(filename1, numhead)
(t2, v2, header2) = rw(filename2, numhead)
(t4, v4, header4) = rw(filename4, numhead)
(t8, v8, header8) = rw(filename8, numhead)
#downsampling waveform values
(t_down_1, v_down_1) = downsampling(t1 - start_index * 1 / 20000000000,
v1, fsps, new_fsps, start_index)
(t_down_2, v_down_2) = downsampling(t2 - start_index * 1 / 20000000000,
v2, fsps, new_fsps, start_index)
(t_down_4, v_down_4) = downsampling(t4 - start_index * 1 / 20000000000,
v4, fsps, new_fsps, start_index)
(t_down_8, v_down_8) = downsampling(t8 - start_index * 1 / 20000000000,
v8, fsps, new_fsps, start_index)
#digitizing waveform values
v_digit_1 = digitize(v_down_1, noise)
v_digit_2 = digitize(v_down_2, noise)
v_digit_4 = digitize(v_down_4, noise)
v_digit_8 = digitize(v_down_8, noise)
#saving downsampled and digitized waveforms
write_waveform(t_down_1, v_digit_1, writename1, header1)
write_waveform(t_down_2, v_digit_2, writename2, header2)
write_waveform(t_down_4, v_digit_4, writename4, header4)
write_waveform(t_down_8, v_digit_8, writename8, header8)
def p1_sort(filenum, datadate, lowpass, numhead, numtaps, threshold, baseline):
filename = 'g:/data/watchman/' + datadate + '_watchman_spe/C2--waveforms--%05d.txt' % filenum
spe_wasname = 'g:/data/watchman/' + datadate + '_watchman_spe/d1/d1_raw/D1--waveforms--%05d.txt' % filenum
spe_not_there = 'g:/data/watchman/' + datadate + '_watchman_spe/d1/not_spe/D1--waveforms--%05d.txt' % filenum
spe_unsure = 'g:/data/watchman/' + datadate + '_watchman_spe/d1/unsure_if_spe/D1--waveforms--%05d.txt' % filenum
if not os.path.exists('g:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_raw/'):
os.makedirs('g:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_raw/')
if not os.path.exists('g:/data/watchman/' + datadate +
'_watchman_spe/d1/not_spe/'):
os.makedirs('g:/data/watchman/' + datadate +
'_watchman_spe/d1/not_spe/')
if not os.path.exists('g:/data/watchman/' + datadate +
'_watchman_spe/d1/unsure_if_spe/'):
os.makedirs('g:/data/watchman/' + datadate +
'_watchman_spe/d1/unsure_if_spe/')
if os.path.isfile(spe_wasname):
pass
elif os.path.isfile(spe_not_there):
pass
elif os.path.isfile(spe_unsure):
pass
else:
(t, v, header) = rw(filename, numhead)
y = signal.filtfilt(lowpass, 1.0, v)
y2 = y[numtaps:len(y) - 1]
t2 = t[numtaps:len(y) - 1]
y_flip = -1 * y2
height = -1 * (baseline + threshold)
peaks, _ = signal.find_peaks(y_flip, height, distance=370)
y_peaks = y2[peaks]
t_peaks = t2[peaks]
if len(peaks) != 0: #Making sure there is a peak
if len(peaks) == 1 and peaks[
0] >= 450: #Checking if only 1 peak exists, making sure it's in proper range
if min(
y2[370:1370]
) < baseline + threshold: #Checking if peak is below -.0015V in range 370 to 1370
write_waveform(t2, y2, spe_wasname, header)
print(
len(
os.listdir('g:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_raw/')))
else:
if min(
y2[370:1370]
) < baseline + threshold: #Shows plot if min is less than -0.0015V in range 370 to 1370
plt.figure()
plt.plot(t, v, 'b')
plt.plot(t2, y2, 'r', linewidth=2.5)
plt.plot(t_peaks, y_peaks, 'x', color='cyan')
plt.grid(True)
print('Displaying file #%05d' % filenum)
plt.get_current_fig_manager().window.showMaximized(
) #maximizes plot
plt.show()
spe_check = 'pre-loop initialization'
while spe_check != 'y' and spe_check != 'u' and spe_check != 'n':
spe_check = input(
'Is there a single visible SPE? "y" or "n" or "u"\n'
)
#writing data to proper folder
if spe_check == 'y':
write_waveform(t2, y2, spe_wasname, header)
elif spe_check == 'n':
write_waveform(t2, y2, spe_not_there, header)
elif spe_check == 'u':
write_waveform(t2, y2, spe_unsure, header)
print('File #%05d: Done' % filenum)
print(
len(
os.listdir('g:/data/watchman/' + datadate +
'_watchman_spe/d1/d1_raw/')))
return
def fitter_timing(datadate,samplerate_name,shaping):
if samplerate_name == 'INVALID':
return("Failed")
t_fitter,v_fitter,_ = rw('G:/data/watchman/'+datadate+'_watchman_spe/d2/d2_average.txt',1)
uspl = us(t_fitter,v_fitter)
filedir = 'G:/data/watchman/'+str(datadate)+'_watchman_spe/studies/phase/'+samplerate_name+'/'
Nloops = len(os.listdir(filedir + 'phase=0/phase_'+shaping))
for i in range(Nloops):
filename_exact = 'G:/data/watchman/'+str(datadate)+'_watchman_spe/d3/d3_raw_gained/D3--waveforms--%05d.txt' % i
t_exact,v_exact,_ = rw(filename_exact,5)
j = 0
check_value = 0
while j < 80 and check_value == 0:
print(str(i) + ', Phase=' + str(j))
filename = filedir + 'phase='+str(j)+'/phase_'+shaping+'/Phase--waveforms--%05d.txt' % i
t,v,_ = rw(filename,5)
v = -1*v
ET = t[0:10]
EV = v[0:10]
chi2_min = -1
x_min = -1
y_min = -1
shift_min = -1
shifts = np.arange(0,80/20000000000,1e-11)
for shift in shifts:
pre_OV = uspl(ET + shift)
A = np.array([[np.sum(np.square(pre_OV)),np.sum(pre_OV),np.sum(np.multiply(pre_OV,EV))],[np.sum(pre_OV),len(EV),np.sum(EV)]])
A[0] = A[0]/A[0][0]
A[1] = np.subtract(A[1],A[1][0]*A[0])
A[1] = A[1]/A[1][1]
A[0] = np.subtract(A[0],A[0][1]*A[1])
x = A[0][2]
y = A[1][2]
OV = x*pre_OV + y
chi2 = chi_squared(OV,EV)
if chi2_min < 0:
shift_min = shift
chi2_min = chi2
x_min = x
y_min = y
elif chi2 < chi2_min:
shift_min = shift
chi2_min = chi2
x_min = x
y_min = y
v_fit = x_min*uspl(t_fitter + shift_min) + y_min
t_cross = timing_extraction(t_fitter,v_fit)
timing_check = -1*j/20000000000 - t_cross
if timing_check <= -1e-9 or chi2_min >= 5000 or timing_check >= 1e-9:
t_exact = t_exact - j/20000000000
v_peak_ind = np.where(v == np.amax(v))[0][0]
t_peak = t[v_peak_ind]
t_exact_check = np.abs(t_exact - t_peak)
t_exact_loc = np.where(t_exact_check == np.amin(t_exact_check))[0][0]
v_exact = v[v_peak_ind]/v_exact[t_exact_loc]*v_exact
fig,ax = plt.subplots()
ax.plot(t,v)
ax.plot(t_fitter,v_fit)
ax.plot(t_exact,v_exact)
ax.axvline(-1*j/20000000000,color = 'Black')
ax.axvline(t_cross,color = 'Red')
ax.set_title(str(t_cross) + ', ' + str(chi2_min) + ', ' + str(i))
plt.get_current_fig_manager().window.showMaximized()
plt.show(block = False)
plt.pause(0.1)
fig.savefig('G:/data/watchman/20190724_watchman_spe/studies/phase/Histograms/'+samplerate_name+'/Doubles Copy/%05d.png' % i,dpi = 500)
print("Was double!")
plt.close()
check_value += 1
j += 1
return("Passed")
def phase_array_gen(samplerate, samplerate_name, shaping, datadate, n_box,
n_delay, n_att, numhead):
phase_time = 1 / 20000000000
maxphase = int(20000000000 / samplerate + 0.5)
phase_array = np.arange(0, maxphase)
x = []
y = []
x_bins = []
median_array = []
correction = []
correction_median_array = []
for i in range(len(phase_array)):
filedir = 'G:/data/watchman/' + str(
datadate
) + '_watchman_spe/studies/phase/' + samplerate_name + '/phase=' + str(
phase_array[i]) + '/phase_' + shaping + '/'
Nloops = len(os.listdir(filedir))
y_j = []
x_j = []
correction_j = []
for j in range(Nloops):
print('Uncorrected Files ' + samplerate_name + ';' + str(n_box) +
',' + str(n_delay) + ',' + str(n_att) + ';' + str(i) + ',' +
str(j))
filename = filedir + 'Phase--waveforms--%05d.txt' % j
(t, v, _) = rw(filename, numhead)
t_avg, v_avg = boxcar_wf(t, v, n_box)
v_delay = delay_wf(v_avg, n_delay)
v_att = attenuate_wf(v_avg, n_att)
v_sum = sum_wf(v_att, v_delay)
t_cross, _, _ = zc_locator(t_avg, v_sum)
y_j.append(t_cross)
x_j.append(-1 * i * phase_time)
correction_j.append(-1 * i * phase_time - t_cross)
median_array.append(np.median(np.asarray(y_j)))
correction_median_array.append(np.median(np.asarray(correction_j)))
y = y + y_j
x = x + x_j
correction = correction + correction_j
x_bins.append(-1 * (i - 0.5) * phase_time)
y = np.asarray(y)
y = y - median_array[0]
correction = np.asarray(correction)
correction = correction + median_array[0]
correction_median_array = np.asarray(correction_median_array)
correction_median_array = correction_median_array + median_array[0]
median_value = median_array[0]
median_array = np.asarray(median_array)
median_array = median_array - median_array[0]
ybin = 1 / (2 * samplerate)
y_bins = np.linspace(-2 * ybin, 0, num=maxphase, endpoint=True)
y_bins_corrections = np.linspace(-ybin, ybin, num=maxphase, endpoint=True)
x_bins = np.asarray(x_bins)
x_bins = np.flip(x_bins)
y_corrected = []
corrected_median_array = []
corrected_corrections = []
corrected_correction_median_array = []
for i in range(len(phase_array)):
filedir = 'G:/data/watchman/' + str(
datadate
) + '_watchman_spe/studies/phase/' + samplerate_name + '/phase=' + str(
phase_array[i]) + '/phase_' + shaping + '/'
Nloops = len(os.listdir(filedir))
corrected_corrections_j = []
y_corrected_j = []
for j in range(Nloops):
print('Corrected Files ' + samplerate_name + ';' + str(n_box) +
',' + str(n_delay) + ',' + str(n_att) + ';' + str(i) + ',' +
str(j))
filename = filedir + 'Phase--waveforms--%05d.txt' % j
(t, v, _) = rw(filename, numhead)
t_avg, v_avg = boxcar_wf(t, v, n_box)
v_delay = delay_wf(v_avg, n_delay)
v_att = attenuate_wf(v_avg, n_att)
v_sum = sum_wf(v_att, v_delay)
t_cross, _, _ = zc_locator(t_avg, v_sum)
t_corrected = t_cross - median_value + correction_median_array[i]
y_corrected_j.append(t_corrected)
corrected_correction = -1 * i * phase_time - t_corrected
corrected_corrections_j.append(corrected_correction)
corrected_median_array.append(np.median(np.asarray(y_corrected_j)))
corrected_correction_median_array.append(
np.median(np.asarray(corrected_corrections_j)))
y_corrected = y_corrected + y_corrected_j
corrected_corrections = corrected_corrections + corrected_corrections_j
y_corrected = np.asarray(y_corrected)
corrected_correction_median_array = np.asarray(
corrected_correction_median_array)
corrected_corrections = np.asarray(corrected_corrections)
if samplerate_name == '250 Msps' and shaping == 'raw_gained_analyzed':
established_x_noised = []
established_y_noised = []
established_x_bins_noised = []
established_median_array_noised = []
established_correction_noised = []
established_correction_median_array_noised = []
for i in range(len(phase_array)):
filedir = 'G:/data/watchman/' + str(
datadate
) + '_watchman_spe/studies/phase/' + samplerate_name + '/file_template/phase=' + str(
phase_array[i]) + '/phase_' + shaping + '_noised/'
Nloops = len(os.listdir(filedir))
established_y_j_noised = []
established_x_j_noised = []
established_correction_j_noised = []
for j in range(Nloops):
print('Established Noised Uncorrected Files ' +
samplerate_name + ';' + str(n_box) + ',' + str(n_delay) +
',' + str(n_att) + ';' + str(i) + ',' + str(j))
filename = filedir + 'Phase--waveforms--%05d.txt' % j
(t, v, _) = rw(filename, numhead)
t_avg, v_avg = boxcar_wf(t, v, n_box)
v_delay = delay_wf(v_avg, n_delay)
v_att = attenuate_wf(v_avg, n_att)
v_sum = sum_wf(v_att, v_delay)
t_cross, _, _ = zc_locator(t_avg, v_sum)
established_y_j_noised.append(t_cross)
established_x_j_noised.append(-1 * i * phase_time)
established_correction_j_noised.append(-1 * i * phase_time -
t_cross)
established_median_array_noised.append(
np.median(np.asarray(established_y_j_noised)))
established_correction_median_array_noised.append(
np.median(np.asarray(established_correction_j_noised)))
established_y_noised = established_y_noised + established_y_j_noised
established_x_noised = established_x_noised + established_x_j_noised
established_correction_noised = established_correction_noised + established_correction_j_noised
established_x_bins_noised.append(-1 * (i - 0.5) * phase_time)
established_y_noised = np.asarray(established_y_noised)
established_y_noised = established_y_noised - established_median_array_noised[
0]
established_correction_noised = np.asarray(
established_correction_noised)
established_correction_noised = established_correction_noised + established_median_array_noised[
0]
established_correction_median_array_noised = np.asarray(
established_correction_median_array_noised)
established_correction_median_array_noised = established_correction_median_array_noised + established_median_array_noised[
0]
established_median_value_noised = established_median_array_noised[0]
established_median_array_noised = np.asarray(
established_median_array_noised)
established_median_array_noised = established_median_array_noised - established_median_array_noised[
0]
established_ybin_noised = 1 / (2 * samplerate)
established_y_bins_noised = np.linspace(-2 * established_ybin_noised,
0,
num=maxphase,
endpoint=True)
established_y_bins_corrections_noised = np.linspace(
-established_ybin_noised,
established_ybin_noised,
num=maxphase,
endpoint=True)
established_x_bins_noised = np.asarray(established_x_bins_noised)
established_x_bins_noised = np.flip(established_x_bins_noised)
established_y_corrected_noised = []
established_corrected_median_array_noised = []
established_corrected_corrections_noised = []
established_corrected_correction_median_array_noised = []
for i in range(len(phase_array)):
filedir = 'G:/data/watchman/' + str(
datadate
) + '_watchman_spe/studies/phase/' + samplerate_name + '/file_template/phase=' + str(
phase_array[i]) + '/phase_' + shaping + '_noised/'
Nloops = len(os.listdir(filedir))
established_corrected_corrections_j_noised = []
established_y_corrected_j_noised = []
for j in range(Nloops):
print('Established Noised Corrected Files ' + samplerate_name +
';' + str(n_box) + ',' + str(n_delay) + ',' +
str(n_att) + ';' + str(i) + ',' + str(j))
filename = filedir + 'Phase--waveforms--%05d.txt' % j
(t, v, _) = rw(filename, numhead)
t_avg, v_avg = boxcar_wf(t, v, n_box)
v_delay = delay_wf(v_avg, n_delay)
v_att = attenuate_wf(v_avg, n_att)
v_sum = sum_wf(v_att, v_delay)
t_cross, _, _ = zc_locator(t_avg, v_sum)
established_t_corrected_noised = t_cross - established_median_value_noised + established_correction_median_array_noised[
i]
established_y_corrected_j_noised.append(
established_t_corrected_noised)
established_corrected_correction_noised = -1 * i * phase_time - established_t_corrected_noised
established_corrected_corrections_j_noised.append(
established_corrected_correction_noised)
established_corrected_median_array_noised.append(
np.median(np.asarray(established_y_corrected_j_noised)))
established_corrected_correction_median_array_noised.append(
np.median(
np.asarray(established_corrected_corrections_j_noised)))
established_y_corrected_noised = established_y_corrected_noised + established_y_corrected_j_noised
established_corrected_corrections_noised = established_corrected_corrections_noised + established_corrected_corrections_j_noised
established_y_corrected_noised = np.asarray(
established_y_corrected_noised)
established_corrected_correction_median_array_noised = np.asarray(
established_corrected_correction_median_array_noised)
established_corrected_corrections_noised = np.asarray(
established_corrected_corrections_noised)
established_x_peaked = []
established_y_peaked = []
established_x_bins_peaked = []
established_median_array_peaked = []
established_correction_peaked = []
established_correction_median_array_peaked = []
for i in range(len(phase_array)):
filedir = 'G:/data/watchman/' + str(
datadate
) + '_watchman_spe/studies/phase/' + samplerate_name + '/file_template/phase=' + str(
phase_array[i]) + '/phase_' + shaping + '_peaked/'
Nloops = len(os.listdir(filedir))
established_y_j_peaked = []
established_x_j_peaked = []
established_correction_j_peaked = []
for j in range(Nloops):
print('Established Peaked Uncorrected Files ' +
samplerate_name + ';' + str(n_box) + ',' + str(n_delay) +
',' + str(n_att) + ';' + str(i) + ',' + str(j))
filename = filedir + 'Phase--waveforms--%05d.txt' % j
(t, v, _) = rw(filename, numhead)
t_avg, v_avg = boxcar_wf(t, v, n_box)
v_delay = delay_wf(v_avg, n_delay)
v_att = attenuate_wf(v_avg, n_att)
v_sum = sum_wf(v_att, v_delay)
t_cross, _, _ = zc_locator(t_avg, v_sum)
established_y_j_peaked.append(t_cross)
established_x_j_peaked.append(-1 * i * phase_time)
established_correction_j_peaked.append(-1 * i * phase_time -
t_cross)
established_median_array_peaked.append(
np.median(np.asarray(established_y_j_peaked)))
established_correction_median_array_peaked.append(
np.median(np.asarray(established_correction_j_peaked)))
established_y_peaked = established_y_peaked + established_y_j_peaked
established_x_peaked = established_x_peaked + established_x_j_peaked
established_correction_peaked = established_correction_peaked + established_correction_j_peaked
established_x_bins_peaked.append(-1 * (i - 0.5) * phase_time)
established_y_peaked = np.asarray(established_y_peaked)
established_y_peaked = established_y_peaked - established_median_array_peaked[
0]
established_correction_peaked = np.asarray(
established_correction_peaked)
established_correction_peaked = established_correction_peaked + established_median_array_peaked[
0]
established_correction_median_array_peaked = np.asarray(
established_correction_median_array_peaked)
established_correction_median_array_peaked = established_correction_median_array_peaked + established_median_array_peaked[
0]
established_median_value_peaked = established_median_array_peaked[0]
established_median_array_peaked = np.asarray(
established_median_array_peaked)
established_median_array_peaked = established_median_array_peaked - established_median_array_peaked[
0]
established_ybin_peaked = 1 / (2 * samplerate)
established_y_bins_peaked = np.linspace(-2 * established_ybin_peaked,
0,
num=maxphase,
endpoint=True)
established_y_bins_corrections_peaked = np.linspace(
-established_ybin_peaked,
established_ybin_peaked,
num=maxphase,
endpoint=True)
established_x_bins_peaked = np.asarray(established_x_bins_peaked)
established_x_bins_peaked = np.flip(established_x_bins_peaked)
established_y_corrected_peaked = []
established_corrected_median_array_peaked = []
established_corrected_corrections_peaked = []
established_corrected_correction_median_array_peaked = []
for i in range(len(phase_array)):
filedir = 'G:/data/watchman/' + str(
datadate
) + '_watchman_spe/studies/phase/' + samplerate_name + '/file_template/phase=' + str(
phase_array[i]) + '/phase_' + shaping + '_peaked/'
Nloops = len(os.listdir(filedir))
established_corrected_corrections_j_peaked = []
established_y_corrected_j_peaked = []
for j in range(Nloops):
print('Established Peaked Corrected Files ' + samplerate_name +
';' + str(n_box) + ',' + str(n_delay) + ',' +
str(n_att) + ';' + str(i) + ',' + str(j))
filename = filedir + 'Phase--waveforms--%05d.txt' % j
(t, v, _) = rw(filename, numhead)
t_avg, v_avg = boxcar_wf(t, v, n_box)
v_delay = delay_wf(v_avg, n_delay)
v_att = attenuate_wf(v_avg, n_att)
v_sum = sum_wf(v_att, v_delay)
t_cross, _, _ = zc_locator(t_avg, v_sum)
established_t_corrected_peaked = t_cross - established_median_value_peaked + established_correction_median_array_peaked[
i]
established_y_corrected_j_peaked.append(
established_t_corrected_peaked)
established_corrected_correction_peaked = -1 * i * phase_time - established_t_corrected_peaked
established_corrected_corrections_j_peaked.append(
established_corrected_correction_peaked)
established_corrected_median_array_peaked.append(
np.median(np.asarray(established_y_corrected_j_peaked)))
established_corrected_correction_median_array_peaked.append(
np.median(
np.asarray(established_corrected_corrections_j_peaked)))
established_y_corrected_peaked = established_y_corrected_peaked + established_y_corrected_j_peaked
established_corrected_corrections_peaked = established_corrected_corrections_peaked + established_corrected_corrections_j_peaked
established_y_corrected_peaked = np.asarray(
established_y_corrected_peaked)
established_corrected_correction_median_array_peaked = np.asarray(
established_corrected_correction_median_array_peaked)
established_corrected_corrections_peaked = np.asarray(
established_corrected_corrections_peaked)
savedir = 'G:/data/watchman/' + str(
datadate
) + '_watchman_spe/studies/phase/' + samplerate_name + '/array_data/'
if not os.path.exists(savedir):
os.makedirs(savedir)
np.savetxt(savedir + 'x.csv', x, delimiter=',')
np.savetxt(savedir + 'y.csv', y, delimiter=',')
np.savetxt(savedir + 'x_bins.csv', x_bins, delimiter=',')
np.savetxt(savedir + 'y_bins.csv', y_bins, delimiter=',')
np.savetxt(savedir + 'median_array.csv', median_array, delimiter=',')
np.savetxt(savedir + 'correction.csv', correction, delimiter=',')
np.savetxt(savedir + 'y_bins_corrections.csv',
y_bins_corrections,
delimiter=',')
np.savetxt(savedir + 'correction_median_array.csv',
correction_median_array,
delimiter=',')
np.savetxt(savedir + 'y_corrected.csv', y_corrected, delimiter=',')
np.savetxt(savedir + 'corrected_median_array.csv',
corrected_median_array,
delimiter=',')
np.savetxt(savedir + 'corrected_corrections.csv',
corrected_corrections,
delimiter=',')
np.savetxt(savedir + 'corrected_correction_median_array.csv',
corrected_correction_median_array,
delimiter=',')
np.savetxt(savedir + 'established_x_noised.csv',
established_x_noised,
delimiter=',')
np.savetxt(savedir + 'established_y_noised.csv',
established_y_noised,
delimiter=',')
np.savetxt(savedir + 'established_x_bins_noised.csv',
established_x_bins_noised,
delimiter=',')
np.savetxt(savedir + 'established_y_bins_noised.csv',
established_y_bins_noised,
delimiter=',')
np.savetxt(savedir + 'established_median_array_noised.csv',
established_median_array_noised,
delimiter=',')
np.savetxt(savedir + 'established_correction_noised.csv',
established_correction_noised,
delimiter=',')
np.savetxt(savedir + 'established_y_bins_corrections_noised.csv',
established_y_bins_corrections_noised,
delimiter=',')
np.savetxt(savedir + 'established_correction_median_array_noised.csv',
established_correction_median_array_noised,
delimiter=',')
np.savetxt(savedir + 'established_y_corrected_noised.csv',
established_y_corrected_noised,
delimiter=',')
np.savetxt(savedir + 'established_corrected_median_array_noised.csv',
established_corrected_median_array_noised,
delimiter=',')
np.savetxt(savedir + 'established_corrected_corrections_noised.csv',
established_corrected_corrections_noised,
delimiter=',')
np.savetxt(savedir +
'established_corrected_correction_median_array_noised.csv',
established_corrected_correction_median_array_noised,
delimiter=',')
np.savetxt(savedir + 'established_x_peaked.csv',
established_x_peaked,
delimiter=',')
np.savetxt(savedir + 'established_y_peaked.csv',
established_y_peaked,
delimiter=',')
np.savetxt(savedir + 'established_x_bins_peaked.csv',
established_x_bins_peaked,
delimiter=',')
np.savetxt(savedir + 'established_y_bins_peaked.csv',
established_y_bins_peaked,
delimiter=',')
np.savetxt(savedir + 'established_median_array_peaked.csv',
established_median_array_peaked,
delimiter=',')
np.savetxt(savedir + 'established_correction_peaked.csv',
established_correction_peaked,
delimiter=',')
np.savetxt(savedir + 'established_y_bins_corrections_peaked.csv',
established_y_bins_corrections_peaked,
delimiter=',')
np.savetxt(savedir + 'established_correction_median_array_peaked.csv',
established_correction_median_array_peaked,
delimiter=',')
np.savetxt(savedir + 'established_y_corrected_peaked.csv',
established_y_corrected_peaked,
delimiter=',')
np.savetxt(savedir + 'established_corrected_median_array_peaked.csv',
established_corrected_median_array_peaked,
delimiter=',')
np.savetxt(savedir + 'established_corrected_corrections_peaked.csv',
established_corrected_corrections_peaked,
delimiter=',')
np.savetxt(savedir +
'established_corrected_correction_median_array_peaked.csv',
established_corrected_correction_median_array_peaked,
delimiter=',')
return ()
#import necessary
from matplotlib import pyplot as plt
from readwaveform import read_waveform as rw
import numpy as np
import os
#plotting the waveforms
Nloops = len(
os.listdir(
'G:/data/watchman/20190724_watchman_spe/d3/500 Mhz/d3_averages/raw/'))
plt.rcParams.update({'font.size': 14})
for i in range(Nloops):
print('File: %05d' % i)
#collecting data for various risetimes
(t_single, v_single, _) = rw(
'G:/Data/watchman/20190724_watchman_spe/d3/500 Mhz/d3_averages/raw/D3--waveforms--%05d.txt'
% i, 1)
(t_double, v_double, _) = rw(
'G:/Data/watchman/20190724_watchman_spe/d3/500 Mhz/d3_averages/rise_doubled/D3--waveforms--%05d.txt'
% i, 1)
(t_quadruple, v_quadruple, _) = rw(
'G:/Data/watchman/2019724_watchman_spe/d3/500 Mhz/d3_averages/rise_quadrupled/D3--waveforms--%05d.txt'
% i, 1)
(t_octuple, v_octuple, _) = rw(
'G:/Data/watchman/20190724_watchman_spe/d3/500 Mhz/d3_averages/rise_octupled/D3--waveforms--%05d.txt'
% i, 1)
#initializing plots
plt.rcParams.update({'font.size': 14})
unshaped, = plt.plot(t_single, -1 * v_single, label='Unshaped Waveform')
doubled, = plt.plot(t_double,
-1 * v_double,
def fitter_timing(datadate, numhead, samplerate, samplerate_name, shaping):
if samplerate_name == 'INVALID':
return ("Failed")
phase_time = 1 / 20000000000
maxphase = int(20000000000 / samplerate + 0.5)
t_fitter, v_fitter, _ = rw(
'G:/data/watchman/' + datadate + '_watchman_spe/d2/d2_average.txt', 1)
uspl = us(t_fitter, v_fitter)
filedir = 'G:/data/watchman/' + str(
datadate
) + '_watchman_spe/studies/phase/' + samplerate_name + '/file_template/'
Nloops = len(os.listdir(filedir + 'phase=0/phase_' + shaping))
difference_list = []
chi_list = []
for i in range(Nloops):
print(i)
j = random.randint(0, maxphase - 1)
filename = filedir + 'phase=' + str(
j) + '/phase_' + shaping + '/Phase--waveforms--%05d.txt' % i
t, v, _ = rw(filename, numhead)
v = -1 * v
ET = t[0:10]
EV = v[0:10]
chi2_min = -1
x_min = -1
y_min = -1
shift_min = -1
shifts = np.arange(0, 80 / 20000000000, 1e-11)
for shift in shifts:
pre_OV = uspl(ET + shift)
A = np.array([[
np.sum(np.square(pre_OV)),
np.sum(pre_OV),
np.sum(np.multiply(pre_OV, EV))
], [np.sum(pre_OV), len(EV), np.sum(EV)]])
A[0] = A[0] / A[0][0]
A[1] = np.subtract(A[1], A[1][0] * A[0])
A[1] = A[1] / A[1][1]
A[0] = np.subtract(A[0], A[0][1] * A[1])
x = A[0][2]
y = A[1][2]
OV = x * pre_OV + y
chi2 = chi_squared(OV, EV)
if chi2_min < 0:
shift_min = shift
chi2_min = chi2
x_min = x
y_min = y
elif chi2 < chi2_min:
shift_min = shift
chi2_min = chi2
x_min = x
y_min = y
v_fit = x_min * uspl(t_fitter + shift_min) + y_min
t_cross = timing_extraction(t_fitter, v_fit)
#if (-1*j*phase_time - t_cross) < -1e-7:
# _,ax = plt.subplots()
# ax.plot(t,v)
# ax.plot(t_fitter,v_fit)
# ax.scatter(ET,EV)
# ax.axvline(-1*j*phase_time,color = 'Black')
# ax.axvline(t_cross,color = 'Red')
# ax.set_title(str(-1*j*phase_time - t_cross) + ', ' + str(chi2_min) + ', ' + str(i) + ', ' + str(j))
# plt.get_current_fig_manager().window.showMaximized()
# plt.show()
difference_list.append((-1 * j * phase_time - t_cross)[0])
chi_list.append(chi2_min)
difference_list = np.asarray(difference_list)
chi_list = np.asarray(chi_list)
true_mean = '%5g' % (np.mean(difference_list) * 1e12)
true_std = '%5g' % (np.std(difference_list) * 1e12)
bins = 30 #np.linspace(-2.2e-9,2.2e-9,num = 100)
histo_data, bins_data = np.histogram(difference_list, bins=bins)
binwidth = (bins_data[1] - bins_data[0])
binscenters = np.array([
0.5 * (bins_data[i] + bins_data[i + 1])
for i in range(len(bins_data) - 1)
])
FontSize = 32
plt.rcParams.update({'font.size': FontSize})
_, ax = plt.subplots()
ax.bar(binscenters, histo_data, width=binwidth)
ax.set_xlabel('True Timing - Recovered Timing')
ax.set_ylabel('Count')
ax.set_title(samplerate_name + ' - Fitter Timings')
ax.text(0.05,
0.95,
'Distribution Parameters:\nMean: ' + true_mean +
' ps\nStandard Deviation: ' + true_std + ' ps',
transform=ax.transAxes,
fontsize=FontSize,
verticalalignment='top',
bbox=dict(boxstyle='round', facecolor='White', alpha=0.5))
plt.get_current_fig_manager().window.showMaximized()
plt.show()
plt.close()
bins = 30 #np.linspace(0,30200,num = 100)
histo_data, bins_data = np.histogram(chi_list, bins=bins)
binwidth = (bins_data[1] - bins_data[0])
binscenters = np.array([
0.5 * (bins_data[i] + bins_data[i + 1])
for i in range(len(bins_data) - 1)
])
plt.rcParams.update({'font.size': FontSize})
plt.bar(binscenters, histo_data, width=binwidth, log=True)
plt.xlabel('Chi Squared')
plt.ylabel('Count')
plt.title(samplerate_name + ' - Chi Squared Counts - Fitter Timings')
plt.get_current_fig_manager().window.showMaximized()
plt.show()
plt.close()
_, ax = plt.subplots()
h = ax.hist2d(difference_list, chi_list, bins=30, norm=LogNorm())
plt.colorbar(h[3], ax=ax)
ax.set_title(samplerate_name +
' - Chi Squared vs. Timing Corrections - Fitter Timings')
ax.set_xlabel('Timing Corrections')
ax.set_ylabel('Chi Squared')
plt.get_current_fig_manager().window.showMaximized()
plt.show()
plt.close()
return ("Passed")
def p1b_sort(datadate,charge_mean,peak_mean,FWHM_mean,numhead):
#set file locations for charge and peak histograms
charge_name = 'G:/data/watchman/'+datadate+'_watchman_spe/d1/d1_histograms/charge.txt'
peak_name = 'G:/data/watchman/'+datadate+'_watchman_spe/d1/d1_histograms/peak_amplitude.txt'
FWHM_name = 'G:/data/watchman/'+datadate+'_watchman_spe/d1/d1_histograms/FWHM.txt'
ten_jitter_name = 'G:/data/watchman/'+datadate+'_watchman_spe/d1/d1_histograms/10_jitter.txt'
twenty_jitter_name = 'G:/data/watchman/'+datadate+'_watchman_spe/d1/d1_histograms/20_jitter.txt'
#initialize histogram arrays
charge_histo = np.array([])
peak_histo = np.array([])
FWHM_histo = np.array([])
ten_jitter_histo = np.array([])
twenty_jitter_histo = np.array([])
#read histogram txt files int othe arrays
charge_fin = open(charge_name,'r')
for line in charge_fin:
charge_histo = np.append(charge_histo, float(line.split(',')[0]))
charge_fin.close
peak_fin = open(peak_name,'r')
for line in peak_fin:
peak_histo = np.append(peak_histo, float(line.split(',')[0]))
peak_fin.close
FWHM_fin = open(FWHM_name,'r')
for line in FWHM_fin:
FWHM_histo = np.append(FWHM_histo, float(line.split(',')[0]))
FWHM_fin.close
ten_jitter_fin = open(ten_jitter_name,'r')
for line in ten_jitter_fin:
ten_jitter_histo = np.append(ten_jitter_histo, float(line.split(',')[0]))
ten_jitter_fin.close
twenty_jitter_fin = open(twenty_jitter_name,'r')
for line in twenty_jitter_fin:
twenty_jitter_histo = np.append(twenty_jitter_histo, float(line.split(',')[0]))
twenty_jitter_fin.close
#setting up arrays listing indices of where the value is twice the mean or greater
charge_doubles = np.asarray(charge_histo >= 2*charge_mean).nonzero()
charge_doubles = charge_doubles[0]
peak_doubles = np.asarray(peak_histo >= 2*peak_mean).nonzero()
peak_doubles = peak_doubles[0]
FWHM_doubles = np.asarray(FWHM_histo >= 2*FWHM_mean).nonzero()
FWHM_doubles = FWHM_doubles[0]
ten_jitter_positive = np.asarray(ten_jitter_histo > 0).nonzero()
ten_jitter_positive = ten_jitter_positive[0]
twenty_jitter_positive = np.asarray(twenty_jitter_histo > 0).nonzero()
twenty_jitter_positive = twenty_jitter_positive[0]
for i in range(len(charge_histo)):
print(i)
#setting location of files to read
filename = 'G:/data/watchman/'+datadate+'_watchman_spe/d1/d1_50centered/D1--waveforms--%05d.txt' % i
#setting up locations to write each file to
writename_double = 'G:/data/watchman/'+datadate+'_watchman_spe/d1/d1_final_doubles/D1--waveforms--%05d.txt' % i
writename_single = 'G:/data/watchman/'+datadate+'_watchman_spe/d1/d1_final_spes/D1--waveforms--%05d.txt' % i
if not os.path.exists('G:/data/watchman/'+datadate+'_watchman_spe/d1/d1_final_doubles/'):
os.makedirs('G:/data/watchman/'+datadate+'_watchman_spe/d1/d1_final_doubles/')
if not os.path.exists('G:/data/watchman/'+datadate+'_watchman_spe/d1/d1_final_spes/'):
os.makedirs('G:/data/watchman/'+datadate+'_watchman_spe/d1/d1_final_spes/')
t,v,header = rw(filename,numhead) #reading data from waveform file
#checking if both charge and peak or charge and FWHM are greater than twice the mean
if (np.any(charge_doubles == i) and np.any(peak_doubles == i)) or (np.any(FWHM_doubles == i) and np.any(charge_doubles == i)):
print("Was double!")
write_waveform(t,v,writename_double,header)
#checking if any charge, peak, or FWHM are greater than twice the mean or if 10% or 20% rise times are positive
elif any([np.any(charge_doubles == i), np.any(peak_doubles == i), np.any(FWHM_doubles == i), np.any(ten_jitter_positive == i), np.any(twenty_jitter_positive == i)]):
#printing off what caused the graph to display for manual selection
if np.any(charge_doubles == i):
print("Charge")
if np.any(peak_doubles == i):
print("Peak")
if np.any(FWHM_doubles == i):
print("FWHM")
if np.any(ten_jitter_positive == i):
print("10% Jitter")
if np.any(twenty_jitter_positive == i):
print("20% Jitter")
plt.title(filename)
plt.plot(t,v) #plotting waveform in question
plt.get_current_fig_manager().window.showMaximized() #maximizes plot
plt.show()
double_check = 'Initialization.'
while double_check != 's' and double_check != 'd':
double_check = input('Is there a single or double? "s" or "d"\n')
if double_check == 's':
write_waveform(t,v,writename_single,header)
if double_check == 'd':
print("Was double!")
write_waveform(t,v,writename_double,header)
else:
write_waveform(t,v,writename_single,header)
return
