KCG/base/backend/dataset.py

@@ -133,13 +133,6 @@ class DataSet(object):
         
         return pdata[:,adc-1]
 
-    def follow(self, adc=1, frm=0, to=-1, bunch=0, **kwargs):
-        """Follow one bunch through time"""
-        # pdata = self.array[frm:to, :-1]
-        pdata = self.array[bunch::BUNCHES_PER_TURN, adc-1]
-        pdata = pdata[frm:to]
-        return pdata
-
     def combined(self, frm=0, to=-1, show_reconstructed=True):
         array = self.array[frm:to, :]
 
@@ -182,3 +175,4 @@ class DataSet(object):
             # axis.plot(xs, ys, '.', alpha=0.3)
             ret.append(np.array([xs, ys]))
         return ret
+

KCG/base/backend/io.py

@@ -42,7 +42,7 @@ def decode_data(data):
         data = data[np.where(data != 0xDEADDEAD)]  # This is the new filling
 
         # Make sure we read multiple of fours
-        data = data[:int(4 * (math.floor(data.size / 4)))]
+        data = data[:4 * int((math.floor(data.size / 4)))]
 
         bunch_low = data & 0xfff
         bunch_high = np.right_shift(data, 12) & 0xfff
@@ -57,7 +57,7 @@ def decode_data(data):
         result[0::2, 4] = bunch_number[::4]
         result[1::2, 4] = bunch_number[::4] + 1
 
-        result = result[:int(BUNCHES_PER_TURN * (math.floor(result.shape[0] / BUNCHES_PER_TURN))), :]
+        result = result[:BUNCHES_PER_TURN * int((math.floor(result.shape[0] / BUNCHES_PER_TURN))), :]
         return result
 
 def data_has_header(data):

KCG/base/backendinterface.py

@@ -964,7 +964,7 @@ def bk_get_temperature(board_id):
 backup_get_temp = bk_get_temperature
 
 
-def bk_time_scan(board_id, c_frm, c_to, f_frm, f_to, ts_pbar, plot_func, turns_observe=None, turns_skip=None, bucket_to_use=None, threshold_counts=None):
+def bk_time_scan(board_id, c_frm, c_to, f_frm, f_to, ts_pbar, plot_func, turns_observe=None, turns_skip=None):
     """
     Toggle Timescan.
     :param board_id: id of the board do manipulate
@@ -981,7 +981,7 @@ def bk_time_scan(board_id, c_frm, c_to, f_frm, f_to, ts_pbar, plot_func, turns_o
     if board.get_board_status(board_id).time_scan:
         _bif_stop_time_scan(board_id, ts_pbar)
     else:
-        _bif_start_time_scan(board_id, c_frm, c_to, f_frm, f_to, ts_pbar, plot_func, turns_observe, turns_skip, bucket_to_use, threshold_counts)
+        _bif_start_time_scan(board_id, c_frm, c_to, f_frm, f_to, ts_pbar, plot_func, turns_observe, turns_skip)
 
 
 def _bif_stop_time_scan(board_id, ts_pbar):
@@ -1010,7 +1010,7 @@ def _bif_stop_time_scan(board_id, ts_pbar):
 # thread_ts = None
 
 
-def _bif_start_time_scan(board_id, c_frm, c_to, f_frm, f_to, timescan_progressbar, plot_func, turns_observe, turns_skip, bucket_to_use=None, threshold_counts=None):
+def _bif_start_time_scan(board_id, c_frm, c_to, f_frm, f_to, timescan_progressbar, plot_func, turns_observe, turns_skip):
     """
     Start the timscan. This starts the timer
     :param board_id: id of the board do manipulate
