def _create_pvs(self):
"""Create PVs."""
Timing._pvs = dict()
for dict_ in Timing.properties.values():
for pvname in dict_.keys():
if pvname in Timing._pvs.keys():
continue
pvname = _PVName(pvname)
Timing._pvs[pvname] = _PV(
VACA_PREFIX+pvname, connection_timeout=TIMEOUT_CONNECTION)
if pvname.propty_suffix in ('Cmd', 'Mon'):
continue
self._initial_state[pvname] = Timing._pvs[pvname].value
if pvname.propty_suffix == 'SP':
pvname_sts = pvname.substitute(propty_suffix='RB')
elif pvname.propty_suffix == 'Sel':
pvname_sts = pvname.substitute(propty_suffix='Sts')
else:
continue
Timing._pvs[pvname_sts] = _PV(
VACA_PREFIX+pvname_sts,
connection_timeout=TIMEOUT_CONNECTION)
def __init__(self):
"""Class constructor."""
super().__init__()
# consts
self._pvs_database = _get_database('BO')
self._dcct = 'BO-35D:DI-DCCT'
# initialize vars
self._samplecnt = None
self._measperiod = None
self._reliablemeas = None
self._last_raw_reading = None
currthold_db = self._pvs_database['CurrThold-SP']
self._currthold = currthold_db['value']
self._currthold_lolim = currthold_db['lolim']
self._currthold_hilim = currthold_db['hilim']
self._rampeff = None
self._currents = dict()
self._charges = dict()
for k in self.ENERGY2TIME:
# currents
self._currents[k] = 0.0
# charges
ppty = 'Charge' + k + '-Mon'
data = self._get_value_from_arch('BO-Glob:AP-CurrInfo:' + ppty)
if data is None:
charge = 0.0
else:
charge = data[1][0]
self._charges[k] = charge
data = self._get_value_from_arch(
'BO-Glob:AP-CurrInfo:IntCurrent3GeV-Mon')
if data is None:
self._intcurrent3gev = 0.0
else:
self._intcurrent3gev = data[1][0]
# PVs
self._rawreadings_pv = _PV(_vaca_prefix + self._dcct +
':RawReadings-Mon',
connection_timeout=0.05,
callback=self._callback_get_rawreadings,
auto_monitor=True)
self._samplecnt_pv = _PV(_vaca_prefix + self._dcct +
':FastSampleCnt-RB',
connection_timeout=0.05,
callback=self._callback_get_samplecnt)
self._measperiod_pv = _PV(_vaca_prefix + self._dcct +
':FastMeasPeriod-RB',
connection_timeout=0.05,
callback=self._callback_get_measperiod)
self._reliablemeas_pv = _PV(_vaca_prefix + self._dcct +
':ReliableMeas-Mon',
connection_timeout=0.05,
callback=self._callback_get_reliablemeas)
def __init__(self):
"""Class constructor."""
super().__init__()
self._init_time = _time.time()
self._pvs_database = _get_database()
self._mode = _Const.Fit.Linear
self._current_offset = 0.0
self._frst_smpl_ts = self._init_time
self._last_smpl_ts = -1
self._frst_smpl_ts_dcct = self._init_time
self._last_smpl_ts_dcct = -1
self._smpl_intvl_mon_dcct = 0.0
self._frst_smpl_ts_bpm = self._init_time
self._last_smpl_ts_bpm = -1
self._smpl_intvl_mon_bpm = 0.0
self._last_ts_set = 'last'
self._sampling_interval = 500.0
self._min_intvl_btw_spl = 0.0
self._rstbuff_cmd_count = 0
self._buffautorst_mode = _Const.BuffAutoRst.Off
self._buffautorst_dcurr = 0.1
self._is_stored = 0
self._lifetime = 0
self._lifetime_bpm = 0
self._current_pv = _PV(_vaca_prefix +
'SI-Glob:AP-CurrInfo:Current-Mon',
connection_timeout=0.05)
self._bpmsum_pv = _PV(_vaca_prefix + 'SI-01M1:DI-BPM:Sum-Mon',
connection_timeout=0.05)
self._storedebeam_pv = _PV(_vaca_prefix +
'SI-Glob:AP-CurrInfo:StoredEBeam-Mon',
connection_timeout=0.05)
self._current_buffer = _SiriusPVTimeSerie(
pv=self._current_pv,
mode=0,
nr_max_points=_MAX_BUFFER_SIZE,
use_pv_timestamp=False)
self._bpmsum_buffer = _SiriusPVTimeSerie(
pv=self._bpmsum_pv,
mode=0,
nr_max_points=_MAX_BUFFER_SIZE,
use_pv_timestamp=False)
self._current_pv.add_callback(self._callback_calclifetime)
self._bpmsum_pv.add_callback(self._callback_calclifetime)
self._storedebeam_pv.add_callback(self._callback_get_storedebeam)
def _create_pvs():
pvs = dict()
for trig in BOTIRampFactory._triggers:
for ppty in {'Src-Sts', 'Delay-RB'}:
pvname = trig + ':' + ppty
pvs[pvname] = _PV(pvname, connection_timeout=TIMEOUT_CONN)
for ev in BOTIRampFactory._events:
pvname = ev + 'Delay-RB'
pvs[pvname] = _PV(pvname, connection_timeout=TIMEOUT_CONN)
egun_sb_sts_pvname = 'LI-01:EG-PulsePS:singleselstatus'
pvs[egun_sb_sts_pvname] = _PV(
egun_sb_sts_pvname, connection_timeout=TIMEOUT_CONN)
BOTIRampFactory._PVs = pvs
def __init__(self,
cyclers=None,
timing=None,
is_bo=False,
ramp_config=None,
logger=None):
"""Initialize."""
# initialize auxiliar variables
self._mode = None
self._sections = list()
self._only_linac = None
self._cycle_duration = 0
self._aux_cyclers = dict()
self._cycle_trims_duration = 0
self._checks_result = dict()
# in case cyclers are not set and user wants to cycle bo
self._is_bo = is_bo
self._ramp_config = ramp_config
# cyclers
self.cyclers = cyclers
# timing connector
self.timing = timing
# logger
self._logger_message = ''
self.logger = logger
# egun pv
if 'LI-01:PS-Spect' in self.psnames:
self._pv_egun = _PV('LI-01:EG-TriggerPS:enablereal',
connection_timeout=0.05)
def __init__(self, callback=None):
"""."""
self.image_processor = _ProcessImage(callback=callback)
self._profile = self.DEF_PROFILE
self.image_processor.px2mmscalex = self.DEF_COEFX
self.image_processor.px2mmscaley = self.DEF_COEFY
self._width_source = _PV(self._profile + 'cam1:ArraySizeX_RBV')
self._image_source = _PV(self._profile + 'image1:ArrayData',
auto_monitor=True)
super().__init__(callback=callback)
self._thread = _Repeater(1 / self.DEF_RATE,
self.process_image,
niter=0)
self._thread.pause()
self._thread.start()
def __init__(self, callback=None):
"""."""
self.energy_calculator = CalcEnergy(callback=callback)
self.image_processor = _ProcessImage(callback=callback)
self._profile = self.DEFAULT_PROFILE
self._coefx = _PV(self.DEFAULT_PROFILE + ':X:Gauss:Coef',
callback=self._update_coefx)
self._coefy = _PV(self.DEFAULT_PROFILE + ':Y:Gauss:Coef',
callback=self._update_coefy)
self._width_source = _PV(self.DEFAULT_PROFILE + ':ROI:MaxSizeX_RBV')
self._image_source = _PV(self.DEFAULT_PROFILE + ':RAW:ArrayData',
auto_monitor=False)
self._current_source = _PV(self.DEFAULT_SPECT + ':Current-Mon')
super().__init__(callback=callback)
self._thread = _Repeater(0.5, self.meas_energy, niter=0)
self._thread.pause()
self._thread.start()
def __init__(self, parent=None, prefix='', tl=None):
"""Class construc."""
super(PosAngCorr, self).__init__(parent)
if not prefix:
self._prefix = _VACA_PREFIX
else:
self._prefix = prefix
self._tl = tl.upper()
base_name = _PVName('TL-Glob:AP-PosAng')
self.posang_prefix = base_name.substitute(
prefix=self._prefix, sec=self._tl)
self.setObjectName(self._tl+'App')
self.setWindowTitle(self._tl + ' Position and Angle Correction Window')
if self._tl == 'TS':
self._is_chsept = False
ch3_pv = _PV(self.posang_prefix.substitute(propty='CH3-Cte'),
connection_timeout=1)
if not ch3_pv.wait_for_connection():
self._is_chsept = True
if tl == 'ts':
corr_h = (Const.TS_CORRH_POSANG_CHSEPT if self._is_chsept
else Const.TS_CORRH_POSANG_SEPTSEPT)
corr_v = Const.TS_CORRV_POSANG
elif tl == 'tb':
corr_h = Const.TB_CORRH_POSANG
corr_v = Const.TB_CORRV_POSANG
self.corrs = dict()
self.corrs['CH1'] = _PVName(corr_h[0])
self.corrs['CH2'] = _PVName(corr_h[1])
if len(corr_h) == 3:
self.corrs['CH3'] = _PVName(corr_h[2])
self.corrs['CV1'] = _PVName(corr_v[0])
self.corrs['CV2'] = _PVName(corr_v[1])
if len(corr_v) == 4:
self.corrs['CV3'] = _PVName(corr_v[2])
self.corrs['CV4'] = _PVName(corr_v[3])
self._just_need_update = False
self._update_ref_action = False
self._my_input_widgets = list()
self._setupUi()
self.setFocus(True)
self.setFocusPolicy(Qt.StrongFocus)
self._ask_message = QMessageBox(self)
self._ask_message.setWindowTitle('Message')
self._ask_message.setText(
'The '+self._tl+' PosAng IOC indicates reference needs to '
'be updated! Do you want to update the reference?')
self._ask_message.setStandardButtons(QMessageBox.No | QMessageBox.Yes)
self._ask_message.setDefaultButton(QMessageBox.No)
self.app = QApplication.instance()
self.app.focusChanged.connect(self._spinbox_onfocus)
def _create_primary_pvs_list(self, pvs):
# get list of primary pvs
ppvs = list() # List with PVs used by the computed PV
for pvobj in pvs:
if isinstance(pvobj, str): # give up string option.
tpv = _PV(pvobj, connection_timeout=_CONN_TIMEOUT)
ppvs.append(tpv)
else:
ppvs.append(pvobj)
return ppvs
def __init__(self, psname):
"""Constructor."""
self._psname = psname
self._waveform = None
self._cycle_duration = None
self._times = None
self._pvs = dict()
for prop in LinacPSCycler.properties:
if prop not in self._pvs.keys():
self._pvs[prop] = _PV(
VACA_PREFIX + self._psname + ':' + prop,
connection_timeout=TIMEOUT_CONNECTION)
def __init__(self,
parent=None,
restore_initial_value=False,
dis='PS',
state='on',
devices=list()):
"""Constructor."""
super().__init__(parent)
self._dis = dis
filt = {'dev': 'Mags'} if dis == 'PS' else {'dev': '.*(Kckr|Sept).*'}
self._triggers = _HLTimeSearch.get_hl_triggers(filters=filt)
self._pvs_sp = {
trg: _PV(trg + ':State-Sel', connection_timeout=0.05)
for trg in self._triggers
}
self._pvs_rb = {
trg: _PV(trg + ':State-Sts', connection_timeout=0.05)
for trg in self._triggers
}
for trg, pv in self._pvs_rb.items():
pv.wait_for_connection(TIMEOUT_CONN)
if trg not in TriggerTask.initial_triggers_state.keys():
TriggerTask.initial_triggers_state[trg] = pv.value
if restore_initial_value:
self.trig2val = {
k: v
for k, v in TriggerTask.initial_triggers_state.items()
if k in self._triggers
}
else:
val = Const.DsblEnbl.Enbl if state == 'on' else Const.DsblEnbl.Dsbl
self.trig2val = {trig: val for trig in self._triggers}
self._devices = devices
self._trig2ctrl = self._get_trigger_by_psname(self._devices)
self._quit_task = False
def __init__(self, device):
"""Init."""
super().__init__(device)
self.properties = [
'Reset-Cmd', 'GenIntlk-Mon', 'GenWarn-Mon', 'OpMode-Sts',
'PwrState-Sel', 'PwrState-Sts',
'Voltage-SP', 'VoltageRef-Mon', 'Voltage-Mon']
for ppty in self.properties:
self._pvs[ppty] = _PV(
_PVName(device).substitute(prefix=VACA_PREFIX, propty=ppty),
connection_timeout=TIMEOUT_CONN)
def __init__(self, psname, ramp_config=None):
"""Constructor."""
self._psname = psname
self._ramp_config = ramp_config
self._waveform = None
self._siggen = None
self._init_wfm_pulsecnt = None
self._pvs = dict()
for prop in PSCycler.properties:
if prop not in self._pvs.keys():
self._pvs[prop] = _PV(
VACA_PREFIX + self._psname + ':' + prop,
connection_timeout=TIMEOUT_CONNECTION)
def __init__(self, device):
super().__init__(device)
self.properties = [
'StatusIntlk-Mon', 'IntlkWarn-Mon',
'PwrState-Sel', 'PwrState-Sts',
'Current-SP', 'Current-Mon',
'Connected-Mon']
for ppty in self.properties:
self._pvs[ppty] = _PV(
_PVName(device).substitute(prefix=VACA_PREFIX, propty=ppty),
connection_timeout=TIMEOUT_CONN)
self.intlkwarn_bit = _PSE.LINAC_INTLCK_WARN.index('LoadI Over Thrs')
splims = PSSearch.conv_psname_2_splims(device)
self.test_current = splims['TSTV']
self.test_tol = splims['TSTR']
def __init__(self, device):
"""Init."""
super().__init__(device)
self.properties = [
'Reset-Cmd',
'OpMode-Sel', 'OpMode-Sts',
'PwrState-Sel', 'PwrState-Sts',
'CtrlLoop-Sel', 'CtrlLoop-Sts',
'CapacitorBankVoltage-SP', 'CapacitorBankVoltageRef-Mon',
'CapacitorBankVoltage-Mon']
self._intlk_pvs = get_ps_interlocks(psname=self.device)
self.properties.extend(self._intlk_pvs)
for ppty in self.properties:
self._pvs[ppty] = _PV(
_PVName(device).substitute(prefix=VACA_PREFIX, propty=ppty),
connection_timeout=TIMEOUT_CONN)
def _applyconfig(self):
sender_text = self.sender().text()
if 'Standby' in sender_text:
config_name = 'standby'
elif 'TurnOff' in sender_text:
config_name = 'turnoff'
ans = QMessageBox.question(
self, 'Are you Sure?',
"Do you really want to apply the Configuration '" +
config_name + "' to the machine?", QMessageBox.Yes,
QMessageBox.Cancel)
if ans != QMessageBox.Yes:
return
current, ok = QInputDialog.getDouble(
self,
'Enter value: ', 'Enter FilaPS standby current [A]\n'
'or cancel to not set it: ',
value=0.7,
min=0.0,
max=1.5,
decimals=3)
if ok:
fila_pv = _PV(_prefix + 'LI-01:EG-FilaPS:currentoutsoft',
connection_timeout=0.05)
fila_pv.get() # force connection
if fila_pv.connected:
fila_pv.put(current)
else:
QMessageBox.warning(
self, 'Message',
'Could not connect to LI-01:EG-FilaPS!')
client = ConfigDBClient()
WinClass = create_window_from_widget(
SelectAndApplyPVsWidget, 'Select PVs to Apply Standby')
wind = WinClass(self, client)
wind.widget.settingFinished.connect(wind.close)
wind.widget.fill_config('global_config', config_name)
wind.exec_()
def __init__(self, device):
"""Init."""
super().__init__(device)
self.properties = [
'PSAmpOverCurrFlagL-Sts', 'PSAmpOverTempFlagL-Sts',
'PSAmpOverCurrFlagR-Sts', 'PSAmpOverTempFlagR-Sts',
'PwrState-Sel', 'PwrState-Sts',
'CtrlLoop-Sel', 'CtrlLoop-Sts',
'Current-SP', 'Current-RB',
'TestOpenLoopTriang-Sel', 'TestOpenLoopTriang-Sts',
'TestOpenLoopSquare-Sel', 'TestOpenLoopSquare-Sts',
'TestClosedLoopSquare-Sel', 'TestClosedLoopSquare-Sts',
]
for ppty in self.properties:
self._pvs[ppty] = _PV(
_PVName(device).substitute(prefix=VACA_PREFIX, propty=ppty),
connection_timeout=TIMEOUT_CONN)
splims = PSSearch.conv_psname_2_splims(device)
self.test_current = splims['TSTV']
self.test_tol = splims['TSTR']
def __init__(self, device):
"""Init."""
super().__init__(device)
self.properties = [
'Reset-Cmd',
'Intlk1-Mon', 'Intlk2-Mon', 'Intlk3-Mon', 'Intlk4-Mon',
'Intlk5-Mon', 'Intlk6-Mon', 'Intlk7-Mon',
'PwrState-Sel', 'PwrState-Sts',
'Pulse-Sel', 'Pulse-Sts',
'Voltage-SP', 'Voltage-RB', 'Voltage-Mon']
if 'Kckr' in self.device:
self.properties.append('Intlk8-Mon')
for ppty in self.properties:
self._pvs[ppty] = _PV(
_PVName(device).substitute(prefix=VACA_PREFIX, propty=ppty),
connection_timeout=TIMEOUT_CONN)
splims = PSSearch.conv_psname_2_splims(device)
self.test_voltage = splims['TSTV']
self.test_tol = splims['TSTR']
def __init__(self, acc):
"""Class constructor."""
super().__init__(acc)
# consts
self._delta_tunex = 0.0
self._delta_tuney = 0.0
self._set_new_refkl_cmd_count = 0
if self._acc == 'SI':
self._meas_config_dkl_qf = 0.020
self._meas_config_dkl_qd = 0.020
# Connect to Quadrupoles Families
self._psfam_refkl = {fam: 0 for fam in self._psfams}
self._lastcalc_deltakl = {fam: 0 for fam in self._psfams}
for fam in self._psfams:
self._psfam_intstr_rb_pvs[fam] = _PV(
_vaca_prefix + self._acc + '-Fam:PS-' + fam + ':KL-RB',
callback=[
self._callback_init_refkl,
self._callback_estimate_deltatune
],
connection_timeout=0.05)
self.map_pv2write.update({
'DeltaTuneX-SP':
self.set_dtune_x,
'DeltaTuneY-SP':
self.set_dtune_y,
'SetNewRefKL-Cmd':
self.cmd_set_newref,
'MeasConfigDeltaKLFamQF-SP':
self.set_meas_config_dkl_qf,
'MeasConfigDeltaKLFamQD-SP':
self.set_meas_config_dkl_qd,
})
def __init__(self, parent=None):
"""Set up the ui."""
super().__init__(parent)
# setup the ui
uifile = _getUiFile(self)
self.ui = _uic.loadUi(uifile, self)
self.updating_couple_flag = False
self.coupling_master = _PV('und:CouplingMaster')
self.coupling_slaves = _PV('und:CouplingSlaves')
self.en_coupling = _PV('und:EnGeneralCoupling')
self.coupling_direction = {'slv1': _PV('und:CouplingDirection[0]'),
'slv2': _PV('und:CouplingDirection[1]'),
'slv3': _PV('und:CouplingDirection[2]')}
# connect signals and slots
self.connect_signals_slots()
def __init__(self, device):
"""Init."""
super().__init__(device)
self.properties = [
'Reset-Cmd',
'OpMode-Sel', 'OpMode-Sts',
'PwrState-Sel', 'PwrState-Sts',
'CtrlLoop-Sel', 'CtrlLoop-Sts',
'Current-SP', 'CurrentRef-Mon', 'Current-Mon']
self._intlk_pvs = get_ps_interlocks(psname=self.device)
self.properties.extend(self._intlk_pvs)
if PSSearch.conv_psname_2_psmodel(self.device) == 'FBP':
self.properties.extend(['SOFBMode-Sel', 'SOFBMode-Sts'])
for ppty in self.properties:
self._pvs[ppty] = _PV(
_PVName(device).substitute(prefix=VACA_PREFIX, propty=ppty),
connection_timeout=TIMEOUT_CONN)
splims = PSSearch.conv_psname_2_splims(device)
self.test_current = splims['TSTV']
self.test_tol = splims['TSTR']
def __init__(self, callback=None):
"""."""
self.image_processor = _ProcessImage(callback=callback)
self.image_processor.px2mmscalex = self.DEF_COEFX
self.image_processor.px2mmscaley = self.DEF_COEFY
self.image_processor.roiautocenter = self.AutoCenter.Manual
self.image_processor.imageflipx = self.image_processor.ImgFlip.On
self.image_processor.imageflipy = self.image_processor.ImgFlip.Off
self.image_processor.roisizex = self.DEF_ROISIZE
self.image_processor.roisizey = self.DEF_ROISIZE
self.image_processor.roicenterx = self.TARGETX
self.image_processor.roicentery = self.TARGETY
self.image_processor.method = self.Method.Moments
self._profile = self.DEF_PROFILE
self._target_posx = self.TARGETX
self._target_posy = self.TARGETY
self._needed_dbumpx = 0.0
self._needed_dbumpy = 0.0
self._applied_bumpx = 0.0
self._applied_bumpy = 0.0
self._need_update = True
self._apply_status = self.ApplyStatus.Idle
conf = _ConfigDBClient(config_type='si_orbit')
self._refs = conf.get_config_value('ref_orb')
self._sofb_pvs = dict(refx_sp=_PV('SI-Glob:AP-SOFB:RefOrbX-SP'),
refy_sp=_PV('SI-Glob:AP-SOFB:RefOrbY-SP'),
refx_rb=_PV('SI-Glob:AP-SOFB:RefOrbX-RB',
callback=self._set_need_update),
refy_rb=_PV('SI-Glob:AP-SOFB:RefOrbY-RB',
callback=self._set_need_update))
self._width_source = _PV(self._profile + 'cam1:ArraySizeX_RBV')
self._image_source = _PV(self._profile + 'image1:ArrayData',
auto_monitor=True)
super().__init__(callback=callback)
self._thread = _Repeater(1 / self.DEF_RATE,
self.process_image,
niter=0)
self._thread.pause()
self._thread.start()
def _create_pvs(self):
pvs = dict()
for param, pvname in BORFRampFactory._ppties.items():
pvs[param] = _PV(pvname, connection_timeout=TIMEOUT_CONN)
BORFRampFactory._PVs = pvs
def __init__(self, acc):
"""Class constructor."""
super().__init__()
self._acc = acc.upper()
# consts
if self._optics_param == 'tune':
self._pvs_database = _get_tune_database(self._acc)
if self._acc == 'BO':
self._psfams = _Const.BO_QFAMS_TUNECORR
self._psfam_nelm = _Const.BO_QFAMS_NELM
else:
self._psfams = _Const.SI_QFAMS_TUNECORR
self._psfam_nelm = _Const.SI_QFAMS_NELM
self._trigger_name = 'SI-Glob:TI-Mags-Quads'
self._event_name = 'TunSI'
else:
self._pvs_database = _get_chrom_database(self._acc)
if self._acc == 'BO':
self._psfams = _Const.BO_SFAMS_CHROMCORR
self._psfam_nelm = _Const.BO_SFAMS_NELM
else:
self._psfams = _Const.SI_SFAMS_CHROMCORR
self._psfam_nelm = _Const.SI_SFAMS_NELM
self._trigger_name = 'SI-Glob:TI-Mags-Sexts'
self._event_name = 'ChromSI'
self._status = ALLSET if self._acc == 'SI' else 0x0f
self._optprm_est = [0.0, 0.0]
self._apply_corr_cmd_count = 0
self._config_ps_cmd_count = 0
self._psfam_check_connection = {fam: 0 for fam in self._psfams}
self._psfam_check_pwrstate_sts = {fam: 0 for fam in self._psfams}
self._psfam_check_opmode_sts = {fam: -1 for fam in self._psfams}
self._psfam_check_ctrlmode_mon = {fam: 1 for fam in self._psfams}
self._psfam_intstr_rb = {fam: 0 for fam in self._psfams}
if self._acc == 'SI':
self._corr_method = _Const.CorrMeth.Proportional
self._corr_group = _Const.CorrGroup.TwoKnobs
self._sync_corr = _Const.SyncCorr.Off
self._config_ti_cmd_count = 0
self._timing_check_config = 9*[0]
self._measuring_config = False
self._meas_config_status = _Const.MeasMon.Idle
self._meas_config_lastcomm = _Const.MeasCmd.Reset
self._meas_config_wait = 1
self._meas_config_name = 'UNDEF'
self._meas_config_2_save = None
self._meas_config_save_cmd_count = 0
self._is_storedebeam = 0
else:
self._corr_method = _Const.CorrMeth.Additional
self._corr_group = _Const.CorrGroup.TwoKnobs
self._sync_corr = _Const.SyncCorr.Off
# Get focusing and defocusing families
psfam_focusing = []
psfam_defocusing = []
ps_focus_type = 'QF' if self._optics_param == 'tune' else 'SF'
for fam in self._psfams:
if ps_focus_type in fam:
psfam_focusing.append(fam)
else:
psfam_defocusing.append(fam)
psfam_focusing = tuple(psfam_focusing)
psfam_defocusing = tuple(psfam_defocusing)
# Initialize correction parameters from local file and configdb
self.cn_handler = _HandleConfigNameFile(self._acc, self._optics_param)
self.cdb_client = _ConfigDBClient(
config_type=self._acc.lower()+'_'+self._optics_param+'corr_params')
[done, corrparams] = self._get_corrparams()
if done:
self._config_name = corrparams[0]
self._nominal_matrix = corrparams[1]
self._psfam_nom_intstr = corrparams[2]
self._nominal_opticsparam = corrparams[3]
self._opticscorr = _OpticsCorr(
magnetfams_ordering=self._psfams,
nominal_matrix=self._nominal_matrix,
nominal_intstrengths=self._psfam_nom_intstr,
nominal_opticsparam=self._nominal_opticsparam,
magnetfams_focusing=psfam_focusing,
magnetfams_defocusing=psfam_defocusing)
else:
raise Exception(
"Could not read correction parameters from configdb.")
# Connect to Quadrupoles Families
self._psfam_intstr_sp_pvs = dict()
self._psfam_intstr_rb_pvs = dict()
self._psfam_pwrstate_sel_pvs = dict()
self._psfam_pwrstate_sts_pvs = dict()
self._psfam_opmode_sel_pvs = dict()
self._psfam_opmode_sts_pvs = dict()
self._psfam_ctrlmode_mon_pvs = dict()
for fam in self._psfams:
pss = _SiriusPVName(_vaca_prefix+self._acc+'-Fam:PS-'+fam)
intstr = 'KL' if self._optics_param == 'tune' else 'SL'
self._psfam_intstr_sp_pvs[fam] = _PV(
pss.substitute(propty_name=intstr, propty_suffix='SP'),
connection_callback=self._callback_conn_psfam,
connection_timeout=0.05)
self._psfam_pwrstate_sel_pvs[fam] = _PV(
pss.substitute(propty_name='PwrState', propty_suffix='Sel'),
connection_timeout=0.05)
self._psfam_pwrstate_sts_pvs[fam] = _PV(
pss.substitute(propty_name='PwrState', propty_suffix='Sts'),
callback=self._callback_psfam_pwrstate_sts,
connection_timeout=0.05)
self._psfam_opmode_sel_pvs[fam] = _PV(
pss.substitute(propty_name='OpMode', propty_suffix='Sel'),
connection_timeout=0.05)
self._psfam_opmode_sts_pvs[fam] = _PV(
pss.substitute(propty_name='OpMode', propty_suffix='Sts'),
callback=self._callback_psfam_opmode_sts,
connection_timeout=0.05)
self._psfam_ctrlmode_mon_pvs[fam] = _PV(
pss.substitute(propty_name='CtrlMode', propty_suffix='Mon'),
callback=self._callback_psfam_ctrlmode_mon,
connection_timeout=0.05)
if self._acc == 'SI':
# Connect to Timing
trig_name = self._trigger_name
evt_name = self._event_name
try:
trig_db = _get_trig_db(trig_name)
self._evt_src_idx = trig_db['Src-Sel']['enums'].index(evt_name)
except (KeyError, ValueError):
self._evt_src_idx = 1
self._trigger_state_sel = _PV(
_vaca_prefix+trig_name+':State-Sel', connection_timeout=0.05)
self._trigger_state_sts = _PV(
_vaca_prefix+trig_name+':State-Sts',
callback=self._callback_timing_state, connection_timeout=0.05)
self._trigger_polarity_sel = _PV(
_vaca_prefix+trig_name+':Polarity-Sel',
connection_timeout=0.05)
self._trigger_polarity_sts = _PV(
_vaca_prefix+trig_name+':Polarity-Sts',
callback=self._callback_timing_state, connection_timeout=0.05)
self._trigger_src_sel = _PV(
_vaca_prefix+trig_name+':Src-Sel', connection_timeout=0.05)
self._trigger_src_sts = _PV(
_vaca_prefix+trig_name+':Src-Sts',
callback=self._callback_timing_state, connection_timeout=0.05)
self._trigger_nrpulses_sp = _PV(
_vaca_prefix+trig_name+':NrPulses-SP',
connection_timeout=0.05)
self._trigger_nrpulses_rb = _PV(
_vaca_prefix+trig_name+':NrPulses-RB',
callback=self._callback_timing_state, connection_timeout=0.05)
self._trigger_duration_sp = _PV(
_vaca_prefix+trig_name+':Duration-SP',
connection_timeout=0.05)
self._trigger_duration_rb = _PV(
_vaca_prefix+trig_name+':Duration-RB',
callback=self._callback_timing_state, connection_timeout=0.05)
self._trigger_delay_sp = _PV(
_vaca_prefix+trig_name+':Delay-SP', connection_timeout=0.05)
self._trigger_delay_rb = _PV(
_vaca_prefix+trig_name+':Delay-RB',
callback=self._callback_timing_state, connection_timeout=0.05)
evg = _LLTimeSearch.get_evg_name()
self._event_mode_sel = _PV(
_vaca_prefix+evg+':'+evt_name+'Mode-Sel',
connection_timeout=0.05)
self._event_mode_sts = _PV(
_vaca_prefix+evg+':'+evt_name+'Mode-Sts',
callback=self._callback_timing_state, connection_timeout=0.05)
self._event_delaytype_sel = _PV(
_vaca_prefix+evg+':'+evt_name+'DelayType-Sel',
connection_timeout=0.05)
self._event_delaytype_sts = _PV(
_vaca_prefix+evg+':'+evt_name+'DelayType-Sts',
callback=self._callback_timing_state, connection_timeout=0.05)
self._event_delay_sp = _PV(
_vaca_prefix+evg+':'+evt_name+'Delay-SP',
connection_timeout=0.05)
self._event_delay_rb = _PV(
_vaca_prefix+evg+':'+evt_name+'Delay-RB',
callback=self._callback_timing_state, connection_timeout=0.05)
self._event_exttrig_cmd = _PV(
_vaca_prefix+evg+':'+evt_name+'ExtTrig-Cmd',
connection_timeout=0.05)
# Connect to CurrInfo
self._storedebeam_pv = _PV(
_vaca_prefix+'SI-Glob:AP-CurrInfo:StoredEBeam-Mon',
callback=self._callback_get_storedebeam,
connection_timeout=0.05)
# Connect to Tunes
self._tune_x_pv = _PV(
_vaca_prefix+'SI-Glob:DI-Tune-H:TuneFrac-Mon',
connection_timeout=0.05)
self._tune_y_pv = _PV(
_vaca_prefix+'SI-Glob:DI-Tune-V:TuneFrac-Mon',
connection_timeout=0.05)
# Create map of pv -> write function
self.map_pv2write = {
'ApplyDelta-Cmd': self.cmd_apply_corr,
'ConfigName-SP': self.set_config_name,
'CorrMeth-Sel': self.set_corr_meth,
'CorrGroup-Sel': self.set_corr_group,
'SyncCorr-Sel': self.set_sync_corr,
'ConfigPS-Cmd': self.cmd_config_ps,
'ConfigTiming-Cmd': self.cmd_config_ti,
'MeasConfigWait-SP': self.set_meas_config_wait,
'MeasConfig-Cmd': self.cmd_meas_config,
'MeasConfigName-SP': self.set_meas_config_name,
'MeasConfigSave-Cmd': self.cmd_meas_config_save,
}
def __init__(self, tl, corrs_type):
"""Class constructor."""
super().__init__()
self._pvs_database = _get_database(tl, corrs_type)
# consts
self._TL = tl.upper()
self._CORRSTYPE = corrs_type
if self._TL == 'TS':
corrh = (_PAConst.TS_CORRH_POSANG_CHSEPT if self._CORRSTYPE
== 'ch-sept' else _PAConst.TS_CORRH_POSANG_SEPTSEPT)
corrv = _PAConst.TS_CORRV_POSANG
elif self._TL == 'TB':
corrh = _PAConst.TB_CORRH_POSANG
corrv = _PAConst.TB_CORRV_POSANG
self._status = _ALLSET
self._ref_check_update = _PAConst.NeedRefUpdate.NeedUpdate
self._orbx_deltapos = 0
self._orby_deltapos = 0
self._orbx_deltaang = 0
self._orby_deltaang = 0
self._setnewrefkick_cmd_count = 0
self._config_ps_cmd_count = 0
self.cn_handler = _HandleConfigNameFile(self._TL, self._CORRSTYPE)
self.cdb_client = _ConfigDBClient(config_type=self._TL.lower() +
'_posang_respm')
[done, corrparams] = self._get_corrparams()
if done:
self._config_name = corrparams[0]
self._respmat_x = corrparams[1]
self._respmat_y = corrparams[2]
else:
raise Exception(
"Could not read correction parameters from configdb.")
self._correctors = dict()
self._correctors['CH1'] = _SiriusPVName(corrh[0])
self._correctors['CH2'] = _SiriusPVName(corrh[1])
if len(corrh) == 3:
self._correctors['CH3'] = _SiriusPVName(corrh[2])
self._correctors['CV1'] = _SiriusPVName(corrv[0])
self._correctors['CV2'] = _SiriusPVName(corrv[1])
if len(corrv) == 4:
self._correctors['CV3'] = _SiriusPVName(corrv[2])
self._correctors['CV4'] = _SiriusPVName(corrv[3])
self._corrs2id = {v: k for k, v in self._correctors.items()}
self._corr_check_connection = dict()
self._corr_check_pwrstate_sts = dict()
self._corr_check_opmode_sts = dict()
self._corr_check_ctrlmode_mon = dict()
# obs: ignore PU on OpMode and CtrlMode checks
for corr_id, corr in self._correctors.items():
self._corr_check_connection[corr_id] = 0
self._corr_check_pwrstate_sts[corr_id] = 0
if 'Sept' in corr.dev:
self._corr_check_opmode_sts[corr_id] = _PSC.States.SlowRef
self._corr_check_ctrlmode_mon[corr_id] = _PSC.Interface.Remote
else:
self._corr_check_opmode_sts[corr_id] = 1
self._corr_check_ctrlmode_mon[corr_id] = 1
# Connect to correctors
self._corr_kick_sp_pvs = dict()
self._corr_kick_rb_pvs = dict()
self._corr_pwrstate_sel_pvs = dict()
self._corr_pwrstate_sts_pvs = dict()
self._corr_opmode_sel_pvs = dict()
self._corr_opmode_sts_pvs = dict()
self._corr_ctrlmode_mon_pvs = dict()
self._corr_refkick = dict()
self._corr_unit_factor = dict()
self._corr_kick_rb_impl = dict()
self._corr_last_delta = dict()
for corr in self._correctors.values():
pss = corr.substitute(prefix=_vaca_prefix)
self._corr_kick_sp_pvs[corr] = _PV(pss.substitute(
propty_name='Kick', propty_suffix='SP'),
connection_timeout=0.05)
self._corr_refkick[corr] = 0
self._corr_last_delta[corr] = 0
self._corr_kick_rb_impl[corr] = 0
self._corr_kick_rb_pvs[corr] = _PV(
pss.substitute(propty_name='Kick', propty_suffix='RB'),
callback=[
self._callback_init_refkick, self._callback_corr_kick_rb
],
connection_callback=self._connection_callback_corr_kick_pvs,
connection_timeout=0.05)
self._corr_pwrstate_sel_pvs[corr] = _PV(pss.substitute(
propty_name='PwrState', propty_suffix='Sel'),
connection_timeout=0.05)
self._corr_pwrstate_sts_pvs[corr] = _PV(
pss.substitute(propty_name='PwrState', propty_suffix='Sts'),
callback=self._callback_corr_pwrstate_sts,
connection_timeout=0.05)
if 'Sept' not in corr.dev:
self._corr_opmode_sel_pvs[corr] = _PV(pss.substitute(
propty_name='OpMode', propty_suffix='Sel'),
connection_timeout=0.05)
self._corr_opmode_sts_pvs[corr] = _PV(
pss.substitute(propty_name='OpMode', propty_suffix='Sts'),
callback=self._callback_corr_opmode_sts,
connection_timeout=0.05)
self._corr_ctrlmode_mon_pvs[corr] = _PV(
pss.substitute(propty_name='CtrlMode',
propty_suffix='Mon'),
callback=self._callback_corr_ctrlmode_mon,
connection_timeout=0.05)
self._corr_unit_factor[corr] = 1e-6 # urad to rad
else:
self._corr_unit_factor[corr] = 1e-3 # mrad to rad
def __init__(self,
cyclers=dict(),
timing=None,
is_bo=False,
ramp_config=None,
logger=None):
"""Initialize."""
self._mode = None
self._is_bo = is_bo
self._ramp_config = ramp_config
self._checks_result = dict()
self._aux_cyclers = dict()
# cyclers
self.cyclers = cyclers
self._sections = _get_sections(self.psnames)
self._only_linac = self._sections == [
'LI',
]
# timing connector
self._timing = timing if timing is not None else Timing()
self._triggers = _get_trigger_by_psname(self.psnames)
# egun pv
if 'LI-01:PS-Spect' in self.psnames:
self._pv_egun = _PV('LI-01:EG-TriggerPS:enablereal',
connection_timeout=0.05)
# cycle duration
duration = 0
for psname in self.psnames:
duration = max(duration,
self._cyclers[psname].cycle_duration(self._mode))
self._cycle_duration = duration
# task sizes
self.prepare_timing_size = 3
self.prepare_timing_max_duration = 10
self.prepare_ps_size = 2 * len(self.psnames) + 1
self.prepare_ps_max_duration = 20
self.cycle_size = (
2 + # check timing
len(self.psnames) + 3 + # check params
len(self.psnames) + # check opmode
2 + # set and check triggers enable
3 + round(self._cycle_duration) + # cycle
len(self.psnames) + # check final
len(self.psnames) + 2) # reset subsystems
self.cycle_max_duration = (
8 + # check timing
TIMEOUT_CHECK + # check params
2 * TIMEOUT_CHECK + # check opmode
6 + # set and check triggers enable
60 + # wait for timing trigger
round(self._cycle_duration) + # cycle
12 + # check final
5) # reset subsystems
if 'SI' in self._sections:
# trims psnames
trims = set(
_PSSearch.get_psnames({
'sec': 'SI',
'sub': '[0-2][0-9].*',
'dis': 'PS',
'dev': '(CH|CV|QS|QD.*|QF.*|Q[1-4])'
}))
cv2_c2 = set(
_PSSearch.get_psnames({
'sec': 'SI',
'sub': '[0-2][0-9]C2',
'dis': 'PS',
'dev': 'CV',
'idx': '2'
}))
qs_c2 = set(
_PSSearch.get_psnames({
'sec': 'SI',
'sub': '[0-2][0-9]C2',
'dis': 'PS',
'dev': 'QS'
}))
self.trims_psnames = list(trims - cv2_c2 - qs_c2)
# connect to trims
self.prepare_ps_size += len(self.psnames)
self.prepare_ps_max_duration += 2 * TIMEOUT_CHECK
# set and check currents to zero
self.prepare_ps_size += 2 * len(self.psnames)
self.prepare_ps_max_duration += TIMEOUT_CHECK_SI_CURRENTS
# logger
self._logger = logger
self._logger_message = ''
if not logger:
_log.basicConfig(format='%(asctime)s | %(message)s',
datefmt='%F %T',
level=_log.INFO,
stream=_sys.stdout)
def _select_experimental_setup(self):
"""."""
self.emittance_calculator.place = self._place
if self._place.lower().startswith('li'):
prof = 'LA-BI:PRF5'
self._image_source = _PV(prof + ':RAW:ArrayData')
self._width_source = _PV(prof + ':ROI:MaxSizeX_RBV',
callback=self._update_width)
self._coefx = _PV(prof + ':X:Gauss:Coef',
callback=self._update_coefx)
self._coefy = _PV(prof + ':Y:Gauss:Coef',
callback=self._update_coefy)
self.quad_I_sp = _PV('LI-01:PS-QF3:Current-SP')
self.quad_I_rb = _PV('LI-01:PS-QF3:Current-Mon')
elif self._place.lower().startswith('tb'):
self._image_source = _PV('TB-02:DI-Scrn-2:ImgData-Mon')
self._width_source = _PV('TB-02:DI-Scrn-2:ImgMaxWidth-Cte',
callback=self._update_width)
self._coefx = _PV('TB-02:DI-ScrnCam-2:ImgScaleFactorX-RB',
callback=self._update_coefx)
self._coefy = _PV('TB-02:DI-ScrnCam-2:ImgScaleFactorY-RB',
callback=self._update_coefy)
quad = self.emittance_calculator.quadname
self.quad_I_sp = _PV(quad + ':Current-SP')
self.quad_I_rb = _PV(quad + ':Current-RB')
def __init__(self, test_pos=None, comments='', mode=0, wtime=10):
"""Initizalizes the thread.
Args:
test_pos (list): list with the points to be scanned.
comments (str): test description.
mode (int): 0 for discrete mode;
1 for continuous mode;
2 for manual mode.
wtime (float): wainting time (in seconds) between two points.
"""
super().__init__()
self.setDaemon = True
self.name = "ThdTestAxis"
if test_pos is None:
self.test_pos = [-1, 1, 0]
else:
self.test_pos = test_pos
self.wtime = wtime
self.comments = comments
if mode in [0, 1, 2]:
self.mode = mode
else:
self.mode = 0
self.continuous_flag = False
self.manual_flag = False
self.acquire_flag = False
self.motorA = {
'ActualPos': _PV('und:AxisA:ActualPosition'),
'ActualSpd': _PV('und:AxisA:ActualVelocity'),
'Current': _PV('und:AxisA:OutputCurrent'),
'PosError': _PV('und:AxisA:PositionError'),
'Torque': _PV('und:AxisA:TorqueReference'),
'Status': _PV('und:AxisA:AxisStatus'),
'MotionStatus': _PV('und:AxisA:MotionStatus'),
'HomePos': _PV('und:AxisA:HomePos'),
'MovePos': _PV('und:AxisA:MovePos'),
'MoveFlag': _PV('und:AxisA:Move'),
'OvertravelN': _PV('und:OvertravelN1'),
'OvertravelP': _PV('und:OvertravelP1'),
'Moving': _PV('und:AxisA:MoveStatus'),
'ServoOn': _PV('und:AxisA:DriveEnableStatus'),
'BrakeOff': _PV('und:AxisA:BrakeStatus')
}
self.motorB = {
'ActualPos': _PV('und:AxisB:ActualPosition'),
'ActualSpd': _PV('und:AxisB:ActualVelocity'),
'Current': _PV('und:AxisB:OutputCurrent'),
'PosError': _PV('und:AxisB:PositionError'),
'Torque': _PV('und:AxisB:TorqueReference'),
'Status': _PV('und:AxisB:AxisStatus'),
'MotionStatus': _PV('und:AxisB:MotionStatus'),
'HomePos': _PV('und:AxisB:HomePos'),
'MovePos': _PV('und:AxisB:MovePos'),
'MoveFlag': _PV('und:AxisB:Move'),
'OvertravelN': _PV('und:OvertravelN2'),
'OvertravelP': _PV('und:OvertravelP2'),
'Moving': _PV('und:AxisB:MoveStatus'),
'ServoOn': _PV('und:AxisB:DriveEnableStatus'),
'BrakeOff': _PV('und:AxisB:BrakeStatus')
}
self.motorC = {
'ActualPos': _PV('und:AxisC:ActualPosition'),
'ActualSpd': _PV('und:AxisC:ActualVelocity'),
'Current': _PV('und:AxisC:OutputCurrent'),
'PosError': _PV('und:AxisC:PositionError'),
'Torque': _PV('und:AxisC:TorqueReference'),
'Status': _PV('und:AxisC:AxisStatus'),
'MotionStatus': _PV('und:AxisC:MotionStatus'),
'HomePos': _PV('und:AxisC:HomePos'),
'MovePos': _PV('und:AxisC:MovePos'),
'MoveFlag': _PV('und:AxisC:Move'),
'OvertravelN': _PV('und:OvertravelN3'),
'OvertravelP': _PV('und:OvertravelP3'),
'Moving': _PV('und:AxisC:MoveStatus'),
'ServoOn': _PV('und:AxisC:DriveEnableStatus'),
'BrakeOff': _PV('und:AxisC:BrakeStatus')
}
self.motorD = {
'ActualPos': _PV('und:AxisD:ActualPosition'),
'ActualSpd': _PV('und:AxisD:ActualVelocity'),
'Current': _PV('und:AxisD:OutputCurrent'),
'PosError': _PV('und:AxisD:PositionError'),
'Torque': _PV('und:AxisD:TorqueReference'),
'Status': _PV('und:AxisD:AxisStatus'),
'MotionStatus': _PV('und:AxisD:MotionStatus'),
'HomePos': _PV('und:AxisD:HomePos'),
'MovePos': _PV('und:AxisD:MovePos'),
'MoveFlag': _PV('und:AxisD:Move'),
'OvertravelN': _PV('und:OvertravelN4'),
'OvertravelP': _PV('und:OvertravelP4'),
'Moving': _PV('und:AxisD:MoveStatus'),
'ServoOn': _PV('und:AxisD:DriveEnableStatus'),
'BrakeOff': _PV('und:AxisD:BrakeStatus')
}
self.en_flags = {
'EnContactor': _PV('und:EnContactor'),
'EnClear': _PV('und:EnClear'),
'EnServo': _PV('und:EnServo'),
'DisServo': _PV('und:DisServo'),
'EnHome': _PV('und:EnHome'),
'EnCmsMode': _PV('und:EnCmsMode'),
'EnVIMode': _PV('und:EnVIMode'),
'EnHIMode': _PV('und:EnHIMode'),
'EnEPMode': _PV('und:EnEPMode'),
'EnLPMode': _PV('und:EnLPMode'),
'EnMove': _PV('und:EnMove'),
'EnCam': _PV('und:EnCam'),
'EnContactor': _PV('und:EnContactor'),
'EnCoupling': _PV('und:EnGeneralCoupling')
}
def __init__(self):
self.pv_hv_volt_sp = _PV('LI-01:EG-HVPS:voltoutsoft')
self.pv_hv_volt_rb = _PV('LI-01:EG-HVPS:voltinsoft')
self.pv_hv_curlim_sp = _PV('LI-01:EG-HVPS:currentoutsoft')
self.pv_hv_curleak_mon = _PV('LI-01:EG-HVPS:currentinsoft')
self.pv_hv_enbl_sp = _PV('LI-01:EG-HVPS:enable')
self.pv_hv_enbl_rb = _PV('LI-01:EG-HVPS:enstatus')
self.pv_hv_switch_sp = _PV('LI-01:EG-HVPS:switch')
self.pv_hv_switch_rb = _PV('LI-01:EG-HVPS:swstatus')
self.pv_fila_cur_sp = _PV('LI-01:EG-FilaPS:currentoutsoft')
self.pv_fila_cur_rb = _PV('LI-01:EG-FilaPS:currentinsoft')
self.pv_fila_volt_mon = _PV('LI-01:EG-FilaPS:voltinsoft')
self.pv_fila_switch_sp = _PV('LI-01:EG-FilaPS:switch')
self.pv_fila_switch_rb = _PV('LI-01:EG-FilaPS:swstatus')
self.pv_bias_volt_sp = _PV('LI-01:EG-BiasPS:voltoutsoft')
self.pv_bias_volt_rb = _PV('LI-01:EG-BiasPS:voltinsoft')
self.pv_bias_cur_mon = _PV('LI-01:EG-BiasPS:currentinsoft')
self.pv_bias_switch_sp = _PV('LI-01:EG-BiasPS:switch')
self.pv_bias_switch_rb = _PV('LI-01:EG-BiasPS:swstatus')
self.pv_pulse_power_sp = _PV('LI-01:EG-PulsePS:poweroutsoft')
self.pv_pulse_power_rb = _PV('LI-01:EG-PulsePS:powerinsoft')
self.pv_mult_sel_sp = _PV('LI-01:EG-PulsePS:multiselect')
self.pv_mult_sel_rb = _PV('LI-01:EG-PulsePS:multiselstatus')
self.pv_mult_swt_sp = _PV('LI-01:EG-PulsePS:multiswitch')
self.pv_mult_swt_rb = _PV('LI-01:EG-PulsePS:multiswstatus')
self.pv_sngl_sel_sp = _PV('LI-01:EG-PulsePS:singleselect')
self.pv_sngl_sel_rb = _PV('LI-01:EG-PulsePS:singleselstatus')
self.pv_sngl_swt_sp = _PV('LI-01:EG-PulsePS:singleswitch')
self.pv_sngl_swt_rb = _PV('LI-01:EG-PulsePS:singleswstatus')
self.pv_sys_start_sp = _PV('LI-01:EG-System:start')
self.pv_sys_valve_mon = _PV('LI-01:EG-Valve:status')
self.pv_sys_gate_mon = _PV('LI-01:EG-Gate:status')
self.pv_sys_vacuum_mon = _PV('LI-01:EG-Vacuum:status')
self.pv_trig_state_sp = _PV('LI-01:EG-TriggerPS:enable')
self.pv_trig_state_rb = _PV('LI-01:EG-TriggerPS:status')
self.pv_trig_allow_mon = _PV('LI-01:EG-TriggerPS:allow')
self.pv_mps_permit = _PV('LA-CN:H1MPS-1:GunPermit')
self.pv_vacuum_ccg1 = _PV('LA-VA:H1VGC-01:RdPrs-1')
self.names = ['LA-CN:H1MPS-1:CCG1', 'LA-CN:H1MPS-1:CCG2']
self.pvs_mps_resets = []
self.pvs_mps_status_raw = []
self.pvs_mps_status_proc = []
for name in self.names:
self.pvs_mps_resets.append(_PV(name + 'Warn_R'))
self.pvs_mps_status_raw.append(_PV(name + 'Warn_I'))
self.pvs_mps_status_proc.append(_PV(name + 'Warn_L'))
self.opmode = self.MULTIBUNCH
self.goal_volt = 0.0
self.goal_pressure = 1.0e-9
self.fila_curr = 0.0
self._fila_ramp_dur = 10 # min
self.bias_volt = -60
self.leak_curr = 0.0
self.beam_pulse = True
self.fila_ishot = False
self.total_duration = -1
self._stop_running = False
self._thread = _Thread(target=self._set_stop, daemon=True)
self._thread.start()
def _create_pvs(self):
pvs = dict()
for psname in self.psnames:
pvs[psname] = _PV(
psname + ':Wfm-SP', connection_timeout=TIMEOUT_CONN)
BONormListFactory._PVs = pvs
