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