@@ -1022,8 +1022,6 @@ def _bif_start_time_scan(board_id, c_frm, c_to, f_frm, f_to, timescan_progressba
     :param plot_func: Function to use to plot the data
     :param turns_observe: Number of turns to observe for the timescan (original values will be restored after timescan)
     :param turns_skip: Number of turns to skip for the timescan (original values will be restored after timescan)
-    :param bucket_to_use: Number of the bucket whos data will be used to calculate the average signal at each timescan step (if None all bunches will be used)
-    :param threshold_counts: Skip buckets with adc counts between 2048 +- threshold_counts
     :return: -
     """
     thread = storage.get_board_specific_storage(board_id).setdefault("TimeScanThread", storage.ThreadStorage())
@@ -1068,15 +1066,14 @@ def _bif_start_time_scan(board_id, c_frm, c_to, f_frm, f_to, timescan_progressba
         stopSignal = QtCore.pyqtSignal()
         finished = QtCore.pyqtSignal()
 
-        def __init__(self, c_frm, c_to, f_frm, f_to, timescan_progressbar, bucket_to_use, threshold_counts):
+        def __init__(self, c_frm, c_to, f_frm, f_to, timescan_progressbar):
             super(thread_time_scan, self).__init__()
             self.c_frm = c_frm
             self.c_to = c_to
             self.f_frm = f_frm
             self.f_to = f_to
             self.timescan_progressbar = timescan_progressbar
-            self.bucket_to_use = bucket_to_use
-            
+
         def time_scan(self):
             '''Method to run in the thread that does the timescan'''
             Elements.setEnabled('acquire_{}'.format(board_id), False, exclude=Elements.getElements('start_time_scan_{}'.format(board_id)))
@@ -1142,10 +1139,7 @@ def _bif_start_time_scan(board_id, c_frm, c_to, f_frm, f_to, timescan_progressba
                         return
 
                     for adc in range(4):
-                        if self.bucket_to_use is None:
-                            buckets = data.array[:, adc]
-                        else:
-                            buckets = data.array[self.bucket_to_use::config.bunches_per_turn, adc]
+                        buckets = data.array[:, adc:adc + 1].reshape(-1)
                         heatmap[adc, f_step, c_step] = float(buckets.sum()) / buckets.shape[0]
                         #Uncomment this to change back to the old (non functional) method of maxima determination
                         """
@@ -1233,7 +1227,7 @@ def _bif_start_time_scan(board_id, c_frm, c_to, f_frm, f_to, timescan_progressba
 
         return
 
-    tst = thread_time_scan(c_frm, c_to, f_frm, f_to, timescan_progressbar, bucket_to_use, threshold_counts)
+    tst = thread_time_scan(c_frm, c_to, f_frm, f_to, timescan_progressbar)
     thread.register(tst)
     thread.connect('pbarSignal', timescan_progressbar.setValue)
     thread.connect('finished', lambda: finished(timescan_progressbar))

KCG/base/kcg.py

@@ -108,8 +108,6 @@ def readconfig(parent):
         config.save_location = os.getcwd()
     else:
         config.save_location = config.default_save_location
-    
-    storage.storage.offset_correction = config.fifty_ohm_timescan_datafile
 
 
 _MultiView_Name_ = "MultiView"
@@ -476,8 +474,7 @@ class Gui(QtGui.QMainWindow):
                 QtGui.QMessageBox.information(self, "Change Language", "Language change takes effect after Gui restart", 1)
             if setting == 'advanced_control':
                 self.showAdvancedControl(getattr(self.storage, setting))
-#       if setting == 'offset_correction':
-#       config.fifty_ohm_timescan_datafile = getattr(self.storage, setting)
+
             for bid in available_boards.board_ids:
                 try:
                     if bif.bk_get_config(bid, setting) != None:

KCG/base/leftbar.py

@@ -319,7 +319,7 @@ class LeftBar(kcgw.KCGWidgets):
     # uid = unique_id
     # usid = unique_sub_id
     # upid = unique_parent_id
-    possiblePlots = ["Heatmap", "FFT", "Trains", "Combined", "Compare", "Follow"]
+    possiblePlots = ["Heatmap", "FFT", "Trains", "Combined", "Compare"]
 
     def __init__(self, parent):
         super(LeftBar, self).__init__("LeftBar")

KCG/base/plotWidget.py

@@ -36,7 +36,7 @@ class Enum():
             setattr(self, i, self.idx)
             self.idx += 1
 
-plotList = [tr("Label", "Heatmap"), tr("Label", "FFT"), tr("Label", "Trains"), tr("Label", "Combined"), tr("Label", "Compare"), tr("Label", "Follow")]
+plotList = [tr("Label", "Heatmap"), tr("Label", "FFT"), tr("Label", "Trains"), tr("Label", "Combined"), tr("Label", "Compare")]
 PlotType = Enum(*[str(i) for i in plotList])
 
 # gradient = {'mode': 'rgb',
@@ -479,7 +479,7 @@ class SubPlotWidget(pg.GraphicsLayoutWidget):
             self._disableCustomAutoRange()
             self.plotItem.setClipToView(True)
 
-        if self.plotType == PlotType.Trains or self.plotType == PlotType.Follow:
+        if self.plotType == PlotType.Trains:
             self.img.clear()
             self.plotItemPlot[0].show()
             self.gradient_legend.hide()
@@ -550,7 +550,7 @@ class SubPlotWidget(pg.GraphicsLayoutWidget):
         elif self.plotType == PlotType.FFT:
             self.plotItem.setLabel('left', 'Bunch Position', '')
             self.plotItem.setLabel('bottom', 'Frequency', 'Hz')
-        elif self.plotType == PlotType.Trains or self.plotType == PlotType.Follow:
+        elif self.plotType == PlotType.Trains:
             self.plotItem.setLabel('left', '', '')
             self.plotItem.setLabel('bottom', 'Sample Point', '')
         elif self.plotType == PlotType.Combined:
@@ -659,10 +659,9 @@ class PlotWidget(kcgw.KCGWidgets):
         self.trains_button   = self.createButton(text=tr("Button", "Trains"),   connect=lambda: self.plot(type=PlotType.Trains))
         self.combined_button = self.createButton(text=tr("Button", "Combined"), connect=lambda: self.plot(type=PlotType.Combined))
         self.compare_button  = self.createButton(text=tr("Button", "Compare"),  connect=lambda: self.plot(type=PlotType.Compare))
-        self.follow_button   = self.createButton(text=tr("Button", "Follow"),   connect=lambda: self.plot(type=PlotType.Follow))
         self.type_buttons    = {PlotType.Heatmap:self.heatmap_button, PlotType.FFT:self.fft_button,
                                 PlotType.Trains:self.trains_button,   PlotType.Combined:self.combined_button,
-                                PlotType.Compare:self.compare_button, PlotType.Follow:self.follow_button}
+                             PlotType.Compare:self.compare_button}
         self.defaultButtonStyleSheet = self.heatmap_button.styleSheet()
 
         self.plot_buttons_layout.addWidget(self.heatmap_button)
@@ -670,7 +669,6 @@ class PlotWidget(kcgw.KCGWidgets):
         self.plot_buttons_layout.addWidget(self.trains_button)
         self.plot_buttons_layout.addWidget(self.combined_button)
         self.plot_buttons_layout.addWidget(self.compare_button)
-        self.plot_buttons_layout.addWidget(self.follow_button)
 
 
         self.adcCheckBox = []
@@ -721,16 +719,9 @@ class PlotWidget(kcgw.KCGWidgets):
         self.groupWidgetCompare.hide()
 
         self.from_to_layout = QtGui.QHBoxLayout()
-        self.bucket_part = QtGui.QWidget()
-        self.bucket_layout = QtGui.QHBoxLayout()
-        self.bucket_layout.addWidget(self.createLabel(tr("Label", "Bucket:")))
-        self.bucket_spinbox = self.createSpinbox(0, config.bunches_per_turn-1, interval=1, connect=lambda: self.plot(self.theType))
-        self.bucket_layout.addWidget(self.bucket_spinbox)
-        self.bucket_part.setLayout(self.bucket_layout)
         self.from_spinbox = self.createSpinbox(0, 100000000, interval=100, connect=lambda: self.plot(self.theType))
         self.to_spinbox = self.createSpinbox(0, 100000000, start_value=1000, interval=100, connect=lambda: self.plot(self.theType))
         self.from_to_layout.addStretch()
-        self.from_to_layout.addWidget(self.bucket_part)
         self.from_to_layout.addWidget(self.createLabel(tr("Label", "From:")))
         self.from_to_layout.addWidget(self.from_spinbox)
         self.from_to_layout.addWidget(self.createLabel(tr("Label", "To:")))
@@ -815,10 +806,6 @@ class PlotWidget(kcgw.KCGWidgets):
                 style += self.defaultButtonStyleSheet
             style += "QPushButton:focus{background-color: lightgrey!important; border-color: lightblue;}"  # Note: this does not work
             button.setStyleSheet(style)
-        if self.theType == PlotType.Follow:
-            self.bucket_part.show()
-        else:
-            self.bucket_part.hide()
         
         
         if self.theType == PlotType.Trains:
@@ -863,7 +850,7 @@ class PlotWidget(kcgw.KCGWidgets):
                     type = self._old_type
                 else:
                     type = self.theType
-            if type == PlotType.Trains or type == PlotType.Combined or type == PlotType.Follow:
+            if type == PlotType.Trains or type == PlotType.Combined:
                 self.do_plot(type, autorange=True)
             else:
                 self.do_plot(type, autorange=False)
@@ -912,7 +899,6 @@ class PlotWidget(kcgw.KCGWidgets):
 
         f = self.from_spinbox.value()
         t = self.to_spinbox.value() if self.to_spinbox.value() > f else f+1
-        b = self.bucket_spinbox.value()
         if type == PlotType.FFT:
             self.plot_widget.plot(np.abs(self.data.fft(adc=self.adc, frm=f, to=t+1, drop_first_bin=True)).transpose(),
                                   autorange=autorange,
@@ -923,8 +909,6 @@ class PlotWidget(kcgw.KCGWidgets):
             self.plot_widget.plot([self.data.heatmap(adc=self.adc, frm=f, to=t).transpose(),self.data.heatmap(adc=self.secadc, frm=f, to=t).transpose()], autorange=autorange)
         if type == PlotType.Trains:
             self.plot_widget.plot(self.data.train(adc=self.adc, frm=f, to=t), autorange=autorange)
-        if type == PlotType.Follow:
-            self.plot_widget.plot(self.data.follow(adc=self.adc, frm=f, to=t, bunch=b), autorange=autorange)
         if type == PlotType.Combined:
             self.plot_widget.plot(self.data.combined(frm=f, to=t), autorange=autorange)
 

KCG/base/settings.py

@@ -28,7 +28,6 @@ class Settings(kcgw.KCGWidgets):
         self.headerTick = self.build_new_setting(QtGui.QCheckBox(tr("Button", "Header")), 'header')
         self.subDirName = self.build_new_setting(self.createInput(self.storage_handler.subdirname, width=320), 'subdirname')
         self.dirName = self.build_new_setting(self.createInput(self.storage_handler.save_location, width=320), 'save_location')
-        
         self.language = self.build_new_setting(QtGui.QComboBox(), 'language')
         self.advanced_control = self.build_new_setting(self.createCheckbox(tr("Label", "Enable Advanced Table View")), 'advanced_control')
         for lang in self.langlist:

KCG/config.py

@@ -153,7 +153,7 @@ class Configuration(object):
         Misc_conf = ['newPlotLiveIcon', 'newPlotDataIcon', 'timingIcon', 'singleReadIcon',
                      'acquireSettingsIcon', 'startIcon', 'stopIcon', 'logIcon', 'logCommentIcon', 'guiIcon', 'style',
                      'board_detection_method', 'device_list', 'device_names',
-                     'num_dummy_boards', 'fifty_ohm_timescan_datafile']
+                     'num_dummy_boards']
 
         try:
             machine_c = ConfSection('Machine', Machine_conf, config, log_level=self._log_level)

KCG/widgets/initialconfig.py

@@ -350,7 +350,7 @@ class ConfigSetup(kcgw.KCGWidgets):
             self.logging_entries.append(self.configs[-1])
 
         self.scrollWidget.setWidget(self.wid)
-       
+
     def save(self):
         """
         Save the configuration entered in the config window to a configuration file

KCG/widgets/timingWidget.py

@@ -106,7 +106,6 @@ class timingPlotWidget(kcgw.KCGWidgets):
             self.plot()
 
    
-    
     def colour_plot(self):
         """
         Initialize Color Plot
@@ -397,13 +396,6 @@ class timingPart(kcgw.KCGWidgets):
         self.fine_scan_min_spinbox = self.createSpinbox(0, bif.bk_get_config(board_id, 'chip_delay_max'), start_value=0)
         self.fine_scan_max_spinbox = self.createSpinbox(0, bif.bk_get_config(board_id, 'chip_delay_max'), start_value=bif.bk_get_config(board_id, 'chip_delay_max'))
 
-        self.average_one_bunch_label = self.createLabel(tr("Label", "Average bunch number"))
-        self.average_all_bunches_checkbox = self.createCheckbox(tr("Button", "Average all bunches"), tr("Tooltip", "Average over signal from all bunches for timescan"),
-                                                         checked=True,connect=self.showAverageOneBunch)
-        self.average_one_bunch_spinbox = self.createSpinbox(0, BUNCHES_PER_TURN-1, start_value=0)
-        self.average_one_bunch_spinbox.setEnabled(False)
-
-        
         self.turns_observe_spinbox = self.createSpinbox(1, 10000000, start_value=100)
         self.turns_skip_spinbox = self.createSpinbox(0, 100, start_value=2)
 
@@ -430,11 +422,7 @@ class timingPart(kcgw.KCGWidgets):
         self.timeScanLayout.addWidget(self.turns_observe_spinbox, 3, 2)
         self.timeScanLayout.addWidget(self.createLabel("Turns to Skip"), 4, 1)
         self.timeScanLayout.addWidget(self.turns_skip_spinbox, 4, 2)
-        self.timeScanLayout.addWidget(self.average_all_bunches_checkbox, 5, 0)
-        self.timeScanLayout.addWidget(self.average_one_bunch_label, 5, 1)
-        self.timeScanLayout.addWidget(self.average_one_bunch_spinbox, 5, 2)
-       
-        self.timeScanLayout.addWidget(self.time_scan_button, 7, 2)
+        self.timeScanLayout.addWidget(self.time_scan_button, 5, 2)
         self.setTabOrder(self.fine_scan_max_spinbox, self.time_scan_button)
 
         #  --------[ End Time Scan Part ]-------------
@@ -643,14 +631,6 @@ class timingPart(kcgw.KCGWidgets):
         if not self.adc1CoarseInput.isEnabled():
             board.get_board_config(self.board_id).update('adc_1_delay_individual', -1) # Be careful this does no silent update
 
-    def showAverageOneBunch(self):
-        """
-        Toggle to use an individual bunch for the averaging in the time delay scan or to use all bunches
-        :return: -
-        """
-        self.average_one_bunch_spinbox.setEnabled(not self.average_all_bunches_checkbox.checkState())
-        
-
     def showTimeScan(self):
         """
         Show the time scan part of this window
@@ -695,7 +675,6 @@ class timingPart(kcgw.KCGWidgets):
             self.plotWidget.plot,
             turns_observe = self.turns_observe_spinbox.value(),
             turns_skip = self.turns_skip_spinbox.value(),
-            bucket_to_use = self.average_one_bunch_spinbox.value() if self.average_one_bunch_spinbox.isEnabled() else None
         )
 
     def setValueSilent(self, element, value):

setup.py

@@ -1,17 +1,11 @@
 #!/usr/bin/python
 from setuptools import setup, find_packages
-import time, subprocess
+
 DESCRIPTION = "KCG KAPTURE Control Gui"
-git_count = subprocess.check_output(["git", "rev-list", "--count", "HEAD"]).strip()
-version_time = time.strftime("%d%m%y")
-VERSION = "0.3.2."+git_count+"."+version_time+"-beta"
-with open("KCG/VERSION", 'w') as vfile:
-    vfile.write(VERSION)
 
 setup(
     name='KCG',
-#    version='0.3.2.197.0704-beta',
-    version=VERSION,
+    version='0.3.2.197.0704-beta',
     author='Patrick Schreiber',
     author_email='uldfk@student.kit.edu',
 #    license='GPL',