hipa_apps4ops/tina
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added injector2

Browse Source
This commit is contained in:
chrin
2025-12-10 12:40:25 +01:00
parent f8b3479715
commit 5476f36cd3
6 changed files with 571 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

267
readdatafileInjector.py Normal file
View File

@@ -0,0 +1,267 @@
import h5py as hdf
import math
import numpy as np
from scipy import signal
from scipy.signal import hilbert
import sys
import matplotlib
import matplotlib.pyplot as plt
file = open('/hipa/bd/data/measurements/tina/C1--333--00000 1ms 800uA.dat','r')
content = file.readlines()
#print(content)
file.close()
t = []
y1 = []
y2 = []
yall1 = []
yall2 = []
idxall = []
#t_stepsize = 0.0000000004*50
t_stepsize = 1/(50.6328*10**6)/50 # 0.00000002
print(t_stepsize)
print(1/(2.5*10**9))
#t_stepsize = 1/(2.5*10**9)
t_offset = 2500002/2
t_inc = 0
for count, entry in enumerate(content[0:]):
entry=entry.replace('\n','')
val=entry.split(' ')
if count < 50:
print(count, val[0], val[1])
t_inc += t_stepsize
t.append(val[0])
yall1.append(float(val[1])*(-1))
#yall2.append(float(val[2]))
idxall.append(t_inc) #count
#if count < 200:
# break
# print(val[1], val[2], count, t_inc )
#if count > 300:
# sys.exit(0)
sys.exit()
start=12
stop=2500002
_y1 = []
_y2 = []
count = 0
t_inc = 0
idx = []
for val in range(start,stop,50):
_test1_array = yall1[val : val+50]
_test2_array = yall2[val : val+50]
_y1.append(np.array(_test1_array).max())
_y2.append(np.array(_test2_array).max())
count += 1
t_inc += t_stepsize
idx.append(t_inc)
idx = np.array(idx) - t_offset*t_stepsize
y1 = _y1
y2 = _y2
print(y1[0:50], y2[0:50] )
f1 = hdf.File('/hipa/bd/data/measurements/Tina_2024-09-13_15:57:07.h5','a')
#f1 = hdf.File('/hipa/bd/data/measurements/Tina_2024-07-03_15:44:14.h5','a') #5Tina_2024-08-07_10:41:04.h5','a')
grp = f1.require_group('Raw_data')
if 't' in grp:
del grp['t']
if 'y1' in grp:
del grp['y1']
if 't_idx' in grp:
del grp['t_idx']
if 'y2' in grp:
del grp['y2']
if 'yall1' in grp:
del grp['yall1']
if 'yall2' in grp:
del grp['yall2']
dset_yall1 = grp.create_dataset('yall1', data=yall1)
dset_yall2 = grp.create_dataset('yall2', data=yall2)
dset_t = grp.create_dataset("t", data=t)
dset_y1 = grp.create_dataset('y1', data=y1)
dset_y2 = grp.create_dataset('y2', data=y2)
dset_t_idx = grp.create_dataset("t_idx", data=idx)
print(dset_y1.name)
f1.close()
analytic_signal_1 = y1 #hilbert(y1)
amplitude_envelope_1 = np.abs(analytic_signal_1) #analytic_signal_1 #
analytic_signal_2 = y2 #hilbert(y2)
amplitude_envelope_2 = np.abs(analytic_signal_2) #analytic_signal_2 #
#amplitude_envelope_1, peaks1 = signal.find_peaks(y1, height=0.012)
#amplitude_envelope_2, peaks2 = signal.find_peaks(y2, height=0.015)
mean_amplitude_envelope_1 = np.mean(amplitude_envelope_1, keepdims=True)
mean_amplitude_envelope_2 = np.mean(amplitude_envelope_2, keepdims=True)
mean_amplitude_envelope_1 = np.mean(analytic_signal_1, keepdims=True)
mean_amplitude_envelope_2 = np.mean(analytic_signal_2, keepdims=True)
print(mean_amplitude_envelope_1, mean_amplitude_envelope_2)
normalized_amplitude_envelope_1 = (analytic_signal_1 - mean_amplitude_envelope_1) #/ (np.std(amplitude_envelope_1)) # * len(amplitude_envelope_1))
normalized_amplitude_envelope_2 = (analytic_signal_2 - mean_amplitude_envelope_2) #/ (np.std(amplitude_envelope_2))
#normalized_amplitude_envelope_1 = (amplitude_envelope_1 - mean_amplitude_envelope_1) #/ (np.std(amplitude_envelope_1)) # * len(amplitude_envelope_1))
#normalized_amplitude_envelope_2 = (amplitude_envelope_2 - mean_amplitude_envelope_2) #/ (np.std(amplitude_envelope_2))
#rms_amplitude_envelope_1 = np.sqrt(np.mean(normalized_amplitude_envelope_1**2))
#rms_amplitude_envelope_2 = np.sqrt(np.mean(normalized_amplitude_envelope_2**2))
#print(rms_amplitude_envelope_1, rms_amplitude_envelope_2)
#norm_1 = np.linalg.norm(amplitude_envelope_1)
#normalized_amplitude_envelope_1 = amplitude_envelope_1/norm_1
#norm_2 = np.linalg.norm(amplitude_envelope_2)
#normalized_amplitude_envelope_2 = amplitude_envelope_2/norm_2
print (normalized_amplitude_envelope_1[0:10])
print (amplitude_envelope_1[0:10])
'''
y2_peaks = signal.find_peaks(normalized_amplitude_envelope_2, height=0.005)
y1_peaks = signal.find_peaks(normalized_amplitude_envelope_1, height=0.002)
print(y2_peaks)
print(y1_peaks)
print(y1_peaks[0])
print(y1_peaks[1]['peak_heights'])
print("length y1 peaks", len(y1_peaks[0]))
print(y2_peaks[0])
print(y2_peaks[1]['peak_heights'])
print("length y2 peaks", len(y2_peaks[0]))
#sys.exit(1)
normalized_amplitude_envelope_1_p = y1_peaks[1]['peak_heights']
normalized_amplitude_envelope_2_p = y2_peaks[1]['peak_heights']
#normalized_amplitude_envelope_1_p = y1
#normalized_amplitude_envelope_2_p = y2
#sys.exit(0)
'''
y1_array = []
y2_array = []
'''
for i, val in enumerate(y1):
if (i in y1_peaks[0]):
_idx = np.where(y1_peaks[0] == i)[0][0]
y1_array.append(y1_peaks[1]['peak_heights'][_idx])
else:
y1_array.append(0)
for i, val in enumerate(y2):
if i in y2_peaks[0]:
_idx = np.where(y2_peaks[0] == i)[0][0]
y2_array.append(y2_peaks[1]['peak_heights'][_idx])
else:
y2_array.append(0)
'''
#print(len(y1_array))
#print(len(y2_array))
#sys.exit(0)
#normalized_amplitude_envelope_1_p = y1_array
#normalized_amplitude_envelope_2_p = y2_array
idx2 = []
idx_neg = []
#for val in reversed(idx[1:]):
# idx_neg.append(val * (-1))
#idx2 = idx + idx_neg
mid_time = idx[-1]/2
for val in idx:
idx_neg.append(val-mid_time)
#print(normalized_amplitude_envelope_1_p)
#print(normalized_amplitude_envelope_2_p)
#normalized_amplitude_envelope_1_p = y1
#normalized_amplitude_envelope_2_p = y2
corr = signal.correlate(normalized_amplitude_envelope_2, normalized_amplitude_envelope_1, mode='same', method='auto')/len(amplitude_envelope_1)
corr_full = signal.correlate(normalized_amplitude_envelope_2, normalized_amplitude_envelope_1, mode='full', method='auto') #/len(amplitude_envelope_1)
#corr_valid = signal.correlate(normalized_amplitude_envelope_1, normalized_amplitude_envelope_2, mode='valid', method='auto')
lags = signal.correlation_lags(len(normalized_amplitude_envelope_2), len(normalized_amplitude_envelope_1), mode='same')
lags_full = signal.correlation_lags(len(normalized_amplitude_envelope_2), len(normalized_amplitude_envelope_1), mode='full')
lags_full = lags_full #* t_stepsize
lags = lags #* t_stepsize
#lags_valid = signal.correlation_lags(len(normalized_amplitude_envelope_2), len(normalized_amplitude_envelope_1), mode='valid')
lag_full = lags_full[np.argmax(corr_full)]
lag = lags[np.argmax(corr)]
#lag_valid = lags_valid[np.argmax(corr_valid)]
#corr = corr/rms_amplitude_envelope_1/rms_amplitude_envelope_2
print("lag same/full", lag, lag_full)
print("lag same/full", lag * t_stepsize, lag_full * t_stepsize)
print("length lags", len(lags))
print("VALID", signal.correlate(normalized_amplitude_envelope_1, normalized_amplitude_envelope_2, mode='valid'))
#lags = signal.correlation_lags(len(amplitude_envelope_2), len(amplitude_envelope_1))
#corr4 = signal.correlate(analytic_signal_1, analytic_signal_2, mode='full')
print(len(y2))
print(len(amplitude_envelope_2))
print("max correlation", np.max(corr))
print("arg of max corrrelation", np.argmax(corr))
print("time index", idx[np.argmax(corr)])
#print(y1)
#y1 = [0.000231, -0.000273, 0.000206, 0.000408,
#0.000609, 0.000231, 0.000508, 0.000760,
#0.000433, 0.000206, 0.000231, 0.000130]
subplots = 4
ln=500
ln2=1239770
ln3=1260230
if subplots == 4:
fig, (ax) = plt.subplots(nrows=2, ncols=2, figsize=(18,9))
#ax1.yticks(np.arange(min(y1), max(y1), 1))
ax[0,0].ticklabel_format(useOffset=False, style='plain')
#ax[0,0].plot(idx[0:ln], amplitude_envelope_1[0:ln], 'b')
#y1
ax[0,0].plot(idxall[0:ln], yall1[0:ln], 'ro')
###ax[0,0].plot(idx[0:ln2], normalized_amplitude_envelope_1[0:ln2], 'ro')
#ax1.set_ylim([-0.05, 0.05])
#y2
###ax[1,0].plot(idx[0:ln2], normalized_amplitude_envelope_2[0:ln2], 'ro')
ax[1,0].plot(idxall[0:ln], yall2[0:ln], 'ro')
#ax[1,0].plot(idx[0:ln], amplitude_envelope_2[0:ln], 'g')
#else:
# fig, (ax3, ax4) = plt.subplots(2, figsize=(20,12))
ax[0,1].plot(lags[:], corr[:])
#ax3.plot(corr)
ax[1,1].plot(lags_full[:], corr_full[:], 'yo')
#start, end = ax1.get_ylim()
#start2, end2 = ax2.get_ylim()
#print(start, end)
#print(start2, end2)
#ax1.yaxis.set_ticks(np.arange(start, end, 10))
#ax2.yaxis.set_ticks(np.arange(start2, end2, 10))
plt.show()

