def get_map2write(self):
"""."""
return {
'Dispersion-SP': _part(self.write, 'dispersion'),
'Angle-SP': _part(self.write, 'angle'),
'Spectrometer-SP': _part(self.write, 'spectrometer'),
}
def _prepare_ps(self):
tasks = [None] * 3
tasks[0] = _CommandThread(
parent=self,
conn=self.conn_ti,
cmds=_part(self.conn_ti.cmd_set_magnet_trigger_state,
_TIc.DsblEnbl.Dsbl),
warn_msgs='Failed to turn magnets trigger off!')
tasks[1] = _CommandThread(
parent=self,
conn=self.conn_ps,
use_log=True,
cmds=self.conn_ps.cmd_opmode_rmpwfm,
warn_msgs='Failed to set PS OpMode to RmpWfm!')
tasks[2] = _CommandThread(
parent=self,
conn=self.conn_ti,
cmds=_part(self.conn_ti.cmd_set_magnet_trigger_state,
_TIc.DsblEnbl.Enbl),
warn_msgs='Failed to turn magnets trigger on!')
labels = [
'Turning magnets trigger off...',
'Setting power supplies OpMode to RmpWfm...',
'Turning magnets trigger on...'
]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def get_map2write(self):
"""."""
dic_ = self.image_processor.get_map2write()
dic_.update({
'MeasureCtrl-Sel': _part(self.write, 'measuring'),
'MeasureRate-SP': _part(self.write, 'rate'),
})
return dic_
def get_map2read(self):
"""."""
dic_ = self.image_processor.get_map2read()
dic_.update({
'MeasureCtrl-Sts': _part(self.read, 'measuring'),
'MeasureRate-RB': _part(self.read, 'rate'),
})
return dic_
def uigetgraph(self, pln, size):
"""."""
graph = Graph(self)
graph.doubleclick.connect(_part(self._set_enable_list, pln))
graph.plotItem.scene().sigMouseMoved.connect(
_part(self._show_tooltip, pln=pln))
if self.is_orb:
xlabel = 'BPM '
elif pln.lower().endswith('x'):
xlabel = 'CH '
else:
xlabel = 'CV '
xlabel += 'Position'
graph.setLabel('bottom', text=xlabel, units='m')
lab = 'Orbit' if self.is_orb else 'Kick Angle'
unit = 'm' if self.is_orb else 'rad'
graph.setLabel('left', text=lab, units=unit)
graph.setObjectName(lab.replace(' ', '') + pln)
for i, lname in enumerate(self.line_names):
opts = dict(y_channel='A',
x_channel='B',
name=lname,
color=self._get_color(pln, i),
redraw_mode=2,
lineStyle=1,
lineWidth=2 if i else 3,
symbol='o',
symbolSize=10)
graph.addChannel(**opts)
pen = mkPen(opts['color'], width=opts['lineWidth'])
pen.setStyle(4)
cpstd = InfiniteLine(pos=0.0, pen=pen, angle=0)
self.updater[i].ave_pstd[pln].connect(cpstd.setValue)
graph.addItem(cpstd)
cmstd = InfiniteLine(pos=0.0, pen=pen, angle=0)
self.updater[i].ave_mstd[pln].connect(cmstd.setValue)
graph.addItem(cmstd)
pen.setStyle(2)
cave = InfiniteLine(pos=0.0, pen=pen, angle=0)
self.updater[i].ave[pln].connect(cave.setValue)
graph.addItem(cave)
cdta = graph.curveAtIndex(-1)
self.updater[i].data_sig[pln].connect(
_part(self._update_waveform, cdta, pln, i))
cdta.setVisible(not i)
cdta.curve.setZValue(-4 * i)
cdta.scatter.setZValue(-4 * i)
for j, cur in enumerate((cpstd, cmstd, cave), 1):
cur.setZValue(-4 * i - j)
cur.setVisible(False)
graph.plotItem.legend.removeItem('')
graph.setStyleSheet("""
#{0}{{
min-width:{1}em;
min-height:{2}em;
}}""".format(lab.replace(' ', '') + pln, size[0], size[1]))
return graph
def get_map2write(self):
"""."""
dic_ = self.image_processor.get_map2write()
dic_.update({
'ApplyBump-Cmd': self.cmd_apply_bump,
'MeasureCtrl-Sel': _part(self.write, 'measuring'),
'MeasureRate-SP': _part(self.write, 'rate'),
'TargetPosX-SP': _part(self.write, 'target_posx'),
'TargetPosY-SP': _part(self.write, 'target_posy'),
})
return dic_
def __init__(self, ctrls, is_orb, acc='SI'):
"""Initialize object."""
super().__init__()
self.ctrls = ctrls
self.acc = acc
self._csorb = SOFBFactory.create(acc)
self.is_orb = is_orb
self._isvisible = True
text = sorted(ctrls)[0]
self.current_text = {'val': text, 'ref': text}
self.ave = {'x': self.avex, 'y': self.avey}
self.p2p = {'x': self.p2px, 'y': self.p2py}
self.std = {'x': self.stdx, 'y': self.stdy}
self.ave_pstd = {'x': self.ave_pstdx, 'y': self.ave_pstdy}
self.ave_mstd = {'x': self.ave_mstdx, 'y': self.ave_mstdy}
self.data_sig = {'x': self.data_sigx, 'y': self.data_sigy}
self.raw_ref_sig = {'x': self.ref_sigx, 'y': self.ref_sigy}
self.slots = {
'val': {
'x': _part(self._update_vectors, 'val', 'x'),
'y': _part(self._update_vectors, 'val', 'y')
},
'ref': {
'x': _part(self._update_vectors, 'ref', 'x'),
'y': _part(self._update_vectors, 'ref', 'y')
}
}
nbpms = self._csorb.nr_bpms * self._csorb.MAX_RINGSZ
szx = nbpms if self.is_orb else self._csorb.nr_ch
szy = nbpms if self.is_orb else self._csorb.nr_cv
self.vectors = {
'val': {
'x': _np.zeros(szx, dtype=float),
'y': _np.zeros(szy, dtype=float)
},
'ref': {
'x': _np.zeros(szx, dtype=float),
'y': _np.zeros(szy, dtype=float)
}
}
self.enbl_list = {
'x': _np.ones(szx, dtype=bool),
'y': _np.ones(szy, dtype=bool)
}
sig_x = self.ctrls[self.current_text['ref']]['x']['signal']
sig_y = self.ctrls[self.current_text['ref']]['y']['signal']
sig_x[_np.ndarray].connect(self.slots['ref']['x'])
sig_y[_np.ndarray].connect(self.slots['ref']['y'])
sig_x = self.ctrls[self.current_text['val']]['x']['signal']
sig_y = self.ctrls[self.current_text['val']]['y']['signal']
sig_x[_np.ndarray].connect(self.slots['val']['x'])
sig_y[_np.ndarray].connect(self.slots['val']['y'])
def get_map2write(self):
"""Get the write methods of the class."""
dbase = {
'SOFBMode-Sel': self.set_orbit_mode,
'SyncWithInjection-Sel': self.set_sync_with_injection,
'TrigAcqConfig-Cmd': self.acq_config_bpms,
'TrigAcqCtrl-Sel': self.set_trig_acq_control,
'TrigAcqChan-Sel': self.set_trig_acq_channel,
'TrigDataChan-Sel': self.set_trig_acq_datachan,
'TrigAcqTrigger-Sel': self.set_trig_acq_trigger,
'TrigAcqRepeat-Sel': self.set_trig_acq_repeat,
'TrigDataSel-Sel': self.set_trig_acq_datasel,
'TrigDataThres-SP': self.set_trig_acq_datathres,
'TrigDataHyst-SP': self.set_trig_acq_datahyst,
'TrigDataPol-Sel': self.set_trig_acq_datapol,
'TrigNrSamplesPre-SP': _part(self.set_acq_nrsamples, ispost=False),
'TrigNrSamplesPost-SP': _part(self.set_acq_nrsamples, ispost=True),
'RefOrbX-SP': _part(self.set_reforb, 'X'),
'RefOrbY-SP': _part(self.set_reforb, 'Y'),
'OfflineOrbX-SP': _part(self.set_offlineorb, 'X'),
'OfflineOrbY-SP': _part(self.set_offlineorb, 'Y'),
'SmoothNrPts-SP': self.set_smooth_npts,
'SmoothMethod-Sel': self.set_smooth_method,
'SmoothReset-Cmd': self.set_smooth_reset,
'SPassMaskSplBeg-SP': _part(self.set_spass_mask, beg=True),
'SPassMaskSplEnd-SP': _part(self.set_spass_mask, beg=False),
'SPassBgCtrl-Cmd': self.set_spass_bg,
'SPassUseBg-Sel': self.set_spass_usebg,
'SPassAvgNrTurns-SP': self.set_spass_average,
'OrbAcqRate-SP': self.set_orbit_acq_rate,
'TrigNrShots-SP': self.set_trig_acq_nrshots,
'PolyCalibration-Sel': self.set_poly_calibration,
}
if not self.isring:
return dbase
dbase.update({
'MTurnAcquire-Cmd':
self.acquire_mturn_orbit,
'MTurnIdx-SP':
self.set_orbit_multiturn_idx,
'MTurnDownSample-SP':
self.set_mturndownsample,
'MTurnSyncTim-Sel':
self.set_mturn_sync,
'MTurnUseMask-Sel':
self.set_mturn_usemask,
'MTurnMaskSplBeg-SP':
_part(self.set_mturnmask, beg=True),
'MTurnMaskSplEnd-SP':
_part(self.set_mturnmask, beg=False),
})
return dbase
def get_map2write(self):
"""Get the write methods of the class."""
dbase = {
'RespMat-SP': self.set_respmat,
'CHEnblList-SP': _part(self.set_enbllist, 'ch'),
'CVEnblList-SP': _part(self.set_enbllist, 'cv'),
'BPMXEnblList-SP': _part(self.set_enbllist, 'bpmx'),
'BPMYEnblList-SP': _part(self.set_enbllist, 'bpmy'),
'NrSingValues-SP': self.set_num_sing_values,
}
if self.acc == 'SI':
dbase['RFEnbl-Sel'] = _part(self.set_enbllist, 'rf')
return dbase
def contextMenuEvent(self, event):
"""Implement context menu to add auxiliary actions."""
pos = self.mapToGlobal(event.pos())
if not self.pannel.underMouse():
return
menu = QMenu(self)
show = menu.addAction('Show all curves')
show.triggered.connect(_part(self._set_checkbox_state, True))
hide = menu.addAction('Hide all curves')
hide.triggered.connect(_part(self._set_checkbox_state, False))
conn = menu.addAction('Show Connections...')
conn.triggered.connect(self._show_connections)
menu.popup(pos)
def get_map2write(self):
"""Get the write methods of the class."""
dbase = {
'RespMat-SP': self.set_respmat,
'CHEnblList-SP': _part(self.set_enbllist, 'ch'),
'CVEnblList-SP': _part(self.set_enbllist, 'cv'),
'BPMXEnblList-SP': _part(self.set_enbllist, 'bpmx'),
'BPMYEnblList-SP': _part(self.set_enbllist, 'bpmy'),
'MinSingValue-SP': self.set_min_sing_value,
'TikhonovRegConst-SP': self.set_tikhonov_reg_const,
}
if self.acc == 'SI':
dbase['RFEnbl-Sel'] = _part(self.set_enbllist, 'rf')
return dbase
def __init__(self, parent, sigs, device, prefix, csorb):
"""."""
super().__init__(parent)
self._csorb = csorb
self.prefix = prefix
self.device = _PVName(device)
self.devpref = self.device.substitute(prefix=prefix)
self.setObjectName(csorb.acc + 'App')
self.setupui()
self.sigs = sigs
self.fun2setref = {
'x': _part(self.setreforbits, 'x'),
'y': _part(self.setreforbits, 'y')
}
def setupui(self):
vbl = QVBoxLayout(self)
self.stack = QStackedWidget(self)
vbl.addWidget(self.stack)
rbA = QRadioButton('Antennas', self)
rbP = QRadioButton('Positions', self)
rbA.toggled.connect(_part(self.toggle_button, 0))
rbP.toggled.connect(_part(self.toggle_button, 1))
self.radio_buttons.append(rbA)
self.radio_buttons.append(rbP)
rbA.setChecked(True)
hbl = QHBoxLayout()
hbl.addStretch()
hbl.addWidget(rbA)
hbl.addStretch()
hbl.addWidget(rbP)
hbl.addStretch()
vbl.addItem(hbl)
# ##### Antennas Widget ######
stack1 = QWidget(self.stack)
self.stack.addWidget(stack1)
vbl = QVBoxLayout(stack1)
graph = self.create_graph(stack1, 'ant')
vbl.addWidget(graph)
stats = self.create_statistics(stack1, 'ant')
vbl.addWidget(stats)
# ##### Position and Amplitudes Widget ######
stack2 = QWidget(self.stack)
self.stack.addWidget(stack2)
vbl = QVBoxLayout(stack2)
graph = self.create_graph(stack2, 'pos')
vbl.addWidget(graph)
graph = self.create_graph(stack2, 'amp')
vbl.addWidget(graph)
self.setStyleSheet("""
#SinglePassDataGraph{
min-width:48em;
min-height:24em;
}
QLabel{
min-width:6em; max-width:6em;
min-height:1.5em; max-height:1.5em;
}""")
def _set_check_pwrstate(self, dev_type, state, show=True):
self.ok_ps.clear()
self.nok_ps.clear()
if isinstance(dev_type, list):
devices = list(dev_type)
dev_type = devices[0].dis
else:
if dev_type == 'PS':
devices = self._get_selected_ps()
elif dev_type == 'PU':
devices = self._get_selected_pu()
if not devices:
return
if state == 'on' and dev_type == 'PS':
dev2ctrl = list(set(devices) - set(self._si_fam_psnames))
else:
dev2ctrl = devices
task0 = CreateTesters(devices, parent=self)
task1 = SetPwrState(dev2ctrl, state=state, parent=self)
task2 = CheckPwrState(devices, state=state, is_test=True, parent=self)
task2.itemDone.connect(_part(self._log, show=show))
tasks = [task0, task1, task2]
labels = [
'Connecting to devices...',
'Turning ' + dev_type + ' ' + state + '...',
'Checking ' + dev_type + ' powered ' + state + '...'
]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def __init__(self,
parent=None,
pslist=[],
name='',
delta=0.0,
idxini=0,
idxfin=4000,
legend=False):
super().__init__(parent)
self._pvslist = pslist
self.name = name
self._legend = legend
self._idx_ini = idxini
self._idx_fin = idxfin
self._delta = delta
self.curves = []
self.setupui()
self.setFocus(True)
self.setFocusPolicy(Qt.StrongFocus)
self.chans = [
_ConnSig(
_PVName(ps).substitute(prefix=_VACA_PREFIX, propty='Wfm-Mon'))
for ps in pslist
]
for idx, chan in enumerate(self.chans):
chan.new_value_signal[_np.ndarray].connect(
_part(self._update_curve, idx))
def _check_pwrstate(self, devices, state, is_test=True, show=True):
self.ok_ps.clear()
self.nok_ps.clear()
task0 = CreateTesters(devices, parent=self)
if state == 'offintlk':
text = 'off or interlock'
task1 = CheckOpMode(devices,
state=[_PSC.States.Off, _PSC.States.Interlock],
parent=self)
else:
text = state
task1 = CheckPwrState(devices,
state=state,
is_test=is_test,
parent=self)
task1.itemDone.connect(_part(self._log, show=show))
tasks = [task0, task1]
labels = [
'Connecting to devices...',
'Checking devices powered ' + text + '...'
]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def get_map2read(self):
"""."""
database = dict()
dic_ = self.image_processor.get_map2read()
dic_.update(self.emittance_calculator.get_map2read())
dic_.update({'MeasureCtrl-Sts': _part(self.read, 'measuring')})
return {k: v for k, v in dic_.items() if k in database}
def get_map2read(self):
"""."""
dic_ = self.image_processor.get_map2read()
dic_.update({
'MeasureCtrl-Sts': _part(self.read, 'measuring'),
'MeasureRate-RB': _part(self.read, 'rate'),
'TargetPosX-RB': _part(self.read, 'target_posx'),
'TargetPosY-RB': _part(self.read, 'target_posy'),
'NeededDeltaBumpX-Mon': _part(self.read, 'needed_dbumpx'),
'NeededDeltaBumpY-Mon': _part(self.read, 'needed_dbumpy'),
'AppliedBumpX-Mon': _part(self.read, 'applied_bumpx'),
'AppliedBumpY-Mon': _part(self.read, 'applied_bumpy'),
'ApplyStatus-Mon': _part(self.read, 'apply_status'),
})
return dic_
def __init__(self,
parent,
device,
ctrls,
names,
is_orb,
prefix='',
acc='SI'):
"""."""
super(BaseWidget, self).__init__(parent)
self.setObjectName(acc.upper() + 'App')
self.EXT = f'.{acc.lower()}dorb'
self.EXT_FLT = f'Sirius Delta Orbit Files (*.{acc.lower()}dorb)'
self.line_names = names
self.prefix = prefix
self.device = _PVName(device)
self.devpref = self.device.substitute(prefix=prefix)
self.controls = ctrls
self._csorb = SOFBFactory.create(acc)
self.update_rate = 2.1 # Hz
self.last_dir = self.DEFAULT_DIR
self.is_orb = is_orb
self.timer = QTimer()
self.thread = QThread()
self.updater = []
self.graph = {'x': None, 'y': None}
for _ in range(2):
upd = UpdateGraph(ctrls, is_orb, acc)
upd.moveToThread(self.thread)
self.timer.timeout.connect(upd.update_graphic)
self.updater.append(upd)
self.setupui()
self.connect_signals()
prefx, prefy = ('BPMX', 'BPMY') if self.is_orb else ('CH', 'CV')
self.enbl_pvs = {
'x':
_ConnSig(self.devpref.substitute(propty=prefx + 'EnblList-RB')),
'y':
_ConnSig(self.devpref.substitute(propty=prefy + 'EnblList-RB'))
}
for pln, signal in self.enbl_pvs.items():
sig = signal.new_value_signal[_np.ndarray]
for upd in self.updater:
sig.connect(_part(upd.set_enbl_list, pln))
self.enbl_pvs_set = {
'x':
_ConnSig(self.devpref.substitute(propty=prefx + 'EnblList-SP')),
'y':
_ConnSig(self.devpref.substitute(propty=prefy + 'EnblList-SP'))
}
self.thread.start()
self.timer.start(1000 / self.update_rate)
def add_marker(
self, xchannel, ychannel, name,
color=QColor('blue'), symbol='o', symbolSize=10):
"""."""
self.addChannel(
x_channel='FAKE:X', y_channel='FAKE:Y',
name=name, color=color,
lineStyle=Qt.NoPen, lineWidth=1,
symbol=symbol, symbolSize=symbolSize)
curve = self.curveAtIndex(-1)
curve.opts['symbolBrush'] = mkBrush(color)
x_chan_obj = SiriusConnectionSignal(xchannel)
x_chan_obj.new_value_signal[float].connect(
_part(self._update_marker_value, curve, 'X'))
y_chan_obj = SiriusConnectionSignal(ychannel)
y_chan_obj.new_value_signal[float].connect(
_part(self._update_marker_value, curve, 'Y'))
self._markers[name] = [(x_chan_obj, y_chan_obj), curve]
def _open_matrix_sel(self):
wid = QDialog(self)
wid.setObjectName(self._csorb.acc + 'App')
wid.setLayout(QVBoxLayout())
cbbox = QComboBox(wid)
cbbox.setEditable(True)
cbbox.setMaxVisibleItems(10)
corrnames = self._csorb.ch_names + self._csorb.cv_names
if self._csorb.acc in {'SI', 'BO'}:
corrnames.append('RF')
cbbox.addItems(corrnames)
wid.layout().addWidget(QLabel('Choose the corrector:', wid))
wid.layout().addWidget(cbbox)
ledit = QDoubleSpinBoxPlus(wid)
ledit.setMinimum(float('-inf'))
ledit.setMaximum(float('inf'))
ledit.setValue(1.0)
wid.layout().addWidget(QLabel('Choose the Kick [urad]:', wid))
wid.layout().addWidget(ledit)
ledit.valueChanged.connect(_part(self._accept_mat_sel, ledit, cbbox))
cbbox.currentIndexChanged.connect(
_part(self._accept_mat_sel, ledit, cbbox))
hlay = QHBoxLayout()
cancel = QPushButton('Cancel', wid)
confirm = QPushButton('Ok', wid)
cancel.clicked.connect(wid.reject)
confirm.clicked.connect(wid.accept)
confirm.clicked.connect(_part(self._accept_mat_sel, ledit, cbbox))
confirm.setDefault(True)
hlay.addStretch()
hlay.addWidget(cancel)
hlay.addStretch()
hlay.addWidget(confirm)
hlay.addStretch()
wid.layout().addItem(hlay)
res = wid.exec_()
if res != QDialog.Accepted:
self._reset_orbit()
def _setupChromWidget(self):
for cord in ['X', 'Y']:
setattr(self, 'label_Chrom'+cord,
QLabel('ξ<sub>'+cord+'</sub>: '))
lab = getattr(self, 'label_Chrom'+cord)
lab.setStyleSheet("min-width:1.55em; max-width:1.55em;")
setattr(self, 'sb_Chrom'+cord, QDoubleSpinBoxPlus(self))
sb = getattr(self, 'sb_Chrom'+cord)
sb.setDecimals(6)
sb.setMinimum(-5)
sb.setMaximum(5)
sb.setSingleStep(0.0001)
sb.setObjectName('chrom'+cord)
sb.setValue(self._deltas['chrom'+cord])
sb.editingFinished.connect(self._handleChromSet)
label_SL = QLabel('<h4>ΔSL [1/m<sup>2</sup>]</h4>', self)
label_SL.setStyleSheet("""min-height:1.55em; max-height:1.55em;
qproperty-alignment: AlignCenter;""")
self.l_deltaSLSF = QLabel('', self)
self.l_deltaSLSD = QLabel('', self)
self.bt_update_ref_deltaSL = QPushButton('Update reference', self)
self.bt_update_ref_deltaSL.clicked.connect(
_part(self._updateReference, 'sexts'))
gbox = QGroupBox('Chromaticity', self)
lay = QGridLayout()
lay.addWidget(self.label_ChromX, 1, 0)
lay.addWidget(self.sb_ChromX, 1, 1)
lay.addWidget(self.label_ChromY, 1, 3)
lay.addWidget(self.sb_ChromY, 1, 4)
lay.addWidget(label_SL, 3, 0, 1, 5)
lay.addWidget(QLabel('SF: '), 4, 0)
lay.addWidget(self.l_deltaSLSF, 4, 1)
lay.addWidget(QLabel('SD: '), 4, 3)
lay.addWidget(self.l_deltaSLSD, 4, 4)
lay.addWidget(self.bt_update_ref_deltaSL, 6, 3, 1, 2)
lay.setVerticalSpacing(6)
lay.setColumnStretch(0, 2)
lay.setColumnStretch(1, 4)
lay.setColumnStretch(2, 1)
lay.setColumnStretch(3, 2)
lay.setColumnStretch(4, 4)
lay.setRowStretch(0, 1)
lay.setRowStretch(1, 2)
lay.setRowStretch(2, 1)
lay.setRowStretch(3, 2)
lay.setRowStretch(4, 2)
lay.setRowStretch(5, 1)
lay.setRowStretch(6, 2)
gbox.setLayout(lay)
return gbox
def _apply_ps(self, psnames=list(), dialog_parent=None):
if dialog_parent is None:
dialog_parent = self
task = _CommandThread(parent=self,
conn=self.conn_ps,
use_log=True,
size=len(psnames),
cmds=_part(self.conn_ps.cmd_wfm, psnames),
warn_msgs='Failed to set waveform!')
dlg = ProgressDialog('Setting magnets waveforms...', task,
dialog_parent)
dlg.exec_()
def _setupTuneWidget(self):
for cord in ['X', 'Y']:
setattr(self, 'label_deltaTune'+cord,
QLabel('Δν<sub>'+cord+'</sub>: '))
lab = getattr(self, 'label_deltaTune'+cord)
lab.setStyleSheet("min-width:1.55em; max-width:1.55em;")
setattr(self, 'sb_deltaTune'+cord, QDoubleSpinBoxPlus(self))
sb = getattr(self, 'sb_deltaTune'+cord)
sb.setDecimals(6)
sb.setMinimum(-5)
sb.setMaximum(5)
sb.setSingleStep(0.0001)
sb.setObjectName('tune'+cord)
sb.editingFinished.connect(self._handleDeltaTuneSet)
label_KL = QLabel('<h4>ΔKL [1/m]</h4>', self)
label_KL.setStyleSheet("""min-height:1.55em; max-height:1.55em;
qproperty-alignment: AlignCenter;""")
self.l_deltaKLQF = QLabel('', self)
self.l_deltaKLQD = QLabel('', self)
self.bt_update_ref_deltaKL = QPushButton('Update reference', self)
self.bt_update_ref_deltaKL.clicked.connect(
_part(self._updateReference, 'quads'))
gbox = QGroupBox('Tune', self)
lay = QGridLayout()
lay.addWidget(self.label_deltaTuneX, 1, 0)
lay.addWidget(self.sb_deltaTuneX, 1, 1)
lay.addWidget(self.label_deltaTuneY, 1, 3)
lay.addWidget(self.sb_deltaTuneY, 1, 4)
lay.addWidget(label_KL, 3, 0, 1, 5)
lay.addWidget(QLabel('QF: '), 4, 0)
lay.addWidget(self.l_deltaKLQF, 4, 1)
lay.addWidget(QLabel('QD: '), 4, 3)
lay.addWidget(self.l_deltaKLQD, 4, 4)
lay.addWidget(self.bt_update_ref_deltaKL, 6, 3, 1, 2)
lay.setVerticalSpacing(6)
lay.setColumnStretch(0, 2)
lay.setColumnStretch(1, 4)
lay.setColumnStretch(2, 1)
lay.setColumnStretch(3, 2)
lay.setColumnStretch(4, 4)
lay.setRowStretch(0, 1)
lay.setRowStretch(1, 2)
lay.setRowStretch(2, 1)
lay.setRowStretch(3, 2)
lay.setRowStretch(4, 2)
lay.setRowStretch(5, 1)
lay.setRowStretch(6, 2)
gbox.setLayout(lay)
return gbox
def connect_newprocess(widget,
cmd,
is_window=True,
parent=None,
signal=None,
is_pydm=False,
**kwargs):
"""Execute a child program in a new process."""
signal = signal or get_appropriate_signal(widget)
signal.connect(lambda: run_newprocess(cmd, is_pydm=is_pydm, **kwargs))
if is_window:
signal.connect(_part(_show_loading_message, parent, cmd, is_pydm))
def add_scatter_curve(
self, ychannel='', xchannel='', name='', color=QColor('blue'),
lineStyle=Qt.NoPen, lineWidth=1, symbolSize=10, nchannel=None,
offset=None):
"""."""
self.addChannel(
x_channel='', y_channel='',
name=name, color=color, lineStyle=lineStyle, lineWidth=lineWidth,
symbol='o', symbolSize=symbolSize)
curve = self.curveAtIndex(-1)
curve.opts['symbolBrush'] = mkBrush(color)
curve.nchannel = None
curve.offset = offset
if nchannel is not None:
curve.nchannel = SiriusConnectionSignal(nchannel)
x_chan_obj = SiriusConnectionSignal(xchannel)
x_chan_obj.new_value_signal[np.ndarray].connect(
_part(self._update_waveform_value, curve, 'X'))
y_chan_obj = SiriusConnectionSignal(ychannel)
y_chan_obj.new_value_signal[np.ndarray].connect(
_part(self._update_waveform_value, curve, 'Y'))
self._curves_names.append(((x_chan_obj, y_chan_obj), curve))
def __init__(self, parent, ctrls, setpoint=None, readback=None, acc='SI'):
"""."""
QComboBox.__init__(self, parent)
PyDMPrimitiveWidget.__init__(self)
self.setpoint = setpoint or dict()
self.readback = readback or dict()
self.ctrls = ctrls
self._csorb = SOFBFactory.create(acc)
self._config_type = acc.lower() + '_orbit'
self._client = ConfigDBClient(config_type=self._config_type)
self.orbits = {
'x': _np.zeros(self._csorb.nr_bpms, dtype=float),
'y': _np.zeros(self._csorb.nr_bpms, dtype=float)
}
self.signals_to_watch = dict()
self.slots = {
'x': _part(self._watch_if_changed, 'x'),
'y': _part(self._watch_if_changed, 'y')
}
self.setup_ui()
self.connect_signals()
def uicreate_combobox(self, parent, orb_tp, idx):
"""."""
combo = QComboBox(parent)
combo.setObjectName('ComboBox_' + orb_tp + str(idx))
sz_pol = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
combo.setSizePolicy(sz_pol)
combo.setMaxVisibleItems(10)
for name in sorted(self.controls.keys()):
combo.addItem(name)
combo.addItem('Zero')
combo.currentTextChanged.connect(
_part(self.updater[idx].some_changed, orb_tp))
combo.setCurrentIndex(0)
return combo
def get_map2read(self):
"""."""
return {
'Dispersion-RB': _part(self.read, 'dispersion'),
'Angle-RB': _part(self.read, 'angle'),
'Spectrometer-RB': _part(self.read, 'spectrometer'),
'IntDipole-Mon': _part(self.read, 'intdipole'),
'Energy-Mon': _part(self.read, 'energy'),
'Spread-Mon': _part(self.read, 'spread'),
}
def _setupOrbitWidget(self):
self.bt_get_kicks = QPushButton('Get Kicks from SOFB', self)
self.bt_get_kicks.clicked.connect(self._handleGetKicksFromSOFB)
label_correctH = QLabel('Correct H', self,
alignment=Qt.AlignRight | Qt.AlignVCenter)
self.sb_correctH = QDoubleSpinBoxPlus(self)
self.sb_correctH.setValue(self._deltas['factorH'])
self.sb_correctH.setDecimals(1)
self.sb_correctH.setMinimum(-10000)
self.sb_correctH.setMaximum(10000)
self.sb_correctH.setSingleStep(0.1)
self.sb_correctH.setObjectName('factorH')
self.sb_correctH.editingFinished.connect(self._handleCorrFactorsSet)
labelH = QLabel('%', self)
label_correctV = QLabel('Correct V', self,
alignment=Qt.AlignRight | Qt.AlignVCenter)
self.sb_correctV = QDoubleSpinBoxPlus(self)
self.sb_correctV.setValue(self._deltas['factorV'])
self.sb_correctV.setDecimals(1)
self.sb_correctV.setMinimum(-10000)
self.sb_correctV.setMaximum(10000)
self.sb_correctV.setSingleStep(0.1)
self.sb_correctV.setObjectName('factorV')
self.sb_correctV.editingFinished.connect(self._handleCorrFactorsSet)
labelV = QLabel('%', self)
self.bt_update_ref_orbit = QPushButton('Update reference', self)
self.bt_update_ref_orbit.clicked.connect(
_part(self._updateReference, 'corrs'))
gbox = QGroupBox('Orbit', self)
lay = QGridLayout()
lay.addWidget(self.bt_get_kicks, 0, 0, 1, 4)
lay.addWidget(label_correctH, 1, 0)
lay.addWidget(self.sb_correctH, 1, 2)
lay.addWidget(labelH, 1, 3)
lay.addWidget(label_correctV, 2, 0)
lay.addWidget(self.sb_correctV, 2, 2)
lay.addWidget(labelV, 2, 3)
lay.addWidget(self.bt_update_ref_orbit, 3, 2, 1, 2)
lay.setColumnStretch(0, 16)
lay.setColumnStretch(1, 1)
lay.setColumnStretch(2, 14)
lay.setColumnStretch(3, 2)
gbox.setLayout(lay)
return gbox
