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)
    def __init__(self, xname, zname, **kwargs):
        pg.GraphicsObject.__init__(self)
        self.picture = pg.QtGui.QPicture()
        self.x = kwargs.get('x', 0)
        self.y = kwargs.get('y', 0)
        self.color = kwargs.get('color', QtCore.Qt.darkCyan)

        self.chan_x = cda.DChan(name=xname)
        self.chan_x.valueMeasured.connect(self.new_x)
        self.chan_z = cda.DChan(name=zname)
        self.chan_z.valueMeasured.connect(self.new_z)

        self.point_obj()
Exemple #3
0
 def datareadNcalc(self,mode):
     self.Magnets=[]
     self.listMagnets()
     self.vals={}
     self.chans={}
     self.chans["canhw:12.drm.Iset"]=cda.DChan("canhw:12.drm.Iset")
     print("Read channels...")
     print(self.Magnets)
     for magname in self.Magnets:
         Mcurrents = MagnetType[magname][1]
         for current in Mcurrents:
             if "canhw:{0}.Iset".format(current) not in self.chans.keys():
                 self.chans["canhw:{0}.Iset".format(current)] = cda.DChan("canhw:{0}.Iset".format(current))
     connects = {k:v.valueMeasured.connect(self.callback) for (k,v) in self.chans.items()}
Exemple #4
0
    def __init__(self):
        super(LinBeamCtl, self).__init__()
        self.stateRequested = cda.InstSignal(str)
        self.stateChanged = cda.InstSignal(str)
        self.stateMeas = cda.InstSignal(str)

        self.cav_h_iset_chan = cda.DChan('canhw:11.rst1.CAV_H.Iset',
                                         on_update=True)
        self.cav_h_imeas_chan = cda.DChan('canhw:11.rst1.CAV_H.Imes',
                                          on_update=True)

        self.cav_h_iset_chan.valueChanged.connect(self.iset_cb)
        self.cav_h_imeas_chan.valueChanged.connect(self.imeas_cb)

        self.iset_saved = None
        self.state = None
        self.state_meas = None
Exemple #5
0
 def create_chan(self, chan):
     print(chan.val)
     channel = cda.DChan(self.chans[self.i] + '.Iset', private=1)
     self.dict_chans[self.i] = channel
     self.dict_chans[self.i].valueMeasured.connect(self.connection_check)
     self.i += 1
     print('connection added')
     print(self.dict_chans)
Exemple #6
0
    def __init__(self):
        self.runmodeChanged = cda.InstSignal(str)
        self.nshotsChanged = cda.InstSignal(int)
        self.runDone = cda.InstSignal()

        # state variables.
        self.runmode = None
        self.runmode_req = False
        self.running = False
        self.run_req = False
        self.nshots = 0  # number of requested shots
        self.nshots_req = False
        self.eshots = 5
        self.pshots = 10
        self.particles = 'e'

        self.c_runmode = cda.DChan(prefix + 'syn_ie4.mode', on_update=True)
        self.c_start = cda.DChan(prefix + 'syn_ie4.bum_start', on_update=True)
        self.c_stop = cda.DChan(prefix + 'syn_ie4.bum_stop', on_update=True)
        self.c_lamsig = cda.DChan(prefix + 'syn_ie4.lam_sig', on_update=True)
        self.c_nshots = cda.DChan(prefix + 'syn_ie4.re_bum', on_update=True)

        self.c_runmode.valueMeasured.connect(self.runmode_update)
        self.c_nshots.valueChanged.connect(self.nshots_update)
        self.c_lamsig.valueMeasured.connect(self.done_proc)

        self.c_eshots = cda.DChan('cxhw:0.ddm.eshots')
        self.c_pshots = cda.DChan('cxhw:0.ddm.pshots')
        self.c_eshots.valueChanged.connect(self.shots_update)
        self.c_pshots.valueChanged.connect(self.shots_update)
