class AcceptFiles(QDialog):
def __init__(self, files):
super().__init__()
self.ok = QPushButton("Add", self)
self.ok.clicked.connect(self.accept)
discard = QPushButton("Discard", self)
discard.clicked.connect(self.close)
self.files = QListWidget(self)
self.files.setSelectionMode(QAbstractItemView.ExtendedSelection)
for file_name in files:
self.files.addItem(file_name)
for i in range(self.files.count()):
self.files.item(i).setSelected(True)
self.ok.setDefault(True)
self.ok.setAutoDefault(True)
layout = QVBoxLayout()
layout.addWidget(QLabel("Found {} files".format(len(files))))
layout.addWidget(self.files)
butt_layout = QHBoxLayout()
butt_layout.addWidget(discard)
butt_layout.addStretch()
butt_layout.addWidget(self.ok)
layout.addLayout(butt_layout)
self.setLayout(layout)
def selection_changed(self):
if self.files.selectedItems().count() == 0:
self.ok.setDisabled(True)
else:
self.ok.setEnabled(True)
def get_files(self):
return [str(item.text()) for item in self.files.selectedItems()]
class MontageDialog(QDialog):
def __init__(self, parent, montages, selected=None):
super().__init__(parent)
self.setWindowTitle("Set montage")
vbox = QVBoxLayout(self)
self.montages = QListWidget()
self.montages.insertItems(0, montages)
self.montages.setSelectionMode(QListWidget.SingleSelection)
if selected is not None:
for i in range(self.montages.count()):
if self.montages.item(i).data(0) == selected:
self.montages.item(i).setSelected(True)
vbox.addWidget(self.montages)
hbox = QHBoxLayout()
self.view_button = QPushButton("View")
self.view_button.clicked.connect(self.view_montage)
hbox.addWidget(self.view_button)
hbox.addStretch()
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
hbox.addWidget(self.buttonbox)
vbox.addLayout(hbox)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
self.montages.itemSelectionChanged.connect(self.toggle_buttons)
self.toggle_buttons() # initialize OK and View buttons state
@Slot()
def toggle_buttons(self):
"""Toggle OK and View buttons.
"""
if self.montages.selectedItems():
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(True)
self.view_button.setEnabled(True)
else:
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
self.view_button.setEnabled(False)
def view_montage(self):
name = self.montages.selectedItems()[0].data(0)
montage = make_standard_montage(name)
fig = montage.plot(show_names=True, show=False)
win = fig.canvas.manager.window
win.setWindowModality(Qt.WindowModal)
win.setWindowTitle("Montage")
win.findChild(QStatusBar).hide()
win.findChild(QToolBar).hide()
fig.show()
class PickChannelsDialog(QDialog):
def __init__(self, parent, channels, selected=None, title="Pick channels"):
super().__init__(parent)
self.setWindowTitle(title)
if selected is None:
selected = []
self.initial_selection = selected
vbox = QVBoxLayout(self)
self.channels = QListWidget()
self.channels.insertItems(0, channels)
self.channels.setSelectionMode(QListWidget.ExtendedSelection)
for i in range(self.channels.count()):
if self.channels.item(i).data(0) in selected:
self.channels.item(i).setSelected(True)
vbox.addWidget(self.channels)
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok |
QDialogButtonBox.Cancel)
vbox.addWidget(self.buttonbox)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
self.channels.itemSelectionChanged.connect(self.toggle_buttons)
self.toggle_buttons() # initialize OK button state
@Slot()
def toggle_buttons(self):
"""Toggle OK button.
"""
selected = [item.data(0) for item in self.channels.selectedItems()]
if selected != self.initial_selection:
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(True)
else:
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
class PopInDialog(QDialog):
pop_in_tabs = Signal(list)
def __init__(self, parent, loggers):
super().__init__(parent)
self.loggers = loggers
self.setupUi()
def setupUi(self):
self.resize(200, 320)
self.vbox = QVBoxLayout(self)
self.listWidget = QListWidget(self)
self.listWidget.setSelectionMode(self.listWidget.MultiSelection)
self.listWidget.selectionModel().reset()
self.vbox.addWidget(self.listWidget)
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, self)
self.vbox.addWidget(self.buttonBox)
self.buttonBox.accepted.connect(self.accept)
self.listWidget.doubleClicked.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.fill_logger_list()
def fill_logger_list(self):
for logger in self.loggers:
if logger.popped_out:
self.listWidget.addItem(logger.name)
self.listWidget.setCurrentRow(0)
def accept(self, index=None):
names = []
if index is not None:
item = self.listWidget.itemFromIndex(index)
names.append(item.text())
else:
for item in self.listWidget.selectedItems():
names.append(item.text())
if len(names) > 0:
self.pop_in_tabs.emit(names)
self.done(0)
def reject(self):
self.done(0)
class LoadRecentFiles(QDialog):
def __init__(self, settings: BaseSettings, parent=None):
super().__init__(parent)
self.settings = settings
self.file_list = QListWidget()
self.file_list.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.cancel_btn = QPushButton("Cancel", clicked=self.reject)
self.load_btn = QPushButton("Load", clicked=self.accept)
for name_list, method in settings.get_last_files_multiple():
entry = f"{name_list[0]} {method}"
item = QListWidgetItem(entry, self.file_list)
item.setData(Qt.UserRole, (name_list, method))
last_set = {(tuple(x), y)
for x, y in settings.get_last_files_multiple()}
for name_list, method in settings.get_last_files():
if (tuple(name_list), method) in last_set:
continue
entry = f"{name_list[0]} {method}"
item = QListWidgetItem(entry, self.file_list)
item.setData(Qt.UserRole, (name_list, method))
layout = QGridLayout()
layout.addWidget(QLabel("Select files"))
layout.addWidget(self.file_list, 1, 0, 1, 2)
layout.addWidget(self.cancel_btn, 2, 0)
layout.addWidget(self.load_btn, 2, 1)
self.setLayout(layout)
self.resize(
*self.settings.get_from_profile("multiple_files_dialog_size", (
self.size().width(), self.size().height())))
def get_files(self) -> List[Tuple[List[str], str]]:
return [
item.data(Qt.UserRole) for item in self.file_list.selectedItems()
]
def accept(self) -> None:
self.settings.set_in_profile(
"multiple_files_dialog_size",
(self.size().width(), self.size().height()))
super().accept()
def drag_with_pixmap(list_widget: QListWidget) -> QDrag:
"""Create a QDrag object with a pixmap of the currently select list item.
This method is useful when you have a QListWidget that displays custom
widgets for each QListWidgetItem instance in the list (usually by calling
``QListWidget.setItemWidget(item, widget)``). When used in a
``QListWidget.startDrag`` method, this function creates a QDrag object that
shows an image of the item being dragged (rather than an empty rectangle).
Parameters
----------
list_widget : QListWidget
The QListWidget for which to create a QDrag object.
Returns
-------
QDrag
A QDrag instance with a pixmap of the currently selected item.
Examples
--------
>>> class QListWidget:
... def startDrag(self, supportedActions):
... drag = drag_with_pixmap(self)
... drag.exec_(supportedActions, Qt.MoveAction)
"""
drag = QDrag(list_widget)
drag.setMimeData(list_widget.mimeData(list_widget.selectedItems()))
size = list_widget.viewport().visibleRegion().boundingRect().size()
pixmap = QPixmap(size)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
for index in list_widget.selectedIndexes():
rect = list_widget.visualRect(index)
painter.drawPixmap(rect, list_widget.viewport().grab(rect))
painter.end()
drag.setPixmap(pixmap)
drag.setHotSpot(list_widget.viewport().mapFromGlobal(QCursor.pos()))
return drag
class EpochDialog(QDialog):
def __init__(self, parent, events):
super().__init__(parent)
self.setWindowTitle("Create Epochs")
grid = QGridLayout(self)
label = QLabel("Events:")
label.setAlignment(Qt.AlignTop)
grid.addWidget(label, 0, 0, 1, 1)
self.events = QListWidget()
self.events.insertItems(0, unique(events[:, 2]).astype(str))
self.events.setSelectionMode(QListWidget.ExtendedSelection)
grid.addWidget(self.events, 0, 1, 1, 2)
grid.addWidget(QLabel("Interval around events:"), 1, 0, 1, 1)
self.tmin = QDoubleSpinBox()
self.tmin.setMinimum(-10000)
self.tmin.setValue(-0.2)
self.tmin.setSingleStep(0.1)
self.tmin.setAlignment(Qt.AlignRight)
self.tmax = QDoubleSpinBox()
self.tmax.setMinimum(-10000)
self.tmax.setValue(0.5)
self.tmax.setSingleStep(0.1)
self.tmax.setAlignment(Qt.AlignRight)
grid.addWidget(self.tmin, 1, 1, 1, 1)
grid.addWidget(self.tmax, 1, 2, 1, 1)
self.baseline = QCheckBox("Baseline Correction:")
self.baseline.setChecked(True)
self.baseline.stateChanged.connect(self.toggle_baseline)
grid.addWidget(self.baseline, 2, 0, 1, 1)
self.a = QDoubleSpinBox()
self.a.setMinimum(-10000)
self.a.setValue(-0.2)
self.a.setSingleStep(0.1)
self.a.setAlignment(Qt.AlignRight)
self.b = QDoubleSpinBox()
self.b.setMinimum(-10000)
self.b.setValue(0)
self.b.setSingleStep(0.1)
self.b.setAlignment(Qt.AlignRight)
grid.addWidget(self.a, 2, 1, 1, 1)
grid.addWidget(self.b, 2, 2, 1, 1)
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
grid.addWidget(self.buttonbox, 3, 0, 1, -1)
self.events.itemSelectionChanged.connect(self.toggle_ok)
self.toggle_ok()
grid.setSizeConstraint(QGridLayout.SetFixedSize)
@Slot()
def toggle_ok(self):
if self.events.selectedItems():
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(True)
else:
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
@Slot()
def toggle_baseline(self):
if self.baseline.isChecked():
self.a.setEnabled(True)
self.b.setEnabled(True)
else:
self.a.setEnabled(False)
self.b.setEnabled(False)
class CheckList(QWidget):
def __init__(self, model, label="", help_link="", custom_filter_button=None):
"""
:param custom_filter_button: if needed, add a button that opens a
custom filter menu. Useful when search alone isn't enough to filter the
list.
:type custom_filter_button: QToolButton
"""
QWidget.__init__(self)
self._model = model
if help_link != "":
addHelpToWidget(self, help_link)
layout = QVBoxLayout()
self._createCheckButtons()
self._list = QListWidget()
self._list.setContextMenuPolicy(Qt.CustomContextMenu)
self._list.setSelectionMode(QAbstractItemView.ExtendedSelection)
self._search_box = SearchBox()
check_button_layout = QHBoxLayout()
check_button_layout.setContentsMargins(0, 0, 0, 0)
check_button_layout.setSpacing(0)
check_button_layout.addWidget(QLabel(label))
check_button_layout.addStretch(1)
check_button_layout.addWidget(self._checkAllButton)
check_button_layout.addWidget(self._uncheckAllButton)
layout.addLayout(check_button_layout)
layout.addWidget(self._list)
"""
Inserts the custom filter button, if provided. The caller is responsible
for all related actions.
"""
if custom_filter_button is not None:
search_bar_layout = QHBoxLayout()
search_bar_layout.addWidget(self._search_box)
search_bar_layout.addWidget(custom_filter_button)
layout.addLayout(search_bar_layout)
else:
layout.addWidget(self._search_box)
self.setLayout(layout)
self._checkAllButton.clicked.connect(self.checkAll)
self._uncheckAllButton.clicked.connect(self.uncheckAll)
self._list.itemChanged.connect(self.itemChanged)
self._search_box.filterChanged.connect(self.filterList)
self._list.customContextMenuRequested.connect(self.showContextMenu)
self._model.selectionChanged.connect(self.modelChanged)
self._model.modelChanged.connect(self.modelChanged)
self.modelChanged()
def _createCheckButtons(self):
self._checkAllButton = QToolButton()
self._checkAllButton.setIcon(resourceIcon("check.svg"))
self._checkAllButton.setIconSize(QSize(16, 16))
self._checkAllButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
self._checkAllButton.setAutoRaise(True)
self._checkAllButton.setToolTip("Select all")
self._uncheckAllButton = QToolButton()
self._uncheckAllButton.setIcon(resourceIcon("checkbox_outline.svg"))
self._uncheckAllButton.setIconSize(QSize(16, 16))
self._uncheckAllButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
self._uncheckAllButton.setAutoRaise(True)
self._uncheckAllButton.setToolTip("Unselect all")
def itemChanged(self, item):
"""@type item: QListWidgetItem"""
if item.checkState() == Qt.Checked:
self._model.selectValue(str(item.text()))
elif item.checkState() == Qt.Unchecked:
self._model.unselectValue(str(item.text()))
else:
raise AssertionError("Unhandled checkstate!")
def modelChanged(self):
self._list.clear()
items = self._model.getList()
for item in items:
list_item = QListWidgetItem(item)
list_item.setFlags(list_item.flags() | Qt.ItemIsUserCheckable)
if self._model.isValueSelected(item):
list_item.setCheckState(Qt.Checked)
else:
list_item.setCheckState(Qt.Unchecked)
self._list.addItem(list_item)
self.filterList(self._search_box.filter())
def setSelectionEnabled(self, enabled):
self.setEnabled(enabled)
self._checkAllButton.setEnabled(enabled)
self._uncheckAllButton.setEnabled(enabled)
def filterList(self, filter):
filter = filter.lower()
for index in range(0, self._list.count()):
item = self._list.item(index)
text = str(item.text()).lower()
if filter == "":
item.setHidden(False)
elif filter in text:
item.setHidden(False)
else:
item.setHidden(True)
def checkAll(self):
"""
Checks all visible items in the list.
"""
for index in range(0, self._list.count()):
item = self._list.item(index)
if not item.isHidden():
self._model.selectValue(str(item.text()))
def uncheckAll(self):
"""
Unchecks all items in the list, visible or not
"""
self._model.unselectAll()
def checkSelected(self):
items = []
for item in self._list.selectedItems():
items.append(str(item.text()))
for item in items:
self._model.selectValue(item)
def uncheckSelected(self):
items = []
for item in self._list.selectedItems():
items.append(str(item.text()))
for item in items:
self._model.unselectValue(item)
def showContextMenu(self, point):
p = self._list.mapToGlobal(point)
menu = QMenu()
check_selected = menu.addAction("Check selected")
uncheck_selected = menu.addAction("Uncheck selected")
menu.addSeparator()
clear_selection = menu.addAction("Clear selection")
selected_item = menu.exec_(p)
if selected_item == check_selected:
self.checkSelected()
elif selected_item == uncheck_selected:
self.uncheckSelected()
elif selected_item == clear_selection:
self._list.clearSelection()
class HeaderEditDialog(QDialog):
# name of the current preset; whether to set this preset as default; list of Columns
header_changed = Signal(str, bool, list)
def __init__(self, parent, table_header):
super().__init__(parent)
self.table_header = table_header
self.default_preset_name = None
self.preset_name = table_header.preset_name
self.columns = deepcopy(table_header.columns)
self.setupUi()
self.update_output()
def setupUi(self):
self.resize(240, 400)
self.vbox = QVBoxLayout(self)
self.presetLabel = QLabel(self)
self.columnList = QListWidget(self)
self.setAsDefaultCheckbox = QCheckBox("Set as default preset", self)
self.vbox.addWidget(self.presetLabel)
self.vbox.addWidget(self.columnList)
self.vbox.addWidget(self.setAsDefaultCheckbox)
self.columnList.setDragDropMode(QListWidget.InternalMove)
self.columnList.setDefaultDropAction(Qt.MoveAction)
self.columnList.setSelectionMode(QListWidget.ExtendedSelection)
self.columnList.setAlternatingRowColors(True)
self.columnList.installEventFilter(self)
self.columnList.setContextMenuPolicy(Qt.CustomContextMenu)
self.columnList.customContextMenuRequested.connect(self.open_menu)
self.columnList.model().rowsMoved.connect(self.read_columns_from_list)
# for a dumb qss hack to make selected checkboxes not white on a light theme
self.columnList.setObjectName("ColumnList")
buttons = QDialogButtonBox.Reset | QDialogButtonBox.Save | QDialogButtonBox.Cancel
self.buttonBox = QDialogButtonBox(buttons, self)
self.vbox.addWidget(self.buttonBox)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.resetButton = self.buttonBox.button(QDialogButtonBox.Reset)
self.resetButton.clicked.connect(self.reset_to_stock)
def eventFilter(self, object, event):
if event.type() == QEvent.KeyPress:
if event.key() == Qt.Key_Space or event.key() == Qt.Key_Return:
self.toggle_selected_columns()
return True
if event.key() == Qt.Key_Delete:
self.delete_selected()
return True
return False
def update_output(self):
self.presetLabel.setText("Preset: {}".format(self.preset_name))
self.setAsDefaultCheckbox.setChecked(
CONFIG['default_header_preset'] == self.preset_name)
self.columnList.clear()
for column in self.columns:
ColumnListItem(self.columnList, column)
def accept(self):
self.read_columns_from_list()
self.header_changed.emit(self.preset_name,
self.setAsDefaultCheckbox.isChecked(),
self.columns)
self.done(0)
def reject(self):
self.done(0)
def reset_to_stock(self):
self.columns = deepcopy(DEFAULT_COLUMNS)
self.update_output()
def read_columns_from_list(self):
new_columns = []
for i in range(self.columnList.count()):
item = self.columnList.item(i)
new_columns.append(item.column)
self.columns = new_columns
def toggle_selected_columns(self):
selected = self.columnList.selectedItems()
for item in selected:
value_now = item.data(Qt.CheckStateRole)
item.setData(Qt.CheckStateRole, not value_now)
self.columnList.reset(
) # @Improvement: is there a better way to update QListWidget?
def open_menu(self, position):
menu = QMenu(self)
preset_menu = menu.addMenu('Presets')
preset_menu.addAction('New preset', self.new_preset_dialog)
preset_menu.addSeparator()
preset_names = CONFIG.get_header_presets()
if len(preset_names) == 0:
action = preset_menu.addAction('No presets')
action.setEnabled(False)
else:
delete_menu = menu.addMenu('Delete preset')
for name in preset_names:
preset_menu.addAction(name, partial(self.load_preset, name))
delete_menu.addAction(name, partial(self.delete_preset, name))
menu.addSeparator()
menu.addAction('New column...', self.create_new_column_dialog)
if len(self.columnList.selectedIndexes()) > 0:
menu.addAction('Delete selected', self.delete_selected)
menu.popup(self.columnList.viewport().mapToGlobal(position))
def load_preset(self, name):
new_columns = CONFIG.load_header_preset(name)
if not new_columns:
return
self.columns = new_columns
self.preset_name = name
self.update_output()
def new_preset_dialog(self):
d = QInputDialog(self)
d.setLabelText('Enter the new name for the new preset:')
d.setWindowTitle('Create new preset')
d.textValueSelected.connect(self.create_new_preset)
d.open()
def create_new_preset(self, name):
if name in CONFIG.get_header_presets():
show_warning_dialog(
self, "Preset creation error",
'Preset named "{}" already exists.'.format(name))
return
if len(name.strip()) == 0:
show_warning_dialog(
self, "Preset creation error",
'This preset name is not allowed.'.format(name))
return
self.preset_name = name
self.update_output()
CONFIG.save_header_preset(name, self.columns)
def delete_preset(self, name):
CONFIG.delete_header_preset(name)
if name == self.preset_name:
self.columns = deepcopy(DEFAULT_COLUMNS)
self.update_output()
def create_new_column_dialog(self):
d = CreateNewColumnDialog(self)
d.add_new_column.connect(self.add_new_column)
d.setWindowTitle('Create new column')
d.open()
def add_new_column(self, name, title):
new_column = Column(name, title)
# if the last column is message, insert this column before it (I think that makes sense?)
if len(self.columns) == 0:
self.columns.append(new_column)
elif self.columns[-1].name in ('message', 'msg'):
self.columns.insert(-1, new_column)
else:
self.columns.append(new_column)
self.update_output()
def delete_selected(self):
selected = self.columnList.selectedItems()
for item in selected:
self.columnList.takeItem(self.columnList.row(item))
self.read_columns_from_list()
self.update_output()
class CycleWindow(SiriusMainWindow):
"""Power supplies cycle window."""
def __init__(self, parent=None, checked_accs=(), adv_mode=False):
"""Constructor."""
super().__init__(parent)
self.setObjectName('ASApp')
cor = get_appropriate_color(section='AS')
self.setWindowIcon(qta.icon('mdi.recycle', color=cor))
self._is_adv_mode = adv_mode
# Data structs
self._psnames = get_psnames(isadv=self._is_adv_mode)
self._timing = Timing()
self._ps2cycle = list()
self._ps_ready = list()
self._ps_failed = list()
self._checked_accs = checked_accs
# Flags
self._is_preparing = ''
self._prepared_init_vals = {
'timing': False,
'ps_sofbmode': False,
'ps_om_slowref': False,
'ps_current': False,
'ps_params': False,
'ps_om_cycle': False,
'trims': True
}
self._prepared = self._prepared_init_vals.copy()
self._icon_check = qta.icon('fa5s.check')
self._pixmap_check = self._icon_check.pixmap(
self._icon_check.actualSize(QSize(16, 16)))
self._icon_not = qta.icon('fa5s.times')
self._pixmap_not = self._icon_not.pixmap(
self._icon_not.actualSize(QSize(16, 16)))
# Tasks
self._step_2_task = {
'save_timing': SaveTiming,
'timing': PrepareTiming,
'ps_sofbmode': PreparePSSOFBMode,
'ps_om_slowref': PreparePSOpModeSlowRef,
'ps_current': PreparePSCurrentZero,
'ps_params': PreparePSParams,
'ps_om_cycle': PreparePSOpModeCycle,
'trims': CycleTrims,
'cycle': Cycle,
'restore_timing': RestoreTiming,
}
# Setup UI
self._needs_update_setup = False
self._setup_ui()
self._update_setup_timer = QTimer(self)
self._update_setup_timer.timeout.connect(self._update_setup)
self._update_setup_timer.setInterval(250)
self._update_setup_timer.start()
self.setWindowTitle('PS Cycle')
def _setup_ui(self):
# central widget
self.central_widget = QWidget()
self.setCentralWidget(self.central_widget)
# tree
gb_tree = QGroupBox('Select power supplies:')
self.pwrsupplies_tree = PVNameTree(self._psnames, ('sec', 'mag_group'),
tuple(), self)
self.pwrsupplies_tree.tree.setHeaderHidden(True)
self.pwrsupplies_tree.tree.setColumnCount(1)
glay_tree = QVBoxLayout(gb_tree)
glay_tree.addWidget(self.pwrsupplies_tree)
# commands
lb_prep_ti = QLabel('<h4>Prepare Timing</h4>',
self,
alignment=Qt.AlignCenter)
ti_ch = [
PVName(name).substitute(prefix=VACA_PREFIX)
for name in self._timing.get_pvnames_by_psnames()
]
self.ticonn_led = PyDMLedMultiConn(self, channels=ti_ch)
self.save_timing_bt = QPushButton('1. Save Timing Initial State', self)
self.save_timing_bt.setToolTip(
'Save timing current state as initial state.')
self.save_timing_bt.clicked.connect(
_part(self._run_task, 'save_timing'))
self.save_timing_bt.clicked.connect(self._set_lastcomm)
self.prepare_timing_bt = QPushButton('2. Prepare Timing', self)
self.prepare_timing_bt.setToolTip('Prepare EVG, triggers and events')
self.prepare_timing_bt.clicked.connect(_part(self._run_task, 'timing'))
self.prepare_timing_bt.clicked.connect(self._set_lastcomm)
self.prepare_timing_lb = QLabel(self)
self.prepare_timing_lb.setPixmap(self._pixmap_not)
lb_prep_ps = QLabel('<h4>Prepare PS</h4>',
self,
alignment=Qt.AlignCenter)
self.psconn_led = PyDMLedMultiConn(self)
self.set_ps_sofbmode_off_bt = QPushButton('3. Turn off PS SOFBMode',
self)
self.set_ps_sofbmode_off_bt.setToolTip(
'Turn off power supplies SOFBMode.')
self.set_ps_sofbmode_off_bt.clicked.connect(
_part(self._run_task, 'ps_sofbmode'))
self.set_ps_sofbmode_off_bt.clicked.connect(self._set_lastcomm)
self.set_ps_sofbmode_off_lb = QLabel(self)
self.set_ps_sofbmode_off_lb.setPixmap(self._pixmap_not)
self.set_ps_opmode_slowref_bt = QPushButton(
'4. Set PS OpMode to SlowRef', self)
self.set_ps_opmode_slowref_bt.setToolTip(
'Set power supplies OpMode to SlowRef.')
self.set_ps_opmode_slowref_bt.clicked.connect(
_part(self._run_task, 'ps_om_slowref'))
self.set_ps_opmode_slowref_bt.clicked.connect(self._set_lastcomm)
self.set_ps_opmode_slowref_lb = QLabel(self)
self.set_ps_opmode_slowref_lb.setPixmap(self._pixmap_not)
self.set_ps_current_zero_bt = QPushButton('5. Set PS current to zero',
self)
self.set_ps_current_zero_bt.setToolTip(
'Set power supplies current to zero.')
self.set_ps_current_zero_bt.clicked.connect(
_part(self._run_task, 'ps_current'))
self.set_ps_current_zero_bt.clicked.connect(self._set_lastcomm)
self.set_ps_current_zero_lb = QLabel(self)
self.set_ps_current_zero_lb.setPixmap(self._pixmap_not)
self.prepare_ps_params_bt = QPushButton('6. Prepare PS Parameters',
self)
self.prepare_ps_params_bt.setToolTip(
'Check power supplies OpMode in SlowRef, check\n'
'current is zero and configure cycle parameters.')
self.prepare_ps_params_bt.clicked.connect(
_part(self._run_task, 'ps_params'))
self.prepare_ps_params_bt.clicked.connect(self._set_lastcomm)
self.prepare_ps_params_lb = QLabel(self)
self.prepare_ps_params_lb.setPixmap(self._pixmap_not)
self.prepare_ps_opmode_bt = QPushButton('7. Prepare PS OpMode', self)
self.prepare_ps_opmode_bt.setToolTip(
'Set power supplies OpMode to Cycle.')
self.prepare_ps_opmode_bt.clicked.connect(
_part(self._run_task, 'ps_om_cycle'))
self.prepare_ps_opmode_bt.clicked.connect(self._set_lastcomm)
self.prepare_ps_opmode_lb = QLabel(self)
self.prepare_ps_opmode_lb.setPixmap(self._pixmap_not)
lb_cycle = QLabel('<h4>Cycle</h4>', self, alignment=Qt.AlignCenter)
self.cycle_trims_bt = QPushButton('8. Cycle Trims', self)
self.cycle_trims_bt.setToolTip(
'Cycle trims:\nStep 1) CH, QS and QTrims\nStep 2) CV')
self.cycle_trims_bt.clicked.connect(_part(self._run_task, 'trims'))
self.cycle_trims_bt.clicked.connect(self._set_lastcomm)
self.cycle_trims_bt.setVisible(False)
self.cycle_trims_lb = QLabel(self)
self.cycle_trims_lb.setPixmap(self._pixmap_check)
self.cycle_trims_lb.setVisible(False)
self.cycle_bt = QPushButton('8. Cycle', self)
self.cycle_bt.setToolTip(
'Check all configurations,\nenable triggers and run cycle.')
self.cycle_bt.clicked.connect(_part(self._run_task, 'cycle'))
self.cycle_bt.clicked.connect(self._set_lastcomm)
self.cycle_bt.setEnabled(False)
lb_rest_ti = QLabel('<h4>Restore Timing</h4>',
self,
alignment=Qt.AlignCenter)
self.restore_timing_bt = QPushButton('9. Restore Timing Initial State',
self)
self.restore_timing_bt.setToolTip('Restore timing initial state.')
self.restore_timing_bt.clicked.connect(
_part(self._run_task, 'restore_timing'))
self.restore_timing_bt.clicked.connect(self._set_lastcomm)
self._prepared_labels = {
'timing': self.prepare_timing_lb,
'ps_sofbmode': self.set_ps_sofbmode_off_lb,
'ps_om_slowref': self.set_ps_opmode_slowref_lb,
'ps_current': self.set_ps_current_zero_lb,
'ps_params': self.prepare_ps_params_lb,
'ps_om_cycle': self.prepare_ps_opmode_lb,
'trims': self.cycle_trims_lb
}
gb_commsts = QGroupBox()
gb_commsts.setStyleSheet("""
QPushButton{min-height:1.5em;}
QLabel{qproperty-alignment: AlignCenter;}""")
lay_commsts = QGridLayout(gb_commsts)
lay_commsts.addItem(
QSpacerItem(1, 1, QSzPlcy.Ignored, QSzPlcy.Expanding), 0, 0, 1, 2)
lay_commsts.addWidget(lb_prep_ti, 1, 0)
lay_commsts.addWidget(self.ticonn_led, 1, 1)
lay_commsts.addWidget(self.save_timing_bt, 2, 0)
lay_commsts.addWidget(self.prepare_timing_bt, 3, 0)
lay_commsts.addWidget(self.prepare_timing_lb, 3, 1)
lay_commsts.addItem(
QSpacerItem(1, 1, QSzPlcy.Ignored, QSzPlcy.Expanding), 4, 0)
lay_commsts.addWidget(lb_prep_ps, 5, 0)
lay_commsts.addWidget(self.psconn_led, 5, 1)
lay_commsts.addWidget(self.set_ps_sofbmode_off_bt, 6, 0)
lay_commsts.addWidget(self.set_ps_sofbmode_off_lb, 6, 1)
lay_commsts.addWidget(self.set_ps_opmode_slowref_bt, 7, 0)
lay_commsts.addWidget(self.set_ps_opmode_slowref_lb, 7, 1)
lay_commsts.addWidget(self.set_ps_current_zero_bt, 8, 0)
lay_commsts.addWidget(self.set_ps_current_zero_lb, 8, 1)
lay_commsts.addWidget(self.prepare_ps_params_bt, 9, 0)
lay_commsts.addWidget(self.prepare_ps_params_lb, 9, 1)
lay_commsts.addWidget(self.prepare_ps_opmode_bt, 10, 0)
lay_commsts.addWidget(self.prepare_ps_opmode_lb, 10, 1)
lay_commsts.addItem(
QSpacerItem(1, 1, QSzPlcy.Ignored, QSzPlcy.Expanding), 11, 0)
lay_commsts.addWidget(lb_cycle, 12, 0)
lay_commsts.addWidget(self.cycle_trims_bt, 13, 0)
lay_commsts.addWidget(self.cycle_trims_lb, 13, 1)
lay_commsts.addWidget(self.cycle_bt, 14, 0)
lay_commsts.addItem(
QSpacerItem(1, 1, QSzPlcy.Ignored, QSzPlcy.Expanding), 15, 0)
lay_commsts.addWidget(lb_rest_ti, 16, 0)
lay_commsts.addWidget(self.restore_timing_bt, 17, 0)
lay_commsts.addItem(
QSpacerItem(1, 1, QSzPlcy.Ignored, QSzPlcy.Expanding), 18, 0)
lay_commsts.setColumnStretch(0, 10)
lay_commsts.setColumnStretch(1, 1)
lay_commsts.setVerticalSpacing(12)
lay_commsts.setHorizontalSpacing(6)
self.label_lastcomm = QLabel('Last Command: ', self)
self.clearhist_bt = QPushButton('Clear', self)
self.clearhist_bt.clicked.connect(self._clear_lastcomm)
lay_lc = QHBoxLayout()
lay_lc.setContentsMargins(0, 0, 0, 0)
lay_lc.addWidget(self.label_lastcomm, alignment=Qt.AlignLeft)
lay_lc.addWidget(self.clearhist_bt, alignment=Qt.AlignRight)
lay_lc.setStretch(0, 10)
lay_lc.setStretch(1, 1)
self.progress_list = QListWidget(self)
self.progress_list.setObjectName('progresslist')
self.progress_list.setStyleSheet('#progresslist{min-width:20em;}')
self.progress_list.itemDoubleClicked.connect(self._open_ps_detail)
self.progress_list.setSelectionMode(QAbstractItemView.MultiSelection)
self.progress_list.setToolTip(
'Select rows and press Ctrl+C to copy and Esc to deselect.')
self.progress_bar = MyProgressBar(self)
lay_log = QVBoxLayout()
lay_log.addLayout(lay_lc)
lay_log.addWidget(self.progress_list)
lay_log.addWidget(self.progress_bar)
# connect tree signals
self.pwrsupplies_tree.tree.doubleClicked.connect(self._open_ps_detail)
self.pwrsupplies_tree.tree.itemChanged.connect(
self._handle_checked_items_changed)
self.pwrsupplies_tree.check_requested_levels(self._checked_accs)
# layout
layout = QGridLayout()
layout.setVerticalSpacing(10)
layout.setHorizontalSpacing(10)
layout.addWidget(
QLabel('<h3>PS Cycle</h3>', self, alignment=Qt.AlignCenter), 0, 0,
1, 3)
layout.addWidget(gb_tree, 1, 0)
layout.addWidget(gb_commsts, 1, 1)
layout.addLayout(lay_log, 1, 2)
layout.setRowStretch(0, 1)
layout.setRowStretch(1, 15)
layout.setColumnStretch(0, 5)
layout.setColumnStretch(1, 4)
layout.setColumnStretch(2, 8)
self.central_widget.setLayout(layout)
# --- handle tasks ---
def _run_task(self, control=''):
if not self._check_connected(control):
return
pwrsupplies = self._get_ps_list()
if not pwrsupplies:
return
if 'ps' in control and not self._verify_ps(pwrsupplies):
return
if control in self._step_2_task:
task_class = self._step_2_task[control]
else:
raise NotImplementedError(
"Task not defined for control '{}'".format(control))
self._is_preparing = control
self._handle_buttons_enabled(False)
self.progress_list.clear()
task = task_class(parent=self,
psnames=pwrsupplies,
timing=self._timing,
isadv=self._is_adv_mode)
task.updated.connect(self._update_progress)
duration = task.duration()
self.progress_bar.setMinimum(0)
self.progress_bar.setMaximum(duration)
self.progress_bar.setValue(0)
pal = self.progress_bar.palette()
pal.setColor(QPalette.Highlight, self.progress_bar.default_color)
self.progress_bar.setPalette(pal)
self.update_bar = UpdateProgressBar(duration, self)
self.update_bar.increment.connect(self.progress_bar.increment)
task.start()
self.update_bar.start()
def _update_progress(self, text, done, warning=False, error=False):
"""Update automated cycle progress list and bar."""
if done:
last_item = self.progress_list.item(self.progress_list.count() - 1)
curr_text = last_item.text()
last_item.setText(curr_text + ' done.')
elif 'Remaining time' in text:
last_item = self.progress_list.item(self.progress_list.count() - 1)
if 'Remaining time' in last_item.text():
last_item.setText(text)
else:
self.progress_list.addItem(text)
self.progress_list.scrollToBottom()
elif 'Sent ' in text:
last_item = self.progress_list.item(self.progress_list.count() - 1)
if 'Sent ' in last_item.text():
last_item.setText(text)
else:
self.progress_list.addItem(text)
self.progress_list.scrollToBottom()
elif 'Successfully checked ' in text:
last_item = self.progress_list.item(self.progress_list.count() - 1)
if 'Successfully checked ' in last_item.text():
last_item.setText(text)
else:
self.progress_list.addItem(text)
self.progress_list.scrollToBottom()
elif 'Created connections ' in text:
last_item = self.progress_list.item(self.progress_list.count() - 1)
if 'Created connections ' in last_item.text():
last_item.setText(text)
else:
self.progress_list.addItem(text)
self.progress_list.scrollToBottom()
else:
item = QListWidgetItem(text)
if error:
item.setForeground(errorcolor)
self.update_bar.exit_task()
pal = self.progress_bar.palette()
pal.setColor(QPalette.Highlight,
self.progress_bar.warning_color)
self.progress_bar.setPalette(pal)
if self._is_preparing in self._prepared.keys():
self._prepared[self._is_preparing] = False
cycle = all(self._prepared.values())
self._handle_buttons_enabled(True, cycle=cycle)
elif warning:
item.setForeground(warncolor)
elif 'finished' in text:
self.update_bar.exit_task()
self.progress_bar.setValue(self.progress_bar.maximum())
if self._is_preparing == 'cycle':
self._prepared = {k: False for k in self._prepared.keys()}
if not self.cycle_trims_bt.isVisible():
self._prepared['trims'] = True
cycle = False
else:
if self._is_preparing in self._prepared.keys():
self._prepared[self._is_preparing] = True
cycle = all(self._prepared.values())
self._handle_buttons_enabled(True, cycle=cycle)
self._handle_stslabels_content()
self.progress_list.addItem(item)
self.progress_list.scrollToBottom()
def _handle_buttons_enabled(self, enable, cycle=False):
self.save_timing_bt.setEnabled(enable)
self.prepare_timing_bt.setEnabled(enable)
self.set_ps_sofbmode_off_bt.setEnabled(enable)
self.set_ps_opmode_slowref_bt.setEnabled(enable)
self.set_ps_current_zero_bt.setEnabled(enable)
self.prepare_ps_params_bt.setEnabled(enable)
self.prepare_ps_opmode_bt.setEnabled(enable)
self.cycle_trims_bt.setEnabled(enable)
self.cycle_bt.setEnabled(cycle)
self.restore_timing_bt.setEnabled(enable)
self.clearhist_bt.setEnabled(enable)
self.pwrsupplies_tree.setEnabled(enable)
def _handle_stslabels_content(self):
for prep, value in self._prepared.items():
pixmap = self._pixmap_check if value else self._pixmap_not
self._prepared_labels[prep].setPixmap(pixmap)
def _set_lastcomm(self):
sender_text = self.sender().text()
self.label_lastcomm.setText('Last Command: ' + sender_text)
def _clear_lastcomm(self):
self.progress_bar.setValue(0)
self.progress_list.clear()
self.label_lastcomm.setText('Last Command: ')
# --- handle ps selection ---
def _get_ps_list(self):
"""Return list of power supplies to cycle."""
# Get power supplies list
pwrsupplies = self.pwrsupplies_tree.checked_items()
if not pwrsupplies:
QMessageBox.critical(self, 'Message', 'No power supply selected!')
return False
sections = get_sections(pwrsupplies)
if 'BO' in sections and len(sections) > 1:
QMessageBox.critical(self, 'Error',
'Can not cycle Booster with other sectors!')
return False
create_task = CreateCyclers(parent=self, psnames=pwrsupplies)
dlg = ProgressDialog('Creating cycles...', create_task, self)
ret = dlg.exec_()
if ret == dlg.Rejected:
return False
return pwrsupplies
def _handle_checked_items_changed(self, item):
psname = PVName(item.data(0, Qt.DisplayRole))
if not _re.match('.*-.*:.*-.*', psname):
return
if not self._is_adv_mode and psname.sec == 'SI' and \
not psname.dev.startswith('FC'):
psname2check = Filter.process_filters(self._psnames,
filters={
'sec': 'SI',
'dev': '(?!FC)'
})
psname2check.remove(psname)
state2set = item.checkState(0)
self.pwrsupplies_tree.tree.blockSignals(True)
for psn in psname2check:
item2check = self.pwrsupplies_tree._item_map[psn]
if item2check.checkState(0) != state2set:
item2check.setData(0, Qt.CheckStateRole, state2set)
self.pwrsupplies_tree.tree.blockSignals(False)
else:
if (psname.sec in ['BO', 'SI'] and psname.dev in ['B', 'B1B2']):
psname2check = PSSearch.get_psnames({
'sec': psname.sec,
'dev': 'B.*'
})
psname2check.remove(psname)
item2check = self.pwrsupplies_tree._item_map[psname2check[0]]
state2set = item.checkState(0)
state2change = item2check.checkState(0)
if state2change != state2set:
self.pwrsupplies_tree.tree.blockSignals(True)
item2check.setData(0, Qt.CheckStateRole, state2set)
self.pwrsupplies_tree.tree.blockSignals(False)
self._prepared.update(self._prepared_init_vals)
self._needs_update_setup = True
def _update_setup(self):
if not self._needs_update_setup:
return
self._needs_update_setup = False
# update leds
psnames = self.pwrsupplies_tree.checked_items()
ti_ch = [
PVName(name).substitute(prefix=VACA_PREFIX)
for name in self._timing.get_pvnames_by_psnames(psnames)
]
self.ticonn_led.set_channels(ti_ch)
ps_ch = list()
for name in psnames:
ps_ch.append(
PVName(name).substitute(prefix=VACA_PREFIX,
propty='PwrState-Sts'))
self.psconn_led.set_channels(ps_ch)
# update buttons and self._prepared dict if not in advanced mode
if not self._is_adv_mode:
has_si = False
for psn in PSSearch.get_psnames({'sec': 'SI', 'dis': 'PS'}):
if psn not in self.pwrsupplies_tree._item_map:
continue
item = self.pwrsupplies_tree._item_map[psn]
has_si |= item.checkState(0) != 0
if not has_si:
self.cycle_bt.setText('8. Cycle')
self.restore_timing_bt.setText(
'9. Restore Timing Initial State')
self.cycle_trims_bt.setVisible(False)
self.cycle_trims_lb.setVisible(False)
self._prepared['trims'] = True
else:
self.cycle_bt.setText('9. Cycle')
self.restore_timing_bt.setText(
'10. Restore Timing Initial State')
self.cycle_trims_bt.setVisible(True)
self.cycle_trims_lb.setVisible(True)
self._prepared['trims'] = False
self._handle_stslabels_content()
self._handle_buttons_enabled(True)
# --- auxiliary checks ---
def _check_connected(self, control):
if control in ['trims', 'cycle']:
leds = [self.ticonn_led, self.psconn_led]
elif 'timing' in control:
leds = [
self.ticonn_led,
]
else:
leds = [
self.psconn_led,
]
for led in leds:
pvs_disconnected = set()
for ch, v in led.channels2conn.items():
if not v:
pvs_disconnected.add(ch)
if pvs_disconnected:
sttr = ''
for item in pvs_disconnected:
sttr += item + '\n'
QMessageBox.information(
self, 'Message',
'The following PVs are not connected:\n' + sttr)
return False
return True
def _verify_ps(self, pwrsupplies):
self._ps_failed = set()
task = VerifyPS(parent=self, psnames=pwrsupplies)
task.itemDone.connect(self._get_ps_not_ready_2_cycle)
dlg = ProgressDialog('Verifying power supplies initial state...', task,
self)
ret = dlg.exec_()
if ret == dlg.Rejected:
self._handle_buttons_enabled(True)
return False
if self._ps_failed:
text = 'Verify power state and interlocks' \
' of the following power supplies'
dlg = PSStatusDialog(self._ps_failed, text, self)
dlg.exec_()
self._handle_buttons_enabled(True)
return False
return True
def _get_ps_not_ready_2_cycle(self, psname, status):
if not status:
self._ps_failed.add(psname)
def _open_ps_detail(self, item):
if self.sender() == self.progress_list:
text_split = item.data(Qt.DisplayRole).split(' ')
psname = ''
for text in text_split:
if _re.match('.*-.*:.*-.*', text):
psname = text
if not psname:
return
else:
psname = item.data()
if not _re.match('.*-.*:.*-.*', psname):
if item.model().rowCount(item) == 1:
psname = item.child(0, 0).data()
else:
return
run_newprocess(['sirius-hla-as-ps-detail.py', psname])
# --- events ---
def keyPressEvent(self, evt):
"""Implement keyPressEvent."""
if evt.matches(QKeySequence.Copy) and self.progress_list.underMouse():
items = self.progress_list.selectedItems()
items = '\n'.join([i.text() for i in items])
QApplication.clipboard().setText(items)
if evt.key() == Qt.Key_Escape and self.progress_list.underMouse():
items = self.progress_list.clearSelection()
super().keyPressEvent(evt)
def closeEvent(self, ev):
self._update_setup_timer.stop()
super().closeEvent(ev)
class SelectFromListDialog(QDialog):
"""Dialog box for selecting multiple items.
The original order of items are preserved in the candidate list.
"""
def __init__(self, parent=None, allItems=(), selectedItems=()):
QDialog.__init__(
self, parent, flags=Qt.WindowSystemMenuHint | Qt.WindowTitleHint)
self.allItems = allItems
self.fromKeys = list(range(len(allItems)))
self.selectedKeys = []
for item in selectedItems:
key = allItems.index(item)
self.fromKeys.remove(key)
self.selectedKeys.append(key)
self.setAttribute(Qt.WA_DeleteOnClose)
fromLabel = QLabel(_("Select from"))
self.fromList = QListWidget(self)
self.fromList.addItems(allItems[key] for key in self.fromKeys)
selectedLabel = QLabel(_("Selected"))
self.selectedList = QListWidget(self)
self.selectedList.addItems(allItems[key] for key in self.selectedKeys)
self.selectButton = QPushButton(_("Select"))
self.deselectButton = QPushButton(_("Deselect"))
self.selectBox = QDialogButtonBox(Qt.Vertical)
self.selectBox.addButton(self.selectButton, QDialogButtonBox.ActionRole)
self.selectBox.addButton(self.deselectButton, QDialogButtonBox.ActionRole)
self.selectButton.clicked.connect(self.on_select)
self.deselectButton.clicked.connect(self.on_deselect)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(
QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
mainLayout = QGridLayout(self)
mainLayout.addWidget(fromLabel, 0, 0)
mainLayout.addWidget(selectedLabel, 0, 2)
mainLayout.addWidget(self.fromList, 1, 0)
mainLayout.addWidget(self.selectBox, 1, 1)
mainLayout.addWidget(self.selectedList, 1, 2)
mainLayout.addWidget(self.buttonBox, 2, 0, 1, 3)
mainLayout.setAlignment(self.selectBox, Qt.AlignCenter)
self.setLayout(mainLayout)
def on_select(self):
if len(self.fromList.selectedItems()):
idx = self.fromList.currentRow()
key = self.fromKeys.pop(idx)
self.selectedKeys.append(key)
item = self.fromList.takeItem(idx)
self.selectedList.addItem(item)
def on_deselect(self):
if len(self.selectedList.selectedItems()):
idx = self.selectedList.currentRow()
item = self.selectedList.takeItem(idx)
key = self.selectedKeys.pop(idx)
idx = next((i for i, v in enumerate(self.fromKeys) if v > key),
len(self.fromKeys))
self.fromKeys.insert(idx, key)
self.fromList.insertItem(idx, item)
class PSTestWindow(SiriusMainWindow):
"""PS test window."""
def __init__(self, parent=None, adv_mode=False):
"""Constructor."""
super().__init__(parent)
self.setWindowTitle('PS/PU Test')
self.setObjectName('ASApp')
cor = get_appropriate_color(section='AS')
self.setWindowIcon(qta.icon('mdi.test-tube', color=cor))
# auxiliar data for initializing SI Fam PS
self._is_adv_mode = adv_mode
self._si_fam_psnames = PSSearch.get_psnames(filters={
'sec': 'SI',
'sub': 'Fam',
'dis': 'PS'
})
# auxiliary data for SI fast correctors
self._si_fastcorrs = PSSearch.get_psnames(filters={
'sec': 'SI',
'dis': 'PS',
'dev': 'FC.*'
})
self._needs_update_setup = False
self._setup_ui()
self._update_setup_timer = QTimer(self)
self._update_setup_timer.timeout.connect(self._update_setup)
self._update_setup_timer.setInterval(250)
self._update_setup_timer.start()
def _setup_ui(self):
# setup central widget
self.central_widget = QFrame()
self.central_widget.setStyleSheet("""
#OkList {
background-color: #eafaea;
}
#NokList {
background-color: #ffebe6;
}
QLabel{
max-height: 1.29em;
}
QTabWidget::pane {
border-left: 2px solid gray;
border-bottom: 2px solid gray;
border-right: 2px solid gray;
}""")
self.setCentralWidget(self.central_widget)
self.tab = QTabWidget(self)
self.tab.setObjectName('ASTab')
# # PS
self.ps_wid = QWidget(self)
lay_ps = QGridLayout(self.ps_wid)
lay_ps.setContentsMargins(0, 9, 0, 0)
lay_ps.setHorizontalSpacing(0)
# PS selection
self.ps_tree = PVNameTree(items=self._get_ps_tree_names(),
tree_levels=('sec', 'mag_group'),
parent=self)
self.ps_tree.tree.setHeaderHidden(True)
self.ps_tree.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
self.ps_tree.tree.setColumnCount(1)
self.ps_tree.tree.doubleClicked.connect(self._open_detail)
self.ps_tree.tree.itemChanged.connect(
self._handle_checked_items_changed)
gbox_ps_select = QGroupBox('Select PS: ', self)
gbox_ps_select.setObjectName('select')
gbox_ps_select.setStyleSheet("""
#select{
border-top: 0px solid transparent;
border-left: 0px solid transparent;
border-bottom: 0px solid transparent;
}""")
lay_ps_select = QVBoxLayout(gbox_ps_select)
lay_ps_select.addWidget(self.ps_tree)
lay_ps.addWidget(gbox_ps_select, 0, 0)
lay_ps.setColumnStretch(0, 1)
# PS commands
self.checkcomm_ps_bt = QPushButton('Check Communication', self)
self.checkcomm_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.checkcomm_ps_bt.clicked.connect(self._check_comm)
self.checkcomm_ps_bt.setToolTip(
'Check PS and DCLinks communication status (verify invalid alarms '
'and, if LI, the value of Connected-Mon PV)')
self.checkstatus_ps_bt = QPushButton('Show Status Summary', self)
self.checkstatus_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.checkstatus_ps_bt.clicked.connect(_part(self._check_status, 'PS'))
self.checkstatus_ps_bt.setToolTip(
'Check PS and DCLinks interlock status and, if powered on, '
'check if it is following reference')
self.dsbltrigger_ps_bt = QPushButton('Disable PS triggers', self)
self.dsbltrigger_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.dsbltrigger_ps_bt.clicked.connect(
_part(self._set_check_trigger_state, 'PS', 'dsbl'))
self.setsofbmode_ps_bt = QPushButton('Turn Off SOFBMode', self)
self.setsofbmode_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.setsofbmode_ps_bt.clicked.connect(
_part(self._set_check_fbp_sofbmode, 'off'))
self.setslowref_ps_bt = QPushButton('Set PS and DCLinks to SlowRef',
self)
self.setslowref_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.setslowref_ps_bt.clicked.connect(self._set_check_opmode_slowref)
self.currzero_ps_bt1 = QPushButton('Set PS Current to zero', self)
self.currzero_ps_bt1.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.currzero_ps_bt1.clicked.connect(self._set_zero_ps)
self.reset_ps_bt = QPushButton('Reset PS and DCLinks', self)
self.reset_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.reset_ps_bt.clicked.connect(_part(self._reset_intlk, 'PS'))
self.prep_sidclink_bt = QPushButton('Prepare SI Fam DCLinks', self)
self.prep_sidclink_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.prep_sidclink_bt.clicked.connect(self._prepare_sidclinks)
self.prep_sidclink_bt.setVisible(False)
self.init_sips_bt = QPushButton('Initialize SI Fam PS', self)
self.init_sips_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.init_sips_bt.clicked.connect(self._set_check_pwrstateinit)
self.init_sips_bt.setVisible(False)
self.aux_label = QLabel('')
self.aux_label.setVisible(False)
self.turnon_dcl_bt = QPushButton('Turn DCLinks On', self)
self.turnon_dcl_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.turnon_dcl_bt.clicked.connect(
_part(self._set_check_pwrstate_dclinks, 'on'))
self.checkctrlloop_dcl_bt = QPushButton('Check DCLinks CtrlLoop', self)
self.checkctrlloop_dcl_bt.clicked.connect(
_part(self._set_lastcomm, 'PS'))
self.checkctrlloop_dcl_bt.clicked.connect(
_part(self._set_check_ctrlloop, 'dclink'))
self.setvolt_dcl_bt = QPushButton('Set DCLinks Voltage', self)
self.setvolt_dcl_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.setvolt_dcl_bt.clicked.connect(self._set_check_dclinks_capvolt)
self.turnon_ps_bt = QPushButton('Turn PS On', self)
self.turnon_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.turnon_ps_bt.clicked.connect(
_part(self._set_check_pwrstate, 'PS', 'on', True))
self.setcheckctrlloop_ps_bt = QPushButton('Check PS CtrlLoop', self)
self.setcheckctrlloop_ps_bt.clicked.connect(
_part(self._set_lastcomm, 'PS'))
self.setcheckctrlloop_ps_bt.clicked.connect(
_part(self._set_check_ctrlloop, 'pwrsupply'))
self.test_ps_bt = QPushButton('Set PS Current to test value', self)
self.test_ps_bt.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.test_ps_bt.clicked.connect(self._set_test_ps)
self.currzero_ps_bt2 = QPushButton('Set PS Current to zero', self)
self.currzero_ps_bt2.clicked.connect(_part(self._set_lastcomm, 'PS'))
self.currzero_ps_bt2.clicked.connect(self._set_zero_ps)
self.restoretrigger_ps_bt = QPushButton('Restore PS triggers', self)
self.restoretrigger_ps_bt.clicked.connect(
_part(self._set_lastcomm, 'PS'))
self.restoretrigger_ps_bt.clicked.connect(
_part(self._restore_triggers_state, 'PS'))
gbox_ps_comm = QGroupBox('Commands', self)
gbox_ps_comm.setObjectName('comm')
gbox_ps_comm.setStyleSheet('#comm{border: 0px solid transparent;}')
lay_ps_comm = QVBoxLayout(gbox_ps_comm)
lay_ps_comm.setContentsMargins(20, 9, 20, 9)
lay_ps_comm.addWidget(QLabel(''))
lay_ps_comm.addWidget(
QLabel('<h4>Check</h4>', self, alignment=Qt.AlignCenter))
lay_ps_comm.addWidget(self.checkcomm_ps_bt)
lay_ps_comm.addWidget(self.checkstatus_ps_bt)
lay_ps_comm.addWidget(QLabel(''))
lay_ps_comm.addWidget(
QLabel('<h4>Prepare</h4>', self, alignment=Qt.AlignCenter))
lay_ps_comm.addWidget(self.dsbltrigger_ps_bt)
lay_ps_comm.addWidget(self.setsofbmode_ps_bt)
lay_ps_comm.addWidget(self.setslowref_ps_bt)
lay_ps_comm.addWidget(self.currzero_ps_bt1)
lay_ps_comm.addWidget(self.reset_ps_bt)
lay_ps_comm.addWidget(QLabel(''))
lay_ps_comm.addWidget(self.prep_sidclink_bt)
lay_ps_comm.addWidget(self.init_sips_bt)
lay_ps_comm.addWidget(self.aux_label)
lay_ps_comm.addWidget(
QLabel('<h4>Config DCLinks</h4>', self, alignment=Qt.AlignCenter))
lay_ps_comm.addWidget(self.turnon_dcl_bt)
lay_ps_comm.addWidget(self.checkctrlloop_dcl_bt)
lay_ps_comm.addWidget(self.setvolt_dcl_bt)
lay_ps_comm.addWidget(QLabel(''))
lay_ps_comm.addWidget(
QLabel('<h4>Test</h4>', self, alignment=Qt.AlignCenter))
lay_ps_comm.addWidget(self.turnon_ps_bt)
lay_ps_comm.addWidget(self.setcheckctrlloop_ps_bt)
lay_ps_comm.addWidget(self.test_ps_bt)
lay_ps_comm.addWidget(self.currzero_ps_bt2)
lay_ps_comm.addWidget(QLabel(''))
lay_ps_comm.addWidget(
QLabel('<h4>Restore</h4>', self, alignment=Qt.AlignCenter))
lay_ps_comm.addWidget(self.restoretrigger_ps_bt)
lay_ps_comm.addWidget(QLabel(''))
lay_ps.addWidget(gbox_ps_comm, 0, 1)
lay_ps.setColumnStretch(1, 1)
self.tab.addTab(self.ps_wid, 'PS')
# # PU
self.pu_wid = QWidget(self)
lay_pu = QGridLayout(self.pu_wid)
lay_pu.setContentsMargins(0, 9, 0, 0)
lay_pu.setHorizontalSpacing(0)
# PU selection
self.pu_tree = PVNameTree(items=self._get_pu_tree_names(),
tree_levels=('sec', ),
parent=self)
self.pu_tree.tree.setHeaderHidden(True)
self.pu_tree.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
self.pu_tree.tree.setColumnCount(1)
self.pu_tree.tree.doubleClicked.connect(self._open_detail)
gbox_pu_select = QGroupBox('Select PU: ', self)
gbox_pu_select.setObjectName('select')
gbox_pu_select.setStyleSheet("""
#select{
border-top: 0px solid transparent;
border-left: 0px solid transparent;
border-bottom: 0px solid transparent;
}""")
lay_pu_select = QVBoxLayout(gbox_pu_select)
lay_pu_select.addWidget(self.pu_tree)
lay_pu.addWidget(gbox_pu_select, 0, 0)
lay_pu.setColumnStretch(0, 1)
# PU commands
self.checkstatus_pu_bt = QPushButton('Show Status Summary', self)
self.checkstatus_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.checkstatus_pu_bt.clicked.connect(_part(self._check_status, 'PU'))
self.checkstatus_pu_bt.setToolTip(
'Check PU interlock status and, if powered on, '
'check if it is following voltage setpoint')
self.voltzero_pu_bt1 = QPushButton('Set PU Voltage to zero', self)
self.voltzero_pu_bt1.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.voltzero_pu_bt1.clicked.connect(_part(self._set_zero_pu, False))
self.reset_pu_bt = QPushButton('Reset PU', self)
self.reset_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.reset_pu_bt.clicked.connect(_part(self._reset_intlk, 'PU'))
self.turnon_pu_bt = QPushButton('Turn PU On', self)
self.turnon_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.turnon_pu_bt.clicked.connect(
_part(self._set_check_pwrstate, 'PU', 'on', True))
self.enblpulse_pu_bt = QPushButton('Enable PU Pulse', self)
self.enblpulse_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.enblpulse_pu_bt.clicked.connect(_part(self._set_check_pulse,
'on'))
self.enbltrigger_pu_bt = QPushButton('Enable PU triggers', self)
self.enbltrigger_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.enbltrigger_pu_bt.clicked.connect(
_part(self._set_check_trigger_state, 'PU', 'on'))
self.test_pu_bt = QPushButton('Set PU Voltage to test value', self)
self.test_pu_bt.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.test_pu_bt.clicked.connect(self._set_test_pu)
self.voltzero_pu_bt2 = QPushButton('Set PU Voltage to zero', self)
self.voltzero_pu_bt2.clicked.connect(_part(self._set_lastcomm, 'PU'))
self.voltzero_pu_bt2.clicked.connect(_part(self._set_zero_pu, True))
self.restoretrigger_pu_bt = QPushButton('Restore PU triggers', self)
self.restoretrigger_pu_bt.clicked.connect(
_part(self._set_lastcomm, 'PU'))
self.restoretrigger_pu_bt.clicked.connect(
_part(self._restore_triggers_state, 'PU'))
gbox_pu_comm = QGroupBox('Commands', self)
gbox_pu_comm.setObjectName('comm')
gbox_pu_comm.setStyleSheet('#comm{border: 0px solid transparent;}')
lay_pu_comm = QVBoxLayout(gbox_pu_comm)
lay_pu_comm.setContentsMargins(20, 9, 20, 9)
lay_pu_comm.addWidget(QLabel(''))
lay_pu_comm.addWidget(
QLabel('<h4>Check</h4>', self, alignment=Qt.AlignCenter))
lay_pu_comm.addWidget(self.checkstatus_pu_bt)
lay_pu_comm.addWidget(QLabel(''))
lay_pu_comm.addWidget(
QLabel('<h4>Prepare</h4>', self, alignment=Qt.AlignCenter))
lay_pu_comm.addWidget(self.voltzero_pu_bt1)
lay_pu_comm.addWidget(self.reset_pu_bt)
lay_pu_comm.addWidget(QLabel(''))
lay_pu_comm.addWidget(
QLabel('<h4>Test</h4>', self, alignment=Qt.AlignCenter))
lay_pu_comm.addWidget(self.turnon_pu_bt)
lay_pu_comm.addWidget(self.enblpulse_pu_bt)
lay_pu_comm.addWidget(self.enbltrigger_pu_bt)
lay_pu_comm.addWidget(self.test_pu_bt)
lay_pu_comm.addWidget(self.voltzero_pu_bt2)
lay_pu_comm.addWidget(QLabel(''))
lay_pu_comm.addWidget(
QLabel('<h4>Restore</h4>', self, alignment=Qt.AlignCenter))
lay_pu_comm.addWidget(self.restoretrigger_pu_bt)
lay_pu_comm.addWidget(QLabel(''))
lay_pu.addWidget(gbox_pu_comm, 0, 1)
lay_pu.setColumnStretch(1, 1)
self.tab.addTab(self.pu_wid, 'PU')
# lists
self.label_lastcomm = QLabel('Last Command: ', self)
self.ok_ps = QListWidget(self)
self.ok_ps.setObjectName('OkList')
self.ok_ps.doubleClicked.connect(self._open_detail)
self.ok_ps.setSelectionMode(QAbstractItemView.MultiSelection)
self.ok_ps.setToolTip(
'Select rows and press Ctrl+C to copy and Esc to deselect.')
self.nok_ps = QListWidget(self)
self.nok_ps.setObjectName('NokList')
self.nok_ps.doubleClicked.connect(self._open_detail)
self.nok_ps.setSelectionMode(QAbstractItemView.MultiSelection)
self.nok_ps.setToolTip(
'Select rows and press Ctrl+C to copy and Esc to deselect.')
self.clearlists_bt = QPushButton('Clear', self)
self.clearlists_bt.clicked.connect(self._clear_lastcomm)
self.ok_ps_aux_list = list()
self.nok_ps_aux_list = list()
hbox = QHBoxLayout()
hbox.addWidget(self.label_lastcomm)
hbox.addWidget(self.clearlists_bt, alignment=Qt.AlignRight)
list_layout = QGridLayout()
list_layout.setContentsMargins(0, 0, 0, 0)
list_layout.setVerticalSpacing(6)
list_layout.setHorizontalSpacing(9)
list_layout.addLayout(hbox, 0, 0, 1, 2)
list_layout.addWidget(
QLabel('<h4>Ok</h4>', self, alignment=Qt.AlignCenter), 1, 0)
list_layout.addWidget(self.ok_ps, 2, 0)
list_layout.addWidget(
QLabel('<h4>Failed</h4>', self, alignment=Qt.AlignCenter), 1, 1)
list_layout.addWidget(self.nok_ps, 2, 1)
# menu
self.menu = self.menuBar()
self.act_cycle = self.menu.addAction('Open Cycle Window')
connect_newprocess(self.act_cycle,
'sirius-hla-as-ps-cycle.py',
parent=self)
self.aux_comm = self.menu.addMenu('Auxiliary commands')
# # auxiliary PS
self.ps_menu = self.aux_comm.addMenu('PS')
self.act_turnoff_ps = self.ps_menu.addAction('Turn PS Off')
self.act_turnoff_ps.triggered.connect(_part(self._set_lastcomm, 'PS'))
self.act_turnoff_ps.triggered.connect(
_part(self._set_check_pwrstate, 'PS', 'off', True))
self.act_turnoff_dclink = self.ps_menu.addAction('Turn DCLinks Off')
self.act_turnoff_dclink.triggered.connect(
_part(self._set_lastcomm, 'PS'))
self.act_turnoff_dclink.triggered.connect(
_part(self._set_check_pwrstate_dclinks, 'off'))
self.act_setcurrent_ps = self.ps_menu.addAction('Set PS Current')
self.act_setcurrent_ps.triggered.connect(
_part(self._set_lastcomm, 'PS'))
self.act_setcurrent_ps.triggered.connect(self._set_check_current)
self.act_opmode_ps = self.ps_menu.addAction('Set PS OpMode')
self.act_opmode_ps.triggered.connect(_part(self._set_lastcomm, 'PS'))
self.act_opmode_ps.triggered.connect(self._set_check_opmode)
# # auxiliary PU
self.pu_menu = self.aux_comm.addMenu('PU')
self.act_turnoff_pu = self.pu_menu.addAction('Turn PU Off')
self.act_turnoff_pu.triggered.connect(_part(self._set_lastcomm, 'PU'))
self.act_turnoff_pu.triggered.connect(
_part(self._set_check_pwrstate, 'PU', 'off', True))
self.act_dsblpulse_pu = self.pu_menu.addAction('Disable PU Pulse')
self.act_dsblpulse_pu.triggered.connect(_part(self._set_lastcomm,
'PU'))
self.act_dsblpulse_pu.triggered.connect(
_part(self._set_check_pulse, 'off'))
# layout
lay = QGridLayout()
lay.setHorizontalSpacing(15)
lay.setVerticalSpacing(5)
lay.addWidget(
QLabel('<h3>Power Supplies Test</h3>',
self,
alignment=Qt.AlignCenter), 0, 0, 1, 3)
lay.addWidget(self.tab, 1, 0)
lay.addLayout(list_layout, 1, 1)
lay.setColumnStretch(0, 2)
lay.setColumnStretch(1, 2)
lay.setRowStretch(0, 2)
lay.setRowStretch(1, 18)
self.central_widget.setLayout(lay)
# ---------- commands ------------
def _check_comm(self):
self.ok_ps.clear()
self.nok_ps.clear()
devices = self._get_selected_ps()
if not devices:
return
dclinks = self._get_related_dclinks(devices, include_regatrons=True)
devices.extend(dclinks)
task0 = CreateTesters(devices, parent=self)
task1 = CheckComm(devices, parent=self)
task1.itemDone.connect(self._log)
labels = [
'Connecting to devices...',
'Checking PS and DCLinks Comm. Status...'
]
tasks = [task0, task1]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _check_status(self, dev_type):
self.ok_ps.clear()
self.nok_ps.clear()
if dev_type == 'PS':
devices = self._get_selected_ps()
if not devices:
return
dclinks = self._get_related_dclinks(devices,
include_regatrons=True)
devices.extend(dclinks)
label1 = 'Reading PS and DCLinks Status...'
elif dev_type == 'PU':
devices = self._get_selected_pu()
if not devices:
return
label1 = 'Reading PU Status...'
task0 = CreateTesters(devices, parent=self)
task1 = CheckStatus(devices, parent=self)
task1.itemDone.connect(self._log)
labels = ['Connecting to devices...', label1]
tasks = [task0, task1]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _set_check_trigger_state(self, dev_type, state):
self.ok_ps.clear()
self.nok_ps.clear()
if dev_type == 'PS':
devices = self._get_selected_ps()
elif dev_type == 'PU':
devices = self._get_selected_pu()
if not devices:
return
task1 = SetTriggerState(parent=self,
dis=dev_type,
state=state,
devices=devices)
task2 = CheckTriggerState(parent=self,
dis=dev_type,
state=state,
devices=devices)
task2.itemDone.connect(self._log)
tasks = [task1, task2]
labels = [
'Disabling ' + dev_type + ' triggers...',
'Checking ' + dev_type + ' trigger states...'
]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _set_check_opmode_slowref(self):
self.ok_ps.clear()
self.nok_ps.clear()
devices = self._get_selected_ps()
if not devices:
return
dclinks = self._get_related_dclinks(devices)
devices.extend(dclinks)
devices = [dev for dev in devices if 'LI-' not in dev]
task0 = CreateTesters(devices, parent=self)
task1 = SetOpMode(devices, state=_PSC.OpMode.SlowRef, parent=self)
task2 = CheckOpMode(devices,
state=[
_PSC.States.SlowRef, _PSC.States.Off,
_PSC.States.Interlock
],
parent=self)
task2.itemDone.connect(self._log)
labels = [
'Connecting to devices...', 'Setting PS OpMode to SlowRef...',
'Checking PS OpMode...'
]
tasks = [task0, task1, task2]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _reset_intlk(self, dev_type):
self.ok_ps.clear()
self.nok_ps.clear()
if dev_type == 'PS':
devices = self._get_selected_ps()
if not devices:
return
dclinks = self._get_related_dclinks(devices,
include_regatrons=True)
devices.extend(dclinks)
dev_label = 'PS and DCLinks'
elif dev_type == 'PU':
devices = self._get_selected_pu()
if not devices:
return
dev_label = 'PU'
devices_not_rst = {
dev
for dev in devices
if dev.sec != 'LI' and dev.dev not in ('FCH', 'FCV')
}
task0 = CreateTesters(devices, parent=self)
task1 = ResetIntlk(devices_not_rst, parent=self)
task2 = CheckIntlk(devices, parent=self)
task2.itemDone.connect(self._log)
tasks = [task0, task1, task2]
labels = [
'Connecting to devices...', 'Reseting ' + dev_label + '...',
'Checking ' + dev_label + ' Interlocks...'
]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
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 _prepare_sidclinks(self):
self.ok_ps.clear()
self.nok_ps.clear()
selected = self._get_selected_ps()
ps2check = [ps for ps in selected if ps in self._si_fam_psnames]
dclinks = self._get_related_dclinks(ps2check, include_regatrons=True)
if not ps2check:
return
# if power state is on, do nothing
self.ok_ps_aux_list.clear()
self.nok_ps_aux_list.clear()
self._check_pwrstate(ps2check, state='on', is_test=False, show=False)
if set(self.ok_ps_aux_list) == set(ps2check):
for dev in dclinks:
self._log(dev, True)
return
ps2act = list(self.nok_ps_aux_list) # act in PS off
dcl2act = self._get_related_dclinks(ps2act, include_regatrons=True)
# print('act', ps2act, dcl2act)
# if need initializing, check if DCLinks are turned off
self.ok_ps_aux_list.clear()
self.nok_ps_aux_list.clear()
self._check_pwrstate(dcl2act, state='off', is_test=False, show=False)
if not self.nok_ps_aux_list:
for dev in dclinks:
self._log(dev, True)
return
dcl2ctrl = list(self.nok_ps_aux_list) # control DCLink on
dcl_ok = set(dclinks) - set(dcl2ctrl)
ps2ctrl = set() # get related psnames
for dcl in dcl2ctrl:
pss = PSSearch.conv_dclink_2_psname(dcl)
ps2ctrl.update(pss)
# print('ctrl', ps2ctrl, dcl2ctrl)
# if some DCLink is on, make sure related PS are turned off
self.ok_ps_aux_list.clear()
self.nok_ps_aux_list.clear()
self._check_pwrstate(ps2ctrl, state='off', is_test=False, show=False)
if self.nok_ps_aux_list:
ps2ctrl = list(self.nok_ps_aux_list)
self.ok_ps_aux_list.clear()
self.nok_ps_aux_list.clear()
self._set_zero_ps(ps2ctrl, show=False)
self.ok_ps_aux_list.clear()
self.nok_ps_aux_list.clear()
self._set_check_pwrstate(dev_type=ps2ctrl, state='off', show=False)
if self.nok_ps_aux_list:
for dev in self.ok_ps_aux_list:
self._log(dev, True)
for dev in self.nok_ps_aux_list:
self._log(dev, False)
text = 'The listed PS seems to be taking too\n'\
'long to turn off.\n'\
'Try to execute this step once again.'
QMessageBox.warning(self, 'Message', text)
return
# finally, turn DCLinks off
self._set_check_pwrstate_dclinks(state='off',
devices=dcl2ctrl,
ps2check=ps2ctrl)
# log DCLinks Ok
for dev in dcl_ok:
self._log(dev, True)
def _set_check_pwrstateinit(self):
self.ok_ps.clear()
self.nok_ps.clear()
selected = self._get_selected_ps()
devices = [ps for ps in selected if ps in self._si_fam_psnames]
if not devices:
return
# if power state is on, do nothing
self.ok_ps_aux_list.clear()
self.nok_ps_aux_list.clear()
self._check_pwrstate(devices, state='on', is_test=False, show=False)
if len(self.ok_ps_aux_list) == len(devices):
for dev in self.ok_ps_aux_list:
self._log(dev, True)
return
# if need initializing, check if DCLinks are turned off before continue
ps_ok = list(self.ok_ps_aux_list)
ps2ctrl = list(self.nok_ps_aux_list) # check PS off
dcl2check = self._get_related_dclinks(ps2ctrl, include_regatrons=True)
# print('set_check_pwrstateinit', ps2ctrl)
self.ok_ps_aux_list.clear()
self.nok_ps_aux_list.clear()
self._check_pwrstate(dcl2check, state='off', is_test=False, show=False)
if len(self.nok_ps_aux_list) > 0:
for dev in self.ok_ps_aux_list:
self._log(dev, True)
for dev in self.nok_ps_aux_list:
self._log(dev, False)
QMessageBox.critical(
self, 'Message', 'Make sure related DCLinks are turned\n'
'off before initialize SI Fam PS!')
return
# list in Ok PS already on
for dev in ps_ok:
self._log(dev, True)
# then, initialize SI Fam PS
task0 = CreateTesters(ps2ctrl, parent=self)
task1 = SetPwrState(ps2ctrl, state='on', parent=self)
task2 = CheckOpMode(ps2ctrl,
state=_PSC.States.Initializing,
parent=self)
task2.itemDone.connect(self._log)
tasks = [task0, task1, task2]
labels = [
'Connecting to devices...', 'Initializing SI Fam PS...',
'Checking SI Fam PS initialized...'
]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _set_check_pulse(self, state):
self.ok_ps.clear()
self.nok_ps.clear()
devices = self._get_selected_pu()
if not devices:
return
task0 = CreateTesters(devices, parent=self)
task1 = SetPulse(devices, state=state, parent=self)
task2 = CheckPulse(devices, state=state, parent=self)
task2.itemDone.connect(self._log)
tasks = [task0, task1, task2]
labels = [
'Connecting to devices...', 'Turning PU Pulse ' + state + '...',
'Checking PU Pulse ' + state + '...'
]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _set_check_pwrstate_dclinks(self,
state,
devices=list(),
ps2check=list()):
self.ok_ps.clear()
self.nok_ps.clear()
if not devices:
pwrsupplies = self._get_selected_ps()
if not pwrsupplies:
return
devices = self._get_related_dclinks(pwrsupplies,
include_regatrons=True)
ps2check = set()
for dev in devices:
ps2check.update(PSSearch.conv_dclink_2_psname(dev))
if not devices:
return
if state == 'off':
self.ok_ps_aux_list.clear()
self.nok_ps_aux_list.clear()
self._check_pwrstate(ps2check, state='offintlk', show=False)
if len(self.nok_ps_aux_list) > 0:
for dev in self.ok_ps_aux_list:
self._log(dev, True)
for dev in self.nok_ps_aux_list:
self._log(dev, False)
QMessageBox.critical(
self, 'Message', 'Make sure all related power supplies\n'
'are turned off before turning DCLinks off!')
return
task0 = CreateTesters(devices, parent=self)
task1 = SetPwrState(devices, state=state, parent=self)
task2 = CheckPwrState(devices, state=state, is_test=True, parent=self)
tasks = [task0, task1, task2]
labels = [
'Connecting to DCLinks...', 'Turning DCLinks ' + state + '...',
'Checking DCLinks powered ' + state + '...'
]
if state == 'on':
task3 = CheckInitOk(devices, parent=self)
task3.itemDone.connect(self._log)
tasks.append(task3)
labels.append('Wait DCLinks initialize...')
else:
task2.itemDone.connect(self._log)
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
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 _set_check_ctrlloop(self, dev_type='pwrsupply'):
self.ok_ps.clear()
self.nok_ps.clear()
pwrsupplies = self._get_selected_ps()
if not pwrsupplies:
return
devices_set = {}
if dev_type == 'pwrsupply':
devices = {dev for dev in pwrsupplies if 'LI' not in dev}
devices_set = {dev for dev in devices if dev.dev in ('FCH', 'FCV')}
else:
devices = self._get_related_dclinks(pwrsupplies)
if not devices:
return
tasks = [
CreateTesters(devices, parent=self),
]
labels = [
'Connecting to devices...',
]
if devices_set:
task1 = SetCtrlLoop(devices_set, parent=self)
task2 = CheckCtrlLoop(devices, parent=self)
task2.itemDone.connect(self._log)
tasks.extend([task1, task2])
labels.extend(
['Setting CtrlLoop...', 'Checking CtrlLoop state...'])
else:
task1 = CheckCtrlLoop(devices, parent=self)
task1.itemDone.connect(self._log)
tasks.append(task1)
labels.append('Checking CtrlLoop state...')
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _set_check_dclinks_capvolt(self):
self.ok_ps.clear()
self.nok_ps.clear()
pwrsupplies = self._get_selected_ps()
if not pwrsupplies:
return
devices = self._get_related_dclinks(pwrsupplies,
include_regatrons=True)
dev_exc_regatrons = {
dev
for dev in devices
if PSSearch.conv_psname_2_psmodel(dev) != 'REGATRON_DCLink'
}
if not devices:
return
task0 = CreateTesters(devices, parent=self)
task1 = SetCapBankVolt(dev_exc_regatrons, parent=self)
task2 = CheckCapBankVolt(devices, parent=self)
task2.itemDone.connect(self._log)
labels = [
'Connecting to devices...', 'Setting capacitor bank voltage...',
'Checking capacitor bank voltage...'
]
tasks = [task0, task1, task2]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _set_check_fbp_sofbmode(self, state):
self.ok_ps.clear()
self.nok_ps.clear()
devices = self._get_selected_ps()
devices = [
dev for dev in devices
if PSSearch.conv_psname_2_psmodel(dev) == 'FBP'
]
if not devices:
return
task0 = CreateTesters(devices, parent=self)
task1 = SetSOFBMode(devices, state=state, parent=self)
task2 = CheckSOFBMode(devices, state=state, parent=self)
task2.itemDone.connect(self._log)
tasks = [task0, task1, task2]
labels = [
'Connecting to devices...', 'Turning PS SOFBMode ' + state + '...',
'Checking PS SOFBMode ' + state + '...'
]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _set_test_ps(self):
self.ok_ps.clear()
self.nok_ps.clear()
devices = self._get_selected_ps()
if not devices:
return
task0 = CreateTesters(devices, parent=self)
task1 = SetCurrent(devices, is_test=True, parent=self)
task2 = CheckCurrent(devices, is_test=True, parent=self)
task2.itemDone.connect(self._log)
tasks = [task0, task1, task2]
labels = [
'Connecting to devices...', 'Testing PS... Setting current...',
'Testing PS... Checking current value...'
]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _set_zero_ps(self, devices=list(), show=True):
self.ok_ps.clear()
self.nok_ps.clear()
if not devices:
devices = self._get_selected_ps()
if not devices:
return
task0 = CreateTesters(devices, parent=self)
task1 = SetCurrent(devices, parent=self)
task2 = CheckCurrent(devices, parent=self)
task2.itemDone.connect(_part(self._log, show=show))
tasks = [task0, task1, task2]
labels = [
'Connecting to devices...', 'Setting current to zero...',
'Checking current value...'
]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _set_check_current(self):
self.ok_ps.clear()
self.nok_ps.clear()
devices = self._get_selected_ps()
if not devices:
return
value, ok = QInputDialog.getDouble(self, "Setpoint Input",
"Insert current setpoint: ")
if not ok:
return
task0 = CreateTesters(devices, parent=self)
task1 = SetCurrent(devices, value=value, parent=self)
task2 = CheckCurrent(devices, value=value, parent=self)
task2.itemDone.connect(self._log)
tasks = [task0, task1, task2]
labels = [
'Connecting to devices...', 'Setting current...',
'Checking current value...'
]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _set_check_opmode(self):
self.ok_ps.clear()
self.nok_ps.clear()
devices = self._get_selected_ps()
devices = [
dev for dev in devices
if dev.sec != 'LI' and dev.dev not in ('FCH', 'FCV')
]
if not devices:
return
state, ok = QInputDialog.getItem(self,
"OpMode Input",
"Select OpMode: ",
_PSE.OPMODES,
editable=False)
if not ok:
return
state2set = getattr(_PSC.OpMode, state)
state2check = getattr(_PSC.States, state)
task0 = CreateTesters(devices, parent=self)
task1 = SetOpMode(devices, state=state2set, parent=self)
task2 = CheckOpMode(devices, state=state2check, parent=self)
task2.itemDone.connect(self._log)
labels = [
'Connecting to devices...',
'Setting PS OpMode to ' + state + '...',
'Checking PS OpMode in ' + state + '...'
]
tasks = [task0, task1, task2]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _set_test_pu(self):
self.ok_ps.clear()
self.nok_ps.clear()
devices = self._get_selected_pu()
if not devices:
return
task0 = CreateTesters(devices, parent=self)
task1 = SetVoltage(devices, is_test=True, parent=self)
task2 = CheckVoltage(devices, is_test=True, parent=self)
task2.itemDone.connect(self._log)
tasks = [task0, task1, task2]
labels = [
'Connecting to devices...', 'Testing PU... Setting voltage...',
'Testing PU... Checking voltage value...'
]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _set_zero_pu(self, check=True):
self.ok_ps.clear()
self.nok_ps.clear()
devices = self._get_selected_pu()
if not devices:
return
task0 = CreateTesters(devices, parent=self)
task1 = SetVoltage(devices, parent=self)
tasks = [task0, task1]
labels = ['Connecting to devices...', 'Setting voltage to zero...']
if check:
task2 = CheckVoltage(devices, parent=self)
task2.itemDone.connect(self._log)
tasks.append(task2)
labels.append('Checking voltage value...')
else:
task1.itemDone.connect(self._log)
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
def _restore_triggers_state(self, dev_type):
self.ok_ps.clear()
self.nok_ps.clear()
if dev_type == 'PS':
devices = self._get_selected_ps()
elif dev_type == 'PU':
devices = self._get_selected_pu()
if not devices:
return
task1 = SetTriggerState(parent=self,
restore_initial_value=True,
dis=dev_type,
devices=devices)
task2 = CheckTriggerState(parent=self,
restore_initial_value=True,
dis=dev_type,
devices=devices)
task2.itemDone.connect(self._log)
tasks = [task1, task2]
labels = [
'Restoring ' + dev_type + ' trigger states...',
'Checking ' + dev_type + ' trigger states...'
]
dlg = ProgressDialog(labels, tasks, self)
dlg.exec_()
# ---------- log updates -----------
def _set_lastcomm(self, dev_type):
sender_text = self.sender().text()
self.label_lastcomm.setText('Last Command: ' + dev_type + ' - ' +
sender_text)
def _clear_lastcomm(self):
self.ok_ps.clear()
self.nok_ps.clear()
self.label_lastcomm.setText('Last Command: ')
def _log(self, name, status, show=True):
if show:
if status:
self.ok_ps.addItem(name)
else:
self.nok_ps.addItem(name)
else:
if status:
self.ok_ps_aux_list.append(name)
else:
self.nok_ps_aux_list.append(name)
# ---------- devices control ----------
def _get_ps_tree_names(self):
# add LI, TB, BO, TS
psnames = PSSearch.get_psnames({'sec': '(LI|TB|BO|TS)', 'dis': 'PS'})
# add SI Fams
psnames.extend(
PSSearch.get_psnames({
'sec': 'SI',
'sub': 'Fam',
'dis': 'PS',
'dev': '(B.*|Q.*|S.*)'
}))
# add SI Corrs
psnames.extend(
PSSearch.get_psnames({
'sec': 'SI',
'sub': '[0-2][0-9].*',
'dis': 'PS',
'dev': '(CH|CV)'
}))
# add SI QTrims
psnames.extend(
PSSearch.get_psnames({
'sec': 'SI',
'sub': '[0-2][0-9].*',
'dis': 'PS',
'dev': '(QD.*|QF.*|Q[1-4])'
}))
# add SI QSkews
psnames.extend(
PSSearch.get_psnames({
'sec': 'SI',
'dis': 'PS',
'dev': 'QS'
}))
# add SI Fast Corrs
psnames.extend(
PSSearch.get_psnames({
'sec': 'SI',
'dis': 'PS',
'dev': 'FC.*'
}))
return psnames
def _get_pu_tree_names(self):
punames = PSSearch.get_psnames({
'sec': '(TB|BO|TS|SI)',
'dis': 'PU',
'dev': '.*(Kckr|Sept).*'
})
return punames
def _get_selected_ps(self):
devices = self.ps_tree.checked_items()
if not devices:
QMessageBox.critical(self, 'Message', 'No power supply selected!')
return False
devices = [PVName(dev) for dev in devices]
return devices
def _get_selected_pu(self):
devices = self.pu_tree.checked_items()
if not devices:
QMessageBox.critical(self, 'Message',
'No pulsed power supply selected!')
return False
devices = [PVName(dev) for dev in devices]
return devices
def _get_related_dclinks(self, psnames, include_regatrons=False):
if isinstance(psnames, str):
psnames = [
psnames,
]
alldclinks = set()
for name in psnames:
if 'LI' in name:
continue
dclinks = PSSearch.conv_psname_2_dclink(name)
if dclinks:
dclink_model = PSSearch.conv_psname_2_psmodel(dclinks[0])
if dclink_model != 'REGATRON_DCLink':
alldclinks.update(dclinks)
elif include_regatrons:
for dcl in dclinks:
dcl_typ = PSSearch.conv_psname_2_pstype(dcl)
if dcl_typ == 'as-dclink-regatron-master':
alldclinks.add(dcl)
alldclinks = [PVName(dev) for dev in alldclinks]
return alldclinks
def _open_detail(self, index):
name = PVName(index.data())
if name.dis == 'TI':
app = QApplication.instance()
wind = create_window_from_widget(HLTriggerDetailed,
title=name,
is_main=True)
app.open_window(wind, parent=self, **{'device': name})
return
elif not _re.match('.*-.*:.*-.*', name):
if index.model().rowCount(index) == 1:
name = PVName(index.child(0, 0).data())
else:
return
if name.dis == 'PS':
run_newprocess(['sirius-hla-as-ps-detail.py', name])
elif name.dis == 'PU':
run_newprocess(['sirius-hla-as-pu-detail.py', name])
# ---------- update setup ----------
def _handle_checked_items_changed(self, item):
devname = PVName(item.data(0, Qt.DisplayRole))
if not _re.match('.*-.*:.*-.*', devname):
return
state2set = item.checkState(0)
# ensure power supplies that share dclinks are checked together
if devname in self._si_fam_psnames and not self._is_adv_mode:
dclinks = PSSearch.conv_psname_2_dclink(devname)
if dclinks:
psname2check = set()
for dcl in dclinks:
relps = PSSearch.conv_dclink_2_psname(dcl)
relps.remove(devname)
psname2check.update(relps)
self.ps_tree.tree.blockSignals(True)
for psn in psname2check:
item2check = self.ps_tree._item_map[psn]
if item2check.checkState(0) != state2set:
item2check.setData(0, Qt.CheckStateRole, state2set)
self.ps_tree.tree.blockSignals(False)
self._needs_update_setup = True
def _update_setup(self):
if not self._needs_update_setup:
return
self._needs_update_setup = False
# show/hide buttons to initialize SI Fam PS
has_sifam = False
for psn in self._si_fam_psnames:
item = self.ps_tree._item_map[psn]
has_sifam |= item.checkState(0) != 0
self.prep_sidclink_bt.setVisible(has_sifam)
self.init_sips_bt.setVisible(has_sifam)
self.aux_label.setVisible(has_sifam)
# set CtrlLoop button label
has_fast = False
for psn in self._si_fastcorrs:
item = self.ps_tree._item_map[psn]
has_fast |= item.checkState(0) != 0
text = 'Set(FC) and Check PS CtrlLoop' \
if has_fast else 'Check PS CtrlLoop'
self.setcheckctrlloop_ps_bt.setText(text)
# ---------- events ----------
def keyPressEvent(self, evt):
"""Implement keyPressEvent."""
if evt.matches(QKeySequence.Copy):
if self.ok_ps.underMouse():
items = self.ok_ps.selectedItems()
elif self.nok_ps.underMouse():
items = self.nok_ps.selectedItems()
items = '\n'.join([i.text() for i in items])
QApplication.clipboard().setText(items)
if evt.key() == Qt.Key_Escape:
if self.ok_ps.underMouse():
items = self.ok_ps.clearSelection()
elif self.nok_ps.underMouse():
items = self.nok_ps.clearSelection()
super().keyPressEvent(evt)
class SelectedLinesWidget(QWidget):
""" Widget to show and enable lines to be selected
inp : LineList
Input LineList
init_select : str or list of indices
str -- 'All'
"""
def __init__(self, inp, parent=None, init_select=None, plot_widget=None):
"""
"""
super(SelectedLinesWidget, self).__init__(parent)
self.parent = parent
# Line list Table
if isinstance(inp, LineList):
self.lines = inp._data
self.llst = inp
elif isinstance(inp, Table):
raise ValueError('SelectedLineWidget: DEPRECATED')
else:
raise ValueError('SelectedLineWidget: Wrong type of input')
self.plot_widget = plot_widget
# Create the line list
line_label = QLabel('Lines:')
self.lines_widget = QListWidget(self)
self.lines_widget.setSelectionMode(QAbstractItemView.MultiSelection)
# Initialize list
self.item_flg = 0
self.init_list()
# Initial selection
if init_select is None:
self.selected = [0]
elif init_select == 'All':
self.selected = []
for ii in range(self.lines_widget.count()):
self.lines_widget.item(ii).setSelected(True)
self.selected.append(ii)
else:
self.selected = init_select
if len(self.selected) == 0:
self.selected = [0]
for iselect in self.selected:
self.lines_widget.item(iselect).setSelected(True)
self.lines_widget.scrollToItem(self.lines_widget.item(
self.selected[0]))
# Events
self.lines_widget.itemSelectionChanged.connect(self.on_item_change)
# Layout
vbox = QVBoxLayout()
vbox.addWidget(line_label)
vbox.addWidget(self.lines_widget)
self.setLayout(vbox)
def init_list(self):
nlin = len(self.lines['wrest'])
for ii in range(nlin):
self.lines_widget.addItem('{:s} :: {:.3f} :: {}'.format(
self.lines['name'][ii], self.lines['wrest'][ii],
self.lines['f'][ii]))
def on_item_change(self): #,item):
# For big changes
if self.item_flg == 1:
return
all_items = [
self.lines_widget.item(ii)
for ii in range(self.lines_widget.count())
]
sel_items = self.lines_widget.selectedItems()
self.selected = [all_items.index(isel) for isel in sel_items]
self.selected.sort()
#QtCore.pyqtRemoveInputHook()
#xdb.set_trace()
#QtCore.pyqtRestoreInputHook()
# Update llist
try:
self.plot_widget.llist['show_line'] = self.selected
except AttributeError:
if self.parent is not None:
self.parent.updated_slines(self.selected)
return
else:
self.plot_widget.on_draw()
def on_list_change(self, llist):
# Clear
if not isinstance(llist, LineList):
raise ValueError('Expecting LineList!!')
self.item_flg = 1
self.lines = llist._data
self.llst = llist
self.lines_widget.clear()
# Initialize
self.init_list()
# Set selected
for iselect in self.selected:
self.lines_widget.item(iselect).setSelected(True)
self.lines_widget.scrollToItem(self.lines_widget.item(
self.selected[0]))
self.item_flg = 0
