diff --git a/readdatafileInjector.py b/readdatafileInjector.py new file mode 100644 index 0000000..aa01f71 --- /dev/null +++ b/readdatafileInjector.py @@ -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() diff --git a/src/analysis.py b/src/analysis.py index 158dd84..77a6361 100644 --- a/src/analysis.py +++ b/src/analysis.py @@ -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}' diff --git a/src/gui.py b/src/gui.py index 00793b7..867bb0f 100644 --- a/src/gui.py +++ b/src/gui.py @@ -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 diff --git a/tina.json b/tina.json index 508801f..65227ea 100755 --- a/tina.json +++ b/tina.json @@ -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"}}, diff --git a/tina.py b/tina.py index 14e08b8..5790ef4 100644 --- a/tina.py +++ b/tina.py @@ -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 diff --git a/tina.sh b/tina.sh index 0084581..41fc9c3 100755 --- a/tina.sh +++ b/tina.sh @@ -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