Exemple #7
0
    def __init__(self, dname, dtype, dcnd, dstate_chans, sys_info_d, ofr_list):
        super(Dev, self).__init__()
        self.fail_count = {
            'curr_state': 0,
            'range_state': 0,
            'is_on': 0,
            'ilk': 0
        }
        self.chans = []
        self.values = {}
        self.cnd_callback = {}
        self.sys_chans = {}
        self.ps_error = {'time': 0, 'val': 0, 'prev': 0}

        for dchan in dstate_chans:
            if dname == 'canhw:11.vit_sim_ist':
                chan = cda.DChan('canhw:11' + '.' + dname.split('.')[-1] +
                                 '.' + dchan)
                self.sys_chans[dchan] = chan
            else:
                chan = cda.DChan('cxhw:1' + '.' + dname.split('.')[-1] + '.' +
                                 dchan)
                self.sys_chans[dchan] = chan

        for dchan in dtype:
            chan = cda.DChan(dname + '.' + dchan)
            chan.valueChanged.connect(self.ps_change_state)
            self.chans.append(chan)
            self.values[chan.name] = None
            for elem in dcnd:
                try:
                    for cnd_name in elem['chans']:
                        if chan.name.split('.')[-1] == cnd_name:
                            # print(chan.name, cnd_name)
                            self.cnd_callback[chan.name] = getattr(
                                Cond(dname, dchan, self.values, elem,
                                     self.sys_chans, sys_info_d, ofr_list,
                                     self.fail_count, self.ps_error),
                                elem['func'])
                except Exception as err:
                    print('callbacks creating', err)
    def add_row(self, name, descr, cors_list):
        handle_params = {}
        self.handles_renum()
        self.handle_descr[0] = {'name': name, 'descr': descr, 'cor_list': []}
        for cor in cors_list:
            if cor['name'].split('.')[-1][0] == 'G':
                handle_params[cor['name'].split('.')[-1]] = [
                    cda.DChan(cor['name'] + '.Uset'), cor['step']
                ]
                # handle_params[cor['name'].split('.')[-1]][0].valueMeasured.connect(self.CLB)
            else:
                handle_params[cor['name'].split('.')[-1]] = [
                    cda.DChan(cor['name'] + '.Iset'), cor['step']
                ]
                # handle_params[cor['name'].split('.')[-1]][0].valueMeasured.connect(self.CLB)
            self.handle_descr[0]['cor_list'].append(cor)

        self.table.insertRow(0)
        self.table.setItem(0, 0, QTableWidgetItem(name))
        self.table.setItem(0, 1, QTableWidgetItem(descr))
        self.handles[0] = handle_params
Exemple #9
0
 def __init__(self,
              call_upon_completion,
              name,
              it_id,
              step,
              n_mesh,
              prg,
              resp_type='coords'):
     super(CorMeasure, self).__init__()
     self.chans = {'Iset': None, 'Imes': None}
     self.val = {'Iset': None, 'Imes': None, 'time': None}
     self.name = name
     self.id = it_id
     self.init_val = None
     self.step = step
     self.n_mesh = -1 * n_mesh
     self.prg = prg
     self.stop = n_mesh + 1
     self.response = None
     self.std_err = None
     self.status = None
     self.flag = False
     self.time_flag = False
     self.err_flag = False
     self.data_flag = True
     self.time_stamp = 0
     self.resp_type = resp_type
     self.callback = call_upon_completion
     self.chan_resps = {
         'coords':
         cda.VChan('cxhw:4.bpm_preproc.orbit', max_nelems=64),
         'tunes':
         cda.VChan('cxhw:4.bpm_preproc.tunes', max_nelems=2, on_update=1)
     }
     self.cor_data_resps = {
         'coords': np.zeros([
             32,
         ]),
         'tunes': np.zeros([
             2,
         ])
     }
     self.cor_std = np.zeros([
         32,
     ])
     for chan in ['Iset', 'Imes']:
         cor_chan = cda.DChan(name + '.' + chan)
         cor_chan.valueMeasured.connect(self.val_change)
         self.chans[chan] = cor_chan
     self.cor_data = self.cor_data_resps[resp_type]
     self.chan_data = self.chan_resps[resp_type]
     self.chan_data.valueMeasured.connect(self.data_proc)
Exemple #10
0
    def make_orbit_cor(d, rev_rm, cor_names):
        chans_list = []
        log = {}
        d_i = np.dot(rev_rm, d)

        for cor_name in cor_names:
            cor_chan = cda.DChan('canhw:12.' + cor_name + '.Iset')
            chans_list.append(cor_chan)

        for i in range(len(d_i) - 1):
            chans_list[i].setValue(d_i[i] / 100)
            log[chans_list[i].name] = d_i[i] / 100

        f = open('last_log', 'w')
        f.write(json.dumps(log))
        f.close()