253
src/analysis.py
View File

@@ -96,14 +96,15 @@ class AnalysisProcedure(QObject):
self.t_interval = math.ceil(self.pulse_stepsize / self.t_stepsize)
self.correlation_peak_diff = 0.0
self.signal_min_peak_height = 4 # 50
self.signal_min_peak_distance = 10
self.signal_min_peak_height = 0 # 50
self.signal_min_peak_height_exit = 0
self.signal_min_peak_distance = 20
self.correlation_min_peak_diff = 0.01
self.dt_cable = 44 # ns
self.dn_pickup = -1
self.mod_freq = 500 # GHz
self.duty_cycle = 1 # percentage
####self.mod_freq = 500 # GHz
###self.duty_cycle = 1 # percentage
self.delay = 0
self.lag_full = 0
@@ -143,10 +144,6 @@ class AnalysisProcedure(QObject):
self.input_data = input_data
self.all_data['Input data'] = self.input_data
idx = self.accelerator_list.index(self.accelerator)
self.parent.gui_frame.line_sender_dict['accelerator'].setCurrentIndex(
idx)
print(f'init input parameters {self.input_data}', flush=True)
if reanalysis:
self.loglevel = self.input_parameters['loggingLevel']
@@ -164,18 +161,22 @@ class AnalysisProcedure(QObject):
self.simulation = bool(self.input_data['simulation'])
self.rf_freq = float(self.input_data['freqrf'])
# 2.5 MHz if oscilloscpe
if self.simulation:
if self.simulation and 'Cyclotron' in self.accelerator:
self.rf_sample = 2.5
mess = 'Sampling rate changed to 2.5 MHz for oscilloscope data'
self.parent.trigger_log_message.emit(
MsgSeverity.INFO.name, _pymodule, utils.line_no(), mess, {})
# else:
# self.rf_sample = float(self.input_data['freqsampling'])
try:
self.accelerator = self.input_data['accelerator']
print(f'Accelerator: {self.accelerator}', flush=True)
self.accelerator_peak_search = ' ' + self.accelerator + ' '
self.harmonic_no = float(
self.input_data[self.accelerator]['harmonic'])
@@ -192,12 +193,14 @@ class AnalysisProcedure(QObject):
self.reverse_input_signal = bool(
self.input_data[self.accelerator_peak_search]['reverseInput'])
'''
if self.injector_2 in self.accelerator:
self.mod_freq = float(
self.input_data[self.accelerator]['freqmod']) # * 10**9 GHz
self.duty_cycle = float(
self.input_data[self.accelerator]['dutycycle']) # * 0.01
'''
self.logger.info('INPUT PARAMETERS')
self.logger.info(f'Accelerator: {self.accelerator}')
@@ -230,6 +233,15 @@ class AnalysisProcedure(QObject):
except ValueError as ex:
self.logger.error(f'ValueError {ex}')
try:
self.signal_min_peak_height_exit = int(
self.input_data[self.accelerator_peak_search]['peakHeightExit'])
except KeyError as ex:
self.logger.error(f'KeyError {ex}')
except ValueError as ex:
self.logger.error(f'ValueError {ex}')
# Overide peak search parameters with those given in gui
if reanalysis:
self.correlation_min_peak_diff = float(self.input_parameters[
@@ -248,16 +260,37 @@ class AnalysisProcedure(QObject):
self.input_parameters[self.accelerator_peak_search][
'reverseInput'])
try:
self.signal_min_peak_height_exit = int(
self.input_parameters[self.accelerator_peak_search][
'peakHeightExit'])
except KeyError as ex:
self.logger.error(f'KeyError {ex}')
#backward compatibility
self.signal_min_peak_height_exit = self.signal_min_peak_height
except ValueError as ex:
self.logger.error(f'ValueError {ex}')
#backward compatibility
self.signal_min_peak_height_exit = self.signal_min_peak_height
print(f'self.input_parameters={self.input_parameters}')
print(('Reanalysis: self.correlation_min_peak_diff= ' +
f'{self.correlation_min_peak_diff}'))
self.logger.info(
f'Corr Min Peak Diff {self.correlation_min_peak_diff}')
self.logger.info(f'Min Peak Height {self.signal_min_peak_height}')
self.logger.info(f'Min Peak Height Entry {self.signal_min_peak_height}')
self.logger.info(
f'Min Peak Height Exit {self.signal_min_peak_height_exit}')
self.logger.info(f'Min Peak Distance {self.signal_min_peak_distance}')
idx = self.accelerator_list.index(self.accelerator)
print('accelerator/idx', self.accelerator, idx)
self.parent.gui_frame.line_sender_dict['accelerator'].setCurrentIndex(
idx)
def measure_and_analyze(self, input_data=None):
'''This method is initiated by the START button in Procedure panel
'''
@@ -271,7 +304,8 @@ class AnalysisProcedure(QObject):
self.initialize_input_parameters(input_data)
self.logger.info(
f'Corr Min Peak Diff {self.correlation_min_peak_diff}')
self.logger.info(f'Min Peak Height {self.signal_min_peak_height}')
self.logger.info(f'Min Peak Height Entry {self.signal_min_peak_height}')
self.logger.info(f'Min Peak Height Exit {self.signal_min_peak_height_exit}')
self.logger.info(
f'Min Peak Distance {self.signal_min_peak_distance}')
@@ -314,6 +348,9 @@ class AnalysisProcedure(QObject):
def reanalyze(self, all_data):
'''Reanalysis
'''
print('Reanalyze', flush=True)
print(all_data, flush=True)
@@ -480,36 +517,61 @@ class AnalysisProcedure(QObject):
height = 0.005
print(f'self.signal_min_peak_height = {height}')
#if 'Injector' in self.accelerator:
# height = -470 #530 #350
# y1_height = height
# returns indices of peaks, and dictionary of properties
y1_peaks_pre = signal.find_peaks(self.y1_sample, height=height,
distance=self.signal_min_peak_distance)
print(
'peak length==>', len(
'y1 peak length==>', len(
y1_peaks_pre[1]['peak_heights']), flush=True)
if len(y1_peaks_pre[1]['peak_heights']) < 2:
return False
print('peak length=============>', len(
print('y1 peak length=============>', len(
y1_peaks_pre[1]['peak_heights']), flush=True)
##y1_peaks_avg = np.average(y1_peaks_pre[1]['peak_heights'])
min_y1_p = np.min(y1_peaks_pre[1]['peak_heights'])
max_y1_p = np.max(y1_peaks_pre[1]['peak_heights'])
print(f'min and max value of peak {min_y1_p}, {max_y1_p}')
y1_height = min_y1_p * 0.9 # y1_peaks_avg * 0.726667
try:
##y1_peaks_avg = np.average(y1_peaks_pre[1]['peak_heights'])
min_y1_p = np.min(y1_peaks_pre[1]['peak_heights'])
max_y1_p = np.max(y1_peaks_pre[1]['peak_heights'])
print(f'min and max value of peak y1 {min_y1_p}, {max_y1_p}')
if max_y1_p < 0:
y1_height = max_y1_p * 1.3 # Injector
else:
y1_height = min_y1_p * 0.9 # Cyclotron y1_peaks_avg * 0.726667
except ValueError:
y1_height = height
if not self.simulation:
height = self.signal_min_peak_height_exit
y2_peaks_pre = signal.find_peaks(self.y2_sample, height=height,
distance=self.signal_min_peak_distance)
print(f"y2 Height = {height} dist = {self.signal_min_peak_distance}")
y2_peaks_pre = signal.find_peaks(
self.y2_sample, height=height,
distance=self.signal_min_peak_distance)
##y2_peaks_avg = np.average(y2_peaks_pre[1]['peak_heights'])
min_y2_p = np.min(y2_peaks_pre[1]['peak_heights'])
max_y2_p = np.max(y2_peaks_pre[1]['peak_heights'])
print(f'min and max value of peak {min_y2_p}, {max_y2_p}')
try:
min_y2_p = np.min(y2_peaks_pre[1]['peak_heights'])
max_y2_p = np.max(y2_peaks_pre[1]['peak_heights'])
print(f'min and max value of peak y2 {min_y2_p}, {max_y2_p}')
y2_height = min_y2_p * 0.9 # y2_peaks_avg * 0.566667
y2_height = min_y2_p * 0.9 # y2_peaks_avg * 0.566667
except ValueError:
y2_height = height
print(f'AVG = {y1_height}, {y2_height}', flush=True)
if 'Injector' in self.accelerator and self.simulation:
y1_height = 0.02
y2_height = 0.05
y1_peaks = signal.find_peaks(
self.y1_sample, height=y1_height,
distance=self.signal_min_peak_distance)
@@ -554,6 +616,40 @@ class AnalysisProcedure(QObject):
self.y2_pulse = []
self.t_pulse = []
def extract_raw_data_injector(idx=0):
'''Oscilloscope data
'''
#t_inc = 0
for entry in self.content[0:]:
entry = entry.replace('\n', '')
val = entry.split(' ')
#self.t_sample.append(float(t_inc))
if idx == 0:
self.y1_sample.append(float(val[1]))
self.y1_sample_raw.append(float(val[1]))
#t_inc += self.t_stepsize
else:
self.y2_sample.append(float(val[1]))
self.y2_sample_raw.append(float(val[1]))
#self.y1_sample = self.y1_sample[::-1]
#self.y2_sample = self.y2_sample[::-1]
#self.y1_sample = (hilbert(self.y1_sample_raw))
#print("hilbert y1 done")
#self.y2_sample = (hilbert(self.y2_sample_raw))
#self.y2_sample = self.y2_sample[::-1]
#print('length y1_sample ==', len(self.y1_sample))
#self.y1_sample = np.abs(self.y1_sample)
#self.y2_sample = np.abs(self.y2_sample)
self.t_sample = [None] * len(self.y1_sample)
self.t_sample[0] = 0
t_inc = 0
for i in range(1, len(self.y1_sample)):
t_inc += self.t_stepsize
self.t_sample[i] = t_inc
def extract_raw_data():
'''Oscilloscope data
'''
@@ -664,6 +760,8 @@ class AnalysisProcedure(QObject):
print(f'y1 sample length = {len(self.y1_sample_raw)}')
print(f'y2 sample length = {len(self.y2_sample_raw)}', flush=True)
#print("raw y2 data after unpack", self.y2_sample_raw)
self.y1_sample = [None] * len(self.y1_sample_raw)
self.y2_sample = [None] * len(self.y2_sample_raw)
@@ -682,14 +780,21 @@ class AnalysisProcedure(QObject):
#series = pd.Series(self.y1_sample)
#self.y1_sample = (series * (-1)).tolist()
#self.y1_sample = (series).tolist()
self.y1_sample = (hilbert(self.y1_sample_raw))
self.y2_sample = (hilbert(self.y2_sample_raw))
print('length y1_sample', len(self.y1_sample))
self.y1_sample = np.abs(self.y1_sample)
self.y2_sample = np.abs(self.y2_sample)
print('length y1_sample ==', len(self.y1_sample))
if 'Injector' in self.accelerator:
self.y1_sample = -np.abs(self.y1_sample)
else:
self.y1_sample = np.abs(self.y1_sample)
self.t_sample = [None] * len(self.y1_sample)
self.t_sample[0] = 0
@@ -701,8 +806,27 @@ class AnalysisProcedure(QObject):
else:
self.trigger_progressbar.emit(30)
with open(
'/hipa/bd/data/measurements/tina/20240710-223007_2000.txt',
'/hipa/bd/data/measurements/tina/C1--333--00000 1ms 800uA.dat',
'r', encoding='utf-8') as file:
#with open(
# '/hipa/bd/data/measurements/tina/20240710-223007_2000.txt',
# 'r', encoding='utf-8') as file:
self.content = file.readlines()
if self.abort:
self.aborting(utils.line_no())
return None
#self.trigger_progressbar.emit(60)
#extract_raw_data()
extract_raw_data_injector(0)
with open(
'/hipa/bd/data/measurements/tina/C2--333--00000 1ms 800uA.dat',
'r', encoding='utf-8') as file:
#with open(
# '/hipa/bd/data/measurements/tina/20240710-223007_2000.txt',
# 'r', encoding='utf-8') as file:
self.content = file.readlines()
if self.abort:
@@ -710,8 +834,9 @@ class AnalysisProcedure(QObject):
return None
self.trigger_progressbar.emit(60)
extract_raw_data()
#extract_raw_data()
extract_raw_data_injector(1)
if self.abort:
self.aborting(utils.line_no())
return None
@@ -719,14 +844,15 @@ class AnalysisProcedure(QObject):
self.trigger_progressbar.emit(70)
# Fill Raw data here
rawdata = {
'y1': list(self.y1_sample_raw),
'y2': list(self.y2_sample_raw),
't': list(self.t_sample),
}
print(len(self.y1_sample), type(self.y1_sample), flush=True)
print(len(self.y2_sample), type(self.y2_sample), flush=True)
print(len(self.t_sample), type(self.t_sample), flush=True)
print("length y1", len(self.y1_sample), type(self.y1_sample), flush=True)
print("length y2", len(self.y2_sample), type(self.y2_sample), flush=True)
print("length t", len(self.t_sample), type(self.t_sample), flush=True)
return rawdata
@@ -741,27 +867,10 @@ class AnalysisProcedure(QObject):
print('length raw data', len(self.raw_data['y1']))
self.y1_sample_raw = self.raw_data['y1']
self.y2_sample_raw = self.raw_data['y2']
if self.reverse_input_signal:
for i in range(0, len(self.y1_sample_raw)):
self.y1_sample_raw[i] = self.y1_sample_raw[i] * (-1)
print('y1 pulse has polarity reversed')
if self.reverse_output_signal:
for i in range(0, len(self.y2_sample_raw)):
self.y2_sample_raw[i] = self.y2_sample_raw[i] * (-1)
print('y2 pulse has polarity reversed')
self.y1_sample = (hilbert(self.raw_data['y1']))
self.y2_sample = (hilbert(self.raw_data['y2']))
print('length y1_sample', len(self.y1_sample))
self.y1_sample = np.abs(self.y1_sample)
self.y2_sample = np.abs(self.y2_sample)
self.t_sample = self.raw_data['t']
# self.extract_peak_data()
#self.y1_pulse = (self.y1_sample)
#self.y2_pulse = (self.y2_sample)
print('unpack hdf_data', flush=True)
def process(self, from_hdf5=False):
@@ -783,8 +892,7 @@ class AnalysisProcedure(QObject):
'No measurement made.')
self.parent.trigger_log_message.emit(
MsgSeverity.ERROR.name, _pymodule, utils.line_no(), mess, {})
return {}
self.mean_amplitude_y1 = np.mean(self.y1_pulse, keepdims=True)
@@ -807,8 +915,19 @@ class AnalysisProcedure(QObject):
len(self.normalized_amplitude_envelope_2),
len(self.normalized_amplitude_envelope_1), mode='full')
#print("length ", len(self.corr_full))
#print("max idx ",np.argmax(self.corr_full))
#startpt = int(len(self.corr_full)/2)+1
#endpt = startpt + 1000
#print(self.corr_full[startpt:endpt])
#print("arg max ", np.argmax(self.corr_full[startpt:endpt]))
#if 'Injector' in self.accelerator:
# self.lag_full = int(
# self.lags_full_array[np.argmax(self.corr_full[startpt:endpt])+startpt])
#else:
self.lag_full = int(
self.lags_full_array[np.argmax(self.corr_full)])
#self.delay = self.lag_full * self.t_stepsize*self.t_interval
self.delay = float(self.lag_full * self.pulse_stepsize)
@@ -826,13 +945,20 @@ class AnalysisProcedure(QObject):
print('harmonic', self.harmonic_no, flush=True)
print('dN pickup', self.dn_pickup, flush=True)
print(f'Correlation Peak Diff {self.correlation_peak_diff}')
print(f'Min Peak Height {self.signal_min_peak_height}')
print(f'Min Peak Height Entry {self.signal_min_peak_height}')
print(f'Min Peak Height Exit {self.signal_min_peak_height_exit}')
print(f'Min Peak Distance {self.signal_min_peak_distance}')
self.n_turns = (
((self.delay - self.dt_cable * 10**(-9)) * self.rf_freq * 10**6)
/ self.harmonic_no) + self.dn_pickup
d = ((54 - self.dn_pickup) * self.harmonic_no) + ((self.dt_cable * 10**(-9)) * self.rf_freq * 10**6)
print ("D54", d)
d = ((74 - self.dn_pickup) * self.harmonic_no) + ((self.dt_cable * 10**(-9)) * self.rf_freq * 10**6)
print ("D74", d/self.pulse_stepsize)
print((f'lag = {self.lag_full}, ' +
f'delay = {self.delay*10**6:.3f} \u00B5s ' +
f'nturns = {self.n_turns:.4f}'))
@@ -867,6 +993,7 @@ class AnalysisProcedure(QObject):
'correlation_peak_diff': self.correlation_peak_diff,
'correlation_min_peak_diff': self.correlation_min_peak_diff,
'min_peak_height': self.signal_min_peak_height,
'min_peak_height_exit': self.signal_min_peak_height_exit,
'min_peak_distance': self.signal_min_peak_distance
}
@@ -974,6 +1101,12 @@ class AnalysisProcedure(QObject):
line_end = ymax # self.corr_full.max()
ax2.plot([self.lag_full, self.lag_full], [line_start, line_end],
':', color='r')
#ax2.plot([500, 500], [line_start, line_end],
# ':', color='r')
#ax2.plot([700, 700], [line_start, line_end],
# ':', color='r')
ax2.set_ylim(line_start, line_end)
text = f'No of Turns = {self.n_turns:0.0f}'

109
src/gui.py
View File

@@ -47,30 +47,38 @@ class AppGui(QWidget):
self.gui_frame.measurement_tab_wgt.setFixedHeight(580)
self.gui_frame.operator_wgt.setFixedHeight(640)
# self.gui_frame.expert_wgt.setFixedHeight(240)
self.gui_frame.expert_wgt.layout().addWidget(
self.low_level_display(), 2, 0, 1, 1)
# self.gui_frame.expert_wgt.layout().addWidget(
# self.low_level_ring_display(), 2, 0, 1, 1)
# self.gui_frame.expert_parameters_group.layout().addWidget(
# self.low_level_ring_display()) #, 12, 0, 1, 1)
self.gui_frame.expert_wgt.layout().setVerticalSpacing(30)
self.gui_frame.measurement_tab_wgt.setCurrentIndex(1)
self.gui_frame.measurement_tab_wgt.setCurrentIndex(0)
self.gui_frame.measurement_tab_wgt.setTabText(0, 'Accelerator')
# DAQ
self.daq_wgt = self.daq_group_qtabwidget(widget_type='QStackedWidget')
self.gui_frame.measurement_layout.addWidget(
self.daq_wgt, 0, 1, 1, 1, alignment=Qt.AlignTop)
self.daq_wgt, 0, 1, 1, 1, alignment=Qt.AlignTop | Qt.AlignLeft)
self.daq_wgt.setCurrentIndex(self.parent.default_idx)
self.daq_wgt.currentChanged.emit(self.parent.default_idx)
self.gui_frame.measurement_layout.setVerticalSpacing(0)
# Accelerator Current
self.current_wgt = self.accelerator_current_group_qtabwidget(
widget_type='QStackedWidget')
self.gui_frame.measurement_layout.addWidget(
self.current_wgt, 1, 1, 1, 1,
alignment=Qt.AlignTop | Qt.AlignCenter)
alignment=Qt.AlignTop | Qt.AlignLeft)
self.low_level_wgt = self.low_level_display_group_qtabwidget()
self.gui_frame.measurement_layout.addWidget(
self.low_level_wgt, 2, 1, 1, 1,
alignment=Qt.AlignTop | Qt.AlignLeft)
self.current_wgt.setCurrentIndex(self.parent.default_idx)
self.current_wgt.currentChanged.emit(self.parent.default_idx)
self.low_level_wgt.setCurrentIndex(self.parent.default_idx)
self.low_level_wgt.currentChanged.emit(self.parent.default_idx)
choice_wgt = self.gui_frame.line_sender_dict['signalPeakSearch']
choice_wgt.name = 'Expert'
self.gui_frame.line_sender_dict['signalSearch'] = choice_wgt
@@ -87,27 +95,10 @@ class AppGui(QWidget):
def cb_accelerator(self, idx):
self.daq_wgt.setCurrentIndex(idx)
self.current_wgt.setCurrentIndex(idx)
#is_sender = self.sender().name
#print(_sender, flush=True)
self.low_level_wgt.setCurrentIndex(idx)
self.gui_frame.line_sender_dict[
'signalPeakSearch'].setCurrentIndex(idx)
'''
if "Expert" in is_sender:
self.gui_frame.line_sender_dict[
'signalPeakSearch'].blockSignals(True)
self.gui_frame.line_sender_dict['accelerator'].setCurrentIndex(idx)
self.gui_frame.line_sender_dict[
'signalPeakSearch'].blockSignals(False)
else:
self.gui_frame.line_sender_dict[
'accelerator'].blockSignals(True)
self.gui_frame.line_sender_dict[
'signalPeakSearch'].setCurrentIndex(idx)
self.gui_frame.line_sender_dict[
'accelerator'].blockSignals(False)
'''
def daq_group_qtabwidget(self, widget_type='QStackedWidget'):
accel_wgt_dict = {}
@@ -132,7 +123,7 @@ class AppGui(QWidget):
accel_wgt_dict[accel] = self.daq_group(accel)
accel_tab_widget.addWidget(accel_wgt_dict[accel])
accel_tab_widget.setFixedWidth(380)
accel_tab_widget.setFixedWidth(320)
# accel_tab_widget.setFixedHeight(160)
return accel_tab_widget
@@ -170,10 +161,39 @@ class AppGui(QWidget):
vbox.setContentsMargins(9, 19, 9, 9)
vbox.setSpacing(5)
vbox.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
vbox.setAlignment((Qt.AlignTop | Qt.AlignHCenter))
group_box.setFixedWidth(260)
group_box.setFixedHeight(240)
group_box.setFont(self.font_gui)
group_box.setAlignment(int(Qt.AlignTop | Qt.AlignLeft))
group_box.setLayout(vbox)
qw = QWidget()
grid = QGridLayout()
grid.setSpacing(0)
grid.addWidget(group_box, 0, 0)
qw.setLayout(grid)
return qw
def accelerator_low_level_group(self, accel):
group_box = QGroupBox(f'{accel} IOC')
obj_name = 'CYCLOTRON' if self.parent.ring_cyclotron in accel else \
'INJECTOR'
group_box.setObjectName(obj_name)
vbox = QGridLayout()
if self.parent.ring_cyclotron in accel:
vbox.addWidget(self.low_level_ring_display(), 0, 0)
else:
vbox.addWidget(self.low_level_inj2_display(), 0, 0)
vbox.setContentsMargins(9, 19, 9, 9)
vbox.setSpacing(5)
vbox.setAlignment((Qt.AlignTop | Qt.AlignHCenter))
group_box.setFixedWidth(260)
group_box.setFixedHeight(100)
group_box.setFont(self.font_gui)
group_box.setAlignment(int(Qt.AlignTop | Qt.AlignHCenter))
group_box.setLayout(vbox)
@@ -181,9 +201,18 @@ class AppGui(QWidget):
grid = QGridLayout()
grid.addWidget(group_box, 0, 0)
qw.setLayout(grid)
return qw
def low_level_display_group_qtabwidget(self):
accel_tab_widget = QStackedWidget()
accel_wgt_dict = {}
for accel in (self.accelerator_list):
accel_wgt_dict[accel] = self.accelerator_low_level_group(accel)
accel_tab_widget.addWidget(accel_wgt_dict[accel])
accel_tab_widget.setFixedWidth(320)
accel_tab_widget.setFixedHeight(180)
return accel_tab_widget
def accelerator_current_group_qtabwidget(
self, widget_type='QStackedWidget'):
accel_wgt_dict = {}
@@ -238,7 +267,7 @@ class AppGui(QWidget):
vbox.setContentsMargins(9, 19, 9, 9)
vbox.setSpacing(5)
vbox.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
vbox.setAlignment((Qt.AlignTop | Qt.AlignHCenter))
group_box.setFixedWidth(260)
group_box.setFixedHeight(100)
group_box.setFont(self.font_gui)
@@ -252,18 +281,34 @@ class AppGui(QWidget):
return qw
def low_level_display(self):
def low_level_ring_display(self):
#command = "caqtdm -macro 'DEVICE=ZWSGA-CECL-TCRING' Z_DI_TURN_COUNT.ui"
def low_level_macro():
def low_level_ring_macro():
subprocess.run(['caqtdm', '-macro', 'DEVICE=ZWSGA-CECL-TCRING',
'Z_DI_TURN_COUNT.ui'])
qpb = QPushButton(' Low-level Display ')
qpb.setObjectName('related')
qpb.setToolTip('Execute caqtdm Turn Counter Display')
qpb.clicked.connect(lambda: low_level_macro())
qpb.setToolTip('Execute caqtdm Turn Counter Display for Cyclotron')
qpb.clicked.connect(lambda: low_level_ring_macro())
qpb.setFixedHeight(40)
qpb.setFixedWidth(180)
return qpb
def low_level_inj2_display(self):
#command = "caqtdm -macro 'DEVICE=ZWSGA-CECL-TCRING' Z_DI_TURN_COUNT.ui"
def low_level_inj2_macro():
subprocess.run(['caqtdm', '-macro', 'DEVICE=ZWIHA-CECL-TCINJ2',
'Z_DI_TURN_COUNT.ui'])
qpb = QPushButton(' Low-level Display ')
qpb.setObjectName('related')
qpb.setToolTip('Execute caqtdm Turn Counter Display for Injector 2')
qpb.clicked.connect(lambda: low_level_inj2_macro())
qpb.setFixedHeight(40)
qpb.setFixedWidth(180)
return qpb

