Esempio n. 1
0
    def __init__(self, *args, **kwargs):
        super().__init__(*args)
        self.switching_done = cda.InstSignal()

        self.mode_ctl = kwargs.get('mode_ctl', ModesClient())
        self.k500ctl = kwargs.get('k500ctl', K500Director())

        self.c_k500mode = cda.StrChan('cxhw:0.k500.modet', max_nelems=4)
        self.c_k500user_mode = cda.StrChan('cxout:1.ic_out.mode', max_nelems=4)
        self.c_mode_progress = cda.IChan('cxhw:0.k500.mode_progress')
        self.c_k500_mag_state = cda.StrChan('cxhw:0.k500.mag_state',
                                            max_nelems=4)

        self.k500ctl.progressing.connect(self.c_mode_progress.setValue)

        #self.k500ctl.modeCurUpdate.connect(self.update_cur_mode)
        self.k500ctl.done.connect(self.switched)

        self.req_mode = None
        self.all_mode = None

        self.modes = {
            'syn': None,
            'linac': None,
            'ring': None,
            'syn.transfer': None,
            'K500.e.ext': None,
            'K500.p.ext': None,
            'K500.com': None,
            'K500.cBEP': None,
            'K500.cVEPP3': None,
        }

        self.wait_remag = False
        self.timer = cda.Timer()
    def __init__(self):
        super(IcWatcherAutomatic, self).__init__()
        try:
            self.conn = psycopg2.connect(dbname='icdata',
                                         user='******',
                                         host='pg10-srv',
                                         password='')
            print("Connected to DB")
        except:
            print("No access to DB")

        self.wait_time = 3000
        self.RUN_STATE = 1
        self.atimer_run = False

        self.sys_info_d = {
            'logs':
            cda.StrChan('cxhw:1.ic_watcher.logs', max_nelems=1024,
                        on_update=1),
            'ofr':
            cda.StrChan('cxhw:1.ic_watcher.ofr', max_nelems=1024, on_update=1)
        }
        self.ofr_list = []

        self.devnames_dict = {'vch1000': [], 'ist': []}
        self.state_chans = []

        self.fail_chans = []
        self.rst_list = ['rst_ilks']
        self.rst_dict = {}

        self.cur = self.conn.cursor()
        # self.cur.execute("select devtype.name, chan.name from chan,devtype_chans,devtype "
        #                  "where chan.id=devtype_chans.chan_id and devtype.id=devtype_chans.devtype_id and "
        #                  "devtype.name in ('magnet') group by grouping sets((devtype.name, chan.name))")
        # for elem in self.cur.fetchall():
        #     self.state_chans.append(elem[1])
        # print('state_chans_list', self.state_chans)
        self.cur.execute(
            "select devtype.name, namesys.name || '.' || dev.name as full_name from dev,dev_devtype,devtype, namesys "
            "where dev.id=dev_devtype.dev_id and devtype.id=dev_devtype.devtype_id and namesys.id=dev.namesys_id and "
            "devtype.name in ('vch1000', 'ist') group by grouping sets((devtype.name, full_name))"
        )
        # for elem in self.cur.fetchall():
        #     self.devnames_dict[elem[0]].append(elem[1])
        self.devnames_dict['ist'].append('canhw:11.vit_sim_ist')
        print('devname_dict', self.devnames_dict)

        for elem in self.devnames_dict:
            for devname in self.devnames_dict[elem]:
                chan = cda.DChan('canhw:11' + '.' + devname.split('.')[-1] +
                                 '.' + 'is_on')
                self.fail_chans.append(chan)
                tmp_list = []
                for rst_chan in self.rst_list:
                    tmp_list.append(cda.DChan(devname + '.' + rst_chan))
                self.rst_dict.update({chan.name: tmp_list})
        for chan in self.fail_chans:
            chan.valueChanged.connect(self.auto_run)
Esempio n. 3
0
    def __init__(self, ctrl_dev, srv=True):
        super().__init__()

        # create command and result channels
        self.cmd_chan = cda.StrChan(ctrl_dev + ".cmd", max_nelems=1024, on_update=True, privete=True)
        self.res_chan = cda.StrChan(ctrl_dev + ".res", max_nelems=1024, on_update=True, privete=True)
        self.cmd_chan.valueChanged.connect(self.cmd_cb)
        self.res_chan.valueMeasured.connect(self.res_cb)
        self.srv = srv
Esempio n. 4
0
    def __init__(self):
        super().__init__()

        # create command and result channels
        self.cmd_chan = cda.StrChan(ctl_server + ".modectl.cmd",
                                    max_nelems=1024,
                                    on_update=True,
                                    privete=True)
        self.res_chan = cda.StrChan(ctl_server + ".modectl.res",
                                    max_nelems=1024,
                                    on_update=True,
                                    privete=True)
        self.cmd_chan.valueChanged.connect(self.cmd_cb)
        self.res_chan.valueMeasured.connect(self.res_cb)
Esempio n. 5
0
    def __init__(self, parent):
        super(FFTPlot, self).__init__(parent=parent)
        self.showGrid(x=True, y=True)
        # self.setLogMode(False, True)
        self.setLabel('left', "Ampl")
        self.setLabel('bottom', "Freq")
        self.setRange(xRange=[0, 0.5])
        self.x_plot = pg.PlotCurveItem()
        self.z_plot = pg.PlotCurveItem()
        self.x_lin_reg = pg.LinearRegionItem([0.345, 0.365])
        self.x_lin_reg.setBrush(QtGui.QBrush(QtGui.QColor(0, 0, 255, 50)))
        self.z_lin_reg = pg.LinearRegionItem([0.295, 0.315])
        self.z_lin_reg.setBrush(QtGui.QBrush(QtGui.QColor(255, 0, 0, 50)))
        self.addItem(self.x_lin_reg)
        self.addItem(self.z_lin_reg)
        self.addItem(self.x_plot)
        self.addItem(self.z_plot)

        self.x_bound = [0.345, 0.365]
        self.z_bound = [0.2, 0.4]

        self.chan_tunes_range = cda.StrChan('cxhw:4.bpm_preproc.tunes_range',
                                            max_nelems=1024)
        self.chan_tunes_range.valueMeasured.connect(self.bound_update)

        self.x_lin_reg.sigRegionChangeFinished.connect(self.x_bound_update)
        self.z_lin_reg.sigRegionChangeFinished.connect(self.z_bound_update)
Esempio n. 6
0
    def __init__(self):
        super(TestChan, self).__init__()
        self.win = uic.loadUi(
            '/home/vbalakin/PycharmProjects/c_orbit/uis/test_chans.ui')
        self.win.show()
        self.chan_cmd = cda.StrChan('cxhw:4.bpm_preproc.cmd',
                                    max_nelems=1024,
                                    on_update=1)

        self.win.pushButton.clicked.connect(self.send_info)
Esempio n. 7
0
    def __init__(self):
        super(QMainWindow, self).__init__()
        path = os.getcwd()
        direc = re.sub('knobs', 'uis', path)
        conf = re.sub('knobs', 'config', path)
        uic.loadUi(direc + "/handle_window.ui", self)
        self.setWindowTitle('Handles')
        self.show()

        self.marked_row: int = None
        self.last_id: int = 0
        self.edit_block: bool = False
        self.self_sender: bool = False
        self.knobs_info: dict = {}
        self.cell_col: dict = {0: 'name', 1: 'descr'}

        # table def
        self.knobs_creating = Table(self.table)
        # tree widget
        self.tree = TreeTableCom(self.knobs_creating, 0, self.tree_widget)
        # callbacks
        self.btn_up.clicked.connect(self.step_up)
        self.btn_cst_up.clicked.connect(self.cst_step_up)
        self.btn_down.clicked.connect(self.step_down)
        self.btn_cst_down.clicked.connect(self.cst_step_down)
        self.btn_copy_knob.clicked.connect(self.copy)
        self.btn_add_knob.clicked.connect(self.add)
        self.btn_del_knob.clicked.connect(self.delete)

        soft_conf = load_config_knob(conf + '/knobd_conf.txt')
        chan_conf = soft_conf['chans_conf']
        for chan in ['res', 'cmd']:
            if chan not in chan_conf:
                print(chan + ' is absent in knobd_conf')
                sys.exit(app.exec_())

        self.chan_cmd = cda.StrChan(**chan_conf['cmd'])
        self.chan_res = cda.StrChan(**chan_conf['res'])
        self.chan_res.valueMeasured.connect(self.res)

        self.load_handles()
        self.handles_table.cellPressed.connect(self.index)
        self.handles_table.cellChanged.connect(self.edit_item)
Esempio n. 8
0
    def __init__(self):
        super(RMC, self).__init__()
        direc = os.getcwd()
        direc = re.sub('rma_proc', 'uis', direc)

        uic.loadUi(direc + "/sv_window.ui", self)
        self.setWindowTitle('RM calc')
        pg.setConfigOption('background', 'w')
        pg.setConfigOption('foreground', 'k')
        self.sb_kick: list = [
            self.sb_x_1, self.sb_x_2, self.sb_x_3, self.sb_x_4, self.sb_x_5,
            self.sb_x_6, self.sb_x_7, self.sb_x_8, self.sb_x_9, self.sb_x_10,
            self.sb_x_11, self.sb_x_12, self.sb_x_13, self.sb_x_14,
            self.sb_x_15, self.sb_x_16, self.sb_y_1, self.sb_y_2, self.sb_y_3,
            self.sb_y_4, self.sb_y_5, self.sb_y_6, self.sb_y_7, self.sb_y_8,
            self.sb_y_9, self.sb_y_10, self.sb_y_11, self.sb_y_12,
            self.sb_y_13, self.sb_y_14, self.sb_y_15, self.sb_y_16
        ]
        #                     1, 2, 3, 4, 5, 7, 8, 9, 10,11,12,13,14,15,16,17
        self.kick = np.array([
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        ])

        self.rm = np.array([])
        self.rev_rm = np.array([])
        self.rm_info: dict = {}
        # sing values plot def
        self.plt = pg.PlotWidget(parent=self)
        self.plt.showGrid(x=True, y=True)
        self.plt.setLogMode(False, False)
        self.plt.setRange(yRange=[0, 0.01])
        self.plt_vals = pg.PlotDataItem()
        self.sing_reg = pg.LinearRegionItem(
            values=[0, 0.01], orientation=pg.LinearRegionItem.Horizontal)
        self.sing_val_range: tuple = (0, 10)
        self.plt.addItem(self.sing_reg)
        self.plt.addItem(self.plt_vals)
        p = QVBoxLayout()
        self.sv_plot.setLayout(p)
        p.addWidget(self.plt)
        self.show()

        self.chan_cmd = cda.StrChan('cxhw:4.bpm_preproc.cmd',
                                    max_nelems=1024,
                                    on_update=1)

        self.sing_reg.sigRegionChangeFinished.connect(self.sing_reg_upd)
        self.btn_calc_reverse.clicked.connect(self.reverse_rm)
        self.btn_load_matrix.clicked.connect(self.load_rm)
        self.btn_save_reverse.clicked.connect(self.save_rev_rm)
        self.btn_save_handle.clicked.connect(self.save_handle)
