class MultiTurnData(BaseWidget):
def __init__(self, parent=None, acq_type='ACQ', prefix='', bpm=''):
self.acq_type = acq_type
data_prefix = 'GEN_' if acq_type == 'ACQ' else 'PM_'
super().__init__(
parent=parent, prefix=prefix, bpm=bpm, data_prefix=data_prefix)
self.samplespre = SiriusConnectionSignal(self.get_pvname(
acq_type+'SamplesPre-RB', is_data=False))
self.samplespost = SiriusConnectionSignal(self.get_pvname(
acq_type+'SamplesPost-RB', is_data=False))
self.shots = SiriusConnectionSignal(self.get_pvname(
acq_type+'Shots-RB', is_data=False))
self._chans.extend([self.samplespre, self.samplespost, self.shots])
self.radio_buttons = []
self.setupui()
@property
def nrsamplespershot(self):
if self.samplespost.connected and self.samplespre.connected:
return self.samplespost.getvalue() + self.samplespre.getvalue()
@property
def nrsamples(self):
val = self.nrsamplespershot
if val and self.shots.connected:
return self.nrsamplespershot*self.shots.getvalue()
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, False)
vbl.addWidget(graph)
stats = self.create_statistics(stack1, False)
vbl.addWidget(stats)
if not self.data_prefix.startswith('PM'):
hbl2 = QHBoxLayout()
hbl2.addStretch()
vbl.addItem(hbl2)
pb = QPushButton('Open FFT Data', stack1)
hbl2.addWidget(pb)
hbl2.addStretch()
Window = create_window_from_widget(
FFTData, title=self.bpm+': FFT Data')
util.connect_window(
pb, Window, parent=stack1, prefix=self.prefix,
bpm=self.bpm, data_prefix=self.data_prefix, position=False)
# ##### Position Widget ######
stack2 = QWidget(self.stack)
self.stack.addWidget(stack2)
vbl = QVBoxLayout(stack2)
graph = self.create_graph(stack2, True)
vbl.addWidget(graph)
stats = self.create_statistics(stack2, True)
vbl.addWidget(stats)
if not self.data_prefix.startswith('PM'):
hbl2 = QHBoxLayout()
hbl2.addStretch()
vbl.addItem(hbl2)
pb = QPushButton('Open FFT Data', stack2)
hbl2.addWidget(pb)
hbl2.addStretch()
Window = create_window_from_widget(
FFTData, title=self.bpm+': FFT Data')
util.connect_window(
pb, Window, parent=stack1, prefix=self.prefix,
bpm=self.bpm, data_prefix=self.data_prefix, position=True)
self.setStyleSheet("""
#MultiTurnDataGraph{
min-width:48em;
min-height:24em;
}
QLabel{
min-width:6em; max-width:6em;
min-height:1.5em; max-height:1.5em;
}""")
def create_statistics(self, wid, position=True):
text, unit, names, _ = self._get_properties(position)
wid = QWidget(wid)
hbl = QHBoxLayout(wid)
hbl.addStretch()
grpbx = QGroupBox('Statistics', wid)
hbl.addWidget(grpbx)
hbl.addStretch()
gdl = QGridLayout(grpbx)
gdl.setHorizontalSpacing(20)
gdl.setVerticalSpacing(20)
stats = ('MeanValue', 'Sigma', 'MinValue', 'MaxValue')
for j, stat in enumerate(('Average', 'Sigma', 'Minimum', 'Maximum')):
lab = QLabel(stat, wid)
lab.setAlignment(Qt.AlignCenter)
gdl.addWidget(lab, 0, j+1)
for i, name in enumerate(names):
lab = QLabel(text[:3] + name, wid)
lab.setAlignment(Qt.AlignCenter)
gdl.addWidget(lab, i+1, 0)
for j, stat in enumerate(stats):
lab = SiriusLabel(wid, init_channel=self.get_pvname(
name+'_STATS'+stat+'_RBV'))
lab.setAlignment(Qt.AlignCenter)
lab.unit_changed(unit)
lab.showUnits = True
lab.precisionFromPV = False
lab.precision = 3
gdl.addWidget(lab, i+1, j+1)
return wid
def create_graph(self, wid, position=True):
text, unit, names, colors = self._get_properties(position)
if position:
unit = unit[1:]
graph = GraphWave(
wid, prefix=self.prefix, bpm=self.bpm,
data_prefix=self.data_prefix)
graph.setObjectName('MultiTurnDataGraph')
graph.setLabel('left', text=text, units=unit)
for name, cor in zip(names, colors):
opts = dict(
y_channel=name+'ArrayData',
name=text[:3]+name,
color=cor,
lineStyle=1,
lineWidth=1) # NOTE: If > 1: very low performance
opts['y_channel'] = self.get_pvname(opts['y_channel'])
if position:
graph.addChannel(add_scale=1e-9, **opts)
else:
graph.addChannel(**opts)
return graph
def _get_properties(self, position=True):
if position:
text = 'Positions'
unit = 'nm'
names = ('X', 'Y', 'Q', 'SUM')
colors = ('blue', 'red', 'green', 'black')
else:
text = 'Antennas'
unit = 'count'
names = ('A', 'B', 'C', 'D')
colors = ('blue', 'red', 'green', 'magenta')
return text, unit, names, colors
def toggle_button(self, i, tog):
if tog:
self.stack.setCurrentIndex(i)
def control_visibility_buttons(self, text):
bo = not text.startswith('adc')
self.radio_buttons[1].setVisible(bo)
self.radio_buttons[0].setChecked(True)
class SiriusScrnView(QWidget):
"""
Class to read Sirius screen cameras image data.
To allow saving a grid correctly, control calibrationgrid_flag, which
indicates if the screen is in calibration grid position.
You can control it by using the method/Slot updateCalibrationGridFlag.
"""
save_files = Signal()
def __init__(self, parent=None, prefix=_VACA_PREFIX, device=None):
"""Initialize object."""
QWidget.__init__(self, parent=parent)
self.prefix = prefix
self.device = SiriusPVName(device)
self.scrn_prefix = self.device.substitute(prefix=prefix)
self._receivedData = False
self.setObjectName(self.scrn_prefix.sec + 'App')
self.screen_type_conn = SiriusConnectionSignal(
self.scrn_prefix.substitute(propty='ScrnType-Sts'))
self.screen_type_conn.new_value_signal.connect(
self.updateCalibrationGridFlag)
self._calibrationgrid_flag = self.screen_type_conn.getvalue()
self.save_files.connect(self._saveGridLocalFiles)
self.ch_ImgROIHeight = SiriusConnectionSignal(
self.scrn_prefix.substitute(propty='ImgROIHeight-RB'))
self.ch_ImgROIWidth = SiriusConnectionSignal(
self.scrn_prefix.substitute(propty='ImgROIWidth-RB'))
self.ch_ImgROIOffsetX = SiriusConnectionSignal(
self.scrn_prefix.substitute(propty='ImgROIOffsetX-RB'))
self.ch_ImgROIOffsetY = SiriusConnectionSignal(
self.scrn_prefix.substitute(propty='ImgROIOffsetY-RB'))
self._setupUi()
self.setFocus(True)
self.setFocusPolicy(Qt.StrongFocus)
self._loadCalibrationGrid(default=True)
@property
def calibrationgrid_flag(self):
"""Indicate if the screen device is in calibration grid position."""
return self._calibrationgrid_flag
@Slot(int)
def updateCalibrationGridFlag(self, new_state):
"""Update calibrationgrid_flag property."""
self._calibrationgrid_flag = new_state
if new_state == 1:
self.pushbutton_savegrid.setEnabled(True)
else:
self.pushbutton_savegrid.setEnabled(False)
def _setupUi(self):
self.cameraview_widget = QWidget()
self.cameraview_widget.setLayout(self._cameraviewLayout())
self.settings_widget = QWidget(self)
self.settings_widget.setLayout(self._settingsLayout())
self.settings_widget.setStyleSheet("""
.QLabel{
min-width: 5em;}
QLabel{
qproperty-alignment: AlignCenter;}""")
self.calibrationgrid_widget = QWidget(self)
self.calibrationgrid_widget.setLayout(self._calibrationgridLayout())
self.calibrationgrid_widget.setSizePolicy(QSzPlcy.Expanding,
QSzPlcy.Expanding)
self.calibrationgrid_widget.layout().setAlignment(Qt.AlignHCenter)
self.tab = QTabWidget(self)
self.tab.setStyleSheet("""
QTabWidget::pane {
border-left: 2px solid gray;
border-bottom: 2px solid gray;
border-right: 2px solid gray;
}""")
self.tab.addTab(self.settings_widget, 'Camera Settings')
self.tab.addTab(self.calibrationgrid_widget, 'Calibration')
self.statistics_groupBox = QGroupBox('Statistics', self)
self.statistics_groupBox.setLayout(self._statisticsLayout())
self.statistics_groupBox.setSizePolicy(QSzPlcy.Expanding,
QSzPlcy.Expanding)
self.statistics_groupBox.setStyleSheet("""
.QLabel{
min-width:0.28em; max-width:0.28em;
min-height:1.29em; max-height:1.29em;}
QLabel{
qproperty-alignment: AlignCenter;}
PyDMWidget{
min-width:4.84em; max-width:4.84em;
min-height:1.29em; max-height:1.29em;}""")
self.trigger_groupBox = QGroupBox('Trigger', self)
if 'TB' in self.device or 'BO' in self.device:
trg_prefix = 'AS-Fam:TI-Scrn-TBBO'
elif 'TS' in self.device:
trg_prefix = 'TS-Fam:TI-Scrn'
hbl = QHBoxLayout(self.trigger_groupBox)
hbl.addWidget(
HLTriggerSimple(parent=self.trigger_groupBox,
device=trg_prefix,
prefix=self.prefix))
self.trigger_groupBox.setLayout(hbl)
self.trigger_groupBox.setStyleSheet("""
PyDMWidget{
min-width:4.84em; max-width:4.84em;
min-height:1.29em; max-height:1.29em;}""")
vlay = QVBoxLayout()
vlay.addWidget(self.statistics_groupBox)
vlay.addWidget(self.trigger_groupBox)
vlay.setSpacing(10)
lay = QGridLayout(self)
lay.setHorizontalSpacing(10)
lay.setVerticalSpacing(10)
lay.addWidget(self.cameraview_widget, 0, 0, 1, 2)
lay.addWidget(self.tab, 1, 0)
lay.addLayout(vlay, 1, 1)
lay.setRowStretch(0, 15)
lay.setRowStretch(1, 7)
def _cameraviewLayout(self):
label = QLabel(self.device, self)
label.setStyleSheet("""font-weight: bold;max-height:1.29em;""")
label.setAlignment(Qt.AlignCenter)
self.image_view = _SiriusImageView(
parent=self,
image_channel=self.scrn_prefix.substitute(propty='ImgData-Mon'),
width_channel=self.scrn_prefix.substitute(propty='ImgROIWidth-RB'),
offsetx_channel=self.scrn_prefix.substitute(
propty='ImgROIOffsetX-RB'),
offsety_channel=self.scrn_prefix.substitute(
propty='ImgROIOffsetY-RB'),
maxwidth_channel=self.scrn_prefix.substitute(
propty='ImgMaxWidth-Cte'),
maxheight_channel=self.scrn_prefix.substitute(
propty='ImgMaxHeight-Cte'))
self.image_view.setObjectName('ScrnView')
self.image_view.normalizeData = True
self.image_view.readingOrder = self.image_view.Clike
self.image_view.maxRedrawRate = 15
self.image_view.setStyleSheet("""
#ScrnView{min-width:30em; min-height:24em;}""")
self.image_view.failToSaveGrid.connect(self._showFailToSaveGridMsg)
self.image_view.receivedData.connect(self._setReceivedDataFlag)
lay = QGridLayout()
lay.setContentsMargins(0, 0, 0, 0)
lay.addWidget(label, 0, 1)
lay.addItem(QSpacerItem(40, 2, QSzPlcy.Preferred, QSzPlcy.Fixed), 1, 1)
lay.addWidget(self.image_view, 2, 1)
return lay
def _calibrationgridLayout(self):
self.checkBox_showgrid = QCheckBox('Show', self)
self.checkBox_showgrid.setEnabled(False)
self.checkBox_showgrid.setStyleSheet("""
min-width:4em; max-width:4em;
min-height:1.29em; max-height:1.29em;""")
self.checkBox_showgrid.toggled.connect(
self.image_view.showCalibrationGrid)
self.pushbutton_savegrid = QPushButton('Save', self)
self.pushbutton_savegrid.setEnabled(False)
self.pushbutton_savegrid.setStyleSheet("""
min-width:4em; max-width:4em;
min-height:1.29em; max-height:1.29em;""")
self.pushbutton_savegrid.clicked.connect(self._saveCalibrationGrid)
self.pushbutton_loadgrid = QPushButton('Load', self)
self.pushbutton_loadgrid.setStyleSheet("""
min-width:4em; max-width:4em;
min-height:1.29em; max-height:1.29em;""")
self.pushbutton_loadgrid.clicked.connect(self._loadCalibrationGrid)
hbox_grid = QHBoxLayout()
hbox_grid.addWidget(self.checkBox_showgrid)
hbox_grid.addWidget(self.pushbutton_savegrid)
hbox_grid.addWidget(self.pushbutton_loadgrid)
lb = QLabel('Show levels <')
lb.setStyleSheet("min-width:7em;max-width:7em;")
self.spinbox_gridfilterfactor = QSpinBoxPlus()
self.spinbox_gridfilterfactor.setMaximum(100)
self.spinbox_gridfilterfactor.setMinimum(0)
self.spinbox_gridfilterfactor.setValue(
self.image_view.calibration_grid_filterfactor)
self.spinbox_gridfilterfactor.editingFinished.connect(
self._setCalibrationGridFilterFactor)
self.spinbox_gridfilterfactor.setStyleSheet("""
min-width:4em; max-width:4em;""")
hbox_filter = QHBoxLayout()
hbox_filter.setSpacing(0)
hbox_filter.addWidget(lb)
hbox_filter.addWidget(self.spinbox_gridfilterfactor)
hbox_filter.addWidget(QLabel(' %'))
lb = QLabel('Remove border: ')
lb.setStyleSheet("min-width:7em;max-width:7em;")
self.spinbox_removeborder = QSpinBoxPlus()
self.spinbox_removeborder.setMaximum(512)
self.spinbox_removeborder.setMinimum(0)
self.spinbox_removeborder.setValue(
self.image_view.calibration_grid_removeborder)
self.spinbox_removeborder.editingFinished.connect(
self._setCalibrationGridBorder2Remove)
self.spinbox_removeborder.setStyleSheet("""
min-width:4em; max-width:4em;""")
hbox_remove = QHBoxLayout()
hbox_remove.setSpacing(0)
hbox_remove.addWidget(lb)
hbox_remove.addWidget(self.spinbox_removeborder)
hbox_remove.addWidget(QLabel(' px'))
hbox_EnblLED = _create_propty_layout(parent=self,
prefix=self.scrn_prefix,
propty='EnblLED',
propty_type='enbldisabl',
width=4.68)
lay = QFormLayout()
lay.addItem(QSpacerItem(1, 10, QSzPlcy.Ignored, QSzPlcy.Preferred))
lay.addRow(' Grid: ', hbox_grid)
lay.addItem(QSpacerItem(1, 10, QSzPlcy.Ignored, QSzPlcy.Preferred))
lay.addRow(' ', hbox_filter)
lay.addRow(' ', hbox_remove)
lay.addItem(QSpacerItem(1, 20, QSzPlcy.Ignored, QSzPlcy.Preferred))
lay.addRow(' LED: ', hbox_EnblLED)
lay.addItem(QSpacerItem(1, 10, QSzPlcy.Ignored, QSzPlcy.Preferred))
lay.setLabelAlignment(Qt.AlignRight)
lay.setFormAlignment(Qt.AlignCenter)
return lay
def _settingsLayout(self):
label_CamEnbl = QLabel('Enable: ', self)
hbox_CamEnbl = _create_propty_layout(parent=self,
prefix=self.scrn_prefix,
propty='CamEnbl',
propty_type='enbldisabl')
label_CamAcqPeriod = QLabel('Acquire\nPeriod [s]:', self)
hbox_CamAcqPeriod = _create_propty_layout(parent=self,
prefix=self.scrn_prefix,
propty='CamAcqPeriod',
propty_type='sprb',
width=5.0)
label_CamExposureTime = QLabel('Exposure\nTime [us]:', self)
hbox_CamExposureTime = _create_propty_layout(parent=self,
prefix=self.scrn_prefix,
propty='CamExposureTime',
propty_type='sprb',
width=5.0)
label_CamGain = QLabel('Gain[dB]:', self)
hbox_CamGain = _create_propty_layout(parent=self,
prefix=self.scrn_prefix,
propty='CamGain',
width=5.0,
propty_type='sprb')
label_AutoGain = QLabel('Auto Gain: ', self)
self.pb_autogain = PyDMPushButton(
label='',
icon=qta.icon('mdi.auto-fix'),
parent=self,
pressValue=1,
init_channel=self.scrn_prefix.substitute(propty='CamAutoGain-Cmd'))
self.pb_autogain.setObjectName('autog')
self.pb_autogain.setStyleSheet(
"#autog{min-width:25px; max-width:25px; icon-size:20px;}")
cam_prefix = SiriusPVName(self.scrn_prefix).substitute(dev='ScrnCam')
label_Reset = QLabel('Reset: ', self)
self.pb_dtl = PyDMPushButton(
label='',
icon=qta.icon('fa5s.sync'),
parent=self,
pressValue=1,
init_channel=cam_prefix.substitute(propty='Rst-Cmd'))
self.pb_dtl.setObjectName('reset')
self.pb_dtl.setStyleSheet(
"#reset{min-width:25px; max-width:25px; icon-size:20px;}")
self.pb_details = QPushButton(qta.icon('fa5s.ellipsis-h'), '', self)
self.pb_details.setToolTip('More settings')
self.pb_details.setObjectName('detail')
self.pb_details.setStyleSheet(
"#detail{min-width:25px; max-width:25px; icon-size:20px;}")
self.pb_details.setSizePolicy(QSzPlcy.Expanding, QSzPlcy.Preferred)
util.connect_window(self.pb_details,
_ScrnSettingsDetails,
parent=self,
prefix=self.prefix,
device=self.device)
hbox_aux = QHBoxLayout()
hbox_aux.addWidget(self.pb_dtl, alignment=Qt.AlignLeft)
hbox_aux.addWidget(self.pb_details, alignment=Qt.AlignRight)
lay = QFormLayout()
lay.setFormAlignment(Qt.AlignCenter)
lay.addRow(label_CamEnbl, hbox_CamEnbl)
lay.addRow(label_CamAcqPeriod, hbox_CamAcqPeriod)
lay.addRow(label_CamExposureTime, hbox_CamExposureTime)
lay.addRow(label_CamGain, hbox_CamGain)
lay.addRow(label_AutoGain, self.pb_autogain)
lay.addRow(label_Reset, hbox_aux)
return lay
def _statisticsLayout(self):
# - Method
label_Method = QLabel('CalcMethod:', self)
label_Method.setStyleSheet("min-width:7em;")
self.comboBox_Method = QComboBox(self)
self.comboBox_Method.addItem('DimFei', 0)
self.comboBox_Method.addItem('NDStats', 1)
self.comboBox_Method.setCurrentIndex(0)
self.comboBox_Method.setStyleSheet("""
QComboBox::item {height: 1em;}
QComboBox{min-width:6em;}""")
self.comboBox_Method.currentIndexChanged.connect(
self._handleShowStatistics)
# - Centroid
label_Centroid = QLabel('Centroid [mm]: ', self)
label_Centroid.setStyleSheet("min-width:7em;")
label_i_Center = QLabel('(', self)
self.PyDMLabel_CenterXDimFei = PyDMLabel(
parent=self,
init_channel=self.scrn_prefix.substitute(
propty='CenterXDimFei-Mon'))
self.PyDMLabel_CenterXDimFei.setStyleSheet(
'min-width:4em; max-width:4em;')
self.PyDMLabel_CenterXNDStats = PyDMLabel(
parent=self,
init_channel=self.scrn_prefix.substitute(
propty='CenterXNDStats-Mon'))
self.PyDMLabel_CenterXNDStats.setStyleSheet(
'min-width:4em; max-width:4em;')
self.PyDMLabel_CenterXNDStats.setVisible(False)
label_m_Center = QLabel(',', self)
self.PyDMLabel_CenterYDimFei = PyDMLabel(
parent=self,
init_channel=self.scrn_prefix.substitute(
propty='CenterYDimFei-Mon'))
self.PyDMLabel_CenterYDimFei.setStyleSheet(
'min-width:4em; max-width:4em;')
self.PyDMLabel_CenterYNDStats = PyDMLabel(
parent=self,
init_channel=self.scrn_prefix.substitute(
propty='CenterYNDStats-Mon'))
self.PyDMLabel_CenterYNDStats.setStyleSheet(
'min-width:4em; max-width:4em;')
self.PyDMLabel_CenterYNDStats.setVisible(False)
label_f_Center = QLabel(')', self)
# - Sigma
label_Sigma = QLabel('Sigma [mm]: ', self)
label_Sigma.setStyleSheet("min-width:7em;")
label_i_Sigma = QLabel('(', self)
self.PyDMLabel_SigmaXDimFei = PyDMLabel(
parent=self,
init_channel=self.scrn_prefix.substitute(
propty='SigmaXDimFei-Mon'))
self.PyDMLabel_SigmaXDimFei.setStyleSheet(
'min-width:4em; max-width:4em;')
self.PyDMLabel_SigmaXNDStats = PyDMLabel(
parent=self,
init_channel=self.scrn_prefix.substitute(
propty='SigmaXNDStats-Mon'))
self.PyDMLabel_SigmaXNDStats.setStyleSheet(
'min-width:4em; max-width:4em;')
self.PyDMLabel_SigmaXNDStats.setVisible(False)
label_m_Sigma = QLabel(',', self)
self.PyDMLabel_SigmaYDimFei = PyDMLabel(
parent=self,
init_channel=self.scrn_prefix.substitute(
propty='SigmaYDimFei-Mon'))
self.PyDMLabel_SigmaYDimFei.setStyleSheet(
'min-width:4em; max-width:4em;')
self.PyDMLabel_SigmaYNDStats = PyDMLabel(
parent=self,
init_channel=self.scrn_prefix.substitute(
propty='SigmaYNDStats-Mon'))
self.PyDMLabel_SigmaYNDStats.setStyleSheet(
'min-width:4em; max-width:4em;')
self.PyDMLabel_SigmaYNDStats.setVisible(False)
label_f_Sigma = QLabel(')', self)
# - Theta
label_Theta = QLabel('Theta [rad]: ')
label_Theta.setStyleSheet("min-width:7em;")
label_i_Theta = QLabel('(', self)
self.PyDMLabel_ThetaDimFei = PyDMLabel(
parent=self,
init_channel=self.scrn_prefix.substitute(propty='ThetaDimFei-Mon'))
self.PyDMLabel_ThetaDimFei.setStyleSheet("max-width:12em;")
self.PyDMLabel_ThetaNDStats = PyDMLabel(
parent=self,
init_channel=self.scrn_prefix.substitute(
propty='ThetaNDStats-Mon'))
self.PyDMLabel_ThetaNDStats.setStyleSheet("max-width:12em;")
self.PyDMLabel_ThetaNDStats.setVisible(False)
label_f_Theta = QLabel(')', self)
lay = QGridLayout()
lay.addWidget(label_Method, 1, 1, 1, 3)
lay.addWidget(self.comboBox_Method, 1, 3, 1, 3)
lay.addWidget(label_Centroid, 3, 1, alignment=Qt.AlignCenter)
lay.addWidget(label_i_Center, 3, 2)
lay.addWidget(self.PyDMLabel_CenterXDimFei, 3, 3)
lay.addWidget(self.PyDMLabel_CenterXNDStats, 3, 3)
lay.addWidget(label_m_Center, 3, 4)
lay.addWidget(self.PyDMLabel_CenterYDimFei, 3, 5)
lay.addWidget(self.PyDMLabel_CenterYNDStats, 3, 5)
lay.addWidget(label_f_Center, 3, 6)
lay.addWidget(label_Sigma, 5, 1, alignment=Qt.AlignCenter)
lay.addWidget(label_i_Sigma, 5, 2)
lay.addWidget(self.PyDMLabel_SigmaXDimFei, 5, 3)
lay.addWidget(self.PyDMLabel_SigmaXNDStats, 5, 3)
lay.addWidget(label_m_Sigma, 5, 4)
lay.addWidget(self.PyDMLabel_SigmaYDimFei, 5, 5)
lay.addWidget(self.PyDMLabel_SigmaYNDStats, 5, 5)
lay.addWidget(label_f_Sigma, 5, 6)
lay.addWidget(label_Theta, 7, 1, alignment=Qt.AlignCenter)
lay.addWidget(label_i_Theta, 7, 2)
lay.addWidget(self.PyDMLabel_ThetaDimFei, 7, 3, 1, 3)
lay.addWidget(self.PyDMLabel_ThetaNDStats, 7, 3, 1, 3)
lay.addWidget(label_f_Theta, 7, 6)
return lay
def _handleShowStatistics(self, visible):
self.PyDMLabel_CenterXDimFei.setVisible(not visible)
self.PyDMLabel_CenterXNDStats.setVisible(visible)
self.PyDMLabel_CenterYDimFei.setVisible(not visible)
self.PyDMLabel_CenterYNDStats.setVisible(visible)
self.PyDMLabel_ThetaDimFei.setVisible(not visible)
self.PyDMLabel_ThetaNDStats.setVisible(visible)
self.PyDMLabel_SigmaXDimFei.setVisible(not visible)
self.PyDMLabel_SigmaXNDStats.setVisible(visible)
self.PyDMLabel_SigmaYDimFei.setVisible(not visible)
self.PyDMLabel_SigmaYNDStats.setVisible(visible)
def _saveCalibrationGrid(self):
t = Thread(target=self._saveCalibrationGrid_thread, daemon=True)
t.start()
def _saveCalibrationGrid_thread(self):
roi_h = float(self.ch_ImgROIHeight.value)
roi_w = float(self.ch_ImgROIWidth.value)
roi_offsetx = float(self.ch_ImgROIOffsetX.value)
roi_offsety = float(self.ch_ImgROIOffsetY.value)
cond = roi_h != float(self.image_view.image_maxheight) or \
roi_w != float(self.image_view.image_maxwidth) or \
roi_offsetx != 0 or roi_offsety != 0
if cond:
# Disable camera acquisition and wait for disabling
self.PyDMStateButton_CamEnbl.send_value_signal[int].emit(0)
state = self.SiriusLedState_CamEnbl.state
while state == 1:
time.sleep(0.1)
state = self.SiriusLedState_CamEnbl.state
# Change ROI to get entire image
self.ch_ImgROIHeight.send_value_signal[float].emit(
float(self.image_view.image_maxheight))
self.ch_ImgROIWidth.send_value_signal[float].emit(
float(self.image_view.image_maxwidth))
self.ch_ImgROIOffsetX.send_value_signal[float].emit(0)
self.ch_ImgROIOffsetY.send_value_signal[float].emit(0)
# Enable led and wait for status
self.PyDMStateButton_EnblLED.send_value_signal[int].emit(1)
while not self.SiriusLedState_EnblLED.state:
time.sleep(0.1)
# Enable camera acquisition and wait for receiveing first frame
self._receivedData = False
self.PyDMStateButton_CamEnbl.send_value_signal[int].emit(1)
while not self._receivedData:
time.sleep(0.1)
# Save grid
self.image_view.saveCalibrationGrid()
if cond:
# Disable camera acquisition and wait for disabling
self.PyDMStateButton_CamEnbl.send_value_signal[int].emit(0)
state = self.SiriusLedState_CamEnbl.state
while state == 1:
time.sleep(0.1)
state = self.SiriusLedState_CamEnbl.state
# Change ROI to original size
self.ch_ImgROIHeight.send_value_signal[float].emit(roi_h)
self.ch_ImgROIWidth.send_value_signal[float].emit(roi_w)
self.ch_ImgROIOffsetX.send_value_signal[float].emit(roi_offsetx)
self.ch_ImgROIOffsetY.send_value_signal[float].emit(roi_offsety)
# Enable camera acquisition
self.PyDMStateButton_CamEnbl.send_value_signal[int].emit(1)
# Enable showing saved grid
time.sleep(0.1)
self.checkBox_showgrid.setEnabled(True)
self.save_files.emit()
def _saveGridLocalFiles(self):
home = os.path.expanduser('~')
folder_month = datetime.now().strftime('%Y-%m')
folder_day = datetime.now().strftime('%Y-%m-%d')
path = os.path.join(home, 'mounts', 'screens-iocs', folder_month,
folder_day)
if not os.path.exists(path):
os.makedirs(path)
fn, _ = QFileDialog.getSaveFileName(
self, 'Save Grid As...', path + '/' + self.device +
datetime.now().strftime('_%Y-%m-%d_%Hh%Mmin'), '*.npy')
if not fn:
return False
path_default = os.path.join(home, 'mounts', 'screens-iocs', 'default')
if not os.path.exists(path_default):
os.makedirs(path_default)
fn_default = path_default + '/' + self.device
grid = self.image_view.calibrationGrid
width = self.image_view.imageWidth
data = np.append(width, grid)
np.save(fn, data)
np.save(fn_default, data)
def _loadCalibrationGrid(self, default=False):
home = os.path.expanduser('~')
if not default:
folder_month = datetime.now().strftime('%Y-%m')
path = os.path.join(home, 'mounts', 'screens-iocs', folder_month)
fn, _ = QFileDialog.getOpenFileName(self, 'Load Grid...', path,
'*.npy')
if not fn:
return
if self.device not in fn:
ans = QMessageBox.question(
self, 'Warning',
'The name of the selected file does not contain the name' +
' of this screen. Are you sure you\'re loading this grid?',
QMessageBox.Yes, QMessageBox.Cancel)
if ans == QMessageBox.Cancel:
return
else:
path = os.path.join(home, 'mounts', 'screens-iocs', 'default')
fn = path + '/' + self.device + '.npy'
try:
data = np.load(fn)
self.image_view.calibrationGrid = data
except Exception as e:
if not default:
QMessageBox.critical(
self, 'Error',
'Could not load calibration grid from file ' + fn + '. ' +
'\nError message: ' + str(e), QMessageBox.Ok)
return
# Enable showing saved grid
self.checkBox_showgrid.setEnabled(True)
def _setReceivedDataFlag(self):
self._receivedData = True
def _setCalibrationGridFilterFactor(self):
self.image_view.set_calibration_grid_filterfactor(
self.spinbox_gridfilterfactor.value())
def _setCalibrationGridBorder2Remove(self):
self.image_view.set_calibration_grid_border2remove(
self.spinbox_removeborder.value())
@Slot()
def _showFailToSaveGridMsg(self):
QMessageBox.warning(self, 'Warning',
'Could not save calibration grid!', QMessageBox.Ok)
class DCCTMonitor(QWidget):
"""DCCT data monitoring."""
def __init__(self, parent=None, prefix='', device=''):
"""Initialize object."""
super().__init__(parent)
self.prefix = prefix
self.device = SiriusPVName(device)
self.use_raw = self.device.sec == 'BO'
self.dcct_prefix = self.device.substitute(prefix=prefix)
self.acqmode_channel = SignalChannel(
self.dcct_prefix.substitute(propty='MeasMode-Sel'))
self.acqmode_channel.new_value_signal[int].connect(self.updateParams)
self.normalnrsamp_channel = SignalChannel(
self.dcct_prefix.substitute(propty='SampleCnt-RB'))
self.normalnrsamp_channel.new_value_signal[int].connect(
self.updateParams)
self.fastnrsamp_channel = SignalChannel(
self.dcct_prefix.substitute(propty='FastSampleCnt-RB'))
self.fastnrsamp_channel.new_value_signal[int].connect(
self.updateParams)
self._acq_mode = None
self._acq_normalnrsamp = None
self._acq_fastnrsamp = None
self._downsampling = 1
self._smooth_method = 'Average'
self._smooth_nracq = 1
self._smooth_buffer = list()
self._setupUi()
def _setupUi(self):
self.currhist = self._setupTimeHistory()
self.currhist.setVisible(not self.use_raw)
self.rawreads = self._setupRawReadings()
self.rawreads.setVisible(self.use_raw)
self.pb_vis = QPushButton(self)
self.pb_vis.setStyleSheet(
'QPushButton{min-width: 0.8em; max-width: 0.8em;}')
self.menu_vis = QMenu()
self.switch_act = self.menu_vis.addAction('Switch to ' + (
'Time History' if self.use_raw else 'Raw Readings'))
self.switch_act.triggered.connect(self._handle_data_visualization)
self.pb_vis.setMenu(self.menu_vis)
self.setStyleSheet("""
.QLabel{max-height:1.5em;}
PyDMWaveformPlot, PyDMTimePlot{min-width:30em; min-height:20em;}
""")
lay = QGridLayout(self)
lay.setContentsMargins(0, 0, 0, 0)
lay.setHorizontalSpacing(0)
lay.addWidget(self.pb_vis, 0, 0, alignment=Qt.AlignTop | Qt.AlignLeft)
lay.addWidget(self.currhist, 0, 1)
lay.addWidget(self.rawreads, 0, 1)
def _setupTimeHistory(self):
self.label_currhist = QLabel('<h3>Current History</h3>',
self,
alignment=Qt.AlignCenter)
self.timegraph = SiriusTimePlot(self)
self.timegraph.timeSpan = 600
channel = self.dcct_prefix.substitute(propty='Current-Mon')
self.timegraph.addYChannel(y_channel=channel,
name='Current History',
color='blue',
lineWidth=1,
lineStyle=Qt.SolidLine)
self.timegraph.autoRangeX = True
self.timegraph.autoRangeY = True
self.timegraph.backgroundColor = QColor(255, 255, 255)
self.timegraph.showLegend = False
self.timegraph.showXGrid = True
self.timegraph.showYGrid = True
self.timegraph.plotItem.showButtons()
self.timecurve = self.timegraph.curveAtIndex(0)
wid = QWidget()
lay = QGridLayout(wid)
lay.setAlignment(Qt.AlignTop)
lay.setRowStretch(0, 1)
lay.setRowStretch(1, 9)
lay.addWidget(self.label_currhist, 0, 0)
lay.addWidget(self.timegraph, 1, 0)
return wid
def _setupRawReadings(self):
self.label_waveread = QLabel('<h3>Current Raw Readings</h3>',
self,
alignment=Qt.AlignCenter)
self.wavegraph = PyDMWaveformPlot(self)
self.wavegraph.setLabels(left='Current [mA]', bottom='Index')
channel = 'FAKE:Readings'
self.rawreadings_channel = SignalChannel(
self.dcct_prefix.substitute(propty='RawReadings-Mon'))
self.rawreadings_channel.new_value_signal[np.ndarray].connect(
self._updateRawBuffer)
self.wavegraph.addChannel(y_channel=channel,
name='Current Raw Readings',
color='blue',
lineWidth=2,
lineStyle=Qt.SolidLine)
self.wavegraph.autoRangeX = True
self.wavegraph.autoRangeY = True
self.wavegraph.backgroundColor = QColor(255, 255, 255)
self.wavegraph.showLegend = False
self.wavegraph.showXGrid = True
self.wavegraph.showYGrid = True
self.wavegraph.plotItem.showButtons()
self.wavecurve = self.wavegraph.curveAtIndex(0)
wid = QWidget()
lay = QGridLayout(wid)
lay.setAlignment(Qt.AlignTop)
lay.setRowStretch(0, 1)
lay.setRowStretch(1, 9)
lay.addWidget(self.label_waveread, 0, 0)
lay.addWidget(self.wavegraph, 1, 0)
# Smoothing
evgname = SiriusPVName(_LLTimeSearch.get_evg_name())
self._evnt_dly = SignalChannel(
evgname.substitute(prefix=self.prefix,
propty='Dig' + self.device.sec + 'Delay-RB'))
self._evnt_dly.new_value_signal[float].connect(self.updateRawXAxis)
self._trig_dly = SignalChannel(
self.dcct_prefix.substitute(dis='TI', propty='Delay-RB'))
self._trig_dly.new_value_signal[float].connect(self.updateRawXAxis)
self._smpl_cnt = SignalChannel(
self.dcct_prefix.substitute(propty='FastSampleCnt-RB'))
self._smpl_cnt.new_value_signal[float].connect(self.updateRawXAxis)
self._meas_per = SignalChannel(
self.dcct_prefix.substitute(propty='FastMeasPeriod-RB'))
self._meas_per.new_value_signal[float].connect(self.updateRawXAxis)
self.cb_timeaxis = QCheckBox('Use time axis', self)
self.cb_timeaxis.setChecked(True)
self.cb_timeaxis.stateChanged.connect(self.updateRawXAxis)
self.cb_timeaxis.setLayoutDirection(Qt.RightToLeft)
lay.addWidget(self.cb_timeaxis, 2, 0, alignment=Qt.AlignLeft)
lay.setRowStretch(2, 1)
l_smoothmethod = QLabel('Method: ', self)
self.cb_smoothmethod = QComboBox(self)
self.cb_smoothmethod.addItems(['Average', 'Median'])
self.cb_smoothmethod.currentTextChanged.connect(
self.setRawSmoothMethod)
l_smoothnracq = QLabel('Nr.Acqs.: ', self)
self.sb_smoothnracq = QSpinBoxPlus(self)
self.sb_smoothnracq.setValue(1)
self.sb_smoothnracq.valueChanged.connect(self.setRawSmoothNrAcq)
l_smoothbuff = QLabel('Buffer Size: ', self)
l_smoothbuff.setSizePolicy(QSzPly.Minimum, QSzPly.Preferred)
self.label_buffsize = QLabel('', self)
self.label_buffsize.setStyleSheet('min-width:3em; max-width:3em;')
self.pb_resetbuff = QPushButton(qta.icon('mdi.delete-empty'), '', self)
self.pb_resetbuff.setToolTip('Reset buffer')
self.pb_resetbuff.setObjectName('resetbuff')
self.pb_resetbuff.setStyleSheet(
"#resetbuff{min-width:25px; max-width:25px; icon-size:20px;}")
self.pb_resetbuff.clicked.connect(self.resetRawBuffer)
hlay_buff = QHBoxLayout()
hlay_buff.addWidget(self.label_buffsize)
hlay_buff.addWidget(self.pb_resetbuff)
l_down = QLabel('Downsampling: ', self)
self.sb_down = QSpinBoxPlus(self)
self.sb_down.setValue(1)
self.sb_down.valueChanged.connect(self.setRawDownsampling)
gbox_smooth = QGroupBox('Smoothing of Readings')
glay_smooth = QGridLayout(gbox_smooth)
glay_smooth.addWidget(l_smoothmethod, 0, 0)
glay_smooth.addWidget(self.cb_smoothmethod, 0, 1)
glay_smooth.addWidget(l_smoothnracq, 1, 0)
glay_smooth.addWidget(self.sb_smoothnracq, 1, 1)
glay_smooth.addWidget(QLabel(''), 0, 2)
glay_smooth.addWidget(l_smoothbuff, 0, 3)
glay_smooth.addLayout(hlay_buff, 0, 4, 1, 2)
glay_smooth.addWidget(l_down, 1, 3)
glay_smooth.addWidget(self.sb_down, 1, 4, 1, 2)
glay_smooth.setColumnStretch(0, 10)
glay_smooth.setColumnStretch(1, 10)
glay_smooth.setColumnStretch(2, 2)
glay_smooth.setColumnStretch(3, 10)
glay_smooth.setColumnStretch(4, 5)
glay_smooth.setColumnStretch(5, 5)
lay.addWidget(gbox_smooth, 3, 0)
lay.setRowStretch(3, 3)
gbox_smooth.setStyleSheet("""
.QLabel{
qproperty-alignment: 'AlignVCenter | AlignRight';}
QPushButton{
min-width:3em; max-width:3em;}""")
return wid
def _updateRawBuffer(self, raw):
if raw is None:
return
samp = self._acq_fastnrsamp \
if self._acq_mode == _DCCTc.MeasModeSel.Fast \
else self._acq_normalnrsamp
if not samp:
return
samp -= samp % self._downsampling
if samp < 1:
return
data = raw[:samp]
self._smooth_buffer.append(data)
if len(self._smooth_buffer) > self._smooth_nracq:
self._smooth_buffer.pop(0)
self._updateRawCurve()
def _updateRawCurve(self):
buff = np.array(self._smooth_buffer, dtype=float)
self.label_buffsize.setText(str(self.smoothBufferSize))
if not len(buff):
return
if len(buff) > 1:
if self._smooth_method == 'Average':
fdata = np.mean(buff, axis=0)
elif self._smooth_method == 'Median':
fdata = np.median(buff, axis=0)
else:
fdata = buff[0]
down = self._downsampling
if down > 1:
fdata = np.mean(fdata.reshape(-1, down), axis=1)
self.wavecurve.receiveYWaveform(fdata)
self.wavecurve.redrawCurve()
def setRawDownsampling(self, new_value):
"""Update number of samples to use in downsampling."""
self._downsampling = new_value
self.resetRawBuffer()
def setRawSmoothMethod(self, new_method):
"""Update method to perform raw readings smoothing."""
self._smooth_method = new_method
self._updateRawCurve()
def setRawSmoothNrAcq(self, new_value):
"""Update number of samples to use in smoothing."""
self._smooth_nracq = new_value
exc = len(self._smooth_buffer) - self._smooth_nracq
if exc > 0:
for i in range(exc):
self._smooth_buffer.pop(0)
@property
def smoothBufferSize(self):
"""Smoothing buffer length."""
return len(self._smooth_buffer)
def resetRawBuffer(self):
"""Reset smoothing buffer."""
self._smooth_buffer = list()
self._updateRawCurve()
def updateParams(self, new_value):
"""Handle control visualization according to mode."""
address = self.sender().address
if 'Mode' in address:
self._acq_mode = new_value
elif 'Fast' in address:
self._acq_fastnrsamp = new_value
else:
self._acq_normalnrsamp = new_value
self.resetRawBuffer()
def updateRawXAxis(self):
"""Update X axis of waveform graph."""
smpl = self._smpl_cnt.getvalue()
if self.cb_timeaxis.checkState():
evnt = self._evnt_dly.getvalue()
trig = self._trig_dly.getvalue()
peri = self._meas_per.getvalue()
if any([val is None for val in [evnt, trig, smpl, peri]]):
return
init = (evnt + trig) / 1e3
endt = init + peri * 1e3
xdata = np.linspace(init, endt, smpl)
xlabel = 'Time [ms]'
else:
xdata = np.arange(0, smpl)
xlabel = 'Index'
self.wavegraph.setLabels(bottom=xlabel)
self.wavecurve.receiveXWaveform(xdata)
def _handle_data_visualization(self):
show_raw = 'Raw' in self.sender().text()
self.sender().setText('Switch to ' +
('Time History' if show_raw else 'Raw Readings'))
self.currhist.setVisible(not show_raw)
self.rawreads.setVisible(show_raw)