51
tina.json
View File

@@ -14,17 +14,17 @@
"addDateToDir" : 0
},
"header" : ["SHIFT", "INJ2", "IP2", "IW2", "PK1", "PK2", "SINQ", "UCN"],
"PV" : {"Injector": {"nturns": "ZWSGA-CECL-TCINJ:TURN-COUNT",
"daqTrigger": "ZWSGA-CECL-TCINJ:TRG-SINGLE:PROC",
"daqReady": "ZWSGA-CECL-TCINJ:SCOPE-ACQ-CNT",
"daqErrorCount": "ZWSGA-CECL-TCINJ:ERR-CNT",
"samplingFreq": "ZWSGA-CECL-TCINJ:SCOPE-SMP-FREQ",
"samplingNum": "ZWSGA-CECL-TCINJ:SCOPE-SMP-NUM",
"daqWindow": "ZWSGA-CECL-TCINJ:SCOPE-ACQ-WINDOW",
"wfEntry": "ZWSGA-CECL-TCINJ:SCOPE-CH0",
"wfExit": "ZWSGA-CECL-TCINJ:SCOPE-CH1",
"IEntry": "ENTRY:IST:1",
"IExit": "EXIT:IST:1"
"PV" : {"Injector": {"nturns": "ZWIHA-CECL-TCINJ2:TURN-COUNT",
"daqTrigger": "ZWIHA-CECL-TCINJ2:TRG-SINGLE.PROC",
"daqReady": "ZWIHA-CECL-TCINJ2:SCOPE-ACQ-CNT",
"daqErrorCount": "ZWIHA-CECL-TCINJ2:ERR-CNT",
"samplingFreq": "ZWIHA-CECL-TCINJ2:SCOPE-SMP-FREQ",
"samplingNum": "ZWIHA-CECL-TCINJ2:SCOPE-SMP-NUM",
"daqWindow": "ZWIHA-CECL-TCINJ2:SCOPE-ACQ-WINDOW",
"wfEntry": "ZWIHA-CECL-TCINJ2:SCOPE-CH0",
"wfExit": "ZWIHA-CECL-TCINJ2:SCOPE-CH1",
"IEntry": "MWC2:IST:2",
"IExit": "MXC1:IST:2"
},
"Cyclotron": {"nturns": "ZWSGA-CECL-TCRING:TURN-COUNT",
"daqTrigger": "ZWSGA-CECL-TCRING:TRG-SINGLE.PROC",
@@ -39,12 +39,12 @@
"IExit": "MHC1:IST:2"
}
},
"Init": {"Injector": {"ZWSGA-CECL-TCINJ:TRG-SINGLE.PROC": 1,
"ZWSGA-CECL-TCINJ:TRG-SOURCE": "Auto",
"ZWSGA-CECL-TCINJ:SCOPE-PRE-TRIGGER": 0,
"ZWSGA-CECL-TCINJ:TRG-AUTO-PERIOD": 4000,
"ZWSGA-CECL-TCINJ:TRG-SW-INHIBIT-ENA": 1,
"ZWSGA-CECL-TCINJ:ADC-CH-OFFSET": 4
"Init": {"Injector": {"ZWIHA-CECL-TCINJ2:TRG-SINGLE.PROC": 1,
"ZWIHA-CECL-TCINJ2:TRG-SOURCE": "Auto",
"ZWIHA-CECL-TCINJ2:SCOPE-PRE-TRIGGER": 0,
"ZWIHA-CECL-TCINJ2:TRG-AUTO-PERIOD": 4000,
"ZWIHA-CECL-TCINJ2:TRG-SW-INHIBIT-ENA": 1,
"ZWIHA-CECL-TCINJ2:ADC-CH-OFFSET": 4
},
"Cyclotron": {"ZWSGA-CECL-TCRING:TRG-SINGLE.PROC": 1,
"ZWSGA-CECL-TCRING:TRG-SOURCE": 0,
@@ -59,11 +59,8 @@
"QTabAccelerator":{
"Injector": {
"harmonic" : {"data":{ "widget": "QLineRead", "text" :"Harmonic No: ", "value": 10}},
"deltaTcable" : {"data":{ "widget": "QLineRead", "text" : "dT Cable (ns):", "value": 6.9 }},
"deltaNpickup" : {"data":{ "widget": "QLineEdit", "text" : "dN Pickup:", "value": 4 }},
"freqmod" : {"data":{ "widget": "QLineRead", "text" :"Mod. Freq (GHz):", "value" : 500}},
"dutycycle" : {"data":{ "widget": "QLineRead", "text" :"Duty Cycle (%):", "value" : 1}}
"deltaTcable" : {"data":{ "widget": "QLineEdit", "text" : "dT Cable (ns):", "value": 0 }},
"deltaNpickup" : {"data":{ "widget": "QLineEdit", "text" : "dN Pickup:", "value": 0 }}
},
"Cyclotron": {
"harmonic" : {"data":{ "widget": "QLineRead", "text" :"Harmonic No: ", "value" : 6}},
@@ -74,15 +71,17 @@
},
"QTabSignalPeakSearch":{
" Injector ": {
"peakHeight": {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min peak height:", "value" : 50 }},
"peakDistance": {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min peak distance: ", "value" : 10 }},
"correlationPeakDifference": {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min dcorr(peak1-peak2):", "value" : 0.01}},
"peakHeight": {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min peak height (entry):", "value" : -600 }},
"peakHeightExit": {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min peak height (exit):", "value" : 320 }},
"peakDistance": {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min peak distance: ", "value" : 20 }},
"correlationPeakDifference": {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min dcorr(peak1-peak2):", "value" : 0.005}},
"minimumCurrent": {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Inj2 I_min (mA):", "value" : "0.100"}},
"reverseInput": {"flag": 1, "data":{ "widget": "QCheckBox", "text" :"Reverse Input Polarity: ", "value" : 1, "orientation":"RightToLeft"}},
"reverseOutput": {"flag": 1, "data":{ "widget": "QCheckBox", "text" :"Reverse Output Polarity: ", "value" : 1, "orientation":"RightToLeft"}}
},
" Cyclotron ": {
"peakHeight": {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min peak height:", "value" : 100 }},
"peakHeight": {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min peak height (entry):", "value" : 50 }},
"peakHeightExit": {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min peak height (entry):", "value" : 50 }},
"peakDistance": {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min peak distance: ", "value" : 10 }},
"correlationPeakDifference": {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min dcorr(peak1-peak2):", "value" : 0.01 }},
"minimumCurrent": {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Inj2 I_min (mA):", "value" : "1.0"}},

4
tina.py
View File

@@ -202,13 +202,15 @@ class StartMain(BaseWindow):
accelerator = self.input_parameters['accelerator']
'''
if self.injector_2 in accelerator:
mess = ('Measurement procedure for Injector 2 \n' +
'has not yet been implementented.')
'has not yet been implemented.')
QMessageBox.information(self, 'Injector 2', mess, QMessageBox.Ok)
QApplication.processEvents()
return False
'''
if self.input_parameters['simulation']:
return True

12
tina.sh
View File

@@ -1,5 +1,5 @@
#!/bin/bash
cd /hipa/bd/applications/tina/1.4.0
cd /hipa/bd/applications/tina/1.5.0
# For use if script is sourced rather than executed
appNameDefault="tina.sh"
@@ -19,12 +19,12 @@ else
fi
_EPICS_HOST_ARCH=${RHREL}-x86_64
_EPICS_BASE=base-7.0.8
_EPICS_BASE=base-7.0.9
# Select Python Version here. Currently one of 3.5, 3.7, 3.8 and 3.10
PYTHON_VERSION=3.10
#cafe-1.20.0-gcc-7.5.0
PYTHON_PATH=.:/opt/gfa/cafe/python/pycafe/cafe-1.21.0/lib/${_EPICS_HOST_ARCH}:/hipa/bd/applications/deps/apps4ops/v1.13.0
PYTHON_PATH=.:/opt/gfa/cafe/python/pycafe/cafe-1.22.0/lib/${_EPICS_HOST_ARCH}:/hipa/bd/applications/deps/apps4ops/v1.15.0
if [ "$1" ]; then
@@ -33,21 +33,21 @@ if [ "$1" ]; then
elif [ "$1" == "3.7" -o "$1" == "37" ]; then
PYTHON_VERSION=3.7
#cafe-1.20.0-gcc-7.3.0
PYTHON_PATH=.:/opt/gfa/cafe/python/pycafe/cafe-1.21.0/lib/${_EPICS_HOST_ARCH}:/hipa/bd/applications/deps/apps4ops/v1.12.0
PYTHON_PATH=.:/opt/gfa/cafe/python/pycafe/cafe-1.21.0/lib/${_EPICS_HOST_ARCH}:/hipa/bd/applications/deps/apps4ops/v1.13.0
#module unload gcc
#module load gcc/10.4.0
export LD_PRELOAD=/usr/local/epics/${_EPICS_BASE}/lib/${_EPICS_HOST_ARCH}/libca.so:/usr/local/epics/${_EPICS_BASE}/lib/${_EPICS_HOST_ARCH}/libCom.so
elif [ "$1" == "3.8" -o "$1" == "38" ]; then
PYTHON_VERSION=3.8
#cafe-1.19.3
PYTHON_PATH=.:/opt/gfa/cafe/python/pycafe/cafe-1.21.0/lib/${_EPICS_HOST_ARCH}:/hipa/bd/applications/deps/apps4ops/v1.12.0
PYTHON_PATH=.:/opt/gfa/cafe/python/pycafe/cafe-1.21.0/lib/${_EPICS_HOST_ARCH}:/hipa/bd/applications/deps/apps4ops/v1.13.0
#module unload gcc
#module load gcc/7.5.0
elif [ "$1" == "3.10" -o "$1" == "310" ]; then
PYTHON_VERSION=3.10
#cafe-1.20.0-gcc-7.5.0
PYTHON_PATH=.:/opt/gfa/cafe/python/pycafe/cafe-1.21.0/lib/${_EPICS_HOST_ARCH}:/hipa/bd/applications/deps/apps4ops/v1.12.0
PYTHON_PATH=.:/opt/gfa/cafe/python/pycafe/cafe-1.22.0/lib/${_EPICS_HOST_ARCH}:/hipa/bd/applications/deps/apps4ops/v1.13.0
#module unload gcc
#module load gcc/7.5.0
else