Esempio n. 9
0
    def __init__(self):
        super().__init__()
        path = os.getcwd()
        conf = re.sub('bpm_plot', 'config', path)
        direc = re.sub('bpm_plot', 'uis', path)

        self.bpms = {}
        self.cur_bpm = ''
        NUM_PER_ROW = 4
        ROW_RESERVED = 5

        self.setWindowTitle('BPM Configuration')
        self.setFixedSize(750, 780)
        grid = QGridLayout()
        i = 0
        for bpm in ['bpm01','bpm02','bpm03','bpm04','bpm05','bpm07','bpm08','bpm09','bpm10','bpm11','bpm12','bpm13',
                    'bpm14','bpm15','bpm16','bpm17']:
            chans_conf = load_bpm_cnames(conf + '/bpm_conf.txt', bpm)
            bpm_wid = uic.loadUi(direc + "/bpm_conf.ui")
            bpm_wid.bpm_name.setText(bpm.upper())
            bpm_wid.bpm_is_on.set_cname(chans_conf['is_on'])
            bpm_wid.bpm_numpts.set_cname(chans_conf['numpts'])
            bpm_wid.bpm_ptsofs.set_cname(chans_conf['ptsofs'])
            bpm_wid.bpm_delay.set_cname(chans_conf['delay'])
            colors = {0: '#0073ff', 1:'#00ff0d'}
            bpm_wid.bpm_istart = CXIntComboBox(cname=chans_conf['istart'], values={0: 'Injection', 1: 'FreeRun'},
                                                                   colors=colors)
            bpm_wid.cbox_grid.addWidget(bpm_wid.bpm_istart)

            grid.addWidget(bpm_wid, ROW_RESERVED * (i // NUM_PER_ROW), i % NUM_PER_ROW, ROW_RESERVED, 1)
            self.bpms[bpm] = bpm_wid
            i += 1
        self.ctrl_panel = uic.loadUi(direc + "/ctrl_btns.ui")
        grid.addWidget(self.ctrl_panel , ROW_RESERVED * (i // NUM_PER_ROW), i % NUM_PER_ROW, 1, NUM_PER_ROW)
        self.setLayout(grid)

        self.ctrl_panel.turns_bpm.currentTextChanged.connect(self.turn_bpm_changed)
        self.ctrl_panel.btn_inj.clicked.connect(self.inj_all)
        self.ctrl_panel.btn_free.clicked.connect(self.free_all)

        path = os.getcwd()
        soft_conf = load_config_orbit(conf + '/orbitd_conf.txt', path)
        chans_conf = soft_conf['chans_conf']
        conf = re.sub('bpm_plot', 'config', path)
        self.chan_cmd = cda.StrChan(**chans_conf['cmd'])
        self.chan_cmd.valueMeasured.connect(self.cmd)
        # self.chan_res = cda.StrChan(**chans_conf['res'])
        # self.chan_res.valueMeasured.connect(self.cmd_res)

        self.set_colors(colors)
        self.chan_cmd.setValue(json.dumps({'client': 'cnfg', 'cmd': 'status'}))
Esempio n. 10
0
    def __init__(self):
        super(TestChan, self).__init__()
        # self.win = uic.loadUi('/home/vbalakin/PycharmProjects/c_orbit/uis/test_chans.ui')
        # self.win.show()
        self.i = 0
        self.dict_chans = {}
        self.chans = {
            0: 'canhw:12.rst3.c1d1_q',
            1: 'canhw:12.rst3.c1d1_q',
            2: 'canhw:12.rst3.c1d2_q'
        }
        # self.win.pushButton.clicked.connect(self.create_chan)

        self.chan_cmd = cda.StrChan('cxhw:4.bpm_preproc.cmd',
                                    max_nelems=1024,
                                    on_update=1)
        self.chan_cmd.valueMeasured.connect(self.create_chan)
Esempio n. 11
0
    def __init__(self):
        super(PlotControl, self).__init__()
        pg.setConfigOption('background', 'w')
        pg.setConfigOption('foreground', 'k')
        path = os.getcwd()
        conf = re.sub('bpm_plot', 'config', path)
        direc = re.sub('bpm_plot', 'uis', path)
        uic.loadUi(direc + "/bpm's.ui", self)
        self.setWindowTitle('Orbit Plot')
        self.show()

        soft_conf = load_config_orbit(conf + '/orbitd_conf.txt', path)
        chans_conf = soft_conf['chans_conf']
        self.bpms = soft_conf['bpm_conf']
        self.bpm_coor = soft_conf['bpm_coor']

        for chan in [
                'act_bpm', 'cmd', 'res', 'orbit', 'control_orbit', 'modet'
        ]:
            if chan not in chans_conf:
                print(chan + ' is absent in orbitd_conf')
                sys.exit(app.exec_())

        self.orbit_plots: dict = {
            'x_orbit':
            OrbitPlot('x',
                      conf + '/x_aper.txt',
                      self.bpms,
                      self.bpm_coor,
                      parent=self),
            'z_orbit':
            OrbitPlot('z',
                      conf + '/z_aper.txt',
                      self.bpms,
                      self.bpm_coor,
                      parent=self)
        }

        # variables for under control objects init
        self.ic_mode: str
        self.cur_orbit: nparray = np.zeros(2 * len(self.bpms))
        self.cur_bpms: list = self.bpms.copy()

        # migrate to special bpm tuning window
        p = QVBoxLayout()
        self.plot_coor.setLayout(p)
        for o_type, plot in self.orbit_plots.items():
            p.addWidget(plot)

        self.btn_dict: dict = {
            'e2v4': self.btn_sel_e2v4,
            'p2v4': self.btn_sel_p2v4,
            'e2v2': self.btn_sel_e2v2,
            'p2v2': self.btn_sel_p2v2
        }
        for key, btn in self.btn_dict.items():
            btn.clicked.connect(self.load_file_)

        self.colors: dict = {
            'e2v4': 'background-color:#55ffff;',
            'p2v4': 'background-color:#ff86ff;',
            'e2v2': 'background-color:#75ff91;',
            'p2v2': 'background-color:#ff6b6b;'
        }
        self.inj_mode_matr: dict = {'p': False, 'e': False}

        # self.btn_bot_on.clicked.connect(self.bot_ctrl)
        # self.btn_bot_off.clicked.connect(self.bot_ctrl)

        # action btn ctrl
        self.btn_bckgr_discard.clicked.connect(self.bckrg_discard)
        self.btn_save.clicked.connect(self.save_file_)
        self.btn_bckgr.clicked.connect(self.bckgr)
        self.btn_step_up.clicked.connect(self.step_up)
        self.btn_step_dn.clicked.connect(self.step_down)
        self.btn_load_rrm.clicked.connect(self.load_resp_mat)
        self.btn_reknob.clicked.connect(self.knob_recalc)

        # other ordinary channels
        self.chan_mode = cda.StrChan(**chans_conf['modet'])
        self.chan_mode.valueMeasured.connect(self.mode_changed)
        self.chan_cmd = cda.StrChan(**chans_conf['cmd'])
        self.chan_res = cda.StrChan(**chans_conf['res'])
        self.chan_res.valueMeasured.connect(self.cmd_res)

        # data chans
        self.chan_orbit = cda.VChan(**chans_conf['orbit'])
        self.chan_orbit.valueMeasured.connect(self.new_orbit)
        self.chan_ctrl_orbit = cda.VChan(**chans_conf['control_orbit'])
        self.chan_ctrl_orbit.valueMeasured.connect(self.new_ctrl_orbit)
        self.chan_act_bpm = cda.StrChan(**chans_conf['act_bpm'])
        self.chan_act_bpm.valueMeasured.connect(self.new_act_bpm)
Esempio n. 12
0
    def __init__(self):
        super(KickerPlot, self).__init__()
        pg.setConfigOption('background', 'w')
        pg.setConfigOption('foreground', 'k')
        uic.loadUi("mainwindow1.ui", self)
        self.show()

        # variables for histo
        self.range_a = -5
        self.range_b = 5
        self.bins_num = 10

        # plot area
        self.e_signal_plots = {
            "pre_pos": SignalPlot(self, -0.05, 1),
            "pre_neg": SignalPlot(self, -1, 0.05),
            "kick_pos": SignalPlot(self, -0.12, 0.25),
            "kick_neg": SignalPlot(self, -0.25, 0.04)
        }
        self.e_histo_plots = {
            key: HistoPlot(self)
            for key, val in self.e_signal_plots.items()
        }
        # widgets positioning
        e_layout = QGridLayout()
        e_layout.addWidget(self.e_histo_plots["pre_pos"], 0, 0)
        e_layout.addWidget(self.e_signal_plots["pre_pos"], 0, 1)
        e_layout.addWidget(self.e_histo_plots["pre_neg"], 1, 0)
        e_layout.addWidget(self.e_signal_plots["pre_neg"], 1, 1)
        e_layout.addWidget(self.e_histo_plots["kick_pos"], 2, 0)
        e_layout.addWidget(self.e_signal_plots["kick_pos"], 2, 1)
        e_layout.addWidget(self.e_histo_plots["kick_neg"], 3, 0)
        e_layout.addWidget(self.e_signal_plots["kick_neg"], 3, 1)
        self.uni_e.setLayout(e_layout)

        self.p_signal_plots = {
            "pre_pos": SignalPlot(self, -0.05, 1),
            "pre_neg": SignalPlot(self, -1, 0.05),
            "kick_pos": SignalPlot(self, -0.12, 0.25),
            "kick_neg": SignalPlot(self, -0.25, 0.04)
        }
        self.p_histo_plots = {
            key: HistoPlot(self)
            for key, val in self.p_signal_plots.items()
        }
        p_layout = QGridLayout()
        p_layout.addWidget(self.p_histo_plots["pre_pos"], 0, 0)
        p_layout.addWidget(self.p_signal_plots["pre_pos"], 0, 1)
        p_layout.addWidget(self.p_histo_plots["pre_neg"], 1, 0)
        p_layout.addWidget(self.p_signal_plots["pre_neg"], 1, 1)
        p_layout.addWidget(self.p_histo_plots["kick_pos"], 2, 0)
        p_layout.addWidget(self.p_signal_plots["kick_pos"], 2, 1)
        p_layout.addWidget(self.p_histo_plots["kick_neg"], 3, 0)
        p_layout.addWidget(self.p_signal_plots["kick_neg"], 3, 1)
        self.uni_p.setLayout(p_layout)

        self.chan_data_t = {
            "e": [
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.prekick.e.pos.Utemp",
                               "e",
                               "pre_pos",
                               n_elems=1024),
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.prekick.e.neg.Utemp",
                               "e",
                               "pre_neg",
                               n_elems=1024),
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.kick.e.pos.Utemp",
                               "e",
                               "kick_pos",
                               n_elems=1024),
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.kick.e.neg.Utemp",
                               "e",
                               "kick_neg",
                               n_elems=1024)
            ],
            "p": [
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.prekick.p.pos.Utemp",
                               "p",
                               "pre_pos",
                               n_elems=1024),
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.prekick.p.neg.Utemp",
                               "p",
                               "pre_neg",
                               n_elems=1024),
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.kick.p.pos.Utemp",
                               "p",
                               "kick_pos",
                               n_elems=1024),
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.kick.p.neg.Utemp",
                               "p",
                               "kick_neg",
                               n_elems=1024)
            ]
        }
        self.chan_hist_t = {
            "e": [
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.prekick.e.pos.delta_t_array",
                               "h_e",
                               "pre_pos",
                               n_elems=200),
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.prekick.e.neg.delta_t_array",
                               "h_e",
                               "pre_neg",
                               n_elems=200),
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.kick.e.pos.delta_t_array",
                               "h_e",
                               "kick_pos",
                               n_elems=200),
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.kick.e.neg.delta_t_array",
                               "h_e",
                               "kick_neg",
                               n_elems=200)
            ],
            "p": [
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.prekick.p.pos.delta_t_array",
                               "h_p",
                               "pre_pos",
                               n_elems=200),
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.prekick.p.neg.delta_t_array",
                               "h_p",
                               "pre_neg",
                               n_elems=200),
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.kick.p.pos.delta_t_array",
                               "h_p",
                               "kick_pos",
                               n_elems=200),
                CXDataExchange(self.data_receiver,
                               "cxhw:2.ext.kick.p.neg.delta_t_array",
                               "h_p",
                               "kick_neg",
                               n_elems=200)
            ]
        }
        self.file_data_exchange = FileDataExchange(os.getcwd(),
                                                   self.data_receiver)

        # other chans
        self.chan_ic_mode = cda.StrChan("cxhw:0.k500.modet", max_nelems=4)
        self.cmd_chan = cda.StrChan("cxhw:2.kickADCproc.inj.cmd",
                                    on_update=1,
                                    max_nelems=1024)
        self.res_chan = cda.StrChan("cxhw:2.kickADCproc.inj.res",
                                    on_update=1,
                                    max_nelems=1024)

        self.chan_ic_mode.valueChanged.connect(self.active_tab)  # OK

        self.pushButton_save.clicked.connect(self.push_save)  # OK
        self.button_stg_dflt.clicked.connect(self.stg_dflt)  # OK
        self.spinBox_hist_range.valueChanged.connect(self.hist_tun)  # OK
        self.spinBox_bins_len.valueChanged.connect(self.hist_tun)  # OK

        # for some operations e.g. switching
        self.active_tab_ = {'p': 0, 'e': 1}
        self.ic_mode = ''
        self.save_label = {
            'p': self.label_save_time_p,
            'e': self.label_save_time_e
        }