Exemple #11
0
    def chans_connect(self, chans, values, names, devtype='UM4'):
        try:
            conn = psycopg2.connect(dbname='icdata',
                                    user='******',
                                    host='pg10-srv',
                                    password='')
            print("Connected to DB")
        except Exception as err:
            print("No access to DB", err)

        devnames_list = []
        chan_list = []

        cur = conn.cursor()
        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 (%(DEVTYPE)s) group by grouping sets((devtype.name, full_name))",
            {'DEVTYPE': devtype})
        for elem in cur.fetchall():
            devnames_list.append(elem[1])
        print('devname_list', devnames_list)

        for key in chans:
            chan_list.append(key)

        for dname in devnames_list:
            name = dname.split('.')[-1]
            print(name, names)
            if name in names:
                for chan_type in chan_list:
                    print(dname + '.' + chan_type)
                    if devtype == 'UM4':
                        chan = cda.DChan(dname + '.' + chan_type)
                    elif devtype == 'ring_bpm_preproc':
                        chan = cda.VChan(dname + '.' + chan_type,
                                         max_nelems=16)
                    else:
                        print('unknown devtype: ', devtype)
                        break
                    chans[chan_type][name] = chan
                    values[chan_type][name] = None
                    chan.valueMeasured.connect(
                        functools.partial(self.chan_val_change, chan, values))
        print(chans)
        return values, chans
Exemple #12
0
    def __init__(self, call_upon_completion, name, step, stop, odz, elem_prg):
        super(Magnetization, self).__init__()
        self.chans = {'Iset': None, 'Imes': None}
        self.val = {'Iset': None, 'Imes': None}
        self.name = name
        self.init_val = None
        self.step = step
        self.stop = stop
        self.counter = 0
        self.status = None
        self.flag = False
        self.time_flag = False
        self.err_flag = False
        self.time_stamp = 0
        self.odz = odz
        self.elem_prg = elem_prg
        self.callback = call_upon_completion

        for chan in ['Iset', 'Imes']:
            cor_chan = cda.DChan(name + '.' + chan)
            cor_chan.valueMeasured.connect(self.val_change)
            self.chans[chan] = cor_chan
Exemple #13
0
    def __init__(self, devname, name=None):
        super(MagWalker, self).__init__()
        self.done = cda.InstSignal(str)
        self.progressing = cda.InstSignal(str, int)
        self.started = cda.InstSignal(str)

        self.devname = devname
        self.name = name
        if name is None:
            self.name = devname

        # channels:
        # walker.list - requested list of points to go through
        # walker.start - run process
        # walker.stop - stop running
        # walker.cur_step - current step, -1 when stopped (or finished)
        self.list_chan = cda.VChan(devname + '.walker.list',
                                   dtype=cda.DTYPE_DOUBLE,
                                   max_nelems=20,
                                   on_update=True)
        self.start_chan = cda.DChan(devname + '.walker.start', on_update=True)
        self.stop_chan = cda.DChan(devname + '.walker.stop', on_update=True)
        self.cur_step_chan = cda.DChan(devname + '.walker.cur_step',
                                       on_update=True)
        self.iset_cur_chan = cda.DChan(devname + '.iset_cur', on_update=True)
        self.iset_chan = cda.DChan(devname + '.iset', on_update=True)

        # just for some control
        self.imeas_chan = cda.DChan(devname + '.imes', on_update=True)

        self.initialized = False
        self.cur_list = None
        self.requested_list = None
        self.run_requested = False
        self.running = False
        self.progress = 0
        self.step = -1
        self.step_pos = 0
        self.path_length = 0
        self.start_iset = 0
        self.ext_cur_list = None

        self.list_chan.valueMeasured.connect(self.list_update)
        self.cur_step_chan.valueChanged.connect(self.step_update)
        self.iset_cur_chan.valueChanged.connect(self.iset_cur_update)
Exemple #14
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()
    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()
    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
        }
Exemple #17
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
        }
Exemple #18
0
#!/usr/bin/env python3
import sys
import signal
from PyQt5 import QtCore
import pycx4.qcda as cda

signal.signal(signal.SIGINT, signal.SIG_DFL)


def printval(chan):
    print(chan.val)


app = QtCore.QCoreApplication(sys.argv)

c = cda.DChan('canhw:13.S13_out.Imes')
c.valueMeasured.connect(printval)

app.exec_()
from PyQt5 import QtCore

# since protocol requires
flags = sys.getdlopenflags()
sys.setdlopenflags(flags | os.RTLD_GLOBAL)
import pycx4.qcda as cda
#sys.setdlopenflags(flags)

import signal

signal.signal(signal.SIGINT, signal.SIG_DFL)


def printval(chan):
    print(chan.val)


app = QtCore.QCoreApplication(sys.argv)

cont = cda.Context("EPICS::")

chan = cda.DChan("V5:PA:Current1M", context=cont)
#chan = cda.Chan("canhw:13.S13_out.Imes")
chan.valueMeasured.connect(printval)

print(cont)
print(chan)

app.exec_()
#cda.main_loop()