added injector2

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()

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_height = 0  # 50
-        self.signal_min_peak_distance = 10
+        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.mod_freq = 500  # GHz
-        self.duty_cycle = 1  # percentage
+        ###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'])
+        try:
-        max_y1_p = np.max(y1_peaks_pre[1]['peak_heights'])
+            ##y1_peaks_avg = np.average(y1_peaks_pre[1]['peak_heights'])
-        print(f'min and max value of peak {min_y1_p},  {max_y1_p}')
+            min_y1_p = np.min(y1_peaks_pre[1]['peak_heights'])
-        y1_height = min_y1_p * 0.9  # y1_peaks_avg * 0.726667
+            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,
+        print(f"y2 Height = {height} dist = {self.signal_min_peak_distance}")
-                                         distance=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'])
+        try:
-        max_y2_p = np.max(y2_peaks_pre[1]['peak_heights'])
+            min_y2_p = np.min(y2_peaks_pre[1]['peak_heights'])
-        print(f'min and max value of peak {min_y2_p},  {max_y2_p}')
+            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("length y1", len(self.y1_sample), type(self.y1_sample), flush=True)
-        print(len(self.y2_sample), type(self.y2_sample), flush=True)
+        print("length y2", len(self.y2_sample), type(self.y2_sample), flush=True)
-        print(len(self.t_sample), type(self.t_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}'

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.gui_frame.expert_wgt.layout().addWidget(
-            self.low_level_display(), 2, 0, 1, 1)
+        #    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
+        self.low_level_wgt.setCurrentIndex(idx)
-        #print(_sender, flush=True)
         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.setToolTip('Execute caqtdm Turn Counter Display for Cyclotron')
-        qpb.clicked.connect(lambda: low_level_macro())
+        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

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",
+    "PV" : {"Injector": {"nturns": "ZWIHA-CECL-TCINJ2:TURN-COUNT",
-			 "daqTrigger": "ZWSGA-CECL-TCINJ:TRG-SINGLE:PROC",
+			 "daqTrigger": "ZWIHA-CECL-TCINJ2:TRG-SINGLE.PROC",
-			 "daqReady": "ZWSGA-CECL-TCINJ:SCOPE-ACQ-CNT",
+			 "daqReady": "ZWIHA-CECL-TCINJ2:SCOPE-ACQ-CNT",
-			 "daqErrorCount": "ZWSGA-CECL-TCINJ:ERR-CNT",
+			 "daqErrorCount": "ZWIHA-CECL-TCINJ2:ERR-CNT",
-			 "samplingFreq": "ZWSGA-CECL-TCINJ:SCOPE-SMP-FREQ",
+			 "samplingFreq": "ZWIHA-CECL-TCINJ2:SCOPE-SMP-FREQ",
-			 "samplingNum": "ZWSGA-CECL-TCINJ:SCOPE-SMP-NUM",
+			 "samplingNum": "ZWIHA-CECL-TCINJ2:SCOPE-SMP-NUM",
-			 "daqWindow": "ZWSGA-CECL-TCINJ:SCOPE-ACQ-WINDOW",
+			 "daqWindow": "ZWIHA-CECL-TCINJ2:SCOPE-ACQ-WINDOW",
-			 "wfEntry": "ZWSGA-CECL-TCINJ:SCOPE-CH0",
+			 "wfEntry": "ZWIHA-CECL-TCINJ2:SCOPE-CH0",
-			 "wfExit": "ZWSGA-CECL-TCINJ:SCOPE-CH1",
+			 "wfExit": "ZWIHA-CECL-TCINJ2:SCOPE-CH1",
-			 "IEntry": "ENTRY:IST:1",
+			 "IEntry": "MWC2:IST:2",
-                         "IExit": "EXIT:IST:1" 
+                         "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,
+    "Init": {"Injector": {"ZWIHA-CECL-TCINJ2:TRG-SINGLE.PROC": 1,
-			  "ZWSGA-CECL-TCINJ:TRG-SOURCE": "Auto",
+			  "ZWIHA-CECL-TCINJ2:TRG-SOURCE": "Auto",
-			  "ZWSGA-CECL-TCINJ:SCOPE-PRE-TRIGGER": 0,
+			  "ZWIHA-CECL-TCINJ2:SCOPE-PRE-TRIGGER": 0,
-			  "ZWSGA-CECL-TCINJ:TRG-AUTO-PERIOD": 4000,
+			  "ZWIHA-CECL-TCINJ2:TRG-AUTO-PERIOD": 4000,
-			  "ZWSGA-CECL-TCINJ:TRG-SW-INHIBIT-ENA": 1,
+			  "ZWIHA-CECL-TCINJ2:TRG-SW-INHIBIT-ENA": 1,
-			  "ZWSGA-CECL-TCINJ:ADC-CH-OFFSET": 4
+			  "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 }},
+	    "deltaTcable" : {"data":{ "widget": "QLineEdit",  "text" : "dT Cable (ns):", "value": 0 }},
-	    "deltaNpickup" : {"data":{ "widget": "QLineEdit",  "text" : "dN Pickup:", "value": 4 }},
+	    "deltaNpickup" : {"data":{ "widget": "QLineEdit",  "text" : "dN Pickup:", "value": 0 }}	   	   
-	    "freqmod" : {"data":{ "widget": "QLineRead", "text" :"Mod. Freq (GHz):", "value" : 500}},
-	    "dutycycle" : {"data":{ "widget": "QLineRead", "text" :"Duty Cycle (%):", "value" : 1}}
-	   
 	},
         "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 }},
+	    "peakHeight":  {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min peak height (entry):", "value" : -600 }},
-	    "peakDistance":  {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min peak distance: ", "value" : 10 }},
+	    "peakHeightExit":  {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min peak height (exit):", "value" : 320 }},
-	    "correlationPeakDifference":  {"flag": 1, "data":{ "widget": "QLineEdit", "text" :"Min dcorr(peak1-peak2):", "value" : 0.01}},
+	    "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"}},

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

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