Esempio n. 13
0
    def __init__(self):
        super(TurnsControl, self).__init__()
        pg.setConfigOption('background', 'w')
        pg.setConfigOption('foreground', 'k')
        path = os.getcwd()
        conf = re.sub('bpm_plot', 'config', path)
        direc = re.sub('bpm_plot', 'uis', path)
        uic.loadUi(direc + "/plot's.ui", self)
        self.setWindowTitle('Turns Plot')
        self.show()

        self.ic_mode = 'e'
        self.cur_bpm = 'bpm01'
        self.cur_num_pts = 1024
        self.is_single_shot = False
        self.make_turns_shot = False
        self.make_fft_shot = False
        self.make_coor_shot = False

        soft_conf = load_config_orbit(conf + '/orbitd_conf.txt', path)
        chans_conf = soft_conf['chans_conf']
        self.cur_cal = soft_conf['cur_calib']

        for chan in ['turns', 'cmd', 'coor', 'fft', 'modet']:
            if chan not in chans_conf:
                print(chan + ' is absent in orbitd_conf')
                sys.exit(app.exec_())

        # fft and turns
        self.fft_p = FFTPlot(self)
        self.coor_p = CoorPlot(self)
        p0 = QVBoxLayout()
        self.fft_plot_p.setLayout(p0)
        p0.addWidget(self.coor_p)
        p0.addWidget(self.fft_p)

        self.fft_e = FFTPlot(self)
        self.coor_e = CoorPlot(self)
        p1 = QVBoxLayout()
        self.fft_plot_e.setLayout(p1)
        p1.addWidget(self.coor_e)
        p1.addWidget(self.fft_e)

        self.cur_p = CurPlot(self)
        p2 = QVBoxLayout()
        self.turns_mes_plot_p.setLayout(p2)
        p2.addWidget(self.cur_p)

        self.cur_e = CurPlot(self)
        p3 = QVBoxLayout()
        self.turns_mes_plot_e.setLayout(p3)
        p3.addWidget(self.cur_e)

        self.chan_turns = cda.VChan(**chans_conf['turns'])
        self.chan_turns.valueMeasured.connect(self.cur_proc)
        self.chan_fft = cda.VChan(**chans_conf['fft'])
        self.chan_fft.valueMeasured.connect(self.fft_proc)
        self.chan_coor = cda.VChan(**chans_conf['coor'])
        self.chan_coor.valueMeasured.connect(self.coor_proc)
        self.chan_mode = cda.StrChan(**chans_conf['modet'])
        self.chan_mode.valueMeasured.connect(self.mode_proc)
        self.chan_cmd = cda.StrChan(**chans_conf['cmd'])
        self.chan_cmd.valueMeasured.connect(self.cmd)
        # self.chan_res = cda.StrChan(**chans_conf['res'])
        # self.chan_res.valueMeasured.connect(self.cmd_res)

        # boxes changes
        self.btn_shot.clicked.connect(self.shot)
        self.chb_single_shot.stateChanged.connect(self.shot_mode)
        self.btn_save.clicked.connect(self.save)

        self.chan_cmd.setValue(json.dumps({
            'client': 'turns',
            'cmd': 'status'
        }))
Esempio n. 14
0
    def __init__(self):
        super(InjTune, self).__init__()
        path = os.getcwd()
        direc = re.sub('knobs', 'uis', path)
        conf = re.sub('knobs', 'config', path)
        self.p_win = uic.loadUi(direc + "/inj_vs_tune.ui")
        self.setWindowTitle('InjResp')
        self.p_win.show()

        soft_conf = load_config_knob(conf + '/knobd_conf.txt')
        chan_conf = soft_conf['chans_conf']
        for chan in [
                'res', 'cmd', 'tunes', 'extractioncurrent', 'eshots', 'pshots',
                'modet', 'extracted'
        ]:
            if chan not in chan_conf:
                print(chan + ' is absent in knobd_conf')
                sys.exit(app.exec_())

        self.chan_cmd = cda.StrChan(**chan_conf['cmd'])
        self.chan_res = cda.StrChan(**chan_conf['res'])
        self.chan_res.valueMeasured.connect(self.res)
        self.chan_tunes = cda.VChan(**chan_conf['tunes'])
        self.chan_tunes.valueMeasured.connect(self.tunes_changed)
        self.chan_extracted = cda.DChan(**chan_conf['extractioncurrent'])
        self.chan_extracted.valueMeasured.connect(self.extracted_current)
        self.chan_eshots = cda.DChan(**chan_conf['eshots'])
        self.chan_eshots.valueMeasured.connect(self.shots_num)
        self.chan_pshots = cda.DChan(**chan_conf['pshots'])
        self.chan_pshots.valueMeasured.connect(self.shots_num)
        self.chan_modet = cda.StrChan(**chan_conf['modet'])
        self.chan_modet.valueMeasured.connect(self.modet)
        self.chan_modet = cda.DChan(**chan_conf['extracted'])
        self.chan_modet.valueMeasured.connect(self.extraction)

        self.p_win.handles_table.cellPressed.connect(self.index)
        self.handle_1: object = BtnHandle(self.p_win.btn_handle_1, 'Handle #1',
                                          'Handle #2')
        self.p_win.btn_handle_1.clicked.connect(
            partial(self.hand_choosed, self.handle_1))
        self.handle_2: object = BtnHandle(self.p_win.btn_handle_2, 'Handle #2',
                                          'Handle #1')
        self.p_win.btn_handle_2.clicked.connect(
            partial(self.hand_choosed, self.handle_2))
        self.p_win.btn_start.clicked.connect(self.start)

        #########################
        self.shift: function = None  # tune shift func
        self.handle: object = None
        ##########################
        self.extraction_flag: bool = False
        self.cur_flag: bool = False
        self.tunes_flag: bool = False
        self.shots_skip: dict = {'p': 10, 'e': 2}
        ##########################
        self.marked_row: int = None
        self.cross_booked: dict = {'Handle #1': None, 'Handle #2': None}
        ##########################
        self.mode: str = 'e'
        self.cur_tunes: list = [0.0, 0.0]
        self.ring_cur_arr: list = []
        self.ring_cur_data: dict = {}
        ##########################
        self.skip_counter: int = 0
        self.counter: int = 0
        self.n_amount: int = 36
        self.shots_counter: int = 1
        self.n_mesh: int = 1
        self.n_shots: int = 3
        self.cur_1_it: int = 0
        self.cur_2_it: int = 0
        ##########################
        self.load_handles()
Esempio n. 15
0
    def init_chans(self):
        self.chan_adc200_ptsofs_1 = cda.DChan("cxhw:18.adc200_kkr1.ptsofs")
        self.chan_adc200_ptsofs_2 = cda.DChan("cxhw:18.adc200_kkr2.ptsofs")
        self.chan_adc200_numpts_1 = cda.DChan("cxhw:18.adc200_kkr1.numpts")
        self.chan_adc200_numpts_2 = cda.DChan("cxhw:18.adc200_kkr2.numpts")
        self.chan_adc200_timing_1 = cda.DChan("cxhw:18.adc200_kkr1.timing")
        self.chan_adc200_timing_2 = cda.DChan("cxhw:18.adc200_kkr2.timing")
        self.chan_adc200_frq_div_1 = cda.DChan("cxhw:18.adc200_kkr1.frqdiv")
        self.chan_adc200_frq_div_2 = cda.DChan("cxhw:18.adc200_kkr2.frqdiv")
        self.chan_adc200_range_1_1 = cda.DChan("cxhw:18.adc200_kkr1.range1")
        self.chan_adc200_range_1_2 = cda.DChan("cxhw:18.adc200_kkr1.range2")
        self.chan_adc200_range_2_1 = cda.DChan("cxhw:18.adc200_kkr2.range1")
        self.chan_adc200_range_2_2 = cda.DChan("cxhw:18.adc200_kkr2.range2")

        self.chan_pp = cda.VChan("cxhw:18.adc200_kkr1.line1", max_nelems=424)
        self.chan_pn = cda.VChan("cxhw:18.adc200_kkr1.line2", max_nelems=424)
        self.chan_kp = cda.VChan("cxhw:18.adc200_kkr2.line1", max_nelems=424)
        self.chan_kn = cda.VChan("cxhw:18.adc200_kkr2.line2", max_nelems=424)

        self.chan_sel_all = cda.DChan("cxhw:18.kkr_sel_all.0")

        self.cmd_chan = cda.StrChan("cxhw:2.kickADCproc.inj.cmd",
                                    on_update=1,
                                    max_nelems=1024)
        self.res_chan = cda.StrChan("cxhw:2.kickADCproc.inj.res",
                                    on_update=1,
                                    max_nelems=1024)

        self.chan_ic_mode = cda.StrChan("cxhw:0.k500.modet", max_nelems=4)

        self.chan_Tgood_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.Tgood",
            max_nelems=1024)  # positrons "-" prekick
        self.chan_Ugood_ppn = cda.VChan("cxhw:2.inj.prekick.p.neg.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_ppn = cda.VChan("cxhw:2.inj.prekick.p.neg.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_ppn = cda.VChan("cxhw:2.inj.prekick.p.neg.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_ppn = cda.DChan("cxhw:2.inj.prekick.p.neg.delta_a")
        self.chan_delta_t_ppn = cda.DChan("cxhw:2.inj.prekick.p.neg.delta_t")
        self.chan_n_interp_ppn = cda.DChan("cxhw:2.inj.prekick.p.neg.n_interp")
        self.chan_sigma_t_ppn = cda.DChan("cxhw:2.inj.prekick.p.neg.sigma_cur")
        self.chan_delta_arr_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.delta_t_array", max_nelems=100)
        self.chan_t_peak_ppn = cda.DChan("cxhw:2.inj.prekick.p.neg.t_peak")
        self.chan_histo_range_ppn = cda.DChan(
            "cxhw:2.inj.prekick.p.neg.histo_range")
        self.chan_histo_x_all_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_x_1", max_nelems=101)
        self.chan_histo_y_1_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_y_1", max_nelems=101)
        self.chan_histo_x_2_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_x_2", max_nelems=101)
        self.chan_histo_y_2_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_y_2", max_nelems=101)
        self.chan_histo_x_3_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_x_3", max_nelems=101)
        self.chan_histo_y_3_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_y_3", max_nelems=101)
        self.chan_abs_a_good_ppn = cda.DChan(
            "cxhw:2.inj.prekick.p.neg.abs_a_good")

        self.chan_Tgood_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.Tgood",
                                        max_nelems=1024)  # positrons "-" kick
        self.chan_Ugood_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_kpn = cda.DChan("cxhw:2.inj.kick.p.neg.delta_a")
        self.chan_delta_t_kpn = cda.DChan("cxhw:2.inj.kick.p.neg.delta_t")
        self.chan_n_interp_kpn = cda.DChan("cxhw:2.inj.kick.p.neg.n_interp")
        self.chan_sigma_t_kpn = cda.DChan("cxhw:2.inj.kick.p.neg.sigma_cur")
        self.chan_delta_arr_kpn = cda.VChan(
            "cxhw:2.inj.kick.p.neg.delta_t_array", max_nelems=200)
        self.chan_t_peak_kpn = cda.DChan("cxhw:2.inj.kick.p.neg.t_peak")
        self.chan_histo_x_all_kpn = cda.VChan(
            "cxhw:2.inj.kick.p.neg.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_kpn = cda.VChan(
            "cxhw:2.inj.kick.p.neg.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.histo_x_1",
                                            max_nelems=101)
        self.chan_histo_y_1_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.histo_y_1",
                                            max_nelems=101)
        self.chan_histo_x_2_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.histo_x_2",
                                            max_nelems=101)
        self.chan_histo_y_2_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.histo_y_2",
                                            max_nelems=101)
        self.chan_histo_x_3_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.histo_x_3",
                                            max_nelems=101)
        self.chan_histo_y_3_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.histo_y_3",
                                            max_nelems=101)
        self.chan_abs_a_good_kpn = cda.DChan(
            "cxhw:2.inj.kick.p.neg.abs_a_good")

        self.chan_Tgood_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.Tgood",
            max_nelems=1024)  # positrons "+" prekick
        self.chan_Ugood_ppp = cda.VChan("cxhw:2.inj.prekick.p.pos.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_ppp = cda.VChan("cxhw:2.inj.prekick.p.pos.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_ppp = cda.VChan("cxhw:2.inj.prekick.p.pos.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_ppp = cda.DChan("cxhw:2.inj.prekick.p.pos.delta_a")
        self.chan_delta_t_ppp = cda.DChan("cxhw:2.inj.prekick.p.pos.delta_t")
        self.chan_n_interp_ppp = cda.DChan("cxhw:2.inj.prekick.p.pos.n_interp")
        self.chan_sigma_t_ppp = cda.DChan("cxhw:2.inj.prekick.p.pos.sigma_cur")
        self.chan_delta_arr_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.delta_t_array", max_nelems=200)
        self.chan_t_peak_ppp = cda.DChan("cxhw:2.inj.prekick.p.pos.t_peak")
        self.chan_histo_x_all_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_x_1", max_nelems=101)
        self.chan_histo_y_1_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_y_1", max_nelems=101)
        self.chan_histo_x_2_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_x_2", max_nelems=101)
        self.chan_histo_y_2_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_y_2", max_nelems=101)
        self.chan_histo_x_3_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_x_3", max_nelems=101)
        self.chan_histo_y_3_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_y_3", max_nelems=101)
        self.chan_abs_a_good_ppp = cda.DChan(
            "cxhw:2.inj.prekick.p.pos.abs_a_good")

        self.chan_Tgood_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.Tgood",
                                        max_nelems=1024)  # positrons "+" kick
        self.chan_Ugood_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_kpp = cda.DChan("cxhw:2.inj.kick.p.pos.delta_a")
        self.chan_delta_t_kpp = cda.DChan("cxhw:2.inj.kick.p.pos.delta_t")
        self.chan_n_interp_kpp = cda.DChan("cxhw:2.inj.kick.p.pos.n_interp")
        self.chan_sigma_t_kpp = cda.DChan("cxhw:2.inj.kick.p.pos.sigma_cur")
        self.chan_delta_arr_kpp = cda.VChan(
            "cxhw:2.inj.kick.p.pos.delta_t_array", max_nelems=200)
        self.chan_t_peak_kpp = cda.DChan("cxhw:2.inj.kick.p.pos.t_peak")
        self.chan_histo_x_all_kpp = cda.VChan(
            "cxhw:2.inj.kick.p.pos.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_kpp = cda.VChan(
            "cxhw:2.inj.kick.p.pos.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.histo_x_1",
                                            max_nelems=101)
        self.chan_histo_y_1_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.histo_y_1",
                                            max_nelems=101)
        self.chan_histo_x_2_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.histo_x_2",
                                            max_nelems=101)
        self.chan_histo_y_2_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.histo_y_2",
                                            max_nelems=101)
        self.chan_histo_x_3_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.histo_x_3",
                                            max_nelems=101)
        self.chan_histo_y_3_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.histo_y_3",
                                            max_nelems=101)
        self.chan_abs_a_good_kpp = cda.DChan(
            "cxhw:2.inj.kick.p.pos.abs_a_good")

        self.chan_Tgood_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.Tgood",
            max_nelems=1024)  # electrons "-" prekick
        self.chan_Ugood_pen = cda.VChan("cxhw:2.inj.prekick.e.neg.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_pen = cda.VChan("cxhw:2.inj.prekick.e.neg.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_pen = cda.VChan("cxhw:2.inj.prekick.e.neg.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_pen = cda.DChan("cxhw:2.inj.prekick.e.neg.delta_a")
        self.chan_delta_t_pen = cda.DChan("cxhw:2.inj.prekick.e.neg.delta_t")
        self.chan_n_interp_pen = cda.DChan("cxhw:2.inj.prekick.e.neg.n_interp")
        self.chan_sigma_t_pen = cda.DChan("cxhw:2.inj.prekick.e.neg.sigma_cur")
        self.chan_delta_arr_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.delta_t_array", max_nelems=200)
        self.chan_t_peak_pen = cda.DChan("cxhw:2.inj.prekick.e.neg.t_peak")
        self.chan_histo_x_all_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_x_1", max_nelems=101)
        self.chan_histo_y_1_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_y_1", max_nelems=101)
        self.chan_histo_x_2_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_x_2", max_nelems=101)
        self.chan_histo_y_2_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_y_2", max_nelems=101)
        self.chan_histo_x_3_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_x_3", max_nelems=101)
        self.chan_histo_y_3_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_y_3", max_nelems=101)
        self.chan_abs_a_good_pen = cda.DChan(
            "cxhw:2.inj.prekick.e.neg.abs_a_good")

        self.chan_Tgood_ken = cda.VChan("cxhw:2.inj.kick.e.neg.Tgood",
                                        max_nelems=1024)  # electrons "-" kick
        self.chan_Ugood_ken = cda.VChan("cxhw:2.inj.kick.e.neg.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_ken = cda.VChan("cxhw:2.inj.kick.e.neg.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_ken = cda.VChan("cxhw:2.inj.kick.e.neg.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_ken = cda.DChan("cxhw:2.inj.kick.e.neg.delta_a")
        self.chan_delta_t_ken = cda.DChan("cxhw:2.inj.kick.e.neg.delta_t")
        self.chan_n_interp_ken = cda.DChan("cxhw:2.inj.kick.e.neg.n_interp")
        self.chan_sigma_t_ken = cda.DChan("cxhw:2.inj.kick.e.neg.sigma_cur")
        self.chan_delta_arr_ken = cda.VChan(
            "cxhw:2.inj.kick.e.neg.delta_t_array", max_nelems=200)
        self.chan_t_peak_ken = cda.DChan("cxhw:2.inj.kick.e.neg.t_peak")
        self.chan_histo_x_all_ken = cda.VChan(
            "cxhw:2.inj.kick.e.neg.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_ken = cda.VChan(
            "cxhw:2.inj.kick.e.neg.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_ken = cda.VChan("cxhw:2.inj.kick.e.neg.histo_x_1",
                                            max_nelems=101)
        self.chan_histo_y_1_ken = cda.VChan("cxhw:2.inj.kick.e.neg.histo_y_1",
                                            max_nelems=101)
        self.chan_histo_x_2_ken = cda.VChan("cxhw:2.inj.kick.e.neg.histo_x_2",
                                            max_nelems=101)
        self.chan_histo_y_2_ken = cda.VChan("cxhw:2.inj.kick.e.neg.histo_y_2",
                                            max_nelems=101)
        self.chan_histo_x_3_ken = cda.VChan("cxhw:2.inj.kick.e.neg.histo_x_3",
                                            max_nelems=101)
        self.chan_histo_y_3_ken = cda.VChan("cxhw:2.inj.kick.e.neg.histo_y_3",
                                            max_nelems=101)
        self.chan_abs_a_good_ken = cda.DChan(
            "cxhw:2.inj.kick.e.neg.abs_a_good")

        self.chan_Tgood_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.Tgood",
            max_nelems=1024)  # electrons "+" prekick
        self.chan_Ugood_pep = cda.VChan("cxhw:2.inj.prekick.e.pos.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_pep = cda.VChan("cxhw:2.inj.prekick.e.pos.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_pep = cda.VChan("cxhw:2.inj.prekick.e.pos.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_pep = cda.DChan("cxhw:2.inj.prekick.e.pos.delta_a")
        self.chan_delta_t_pep = cda.DChan("cxhw:2.inj.prekick.e.pos.delta_t")
        self.chan_n_interp_pep = cda.DChan("cxhw:2.inj.prekick.e.pos.n_interp")
        self.chan_sigma_t_pep = cda.DChan("cxhw:2.inj.prekick.e.pos.sigma_cur")
        self.chan_delta_arr_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.delta_t_array", max_nelems=200)
        self.chan_t_peak_pep = cda.DChan("cxhw:2.inj.prekick.e.pos.t_peak")
        self.chan_histo_x_all_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_x_1", max_nelems=101)
        self.chan_histo_y_1_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_y_1", max_nelems=101)
        self.chan_histo_x_2_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_x_2", max_nelems=101)
        self.chan_histo_y_2_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_y_2", max_nelems=101)
        self.chan_histo_x_3_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_x_3", max_nelems=101)
        self.chan_histo_y_3_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_y_3", max_nelems=101)
        self.chan_abs_a_good_pep = cda.DChan(
            "cxhw:2.inj.prekick.e.pos.abs_a_good")

        self.chan_Tgood_kep = cda.VChan("cxhw:2.inj.kick.e.pos.Tgood",
                                        max_nelems=1024)  # electrons "+" kick
        self.chan_Ugood_kep = cda.VChan("cxhw:2.inj.kick.e.pos.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_kep = cda.VChan("cxhw:2.inj.kick.e.pos.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_kep = cda.VChan("cxhw:2.inj.kick.e.pos.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_kep = cda.DChan("cxhw:2.inj.kick.e.pos.delta_a")
        self.chan_delta_t_kep = cda.DChan("cxhw:2.inj.kick.e.pos.delta_t")
        self.chan_n_interp_kep = cda.DChan("cxhw:2.inj.kick.e.pos.n_interp")
        self.chan_sigma_t_kep = cda.DChan("cxhw:2.inj.kick.e.pos.sigma_cur")
        self.chan_delta_arr_kep = cda.VChan(
            "cxhw:2.inj.kick.e.pos.delta_t_array", max_nelems=200)
        self.chan_t_peak_kep = cda.DChan("cxhw:2.inj.kick.e.pos.t_peak")
        self.chan_histo_x_all_kep = cda.VChan(
            "cxhw:2.inj.kick.e.pos.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_kep = cda.VChan(
            "cxhw:2.inj.kick.e.pos.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_kep = cda.VChan("cxhw:2.inj.kick.e.pos.histo_x_1",
                                            max_nelems=101)
        self.chan_histo_y_1_kep = cda.VChan("cxhw:2.inj.kick.e.pos.histo_y_1",
                                            max_nelems=101)
        self.chan_histo_x_2_kep = cda.VChan("cxhw:2.inj.kick.e.pos.histo_x_2",
                                            max_nelems=101)
        self.chan_histo_y_2_kep = cda.VChan("cxhw:2.inj.kick.e.pos.histo_y_2",
                                            max_nelems=101)
        self.chan_histo_x_3_kep = cda.VChan("cxhw:2.inj.kick.e.pos.histo_x_3",
                                            max_nelems=101)
        self.chan_histo_y_3_kep = cda.VChan("cxhw:2.inj.kick.e.pos.histo_y_3",
                                            max_nelems=101)
        self.chan_abs_a_good_kep = cda.DChan(
            "cxhw:2.inj.kick.e.pos.abs_a_good")

        self.list_hist_ppp = [
            self.chan_histo_x_all_ppp, self.chan_histo_y_all_ppp,
            self.chan_histo_x_1_ppp, self.chan_histo_y_1_ppp,
            self.chan_histo_x_2_ppp, self.chan_histo_y_2_ppp,
            self.chan_histo_x_3_ppp, self.chan_histo_y_3_ppp
        ]
        self.list_hist_ppn = [
            self.chan_histo_x_all_ppn, self.chan_histo_y_all_ppn,
            self.chan_histo_x_1_ppn, self.chan_histo_y_1_ppn,
            self.chan_histo_x_2_ppn, self.chan_histo_y_2_ppn,
            self.chan_histo_x_3_ppn, self.chan_histo_y_3_ppn
        ]
        self.list_hist_kpp = [
            self.chan_histo_x_all_kpp, self.chan_histo_y_all_kpp,
            self.chan_histo_x_1_kpp, self.chan_histo_y_1_kpp,
            self.chan_histo_x_2_kpp, self.chan_histo_y_2_kpp,
            self.chan_histo_x_3_kpp, self.chan_histo_y_3_kpp
        ]
        self.list_hist_kpn = [
            self.chan_histo_x_all_kpn, self.chan_histo_y_all_kpn,
            self.chan_histo_x_1_kpn, self.chan_histo_y_1_kpn,
            self.chan_histo_x_2_kpn, self.chan_histo_y_2_kpn,
            self.chan_histo_x_3_kpn, self.chan_histo_y_3_kpn
        ]
        self.list_hist_pep = [
            self.chan_histo_x_all_pep, self.chan_histo_y_all_pep,
            self.chan_histo_x_1_pep, self.chan_histo_y_1_pep,
            self.chan_histo_x_2_pep, self.chan_histo_y_2_pep,
            self.chan_histo_x_3_ppp, self.chan_histo_y_3_ppp
        ]
        self.list_hist_pen = [
            self.chan_histo_x_all_pen, self.chan_histo_y_all_pen,
            self.chan_histo_x_1_pen, self.chan_histo_y_1_pen,
            self.chan_histo_x_2_pen, self.chan_histo_y_2_pen,
            self.chan_histo_x_3_pen, self.chan_histo_y_3_pen
        ]
        self.list_hist_kep = [
            self.chan_histo_x_all_kep, self.chan_histo_y_all_kep,
            self.chan_histo_x_1_kep, self.chan_histo_y_1_kep,
            self.chan_histo_x_2_kep, self.chan_histo_y_2_kep,
            self.chan_histo_x_3_kep, self.chan_histo_y_3_kep
        ]
        self.list_hist_ken = [
            self.chan_histo_x_all_ken, self.chan_histo_y_all_ken,
            self.chan_histo_x_1_ken, self.chan_histo_y_1_ken,
            self.chan_histo_x_2_ken, self.chan_histo_y_2_ken,
            self.chan_histo_x_3_ken, self.chan_histo_y_3_ken
        ]

        self.dict_hist = {
            'cxhw:18.adc200_kkr1.line1p': self.list_hist_ppp,
            'cxhw:18.adc200_kkr1.line2p': self.list_hist_ppn,
            'cxhw:18.adc200_kkr2.line1p': self.list_hist_kpp,
            'cxhw:18.adc200_kkr2.line2p': self.list_hist_kpn,
            'cxhw:18.adc200_kkr1.line1e': self.list_hist_pep,
            'cxhw:18.adc200_kkr1.line2e': self.list_hist_pen,
            'cxhw:18.adc200_kkr2.line1e': self.list_hist_kep,
            'cxhw:18.adc200_kkr2.line2e': self.list_hist_ken
        }
        self.dict_good_chans = {
            'cxhw:18.adc200_kkr1.line1p': self.chan_Ugood_ppp,
            'cxhw:18.adc200_kkr1.line2p': self.chan_Ugood_ppn,
            'cxhw:18.adc200_kkr2.line1p': self.chan_Ugood_kpp,
            'cxhw:18.adc200_kkr2.line2p': self.chan_Ugood_kpn,
            'cxhw:18.adc200_kkr1.line1e': self.chan_Ugood_pep,
            'cxhw:18.adc200_kkr1.line2e': self.chan_Ugood_pen,
            'cxhw:18.adc200_kkr2.line1e': self.chan_Ugood_kep,
            'cxhw:18.adc200_kkr2.line2e': self.chan_Ugood_ken
        }
        self.dict_temp_chans = {
            'cxhw:18.adc200_kkr1.line1p': self.chan_Utemp_ppp,
            'cxhw:18.adc200_kkr1.line2p': self.chan_Utemp_ppn,
            'cxhw:18.adc200_kkr2.line1p': self.chan_Utemp_kpp,
            'cxhw:18.adc200_kkr2.line2p': self.chan_Utemp_kpn,
            'cxhw:18.adc200_kkr1.line1e': self.chan_Utemp_pep,
            'cxhw:18.adc200_kkr1.line2e': self.chan_Utemp_pen,
            'cxhw:18.adc200_kkr2.line1e': self.chan_Utemp_kep,
            'cxhw:18.adc200_kkr2.line2e': self.chan_Utemp_ken
        }
        self.dict_delta_t = {
            'cxhw:18.adc200_kkr1.line1p': self.chan_delta_t_ppp,
            'cxhw:18.adc200_kkr1.line2p': self.chan_delta_t_ppn,
            'cxhw:18.adc200_kkr2.line1p': self.chan_delta_t_kpp,
            'cxhw:18.adc200_kkr2.line2p': self.chan_delta_t_kpn,
            'cxhw:18.adc200_kkr1.line1e': self.chan_delta_t_pep,
            'cxhw:18.adc200_kkr1.line2e': self.chan_delta_t_pen,
            'cxhw:18.adc200_kkr2.line1e': self.chan_delta_t_kep,
            'cxhw:18.adc200_kkr2.line2e': self.chan_delta_t_ken
        }
        self.dict_delta_arr = {
            'cxhw:18.adc200_kkr1.line1p': self.chan_delta_arr_ppp,
            'cxhw:18.adc200_kkr1.line2p': self.chan_delta_arr_ppn,
            'cxhw:18.adc200_kkr2.line1p': self.chan_delta_arr_kpp,
            'cxhw:18.adc200_kkr2.line2p': self.chan_delta_arr_kpn,
            'cxhw:18.adc200_kkr1.line1e': self.chan_delta_arr_pep,
            'cxhw:18.adc200_kkr1.line2e': self.chan_delta_arr_pen,
            'cxhw:18.adc200_kkr2.line1e': self.chan_delta_arr_kep,
            'cxhw:18.adc200_kkr2.line2e': self.chan_delta_arr_ken
        }
        self.dict_sigma_t = {
            'cxhw:18.adc200_kkr1.line1p': self.chan_sigma_t_ppp,
            'cxhw:18.adc200_kkr1.line2p': self.chan_sigma_t_ppn,
            'cxhw:18.adc200_kkr2.line1p': self.chan_sigma_t_kpp,
            'cxhw:18.adc200_kkr2.line2p': self.chan_sigma_t_kpn,
            'cxhw:18.adc200_kkr1.line1e': self.chan_sigma_t_pep,
            'cxhw:18.adc200_kkr1.line2e': self.chan_sigma_t_pen,
            'cxhw:18.adc200_kkr2.line1e': self.chan_sigma_t_kep,
            'cxhw:18.adc200_kkr2.line2e': self.chan_sigma_t_ken
        }
        self.dict_t_peak = {
            'cxhw:18.adc200_kkr1.line1p': self.chan_t_peak_ppp,
            'cxhw:18.adc200_kkr1.line2p': self.chan_t_peak_ppn,
            'cxhw:18.adc200_kkr2.line1p': self.chan_t_peak_kpp,
            'cxhw:18.adc200_kkr2.line2p': self.chan_t_peak_kpn,
            'cxhw:18.adc200_kkr1.line1e': self.chan_t_peak_pep,
            'cxhw:18.adc200_kkr1.line2e': self.chan_t_peak_pen,
            'cxhw:18.adc200_kkr2.line1e': self.chan_t_peak_kep,
            'cxhw:18.adc200_kkr2.line2e': self.chan_t_peak_ken
        }
Esempio n. 16
0
    def init_chans(self):
        self.chan_sel_all = cda.DChan("cxhw:18.kkr_sel_all.0")

        self.cmd_chan = cda.StrChan("cxhw:2.kickADCproc.inj.cmd@u")
        self.res_chan = cda.StrChan("cxhw:2.kickADCproc.inj.res@u")

        self.chan_ic_mode = cda.StrChan("cxhw:0.k500.modet", max_nelems=4)

        self.chan_Tgood_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.Tgood",
            max_nelems=1024)  # positrons "-" prekick
        self.chan_Ugood_ppn = cda.VChan("cxhw:2.inj.prekick.p.neg.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_ppn = cda.VChan("cxhw:2.inj.prekick.p.neg.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_ppn = cda.VChan("cxhw:2.inj.prekick.p.neg.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_ppn = cda.DChan("cxhw:2.inj.prekick.p.neg.delta_a")
        self.chan_delta_t_ppn = cda.DChan("cxhw:2.inj.prekick.p.neg.delta_t")
        self.chan_n_interp_ppn = cda.DChan("cxhw:2.inj.prekick.p.neg.n_interp")
        self.chan_sigma_t_ppn = cda.DChan("cxhw:2.inj.prekick.p.neg.sigma_cur")
        self.chan_delta_arr_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.delta_t_array", max_nelems=100)
        self.chan_t_peak_ppn = cda.DChan("cxhw:2.inj.prekick.p.neg.t_peak")
        self.chan_histo_range_ppn = cda.DChan(
            "cxhw:2.inj.prekick.p.neg.histo_range")
        self.chan_histo_x_all_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_x_1", max_nelems=101)
        self.chan_histo_y_1_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_y_1", max_nelems=101)
        self.chan_histo_x_2_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_x_2", max_nelems=101)
        self.chan_histo_y_2_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_y_2", max_nelems=101)
        self.chan_histo_x_3_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_x_3", max_nelems=101)
        self.chan_histo_y_3_ppn = cda.VChan(
            "cxhw:2.inj.prekick.p.neg.histo_y_3", max_nelems=101)

        self.chan_Tgood_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.Tgood",
                                        max_nelems=1024)  # positrons "-" kick
        self.chan_Ugood_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_kpn = cda.DChan("cxhw:2.inj.kick.p.neg.delta_a")
        self.chan_delta_t_kpn = cda.DChan("cxhw:2.inj.kick.p.neg.delta_t")
        self.chan_n_interp_kpn = cda.DChan("cxhw:2.inj.kick.p.neg.n_interp")
        self.chan_sigma_t_kpn = cda.DChan("cxhw:2.inj.kick.p.neg.sigma_cur")
        self.chan_delta_arr_kpn = cda.VChan(
            "cxhw:2.inj.kick.p.neg.delta_t_array", max_nelems=200)
        self.chan_t_peak_kpn = cda.DChan("cxhw:2.inj.kick.p.neg.t_peak")
        self.chan_histo_x_all_kpn = cda.VChan(
            "cxhw:2.inj.kick.p.neg.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_kpn = cda.VChan(
            "cxhw:2.inj.kick.p.neg.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.histo_x_1",
                                            max_nelems=101)
        self.chan_histo_y_1_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.histo_y_1",
                                            max_nelems=101)
        self.chan_histo_x_2_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.histo_x_2",
                                            max_nelems=101)
        self.chan_histo_y_2_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.histo_y_2",
                                            max_nelems=101)
        self.chan_histo_x_3_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.histo_x_3",
                                            max_nelems=101)
        self.chan_histo_y_3_kpn = cda.VChan("cxhw:2.inj.kick.p.neg.histo_y_3",
                                            max_nelems=101)

        self.chan_Tgood_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.Tgood",
            max_nelems=1024)  # positrons "+" prekick
        self.chan_Ugood_ppp = cda.VChan("cxhw:2.inj.prekick.p.pos.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_ppp = cda.VChan("cxhw:2.inj.prekick.p.pos.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_ppp = cda.VChan("cxhw:2.inj.prekick.p.pos.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_ppp = cda.DChan("cxhw:2.inj.prekick.p.pos.delta_a")
        self.chan_delta_t_ppp = cda.DChan("cxhw:2.inj.prekick.p.pos.delta_t")
        self.chan_n_interp_ppp = cda.DChan("cxhw:2.inj.prekick.p.pos.n_interp")
        self.chan_sigma_t_ppp = cda.DChan("cxhw:2.inj.prekick.p.pos.sigma_cur")
        self.chan_delta_arr_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.delta_t_array", max_nelems=200)
        self.chan_t_peak_ppp = cda.DChan("cxhw:2.inj.prekick.p.pos.t_peak")
        self.chan_histo_x_all_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_x_1", max_nelems=101)
        self.chan_histo_y_1_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_y_1", max_nelems=101)
        self.chan_histo_x_2_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_x_2", max_nelems=101)
        self.chan_histo_y_2_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_y_2", max_nelems=101)
        self.chan_histo_x_3_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_x_3", max_nelems=101)
        self.chan_histo_y_3_ppp = cda.VChan(
            "cxhw:2.inj.prekick.p.pos.histo_y_3", max_nelems=101)

        self.chan_Tgood_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.Tgood",
                                        max_nelems=1024)  # positrons "+" kick
        self.chan_Ugood_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_kpp = cda.DChan("cxhw:2.inj.kick.p.pos.delta_a")
        self.chan_delta_t_kpp = cda.DChan("cxhw:2.inj.kick.p.pos.delta_t")
        self.chan_n_interp_kpp = cda.DChan("cxhw:2.inj.kick.p.pos.n_interp")
        self.chan_sigma_t_kpp = cda.DChan("cxhw:2.inj.kick.p.pos.sigma_cur")
        self.chan_delta_arr_kpp = cda.VChan(
            "cxhw:2.inj.kick.p.pos.delta_t_array", max_nelems=200)
        self.chan_t_peak_kpp = cda.DChan("cxhw:2.inj.kick.p.pos.t_peak")
        self.chan_histo_x_all_kpp = cda.VChan(
            "cxhw:2.inj.kick.p.pos.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_kpp = cda.VChan(
            "cxhw:2.inj.kick.p.pos.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.histo_x_1",
                                            max_nelems=101)
        self.chan_histo_y_1_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.histo_y_1",
                                            max_nelems=101)
        self.chan_histo_x_2_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.histo_x_2",
                                            max_nelems=101)
        self.chan_histo_y_2_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.histo_y_2",
                                            max_nelems=101)
        self.chan_histo_x_3_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.histo_x_3",
                                            max_nelems=101)
        self.chan_histo_y_3_kpp = cda.VChan("cxhw:2.inj.kick.p.pos.histo_y_3",
                                            max_nelems=101)

        self.chan_Tgood_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.Tgood",
            max_nelems=1024)  # electrons "-" prekick
        self.chan_Ugood_pen = cda.VChan("cxhw:2.inj.prekick.e.neg.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_pen = cda.VChan("cxhw:2.inj.prekick.e.neg.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_pen = cda.VChan("cxhw:2.inj.prekick.e.neg.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_pen = cda.DChan("cxhw:2.inj.prekick.e.neg.delta_a")
        self.chan_delta_t_pen = cda.DChan("cxhw:2.inj.prekick.e.neg.delta_t")
        self.chan_n_interp_pen = cda.DChan("cxhw:2.inj.prekick.e.neg.n_interp")
        self.chan_sigma_t_pen = cda.DChan("cxhw:2.inj.prekick.e.neg.sigma_cur")
        self.chan_delta_arr_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.delta_t_array", max_nelems=200)
        self.chan_t_peak_pen = cda.DChan("cxhw:2.inj.prekick.e.neg.t_peak")
        self.chan_histo_x_all_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_x_1", max_nelems=101)
        self.chan_histo_y_1_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_y_1", max_nelems=101)
        self.chan_histo_x_2_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_x_2", max_nelems=101)
        self.chan_histo_y_2_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_y_2", max_nelems=101)
        self.chan_histo_x_3_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_x_3", max_nelems=101)
        self.chan_histo_y_3_pen = cda.VChan(
            "cxhw:2.inj.prekick.e.neg.histo_y_3", max_nelems=101)

        self.chan_Tgood_ken = cda.VChan("cxhw:2.inj.kick.e.neg.Tgood",
                                        max_nelems=1024)  # electrons "-" kick
        self.chan_Ugood_ken = cda.VChan("cxhw:2.inj.kick.e.neg.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_ken = cda.VChan("cxhw:2.inj.kick.e.neg.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_ken = cda.VChan("cxhw:2.inj.kick.e.neg.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_ken = cda.DChan("cxhw:2.inj.kick.e.neg.delta_a")
        self.chan_delta_t_ken = cda.DChan("cxhw:2.inj.kick.e.neg.delta_t")
        self.chan_n_interp_ken = cda.DChan("cxhw:2.inj.kick.e.neg.n_interp")
        self.chan_sigma_t_ken = cda.DChan("cxhw:2.inj.kick.e.neg.sigma_cur")
        self.chan_delta_arr_ken = cda.VChan(
            "cxhw:2.inj.kick.e.neg.delta_t_array", max_nelems=200)
        self.chan_t_peak_ken = cda.DChan("cxhw:2.inj.kick.e.neg.t_peak")
        self.chan_histo_x_all_ken = cda.VChan(
            "cxhw:2.inj.kick.e.neg.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_ken = cda.VChan(
            "cxhw:2.inj.kick.e.neg.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_ken = cda.VChan("cxhw:2.inj.kick.e.neg.histo_x_1",
                                            max_nelems=101)
        self.chan_histo_y_1_ken = cda.VChan("cxhw:2.inj.kick.e.neg.histo_y_1",
                                            max_nelems=101)
        self.chan_histo_x_2_ken = cda.VChan("cxhw:2.inj.kick.e.neg.histo_x_2",
                                            max_nelems=101)
        self.chan_histo_y_2_ken = cda.VChan("cxhw:2.inj.kick.e.neg.histo_y_2",
                                            max_nelems=101)
        self.chan_histo_x_3_ken = cda.VChan("cxhw:2.inj.kick.e.neg.histo_x_3",
                                            max_nelems=101)
        self.chan_histo_y_3_ken = cda.VChan("cxhw:2.inj.kick.e.neg.histo_y_3",
                                            max_nelems=101)

        self.chan_Tgood_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.Tgood",
            max_nelems=1024)  # electrons "+" prekick
        self.chan_Ugood_pep = cda.VChan("cxhw:2.inj.prekick.e.pos.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_pep = cda.VChan("cxhw:2.inj.prekick.e.pos.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_pep = cda.VChan("cxhw:2.inj.prekick.e.pos.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_pep = cda.DChan("cxhw:2.inj.prekick.e.pos.delta_a")
        self.chan_delta_t_pep = cda.DChan("cxhw:2.inj.prekick.e.pos.delta_t")
        self.chan_n_interp_pep = cda.DChan("cxhw:2.inj.prekick.e.pos.n_interp")
        self.chan_sigma_t_pep = cda.DChan("cxhw:2.inj.prekick.e.pos.sigma_cur")
        self.chan_delta_arr_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.delta_t_array", max_nelems=200)
        self.chan_t_peak_pep = cda.DChan("cxhw:2.inj.prekick.e.pos.t_peak")
        self.chan_histo_x_all_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_x_1", max_nelems=101)
        self.chan_histo_y_1_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_y_1", max_nelems=101)
        self.chan_histo_x_2_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_x_2", max_nelems=101)
        self.chan_histo_y_2_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_y_2", max_nelems=101)
        self.chan_histo_x_3_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_x_3", max_nelems=101)
        self.chan_histo_y_3_pep = cda.VChan(
            "cxhw:2.inj.prekick.e.pos.histo_y_3", max_nelems=101)

        self.chan_Tgood_kep = cda.VChan("cxhw:2.inj.kick.e.pos.Tgood",
                                        max_nelems=1024)  # electrons "+" kick
        self.chan_Ugood_kep = cda.VChan("cxhw:2.inj.kick.e.pos.Ugood",
                                        max_nelems=1024)
        self.chan_Ttemp_kep = cda.VChan("cxhw:2.inj.kick.e.pos.Ttemp",
                                        max_nelems=1024)
        self.chan_Utemp_kep = cda.VChan("cxhw:2.inj.kick.e.pos.Utemp",
                                        max_nelems=1024)
        self.chan_delta_a_kep = cda.DChan("cxhw:2.inj.kick.e.pos.delta_a")
        self.chan_delta_t_kep = cda.DChan("cxhw:2.inj.kick.e.pos.delta_t")
        self.chan_n_interp_kep = cda.DChan("cxhw:2.inj.kick.e.pos.n_interp")
        self.chan_sigma_t_kep = cda.DChan("cxhw:2.inj.kick.e.pos.sigma_cur")
        self.chan_delta_arr_kep = cda.VChan(
            "cxhw:2.inj.kick.e.pos.delta_t_array", max_nelems=200)
        self.chan_t_peak_kep = cda.DChan("cxhw:2.inj.kick.e.pos.t_peak")
        self.chan_histo_x_all_kep = cda.VChan(
            "cxhw:2.inj.kick.e.pos.histo_x_all", max_nelems=100)
        self.chan_histo_y_all_kep = cda.VChan(
            "cxhw:2.inj.kick.e.pos.histo_y_all", max_nelems=100)
        self.chan_histo_x_1_kep = cda.VChan("cxhw:2.inj.kick.e.pos.histo_x_1",
                                            max_nelems=101)
        self.chan_histo_y_1_kep = cda.VChan("cxhw:2.inj.kick.e.pos.histo_y_1",
                                            max_nelems=101)
        self.chan_histo_x_2_kep = cda.VChan("cxhw:2.inj.kick.e.pos.histo_x_2",
                                            max_nelems=101)
        self.chan_histo_y_2_kep = cda.VChan("cxhw:2.inj.kick.e.pos.histo_y_2",
                                            max_nelems=101)
        self.chan_histo_x_3_kep = cda.VChan("cxhw:2.inj.kick.e.pos.histo_x_3",
                                            max_nelems=101)
        self.chan_histo_y_3_kep = cda.VChan("cxhw:2.inj.kick.e.pos.histo_y_3",
                                            max_nelems=101)

        self.dict_count = {
            'cxhw:2.inj.prekick.p.neg.Utemp': 0,
            'cxhw:2.inj.kick.p.neg.Utemp': 0,
            'cxhw:2.inj.prekick.p.pos.Utemp': 0,
            'cxhw:2.inj.kick.p.pos.Utemp': 0,
            'cxhw:2.inj.prekick.e.neg.Utemp': 0,
            'cxhw:2.inj.kick.e.neg.Utemp': 0,
            'cxhw:2.inj.prekick.e.pos.Utemp': 0,
            'cxhw:2.inj.kick.e.pos.Utemp': 0
        }

        self.dict_delta_t = {
            'cxhw:2.inj.prekick.p.pos.Utemp': self.chan_delta_t_ppp,
            'cxhw:2.inj.prekick.p.neg.Utemp': self.chan_delta_t_ppn,
            'cxhw:2.inj.kick.p.pos.Utemp': self.chan_delta_t_kpp,
            'cxhw:2.inj.kick.p.neg.Utemp': self.chan_delta_t_kpn,
            'cxhw:2.inj.prekick.e.pos.Utemp': self.chan_delta_t_pep,
            'cxhw:2.inj.prekick.e.neg.Utemp': self.chan_delta_t_pen,
            'cxhw:2.inj.kick.e.pos.Utemp': self.chan_delta_t_kep,
            'cxhw:2.inj.kick.e.neg.Utemp': self.chan_delta_t_ken
        }

        self.dict_sigma_t = {
            'cxhw:2.inj.prekick.p.pos.Utemp': self.chan_sigma_t_ppp,
            'cxhw:2.inj.prekick.p.neg.Utemp': self.chan_sigma_t_ppn,
            'cxhw:2.inj.kick.p.pos.Utemp': self.chan_sigma_t_kpp,
            'cxhw:2.inj.kick.p.neg.Utemp': self.chan_sigma_t_kpn,
            'cxhw:2.inj.prekick.e.pos.Utemp': self.chan_sigma_t_pep,
            'cxhw:2.inj.prekick.e.neg.Utemp': self.chan_sigma_t_pen,
            'cxhw:2.inj.kick.e.pos.Utemp': self.chan_sigma_t_kep,
            'cxhw:2.inj.kick.e.neg.Utemp': self.chan_sigma_t_ken
        }

        self.dict_good_chans = {
            'cxhw:2.inj.prekick.p.pos.Utemp': self.chan_Ugood_ppp,
            'cxhw:2.inj.prekick.p.neg.Utemp': self.chan_Ugood_ppn,
            'cxhw:2.inj.kick.p.pos.Utemp': self.chan_Ugood_kpp,
            'cxhw:2.inj.kick.p.neg.Utemp': self.chan_Ugood_kpn,
            'cxhw:2.inj.prekick.e.pos.Utemp': self.chan_Ugood_pep,
            'cxhw:2.inj.prekick.e.neg.Utemp': self.chan_Ugood_pen,
            'cxhw:2.inj.kick.e.pos.Utemp': self.chan_Ugood_kep,
            'cxhw:2.inj.kick.e.neg.Utemp': self.chan_Ugood_ken
        }

        self.dict_temp_chans = {
            'cxhw:2.inj.prekick.p.pos.Utemp': self.chan_Utemp_ppp,
            'cxhw:2.inj.prekick.p.neg.Utemp': self.chan_Utemp_ppn,
            'cxhw:2.inj.kick.p.pos.Utemp': self.chan_Utemp_kpp,
            'cxhw:2.inj.kick.p.neg.Utemp': self.chan_Utemp_kpn,
            'cxhw:2.inj.prekick.e.pos.Utemp': self.chan_Utemp_pep,
            'cxhw:2.inj.prekick.e.neg.Utemp': self.chan_Utemp_pen,
            'cxhw:2.inj.kick.e.pos.Utemp': self.chan_Utemp_kep,
            'cxhw:2.inj.kick.e.neg.Utemp': self.chan_Utemp_ken
        }

        self.list_hist_ppp = [
            self.chan_histo_x_all_ppp, self.chan_histo_y_all_ppp,
            self.chan_histo_x_1_ppp, self.chan_histo_y_1_ppp,
            self.chan_histo_x_2_ppp, self.chan_histo_y_2_ppp,
            self.chan_histo_x_3_ppp, self.chan_histo_y_3_ppp
        ]
        self.list_hist_ppn = [
            self.chan_histo_x_all_ppn, self.chan_histo_y_all_ppn,
            self.chan_histo_x_1_ppn, self.chan_histo_y_1_ppn,
            self.chan_histo_x_2_ppn, self.chan_histo_y_2_ppn,
            self.chan_histo_x_3_ppn, self.chan_histo_y_3_ppn
        ]
        self.list_hist_kpp = [
            self.chan_histo_x_all_kpp, self.chan_histo_y_all_kpp,
            self.chan_histo_x_1_kpp, self.chan_histo_y_1_kpp,
            self.chan_histo_x_2_kpp, self.chan_histo_y_2_kpp,
            self.chan_histo_x_3_kpp, self.chan_histo_y_3_kpp
        ]
        self.list_hist_kpn = [
            self.chan_histo_x_all_kpn, self.chan_histo_y_all_kpn,
            self.chan_histo_x_1_kpn, self.chan_histo_y_1_kpn,
            self.chan_histo_x_2_kpn, self.chan_histo_y_2_kpn,
            self.chan_histo_x_3_kpn, self.chan_histo_y_3_kpn
        ]
        self.list_hist_pep = [
            self.chan_histo_x_all_pep, self.chan_histo_y_all_pep,
            self.chan_histo_x_1_pep, self.chan_histo_y_1_pep,
            self.chan_histo_x_2_pep, self.chan_histo_y_2_pep,
            self.chan_histo_x_3_ppp, self.chan_histo_y_3_ppp
        ]
        self.list_hist_pen = [
            self.chan_histo_x_all_pen, self.chan_histo_y_all_pen,
            self.chan_histo_x_1_pen, self.chan_histo_y_1_pen,
            self.chan_histo_x_2_pen, self.chan_histo_y_2_pen,
            self.chan_histo_x_3_pen, self.chan_histo_y_3_pen
        ]
        self.list_hist_kep = [
            self.chan_histo_x_all_kep, self.chan_histo_y_all_kep,
            self.chan_histo_x_1_kep, self.chan_histo_y_1_kep,
            self.chan_histo_x_2_kep, self.chan_histo_y_2_kep,
            self.chan_histo_x_3_kep, self.chan_histo_y_3_kep
        ]
        self.list_hist_ken = [
            self.chan_histo_x_all_ken, self.chan_histo_y_all_ken,
            self.chan_histo_x_1_ken, self.chan_histo_y_1_ken,
            self.chan_histo_x_2_ken, self.chan_histo_y_2_ken,
            self.chan_histo_x_3_ken, self.chan_histo_y_3_ken
        ]

        self.dict_hist = {
            'cxhw:2.inj.prekick.p.pos.Utemp': self.list_hist_ppp,
            'cxhw:2.inj.prekick.p.neg.Utemp': self.list_hist_ppn,
            'cxhw:2.inj.kick.p.pos.Utemp': self.list_hist_kpp,
            'cxhw:2.inj.kick.p.neg.Utemp': self.list_hist_kpn,
            'cxhw:2.inj.prekick.e.pos.Utemp': self.list_hist_pep,
            'cxhw:2.inj.prekick.e.neg.Utemp': self.list_hist_pen,
            'cxhw:2.inj.kick.e.pos.Utemp': self.list_hist_kep,
            'cxhw:2.inj.kick.e.neg.Utemp': self.list_hist_ken
        }
Esempio n. 17
0
    def __init__(self):
        super(TunesControl, self).__init__()
        pg.setConfigOption('background', 'w')
        pg.setConfigOption('foreground', 'k')
        path = os.getcwd()
        conf = re.sub('bpm_plot', 'config', path)
        direc = re.sub('bpm_plot', 'uis', path)
        uic.loadUi(direc + "/wp's.ui", self)
        self.setWindowTitle('Tunes Plot')
        self.show()

        self.ic_mode = ''
        self.cur_tunes = np.zeros(2)
        self.dir = os.getcwd()

        self.tunes_plot = pg.PlotWidget()
        p = QVBoxLayout()
        self.wp_plot.setLayout(p)
        p.addWidget(self.tunes_plot)

        # res_diag tune properties set
        self.tunes_plot.setRange(yRange=[0, 1])
        self.tunes_plot.setRange(xRange=[0, 1])
        self.tunes_plot.addItem(LinesPlot(Converter.res_diag(4), order=4, color=QtGui.QColor('#852EBA')))
        self.tunes_plot.addItem(LinesPlot(Converter.res_diag(3), order=3, color=QtGui.QColor('#B5FBDD')))
        self.tunes_plot.addItem(LinesPlot(Converter.res_diag(2), order=2, color=QtGui.QColor('#FFA96B')))
        self.tunes_plot.addItem(LinesPlot(Converter.res_diag(1), order=1, color=QtCore.Qt.black))
        self.tunes = {'e2v4': TunesMarker(color=QtGui.QColor('#55ffff')),
                      'p2v4': TunesMarker(color=QtGui.QColor('#ff86ff')),
                      'e2v2': TunesMarker(color=QtGui.QColor('#75ff91')),
                      'p2v2': TunesMarker(color=QtGui.QColor('#ff6b6b')),
                      'cur': TunesMarker(color=QtGui.QColor('#808285'))}
        for t_type, tune_marker in self.tunes.items():
            self.tunes_plot.addItem(tune_marker)
        self.legend = pg.LegendItem()
        self.legend.setParentItem(self.tunes_plot.getPlotItem())

        self.btn_dict = {'e2v4': self.btn_sel_e2v4, 'p2v4': self.btn_sel_p2v4, 'e2v2': self.btn_sel_e2v2,
                         'p2v2': self.btn_sel_p2v2}
        for key, btn in self.btn_dict.items():
            btn.clicked.connect(self.load_file_)
        self.btn_save.clicked.connect(self.save_file_)
        self.colors = {'e2v4': 'background-color:#55ffff;', 'p2v4': 'background-color:#ff86ff;',
                       'e2v2': 'background-color:#75ff91;', 'p2v2': 'background-color:#ff6b6b;'}
        self.lbl_dict = {'e2v4': self.lbl_e2v4, 'p2v4': self.lbl_p2v4, 'e2v2': self.lbl_e2v2, 'p2v2': self.lbl_p2v2,
                         'cur': self.lbl_cur}

        soft_conf = load_config_orbit(conf + '/orbitd_conf.txt', path)
        chans_conf = soft_conf['chans_conf']

        for chan in ['tunes', 'cmd', 'res', 'control_tunes', 'modet']:
            if chan not in chans_conf:
                print(chan + ' is absent in orbitd_conf')
                sys.exit(app.exec_())

        self.chan_mode = cda.StrChan(**chans_conf['modet'])
        self.chan_mode.valueMeasured.connect(self.mode_changed)
        self.chan_tunes = cda.VChan(**chans_conf['tunes'])
        self.chan_tunes.valueMeasured.connect(self.tunes_update)
        self.chan_ctrl_tunes = cda.StrChan(**chans_conf['control_tunes'])
        self.chan_ctrl_tunes.valueMeasured.connect(self.ctrl_tunes_update)
        self.chan_cmd = cda.StrChan(**chans_conf['cmd'])
        self.chan_res = cda.StrChan(**chans_conf['res'])
        self.chan_res.valueMeasured.connect(self.cmd_result)
        # put IC mode tunes into their place on res_diag
        self.chan_cmd.setValue((json.dumps({'cmd': 'start_tunes', 'client': 'tunes'})))
Esempio n. 18
0
    def __init__(self):
        super(IcWatcher, self).__init__()
        try:
            self.conn = psycopg2.connect(dbname='icdata',
                                         user='******',
                                         host='pg10-srv',
                                         password='')
            print("Connected to DB")
        except:
            print("No access to DB")

        self.sys_info_d = {
            'logs':
            cda.StrChan('cxhw:1.ic_watcher.logs', max_nelems=1024,
                        on_update=1),
            'ofr':
            cda.StrChan('cxhw:1.ic_watcher.ofr', max_nelems=1024, on_update=1)
        }
        self.ofr_list = []

        self.dev_chans_list = []

        self.conditions_um4 = [{
            'func': 'curr_state',
            'chans': ['Iset', 'Imes'],
            'wait_time': 3000,
            'up_lim': 8000,
            'down_lim': 200,
            'err_code': 'I_mes_problem'
        }, {
            'func': 'range_state',
            'chans': ['Umes'],
            'up_lim': 13,
            'down_lim': 0,
            'err_code': 'U_out_of_range'
        }]
        self.conditions_vs = [{
            'func': 'range_state',
            'chans': ['Imes'],
            'up_lim': 256,
            'down_lim': 0,
            'err_code': 'I_out_of_range'
        }, {
            'func': 'range_state',
            'chans': ['Umes'],
            'up_lim': 7,
            'down_lim': 2,
            'err_code': 'U_out_of_range'
        }]
        self.conditions_um15 = [{
            'func': 'curr_state',
            'chans': ['Iset', 'Imes'],
            'wait_time': 3000,
            'up_lim': 8000,
            'down_lim': 200,
            'err_code': 'I_mes_problem'
        }]
        self.conditions_vch300 = [{
            'func': 'curr_state',
            'chans': ['Iset', 'Imes'],
            'wait_time': 3000,
            'up_lim': 1000,
            'down_lim': 0,
            'err_code': 'I_mes_problem'
        }]
        self.conditions_v300 = [{
            'func': 'curr_state',
            'chans': ['Iset', 'Imes'],
            'wait_time': 3000,
            'up_lim': 1000,
            'down_lim': 0,
            'err_code': 'I_mes_problem'
        }]
        self.conditions_pa10 = [{
            'func': 'curr_state',
            'chans': ['Iset', 'Imes'],
            'wait_time': 3000,
            'up_lim': 1000,
            'down_lim': 0,
            'err_code': 'I_mes_problem'
        }, {
            'func': 'range_state',
            'chans': ['Umes'],
            'up_lim': 13,
            'down_lim': 0,
            'err_code': 'U_out_of_range'
        }]
        self.conditions_vch1000 = [{
            'func': 'curr_state',
            'chans': ['Iset', 'dcct1'],
            'wait_time': 3000,
            'up_lim': 5000,
            'down_lim': 0,
            'err_code': 'I_mes_problem'
        }, {
            'func': 'is_on',
            'chans': ['is_on'],
            'err_code': 'PS is off'
        }, {
            'func':
            'ilk',
            'chans': [
                'ilk_imax', 'ilk_inverter', 'ilk_out_prot1', 'ilk_out_prot2',
                'ilk_out_prot3', 'ilk_phase', 'ilk_temp'
            ],
            'wait_time':
            3000,
            'err_code':
            'Interlock'
        }]
        self.conditions_ist = [{
            'func': 'curr_state',
            'chans': ['Iset', 'dcct1'],
            'wait_time': 3000,
            'up_lim': 5000,
            'down_lim': 0,
            'err_code': 'I_mes_problem'
        }, {
            'func': 'is_on',
            'chans': ['is_on'],
            'err_code': 'is_on'
        }, {
            'func':
            'ilk',
            'chans': [
                'ilk_imax', 'ilk_umax', 'ilk_out_prot', 'ilk_phase',
                'ilk_temp', 'ilk_water', 'ilk_battery'
            ],
            'wait_time':
            3000,
            'err_code':
            'Interlock'
        }]

        self.conditions_dict = {
            'UM15': self.conditions_um15,
            'UM4': self.conditions_um4,
            'vaciva': self.conditions_vs,
            'vac124': self.conditions_vs,
            'vch300': self.conditions_vch300,
            'v300': self.conditions_v300,
            'pa10': self.conditions_pa10,
            'vch1000': self.conditions_vch1000,
            'ist': self.conditions_ist
        }
        self.state_chans_dict = {'magnet': [], 'ion_pump': []}
        self.choose_state_dict = {
            'UM15': 'magnet',
            'UM4': 'magnet',
            'vaciva': 'ion_pump',
            'vac124': 'ion_pump',
            'vch300': 'magnet',
            'v300': 'magnet',
            'pa10': 'magnet',
            'vch1000': 'magnet',
            'ist': 'magnet'
        }
        self.chans_dict = {
            'UM15': [],
            'UM4': [],
            'vaciva': [],
            'vac124': [],
            'vch300': [],
            'v300': [],
            'pa10': [],
            'vch1000': [],
            'ist': []
        }
        self.devnames_dict = {
            'UM15': [],
            'UM4': [],
            'vaciva': [],
            'vac124': [],
            'vch300': [],
            'v300': [],
            'pa10': [],
            'vch1000': [],
            'ist': []
        }

        self.cur = self.conn.cursor()
        self.cur.execute(
            "select devtype.name, chan.name from chan,devtype_chans,devtype "
            "where chan.id=devtype_chans.chan_id and devtype.id=devtype_chans.devtype_id and "
            "devtype.name in ('magnet', 'ion_pump') group by grouping sets((devtype.name, chan.name))"
        )
        for elem in self.cur.fetchall():
            self.state_chans_dict[elem[0]].append(elem[1])
        print('state_chans_dict', self.state_chans_dict)

        self.cur.execute(
            "select devtype.name, chan.name from chan,devtype_chans,devtype "
            "where chan.id=devtype_chans.chan_id and devtype.id=devtype_chans.devtype_id and "
            "devtype.name in ('UM4', 'UM15', 'vaciva', 'vac124', 'vch300', 'v300', 'pa10', 'vch1000', 'ist') group by grouping sets((devtype.name, chan.name))"
        )
        # 'UM4', 'UM15', 'vaciva', 'vac124', 'vch300', 'v300', 'pa10', 'vch1000', 'ist'
        for elem in self.cur.fetchall():
            self.chans_dict[elem[0]].append(elem[1])
        print(self.chans_dict)

        self.cur.execute(
            "select devtype.name, namesys.name || '.' || dev.name as full_name from dev,dev_devtype,devtype, namesys "
            "where dev.id=dev_devtype.dev_id and devtype.id=dev_devtype.devtype_id and namesys.id=dev.namesys_id and "
            "devtype.name in ('UM4', 'UM15', 'vaciva', 'vac124', 'vch300', 'v300', 'pa10', 'vch1000', 'ist') group by grouping sets((devtype.name, full_name))"
        )
        for elem in self.cur.fetchall():
            self.devnames_dict[elem[0]].append(elem[1])
        # self.devnames_dict['ist'].append('canhw:11.vit_sim_ist')
        print('devname_dict', self.devnames_dict)

        for elem in self.devnames_dict:
            for dname in self.devnames_dict[elem]:
                self.dev_chans_list.append(
                    Dev(dname, self.chans_dict[elem],
                        self.conditions_dict[elem],
                        self.state_chans_dict[self.choose_state_dict[elem]],
                        self.sys_info_d, self.ofr_list))
Esempio n. 19
0
    def __init__(self):
        super().__init__()

        self.particles = "e"
        self.req_particles = None

        self.pu_mode = None
        self.req_pu_mode = None
        self.req_kickers_mode = False
        self.state = 'idle'
        self.ic_runmode = 'idle'

        self.linStarter = LinStarter()
        self.extractor = Extractor()
        self.modeCtl = ModesClient()
        self.pu_ctl = PUSwitcher()

        self.mode_subsys = [37, 38, 39]

        self.modeCtl.markedReady.connect(self.kickers_loaded)
        self.linStarter.runDone.connect(self.next_state)
        self.extractor.extractionDone.connect(self.next_state)
        self.pu_ctl.switching_done.connect(self.next_state)

        self.timer = cda.Timer()
        self.calibr_timer = cda.Timer()

        self.states = [
            self.__idle, self.__preinject, self.__inject2, self.__injected,
            self.__preextract, self.__extract2, self.__extracted,
            self.__pu_switching, self.__pu_switched
        ]

        # output channels
        self.c_state = cda.StrChan('cxhw:0.ddm.state',
                                   on_update=True,
                                   max_nelems=20)
        self.c_stateMsg = cda.StrChan('cxhw:0.ddm.stateMsg',
                                      on_update=True,
                                      max_nelems=100)

        self.c_icrunmode = cda.StrChan('cxhw:0.ddm.ICRunMode',
                                       on_update=True,
                                       max_nelems=20)

        # command channels
        self.cmds = [
            'stop', 'inject', 'extract', 'nround', 'autorun', 'e2v4', 'p2v4',
            'e2v2', 'p2v2'
        ]
        self.c_cmds = [
            cda.IChan('cxhw:0.ddm.' + x, on_update=True) for x in self.cmds
        ]
        for c in self.c_cmds:
            c.valueMeasured.connect(self.cmd_proc)

        # option-command channels
        self.c_particles = cda.StrChan('cxhw:0.ddm.particles',
                                       on_update=True,
                                       max_nelems=20)
        self.c_particles.valueMeasured.connect(self.particles_update)
        self.c_particles.setValue(self.particles)

        self.c_extr_train = cda.IChan('cxhw:0.ddm.extr_train', on_update=True)
        self.c_extr_train.valueMeasured.connect(self.train_proc)

        self.c_extr_train_interval = cda.DChan(
            'cxhw:0.ddm.extr_train_interval', on_update=True)
        self.c_extr_train_interval.valueMeasured.connect(
            self.train_interval_update)

        # event channels
        self.c_injected = cda.IChan('cxhw:0.ddm.injected', on_update=True)
        self.c_extracted = cda.IChan('cxhw:0.ddm.extracted', on_update=True)

        # beam current channels
        self.c_beamcur = cda.DChan('cxhw:0.dcct.beamcurrent', on_update=True)
        self.c_extr_beamCur = cda.DChan('cxhw:0.dcct.ExtractionCurrent',
                                        on_update=True)

        self.c_v2k_auto = cda.IChan('cxhw:0.ddm.v2k_auto', on_update=True)
        self.c_v2k_particles = cda.StrChan('cxhw:0.bep.particles',
                                           on_update=True,
                                           max_nelems=20)
        self.c_v2k_particles.valueMeasured.connect(self.v2k_auto_mode)
        self.c_v2k_offline = cda.IChan('cxhw:0.bep.offline', on_update=True)
        self.c_v2k_offline.valueMeasured.connect(self.v2k_offline_proc)

        self.linbeam_cor = LinBeamCtl()